From bcf7cd4431a07c7f7bda78b38abc9eab1ae295c0 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 6 Jun 2024 16:24:51 -0400
Subject: [PATCH 001/341] added Dockerfile

---
 Dockerfile           | 41 +++++++++++++++++++++++++++++++++++++++++
 docker-entrypoint.sh |  1 +
 2 files changed, 42 insertions(+)
 create mode 100644 Dockerfile
 create mode 100755 docker-entrypoint.sh

diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 00000000..f39e9790
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,41 @@
+FROM golang:1.22.3-alpine as builder
+
+WORKDIR /workspace
+
+# add go modules lockfiles
+COPY go.mod go.sum ./
+RUN go mod download
+
+# prefetch the binaries, so that they will be cached and not downloaded on each change
+RUN go run github.com/steebchen/prisma-client-go prefetch
+
+COPY ./ ./
+# generate the Prisma Client Go client
+RUN go generate ./...
+
+# build a fully standalone binary with zero dependencies
+RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -ldflags '-extldflags "-static"' -o app .
+
+
+# <!> railway.app does not really have a way to run a migration container on the volume, so we have to improvise here
+# in order to run migrations, we need to have go and prisma installed
+FROM golang:1.22.3-alpine
+
+# set timezone
+ENV TZ=Europe/Berlin
+
+# copy final binary
+COPY --from=builder /workspace/app /app
+
+# copy migrations and schema
+COPY --from=builder /workspace/internal/database/prisma/migrations /prisma/migrations
+COPY --from=builder /workspace/internal/database/prisma/schema.prisma /prisma/schema.prisma
+COPY --from=builder /workspace/docker-entrypoint.sh /docker-entrypoint.sh
+COPY --from=builder /workspace/go.mod /go.mod
+COPY --from=builder /workspace/go.sum /go.sum
+
+# install prisma and prefetch binaries
+RUN go install github.com/steebchen/prisma-client-go
+RUN go run github.com/steebchen/prisma-client-go prefetch
+
+ENTRYPOINT ["/docker-entrypoint.sh"]
diff --git a/docker-entrypoint.sh b/docker-entrypoint.sh
new file mode 100755
index 00000000..7c11860c
--- /dev/null
+++ b/docker-entrypoint.sh
@@ -0,0 +1 @@
+go run github.com/steebchen/prisma-client-go migrate deploy --schema /prisma/schema.prisma && /app

From 4d6cafec1664b0c383f4c030c9ab2462f5264479 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 6 Jun 2024 16:46:43 -0400
Subject: [PATCH 002/341] added fly.io config and workflow

---
 .github/workflows/canary_fly.yml | 18 ++++++++++++++
 fly.canary.toml                  | 41 ++++++++++++++++++++++++++++++++
 2 files changed, 59 insertions(+)
 create mode 100644 .github/workflows/canary_fly.yml
 create mode 100644 fly.canary.toml

diff --git a/.github/workflows/canary_fly.yml b/.github/workflows/canary_fly.yml
new file mode 100644
index 00000000..1f0ce2ed
--- /dev/null
+++ b/.github/workflows/canary_fly.yml
@@ -0,0 +1,18 @@
+name: Fly Deploy to Canary
+
+on:
+  push:
+    branches:
+      - canary
+  workflow_dispatch: {}
+
+jobs:
+  deploy:
+    name: Deploy app to canary
+    runs-on: ubuntu-latest
+    concurrency: deploy-group
+    steps:
+      - uses: actions/checkout@v4
+      - run: flyctl deploy --remote-only -c fly.canary.toml
+        env:
+          FLY_API_TOKEN: ${{ secrets.FLY_API_TOKEN_CANARY }}
diff --git a/fly.canary.toml b/fly.canary.toml
new file mode 100644
index 00000000..72616c2a
--- /dev/null
+++ b/fly.canary.toml
@@ -0,0 +1,41 @@
+app = 'aftermath-canary'
+primary_region = 'lhr'
+kill_signal = 'SIGINT'
+kill_timeout = '5s'
+
+
+[http_service]
+internal_port = 8080
+force_https = true
+auto_stop_machines = false
+auto_start_machines = false
+processes = ['app']
+
+[env]
+# Database configuration
+DATABASE_URL = "file:/data/db/canary.db"
+# Wargaming API
+WG_PRIMARY_APP_RPS = "10"
+WG_REQUEST_TIMEOUT_SEC = "5"
+# External services
+BLITZ_STARS_API_URL = "https://www.blitzstars.com/api"
+WOT_BLITZ_PUBLIC_API_URL_FMT = "https://%s.wotblitz.com/en/api"
+WOT_INSPECTOR_REPLAYS_URL = 'https://api.wotinspector.com/v2/blitz/replays/'
+WOT_INSPECTOR_TANK_DB_URL = "https://armor.wotinspector.com/static/armorinspector/tank_db_blitz.js"
+# Discord
+DISCORD_PRIMARY_GUILD_ID = "1090331056449781793"
+# Misc configuration
+LOG_LEVEL = "info"
+NETWORK = "tcp"
+PORT = "8080"
+
+[[mounts]]
+source = 'aftermath_canary_data'
+destination = '/data/db'
+initial_size = '1GB'
+auto_extend_size_threshold = 80
+auto_extend_size_increment = '1GB'
+auto_extend_size_limit = '100GB'
+
+[[vm]]
+size = 'shared-cpu-2x'

From 3364a834e728dded9efaa464997b78a812e3f46a Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 6 Jun 2024 16:47:49 -0400
Subject: [PATCH 003/341] added missing action

---
 .github/workflows/canary_fly.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/canary_fly.yml b/.github/workflows/canary_fly.yml
index 1f0ce2ed..1676b04d 100644
--- a/.github/workflows/canary_fly.yml
+++ b/.github/workflows/canary_fly.yml
@@ -13,6 +13,7 @@ jobs:
     concurrency: deploy-group
     steps:
       - uses: actions/checkout@v4
+      - uses: superfly/flyctl-actions/setup-flyctl@master
       - run: flyctl deploy --remote-only -c fly.canary.toml
         env:
           FLY_API_TOKEN: ${{ secrets.FLY_API_TOKEN_CANARY }}

From 598e05666ff964fce92282a1aa97bd6056a0780a Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 6 Jun 2024 16:51:53 -0400
Subject: [PATCH 004/341] added env with secrets

---
 .github/workflows/canary_fly.yml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/canary_fly.yml b/.github/workflows/canary_fly.yml
index 1676b04d..02b8f6d4 100644
--- a/.github/workflows/canary_fly.yml
+++ b/.github/workflows/canary_fly.yml
@@ -9,6 +9,7 @@ on:
 jobs:
   deploy:
     name: Deploy app to canary
+    environment: Fly Canary
     runs-on: ubuntu-latest
     concurrency: deploy-group
     steps:
@@ -16,4 +17,4 @@ jobs:
       - uses: superfly/flyctl-actions/setup-flyctl@master
       - run: flyctl deploy --remote-only -c fly.canary.toml
         env:
-          FLY_API_TOKEN: ${{ secrets.FLY_API_TOKEN_CANARY }}
+          FLY_API_TOKEN: ${{ secrets.FLY_API_TOKEN }}

From e1a6d5a1ebcd512a00dc81d15dce0d6532b8aea5 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 6 Jun 2024 16:54:12 -0400
Subject: [PATCH 005/341] added initial migration

---
 .../20240606205337_init/migration.sql         | 299 ++++++++++++++++++
 .../prisma/migrations/migration_lock.toml     |   3 +
 2 files changed, 302 insertions(+)
 create mode 100644 internal/database/prisma/migrations/20240606205337_init/migration.sql
 create mode 100644 internal/database/prisma/migrations/migration_lock.toml

diff --git a/internal/database/prisma/migrations/20240606205337_init/migration.sql b/internal/database/prisma/migrations/20240606205337_init/migration.sql
new file mode 100644
index 00000000..d8843022
--- /dev/null
+++ b/internal/database/prisma/migrations/20240606205337_init/migration.sql
@@ -0,0 +1,299 @@
+-- CreateTable
+CREATE TABLE "app_configurations" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    "valueEncoded" TEXT NOT NULL,
+    "metadataEncoded" TEXT NOT NULL DEFAULT ''
+);
+
+-- CreateTable
+CREATE TABLE "auth_nonces" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    "expiresAt" DATETIME NOT NULL,
+    "referenceId" TEXT NOT NULL,
+    "metadataEncoded" TEXT NOT NULL DEFAULT ''
+);
+
+-- CreateTable
+CREATE TABLE "users" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    "permissions" TEXT NOT NULL,
+    "featureFlagsEncoded" TEXT NOT NULL DEFAULT ''
+);
+
+-- CreateTable
+CREATE TABLE "user_subscriptions" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    "userId" TEXT NOT NULL,
+    "type" TEXT NOT NULL,
+    "expiresAt" DATETIME NOT NULL,
+    "referenceId" TEXT NOT NULL,
+    "permissions" TEXT NOT NULL,
+    CONSTRAINT "user_subscriptions_userId_fkey" FOREIGN KEY ("userId") REFERENCES "users" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);
+
+-- CreateTable
+CREATE TABLE "user_connections" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    "userId" TEXT NOT NULL,
+    "type" TEXT NOT NULL,
+    "permissions" TEXT NOT NULL,
+    "referenceId" TEXT NOT NULL,
+    "metadataEncoded" TEXT NOT NULL DEFAULT '',
+    CONSTRAINT "user_connections_userId_fkey" FOREIGN KEY ("userId") REFERENCES "users" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);
+
+-- CreateTable
+CREATE TABLE "user_content" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    "userId" TEXT NOT NULL,
+    "type" TEXT NOT NULL,
+    "referenceId" TEXT NOT NULL,
+    "valueEncoded" TEXT NOT NULL,
+    "metadataEncoded" TEXT NOT NULL DEFAULT '',
+    CONSTRAINT "user_content_userId_fkey" FOREIGN KEY ("userId") REFERENCES "users" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);
+
+-- CreateTable
+CREATE TABLE "accounts" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    "lastBattleTime" DATETIME NOT NULL,
+    "accountCreatedAt" DATETIME NOT NULL,
+    "realm" TEXT NOT NULL,
+    "nickname" TEXT NOT NULL,
+    "private" BOOLEAN NOT NULL DEFAULT false,
+    "clanId" TEXT,
+    CONSTRAINT "accounts_clanId_fkey" FOREIGN KEY ("clanId") REFERENCES "account_clans" ("id") ON DELETE SET NULL ON UPDATE CASCADE
+);
+
+-- CreateTable
+CREATE TABLE "account_snapshots" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "createdAt" DATETIME NOT NULL,
+    "updatedAt" DATETIME NOT NULL,
+    "type" TEXT NOT NULL,
+    "accountId" TEXT NOT NULL,
+    "referenceId" TEXT NOT NULL,
+    "lastBattleTime" DATETIME NOT NULL,
+    "dataEncoded" TEXT NOT NULL
+);
+
+-- CreateTable
+CREATE TABLE "account_rating_season_snapshots" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "createdAt" DATETIME NOT NULL,
+    "updatedAt" DATETIME NOT NULL,
+    "seasonId" TEXT NOT NULL,
+    "accountId" TEXT NOT NULL,
+    "referenceId" TEXT NOT NULL,
+    "lastBattleTime" DATETIME NOT NULL,
+    "dataEncoded" TEXT NOT NULL
+);
+
+-- CreateTable
+CREATE TABLE "account_clans" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "createdAt" DATETIME NOT NULL,
+    "updatedAt" DATETIME NOT NULL,
+    "tag" TEXT NOT NULL,
+    "name" TEXT NOT NULL,
+    "emblemId" TEXT NOT NULL DEFAULT '',
+    "membersString" TEXT NOT NULL,
+    "recordUpdatedAt" DATETIME NOT NULL
+);
+
+-- CreateTable
+CREATE TABLE "glossary_averages" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    "dataEncoded" TEXT NOT NULL
+);
+
+-- CreateTable
+CREATE TABLE "glossary_vehicles" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    "tier" INTEGER NOT NULL,
+    "type" TEXT NOT NULL,
+    "class" TEXT NOT NULL,
+    "nation" TEXT NOT NULL,
+    "localizedNamesEncoded" TEXT NOT NULL
+);
+
+-- CreateTable
+CREATE TABLE "glossary_achievements" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    "section" TEXT NOT NULL,
+    "dataEncoded" TEXT NOT NULL
+);
+
+-- CreateTable
+CREATE TABLE "user_interactions" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    "type" TEXT NOT NULL,
+    "userId" TEXT NOT NULL,
+    "referenceId" TEXT NOT NULL,
+    "dataEncoded" TEXT NOT NULL,
+    "metadataEncoded" TEXT NOT NULL DEFAULT ''
+);
+
+-- CreateTable
+CREATE TABLE "discord_live_sessions" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    "locale" TEXT NOT NULL,
+    "userId" TEXT NOT NULL,
+    "referenceId" TEXT NOT NULL,
+    "guildId" TEXT,
+    "channelId" TEXT NOT NULL,
+    "messageId" TEXT NOT NULL,
+    "lastUpdate" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "lastBattleTime" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "optionsEncoded" TEXT NOT NULL
+);
+
+-- CreateTable
+CREATE TABLE "stats_request_options" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    "type" TEXT NOT NULL,
+    "userId" TEXT NOT NULL,
+    "accountId" TEXT NOT NULL,
+    "referenceId" TEXT NOT NULL,
+    "dataEncoded" TEXT NOT NULL
+);
+
+-- CreateIndex
+CREATE INDEX "auth_nonces_createdAt_idx" ON "auth_nonces"("createdAt");
+
+-- CreateIndex
+CREATE INDEX "auth_nonces_referenceId_idx" ON "auth_nonces"("referenceId");
+
+-- CreateIndex
+CREATE INDEX "auth_nonces_referenceId_expiresAt_idx" ON "auth_nonces"("referenceId", "expiresAt");
+
+-- CreateIndex
+CREATE INDEX "user_subscriptions_userId_idx" ON "user_subscriptions"("userId");
+
+-- CreateIndex
+CREATE INDEX "user_subscriptions_expiresAt_idx" ON "user_subscriptions"("expiresAt");
+
+-- CreateIndex
+CREATE INDEX "user_subscriptions_type_userId_expiresAt_idx" ON "user_subscriptions"("type", "userId", "expiresAt");
+
+-- CreateIndex
+CREATE INDEX "user_subscriptions_type_userId_idx" ON "user_subscriptions"("type", "userId");
+
+-- CreateIndex
+CREATE INDEX "user_subscriptions_referenceId_idx" ON "user_subscriptions"("referenceId");
+
+-- CreateIndex
+CREATE INDEX "user_subscriptions_type_referenceId_idx" ON "user_subscriptions"("type", "referenceId");
+
+-- CreateIndex
+CREATE INDEX "user_connections_userId_idx" ON "user_connections"("userId");
+
+-- CreateIndex
+CREATE INDEX "user_connections_type_userId_idx" ON "user_connections"("type", "userId");
+
+-- CreateIndex
+CREATE INDEX "user_connections_referenceId_idx" ON "user_connections"("referenceId");
+
+-- CreateIndex
+CREATE INDEX "user_connections_type_referenceId_idx" ON "user_connections"("type", "referenceId");
+
+-- CreateIndex
+CREATE INDEX "user_content_userId_idx" ON "user_content"("userId");
+
+-- CreateIndex
+CREATE INDEX "user_content_type_userId_idx" ON "user_content"("type", "userId");
+
+-- CreateIndex
+CREATE INDEX "user_content_referenceId_idx" ON "user_content"("referenceId");
+
+-- CreateIndex
+CREATE INDEX "user_content_type_referenceId_idx" ON "user_content"("type", "referenceId");
+
+-- CreateIndex
+CREATE INDEX "accounts_realm_idx" ON "accounts"("realm");
+
+-- CreateIndex
+CREATE INDEX "accounts_clanId_idx" ON "accounts"("clanId");
+
+-- CreateIndex
+CREATE INDEX "accounts_nickname_idx" ON "accounts"("nickname");
+
+-- CreateIndex
+CREATE INDEX "accounts_lastBattleTime_idx" ON "accounts"("lastBattleTime");
+
+-- CreateIndex
+CREATE INDEX "account_snapshots_createdAt_idx" ON "account_snapshots"("createdAt");
+
+-- CreateIndex
+CREATE INDEX "account_snapshots_type_accountId_idx" ON "account_snapshots"("type", "accountId");
+
+-- CreateIndex
+CREATE INDEX "account_snapshots_type_accountId_createdAt_idx" ON "account_snapshots"("type", "accountId", "createdAt");
+
+-- CreateIndex
+CREATE INDEX "account_snapshots_type_accountId_lastBattleTime_idx" ON "account_snapshots"("type", "accountId", "lastBattleTime");
+
+-- CreateIndex
+CREATE INDEX "account_snapshots_type_referenceId_idx" ON "account_snapshots"("type", "referenceId");
+
+-- CreateIndex
+CREATE INDEX "account_snapshots_type_referenceId_createdAt_idx" ON "account_snapshots"("type", "referenceId", "createdAt");
+
+-- CreateIndex
+CREATE INDEX "account_rating_season_snapshots_createdAt_idx" ON "account_rating_season_snapshots"("createdAt");
+
+-- CreateIndex
+CREATE INDEX "account_rating_season_snapshots_seasonId_accountId_idx" ON "account_rating_season_snapshots"("seasonId", "accountId");
+
+-- CreateIndex
+CREATE INDEX "account_rating_season_snapshots_seasonId_referenceId_idx" ON "account_rating_season_snapshots"("seasonId", "referenceId");
+
+-- CreateIndex
+CREATE INDEX "account_clans_tag_idx" ON "account_clans"("tag");
+
+-- CreateIndex
+CREATE INDEX "user_interactions_type_idx" ON "user_interactions"("type");
+
+-- CreateIndex
+CREATE INDEX "user_interactions_userId_idx" ON "user_interactions"("userId");
+
+-- CreateIndex
+CREATE INDEX "user_interactions_userId_type_idx" ON "user_interactions"("userId", "type");
+
+-- CreateIndex
+CREATE INDEX "user_interactions_referenceId_idx" ON "user_interactions"("referenceId");
+
+-- CreateIndex
+CREATE INDEX "user_interactions_referenceId_type_idx" ON "user_interactions"("referenceId", "type");
+
+-- CreateIndex
+CREATE INDEX "discord_live_sessions_referenceId_idx" ON "discord_live_sessions"("referenceId");
+
+-- CreateIndex
+CREATE INDEX "stats_request_options_referenceId_idx" ON "stats_request_options"("referenceId");
diff --git a/internal/database/prisma/migrations/migration_lock.toml b/internal/database/prisma/migrations/migration_lock.toml
new file mode 100644
index 00000000..e5e5c470
--- /dev/null
+++ b/internal/database/prisma/migrations/migration_lock.toml
@@ -0,0 +1,3 @@
+# Please do not edit this file manually
+# It should be added in your version-control system (i.e. Git)
+provider = "sqlite"
\ No newline at end of file

From 5b3464a6576dce538b5d1b8a118d7823196e89ac Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 6 Jun 2024 16:57:35 -0400
Subject: [PATCH 006/341] added header

---
 docker-entrypoint.sh | 1 +
 1 file changed, 1 insertion(+)

diff --git a/docker-entrypoint.sh b/docker-entrypoint.sh
index 7c11860c..6f30e8bf 100755
--- a/docker-entrypoint.sh
+++ b/docker-entrypoint.sh
@@ -1 +1,2 @@
+#!/bin/bash
 go run github.com/steebchen/prisma-client-go migrate deploy --schema /prisma/schema.prisma && /app

From acb30bebe3a8221dc3744104a5aa02bac2fc09ac Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 6 Jun 2024 17:03:07 -0400
Subject: [PATCH 007/341] updated dockerfile

---
 Dockerfile | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Dockerfile b/Dockerfile
index f39e9790..993f4f5e 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -14,7 +14,7 @@ COPY ./ ./
 RUN go generate ./...
 
 # build a fully standalone binary with zero dependencies
-RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -ldflags '-extldflags "-static"' -o app .
+RUN CGO_ENABLED=0 GOOS=linux go build -o app .
 
 
 # <!> railway.app does not really have a way to run a migration container on the volume, so we have to improvise here
@@ -37,5 +37,6 @@ COPY --from=builder /workspace/go.sum /go.sum
 # install prisma and prefetch binaries
 RUN go install github.com/steebchen/prisma-client-go
 RUN go run github.com/steebchen/prisma-client-go prefetch
+RUN chmod +x /docker-entrypoint.sh
 
 ENTRYPOINT ["/docker-entrypoint.sh"]

From 9ef67b94ac538a6e1e941f853229a045a12e61b4 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 6 Jun 2024 17:21:43 -0400
Subject: [PATCH 008/341] changed shell, added timeout

---
 .github/workflows/canary_fly.yml | 3 ++-
 docker-entrypoint.sh             | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/canary_fly.yml b/.github/workflows/canary_fly.yml
index 02b8f6d4..41ce70af 100644
--- a/.github/workflows/canary_fly.yml
+++ b/.github/workflows/canary_fly.yml
@@ -9,9 +9,10 @@ on:
 jobs:
   deploy:
     name: Deploy app to canary
-    environment: Fly Canary
     runs-on: ubuntu-latest
+    environment: Fly Canary
     concurrency: deploy-group
+    timeout-minutes: 3
     steps:
       - uses: actions/checkout@v4
       - uses: superfly/flyctl-actions/setup-flyctl@master
diff --git a/docker-entrypoint.sh b/docker-entrypoint.sh
index 6f30e8bf..e03049b6 100755
--- a/docker-entrypoint.sh
+++ b/docker-entrypoint.sh
@@ -1,2 +1,2 @@
-#!/bin/bash
+#!/bin/sh
 go run github.com/steebchen/prisma-client-go migrate deploy --schema /prisma/schema.prisma && /app

From f7bd45139c39f43e92f72a9f4d8bfc36d527dc99 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 6 Jun 2024 17:25:48 -0400
Subject: [PATCH 009/341] pulling port from env

---
 main.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/main.go b/main.go
index 842f96af..054869a1 100644
--- a/main.go
+++ b/main.go
@@ -47,7 +47,7 @@ func main() {
 	}
 
 	http.Handle("/discord/callback", discordHandler)
-	panic(http.ListenAndServe(":9092", nil))
+	panic(http.ListenAndServe(":"+os.Getenv("PORT"), nil))
 
 	// test
 	// localePrinter := func(s string) string { return "localized:" + s }

From 38e09a559a3f72b6300b24579fa383c8e7955693 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 6 Jun 2024 17:26:18 -0400
Subject: [PATCH 010/341] cleaned up main

---
 main.go | 28 ----------------------------
 1 file changed, 28 deletions(-)

diff --git a/main.go b/main.go
index 054869a1..c3312e0b 100644
--- a/main.go
+++ b/main.go
@@ -48,34 +48,6 @@ func main() {
 
 	http.Handle("/discord/callback", discordHandler)
 	panic(http.ListenAndServe(":"+os.Getenv("PORT"), nil))
-
-	// test
-	// localePrinter := func(s string) string { return "localized:" + s }
-
-	// renderer := stats.NewRenderer(statsClient, language.English)
-
-	// var days time.Duration = 60
-	// img, meta, err := renderer.Period(context.Background(), "579553160", time.Now().Add(time.Hour*24*days*-1))
-	// if err != nil {
-	// 	panic(err)
-	// }
-
-	// fmt.Printf("rendered in %v\n", meta.TotalTime())
-
-	// bgImage, _ := assets.GetLoadedImage("bg-light")
-	// finalImage := render.AddBackground(img, bgImage, render.Style{Blur: 10, BorderRadius: 30})
-
-	// f, err := os.Create("tmp/test-image.png")
-	// if err != nil {
-	// 	panic(err)
-	// }
-	// defer f.Close()
-
-	// err = png.Encode(f, finalImage)
-	// if err != nil {
-	// 	panic(err)
-	// }
-
 }
 
 func loadStaticAssets(static fs.FS) {

From 365684347bca20c73f789b26f0f0938918df1aa4 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 6 Jun 2024 19:40:47 -0400
Subject: [PATCH 011/341] averages

---
 cmds/core/client.go                      | 31 +++++++---
 cmds/core/scheduler/cron.go              | 44 +++++++++++++
 cmds/core/scheduler/glossary.go          | 48 +++++++++++++++
 cmds/core/scheduler/workers.go           | 68 +++++++++++++++++++++
 cmds/discord/commands/link.go            |  4 +-
 cmds/discord/commands/stats.go           |  4 +-
 cmds/discord/common/context.go           |  2 +-
 go.mod                                   |  4 ++
 go.sum                                   | 33 +++++++++-
 internal/database/client.go              |  6 +-
 internal/database/external.go            | 33 ++++++++--
 internal/database/prisma/schema.prisma   |  2 +-
 internal/database/users.go               |  8 +--
 internal/external/blitzstars/averages.go | 78 ++++++++++++++++++++++++
 internal/external/blitzstars/client.go   |  7 ++-
 internal/stats/fetch/client.go           | 36 ++++++++++-
 internal/stats/fetch/multisource.go      | 64 +++++++++++++++++--
 internal/stats/frame/frame.go            | 27 ++++----
 internal/stats/frame/value.go            |  2 +-
 internal/stats/period.go                 |  2 +-
 internal/stats/prepare/common/card.go    | 16 ++---
 internal/stats/prepare/period/preset.go  |  3 +-
 main.go                                  | 52 ++++++++--------
 23 files changed, 488 insertions(+), 86 deletions(-)
 create mode 100644 cmds/core/scheduler/cron.go
 create mode 100644 cmds/core/scheduler/glossary.go
 create mode 100644 cmds/core/scheduler/workers.go
 create mode 100644 internal/external/blitzstars/averages.go

diff --git a/cmds/core/client.go b/cmds/core/client.go
index a5512bc4..cd1e9381 100644
--- a/cmds/core/client.go
+++ b/cmds/core/client.go
@@ -7,15 +7,32 @@ import (
 	"golang.org/x/text/language"
 )
 
-type Client struct {
-	Fetch fetch.Client
-	DB    database.Client
+var _ Client = &client{}
+
+type Client interface {
+	Render(locale language.Tag) stats.Renderer
+
+	Database() database.Client
+	Fetch() fetch.Client
+}
+
+type client struct {
+	fetch fetch.Client
+	db    database.Client
+}
+
+func (c *client) Database() database.Client {
+	return c.db
+}
+
+func (c *client) Fetch() fetch.Client {
+	return c.fetch
 }
 
-func (c *Client) Render(locale language.Tag) stats.Renderer {
-	return stats.NewRenderer(c.Fetch, locale)
+func (c *client) Render(locale language.Tag) stats.Renderer {
+	return stats.NewRenderer(c.fetch, locale)
 }
 
-func NewClient(fetch fetch.Client, database database.Client) Client {
-	return Client{Fetch: fetch, DB: database}
+func NewClient(fetch fetch.Client, database database.Client) *client {
+	return &client{fetch: fetch, db: database}
 }
diff --git a/cmds/core/scheduler/cron.go b/cmds/core/scheduler/cron.go
new file mode 100644
index 00000000..23ea3de7
--- /dev/null
+++ b/cmds/core/scheduler/cron.go
@@ -0,0 +1,44 @@
+package scheduler
+
+import (
+	"time"
+
+	"github.com/cufee/aftermath/cmds/core"
+	"github.com/go-co-op/gocron"
+	"github.com/rs/zerolog/log"
+)
+
+func StartCronJobs(client core.Client) {
+	log.Info().Msg("starting cron jobs")
+
+	c := gocron.NewScheduler(time.UTC)
+	// Tasks
+	c.Cron("* * * * *").Do(runTasksWorker(client))
+	c.Cron("0 * * * *").Do(restartTasksWorker(client))
+
+	// Glossary - Do it around the same time WG releases game updates
+	c.Cron("0 10 * * *").Do(UpdateGlossaryWorker(client))
+	c.Cron("0 12 * * *").Do(UpdateGlossaryWorker(client))
+	// c.AddFunc("40 9 * * 0", updateAchievementsWorker)
+
+	// Averages - Update averages shortly after session refreshes
+	c.Cron("0 10 * * *").Do(UpdateAveragesWorker(client))
+	c.Cron("0 2 * * *").Do(UpdateAveragesWorker(client))
+	c.Cron("0 19 * * *").Do(UpdateAveragesWorker(client))
+
+	// Sessions
+	c.Cron("0 9 * * *").Do(createSessionTasksWorker(client, "NA"))  // NA
+	c.Cron("0 1 * * *").Do(createSessionTasksWorker(client, "EU"))  // EU
+	c.Cron("0 18 * * *").Do(createSessionTasksWorker(client, "AS")) // Asia
+
+	// Refresh WN8
+	// "45 9 * * *" 	// NA
+	// "45 1 * * *" 	// EU
+	// "45 18 * * *" 	// Asia
+
+	// Configurations
+	c.Cron("0 0 */7 * *").Do(rotateBackgroundPresetsWorker(client))
+
+	// Start the Cron job scheduler
+	c.StartAsync()
+}
diff --git a/cmds/core/scheduler/glossary.go b/cmds/core/scheduler/glossary.go
new file mode 100644
index 00000000..a81cd930
--- /dev/null
+++ b/cmds/core/scheduler/glossary.go
@@ -0,0 +1,48 @@
+package scheduler
+
+import (
+	"context"
+	"time"
+
+	"github.com/cufee/aftermath/cmds/core"
+	"github.com/rs/zerolog/log"
+)
+
+// CurrentTankAverages
+
+func UpdateAveragesWorker(client core.Client) func() {
+	return func() {
+		log.Info().Msg("updating tank averages cache")
+
+		ctx, cancel := context.WithTimeout(context.Background(), time.Minute*1)
+		defer cancel()
+
+		// we just run the logic directly as it's not a heavy task and it doesn't matter if it fails
+		averages, err := client.Fetch().CurrentTankAverages(ctx)
+		if err != nil {
+			log.Err(err).Msg("failed to update averages cache")
+			return
+		}
+
+		err = client.Database().UpsertVehicleAverages(ctx, averages)
+		if err != nil {
+			log.Err(err).Msg("failed to update averages cache")
+			return
+		}
+
+		log.Info().Msg("averages cache updated")
+	}
+}
+
+func UpdateGlossaryWorker(client core.Client) func() {
+	return func() {
+		// // We just run the logic directly as it's not a heavy task and it doesn't matter if it fails due to the app failing
+		// log.Info().Msg("updating glossary cache")
+		// err := cache.UpdateGlossaryCache()
+		// if err != nil {
+		// 	log.Err(err).Msg("failed to update glossary cache")
+		// } else {
+		// 	log.Info().Msg("glossary cache updated")
+		// }
+	}
+}
diff --git a/cmds/core/scheduler/workers.go b/cmds/core/scheduler/workers.go
new file mode 100644
index 00000000..d5037340
--- /dev/null
+++ b/cmds/core/scheduler/workers.go
@@ -0,0 +1,68 @@
+package scheduler
+
+import (
+	"github.com/cufee/aftermath/cmds/core"
+)
+
+func rotateBackgroundPresetsWorker(client core.Client) func() {
+	return func() {
+		// // We just run the logic directly as it's not a heavy task and it doesn't matter if it fails due to the app failing
+		// log.Info().Msg("rotating background presets")
+		// images, err := content.PickRandomBackgroundImages(3)
+		// if err != nil {
+		// 	log.Err(err).Msg("failed to pick random background images")
+		// 	return
+		// }
+		// err = database.UpdateAppConfiguration[[]string]("backgroundImagesSelection", images, nil, true)
+		// if err != nil {
+		// 	log.Err(err).Msg("failed to update background images selection")
+		// }
+	}
+}
+
+func createSessionTasksWorker(client core.Client, realm string) func() {
+	return func() {
+		// err := tasks.CreateSessionUpdateTasks(realm)
+		// if err != nil {
+		// 	log.Err(err).Msg("failed to create session update tasks")
+		// }
+	}
+}
+
+func runTasksWorker(client core.Client) func() {
+	return func() {
+		// 	if tasks.DefaultQueue.ActiveWorkers() > 0 {
+		// 		return
+		// 	}
+
+		// 	activeTasks, err := tasks.StartScheduledTasks(nil, 50)
+		// 	if err != nil {
+		// 		log.Err(err).Msg("failed to start scheduled tasks")
+		// 		return
+		// 	}
+		// 	if len(activeTasks) == 0 {
+		// 		return
+		// 	}
+
+		// 	tasks.DefaultQueue.Process(func(err error) {
+		// 		if err != nil {
+		// 			log.Err(err).Msg("failed to process tasks")
+		// 			return
+		// 		}
+
+		// 		// If the queue is now empty, we can run the next batch of tasks right away
+		// 		runTasksWorker()
+
+		// 	}, activeTasks...)
+	}
+}
+
+func restartTasksWorker(client core.Client) func() {
+	return func() {
+		// _, err := tasks.RestartAbandonedTasks(nil)
+		// if err != nil {
+		// 	log.Err(err).Msg("failed to start scheduled tasks")
+		// 	return
+		// }
+	}
+}
diff --git a/cmds/discord/commands/link.go b/cmds/discord/commands/link.go
index 7d735039..0eb0c5d2 100644
--- a/cmds/discord/commands/link.go
+++ b/cmds/discord/commands/link.go
@@ -41,7 +41,7 @@ func init() {
 					return ctx.Reply(message)
 				}
 
-				account, err := ctx.Core.Fetch.Search(ctx.Context, options.Nickname, options.Server)
+				account, err := ctx.Core.Fetch().Search(ctx.Context, options.Nickname, options.Server)
 				if err != nil {
 					if err.Error() == "no results found" {
 						return ctx.ReplyFmt("stats_error_nickname_not_fount_fmt", options.Nickname, strings.ToUpper(options.Server))
@@ -59,7 +59,7 @@ func init() {
 				currentConnection.Metadata["verified"] = false
 				currentConnection.ReferenceID = fmt.Sprint(account.ID)
 
-				_, err = ctx.Core.DB.UpsertConnection(ctx.Context, currentConnection)
+				_, err = ctx.Core.Database().UpsertConnection(ctx.Context, currentConnection)
 				if err != nil {
 					return ctx.Err(err)
 				}
diff --git a/cmds/discord/commands/stats.go b/cmds/discord/commands/stats.go
index 94b5f42d..9af35d25 100644
--- a/cmds/discord/commands/stats.go
+++ b/cmds/discord/commands/stats.go
@@ -30,7 +30,7 @@ func init() {
 				switch {
 				case options.UserID != "":
 					// mentioned another user, check if the user has an account linked
-					mentionedUser, _ := ctx.Core.DB.GetUserByID(ctx.Context, options.UserID, database.WithConnections(), database.WithContent())
+					mentionedUser, _ := ctx.Core.Database().GetUserByID(ctx.Context, options.UserID, database.WithConnections(), database.WithContent())
 					defaultAccount, hasDefaultAccount := mentionedUser.Connection(database.ConnectionTypeWargaming)
 					if !hasDefaultAccount {
 						return ctx.Reply("stats_error_connection_not_found_vague")
@@ -40,7 +40,7 @@ func init() {
 
 				case options.Nickname != "" && options.Server != "":
 					// nickname provided and server selected - lookup the account
-					account, err := ctx.Core.Fetch.Search(ctx.Context, options.Nickname, options.Server)
+					account, err := ctx.Core.Fetch().Search(ctx.Context, options.Nickname, options.Server)
 					if err != nil {
 						if err.Error() == "no results found" {
 							return ctx.ReplyFmt("stats_error_nickname_not_fount_fmt", options.Nickname, strings.ToUpper(options.Server))
diff --git a/cmds/discord/common/context.go b/cmds/discord/common/context.go
index bdfa25fd..96018022 100644
--- a/cmds/discord/common/context.go
+++ b/cmds/discord/common/context.go
@@ -54,7 +54,7 @@ func NewContext(ctx context.Context, interaction discordgo.Interaction, respondC
 		return nil, errors.New("failed to get a valid discord user id")
 	}
 
-	user, err := client.DB.GetOrCreateUserByID(ctx, c.Member.ID, database.WithConnections(), database.WithSubscriptions())
+	user, err := client.Database().GetOrCreateUserByID(ctx, c.Member.ID, database.WithConnections(), database.WithSubscriptions())
 	if err != nil {
 		return nil, err
 	}
diff --git a/go.mod b/go.mod
index bdc7e794..e4c1c034 100644
--- a/go.mod
+++ b/go.mod
@@ -7,6 +7,7 @@ require (
 	github.com/cufee/am-wg-proxy-next/v2 v2.1.2
 	github.com/disintegration/imaging v1.6.2
 	github.com/fogleman/gg v1.3.0
+	github.com/go-co-op/gocron v1.37.0
 	github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0
 	github.com/joho/godotenv v1.5.1
 	github.com/rs/zerolog v1.33.0
@@ -22,11 +23,14 @@ require (
 
 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/google/uuid v1.5.0 // indirect
 	github.com/gorilla/websocket v1.5.1 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/robfig/cron/v3 v3.0.1 // indirect
+	go.uber.org/atomic v1.9.0 // indirect
 	golang.org/x/crypto v0.19.0 // indirect
 	golang.org/x/net v0.21.0 // indirect
 	golang.org/x/sys v0.17.0 // indirect
diff --git a/go.sum b/go.sum
index 1a4a8bcb..fa0e39ca 100644
--- a/go.sum
+++ b/go.sum
@@ -1,6 +1,7 @@
 github.com/bwmarrin/discordgo v0.28.1 h1:gXsuo2GBO7NbR6uqmrrBDplPUx2T3nzu775q/Rd1aG4=
 github.com/bwmarrin/discordgo v0.28.1/go.mod h1:NJZpH+1AfhIcyQsPeuBKsUtYrRnjkyu0kIVMCHkZtRY=
 github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/cufee/am-wg-proxy-next/v2 v2.1.2 h1:j45xbLPs5FqSsfEccls8AWXK1DIWjnIFEKoiB7M/TGY=
 github.com/cufee/am-wg-proxy-next/v2 v2.1.2/go.mod h1:+VxiIdbrdhHdRThASbVmZ5Fz4H6XPCzL3S2Ix6TO/84=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -10,24 +11,43 @@ github.com/disintegration/imaging v1.6.2 h1:w1LecBlG2Lnp8B3jk5zSuNqd7b4DXhcjwek1
 github.com/disintegration/imaging v1.6.2/go.mod h1:44/5580QXChDfwIclfc/PCwrr44amcmDAg8hxG0Ewe4=
 github.com/fogleman/gg v1.3.0 h1:/7zJX8F6AaYQc57WQCyN9cAIz+4bCJGO9B+dyW29am8=
 github.com/fogleman/gg v1.3.0/go.mod h1:R/bRT+9gY/C5z7JzPU0zXsXHKM4/ayA+zqcVNZzPa1k=
+github.com/go-co-op/gocron v1.37.0 h1:ZYDJGtQ4OMhTLKOKMIch+/CY70Brbb1dGdooLEhh7b0=
+github.com/go-co-op/gocron v1.37.0/go.mod h1:3L/n6BkO7ABj+TrfSVXLRzsP26zmikL4ISkLQ0O8iNY=
 github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
 github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 h1:DACJavvAHhabrF08vX0COfcOBJRhZ8lUbR+ZWIs0Y5g=
 github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k=
+github.com/google/uuid v1.4.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/google/uuid v1.5.0 h1:1p67kYwdtXjb0gL0BPiP1Av9wiZPo5A8z2cWkTZ+eyU=
+github.com/google/uuid v1.5.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/gorilla/websocket v1.5.1 h1:gmztn0JnHVt9JZquRuzLw3g4wouNVzKL15iLr/zn/QY=
 github.com/gorilla/websocket v1.5.1/go.mod h1:x3kM2JMyaluk02fnUJpQuwD2dCS5NDG2ZHL0uE0tcaY=
 github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
 github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
+github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
+github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
 github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
 github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
+github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=
+github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
+github.com/rogpeppe/go-internal v1.8.1 h1:geMPLpDpQOgVyCg5z5GoRwLHepNdb71NXb67XFkP+Eg=
+github.com/rogpeppe/go-internal v1.8.1/go.mod h1:JeRgkft04UBgHMgCIwADu4Pn6Mtm5d4nPKWu0nJ5d+o=
 github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
 github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8=
 github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
@@ -36,7 +56,12 @@ github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+D
 github.com/steebchen/prisma-client-go v0.37.0 h1:CYfRxUnIsJRlCvPM4Yw2fElB7Y9rC4f2/PPmHliqyTc=
 github.com/steebchen/prisma-client-go v0.37.0/go.mod h1:wp2xU9HO5WIefc65vcl1HOiFUzaHKyOhHw5atrzs8hc=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
 github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 go.dedis.ch/fixbuf v1.0.3 h1:hGcV9Cd/znUxlusJ64eAlExS+5cJDIyTyEG+otu5wQs=
@@ -48,6 +73,8 @@ go.dedis.ch/protobuf v1.0.5/go.mod h1:eIV4wicvi6JK0q/QnfIEGeSFNG0ZeB24kzut5+HaRL
 go.dedis.ch/protobuf v1.0.7/go.mod h1:pv5ysfkDX/EawiPqcW3ikOxsL5t+BqnV6xHSmE79KI4=
 go.dedis.ch/protobuf v1.0.11 h1:FTYVIEzY/bfl37lu3pR4lIj+F9Vp1jE8oh91VmxKgLo=
 go.dedis.ch/protobuf v1.0.11/go.mod h1:97QR256dnkimeNdfmURz0wAMNVbd1VmLXhG1CrTYrJ4=
+go.uber.org/atomic v1.9.0 h1:ECmE8Bn/WFTYwEW/bpKD3M8VtR/zQVbavAoalC1PYyE=
+go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
 golang.org/x/crypto v0.0.0-20190123085648-057139ce5d2b/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
 golang.org/x/crypto v0.19.0 h1:ENy+Az/9Y1vSrlrvBSyna3PITt4tiZLf7sgCjZBX7Wo=
@@ -73,7 +100,11 @@ golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.15.0 h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk=
 golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/internal/database/client.go b/internal/database/client.go
index 575b6fd6..d4749a3f 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -8,8 +8,8 @@ import (
 )
 
 type Client interface {
-	SetVehicleAverages(ctx context.Context, averages map[string]frame.StatsFrame) error
 	GetVehicleAverages(ctx context.Context, ids []string) (map[string]frame.StatsFrame, error)
+	UpsertVehicleAverages(ctx context.Context, averages map[string]frame.StatsFrame) error
 
 	GetUserByID(ctx context.Context, id string, opts ...userGetOption) (User, error)
 	GetOrCreateUserByID(ctx context.Context, id string, opts ...userGetOption) (User, error)
@@ -20,7 +20,7 @@ type Client interface {
 // var _ Client = &client{} // just a marker to see if it is implemented correctly
 
 type client struct {
-	prisma *db.PrismaClient
+	Raw *db.PrismaClient
 }
 
 func NewClient() (*client, error) {
@@ -30,5 +30,5 @@ func NewClient() (*client, error) {
 		return nil, err
 	}
 
-	return &client{prisma: prisma}, nil
+	return &client{Raw: prisma}, nil
 }
diff --git a/internal/database/external.go b/internal/database/external.go
index f644c3f3..87117a4a 100644
--- a/internal/database/external.go
+++ b/internal/database/external.go
@@ -8,6 +8,7 @@ import (
 	"github.com/cufee/aftermath/internal/localization"
 	"github.com/cufee/aftermath/internal/stats/frame"
 	"github.com/rs/zerolog/log"
+	"github.com/steebchen/prisma-client-go/runtime/transaction"
 )
 
 type GlossaryVehicle struct {
@@ -18,12 +19,32 @@ func (v GlossaryVehicle) Name(printer localization.Printer) string {
 	return printer("name")
 }
 
-func (c *client) SetVehicleAverages(ctx context.Context, averages map[string]frame.StatsFrame) error {
+func (c *client) UpsertVehicleAverages(ctx context.Context, averages map[string]frame.StatsFrame) error {
 	if len(averages) < 1 {
 		return nil
 	}
 
-	return nil
+	var transactions []transaction.Transaction
+	for id, data := range averages {
+		encoded, err := data.Encode()
+		if err != nil {
+			log.Err(err).Str("id", id).Msg("failed to encode a stats frame for vehicle averages")
+			continue
+		}
+
+		transactions = append(transactions, c.Raw.VehicleAverage.
+			UpsertOne(db.VehicleAverage.ID.Equals(id)).
+			Create(
+				db.VehicleAverage.ID.Set(id),
+				db.VehicleAverage.DataEncoded.Set(encoded),
+			).
+			Update(
+				db.VehicleAverage.DataEncoded.Set(encoded),
+			).Tx(),
+		)
+	}
+
+	return c.Raw.Prisma.Transaction(transactions...).Exec(ctx)
 }
 
 func (c *client) GetVehicleAverages(ctx context.Context, ids []string) (map[string]frame.StatsFrame, error) {
@@ -33,7 +54,7 @@ func (c *client) GetVehicleAverages(ctx context.Context, ids []string) (map[stri
 
 	qCtx, cancel := context.WithTimeout(ctx, time.Second)
 	defer cancel()
-	records, err := c.prisma.VehicleAverage.FindMany(db.VehicleAverage.ID.In(ids)).Exec(qCtx)
+	records, err := c.Raw.VehicleAverage.FindMany(db.VehicleAverage.ID.In(ids)).Exec(qCtx)
 	if err != nil {
 		return nil, err
 	}
@@ -44,9 +65,9 @@ func (c *client) GetVehicleAverages(ctx context.Context, ids []string) (map[stri
 
 	for _, record := range records {
 		parsed, err := frame.DecodeStatsFrame(record.DataEncoded)
-		if err != nil && !db.IsErrNotFound(err) {
+		lastErr = err
+		if err != nil {
 			badRecords = append(badRecords, record.ID)
-			lastErr = err
 			continue
 		}
 		averages[record.ID] = parsed
@@ -61,7 +82,7 @@ func (c *client) GetVehicleAverages(ctx context.Context, ids []string) (map[stri
 		// we can just delete the record and move on
 		ctx, cancel := context.WithCancel(context.Background())
 		defer cancel()
-		_, err := c.prisma.VehicleAverage.FindMany(db.VehicleAverage.ID.In(badRecords)).Delete().Exec(ctx)
+		_, err := c.Raw.VehicleAverage.FindMany(db.VehicleAverage.ID.In(badRecords)).Delete().Exec(ctx)
 		if err != nil {
 			log.Err(err).Strs("ids", badRecords).Msg("failed to delete a bad vehicle average records")
 		}
diff --git a/internal/database/prisma/schema.prisma b/internal/database/prisma/schema.prisma
index 1b54ac15..f4a0c95d 100644
--- a/internal/database/prisma/schema.prisma
+++ b/internal/database/prisma/schema.prisma
@@ -209,7 +209,7 @@ model Clan {
 }
 
 model VehicleAverage {
-  id        String   @id @default(uuid())
+  id        String   @id
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt
 
diff --git a/internal/database/users.go b/internal/database/users.go
index c9458a51..eee8e046 100644
--- a/internal/database/users.go
+++ b/internal/database/users.go
@@ -176,7 +176,7 @@ func (c *client) GetOrCreateUserByID(ctx context.Context, id string, opts ...use
 	user, err := c.GetUserByID(ctx, id, opts...)
 	if err != nil {
 		if db.IsErrNotFound(err) {
-			model, err := c.prisma.User.CreateOne(db.User.ID.Set(id), db.User.Permissions.Set(permissions.User.Encode())).Exec(ctx)
+			model, err := c.Raw.User.CreateOne(db.User.ID.Set(id), db.User.Permissions.Set(permissions.User.Encode())).Exec(ctx)
 			if err != nil {
 				return User{}, err
 			}
@@ -210,7 +210,7 @@ func (c *client) GetUserByID(ctx context.Context, id string, opts ...userGetOpti
 		fields = append(fields, db.User.Content.Fetch())
 	}
 
-	model, err := c.prisma.User.FindUnique(db.User.ID.Equals(id)).With(fields...).Exec(ctx)
+	model, err := c.Raw.User.FindUnique(db.User.ID.Equals(id)).With(fields...).Exec(ctx)
 	if err != nil {
 		return User{}, err
 	}
@@ -238,7 +238,7 @@ func (c *client) UpdateConnection(ctx context.Context, connection UserConnection
 		return UserConnection{}, fmt.Errorf("failed to encode metadata: %w", err)
 	}
 
-	model, err := c.prisma.UserConnection.FindUnique(db.UserConnection.ID.Equals(connection.ID)).Update(
+	model, err := c.Raw.UserConnection.FindUnique(db.UserConnection.ID.Equals(connection.ID)).Update(
 		db.UserConnection.ReferenceID.Set(connection.ReferenceID),
 		db.UserConnection.Permissions.Set(connection.Permissions.Encode()),
 		db.UserConnection.MetadataEncoded.Set(string(encoded)),
@@ -269,7 +269,7 @@ func (c *client) UpsertConnection(ctx context.Context, connection UserConnection
 		return UserConnection{}, fmt.Errorf("failed to encode metadata: %w", err)
 	}
 
-	model, err := c.prisma.UserConnection.CreateOne(
+	model, err := c.Raw.UserConnection.CreateOne(
 		db.UserConnection.User.Link(db.User.ID.Equals(connection.UserID)),
 		db.UserConnection.Type.Set(string(connection.Type)),
 		db.UserConnection.Permissions.Set(connection.Permissions.Encode()),
diff --git a/internal/external/blitzstars/averages.go b/internal/external/blitzstars/averages.go
new file mode 100644
index 00000000..b7ddddb4
--- /dev/null
+++ b/internal/external/blitzstars/averages.go
@@ -0,0 +1,78 @@
+package blitzstars
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+
+	"github.com/cufee/aftermath/internal/stats/frame"
+)
+
+// Response from https://www.blitzstars.com/ average stats endpoint
+type VehicleAverages struct {
+	TankID  int `json:"tank_id"`
+	Players int `json:"number_of_players"`
+	All     struct {
+		AvgBattles              float32 `json:"battles,omitempty"`
+		AvgDroppedCapturePoints float32 `json:"dropped_capture_points,omitempty"`
+	} `json:",omitempty"`
+	Special struct {
+		Winrate         float32 `json:"winrate,omitempty"`
+		DamageRatio     float32 `json:"damageRatio,omitempty"`
+		Kdr             float32 `json:"kdr,omitempty"`
+		DamagePerBattle float32 `json:"damagePerBattle,omitempty"`
+		KillsPerBattle  float32 `json:"killsPerBattle,omitempty"`
+		HitsPerBattle   float32 `json:"hitsPerBattle,omitempty"`
+		SpotsPerBattle  float32 `json:"spotsPerBattle,omitempty"`
+		Wpm             float32 `json:"wpm,omitempty"`
+		Dpm             float32 `json:"dpm,omitempty"`
+		Kpm             float32 `json:"kpm,omitempty"`
+		HitRate         float32 `json:"hitRate,omitempty"`
+		SurvivalRate    float32 `json:"survivalRate,omitempty"`
+	} `json:"special,omitempty"`
+}
+
+func (c *client) CurrentTankAverages(ctx context.Context) (map[string]frame.StatsFrame, error) {
+	req, err := http.NewRequest("GET", c.apiURL+"/tankaverages.json", nil)
+	if err != nil {
+		return nil, err
+	}
+
+	res, err := c.http.Do(req.WithContext(ctx))
+	if err != nil {
+		return nil, err
+	}
+
+	defer res.Body.Close()
+	if res.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("bad status code: %d", res.StatusCode)
+	}
+
+	var averages []VehicleAverages
+	err = json.NewDecoder(res.Body).Decode(&averages)
+	if err != nil {
+		return nil, err
+	}
+
+	averagesMap := make(map[string]frame.StatsFrame)
+	for _, average := range averages {
+		battles := average.All.AvgBattles * float32(average.Players)
+
+		averagesMap[fmt.Sprint(average.TankID)] = frame.StatsFrame{
+			Battles:     frame.ValueInt(battles),
+			BattlesWon:  frame.ValueInt(average.Special.Winrate * battles / 100),
+			DamageDealt: frame.ValueInt(average.Special.DamagePerBattle * battles),
+
+			ShotsHit:   frame.ValueInt(average.Special.HitsPerBattle * battles),
+			ShotsFired: frame.ValueInt((average.Special.HitsPerBattle * battles) / (average.Special.HitRate / 100)),
+
+			Frags:                frame.ValueInt(average.Special.KillsPerBattle * battles),
+			EnemiesSpotted:       frame.ValueInt(average.Special.SpotsPerBattle * battles),
+			DroppedCapturePoints: frame.ValueInt(average.All.AvgDroppedCapturePoints * battles),
+		}
+
+	}
+
+	return averagesMap, nil
+}
diff --git a/internal/external/blitzstars/client.go b/internal/external/blitzstars/client.go
index 5c49b4e6..2015050e 100644
--- a/internal/external/blitzstars/client.go
+++ b/internal/external/blitzstars/client.go
@@ -4,9 +4,12 @@ import (
 	"context"
 	"net/http"
 	"time"
+
+	"github.com/cufee/aftermath/internal/stats/frame"
 )
 
 type Client interface {
+	CurrentTankAverages(ctx context.Context) (map[string]frame.StatsFrame, error)
 	AccountTankHistories(ctx context.Context, accountId string) (map[int][]TankHistoryEntry, error)
 }
 
@@ -18,10 +21,10 @@ type client struct {
 	requestTimeout time.Duration
 }
 
-func NewClient(apiURL string, requestTimeout time.Duration) *client {
+func NewClient(apiURL string, requestTimeout time.Duration) (*client, error) {
 	return &client{
 		apiURL:         apiURL,
 		requestTimeout: requestTimeout,
 		http:           http.Client{Timeout: requestTimeout},
-	}
+	}, nil
 }
diff --git a/internal/stats/fetch/client.go b/internal/stats/fetch/client.go
index 18c82a8f..8c273edb 100644
--- a/internal/stats/fetch/client.go
+++ b/internal/stats/fetch/client.go
@@ -23,6 +23,24 @@ type AccountStatsOverPeriod struct {
 	LastBattleTime time.Time `json:"lastBattleTime"`
 }
 
+func (stats *AccountStatsOverPeriod) AddWN8(averages map[string]frame.StatsFrame) {
+	var weightedTotal, battlesTotal float32
+	for id, data := range stats.RegularBattles.Vehicles {
+		tankAverages, ok := averages[id]
+		if !ok || data.Battles < 1 {
+			continue
+		}
+		weightedTotal += data.Battles.Float() * data.WN8(tankAverages).Float()
+		battlesTotal += data.Battles.Float()
+	}
+	if battlesTotal < 1 {
+		return
+	}
+
+	wn8 := int(weightedTotal) / int(battlesTotal)
+	stats.RegularBattles.SetWN8(wn8)
+}
+
 type StatsWithVehicles struct {
 	frame.StatsFrame
 	Vehicles map[string]frame.VehicleStatsFrame
@@ -30,6 +48,20 @@ type StatsWithVehicles struct {
 
 type Client interface {
 	Search(ctx context.Context, nickname, realm string) (types.Account, error)
-	CurrentStats(ctx context.Context, id string) (AccountStatsOverPeriod, error)
-	PeriodStats(ctx context.Context, id string, from time.Time) (AccountStatsOverPeriod, error)
+	CurrentStats(ctx context.Context, id string, opts ...statsOption) (AccountStatsOverPeriod, error)
+	PeriodStats(ctx context.Context, id string, from time.Time, opts ...statsOption) (AccountStatsOverPeriod, error)
+
+	CurrentTankAverages(ctx context.Context) (map[string]frame.StatsFrame, error)
+}
+
+type statsOptions struct {
+	withWN8 bool
+}
+
+type statsOption func(*statsOptions)
+
+func WithWN8() statsOption {
+	return func(so *statsOptions) {
+		so.withWN8 = true
+	}
 }
diff --git a/internal/stats/fetch/multisource.go b/internal/stats/fetch/multisource.go
index 7a48dcf1..134c933f 100644
--- a/internal/stats/fetch/multisource.go
+++ b/internal/stats/fetch/multisource.go
@@ -3,12 +3,14 @@ package fetch
 import (
 	"context"
 	"errors"
+	"fmt"
 	"sync"
 	"time"
 
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/external/blitzstars"
 	"github.com/cufee/aftermath/internal/external/wargaming"
+	"github.com/cufee/aftermath/internal/stats/frame"
 	"github.com/cufee/am-wg-proxy-next/v2/types"
 )
 
@@ -51,7 +53,12 @@ Get live account stats from wargaming
   - Each request will be retried c.retriesPerRequest times
   - This function will assume the player ID is valid and optimistically run all request concurrently, returning the first error once all request finish
 */
-func (c *multiSourceClient) CurrentStats(ctx context.Context, id string) (AccountStatsOverPeriod, error) {
+func (c *multiSourceClient) CurrentStats(ctx context.Context, id string, opts ...statsOption) (AccountStatsOverPeriod, error) {
+	var options statsOptions
+	for _, apply := range opts {
+		apply(&options)
+	}
+
 	realm := c.wargaming.RealmFromAccountID(id)
 
 	var group sync.WaitGroup
@@ -60,6 +67,7 @@ func (c *multiSourceClient) CurrentStats(ctx context.Context, id string) (Accoun
 	var clan types.ClanMember
 	var account DataWithErr[types.ExtendedAccount]
 	var vehicles DataWithErr[[]types.VehicleStatsFrame]
+	var averages DataWithErr[map[string]frame.StatsFrame]
 
 	go func() {
 		defer group.Done()
@@ -79,6 +87,17 @@ func (c *multiSourceClient) CurrentStats(ctx context.Context, id string) (Accoun
 		vehicles = withRetry(func() ([]types.VehicleStatsFrame, error) {
 			return c.wargaming.AccountVehicles(ctx, realm, id)
 		}, c.retriesPerRequest, c.retrySleepInterval)
+
+		if vehicles.Err != nil || len(vehicles.Data) < 1 || !options.withWN8 {
+			return
+		}
+
+		var ids []string
+		for _, v := range vehicles.Data {
+			ids = append(ids, fmt.Sprint(v.TankID))
+		}
+		a, err := c.database.GetVehicleAverages(ctx, ids)
+		averages = DataWithErr[map[string]frame.StatsFrame]{a, err}
 	}()
 
 	group.Wait()
@@ -90,11 +109,22 @@ func (c *multiSourceClient) CurrentStats(ctx context.Context, id string) (Accoun
 		return AccountStatsOverPeriod{}, vehicles.Err
 	}
 
-	return wargamingToStats(realm, account.Data, clan, vehicles.Data), nil
+	stats := wargamingToStats(realm, account.Data, clan, vehicles.Data)
+	if options.withWN8 {
+		stats.AddWN8(averages.Data)
+	}
+
+	return stats, nil
 }
 
-func (c *multiSourceClient) PeriodStats(ctx context.Context, id string, periodStart time.Time) (AccountStatsOverPeriod, error) {
+func (c *multiSourceClient) PeriodStats(ctx context.Context, id string, periodStart time.Time, opts ...statsOption) (AccountStatsOverPeriod, error) {
+	var options statsOptions
+	for _, apply := range opts {
+		apply(&options)
+	}
+
 	var histories DataWithErr[map[int][]blitzstars.TankHistoryEntry]
+	var averages DataWithErr[map[string]frame.StatsFrame]
 	var current DataWithErr[AccountStatsOverPeriod]
 
 	var group sync.WaitGroup
@@ -104,6 +134,17 @@ func (c *multiSourceClient) PeriodStats(ctx context.Context, id string, periodSt
 
 		stats, err := c.CurrentStats(ctx, id)
 		current = DataWithErr[AccountStatsOverPeriod]{stats, err}
+
+		if err != nil || stats.RegularBattles.Battles < 1 || !options.withWN8 {
+			return
+		}
+
+		var ids []string
+		for id := range stats.RegularBattles.Vehicles {
+			ids = append(ids, id)
+		}
+		a, err := c.database.GetVehicleAverages(ctx, ids)
+		averages = DataWithErr[map[string]frame.StatsFrame]{a, err}
 	}()
 
 	// TODO: lookup a session from the database first
@@ -116,7 +157,11 @@ func (c *multiSourceClient) PeriodStats(ctx context.Context, id string, periodSt
 			return AccountStatsOverPeriod{}, current.Err
 		}
 
-		return current.Data, nil
+		stats := current.Data
+		if options.withWN8 {
+			stats.AddWN8(averages.Data)
+		}
+		return stats, nil
 	}
 
 	group.Add(1)
@@ -139,5 +184,14 @@ func (c *multiSourceClient) PeriodStats(ctx context.Context, id string, periodSt
 	current.Data.PeriodStart = periodStart
 	current.Data.RatingBattles = StatsWithVehicles{} // blitzstars do not provide rating battles stats
 	current.Data.RegularBattles = blitzstarsToStats(current.Data.RegularBattles.Vehicles, histories.Data, periodStart)
-	return current.Data, nil
+
+	stats := current.Data
+	if options.withWN8 {
+		stats.AddWN8(averages.Data)
+	}
+	return stats, nil
+}
+
+func (c *multiSourceClient) CurrentTankAverages(ctx context.Context) (map[string]frame.StatsFrame, error) {
+	return c.blitzstars.CurrentTankAverages(ctx)
 }
diff --git a/internal/stats/frame/frame.go b/internal/stats/frame/frame.go
index 2a64c61c..570f97bd 100644
--- a/internal/stats/frame/frame.go
+++ b/internal/stats/frame/frame.go
@@ -1,10 +1,9 @@
 package frame
 
 import (
+	"encoding/json"
 	"math"
 	"time"
-
-	"go.dedis.ch/protobuf"
 )
 
 /*
@@ -42,7 +41,7 @@ type StatsFrame struct {
 
 func DecodeStatsFrame(encoded string) (StatsFrame, error) {
 	var data StatsFrame
-	err := protobuf.Decode([]byte(encoded), &data)
+	err := json.Unmarshal([]byte(encoded), &data)
 	if err != nil {
 		return StatsFrame{}, err
 	}
@@ -53,7 +52,7 @@ func DecodeStatsFrame(encoded string) (StatsFrame, error) {
 Encode StatsFrame to string
 */
 func (r *StatsFrame) Encode() (string, error) {
-	data, err := protobuf.Encode(r)
+	data, err := json.Marshal(r)
 	if err != nil {
 		return "", err
 	}
@@ -63,7 +62,7 @@ func (r *StatsFrame) Encode() (string, error) {
 /*
 Calculate and return average damage per battle
 */
-func (r *StatsFrame) AvgDamage() Value {
+func (r *StatsFrame) AvgDamage(_ ...any) Value {
 	if r.Battles == 0 {
 		return InvalidValue
 	}
@@ -76,7 +75,7 @@ func (r *StatsFrame) AvgDamage() Value {
 /*
 Calculate and return damage dealt vs damage received ration
 */
-func (r *StatsFrame) DamageRatio() Value {
+func (r *StatsFrame) DamageRatio(_ ...any) Value {
 	if r.Battles == 0 || r.DamageReceived == 0 {
 		return InvalidValue
 	}
@@ -89,7 +88,7 @@ func (r *StatsFrame) DamageRatio() Value {
 /*
 Calculate and return survival battles vs total battles ratio
 */
-func (r *StatsFrame) SurvivalRatio() Value {
+func (r *StatsFrame) SurvivalRatio(_ ...any) Value {
 	if r.Battles == 0 {
 		return InvalidValue
 	}
@@ -102,7 +101,7 @@ func (r *StatsFrame) SurvivalRatio() Value {
 /*
 Calculate and return survival percentage
 */
-func (r *StatsFrame) Survival() Value {
+func (r *StatsFrame) Survival(_ ...any) Value {
 	if r.Battles == 0 {
 		return InvalidValue
 	}
@@ -115,7 +114,7 @@ func (r *StatsFrame) Survival() Value {
 /*
 Calculate and return win percentage
 */
-func (r *StatsFrame) WinRate() Value {
+func (r *StatsFrame) WinRate(_ ...any) Value {
 	if r.Battles == 0 {
 		return InvalidValue
 	}
@@ -128,7 +127,7 @@ func (r *StatsFrame) WinRate() Value {
 /*
 Calculate and return accuracy
 */
-func (r *StatsFrame) Accuracy() Value {
+func (r *StatsFrame) Accuracy(_ ...any) Value {
 	if r.Battles == 0 || r.ShotsFired == 0 {
 		return InvalidValue
 	}
@@ -149,17 +148,17 @@ func (r *StatsFrame) SetWN8(wn8 int) {
 	 Calculate WN8 Rating for a tank using the following formula:
 		(980*rDAMAGEc + 210*rDAMAGEc*rFRAGc + 155*rFRAGc*rSPOTc + 75*rDEFc*rFRAGc + 145*MIN(1.8,rWINc))/EXPc
 */
-func (r *StatsFrame) WN8(vehicleAverages ...StatsFrame) Value {
+func (r *StatsFrame) WN8(averages ...any) Value {
 	if r.wn8 > 0 {
 		return r.wn8
 	}
 
-	if r.Battles == 0 || len(vehicleAverages) < 1 {
+	if r.Battles == 0 || len(averages) < 1 {
 		return InvalidValue
 	}
 
-	average := vehicleAverages[0]
-	if average.Battles == 0 {
+	average, ok := averages[0].(StatsFrame)
+	if !ok || average.Battles == 0 {
 		return InvalidValue
 	}
 
diff --git a/internal/stats/frame/value.go b/internal/stats/frame/value.go
index 86a7b9ee..6b15afbe 100644
--- a/internal/stats/frame/value.go
+++ b/internal/stats/frame/value.go
@@ -2,7 +2,7 @@ package frame
 
 import "fmt"
 
-type ValueInt uint32
+type ValueInt int
 
 func (value ValueInt) String() string {
 	return fmt.Sprintf("%d", value)
diff --git a/internal/stats/period.go b/internal/stats/period.go
index c36e3b99..3e61b421 100644
--- a/internal/stats/period.go
+++ b/internal/stats/period.go
@@ -26,7 +26,7 @@ func (r *renderer) Period(ctx context.Context, accountId string, from time.Time,
 	}
 
 	stop := meta.Timer("fetchClient#PeriodStats")
-	stats, err := r.fetchClient.PeriodStats(ctx, accountId, from)
+	stats, err := r.fetchClient.PeriodStats(ctx, accountId, from, fetch.WithWN8())
 	stop()
 	if err != nil {
 		return nil, meta, err
diff --git a/internal/stats/prepare/common/card.go b/internal/stats/prepare/common/card.go
index f3af6977..56e370ce 100644
--- a/internal/stats/prepare/common/card.go
+++ b/internal/stats/prepare/common/card.go
@@ -38,28 +38,28 @@ func (block *StatsBlock[D]) Localize(printer func(string) string) {
 	block.Label = printer(block.Label)
 }
 
-func (block *StatsBlock[D]) FillValue(stats frame.StatsFrame) error {
+func (block *StatsBlock[D]) FillValue(stats frame.StatsFrame, args ...any) error {
 	switch block.Tag {
 	case TagWN8:
-		block.Value = stats.WN8()
+		block.Value = stats.WN8(args...)
 	case TagFrags:
 		block.Value = stats.Frags
 	case TagBattles:
 		block.Value = stats.Battles
 	case TagWinrate:
-		block.Value = stats.WinRate()
+		block.Value = stats.WinRate(args...)
 	case TagAccuracy:
-		block.Value = stats.Accuracy()
+		block.Value = stats.Accuracy(args...)
 	case TagRankedRating:
 		block.Value = stats.Rating
 	case TagAvgDamage:
-		block.Value = stats.AvgDamage()
+		block.Value = stats.AvgDamage(args...)
 	case TagDamageRatio:
-		block.Value = stats.DamageRatio()
+		block.Value = stats.DamageRatio(args...)
 	case TagSurvivalRatio:
-		block.Value = stats.SurvivalRatio()
+		block.Value = stats.SurvivalRatio(args...)
 	case TagSurvivalPercent:
-		block.Value = stats.Survival()
+		block.Value = stats.Survival(args...)
 	case TagDamageDealt:
 		block.Value = stats.DamageDealt
 	case TagDamageTaken:
diff --git a/internal/stats/prepare/period/preset.go b/internal/stats/prepare/period/preset.go
index 253e03b6..781aaaec 100644
--- a/internal/stats/prepare/period/preset.go
+++ b/internal/stats/prepare/period/preset.go
@@ -7,8 +7,8 @@ import (
 
 func presetToBlock(preset common.Tag, stats frame.StatsFrame) common.StatsBlock[BlockData] {
 	block := common.StatsBlock[BlockData](common.NewBlock(preset, BlockData{}))
-	block.FillValue(stats)
 
+	var args []any
 	switch preset {
 	case common.TagWN8:
 		block.Data.Flavor = BlockFlavorSpecial
@@ -32,5 +32,6 @@ func presetToBlock(preset common.Tag, stats frame.StatsFrame) common.StatsBlock[
 		block.Data.Flavor = BlockFlavorDefault
 	}
 
+	block.FillValue(stats, args...)
 	return block
 }
diff --git a/main.go b/main.go
index c3312e0b..2f8f7850 100644
--- a/main.go
+++ b/main.go
@@ -9,6 +9,7 @@ import (
 	"time"
 
 	"github.com/cufee/aftermath/cmds/core"
+	"github.com/cufee/aftermath/cmds/core/scheduler"
 	"github.com/cufee/aftermath/cmds/discord"
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/external/blitzstars"
@@ -35,11 +36,9 @@ func main() {
 
 	loadStaticAssets(static)
 
-	dbClient, err := database.NewClient()
-	if err != nil {
-		panic(err)
-	}
-	coreClient := core.NewClient(fetchClientFromEnv(), dbClient)
+	coreClient := coreClientFromEnv()
+
+	scheduler.UpdateAveragesWorker(coreClient)()
 
 	discordHandler, err := discord.NewRouterHandler(coreClient, os.Getenv("DISCORD_TOKEN"), os.Getenv("DISCORD_PUBLIC_KEY"))
 	if err != nil {
@@ -50,24 +49,7 @@ func main() {
 	panic(http.ListenAndServe(":"+os.Getenv("PORT"), nil))
 }
 
-func loadStaticAssets(static fs.FS) {
-	// Assets for rendering
-	err := assets.LoadAssets(static, "static")
-	if err != nil {
-		log.Fatalf("assets#LoadAssets failed to load assets from static/ embed.FS %s", err)
-	}
-	err = render.InitLoadedAssets()
-	if err != nil {
-		log.Fatalf("render#InitLoadedAssets failed %s", err)
-	}
-	err = localization.LoadAssets(static, "static/localization")
-	if err != nil {
-		log.Fatalf("localization#LoadAssets failed %s", err)
-	}
-
-}
-
-func fetchClientFromEnv() fetch.Client {
+func coreClientFromEnv() core.Client {
 	// Dependencies
 	wgClient, err := wargaming.NewClientFromEnv(os.Getenv("WG_PRIMARY_APP_ID"), os.Getenv("WG_PRIMARY_APP_RPS"), os.Getenv("WG_REQUEST_TIMEOUT_SEC"), os.Getenv("WG_PROXY_HOST_LIST"))
 	if err != nil {
@@ -77,7 +59,10 @@ func fetchClientFromEnv() fetch.Client {
 	if err != nil {
 		log.Fatalf("database#NewClient failed %s", err)
 	}
-	bsClient := blitzstars.NewClient(os.Getenv("BLITZ_STARS_API_URL"), time.Second*3)
+	bsClient, err := blitzstars.NewClient(os.Getenv("BLITZ_STARS_API_URL"), time.Second*10)
+	if err != nil {
+		log.Fatalf("failed to init a blitzstars client %s", err)
+	}
 
 	// Fetch client
 	client, err := fetch.NewMultiSourceClient(wgClient, bsClient, dbClient)
@@ -85,5 +70,22 @@ func fetchClientFromEnv() fetch.Client {
 		log.Fatalf("fetch#NewMultiSourceClient failed %s", err)
 	}
 
-	return client
+	return core.NewClient(client, dbClient)
+}
+
+func loadStaticAssets(static fs.FS) {
+	// Assets for rendering
+	err := assets.LoadAssets(static, "static")
+	if err != nil {
+		log.Fatalf("assets#LoadAssets failed to load assets from static/ embed.FS %s", err)
+	}
+	err = render.InitLoadedAssets()
+	if err != nil {
+		log.Fatalf("render#InitLoadedAssets failed %s", err)
+	}
+	err = localization.LoadAssets(static, "static/localization")
+	if err != nil {
+		log.Fatalf("localization#LoadAssets failed %s", err)
+	}
+
 }

From 7bd15ddda678f72ac01e560b8988330b24011deb Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 6 Jun 2024 19:41:48 -0400
Subject: [PATCH 012/341] disabled averages worked by default

---
 main.go | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/main.go b/main.go
index 2f8f7850..5fbdc16a 100644
--- a/main.go
+++ b/main.go
@@ -9,7 +9,6 @@ import (
 	"time"
 
 	"github.com/cufee/aftermath/cmds/core"
-	"github.com/cufee/aftermath/cmds/core/scheduler"
 	"github.com/cufee/aftermath/cmds/discord"
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/external/blitzstars"
@@ -38,7 +37,7 @@ func main() {
 
 	coreClient := coreClientFromEnv()
 
-	scheduler.UpdateAveragesWorker(coreClient)()
+	// scheduler.UpdateAveragesWorker(coreClient)()
 
 	discordHandler, err := discord.NewRouterHandler(coreClient, os.Getenv("DISCORD_TOKEN"), os.Getenv("DISCORD_PUBLIC_KEY"))
 	if err != nil {

From c9fe767aaf907d6387d9ced60f6cc2646c611f78 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 6 Jun 2024 21:07:39 -0400
Subject: [PATCH 013/341] minor style tweaks

---
 internal/stats/image.go                   |   6 +++---
 internal/stats/render/common/badges.go    |  14 +++++++-------
 internal/stats/render/common/constants.go |   3 ++-
 internal/stats/render/common/footer.go    |   2 +-
 internal/stats/render/period/constants.go |   4 ++--
 internal/stats/render/segments.go         |   2 +-
 static/images/backgrounds/bg-default.jpg  | Bin 7541 -> 36041 bytes
 static/localization/en/stats.yaml         |   2 +-
 8 files changed, 17 insertions(+), 16 deletions(-)

diff --git a/internal/stats/image.go b/internal/stats/image.go
index 7c06a7a3..9e73843b 100644
--- a/internal/stats/image.go
+++ b/internal/stats/image.go
@@ -10,7 +10,7 @@ import (
 )
 
 type Image interface {
-	AddBackground(image.Image) error
+	AddBackground(image.Image, common.Style) error
 	PNG(io.Writer) error
 }
 
@@ -18,11 +18,11 @@ type imageImp struct {
 	image.Image
 }
 
-func (i *imageImp) AddBackground(bg image.Image) error {
+func (i *imageImp) AddBackground(bg image.Image, style common.Style) error {
 	if bg == nil {
 		return errors.New("background cannot be nil")
 	}
-	i.Image = common.AddBackground(i, bg, common.Style{Blur: 10, BorderRadius: 30})
+	i.Image = common.AddBackground(i, bg, style)
 	return nil
 }
 
diff --git a/internal/stats/render/common/badges.go b/internal/stats/render/common/badges.go
index eaab0ec9..12e6e1dd 100644
--- a/internal/stats/render/common/badges.go
+++ b/internal/stats/render/common/badges.go
@@ -54,7 +54,7 @@ var (
 		Name: "Supporter",
 		Icon: "images/icons/fire",
 		Style: subscriptionPillStyle{
-			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: DefaultCardColor, BorderRadius: 15, PaddingX: 7, PaddingY: 5, Height: 32},
+			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: DefaultCardColorNoAlpha, BorderRadius: 15, PaddingX: 7, PaddingY: 5, Height: 32},
 			Icon:      Style{Width: 16, Height: 16, BackgroundColor: TextSubscriptionPlus},
 			Text:      Style{Font: &FontSmall, FontColor: TextSecondary, PaddingX: 5},
 		},
@@ -63,7 +63,7 @@ var (
 		Name: "Aftermath+",
 		Icon: "images/icons/star",
 		Style: subscriptionPillStyle{
-			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: DefaultCardColor, BorderRadius: 15, PaddingX: 5, PaddingY: 5, Height: 32},
+			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: DefaultCardColorNoAlpha, BorderRadius: 15, PaddingX: 5, PaddingY: 5, Height: 32},
 			Icon:      Style{Width: 24, Height: 24, BackgroundColor: TextSubscriptionPlus},
 			Text:      Style{Font: &FontSmall, FontColor: TextSecondary, PaddingX: 5},
 		},
@@ -72,7 +72,7 @@ var (
 		Name: "Aftermath Pro",
 		Icon: "images/icons/star",
 		Style: subscriptionPillStyle{
-			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: DefaultCardColor, BorderRadius: 15, PaddingX: 5, PaddingY: 5, Height: 32},
+			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: DefaultCardColorNoAlpha, BorderRadius: 15, PaddingX: 5, PaddingY: 5, Height: 32},
 			Icon:      Style{Width: 24, Height: 24, BackgroundColor: TextSubscriptionPremium},
 			Text:      Style{Font: &FontSmall, FontColor: TextSecondary, PaddingX: 5},
 		},
@@ -107,7 +107,7 @@ var (
 		Name: "Community Moderator",
 		Icon: "images/icons/logo-128",
 		Style: subscriptionPillStyle{
-			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: DefaultCardColor, BorderRadius: 15, PaddingX: 7, PaddingY: 5, Gap: 5, Height: 32},
+			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: DefaultCardColorNoAlpha, BorderRadius: 15, PaddingX: 7, PaddingY: 5, Gap: 5, Height: 32},
 			Icon:      Style{Width: 20, Height: 20},
 			Text:      Style{Font: &FontSmall, FontColor: TextSecondary, PaddingX: 2},
 		},
@@ -116,7 +116,7 @@ var (
 		Name: "Moderator",
 		Icon: "images/icons/logo-128",
 		Style: subscriptionPillStyle{
-			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: DefaultCardColor, BorderRadius: 15, PaddingX: 7, PaddingY: 5, Gap: 5, Height: 32},
+			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: DefaultCardColorNoAlpha, BorderRadius: 15, PaddingX: 7, PaddingY: 5, Gap: 5, Height: 32},
 			Icon:      Style{Width: 20, Height: 20},
 			Text:      Style{Font: &FontSmall, FontColor: TextSecondary, PaddingX: 2},
 		},
@@ -125,7 +125,7 @@ var (
 		Name: "Booster",
 		Icon: "images/icons/discord-booster",
 		Style: subscriptionPillStyle{
-			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: DefaultCardColor, BorderRadius: 15, PaddingX: 10, PaddingY: 5, Gap: 5, Height: 32},
+			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: DefaultCardColorNoAlpha, BorderRadius: 15, PaddingX: 10, PaddingY: 5, Gap: 5, Height: 32},
 			Icon:      Style{Width: 20, Height: 20},
 			Text:      Style{Font: &FontSmall, FontColor: TextSecondary},
 		},
@@ -134,7 +134,7 @@ var (
 		Name: "Translator",
 		Icon: "images/icons/translator",
 		Style: subscriptionPillStyle{
-			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: DefaultCardColor, BorderRadius: 15, PaddingX: 10, PaddingY: 5, Gap: 5, Height: 32},
+			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: DefaultCardColorNoAlpha, BorderRadius: 15, PaddingX: 10, PaddingY: 5, Gap: 5, Height: 32},
 			Icon:      Style{Width: 20, Height: 20, BackgroundColor: TextPrimary},
 			Text:      Style{Font: &FontSmall, FontColor: TextSecondary},
 		},
diff --git a/internal/stats/render/common/constants.go b/internal/stats/render/common/constants.go
index cbbe28b4..dcdcb341 100644
--- a/internal/stats/render/common/constants.go
+++ b/internal/stats/render/common/constants.go
@@ -24,7 +24,8 @@ var (
 	TextSubscriptionPlus    = color.RGBA{72, 167, 250, 255}
 	TextSubscriptionPremium = color.RGBA{255, 223, 0, 255}
 
-	DefaultCardColor = color.RGBA{10, 10, 10, 180}
+	DefaultCardColor        = color.RGBA{10, 10, 10, 180}
+	DefaultCardColorNoAlpha = color.RGBA{10, 10, 10, 255}
 
 	ColorAftermathRed  = color.RGBA{255, 0, 120, 255}
 	ColorAftermathBlue = color.RGBA{90, 90, 255, 255}
diff --git a/internal/stats/render/common/footer.go b/internal/stats/render/common/footer.go
index d5c26294..53055e89 100644
--- a/internal/stats/render/common/footer.go
+++ b/internal/stats/render/common/footer.go
@@ -1,7 +1,7 @@
 package common
 
 func NewFooterCard(text string) Block {
-	backgroundColor := DefaultCardColor
+	backgroundColor := DefaultCardColorNoAlpha
 	backgroundColor.A = 120
 	return NewBlocksContent(Style{
 		JustifyContent:  JustifyContentCenter,
diff --git a/internal/stats/render/period/constants.go b/internal/stats/render/period/constants.go
index b339fc78..bbb2b7a3 100644
--- a/internal/stats/render/period/constants.go
+++ b/internal/stats/render/period/constants.go
@@ -35,7 +35,7 @@ func getOverviewStyle(columnWidth float64) overviewStyle {
 		Direction:      common.DirectionVertical,
 		AlignItems:     common.AlignItemsCenter,
 		JustifyContent: common.JustifyContentCenter,
-		PaddingX:       15,
+		PaddingX:       10,
 		PaddingY:       0,
 		Gap:            10,
 		Width:          columnWidth,
@@ -52,7 +52,7 @@ func defaultCardStyle(width float64) common.Style {
 		AlignItems:      common.AlignItemsCenter,
 		Direction:       common.DirectionVertical,
 		BackgroundColor: common.DefaultCardColor,
-		BorderRadius:    20,
+		BorderRadius:    25,
 		PaddingY:        10,
 		PaddingX:        20,
 		Gap:             20,
diff --git a/internal/stats/render/segments.go b/internal/stats/render/segments.go
index 87bf19a4..561e915c 100644
--- a/internal/stats/render/segments.go
+++ b/internal/stats/render/segments.go
@@ -49,7 +49,7 @@ func (s *Segments) Render(opts ...Option) (image.Image, error) {
 	if err != nil {
 		return nil, err
 	}
-	mainSegmentImg = common.AddBackground(mainSegmentImg, options.Background, common.Style{Blur: 10, BorderRadius: 30})
+	mainSegmentImg = common.AddBackground(mainSegmentImg, options.Background, common.Style{Blur: 10, BorderRadius: 42.5})
 
 	frameParts = append(frameParts, common.NewImageContent(common.Style{}, mainSegmentImg))
 	if len(s.header) > 0 {
diff --git a/static/images/backgrounds/bg-default.jpg b/static/images/backgrounds/bg-default.jpg
index abe35ea3e36d4af3f1f8317ee32e9141907a66cc..d752d09c77a0818bb8bd2f54bb9fe3233942504a 100644
GIT binary patch
literal 36041
zcmbq*bwCwe*Y9xX?hfIQA_CGN-QC^YT>=8q-3Zd%D2<AUfFLQ|hyv0IN{NKPopbQ<
z@qO?2-GA<$an3$__Fj9%Z>_!d%)#sV>lFY`QC2|~KtMnM<iP{D{tRhQkdiV}*Hn{L
zP?iC2005-O*~-NWNgM!NT)jOt<s@nK4Gd{fw*eIJAO-FM7#3Du?h@+i%E13xPG$j+
z5&%ryh0*$7yZz5Mu&r&ptN;Lk7Q8KP<?iVX*3H2>-ve)VSUn4@6It0?ScCPaV4ckq
zWDu;+!`dxx>btPI9lQ<!s{oOwwx$#)8xdHiwfn1X`B&Y_-qQu_!vpqVuy%0;=|l8y
z>ejG&Agu1<>;v)!FE9zQY+QA;z)uG79~B@6C;%#eIzS6p0zQBP;0$<!`f>nV!4@w-
z6TC0^zl^7Vk5>mrS%RY+04s2WG~fof02c7^0L%tpAF%wZTQ6H~E_f3HmLvcmf4aUt
zVgvxxbO5+axxT(AzP`RJ0RY4$0O)f4cf4B>00{g5+f)8+V<-dw+z0@8-urKx<r4sS
z5e)!j3+@)47Vvox!7Iep761+_0RY<o00_qc0K@1;Z{R)HeV}v>0JK3}DUSd^b`AhA
z*@3i;{};K@zyW{s_W$hjTYuLd04W%L|Gx^1$p04s*x>8806rS<7GVex0Uv<iBOu}<
zT=xQ$f0%>m0#=X^ks$yADhha$`mag<xd|Xc5YW+3P_GvOEJOqVf`^C)V)+X3qW-8#
zvslIWjGuFmC^yY^Gtz)@dp&l6(^oz>(`P+#p~=@fH%%$*F1oG)r)Sln0?)9fAmQ|8
zK}Y@U4;R&{I7c(<FCTOaWAYbj#vVIY)nkljw8)Q;EtINe)$Ba`To<alKNI=WeZmYc
zRD-F~>m$YEg3BjAxDSLUi$>H37dB<B^K*P{BL&@c<@1wNll1eGQEg)vxOBbqb7X7>
z7p639S5%`0c@|v^td+E;e;m>8i9D!Qgf7NR%a;GpsfqoV^X$osp}L%7Mm^$J_;o2$
zWfU#(eojR)+ZeUb6xN!6)n|#`N<qA$YQcl&<);Ax(@pX=#)k|9t`3wLBpZnaP+#R&
zf)={!0puFK3b{|1?Z^!#-EF&VP_USXNIxg%xH+6vj|5%Nf2vk%DR*&E(u|vt)%4NZ
zOvooEwpU%m(<*nttCyacfEL`bPtAcehh;`35ol7d^Hw=|eJgz>B6_x5A6ykoPU6j=
zEvO|Ni<JkVXH^}fXbRh{_V(<}OF!nS*loVg#XiE-Y`daXoc~zB8~d>2JbjBMwxF_J
z%{rjv#iGv+|4ge$t?rrQj9H;eh6&@g;wwC(auZq(@tH}CV=2AJS9G=h)#i>XA0=yw
z9Wi3~$I?FL6r6SHU8?-L%`rqZNL9n~K~!Z7Bb3>O=IoxU!L4+XjibUROdHu}p03Ux
zvzZ|rDE6Y9ZRN9Ka|DBDiXPU1178<+zU2qB{viJHV@7V8TcbdGN5?~J%LGy>KjT4K
z#=3*NX#7De>%~#cQMpB}|D3vG%z1-@)cM8THKS$G;PUg>Q+{lzcQW~?x5U#Wk?jT-
z#&xyx)8uRh7fOAVKW5s2m1bY>kGUIfM{&%(qW5IZw?7K&=FQNYCu`(SW}fE+)rfpr
zto`BZSc7R?b9P5o+nr!dPyWt0ws+Vijf>f+X|ho5*6r02@hFrh93L<`aypd!mPL+&
zpPWBB<rO);viEPWJGrf&Vru*$&uMdTp(5B=CzHLvI6s|tbF4I%CdsWI;zr`?LnAyf
zgIrteG@7va;!N>O^_kOLl#%8F>#VNi4;|trABXWHjkl_y&&o)|a!o`%KfbSv(f?$_
zBX~#MzNi?Xr0qvp@c1++cHq|L<(=c@eariDV=qVE7Iu$@$8|HK&5oouW9=^7VKPx(
zxX<qR{)v*13EQvTYru7El=KCnzzYk<ZRlj_%ce@h^ZIh9<?;_YqT0`-15|#P+LY+{
z)%EDS)lID~9&t_Pdqp+VnQKBLx$wSL@VUADN=ax*q-$lBqYw4k_OIpAtH)Q^N)Bqf
zo^)Fic9N3axgkDwBMS$r#<>}&TZ3)ECb<WzXA|!~(mnL`5uz={ltZ0L)+2Vz&wrO8
z^kSxi^;5^E#f<%S$NDvV2F_XI>Jm!M7Wb5ILEeJj$2aMgYTI*Fa4cH{tL#{xZceUg
zDxLf~e{gr9di%San%npzxoZIBY*A}+Ai7XCAA7SjJrvg>-D~~*LOcIjGt<hMudBPm
z<nTw@OLwQq(VyeQ#xgH6yj`nwmhPId?wr5yeqcIdqOIaP^E#!PE~?2!7C{K5R`BQe
zmd?`V{hUM`l@`I42aL*_#jihb<SHIbmpY+5F4&zuquz1YyPVs0TiG&FbNJqP7^50-
z*c@2(KH(Zj!W|A@YaU$*^nKKC_bu~5#g<kP#&M5njK(;10HT$Yo(i^z2~llM`}f&^
z=U)=*WCA~>my|qK!6GII;7Kq~84W5NEj^2~yN9!`Czt!cV|>(+=$13%?Ged%)wZi=
zcNZLfZsu)`E-zdI!NEj&4lYLyXBXt-Z}eTH{N%Z#@7rzR4u|IFXB57YsF&v5w);?p
z;f+!d;xvx281Qn$n{~U~c;?gbvSy*ztAQ7}hT77PW9cC6*xJZg7(58JUR9%pg(I@j
zGzpu<OWxc$kzPTxEpohQcUi=Ala8zRUgn*hbw0h?{&nZO+nYBRu6)Tua!@f=?lS+r
zGw0pU6XK&|=i?9kT&9tQpg+fv0}$2JvA1#dM1+{P*@?X;t96!H>x10hFh9-p>#$So
zj>%AGtkRZX?J9mf#E~s`^mx>gy06*)@gwNaW-;_QWwKXh<RtH6@_zj-!9~xbzUA3R
z_E+Q=j(T&?fA9-6%tclI(r)XYrEzB|-a;82D~)!o2nwLr6DQur7LnvHy5G{eL+mJG
zGNeQC%2!YD(_n>6Qc|T-er!G~6N|P2OG9zqEACubFYQrB^1kM?$9nAGw8GbbA~q|9
z@rS0lHaFEb%go6~ZaZSnt^s_9?^<)qF6(L^cAK_pO#GarK1a*pY*SNl)L|R*9KSP-
zc``*DfcQw-aT}c)GP9vsswX=XN8Mi;IC#>z^l2q$DF0OPo$A@HLRGPbgp{DS9$(y+
z!O}W+vaJ`(sHMh8iOi08xs>TzyU6{d<2M%$K~HY+AK#ibizltCT)4cbdiK3NQNeN8
zl%n#aS*P@sif$?gu_4bfs%psGG<5*^E+{lYb1A04kcQ)Sxt3Dp#;<j+dgE{A1#61r
z=-4c}49734LW-Bp?_|q(v5h)X_BRQ(*a^jL>Gqt5Os>4}{HR!vdHmq{R`1%8>op*A
z#WkCA4Oq!Ko`0&?np?Q27t_JeZZWQ!GAXZ7vPr6gzM`*}AM(SWprq0Bj($K<M`?ud
za!7giTX2&<&0)RDGQA^Bem)xZZ9ZCU@k?43J+aBN7Ckza&568Pj$G-ZsxZx^WnXM3
z3Qfb*Wt%sCpBCMZ#B!~!zMdY&S?i6t&R)FHdN{YN*;HRWn|2a2Q(>f{oxv_*%q!5k
zgRce^qIc^17E^aHQ*O1T`{bjQoX3wq>%h}al~0NGjy|g-*et#*+TtDhEb=1E;B4Ck
zK?b8W{*Pa<#`3ZX>1%_r@L|D0Yk7yr-Qun9&*!dzr@=DNbScr2SFuMYxf>k;EkEwC
zPDRf0dAoVdl(!G-P<PNZmzgEpG3E1?t;}GjHny(O@o*lPnAk6L9OIaJQL?CbiTjaJ
ziRJ|{D@7U0OVQG7ZH(bf9jfn&ckjM0S5iEx_WVM+T>dKa_yy-O-;-z5t)1J~z~i{G
z#{-5ramR6PwLjiDd^Or|;ML1{h1OEFCTLTm_yqeS{kcQl>cj0scGdzzo@(PSlOONZ
zmLG`mGOre7h%g7p7j<ZAx7-$=KxmB&cx%5oA)(UNqQ^fIuk9srVmK|j?V=TQ{9?f^
zZK|MP>apF?X8(oS@G+O8vie8Ii&kFJqg<`g`o*anCZCqso*50zcs=Sk-n`)SNIQye
z)W$l;xOzAV89Eq?VkT5?f~N|d531LgCo9z}HDtyD;`bE3g_W;rqwbx(d8$aCZIt`n
z_+qIu_^5imwYcN%j)Rid(eAIn!t{eR$7`Vc*RobwnT+b3+|Zm(@Wr!Wv4EB%!gsZd
ztbEd%FE#oc<L#(jMT{9}k3ICKG%8A!q=#o#bH`fLv_55XYkk6>-kG>PJz+W3=r}xs
zsF?gQ{3*qJODEqn`}ablTwhkd`@8&=Z<G}8r;mD0oQb{Rt3SUrrhET0CGUOcHNdtM
z5p<f|!B^;F#<!%K_YA+*JbtL=&H}~jt4ZzGJ{mPs#WuC&dz|ITwrYm{#$QMIf95=#
z6b?{-e4Kh>`Vglx{>RvbrBSgHNha>6v!A<$5#=)N(aWeo%!P8wZ?;4Ri_v$K*6p4@
zn!E<k8W-wvDATeQ7Drn(+Fjl(zOf0`ea*2{v&Ool!(3yhN4l8wgkm<5ipNyjp(b0i
z@_gaT(X+8$FHBI>)HSW~a;Buj&CumQXx`rRrT1M+&CqG$0Gx9Q-@DsxsD8o0!^$*v
zB8X?30r&}9N9SV4%kS8>ZI78UY&+lO|NPQn(B3{(ZZ`a)TH*QYnR_Lriut$mmkbU0
zJoYRX-W|7n>N_nEZTP7jG`H9|uqk@ES#X-9q9*%MX^-wO>_zd{64z)&(jZ1w>V@0$
z55}h&-ER5a@6Q`-V;&fme#3}cNRK%72u%BL;r*5OBft}X1PDF>9xWXr=RFB9@kayq
z-3Z8#X#<KL6^qv|q7Ikb?ykOmk-6sYhHYW($V(AV8c!0qmL!l0m5wD~kRR2;+Q@5;
zavvoh7PP}!&1-%<WWkxGTtPz-Pmw5F>hH==IqdH$Hg$IcB(fM!F>K(-rr&6lB(OC|
z0F_Q=0|&!K!ag%S;Y8S0IkS~3jQu>SrorhFW%oZB4g0%+<N2cwKT-7PgN;1~a1yD#
zu>?$-+~f(XdEA-qqXs=>Rv<InATtI-HXswiFAp27G(a*i9^9~D9PEFh>@je{ws_i_
zG4w8;%A+@lNeew9p%*049OXG`Ff3>VvI3_zWWxo@L3Lr-R|?W_sQP4-2vfu%$c`VV
zi>JI9Z{H2AdhV|!G020;=n=4E>w{Bxx{=BCUOE=8ACG=w`1mP}m!Duvz}0X#3rgUG
zZR6QyTt@>It=ojRLH@}TV9Xl~b8#hrGL_kaWc#T+ET6))Q0npWMh|@rpA3ifVIr{W
zVP*`EjS4eq-F`e|LoZ;5_TDBdHIx2c)_Yq9Tc~tlPEBoJ4mjGCpWdYpCb_@UT^o?^
zp$%|mVPPgvdEgvb!)(pqm|@s3E>Mudq@bFbDVWGFmt19=K(WCwQ4O;c!}`W`dK|d8
zxab57s<45uX+Tc<3~adxpwQreFEur_DzYG_v!IILN(P4+zTNPA>0#9anu>q{9KiJ+
zHl`Ui%m$zEXt`BKrwTS3Ov(*#q9$-618^dCf&Kj~c^JfC6G6F#SrSU1f!{y9+Iz5}
zqnqQ%10Mkn;>~PmtIddO^XM0a*&&vIYxo|yO{NAuKH<S~TKiEAd<Kv&*d#ntijAHy
z_^sVgju~ca8fF>NmaaDOnKOA5>@%n1SgZK#rZY%fCZ0mS(ef8)V`=#qcxT>BN2vDM
zoXOdx&(55Q(P7OykQ)%`FzReDY=buIJ;TRmg+ih9w>3+r>Rx@B`@xs<(C6}ziD9kI
zZ*d*U<4M@`w>|~Nz{`kjxnc&Zo=JeuOkG8~*?p6w{vR{7hch}(n>h{@CGT|N53eji
zii}{tSWU1m&({wh7Wejea#h-Y);%+<Y1P}z(amwt(XqVR8i<M2V1;T|Yfe{votg=#
zZJqk4!j!I1`J%JK@XL&jjzdL`j?Oi(SbI?j_R?V0uGUh};Q2Z=_2I*Z$-O<kTotBI
zp9<bw115&8jx{aMK&92xbiRy<$pE`*R-`+WHSU4M`;|#YMY=-EqQl<Tt%LciXC`-H
z{cBZNpXuoQ>IL~MVFZP8V0G95d++S|zItfq&@$=5lN%6lHopt@oiS{6(s6uMQ>%A{
zPw-D?z8|KwQ&Tf09d%FKocHpXrWDFRzUDsYKC3MUht%qJ*6KLcT(uu{!l>(&P3l=X
z+>Dvr^X}Zyb5q{S2YIZ7jr#bo-l-f^4>->8nNCgZHNf&kd#bMD%}58Vh;(qAv(Kr?
z#|(*`5&j4UZ3C9e>0e{L7h-xFW}RTbyo(Qel!T0g2tdFBf2xE4K_s|mv5zmI;Xz1O
zoH~KWNxLc@+St?$51)t#2x17z%2871(@|0knKG%?rt7A=@xk&h*5jArKBgL_stppi
zVJR0xq{-(pHfb`XGOj525rBngm$4xwrQDCG9_j5qiz)J*u1X6!I=Z_FPls-U-?~%%
zxHwQ$5^~XFQwFTL$k~(=B-wiEtu?TsWbmcA$g!f77}FFO(&r0$(-feR{}kzBkOr(s
z92~{S%Mb6~96B$n&j^V-8MF>%#2AbYWr7~iWjW_e?dC3lT%LdgHHddJRS1-<wZ2wU
z5GXLD$)}`5M6xJZ(9tRG-=5cejp0jF56O?b(^c-rL>el&53+b49UTK!^%kPW3A41c
z1eqk>je~ZiN>A`u%r&vV=$a0c7;s2FDv_T~L}vimmH)5unBk`Up<%kN3(|;rHc$!E
zAM^#ZFzt@#?K7|fwpnW(N>HR0gM@DTF>*j8CG#VmgNpozF``|D+tSY>?^J}r7_GDb
zIftpW98@>gIoG)m2a3*$GFaj+zQH*Ibtpv#SME*af8z16BFt9s0;6#aB=D~%B9ALa
zNnocer<txB9a_w;>uyquF;U~e%!CysTV^j6EI%%9qF{Dol>Fa{gsPXL!wQ-t{)FE(
zAnhm{2GbeLklRw@Q5K!e*hgo-`AL)?2T%FGX8(r^0s>I{Ye4ygF%3%jwHo_)8m=yD
z-F48m_-=#IMp-_`79D3N7M&%$beH(m6z~(>k6x2tAEs<YQ*@=SG|&=~^o_TJ(9#|f
zC@{-hRqv`<D$r~4Kx0a7)bgIs;>{x_$_vg9TUP_qiD-YFND&bcv9SIyo|qd&Vi^j0
zPZ$c1kA<jlI~mfz3Fz3%7^ft8=_PqNd(FK$&(1B5j(fItqQ|Ci3oCAkfoMQ8v$h8{
zrCg7cKL7Ylgn~%yE(3#_rRF(-G#t`TCcqX2DCw_5Q0uS*lp193<|O32C6*4Sq%0bo
z6?l0w!Hv$qYnlR#Igqj6Y{FOsTOJb5rztRBir|DvO5%esf}JT>G1EPq?Oua7tWj<q
z-f;T+c4{#a;|d7d$FYo1&?)}V9kjLLZ?2yH@+;pgoxhpC^Jsh<rdm*--)9AR<cEU4
znFFQ&Lldlkv~EtAlnf`#jSTs!6>hd}kG4Q^%}jlu-;?ukHG_b`(A;G&gW{t_NYarR
z!zHbI#B@vShV~zg&~cPJ1nms-T-XVt%BHNW=D`gz>BD`&eIb;umYgToXLDk65*YYd
zRMZ28M7$Vj80G&o4oErmH)tpb!RX>B8}XZ2P=y5YSy@@xAWfls)k>}ElmQ!CUGQYF
zjJi#<D`|=*pDq0?Mw%W+S#Z8bmf}O9EyV@r?9v4tUQ8OZC5Q*m25<wx+0@U<D)<Zr
z4oh1%SvT3B_ZQhexxd+-*q&I=4>lf@uF3T!Ct_meNxt2}E7O#uBZ!q&Al&XzD!kyF
zh-&+lW#40brOYD<(gs~A0@UGey~6Rs^t;#||9kidW#0<z;c~W~2R*f!rQw8xrdRG$
zgxqX|5|ocgL6)k%6eqX^>Pv?&1k;RA>U6}bZAlXz(DsZVu2UJ(mQ(rH3wk@jt#@oy
zBVI%=Sl)kne>DoK0;cD0c1wOzZ)MGF&FuOc)2-;h5Ud~gnFv4n=h$|Fs0aKrhDjkE
zJLs5m0@Qm6+^jcty9wkV6fTI~lo;>cun%(F@$XSccj%Si=hn5K9Pb)bNV0SxDw2?U
z3$Nih3C+?Ka&$w(b0RLz<8vlHC?7rUS4nzHx>G1vhbaiE!4e_KNTA4&%BR3Q7hXe1
zOs$bSU+}rKI(K1uWcTl5)Q<Zh_d^=AeU1I2Gf|pH%rGk;-@@tdjf`NUv+#<^V#dvr
zwzxbxr~my4MeBi8LF2&Y04IZ^Fui(OSs6xHSs7FfNb*09Z-Kcm!3rrw?<PmP23-RS
z`+H-Z7ox-~r+VR^KNNN!+%w;0yBiq^N=1)r$$7$zYiXXq#rZxTi~Ni9<q0U5FVvS{
zTY<$yfsvyGHsduw{b)>Q<;!bOv;`PM;hF;>WyhV}LEb_Be(P-@GkEp|8h;igT%Fg4
zc9UR;Qpfa|_+R2j#J;`QI#wkWi0PS6;9ldj+Kz<=;l)TwN*6=nfrBCK(b^xPe~bc>
zg<%#1ncdP@=P&<jV1DZw5Zio6Ku36qKQH~qlkgNMQs`jrl%^oIb~ScEdPR8a6ihfc
zz&AJ$1VpeP{mwT4FyXKuythw4r-6r`N~`ICBvCv;6l&QGZCZt=91vK_;nDT^HO`%`
zwa|XVxP4UtW-7v1fpqW;+gHIh_n^`XedkA|n(1x6-8~UriYkkfKuspZ3Hw_4A78sx
z1aOdw6kik6BdvycSbtV!nBY+%l>XfDoasp$)btrPtPo01fV5%l;}Z-D*c4Ww6%IMJ
zg#wA99u$F}dCqzrj$$Tdb9hoK5_ud-RVeJIWOJxc^;Z;|bkd&YTd#lv;Z#qU+n{Fi
zmlPCK?gGV6ap<K>UK7UhsNQ+Y7Pl{u^qL?F6`=<)>K|68w(!eG>6NHXc^b#U)ldqs
z*}U4ylOFKwJFHBaIr2PNOk_MMRS2r`u5a-%haW3GYlA}jidcE*U3sKo?xyJP{Ft7E
zIe9v@@u*-E$Td#B28AJzPGwLafHNeUwW5erOZ`V2b`J{U&pd6t4mt8uvdN+<G=Z>6
z8qWkMmr%-AYN=|R;^|nOHrByeRpeA=>cJ8xPx~CE*y0lTlXHfss0Kxbl<~DN_2e)O
zQ*^ystvK}Yj3fe$zh#0m-Y<&HhVc|5k3#G~Hu;wxXbqL1+Lg)VMF+V(9(Q~5@$TZ#
zshcBA$2`N2*%ZA8Ii=g0|8D#@1Jbb*Rm``{$SZmLyKs|(YFqJ;lUvy~C9Rc`0tMsY
z0Yyvsy5!D?Fe`x5d}9h86@1M|h0?KfxkBhAJMy{lt<P)uV+a0+_8e5-FLUnn-@gWI
zqp-1XQYVGv6u&8!=%hc*x5>y9Z+a8B-c-Jn!xRsN;etnjrvF7P+4wjddEi9=4l_oC
zE}s>55N2v9nb>U9m~VOJB3K*112mLQJ)}CQv#Zw3ZJ%}S!!HV^*oxN_PTi&9(%viH
zD;a)_2CNN=Pf2uNLx=VaAOjEBjJGb>k~UJ8nixLoM-|9n5rndUz`gesD)mnZ`AUVZ
z>yQKDPKEH7Y2Y<rcl!G5>YaQw>5e<c<ce8&SEnM!l(|_&cX7BB>gmfZuV2PqZD1X-
z60!UNIAJPl?6iUDM#@rC$1q)+<5H`u0f7fwtiU&+pH%4L8MfJ#qa5W4_F(ZaMI{nw
ze3#D#^BOfsJ=H0({#I9QS4~%SS9Lc9Oh$KBvrwH-op3pnBy2Vc@a~tcudt(A=;yBD
zYZ58s6q{7GD40MTZPuJd$jgn^{A}@z1nx^7R0b>{ZBV%5fs}E0SrHn!@u<{_NIiky
zr+SrSu^%zCOq)(UQjwS`w!}V%z8a@-S}2wE1*3t>!=q6pS_1=+YQ5)xs}VIQlFh?R
z@jQhdkGYpHc=LcXgSZ&C`?9A_g~U)L_oGR?o56^HjKX>V`W2)eQoDRYtn`mK?y`9>
zd}2JM@Z;GRdJ;MpIukk*rn8b^{nZq`tBEpmu2VQu>Sij7HtPp$u`KD&{G^N8PZ&Yr
zSoZ~}$zVXA>Ysv|c8G;n?mwjI`zungw)Mi!lp12mDjkes5SJ7(^3}3Q*gOu!)6x20
zsO2-PYh+TG4Qv9>2AzKkW%}#T2z&U>QWIrbEXy}VhSD|`f~R1N;h88)_FCRPk!#w2
z$bs4{QkXt}BJ>DVZ3PT^p;C}2WFundNasj_Ezn{$U9}$?YC+@Gf-Wcw6V3q!+ECCr
z(PveWzTOy#5-yqnOpDI9JO>D2QBkKJsn!(l>vF@_?((ES3Voi&(alVp`oWpA^K;l_
zJHM!5a(Z9kgsbIA*5^q(f!2y-xJ}HW9aqL0sa~^%Uj~nhIE`ICNywmV0wj7cBT0D<
z{RF4Y_+|hKw_Kp)WCF$&q!LBYyv<5^vQGpO!2l#cNcy6(b2cK9cxA^F89`jVt2k6#
zgC2P$!JWli9VSmV85i#g7%VGC>DBUNvsOcUkXBwpJ(kj}OTZ`<G;DrxG-yq3tpvAL
z)J8)PD4fu~fhnpfsxIt+;}#BZ%i!8Cu>F}%YUnuYJH(;{`QAipbJ<4mMB~r&8ow6~
zf>74M68jA6BAC*uNoG2Q*PnNsZ80{${E61UOw`jr^P6g!YU`2@PMMIL0*F`pNl8m<
zBibi#K2<6B5$T14dtSXzInX{-7;GArF-5X$37nEm#2k=NG7K^zPL^W&1wWA|p}qEL
z46$8#?qH}Ru+Mf}&bu7e-Dq5Tj@t$TBmA2xN1M>)<ptrh^k)}I(QEl5SY9t-o_Av;
zkI`%3lE<BiNy?J)yf-EVEF~;)O`P=lMY2dvTlg6Jl8t(!P~JF{LV<{g4nqotSf~d$
z4;ap$fz!l*u@4M@Wk$Nc4pln_#q;kJ?&dQq3aNjQdO8VTn4~AR8VT;ELYE7*BN{l|
zAipr~bQQe@FD0)*sjQ*0m>(?f1+UYEv4E3Du&iiwPn`)pq6fotiI_);1EEs4K;32R
zQxfqe<W#nJX40iR^gfYm;6S?c7Fr%TYd_33ppCHk9JoQV77E0qLgi-Y=(JhE%~wRs
zEDK&NT1tHz#sxb5%`Q_;ZGGogB5Zw20T)|WaLrwvZ$i!hQReeal`^fgkfDlEgSB6i
z+N#Qj9$fxF{D%i$q|h}Yy#{vz_>v|OkvHg)iDOGZ>ytKrjgEl{69y&`I(iTv<K7re
zqUhRB3NVVNC!zO)iz)}w?D`7K^H&~&D-szq_FxavX908fZWbKGB$Q|nveNu?jo2}+
z;ND0EUsBqM9>NR5*1)VRxOs;cGnLn;#~xI&QD9)pQ|QfMdcjDbvGiC$&eLPL5D5k{
zYO9bH#m3^|dU+^XguA2w-QG%A@?y+f81IVCN}?Z#7tjxiL$%*&!BHidgp4mOFTd?C
zM5AW2a$+iCRvwG_lOZa$e6NwGV-UQGfNs_VW(WPA?$V!C?{xEYoG=rw62|Sv%3y=f
zAJa@5r16m?@M`m<S?RH3^cpD!W?3*A#kWZtI$)|VhCN+Tz);$@I&LoP>hzSiFX;Wr
zHs9>&xvK(~ArFRmrWYWf%od>19Zp+^dSmO+qG(sWFl7ul%bn9*20+EeBczje>AW`1
zIixw3CxXD2nja=dA3-h$A6c<&9V&TBpZ!V$zbtUQeY9XFmi89RLJQX04wVX#VjoRF
zrH;YmkpT~Y0LX~o)2e^UJqZAhmQx);+#JH?UW`wd_WKz>iWns8K=IN??m-=dA7?*n
zFgC^;J9j=ipDpogG;=%Uay?~S0lFbco+yL={2aR*i~a_NV<jUdf#cp!YbOli)-amG
zI+PcEFTJ=?Y%>zIS@hnxe~o~>VqgM!K!6}4!(KG}<^lmv!vmidd}c-`5t>@O%6TyH
z&zlA@It*D?w3-1#3uo;2w3=MKk)bR$F`UB5^j(K3DpVv~#7&8-rRGbarPdUDBv|}N
zb)%T^<mQxj8u+1<cnnk4eA;Nm<}EGz#1(k@cn!|Qn8=}Rfc@!nTKg$W6h%H~9!vXp
zh<(HadP$1?L~HPhGiA28FRlCp5x)FgHa0UP^;WdvrU*^!43xM0*xeN?^W=!0z(m70
z66_wDjrAUc27N+lrWh5{azxn#K9odqMCcOu!H+Z%Q<TFY6B!xC!dP<54@EB_l=*^^
z8*XktQ3{Ge!Q=3fXGu7LTAA82gej&0T7xpg1Ku*Xc)8;6+L`jsG&(yQ=hSLcAs6j}
z>=1uqKW%q|TU1O9B??7JnST+cl9K9f7jl9MQMl~eiBjEs*#Vv<3Ss-DkSr;071An0
zXL-K*g$7V_lzO{GHr-kiNQ5#F){+M2Qu9ViOiY~6k13c0=%x4Wqa;%BQ4dfqmr-UT
zm`{{{ckbF3Ai9qzn;341#VeksD~L2<11Ml&ft=cWWbeUKz!WW3zemiFkYYbi!Q(2!
zNk*$ewiMzlp3oRm!$Ot=?Ml&4k>{h`CgVoye<4gJDI7~UAz_KcPFv*8N7CJfvc`ws
zhA91nB#@I--np2?Caf2|<O%_xO+$~i=C#=uZo=01&SoG^#)sYGk;qT$jQ#jIW<2&|
z{m1i!(#}<cED&o1^8TshhF!90i?q>z%xGU_c{a*BwAkTbcLoXu2M5bjbM{Cc(+H3<
zA5!d7>PCrt9MQ4<Dee1=>wG1n0UZ2#Z%?f>mYAiI!^E@22_#phJaVg?(W)r)_4Uoy
z+0av#@Dx}^MSGH)9izfEO6kd}*vU#(qsG5cpd+$I7yykRVDMzb<3f2Xt=WVV9(r{r
zyZQ-ZqV%aFZ8J+yOWWO26-}UzzGZHa7rF6nE7VSeZ2ApZ4T;x;orpvk=kf;txXr+Z
zX6{cTsgJ)}U4zr3p0c(RR>B%n1AR&=(p_ZblVE8uCX;t;Feb~y%ONj;IXt}LGVa{-
zGxjm0+q^La6VIQ7MpmS4r9m#Lao#biw2J2y*M&T1WZto<sVQFtIL1C5-9J%j@?Ld-
ztk5OJJ$IWr5pMsP3UNGnK1>1{Ddn!i%qqudTd7heSFYX2?p9gSV*lu44vz3HWr5t<
z)t;EuUMtPx_!WzM`R!!gaPsjl<93qoAmDqFVw49qyHTYQH56QyyV%GB{00r-)EY4j
zO_)dnbaD6CNikD6hj7-!7fS?Axp)=&yJhU$Q<&v@?l(-|TR;@=k>{(bQs*iWrXNZj
zdW;<czLUu$Lt%{)UNK2Qku7~W&KXxq6)14(cz^VimwLHZ&Q_dK0N|kxfC_9f3->lO
zksSi!sSwX=ptIuEcz+(2e^+1m4(U3g#*#e+)@efzRp9+Zl+sreV&U4n*eRIVA&Oyd
zd+>WMV+oPNEF>Bjj4-dRvTDeVuBZeO98FU_F;hN<zqW4@IQ6lAKt28d+v?@a6O9E#
zdCo~vlo@%(FDX6eWC^nLIOF0u1^(#b>E=D>R7ZqF?w<ubu))YA@qiYKbJ#e5di;wW
z%d{^jpK;2(4LQffx!KR34A|jOm{;Pd1XcH@3Wlv>V`GcmtE5=tB8-QCC2Ul6*jq5c
zzCJ!-EN4Hm7p0D)SlHI=7>K%0-9Lw$Z^&=RcX)LNY=!+8gCOO`a2W5qcG`aZ$uc2|
z=o5>nO07z*q%t7V_C}mtd=eX_%Ey5$>jP6~6yH4|-gAG65Px=Oi}3nWSyoCVu*?Z#
zWBEwQ>R|649GbSRF|X}ZX_1&{)KDaCJLYQhS_|hS8u%#kVxA>xfzcQK15fy`WbyFH
z-WHoN7U;H{Jnv#4DTO}GuezK*Ax&zbac`}-<?mbu!9=^)lv7;jOo>_Ee+>Ykai>Y|
z+J6SHM22y#y`Lj%>V6XCg1UINQjC(0$Wl^~V{t@b4jIm<mM3<X;I?hM1}usn-Zy#l
z{BdCM`eS{WUkP{!@@N_^(9iXGv12Ev*jZ^-bY3WsVVa{S`+AS~a*sr@*@ZKW5W65o
zLa*c|6=^HVWYhe=@lL#bZlF-XOU~nk=IXboASpxmi{8$jn2UK8B9DNC#ziDA%N1tN
z^tHNaB@)j-nlqMt1Yd(BviwvY^3dybw)X5^WJ(%>+e#P$l7V#-xl1O21Vmvlvx@-*
zjTSP$Fe+iGR(nQ|ASdJ<b)t_wDAIhQUbqVt2e3k+28>1cGC-^ffZ(M2q`Na@g5nPI
zt(1tcujigU=HzVZ-#d>6rzTk>)GZZN2*SisLdC<#okQIUhY67G>htve(j~A?Ay1*j
zEc20SV7dmf?2#I&B^Xa9o_LTT(54K?&_`=?5zY>Vk_EocdT5TKNf&`9nfp1zU*S#R
zD#V=lb4$L|zJ??aCC{iNeY<19x{@WOag0@%{WOMdQ;A_stAT`~i?*?Zz}=n?UvTzr
z1fC`#5_!JG@Wfq|I0ig%HxG@^WWnK#vMwzmkL#Ek>btAa#l(-#p1xEJRiJf-Od_?l
zFfuL3Gp0&0(X@z50Ek5unrKMqm@Ewl(0BCUvd)4JARt0ez}H)_0$bP-0DQW85*ijB
zp{d=)6Z@-;2VkZFU)W*q!0=-8-n7<v4pdNuhd<{j(4bOq|1Q+TIO@fM^S$-EH5w%A
z@O_McEg)=xx;y<@9w~lB)m|BmwxJS=co?OxzOt7T2$k?Q*gRW^8W@q{@*!Ix><><&
zS(UJy)1!NVmSRHU|Hjv%Nf4{AQX>f=)#PL8`!t6tAM|*=fpg34dM)!Kj-7Ed2wLwq
zs}`tqLwml{BpY!Vn%y}*dAd{H#P18%f{t>!Q{mGXJBHcw67nwI=T%5utx@*yOTYUX
zsrSQ|kLtD~UWX=P?<{hrt+6|b#WM~r$Eb&N<@Wg%VN$J&(1yGhXb4UxFYqW6VNFD6
zrM2^367P8Zr2viKP`v+u0Kps!TP(ANMBaXR+*bl1I}JLI#(S7TU3h>6bP<R*A0O8w
zpx`+oGgX<R0BOjDmE~HrC?s7X#}YfpO~}_k40ZRyua`Fiv(=T`vCPWz){L9)2==wv
zYTffV&5jS<F<_P&QL2$Nwaaav!2e>!b<8Vm!8qLV<%?e13lR;uC%HdYEnn-@>&lrQ
zi{4S#;OWZjPQtO&UI{zKIuGeSOH8#G&eD>~VP|aS4!pw9@Y?wr9*Ipqa`cXRJ-=Ei
z=Z^OCX0RPjOiKPJ@IbR;r0q)_g<S4dT&5}OT&)QS%@xC>zw}C;xbUlX*O?E#bst(k
zE`HlHdEvO%uII7{woUR-O>@2U+boJ8jmvW}&IoP$If>a&-S!pP+-pQ0je}TVvF&yU
zggq#ARjYT+K2r-o?)~odOFc{`;*r^T9d-1Z6q87mG5!DSgJgU`|F$x=Z-T87z#QAz
z$CJk!XZ=L`3UEewy8Z7&Q#}U`tEVmdzYP6?p(4^INtNe{_+^Xjfj)ALv<Y9e+F6>A
z?0$8y=7)TJvvRKd^`WW_-ej!Zle|Mp9jeBkB>lo+ST;_>Tl*4mvA3pjM6lf1r%}cx
zc~H?wvjWDj67*jIuX7d-QKdbRqHtgK1CV02SroVYXK8-gUsM=2%c>JLe-wuKaeouc
zn+^$^AC>K(*H1alm*|)-be)dn<Gn!kH0om2JXeG(FGLy5b_hgblygmpGN!&Q{F3!P
zkH3VL$jg_aNFYu17gU@(HeE9UA%r1;MzjVEt0x|H=U(;}h16u#IHe}a1C?IP52IBc
zsBH+~?@kFlASXvPR1)9BeILEUYsl=rifb>Hrd|&@O<sj}tX>J_V8D8WPfG%HO`SOw
zTSp~cqFUo2Bu6h-;X`D)-f^*Pq4-WniOW9~lTX_Pf=EC>V|ARW_4*$d#vJX4;cra_
z(~p(AdyI&)JpCNiZ)BbuW`sDRv`b9K!9DVEJLbo|>;Q@q&a{n1AMXcgyGe39y45bW
zXTR`2DK!aFO{@r7N)s}vK0@-vQEHftN*@vyeBH>QIVOgr@3~1dz8N3u{C-(1?Eavy
zA=QLod28<0zMMb%z`B=Q$VM!la<<?vBJ=maioKC`K$V(p`cS3YO6~K#Kxe(ajlVDm
z!(|Jpg_hSWM%PwO3Z5yeN2{k6@Gpp-;`mo1Ab+l;)MMlXWX76=S^e@{2!_mo_(E$x
z?E`^D#>ZU<q@n}+)t^0Dl>QTn|1(_gAbNc-`*%v>f8F4hT%p2gvS|7NO%U^E;d2e{
zC$p`i21FlYn)|xXG-DYsMK#ch+SBem;4eFjS$V~F^iWjF+LMKsYUOO5DC1t<r{;Y%
zjC_T%yopa$%_DnN-dcd+o2N?%ED>#Yq(&|wG5Ufn>9uB-tJEKRm{U!Aw&Tn(^=5KI
z82|gb@;9RBX{~MPsQdW~m6m*R?@HgdZ>gU%>)+p0E#s*|m^feVienh;t5Br(SYOeg
zOlBsCd7o>%3BQ1j?)$OYJ?Z0gjI4fp1-I~;e1HyqcHYO<Xwh-xBu|=ji;(;CW@Yd4
z4i{at?Xjy7?^k?A-rLef3x%#&HiYoZrpDpNBdYVYx<|12c3+KFS%hN@Lb8hib98#t
z<eD%t&H-QYbCuAD)~M~@a3+#`YlM2v`Ykjhw_)ZraRfp|OM-fWK1FD2ZRE|Dx8ml4
z&yEP1jPp+;u@RsRmv@E5ND6Mn-#xmx{ed{mTX_0a1>?c`H9*|`^5^6o863W6Y{?oM
zsUyTSMh0&lA^nX|qIxgafRbbm{_k%e8=nWPtit1|B72aCyL;*I$i;p+sc6AV0ga8#
z%TvwxLN#M5mcygqU$<q(D(i5F{QWzF@u>@PR)WzI7}|XEP5xh)T)Nmnp4VRb5!S#j
zdM@Eh%r9bI0id;=$VI9VCYBiJQx*o%HQXhknmN<M=~<R%e_OHjl<03j0%WnD)^YGG
zYQ*bu{zj)R%GR>HGp0;5Z?H~JKQ9tpH<V4V%H{3f@pz1v_C`yEKcWyruK_CVTobip
zS`=|=pWA6GkkQ?~y4=^6cMW}GJ}X80&!m!6KUAJ>XO>h-_(6Y)*CnV&DK84SAGS&;
z@Q6XuodJO^zc{w0$V38{2mJZ19q;fLnKM=7^RL_VcnC~$QAoeuM-rNI7ZaW1(PCH)
za}jpNFYo<bh34dM2NKDy4R)3A)2K2E*zvt8+!n_QS>u97LNatN>by@oA#Jo;3~*Fc
zg;tBn&PdzZ@w-@zwGi4u_U@BxU?~9Bi_`pQkbXg2`Tqn~E*8S4x0h_{>x-{_i}BD&
zoj<FqWMQ`K8a*aO&K`I^N$LJia3wQ;+azA$P(&u^Vx;stylNn71}E0UydQO4>?yRD
zcmPbc7ZZ~CMv%H=-+6^+(#2D^4GHagGi1&JfWK4bq(bUJ=mNJil*AA*?FuZz(o_*>
za~vhLOBj9glre5Me#8^@soD||Wn0szs?fajh!v&7s#(~|N>f9)P<B{)CxzasR|CHI
ziibYvf9zMee+`s<u-f_B^#4HS8@@Yhp72Z9E~{%mw>;3R`jgf@99t9FdqNq&_u5Uy
zC}5_PZi3-W%G{7mu=enOUTNU~g5!-Cws2EICM-tGG6b0MDO--CL2@o6ud)E>)&dQ&
zuqt1y&ELTj7HNs$8G-M|+UMV|0p}ZafH|9Vw!57U*m|;OhF?&5PTY+(m3>SUCR-7O
z&HR`NDHT^LelzX|A1>EbzEJlvcN_NN{q`s|Xh-yfEYKPx?n?2f#?JFL?z4t3L$t`X
z`%6F~;il_ySB$t|kmapS>j$Lf7j#0y*FaTbe|o6&%cE>*SK&MiFp7QF>w6dIszLe2
zGVA^=6}f#Vf8aY#U(uZ86=hrhzLet{9+c_O{Bbg=^z;KV9Z6aO_J!W6@h3s~sk^J}
zS3$Q^?ppjvK@WApn!3sR{s96SDKp0N7-iu`9P5vOeVj$AZm6b%`&C#cEGKGjmxLm<
zZ)ro!4SRUt7X$!@5J4RE8ld?$_uwW|I-Re=KQAZVs2fXfSB#Kf%-}8HzDc))UoUt5
z&dq2{-IgO++Kzv8zZEuL)AL%6;1XwF$E9tMp?e)yL~C-e!9_HCNeYt@F6e(<)c>zU
zN*7glI;6eb1T+wsv)TV^=-(NdYtZqZyH4$3Y6r_x9$W+OelK9OmJ!%g-XRqCzA_xc
zSA-(!Fs^qK<T!?OKXehu9Ro1t6IyR|{l+6}Xw}tY^LtpkR8m>0QM6Q}Zaps&W~!`t
z3e=@ZaN`-P9SsX9i4WSu8$43Q*{HA-5zJT2)iF^K2}1phT2Y<bC9y&}TK`sUgg%Ew
z4!(IultaQ`PXLsgJNJ3R)*_xY@?K2~M!Hh;G0^}?!}$O_ua^lsAulGuoVSgTMt?9`
zGtR2QersHkjkI9|t--X17Y5Qj^6Z`#+V&6!lWX8`i*QiYLpY-{`tzSG@+PB&WBQ=c
zj56cT<?#;IO4Z?6WTl>NIVeSDdG()LH=W?rAAnGRlbCzp)ZX$tO9jI(`yUj1+k^En
z`B?X-<-Zip?A*f=FiFhS-MQ2#t};L_H5;Q$njna|X8DHy4(!7659Gm+DYUH(*r&?3
zY1=EQzgJi<E>XJ;(=ZXVyUzx`9KkR6zMk`<GB;izj`)uJbrB(iyr~9(^R7h>{E`X*
zAb0o0nUJ_`bfCzQqTN6iNy7+`g*TF+jvfl`rQn$sjOlUsSNv?wkqnL8#BW}*uKaBy
z6xNI9CCa&G+JGg`HK6X`F14rSE-F&768O+ytZ>0#)aOL^jajW3$21r#mBASCJ3&gR
z#kLrcx>IH^SY^%Hqwl3Yv_pa8Nd7P5ziT>(8kekzh^L^^LCshG58&7N6NUcXnEc!L
zA9exL8W0Hlh--_ksQs<=n_taFu7TAMZ<hBXvey8}=1h6_7~4=V4vs&#4|5lRV%hYs
zs2Fu0hrewlJHhKh$V<69_d^m9;zs^C0tL0ZkcSq)In%7@tiqM(lR=0;!8xdfwtren
z5!1+iy?6~c#;nAx4s-FybPtuy?WiM4w<6;SNZ=!eWR_QfhLZW)m32Z)7b8C|Lao&V
ziGTqdZk9j0)<4^=f29Kbd8F^BU@1T4(oM=1%jFWJEsjR-?67z{ns#L`k@>N@Nk0k4
zB1;?XiccBLASzv_C%K^qaPfV`ZV3;;FRpes7PDC;f08WWaMlDm1UCoT``5JaMEbwh
z2*em{m;7;xFfOv3Y9~>SOd1`^WH33ZJ~{|~UBgdP@KW%9@e$a@5pL7}%G_@(@&{x$
zyG-kRTweCPfrCWG9i6{-AHSIgZP&7do9yuN7R?k4Y+ENgV0E@rEZ(fJtLYkelW7*d
zV{<AB`ykkq(kPsC#){_Ft;?^NPeBLNMe3<5s_EUKoNW1MHe_N&*=Sf?)3_@VcwKTm
z10aaIEJ}C>sdBMRwms$Iy5|R<s<kj9h0q$B-^w2kr?}^0bV~Fb5hvK2iNtbw(q|ln
zsv_&qZ3n-bxF^%v){U=ou~-7IUu<n-s3Om4G2J_WMLP^I+F9zsA_JtmtE-3v2Ziy!
z6wzYKF#N_x)>0W<Ok}MWw|ErNoxYR+5|mb|6QAYj#a4nfBpy)dciNY%hlkFll~>d1
znzg8#43f3yPWp?Z)Uo$#_gUpR+%<d_*a^B^^}L|yRD)+wrTO}WYWLtt>#vVa8|N)A
z1vjz{jj0abKP^7m$TpDL8s=(>9?P_`!7XGPLX5_*kZ1Np(&$k{Uh%^YXpm^Y&YDdf
zLX5#ODb*9Vb99J3rCV9IF`Ro!j7BI+R9oC_zAhD0Jh-!gUB=Biy`GP;<2sPAk&C0Q
z@CXtk>p2q5!q6EiO)qGB4H&2u#{byRcnPj=Lxp0bUxy-}x{Z08!IlJgNQAlefBQ1*
z#{YtdXGGwmh1&2WM+6!B;=Y*?V=6Co3|P)z=LC9j{gW?q!#_ZQTMsV{&w~F!e<F)L
z6HZo?s-ct!l@~HMDdMCpJ8F6T*yp*e1Jp8-0n#hl2dL%`(PUY>6WZ6$D-j#A{qAW*
zzV)U(ry8&yVB_KvOyESH!Tf}SoP(c5;_e}6U1<3>Y&u+jm4=L*AB#4xF2V|8xgfVs
z%Y~GXw_Nmr4uXaXzJlU;q*27%m%({FtfLS3;*gmeln$42`?p@r+`vZG_S0PFWN25I
z8LD8&fZ?bMmyE*H4})8RSCP)LhRG|MwBmrw8?>9J2dL(E7ZK)5g-y_62)^fQ%M)y7
zi51;!*$5I29%z-1vTwtK14{bK&B(Bin>iS&S$PwvC?(gxXMh9AN-MxOzn!Z1tAY&Y
zIu&(e+2MbF%VHU86_30U=;!(;TKu=eS*|}+em8IuB86XO7E(cggy>+)=Q5EU_XZX`
z?A^VFxeCL>3k)73EwlpOA(RNULg?Gv0<_!Ri6735?8Up+AR&(EQ-s<mxMW0V5Y$r@
z3*??e!zXqgm#?t9+)h%5$bgA&@6`>$MTNhVKRtb;@2?eVDZR?nUc=4CQ~XuvCemna
zeZKTpZ%sV=7H2pXzY(2*slQyX4Nphl+JL7$e-azm(<@&Xo)FbmDiLD^TEE^R@=M<$
zF(Y<&6*-QZkV>r0X;O{Od7^6V*Ozu&^LPEX{Qr$CStk4Q?ev`KOO0RX3ulsfGv?!m
zob5yk9&ApJb((5Ryf8nkcjl!R#LXlRoejeE0(U_11nzvwGI_Qj4rZ*zCfXt;Z8}<D
zEf5l*&$o=2=8WdSgM;jSYepR+(|2lBQ#PN&`_#R>_&eEs9ySyZfn4Zm6bVVT^iNb+
zD5+HCM=7<f4VOxJslfVoi_{0jgEV(g`M8{@Y$H~?ik{1ilZl&ur)WYe!q@L58mC3f
z^pSbc(N7zEgFi53T?BK2S@I%fOrx7DR@S<QPe+SkaqBCTn`urER3n70GbE>o-eQkS
zil7HEelvz${+Zcx1G)azg991lB@fHX63jFl)U(@Q7#`0m%!T=zM(4;ZeC7X7XABH3
zB_!dy{IlRrLslDcW{?kiJ0k`AL?v)#pGY$yU&#i0s&tv*Jb5I@_9spii_<Q9DpV$<
zVD;H%EL4TCAdV5g9Y6?y6n~&{po(Dez>YHXjrb-WC*U9v6(^GaRX%S#izHy8ZX1h+
zlLe(H{~oWn`9Y{e2z?+~Ueth^lSL>j+Eavi_s&3$am&m&;wa^9b*cvudQqN_Ze#7K
z+!I3*rb?(a{1Mg#v41OLqGWIo*l<|vM0xa)`0u6opY<8O7=fbep;AplZV+`7h3aqw
ztB{HF)aSoC6aLPQ46j^oV$)5yhNT`iL5pJJVZzb-XR5OPo4TF3u)7*(hXW<fo|H~0
zT^}i01H+GG7WUk7Il|A)P>(}fBpO<d?=bv2v)1L|?^pX$;n-r;Y=YNNt7g^m55hR1
z<Pz^!OEB;I@iVify8tWmld7Z<zA4j1JPhj*hGdqq(#lkL;V2J=xolAed&wvih%2O?
zuoTnv`3rh}O0T2$J+lP=PG+E8=Gy}HxG{-9l#Ag4#00x4zQyz$Wd<iy5Q_%fUO_17
z?`BJYPaAoSsOTw*(LK351!*kcK}x4cJIDBUkb=AAjmo@Y*DEdk#Sz2@2v`))0KEaE
z83amPd%o3QSO0|Ue?riWBJ;!3_wJ)IFHWufAcatr;!fMz*4M%G7#RFaR7}hLpw1wP
zTUx)5Z;tK>c?r7}rBiCJM-H^_-t#uBmm}m^Z*E1O`$$R(2a6R0jz-v??>%ztP6anA
z$%{oed8*eS4$`d8m1pxx6x72}`aL%bxe&76Pqy<C6(e$pjiZIo$~616hDdS&j&~VO
zX-SYU+LA*T&^S}4P`S}d&~KrV;#PZ$=enKa{=o9w73*>i`_?@&5N`a2#f2^#y?XF3
z{QUEj@;{z0(g;@3{Yh7E);(Ch3hu7&{*}6c!3dtY{sWjltK73k{Dw;~?6|_P1M|I+
zi8{TPW5PoY?WrIU2K3N}NPq~kN|e}7LAynKJjP|AV$k(x(AZZf^t|b|@0j-%K>&=C
z2*FTg6gra^POv=(t7g9KJ6ZfP<NCz7)1@LTTJ?F$m}pCvAPqvO>MJ6IUW{BUyx34D
z$D79_u>G1nY&Z6onZf5J;!mo}`yruswTzM&(Xx74ZuVb=SAU+OJf_Ay(Do5qJ_FxN
zF~i<VAtJ(mZu0vNTH)`dEHpe)LyNm7_8V8h_fqiJQn24i;~}b}mnL+k580cep^Owd
zS4x)mn5KMqOuLQ{lYq}T$D#?KN0W<=u|$X5=d~Mjq-*A!UA*w*c{qVQXq9EVu$Lyq
zf)&tu+kisIe&SrL!>o=7tEUXN=9Uf}gKEaaS~Xn?LdctETdAcLN-gs^$-7+WSly*j
z`w<c$Xei6xasuX6IBeIzv^yt?3NMAT;+;&CiV`8t5~wd8?=?V9;DsX=NnnM8wjV1P
zed}$0Y52~4In+ttB;2w+s#^++0;1_H?m^7<E9XX3RBMbb?p_HQt=*$sx^t)kgGR<+
z6UFL7@OoeFRxda}eng^K&wXmuGM@tZ9!|nECGP`lQ6dz^cxjyOHt{U&7RS?^9LG?`
zB#9P`SuQQ}x9HGp{;ySewCHw$9&G25p;_LcKcv2tF~m;3682%>qUWDI{!pUgOU-&e
zLe}ls&I@pLhz4GvM3d7DHJ~4hJciIJU4BG!#Go1IzF&A|ezcuBMAaeQ`gy;SLHWtA
z(51?57v_1gnyfHr|Aff6Nuo@DzK#*Di;8}=lh{_$Pbqu+lf@Utv~AIXl{uaKHkkTm
z$-J7gkH)CK6+2-bY}Oc#ovn4ugpZZTv2gtWCJ!D~qd_+V=C6v{DdLlbN(l75(?xEz
zZ=lLODDvICT)v%kQ9|37-+?<GBUt$ncSpJ3+V(#Ey#?~5f%m@3^jm$3y`q8EPybY;
z{%L_#xWzm3uvKHmAeYPJEF+LBcU~d7abQe$wY2ON;kbwC)M8V#EEfB6<SRv_E-b7U
zM-z`x>8h+#H<I3cgqWkC7@cho5#lYL4FrrlU~vs7oT{F7cvZ)OdYIGre~C1G*CJSW
zM#<nB5PtCL^b2Xf_|vbeT2uSPa$XnU|CeG7xPMURXMv7lF9u|;B2*zw^qCEA@Ngmk
zAL`QvY<lkCaDT#!fqnfJyM^sJR{AqSpD|>x(kznL9HlcjdiF~#Xu<ne5%1F^Bq+sp
zG_53e?<J%qn3f6FHd_+*W@?tHt?B4QDxqAdt{GK)Vm@lIR99p6SjWn(X>d-U;vMo$
z5{t<tQ=i`=XGzb}o-afPp_ut;u(^r<7u6Y2|D*1)RF$dj<J`*d9g*sCvS0Oq%p%0K
zw=%v*e55aiH$Msq;@HP6zd|_f>=I3}Sm@vP&7%tqUKwQ(v4KcXeqfO1d?~@chHK?w
zHEbg(LH<xhm7@NLxjTTzExcM9XO7a)9lN4N3j*q>z7GdKtM6sNx}D)H(f?`dE1;rk
zyS9fOdMIh>5a~`CVCW7h5kVRxB?Re4>28K@5F`X71f-<9k#0c=Y5xQGJn#2@-@g`X
zX3orEE#^AczV@~Ez3)R8-*v1_3gI$8J8?aSvOHPf*$2^^KcMVCAPDG_`~m1D{wxv7
z-+i2|OZv?TVI8r1^1__~Asm%=50@Ev%zIudJH?{oNqnRxb)v)9$e0=h>J1d->WnG_
z3J;J|rQfF&zl8q}-@c6_DSrKtNBur!*W@CALk*jQxH0`bqJ<tIU_$?ZGDQ{;ieG#`
za7I)nyM8wG07m~|o6$qutq=UBboAL9?`t*1PLT!*-Cg!A0uU$n(vXZAQdiTB`%XY^
z)3AuE_d$HW*9gQ!fvQMcl6oUS*h4&@hceE>bY_O%Rf3Cn>`Yu{i%UZFjc{6V5y0Sr
zT9ii*Ne=?MYi)q1pg_;FUfqzP@PvO~g#Po6<zwBAp4Vh^=WEW;XlRq?qDKy!DA|J#
z)~)fhKlp6VGCguB+k9;x-FP~Z$fRp?9-KqUkogZD-|TG0pGHdlA3lQ}-MzES6ZCDU
zf?RpzC6gPjk(wt=p&S#R2O$OQKF|Xf8qW6SXMIQ-tzQ<mkW=|C>N8m@aB`;-(5ZF1
zSH0sU`Z3bXIENj?ml47-$Wdr$z9(1E^-*)s+h|S*(?87a{s{^IL9o->Y2LhCPdC?0
zH0d}P4TV7@T`2mPi6Kxvs>*k?>HPWW7MBJ&624VM*C8{6_-*6k9vGTnljn7ITZQGo
zwxbmfyN_A&#!6B}3sIKe=B;f@Y=5v@U4<;%DekSt+GXPAEr?RdFRl6@`hEJQe8?++
zK51oSA0AH<CV-_MLLyLY^G4w2b>LEPONby88<jTXBel_Wcm6M`uZKvZ_G9Tr1zt-e
zk6Hz~=9dMo?89+@^#fa@$)xJh@Ec-$UN3?{*HED@>|utlYXj`3UnD_wrFy-;%Z*CH
zH&ExUUp@>4ku0{yZH+Ra#~K|Ke5}x&3w*$7HAcUk=@71n5|uGv=#=lvzBXF-?paYa
za*9A}RkhKO^Y3xX?d<p8Kqz*n4c##6F0K6&naE)D5F($Gi)HMTtb+@gYlw>6t2vQh
zO4M9fXmm_7{|ZMya?yF0!rKdvKcIRv_1(S})YW&W+PF``DBu9UmFqMhE<BT+k!trk
z9WZ?H>o3!z{n;(bqjs>Gp}cdZnC#9T-`yo}i98hTahFQa--Ni)y$7ZV(YFLEt@ib#
za#4xx+ZP!A9^UctUpn5tP_}ll{Tb7xMvUhr(AG_=9w57xRG&tTNb6$1s?JyRNbYdR
zlQDLLq1-FwAdqBybSmXLd`yDA&i9Npba40W_oKk6{DGF~qaY+pYbsnnrHjmvj_=Cn
zE&Q9{@E>(&ZJXei&j@Q)B}W<wgUd#PRZ@0*4fwNX;Vpa|GfEH=p|4m?&xZqo-T4<I
zE}7JV*8?V>y*A7#bAluXPYp^<+B8VMo*GoiRUQU$Ri*&D{4e5(#XQ$`u<NA~@dTyX
zZH?0*T?^({B`a+yJCCNAUso*${1RD^G<mUq;o=rZ%(=;Xq_eSipTB_ZDOtHd0{ah?
zj2j8!O-wr?z)s>EBu>N@h;KirGSGx(P!N6%BSq6&C&WS!4sOaCO(Q|17|ZM|9xis6
z%Hv-L3xQtJAuI9q33Z@A9W8Eh{d`%K-p6<c<|v}Z4!F<yRD`n$V_;|#Y7p1HD6o~4
zN)}DDGo<;#oE~hYDnYF8L3uo$^SW{F`<9F9c?+k`uuhxT;|(m^G1vnq!2mk0ZBQr#
z6$2zyAFwSPBaA9G&xVzSO~C~BHNHTJ(?s7PQXRX+7Jb&0v<pp8@5<+a4^`*E&lVh^
zcGrwxN58@UMRy4kQ0GkT<df{D*%?>Y1(FbyTKz%QW*Zbly}gaJrr*OMIYzIwuy(C|
zN0?!Wn8}0{QSuu(c#M2qjWOAjHsHWyX&<+2_db$0wzjQ9auUP+Hkp>!<IxRs`H$&j
zH6AwXjx1FWnG+rTkmxfzK%KZ=!VPrfZc~1tGv<*?yg;u^F7u-&R)0M}JZ#>^1wG8f
z+KG;!oqmIepQ#<NSCy9*FE9pMh`w~g(OAyNBbiBcMK9=`LO9ge-h6)4OTh34MD6zI
z@R|H6DoX)%Xw|W*GqH)f<E9pmu?|Bkrdj^~VmrbXbB9>-Q^;%8Myk=2$ezhU?IltQ
zGXa&kRl4wE{YqPJVU~=F<MS(;PuMa$3%t%embrX|c=S_0QTcdlH{LMYq3G9P*Rh6J
zlXg%l`MeI2tNSq982ZK(jw&2hV1SF>y6R~JXwlCW4vJ-g#_s*|cFT49I?=z%6I!*P
zPFx0@z%ADU^#GV|@W>wtO)xvjrjb0E7-#OL^+d@56j#tRq!viQ(_6Eoyt8SFZggnd
zJiWt02?iUiKCgWsQT6?NJVUkyL{phTuHI6_FG{i7lKqrdC|uB|+V`vO6R}8$S<oQW
zk@jw&5bN*mpG#@gfnBY0$2$jLcZpQLn^pl+OcZ70DWoAS$WNWTy2I-Wcv7gFlVH{4
z^I=Aiky&eIcn*%0W?}AyCfD3e7-L?>2xuIs5kl%qbQp+ggyKnyC&TZM{_!D|cf49M
zC@m%>At-dapN<}(G<cGhTWts-)WTW{2m)J2ZGw5;db9KkMU0n}FZaA?&9lGEDHUvg
zzqqv}q0c*_QmHw`1B!n!2NLHXzeNKhV^0c^nU=<r*PR+!D{#{CeVR|h4Of3q!}sjW
zbF^q6CbabUI1E{Gq)=9c`K{oWHZAFA_C>u~FOO;J*_3~z9dD8_hac>neSvMd)PEV?
z$+{6ZWCjtOEg@;jr_v#i<=3~JBxume<M9bvxAteDLHU<Zx6=}81NK}}Du_Ii$?Xo7
zq<E!3U%Dnezn)rFLt?2?Cl>7%@Z=b3k7A-P$lAGBABa6}#{Bl2tbI(s-j<ZYBit=_
zdji8)J6Fs{@hI>q0_8*JNsk|8$U<FBrY`Ny(83O0^Vj8?-@95Tzcjl*EzwNWFG<--
zL=sW+7fxmrjInI$1{MfUio;Sqt11r<njI$+b_&yPQ21cnM!?m~RQt!upgYr!SylAu
zsN{nOm7$uUHE*k#gX0!LpKE~QS0oqq;QqP9UjzPu#}qm>r)32u)qpbrpZ|=l!p$OO
z#-Wgzh7vmnw<C0f&Vgx7F@hc4rad){5u;>_1=VoWg@{ZA5Q-L_6+{N1r1sAZ(8`Ym
zPD67?c2tNob>9)_5Sis*sp81<pGPC$3D^HDN-MPeSx*X7>2*s;6lQpUbMd5<C518a
z)t$|S7e-Sqta{2U3~%t&AN6bnKJO}TB^c5&`2@j!NwUJS1q~2QvzH;=&LL04)w3P&
zcvsb<k1hKI*mhAn`D1G66&z&pf=9h*;)MC0+W+DG=JOLUk+lqyf=@0ptnvGanBfOC
zP;iU0t;_}7U-4G{c^4F3ZhobUN90$t$mig#MoAJDa}b4xylZBt4>_1X{w&oL^EI;i
zhwm|=apq#lzxBuK;<ZBIOx0@uX^R)&SZnzO&`Vtr(pR)$F`632o}L7}XJ@@I=oY0H
z6Jyz?c12Grobt=@KZW3<`G+@kD!x9X&@qs5x)0)GU!;gb6m%&xOGy7sBpwu>Z@AV;
z6b{)7eu>K1`9{*nPMG3-1Wpl3vSF37v*`#*<(pl{h*$6jTy-C$xn0_Wt-nf9SgO2h
zOPt%m4*QqffQuJUMH>YZ9DUete<kRq`~pcctc=C4`WQ`v*I4E$4X#Nx!9%qTgs{4e
z{gapik!Mp@MarS3;;C{C8T`thZN%go#NL#UBVm`>qzw*K7uisXJUoMaG_Z-uCa0jo
z|6(%QH2k@CL_lcI%9f)*-ON?A>TPQMlvq&uWaBDKLyqv$L*PW)VV^MI+M>|8GYLNT
zoG$(bzjGEx@QoCrEjEg)af*^C68=bf)PSZ@XHu<*EOQJamSOivj0<eCn@OgTc0-g3
z;S&)2Cx1X`!e`npKmUMSueR#0wz7&2w#C(#M*mX@LIts@dg2Kh5Sf?rL2%@oV^dHY
zg4%vXO{65DVDK2ZyCfsD$b#4_<SPb+lvTv%YyxU6p7$*sD{0^W@4RNw84w;pG4?79
z9D(z*E^uUcHrd=ue>S#8B5b*rafurtCMDm4?*YxxD#J^vC)`ir<tAw~{WkWSF(Zf)
zi2FzGI|YI`2w%+EEK9Q+{2caMcmII2x<Tl|HlI(x>~gp-7&o|j_#~4jGo0!4#!MfH
zD~UuKO$raUs5DmxBD23qsmmD+F!?grv;z@(c=%}wM#2|a!x2~cDjNYa-KH+5=bqiz
z-@vagSULhlSoJzJY`;DK&#`U{>2B??K`;@!J{4rT5ouUG_^n3?Pg|?oe^<ee=5QMs
zx8A;09zOm32PB6IryOB`t`;VQb=~x_lBmu3m=P=0q$T`fxP{j{w>7^$<frZO6*N=g
z1Jh3gqMUGnanlkvES--D<W;9!>IGR}4Zha4#6Z&22KYo0`<Q#^^)4d#OuwgwTDBf8
z3DX#BFLuXUAp1rCB-;*n%h&-*#9Ae%{R9$R0;$EHxgubbXW*3JO?MksY&X7nlGqLO
zK>jI0QD-x{F0kTl0+eMA%o`*`GrFU>?MgmqtfFB%1#$6g3MF~xXm#(WDhKW=WOId?
zY}%x_gQ*FuUptX5?d4AE4cJuh%FwfRUxjckxX4s*;u=JNcXeeL{7H^0jyZ&61Ef-~
zc&oXLa;Yk1U>f#hLr0!;{>nB5ui?r_m?ss59<XHv<2R9&`u#^{j7)jtCr{Mi1E|x4
zk(zIV=f1nfPg7+V34<)RTUUK(fn;ra$R_|!Z$CZfSOTXdr<C<AeY>c?+DYGWe>7Ma
z_Xm{GD$Mp-{JlNy%3Q};-Qf*z5Q<(;jW&w`%(?DuF~NIB5D)?gv?KF_Cned)$aDZ2
z0tIl%w0X@6eLR|Z0gJwE<QD6`5_t<B?u;ZBxncgm6H^dOB~Ks%g4Kq<;DZ4&0u{MV
z>C4jm<+w;RZ6ulIKf?YP0x0}@*oW++@OaSA3ZTOE_*d%?RWHwg%<iiw(kz<z<66xi
z`eBQ5ze%)p5LabpQfi%Kg?`pp>8rU22pF}hpj&yPJQ|>_W5w)y>ghwz9hKZ!5M*jF
zqG(A=6n@?dG)W+k2JeG{TqZ5@hqxK?<8P%P*e_x;2skrRZ71#jZ%>8dLx^}zRVTb5
zBJ<*8CZ9wR%wc;dccFHl6~e<^Z(0>*W=P>JnLvpw-H$cVd8%T6f=A>lf-|M!A{xK1
zDt?JnOn<U`w^l!4fWSn)9Y_XG`@kGLmYrRJSCdi9gx8mg+LrZ|*;PGR^UbeN(yt}R
zWA=|?DR|%EJZ}%z#l(%mD?vgv*`cKZJE9SW3iAqSeWSA0vScg4vlLM;)x^tq%bXF#
z&$+g8F3t1q`+6$Da*rqp>W|409?F>Hz3^_+`#x1#)p}0#h577O+8d#-0wEHplr*J2
zGTZRBukR5?mW~xXZ8TN!^qY^Xh3J#*KZ{7nqzL>Hah)#B&i-o9oykJ%FxD$bEA72s
zGeH@d+x@KmRZicY`^(>a_7!j0ZBQ>QWeslCck{JQdV!iigw(n1VdR>5qlF+<G2Hkq
z*1q1jlDgpG=h}_s*{knN^L+1zDOCidfUb=F^xj@+?bp@U1uC`eVrBgE+YQx>cg|<N
z@DC{B3S;{FCMk>dq1R*jJ@;bg4P3HO!-QLK(H$9cHlISLy?wSgh=gZ9X`^W#wBHUD
z{ml6woaGJ4^p7Lln^-{Rm1?TzC)10@f0Qrn>hG&hX4f`ld~r9;y#Q}SLP_(uahC{r
zkZ7K55%rEd1R>o!RhAhKQQG54aDy{s1n0;6w3Rv35i!<z&yM{vdnACoe%mfOP|44Z
zKC=Lf3>wghIAocYDKhN-+bF&5oyOY)?E#PYKXHD@J`n!ah!oq7P?y0}t6Q?->+`6T
zh|S{a=i-)hFLvu}dN@s0gv&wx%V!8WY?X1ZJM16@e1*@!lg={`Fs-@0XM{{`339S%
zA1_&?S16|qrR57I!x>3LV!<g}>1czKqqrje1sq-2GA?>E*~}65RW^bj2X^V69l;7n
zZO-ciEIn^fKOp*VH-@F2RxaK0StG<@HlxIOVCH{WpR(HyrE3SUni-2?c9j!`a?HN3
zuTm?EXfUxGw?&&r=K91Ruo{0rUr^?e6i#GBLdcrRK`HRXm>g_1<!M3)Lg1F@b3|&n
zPh{Da(`b`bX@q#(JQDcFL4buOThZgcCct+DufJCb4qCzw9~^tbkhlDVh<fJ~wLjes
zhu5Q<a`-(AJ;uF^5-q+B-D<H4j!C#RY!kv9gP7f+p+Yl8Ey$y*x=f^`9c)gO7gT`N
zzpp=vy#S138rK)uJzyfgd`u8=9gpG5P5z63+)Jy6OOR;FqmOaFKtB}A<i)p9)0mQU
z-<8Xy;&Ds={+^?on8u>jLL8v4SLECIA@db*XHu|}es`X0tlC4!=0PR_`$rNHa5D`-
z+~IM-o4)U4lb*}OO-h>xPY_vOv_wjumpE(|U)N~UKSgOL6im5EvxOOPDy7-i`H4#q
zO%BB#iado}mVcD3tA~C2QJ3c6-cC+AK)$MszLS;_E6_GRd!qaYM1D>v9l2}oSNut)
ze2MyM2IBO~z5LBTD|qFl2|vdxBSUT$#`>BH<B8v8*cv=W%Cv?`yeXcXXuq3|q>Nq;
zDpW9p?9tJAND>Tdyv#^#f(M7Xxo&hQawCNj#ub`4x-H;@lPt6<ItL2A6ANq_6_Pa4
z+m&g8`x23jCUAc-q^nz5M&IIg23(6K%I6QWq{x2Qh~=}GaMU)t!6dn9U_NSjHPxR0
z8w~;ItNo9P*0N?~hxt^(X@YDqArjIiJpa4Qeni1!p;%vSS#pwibwJa!f67-}_H8zo
zBhUATcBQlk-sKw(*+wB;A-Jb%^Kl&O&5@Ka)v+dKJ1Lv;h04qs7$P_&ZHZ33+}h8`
z{ha9#F2o~WvAHM%neJ-*JzB-)n~MK+!}6IwL9$1Rt;!9mdLziPuHkKt4lC0BZ)amx
z>gM_{blXzNlS@N%Iow=x7uSz1OwBVQ9b>w5mi+Ki_#66S7`s|6{eW$N5>15eJ{NdK
z8`*wSU}_$mGOBhaLGU<cBNrByToGBd(0gXg%?IUb)l%lyXgRcPr~-M`fiESQ$(4;Q
z#I^Z4+ifox=~oE)zaJC1@!&Taja%-&LepxqeyRI3RY=BKP&l3O6#{QqNSQF=mvqQc
zURHI+N8H&JO(!W}@XRh70dZ|xdj`RX#eT2|0e<OaJ4_Z(ihYF-I7%QPGg~6?IxIeT
zKv&2aY>L+LiY9~^gx~fh@k<$BpZi)b>p^86kGjwi8KVpm#Vg!x)i6_}S3U~(0r<}n
z#f$88nQe<6%BwxV6TItb<H@t~i8t`3e(}hu!X`LSFFc`8w7&|;rNzuFJRQ+Z%Iqtq
z1#$IzZ#lxGk;ubhSyIW{=48y3Fooih-8yAL$B;i<T_TG?e1+Z$n+|6dXZt7*255$r
zu=-Od5d@cB^_63tE|G1P@JO_#Q{t2&od5I(S`_`RijD3%&c7<Q*Po9KUE#|t<B;VU
zj##Qjqdgf~G1srNm-H!G4ns4~`_9<*_Ss3di^I<W39y6QdmL->B29l6yothgWN0+S
zHg4e#NpKI_dX*V-fCqZBN#It~H*o`M;Vh(p3pG}6Ruv9Y0nox`s#QYCh<39cwx8vP
zjmo}H9=P6++riWbBERv=!`p#nPs_Xg7=VX-_Qr?kt_{z@NA{xnli)FET~h7=*V$6O
zoCGn?WcLZmMy}#1)LQ3EWI-E-c>Sz@8RO;VG0tx&{Yd4+=bxsWvXy&tYF5JVhTTmj
zHQPoID&G-sgU=Tlf1NW$O5W7#13EApCe^o2ZB}O)`oz-XWrdedEpwY(G7uzjNY`fV
z3r=1GcRcy0mXyJ7$DH%Te-bYgVSDvUm|Bkdd5gW6`h!etOkKVgeKcI<^<Dqgs<~Pm
zCh4Zdz<A)h;=u}4XM~J^otek0#VRuqH(A3UfO07a#_1M2IHom>MNzk3yR8KsUhnwO
z&pf;y{3cS17x`Vs8H_&z8`~iwZ(m+8Qgh!S)rX;yCB<Z4Ap)fq$_KR(S?O(aL-<Nr
zeHeztP*X;U+@*!iheOf1?<|LsgWy`(Acfy%N$$wiPTvHgk}e5+**1>dY(QHEGVyRy
z8<jF&{0s+n_Dm!%0y8zSpbmSrc}6lEf*46jAd$co!}y4Wvk`m?>$hQuSZHP*B8bnU
zU|7W&=z%<}XBML|ec+D)u9^9tpf44bMUcM1aphXIk5qbCjd{Yh-N~MW8n@v*zAQay
z_l@&#MR~#yja_xkTmVgEGPyw@e<Xw7)#V!AmjY%;mPp#w2<+@Y9&Lh+HzI$eANPLY
zMLA4{Fg@<wrD&bY>Hn;u$s(QB-z96tqZ6N3pDaCQ4QDIP9JZm?*vQsxy`J`Ia+hLX
zWe`G|%<Gtalc{|hlqJ5V0&;6*ULpBEhbtrVJzXBJX8%uJP7qV63p1leQWvv>E~Ap=
zVeD6@gE+*;rm11*L|YeR>%&qok*3$i`6<96w)|Mtr=}nNWHbwNY1phi=!By=O%hNx
zYyl&i57*%TZAz4VFJ!BEp8j{R*ci{gsQx=dfBOl>HaRfTY9RVrP4?Ot{v7}wF?90=
zDQ{u-Y^NDzO{MXl9whTCMd|K>b%d-J-+%ndV<gcjb^p6+O4Do6A|83Q5S{!f<q%gu
zRhR_v8u}}E-Pc0!Qz;H)ugU^XzMjolfR$!w>p#aXtn8NDyiS2Hn!FTe%G9R2nwRMG
zK8<G!0b!zEu!Zll)O|4V&w47ed3%MT_k(W={~D!&UbHOP`{2_-d+1A10Q}*Pn|}x)
zU4#!TPF*^KjcWKK2PjRmYsqU2uR#k0c~q7Shr&6?RUgwf4SSINDKN+F;q7>I+PO)=
z^)<A^uDRL;bi$`vn3NmLYt5CJz0nk;WlV?filwT<+ta$^dvLHO3C^US#`f`G*ew%E
ztFWAOeSL!LuRGQf0aa^5#h<l4plZ|uVW2mmO?^=vN6($f0>i*aZsb!r2p?=qYgE)&
zpl$ZkDn?$4k3%A@!4i$Xo<!|H8v0s3!>RjoHGRyC99yfCEd{~8T`1W8-11IJF~SPK
zHKAq(oxNp|I3i9XqM_5Id<9zPs-MvQx}UWTRTG>(XSNJPvae;9>X6C;?*Z+nZaW_>
zU~N)JY!#Sjz-^(E1<D$nuff1FO%~X~XyR;41J<JnL2VXy!YPjjF~pMC;$Gx|%=v#Q
zn9EbcBeISQ^JY0nS~WENp+uZBHR8^k=tli!1xairVaBpzq1rBozA$v3rXmQ3G0@`J
ztIeG1%9sEKY@Y)IwzD@PMfzP==Q+_2%ITmQ@d7dpsTe-7!N|;~_y=<AQ<-Y?<NRcC
zeism0<aftj*iKtGNLpX)S^0w{sHLE#uKrsn*#&#pu2k9ocneOw`pV6CUOz7F0d_S`
zPD-f90<cT&na=$-x_L2G>ro;7aw6;0+JsU5fA)C_(gXXAu*V;Vz<)18j3f6J%q$V!
zCfYAuskw^3%Wb&+14_y#_au4*ps6pK-HXUB2)6@56LS^*)b$C`^PxbTsExBt^bxB4
zV#TLVF5X(ZXp(1rzoz^VBHYW=BJhg4oa}V8COcIDg61URx40u|9OO|SkDBij@Xs0~
zVP1rii{-CudQ6flqlKqlJ`#F&O-_p!RA+1wSkw-@90CdVir~zQ65v-XV^~mc=L^G$
zI#-+b&PJ9)Wtq8~cqwTuOmI_WmWU><+ma$78n%R>aSDQgVHHWtPpAnyzPJ)n#@RCF
z&cA$l+4ea{@Ej;Uh60N{T|hVh)S*QpA>;@9adH@i^HQLAsMmjyk?@Dz#3W~UvfwO2
zB$#ktjE2V0PtAf>P_To;Rt^J|a3Ut=qQ1Ir9zVX3CX)4e<l2465t)4ljwDH2bG3{?
zZ}TtcL;onnhIm?|=ZgKM!e=o3g7RldwCtwi3-|`T#SIg;_hVs#+}=PC{oifdw;Q*)
z@M!KgZr={b+-=;x8;}8R{VopaAANg4!W1p_oe|z{QFCaIZ>&(!hI46a+GAj_L;>ZG
zENQb8BOrGQ9C?WNt=TonusA$z>T}Gq(M4TJItClj@X8G{yzi_{Q&ui{zr<S$%<#YD
zHK&&aj@+L?4=hieI#m-$e>5g9elhwB_5lt1mnn#=YOIImkU%262KV5EVDj6{ygvzo
zFR=yAtbEE-*~_`&J+fBFaQkt8N$&OjFlz`EP8#z*`SFLXGvFr&8|{OxvnQ0DF7);A
zm@_8b(3gVUi)7qpVZ!{t^eMLT5?6il1C<K8-Yu&}N@%<#mcX&2RJyMRlG#x~J+&vY
z)kegq`i{F&)|g`)S*g761>+@YwDLg#QvvMbEZ6!1YT&P|dDE_<MA>PfmM&Ax%Vpn*
zHMRQ_s-JurIOU;5MN*A?>GAg?b=8AlB%K&pYy_;&7SHr_sgILqBHAm;ARbDux|Vgc
z8JvGcHK|P}{!($uJ_!wK6O7!AC}%)vR=`?^`}h<&MYBQKTAq%cq~!fR=7gP8pSm%b
z@)CPau3Pa71^xk*n;7W)KJJ>&=G8u~PlSZ_8q{R1nVHhy#Wrh_3RJq&wzd}VucPM#
zL(J`a!;fG`E`oFMj1~H-zqqS`vk3;qSMAhNIZ_V{`^XXUhK`Q8De^GYFzpkZn~l;v
zMnNRgJ8Rl;mD=hB8PUVfKU$AM6V{PWy%#W?x|FOEC)ITWXy``9Oz*D6_=6fsW;RP<
z0DnoY&>Y{6164lCT<>VsC~?%ZLbL3a<E@WbL(Rf>SHMraP0?a|Vz?@3@y&cm2ke?H
z)A6Zsj(6gaVDY0LK8XuV>6-WtXXo;c-ZhYcFU(`o<P9Q_y?EpX^2+IVx6<~^pDsk~
zU!~M^!-c>)Ln72KE3|UEr{x#$hb+63oC)4;hi%_qHysxB)jj$jVWwUIz;9`T#TfZb
z97=N*7HhjEW9ipeja|>X)*dLQH9OYkg#ot~!x^R?Cczgn^e+%ca2+U>M|Bz&Z=JB@
zM&y_oJ>fdTth3cuFgYZCHCvPLiPZPi(4`YYnv$6h&!bK|caME`NAgU=CPn`r>bvrX
zMNq3FQc2{kcV2Vzd{c;BkgSt38~6l;CDl>BB$8@!AA|{}DiE^v6&}=9&QtYu&~l52
zFDsZ<D_`vuMc{Q8`V2P85?{kp3QsP4Q^LSfw^j75BaBW`bWh<|WfIXz9R<B97@NQA
z)%1s*bE>LC))HxYl#Y29Bz{sphO99iS~Vj70U@wu6>8tVZ_rg9G;e+n{kR+qY5qE4
zi$4YPI`%zj=2-8i-U!Q_E{mF9cHAcVv{_47sFkz<lJ2TMxJ|U~@Qh(S4R?1lM6@`+
zpnuv{707U9^YGXGd4JJ`VWDPGbRPF4zLgPe%DMl@-`<N$jGJv?*TB~5F@EEl?uF76
z#)T<L`Z9&>RVvqJkb2P}d%Qm4!Hbsg=>C_)JtVH|%K<``R7*R_S15D*<qUs8pD>l3
zH>!~FC-yj1X^p!%`70{A{8<r>DLQOS=cIaIm}!O&)Ai1-{F;xCQr`z#ak5qJ_vY;a
z8m;+jpOL$N1F8YV9jb1}Bc&eCe0>?1tZq<4DcG<w__;M=tpBn6(lCVxO=?9LBji+_
z<#dxv>{6S$M{#+~%(z<a*m*|U#Ed8+UYj4lQ}z3pv$Kgx0CrYkYDq#}L>fmYBIT^d
z4Xr3zRfVv;2#tb(#YiemZz%EQ<Ke@gaep8Pa&$3K&uJwDb$b|pj}eSf4`*s#h9^%D
z-kcfnxf40@;vEmr@yDV!9|I5;{_a31?J1pbOuN`jMXxwzJPqJR2;bdo1Fq6NqzsuO
zQS4jy=l#Vx*fN~LlANUxlW}12)9mQIx@gBz;T_Ji>~vOSa{ac!iF)6Yu%_UYq-)#J
zz9L_mwYVTc18*{)$om`NnpD2GNB38NVO#L}BxTMo8MPmn40$}k73c9g_OZvaZvfJv
zhYz0b)-;Z~Q!R~gS88=B?=C8wD48xcul?6SnCbQTIhQ3uAa_=HQ!ImF`p_HsAUxKP
z4~{NnJEJl!p^cNyTqgGYuw;!QepE@BdHxwB<D~OdC%U$`7|VGRc!AGs;vbx_JSJyW
z#!-o9q>0Nz?>p`X?O*C5g&u7U;Apg~KIC6O^zls`8iQkC0lIQ*9{h68;?ggUYy>|_
z!Q!)NS8*7wt?j7$R~{O8>yM<I`3zO~E#y`r7idY&ogsB~+oCJsPAY4ibA>p5FWoAa
zpJ3G@A=O>Zu@wIh>zHKivE;bS-!gBuoL|iDc^!=lebwSTx%P|M6BcjT{pO*?Zz5m8
zs3+l*AYk`CkCFn{;*nbwb-;qxZ(Q>4weW2T8;Mc>$$&ibQb84sUF=V9o|AD6e%O27
z@!!x(e4y}+`t${K@P28KPAIDFR&aIbBru!b(u$%a0pe1VDGN}z^!_ri&A;*Hn<_D3
zJUL+SDB!j?{AI8#I6CK3_EB@;I5O^mKk-9Sr6@EYZ*eZq5Z+u+3p<m=4f;65VF1Am
zLsJQEj7<W-cd_D0%X}Ohrycu@;LwnHD+*x`I8uLJyf5uqSYs0Yl2&FQ!BByZE_|=y
z11bDzl+P#aCi;O-wv8x?VyjE<*0JjWzDvg->G|PyaZjwN->HPsJz_<3`fEVCtkGdZ
zQ=aQ7s!G`xO$$$+e0OMweKW?LYikn+q}dS!E|m30igIv#H<8PE^I2Lc+4bSiUmn;i
zdHN{I%XuSSXUU{8m1k8qI~xaBRs9Ela$d}%8*0@<{Fw`9QaL-{lzLq9g~Z^?u_7cy
z?lV9U-*xppCTHR+Gt|!b<&Ou==Y+-Sh&MO7N=e)*`(N<yna)(6^s(XZJFUebksUDe
z(0QejXZu7u$-T{Qd+*In!o89CZ>NJwAXXUgCJy5%{+A&~52dXz$A0O6-#ZM^r#S4j
z8K`+jS@ZPmp@1e*h|ucolQ`@}8lv(Kb!k;4__N7pBpWjC92-q0H<Pmn*Tha|`Tvwv
ze<QBt8gZeH8ZgZqfW{<8#QHnRn|fMELq~?xyd>W?*ZkX0lsNN)TSb+}3%8}>9+dB*
zaP@F;8g^dz{O(>D?#cR%W-sw3lDY1}tzMb8KiK~dsL?P)2y~44ZBy9}$}wAihQ;Hm
zW~~BjXjGI(R>KNxX44A!&M|XrRRH*my$jwEu~$HrcnKj<Ku&Wwy$uB5vz$SnC&$}i
zvd33V&!)>K(;R-bh{#-X(CWmnFpd>#VUTp{e|sM!<4J>`ke<uLMv=8=XKC<W=;9fF
zIlbP{=uE8@^)wC?kn;$^1Cb}Dc28}MezvV)G8YHU?(r%y_N*U_|9}m^py6V$zrN<)
zM>=59#9x`s$K3l(b>Feoa0=6RK3)(?;YZiUQ0J{gscFGmO4Gf7J+~2lEYO?!Nq0;q
z7q#Z=){Ody-LAs2i85jcW~y)wD#%E<;sNi(@12%w7&}6z+bx)L=^<W^RW>|;5mWgY
z4E3fb;lt~!^gmZ^Cpz8Fco$H=^eD{*&y^vq?j@86t@^-yUB3QUMM{z(;ZLJTS6tD5
zgxmJw<JOqOM`)|~3R_FY{+O~J!nxIf;_$0sj-j)Z=;7OsZ)4*Y#6IuLp<HEr+o{D2
zEJ*}s-zdo+l<yX-0223#x#hc&F)Km)k8^A6M}0q768(se9BGw{HHdpxE6XGJdaGAG
z3!^j}I~rY1JDE8U)Q@T#4^ZR|)O$kzCHaFTh131KT;1m+OW}=%EIwJ;1$kKNJn`dh
zpqr^u<}vNKo|~JL_`filydT=K7}>zXe4n-&iaIiEttxcguEZQ>QDfXu{a3po7H7EY
zNy_U)sD<f0R{~+2ISojRZ&S6+%jxTwzJFGqpkN#|F3brf<_TkvwvlYPh9Z%)MQ23s
z9;k#oGG>Y*xBKfr>abrVZ_zp3`N534u;oQa&GI5GzDE&u^6^wB$72S_pPSSVeP=wk
z%X?F>Q7)fE+!Fa#6U?O~ya5DF?Xj;Z)Xl_IEk+97Ke~APe@=itd78Jh-V?rIrRjkO
zE$4cQ0fy>sA%J}yGi0w;Cr+S-950K80ueO`!tKpuJgGr&kZXcMA-fs|>$0?$Fy@bi
zirBw!Lc>8MX7#r8<f#4+MXSvvYcg(Xct`A13P%7A{`K7VS{;C%IrinVd=N{RP9e`C
zzA;Sma?5vnoJ8p~6MIGJk(Q!ZE)HcvUW6B(OWD?)H~`Gk*TE#SBos6lnZWxl7UVE$
zjj4|l4Kt#7h2%MB22=&_x_St%kn6lNMA)!@7eZ+k3M*GA@&hwPZ5y!zqEqUz>tRA%
zh<`w49)F$Re{=0N{Q)3_x#ed4{QJ6EAQ;ex>a0S5n6Rdie@UuG-r*xlWJxD@`=kKk
z3`HX>W!Dj4W(<(vS}I5X+$st1@x@Qd2(&Z$B>I&A)}t*Cd@YN1JZRw^FT><i@S>aX
zZTEp&E_}?&2Qrynnyil$GWRMc>QL%@kl+UBm6(ka0IS=8ovIA!;LvmOe+)HB7*z}R
z54n5Ae7fEL8}Mm&3C!hRsl6=*Xykee!i+XrEEo8!7^=ikRw9d*`Qxy~i2feIfy}G2
z(aX`Q_27gVS)}IV>Tlu_&D>q>nkx-GI<g(B9$xZrLG|U)Jjmq(oomPWB+-OI*`x7*
zaMxemqd^a^Vi^`XlQdyf=vgGc5QGyx>%$Ym7&f>k8lRDjR>z1<L9xQovQ8F8d^`;+
z7iEIBL51B@Jtse!FcNu_i4$xvrX{ks>!><^hC*bQA8l3fz7Hmln+j|34Zfo4Z4MvP
zhkxZ+(IEyGa4Xq6f+vMCh%E1Al2*C7_2j|pW1#4e2Z{l}4bzh&^nfqJ3989%E0KTR
z)Ht%JINSPw7V=T0$CCZLya#z<@JF4{eb!fK7Ro$~!=R%`r0?8SD%!f^7Y|Dj@J|$7
zM0_dFHi+S=x}Ja-j%)L)>jEa%6uF%QA_Plw`CX`kx4AKQSG?^Y{3>Vs17cU{0p7m1
zUZ|4=oC&~N(n;ljJE}fub#BH#kQHCS6GE54Cw{E;y6X=}Lc^bdLp3`m|M5_e^3TW}
zwZIRZuIi-yqXoy4FZ@XTEjk&iuc-FqUlU<KBJ83DXB93@Mjr*PrbXhGV{oig)`>B*
z*#$g$mNhsdcx58Q=@I?ulSFzj1cG>}T83dMV|P?V(M7++Z9Lr++&?RFLBiT&we1=G
zu69n$3#~;i&ffm|7Lxy@oc~fsC2z$2H0@ZnmW2H|`3K$~H|m+39u{a$1iy0wiTv#6
z(5V*+JDAN0oK>#R2@x`33?YB@_X%(p9l0ybqe+b#kT&kKJN<%B3!$eu%sC4wqKm$n
zb8%2*oabLKAm|0cQk{l`imK7@9UXGlrj3bd7pF9yzsc*`s%jIGN9eTzi-3&j=Vl6A
zV8rJmaXkC2I8hW*YQMEo+`_eh#~H>%XcTfyL8T9|NPHe8X_Zb*+L^}wbQ@bQd~Z8G
z8Ro}QKbRtIqB-k7x$~GTbKI=g;zZU2>idcn<n-BBeR`PQl^31V0Vjj{o9M;Ez(kr2
zin~|^!-wVEb`inGSlp*>EKcj1NzD96(Rkj2No51Mt=ay6HSaEni~rJZFWCPUvA-Xo
zwmBg_Sw+6*BxIdh-}jkkY5tZoq5~XnY4{5vS1{>Yk%Ugc^SZtj3eUOwM!^Wo81L1i
zBineu;{eS9;OA*z)~xc4K?V96kY0<!)jPWqB28dZC3uVrUfUz7<?9NNreoT<M+yOt
zJ={xzkf~W+6j1V+2;AVm2lNRms6NIm@mXqo@*Y(6oXAGk!Id~j{rn{IT9~<ktXPJ4
zvb)79B?DNsb#CTM`Yw^);<+8eN>=bf*p&3!=3t5>Nyk&l2t)v|7yv1L$|ghN1TwA&
zj*vm%U*?&F?=>F^F_&4tRo5Lq%>hD}hsWT?wNEEl=<r|7qxsM@b&$)TVo-96A&XVT
z@_ooE@>m{h8GYoBya@*10{fffws`||4x%mCkS?$9TU_`3g@;^7a?$RT8-I&19mwj&
z9HZG&ssp<U@OJ<d=J#Ls2(|eEtaKXHAVwt6NB^J%!be1G3sigDXQ|OA2xX#SmfTcc
zzko0lj2Cohk;<toBaNK&$+atu*6L(|d%z?D-=A)_S3bc@8C)cCKMZ)}@wUZyBd?tv
z{b`GHA3e5@EZSt?9WEFP{Z@5q&9}Jx{pz<AL*&8g4`G@_S$3Bu8)&%Fp&|YtQF1<!
zh;gfD%kJv)Ew<{Jq6<aAg9&k7&G+h-lJV3hqndgs6++*p$M~}k@GS{KPJs%N4&gyt
zuzU;V+bET!^+kop)0v;ba&ATMzbhl@^lLVNb*!7)0D3X>6GI1f!6uMVld3K}rM?pJ
z#RUVrFZI}U_x2u$OEL)mc<A;1+O2!)$lW|wg9oBS`a(j{NXMxOqT^{^7yP=$C~J^p
zCR*3Bra>|(sb0t93S&5vF-kcE_ixy=^9ZGm&sX6_RZG|OFYU!JarS?!8e^oX@!LAe
zakZ$-;AVqQm>hJy=<M{|PM{?L;S9&A-@<eA<@OQ4qGnBXaHtIPVPz3(nt+FiO)q{f
z`63zfD-qY$pc%s-Nlk@8>-g+w_^K?(%06gJlgOkB^Ea-&a1Ez?=H$^TD}DYxmh=Xh
zmnnz96YOPZut}*IRVXwNgxmgsPS|9tb`(nMk2P1PepUt^Ouk@qj@KE3x9rbu|D{+w
z(z^b@jX~y#!W)e~Ay{V9WK#wa>0x*%H2R8$P_O$6iVC73#Q0V6Eq?JuHV_xUSN{n>
zqHK1Cm(o93ux{InP>jXb@REwkG)ySi{CQ-GL^0O*`Ia)W#@&+$&(vVbgJJ8c->bBJ
zrs+!H?<cYJe?U@fa|H&)i3zh}x@lRMSiC|UP@Na=9t)!oWgwyy_|)|!+wcJ|Z#xvp
zv%jF0Std#@u?S8oOpO3WGT|nQ%SQ#NEz`%@ANFV8pB1&fW6L{veK4uiKP8?~jrDOT
zdrMx41pJ*LqHq$qBi&|rKPELo@D?U!xt<=VEzfRz1S@@<#@y=Z7Kj-{nXeJ3Vwhy1
zMeB6jBwR9lT*eLrBSvzDk>aG_Hedz|!F7F3*?o(P3V=Qdzj`lf@oDIF4v+ilZR@i2
zyL^6N!rw$rS~PWw6siWnC+M-46OVf3qizaUVN*OXLbNYk09&<^lois*ChRVDP@T??
z3RL<}jtZpXdj*s6zU(qwDaj6|C_Udjkbj^_zhWedRu&(~i;Oe+q(O!x*hfp7vQfv7
z_;Dp>G!j0im?q{!%MuYYwDdDWBWM5Kk8TD0pQH8o?T)*qV*f&?Q*_YGHK_m~>(by3
z%C47{CVjm@z{5AR`6`zkVJr{x+lJRg4>%e8onGk42RbgLvv~7d6@r-?LLL&oWMpiE
z`n+<m%BKrl&uExj(!S_PgLXpRI_YZI)}w-^Al@klUwH&DFEYu9=p!?VTt2;axLOzO
zBv3zAuag3ylEpXBmqIF&6p5Qn>-XkWR4eIA9J=mo-n*}lcsN7l&5g2L{p8B@t4gPX
zNAEx1Ihvg}f9fdK94&Wbm;V0T)xiT1C-qlSSXkjz0yLN;Mn=i?a%EeD+Rhl5$CR|P
z?;)aaUeyl;WCIf30eJ|TjKFRQ0EQZgU7Dt}2))}vSjpD?G3;SAdBdlPn91ZCH}$#k
ztZ8Q3kr64o$af-110}av5uAF1qgn<gPU^oriEmfDaedoM`p%*=mygULbLbGhT4T67
zm{goi+O$?!2zQXkDg$g3ExqDtrpJ6}Xj^o;0UZ~~;A~ZC;nDTu+v4`VOu)VBoONNL
z=b|Bv?_VWfxHU8^)$4pa_ZoT^BzF&7npG4J0W~2j^E&HIei$WN7Wa|2)Kv@}{_Hy8
zz^@mQ=$hCXO8n5xeJ-~5A!)~`y52Bz*%r~%%DcrH^!$)MW0L{o(T;V_stsRj^P{TN
zWZfg+6zb|%3)>Nu^yHV5KsafKikS+$b}VJCQO<ir-s&!4I@2^pZm1xJ%7#}GxtRA0
z!PpxAxAWoWoLN<!C)cK!L65wy*4|r*8C;&k(8@CkrU0PekM<7&{y@VRAGY%cBw_|o
z;XczzGSH}akUc5_*n=}9%re~XNM?o$o{3#qCM_BZ;^vO9qsWppc610Z52n1p3Lm#>
zr^P@HvC{ej>cz*SUlk5C&(%*G@9E?H?BIn?NV=Y6GMw5>Q_7W*!F?yGSnEfdN&!Ni
z=VOdU9%2ux@8jnVv2SO|Q5oFLOacp=c8U<khhpgERkS!RV;9J6ZT^i{fWqwl^uP}#
z4(mi}uaPdLYkEIGN}zR6jY*tBP0XadFvLb1^vc-&6xw;(Bk;SNt9Gp%;?ZNbv8t^N
zp+Y#Gx9;m?PXxN7mniR@0r9DHQ(PE3OHP`rQ+W>GyIAWVczr&{^wNVe^Or<?IS^s#
z+0!_x?zH-PDIHOg@+qmCM|HXZ9W!vl7d!`(QXB#vyD~d+lC0d(z%NU1t#Ae^vB!CA
zJ30VWW>>;{g^@aSpi}}>hF6|lzRPD#xlkj=Ryf|Yi$2kFn4XIcosLuKENGxFOz5HX
z>tlK~3y!S6X60UW{|ZQqEovzcXRHPCoo$i0dXJ|^4qMZcSj_TWqoALTng-`%&@HTN
z&OYN#ta%sh@5t@%sM4K)xag2302aYpB}Q{2#>^vteO6D}0aeBTJ)?Trbx8><n*=k}
z{X-?{rNtT`+OV&8|3{D|RXrlgxK!75-Ig+*tHlnn8@DA<TznJ%Onzr`sjSfPSM`=X
z=0yHA<Li!Ek*I_usW*oAB#Vm|LFhf8U&m>4dfO{q%zkpdC4X<I^kv^3EhGLq&+@MJ
z)NtxK=2f!NttlrrBP8eLJQy|w$AL>}*oWXf{FcT`@SdJPblmQ90;}<&S97z$1I<N9
zQhQqbw)-G#9Q<`Ff9l{si}pMDF(cRJ`JIYz2OBIsiniebpSdpJDIiyW?G576UZp3F
zoS0M>Y5}ejf(aHDgdnAMV9pG4BJ??{$&ZPtpuXMqb>b7b))MJ!jgbdskv}+iO$iin
z<J-Gaecco+(rqxKv6U8Gc>vM2=GY0uF4_-QeHBWsK1Y%{gL-pvE8Qqcsjjz?D96IH
z`5?VPx!7ZSDo=8)GgA@BdL)}9$$m|n+Oh8jugjE$S(SyE%MNDQ%9U&Y`}M$)$#3SQ
z$Jer9!{<e{bh`X^S1%{l4T;V+fPnXul&;CF@Ve-|W8pnL-;u=l379=xyl19FAcZQB
zJd>4jpEW%RVETB?5`Ol4O9k8P;{v{7tfShr>pn2@^9S@jb`+*hD?BKoLC$~b8;op>
zaHcH+Gn}u}J@Ha!qU)*f4tz(jVnISWv$d~<)nFWk_Vbb#u`?VQ!Y=ybsGfn`+pTmz
zN-iFUn!(~HA{HGuQcK%yU)sWZ{PyWuO-4`!^y3_8Kcs((8+|Nl<!sVbdU!*Eny@8L
zn78I*;6(Uh0$D}!v#X0F6OEyWaLJEwekc|#!dEiF>PR9M>7tcT<TVDc!4@o!iDYrB
zH(Z|eyeLg2A2#bE4*aKi(!!6|%s|49o4HAl@dUmm^MLkk!2K>!Pf;0sN_q%*A%sU5
zW5_o?`9Sjw2(v408bm2zHwdx>G<u&U-W)v(?<N*N<PV7K+c7iZ3iH5b_;3J;uilZe
i*#+e81#r`Q6-l+AAz)vIMfW+-;lz`BllA-0%>M&oI;=nd

literal 7541
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
W<e5J|VY-`NEEmc>7rbYA`hNj&0oVut

diff --git a/static/localization/en/stats.yaml b/static/localization/en/stats.yaml
index 3ac23f88..49f3a7fd 100755
--- a/static/localization/en/stats.yaml
+++ b/static/localization/en/stats.yaml
@@ -14,7 +14,7 @@
 - key: label_frags
   value: Kills
 - key: label_damage_ratio
-  value: Damage Ratio
+  value: Dmg. Ratio
 - key: label_damage_blocked
   value: Blocked
 - key: label_avg_tier

From 50072830582cfd53906fed58066e2e274fdf0967 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 6 Jun 2024 21:53:13 -0400
Subject: [PATCH 014/341] added glossary

---
 cmds/core/client.go                           | 17 +++-
 cmds/core/scheduler/glossary.go               | 41 ++++++--
 go.mod                                        |  1 -
 go.sum                                        | 11 ---
 .../database/{external.go => averages.go}     |  9 --
 internal/database/client.go                   |  2 +
 internal/database/vehicles.go                 | 93 +++++++++++++++++++
 internal/stats/period.go                      | 22 ++++-
 internal/stats/prepare/common/tags.go         |  3 +
 internal/stats/prepare/period/card.go         | 13 ++-
 internal/stats/prepare/period/options.go      |  9 +-
 internal/stats/prepare/period/tier.go         | 36 ++++---
 .../stats/render/common/tier-percentage.go    |  2 +-
 internal/stats/renderer.go                    |  5 +-
 main.go                                       |  4 +-
 15 files changed, 206 insertions(+), 62 deletions(-)
 rename internal/database/{external.go => averages.go} (91%)
 create mode 100644 internal/database/vehicles.go

diff --git a/cmds/core/client.go b/cmds/core/client.go
index cd1e9381..db5ca9b7 100644
--- a/cmds/core/client.go
+++ b/cmds/core/client.go
@@ -2,6 +2,7 @@ package core
 
 import (
 	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/external/wargaming"
 	"github.com/cufee/aftermath/internal/stats"
 	"github.com/cufee/aftermath/internal/stats/fetch"
 	"golang.org/x/text/language"
@@ -12,13 +13,19 @@ var _ Client = &client{}
 type Client interface {
 	Render(locale language.Tag) stats.Renderer
 
+	Wargaming() wargaming.Client
 	Database() database.Client
 	Fetch() fetch.Client
 }
 
 type client struct {
-	fetch fetch.Client
-	db    database.Client
+	wargaming wargaming.Client
+	fetch     fetch.Client
+	db        database.Client
+}
+
+func (c *client) Wargaming() wargaming.Client {
+	return c.wargaming
 }
 
 func (c *client) Database() database.Client {
@@ -30,9 +37,9 @@ func (c *client) Fetch() fetch.Client {
 }
 
 func (c *client) Render(locale language.Tag) stats.Renderer {
-	return stats.NewRenderer(c.fetch, locale)
+	return stats.NewRenderer(c.fetch, c.db, locale)
 }
 
-func NewClient(fetch fetch.Client, database database.Client) *client {
-	return &client{fetch: fetch, db: database}
+func NewClient(fetch fetch.Client, wargaming wargaming.Client, database database.Client) *client {
+	return &client{fetch: fetch, db: database, wargaming: wargaming}
 }
diff --git a/cmds/core/scheduler/glossary.go b/cmds/core/scheduler/glossary.go
index a81cd930..587d651b 100644
--- a/cmds/core/scheduler/glossary.go
+++ b/cmds/core/scheduler/glossary.go
@@ -5,7 +5,9 @@ import (
 	"time"
 
 	"github.com/cufee/aftermath/cmds/core"
+	"github.com/cufee/aftermath/internal/database"
 	"github.com/rs/zerolog/log"
+	"golang.org/x/text/language"
 )
 
 // CurrentTankAverages
@@ -36,13 +38,36 @@ func UpdateAveragesWorker(client core.Client) func() {
 
 func UpdateGlossaryWorker(client core.Client) func() {
 	return func() {
-		// // We just run the logic directly as it's not a heavy task and it doesn't matter if it fails due to the app failing
-		// log.Info().Msg("updating glossary cache")
-		// err := cache.UpdateGlossaryCache()
-		// if err != nil {
-		// 	log.Err(err).Msg("failed to update glossary cache")
-		// } else {
-		// 	log.Info().Msg("glossary cache updated")
-		// }
+		// we just run the logic directly as it's not a heavy task and it doesn't matter if it fails
+		log.Info().Msg("updating glossary cache")
+
+		ctx, cancel := context.WithTimeout(context.Background(), time.Second*15)
+		defer cancel()
+
+		glossary, err := client.Wargaming().CompleteVehicleGlossary(ctx, "eu", "en")
+		if err != nil {
+			log.Err(err).Msg("failed to get vehicle glossary")
+			return
+		}
+
+		vehicles := make(map[string]database.Vehicle)
+		for id, data := range glossary {
+			vehicles[id] = database.Vehicle{
+				ID:   id,
+				Tier: data.Tier,
+				Type: data.Type,
+				// Class: ,
+				Nation:         data.Nation,
+				LocalizedNames: map[language.Tag]string{language.English: data.Name},
+			}
+		}
+
+		err = client.Database().UpsertVehicles(ctx, vehicles)
+		if err != nil {
+			log.Err(err).Msg("failed to save vehicle glossary")
+			return
+		}
+
+		log.Info().Msg("glossary cache updated")
 	}
 }
diff --git a/go.mod b/go.mod
index e4c1c034..08be4bfe 100644
--- a/go.mod
+++ b/go.mod
@@ -14,7 +14,6 @@ require (
 	github.com/shopspring/decimal v1.4.0
 	github.com/steebchen/prisma-client-go v0.37.0
 	github.com/stretchr/testify v1.9.0
-	go.dedis.ch/protobuf v1.0.11
 	golang.org/x/exp v0.0.0-20240530194437-404ba88c7ed0
 	golang.org/x/image v0.16.0
 	golang.org/x/text v0.15.0
diff --git a/go.sum b/go.sum
index fa0e39ca..d1ebe577 100644
--- a/go.sum
+++ b/go.sum
@@ -64,18 +64,8 @@ github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO
 github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
 github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-go.dedis.ch/fixbuf v1.0.3 h1:hGcV9Cd/znUxlusJ64eAlExS+5cJDIyTyEG+otu5wQs=
-go.dedis.ch/fixbuf v1.0.3/go.mod h1:yzJMt34Wa5xD37V5RTdmp38cz3QhMagdGoem9anUalw=
-go.dedis.ch/kyber/v3 v3.0.4/go.mod h1:OzvaEnPvKlyrWyp3kGXlFdp7ap1VC6RkZDTaPikqhsQ=
-go.dedis.ch/kyber/v3 v3.0.9 h1:i0ZbOQocHUjfFasBiUql5zVeC7u/vahFd96DFA8UOWk=
-go.dedis.ch/kyber/v3 v3.0.9/go.mod h1:rhNjUUg6ahf8HEg5HUvVBYoWY4boAafX8tYxX+PS+qg=
-go.dedis.ch/protobuf v1.0.5/go.mod h1:eIV4wicvi6JK0q/QnfIEGeSFNG0ZeB24kzut5+HaRLo=
-go.dedis.ch/protobuf v1.0.7/go.mod h1:pv5ysfkDX/EawiPqcW3ikOxsL5t+BqnV6xHSmE79KI4=
-go.dedis.ch/protobuf v1.0.11 h1:FTYVIEzY/bfl37lu3pR4lIj+F9Vp1jE8oh91VmxKgLo=
-go.dedis.ch/protobuf v1.0.11/go.mod h1:97QR256dnkimeNdfmURz0wAMNVbd1VmLXhG1CrTYrJ4=
 go.uber.org/atomic v1.9.0 h1:ECmE8Bn/WFTYwEW/bpKD3M8VtR/zQVbavAoalC1PYyE=
 go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
-golang.org/x/crypto v0.0.0-20190123085648-057139ce5d2b/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
 golang.org/x/crypto v0.19.0 h1:ENy+Az/9Y1vSrlrvBSyna3PITt4tiZLf7sgCjZBX7Wo=
 golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
@@ -87,7 +77,6 @@ golang.org/x/image v0.16.0/go.mod h1:ugSZItdV4nOxyqp56HmXwH0Ry0nBCpjnZdpDaIHdoPs
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.21.0 h1:AQyQV4dYCvJ7vGmJyKki9+PBdyvhkSd8EIx/qb0AYv4=
 golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
-golang.org/x/sys v0.0.0-20190124100055-b90733256f2e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
diff --git a/internal/database/external.go b/internal/database/averages.go
similarity index 91%
rename from internal/database/external.go
rename to internal/database/averages.go
index 87117a4a..5a27a3f4 100644
--- a/internal/database/external.go
+++ b/internal/database/averages.go
@@ -5,20 +5,11 @@ import (
 	"time"
 
 	"github.com/cufee/aftermath/internal/database/prisma/db"
-	"github.com/cufee/aftermath/internal/localization"
 	"github.com/cufee/aftermath/internal/stats/frame"
 	"github.com/rs/zerolog/log"
 	"github.com/steebchen/prisma-client-go/runtime/transaction"
 )
 
-type GlossaryVehicle struct {
-	db.VehicleModel
-}
-
-func (v GlossaryVehicle) Name(printer localization.Printer) string {
-	return printer("name")
-}
-
 func (c *client) UpsertVehicleAverages(ctx context.Context, averages map[string]frame.StatsFrame) error {
 	if len(averages) < 1 {
 		return nil
diff --git a/internal/database/client.go b/internal/database/client.go
index d4749a3f..de950fa6 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -10,6 +10,8 @@ import (
 type Client interface {
 	GetVehicleAverages(ctx context.Context, ids []string) (map[string]frame.StatsFrame, error)
 	UpsertVehicleAverages(ctx context.Context, averages map[string]frame.StatsFrame) error
+	GetVehicles(ctx context.Context, ids []string) (map[string]Vehicle, error)
+	UpsertVehicles(ctx context.Context, vehicles map[string]Vehicle) error
 
 	GetUserByID(ctx context.Context, id string, opts ...userGetOption) (User, error)
 	GetOrCreateUserByID(ctx context.Context, id string, opts ...userGetOption) (User, error)
diff --git a/internal/database/vehicles.go b/internal/database/vehicles.go
new file mode 100644
index 00000000..95def7d4
--- /dev/null
+++ b/internal/database/vehicles.go
@@ -0,0 +1,93 @@
+package database
+
+import (
+	"context"
+	"encoding/json"
+
+	"github.com/cufee/aftermath/internal/database/prisma/db"
+	"github.com/rs/zerolog/log"
+	"github.com/steebchen/prisma-client-go/runtime/transaction"
+	"golang.org/x/text/language"
+)
+
+type Vehicle struct {
+	ID     string
+	Tier   int
+	Type   string
+	Class  string
+	Nation string
+
+	LocalizedNames map[language.Tag]string
+}
+
+func (v Vehicle) FromModel(model db.VehicleModel) Vehicle {
+	v.ID = model.ID
+	v.Tier = model.Tier
+	v.Type = model.Type
+	v.Nation = model.Nation
+	v.LocalizedNames = make(map[language.Tag]string)
+	if model.LocalizedNamesEncoded != "" {
+		_ = json.Unmarshal([]byte(model.LocalizedNamesEncoded), &v.LocalizedNames)
+	}
+	return v
+}
+
+func (v Vehicle) Name(locale language.Tag) string {
+	if n := v.LocalizedNames[locale]; n != "" {
+		return n
+	}
+	if n := v.LocalizedNames[language.English]; n != "" {
+		return n
+	}
+	return "Secret Tank"
+}
+
+func (c *client) UpsertVehicles(ctx context.Context, vehicles map[string]Vehicle) error {
+	if len(vehicles) < 1 {
+		return nil
+	}
+
+	var transactions []transaction.Transaction
+	for id, data := range vehicles {
+		encoded, err := json.Marshal(data.LocalizedNames)
+		if err != nil {
+			log.Err(err).Str("id", id).Msg("failed to encode a stats frame for vehicle averages")
+			continue
+		}
+
+		transactions = append(transactions, c.Raw.Vehicle.
+			UpsertOne(db.Vehicle.ID.Equals(id)).
+			Create(
+				db.Vehicle.ID.Set(id),
+				db.Vehicle.Tier.Set(data.Tier),
+				db.Vehicle.Type.Set(data.Type),
+				db.Vehicle.Class.Set(data.Class),
+				db.Vehicle.Nation.Set(data.Nation),
+				db.Vehicle.LocalizedNamesEncoded.Set(string(encoded)),
+			).
+			Update(
+				db.Vehicle.Tier.Set(data.Tier),
+				db.Vehicle.Type.Set(data.Type),
+				db.Vehicle.Class.Set(data.Class),
+				db.Vehicle.Nation.Set(data.Nation),
+				db.Vehicle.LocalizedNamesEncoded.Set(string(encoded)),
+			).Tx(),
+		)
+	}
+
+	return c.Raw.Prisma.Transaction(transactions...).Exec(ctx)
+}
+
+func (c *client) GetVehicles(ctx context.Context, ids []string) (map[string]Vehicle, error) {
+	models, err := c.Raw.Vehicle.FindMany(db.Vehicle.ID.In(ids)).Exec(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	vehicles := make(map[string]Vehicle)
+	for _, model := range models {
+		vehicles[model.ID] = vehicles[model.ID].FromModel(model)
+	}
+
+	return vehicles, nil
+}
diff --git a/internal/stats/period.go b/internal/stats/period.go
index 3e61b421..aeb41fdb 100644
--- a/internal/stats/period.go
+++ b/internal/stats/period.go
@@ -2,8 +2,10 @@ package stats
 
 import (
 	"context"
+	"slices"
 	"time"
 
+	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/localization"
 	"github.com/cufee/aftermath/internal/stats/fetch"
 	prepare "github.com/cufee/aftermath/internal/stats/prepare/period"
@@ -14,6 +16,7 @@ import (
 
 type renderer struct {
 	fetchClient fetch.Client
+	database    database.Client
 	locale      language.Tag
 }
 
@@ -33,8 +36,25 @@ func (r *renderer) Period(ctx context.Context, accountId string, from time.Time,
 	}
 	meta.Stats = stats
 
+	stop = meta.Timer("prepare#GetVehicles")
+	var vehicles []string
+	for id := range stats.RegularBattles.Vehicles {
+		vehicles = append(vehicles, id)
+	}
+	for id := range stats.RatingBattles.Vehicles {
+		if !slices.Contains(vehicles, id) {
+			vehicles = append(vehicles, id)
+		}
+	}
+
+	glossary, err := r.database.GetVehicles(ctx, vehicles)
+	if err != nil {
+		return nil, meta, err
+	}
+	stop()
+
 	stop = meta.Timer("prepare#NewCards")
-	cards, err := prepare.NewCards(stats, nil, prepare.WithPrinter(printer))
+	cards, err := prepare.NewCards(stats, glossary, prepare.WithPrinter(printer, r.locale))
 	stop()
 	if err != nil {
 		return nil, meta, err
diff --git a/internal/stats/prepare/common/tags.go b/internal/stats/prepare/common/tags.go
index cba8b267..34301e15 100644
--- a/internal/stats/prepare/common/tags.go
+++ b/internal/stats/prepare/common/tags.go
@@ -24,6 +24,9 @@ const (
 	TagSurvivalPercent Tag = "survival_percent"
 	TagDamageDealt     Tag = "damage_dealt"
 	TagDamageTaken     Tag = "damage_taken"
+
+	// Module Specific
+	TagAvgTier Tag = "avg_tier"
 )
 
 func ParseTags(tags ...string) ([]Tag, error) {
diff --git a/internal/stats/prepare/period/card.go b/internal/stats/prepare/period/card.go
index c6f068df..5931d109 100644
--- a/internal/stats/prepare/period/card.go
+++ b/internal/stats/prepare/period/card.go
@@ -8,13 +8,13 @@ import (
 	"github.com/cufee/aftermath/internal/stats/prepare/common"
 )
 
-func NewCards(stats fetch.AccountStatsOverPeriod, glossary map[string]database.GlossaryVehicle, opts ...Option) (Cards, error) {
+func NewCards(stats fetch.AccountStatsOverPeriod, glossary map[string]database.Vehicle, opts ...Option) (Cards, error) {
 	options := defaultOptions
 	for _, apply := range opts {
 		apply(&options)
 	}
 	if glossary == nil {
-		glossary = make(map[string]database.GlossaryVehicle)
+		glossary = make(map[string]database.Vehicle)
 	}
 
 	var cards Cards
@@ -23,14 +23,13 @@ func NewCards(stats fetch.AccountStatsOverPeriod, glossary map[string]database.G
 	for _, column := range selectedBlocks {
 		var columnBlocks []common.StatsBlock[BlockData]
 		for _, preset := range column {
+			block := presetToBlock(preset, stats.RegularBattles.StatsFrame)
 			if preset == TagAvgTier {
-				// value := calculateAvgTier(input.Stats.Vehicles, input.VehicleGlossary)
-				continue
+				block = avgTierBlock(stats.RegularBattles.Vehicles, glossary)
 			}
-			block := presetToBlock(preset, stats.RegularBattles.StatsFrame)
+
 			block.Localize(options.localePrinter)
 			columnBlocks = append(columnBlocks, block)
-
 		}
 
 		cards.Overview.Type = common.CardTypeOverview
@@ -70,7 +69,7 @@ func NewCards(stats fetch.AccountStatsOverPeriod, glossary map[string]database.G
 		glossary.ID = data.vehicle.VehicleID
 
 		cards.Highlights = append(cards.Highlights, VehicleCard{
-			Title:  fmt.Sprintf("%s %s", common.IntToRoman(glossary.Tier), glossary.Name(options.localePrinter)),
+			Title:  fmt.Sprintf("%s %s", common.IntToRoman(glossary.Tier), glossary.Name(options.locale)),
 			Type:   common.CardTypeVehicle,
 			Blocks: vehicleBlocks,
 			Meta:   options.localePrinter(data.highlight.label),
diff --git a/internal/stats/prepare/period/options.go b/internal/stats/prepare/period/options.go
index 9f6a9fa9..a7a3f1d8 100644
--- a/internal/stats/prepare/period/options.go
+++ b/internal/stats/prepare/period/options.go
@@ -1,13 +1,16 @@
 package period
 
-var defaultOptions = options{localePrinter: func(s string) string { return s }}
+import "golang.org/x/text/language"
+
+var defaultOptions = options{localePrinter: func(s string) string { return s }, locale: language.English}
 
 type options struct {
 	localePrinter func(string) string
+	locale        language.Tag
 }
 
 type Option func(*options)
 
-func WithPrinter(printer func(string) string) func(*options) {
-	return func(o *options) { o.localePrinter = printer }
+func WithPrinter(printer func(string) string, locale language.Tag) func(*options) {
+	return func(o *options) { o.localePrinter = printer; o.locale = locale }
 }
diff --git a/internal/stats/prepare/period/tier.go b/internal/stats/prepare/period/tier.go
index 2096e4aa..5b085788 100644
--- a/internal/stats/prepare/period/tier.go
+++ b/internal/stats/prepare/period/tier.go
@@ -1,17 +1,27 @@
 package period
 
-// func calculateAvgTier(vehicles map[string]fetch.VehicleStatsFrame, glossary map[string]struct{}) fetch.Value {
-// 	var weightedTierTotal float32
+import (
+	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/stats/frame"
+	"github.com/cufee/aftermath/internal/stats/prepare/common"
+)
 
-// 	for _, vehicle := range vehicles {
-// 		if data, ok := glossary[vehicle.VehicleID]; ok && data.Tier > 0 {
-// 			battlesTotal += vehicle.Battles
-// 			weightedTierTotal += float32(vehicle.Battles * data.Tier)
-// 		}
-// 	}
-// 	if battlesTotal == 0 {
-// 		return fetch.InvalidValue
-// 	}
+func avgTierBlock(vehicles map[string]frame.VehicleStatsFrame, glossary map[string]database.Vehicle) common.StatsBlock[BlockData] {
+	block := common.StatsBlock[BlockData](common.NewBlock(common.TagAvgTier, BlockData{Flavor: BlockFlavorSecondary}))
 
-// 	return weightedTierTotal / float32(battlesTotal)
-// }
+	var weightedTotal, battlesTotal float32
+
+	for _, vehicle := range vehicles {
+		if data, ok := glossary[vehicle.VehicleID]; ok && data.Tier > 0 {
+			battlesTotal += vehicle.Battles.Float()
+			weightedTotal += vehicle.Battles.Float() * float32(data.Tier)
+		}
+	}
+	if battlesTotal == 0 {
+		block.Value = frame.InvalidValue
+		return block
+	}
+
+	block.Value = frame.ValueFloatDecimal(weightedTotal / battlesTotal)
+	return block
+}
diff --git a/internal/stats/render/common/tier-percentage.go b/internal/stats/render/common/tier-percentage.go
index 92cced6e..dd96c2d4 100644
--- a/internal/stats/render/common/tier-percentage.go
+++ b/internal/stats/render/common/tier-percentage.go
@@ -8,7 +8,7 @@ import (
 	"github.com/cufee/aftermath/internal/stats/frame"
 )
 
-func NewTierPercentageCard(style Style, vehicles map[string]frame.VehicleStatsFrame, glossary map[int]database.GlossaryVehicle) Block {
+func NewTierPercentageCard(style Style, vehicles map[string]frame.VehicleStatsFrame, glossary map[int]database.Vehicle) Block {
 	var blocks []Block
 	var elements int = 10
 
diff --git a/internal/stats/renderer.go b/internal/stats/renderer.go
index fb382966..3bd2e7ad 100644
--- a/internal/stats/renderer.go
+++ b/internal/stats/renderer.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"time"
 
+	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/stats/fetch"
 	"github.com/cufee/aftermath/internal/stats/render"
 	"golang.org/x/text/language"
@@ -18,6 +19,6 @@ type Renderer interface {
 	// Session(accountId string, from time.Time) (image.Image, error)
 }
 
-func NewRenderer(fetch fetch.Client, locale language.Tag) *renderer {
-	return &renderer{fetch, locale}
+func NewRenderer(fetch fetch.Client, database database.Client, locale language.Tag) *renderer {
+	return &renderer{fetch, database, locale}
 }
diff --git a/main.go b/main.go
index 5fbdc16a..a57a607c 100644
--- a/main.go
+++ b/main.go
@@ -9,6 +9,7 @@ import (
 	"time"
 
 	"github.com/cufee/aftermath/cmds/core"
+	"github.com/cufee/aftermath/cmds/core/scheduler"
 	"github.com/cufee/aftermath/cmds/discord"
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/external/blitzstars"
@@ -38,6 +39,7 @@ func main() {
 	coreClient := coreClientFromEnv()
 
 	// scheduler.UpdateAveragesWorker(coreClient)()
+	scheduler.UpdateGlossaryWorker(coreClient)()
 
 	discordHandler, err := discord.NewRouterHandler(coreClient, os.Getenv("DISCORD_TOKEN"), os.Getenv("DISCORD_PUBLIC_KEY"))
 	if err != nil {
@@ -69,7 +71,7 @@ func coreClientFromEnv() core.Client {
 		log.Fatalf("fetch#NewMultiSourceClient failed %s", err)
 	}
 
-	return core.NewClient(client, dbClient)
+	return core.NewClient(client, wgClient, dbClient)
 }
 
 func loadStaticAssets(static fs.FS) {

From 112dcf5100f92ad2949b7040498fe6882bfd011c Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 6 Jun 2024 22:07:08 -0400
Subject: [PATCH 015/341] added retry to all discord calls

---
 cmds/discord/rest/client.go              | 49 ++++++++++++++----------
 cmds/discord/router/handler.go           |  3 --
 internal/{stats/fetch => retry}/retry.go |  6 +--
 internal/stats/fetch/multisource.go      | 25 ++++++------
 main.go                                  |  4 +-
 5 files changed, 45 insertions(+), 42 deletions(-)
 rename internal/{stats/fetch => retry}/retry.go (67%)

diff --git a/cmds/discord/rest/client.go b/cmds/discord/rest/client.go
index 7c85e32c..bbc26f9f 100644
--- a/cmds/discord/rest/client.go
+++ b/cmds/discord/rest/client.go
@@ -13,6 +13,7 @@ import (
 	"time"
 
 	"github.com/bwmarrin/discordgo"
+	"github.com/cufee/aftermath/internal/retry"
 )
 
 type Client struct {
@@ -25,7 +26,7 @@ type Client struct {
 func NewClient(token string) (*Client, error) {
 	client := &Client{
 		token: token,
-		http:  http.Client{Timeout: time.Millisecond * 3000},
+		http:  http.Client{Timeout: time.Millisecond * 1000},
 	}
 
 	_, err := client.lookupApplicationID()
@@ -109,29 +110,35 @@ func partHeader(contentDisposition string, contentType string) textproto.MIMEHea
 }
 
 func (c *Client) do(req *http.Request, target any) error {
-	res, err := c.http.Do(req)
-	if err != nil {
-		return err
-	}
-	defer res.Body.Close()
-
-	if res.StatusCode > 299 {
-		var body discordgo.APIErrorMessage
-		_ = json.NewDecoder(res.Body).Decode(&body)
-		message := body.Message
-		if message == "" {
-			message = res.Status
+	result := retry.Retry(func() (any, error) {
+		res, err := c.http.Do(req)
+		if err != nil {
+			return nil, err
 		}
-		return errors.New("discord: " + strings.ToLower(message))
-	}
+		defer res.Body.Close()
 
-	if target != nil {
-		err = json.NewDecoder(res.Body).Decode(target)
-		if err != nil {
-			return fmt.Errorf("failed to decode response body :%w", err)
+		if res.StatusCode > 299 {
+			var body discordgo.APIErrorMessage
+			_ = json.NewDecoder(res.Body).Decode(&body)
+			message := body.Message
+			if message == "" {
+				message = res.Status
+			}
+
+			return nil, errors.New("discord: " + strings.ToLower(message))
 		}
-	}
-	return nil
+
+		if target != nil {
+			err = json.NewDecoder(res.Body).Decode(target)
+			if err != nil {
+				return nil, fmt.Errorf("failed to decode response body :%w", err)
+			}
+		}
+
+		return nil, nil
+	}, 3, time.Millisecond*150)
+
+	return result.Err
 }
 
 func (c *Client) lookupApplicationID() (string, error) {
diff --git a/cmds/discord/router/handler.go b/cmds/discord/router/handler.go
index 73fb9a96..685030b4 100644
--- a/cmds/discord/router/handler.go
+++ b/cmds/discord/router/handler.go
@@ -127,9 +127,6 @@ func (router *Router) HTTPHandler() (http.HandlerFunc, error) {
 		go func() {
 			// unlock once this context is done and the ack is delivered
 			<-r.Context().Done()
-			// give discord time to register the reply
-			// in very rare cases, out reply comes right after the unlock and discord returns an error
-			time.Sleep(time.Millisecond * 50)
 			state.mx.Unlock()
 		}()
 
diff --git a/internal/stats/fetch/retry.go b/internal/retry/retry.go
similarity index 67%
rename from internal/stats/fetch/retry.go
rename to internal/retry/retry.go
index 26d5c08d..f45c4ad9 100644
--- a/internal/stats/fetch/retry.go
+++ b/internal/retry/retry.go
@@ -1,4 +1,4 @@
-package fetch
+package retry
 
 import (
 	"errors"
@@ -10,7 +10,7 @@ type DataWithErr[T any] struct {
 	Err  error
 }
 
-func withRetry[T any](fn func() (T, error), tries int, sleepOnFail time.Duration) DataWithErr[T] {
+func Retry[T any](fn func() (T, error), tries int, sleepOnFail time.Duration) DataWithErr[T] {
 	if tries < 1 {
 		return DataWithErr[T]{Err: errors.New("invalid number of tries provided")}
 	}
@@ -22,5 +22,5 @@ func withRetry[T any](fn func() (T, error), tries int, sleepOnFail time.Duration
 	}
 
 	time.Sleep(sleepOnFail)
-	return withRetry(fn, tries, sleepOnFail)
+	return Retry(fn, tries, sleepOnFail)
 }
diff --git a/internal/stats/fetch/multisource.go b/internal/stats/fetch/multisource.go
index 134c933f..ddd08882 100644
--- a/internal/stats/fetch/multisource.go
+++ b/internal/stats/fetch/multisource.go
@@ -10,6 +10,7 @@ import (
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/external/blitzstars"
 	"github.com/cufee/aftermath/internal/external/wargaming"
+	"github.com/cufee/aftermath/internal/retry"
 	"github.com/cufee/aftermath/internal/stats/frame"
 	"github.com/cufee/am-wg-proxy-next/v2/types"
 )
@@ -65,14 +66,14 @@ func (c *multiSourceClient) CurrentStats(ctx context.Context, id string, opts ..
 	group.Add(3)
 
 	var clan types.ClanMember
-	var account DataWithErr[types.ExtendedAccount]
-	var vehicles DataWithErr[[]types.VehicleStatsFrame]
-	var averages DataWithErr[map[string]frame.StatsFrame]
+	var account retry.DataWithErr[types.ExtendedAccount]
+	var vehicles retry.DataWithErr[[]types.VehicleStatsFrame]
+	var averages retry.DataWithErr[map[string]frame.StatsFrame]
 
 	go func() {
 		defer group.Done()
 
-		account = withRetry(func() (types.ExtendedAccount, error) {
+		account = retry.Retry(func() (types.ExtendedAccount, error) {
 			return c.wargaming.AccountByID(ctx, realm, id)
 		}, c.retriesPerRequest, c.retrySleepInterval)
 	}()
@@ -84,7 +85,7 @@ func (c *multiSourceClient) CurrentStats(ctx context.Context, id string, opts ..
 	go func() {
 		defer group.Done()
 
-		vehicles = withRetry(func() ([]types.VehicleStatsFrame, error) {
+		vehicles = retry.Retry(func() ([]types.VehicleStatsFrame, error) {
 			return c.wargaming.AccountVehicles(ctx, realm, id)
 		}, c.retriesPerRequest, c.retrySleepInterval)
 
@@ -97,7 +98,7 @@ func (c *multiSourceClient) CurrentStats(ctx context.Context, id string, opts ..
 			ids = append(ids, fmt.Sprint(v.TankID))
 		}
 		a, err := c.database.GetVehicleAverages(ctx, ids)
-		averages = DataWithErr[map[string]frame.StatsFrame]{a, err}
+		averages = retry.DataWithErr[map[string]frame.StatsFrame]{Data: a, Err: err}
 	}()
 
 	group.Wait()
@@ -123,9 +124,9 @@ func (c *multiSourceClient) PeriodStats(ctx context.Context, id string, periodSt
 		apply(&options)
 	}
 
-	var histories DataWithErr[map[int][]blitzstars.TankHistoryEntry]
-	var averages DataWithErr[map[string]frame.StatsFrame]
-	var current DataWithErr[AccountStatsOverPeriod]
+	var histories retry.DataWithErr[map[int][]blitzstars.TankHistoryEntry]
+	var averages retry.DataWithErr[map[string]frame.StatsFrame]
+	var current retry.DataWithErr[AccountStatsOverPeriod]
 
 	var group sync.WaitGroup
 	group.Add(1)
@@ -133,7 +134,7 @@ func (c *multiSourceClient) PeriodStats(ctx context.Context, id string, periodSt
 		defer group.Done()
 
 		stats, err := c.CurrentStats(ctx, id)
-		current = DataWithErr[AccountStatsOverPeriod]{stats, err}
+		current = retry.DataWithErr[AccountStatsOverPeriod]{Data: stats, Err: err}
 
 		if err != nil || stats.RegularBattles.Battles < 1 || !options.withWN8 {
 			return
@@ -144,7 +145,7 @@ func (c *multiSourceClient) PeriodStats(ctx context.Context, id string, periodSt
 			ids = append(ids, id)
 		}
 		a, err := c.database.GetVehicleAverages(ctx, ids)
-		averages = DataWithErr[map[string]frame.StatsFrame]{a, err}
+		averages = retry.DataWithErr[map[string]frame.StatsFrame]{Data: a, Err: err}
 	}()
 
 	// TODO: lookup a session from the database first
@@ -167,7 +168,7 @@ func (c *multiSourceClient) PeriodStats(ctx context.Context, id string, periodSt
 	group.Add(1)
 	go func() {
 		defer group.Done()
-		histories = withRetry(func() (map[int][]blitzstars.TankHistoryEntry, error) {
+		histories = retry.Retry(func() (map[int][]blitzstars.TankHistoryEntry, error) {
 			return c.blitzstars.AccountTankHistories(ctx, id)
 		}, c.retriesPerRequest, c.retrySleepInterval)
 	}()
diff --git a/main.go b/main.go
index a57a607c..4351c111 100644
--- a/main.go
+++ b/main.go
@@ -9,7 +9,6 @@ import (
 	"time"
 
 	"github.com/cufee/aftermath/cmds/core"
-	"github.com/cufee/aftermath/cmds/core/scheduler"
 	"github.com/cufee/aftermath/cmds/discord"
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/external/blitzstars"
@@ -39,7 +38,7 @@ func main() {
 	coreClient := coreClientFromEnv()
 
 	// scheduler.UpdateAveragesWorker(coreClient)()
-	scheduler.UpdateGlossaryWorker(coreClient)()
+	// scheduler.UpdateGlossaryWorker(coreClient)()
 
 	discordHandler, err := discord.NewRouterHandler(coreClient, os.Getenv("DISCORD_TOKEN"), os.Getenv("DISCORD_PUBLIC_KEY"))
 	if err != nil {
@@ -88,5 +87,4 @@ func loadStaticAssets(static fs.FS) {
 	if err != nil {
 		log.Fatalf("localization#LoadAssets failed %s", err)
 	}
-
 }

From e3f4842e0e00f39d20f6e4ae933853336f22d0c5 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 6 Jun 2024 22:11:53 -0400
Subject: [PATCH 016/341] handling 0 length request slice

---
 internal/database/vehicles.go | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/internal/database/vehicles.go b/internal/database/vehicles.go
index 95def7d4..d231f256 100644
--- a/internal/database/vehicles.go
+++ b/internal/database/vehicles.go
@@ -79,6 +79,10 @@ func (c *client) UpsertVehicles(ctx context.Context, vehicles map[string]Vehicle
 }
 
 func (c *client) GetVehicles(ctx context.Context, ids []string) (map[string]Vehicle, error) {
+	if len(ids) < 1 {
+		return nil, nil
+	}
+
 	models, err := c.Raw.Vehicle.FindMany(db.Vehicle.ID.In(ids)).Exec(ctx)
 	if err != nil {
 		return nil, err

From 2ea3d4409b3849b4e609572d20ea78dc10f1f57c Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 7 Jun 2024 16:52:51 -0400
Subject: [PATCH 017/341] scheduler queue, db accounts

---
 cmds/core/scheduler/cron.go                   |   9 +-
 cmds/core/scheduler/tasks/handler.go          |  17 ++
 cmds/core/scheduler/tasks/queue.go            | 125 +++++++++
 cmds/core/scheduler/tasks/sessions.go         |  88 +++++++
 cmds/core/scheduler/tasks/split.go            |  24 ++
 cmds/core/scheduler/workers.go                |   5 +-
 cmds/discord/commands/ping.go                 |  16 ++
 cmds/discord/router/handler.go                |  13 +-
 go.mod                                        |   3 +
 go.sum                                        |  15 ++
 internal/database/accounts.go                 | 132 ++++++++++
 internal/database/averages.go                 |   8 +-
 internal/database/client.go                   |  23 +-
 internal/database/prisma/schema.prisma        |  32 ++-
 internal/database/tasks.go                    | 247 ++++++++++++++++++
 internal/database/users.go                    |  22 +-
 internal/database/vehicles.go                 |   6 +-
 internal/permissions/actions.go               |  22 +-
 internal/permissions/roles.go                 |   3 +-
 internal/permissions/type.go                  |   2 +-
 internal/stats/fetch/client.go                |   4 +-
 internal/stats/fetch/convert.go               |  21 +-
 internal/stats/fetch/replay/errors.go         |   7 +
 internal/stats/fetch/replay/meta.go           |  17 ++
 internal/stats/fetch/replay/replay.go         | 228 ++++++++++++++++
 internal/stats/fetch/replay/results.go        | 181 +++++++++++++
 internal/stats/fetch/replay/unpack.go         | 102 ++++++++
 internal/stats/prepare/replay/replay.go.todo  | 224 ----------------
 internal/stats/render/period/cards.go         |   4 +-
 internal/stats/render/replay/blocks.go.todo   | 108 ++++++++
 internal/stats/render/replay/cards.go.todo    |  90 +++++++
 .../stats/render/replay/constants.go.todo     |  27 ++
 internal/stats/render/replay/elements.go.todo |  48 ++++
 internal/stats/render/replay/preset.go.todo   |  18 ++
 main.go                                       |   7 +-
 35 files changed, 1609 insertions(+), 289 deletions(-)
 create mode 100644 cmds/core/scheduler/tasks/handler.go
 create mode 100644 cmds/core/scheduler/tasks/queue.go
 create mode 100644 cmds/core/scheduler/tasks/sessions.go
 create mode 100644 cmds/core/scheduler/tasks/split.go
 create mode 100644 cmds/discord/commands/ping.go
 create mode 100644 internal/database/accounts.go
 create mode 100644 internal/database/tasks.go
 create mode 100644 internal/stats/fetch/replay/errors.go
 create mode 100644 internal/stats/fetch/replay/meta.go
 create mode 100644 internal/stats/fetch/replay/replay.go
 create mode 100644 internal/stats/fetch/replay/results.go
 create mode 100644 internal/stats/fetch/replay/unpack.go
 delete mode 100644 internal/stats/prepare/replay/replay.go.todo
 create mode 100644 internal/stats/render/replay/blocks.go.todo
 create mode 100644 internal/stats/render/replay/cards.go.todo
 create mode 100644 internal/stats/render/replay/constants.go.todo
 create mode 100644 internal/stats/render/replay/elements.go.todo
 create mode 100644 internal/stats/render/replay/preset.go.todo

diff --git a/cmds/core/scheduler/cron.go b/cmds/core/scheduler/cron.go
index 23ea3de7..d78ad736 100644
--- a/cmds/core/scheduler/cron.go
+++ b/cmds/core/scheduler/cron.go
@@ -4,17 +4,18 @@ import (
 	"time"
 
 	"github.com/cufee/aftermath/cmds/core"
+	"github.com/cufee/aftermath/cmds/core/scheduler/tasks"
 	"github.com/go-co-op/gocron"
 	"github.com/rs/zerolog/log"
 )
 
-func StartCronJobs(client core.Client) {
-	log.Info().Msg("starting cron jobs")
+func StartCronJobs(client core.Client, queue *tasks.Queue) {
+	defer log.Info().Msg("started cron scheduler")
 
 	c := gocron.NewScheduler(time.UTC)
 	// Tasks
-	c.Cron("* * * * *").Do(runTasksWorker(client))
-	c.Cron("0 * * * *").Do(restartTasksWorker(client))
+	c.Cron("* * * * *").Do(runTasksWorker(queue))
+	c.Cron("0 * * * *").Do(restartTasksWorker(queue))
 
 	// Glossary - Do it around the same time WG releases game updates
 	c.Cron("0 10 * * *").Do(UpdateGlossaryWorker(client))
diff --git a/cmds/core/scheduler/tasks/handler.go b/cmds/core/scheduler/tasks/handler.go
new file mode 100644
index 00000000..4c99d1ff
--- /dev/null
+++ b/cmds/core/scheduler/tasks/handler.go
@@ -0,0 +1,17 @@
+package tasks
+
+import (
+	"github.com/cufee/aftermath/cmds/core"
+	"github.com/cufee/aftermath/internal/database"
+)
+
+type TaskHandler struct {
+	process     func(client core.Client, task database.Task) (string, error)
+	shouldRetry func(task *database.Task) bool
+}
+
+var defaultHandlers = make(map[database.TaskType]TaskHandler)
+
+func DefaultHandlers() map[database.TaskType]TaskHandler {
+	return defaultHandlers
+}
diff --git a/cmds/core/scheduler/tasks/queue.go b/cmds/core/scheduler/tasks/queue.go
new file mode 100644
index 00000000..9a5dc94d
--- /dev/null
+++ b/cmds/core/scheduler/tasks/queue.go
@@ -0,0 +1,125 @@
+package tasks
+
+import (
+	"context"
+	"sync"
+	"time"
+
+	"github.com/cufee/aftermath/cmds/core"
+	"github.com/cufee/aftermath/internal/database"
+	"github.com/rs/zerolog/log"
+)
+
+type Queue struct {
+	limiter          chan struct{}
+	concurrencyLimit int
+	lastTaskRun      time.Time
+
+	handlers map[database.TaskType]TaskHandler
+	core     core.Client
+}
+
+func (q *Queue) ConcurrencyLimit() int {
+	return q.concurrencyLimit
+}
+
+func (q *Queue) ActiveWorkers() int {
+	return len(q.limiter)
+}
+
+func (q *Queue) LastTaskRun() time.Time {
+	return q.lastTaskRun
+}
+
+func NewQueue(client core.Client, handlers map[database.TaskType]TaskHandler, concurrencyLimit int) *Queue {
+	return &Queue{
+		core:             client,
+		handlers:         handlers,
+		concurrencyLimit: concurrencyLimit,
+		limiter:          make(chan struct{}, concurrencyLimit),
+	}
+}
+
+func (q *Queue) Process(callback func(error), tasks ...database.Task) {
+	var err error
+	if callback != nil {
+		defer callback(err)
+	}
+	if len(tasks) == 0 {
+		log.Debug().Msg("no tasks to process")
+		return
+	}
+
+	log.Debug().Msgf("processing %d tasks", len(tasks))
+
+	var wg sync.WaitGroup
+	q.lastTaskRun = time.Now()
+	processedTasks := make(chan database.Task, len(tasks))
+	for _, task := range tasks {
+		wg.Add(1)
+		go func(t database.Task) {
+			q.limiter <- struct{}{}
+			defer func() {
+				processedTasks <- t
+				wg.Done()
+				<-q.limiter
+				log.Debug().Msgf("finished processing task %s", t.ID)
+			}()
+			log.Debug().Msgf("processing task %s", t.ID)
+
+			handler, ok := q.handlers[t.Type]
+			if !ok {
+				t.Status = database.TaskStatusFailed
+				t.LogAttempt(database.TaskLog{
+					Targets:   t.Targets,
+					Timestamp: time.Now(),
+					Error:     "missing task type handler",
+				})
+				return
+			}
+
+			attempt := database.TaskLog{
+				Targets:   t.Targets,
+				Timestamp: time.Now(),
+			}
+
+			message, err := handler.process(nil, t)
+			attempt.Comment = message
+			if err != nil {
+				attempt.Error = err.Error()
+				t.Status = database.TaskStatusFailed
+			} else {
+				t.Status = database.TaskStatusComplete
+			}
+			t.LogAttempt(attempt)
+		}(task)
+	}
+
+	wg.Wait()
+	close(processedTasks)
+
+	rescheduledCount := 0
+	processedSlice := make([]database.Task, 0, len(processedTasks))
+	for task := range processedTasks {
+		handler, ok := q.handlers[task.Type]
+		if !ok {
+			continue
+		}
+
+		if task.Status == database.TaskStatusFailed && handler.shouldRetry(&task) {
+			rescheduledCount++
+			task.Status = database.TaskStatusScheduled
+		}
+		processedSlice = append(processedSlice, task)
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
+	defer cancel()
+
+	err = q.core.Database().UpdateTasks(ctx, processedSlice...)
+	if err != nil {
+		return
+	}
+
+	log.Debug().Msgf("processed %d tasks, %d rescheduled", len(processedSlice), rescheduledCount)
+}
diff --git a/cmds/core/scheduler/tasks/sessions.go b/cmds/core/scheduler/tasks/sessions.go
new file mode 100644
index 00000000..45c03af2
--- /dev/null
+++ b/cmds/core/scheduler/tasks/sessions.go
@@ -0,0 +1,88 @@
+package tasks
+
+import (
+	"context"
+	"errors"
+	"strings"
+	"time"
+
+	"github.com/cufee/aftermath/cmds/core"
+	"github.com/cufee/aftermath/internal/database"
+)
+
+func init() {
+	defaultHandlers[database.TaskTypeRecordSessions] = TaskHandler{
+		process: func(client core.Client, task database.Task) (string, error) {
+			if task.Data == nil {
+				return "no data provided", errors.New("no data provided")
+			}
+			realm, ok := task.Data["realm"].(string)
+			if !ok {
+				return "invalid realm", errors.New("invalid realm")
+			}
+
+			return "did nothing for a task on realm " + realm, nil
+
+			// accountErrs, err := cache.RefreshSessionsAndAccounts(models.SessionTypeDaily, nil, realm, task.Targets...)
+			// if err != nil {
+			// 	return "failed to refresh sessions on all account", err
+			// }
+
+			// var failedAccounts []int
+			// for accountId, err := range accountErrs {
+			// 	if err != nil && accountId != 0 {
+			// 		failedAccounts = append(failedAccounts, accountId)
+			// 	}
+			// }
+			// if len(failedAccounts) == 0 {
+			// 	return "finished session update on all accounts", nil
+			// }
+
+			// // Retry failed accounts
+			// task.Targets = failedAccounts
+			// return "retrying failed accounts", errors.New("some accounts failed")
+		},
+		shouldRetry: func(task *database.Task) bool {
+			triesLeft, ok := task.Data["triesLeft"].(int32)
+			if !ok {
+				return false
+			}
+			if triesLeft <= 0 {
+				return false
+			}
+
+			triesLeft -= 1
+			task.Data["triesLeft"] = triesLeft
+			task.ScheduledAfter = time.Now().Add(5 * time.Minute) // Backoff for 5 minutes to avoid spamming
+			return true
+		},
+	}
+}
+
+func CreateSessionUpdateTasks(client core.Client) func(realm string) error {
+	return func(realm string) error {
+		realm = strings.ToUpper(realm)
+		task := database.Task{
+			Type:        database.TaskTypeRecordSessions,
+			ReferenceID: "realm_" + realm,
+			Data: map[string]any{
+				"realm":     realm,
+				"triesLeft": int32(3),
+			},
+		}
+
+		ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
+		defer cancel()
+
+		accounts, err := client.Database().GetRealmAccounts(ctx, realm)
+		if err != nil {
+			return err
+		}
+		if len(accounts) < 1 {
+			return nil
+		}
+
+		// This update requires (2 + n) requests per n players
+		return client.Database().CreateTasks(ctx, splitTaskByTargets(task, 50)...)
+	}
+}
diff --git a/cmds/core/scheduler/tasks/split.go b/cmds/core/scheduler/tasks/split.go
new file mode 100644
index 00000000..38a9df21
--- /dev/null
+++ b/cmds/core/scheduler/tasks/split.go
@@ -0,0 +1,24 @@
+package tasks
+
+import "github.com/cufee/aftermath/internal/database"
+
+func splitTaskByTargets(task database.Task, batchSize int) []database.Task {
+	if len(task.Targets) <= batchSize {
+		return []database.Task{task}
+	}
+
+	var tasks []database.Task
+	subTasks := len(task.Targets) / batchSize
+
+	for i := 0; i <= subTasks; i++ {
+		subTask := task
+		if len(task.Targets) > batchSize*(i+1) {
+			subTask.Targets = (task.Targets[batchSize*i : batchSize*(i+1)])
+		} else {
+			subTask.Targets = (task.Targets[batchSize*i:])
+		}
+		tasks = append(tasks, subTask)
+	}
+
+	return tasks
+}
diff --git a/cmds/core/scheduler/workers.go b/cmds/core/scheduler/workers.go
index d5037340..06c8eff7 100644
--- a/cmds/core/scheduler/workers.go
+++ b/cmds/core/scheduler/workers.go
@@ -2,6 +2,7 @@ package scheduler
 
 import (
 	"github.com/cufee/aftermath/cmds/core"
+	"github.com/cufee/aftermath/cmds/core/scheduler/tasks"
 )
 
 func rotateBackgroundPresetsWorker(client core.Client) func() {
@@ -29,7 +30,7 @@ func createSessionTasksWorker(client core.Client, realm string) func() {
 	}
 }
 
-func runTasksWorker(client core.Client) func() {
+func runTasksWorker(queue *tasks.Queue) func() {
 	return func() {
 		// 	if tasks.DefaultQueue.ActiveWorkers() > 0 {
 		// 		return
@@ -57,7 +58,7 @@ func runTasksWorker(client core.Client) func() {
 	}
 }
 
-func restartTasksWorker(client core.Client) func() {
+func restartTasksWorker(queue *tasks.Queue) func() {
 	return func() {
 		// _, err := tasks.RestartAbandonedTasks(nil)
 		// if err != nil {
diff --git a/cmds/discord/commands/ping.go b/cmds/discord/commands/ping.go
new file mode 100644
index 00000000..7e062030
--- /dev/null
+++ b/cmds/discord/commands/ping.go
@@ -0,0 +1,16 @@
+package commands
+
+import (
+	"github.com/cufee/aftermath/cmds/discord/commands/builder"
+	"github.com/cufee/aftermath/cmds/discord/common"
+)
+
+func init() {
+	Loaded.add(
+		builder.NewCommand("ping").
+			Params(builder.SetDescKey("Pong!")).
+			Handler(func(ctx *common.Context) error {
+				return ctx.Reply("Pong!")
+			}),
+	)
+}
diff --git a/cmds/discord/router/handler.go b/cmds/discord/router/handler.go
index 685030b4..ff110617 100644
--- a/cmds/discord/router/handler.go
+++ b/cmds/discord/router/handler.go
@@ -109,7 +109,7 @@ func (router *Router) HTTPHandler() (http.HandlerFunc, error) {
 		command, err := router.routeInteraction(data)
 		if err != nil {
 			http.Error(w, err.Error(), http.StatusInternalServerError)
-			log.Err(err).Msg("failed to route interaction")
+			log.Err(err).Str("id", data.ID).Msg("failed to route interaction")
 			return
 		}
 
@@ -117,16 +117,19 @@ func (router *Router) HTTPHandler() (http.HandlerFunc, error) {
 		err = writeDeferredInteractionResponseAck(w, data.Type, command.Ephemeral)
 		if err != nil {
 			http.Error(w, err.Error(), http.StatusInternalServerError)
-			log.Err(err).Msg("failed to ack an interaction")
+			log.Err(err).Str("id", data.ID).Msg("failed to ack an interaction")
 			return
 		}
 
 		// route the interaction to a proper handler for a later reply
-		state := &interactionState{mx: &sync.Mutex{}, acked: true}
+		state := &interactionState{mx: &sync.Mutex{}}
 		state.mx.Lock()
 		go func() {
 			// unlock once this context is done and the ack is delivered
 			<-r.Context().Done()
+			log.Debug().Str("id", data.ID).Msg("sent an interaction ack")
+
+			state.acked = true
 			state.mx.Unlock()
 		}()
 
@@ -190,7 +193,7 @@ func sendPingReply(w http.ResponseWriter) {
 }
 
 func (router *Router) startInteractionHandlerAsync(interaction discordgo.Interaction, state *interactionState, command *builder.Command) {
-	log.Debug().Str("id", interaction.ID).Msg("started handling an interaction")
+	log.Info().Str("id", interaction.ID).Msg("started handling an interaction")
 
 	// create a timer for the interaction response
 	responseTimer := time.NewTimer(interactionTimeout)
@@ -220,7 +223,7 @@ func (router *Router) startInteractionHandlerAsync(interaction discordgo.Interac
 				// we are done, there is nothing else we should do here
 				// lock in case responseCh is still busy sending some data over
 				defer state.mx.Unlock()
-				log.Debug().Str("id", interaction.ID).Msg("finished handling an interaction")
+				log.Info().Str("id", interaction.ID).Msg("finished handling an interaction")
 				return
 
 			case data := <-responseCh:
diff --git a/go.mod b/go.mod
index 08be4bfe..56825584 100644
--- a/go.mod
+++ b/go.mod
@@ -10,12 +10,15 @@ require (
 	github.com/go-co-op/gocron v1.37.0
 	github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0
 	github.com/joho/godotenv v1.5.1
+	github.com/nlpodyssey/gopickle v0.3.0
 	github.com/rs/zerolog v1.33.0
 	github.com/shopspring/decimal v1.4.0
 	github.com/steebchen/prisma-client-go v0.37.0
 	github.com/stretchr/testify v1.9.0
+	go.dedis.ch/protobuf v1.0.11
 	golang.org/x/exp v0.0.0-20240530194437-404ba88c7ed0
 	golang.org/x/image v0.16.0
+	golang.org/x/sync v0.7.0
 	golang.org/x/text v0.15.0
 	gopkg.in/yaml.v3 v3.0.1
 )
diff --git a/go.sum b/go.sum
index d1ebe577..4b9b9c9d 100644
--- a/go.sum
+++ b/go.sum
@@ -38,6 +38,8 @@ github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/
 github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/nlpodyssey/gopickle v0.3.0 h1:BLUE5gxFLyyNOPzlXxt6GoHEMMxD0qhsE4p0CIQyoLw=
+github.com/nlpodyssey/gopickle v0.3.0/go.mod h1:f070HJ/yR+eLi5WmM1OXJEGaTpuJEUiib19olXgYha0=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
@@ -64,8 +66,18 @@ github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO
 github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
 github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+go.dedis.ch/fixbuf v1.0.3 h1:hGcV9Cd/znUxlusJ64eAlExS+5cJDIyTyEG+otu5wQs=
+go.dedis.ch/fixbuf v1.0.3/go.mod h1:yzJMt34Wa5xD37V5RTdmp38cz3QhMagdGoem9anUalw=
+go.dedis.ch/kyber/v3 v3.0.4/go.mod h1:OzvaEnPvKlyrWyp3kGXlFdp7ap1VC6RkZDTaPikqhsQ=
+go.dedis.ch/kyber/v3 v3.0.9 h1:i0ZbOQocHUjfFasBiUql5zVeC7u/vahFd96DFA8UOWk=
+go.dedis.ch/kyber/v3 v3.0.9/go.mod h1:rhNjUUg6ahf8HEg5HUvVBYoWY4boAafX8tYxX+PS+qg=
+go.dedis.ch/protobuf v1.0.5/go.mod h1:eIV4wicvi6JK0q/QnfIEGeSFNG0ZeB24kzut5+HaRLo=
+go.dedis.ch/protobuf v1.0.7/go.mod h1:pv5ysfkDX/EawiPqcW3ikOxsL5t+BqnV6xHSmE79KI4=
+go.dedis.ch/protobuf v1.0.11 h1:FTYVIEzY/bfl37lu3pR4lIj+F9Vp1jE8oh91VmxKgLo=
+go.dedis.ch/protobuf v1.0.11/go.mod h1:97QR256dnkimeNdfmURz0wAMNVbd1VmLXhG1CrTYrJ4=
 go.uber.org/atomic v1.9.0 h1:ECmE8Bn/WFTYwEW/bpKD3M8VtR/zQVbavAoalC1PYyE=
 go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
+golang.org/x/crypto v0.0.0-20190123085648-057139ce5d2b/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
 golang.org/x/crypto v0.19.0 h1:ENy+Az/9Y1vSrlrvBSyna3PITt4tiZLf7sgCjZBX7Wo=
 golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
@@ -77,6 +89,9 @@ golang.org/x/image v0.16.0/go.mod h1:ugSZItdV4nOxyqp56HmXwH0Ry0nBCpjnZdpDaIHdoPs
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.21.0 h1:AQyQV4dYCvJ7vGmJyKki9+PBdyvhkSd8EIx/qb0AYv4=
 golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
+golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
+golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sys v0.0.0-20190124100055-b90733256f2e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
diff --git a/internal/database/accounts.go b/internal/database/accounts.go
new file mode 100644
index 00000000..14330bcf
--- /dev/null
+++ b/internal/database/accounts.go
@@ -0,0 +1,132 @@
+package database
+
+import (
+	"context"
+	"sync"
+	"time"
+
+	"github.com/cufee/aftermath/internal/database/prisma/db"
+)
+
+type Account struct {
+	ID       string
+	Realm    string
+	Nickname string
+
+	Private        bool
+	CreatedAt      time.Time
+	LastBattleTime time.Time
+
+	ClanID  string
+	ClanTag string
+}
+
+func (a Account) FromModel(model db.AccountModel) Account {
+	a.ID = model.ID
+	a.Realm = model.Realm
+	a.Nickname = model.Nickname
+	a.Private = model.Private
+	a.CreatedAt = model.CreatedAt
+	a.LastBattleTime = model.LastBattleTime
+	return a
+}
+
+func (a *Account) AddClan(model *db.ClanModel) {
+	a.ClanID = model.ID
+	a.ClanTag = model.Tag
+}
+
+func (c *client) GetRealmAccounts(ctx context.Context, realm string) ([]Account, error) {
+	models, err := c.prisma.Account.FindMany(db.Account.Realm.Equals(realm)).With(db.Account.Clan.Fetch()).Exec(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	var accounts []Account
+	for _, model := range models {
+		account := Account{}.FromModel(model)
+		if clan, ok := model.Clan(); ok {
+			account.AddClan(clan)
+		}
+		accounts = append(accounts, account)
+	}
+
+	return accounts, nil
+}
+
+func (c *client) GetAccountByID(ctx context.Context, id string) (Account, error) {
+	model, err := c.prisma.Account.FindUnique(db.Account.ID.Equals(id)).With(db.Account.Clan.Fetch()).Exec(ctx)
+	if err != nil {
+		return Account{}, err
+	}
+
+	account := Account{}.FromModel(*model)
+	if clan, ok := model.Clan(); ok {
+		account.AddClan(clan)
+	}
+
+	return account, nil
+}
+
+func (c *client) GetAccounts(ctx context.Context, ids []string) ([]Account, error) {
+	if len(ids) < 1 {
+		return nil, nil
+	}
+
+	models, err := c.prisma.Account.FindMany(db.Account.ID.In(ids)).With(db.Account.Clan.Fetch()).Exec(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	var accounts []Account
+	for _, model := range models {
+		account := Account{}.FromModel(model)
+		if clan, ok := model.Clan(); ok {
+			account.AddClan(clan)
+		}
+		accounts = append(accounts, account)
+	}
+
+	return accounts, nil
+}
+
+func (c *client) UpsertAccounts(ctx context.Context, accounts []Account) map[string]error {
+	if len(accounts) < 1 {
+		return nil
+	}
+
+	var mx sync.Mutex
+	var wg sync.WaitGroup
+	errors := make(map[string]error, len(accounts))
+
+	// we don't really want to exit if one fails
+	for _, account := range accounts {
+		wg.Add(1)
+		go func(account Account) {
+			defer wg.Done()
+			optional := []db.AccountSetParam{db.Account.Private.Set(account.Private)}
+			if account.ClanID != "" {
+				optional = append(optional, db.Account.Clan.Link(db.Clan.ID.Equals(account.ClanID)))
+			}
+
+			_, err := c.prisma.Account.
+				UpsertOne(db.Account.ID.Equals(account.ID)).
+				Create(db.Account.ID.Set(account.ID),
+					db.Account.LastBattleTime.Set(account.LastBattleTime),
+					db.Account.AccountCreatedAt.Set(account.CreatedAt),
+					db.Account.Realm.Set(account.Realm),
+					db.Account.Nickname.Set(account.Nickname),
+					optional...,
+				).
+				Exec(ctx)
+			if err != nil {
+				mx.Lock()
+				errors[account.ID] = err
+				mx.Unlock()
+			}
+		}(account)
+	}
+	wg.Wait()
+
+	return errors
+}
diff --git a/internal/database/averages.go b/internal/database/averages.go
index 5a27a3f4..a2e59a64 100644
--- a/internal/database/averages.go
+++ b/internal/database/averages.go
@@ -23,7 +23,7 @@ func (c *client) UpsertVehicleAverages(ctx context.Context, averages map[string]
 			continue
 		}
 
-		transactions = append(transactions, c.Raw.VehicleAverage.
+		transactions = append(transactions, c.prisma.VehicleAverage.
 			UpsertOne(db.VehicleAverage.ID.Equals(id)).
 			Create(
 				db.VehicleAverage.ID.Set(id),
@@ -35,7 +35,7 @@ func (c *client) UpsertVehicleAverages(ctx context.Context, averages map[string]
 		)
 	}
 
-	return c.Raw.Prisma.Transaction(transactions...).Exec(ctx)
+	return c.prisma.Prisma.Transaction(transactions...).Exec(ctx)
 }
 
 func (c *client) GetVehicleAverages(ctx context.Context, ids []string) (map[string]frame.StatsFrame, error) {
@@ -45,7 +45,7 @@ func (c *client) GetVehicleAverages(ctx context.Context, ids []string) (map[stri
 
 	qCtx, cancel := context.WithTimeout(ctx, time.Second)
 	defer cancel()
-	records, err := c.Raw.VehicleAverage.FindMany(db.VehicleAverage.ID.In(ids)).Exec(qCtx)
+	records, err := c.prisma.VehicleAverage.FindMany(db.VehicleAverage.ID.In(ids)).Exec(qCtx)
 	if err != nil {
 		return nil, err
 	}
@@ -73,7 +73,7 @@ func (c *client) GetVehicleAverages(ctx context.Context, ids []string) (map[stri
 		// we can just delete the record and move on
 		ctx, cancel := context.WithCancel(context.Background())
 		defer cancel()
-		_, err := c.Raw.VehicleAverage.FindMany(db.VehicleAverage.ID.In(badRecords)).Delete().Exec(ctx)
+		_, err := c.prisma.VehicleAverage.FindMany(db.VehicleAverage.ID.In(badRecords)).Delete().Exec(ctx)
 		if err != nil {
 			log.Err(err).Strs("ids", badRecords).Msg("failed to delete a bad vehicle average records")
 		}
diff --git a/internal/database/client.go b/internal/database/client.go
index de950fa6..d9225317 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -5,9 +5,15 @@ import (
 
 	"github.com/cufee/aftermath/internal/database/prisma/db"
 	"github.com/cufee/aftermath/internal/stats/frame"
+	"golang.org/x/sync/semaphore"
 )
 
 type Client interface {
+	GetAccountByID(ctx context.Context, id string) (Account, error)
+	GetAccounts(ctx context.Context, ids []string) ([]Account, error)
+	GetRealmAccounts(ctx context.Context, realm string) ([]Account, error)
+	UpsertAccounts(ctx context.Context, accounts []Account) map[string]error
+
 	GetVehicleAverages(ctx context.Context, ids []string) (map[string]frame.StatsFrame, error)
 	UpsertVehicleAverages(ctx context.Context, averages map[string]frame.StatsFrame) error
 	GetVehicles(ctx context.Context, ids []string) (map[string]Vehicle, error)
@@ -17,12 +23,23 @@ type Client interface {
 	GetOrCreateUserByID(ctx context.Context, id string, opts ...userGetOption) (User, error)
 	UpdateConnection(ctx context.Context, connection UserConnection) (UserConnection, error)
 	UpsertConnection(ctx context.Context, connection UserConnection) (UserConnection, error)
+
+	CreateTasks(ctx context.Context, tasks ...Task) error
+	UpdateTasks(ctx context.Context, tasks ...Task) error
+	DeleteTasks(ctx context.Context, ids ...string) error
 }
 
-// var _ Client = &client{} // just a marker to see if it is implemented correctly
+var _ Client = &client{}
 
 type client struct {
-	Raw *db.PrismaClient
+	prisma *db.PrismaClient
+	// Prisma does not currently support updateManyAndReturn
+	// in order to avoid a case where we
+	tasksUpdateSem *semaphore.Weighted
+}
+
+func (c *client) Prisma() *db.PrismaClient {
+	return c.prisma
 }
 
 func NewClient() (*client, error) {
@@ -32,5 +49,5 @@ func NewClient() (*client, error) {
 		return nil, err
 	}
 
-	return &client{Raw: prisma}, nil
+	return &client{prisma: prisma, tasksUpdateSem: semaphore.NewWeighted(1)}, nil
 }
diff --git a/internal/database/prisma/schema.prisma b/internal/database/prisma/schema.prisma
index f4a0c95d..beff86c1 100644
--- a/internal/database/prisma/schema.prisma
+++ b/internal/database/prisma/schema.prisma
@@ -23,8 +23,8 @@ model AppConfiguration {
 }
 
 //
-// === Authentification === 
-// 
+// === Authentification ===
+//
 
 model AuthNonce {
   id        String   @id @default(cuid())
@@ -245,9 +245,9 @@ model Achievement {
   @@map("glossary_achievements")
 }
 
-// 
-// === App Data === 
-// 
+//
+// === App Data ===
+//
 
 model UserInteraction {
   id        String   @id @default(cuid())
@@ -307,3 +307,25 @@ model StatsRequestsOptions {
   @@index([referenceId])
   @@map("stats_request_options")
 }
+
+model CronTask {
+  id        String   @id @default(cuid())
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  type           String
+  referenceId    String
+  targetsEncoded String
+
+  status         String
+  lastRun        DateTime
+  scheduledAfter DateTime
+
+  logsEncoded String @default("")
+  dataEncoded String @default("")
+
+  @@index([referenceId])
+  @@index([status, referenceId, scheduledAfter])
+  @@index([lastRun, status])
+  @@map("cron_tasks")
+}
diff --git a/internal/database/tasks.go b/internal/database/tasks.go
new file mode 100644
index 00000000..1890cff3
--- /dev/null
+++ b/internal/database/tasks.go
@@ -0,0 +1,247 @@
+package database
+
+import (
+	"context"
+	"encoding/json"
+	"strings"
+	"time"
+
+	"github.com/cufee/aftermath/internal/database/prisma/db"
+)
+
+type TaskType string
+
+const (
+	TaskTypeUpdateClans              TaskType = "UPDATE_CLANS"
+	TaskTypeRecordSessions           TaskType = "RECORD_ACCOUNT_SESSIONS"
+	TaskTypeUpdateAccountWN8         TaskType = "UPDATE_ACCOUNT_WN8"
+	TaskTypeRecordPlayerAchievements TaskType = "UPDATE_ACCOUNT_ACHIEVEMENTS"
+)
+
+// Task statuses
+type taskStatus string
+
+const (
+	TaskStatusScheduled  taskStatus = "TASK_SCHEDULED"
+	TaskStatusInProgress taskStatus = "TASK_IN_PROGRESS"
+	TaskStatusComplete   taskStatus = "TASK_COMPLETE"
+	TaskStatusFailed     taskStatus = "TASK_FAILED"
+)
+
+type Task struct {
+	ID        string    `json:"id"`
+	Type      TaskType  `json:"kind"`
+	CreatedAt time.Time `json:"createdAt"`
+	UpdatedAt time.Time `json:"updatedAt"`
+
+	ReferenceID string   `json:"referenceId"`
+	Targets     []string `json:"targets"`
+
+	Logs []TaskLog `json:"logs"`
+
+	Status         taskStatus `json:"status"`
+	ScheduledAfter time.Time  `json:"scheduledAfter"`
+	LastRun        time.Time  `json:"lastRun"`
+
+	Data map[string]any `json:"data"`
+}
+
+func (t Task) FromModel(model db.CronTaskModel) Task {
+	t.ID = model.ID
+	t.Type = TaskType(model.Type)
+
+	t.Status = taskStatus(model.Status)
+	t.ReferenceID = model.ReferenceID
+
+	t.LastRun = model.LastRun
+	t.CreatedAt = model.CreatedAt
+	t.UpdatedAt = model.UpdatedAt
+	t.ScheduledAfter = model.ScheduledAfter
+
+	t.decodeData(model.DataEncoded)
+	t.decodeLogs(model.LogsEncoded)
+	t.decodeTargets(model.TargetsEncoded)
+	return t
+}
+
+func (t *Task) LogAttempt(log TaskLog) {
+	t.Logs = append(t.Logs, log)
+}
+
+func (t *Task) OnCreated() {
+	t.LastRun = time.Now()
+	t.CreatedAt = time.Now()
+	t.UpdatedAt = time.Now()
+}
+func (t *Task) OnUpdated() {
+	t.UpdatedAt = time.Now()
+}
+
+func (t *Task) encodeTargets() string {
+	return strings.Join(t.Targets, ";")
+}
+func (t *Task) decodeTargets(targets string) {
+	t.Targets = strings.Split(targets, ";")
+}
+
+func (t *Task) encodeLogs() string {
+	data, _ := json.Marshal(t.Logs)
+	return string(data)
+}
+func (t *Task) decodeLogs(logs string) {
+	_ = json.Unmarshal([]byte(logs), &t.Logs)
+}
+
+func (t *Task) encodeData() string {
+	if t.Data == nil {
+		return ""
+	}
+	data, _ := json.Marshal(t.Data)
+	return string(data)
+}
+func (t *Task) decodeData(data string) {
+	t.Data = make(map[string]any)
+	_ = json.Unmarshal([]byte(data), &t.Data)
+}
+
+type TaskLog struct {
+	Targets   []string  `json:"targets" bson:"targets"`
+	Timestamp time.Time `json:"timestamp" bson:"timestamp"`
+	Comment   string    `json:"result" bson:"result"`
+	Error     string    `json:"error" bson:"error"`
+}
+
+func NewAttemptLog(task Task, comment, err string) TaskLog {
+	return TaskLog{
+		Targets:   task.Targets,
+		Timestamp: time.Now(),
+		Comment:   comment,
+		Error:     err,
+	}
+}
+
+/*
+GetAndStartTasks retrieves up to limit number of tasks matching the referenceId and updates their status to in progress
+  - this func will block until all other calls to task update funcs are done
+*/
+func (c *client) GetAndStartTasks(ctx context.Context, referenceId string, limit int) ([]Task, error) {
+	if limit < 1 {
+		return nil, nil
+	}
+	if err := c.tasksUpdateSem.Acquire(ctx, 1); err != nil {
+		return nil, err
+	}
+
+	models, err := c.prisma.CronTask.
+		FindMany(
+			db.CronTask.Status.Equals(string(TaskStatusScheduled)),
+			db.CronTask.ReferenceID.Equals(referenceId),
+			db.CronTask.ScheduledAfter.Gte(time.Now()),
+		).
+		Take(limit).
+		Exec(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	var ids []string
+	var tasks []Task
+	for _, model := range models {
+		tasks = append(tasks, Task{}.FromModel(model))
+		ids = append(ids, model.ID)
+	}
+
+	_, err = c.prisma.CronTask.
+		FindMany(db.CronTask.ID.In(ids)).
+		Update(db.CronTask.Status.Set(string(TaskStatusInProgress))).
+		Exec(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	return tasks, nil
+}
+
+func (c *client) CreateTasks(ctx context.Context, tasks ...Task) error {
+	if len(tasks) < 1 {
+		return nil
+	}
+	// we do not block using c.tasksUpdateSem here because the order of ops in GetAndStartTasks makes this safe
+
+	var txns []db.PrismaTransaction
+	for _, task := range tasks {
+		task.OnCreated()
+		txns = append(txns, c.prisma.CronTask.CreateOne(
+			db.CronTask.Type.Set(string(task.Type)),
+			db.CronTask.ReferenceID.Set(task.ReferenceID),
+			db.CronTask.TargetsEncoded.Set(task.encodeTargets()),
+			db.CronTask.Status.Set(string(task.Status)),
+			db.CronTask.LastRun.Set(task.LastRun),
+			db.CronTask.ScheduledAfter.Set(task.ScheduledAfter),
+			db.CronTask.LogsEncoded.Set(task.encodeLogs()),
+			db.CronTask.DataEncoded.Set(task.encodeData()),
+		).Tx())
+	}
+
+	err := c.prisma.Prisma.Transaction(txns...).Exec(ctx)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+/*
+UpdateTasks will update all tasks passed in
+  - the following fields will be replaced: targets, status, leastRun, scheduleAfterm logs, data
+  - this func will block until all other calls to task update funcs are done
+*/
+func (c *client) UpdateTasks(ctx context.Context, tasks ...Task) error {
+	if len(tasks) < 1 {
+		return nil
+	}
+
+	if err := c.tasksUpdateSem.Acquire(ctx, 1); err != nil {
+		return err
+	}
+
+	var txns []db.PrismaTransaction
+	for _, task := range tasks {
+		task.OnUpdated()
+		txns = append(txns, c.prisma.CronTask.
+			FindUnique(db.CronTask.ID.Equals(task.ID)).
+			Update(
+				db.CronTask.TargetsEncoded.Set(task.encodeTargets()),
+				db.CronTask.Status.Set(string(task.Status)),
+				db.CronTask.LastRun.Set(task.LastRun),
+				db.CronTask.ScheduledAfter.Set(task.ScheduledAfter),
+				db.CronTask.LogsEncoded.Set(task.encodeLogs()),
+				db.CronTask.DataEncoded.Set(task.encodeData()),
+			).Tx())
+	}
+
+	err := c.prisma.Prisma.Transaction(txns...).Exec(ctx)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+/*
+DeleteTasks will delete all tasks matching by ids
+  - this func will block until all other calls to task update funcs are done
+*/
+func (c *client) DeleteTasks(ctx context.Context, ids ...string) error {
+	if len(ids) < 1 {
+		return nil
+	}
+
+	if err := c.tasksUpdateSem.Acquire(ctx, 1); err != nil {
+		return nil
+	}
+
+	_, err := c.prisma.CronTask.FindMany(db.CronTask.ID.In(ids)).Delete().Exec(ctx)
+	if err != nil {
+		return err
+	}
+	return nil
+}
diff --git a/internal/database/users.go b/internal/database/users.go
index eee8e046..270e7ab1 100644
--- a/internal/database/users.go
+++ b/internal/database/users.go
@@ -128,20 +128,6 @@ type UserSubscription struct {
 	ExpiresAt   time.Time
 	ReferenceID string
 	Permissions permissions.Permissions
-
-	// id        String   @id @default(cuid())
-	// createdAt DateTime @default(now())
-	// updatedAt DateTime @updatedAt
-
-	// user   User   @relation(fields: [userId], references: [id])
-	// userId String
-
-	// type        String
-	// expiresAt   DateTime
-	// referenceId String
-	// permissions String?
-
-	db.UserSubscriptionModel
 }
 
 type userGetOpts struct {
@@ -176,7 +162,7 @@ func (c *client) GetOrCreateUserByID(ctx context.Context, id string, opts ...use
 	user, err := c.GetUserByID(ctx, id, opts...)
 	if err != nil {
 		if db.IsErrNotFound(err) {
-			model, err := c.Raw.User.CreateOne(db.User.ID.Set(id), db.User.Permissions.Set(permissions.User.Encode())).Exec(ctx)
+			model, err := c.prisma.User.CreateOne(db.User.ID.Set(id), db.User.Permissions.Set(permissions.User.Encode())).Exec(ctx)
 			if err != nil {
 				return User{}, err
 			}
@@ -210,7 +196,7 @@ func (c *client) GetUserByID(ctx context.Context, id string, opts ...userGetOpti
 		fields = append(fields, db.User.Content.Fetch())
 	}
 
-	model, err := c.Raw.User.FindUnique(db.User.ID.Equals(id)).With(fields...).Exec(ctx)
+	model, err := c.prisma.User.FindUnique(db.User.ID.Equals(id)).With(fields...).Exec(ctx)
 	if err != nil {
 		return User{}, err
 	}
@@ -238,7 +224,7 @@ func (c *client) UpdateConnection(ctx context.Context, connection UserConnection
 		return UserConnection{}, fmt.Errorf("failed to encode metadata: %w", err)
 	}
 
-	model, err := c.Raw.UserConnection.FindUnique(db.UserConnection.ID.Equals(connection.ID)).Update(
+	model, err := c.prisma.UserConnection.FindUnique(db.UserConnection.ID.Equals(connection.ID)).Update(
 		db.UserConnection.ReferenceID.Set(connection.ReferenceID),
 		db.UserConnection.Permissions.Set(connection.Permissions.Encode()),
 		db.UserConnection.MetadataEncoded.Set(string(encoded)),
@@ -269,7 +255,7 @@ func (c *client) UpsertConnection(ctx context.Context, connection UserConnection
 		return UserConnection{}, fmt.Errorf("failed to encode metadata: %w", err)
 	}
 
-	model, err := c.Raw.UserConnection.CreateOne(
+	model, err := c.prisma.UserConnection.CreateOne(
 		db.UserConnection.User.Link(db.User.ID.Equals(connection.UserID)),
 		db.UserConnection.Type.Set(string(connection.Type)),
 		db.UserConnection.Permissions.Set(connection.Permissions.Encode()),
diff --git a/internal/database/vehicles.go b/internal/database/vehicles.go
index d231f256..eb16c885 100644
--- a/internal/database/vehicles.go
+++ b/internal/database/vehicles.go
@@ -55,7 +55,7 @@ func (c *client) UpsertVehicles(ctx context.Context, vehicles map[string]Vehicle
 			continue
 		}
 
-		transactions = append(transactions, c.Raw.Vehicle.
+		transactions = append(transactions, c.prisma.Vehicle.
 			UpsertOne(db.Vehicle.ID.Equals(id)).
 			Create(
 				db.Vehicle.ID.Set(id),
@@ -75,7 +75,7 @@ func (c *client) UpsertVehicles(ctx context.Context, vehicles map[string]Vehicle
 		)
 	}
 
-	return c.Raw.Prisma.Transaction(transactions...).Exec(ctx)
+	return c.prisma.Prisma.Transaction(transactions...).Exec(ctx)
 }
 
 func (c *client) GetVehicles(ctx context.Context, ids []string) (map[string]Vehicle, error) {
@@ -83,7 +83,7 @@ func (c *client) GetVehicles(ctx context.Context, ids []string) (map[string]Vehi
 		return nil, nil
 	}
 
-	models, err := c.Raw.Vehicle.FindMany(db.Vehicle.ID.In(ids)).Exec(ctx)
+	models, err := c.prisma.Vehicle.FindMany(db.Vehicle.ID.In(ids)).Exec(ctx)
 	if err != nil {
 		return nil, err
 	}
diff --git a/internal/permissions/actions.go b/internal/permissions/actions.go
index 55bcfaec..9c5b3b23 100644
--- a/internal/permissions/actions.go
+++ b/internal/permissions/actions.go
@@ -35,16 +35,16 @@ var (
 	RemoveUserPersonalContent             = fromLsh(32)
 
 	// Subscriptions
-	ViewUserSubscriptions     Permissions = fromLsh(33)
-	CreateUserSubscription                = fromLsh(34)
-	ExtendUserSubscription                = fromLsh(35)
-	TerminateUserSubscription             = fromLsh(36)
+	ViewUserSubscriptions     Permissions = fromLsh(35)
+	CreateUserSubscription                = fromLsh(36)
+	ExtendUserSubscription                = fromLsh(37)
+	TerminateUserSubscription             = fromLsh(38)
 
 	// Connections
-	ViewUserConnections  Permissions = fromLsh(37)
-	CreateUserConnection             = fromLsh(38)
-	UpdateUserConnection             = fromLsh(39)
-	RemoveUserConnection             = fromLsh(30)
+	ViewUserConnections  Permissions = fromLsh(40)
+	CreateUserConnection             = fromLsh(41)
+	UpdateUserConnection             = fromLsh(42)
+	RemoveUserConnection             = fromLsh(43)
 
 	// Restrictions
 	ViewUserRestrictions      Permissions = fromLsh(45)
@@ -56,7 +56,7 @@ var (
 	RemoveHardRestriction                 = fromLsh(51)
 )
 
-const (
-// Admin
-// _ Permissions = = fromLsh(60)
+var (
+	// Admin
+	ViewLogs Permissions = fromLsh(60)
 )
diff --git a/internal/permissions/roles.go b/internal/permissions/roles.go
index 5ffe58ea..364b861d 100644
--- a/internal/permissions/roles.go
+++ b/internal/permissions/roles.go
@@ -50,5 +50,6 @@ var (
 			Add(UpdateSoftRestriction).
 			Add(UpdateHardRestriction).
 			Add(RemoveSoftRestriction).
-			Add(RemoveHardRestriction)
+			Add(RemoveHardRestriction).
+			Add(ViewLogs)
 )
diff --git a/internal/permissions/type.go b/internal/permissions/type.go
index 42efc11d..7723547c 100644
--- a/internal/permissions/type.go
+++ b/internal/permissions/type.go
@@ -6,7 +6,7 @@ import (
 	"strings"
 )
 
-const version = "v3"
+const version = "v4"
 
 type Permissions struct {
 	value *big.Int
diff --git a/internal/stats/fetch/client.go b/internal/stats/fetch/client.go
index 8c273edb..b0dd727e 100644
--- a/internal/stats/fetch/client.go
+++ b/internal/stats/fetch/client.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"time"
 
+	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/stats/frame"
 	"github.com/cufee/am-wg-proxy-next/v2/types"
 )
@@ -11,8 +12,7 @@ import (
 type AccountStatsOverPeriod struct {
 	Realm string `json:"realm"`
 
-	Account types.Account `json:"account"`
-	Clan    types.Clan    `json:"clan"`
+	Account database.Account `json:"account"`
 
 	PeriodStart time.Time `json:"start"`
 	PeriodEnd   time.Time `json:"end"`
diff --git a/internal/stats/fetch/convert.go b/internal/stats/fetch/convert.go
index e9c11d61..7db9f1c4 100644
--- a/internal/stats/fetch/convert.go
+++ b/internal/stats/fetch/convert.go
@@ -5,6 +5,7 @@ import (
 	"strconv"
 	"time"
 
+	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/external/blitzstars"
 	"github.com/cufee/aftermath/internal/stats/frame"
 	"github.com/cufee/am-wg-proxy-next/v2/types"
@@ -14,11 +15,25 @@ func timestampToTime(timestamp int) time.Time {
 	return time.Unix(int64(timestamp), 0)
 }
 
+func wargamingToAccount(realm string, account types.ExtendedAccount, clan types.ClanMember, private bool) database.Account {
+	return database.Account{
+		ID:       strconv.Itoa(account.ID),
+		Realm:    realm,
+		Nickname: account.Nickname,
+		ClanTag:  clan.Clan.Tag,
+		ClanID:   strconv.Itoa(clan.ClanID),
+
+		Private:        private,
+		CreatedAt:      timestampToTime(account.CreatedAt),
+		LastBattleTime: timestampToTime(account.LastBattleTime),
+	}
+}
+
 func wargamingToStats(realm string, accountData types.ExtendedAccount, clanMember types.ClanMember, vehicleData []types.VehicleStatsFrame) AccountStatsOverPeriod {
 	stats := AccountStatsOverPeriod{
-		Realm:   realm,
-		Account: accountData.Account,
-		Clan:    clanMember.Clan,
+		Realm: realm,
+		// we got the stats, so the account is obv not private at this point
+		Account: wargamingToAccount(realm, accountData, clanMember, false),
 		RegularBattles: StatsWithVehicles{
 			StatsFrame: wargamingToFrame(accountData.Statistics.All),
 			Vehicles:   wargamingVehiclesToFrame(vehicleData),
diff --git a/internal/stats/fetch/replay/errors.go b/internal/stats/fetch/replay/errors.go
new file mode 100644
index 00000000..03d97a99
--- /dev/null
+++ b/internal/stats/fetch/replay/errors.go
@@ -0,0 +1,7 @@
+package replay
+
+import "errors"
+
+var (
+	ErrInvalidReplayFile = errors.New("invalid replay file")
+)
diff --git a/internal/stats/fetch/replay/meta.go b/internal/stats/fetch/replay/meta.go
new file mode 100644
index 00000000..faa7e7bc
--- /dev/null
+++ b/internal/stats/fetch/replay/meta.go
@@ -0,0 +1,17 @@
+package replay
+
+type replayMeta struct {
+	Version               string  `json:"version"`
+	Title                 string  `json:"title"`
+	Dbid                  string  `json:"dbid"`
+	PlayerName            string  `json:"playerName"`
+	BattleStartTime       string  `json:"battleStartTime"`
+	PlayerVehicleName     string  `json:"playerVehicleName"`
+	MapName               string  `json:"mapName"`
+	ArenaUniqueID         string  `json:"arenaUniqueId"`
+	BattleDuration        float64 `json:"battleDuration"`
+	VehicleCompDescriptor int     `json:"vehicleCompDescriptor"`
+	CamouflageID          int     `json:"camouflageId"`
+	MapID                 int     `json:"mapId"`
+	ArenaBonusType        int     `json:"arenaBonusType"`
+}
diff --git a/internal/stats/fetch/replay/replay.go b/internal/stats/fetch/replay/replay.go
new file mode 100644
index 00000000..41236fa5
--- /dev/null
+++ b/internal/stats/fetch/replay/replay.go
@@ -0,0 +1,228 @@
+package replay
+
+import (
+	"fmt"
+	"strconv"
+	"time"
+
+	"github.com/cufee/aftermath/internal/stats/frame"
+)
+
+type battleType struct {
+	ID  int    `json:"id" protobuf:"10"`
+	Tag string `json:"tag" protobuf:"11"`
+}
+
+func (bt battleType) String() string {
+	return bt.Tag
+}
+
+var (
+	BattleTypeUnknown   = battleType{-1, "battle_type_unknown"}
+	BattleTypeRandom    = battleType{0, "battle_type_regular"}
+	BattleTypeSupremacy = battleType{1, "battle_type_supremacy"}
+)
+
+var battleTypes = map[int]battleType{
+	0: BattleTypeRandom,
+	1: BattleTypeSupremacy,
+}
+
+type gameMode struct {
+	ID      int    `json:"id" protobuf:"15"`
+	Name    string `json:"name" protobuf:"16"`
+	Special bool   `json:"special" protobuf:"17"` // Signifies if WN8 should be calculated
+}
+
+func (gm gameMode) String() string {
+	return gm.Name
+}
+
+var (
+	GameModeUnknown         = gameMode{-1, "game_mode_unknown", false}
+	GameModeRegular         = gameMode{1, "game_mode_regular", false}
+	GameModeTraining        = gameMode{2, "game_mode_training", true}
+	GameModeTournament      = gameMode{4, "game_mode_tournament", true}
+	GameModeQuickTournament = gameMode{5, "game_mode_quick_tournament", true}
+	GameModeRating          = gameMode{7, "game_mode_rating", false}
+	GameModeMadGames        = gameMode{8, "game_mode_mad_games", true}
+	GameModeRealistic       = gameMode{22, "game_mode_realistic", false}
+	GameModeUprising        = gameMode{23, "game_mode_uprising", true}
+	GameModeGravity         = gameMode{24, "game_mode_gravity", true}
+	GameModeSkirmish        = gameMode{25, "game_mode_skirmish", false}
+	GameModeBurningGames    = gameMode{26, "game_mode_burning_games", true}
+)
+
+var gameModes = map[int]gameMode{
+	1:  GameModeRegular,
+	2:  GameModeTraining,
+	4:  GameModeTournament,
+	5:  GameModeQuickTournament,
+	7:  GameModeRating,
+	8:  GameModeMadGames,
+	22: GameModeRealistic,
+	23: GameModeUprising,
+	24: GameModeGravity,
+	25: GameModeSkirmish,
+	26: GameModeBurningGames,
+}
+
+type Replay struct {
+	MapID      int        `json:"mapId" protobuf:"10"`
+	GameMode   gameMode   `json:"gameMode" protobuf:"11"`
+	BattleType battleType `json:"battleType" protobuf:"12"`
+
+	Victory        bool      `json:"victory" protobuf:"15"`
+	BattleTime     time.Time `json:"battleTime" protobuf:"16"`
+	BattleDuration int       `json:"battleDuration" protobuf:"17"`
+
+	Spoils      Spoils `json:"spoils" protobuf:"20"`
+	Protagonist Player `json:"protagonist" protobuf:"21"`
+
+	Teams Teams `json:"teams" protobuf:"22"`
+}
+
+func Prettify(battle battleResults, meta replayMeta) *Replay {
+	var replay Replay
+
+	replay.GameMode = GameModeUnknown
+	if gm, ok := gameModes[int(battle.RoomType)]; ok {
+		replay.GameMode = gm
+	}
+
+	// ModeAndMap
+	replay.BattleType = BattleTypeUnknown
+	if bt, ok := battleTypes[battle.GameMode()]; ok {
+		replay.BattleType = bt
+	}
+
+	replay.MapID = battle.MapID()
+	ts, _ := strconv.ParseInt(meta.BattleStartTime, 10, 64)
+	replay.BattleTime = time.Unix(ts, 0)
+	replay.BattleDuration = int(meta.BattleDuration)
+
+	replay.Spoils = Spoils{
+		Exp:     frame.ValueInt(battle.Author.TotalXP),
+		Credits: frame.ValueInt(battle.Author.TotalCredits),
+		// TODO: Find where mastery is set
+		// MasteryBadge: data.MasteryBadge,
+	}
+
+	var allyTeam uint32
+	players := make(map[int]playerInfo)
+	for _, p := range battle.Players {
+		players[int(p.AccountID)] = p.Info
+		if p.AccountID == battle.Author.AccountID {
+			allyTeam = p.Info.Team
+		}
+	}
+	for _, result := range battle.PlayerResults {
+		info, ok := players[int(result.Info.AccountID)]
+		if !ok {
+			continue
+		}
+		player := playerFromData(battle, info, result.Info)
+		if player.ID == fmt.Sprint(battle.Author.AccountID) {
+			replay.Protagonist = player
+		}
+		if info.Team == allyTeam {
+			replay.Teams.Allies = append(replay.Teams.Allies, player)
+		} else {
+			replay.Teams.Enemies = append(replay.Teams.Enemies, player)
+		}
+	}
+
+	replay.Victory = allyTeam == battle.WinnerTeam
+	return &replay
+}
+
+type Teams struct {
+	Allies  []Player `json:"allies" protobuf:"10,repeated"`
+	Enemies []Player `json:"enemies" protobuf:"11,repeated"`
+}
+
+type Player struct {
+	ID       string `json:"id" protobuf:"10"`
+	ClanID   string `json:"clanId" protobuf:"11"`
+	ClanTag  string `json:"clanTag" protobuf:"12"`
+	Nickname string `json:"nickname" protobuf:"13"`
+
+	VehicleID string         `json:"vehicleId" protobuf:"15"`
+	PlatoonID *int           `json:"platoonId" protobuf:"16"`
+	TimeAlive frame.ValueInt `json:"timeAlive" protobuf:"17"`
+	HPLeft    frame.ValueInt `json:"hpLeft" protobuf:"18"`
+
+	Performance  Performance    `json:"performance" protobuf:"20"`
+	Achievements map[string]int `json:"achievements" protobuf:"21"`
+}
+
+func playerFromData(battle battleResults, info playerInfo, result playerResultsInfo) Player {
+	var player Player
+	player.ID = fmt.Sprint(result.AccountID)
+	player.Nickname = info.Nickname
+	player.VehicleID = fmt.Sprint(result.TankID)
+	if info.ClanTag != nil && info.ClanID != nil {
+		player.ClanTag = *info.ClanTag
+		player.ClanID = fmt.Sprint(*info.ClanID)
+	}
+
+	if info.PlatoonID != nil {
+		id := int(*info.PlatoonID)
+		player.PlatoonID = &id
+	}
+
+	var stats frame.StatsFrame
+	stats.Battles = 1
+	if info.Team == battle.WinnerTeam {
+		stats.BattlesWon = 1
+	}
+
+	if result.HitpointsLeft != nil {
+		player.HPLeft = frame.ValueInt(*result.HitpointsLeft)
+	}
+	if player.HPLeft > 0 {
+		stats.BattlesSurvived = 1
+	}
+
+	stats.DamageDealt = frame.ValueInt(result.DamageDealt)
+	stats.DamageReceived = frame.ValueInt(result.DamageReceived)
+	stats.ShotsHit = frame.ValueInt(result.ShotsHit)
+	stats.ShotsFired = frame.ValueInt(result.ShotsFired)
+	stats.Frags = frame.ValueInt(result.EnemiesDestroyed)
+	stats.MaxFrags = frame.ValueInt(stats.Frags)
+	stats.EnemiesSpotted = frame.ValueInt(result.DamageAssisted)
+	// TODO: Parse this from replays, it seems that those fields are only present when a battle was won by cap
+	// frame.CapturePoints =
+	// frame.DroppedCapturePoints =
+	player.Performance = Performance{
+		DamageBlocked:    frame.ValueInt(result.DamageBlocked),
+		DamageReceived:   frame.ValueInt(result.DamageReceived),
+		DamageAssisted:   frame.ValueInt(result.DamageAssisted + result.DamageAssistedTrack),
+		DistanceTraveled: frame.ValueInt(result.DistanceTraveled),
+		StatsFrame:       stats,
+	}
+
+	// player.Achievements = make(map[int]int)
+	// for _, a := range append(result.Achievements, result.AchievementsOther...) {
+	// 	player.Achievements[int(a.Tag)] = int(a.Value)
+	// }
+
+	return player
+}
+
+type Performance struct {
+	DamageBlocked         frame.ValueInt `json:"damageBlocked" protobuf:"10"`
+	DamageReceived        frame.ValueInt `json:"damageReceived" protobuf:"11"`
+	DamageAssisted        frame.ValueInt `json:"damageAssisted" protobuf:"12"`
+	DistanceTraveled      frame.ValueInt `json:"distanceTraveled" protobuf:"13"`
+	SupremacyPointsEarned frame.ValueInt `json:"supremacyPointsEarned" protobuf:"14"`
+	SupremacyPointsStolen frame.ValueInt `json:"supremacyPointsStolen" protobuf:"15"`
+
+	frame.StatsFrame `json:",inline" protobuf:"20"`
+}
+
+type Spoils struct {
+	Exp          frame.ValueInt `json:"exp" protobuf:"10"`
+	Credits      frame.ValueInt `json:"credits" protobuf:"11"`
+	MasteryBadge int            `json:"masteryBadge" protobuf:"12"`
+}
diff --git a/internal/stats/fetch/replay/results.go b/internal/stats/fetch/replay/results.go
new file mode 100644
index 00000000..92d963fa
--- /dev/null
+++ b/internal/stats/fetch/replay/results.go
@@ -0,0 +1,181 @@
+package replay
+
+import (
+	"io"
+
+	"github.com/nlpodyssey/gopickle/pickle"
+	"github.com/nlpodyssey/gopickle/types"
+	"go.dedis.ch/protobuf"
+)
+
+type battleResults struct {
+	ModeAndMap uint32 `protobuf:"1" json:"modeAndMap"`
+	Timestamp  uint64 `protobuf:"2" json:"timestamp"`
+	WinnerTeam uint32 `protobuf:"3" json:"winnerTeam"`
+
+	EnemiesDestroyed uint32 `protobuf:"4" json:"enemiesKilled"`
+	TimeAlive        uint32 `protobuf:"5" json:"timeAlive"`
+
+	Author   author `protobuf:"8,required" json:"protagonist"`
+	RoomType uint32 `protobuf:"9" json:"roomType"`
+
+	RepairCost uint32 `protobuf:"136" json:"repairCost"`
+	FreeXP     uint32 `protobuf:"137" json:"freeXp"`
+
+	TotalXP     uint32 `protobuf:"181" json:"totalXp"`
+	BaseFreeXP  uint32 `protobuf:"182" json:"freeXpBase"`
+	CreditsBase uint32 `protobuf:"183" json:"creditsBase"`
+
+	// 185 {
+	// 	1: "None"
+	// 	2 {
+	// 		27 {
+	// 			1: 2020
+	// 			2: 63
+	// 		}
+	// 	}
+	// }
+	// 185 {
+	// 	1: "booster"
+	// 	2 {
+	// 		1: 21959
+	// 		2: 10
+	// 	}
+	// }
+
+	Players       []player        `protobuf:"201,repeated" json:"players"`
+	PlayerResults []playerResults `protobuf:"301,repeated" json:"playerResults"`
+}
+
+func (result *battleResults) MapID() int {
+	return int(result.ModeAndMap & 0xFFFF)
+}
+
+func (result *battleResults) GameMode() int {
+	/// - `0x0xxxx` is «encounter»
+	/// - `0x1xxxx` flag is «supremacy»
+	return int((result.ModeAndMap >> 16) & 0xFF)
+}
+
+type player struct {
+	AccountID uint32     `protobuf:"1" json:"accountId"`
+	Info      playerInfo `protobuf:"2,required" json:"info"`
+}
+
+type playerInfo struct {
+	Nickname  string  `protobuf:"1" json:"nickname"`
+	PlatoonID *uint32 `protobuf:"2,optional" json:"platoon"`
+	Team      uint32  `protobuf:"3" json:"team"`
+	ClanID    *uint32 `protobuf:"4,optional" json:"clanId"`
+	ClanTag   *string `protobuf:"5,optional" json:"clanTag"`
+	// 6: "\000\000"
+	Avatar avatar `protobuf:"7,required" json:"avatar"`
+	// 8: 463102
+	Rank *uint32 `protobuf:"9,optional" json:"rank"`
+}
+
+type playerResults struct {
+	ResultID uint32            `protobuf:"1" json:"id"`
+	Info     playerResultsInfo `protobuf:"2,required" json:"result"`
+}
+
+type playerResultsInfo struct {
+	HitpointsLeft       *uint64 `protobuf:"1,optional" json:"hitpointsLeft"`
+	CreditsEarned       uint32  `protobuf:"2" json:"creditsEarned"`
+	BaseXP              uint32  `protobuf:"3" json:"baseXp"`
+	ShotsFired          uint32  `protobuf:"4" json:"shotsFired"`
+	ShotsHit            uint32  `protobuf:"5" json:"shotsHit"`
+	ShotsPenetrated     uint32  `protobuf:"7" json:"shotsPenetrated"`
+	DamageDealt         uint32  `protobuf:"8" json:"damageDealt"`
+	DamageAssisted      uint32  `protobuf:"9" json:"damageAssisted"`
+	DamageAssistedTrack uint32  `protobuf:"10" json:"damageAssistedTrack"`
+	DamageReceived      uint32  `protobuf:"11" json:"damageReceived"`
+	HitsReceived        uint32  `protobuf:"12" json:"hitsReceived"`
+	HitsBlocked         uint32  `protobuf:"13" json:"hitsBlocked"`
+	HitsPenetrated      uint32  `protobuf:"15" json:"hitsPenetrated"`
+	EnemiesSpotted      uint32  `protobuf:"16" json:"enemiesSpotted"`
+	EnemiesDamaged      uint32  `protobuf:"17" json:"enemiesDamaged"`
+	EnemiesDestroyed    uint32  `protobuf:"18" json:"enemiesDestroyed"`
+	DistanceTraveled    uint32  `protobuf:"23" json:"distanceTraveled"`
+	TimeAlive           uint32  `protobuf:"24" json:"timeAlive"`
+	KilledByAccountID   uint32  `protobuf:"25" json:"killedBy"`
+	//  26: "\323\003"
+	Achievements          []Achievement `protobuf:"27,repeated" json:"achievements"`
+	AchievementsOther     []Achievement `protobuf:"28,repeated" json:"achievementsOther"`
+	DamageXP              uint32        `protobuf:"29" json:"damageXp"`
+	AssistXP              uint32        `protobuf:"30" json:"assistXp"`
+	TeamBonusXP           uint32        `protobuf:"31" json:"teamBonusXp"`
+	SupremacyPointsEarned uint32        `protobuf:"32" json:"supremacyPointsEarned"`
+	SupremacyPointsStolen uint32        `protobuf:"33" json:"supremacyPointsStolen"`
+
+	AccountID uint32 `protobuf:"101" json:"accountId"`
+	Team      uint32 `protobuf:"102" json:"team"`
+	TankID    uint32 `protobuf:"103" json:"tankId"`
+	//  105: 18446744073709551615
+	// 	106: 80120
+	MMRating      float32 `protobuf:"107" json:"mmRating"`
+	DamageBlocked uint32  `protobuf:"117" json:"damageBlocked"`
+}
+
+func (results *playerResultsInfo) DisplayRating() float32 {
+	return results.MMRating*10 + 3000
+}
+
+type Achievement struct {
+	Tag   uint32 `protobuf:"1" json:"tag"`
+	Value uint32 `protobuf:"2" json:"value"`
+}
+
+const PlayerAfkHitpointsLeft = -2
+
+type author struct {
+	// The field is PlayerAfkHitpointsLeft if the player is auto-destroyed by inactivity.
+	HitpointsLeft   int32  `protobuf:"1" json:"hitpointsLeft"`
+	TotalCredits    uint32 `protobuf:"2" json:"creditsEarned"`
+	TotalXP         uint32 `protobuf:"3" json:"xpEarned"`
+	ShotsFired      uint32 `protobuf:"4" json:"shotsFired"`
+	ShotsHit        uint32 `protobuf:"5" json:"shotsHit"`
+	ShotsSplashHit  uint32 `protobuf:"6" json:"shotsSplashHit"`
+	ShotsPenetrated uint32 `protobuf:"7" json:"shotsPenetrated"`
+	DamageDealt     uint32 `protobuf:"8" json:"damageDealt"`
+
+	AccountID uint32 `protobuf:"101" json:"accountId"`
+	Team      uint32 `protobuf:"102" json:"team"`
+}
+
+type avatar struct {
+	// 1: 312062 id?
+	Info avatarInfo `protobuf:"2,required" json:"data"`
+}
+
+type avatarInfo struct {
+	// 1: 312062 id?
+	GfxURL  string `protobuf:"2" json:"gfxUrl"`
+	Gfx2URL string `protobuf:"3" json:"gfx2Url"`
+	Kind    string `protobuf:"4" json:"kind"`
+}
+
+// Un-pickled `battle_results.dat`.
+//
+// # `battle_results.dat` structure
+//
+// Entire file is a [pickled](https://docs.python.org/3/library/pickle.html) 2-tuple:
+//
+// - Arena unique ID
+// - Battle results serialized with [Protocol Buffers](https://developers.google.com/protocol-buffers)
+func decodeBattleResults(reader io.Reader) (*battleResults, error) {
+	unpickler := pickle.NewUnpickler(reader)
+	data, err := unpickler.Load()
+	if err != nil {
+		return nil, err
+	}
+
+	if tuple, ok := data.(*types.Tuple); ok && tuple.Len() == 2 {
+		if data, ok := tuple.Get(1).(string); ok {
+			var result battleResults
+			return &result, protobuf.Decode([]byte(data), &result)
+		}
+		return nil, ErrInvalidReplayFile
+	}
+	return nil, ErrInvalidReplayFile
+}
diff --git a/internal/stats/fetch/replay/unpack.go b/internal/stats/fetch/replay/unpack.go
new file mode 100644
index 00000000..65903a6d
--- /dev/null
+++ b/internal/stats/fetch/replay/unpack.go
@@ -0,0 +1,102 @@
+package replay
+
+import (
+	"archive/zip"
+	"bytes"
+	"encoding/json"
+	"io"
+	"net/http"
+	"strconv"
+
+	"github.com/rs/zerolog/log"
+)
+
+func UnpackRemote(link string) (*UnpackedReplay, error) {
+	resp, err := http.DefaultClient.Get(link)
+	if err != nil {
+		return nil, ErrInvalidReplayFile
+	}
+	defer resp.Body.Close()
+
+	// Convert 10 MB to bytes
+	const maxFileSize = 10 * 1024 * 1024
+
+	// Check the Content-Length header
+	contentLengthStr := resp.Header.Get("Content-Length")
+	if contentLengthStr == "" {
+		log.Warn().Msg("Content-Length header is missing on remote replay file")
+		return nil, ErrInvalidReplayFile
+	}
+
+	contentLength, err := strconv.ParseInt(contentLengthStr, 10, 64)
+	if err != nil {
+		return nil, err
+	}
+	if contentLength > maxFileSize {
+		return nil, ErrInvalidReplayFile
+	}
+
+	data, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	return Unpack(bytes.NewReader(data), contentLength)
+}
+
+// World of Tanks Blitz replay.
+//
+// # Replay structure
+//
+// `*.wotbreplay` is a ZIP-archive containing:
+//
+// - `battle_results.dat`
+// - `meta.json`
+// - `data.wotreplay`
+
+type UnpackedReplay struct {
+	BattleResult battleResults `json:"results"`
+	Meta         replayMeta    `json:"meta"`
+}
+
+func Unpack(file io.ReaderAt, size int64) (*UnpackedReplay, error) {
+	archive, err := newZipFromReader(file, size)
+	if err != nil {
+		return nil, err
+	}
+	if len(archive.File) < 3 {
+		return nil, ErrInvalidReplayFile
+	}
+
+	var data UnpackedReplay
+
+	resultsDat, err := archive.Open("battle_results.dat")
+	if err != nil {
+		return nil, ErrInvalidReplayFile
+	}
+	result, err := decodeBattleResults(resultsDat)
+	if err != nil {
+		return nil, ErrInvalidReplayFile
+	}
+	data.BattleResult = *result
+
+	meta, err := archive.Open("meta.json")
+	if err != nil {
+		return nil, ErrInvalidReplayFile
+	}
+	metaBytes, err := io.ReadAll(meta)
+	if err != nil {
+		return nil, err
+	}
+
+	return &data, json.Unmarshal(metaBytes, &data.Meta)
+}
+
+func newZipFromReader(file io.ReaderAt, size int64) (*zip.Reader, error) {
+	reader, err := zip.NewReader(file, size)
+	if err != nil {
+		return nil, err
+	}
+
+	return reader, nil
+}
diff --git a/internal/stats/prepare/replay/replay.go.todo b/internal/stats/prepare/replay/replay.go.todo
deleted file mode 100644
index 3f255378..00000000
--- a/internal/stats/prepare/replay/replay.go.todo
+++ /dev/null
@@ -1,224 +0,0 @@
-package prepare
-
-import (
-	"time"
-)
-
-type battleType struct {
-	ID  int    `json:"id" protobuf:"10"`
-	Tag string `json:"tag" protobuf:"11"`
-}
-
-func (bt battleType) String() string {
-	return bt.Tag
-}
-
-var (
-	BattleTypeUnknown   = battleType{-1, "battle_type_unknown"}
-	BattleTypeRandom    = battleType{0, "battle_type_regular"}
-	BattleTypeSupremacy = battleType{1, "battle_type_supremacy"}
-)
-
-var battleTypes = map[int]battleType{
-	0: BattleTypeRandom,
-	1: BattleTypeSupremacy,
-}
-
-type gameMode struct {
-	ID      int    `json:"id" protobuf:"15"`
-	Name    string `json:"name" protobuf:"16"`
-	Special bool   `json:"special" protobuf:"17"` // Signifies if WN8 should be calculated
-}
-
-func (gm gameMode) String() string {
-	return gm.Name
-}
-
-var (
-	GameModeUnknown         = gameMode{-1, "game_mode_unknown", false}
-	GameModeRegular         = gameMode{1, "game_mode_regular", false}
-	GameModeTraining        = gameMode{2, "game_mode_training", true}
-	GameModeTournament      = gameMode{4, "game_mode_tournament", true}
-	GameModeQuickTournament = gameMode{5, "game_mode_quick_tournament", true}
-	GameModeRating          = gameMode{7, "game_mode_rating", false}
-	GameModeMadGames        = gameMode{8, "game_mode_mad_games", true}
-	GameModeRealistic       = gameMode{22, "game_mode_realistic", false}
-	GameModeUprising        = gameMode{23, "game_mode_uprising", true}
-	GameModeGravity         = gameMode{24, "game_mode_gravity", true}
-	GameModeSkirmish        = gameMode{25, "game_mode_skirmish", false}
-	GameModeBurningGames    = gameMode{26, "game_mode_burning_games", true}
-)
-
-var gameModes = map[int]gameMode{
-	1:  GameModeRegular,
-	2:  GameModeTraining,
-	4:  GameModeTournament,
-	5:  GameModeQuickTournament,
-	7:  GameModeRating,
-	8:  GameModeMadGames,
-	22: GameModeRealistic,
-	23: GameModeUprising,
-	24: GameModeGravity,
-	25: GameModeSkirmish,
-	26: GameModeBurningGames,
-}
-
-type Replay struct {
-	MapID      int        `json:"mapId" protobuf:"10"`
-	GameMode   gameMode   `json:"gameMode" protobuf:"11"`
-	BattleType battleType `json:"battleType" protobuf:"12"`
-
-	Victory        bool      `json:"victory" protobuf:"15"`
-	BattleTime     time.Time `json:"battleTime" protobuf:"16"`
-	BattleDuration int       `json:"battleDuration" protobuf:"17"`
-
-	Spoils      Spoils `json:"spoils" protobuf:"20"`
-	Protagonist Player `json:"protagonist" protobuf:"21"`
-
-	Teams Teams `json:"teams" protobuf:"22"`
-}
-
-// func Prettify(battle battleResults, meta replayMeta) *Replay {
-// 	var replay Replay
-
-// 	replay.GameMode = GameModeUnknown
-// 	if gm, ok := gameModes[int(battle.RoomType)]; ok {
-// 		replay.GameMode = gm
-// 	}
-
-// 	// ModeAndMap
-// 	replay.BattleType = BattleTypeUnknown
-// 	if bt, ok := battleTypes[battle.GameMode()]; ok {
-// 		replay.BattleType = bt
-// 	}
-
-// 	replay.MapID = battle.MapID()
-// 	ts, _ := strconv.ParseInt(meta.BattleStartTime, 10, 64)
-// 	replay.BattleTime = time.Unix(ts, 0)
-// 	replay.BattleDuration = int(meta.BattleDuration)
-
-// 	replay.Spoils = Spoils{
-// 		Exp:     int(battle.Author.TotalXP),
-// 		Credits: int(battle.Author.TotalCredits),
-// 		// TODO: Find where mastery is set
-// 		// MasteryBadge: data.MasteryBadge,
-// 	}
-
-// 	var allyTeam uint32
-// 	players := make(map[int]playerInfo)
-// 	for _, p := range battle.Players {
-// 		players[int(p.AccountID)] = p.Info
-// 		if p.AccountID == battle.Author.AccountID {
-// 			allyTeam = p.Info.Team
-// 		}
-// 	}
-// 	for _, result := range battle.PlayerResults {
-// 		info, ok := players[int(result.Info.AccountID)]
-// 		if !ok {
-// 			continue
-// 		}
-// 		player := playerFromData(battle, info, result.Info)
-// 		if player.ID == int(battle.Author.AccountID) {
-// 			replay.Protagonist = player
-// 		}
-// 		if info.Team == allyTeam {
-// 			replay.Teams.Allies = append(replay.Teams.Allies, player)
-// 		} else {
-// 			replay.Teams.Enemies = append(replay.Teams.Enemies, player)
-// 		}
-// 	}
-
-// 	replay.Victory = allyTeam == battle.WinnerTeam
-// 	return &replay
-// }
-
-type Teams struct {
-	Allies  []Player `json:"allies" protobuf:"10,repeated"`
-	Enemies []Player `json:"enemies" protobuf:"11,repeated"`
-}
-
-type Player struct {
-	ID       int    `json:"id" protobuf:"10"`
-	ClanID   int    `json:"clanId" protobuf:"11"`
-	ClanTag  string `json:"clanTag" protobuf:"12"`
-	Nickname string `json:"nickname" protobuf:"13"`
-
-	VehicleID int      `json:"vehicleId" protobuf:"15"`
-	PlatoonID *int     `json:"platoonId" protobuf:"16"`
-	TimeAlive ValueInt `json:"timeAlive" protobuf:"17"`
-	HPLeft    ValueInt `json:"hpLeft" protobuf:"18"`
-
-	Performance Performance `json:"performance" protobuf:"20"`
-	// Achievements map[int]int `json:"achievements" protobuf:"21"`
-}
-
-// func playerFromData(battle battleResults, info playerInfo, result playerResultsInfo) Player {
-// 	var player Player
-// 	player.ID = int(result.AccountID)
-// 	player.Nickname = info.Nickname
-// 	player.VehicleID = int(result.TankID)
-// 	if info.ClanTag != nil && info.ClanID != nil {
-// 		player.ClanTag = *info.ClanTag
-// 		player.ClanID = int(*info.ClanID)
-// 	}
-
-// 	if info.PlatoonID != nil {
-// 		id := int(*info.PlatoonID)
-// 		player.PlatoonID = &id
-// 	}
-
-// 	var frame stats.ReducedStatsFrame
-// 	frame.Battles = 1
-// 	if info.Team == battle.WinnerTeam {
-// 		frame.BattlesWon = 1
-// 	}
-
-// 	if result.HitpointsLeft != nil {
-// 		player.HPLeft = int(*result.HitpointsLeft)
-// 	}
-// 	if player.HPLeft > 0 {
-// 		frame.BattlesSurvived = 1
-// 	}
-
-// 	frame.DamageDealt = int(result.DamageDealt)
-// 	frame.DamageReceived = int(result.DamageReceived)
-// 	frame.ShotsHit = int(result.ShotsHit)
-// 	frame.ShotsFired = int(result.ShotsFired)
-// 	frame.Frags = int(result.EnemiesDestroyed)
-// 	frame.MaxFrags = frame.Frags
-// 	frame.EnemiesSpotted = int(result.DamageAssisted)
-// 	// TODO: Parse this from replays, it seems that those fields are only present when a battle was won by cap
-// 	// frame.CapturePoints =
-// 	// frame.DroppedCapturePoints =
-// 	player.Performance = Performance{
-// 		DamageBlocked:     int(result.DamageBlocked),
-// 		DamageReceived:    int(result.DamageReceived),
-// 		DamageAssisted:    int(result.DamageAssisted + result.DamageAssistedTrack),
-// 		DistanceTraveled:  int(result.DistanceTraveled),
-// 		ReducedStatsFrame: frame,
-// 	}
-
-// 	player.Achievements = make(map[int]int)
-// 	for _, a := range append(result.Achievements, result.AchievementsOther...) {
-// 		player.Achievements[int(a.Tag)] = int(a.Value)
-// 	}
-
-// 	return player
-// }
-
-type Performance struct {
-	DamageBlocked         ValueInt `json:"damageBlocked" protobuf:"10"`
-	DamageReceived        ValueInt `json:"damageReceived" protobuf:"11"`
-	DamageAssisted        ValueInt `json:"damageAssisted" protobuf:"12"`
-	DistanceTraveled      ValueInt `json:"distanceTraveled" protobuf:"13"`
-	SupremacyPointsEarned ValueInt `json:"supremacyPointsEarned" protobuf:"14"`
-	SupremacyPointsStolen ValueInt `json:"supremacyPointsStolen" protobuf:"15"`
-
-	StatsFrame `json:",inline" protobuf:"20"`
-}
-
-type Spoils struct {
-	Exp          ValueInt `json:"exp" protobuf:"10"`
-	Credits      ValueInt `json:"credits" protobuf:"11"`
-	MasteryBadge int      `json:"masteryBadge" protobuf:"12"`
-}
diff --git a/internal/stats/render/period/cards.go b/internal/stats/render/period/cards.go
index 787a7817..7c23d2f1 100644
--- a/internal/stats/render/period/cards.go
+++ b/internal/stats/render/period/cards.go
@@ -28,7 +28,7 @@ func generateCards(stats fetch.AccountStatsOverPeriod, cards period.Cards, subs
 	{
 		{
 			titleStyle := common.DefaultPlayerTitleStyle(titleCardStyle(cardWidth))
-			clanSize := common.MeasureString(stats.Clan.Tag, *titleStyle.ClanTag.Font)
+			clanSize := common.MeasureString(stats.Account.ClanTag, *titleStyle.ClanTag.Font)
 			nameSize := common.MeasureString(stats.Account.Nickname, *titleStyle.Nickname.Font)
 			cardWidth = common.Max(cardWidth, titleStyle.TotalPaddingAndGaps()+nameSize.TotalWidth+clanSize.TotalWidth*2)
 		}
@@ -118,7 +118,7 @@ func generateCards(stats fetch.AccountStatsOverPeriod, cards period.Cards, subs
 	}
 
 	// Player Title card
-	segments.AddContent(common.NewPlayerTitleCard(common.DefaultPlayerTitleStyle(titleCardStyle(cardWidth)), stats.Account.Nickname, stats.Clan.Tag, subs))
+	segments.AddContent(common.NewPlayerTitleCard(common.DefaultPlayerTitleStyle(titleCardStyle(cardWidth)), stats.Account.Nickname, stats.Account.ClanTag, subs))
 
 	// Overview Card
 	{
diff --git a/internal/stats/render/replay/blocks.go.todo b/internal/stats/render/replay/blocks.go.todo
new file mode 100644
index 00000000..ab08e47b
--- /dev/null
+++ b/internal/stats/render/replay/blocks.go.todo
@@ -0,0 +1,108 @@
+package replay
+
+import (
+	"fmt"
+	"math"
+
+	"github.com/cufee/aftermath-core/dataprep"
+	"github.com/cufee/aftermath-core/dataprep/replay"
+	prepare "github.com/cufee/aftermath/internal/stats/prepare/replay"
+	"github.com/cufee/aftermath/internal/stats/render/common"
+)
+
+func newTitleBlock(replay *prepare.Replay, width float64, printer func(string) string) common.Block {
+	var titleBlocks []common.Block
+	if replay.Victory {
+		titleBlocks = append(titleBlocks, common.NewTextContent(common.Style{
+			Font:      &common.FontLarge,
+			FontColor: common.TextPrimary,
+		}, printer("label_victory")))
+	} else {
+		titleBlocks = append(titleBlocks, common.NewTextContent(common.Style{
+			Font:      &common.FontLarge,
+			FontColor: common.TextPrimary,
+		}, printer("label_defeat")))
+	}
+
+	titleBlocks = append(titleBlocks, common.NewTextContent(common.Style{
+		Font:      &common.FontLarge,
+		FontColor: common.TextSecondary,
+	}, fmt.Sprintf(" - %s", printer("label_"+replay.BattleType.String()))))
+
+	style := defaultCardStyle(width, 75)
+	style.JustifyContent = common.JustifyContentCenter
+	style.Direction = common.DirectionHorizontal
+	style.AlignItems = common.AlignItemsCenter
+
+	return common.NewBlocksContent(style, titleBlocks...)
+}
+
+func newPlayerCard(style common.Style, sizes map[dataprep.Tag]float64, card replay.Card, player parse.Player, ally, protagonist bool) common.Block {
+	hpBarValue := float64(player.HPLeft) / float64((player.Performance.DamageReceived + player.HPLeft))
+	if hpBarValue > 0 {
+		hpBarValue = math.Max(hpBarValue, 0.2)
+	}
+
+	var hpBar common.Block
+	if ally {
+		hpBar = newProgressBar(60, int(hpBarValue*100), progressDirectionVertical, hpBarColorAllies)
+	} else {
+		hpBar = newProgressBar(60, int(hpBarValue*100), progressDirectionVertical, hpBarColorEnemies)
+	}
+
+	vehicleColor := common.TextPrimary
+	if player.HPLeft <= 0 {
+		vehicleColor = common.TextSecondary
+	}
+
+	leftBlock := common.NewBlocksContent(common.Style{
+		Direction:  common.DirectionHorizontal,
+		AlignItems: common.AlignItemsCenter,
+		Gap:        10,
+		Height:     80,
+		// Debug:      true,
+	}, hpBar, common.NewBlocksContent(common.Style{Direction: common.DirectionVertical},
+		common.NewTextContent(common.Style{Font: &common.FontLarge, FontColor: vehicleColor}, card.Title),
+		playerNameBlock(player, protagonist),
+	))
+
+	var rightBlocks []common.Block
+	for _, block := range card.Blocks {
+		rightBlocks = append(rightBlocks, statsBlockToBlock(block, sizes[block.Tag]))
+	}
+	rightBlock := common.NewBlocksContent(common.Style{
+		JustifyContent: common.JustifyContentCenter,
+		AlignItems:     common.AlignItemsCenter,
+		Gap:            10,
+		// Debug: true,
+	}, rightBlocks...)
+
+	style.Direction = common.DirectionHorizontal
+	style.AlignItems = common.AlignItemsCenter
+	style.JustifyContent = common.JustifyContentSpaceBetween
+	// style.Debug = true
+
+	return common.NewBlocksContent(style, leftBlock, rightBlock)
+}
+
+func playerNameBlock(player prepare.Player, protagonist bool) common.Block {
+	nameColor := common.TextSecondary
+	if protagonist {
+		nameColor = protagonistColor
+	}
+
+	var nameBlocks []common.Block
+	nameBlocks = append(nameBlocks, common.NewTextContent(common.Style{
+		Font:      &common.FontLarge,
+		FontColor: nameColor,
+		// Debug:     true,
+	}, player.Nickname))
+	if player.ClanTag != "" {
+		nameBlocks = append(nameBlocks, common.NewTextContent(common.Style{
+			FontColor: common.TextSecondary,
+			Font:      &common.FontLarge,
+			// Debug:     true,
+		}, fmt.Sprintf("[%s]", player.ClanTag)))
+	}
+	return common.NewBlocksContent(common.Style{Direction: common.DirectionHorizontal, Gap: 5, AlignItems: common.AlignItemsCenter}, nameBlocks...)
+}
diff --git a/internal/stats/render/replay/cards.go.todo b/internal/stats/render/replay/cards.go.todo
new file mode 100644
index 00000000..277b3384
--- /dev/null
+++ b/internal/stats/render/replay/cards.go.todo
@@ -0,0 +1,90 @@
+package replay
+
+import (
+	"fmt"
+	"image"
+
+	"github.com/cufee/aftermath-core/dataprep"
+	"github.com/cufee/aftermath-core/dataprep/replay"
+	"golang.org/x/text/language"
+)
+
+// Tank Name 							// WN8 Winrate Damage Blocker Assisted Kills
+// Player Name [Tag]
+
+type ReplayData struct {
+	Cards  replay.Cards
+	Replay *parse.Replay
+}
+
+type RenderOptions struct {
+	Locale language.Tag
+}
+
+func RenderReplayImage(data ReplayData, opts RenderOptions) (image.Image, error) {
+	var alliesBlocks, enemiesBlocks []render.Block
+
+	printer := localization.GetPrinter(opts.Locale)
+
+	var playerNameWidth float64
+	statsSizes := make(map[dataprep.Tag]float64)
+	for _, card := range append(data.Cards.Allies, data.Cards.Enemies...) {
+		// Measure player name and tag or vehicle name
+		name := card.Meta.Player.Nickname
+		if card.Meta.Player.ClanTag != "" {
+			name += fmt.Sprintf(" [%s]", card.Meta.Player.ClanTag)
+		}
+		nameSize := render.MeasureString(name, render.FontLarge)
+		tankSize := render.MeasureString(card.Title, render.FontLarge)
+		size := nameSize
+		if tankSize.TotalWidth > nameSize.TotalWidth {
+			size = tankSize
+		}
+		if size.TotalWidth > playerNameWidth {
+			playerNameWidth = size.TotalWidth
+		}
+
+		// Measure stats value and label
+		for _, block := range card.Blocks {
+			valueSize := render.MeasureString(block.Value.String, render.FontLarge)
+			labelSize := render.MeasureString(block.Label, render.FontSmall)
+			w := valueSize.TotalWidth
+			if labelSize.TotalWidth > valueSize.TotalWidth {
+				w = labelSize.TotalWidth
+			}
+			if w > statsSizes[block.Tag] {
+				statsSizes[block.Tag] = w
+			}
+		}
+	}
+
+	var totalStatsWidth float64
+	for _, width := range statsSizes {
+		totalStatsWidth += width
+	}
+
+	playerStatsCardStyle := defaultCardStyle(playerNameWidth+(float64(len(statsSizes)*10))+totalStatsWidth, 0)
+	totalCardsWidth := (playerStatsCardStyle.Width * 2) - 30
+
+	// Allies
+	for _, card := range data.Cards.Allies {
+		alliesBlocks = append(alliesBlocks, newPlayerCard(playerStatsCardStyle, statsSizes, card, card.Meta.Player, true, card.Meta.Player.ID == data.Replay.Protagonist.ID))
+	}
+	// Enemies
+	for _, card := range data.Cards.Enemies {
+		enemiesBlocks = append(enemiesBlocks, newPlayerCard(playerStatsCardStyle, statsSizes, card, card.Meta.Player, false, false))
+	}
+
+	// Title Card
+	titleBlock := newTitleBlock(data.Replay, totalCardsWidth, printer)
+
+	// Teams
+	var teamsBlocks []render.Block
+	teamsBlocks = append(teamsBlocks, render.NewBlocksContent(render.Style{Direction: render.DirectionVertical, Gap: 10}, alliesBlocks...))
+	teamsBlocks = append(teamsBlocks, render.NewBlocksContent(render.Style{Direction: render.DirectionVertical, Gap: 10}, enemiesBlocks...))
+	playersBlock := render.NewBlocksContent(render.Style{Direction: render.DirectionHorizontal, Gap: 10}, teamsBlocks...)
+	teamsBlock := render.NewBlocksContent(render.Style{Direction: render.DirectionVertical, Gap: 10}, playersBlock)
+
+	frame := render.NewBlocksContent(frameStyle, titleBlock, teamsBlock)
+	return frame.Render()
+}
diff --git a/internal/stats/render/replay/constants.go.todo b/internal/stats/render/replay/constants.go.todo
new file mode 100644
index 00000000..d7404b02
--- /dev/null
+++ b/internal/stats/render/replay/constants.go.todo
@@ -0,0 +1,27 @@
+package replay
+
+import (
+	"image/color"
+
+	"github.com/cufee/aftermath-core/internal/logic/render"
+)
+
+var (
+	frameStyle = render.Style{Direction: render.DirectionVertical, PaddingX: 30, PaddingY: 30, Gap: 10}
+
+	hpBarColorAllies  = color.RGBA{R: 120, G: 255, B: 120, A: 255}
+	hpBarColorEnemies = color.RGBA{R: 255, G: 120, B: 120, A: 255}
+
+	protagonistColor = color.RGBA{255, 223, 0, 255}
+)
+
+func defaultCardStyle(width, height float64) render.Style {
+	return render.Style{
+		Direction:       render.DirectionVertical,
+		Width:           width + 40,
+		Height:          height,
+		BackgroundColor: render.DefaultCardColor,
+		PaddingX:        10,
+		BorderRadius:    15,
+	}
+}
diff --git a/internal/stats/render/replay/elements.go.todo b/internal/stats/render/replay/elements.go.todo
new file mode 100644
index 00000000..fd8fe1b3
--- /dev/null
+++ b/internal/stats/render/replay/elements.go.todo
@@ -0,0 +1,48 @@
+package replay
+
+import (
+	"image/color"
+
+	"github.com/cufee/aftermath-core/internal/logic/render"
+	"github.com/fogleman/gg"
+)
+
+type progressDirection int
+
+const (
+	progressDirectionHorizontal progressDirection = iota
+	progressDirectionVertical
+)
+
+const progressBarWidth = 8
+
+func newProgressBar(size int, progress int, direction progressDirection, fillColor color.Color) render.Block {
+	var width, height int
+	if direction == progressDirectionHorizontal {
+		width = (size)
+		height = progressBarWidth
+	} else {
+		width = progressBarWidth
+		height = (size)
+	}
+
+	ctx := gg.NewContext((width), (height))
+	ctx.SetColor(color.RGBA{70, 70, 70, 255})
+	ctx.DrawRoundedRectangle(0, 0, float64(width), float64(height), 5)
+	ctx.Fill()
+
+	if progress > 0 {
+		ctx.SetColor(fillColor)
+		if direction == progressDirectionHorizontal {
+			ctx.DrawRoundedRectangle(0, 0, float64(progress)/100*float64(width), float64(height), 5)
+		} else {
+			ctx.DrawRoundedRectangle(0, float64(height)-float64(progress)/100*float64(height), float64(width), float64(progress)/100*float64(height), 5)
+		}
+		ctx.Fill()
+	}
+
+	if direction == progressDirectionHorizontal {
+		return render.NewImageContent(render.Style{Width: float64(size), Height: progressBarWidth}, ctx.Image())
+	}
+	return render.NewImageContent(render.Style{Width: progressBarWidth, Height: float64(size)}, ctx.Image())
+}
diff --git a/internal/stats/render/replay/preset.go.todo b/internal/stats/render/replay/preset.go.todo
new file mode 100644
index 00000000..b8abf9cb
--- /dev/null
+++ b/internal/stats/render/replay/preset.go.todo
@@ -0,0 +1,18 @@
+package replay
+
+import (
+	"github.com/cufee/aftermath-core/dataprep/replay"
+	"github.com/cufee/aftermath-core/internal/logic/render"
+)
+
+func statsBlockToBlock(stats replay.StatsBlock, width float64) render.Block {
+	return render.NewBlocksContent(render.Style{Direction: render.DirectionVertical, AlignItems: render.AlignItemsCenter, Width: width},
+		render.NewTextContent(render.Style{
+			Font:      &render.FontLarge,
+			FontColor: render.TextPrimary,
+		}, stats.Value.String),
+		render.NewTextContent(render.Style{
+			Font:      &render.FontSmall,
+			FontColor: render.TextAlt,
+		}, stats.Label))
+}
diff --git a/main.go b/main.go
index 4351c111..b28ad25e 100644
--- a/main.go
+++ b/main.go
@@ -9,6 +9,8 @@ import (
 	"time"
 
 	"github.com/cufee/aftermath/cmds/core"
+	"github.com/cufee/aftermath/cmds/core/scheduler"
+	"github.com/cufee/aftermath/cmds/core/scheduler/tasks"
 	"github.com/cufee/aftermath/cmds/discord"
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/external/blitzstars"
@@ -34,9 +36,12 @@ func main() {
 	zerolog.SetGlobalLevel(level)
 
 	loadStaticAssets(static)
-
 	coreClient := coreClientFromEnv()
 
+	// this can be adjusted to balance memory usage vs time for cache updates
+	taskQueueConcurrency := 10
+	tasksQueue := tasks.NewQueue(coreClient, tasks.DefaultHandlers(), taskQueueConcurrency)
+	scheduler.StartCronJobs(coreClient, tasksQueue)
 	// scheduler.UpdateAveragesWorker(coreClient)()
 	// scheduler.UpdateGlossaryWorker(coreClient)()
 

From 6beb2eeb47aef274a83f5f4be54093ce44401b94 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 7 Jun 2024 16:54:52 -0400
Subject: [PATCH 018/341] logging body on error

---
 cmds/discord/router/handler.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cmds/discord/router/handler.go b/cmds/discord/router/handler.go
index ff110617..5ac61771 100644
--- a/cmds/discord/router/handler.go
+++ b/cmds/discord/router/handler.go
@@ -262,7 +262,7 @@ func (r *Router) sendInteractionReply(interaction discordgo.Interaction, state *
 
 	err := handler()
 	if err != nil {
-		log.Err(err).Msg("failed to send an interaction response")
+		log.Err(err).Any("data", data).Msg("failed to send an interaction response")
 		return
 	}
 	state.acked = true

From 963a13d3d0ff91217fab45516acce7ba7ddf0b47 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 7 Jun 2024 16:55:59 -0400
Subject: [PATCH 019/341] migrations

---
 .../migration.sql                             | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 internal/database/prisma/migrations/20240607205538_added_cron_task/migration.sql

diff --git a/internal/database/prisma/migrations/20240607205538_added_cron_task/migration.sql b/internal/database/prisma/migrations/20240607205538_added_cron_task/migration.sql
new file mode 100644
index 00000000..c334d540
--- /dev/null
+++ b/internal/database/prisma/migrations/20240607205538_added_cron_task/migration.sql
@@ -0,0 +1,23 @@
+-- CreateTable
+CREATE TABLE "cron_tasks" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    "type" TEXT NOT NULL,
+    "referenceId" TEXT NOT NULL,
+    "targetsEncoded" TEXT NOT NULL,
+    "status" TEXT NOT NULL,
+    "lastRun" DATETIME NOT NULL,
+    "scheduledAfter" DATETIME NOT NULL,
+    "logsEncoded" TEXT NOT NULL DEFAULT '',
+    "dataEncoded" TEXT NOT NULL DEFAULT ''
+);
+
+-- CreateIndex
+CREATE INDEX "cron_tasks_referenceId_idx" ON "cron_tasks"("referenceId");
+
+-- CreateIndex
+CREATE INDEX "cron_tasks_status_referenceId_scheduledAfter_idx" ON "cron_tasks"("status", "referenceId", "scheduledAfter");
+
+-- CreateIndex
+CREATE INDEX "cron_tasks_lastRun_status_idx" ON "cron_tasks"("lastRun", "status");

From 290f56e430f437ee2836d857599cc1ee31712e92 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 7 Jun 2024 17:03:00 -0400
Subject: [PATCH 020/341] more logs

---
 cmds/core/scheduler/glossary.go | 6 ++----
 cmds/discord/router/handler.go  | 2 +-
 2 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/cmds/core/scheduler/glossary.go b/cmds/core/scheduler/glossary.go
index 587d651b..40165014 100644
--- a/cmds/core/scheduler/glossary.go
+++ b/cmds/core/scheduler/glossary.go
@@ -10,16 +10,14 @@ import (
 	"golang.org/x/text/language"
 )
 
-// CurrentTankAverages
-
 func UpdateAveragesWorker(client core.Client) func() {
+	// we just run the logic directly as it's not a heavy task and it doesn't matter if it fails
 	return func() {
 		log.Info().Msg("updating tank averages cache")
 
 		ctx, cancel := context.WithTimeout(context.Background(), time.Minute*1)
 		defer cancel()
 
-		// we just run the logic directly as it's not a heavy task and it doesn't matter if it fails
 		averages, err := client.Fetch().CurrentTankAverages(ctx)
 		if err != nil {
 			log.Err(err).Msg("failed to update averages cache")
@@ -37,8 +35,8 @@ func UpdateAveragesWorker(client core.Client) func() {
 }
 
 func UpdateGlossaryWorker(client core.Client) func() {
+	// we just run the logic directly as it's not a heavy task and it doesn't matter if it fails
 	return func() {
-		// we just run the logic directly as it's not a heavy task and it doesn't matter if it fails
 		log.Info().Msg("updating glossary cache")
 
 		ctx, cancel := context.WithTimeout(context.Background(), time.Second*15)
diff --git a/cmds/discord/router/handler.go b/cmds/discord/router/handler.go
index 5ac61771..223b9a18 100644
--- a/cmds/discord/router/handler.go
+++ b/cmds/discord/router/handler.go
@@ -262,7 +262,7 @@ func (r *Router) sendInteractionReply(interaction discordgo.Interaction, state *
 
 	err := handler()
 	if err != nil {
-		log.Err(err).Any("data", data).Msg("failed to send an interaction response")
+		log.Err(err).Any("data", data).Str("id", interaction.ID).Stack().Msg("failed to send an interaction response")
 		return
 	}
 	state.acked = true

From c8ca0be3ef01dc092978f091266fc3565f4e85d8 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sat, 8 Jun 2024 16:13:48 -0400
Subject: [PATCH 021/341] encoding changes

---
 cmds/core/scheduler/glossary.go        |   2 +-
 cmds/discord/common/context.go         |  21 +-
 cmds/discord/router/handler.go         |   7 +-
 internal/database/prisma/schema.prisma | 308 ++++++++++++++-----------
 internal/database/tasks.go             |  35 +--
 internal/database/users.go             |  14 +-
 internal/database/vehicles.go          |  33 +--
 internal/encoding/gob.go               |  26 +++
 internal/stats/frame/frame.go          |  19 +-
 9 files changed, 271 insertions(+), 194 deletions(-)
 create mode 100644 internal/encoding/gob.go

diff --git a/cmds/core/scheduler/glossary.go b/cmds/core/scheduler/glossary.go
index 40165014..b6961d73 100644
--- a/cmds/core/scheduler/glossary.go
+++ b/cmds/core/scheduler/glossary.go
@@ -56,7 +56,7 @@ func UpdateGlossaryWorker(client core.Client) func() {
 				Type: data.Type,
 				// Class: ,
 				Nation:         data.Nation,
-				LocalizedNames: map[language.Tag]string{language.English: data.Name},
+				LocalizedNames: map[string]string{language.English.String(): data.Name},
 			}
 		}
 
diff --git a/cmds/discord/common/context.go b/cmds/discord/common/context.go
index 96018022..e9e6b74e 100644
--- a/cmds/discord/common/context.go
+++ b/cmds/discord/common/context.go
@@ -75,27 +75,36 @@ func NewContext(ctx context.Context, interaction discordgo.Interaction, respondC
 	return c, nil
 }
 
-func (c *Context) Reply(key string) error {
-	c.respondCh <- discordgo.InteractionResponseData{Content: c.Localize(key)}
+func (c *Context) Message(message string) error {
+	if message == "" {
+		return errors.New("bad reply call with blank message")
+	}
+	c.respondCh <- discordgo.InteractionResponseData{Content: message}
 	return nil
 }
 
+func (c *Context) Reply(key string) error {
+	return c.Message(c.Localize(key))
+}
+
 func (c *Context) Err(err error) error {
 	log.Err(err).Str("interactionId", c.interaction.ID).Msg("error while handling an interaction")
-	return c.Reply(err.Error())
+	return c.Reply("common_error_unhandled_not_reported")
 }
 
 func (c *Context) Error(message string) error {
 	log.Error().Str("message", message).Str("interactionId", c.interaction.ID).Msg("error while handling an interaction")
-	return c.Reply(message)
+	return c.Reply("common_error_unhandled_not_reported")
 }
 
 func (c *Context) ReplyFmt(key string, args ...any) error {
-	c.respondCh <- discordgo.InteractionResponseData{Content: fmt.Sprintf(c.Localize(key), args...)}
-	return nil
+	return c.Message(fmt.Sprintf(c.Localize(key), args...))
 }
 
 func (c *Context) File(r io.Reader, name string) error {
+	if r == nil {
+		return errors.New("bad Context#File call with nil io.Reader")
+	}
 	c.respondCh <- discordgo.InteractionResponseData{Files: []*discordgo.File{{Reader: r, Name: name}}}
 	return nil
 }
diff --git a/cmds/discord/router/handler.go b/cmds/discord/router/handler.go
index 223b9a18..7f11f828 100644
--- a/cmds/discord/router/handler.go
+++ b/cmds/discord/router/handler.go
@@ -162,24 +162,25 @@ func (r *Router) routeInteraction(interaction discordgo.Interaction) (*builder.C
 }
 
 func (r *Router) handleInteraction(ctx context.Context, cancel context.CancelFunc, interaction discordgo.Interaction, command *builder.Command, reply chan<- discordgo.InteractionResponseData) {
-	defer cancel()
 	defer func() {
 		if r := recover(); r != nil {
 			log.Error().Interface("error", r).Msg("interaction handler panic")
+			reply <- discordgo.InteractionResponseData{Content: "Something went really wrong while working on your command. Please try again later."}
 		}
+		cancel()
 	}()
 
 	cCtx, err := common.NewContext(ctx, interaction, reply, r.restClient, r.core)
 	if err != nil {
 		log.Err(err).Msg("failed to create a common.Context for a handler")
-		reply <- discordgo.InteractionResponseData{Content: "Something went wrong while working on your command. Please try again later."}
+		reply <- discordgo.InteractionResponseData{Content: cCtx.Localize("common_error_unhandled_not_reported")}
 		return
 	}
 
 	err = command.Handler(cCtx)
 	if err != nil {
 		log.Err(err).Msg("handler returned an error")
-		reply <- discordgo.InteractionResponseData{Content: "Something went wrong while working on your command. Please try again later."}
+		reply <- discordgo.InteractionResponseData{Content: cCtx.Localize("common_error_unhandled_not_reported")}
 		return
 	}
 }
diff --git a/internal/database/prisma/schema.prisma b/internal/database/prisma/schema.prisma
index beff86c1..3dc63ba0 100644
--- a/internal/database/prisma/schema.prisma
+++ b/internal/database/prisma/schema.prisma
@@ -8,51 +8,79 @@ generator db {
 }
 
 //
-// === App Configuration ===
+// === App Data ===
 //
 
+// Stores some long-lived app condiguration values
+// the values here would typically be set programmatically
 model AppConfiguration {
   id        String   @id @default(cuid())
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt
 
-  valueEncoded    String
-  metadataEncoded String @default("")
+  valueEncoded    Bytes
+  metadataEncoded Bytes @default("")
 
   @@map("app_configurations")
 }
 
-//
-// === Authentification ===
-//
-
-model AuthNonce {
+// A record of a cron task
+model CronTask {
   id        String   @id @default(cuid())
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt
 
-  expiresAt DateTime
+  type           String
+  referenceId    String
+  targetsEncoded Bytes
+
+  status         String
+  lastRun        DateTime
+  scheduledAfter DateTime
 
-  referenceId     String
-  metadataEncoded String @default("")
+  logsEncoded Bytes @default("")
+  dataEncoded Bytes @default("")
 
-  @@index([createdAt])
   @@index([referenceId])
-  @@index([referenceId, expiresAt])
-  @@map("auth_nonces")
+  @@index([status, referenceId, scheduledAfter])
+  @@index([lastRun, status])
+  @@map("cron_tasks")
 }
 
+//
+// === Authentification ===
+//
+
+// // A single-use nonce value generated during the auth flow
+// model AuthNonce {
+//   id        String   @id @default(cuid())
+//   createdAt DateTime @default(now())
+//   updatedAt DateTime @updatedAt
+
+//   expiresAt DateTime
+
+//   referenceId     String
+//   metadataEncoded Bytes  @default("")
+
+//   @@index([createdAt])
+//   @@index([referenceId])
+//   @@index([referenceId, expiresAt])
+//   @@map("auth_nonces")
+//   @@ignore
+// }
+
 //
 // === Users ===
 //
 
+// User record withing the app, primary id is a Discord user ID
 model User {
   id        String   @id
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt
 
-  permissions         String
-  featureFlagsEncoded String @default("")
+  permissions  String
+  featureFlags Int    @default(0)
 
   subscriptions UserSubscription[]
   connections   UserConnection[]
@@ -61,6 +89,7 @@ model User {
   @@map("users")
 }
 
+// A subscription record for a user
 model UserSubscription {
   id        String   @id @default(cuid())
   createdAt DateTime @default(now())
@@ -74,15 +103,11 @@ model UserSubscription {
   referenceId String
   permissions String
 
-  @@index([userId])
-  @@index([expiresAt])
-  @@index([type, userId, expiresAt])
-  @@index([type, userId])
-  @@index([referenceId])
-  @@index([type, referenceId])
   @@map("user_subscriptions")
 }
 
+// A connection to some external service for a user, like Google or Wargaming
+//   - ReferenceID here would be a user id received from the external service
 model UserConnection {
   id        String   @id @default(cuid())
   createdAt DateTime @default(now())
@@ -95,7 +120,7 @@ model UserConnection {
   permissions String
   referenceId String
 
-  metadataEncoded String @default("")
+  metadataEncoded Bytes @default("")
 
   @@index([userId])
   @@index([type, userId])
@@ -104,6 +129,7 @@ model UserConnection {
   @@map("user_connections")
 }
 
+// Content uploaded by a user, such as an image
 model UserContent {
   id        String   @id @default(cuid())
   createdAt DateTime @default(now())
@@ -115,8 +141,8 @@ model UserContent {
   type        String
   referenceId String
 
-  valueEncoded    String
-  metadataEncoded String @default("")
+  valueEncoded    Bytes
+  metadataEncoded Bytes @default("")
 
   @@index([userId])
   @@index([type, userId])
@@ -126,9 +152,10 @@ model UserContent {
 }
 
 //
-// === External Data ===
+// === Wargaming Data ===
 //
 
+// Wargaming Account record
 model Account {
   id        String   @id
   createdAt DateTime @default(now())
@@ -151,73 +178,108 @@ model Account {
   @@map("accounts")
 }
 
+// Wargaming Clan record
+model Clan {
+  id        String   @id
+  createdAt DateTime
+  updatedAt DateTime @updatedAt
+
+  tag      String
+  name     String
+  emblemId String @default("")
+
+  accounts      Account[]
+  membersString String
+
+  recordUpdatedAt DateTime @updatedAt
+
+  @@index([tag])
+  @@map("account_clans")
+}
+
+// A snapshot of account statistics
 model AccountSnapshot {
   id        String   @id @default(cuid())
   createdAt DateTime
-  updatedAt DateTime @updatedAt
 
   type           String
-  accountId      String
-  referenceId    String
   lastBattleTime DateTime
 
-  dataEncoded String
+  accountId   String
+  referenceId String
+
+  frameEncoded Bytes
 
   @@index([createdAt])
-  @@index([type, accountId])
-  @@index([type, accountId, createdAt])
-  @@index([type, accountId, lastBattleTime])
-  @@index([type, referenceId])
-  @@index([type, referenceId, createdAt])
+  @@index([accountId, lastBattleTime])
   @@map("account_snapshots")
 }
 
-model AccountRatingSeasonSnapshot {
+// A snapshot of vehicle statistics on a specific account
+model VehicleSnapshot {
   id        String   @id @default(cuid())
   createdAt DateTime
-  updatedAt DateTime @updatedAt
 
-  seasonId       String
-  accountId      String
-  referenceId    String
+  type           String
   lastBattleTime DateTime
 
-  dataEncoded String
+  accountId   String
+  vehicleId   String
+  referenceId String
+
+  frameEncoded Bytes
 
   @@index([createdAt])
-  @@index([seasonId, accountId])
-  @@index([seasonId, referenceId])
-  @@map("account_rating_season_snapshots")
+  @@index([accountId, vehicleId, lastBattleTime])
+  @@map("vehicle_snapshots")
 }
 
-model Clan {
-  id        String   @id
-  createdAt DateTime
+// A snapshot of all account achievements
+model AchievementsSnapshot {
+  id        String   @id @default(uuid())
+  createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt
 
-  tag      String
-  name     String
-  emblemId String @default("")
-
-  accounts      Account[]
-  membersString String
+  accountId   String
+  referenceId String
 
-  recordUpdatedAt DateTime @updatedAt
+  dataEncoded Bytes
 
-  @@index([tag])
-  @@map("account_clans")
+  @@map("achievements_snapshots")
 }
 
+// // A snapshot of account rating season stats
+// model AccountRatingSeasonSnapshot {
+//   id        String   @id @default(cuid())
+//   createdAt DateTime
+//   updatedAt DateTime @updatedAt
+
+//   seasonId       String
+//   accountId      String
+//   referenceId    String
+//   lastBattleTime DateTime
+
+//   dataEncoded Bytes
+
+//   @@index([createdAt])
+//   @@index([seasonId, accountId])
+//   @@index([seasonId, referenceId])
+//   @@map("account_rating_season_snapshots")
+//   @@ignore // unused atm and may require significant changes
+// }
+
+// A stats frame representing an average player performance on a vehicle
 model VehicleAverage {
   id        String   @id
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt
 
-  dataEncoded String
+  dataEncoded Bytes
 
   @@map("glossary_averages")
 }
 
+// Wargaming Vehicle glossary information
 model Vehicle {
   id        String   @id
   createdAt DateTime @default(now())
@@ -228,104 +290,84 @@ model Vehicle {
   class  String
   nation String
 
-  localizedNamesEncoded String
+  localizedNamesEncoded Bytes
 
   @@map("glossary_vehicles")
 }
 
-model Achievement {
-  id        String   @id @default(uuid())
-  createdAt DateTime @default(now())
-  updatedAt DateTime @updatedAt
+// // Wargaming Achievement glossary information
+// model Achievement {
+//   id        String   @id @default(uuid())
+//   createdAt DateTime @default(now())
+//   updatedAt DateTime @updatedAt
 
-  section String
+//   section String
 
-  dataEncoded String
+//   dataEncoded Bytes
 
-  @@map("glossary_achievements")
-}
+//   @@map("glossary_achievements")
+//   @@ignore
+// }
 
 //
-// === App Data ===
+// === Discord Data ===
 //
 
-model UserInteraction {
-  id        String   @id @default(cuid())
-  createdAt DateTime @default(now())
-  updatedAt DateTime @updatedAt
-
-  type        String
-  userId      String
-  referenceId String
-
-  dataEncoded     String
-  metadataEncoded String @default("")
-
-  @@index([type])
-  @@index([userId])
-  @@index([userId, type])
-  @@index([referenceId])
-  @@index([referenceId, type])
-  @@map("user_interactions")
-}
-
-model DiscordBotLiveSession {
-  id        String   @id @default(cuid())
-  createdAt DateTime @default(now())
-  updatedAt DateTime @updatedAt
+// // A log of a user interaction with the bot
+// model DiscordInteraction {
+//   id        String   @id @default(cuid())
+//   createdAt DateTime @default(now())
+//   updatedAt DateTime @updatedAt
 
-  locale String
+//   type        String
+//   userId      String
+//   referenceId String
 
-  userId      String
-  referenceId String
+//   dataEncoded     Bytes
+//   metadataEncoded Bytes @default("")
 
-  guildId   String?
-  channelId String
-  messageId String
+//   @@map("user_interactions")
+//   @@ignore
+// }
 
-  lastUpdate     DateTime @default(now())
-  lastBattleTime DateTime @default(now())
+// // An active live session record of a user, requested through the bot
+// model LiveSession {
+//   id        String   @id @default(cuid())
+//   createdAt DateTime @default(now())
+//   updatedAt DateTime @updatedAt
 
-  optionsEncoded String
+//   locale String
 
-  @@index([referenceId])
-  @@map("discord_live_sessions")
-}
+//   userId      String
+//   referenceId String
 
-model StatsRequestsOptions {
-  id        String   @id @default(cuid())
-  createdAt DateTime @default(now())
-  updatedAt DateTime @updatedAt
+//   lastUpdate     DateTime @default(now())
+//   lastBattleTime DateTime @default(now())
 
-  type        String
-  userId      String
-  accountId   String
-  referenceId String
+//   options   StatsRequestsOptions @relation(fields: [optionsId], references: [id])
+//   optionsId String
 
-  dataEncoded String
+//   metadataEncoded Bytes @default("")
 
-  @@index([referenceId])
-  @@map("stats_request_options")
-}
+//   @@index([referenceId])
+//   @@map("live_sessions")
+//   @@ignore
+// }
 
-model CronTask {
-  id        String   @id @default(cuid())
-  createdAt DateTime @default(now())
-  updatedAt DateTime @updatedAt
+// model StatsRequestsOptions {
+//   id        String   @id @default(cuid())
+//   createdAt DateTime @default(now())
+//   updatedAt DateTime @updatedAt
 
-  type           String
-  referenceId    String
-  targetsEncoded String
+//   type        String
+//   userId      String
+//   accountId   String
+//   referenceId String
 
-  status         String
-  lastRun        DateTime
-  scheduledAfter DateTime
-
-  logsEncoded String @default("")
-  dataEncoded String @default("")
+//   dataEncoded  Bytes
+//   liveSessions LiveSession[] @ignore
 
-  @@index([referenceId])
-  @@index([status, referenceId, scheduledAfter])
-  @@index([lastRun, status])
-  @@map("cron_tasks")
-}
+//   @@index([referenceId])
+//   @@map("stats_request_options")
+//   @@ignore
+// }
diff --git a/internal/database/tasks.go b/internal/database/tasks.go
index 1890cff3..b6cc64e6 100644
--- a/internal/database/tasks.go
+++ b/internal/database/tasks.go
@@ -2,11 +2,11 @@ package database
 
 import (
 	"context"
-	"encoding/json"
 	"strings"
 	"time"
 
 	"github.com/cufee/aftermath/internal/database/prisma/db"
+	"github.com/cufee/aftermath/internal/encoding"
 )
 
 type TaskType string
@@ -77,31 +77,34 @@ func (t *Task) OnUpdated() {
 	t.UpdatedAt = time.Now()
 }
 
-func (t *Task) encodeTargets() string {
-	return strings.Join(t.Targets, ";")
+func (t *Task) encodeTargets() []byte {
+	return []byte(strings.Join(t.Targets, ";"))
 }
-func (t *Task) decodeTargets(targets string) {
-	t.Targets = strings.Split(targets, ";")
+func (t *Task) decodeTargets(targets []byte) {
+	t.Targets = strings.Split(string(targets), ";")
 }
 
-func (t *Task) encodeLogs() string {
-	data, _ := json.Marshal(t.Logs)
-	return string(data)
+func (t *Task) encodeLogs() []byte {
+	if t.Logs == nil {
+		return nil
+	}
+	data, _ := encoding.EncodeGob(t.Logs)
+	return data
 }
-func (t *Task) decodeLogs(logs string) {
-	_ = json.Unmarshal([]byte(logs), &t.Logs)
+func (t *Task) decodeLogs(logs []byte) {
+	_ = encoding.DecodeGob(logs, &t.Logs)
 }
 
-func (t *Task) encodeData() string {
+func (t *Task) encodeData() []byte {
 	if t.Data == nil {
-		return ""
+		return nil
 	}
-	data, _ := json.Marshal(t.Data)
-	return string(data)
+	data, _ := encoding.EncodeGob(t.Data)
+	return data
 }
-func (t *Task) decodeData(data string) {
+func (t *Task) decodeData(data []byte) {
 	t.Data = make(map[string]any)
-	_ = json.Unmarshal([]byte(data), &t.Data)
+	_ = encoding.DecodeGob(data, &t.Data)
 }
 
 type TaskLog struct {
diff --git a/internal/database/users.go b/internal/database/users.go
index 270e7ab1..09dbc345 100644
--- a/internal/database/users.go
+++ b/internal/database/users.go
@@ -2,13 +2,13 @@ package database
 
 import (
 	"context"
-	"encoding/json"
 	"errors"
 	"fmt"
 	"slices"
 	"time"
 
 	"github.com/cufee/aftermath/internal/database/prisma/db"
+	"github.com/cufee/aftermath/internal/encoding"
 	"github.com/cufee/aftermath/internal/permissions"
 )
 
@@ -65,8 +65,8 @@ func (c UserConnection) FromModel(model *db.UserConnectionModel) UserConnection
 	c.Permissions = permissions.Parse(model.Permissions, permissions.Blank)
 
 	c.Type = ConnectionType(model.Type)
-	if model.MetadataEncoded != "" {
-		_ = json.Unmarshal([]byte(model.MetadataEncoded), &c.Metadata)
+	if model.MetadataEncoded != nil {
+		_ = encoding.DecodeGob(model.MetadataEncoded, &c.Metadata)
 	}
 	return c
 }
@@ -219,7 +219,7 @@ func (c *client) UpdateConnection(ctx context.Context, connection UserConnection
 		return UserConnection{}, errors.New("connection referenceID cannot be left blank")
 	}
 
-	encoded, err := json.Marshal(connection.Metadata)
+	encoded, err := encoding.EncodeGob(connection.Metadata)
 	if err != nil {
 		return UserConnection{}, fmt.Errorf("failed to encode metadata: %w", err)
 	}
@@ -227,7 +227,7 @@ func (c *client) UpdateConnection(ctx context.Context, connection UserConnection
 	model, err := c.prisma.UserConnection.FindUnique(db.UserConnection.ID.Equals(connection.ID)).Update(
 		db.UserConnection.ReferenceID.Set(connection.ReferenceID),
 		db.UserConnection.Permissions.Set(connection.Permissions.Encode()),
-		db.UserConnection.MetadataEncoded.Set(string(encoded)),
+		db.UserConnection.MetadataEncoded.Set(encoded),
 	).Exec(ctx)
 	if err != nil {
 		return UserConnection{}, err
@@ -250,7 +250,7 @@ func (c *client) UpsertConnection(ctx context.Context, connection UserConnection
 		return UserConnection{}, errors.New("connection Type cannot be left blank")
 	}
 
-	encoded, err := json.Marshal(connection.Metadata)
+	encoded, err := encoding.EncodeGob(connection.Metadata)
 	if err != nil {
 		return UserConnection{}, fmt.Errorf("failed to encode metadata: %w", err)
 	}
@@ -260,7 +260,7 @@ func (c *client) UpsertConnection(ctx context.Context, connection UserConnection
 		db.UserConnection.Type.Set(string(connection.Type)),
 		db.UserConnection.Permissions.Set(connection.Permissions.Encode()),
 		db.UserConnection.ReferenceID.Set(connection.ReferenceID),
-		db.UserConnection.MetadataEncoded.Set(string(encoded)),
+		db.UserConnection.MetadataEncoded.Set(encoded),
 	).Exec(ctx)
 	if err != nil {
 		return UserConnection{}, err
diff --git a/internal/database/vehicles.go b/internal/database/vehicles.go
index eb16c885..bbb67a0b 100644
--- a/internal/database/vehicles.go
+++ b/internal/database/vehicles.go
@@ -2,9 +2,9 @@ package database
 
 import (
 	"context"
-	"encoding/json"
 
 	"github.com/cufee/aftermath/internal/database/prisma/db"
+	"github.com/cufee/aftermath/internal/encoding"
 	"github.com/rs/zerolog/log"
 	"github.com/steebchen/prisma-client-go/runtime/transaction"
 	"golang.org/x/text/language"
@@ -17,7 +17,7 @@ type Vehicle struct {
 	Class  string
 	Nation string
 
-	LocalizedNames map[language.Tag]string
+	LocalizedNames map[string]string
 }
 
 func (v Vehicle) FromModel(model db.VehicleModel) Vehicle {
@@ -25,18 +25,27 @@ func (v Vehicle) FromModel(model db.VehicleModel) Vehicle {
 	v.Tier = model.Tier
 	v.Type = model.Type
 	v.Nation = model.Nation
-	v.LocalizedNames = make(map[language.Tag]string)
-	if model.LocalizedNamesEncoded != "" {
-		_ = json.Unmarshal([]byte(model.LocalizedNamesEncoded), &v.LocalizedNames)
+	v.LocalizedNames = make(map[string]string)
+	if model.LocalizedNamesEncoded != nil {
+		err := encoding.DecodeGob(model.LocalizedNamesEncoded, &v.LocalizedNames)
+		if err != nil {
+			log.Err(err).Str("id", v.ID).Msg("failed to decode vehicle localized names")
+		}
+
 	}
 	return v
 }
 
+func (v Vehicle) EncodeNames() []byte {
+	encoded, _ := encoding.EncodeGob(v.LocalizedNames)
+	return encoded
+}
+
 func (v Vehicle) Name(locale language.Tag) string {
-	if n := v.LocalizedNames[locale]; n != "" {
+	if n := v.LocalizedNames[locale.String()]; n != "" {
 		return n
 	}
-	if n := v.LocalizedNames[language.English]; n != "" {
+	if n := v.LocalizedNames[language.English.String()]; n != "" {
 		return n
 	}
 	return "Secret Tank"
@@ -49,12 +58,6 @@ func (c *client) UpsertVehicles(ctx context.Context, vehicles map[string]Vehicle
 
 	var transactions []transaction.Transaction
 	for id, data := range vehicles {
-		encoded, err := json.Marshal(data.LocalizedNames)
-		if err != nil {
-			log.Err(err).Str("id", id).Msg("failed to encode a stats frame for vehicle averages")
-			continue
-		}
-
 		transactions = append(transactions, c.prisma.Vehicle.
 			UpsertOne(db.Vehicle.ID.Equals(id)).
 			Create(
@@ -63,14 +66,14 @@ func (c *client) UpsertVehicles(ctx context.Context, vehicles map[string]Vehicle
 				db.Vehicle.Type.Set(data.Type),
 				db.Vehicle.Class.Set(data.Class),
 				db.Vehicle.Nation.Set(data.Nation),
-				db.Vehicle.LocalizedNamesEncoded.Set(string(encoded)),
+				db.Vehicle.LocalizedNamesEncoded.Set(data.EncodeNames()),
 			).
 			Update(
 				db.Vehicle.Tier.Set(data.Tier),
 				db.Vehicle.Type.Set(data.Type),
 				db.Vehicle.Class.Set(data.Class),
 				db.Vehicle.Nation.Set(data.Nation),
-				db.Vehicle.LocalizedNamesEncoded.Set(string(encoded)),
+				db.Vehicle.LocalizedNamesEncoded.Set(data.EncodeNames()),
 			).Tx(),
 		)
 	}
diff --git a/internal/encoding/gob.go b/internal/encoding/gob.go
new file mode 100644
index 00000000..d52c5e76
--- /dev/null
+++ b/internal/encoding/gob.go
@@ -0,0 +1,26 @@
+package encoding
+
+import (
+	"bytes"
+	"encoding/gob"
+)
+
+func EncodeGob(data any) ([]byte, error) {
+	if data == nil {
+		return nil, nil
+	}
+	var buf bytes.Buffer
+	err := gob.NewEncoder(&buf).Encode(data)
+	if err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}
+
+func DecodeGob(data []byte, target any) error {
+	err := gob.NewDecoder(bytes.NewBuffer(data)).Decode(target)
+	if err != nil {
+		return err
+	}
+	return nil
+}
diff --git a/internal/stats/frame/frame.go b/internal/stats/frame/frame.go
index 570f97bd..7889ecae 100644
--- a/internal/stats/frame/frame.go
+++ b/internal/stats/frame/frame.go
@@ -1,9 +1,10 @@
 package frame
 
 import (
-	"encoding/json"
 	"math"
 	"time"
+
+	"github.com/cufee/aftermath/internal/encoding"
 )
 
 /*
@@ -39,24 +40,16 @@ type StatsFrame struct {
 	survivalRatio   ValueFloatDecimal `json:"-" bson:"-"`
 }
 
-func DecodeStatsFrame(encoded string) (StatsFrame, error) {
+func DecodeStatsFrame(encoded []byte) (StatsFrame, error) {
 	var data StatsFrame
-	err := json.Unmarshal([]byte(encoded), &data)
-	if err != nil {
-		return StatsFrame{}, err
-	}
-	return data, nil
+	return data, encoding.DecodeGob(encoded, &data)
 }
 
 /*
 Encode StatsFrame to string
 */
-func (r *StatsFrame) Encode() (string, error) {
-	data, err := json.Marshal(r)
-	if err != nil {
-		return "", err
-	}
-	return string(data), nil
+func (r StatsFrame) Encode() ([]byte, error) {
+	return encoding.EncodeGob(r)
 }
 
 /*

From 399c2c795df77aefdafe35677c03e25d0ab6b5de Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sat, 8 Jun 2024 16:53:29 -0400
Subject: [PATCH 022/341] refactored queue

---
 cmds/core/scheduler/cron.go              | 22 ++++-----
 cmds/core/scheduler/{tasks => }/queue.go | 11 +++--
 cmds/core/scheduler/tasks/handler.go     |  4 +-
 cmds/core/scheduler/tasks/sessions.go    | 48 ++++++++++----------
 cmds/core/scheduler/workers.go           | 58 +++++++++++++-----------
 internal/database/client.go              |  1 +
 internal/database/tasks.go               | 15 ++++--
 internal/database/vehicles.go            |  1 -
 main.go                                  | 50 ++++++++++++++++----
 9 files changed, 127 insertions(+), 83 deletions(-)
 rename cmds/core/scheduler/{tasks => }/queue.go (90%)

diff --git a/cmds/core/scheduler/cron.go b/cmds/core/scheduler/cron.go
index d78ad736..1506bc34 100644
--- a/cmds/core/scheduler/cron.go
+++ b/cmds/core/scheduler/cron.go
@@ -3,13 +3,11 @@ package scheduler
 import (
 	"time"
 
-	"github.com/cufee/aftermath/cmds/core"
-	"github.com/cufee/aftermath/cmds/core/scheduler/tasks"
 	"github.com/go-co-op/gocron"
 	"github.com/rs/zerolog/log"
 )
 
-func StartCronJobs(client core.Client, queue *tasks.Queue) {
+func (queue *Queue) StartCronJobsAsync() {
 	defer log.Info().Msg("started cron scheduler")
 
 	c := gocron.NewScheduler(time.UTC)
@@ -18,19 +16,17 @@ func StartCronJobs(client core.Client, queue *tasks.Queue) {
 	c.Cron("0 * * * *").Do(restartTasksWorker(queue))
 
 	// Glossary - Do it around the same time WG releases game updates
-	c.Cron("0 10 * * *").Do(UpdateGlossaryWorker(client))
-	c.Cron("0 12 * * *").Do(UpdateGlossaryWorker(client))
+	c.Cron("0 10 * * *").Do(UpdateGlossaryWorker(queue.core))
+	c.Cron("0 12 * * *").Do(UpdateGlossaryWorker(queue.core))
 	// c.AddFunc("40 9 * * 0", updateAchievementsWorker)
 
-	// Averages - Update averages shortly after session refreshes
-	c.Cron("0 10 * * *").Do(UpdateAveragesWorker(client))
-	c.Cron("0 2 * * *").Do(UpdateAveragesWorker(client))
-	c.Cron("0 19 * * *").Do(UpdateAveragesWorker(client))
+	// Averages - Update averages once daily
+	c.Cron("0 0 * * *").Do(UpdateAveragesWorker(queue.core))
 
 	// Sessions
-	c.Cron("0 9 * * *").Do(createSessionTasksWorker(client, "NA"))  // NA
-	c.Cron("0 1 * * *").Do(createSessionTasksWorker(client, "EU"))  // EU
-	c.Cron("0 18 * * *").Do(createSessionTasksWorker(client, "AS")) // Asia
+	c.Cron("0 9 * * *").Do(createSessionTasksWorker(queue.core, "NA"))  // NA
+	c.Cron("0 1 * * *").Do(createSessionTasksWorker(queue.core, "EU"))  // EU
+	c.Cron("0 18 * * *").Do(createSessionTasksWorker(queue.core, "AS")) // Asia
 
 	// Refresh WN8
 	// "45 9 * * *" 	// NA
@@ -38,7 +34,7 @@ func StartCronJobs(client core.Client, queue *tasks.Queue) {
 	// "45 18 * * *" 	// Asia
 
 	// Configurations
-	c.Cron("0 0 */7 * *").Do(rotateBackgroundPresetsWorker(client))
+	c.Cron("0 0 */7 * *").Do(rotateBackgroundPresetsWorker(queue.core))
 
 	// Start the Cron job scheduler
 	c.StartAsync()
diff --git a/cmds/core/scheduler/tasks/queue.go b/cmds/core/scheduler/queue.go
similarity index 90%
rename from cmds/core/scheduler/tasks/queue.go
rename to cmds/core/scheduler/queue.go
index 9a5dc94d..bce1ef41 100644
--- a/cmds/core/scheduler/tasks/queue.go
+++ b/cmds/core/scheduler/queue.go
@@ -1,4 +1,4 @@
-package tasks
+package scheduler
 
 import (
 	"context"
@@ -6,6 +6,7 @@ import (
 	"time"
 
 	"github.com/cufee/aftermath/cmds/core"
+	"github.com/cufee/aftermath/cmds/core/scheduler/tasks"
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/rs/zerolog/log"
 )
@@ -15,7 +16,7 @@ type Queue struct {
 	concurrencyLimit int
 	lastTaskRun      time.Time
 
-	handlers map[database.TaskType]TaskHandler
+	handlers map[database.TaskType]tasks.TaskHandler
 	core     core.Client
 }
 
@@ -31,7 +32,7 @@ func (q *Queue) LastTaskRun() time.Time {
 	return q.lastTaskRun
 }
 
-func NewQueue(client core.Client, handlers map[database.TaskType]TaskHandler, concurrencyLimit int) *Queue {
+func NewQueue(client core.Client, handlers map[database.TaskType]tasks.TaskHandler, concurrencyLimit int) *Queue {
 	return &Queue{
 		core:             client,
 		handlers:         handlers,
@@ -83,7 +84,7 @@ func (q *Queue) Process(callback func(error), tasks ...database.Task) {
 				Timestamp: time.Now(),
 			}
 
-			message, err := handler.process(nil, t)
+			message, err := handler.Process(nil, t)
 			attempt.Comment = message
 			if err != nil {
 				attempt.Error = err.Error()
@@ -106,7 +107,7 @@ func (q *Queue) Process(callback func(error), tasks ...database.Task) {
 			continue
 		}
 
-		if task.Status == database.TaskStatusFailed && handler.shouldRetry(&task) {
+		if task.Status == database.TaskStatusFailed && handler.ShouldRetry(&task) {
 			rescheduledCount++
 			task.Status = database.TaskStatusScheduled
 		}
diff --git a/cmds/core/scheduler/tasks/handler.go b/cmds/core/scheduler/tasks/handler.go
index 4c99d1ff..fa3d0e6d 100644
--- a/cmds/core/scheduler/tasks/handler.go
+++ b/cmds/core/scheduler/tasks/handler.go
@@ -6,8 +6,8 @@ import (
 )
 
 type TaskHandler struct {
-	process     func(client core.Client, task database.Task) (string, error)
-	shouldRetry func(task *database.Task) bool
+	Process     func(client core.Client, task database.Task) (string, error)
+	ShouldRetry func(task *database.Task) bool
 }
 
 var defaultHandlers = make(map[database.TaskType]TaskHandler)
diff --git a/cmds/core/scheduler/tasks/sessions.go b/cmds/core/scheduler/tasks/sessions.go
index 45c03af2..8a98df0c 100644
--- a/cmds/core/scheduler/tasks/sessions.go
+++ b/cmds/core/scheduler/tasks/sessions.go
@@ -12,7 +12,7 @@ import (
 
 func init() {
 	defaultHandlers[database.TaskTypeRecordSessions] = TaskHandler{
-		process: func(client core.Client, task database.Task) (string, error) {
+		Process: func(client core.Client, task database.Task) (string, error) {
 			if task.Data == nil {
 				return "no data provided", errors.New("no data provided")
 			}
@@ -42,7 +42,7 @@ func init() {
 			// task.Targets = failedAccounts
 			// return "retrying failed accounts", errors.New("some accounts failed")
 		},
-		shouldRetry: func(task *database.Task) bool {
+		ShouldRetry: func(task *database.Task) bool {
 			triesLeft, ok := task.Data["triesLeft"].(int32)
 			if !ok {
 				return false
@@ -59,30 +59,28 @@ func init() {
 	}
 }
 
-func CreateSessionUpdateTasks(client core.Client) func(realm string) error {
-	return func(realm string) error {
-		realm = strings.ToUpper(realm)
-		task := database.Task{
-			Type:        database.TaskTypeRecordSessions,
-			ReferenceID: "realm_" + realm,
-			Data: map[string]any{
-				"realm":     realm,
-				"triesLeft": int32(3),
-			},
-		}
-
-		ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
-		defer cancel()
+func CreateSessionUpdateTasks(client core.Client, realm string) error {
+	realm = strings.ToUpper(realm)
+	task := database.Task{
+		Type:        database.TaskTypeRecordSessions,
+		ReferenceID: "realm_" + realm,
+		Data: map[string]any{
+			"realm":     realm,
+			"triesLeft": int32(3),
+		},
+	}
 
-		accounts, err := client.Database().GetRealmAccounts(ctx, realm)
-		if err != nil {
-			return err
-		}
-		if len(accounts) < 1 {
-			return nil
-		}
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
+	defer cancel()
 
-		// This update requires (2 + n) requests per n players
-		return client.Database().CreateTasks(ctx, splitTaskByTargets(task, 50)...)
+	accounts, err := client.Database().GetRealmAccounts(ctx, realm)
+	if err != nil {
+		return err
 	}
+	if len(accounts) < 1 {
+		return nil
+	}
+
+	// This update requires (2 + n) requests per n players
+	return client.Database().CreateTasks(ctx, splitTaskByTargets(task, 90)...)
 }
diff --git a/cmds/core/scheduler/workers.go b/cmds/core/scheduler/workers.go
index 06c8eff7..e3ca2508 100644
--- a/cmds/core/scheduler/workers.go
+++ b/cmds/core/scheduler/workers.go
@@ -1,8 +1,12 @@
 package scheduler
 
 import (
+	"context"
+	"time"
+
 	"github.com/cufee/aftermath/cmds/core"
 	"github.com/cufee/aftermath/cmds/core/scheduler/tasks"
+	"github.com/rs/zerolog/log"
 )
 
 func rotateBackgroundPresetsWorker(client core.Client) func() {
@@ -23,42 +27,44 @@ func rotateBackgroundPresetsWorker(client core.Client) func() {
 
 func createSessionTasksWorker(client core.Client, realm string) func() {
 	return func() {
-		// err := tasks.CreateSessionUpdateTasks(realm)
-		// if err != nil {
-		// 	log.Err(err).Msg("failed to create session update tasks")
-		// }
+		err := tasks.CreateSessionUpdateTasks(client, realm)
+		if err != nil {
+			log.Err(err).Str("realm", realm).Msg("failed to schedule session update tasks")
+		}
 	}
 }
 
-func runTasksWorker(queue *tasks.Queue) func() {
+func runTasksWorker(queue *Queue) func() {
 	return func() {
-		// 	if tasks.DefaultQueue.ActiveWorkers() > 0 {
-		// 		return
-		// 	}
-
-		// 	activeTasks, err := tasks.StartScheduledTasks(nil, 50)
-		// 	if err != nil {
-		// 		log.Err(err).Msg("failed to start scheduled tasks")
-		// 		return
-		// 	}
-		// 	if len(activeTasks) == 0 {
-		// 		return
-		// 	}
+		activeWorkers := queue.ActiveWorkers()
+		if activeWorkers >= queue.concurrencyLimit {
+			return
+		}
 
-		// 	tasks.DefaultQueue.Process(func(err error) {
-		// 		if err != nil {
-		// 			log.Err(err).Msg("failed to process tasks")
-		// 			return
-		// 		}
+		ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
+		defer cancel()
 
-		// 		// If the queue is now empty, we can run the next batch of tasks right away
-		// 		runTasksWorker()
+		// each task worked handles 1 task at a time, but tasks might be very fast
+		// for now, we queue up 10 tasks per worker, this can be adjusted later/smarter
+		batchSize := queue.concurrencyLimit - activeWorkers
+		tasks, err := queue.core.Database().GetAndStartTasks(ctx, batchSize*10)
+		if err != nil {
+			log.Err(err).Msg("failed to start scheduled tasks")
+			return
+		}
 
-		// 	}, activeTasks...)
+		queue.Process(func(err error) {
+			if err != nil {
+				log.Err(err).Msg("failed to process tasks")
+				return
+			}
+			// if the queue is now empty, we can run the next batch of tasks right away
+			runTasksWorker(queue)
+		}, tasks...)
 	}
 }
 
-func restartTasksWorker(queue *tasks.Queue) func() {
+func restartTasksWorker(queue *Queue) func() {
 	return func() {
 		// _, err := tasks.RestartAbandonedTasks(nil)
 		// if err != nil {
diff --git a/internal/database/client.go b/internal/database/client.go
index d9225317..b7a2be01 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -27,6 +27,7 @@ type Client interface {
 	CreateTasks(ctx context.Context, tasks ...Task) error
 	UpdateTasks(ctx context.Context, tasks ...Task) error
 	DeleteTasks(ctx context.Context, ids ...string) error
+	GetAndStartTasks(ctx context.Context, limit int) ([]Task, error)
 }
 
 var _ Client = &client{}
diff --git a/internal/database/tasks.go b/internal/database/tasks.go
index b6cc64e6..99db4dae 100644
--- a/internal/database/tasks.go
+++ b/internal/database/tasks.go
@@ -127,25 +127,32 @@ func NewAttemptLog(task Task, comment, err string) TaskLog {
 GetAndStartTasks retrieves up to limit number of tasks matching the referenceId and updates their status to in progress
   - this func will block until all other calls to task update funcs are done
 */
-func (c *client) GetAndStartTasks(ctx context.Context, referenceId string, limit int) ([]Task, error) {
+func (c *client) GetAndStartTasks(ctx context.Context, limit int) ([]Task, error) {
 	if limit < 1 {
 		return nil, nil
 	}
 	if err := c.tasksUpdateSem.Acquire(ctx, 1); err != nil {
 		return nil, err
 	}
+	defer c.tasksUpdateSem.Release(1)
 
 	models, err := c.prisma.CronTask.
 		FindMany(
 			db.CronTask.Status.Equals(string(TaskStatusScheduled)),
-			db.CronTask.ReferenceID.Equals(referenceId),
-			db.CronTask.ScheduledAfter.Gte(time.Now()),
+			db.CronTask.ScheduledAfter.Lt(time.Now()),
 		).
+		OrderBy(db.CronTask.ScheduledAfter.Order(db.ASC)).
 		Take(limit).
 		Exec(ctx)
 	if err != nil {
+		if db.IsErrNotFound(err) {
+			return nil, nil
+		}
 		return nil, err
 	}
+	if len(models) < 1 {
+		return nil, nil
+	}
 
 	var ids []string
 	var tasks []Task
@@ -206,6 +213,7 @@ func (c *client) UpdateTasks(ctx context.Context, tasks ...Task) error {
 	if err := c.tasksUpdateSem.Acquire(ctx, 1); err != nil {
 		return err
 	}
+	defer c.tasksUpdateSem.Release(1)
 
 	var txns []db.PrismaTransaction
 	for _, task := range tasks {
@@ -241,6 +249,7 @@ func (c *client) DeleteTasks(ctx context.Context, ids ...string) error {
 	if err := c.tasksUpdateSem.Acquire(ctx, 1); err != nil {
 		return nil
 	}
+	defer c.tasksUpdateSem.Release(1)
 
 	_, err := c.prisma.CronTask.FindMany(db.CronTask.ID.In(ids)).Delete().Exec(ctx)
 	if err != nil {
diff --git a/internal/database/vehicles.go b/internal/database/vehicles.go
index bbb67a0b..2e11eb6e 100644
--- a/internal/database/vehicles.go
+++ b/internal/database/vehicles.go
@@ -31,7 +31,6 @@ func (v Vehicle) FromModel(model db.VehicleModel) Vehicle {
 		if err != nil {
 			log.Err(err).Str("id", v.ID).Msg("failed to decode vehicle localized names")
 		}
-
 	}
 	return v
 }
diff --git a/main.go b/main.go
index b28ad25e..794493d5 100644
--- a/main.go
+++ b/main.go
@@ -6,6 +6,7 @@ import (
 	"log"
 	"net/http"
 	"os"
+	"strconv"
 	"time"
 
 	"github.com/cufee/aftermath/cmds/core"
@@ -37,13 +38,7 @@ func main() {
 
 	loadStaticAssets(static)
 	coreClient := coreClientFromEnv()
-
-	// this can be adjusted to balance memory usage vs time for cache updates
-	taskQueueConcurrency := 10
-	tasksQueue := tasks.NewQueue(coreClient, tasks.DefaultHandlers(), taskQueueConcurrency)
-	scheduler.StartCronJobs(coreClient, tasksQueue)
-	// scheduler.UpdateAveragesWorker(coreClient)()
-	// scheduler.UpdateGlossaryWorker(coreClient)()
+	startSchedulerFromEnvAsync()
 
 	discordHandler, err := discord.NewRouterHandler(coreClient, os.Getenv("DISCORD_TOKEN"), os.Getenv("DISCORD_PUBLIC_KEY"))
 	if err != nil {
@@ -54,11 +49,50 @@ func main() {
 	panic(http.ListenAndServe(":"+os.Getenv("PORT"), nil))
 }
 
+func startSchedulerFromEnvAsync() {
+	if os.Getenv("SCHEDULER_ENABLED") != "true" {
+		return
+	}
+
+	// This wargaming client is using a different proxy as it needs a lot higher rps, but can be slow
+	wgClient, err := wargaming.NewClientFromEnv(os.Getenv("WG_CACHE_APP_ID"), os.Getenv("WG_CACHE_APP_RPS"), os.Getenv("WG_CACHE_REQUEST_TIMEOUT_SEC"), os.Getenv("WG_CACHE_PROXY_HOST_LIST"))
+	if err != nil {
+		log.Fatalf("wgClient: wargaming#NewClientFromEnv failed %s", err)
+	}
+	dbClient, err := database.NewClient()
+	if err != nil {
+		log.Fatalf("database#NewClient failed %s", err)
+	}
+	bsClient, err := blitzstars.NewClient(os.Getenv("BLITZ_STARS_API_URL"), time.Second*10)
+	if err != nil {
+		log.Fatalf("failed to init a blitzstars client %s", err)
+	}
+
+	// Fetch client
+	client, err := fetch.NewMultiSourceClient(wgClient, bsClient, dbClient)
+	if err != nil {
+		log.Fatalf("fetch#NewMultiSourceClient failed %s", err)
+	}
+	coreClient := core.NewClient(client, wgClient, dbClient)
+
+	// Queue
+	taskQueueConcurrency := 10
+	if v, err := strconv.Atoi(os.Getenv("SCHEDULER_CONCURRENT_WORKERS")); err == nil {
+		taskQueueConcurrency = v
+	}
+	queue := scheduler.NewQueue(coreClient, tasks.DefaultHandlers(), taskQueueConcurrency)
+	queue.StartCronJobsAsync()
+
+	// Some tasks should run on startup
+	// scheduler.UpdateAveragesWorker(coreClient)()
+	// scheduler.UpdateGlossaryWorker(coreClient)()
+}
+
 func coreClientFromEnv() core.Client {
 	// Dependencies
 	wgClient, err := wargaming.NewClientFromEnv(os.Getenv("WG_PRIMARY_APP_ID"), os.Getenv("WG_PRIMARY_APP_RPS"), os.Getenv("WG_REQUEST_TIMEOUT_SEC"), os.Getenv("WG_PROXY_HOST_LIST"))
 	if err != nil {
-		log.Fatalf("wargaming#NewClientFromEnv failed %s", err)
+		log.Fatalf("wgClient: wargaming#NewClientFromEnv failed %s", err)
 	}
 	dbClient, err := database.NewClient()
 	if err != nil {

From 7592df7eb12835b10725d5b76d1c1f6059f08b36 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sat, 8 Jun 2024 17:21:44 -0400
Subject: [PATCH 023/341] updating accounts cache

---
 cmds/core/scheduler/cron.go            |  1 +
 go.mod                                 |  2 +-
 go.sum                                 |  4 ++--
 internal/database/accounts.go          | 13 ++++++++++++-
 internal/database/prisma/schema.prisma |  1 -
 internal/stats/fetch/convert.go        |  9 ++++++---
 internal/stats/fetch/multisource.go    | 11 +++++++++++
 7 files changed, 33 insertions(+), 8 deletions(-)

diff --git a/cmds/core/scheduler/cron.go b/cmds/core/scheduler/cron.go
index 1506bc34..daea6b15 100644
--- a/cmds/core/scheduler/cron.go
+++ b/cmds/core/scheduler/cron.go
@@ -13,6 +13,7 @@ func (queue *Queue) StartCronJobsAsync() {
 	c := gocron.NewScheduler(time.UTC)
 	// Tasks
 	c.Cron("* * * * *").Do(runTasksWorker(queue))
+	// some tasks might be stuck due to a panic or restart, restart them
 	c.Cron("0 * * * *").Do(restartTasksWorker(queue))
 
 	// Glossary - Do it around the same time WG releases game updates
diff --git a/go.mod b/go.mod
index 56825584..06d528a3 100644
--- a/go.mod
+++ b/go.mod
@@ -4,7 +4,7 @@ go 1.22.3
 
 require (
 	github.com/bwmarrin/discordgo v0.28.1
-	github.com/cufee/am-wg-proxy-next/v2 v2.1.2
+	github.com/cufee/am-wg-proxy-next/v2 v2.1.3
 	github.com/disintegration/imaging v1.6.2
 	github.com/fogleman/gg v1.3.0
 	github.com/go-co-op/gocron v1.37.0
diff --git a/go.sum b/go.sum
index 4b9b9c9d..4b57b235 100644
--- a/go.sum
+++ b/go.sum
@@ -2,8 +2,8 @@ github.com/bwmarrin/discordgo v0.28.1 h1:gXsuo2GBO7NbR6uqmrrBDplPUx2T3nzu775q/Rd
 github.com/bwmarrin/discordgo v0.28.1/go.mod h1:NJZpH+1AfhIcyQsPeuBKsUtYrRnjkyu0kIVMCHkZtRY=
 github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
-github.com/cufee/am-wg-proxy-next/v2 v2.1.2 h1:j45xbLPs5FqSsfEccls8AWXK1DIWjnIFEKoiB7M/TGY=
-github.com/cufee/am-wg-proxy-next/v2 v2.1.2/go.mod h1:+VxiIdbrdhHdRThASbVmZ5Fz4H6XPCzL3S2Ix6TO/84=
+github.com/cufee/am-wg-proxy-next/v2 v2.1.3 h1:qTzzgEapbI/z81R3nXoiiITfBZeHQ1cnebzSNgaoZlQ=
+github.com/cufee/am-wg-proxy-next/v2 v2.1.3/go.mod h1:+VxiIdbrdhHdRThASbVmZ5Fz4H6XPCzL3S2Ix6TO/84=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
diff --git a/internal/database/accounts.go b/internal/database/accounts.go
index 14330bcf..c8fb1ab7 100644
--- a/internal/database/accounts.go
+++ b/internal/database/accounts.go
@@ -106,7 +106,11 @@ func (c *client) UpsertAccounts(ctx context.Context, accounts []Account) map[str
 			defer wg.Done()
 			optional := []db.AccountSetParam{db.Account.Private.Set(account.Private)}
 			if account.ClanID != "" {
-				optional = append(optional, db.Account.Clan.Link(db.Clan.ID.Equals(account.ClanID)))
+				clan, err := c.prisma.Clan.FindUnique(db.Clan.ID.Equals(account.ClanID)).Exec(ctx)
+				if err == nil {
+					optional = append(optional, db.Account.Clan.Link(db.Clan.ID.Equals(clan.ID)))
+				}
+
 			}
 
 			_, err := c.prisma.Account.
@@ -118,11 +122,18 @@ func (c *client) UpsertAccounts(ctx context.Context, accounts []Account) map[str
 					db.Account.Nickname.Set(account.Nickname),
 					optional...,
 				).
+				Update(
+					append(optional,
+						db.Account.Nickname.Set(account.Nickname),
+						db.Account.LastBattleTime.Set(account.LastBattleTime),
+					)...,
+				).
 				Exec(ctx)
 			if err != nil {
 				mx.Lock()
 				errors[account.ID] = err
 				mx.Unlock()
+				return
 			}
 		}(account)
 	}
diff --git a/internal/database/prisma/schema.prisma b/internal/database/prisma/schema.prisma
index 3dc63ba0..ced783a5 100644
--- a/internal/database/prisma/schema.prisma
+++ b/internal/database/prisma/schema.prisma
@@ -172,7 +172,6 @@ model Account {
   clanId String?
 
   @@index([realm])
-  @@index([clanId])
   @@index([nickname])
   @@index([lastBattleTime])
   @@map("accounts")
diff --git a/internal/stats/fetch/convert.go b/internal/stats/fetch/convert.go
index 7db9f1c4..04377552 100644
--- a/internal/stats/fetch/convert.go
+++ b/internal/stats/fetch/convert.go
@@ -16,17 +16,20 @@ func timestampToTime(timestamp int) time.Time {
 }
 
 func wargamingToAccount(realm string, account types.ExtendedAccount, clan types.ClanMember, private bool) database.Account {
-	return database.Account{
+	a := database.Account{
 		ID:       strconv.Itoa(account.ID),
 		Realm:    realm,
 		Nickname: account.Nickname,
-		ClanTag:  clan.Clan.Tag,
-		ClanID:   strconv.Itoa(clan.ClanID),
 
 		Private:        private,
 		CreatedAt:      timestampToTime(account.CreatedAt),
 		LastBattleTime: timestampToTime(account.LastBattleTime),
 	}
+	if clan.ClanID > 0 {
+		a.ClanTag = clan.Clan.Tag
+		a.ClanID = strconv.Itoa(clan.ClanID)
+	}
+	return a
 }
 
 func wargamingToStats(realm string, accountData types.ExtendedAccount, clanMember types.ClanMember, vehicleData []types.VehicleStatsFrame) AccountStatsOverPeriod {
diff --git a/internal/stats/fetch/multisource.go b/internal/stats/fetch/multisource.go
index ddd08882..300716ee 100644
--- a/internal/stats/fetch/multisource.go
+++ b/internal/stats/fetch/multisource.go
@@ -13,6 +13,7 @@ import (
 	"github.com/cufee/aftermath/internal/retry"
 	"github.com/cufee/aftermath/internal/stats/frame"
 	"github.com/cufee/am-wg-proxy-next/v2/types"
+	"github.com/rs/zerolog/log"
 )
 
 var _ Client = &multiSourceClient{}
@@ -115,6 +116,16 @@ func (c *multiSourceClient) CurrentStats(ctx context.Context, id string, opts ..
 		stats.AddWN8(averages.Data)
 	}
 
+	go func() {
+		ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+		defer cancel()
+
+		errMap := c.database.UpsertAccounts(ctx, []database.Account{stats.Account})
+		if err := errMap[id]; err != nil {
+			log.Err(err).Msg("failed to update account cache")
+		}
+	}()
+
 	return stats, nil
 }
 

From 64f4006152fc98bd7407e5875ba655a609f8e93f Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sat, 8 Jun 2024 17:39:39 -0400
Subject: [PATCH 024/341] minor encoding/scheduler fixes

---
 cmds/core/scheduler/cron.go            | 12 ++++++------
 cmds/core/scheduler/tasks/sessions.go  |  5 +++--
 cmds/core/scheduler/workers.go         | 10 +++++-----
 fly.canary.toml                        |  4 ++++
 internal/database/accounts.go          |  1 -
 internal/database/prisma/schema.prisma | 21 +++++++++++----------
 internal/database/tasks.go             |  8 ++++----
 internal/encoding/gob.go               |  4 ++--
 main.go                                |  2 +-
 9 files changed, 36 insertions(+), 31 deletions(-)

diff --git a/cmds/core/scheduler/cron.go b/cmds/core/scheduler/cron.go
index daea6b15..523c7037 100644
--- a/cmds/core/scheduler/cron.go
+++ b/cmds/core/scheduler/cron.go
@@ -12,9 +12,9 @@ func (queue *Queue) StartCronJobsAsync() {
 
 	c := gocron.NewScheduler(time.UTC)
 	// Tasks
-	c.Cron("* * * * *").Do(runTasksWorker(queue))
+	c.Cron("* * * * *").Do(RunTasksWorker(queue))
 	// some tasks might be stuck due to a panic or restart, restart them
-	c.Cron("0 * * * *").Do(restartTasksWorker(queue))
+	c.Cron("0 * * * *").Do(RestartTasksWorker(queue))
 
 	// Glossary - Do it around the same time WG releases game updates
 	c.Cron("0 10 * * *").Do(UpdateGlossaryWorker(queue.core))
@@ -25,9 +25,9 @@ func (queue *Queue) StartCronJobsAsync() {
 	c.Cron("0 0 * * *").Do(UpdateAveragesWorker(queue.core))
 
 	// Sessions
-	c.Cron("0 9 * * *").Do(createSessionTasksWorker(queue.core, "NA"))  // NA
-	c.Cron("0 1 * * *").Do(createSessionTasksWorker(queue.core, "EU"))  // EU
-	c.Cron("0 18 * * *").Do(createSessionTasksWorker(queue.core, "AS")) // Asia
+	c.Cron("0 9 * * *").Do(CreateSessionTasksWorker(queue.core, "NA"))  // NA
+	c.Cron("0 1 * * *").Do(CreateSessionTasksWorker(queue.core, "EU"))  // EU
+	c.Cron("0 18 * * *").Do(CreateSessionTasksWorker(queue.core, "AS")) // Asia
 
 	// Refresh WN8
 	// "45 9 * * *" 	// NA
@@ -35,7 +35,7 @@ func (queue *Queue) StartCronJobsAsync() {
 	// "45 18 * * *" 	// Asia
 
 	// Configurations
-	c.Cron("0 0 */7 * *").Do(rotateBackgroundPresetsWorker(queue.core))
+	c.Cron("0 0 */7 * *").Do(RotateBackgroundPresetsWorker(queue.core))
 
 	// Start the Cron job scheduler
 	c.StartAsync()
diff --git a/cmds/core/scheduler/tasks/sessions.go b/cmds/core/scheduler/tasks/sessions.go
index 8a98df0c..f999f95c 100644
--- a/cmds/core/scheduler/tasks/sessions.go
+++ b/cmds/core/scheduler/tasks/sessions.go
@@ -62,8 +62,9 @@ func init() {
 func CreateSessionUpdateTasks(client core.Client, realm string) error {
 	realm = strings.ToUpper(realm)
 	task := database.Task{
-		Type:        database.TaskTypeRecordSessions,
-		ReferenceID: "realm_" + realm,
+		Type:           database.TaskTypeRecordSessions,
+		ReferenceID:    "realm_" + realm,
+		ScheduledAfter: time.Now(),
 		Data: map[string]any{
 			"realm":     realm,
 			"triesLeft": int32(3),
diff --git a/cmds/core/scheduler/workers.go b/cmds/core/scheduler/workers.go
index e3ca2508..fa7e033f 100644
--- a/cmds/core/scheduler/workers.go
+++ b/cmds/core/scheduler/workers.go
@@ -9,7 +9,7 @@ import (
 	"github.com/rs/zerolog/log"
 )
 
-func rotateBackgroundPresetsWorker(client core.Client) func() {
+func RotateBackgroundPresetsWorker(client core.Client) func() {
 	return func() {
 		// // We just run the logic directly as it's not a heavy task and it doesn't matter if it fails due to the app failing
 		// log.Info().Msg("rotating background presets")
@@ -25,7 +25,7 @@ func rotateBackgroundPresetsWorker(client core.Client) func() {
 	}
 }
 
-func createSessionTasksWorker(client core.Client, realm string) func() {
+func CreateSessionTasksWorker(client core.Client, realm string) func() {
 	return func() {
 		err := tasks.CreateSessionUpdateTasks(client, realm)
 		if err != nil {
@@ -34,7 +34,7 @@ func createSessionTasksWorker(client core.Client, realm string) func() {
 	}
 }
 
-func runTasksWorker(queue *Queue) func() {
+func RunTasksWorker(queue *Queue) func() {
 	return func() {
 		activeWorkers := queue.ActiveWorkers()
 		if activeWorkers >= queue.concurrencyLimit {
@@ -59,12 +59,12 @@ func runTasksWorker(queue *Queue) func() {
 				return
 			}
 			// if the queue is now empty, we can run the next batch of tasks right away
-			runTasksWorker(queue)
+			RunTasksWorker(queue)
 		}, tasks...)
 	}
 }
 
-func restartTasksWorker(queue *Queue) func() {
+func RestartTasksWorker(queue *Queue) func() {
 	return func() {
 		// _, err := tasks.RestartAbandonedTasks(nil)
 		// if err != nil {
diff --git a/fly.canary.toml b/fly.canary.toml
index 72616c2a..12b4efb0 100644
--- a/fly.canary.toml
+++ b/fly.canary.toml
@@ -17,6 +17,8 @@ DATABASE_URL = "file:/data/db/canary.db"
 # Wargaming API
 WG_PRIMARY_APP_RPS = "10"
 WG_REQUEST_TIMEOUT_SEC = "5"
+WG_CACHE_APP_RPS = "10"
+WG_CACHE_REQUEST_TIMEOUT_SEC = "15"
 # External services
 BLITZ_STARS_API_URL = "https://www.blitzstars.com/api"
 WOT_BLITZ_PUBLIC_API_URL_FMT = "https://%s.wotblitz.com/en/api"
@@ -25,6 +27,8 @@ WOT_INSPECTOR_TANK_DB_URL = "https://armor.wotinspector.com/static/armorinspecto
 # Discord
 DISCORD_PRIMARY_GUILD_ID = "1090331056449781793"
 # Misc configuration
+SCHEDULER_CONCURRENT_WORKERS = 10
+SCHEDULER_ENABLED = "true"
 LOG_LEVEL = "info"
 NETWORK = "tcp"
 PORT = "8080"
diff --git a/internal/database/accounts.go b/internal/database/accounts.go
index c8fb1ab7..50281a1a 100644
--- a/internal/database/accounts.go
+++ b/internal/database/accounts.go
@@ -110,7 +110,6 @@ func (c *client) UpsertAccounts(ctx context.Context, accounts []Account) map[str
 				if err == nil {
 					optional = append(optional, db.Account.Clan.Link(db.Clan.ID.Equals(clan.ID)))
 				}
-
 			}
 
 			_, err := c.prisma.Account.
diff --git a/internal/database/prisma/schema.prisma b/internal/database/prisma/schema.prisma
index ced783a5..8b1303cd 100644
--- a/internal/database/prisma/schema.prisma
+++ b/internal/database/prisma/schema.prisma
@@ -19,7 +19,7 @@ model AppConfiguration {
   updatedAt DateTime @updatedAt
 
   valueEncoded    Bytes
-  metadataEncoded Bytes @default("")
+  metadataEncoded Bytes
 
   @@map("app_configurations")
 }
@@ -38,8 +38,8 @@ model CronTask {
   lastRun        DateTime
   scheduledAfter DateTime
 
-  logsEncoded Bytes @default("")
-  dataEncoded Bytes @default("")
+  logsEncoded Bytes
+  dataEncoded Bytes
 
   @@index([referenceId])
   @@index([status, referenceId, scheduledAfter])
@@ -60,7 +60,7 @@ model CronTask {
 //   expiresAt DateTime
 
 //   referenceId     String
-//   metadataEncoded Bytes  @default("")
+//   metadataEncoded Bytes
 
 //   @@index([createdAt])
 //   @@index([referenceId])
@@ -120,7 +120,7 @@ model UserConnection {
   permissions String
   referenceId String
 
-  metadataEncoded Bytes @default("")
+  metadataEncoded Bytes
 
   @@index([userId])
   @@index([type, userId])
@@ -142,7 +142,7 @@ model UserContent {
   referenceId String
 
   valueEncoded    Bytes
-  metadataEncoded Bytes @default("")
+  metadataEncoded Bytes
 
   @@index([userId])
   @@index([type, userId])
@@ -172,8 +172,9 @@ model Account {
   clanId String?
 
   @@index([realm])
-  @@index([nickname])
-  @@index([lastBattleTime])
+  @@index([realm, lastBattleTime])
+  @@index([id, lastBattleTime])
+  @@index([clanId])
   @@map("accounts")
 }
 
@@ -323,7 +324,7 @@ model Vehicle {
 //   referenceId String
 
 //   dataEncoded     Bytes
-//   metadataEncoded Bytes @default("")
+//   metadataEncoded Bytes
 
 //   @@map("user_interactions")
 //   @@ignore
@@ -346,7 +347,7 @@ model Vehicle {
 //   options   StatsRequestsOptions @relation(fields: [optionsId], references: [id])
 //   optionsId String
 
-//   metadataEncoded Bytes @default("")
+//   metadataEncoded Bytes
 
 //   @@index([referenceId])
 //   @@map("live_sessions")
diff --git a/internal/database/tasks.go b/internal/database/tasks.go
index 99db4dae..196cec4e 100644
--- a/internal/database/tasks.go
+++ b/internal/database/tasks.go
@@ -86,7 +86,7 @@ func (t *Task) decodeTargets(targets []byte) {
 
 func (t *Task) encodeLogs() []byte {
 	if t.Logs == nil {
-		return nil
+		return []byte{}
 	}
 	data, _ := encoding.EncodeGob(t.Logs)
 	return data
@@ -97,7 +97,7 @@ func (t *Task) decodeLogs(logs []byte) {
 
 func (t *Task) encodeData() []byte {
 	if t.Data == nil {
-		return nil
+		return []byte{}
 	}
 	data, _ := encoding.EncodeGob(t.Data)
 	return data
@@ -185,8 +185,8 @@ func (c *client) CreateTasks(ctx context.Context, tasks ...Task) error {
 			db.CronTask.Type.Set(string(task.Type)),
 			db.CronTask.ReferenceID.Set(task.ReferenceID),
 			db.CronTask.TargetsEncoded.Set(task.encodeTargets()),
-			db.CronTask.Status.Set(string(task.Status)),
-			db.CronTask.LastRun.Set(task.LastRun),
+			db.CronTask.Status.Set(string(TaskStatusScheduled)),
+			db.CronTask.LastRun.Set(time.Now()),
 			db.CronTask.ScheduledAfter.Set(task.ScheduledAfter),
 			db.CronTask.LogsEncoded.Set(task.encodeLogs()),
 			db.CronTask.DataEncoded.Set(task.encodeData()),
diff --git a/internal/encoding/gob.go b/internal/encoding/gob.go
index d52c5e76..4c3017f7 100644
--- a/internal/encoding/gob.go
+++ b/internal/encoding/gob.go
@@ -7,12 +7,12 @@ import (
 
 func EncodeGob(data any) ([]byte, error) {
 	if data == nil {
-		return nil, nil
+		return []byte{}, nil
 	}
 	var buf bytes.Buffer
 	err := gob.NewEncoder(&buf).Encode(data)
 	if err != nil {
-		return nil, err
+		return []byte{}, err
 	}
 	return buf.Bytes(), nil
 }
diff --git a/main.go b/main.go
index 794493d5..1b99021d 100644
--- a/main.go
+++ b/main.go
@@ -85,7 +85,7 @@ func startSchedulerFromEnvAsync() {
 
 	// Some tasks should run on startup
 	// scheduler.UpdateAveragesWorker(coreClient)()
-	// scheduler.UpdateGlossaryWorker(coreClient)()
+	// scheduler.CreateSessionTasksWorker(coreClient, "NA")()
 }
 
 func coreClientFromEnv() core.Client {

From e765991d22bb74c1b9ac5f20cd352938bbca3a91 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sat, 8 Jun 2024 17:42:37 -0400
Subject: [PATCH 025/341] added recover

---
 main.go | 33 ++++++++++++++++++++-------------
 1 file changed, 20 insertions(+), 13 deletions(-)

diff --git a/main.go b/main.go
index 1b99021d..ee853493 100644
--- a/main.go
+++ b/main.go
@@ -3,7 +3,7 @@ package main
 import (
 	"embed"
 	"io/fs"
-	"log"
+
 	"net/http"
 	"os"
 	"strconv"
@@ -22,6 +22,7 @@ import (
 	"github.com/cufee/aftermath/internal/stats/render/assets"
 	render "github.com/cufee/aftermath/internal/stats/render/common"
 	"github.com/rs/zerolog"
+	"github.com/rs/zerolog/log"
 
 	_ "github.com/joho/godotenv/autoload"
 )
@@ -57,21 +58,21 @@ func startSchedulerFromEnvAsync() {
 	// This wargaming client is using a different proxy as it needs a lot higher rps, but can be slow
 	wgClient, err := wargaming.NewClientFromEnv(os.Getenv("WG_CACHE_APP_ID"), os.Getenv("WG_CACHE_APP_RPS"), os.Getenv("WG_CACHE_REQUEST_TIMEOUT_SEC"), os.Getenv("WG_CACHE_PROXY_HOST_LIST"))
 	if err != nil {
-		log.Fatalf("wgClient: wargaming#NewClientFromEnv failed %s", err)
+		log.Fatal().Msgf("wgClient: wargaming#NewClientFromEnv failed %s", err)
 	}
 	dbClient, err := database.NewClient()
 	if err != nil {
-		log.Fatalf("database#NewClient failed %s", err)
+		log.Fatal().Msgf("database#NewClient failed %s", err)
 	}
 	bsClient, err := blitzstars.NewClient(os.Getenv("BLITZ_STARS_API_URL"), time.Second*10)
 	if err != nil {
-		log.Fatalf("failed to init a blitzstars client %s", err)
+		log.Fatal().Msgf("failed to init a blitzstars client %s", err)
 	}
 
 	// Fetch client
 	client, err := fetch.NewMultiSourceClient(wgClient, bsClient, dbClient)
 	if err != nil {
-		log.Fatalf("fetch#NewMultiSourceClient failed %s", err)
+		log.Fatal().Msgf("fetch#NewMultiSourceClient failed %s", err)
 	}
 	coreClient := core.NewClient(client, wgClient, dbClient)
 
@@ -81,8 +82,14 @@ func startSchedulerFromEnvAsync() {
 		taskQueueConcurrency = v
 	}
 	queue := scheduler.NewQueue(coreClient, tasks.DefaultHandlers(), taskQueueConcurrency)
-	queue.StartCronJobsAsync()
 
+	defer func() {
+		if r := recover(); r != nil {
+			log.Error().Interface("error", r).Stack().Msg("scheduler panic")
+		}
+	}()
+
+	queue.StartCronJobsAsync()
 	// Some tasks should run on startup
 	// scheduler.UpdateAveragesWorker(coreClient)()
 	// scheduler.CreateSessionTasksWorker(coreClient, "NA")()
@@ -92,21 +99,21 @@ func coreClientFromEnv() core.Client {
 	// Dependencies
 	wgClient, err := wargaming.NewClientFromEnv(os.Getenv("WG_PRIMARY_APP_ID"), os.Getenv("WG_PRIMARY_APP_RPS"), os.Getenv("WG_REQUEST_TIMEOUT_SEC"), os.Getenv("WG_PROXY_HOST_LIST"))
 	if err != nil {
-		log.Fatalf("wgClient: wargaming#NewClientFromEnv failed %s", err)
+		log.Fatal().Msgf("wgClient: wargaming#NewClientFromEnv failed %s", err)
 	}
 	dbClient, err := database.NewClient()
 	if err != nil {
-		log.Fatalf("database#NewClient failed %s", err)
+		log.Fatal().Msgf("database#NewClient failed %s", err)
 	}
 	bsClient, err := blitzstars.NewClient(os.Getenv("BLITZ_STARS_API_URL"), time.Second*10)
 	if err != nil {
-		log.Fatalf("failed to init a blitzstars client %s", err)
+		log.Fatal().Msgf("failed to init a blitzstars client %s", err)
 	}
 
 	// Fetch client
 	client, err := fetch.NewMultiSourceClient(wgClient, bsClient, dbClient)
 	if err != nil {
-		log.Fatalf("fetch#NewMultiSourceClient failed %s", err)
+		log.Fatal().Msgf("fetch#NewMultiSourceClient failed %s", err)
 	}
 
 	return core.NewClient(client, wgClient, dbClient)
@@ -116,14 +123,14 @@ func loadStaticAssets(static fs.FS) {
 	// Assets for rendering
 	err := assets.LoadAssets(static, "static")
 	if err != nil {
-		log.Fatalf("assets#LoadAssets failed to load assets from static/ embed.FS %s", err)
+		log.Fatal().Msgf("assets#LoadAssets failed to load assets from static/ embed.FS %s", err)
 	}
 	err = render.InitLoadedAssets()
 	if err != nil {
-		log.Fatalf("render#InitLoadedAssets failed %s", err)
+		log.Fatal().Msgf("render#InitLoadedAssets failed %s", err)
 	}
 	err = localization.LoadAssets(static, "static/localization")
 	if err != nil {
-		log.Fatalf("localization#LoadAssets failed %s", err)
+		log.Fatal().Msgf("localization#LoadAssets failed %s", err)
 	}
 }

From f3d2f8ef91e9282c90db4af179526684696265bb Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sat, 8 Jun 2024 18:40:58 -0400
Subject: [PATCH 026/341] reset db

---
 .../migration.sql                             |  23 ---
 .../migration.sql                             | 185 +++++-------------
 2 files changed, 48 insertions(+), 160 deletions(-)
 delete mode 100644 internal/database/prisma/migrations/20240607205538_added_cron_task/migration.sql
 rename internal/database/prisma/migrations/{20240606205337_init => 20240608224040_init}/migration.sql (52%)

diff --git a/internal/database/prisma/migrations/20240607205538_added_cron_task/migration.sql b/internal/database/prisma/migrations/20240607205538_added_cron_task/migration.sql
deleted file mode 100644
index c334d540..00000000
--- a/internal/database/prisma/migrations/20240607205538_added_cron_task/migration.sql
+++ /dev/null
@@ -1,23 +0,0 @@
--- CreateTable
-CREATE TABLE "cron_tasks" (
-    "id" TEXT NOT NULL PRIMARY KEY,
-    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "updatedAt" DATETIME NOT NULL,
-    "type" TEXT NOT NULL,
-    "referenceId" TEXT NOT NULL,
-    "targetsEncoded" TEXT NOT NULL,
-    "status" TEXT NOT NULL,
-    "lastRun" DATETIME NOT NULL,
-    "scheduledAfter" DATETIME NOT NULL,
-    "logsEncoded" TEXT NOT NULL DEFAULT '',
-    "dataEncoded" TEXT NOT NULL DEFAULT ''
-);
-
--- CreateIndex
-CREATE INDEX "cron_tasks_referenceId_idx" ON "cron_tasks"("referenceId");
-
--- CreateIndex
-CREATE INDEX "cron_tasks_status_referenceId_scheduledAfter_idx" ON "cron_tasks"("status", "referenceId", "scheduledAfter");
-
--- CreateIndex
-CREATE INDEX "cron_tasks_lastRun_status_idx" ON "cron_tasks"("lastRun", "status");
diff --git a/internal/database/prisma/migrations/20240606205337_init/migration.sql b/internal/database/prisma/migrations/20240608224040_init/migration.sql
similarity index 52%
rename from internal/database/prisma/migrations/20240606205337_init/migration.sql
rename to internal/database/prisma/migrations/20240608224040_init/migration.sql
index d8843022..9b2a667d 100644
--- a/internal/database/prisma/migrations/20240606205337_init/migration.sql
+++ b/internal/database/prisma/migrations/20240608224040_init/migration.sql
@@ -3,18 +3,23 @@ CREATE TABLE "app_configurations" (
     "id" TEXT NOT NULL PRIMARY KEY,
     "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
     "updatedAt" DATETIME NOT NULL,
-    "valueEncoded" TEXT NOT NULL,
-    "metadataEncoded" TEXT NOT NULL DEFAULT ''
+    "valueEncoded" BLOB NOT NULL,
+    "metadataEncoded" BLOB NOT NULL
 );
 
 -- CreateTable
-CREATE TABLE "auth_nonces" (
+CREATE TABLE "cron_tasks" (
     "id" TEXT NOT NULL PRIMARY KEY,
     "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
     "updatedAt" DATETIME NOT NULL,
-    "expiresAt" DATETIME NOT NULL,
+    "type" TEXT NOT NULL,
     "referenceId" TEXT NOT NULL,
-    "metadataEncoded" TEXT NOT NULL DEFAULT ''
+    "targetsEncoded" BLOB NOT NULL,
+    "status" TEXT NOT NULL,
+    "lastRun" DATETIME NOT NULL,
+    "scheduledAfter" DATETIME NOT NULL,
+    "logsEncoded" BLOB NOT NULL,
+    "dataEncoded" BLOB NOT NULL
 );
 
 -- CreateTable
@@ -23,7 +28,7 @@ CREATE TABLE "users" (
     "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
     "updatedAt" DATETIME NOT NULL,
     "permissions" TEXT NOT NULL,
-    "featureFlagsEncoded" TEXT NOT NULL DEFAULT ''
+    "featureFlags" INTEGER NOT NULL DEFAULT 0
 );
 
 -- CreateTable
@@ -48,7 +53,7 @@ CREATE TABLE "user_connections" (
     "type" TEXT NOT NULL,
     "permissions" TEXT NOT NULL,
     "referenceId" TEXT NOT NULL,
-    "metadataEncoded" TEXT NOT NULL DEFAULT '',
+    "metadataEncoded" BLOB NOT NULL,
     CONSTRAINT "user_connections_userId_fkey" FOREIGN KEY ("userId") REFERENCES "users" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
 );
 
@@ -60,8 +65,8 @@ CREATE TABLE "user_content" (
     "userId" TEXT NOT NULL,
     "type" TEXT NOT NULL,
     "referenceId" TEXT NOT NULL,
-    "valueEncoded" TEXT NOT NULL,
-    "metadataEncoded" TEXT NOT NULL DEFAULT '',
+    "valueEncoded" BLOB NOT NULL,
+    "metadataEncoded" BLOB NOT NULL,
     CONSTRAINT "user_content_userId_fkey" FOREIGN KEY ("userId") REFERENCES "users" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
 );
 
@@ -79,30 +84,6 @@ CREATE TABLE "accounts" (
     CONSTRAINT "accounts_clanId_fkey" FOREIGN KEY ("clanId") REFERENCES "account_clans" ("id") ON DELETE SET NULL ON UPDATE CASCADE
 );
 
--- CreateTable
-CREATE TABLE "account_snapshots" (
-    "id" TEXT NOT NULL PRIMARY KEY,
-    "createdAt" DATETIME NOT NULL,
-    "updatedAt" DATETIME NOT NULL,
-    "type" TEXT NOT NULL,
-    "accountId" TEXT NOT NULL,
-    "referenceId" TEXT NOT NULL,
-    "lastBattleTime" DATETIME NOT NULL,
-    "dataEncoded" TEXT NOT NULL
-);
-
--- CreateTable
-CREATE TABLE "account_rating_season_snapshots" (
-    "id" TEXT NOT NULL PRIMARY KEY,
-    "createdAt" DATETIME NOT NULL,
-    "updatedAt" DATETIME NOT NULL,
-    "seasonId" TEXT NOT NULL,
-    "accountId" TEXT NOT NULL,
-    "referenceId" TEXT NOT NULL,
-    "lastBattleTime" DATETIME NOT NULL,
-    "dataEncoded" TEXT NOT NULL
-);
-
 -- CreateTable
 CREATE TABLE "account_clans" (
     "id" TEXT NOT NULL PRIMARY KEY,
@@ -116,100 +97,66 @@ CREATE TABLE "account_clans" (
 );
 
 -- CreateTable
-CREATE TABLE "glossary_averages" (
-    "id" TEXT NOT NULL PRIMARY KEY,
-    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "updatedAt" DATETIME NOT NULL,
-    "dataEncoded" TEXT NOT NULL
-);
-
--- CreateTable
-CREATE TABLE "glossary_vehicles" (
+CREATE TABLE "account_snapshots" (
     "id" TEXT NOT NULL PRIMARY KEY,
-    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "updatedAt" DATETIME NOT NULL,
-    "tier" INTEGER NOT NULL,
+    "createdAt" DATETIME NOT NULL,
     "type" TEXT NOT NULL,
-    "class" TEXT NOT NULL,
-    "nation" TEXT NOT NULL,
-    "localizedNamesEncoded" TEXT NOT NULL
+    "lastBattleTime" DATETIME NOT NULL,
+    "accountId" TEXT NOT NULL,
+    "referenceId" TEXT NOT NULL,
+    "frameEncoded" BLOB NOT NULL
 );
 
 -- CreateTable
-CREATE TABLE "glossary_achievements" (
+CREATE TABLE "vehicle_snapshots" (
     "id" TEXT NOT NULL PRIMARY KEY,
-    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "updatedAt" DATETIME NOT NULL,
-    "section" TEXT NOT NULL,
-    "dataEncoded" TEXT NOT NULL
+    "createdAt" DATETIME NOT NULL,
+    "type" TEXT NOT NULL,
+    "lastBattleTime" DATETIME NOT NULL,
+    "accountId" TEXT NOT NULL,
+    "vehicleId" TEXT NOT NULL,
+    "referenceId" TEXT NOT NULL,
+    "frameEncoded" BLOB NOT NULL
 );
 
 -- CreateTable
-CREATE TABLE "user_interactions" (
+CREATE TABLE "achievements_snapshots" (
     "id" TEXT NOT NULL PRIMARY KEY,
     "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
     "updatedAt" DATETIME NOT NULL,
-    "type" TEXT NOT NULL,
-    "userId" TEXT NOT NULL,
+    "accountId" TEXT NOT NULL,
     "referenceId" TEXT NOT NULL,
-    "dataEncoded" TEXT NOT NULL,
-    "metadataEncoded" TEXT NOT NULL DEFAULT ''
+    "dataEncoded" BLOB NOT NULL
 );
 
 -- CreateTable
-CREATE TABLE "discord_live_sessions" (
+CREATE TABLE "glossary_averages" (
     "id" TEXT NOT NULL PRIMARY KEY,
     "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
     "updatedAt" DATETIME NOT NULL,
-    "locale" TEXT NOT NULL,
-    "userId" TEXT NOT NULL,
-    "referenceId" TEXT NOT NULL,
-    "guildId" TEXT,
-    "channelId" TEXT NOT NULL,
-    "messageId" TEXT NOT NULL,
-    "lastUpdate" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "lastBattleTime" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "optionsEncoded" TEXT NOT NULL
+    "dataEncoded" BLOB NOT NULL
 );
 
 -- CreateTable
-CREATE TABLE "stats_request_options" (
+CREATE TABLE "glossary_vehicles" (
     "id" TEXT NOT NULL PRIMARY KEY,
     "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
     "updatedAt" DATETIME NOT NULL,
+    "tier" INTEGER NOT NULL,
     "type" TEXT NOT NULL,
-    "userId" TEXT NOT NULL,
-    "accountId" TEXT NOT NULL,
-    "referenceId" TEXT NOT NULL,
-    "dataEncoded" TEXT NOT NULL
+    "class" TEXT NOT NULL,
+    "nation" TEXT NOT NULL,
+    "localizedNamesEncoded" BLOB NOT NULL
 );
 
 -- CreateIndex
-CREATE INDEX "auth_nonces_createdAt_idx" ON "auth_nonces"("createdAt");
+CREATE INDEX "cron_tasks_referenceId_idx" ON "cron_tasks"("referenceId");
 
 -- CreateIndex
-CREATE INDEX "auth_nonces_referenceId_idx" ON "auth_nonces"("referenceId");
+CREATE INDEX "cron_tasks_status_referenceId_scheduledAfter_idx" ON "cron_tasks"("status", "referenceId", "scheduledAfter");
 
 -- CreateIndex
-CREATE INDEX "auth_nonces_referenceId_expiresAt_idx" ON "auth_nonces"("referenceId", "expiresAt");
-
--- CreateIndex
-CREATE INDEX "user_subscriptions_userId_idx" ON "user_subscriptions"("userId");
-
--- CreateIndex
-CREATE INDEX "user_subscriptions_expiresAt_idx" ON "user_subscriptions"("expiresAt");
-
--- CreateIndex
-CREATE INDEX "user_subscriptions_type_userId_expiresAt_idx" ON "user_subscriptions"("type", "userId", "expiresAt");
-
--- CreateIndex
-CREATE INDEX "user_subscriptions_type_userId_idx" ON "user_subscriptions"("type", "userId");
-
--- CreateIndex
-CREATE INDEX "user_subscriptions_referenceId_idx" ON "user_subscriptions"("referenceId");
-
--- CreateIndex
-CREATE INDEX "user_subscriptions_type_referenceId_idx" ON "user_subscriptions"("type", "referenceId");
+CREATE INDEX "cron_tasks_lastRun_status_idx" ON "cron_tasks"("lastRun", "status");
 
 -- CreateIndex
 CREATE INDEX "user_connections_userId_idx" ON "user_connections"("userId");
@@ -239,61 +186,25 @@ CREATE INDEX "user_content_type_referenceId_idx" ON "user_content"("type", "refe
 CREATE INDEX "accounts_realm_idx" ON "accounts"("realm");
 
 -- CreateIndex
-CREATE INDEX "accounts_clanId_idx" ON "accounts"("clanId");
-
--- CreateIndex
-CREATE INDEX "accounts_nickname_idx" ON "accounts"("nickname");
+CREATE INDEX "accounts_realm_lastBattleTime_idx" ON "accounts"("realm", "lastBattleTime");
 
 -- CreateIndex
-CREATE INDEX "accounts_lastBattleTime_idx" ON "accounts"("lastBattleTime");
+CREATE INDEX "accounts_id_lastBattleTime_idx" ON "accounts"("id", "lastBattleTime");
 
 -- CreateIndex
-CREATE INDEX "account_snapshots_createdAt_idx" ON "account_snapshots"("createdAt");
-
--- CreateIndex
-CREATE INDEX "account_snapshots_type_accountId_idx" ON "account_snapshots"("type", "accountId");
-
--- CreateIndex
-CREATE INDEX "account_snapshots_type_accountId_createdAt_idx" ON "account_snapshots"("type", "accountId", "createdAt");
-
--- CreateIndex
-CREATE INDEX "account_snapshots_type_accountId_lastBattleTime_idx" ON "account_snapshots"("type", "accountId", "lastBattleTime");
-
--- CreateIndex
-CREATE INDEX "account_snapshots_type_referenceId_idx" ON "account_snapshots"("type", "referenceId");
-
--- CreateIndex
-CREATE INDEX "account_snapshots_type_referenceId_createdAt_idx" ON "account_snapshots"("type", "referenceId", "createdAt");
-
--- CreateIndex
-CREATE INDEX "account_rating_season_snapshots_createdAt_idx" ON "account_rating_season_snapshots"("createdAt");
-
--- CreateIndex
-CREATE INDEX "account_rating_season_snapshots_seasonId_accountId_idx" ON "account_rating_season_snapshots"("seasonId", "accountId");
-
--- CreateIndex
-CREATE INDEX "account_rating_season_snapshots_seasonId_referenceId_idx" ON "account_rating_season_snapshots"("seasonId", "referenceId");
+CREATE INDEX "accounts_clanId_idx" ON "accounts"("clanId");
 
 -- CreateIndex
 CREATE INDEX "account_clans_tag_idx" ON "account_clans"("tag");
 
 -- CreateIndex
-CREATE INDEX "user_interactions_type_idx" ON "user_interactions"("type");
-
--- CreateIndex
-CREATE INDEX "user_interactions_userId_idx" ON "user_interactions"("userId");
-
--- CreateIndex
-CREATE INDEX "user_interactions_userId_type_idx" ON "user_interactions"("userId", "type");
-
--- CreateIndex
-CREATE INDEX "user_interactions_referenceId_idx" ON "user_interactions"("referenceId");
+CREATE INDEX "account_snapshots_createdAt_idx" ON "account_snapshots"("createdAt");
 
 -- CreateIndex
-CREATE INDEX "user_interactions_referenceId_type_idx" ON "user_interactions"("referenceId", "type");
+CREATE INDEX "account_snapshots_accountId_lastBattleTime_idx" ON "account_snapshots"("accountId", "lastBattleTime");
 
 -- CreateIndex
-CREATE INDEX "discord_live_sessions_referenceId_idx" ON "discord_live_sessions"("referenceId");
+CREATE INDEX "vehicle_snapshots_createdAt_idx" ON "vehicle_snapshots"("createdAt");
 
 -- CreateIndex
-CREATE INDEX "stats_request_options_referenceId_idx" ON "stats_request_options"("referenceId");
+CREATE INDEX "vehicle_snapshots_accountId_vehicleId_lastBattleTime_idx" ON "vehicle_snapshots"("accountId", "vehicleId", "lastBattleTime");

From 96fa6fa31f65d834e2336facefa5317fffd4b9ac Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Tue, 11 Jun 2024 13:15:48 -0400
Subject: [PATCH 027/341] added session tracking

---
 cmds/core/scheduler/queue.go           |   2 +-
 cmds/core/scheduler/tasks/sessions.go  | 152 +++++++++++++++++++++----
 internal/database/accounts.go          |   8 ++
 internal/database/client.go            |   3 +
 internal/database/prisma/schema.prisma |   6 +-
 internal/database/snapshots.go         | 104 +++++++++++++++++
 internal/database/tasks.go             |   9 +-
 internal/stats/fetch/convert.go        |   2 +-
 internal/stats/fetch/multisource.go    |   2 +-
 9 files changed, 259 insertions(+), 29 deletions(-)
 create mode 100644 internal/database/snapshots.go

diff --git a/cmds/core/scheduler/queue.go b/cmds/core/scheduler/queue.go
index bce1ef41..b724ee11 100644
--- a/cmds/core/scheduler/queue.go
+++ b/cmds/core/scheduler/queue.go
@@ -84,7 +84,7 @@ func (q *Queue) Process(callback func(error), tasks ...database.Task) {
 				Timestamp: time.Now(),
 			}
 
-			message, err := handler.Process(nil, t)
+			message, err := handler.Process(q.core, t)
 			attempt.Comment = message
 			if err != nil {
 				attempt.Error = err.Error()
diff --git a/cmds/core/scheduler/tasks/sessions.go b/cmds/core/scheduler/tasks/sessions.go
index f999f95c..c8bc87b4 100644
--- a/cmds/core/scheduler/tasks/sessions.go
+++ b/cmds/core/scheduler/tasks/sessions.go
@@ -4,12 +4,19 @@ import (
 	"context"
 	"errors"
 	"strings"
+	"sync"
 	"time"
 
 	"github.com/cufee/aftermath/cmds/core"
 	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/retry"
+	"github.com/cufee/aftermath/internal/stats/fetch"
+	"github.com/cufee/am-wg-proxy-next/v2/types"
+	"github.com/rs/zerolog/log"
 )
 
+type vehicleResponseData map[string][]types.VehicleStatsFrame
+
 func init() {
 	defaultHandlers[database.TaskTypeRecordSessions] = TaskHandler{
 		Process: func(client core.Client, task database.Task) (string, error) {
@@ -18,32 +25,130 @@ func init() {
 			}
 			realm, ok := task.Data["realm"].(string)
 			if !ok {
+				task.Data["triesLeft"] = int(0) // do not retry
 				return "invalid realm", errors.New("invalid realm")
 			}
+			if len(task.Targets) > 100 {
+				task.Data["triesLeft"] = int(0) // do not retry
+				return "cannot process 100+ accounts at a time", errors.New("invalid targets length")
+			}
+			if len(task.Targets) < 1 {
+				task.Data["triesLeft"] = int(0) // do not retry
+				return "targed ids cannot be left blank", errors.New("invalid targets length")
+			}
+
+			log.Debug().Str("taskId", task.ID).Any("targets", task.Targets).Msg("started working on a session refresh task")
+
+			ctx, cancel := context.WithTimeout(context.Background(), time.Second*60)
+			defer cancel()
+
+			accounts, err := client.Wargaming().BatchAccountByID(ctx, realm, task.Targets)
+			if err != nil {
+				return "failed to fetch accounts", err
+			}
 
-			return "did nothing for a task on realm " + realm, nil
-
-			// accountErrs, err := cache.RefreshSessionsAndAccounts(models.SessionTypeDaily, nil, realm, task.Targets...)
-			// if err != nil {
-			// 	return "failed to refresh sessions on all account", err
-			// }
-
-			// var failedAccounts []int
-			// for accountId, err := range accountErrs {
-			// 	if err != nil && accountId != 0 {
-			// 		failedAccounts = append(failedAccounts, accountId)
-			// 	}
-			// }
-			// if len(failedAccounts) == 0 {
-			// 	return "finished session update on all accounts", nil
-			// }
-
-			// // Retry failed accounts
-			// task.Targets = failedAccounts
-			// return "retrying failed accounts", errors.New("some accounts failed")
+			// Make a new slice just in case some accounts were not returned/are private
+			var validAccouts []string
+			for _, id := range task.Targets {
+				data, ok := accounts[id]
+				if !ok {
+					go func(id string) {
+						log.Debug().Str("accountId", id).Str("taskId", task.ID).Msg("account is private")
+						// update account cache (if it exists) to set account as private
+						ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+						defer cancel()
+						err := client.Database().AccountSetPrivate(ctx, id, true)
+						if err != nil {
+							log.Err(err).Str("accountId", id).Msg("failed to set account status as private")
+						}
+					}(id)
+					continue
+				}
+				if data.LastBattleTime < int(time.Now().Add(time.Hour*-25).Unix()) {
+					log.Debug().Str("accountId", id).Str("taskId", task.ID).Msg("account played no battles")
+					// if the last battle was played 25+ hours ago, there is nothing for us to update
+					continue
+				}
+				validAccouts = append(validAccouts, id)
+			}
+
+			if len(validAccouts) == 0 {
+				return "no updates required due to last battle or private accounts status", nil
+			}
+
+			// clans are options-ish
+			clans, err := client.Wargaming().BatchAccountClan(ctx, realm, validAccouts)
+			if err != nil {
+				log.Err(err).Msg("failed to get batch account clans")
+				clans = make(map[string]types.ClanMember)
+			}
+
+			vehicleCh := make(chan retry.DataWithErr[vehicleResponseData], len(validAccouts))
+			var group sync.WaitGroup
+			group.Add(len(validAccouts))
+			for _, id := range validAccouts {
+				go func(id string) {
+					defer group.Done()
+					data, err := client.Wargaming().AccountVehicles(ctx, realm, id)
+					vehicleCh <- retry.DataWithErr[vehicleResponseData]{Data: vehicleResponseData{id: data}, Err: err}
+				}(id)
+			}
+			group.Wait()
+			close(vehicleCh)
+
+			var withErrors []string
+			var accountUpdates []database.Account
+			var snapshots []database.AccountSnapshot
+			for result := range vehicleCh {
+				// there is only 1 key in this map
+				for id, vehicles := range result.Data {
+					if result.Err != nil {
+						withErrors = append(withErrors, id)
+						continue
+					}
+
+					stats := fetch.WargamingToStats(realm, accounts[id], clans[id], vehicles)
+
+					accountUpdates = append(accountUpdates, database.Account{
+						Realm:    stats.Realm,
+						ID:       stats.Account.ID,
+						Nickname: stats.Account.Nickname,
+
+						Private:        false,
+						CreatedAt:      stats.Account.CreatedAt,
+						LastBattleTime: stats.LastBattleTime,
+
+						ClanID:  stats.Account.ClanID,
+						ClanTag: stats.Account.ClanTag,
+					})
+
+					snapshots = append(snapshots, database.AccountSnapshot{
+						Type:           database.SnapshotTypeDaily,
+						CreatedAt:      time.Now(),
+						AccountID:      stats.Account.ID,
+						ReferenceID:    stats.Account.ID,
+						LastBattleTime: stats.LastBattleTime,
+						RatingBattles:  stats.RatingBattles.StatsFrame,
+						RegularBattles: stats.RegularBattles.StatsFrame,
+					})
+				}
+			}
+
+			err = client.Database().CreateAccountSnapshots(ctx, snapshots...)
+			if err != nil {
+				return "failed to save snapshots to database", err
+			}
+
+			if len(withErrors) == 0 {
+				return "finished session update on all accounts", nil
+			}
+
+			// Retry failed accounts
+			task.Targets = withErrors
+			return "retrying failed accounts", errors.New("some accounts failed")
 		},
 		ShouldRetry: func(task *database.Task) bool {
-			triesLeft, ok := task.Data["triesLeft"].(int32)
+			triesLeft, ok := task.Data["triesLeft"].(int)
 			if !ok {
 				return false
 			}
@@ -67,7 +172,7 @@ func CreateSessionUpdateTasks(client core.Client, realm string) error {
 		ScheduledAfter: time.Now(),
 		Data: map[string]any{
 			"realm":     realm,
-			"triesLeft": int32(3),
+			"triesLeft": int(3),
 		},
 	}
 
@@ -81,6 +186,9 @@ func CreateSessionUpdateTasks(client core.Client, realm string) error {
 	if len(accounts) < 1 {
 		return nil
 	}
+	for _, account := range accounts {
+		task.Targets = append(task.Targets, account.ID)
+	}
 
 	// This update requires (2 + n) requests per n players
 	return client.Database().CreateTasks(ctx, splitTaskByTargets(task, 90)...)
diff --git a/internal/database/accounts.go b/internal/database/accounts.go
index 50281a1a..98867e6e 100644
--- a/internal/database/accounts.go
+++ b/internal/database/accounts.go
@@ -140,3 +140,11 @@ func (c *client) UpsertAccounts(ctx context.Context, accounts []Account) map[str
 
 	return errors
 }
+
+func (c *client) AccountSetPrivate(ctx context.Context, id string, value bool) error {
+	_, err := c.prisma.Account.FindUnique(db.Account.ID.Equals(id)).Update(db.Account.Private.Set(value)).Exec(ctx)
+	if err != nil && !db.IsErrNotFound(err) {
+		return err
+	}
+	return nil
+}
diff --git a/internal/database/client.go b/internal/database/client.go
index b7a2be01..d7b2e961 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -13,6 +13,7 @@ type Client interface {
 	GetAccounts(ctx context.Context, ids []string) ([]Account, error)
 	GetRealmAccounts(ctx context.Context, realm string) ([]Account, error)
 	UpsertAccounts(ctx context.Context, accounts []Account) map[string]error
+	AccountSetPrivate(ctx context.Context, id string, value bool) error
 
 	GetVehicleAverages(ctx context.Context, ids []string) (map[string]frame.StatsFrame, error)
 	UpsertVehicleAverages(ctx context.Context, averages map[string]frame.StatsFrame) error
@@ -24,6 +25,8 @@ type Client interface {
 	UpdateConnection(ctx context.Context, connection UserConnection) (UserConnection, error)
 	UpsertConnection(ctx context.Context, connection UserConnection) (UserConnection, error)
 
+	CreateAccountSnapshots(ctx context.Context, snapshots ...AccountSnapshot) error
+
 	CreateTasks(ctx context.Context, tasks ...Task) error
 	UpdateTasks(ctx context.Context, tasks ...Task) error
 	DeleteTasks(ctx context.Context, ids ...string) error
diff --git a/internal/database/prisma/schema.prisma b/internal/database/prisma/schema.prisma
index 8b1303cd..36669dd2 100644
--- a/internal/database/prisma/schema.prisma
+++ b/internal/database/prisma/schema.prisma
@@ -208,7 +208,11 @@ model AccountSnapshot {
   accountId   String
   referenceId String
 
-  frameEncoded Bytes
+  ratingBattles      Int
+  ratingFrameEncoded Bytes
+
+  regularBattles      Int
+  regularFrameEncoded Bytes
 
   @@index([createdAt])
   @@index([accountId, lastBattleTime])
diff --git a/internal/database/snapshots.go b/internal/database/snapshots.go
new file mode 100644
index 00000000..2ae81f9a
--- /dev/null
+++ b/internal/database/snapshots.go
@@ -0,0 +1,104 @@
+package database
+
+import (
+	"context"
+	"time"
+
+	"github.com/cufee/aftermath/internal/database/prisma/db"
+	"github.com/cufee/aftermath/internal/stats/frame"
+	"github.com/rs/zerolog/log"
+	"github.com/steebchen/prisma-client-go/runtime/transaction"
+)
+
+// model AccountSnapshot {
+//   id        String   @id @default(cuid())
+//   createdAt DateTime
+
+//   type           String
+//   lastBattleTime DateTime
+
+//   accountId   String
+//   referenceId String
+
+//   frameEncoded Bytes
+
+//   @@index([createdAt])
+//   @@index([accountId, lastBattleTime])
+//   @@map("account_snapshots")
+// }
+
+type snapshotType string
+
+const (
+	SnapshotTypeDaily snapshotType = "daily"
+)
+
+type AccountSnapshot struct {
+	ID             string
+	Type           snapshotType
+	CreatedAt      time.Time
+	AccountID      string
+	ReferenceID    string
+	LastBattleTime time.Time
+	RatingBattles  frame.StatsFrame
+	RegularBattles frame.StatsFrame
+}
+
+func (s *AccountSnapshot) FromModel(model db.AccountSnapshotModel) error {
+	s.ID = model.ID
+	s.Type = snapshotType(model.Type)
+	s.CreatedAt = model.CreatedAt
+	s.AccountID = model.AccountID
+	s.ReferenceID = model.ReferenceID
+	s.LastBattleTime = model.LastBattleTime
+
+	rating, err := frame.DecodeStatsFrame(model.RatingFrameEncoded)
+	if err != nil {
+		return err
+	}
+	s.RatingBattles = rating
+
+	regular, err := frame.DecodeStatsFrame(model.RegularFrameEncoded)
+	if err != nil {
+		return err
+	}
+	s.RegularBattles = regular
+
+	return nil
+}
+
+func (c *client) CreateAccountSnapshots(ctx context.Context, snapshots ...AccountSnapshot) error {
+	if len(snapshots) < 1 {
+		return nil
+	}
+
+	var transactions []transaction.Transaction
+	for _, data := range snapshots {
+		ratingEncoded, err := data.RatingBattles.Encode()
+		if err != nil {
+			log.Err(err).Str("accountId", data.AccountID).Msg("failed to encode rating stats frame for account snapthsot")
+			continue
+		}
+		regularEncoded, err := data.RegularBattles.Encode()
+		if err != nil {
+			log.Err(err).Str("accountId", data.AccountID).Msg("failed to encode regular stats frame for account snapthsot")
+			continue
+		}
+
+		transactions = append(transactions, c.prisma.AccountSnapshot.
+			CreateOne(
+				db.AccountSnapshot.CreatedAt.Set(data.CreatedAt),
+				db.AccountSnapshot.Type.Set(string(data.Type)),
+				db.AccountSnapshot.LastBattleTime.Set(data.LastBattleTime),
+				db.AccountSnapshot.AccountID.Set(data.AccountID),
+				db.AccountSnapshot.ReferenceID.Set(data.ReferenceID),
+				db.AccountSnapshot.RatingBattles.Set(int(data.RatingBattles.Battles)),
+				db.AccountSnapshot.RatingFrameEncoded.Set(ratingEncoded),
+				db.AccountSnapshot.RegularBattles.Set(int(data.RegularBattles.Battles)),
+				db.AccountSnapshot.RegularFrameEncoded.Set(regularEncoded),
+			).Tx(),
+		)
+	}
+
+	return c.prisma.Prisma.Transaction(transactions...).Exec(ctx)
+}
diff --git a/internal/database/tasks.go b/internal/database/tasks.go
index 196cec4e..292253ee 100644
--- a/internal/database/tasks.go
+++ b/internal/database/tasks.go
@@ -2,6 +2,7 @@ package database
 
 import (
 	"context"
+	"encoding/json"
 	"strings"
 	"time"
 
@@ -81,18 +82,20 @@ func (t *Task) encodeTargets() []byte {
 	return []byte(strings.Join(t.Targets, ";"))
 }
 func (t *Task) decodeTargets(targets []byte) {
-	t.Targets = strings.Split(string(targets), ";")
+	if string(targets) != "" {
+		t.Targets = strings.Split(string(targets), ";")
+	}
 }
 
 func (t *Task) encodeLogs() []byte {
 	if t.Logs == nil {
 		return []byte{}
 	}
-	data, _ := encoding.EncodeGob(t.Logs)
+	data, _ := json.Marshal(t.Logs)
 	return data
 }
 func (t *Task) decodeLogs(logs []byte) {
-	_ = encoding.DecodeGob(logs, &t.Logs)
+	_ = json.Unmarshal(logs, &t.Logs)
 }
 
 func (t *Task) encodeData() []byte {
diff --git a/internal/stats/fetch/convert.go b/internal/stats/fetch/convert.go
index 04377552..96a4a838 100644
--- a/internal/stats/fetch/convert.go
+++ b/internal/stats/fetch/convert.go
@@ -32,7 +32,7 @@ func wargamingToAccount(realm string, account types.ExtendedAccount, clan types.
 	return a
 }
 
-func wargamingToStats(realm string, accountData types.ExtendedAccount, clanMember types.ClanMember, vehicleData []types.VehicleStatsFrame) AccountStatsOverPeriod {
+func WargamingToStats(realm string, accountData types.ExtendedAccount, clanMember types.ClanMember, vehicleData []types.VehicleStatsFrame) AccountStatsOverPeriod {
 	stats := AccountStatsOverPeriod{
 		Realm: realm,
 		// we got the stats, so the account is obv not private at this point
diff --git a/internal/stats/fetch/multisource.go b/internal/stats/fetch/multisource.go
index 300716ee..a98242e9 100644
--- a/internal/stats/fetch/multisource.go
+++ b/internal/stats/fetch/multisource.go
@@ -111,7 +111,7 @@ func (c *multiSourceClient) CurrentStats(ctx context.Context, id string, opts ..
 		return AccountStatsOverPeriod{}, vehicles.Err
 	}
 
-	stats := wargamingToStats(realm, account.Data, clan, vehicles.Data)
+	stats := WargamingToStats(realm, account.Data, clan, vehicles.Data)
 	if options.withWN8 {
 		stats.AddWN8(averages.Data)
 	}

From 5f8a4fd54c54180a69ab2874a07191b62cab3b8a Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Tue, 11 Jun 2024 14:06:06 -0400
Subject: [PATCH 028/341] added vehicle snapshots and cleanup tasks

---
 cmds/core/scheduler/cron.go            |  1 +
 cmds/core/scheduler/tasks/cleanup.go   | 67 ++++++++++++++++++++++
 cmds/core/scheduler/tasks/sessions.go  | 34 +++++++++++-
 cmds/core/scheduler/workers.go         | 37 +++++++++++--
 internal/database/cleanup.go           | 16 ++++++
 internal/database/client.go            |  6 ++
 internal/database/prisma/schema.prisma |  1 +
 internal/database/snapshots.go         | 77 +++++++++++++++++++++++---
 internal/database/tasks.go             | 22 ++++++++
 internal/stats/fetch/convert.go        | 12 ++--
 10 files changed, 252 insertions(+), 21 deletions(-)
 create mode 100644 cmds/core/scheduler/tasks/cleanup.go
 create mode 100644 internal/database/cleanup.go

diff --git a/cmds/core/scheduler/cron.go b/cmds/core/scheduler/cron.go
index 523c7037..144954f7 100644
--- a/cmds/core/scheduler/cron.go
+++ b/cmds/core/scheduler/cron.go
@@ -15,6 +15,7 @@ func (queue *Queue) StartCronJobsAsync() {
 	c.Cron("* * * * *").Do(RunTasksWorker(queue))
 	// some tasks might be stuck due to a panic or restart, restart them
 	c.Cron("0 * * * *").Do(RestartTasksWorker(queue))
+	c.Cron("0 5 * * *").Do(CreateCleanupTaskWorker(queue.core)) // delete expired documents
 
 	// Glossary - Do it around the same time WG releases game updates
 	c.Cron("0 10 * * *").Do(UpdateGlossaryWorker(queue.core))
diff --git a/cmds/core/scheduler/tasks/cleanup.go b/cmds/core/scheduler/tasks/cleanup.go
new file mode 100644
index 00000000..afc1eaab
--- /dev/null
+++ b/cmds/core/scheduler/tasks/cleanup.go
@@ -0,0 +1,67 @@
+package tasks
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"github.com/cufee/aftermath/cmds/core"
+	"github.com/cufee/aftermath/internal/database"
+)
+
+
+func init() {
+	defaultHandlers[database.TaskTypeDatabaseCleanup] = TaskHandler{
+		Process: func(client core.Client, task database.Task) (string, error) {
+			if task.Data == nil {
+				return "no data provided", errors.New("no data provided")
+			}
+			snapshotExpiration, ok := task.Data["expiration_snapshots"].(time.Time)
+			if !ok {
+				return "invalid expiration_snapshots", errors.New("failed to cast expiration_snapshots to time")
+			}
+			taskExpiration, ok := task.Data["expiration_tasks"].(time.Time)
+			if !ok {
+				task.Data["triesLeft"] = int(0) // do not retry
+				return "invalid expiration_tasks", errors.New("failed to cast expiration_tasks to time")
+			}
+
+			ctx, cancel := context.WithTimeout(context.Background(), time.Second * 5)
+			defer cancel()
+
+			err := client.Database().DeleteExpiredTasks(ctx, taskExpiration)
+			if err != nil {
+			return 	"failed to delete expired tasks", err
+			}
+
+			err = client.Database().DeleteExpiredSnapshots(ctx, snapshotExpiration)
+			if err != nil {
+			return 	"failed to delete expired snapshots", err
+			}
+
+			return "cleanup complete", nil
+		},
+		ShouldRetry: func(task *database.Task) bool {
+			return false
+		},
+	}
+}
+
+func CreateCleanupTasks(client core.Client) error {
+	now := time.Now()
+
+	task := database.Task{
+		Type:           database.TaskTypeDatabaseCleanup,
+		ReferenceID:    "database_cleanup",
+		ScheduledAfter: now,
+		Data: map[string]any{
+			"expiration_snapshots":     now.Add(-1 * time.Hour * 24 * 90), // 90 days
+			"expiration_tasks": now.Add(-1 * time.Hour * 24 * 7), // 7 days
+		},
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
+	defer cancel()
+
+	return client.Database().CreateTasks(ctx, task)
+}
diff --git a/cmds/core/scheduler/tasks/sessions.go b/cmds/core/scheduler/tasks/sessions.go
index c8bc87b4..137d2e90 100644
--- a/cmds/core/scheduler/tasks/sessions.go
+++ b/cmds/core/scheduler/tasks/sessions.go
@@ -39,6 +39,7 @@ func init() {
 
 			log.Debug().Str("taskId", task.ID).Any("targets", task.Targets).Msg("started working on a session refresh task")
 
+			createdAt := time.Now()
 			ctx, cancel := context.WithTimeout(context.Background(), time.Second*60)
 			defer cancel()
 
@@ -64,7 +65,7 @@ func init() {
 					}(id)
 					continue
 				}
-				if data.LastBattleTime < int(time.Now().Add(time.Hour*-25).Unix()) {
+				if data.LastBattleTime < int(createdAt.Add(time.Hour*-25).Unix()) {
 					log.Debug().Str("accountId", id).Str("taskId", task.ID).Msg("account played no battles")
 					// if the last battle was played 25+ hours ago, there is nothing for us to update
 					continue
@@ -99,6 +100,7 @@ func init() {
 			var withErrors []string
 			var accountUpdates []database.Account
 			var snapshots []database.AccountSnapshot
+			var vehicleSnapshots []database.VehicleSnapshot
 			for result := range vehicleCh {
 				// there is only 1 key in this map
 				for id, vehicles := range result.Data {
@@ -124,19 +126,45 @@ func init() {
 
 					snapshots = append(snapshots, database.AccountSnapshot{
 						Type:           database.SnapshotTypeDaily,
-						CreatedAt:      time.Now(),
+						CreatedAt:      createdAt,
 						AccountID:      stats.Account.ID,
 						ReferenceID:    stats.Account.ID,
 						LastBattleTime: stats.LastBattleTime,
 						RatingBattles:  stats.RatingBattles.StatsFrame,
 						RegularBattles: stats.RegularBattles.StatsFrame,
 					})
+
+					if len(vehicles) < 1 {
+						continue
+					}
+					vehicleStats := fetch.WargamingVehiclesToFrame(vehicles)
+					for _, vehicle := range vehicleStats {
+						if vehicle.LastBattleTime.Before(createdAt.Add(time.Hour * -25)) {
+							log.Debug().Str("accountId", id).Str("taskId", task.ID).Msg("account played no battles")
+							// if the last battle was played 25+ hours ago, there is nothing for us to update
+							continue
+						}
+						vehicleSnapshots = append(vehicleSnapshots, database.VehicleSnapshot{
+							CreatedAt:      createdAt,
+							Type:           database.SnapshotTypeDaily,
+							LastBattleTime: vehicle.LastBattleTime,
+							AccountID:      stats.Account.ID,
+							VehicleID:      vehicle.VehicleID,
+							ReferenceID:    stats.Account.ID,
+							Stats:          *vehicle.StatsFrame,
+						})
+					}
 				}
 			}
 
 			err = client.Database().CreateAccountSnapshots(ctx, snapshots...)
 			if err != nil {
-				return "failed to save snapshots to database", err
+				return "failed to save account snapshots to database", err
+			}
+
+			err = client.Database().CreateVehicleSnapshots(ctx, vehicleSnapshots...)
+			if err != nil {
+				return "failed to save vehicle snapshots to database", err
 			}
 
 			if len(withErrors) == 0 {
diff --git a/cmds/core/scheduler/workers.go b/cmds/core/scheduler/workers.go
index fa7e033f..65ffb35b 100644
--- a/cmds/core/scheduler/workers.go
+++ b/cmds/core/scheduler/workers.go
@@ -6,9 +6,19 @@ import (
 
 	"github.com/cufee/aftermath/cmds/core"
 	"github.com/cufee/aftermath/cmds/core/scheduler/tasks"
+	"github.com/cufee/aftermath/internal/database"
 	"github.com/rs/zerolog/log"
 )
 
+func CreateCleanupTaskWorker(client core.Client) func() {
+	return func() {
+		err := tasks.CreateCleanupTasks(client)
+		if err != nil {
+			log.Err(err).Msg("failed to schedule a cleanup tasks")
+		}
+	}
+}
+
 func RotateBackgroundPresetsWorker(client core.Client) func() {
 	return func() {
 		// // We just run the logic directly as it's not a heavy task and it doesn't matter if it fails due to the app failing
@@ -66,10 +76,27 @@ func RunTasksWorker(queue *Queue) func() {
 
 func RestartTasksWorker(queue *Queue) func() {
 	return func() {
-		// _, err := tasks.RestartAbandonedTasks(nil)
-		// if err != nil {
-		// 	log.Err(err).Msg("failed to start scheduled tasks")
-		// 	return
-		// }
+		ctx, cancel := context.WithTimeout(context.Background(), time.Second*15)
+		defer cancel()
+
+		staleTasks, err := queue.core.Database().GetStaleTasks(ctx, 100)
+		if err != nil {
+			log.Err(err).Msg("failed to reschedule stale tasks")
+		}
+
+		if len(staleTasks) < 1 {
+			return
+		}
+
+		now := time.Now()
+		for _, task := range staleTasks {
+			task.Status = database.TaskStatusScheduled
+			task.ScheduledAfter = now
+		}
+
+		err = queue.core.Database().UpdateTasks(ctx, staleTasks...)
+		if err != nil {
+			log.Err(err).Msg("failed to update stale tasks")
+		}
 	}
 }
diff --git a/internal/database/cleanup.go b/internal/database/cleanup.go
new file mode 100644
index 00000000..dffc0bf3
--- /dev/null
+++ b/internal/database/cleanup.go
@@ -0,0 +1,16 @@
+package database
+
+import (
+	"context"
+	"time"
+
+	"github.com/cufee/aftermath/internal/database/prisma/db"
+)
+
+func (c *client) DeleteExpiredTasks(ctx context.Context, expiration time.Time) error {
+	_, err := c.prisma.CronTask.FindMany(db.CronTask.CreatedAt.Before(expiration)).Delete().Exec(ctx)
+	if err != nil && db.IsErrNotFound(err) {
+		return err
+	}
+	return nil
+}
diff --git a/internal/database/client.go b/internal/database/client.go
index d7b2e961..67a25310 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -2,6 +2,7 @@ package database
 
 import (
 	"context"
+	"time"
 
 	"github.com/cufee/aftermath/internal/database/prisma/db"
 	"github.com/cufee/aftermath/internal/stats/frame"
@@ -26,11 +27,16 @@ type Client interface {
 	UpsertConnection(ctx context.Context, connection UserConnection) (UserConnection, error)
 
 	CreateAccountSnapshots(ctx context.Context, snapshots ...AccountSnapshot) error
+	CreateVehicleSnapshots(ctx context.Context, snapshots ...VehicleSnapshot) error
 
 	CreateTasks(ctx context.Context, tasks ...Task) error
 	UpdateTasks(ctx context.Context, tasks ...Task) error
 	DeleteTasks(ctx context.Context, ids ...string) error
+	GetStaleTasks(ctx context.Context, limit int) ([]Task, error)
 	GetAndStartTasks(ctx context.Context, limit int) ([]Task, error)
+
+	DeleteExpiredTasks(ctx context.Context, expiration time.Time) error
+	DeleteExpiredSnapshots(ctx context.Context, expiration time.Time) error
 }
 
 var _ Client = &client{}
diff --git a/internal/database/prisma/schema.prisma b/internal/database/prisma/schema.prisma
index 36669dd2..1947d466 100644
--- a/internal/database/prisma/schema.prisma
+++ b/internal/database/prisma/schema.prisma
@@ -231,6 +231,7 @@ model VehicleSnapshot {
   vehicleId   String
   referenceId String
 
+  battles      Int
   frameEncoded Bytes
 
   @@index([createdAt])
diff --git a/internal/database/snapshots.go b/internal/database/snapshots.go
index 2ae81f9a..e458d407 100644
--- a/internal/database/snapshots.go
+++ b/internal/database/snapshots.go
@@ -10,7 +10,13 @@ import (
 	"github.com/steebchen/prisma-client-go/runtime/transaction"
 )
 
-// model AccountSnapshot {
+type snapshotType string
+
+const (
+	SnapshotTypeDaily snapshotType = "daily"
+)
+
+// model VehicleSnapshot {
 //   id        String   @id @default(cuid())
 //   createdAt DateTime
 
@@ -18,20 +24,47 @@ import (
 //   lastBattleTime DateTime
 
 //   accountId   String
+//   vehicleId   String
 //   referenceId String
 
 //   frameEncoded Bytes
 
 //   @@index([createdAt])
-//   @@index([accountId, lastBattleTime])
-//   @@map("account_snapshots")
+//   @@index([accountId, vehicleId, lastBattleTime])
+//   @@map("vehicle_snapshots")
 // }
 
-type snapshotType string
+type VehicleSnapshot struct {
+	ID        string
+	CreatedAt time.Time
 
-const (
-	SnapshotTypeDaily snapshotType = "daily"
-)
+	Type           snapshotType
+	LastBattleTime time.Time
+
+	AccountID   string
+	VehicleID   string
+	ReferenceID string
+
+	Stats frame.StatsFrame
+}
+
+func (s *VehicleSnapshot) FromModel(model db.VehicleSnapshotModel) error {
+	s.ID = model.ID
+	s.Type = snapshotType(model.Type)
+	s.CreatedAt = model.CreatedAt
+	s.LastBattleTime = model.LastBattleTime
+
+	s.AccountID = model.AccountID
+	s.VehicleID = model.VehicleID
+	s.ReferenceID = model.ReferenceID
+
+	stats, err := frame.DecodeStatsFrame(model.FrameEncoded)
+	if err != nil {
+		return err
+	}
+	s.Stats = stats
+	return nil
+}
 
 type AccountSnapshot struct {
 	ID             string
@@ -67,6 +100,36 @@ func (s *AccountSnapshot) FromModel(model db.AccountSnapshotModel) error {
 	return nil
 }
 
+func (c *client) CreateVehicleSnapshots(ctx context.Context, snapshots ...VehicleSnapshot) error {
+	if len(snapshots) < 1 {
+		return nil
+	}
+
+	var transactions []transaction.Transaction
+	for _, data := range snapshots {
+		encoded, err := data.Stats.Encode()
+		if err != nil {
+			log.Err(err).Str("accountId", data.AccountID).Str("vehicleId", data.VehicleID).Msg("failed to encode a stats frame for vehicle snapthsot")
+			continue
+		}
+
+		transactions = append(transactions, c.prisma.VehicleSnapshot.
+			CreateOne(
+				db.VehicleSnapshot.CreatedAt.Set(data.CreatedAt),
+				db.VehicleSnapshot.Type.Set(string(data.Type)),
+				db.VehicleSnapshot.LastBattleTime.Set(data.LastBattleTime),
+				db.VehicleSnapshot.AccountID.Set(data.AccountID),
+				db.VehicleSnapshot.VehicleID.Set(data.VehicleID),
+				db.VehicleSnapshot.ReferenceID.Set(data.ReferenceID),
+				db.VehicleSnapshot.Battles.Set(int(data.Stats.Battles)),
+				db.VehicleSnapshot.FrameEncoded.Set(encoded),
+			).Tx(),
+		)
+	}
+
+	return c.prisma.Prisma.Transaction(transactions...).Exec(ctx)
+}
+
 func (c *client) CreateAccountSnapshots(ctx context.Context, snapshots ...AccountSnapshot) error {
 	if len(snapshots) < 1 {
 		return nil
diff --git a/internal/database/tasks.go b/internal/database/tasks.go
index 292253ee..b87fcfed 100644
--- a/internal/database/tasks.go
+++ b/internal/database/tasks.go
@@ -17,6 +17,8 @@ const (
 	TaskTypeRecordSessions           TaskType = "RECORD_ACCOUNT_SESSIONS"
 	TaskTypeUpdateAccountWN8         TaskType = "UPDATE_ACCOUNT_WN8"
 	TaskTypeRecordPlayerAchievements TaskType = "UPDATE_ACCOUNT_ACHIEVEMENTS"
+
+	TaskTypeDatabaseCleanup TaskType = "CLEANUP_DATABASE"
 )
 
 // Task statuses
@@ -126,6 +128,26 @@ func NewAttemptLog(task Task, comment, err string) TaskLog {
 	}
 }
 
+/*
+Returns up limit tasks that have TaskStatusInProgress and were last updates 1+ hours ago
+*/
+func (c *client) GetStaleTasks(ctx context.Context, limit int) ([]Task, error) {
+	models, err := c.prisma.CronTask.FindMany(db.CronTask.And(
+		db.CronTask.Status.Equals(string(TaskStatusInProgress)),
+		db.CronTask.UpdatedAt.Before(time.Now().Add(time.Hour*-1)),
+	)).OrderBy(db.CronTask.ScheduledAfter.Order(db.ASC)).Take(limit).Exec(ctx)
+	if err != nil && !db.IsErrNotFound(err) {
+		return nil, err
+	}
+
+	var tasks []Task
+	for _, model := range models {
+		tasks = append(tasks, Task{}.FromModel(model))
+	}
+
+	return tasks, nil
+}
+
 /*
 GetAndStartTasks retrieves up to limit number of tasks matching the referenceId and updates their status to in progress
   - this func will block until all other calls to task update funcs are done
diff --git a/internal/stats/fetch/convert.go b/internal/stats/fetch/convert.go
index 96a4a838..84c0a4ff 100644
--- a/internal/stats/fetch/convert.go
+++ b/internal/stats/fetch/convert.go
@@ -38,11 +38,11 @@ func WargamingToStats(realm string, accountData types.ExtendedAccount, clanMembe
 		// we got the stats, so the account is obv not private at this point
 		Account: wargamingToAccount(realm, accountData, clanMember, false),
 		RegularBattles: StatsWithVehicles{
-			StatsFrame: wargamingToFrame(accountData.Statistics.All),
-			Vehicles:   wargamingVehiclesToFrame(vehicleData),
+			StatsFrame: WargamingToFrame(accountData.Statistics.All),
+			Vehicles:   WargamingVehiclesToFrame(vehicleData),
 		},
 		RatingBattles: StatsWithVehicles{
-			StatsFrame: wargamingToFrame(accountData.Statistics.Rating),
+			StatsFrame: WargamingToFrame(accountData.Statistics.Rating),
 			Vehicles:   make(map[string]frame.VehicleStatsFrame),
 		},
 		LastBattleTime: timestampToTime(accountData.LastBattleTime),
@@ -57,7 +57,7 @@ func WargamingToStats(realm string, accountData types.ExtendedAccount, clanMembe
 	return stats
 }
 
-func wargamingToFrame(wg types.StatsFrame) frame.StatsFrame {
+func WargamingToFrame(wg types.StatsFrame) frame.StatsFrame {
 	return frame.StatsFrame{
 		Battles:              frame.ValueInt(wg.Battles),
 		BattlesWon:           frame.ValueInt(wg.Wins),
@@ -75,12 +75,12 @@ func wargamingToFrame(wg types.StatsFrame) frame.StatsFrame {
 	}
 }
 
-func wargamingVehiclesToFrame(wg []types.VehicleStatsFrame) map[string]frame.VehicleStatsFrame {
+func WargamingVehiclesToFrame(wg []types.VehicleStatsFrame) map[string]frame.VehicleStatsFrame {
 	stats := make(map[string]frame.VehicleStatsFrame)
 
 	for _, record := range wg {
 		id := strconv.Itoa(record.TankID)
-		inner := wargamingToFrame(record.Stats)
+		inner := WargamingToFrame(record.Stats)
 		stats[id] = frame.VehicleStatsFrame{
 			VehicleID:      id,
 			StatsFrame:     &inner,

From 39d1dba61db5f0232ced5514e45d558f784cebe0 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Tue, 11 Jun 2024 14:07:32 -0400
Subject: [PATCH 029/341] migration

---
 .../migration.sql                             | 48 +++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 internal/database/prisma/migrations/20240611180703_added_snapshots/migration.sql

diff --git a/internal/database/prisma/migrations/20240611180703_added_snapshots/migration.sql b/internal/database/prisma/migrations/20240611180703_added_snapshots/migration.sql
new file mode 100644
index 00000000..6a503643
--- /dev/null
+++ b/internal/database/prisma/migrations/20240611180703_added_snapshots/migration.sql
@@ -0,0 +1,48 @@
+/*
+  Warnings:
+
+  - You are about to drop the column `frameEncoded` on the `account_snapshots` table. All the data in the column will be lost.
+  - Added the required column `battles` to the `vehicle_snapshots` table without a default value. This is not possible if the table is not empty.
+  - Added the required column `ratingBattles` to the `account_snapshots` table without a default value. This is not possible if the table is not empty.
+  - Added the required column `ratingFrameEncoded` to the `account_snapshots` table without a default value. This is not possible if the table is not empty.
+  - Added the required column `regularBattles` to the `account_snapshots` table without a default value. This is not possible if the table is not empty.
+  - Added the required column `regularFrameEncoded` to the `account_snapshots` table without a default value. This is not possible if the table is not empty.
+
+*/
+-- RedefineTables
+PRAGMA foreign_keys=OFF;
+CREATE TABLE "new_vehicle_snapshots" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "createdAt" DATETIME NOT NULL,
+    "type" TEXT NOT NULL,
+    "lastBattleTime" DATETIME NOT NULL,
+    "accountId" TEXT NOT NULL,
+    "vehicleId" TEXT NOT NULL,
+    "referenceId" TEXT NOT NULL,
+    "battles" INTEGER NOT NULL,
+    "frameEncoded" BLOB NOT NULL
+);
+INSERT INTO "new_vehicle_snapshots" ("accountId", "createdAt", "frameEncoded", "id", "lastBattleTime", "referenceId", "type", "vehicleId") SELECT "accountId", "createdAt", "frameEncoded", "id", "lastBattleTime", "referenceId", "type", "vehicleId" FROM "vehicle_snapshots";
+DROP TABLE "vehicle_snapshots";
+ALTER TABLE "new_vehicle_snapshots" RENAME TO "vehicle_snapshots";
+CREATE INDEX "vehicle_snapshots_createdAt_idx" ON "vehicle_snapshots"("createdAt");
+CREATE INDEX "vehicle_snapshots_accountId_vehicleId_lastBattleTime_idx" ON "vehicle_snapshots"("accountId", "vehicleId", "lastBattleTime");
+CREATE TABLE "new_account_snapshots" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "createdAt" DATETIME NOT NULL,
+    "type" TEXT NOT NULL,
+    "lastBattleTime" DATETIME NOT NULL,
+    "accountId" TEXT NOT NULL,
+    "referenceId" TEXT NOT NULL,
+    "ratingBattles" INTEGER NOT NULL,
+    "ratingFrameEncoded" BLOB NOT NULL,
+    "regularBattles" INTEGER NOT NULL,
+    "regularFrameEncoded" BLOB NOT NULL
+);
+INSERT INTO "new_account_snapshots" ("accountId", "createdAt", "id", "lastBattleTime", "referenceId", "type") SELECT "accountId", "createdAt", "id", "lastBattleTime", "referenceId", "type" FROM "account_snapshots";
+DROP TABLE "account_snapshots";
+ALTER TABLE "new_account_snapshots" RENAME TO "account_snapshots";
+CREATE INDEX "account_snapshots_createdAt_idx" ON "account_snapshots"("createdAt");
+CREATE INDEX "account_snapshots_accountId_lastBattleTime_idx" ON "account_snapshots"("accountId", "lastBattleTime");
+PRAGMA foreign_key_check;
+PRAGMA foreign_keys=ON;

From fbd192a5ab43838d939f212f73c19e144c962de8 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Tue, 11 Jun 2024 14:09:12 -0400
Subject: [PATCH 030/341] added missing code

---
 internal/database/cleanup.go | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/internal/database/cleanup.go b/internal/database/cleanup.go
index dffc0bf3..4f045503 100644
--- a/internal/database/cleanup.go
+++ b/internal/database/cleanup.go
@@ -9,7 +9,19 @@ import (
 
 func (c *client) DeleteExpiredTasks(ctx context.Context, expiration time.Time) error {
 	_, err := c.prisma.CronTask.FindMany(db.CronTask.CreatedAt.Before(expiration)).Delete().Exec(ctx)
-	if err != nil && db.IsErrNotFound(err) {
+	if err != nil && !db.IsErrNotFound(err) {
+		return err
+	}
+	return nil
+}
+
+func (c *client) DeleteExpiredSnapshots(ctx context.Context, expiration time.Time) error {
+	_, err := c.prisma.AccountSnapshot.FindMany(db.AccountSnapshot.CreatedAt.Before(expiration)).Delete().Exec(ctx)
+	if err != nil && !db.IsErrNotFound(err) {
+		return err
+	}
+	_, err = c.prisma.VehicleSnapshot.FindMany(db.VehicleSnapshot.CreatedAt.Before(expiration)).Delete().Exec(ctx)
+	if err != nil && !db.IsErrNotFound(err) {
 		return err
 	}
 	return nil

From 518a988c5a45358aa4f521908f7477d0c5908988 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Tue, 11 Jun 2024 14:12:28 -0400
Subject: [PATCH 031/341] more missing changes :sweat_smile:

---
 cmds/core/scheduler/tasks/sessions.go | 11 ++++++-----
 internal/stats/fetch/convert.go       |  2 +-
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/cmds/core/scheduler/tasks/sessions.go b/cmds/core/scheduler/tasks/sessions.go
index 137d2e90..872b5b82 100644
--- a/cmds/core/scheduler/tasks/sessions.go
+++ b/cmds/core/scheduler/tasks/sessions.go
@@ -36,6 +36,7 @@ func init() {
 				task.Data["triesLeft"] = int(0) // do not retry
 				return "targed ids cannot be left blank", errors.New("invalid targets length")
 			}
+			forceUpdate, _ := task.Data["force"].(bool)
 
 			log.Debug().Str("taskId", task.ID).Any("targets", task.Targets).Msg("started working on a session refresh task")
 
@@ -65,9 +66,9 @@ func init() {
 					}(id)
 					continue
 				}
-				if data.LastBattleTime < int(createdAt.Add(time.Hour*-25).Unix()) {
-					log.Debug().Str("accountId", id).Str("taskId", task.ID).Msg("account played no battles")
+				if !forceUpdate && data.LastBattleTime < int(createdAt.Add(time.Hour*-25).Unix()) {
 					// if the last battle was played 25+ hours ago, there is nothing for us to update
+					log.Debug().Str("accountId", id).Str("taskId", task.ID).Msg("account played no battles")
 					continue
 				}
 				validAccouts = append(validAccouts, id)
@@ -133,15 +134,15 @@ func init() {
 						RatingBattles:  stats.RatingBattles.StatsFrame,
 						RegularBattles: stats.RegularBattles.StatsFrame,
 					})
-
 					if len(vehicles) < 1 {
 						continue
 					}
+
 					vehicleStats := fetch.WargamingVehiclesToFrame(vehicles)
 					for _, vehicle := range vehicleStats {
-						if vehicle.LastBattleTime.Before(createdAt.Add(time.Hour * -25)) {
-							log.Debug().Str("accountId", id).Str("taskId", task.ID).Msg("account played no battles")
+						if !forceUpdate && vehicle.LastBattleTime.Before(createdAt.Add(time.Hour*-25)) {
 							// if the last battle was played 25+ hours ago, there is nothing for us to update
+							log.Debug().Str("accountId", id).Str("vehicleId", vehicle.VehicleID).Str("taskId", task.ID).Msg("vehicle played no battles")
 							continue
 						}
 						vehicleSnapshots = append(vehicleSnapshots, database.VehicleSnapshot{
diff --git a/internal/stats/fetch/convert.go b/internal/stats/fetch/convert.go
index 84c0a4ff..224ea83c 100644
--- a/internal/stats/fetch/convert.go
+++ b/internal/stats/fetch/convert.go
@@ -122,7 +122,7 @@ func blitzstarsToStats(vehicles map[string]frame.VehicleStatsFrame, histories ma
 		}
 
 		if selectedEntry.Stats.Battles < int(vehicle.Battles) {
-			selectedFrame := wargamingToFrame(selectedEntry.Stats)
+			selectedFrame := WargamingToFrame(selectedEntry.Stats)
 			vehicle.StatsFrame.Subtract(selectedFrame)
 
 			stats.Vehicles[vehicle.VehicleID] = vehicle

From ab32f0e7791952736c0aa03028ce6be107a31b85 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Tue, 11 Jun 2024 14:28:28 -0400
Subject: [PATCH 032/341] fixed how period is calculated

---
 internal/stats/fetch/convert.go       |  4 ++--
 internal/stats/fetch/multisource.go   |  1 +
 internal/stats/prepare/period/card.go | 18 +++++++++++-------
 3 files changed, 14 insertions(+), 9 deletions(-)

diff --git a/internal/stats/fetch/convert.go b/internal/stats/fetch/convert.go
index 224ea83c..342d1a18 100644
--- a/internal/stats/fetch/convert.go
+++ b/internal/stats/fetch/convert.go
@@ -46,11 +46,11 @@ func WargamingToStats(realm string, accountData types.ExtendedAccount, clanMembe
 			Vehicles:   make(map[string]frame.VehicleStatsFrame),
 		},
 		LastBattleTime: timestampToTime(accountData.LastBattleTime),
-		PeriodStart:    time.Now(),
 		PeriodEnd:      timestampToTime(accountData.LastBattleTime),
+		PeriodStart:    timestampToTime(accountData.CreatedAt),
 	}
 	// An account can be blank with no last battle played
-	if stats.PeriodEnd.Before(stats.PeriodStart) {
+	if stats.LastBattleTime.IsZero() {
 		stats.PeriodEnd = stats.PeriodStart
 	}
 
diff --git a/internal/stats/fetch/multisource.go b/internal/stats/fetch/multisource.go
index a98242e9..bd59099e 100644
--- a/internal/stats/fetch/multisource.go
+++ b/internal/stats/fetch/multisource.go
@@ -193,6 +193,7 @@ func (c *multiSourceClient) PeriodStats(ctx context.Context, id string, periodSt
 		return AccountStatsOverPeriod{}, histories.Err
 	}
 
+	current.Data.PeriodEnd = time.Now()
 	current.Data.PeriodStart = periodStart
 	current.Data.RatingBattles = StatsWithVehicles{} // blitzstars do not provide rating battles stats
 	current.Data.RegularBattles = blitzstarsToStats(current.Data.RegularBattles.Vehicles, histories.Data, periodStart)
diff --git a/internal/stats/prepare/period/card.go b/internal/stats/prepare/period/card.go
index 5931d109..1b43c812 100644
--- a/internal/stats/prepare/period/card.go
+++ b/internal/stats/prepare/period/card.go
@@ -2,6 +2,7 @@ package period
 
 import (
 	"fmt"
+	"math"
 
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/stats/fetch"
@@ -41,21 +42,24 @@ func NewCards(stats fetch.AccountStatsOverPeriod, glossary map[string]database.V
 	}
 
 	// Vehicle Highlights
-	var minimumBattles int = 5
+	var minimumBattles float64 = 5
 	periodDays := stats.PeriodEnd.Sub(stats.PeriodStart).Hours() / 24
+	withFallback := func(battles float64) float64 {
+		return math.Min(battles, float64(stats.RegularBattles.Battles.Float())/float64(len(selectedHighlights)))
+	}
 	if periodDays > 90 {
-		minimumBattles = 100
+		minimumBattles = withFallback(100)
 	} else if periodDays > 60 {
-		minimumBattles = 75
+		minimumBattles = withFallback(75)
 	} else if periodDays > 30 {
-		minimumBattles = 50
+		minimumBattles = withFallback(50)
 	} else if periodDays > 14 {
-		minimumBattles = 25
+		minimumBattles = withFallback(25)
 	} else if periodDays > 7 {
-		minimumBattles = 10
+		minimumBattles = withFallback(10)
 	}
 
-	highlightedVehicles := getHighlightedVehicles(selectedHighlights, stats.RegularBattles.Vehicles, minimumBattles)
+	highlightedVehicles := getHighlightedVehicles(selectedHighlights, stats.RegularBattles.Vehicles, int(minimumBattles))
 	for _, data := range highlightedVehicles {
 		var vehicleBlocks []common.StatsBlock[BlockData]
 

From 9c678a4b8815344e12e479c698bdaabdd10f3069 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Tue, 11 Jun 2024 15:26:48 -0400
Subject: [PATCH 033/341] fixed bad calculations

---
 .air.toml                                    |  2 +
 internal/stats/render/common/images.go       | 56 +++++++-------------
 internal/stats/render/common/player-title.go |  3 +-
 internal/stats/render/common/strings.go      |  3 ++
 internal/stats/render/period/cards.go        |  8 ++-
 internal/stats/render/period/constants.go    |  2 +-
 6 files changed, 30 insertions(+), 44 deletions(-)
 create mode 100644 .air.toml

diff --git a/.air.toml b/.air.toml
new file mode 100644
index 00000000..44d5d232
--- /dev/null
+++ b/.air.toml
@@ -0,0 +1,2 @@
+[build]
+stop_on_error = true
diff --git a/internal/stats/render/common/images.go b/internal/stats/render/common/images.go
index b350da6c..5e5f6ab3 100644
--- a/internal/stats/render/common/images.go
+++ b/internal/stats/render/common/images.go
@@ -142,8 +142,6 @@ type imageSize struct {
 	extraSpacingX float64
 	extraSpacingY float64
 
-	totalGap float64
-
 	maxElementWidth  float64
 	maxElementHeight float64
 }
@@ -151,63 +149,47 @@ type imageSize struct {
 func getDetailedSize(images []image.Image, style Style) imageSize {
 	imageWidth, imageHeight := style.Width, style.Height
 
-	var totalGap float64
-	if len(images) > 1 {
-		totalGap = float64(len(images)-1) * style.Gap
-	}
-
-	var totalWidth float64 = style.PaddingX * 2
-	var totalHeight float64 = style.PaddingY * 2
-
+	var totalWidth float64
+	var totalHeight float64
 	maxWidth, maxHeight := 0.0, 0.0
-
 	for _, img := range images {
 		imgX := float64(img.Bounds().Dx())
-		if imgX > maxWidth {
-			maxWidth = imgX
-		}
+		maxWidth = max(maxWidth, imgX)
 
 		imgY := float64(img.Bounds().Dy())
-		if imgY > maxHeight {
-			maxHeight = imgY
-		}
+		maxHeight = max(maxHeight, imgY)
 
 		if style.Direction == DirectionHorizontal {
 			totalWidth += float64(img.Bounds().Dx())
+			totalHeight = max(totalHeight, imgY)
 		} else {
 			totalHeight += float64(img.Bounds().Dy())
+			totalWidth = max(totalWidth, imgX)
 		}
 	}
 
-	if style.Width == 0 {
+	totalWidth += style.PaddingX * 2
+	totalHeight += style.PaddingY * 2
+	totalGap := float64(len(images)-1) * style.Gap
+
+	switch style.Direction {
+	case DirectionVertical:
+		totalHeight += totalGap
+	case DirectionHorizontal:
+		totalWidth += totalGap
+	}
+
+	if imageWidth < 1 {
 		imageWidth = totalWidth
 	}
-	if style.Height == 0 {
+	if imageHeight < 1 {
 		imageHeight = totalHeight
 	}
 
 	extraSpacingX := imageWidth - totalWidth
 	extraSpacingY := imageHeight - totalHeight
 
-	switch style.Direction {
-	case DirectionVertical:
-		if extraSpacingY < totalGap {
-			imageHeight += totalGap
-		}
-		if style.Width == 0 {
-			imageWidth = maxWidth + (style.PaddingX * 2)
-		}
-	default: // DirectionHorizontal
-		if extraSpacingX < totalGap {
-			imageWidth += totalGap
-		}
-		if style.Height == 0 {
-			imageHeight = maxHeight + (style.PaddingY)*2
-		}
-	}
-
 	return imageSize{
-		totalGap:         totalGap,
 		width:            imageWidth,
 		height:           imageHeight,
 		extraSpacingX:    extraSpacingX,
diff --git a/internal/stats/render/common/player-title.go b/internal/stats/render/common/player-title.go
index e8bd5036..bced65f9 100644
--- a/internal/stats/render/common/player-title.go
+++ b/internal/stats/render/common/player-title.go
@@ -20,6 +20,7 @@ func (style TitleCardStyle) TotalPaddingAndGaps() float64 {
 func DefaultPlayerTitleStyle(containerStyle Style) TitleCardStyle {
 	containerStyle.AlignItems = AlignItemsCenter
 	containerStyle.Direction = DirectionHorizontal
+	// containerStyle.Debug = true
 
 	clanTagBackgroundColor := DefaultCardColor
 	clanTagBackgroundColor.R += 10
@@ -29,7 +30,7 @@ func DefaultPlayerTitleStyle(containerStyle Style) TitleCardStyle {
 	return TitleCardStyle{
 		Container: containerStyle,
 		Nickname:  Style{Font: &FontLarge, FontColor: TextPrimary},
-		ClanTag:   Style{Font: &FontMedium, FontColor: TextSecondary, PaddingX: 10, PaddingY: 5, BackgroundColor: clanTagBackgroundColor, BorderRadius: 10},
+		ClanTag:   Style{Font: &FontMedium, FontColor: TextSecondary, PaddingX: 10, PaddingY: 5, BackgroundColor: clanTagBackgroundColor, BorderRadius: 15},
 	}
 }
 
diff --git a/internal/stats/render/common/strings.go b/internal/stats/render/common/strings.go
index 4fd5f8f6..c6a3ba15 100644
--- a/internal/stats/render/common/strings.go
+++ b/internal/stats/render/common/strings.go
@@ -18,6 +18,9 @@ func MeasureString(text string, font font.Face) stringSize {
 	if font == nil {
 		return stringSize{}
 	}
+	if text == "" {
+		return stringSize{}
+	}
 
 	measureCtx := gg.NewContext(1, 1)
 	measureCtx.SetFontFace(font)
diff --git a/internal/stats/render/period/cards.go b/internal/stats/render/period/cards.go
index 7c23d2f1..fb83d91d 100644
--- a/internal/stats/render/period/cards.go
+++ b/internal/stats/render/period/cards.go
@@ -103,17 +103,15 @@ func generateCards(stats fetch.AccountStatsOverPeriod, cards period.Cards, subs
 		if err != nil {
 			return segments, err
 		}
-		cardWidth = common.Max(cardWidth, float64(footerImage.Bounds().Dx()))
 		segments.AddFooter(common.NewImageContent(common.Style{Width: cardWidth, Height: float64(footerImage.Bounds().Dy())}, footerImage))
 	}
 
 	// Header card
-	if headerCard, headerCardExists := newHeaderCard(subs, opts); headerCardExists {
+	if headerCard, headerCardExists := newHeaderCard(cardWidth, subs, opts); headerCardExists {
 		headerImage, err := headerCard.Render()
 		if err != nil {
 			return segments, err
 		}
-		cardWidth = common.Max(cardWidth, float64(headerImage.Bounds().Dx()))
 		segments.AddHeader(common.NewImageContent(common.Style{Width: cardWidth, Height: float64(headerImage.Bounds().Dy())}, headerImage))
 	}
 
@@ -141,7 +139,7 @@ func generateCards(stats fetch.AccountStatsOverPeriod, cards period.Cards, subs
 	return segments, nil
 }
 
-func newHeaderCard(subscriptions []database.UserSubscription, options render.Options) (common.Block, bool) {
+func newHeaderCard(width float64, subscriptions []database.UserSubscription, options render.Options) (common.Block, bool) {
 	var cards []common.Block
 
 	var addPromoText = true
@@ -180,7 +178,7 @@ func newHeaderCard(subscriptions []database.UserSubscription, options render.Opt
 		return common.Block{}, false
 	}
 
-	return common.NewBlocksContent(common.Style{Direction: common.DirectionVertical, AlignItems: common.AlignItemsCenter, JustifyContent: common.JustifyContentCenter, Gap: 10}, cards...), true
+	return common.NewBlocksContent(common.Style{Direction: common.DirectionVertical, AlignItems: common.AlignItemsCenter, JustifyContent: common.JustifyContentCenter, Gap: 10, Width: width}, cards...), true
 }
 
 func newHighlightCard(style highlightStyle, card period.VehicleCard) common.Block {
diff --git a/internal/stats/render/period/constants.go b/internal/stats/render/period/constants.go
index bbb2b7a3..a919ef50 100644
--- a/internal/stats/render/period/constants.go
+++ b/internal/stats/render/period/constants.go
@@ -82,7 +82,7 @@ func overviewCardStyle(width float64) common.Style {
 
 func highlightCardStyle(containerStyle common.Style) highlightStyle {
 	container := containerStyle
-	container.Gap = 5
+	container.Gap = 10
 	container.PaddingX = 20
 	container.PaddingY = 15
 	container.Direction = common.DirectionHorizontal

From 3a83c557a32db4d7e80795edb109133c6a6db7bc Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Tue, 11 Jun 2024 15:54:02 -0400
Subject: [PATCH 034/341] fixed bad gap math

---
 internal/stats/render/common/images.go       | 6 ++++--
 internal/stats/render/common/player-title.go | 6 +++---
 internal/stats/render/period/cards.go        | 6 +-----
 internal/stats/render/period/constants.go    | 1 +
 4 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/internal/stats/render/common/images.go b/internal/stats/render/common/images.go
index 5e5f6ab3..7747d34f 100644
--- a/internal/stats/render/common/images.go
+++ b/internal/stats/render/common/images.go
@@ -93,7 +93,7 @@ func renderImages(images []image.Image, style Style) (image.Image, error) {
 		switch style.Direction {
 		case DirectionVertical:
 			if i > 0 {
-				posY += max(style.Gap, justifyOffsetY)
+				posY += justifyOffsetY + style.Gap
 			}
 			lastY = posY + targetHeight
 
@@ -107,7 +107,7 @@ func renderImages(images []image.Image, style Style) (image.Image, error) {
 			}
 		default: // DirectionHorizontal
 			if i > 0 {
-				posX += max(style.Gap, justifyOffsetX)
+				posX += justifyOffsetX + style.Gap
 			}
 			lastX = posX + targetWidth
 
@@ -138,6 +138,7 @@ type imageSize struct {
 	width  float64
 	height float64
 
+	totalGap float64
 	// The amount of extra spacing added to the image, used for alignment
 	extraSpacingX float64
 	extraSpacingY float64
@@ -192,6 +193,7 @@ func getDetailedSize(images []image.Image, style Style) imageSize {
 	return imageSize{
 		width:            imageWidth,
 		height:           imageHeight,
+		totalGap:         totalGap,
 		extraSpacingX:    extraSpacingX,
 		extraSpacingY:    extraSpacingY,
 		maxElementWidth:  maxWidth,
diff --git a/internal/stats/render/common/player-title.go b/internal/stats/render/common/player-title.go
index bced65f9..07bf771c 100644
--- a/internal/stats/render/common/player-title.go
+++ b/internal/stats/render/common/player-title.go
@@ -23,9 +23,9 @@ func DefaultPlayerTitleStyle(containerStyle Style) TitleCardStyle {
 	// containerStyle.Debug = true
 
 	clanTagBackgroundColor := DefaultCardColor
-	clanTagBackgroundColor.R += 10
-	clanTagBackgroundColor.G += 10
-	clanTagBackgroundColor.B += 10
+	clanTagBackgroundColor.R += 15
+	clanTagBackgroundColor.G += 15
+	clanTagBackgroundColor.B += 15
 
 	return TitleCardStyle{
 		Container: containerStyle,
diff --git a/internal/stats/render/period/cards.go b/internal/stats/render/period/cards.go
index fb83d91d..69ed06e0 100644
--- a/internal/stats/render/period/cards.go
+++ b/internal/stats/render/period/cards.go
@@ -108,11 +108,7 @@ func generateCards(stats fetch.AccountStatsOverPeriod, cards period.Cards, subs
 
 	// Header card
 	if headerCard, headerCardExists := newHeaderCard(cardWidth, subs, opts); headerCardExists {
-		headerImage, err := headerCard.Render()
-		if err != nil {
-			return segments, err
-		}
-		segments.AddHeader(common.NewImageContent(common.Style{Width: cardWidth, Height: float64(headerImage.Bounds().Dy())}, headerImage))
+		segments.AddHeader(headerCard)
 	}
 
 	// Player Title card
diff --git a/internal/stats/render/period/constants.go b/internal/stats/render/period/constants.go
index a919ef50..d50686ee 100644
--- a/internal/stats/render/period/constants.go
+++ b/internal/stats/render/period/constants.go
@@ -65,6 +65,7 @@ func defaultCardStyle(width float64) common.Style {
 func titleCardStyle(width float64) common.Style {
 	style := defaultCardStyle(width)
 	style.PaddingX = style.PaddingY
+	// style.Debug = true
 	return style
 }
 

From 06605f90fdb8797114aac86e50cde3a01e965d47 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Tue, 11 Jun 2024 15:58:34 -0400
Subject: [PATCH 035/341] shorted date strings

---
 internal/stats/render/period/cards.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/internal/stats/render/period/cards.go b/internal/stats/render/period/cards.go
index 69ed06e0..27e2326a 100644
--- a/internal/stats/render/period/cards.go
+++ b/internal/stats/render/period/cards.go
@@ -91,8 +91,8 @@ func generateCards(stats fetch.AccountStatsOverPeriod, cards period.Cards, subs
 			footer = append(footer, "Asia")
 		}
 
-		sessionTo := stats.PeriodEnd.Format("January 2, 2006")
-		sessionFrom := stats.PeriodStart.Format("January 2, 2006")
+		sessionTo := stats.PeriodEnd.Format("Jan 2, 2006")
+		sessionFrom := stats.PeriodStart.Format("Jan 2, 2006")
 		if sessionFrom == sessionTo {
 			footer = append(footer, sessionTo)
 		} else {

From 63d973b5e0a46b46a5571e7ce15ff478a3677aad Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Tue, 11 Jun 2024 16:15:37 -0400
Subject: [PATCH 036/341] more logs on err

---
 cmds/core/scheduler/tasks/cleanup.go      | 14 +++++++-------
 cmds/core/scheduler/tasks/sessions.go     |  3 ++-
 cmds/discord/common/context.go            |  3 ++-
 cmds/discord/rest/client.go               |  9 ++++++---
 cmds/discord/router/handler.go            | 12 ++++--------
 internal/database/users.go                |  3 ++-
 internal/localization/load.go             |  3 ++-
 internal/retry/retry.go                   |  3 ++-
 internal/stats/fetch/multisource.go       |  3 ++-
 internal/stats/fetch/replay/errors.go     |  2 +-
 internal/stats/image.go                   |  3 ++-
 internal/stats/prepare/common/card.go     |  2 +-
 internal/stats/prepare/common/tags.go     |  2 +-
 internal/stats/render/common/badges.go    |  3 ++-
 internal/stats/render/common/block.go     |  3 ++-
 internal/stats/render/common/constants.go |  3 ++-
 internal/stats/render/common/images.go    |  3 ++-
 internal/stats/render/period/cards.go     |  5 ++++-
 internal/stats/render/segments.go         |  3 ++-
 19 files changed, 48 insertions(+), 34 deletions(-)

diff --git a/cmds/core/scheduler/tasks/cleanup.go b/cmds/core/scheduler/tasks/cleanup.go
index afc1eaab..47177792 100644
--- a/cmds/core/scheduler/tasks/cleanup.go
+++ b/cmds/core/scheduler/tasks/cleanup.go
@@ -2,14 +2,14 @@ package tasks
 
 import (
 	"context"
-	"errors"
 	"time"
 
+	"github.com/pkg/errors"
+
 	"github.com/cufee/aftermath/cmds/core"
 	"github.com/cufee/aftermath/internal/database"
 )
 
-
 func init() {
 	defaultHandlers[database.TaskTypeDatabaseCleanup] = TaskHandler{
 		Process: func(client core.Client, task database.Task) (string, error) {
@@ -26,17 +26,17 @@ func init() {
 				return "invalid expiration_tasks", errors.New("failed to cast expiration_tasks to time")
 			}
 
-			ctx, cancel := context.WithTimeout(context.Background(), time.Second * 5)
+			ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 			defer cancel()
 
 			err := client.Database().DeleteExpiredTasks(ctx, taskExpiration)
 			if err != nil {
-			return 	"failed to delete expired tasks", err
+				return "failed to delete expired tasks", err
 			}
 
 			err = client.Database().DeleteExpiredSnapshots(ctx, snapshotExpiration)
 			if err != nil {
-			return 	"failed to delete expired snapshots", err
+				return "failed to delete expired snapshots", err
 			}
 
 			return "cleanup complete", nil
@@ -55,8 +55,8 @@ func CreateCleanupTasks(client core.Client) error {
 		ReferenceID:    "database_cleanup",
 		ScheduledAfter: now,
 		Data: map[string]any{
-			"expiration_snapshots":     now.Add(-1 * time.Hour * 24 * 90), // 90 days
-			"expiration_tasks": now.Add(-1 * time.Hour * 24 * 7), // 7 days
+			"expiration_snapshots": now.Add(-1 * time.Hour * 24 * 90), // 90 days
+			"expiration_tasks":     now.Add(-1 * time.Hour * 24 * 7),  // 7 days
 		},
 	}
 
diff --git a/cmds/core/scheduler/tasks/sessions.go b/cmds/core/scheduler/tasks/sessions.go
index 872b5b82..93f69a0d 100644
--- a/cmds/core/scheduler/tasks/sessions.go
+++ b/cmds/core/scheduler/tasks/sessions.go
@@ -2,11 +2,12 @@ package tasks
 
 import (
 	"context"
-	"errors"
 	"strings"
 	"sync"
 	"time"
 
+	"github.com/pkg/errors"
+
 	"github.com/cufee/aftermath/cmds/core"
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/retry"
diff --git a/cmds/discord/common/context.go b/cmds/discord/common/context.go
index e9e6b74e..48f745f4 100644
--- a/cmds/discord/common/context.go
+++ b/cmds/discord/common/context.go
@@ -2,10 +2,11 @@ package common
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"io"
 
+	"github.com/pkg/errors"
+
 	"github.com/bwmarrin/discordgo"
 	"github.com/cufee/aftermath/cmds/core"
 	"github.com/cufee/aftermath/cmds/discord/rest"
diff --git a/cmds/discord/rest/client.go b/cmds/discord/rest/client.go
index bbc26f9f..859686cc 100644
--- a/cmds/discord/rest/client.go
+++ b/cmds/discord/rest/client.go
@@ -3,15 +3,16 @@ package rest
 import (
 	"bytes"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"io"
 	"mime/multipart"
 	"net/http"
 	"net/textproto"
-	"strings"
+	"runtime/debug"
 	"time"
 
+	"github.com/pkg/errors"
+
 	"github.com/bwmarrin/discordgo"
 	"github.com/cufee/aftermath/internal/retry"
 )
@@ -125,7 +126,9 @@ func (c *Client) do(req *http.Request, target any) error {
 				message = res.Status
 			}
 
-			return nil, errors.New("discord: " + strings.ToLower(message))
+			println(string(debug.Stack()))
+
+			return nil, errors.New("discord error: " + message)
 		}
 
 		if target != nil {
diff --git a/cmds/discord/router/handler.go b/cmds/discord/router/handler.go
index 7f11f828..c84fb04a 100644
--- a/cmds/discord/router/handler.go
+++ b/cmds/discord/router/handler.go
@@ -6,13 +6,14 @@ import (
 	"crypto/ed25519"
 	"encoding/hex"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"io"
 	"net/http"
 	"sync"
 	"time"
 
+	"github.com/pkg/errors"
+
 	"github.com/bwmarrin/discordgo"
 	"github.com/cufee/aftermath/cmds/discord/commands/builder"
 	"github.com/cufee/aftermath/cmds/discord/common"
@@ -242,16 +243,11 @@ func (r *Router) sendInteractionReply(interaction discordgo.Interaction, state *
 
 	switch interaction.Type {
 	case discordgo.InteractionApplicationCommand:
-		if state.replied {
+		if state.replied || state.acked {
 			// We already replied to this interaction - edit the message
 			handler = func() error {
 				return r.restClient.UpdateInteractionResponse(interaction.AppID, interaction.Token, data)
 			}
-		} else if state.acked {
-			// We acked this interaction and an initial reply is pending - edit the message
-			handler = func() error {
-				return r.restClient.UpdateInteractionResponse(interaction.AppID, interaction.Token, data)
-			}
 		} else {
 			// We never replied to this message, create a new reply
 			handler = func() error {
@@ -263,7 +259,7 @@ func (r *Router) sendInteractionReply(interaction discordgo.Interaction, state *
 
 	err := handler()
 	if err != nil {
-		log.Err(err).Any("data", data).Str("id", interaction.ID).Stack().Msg("failed to send an interaction response")
+		log.Err(err).Stack().Any("state", state).Any("data", data).Str("id", interaction.ID).Msg("failed to send an interaction response")
 		return
 	}
 	state.acked = true
diff --git a/internal/database/users.go b/internal/database/users.go
index 09dbc345..24d89cee 100644
--- a/internal/database/users.go
+++ b/internal/database/users.go
@@ -2,11 +2,12 @@ package database
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"slices"
 	"time"
 
+	"github.com/pkg/errors"
+
 	"github.com/cufee/aftermath/internal/database/prisma/db"
 	"github.com/cufee/aftermath/internal/encoding"
 	"github.com/cufee/aftermath/internal/permissions"
diff --git a/internal/localization/load.go b/internal/localization/load.go
index 28300e4a..3db9b5e6 100644
--- a/internal/localization/load.go
+++ b/internal/localization/load.go
@@ -2,12 +2,13 @@ package localization
 
 import (
 	"bytes"
-	"errors"
 	"fmt"
 	"io/fs"
 	"path/filepath"
 	"strings"
 
+	"github.com/pkg/errors"
+
 	"github.com/cufee/aftermath/internal/files"
 	"golang.org/x/text/language"
 	"gopkg.in/yaml.v3"
diff --git a/internal/retry/retry.go b/internal/retry/retry.go
index f45c4ad9..7585e5c6 100644
--- a/internal/retry/retry.go
+++ b/internal/retry/retry.go
@@ -1,8 +1,9 @@
 package retry
 
 import (
-	"errors"
 	"time"
+
+	"github.com/pkg/errors"
 )
 
 type DataWithErr[T any] struct {
diff --git a/internal/stats/fetch/multisource.go b/internal/stats/fetch/multisource.go
index bd59099e..42de615c 100644
--- a/internal/stats/fetch/multisource.go
+++ b/internal/stats/fetch/multisource.go
@@ -2,11 +2,12 @@ package fetch
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"sync"
 	"time"
 
+	"github.com/pkg/errors"
+
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/external/blitzstars"
 	"github.com/cufee/aftermath/internal/external/wargaming"
diff --git a/internal/stats/fetch/replay/errors.go b/internal/stats/fetch/replay/errors.go
index 03d97a99..2e80a91e 100644
--- a/internal/stats/fetch/replay/errors.go
+++ b/internal/stats/fetch/replay/errors.go
@@ -1,6 +1,6 @@
 package replay
 
-import "errors"
+import "github.com/pkg/errors"
 
 var (
 	ErrInvalidReplayFile = errors.New("invalid replay file")
diff --git a/internal/stats/image.go b/internal/stats/image.go
index 9e73843b..7e46305c 100644
--- a/internal/stats/image.go
+++ b/internal/stats/image.go
@@ -1,11 +1,12 @@
 package stats
 
 import (
-	"errors"
 	"image"
 	"image/png"
 	"io"
 
+	"github.com/pkg/errors"
+
 	"github.com/cufee/aftermath/internal/stats/render/common"
 )
 
diff --git a/internal/stats/prepare/common/card.go b/internal/stats/prepare/common/card.go
index 56e370ce..bfae299f 100644
--- a/internal/stats/prepare/common/card.go
+++ b/internal/stats/prepare/common/card.go
@@ -1,7 +1,7 @@
 package common
 
 import (
-	"errors"
+	"github.com/pkg/errors"
 
 	"github.com/cufee/aftermath/internal/stats/frame"
 )
diff --git a/internal/stats/prepare/common/tags.go b/internal/stats/prepare/common/tags.go
index 34301e15..4e171eae 100644
--- a/internal/stats/prepare/common/tags.go
+++ b/internal/stats/prepare/common/tags.go
@@ -1,7 +1,7 @@
 package common
 
 import (
-	"errors"
+	"github.com/pkg/errors"
 )
 
 type Tag string
diff --git a/internal/stats/render/common/badges.go b/internal/stats/render/common/badges.go
index 12e6e1dd..3d8e24c0 100644
--- a/internal/stats/render/common/badges.go
+++ b/internal/stats/render/common/badges.go
@@ -1,10 +1,11 @@
 package common
 
 import (
-	"errors"
 	"image/color"
 	"slices"
 
+	"github.com/pkg/errors"
+
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/stats/render/assets"
 )
diff --git a/internal/stats/render/common/block.go b/internal/stats/render/common/block.go
index da5987ec..c5b20853 100644
--- a/internal/stats/render/common/block.go
+++ b/internal/stats/render/common/block.go
@@ -1,10 +1,11 @@
 package common
 
 import (
-	"errors"
 	"image"
 	"strings"
 
+	"github.com/pkg/errors"
+
 	"github.com/disintegration/imaging"
 	"github.com/fogleman/gg"
 )
diff --git a/internal/stats/render/common/constants.go b/internal/stats/render/common/constants.go
index dcdcb341..05e81b19 100644
--- a/internal/stats/render/common/constants.go
+++ b/internal/stats/render/common/constants.go
@@ -1,9 +1,10 @@
 package common
 
 import (
-	"errors"
 	"image/color"
 
+	"github.com/pkg/errors"
+
 	"github.com/cufee/aftermath/internal/stats/render/assets"
 	"golang.org/x/image/font"
 )
diff --git a/internal/stats/render/common/images.go b/internal/stats/render/common/images.go
index 7747d34f..bda0c696 100644
--- a/internal/stats/render/common/images.go
+++ b/internal/stats/render/common/images.go
@@ -1,10 +1,11 @@
 package common
 
 import (
-	"errors"
 	"image"
 	"math"
 
+	"github.com/pkg/errors"
+
 	"github.com/disintegration/imaging"
 	"github.com/fogleman/gg"
 )
diff --git a/internal/stats/render/period/cards.go b/internal/stats/render/period/cards.go
index 27e2326a..107a5f02 100644
--- a/internal/stats/render/period/cards.go
+++ b/internal/stats/render/period/cards.go
@@ -1,9 +1,10 @@
 package period
 
 import (
-	"errors"
 	"strings"
 
+	"github.com/pkg/errors"
+
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/stats/fetch"
 	prepare "github.com/cufee/aftermath/internal/stats/prepare/common"
@@ -103,6 +104,8 @@ func generateCards(stats fetch.AccountStatsOverPeriod, cards period.Cards, subs
 		if err != nil {
 			return segments, err
 		}
+
+		cardWidth = max(cardWidth, float64(footerImage.Bounds().Dx()))
 		segments.AddFooter(common.NewImageContent(common.Style{Width: cardWidth, Height: float64(footerImage.Bounds().Dy())}, footerImage))
 	}
 
diff --git a/internal/stats/render/segments.go b/internal/stats/render/segments.go
index 561e915c..e3135c50 100644
--- a/internal/stats/render/segments.go
+++ b/internal/stats/render/segments.go
@@ -1,9 +1,10 @@
 package render
 
 import (
-	"errors"
 	"image"
 
+	"github.com/pkg/errors"
+
 	"github.com/cufee/aftermath/internal/stats/render/common"
 )
 

From f1862ba8c9fed2563ffab1fc116a87da0907acf7 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Wed, 12 Jun 2024 16:28:28 -0400
Subject: [PATCH 037/341] added sessions

---
 Taskfile.yaml                                 |  21 +-
 cmds/core/scheduler/tasks/sessions.go         |   8 +-
 cmds/discord/commands/builder/option.go       |   7 +
 cmds/discord/commands/session.go              |  76 ++++++
 cmds/discord/rest/client.go                   |  10 +-
 internal/database/client.go                   |   6 +-
 .../20240612202803_sessions/migration.sql     |  50 ++++
 internal/database/prisma/schema.prisma        |  16 +-
 internal/database/snapshots.go                | 254 ++++++++++++++----
 internal/database/snapshots_test.go           | 121 +++++++++
 internal/stats/fetch/client.go                |   2 +
 internal/stats/fetch/multisource.go           | 132 +++++++++
 internal/stats/fetch/multisource_test.go      |  27 ++
 internal/stats/frame/frame.go                 |  18 ++
 internal/stats/period.go                      |   8 -
 .../{player-title.go => player_title.go}      |   2 +-
 ...{tier-percentage.go => tier_percentage.go} |   0
 internal/stats/render/period/constants.go     |   1 +
 internal/stats/renderer.go                    |   8 +-
 internal/stats/session.go                     |  62 +++++
 main.go                                       |   2 +-
 21 files changed, 746 insertions(+), 85 deletions(-)
 create mode 100644 cmds/discord/commands/session.go
 create mode 100644 internal/database/prisma/migrations/20240612202803_sessions/migration.sql
 create mode 100644 internal/database/snapshots_test.go
 create mode 100644 internal/stats/fetch/multisource_test.go
 rename internal/stats/render/common/{player-title.go => player_title.go} (95%)
 rename internal/stats/render/common/{tier-percentage.go => tier_percentage.go} (100%)

diff --git a/Taskfile.yaml b/Taskfile.yaml
index 37aee1de..8f01f48b 100644
--- a/Taskfile.yaml
+++ b/Taskfile.yaml
@@ -8,6 +8,19 @@ vars:
   PRISMA_SCHEMA: --schema ./internal/database/prisma/schema.prisma
 
 tasks:
+  test:
+    desc: runs tests
+    env:
+      DATABASE_URL: "file:{{.USER_WORKING_DIR}}/tmp/local_test.db"
+    cmds:
+      - go run {{ .PRISMA_CLIENT }} db push {{ .PRISMA_SCHEMA }}
+      - |
+        if [ -z "{{ .CLI_ARGS }}" ]; then
+          go test -timeout 30s --count=1 -v ./...
+        else
+          go test -timeout 30s --count=1 -v -run {{ .CLI_ARGS }}
+        fi
+
   prisma-install:
     desc: installs the correct version of prisma
     cmd: go get {{ .PRISMA_CLIENT }}
@@ -18,19 +31,19 @@ tasks:
 
   db-push:
     desc: sync the database with the schema for development
-    cmd: go run {{ .PRISMA_CLIENT }} db push {{ .PRISMA_SCHEMA }} 
+    cmd: go run {{ .PRISMA_CLIENT }} db push {{ .PRISMA_SCHEMA }}
 
   db-generate:
     desc: re-generate the Go client
-    cmd: go run {{ .PRISMA_CLIENT }} generate {{ .PRISMA_SCHEMA }} 
+    cmd: go run {{ .PRISMA_CLIENT }} generate {{ .PRISMA_SCHEMA }}
 
   db-migrate-dev:
     desc: for production use, create a migration locally
-    cmd: go run {{ .PRISMA_CLIENT }} migrate dev {{ .PRISMA_SCHEMA }} 
+    cmd: go run {{ .PRISMA_CLIENT }} migrate dev {{ .PRISMA_SCHEMA }}
 
   db-migrate-deploy:
     desc: sync production database with migrations
-    cmd: go run {{ .PRISMA_CLIENT }} migrate deploy {{ .PRISMA_SCHEMA }} 
+    cmd: go run {{ .PRISMA_CLIENT }} migrate deploy {{ .PRISMA_SCHEMA }}
 
   dev:
     desc: Start a local dev server
diff --git a/cmds/core/scheduler/tasks/sessions.go b/cmds/core/scheduler/tasks/sessions.go
index 93f69a0d..3a731bd0 100644
--- a/cmds/core/scheduler/tasks/sessions.go
+++ b/cmds/core/scheduler/tasks/sessions.go
@@ -112,7 +112,6 @@ func init() {
 					}
 
 					stats := fetch.WargamingToStats(realm, accounts[id], clans[id], vehicles)
-
 					accountUpdates = append(accountUpdates, database.Account{
 						Realm:    stats.Realm,
 						ID:       stats.Account.ID,
@@ -125,7 +124,6 @@ func init() {
 						ClanID:  stats.Account.ClanID,
 						ClanTag: stats.Account.ClanTag,
 					})
-
 					snapshots = append(snapshots, database.AccountSnapshot{
 						Type:           database.SnapshotTypeDaily,
 						CreatedAt:      createdAt,
@@ -135,15 +133,13 @@ func init() {
 						RatingBattles:  stats.RatingBattles.StatsFrame,
 						RegularBattles: stats.RegularBattles.StatsFrame,
 					})
+
 					if len(vehicles) < 1 {
 						continue
 					}
-
 					vehicleStats := fetch.WargamingVehiclesToFrame(vehicles)
 					for _, vehicle := range vehicleStats {
-						if !forceUpdate && vehicle.LastBattleTime.Before(createdAt.Add(time.Hour*-25)) {
-							// if the last battle was played 25+ hours ago, there is nothing for us to update
-							log.Debug().Str("accountId", id).Str("vehicleId", vehicle.VehicleID).Str("taskId", task.ID).Msg("vehicle played no battles")
+						if vehicle.LastBattleTime.IsZero() {
 							continue
 						}
 						vehicleSnapshots = append(vehicleSnapshots, database.VehicleSnapshot{
diff --git a/cmds/discord/commands/builder/option.go b/cmds/discord/commands/builder/option.go
index b669a8bc..2b259aa4 100644
--- a/cmds/discord/commands/builder/option.go
+++ b/cmds/discord/commands/builder/option.go
@@ -25,6 +25,8 @@ type Option struct {
 	maxLength int
 
 	choices []OptionChoice
+
+	options []Option
 }
 
 func NewOption(name string, kind discordgo.ApplicationCommandOptionType) Option {
@@ -69,6 +71,11 @@ func (o Option) Params(params ...Param) Option {
 	return o
 }
 
+func (o Option) Options(options ...Option) Option {
+	o.options = append(o.options, options...)
+	return o
+}
+
 func (o Option) Choices(choices ...OptionChoice) Option {
 	o.choices = append(o.choices, choices...)
 	return o
diff --git a/cmds/discord/commands/session.go b/cmds/discord/commands/session.go
new file mode 100644
index 00000000..b8fbd348
--- /dev/null
+++ b/cmds/discord/commands/session.go
@@ -0,0 +1,76 @@
+package commands
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/cufee/aftermath/cmds/discord/commands/builder"
+	"github.com/cufee/aftermath/cmds/discord/common"
+	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/stats/render"
+	"github.com/cufee/aftermath/internal/stats/render/assets"
+)
+
+func init() {
+	Loaded.add(
+		builder.NewCommand("session").
+			Options(defaultStatsOptions...).
+			Handler(func(ctx *common.Context) error {
+				options := getDefaultStatsOptions(ctx)
+				message, valid := options.Validate(ctx)
+				if !valid {
+					return ctx.Reply(message)
+				}
+
+				var accountID string
+				background, _ := assets.GetLoadedImage("bg-default")
+
+				switch {
+				case options.UserID != "":
+					// mentioned another user, check if the user has an account linked
+					mentionedUser, _ := ctx.Core.Database().GetUserByID(ctx.Context, options.UserID, database.WithConnections(), database.WithContent())
+					defaultAccount, hasDefaultAccount := mentionedUser.Connection(database.ConnectionTypeWargaming)
+					if !hasDefaultAccount {
+						return ctx.Reply("stats_error_connection_not_found_vague")
+					}
+					accountID = defaultAccount.ReferenceID
+					// TODO: Get user background
+
+				case options.Nickname != "" && options.Server != "":
+					// nickname provided and server selected - lookup the account
+					account, err := ctx.Core.Fetch().Search(ctx.Context, options.Nickname, options.Server)
+					if err != nil {
+						if err.Error() == "no results found" {
+							return ctx.ReplyFmt("stats_error_nickname_not_fount_fmt", options.Nickname, strings.ToUpper(options.Server))
+						}
+						return ctx.Err(err)
+					}
+					accountID = fmt.Sprint(account.ID)
+
+				default:
+					defaultAccount, hasDefaultAccount := ctx.User.Connection(database.ConnectionTypeWargaming)
+					if !hasDefaultAccount {
+						return ctx.Reply("stats_error_nickname_or_server_missing")
+					}
+					// command used without options, but user has a default connection
+					accountID = defaultAccount.ReferenceID
+					// TODO: Get user background
+				}
+
+				image, _, err := ctx.Core.Render(ctx.Locale).Session(context.Background(), accountID, options.PeriodStart, render.WithBackground(background))
+				if err != nil {
+					return ctx.Err(err)
+				}
+
+				var buf bytes.Buffer
+				err = image.PNG(&buf)
+				if err != nil {
+					return ctx.Err(err)
+				}
+
+				return ctx.File(&buf, "session_command_by_aftermath.png")
+			}),
+	)
+}
diff --git a/cmds/discord/rest/client.go b/cmds/discord/rest/client.go
index 859686cc..a58c9061 100644
--- a/cmds/discord/rest/client.go
+++ b/cmds/discord/rest/client.go
@@ -8,7 +8,6 @@ import (
 	"mime/multipart"
 	"net/http"
 	"net/textproto"
-	"runtime/debug"
 	"time"
 
 	"github.com/pkg/errors"
@@ -120,13 +119,18 @@ func (c *Client) do(req *http.Request, target any) error {
 
 		if res.StatusCode > 299 {
 			var body discordgo.APIErrorMessage
-			_ = json.NewDecoder(res.Body).Decode(&body)
+			data, err := io.ReadAll(res.Body)
+			if err != nil {
+				return nil, fmt.Errorf("failed to read body: %w", err)
+			}
+
+			_ = json.Unmarshal(data, &body)
 			message := body.Message
 			if message == "" {
 				message = res.Status
 			}
 
-			println(string(debug.Stack()))
+			println(string(data))
 
 			return nil, errors.New("discord error: " + message)
 		}
diff --git a/internal/database/client.go b/internal/database/client.go
index 67a25310..748a5c69 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -9,6 +9,8 @@ import (
 	"golang.org/x/sync/semaphore"
 )
 
+var _ Client = &client{}
+
 type Client interface {
 	GetAccountByID(ctx context.Context, id string) (Account, error)
 	GetAccounts(ctx context.Context, ids []string) ([]Account, error)
@@ -27,7 +29,9 @@ type Client interface {
 	UpsertConnection(ctx context.Context, connection UserConnection) (UserConnection, error)
 
 	CreateAccountSnapshots(ctx context.Context, snapshots ...AccountSnapshot) error
+	GetAccountSnapshot(ctx context.Context, accountID, referenceID string, kind snapshotType, options ...SnapshotQuery) (AccountSnapshot, error)
 	CreateVehicleSnapshots(ctx context.Context, snapshots ...VehicleSnapshot) error
+	GetVehicleSnapshots(ctx context.Context, accountID, referenceID string, kind snapshotType, options ...SnapshotQuery) ([]VehicleSnapshot, error)
 
 	CreateTasks(ctx context.Context, tasks ...Task) error
 	UpdateTasks(ctx context.Context, tasks ...Task) error
@@ -39,8 +43,6 @@ type Client interface {
 	DeleteExpiredSnapshots(ctx context.Context, expiration time.Time) error
 }
 
-var _ Client = &client{}
-
 type client struct {
 	prisma *db.PrismaClient
 	// Prisma does not currently support updateManyAndReturn
diff --git a/internal/database/prisma/migrations/20240612202803_sessions/migration.sql b/internal/database/prisma/migrations/20240612202803_sessions/migration.sql
new file mode 100644
index 00000000..0d46d0ba
--- /dev/null
+++ b/internal/database/prisma/migrations/20240612202803_sessions/migration.sql
@@ -0,0 +1,50 @@
+/*
+  Warnings:
+
+  - You are about to drop the column `updatedAt` on the `achievements_snapshots` table. All the data in the column will be lost.
+
+*/
+-- DropIndex
+DROP INDEX "account_snapshots_accountId_lastBattleTime_idx";
+
+-- DropIndex
+DROP INDEX "vehicle_snapshots_accountId_vehicleId_lastBattleTime_idx";
+
+-- RedefineTables
+PRAGMA foreign_keys=OFF;
+CREATE TABLE "new_achievements_snapshots" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "createdAt" DATETIME NOT NULL,
+    "accountId" TEXT NOT NULL,
+    "referenceId" TEXT NOT NULL,
+    "dataEncoded" BLOB NOT NULL
+);
+INSERT INTO "new_achievements_snapshots" ("accountId", "createdAt", "dataEncoded", "id", "referenceId") SELECT "accountId", "createdAt", "dataEncoded", "id", "referenceId" FROM "achievements_snapshots";
+DROP TABLE "achievements_snapshots";
+ALTER TABLE "new_achievements_snapshots" RENAME TO "achievements_snapshots";
+CREATE INDEX "achievements_snapshots_createdAt_idx" ON "achievements_snapshots"("createdAt");
+CREATE INDEX "achievements_snapshots_accountId_referenceId_idx" ON "achievements_snapshots"("accountId", "referenceId");
+CREATE INDEX "achievements_snapshots_accountId_referenceId_createdAt_idx" ON "achievements_snapshots"("accountId", "referenceId", "createdAt");
+PRAGMA foreign_key_check;
+PRAGMA foreign_keys=ON;
+
+-- CreateIndex
+CREATE INDEX "account_snapshots_type_accountId_referenceId_idx" ON "account_snapshots"("type", "accountId", "referenceId");
+
+-- CreateIndex
+CREATE INDEX "account_snapshots_type_accountId_referenceId_createdAt_idx" ON "account_snapshots"("type", "accountId", "referenceId", "createdAt");
+
+-- CreateIndex
+CREATE INDEX "vehicle_snapshots_vehicleId_createdAt_idx" ON "vehicle_snapshots"("vehicleId", "createdAt");
+
+-- CreateIndex
+CREATE INDEX "vehicle_snapshots_accountId_referenceId_idx" ON "vehicle_snapshots"("accountId", "referenceId");
+
+-- CreateIndex
+CREATE INDEX "vehicle_snapshots_accountId_referenceId_vehicleId_idx" ON "vehicle_snapshots"("accountId", "referenceId", "vehicleId");
+
+-- CreateIndex
+CREATE INDEX "vehicle_snapshots_accountId_referenceId_type_idx" ON "vehicle_snapshots"("accountId", "referenceId", "type");
+
+-- CreateIndex
+CREATE INDEX "vehicle_snapshots_accountId_referenceId_createdAt_idx" ON "vehicle_snapshots"("accountId", "referenceId", "createdAt");
diff --git a/internal/database/prisma/schema.prisma b/internal/database/prisma/schema.prisma
index 1947d466..791b59a2 100644
--- a/internal/database/prisma/schema.prisma
+++ b/internal/database/prisma/schema.prisma
@@ -215,7 +215,8 @@ model AccountSnapshot {
   regularFrameEncoded Bytes
 
   @@index([createdAt])
-  @@index([accountId, lastBattleTime])
+  @@index([type, accountId, referenceId])
+  @@index([type, accountId, referenceId, createdAt])
   @@map("account_snapshots")
 }
 
@@ -235,21 +236,27 @@ model VehicleSnapshot {
   frameEncoded Bytes
 
   @@index([createdAt])
-  @@index([accountId, vehicleId, lastBattleTime])
+  @@index([vehicleId, createdAt])
+  @@index([accountId, referenceId])
+  @@index([accountId, referenceId, vehicleId])
+  @@index([accountId, referenceId, type])
+  @@index([accountId, referenceId, createdAt])
   @@map("vehicle_snapshots")
 }
 
 // A snapshot of all account achievements
 model AchievementsSnapshot {
   id        String   @id @default(uuid())
-  createdAt DateTime @default(now())
-  updatedAt DateTime @updatedAt
+  createdAt DateTime
 
   accountId   String
   referenceId String
 
   dataEncoded Bytes
 
+  @@index([createdAt])
+  @@index([accountId, referenceId])
+  @@index([accountId, referenceId, createdAt])
   @@map("achievements_snapshots")
 }
 
@@ -257,7 +264,6 @@ model AchievementsSnapshot {
 // model AccountRatingSeasonSnapshot {
 //   id        String   @id @default(cuid())
 //   createdAt DateTime
-//   updatedAt DateTime @updatedAt
 
 //   seasonId       String
 //   accountId      String
diff --git a/internal/database/snapshots.go b/internal/database/snapshots.go
index e458d407..dd525cb4 100644
--- a/internal/database/snapshots.go
+++ b/internal/database/snapshots.go
@@ -2,6 +2,8 @@ package database
 
 import (
 	"context"
+	"fmt"
+	"strings"
 	"time"
 
 	"github.com/cufee/aftermath/internal/database/prisma/db"
@@ -10,29 +12,134 @@ import (
 	"github.com/steebchen/prisma-client-go/runtime/transaction"
 )
 
-type snapshotType string
+type getSnapshotQuery struct {
+	vehicleIDs []string
 
-const (
-	SnapshotTypeDaily snapshotType = "daily"
-)
+	createdAfter  *time.Time
+	createdBefore *time.Time
+}
+
+func (s getSnapshotQuery) accountParams(accountID, referenceID string, kind snapshotType) []db.AccountSnapshotWhereParam {
+	var params []db.AccountSnapshotWhereParam
+	params = append(params, db.AccountSnapshot.Type.Equals(string(kind)))
+	params = append(params, db.AccountSnapshot.AccountID.Equals(accountID))
+	params = append(params, db.AccountSnapshot.ReferenceID.Equals(referenceID))
+
+	if s.createdAfter != nil {
+		params = append(params, db.AccountSnapshot.CreatedAt.After(*s.createdAfter))
+	}
+	if s.createdBefore != nil {
+		params = append(params, db.AccountSnapshot.CreatedAt.Before(*s.createdBefore))
+	}
+
+	return params
+}
+
+func (s getSnapshotQuery) vehiclesQuery(accountID, referenceID string, kind snapshotType) (query string, params []interface{}) {
+	var conditions []string
+	var args []interface{}
+
+	// Mandatory conditions
+	conditions = append(conditions, "type = ?")
+	args = append(args, kind)
+
+	conditions = append(conditions, "accountId = ?")
+	args = append(args, accountID)
+
+	conditions = append(conditions, "referenceId = ?")
+	args = append(args, referenceID)
+
+	// Optional conditions
+	if s.createdAfter != nil {
+		conditions = append(conditions, "createdAt > ?")
+		args = append(args, *s.createdAfter)
+	}
+	if s.createdBefore != nil {
+		conditions = append(conditions, "createdAt < ?")
+		args = append(args, *s.createdBefore)
+	}
+
+	// Filter by vehicle IDs if provided
+	if len(s.vehicleIDs) > 0 {
+		placeholders := make([]string, len(s.vehicleIDs))
+		for i, id := range s.vehicleIDs {
+			placeholders[i] = "?"
+			args = append(args, id)
+		}
+		conditions = append(conditions, fmt.Sprintf("vehicleId IN (%s)", strings.Join(placeholders, ",")))
+	}
+
+	// Determine the order by clause
+	var orderBy string = "createdAt ASC"
+	if s.createdBefore != nil {
+		orderBy = "createdAt DESC"
+	}
+
+	// Base query
+	query = `
+		SELECT
+			id, createdAt, type, lastBattleTime, accountId, vehicleId, referenceId, battles, frameEncoded
+		FROM
+			vehicle_snapshots
+		WHERE
+			%s
+		ORDER BY
+			%s
+	`
+
+	// Combine conditions into a single string
+	conditionsStr := strings.Join(conditions, " AND ")
+	query = fmt.Sprintf(query, conditionsStr, orderBy)
+
+	// Wrap the query to select the latest or earliest snapshot per vehicleId
+	wrappedQuery := `
+		SELECT * FROM (
+			%s
+		) AS ordered_snapshots
+		GROUP BY vehicleId
+	`
+
+	query = fmt.Sprintf(wrappedQuery, query)
+	return query, args
+}
+
+func (s getSnapshotQuery) accountOrder() []db.AccountSnapshotOrderByParam {
+	var order []db.AccountSnapshotOrderByParam
+
+	switch {
+	case s.createdAfter != nil:
+		order = append(order, db.AccountSnapshot.CreatedAt.Order(db.ASC))
+	default:
+		order = append(order, db.AccountSnapshot.CreatedAt.Order(db.DESC))
+	}
 
-// model VehicleSnapshot {
-//   id        String   @id @default(cuid())
-//   createdAt DateTime
+	return order
+}
 
-//   type           String
-//   lastBattleTime DateTime
+type SnapshotQuery func(*getSnapshotQuery)
 
-//   accountId   String
-//   vehicleId   String
-//   referenceId String
+func WithVehicleIDs(ids []string) SnapshotQuery {
+	return func(q *getSnapshotQuery) {
+		q.vehicleIDs = ids
+	}
+}
+func WithCreatedAfter(after time.Time) SnapshotQuery {
+	return func(q *getSnapshotQuery) {
+		q.createdAfter = &after
+	}
+}
+func WithCreatedBefore(before time.Time) SnapshotQuery {
+	return func(q *getSnapshotQuery) {
+		q.createdBefore = &before
+	}
+}
 
-//   frameEncoded Bytes
+type snapshotType string
 
-//   @@index([createdAt])
-//   @@index([accountId, vehicleId, lastBattleTime])
-//   @@map("vehicle_snapshots")
-// }
+const (
+	SnapshotTypeLive  snapshotType = "live"
+	SnapshotTypeDaily snapshotType = "daily"
+)
 
 type VehicleSnapshot struct {
 	ID        string
@@ -48,7 +155,7 @@ type VehicleSnapshot struct {
 	Stats frame.StatsFrame
 }
 
-func (s *VehicleSnapshot) FromModel(model db.VehicleSnapshotModel) error {
+func (s VehicleSnapshot) FromModel(model db.VehicleSnapshotModel) (VehicleSnapshot, error) {
 	s.ID = model.ID
 	s.Type = snapshotType(model.Type)
 	s.CreatedAt = model.CreatedAt
@@ -60,44 +167,10 @@ func (s *VehicleSnapshot) FromModel(model db.VehicleSnapshotModel) error {
 
 	stats, err := frame.DecodeStatsFrame(model.FrameEncoded)
 	if err != nil {
-		return err
+		return VehicleSnapshot{}, err
 	}
 	s.Stats = stats
-	return nil
-}
-
-type AccountSnapshot struct {
-	ID             string
-	Type           snapshotType
-	CreatedAt      time.Time
-	AccountID      string
-	ReferenceID    string
-	LastBattleTime time.Time
-	RatingBattles  frame.StatsFrame
-	RegularBattles frame.StatsFrame
-}
-
-func (s *AccountSnapshot) FromModel(model db.AccountSnapshotModel) error {
-	s.ID = model.ID
-	s.Type = snapshotType(model.Type)
-	s.CreatedAt = model.CreatedAt
-	s.AccountID = model.AccountID
-	s.ReferenceID = model.ReferenceID
-	s.LastBattleTime = model.LastBattleTime
-
-	rating, err := frame.DecodeStatsFrame(model.RatingFrameEncoded)
-	if err != nil {
-		return err
-	}
-	s.RatingBattles = rating
-
-	regular, err := frame.DecodeStatsFrame(model.RegularFrameEncoded)
-	if err != nil {
-		return err
-	}
-	s.RegularBattles = regular
-
-	return nil
+	return s, nil
 }
 
 func (c *client) CreateVehicleSnapshots(ctx context.Context, snapshots ...VehicleSnapshot) error {
@@ -130,6 +203,65 @@ func (c *client) CreateVehicleSnapshots(ctx context.Context, snapshots ...Vehicl
 	return c.prisma.Prisma.Transaction(transactions...).Exec(ctx)
 }
 
+func (c *client) GetVehicleSnapshots(ctx context.Context, accountID, referenceID string, kind snapshotType, options ...SnapshotQuery) ([]VehicleSnapshot, error) {
+	var query getSnapshotQuery
+	for _, apply := range options {
+		apply(&query)
+	}
+
+	var models []db.VehicleSnapshotModel
+	raw, args := query.vehiclesQuery(accountID, referenceID, kind)
+	err := c.prisma.Prisma.Raw.QueryRaw(raw, args...).Exec(ctx, &models)
+	if err != nil {
+		return nil, err
+	}
+
+	var snapshots []VehicleSnapshot
+	for _, model := range models {
+		vehicle, err := VehicleSnapshot{}.FromModel(model)
+		if err != nil {
+			return nil, err
+		}
+		snapshots = append(snapshots, vehicle)
+	}
+
+	return snapshots, nil
+}
+
+type AccountSnapshot struct {
+	ID             string
+	Type           snapshotType
+	CreatedAt      time.Time
+	AccountID      string
+	ReferenceID    string
+	LastBattleTime time.Time
+	RatingBattles  frame.StatsFrame
+	RegularBattles frame.StatsFrame
+}
+
+func (s AccountSnapshot) FromModel(model *db.AccountSnapshotModel) (AccountSnapshot, error) {
+	s.ID = model.ID
+	s.Type = snapshotType(model.Type)
+	s.CreatedAt = model.CreatedAt
+	s.AccountID = model.AccountID
+	s.ReferenceID = model.ReferenceID
+	s.LastBattleTime = model.LastBattleTime
+
+	rating, err := frame.DecodeStatsFrame(model.RatingFrameEncoded)
+	if err != nil {
+		return AccountSnapshot{}, err
+	}
+	s.RatingBattles = rating
+
+	regular, err := frame.DecodeStatsFrame(model.RegularFrameEncoded)
+	if err != nil {
+		return AccountSnapshot{}, err
+	}
+	s.RegularBattles = regular
+
+	return s, nil
+}
+
 func (c *client) CreateAccountSnapshots(ctx context.Context, snapshots ...AccountSnapshot) error {
 	if len(snapshots) < 1 {
 		return nil
@@ -165,3 +297,17 @@ func (c *client) CreateAccountSnapshots(ctx context.Context, snapshots ...Accoun
 
 	return c.prisma.Prisma.Transaction(transactions...).Exec(ctx)
 }
+
+func (c *client) GetAccountSnapshot(ctx context.Context, accountID, referenceID string, kind snapshotType, options ...SnapshotQuery) (AccountSnapshot, error) {
+	var query getSnapshotQuery
+	for _, apply := range options {
+		apply(&query)
+	}
+
+	model, err := c.prisma.AccountSnapshot.FindFirst(query.accountParams(accountID, referenceID, kind)...).OrderBy(query.accountOrder()...).Exec(ctx)
+	if err != nil {
+		return AccountSnapshot{}, err
+	}
+
+	return AccountSnapshot{}.FromModel(model)
+}
diff --git a/internal/database/snapshots_test.go b/internal/database/snapshots_test.go
new file mode 100644
index 00000000..c4f7553d
--- /dev/null
+++ b/internal/database/snapshots_test.go
@@ -0,0 +1,121 @@
+package database
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+/*
+DATABASE_URL needs to be set and migrations need to be applied
+*/
+func TestGetVehicleSnapshots(t *testing.T) {
+	client, err := NewClient()
+	assert.NoError(t, err, "new client should not error")
+	defer client.prisma.Disconnect()
+
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*15)
+	defer cancel()
+
+	client.prisma.VehicleSnapshot.FindMany().Delete().Exec(ctx)
+	defer client.prisma.VehicleSnapshot.FindMany().Delete().Exec(ctx)
+
+	createdAtVehicle1 := time.Date(2023, 6, 1, 0, 0, 0, 0, time.UTC)
+	createdAtVehicle2 := time.Date(2023, 8, 1, 0, 0, 0, 0, time.UTC)
+	createdAtVehicle3 := time.Date(2023, 10, 1, 0, 0, 0, 0, time.UTC)
+
+	createdAtVehicle4 := time.Date(2023, 9, 1, 0, 0, 0, 0, time.UTC)
+	createdAtVehicle5 := time.Date(2023, 9, 2, 0, 0, 0, 0, time.UTC)
+
+	vehicle1 := VehicleSnapshot{
+		VehicleID:   "v1",
+		AccountID:   "a1",
+		ReferenceID: "r1",
+
+		Type:           SnapshotTypeDaily,
+		CreatedAt:      createdAtVehicle1,
+		LastBattleTime: createdAtVehicle1,
+	}
+	vehicle2 := VehicleSnapshot{
+		VehicleID:   "v1",
+		AccountID:   "a1",
+		ReferenceID: "r1",
+
+		Type:           SnapshotTypeDaily,
+		CreatedAt:      createdAtVehicle2,
+		LastBattleTime: createdAtVehicle2,
+	}
+	vehicle3 := VehicleSnapshot{
+		VehicleID:   "v1",
+		AccountID:   "a1",
+		ReferenceID: "r1",
+
+		Type:           SnapshotTypeDaily,
+		CreatedAt:      createdAtVehicle3,
+		LastBattleTime: createdAtVehicle3,
+	}
+	vehicle4 := VehicleSnapshot{
+		VehicleID:   "v4",
+		AccountID:   "a1",
+		ReferenceID: "r2",
+
+		Type:           SnapshotTypeDaily,
+		CreatedAt:      createdAtVehicle4,
+		LastBattleTime: createdAtVehicle4,
+	}
+	vehicle5 := VehicleSnapshot{
+		VehicleID:   "v5",
+		AccountID:   "a1",
+		ReferenceID: "r2",
+
+		Type:           SnapshotTypeDaily,
+		CreatedAt:      createdAtVehicle5,
+		LastBattleTime: createdAtVehicle5,
+	}
+	vehicle6 := VehicleSnapshot{
+		VehicleID:   "v5",
+		AccountID:   "a1",
+		ReferenceID: "r2",
+
+		Type:           SnapshotTypeDaily,
+		CreatedAt:      createdAtVehicle5,
+		LastBattleTime: createdAtVehicle5,
+	}
+
+	{ // create snapshots
+		snaphots := []VehicleSnapshot{vehicle1, vehicle2, vehicle3, vehicle4, vehicle5, vehicle6}
+		err = client.CreateVehicleSnapshots(ctx, snaphots...)
+		assert.NoError(t, err, "create vehicle snapshot should not error")
+	}
+	{ // when we check created after, vehicles need to be ordered by createdAt ASC, so we expect to get vehicle2 back
+		vehicles, err := client.GetVehicleSnapshots(ctx, "a1", "r1", SnapshotTypeDaily, WithCreatedAfter(createdAtVehicle1))
+		assert.NoError(t, err, "get vehicle snapshot error")
+		assert.Len(t, vehicles, 1, "should return exactly 1 snapshots")
+		assert.True(t, vehicles[0].CreatedAt.Equal(createdAtVehicle2), "wrong vehicle snapshot returned", vehicles)
+	}
+	{ // when we check created before, vehicles need to be ordered by createdAt DESC, so we expect to get vehicle2 back
+		vehicles, err := client.GetVehicleSnapshots(ctx, "a1", "r1", SnapshotTypeDaily, WithCreatedBefore(createdAtVehicle3))
+		assert.NoError(t, err, "get vehicle snapshot error")
+		assert.Len(t, vehicles, 1, "should return exactly 1 snapshots")
+		assert.True(t, vehicles[0].CreatedAt.Equal(createdAtVehicle2), "wrong vehicle snapshot returned", vehicles)
+	}
+	{ // make sure only 1 vehicle is returned per ID
+		vehicles, err := client.GetVehicleSnapshots(ctx, "a1", "r2", SnapshotTypeDaily, WithCreatedBefore(createdAtVehicle5.Add(time.Hour)))
+		assert.NoError(t, err, "get vehicle snapshot error")
+		assert.Len(t, vehicles, 2, "should return exactly 2 snapshots")
+		assert.NotEqual(t, vehicles[0].ID, vehicles[1].ID, "each vehicle id should only be returned once", vehicles)
+	}
+	{ // get a cehicle with a specific id
+		vehicles, err := client.GetVehicleSnapshots(ctx, "a1", "r2", SnapshotTypeDaily, WithVehicleIDs([]string{"v5"}))
+		assert.NoError(t, err, "get vehicle snapshot error")
+		assert.Len(t, vehicles, 1, "should return exactly 1 snapshots")
+		assert.NotEqual(t, vehicles[0].ID, "v5", "incorrect vehicle returned", vehicles)
+	}
+	{ // this should return no result
+		vehicles, err := client.GetVehicleSnapshots(ctx, "a1", "r1", SnapshotTypeDaily, WithCreatedBefore(createdAtVehicle1))
+		assert.NoError(t, err, "no results from a raw query does not trigger an error")
+		assert.Len(t, vehicles, 0, "return should have no results", vehicles)
+	}
+}
diff --git a/internal/stats/fetch/client.go b/internal/stats/fetch/client.go
index b0dd727e..7cfa4506 100644
--- a/internal/stats/fetch/client.go
+++ b/internal/stats/fetch/client.go
@@ -49,7 +49,9 @@ type StatsWithVehicles struct {
 type Client interface {
 	Search(ctx context.Context, nickname, realm string) (types.Account, error)
 	CurrentStats(ctx context.Context, id string, opts ...statsOption) (AccountStatsOverPeriod, error)
+
 	PeriodStats(ctx context.Context, id string, from time.Time, opts ...statsOption) (AccountStatsOverPeriod, error)
+	SessionStats(ctx context.Context, id string, sessionStart time.Time, opts ...statsOption) (AccountStatsOverPeriod, error)
 
 	CurrentTankAverages(ctx context.Context) (map[string]frame.StatsFrame, error)
 }
diff --git a/internal/stats/fetch/multisource.go b/internal/stats/fetch/multisource.go
index 42de615c..3dd3c7a7 100644
--- a/internal/stats/fetch/multisource.go
+++ b/internal/stats/fetch/multisource.go
@@ -9,6 +9,7 @@ import (
 	"github.com/pkg/errors"
 
 	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/prisma/db"
 	"github.com/cufee/aftermath/internal/external/blitzstars"
 	"github.com/cufee/aftermath/internal/external/wargaming"
 	"github.com/cufee/aftermath/internal/retry"
@@ -111,6 +112,10 @@ func (c *multiSourceClient) CurrentStats(ctx context.Context, id string, opts ..
 	if vehicles.Err != nil {
 		return AccountStatsOverPeriod{}, vehicles.Err
 	}
+	if averages.Err != nil {
+		// not critical, this will only affect WN8
+		log.Err(averages.Err).Msg("failed to get tank averages")
+	}
 
 	stats := WargamingToStats(realm, account.Data, clan, vehicles.Data)
 	if options.withWN8 {
@@ -169,6 +174,10 @@ func (c *multiSourceClient) PeriodStats(ctx context.Context, id string, periodSt
 		if current.Err != nil {
 			return AccountStatsOverPeriod{}, current.Err
 		}
+		if averages.Err != nil {
+			// not critical, this will only affect WN8
+			log.Err(averages.Err).Msg("failed to get tank averages")
+		}
 
 		stats := current.Data
 		if options.withWN8 {
@@ -193,6 +202,10 @@ func (c *multiSourceClient) PeriodStats(ctx context.Context, id string, periodSt
 	if histories.Err != nil {
 		return AccountStatsOverPeriod{}, histories.Err
 	}
+	if averages.Err != nil {
+		// not critical, this will only affect WN8
+		log.Err(averages.Err).Msg("failed to get tank averages")
+	}
 
 	current.Data.PeriodEnd = time.Now()
 	current.Data.PeriodStart = periodStart
@@ -206,6 +219,125 @@ func (c *multiSourceClient) PeriodStats(ctx context.Context, id string, periodSt
 	return stats, nil
 }
 
+func (c *multiSourceClient) SessionStats(ctx context.Context, id string, sessionStart time.Time, opts ...statsOption) (AccountStatsOverPeriod, error) {
+	var options statsOptions
+	for _, apply := range opts {
+		apply(&options)
+	}
+	if sessionStart.IsZero() {
+		sessionStart = time.Now().Add(time.Hour * 25 * -1)
+	}
+
+	var accountSnapshot retry.DataWithErr[database.AccountSnapshot]
+	var vehiclesSnapshots retry.DataWithErr[[]database.VehicleSnapshot]
+	var averages retry.DataWithErr[map[string]frame.StatsFrame]
+	var current retry.DataWithErr[AccountStatsOverPeriod]
+
+	var group sync.WaitGroup
+	group.Add(1)
+	go func() {
+		defer group.Done()
+
+		stats, err := c.CurrentStats(ctx, id)
+		current = retry.DataWithErr[AccountStatsOverPeriod]{Data: stats, Err: err}
+
+		if err != nil || stats.RegularBattles.Battles < 1 || !options.withWN8 {
+			return
+		}
+
+		var ids []string
+		for id := range stats.RegularBattles.Vehicles {
+			ids = append(ids, id)
+		}
+		a, err := c.database.GetVehicleAverages(ctx, ids)
+		averages = retry.DataWithErr[map[string]frame.StatsFrame]{Data: a, Err: err}
+	}()
+
+	// return career stats if stats are requested for 0 or 90+ days, we do not track that far
+	if days := time.Since(sessionStart).Hours() / 24; days > 90 || days < 1 {
+		group.Wait()
+		if current.Err != nil {
+			return AccountStatsOverPeriod{}, current.Err
+		}
+		if averages.Err != nil {
+			// not critical, this will only affect WN8
+			log.Err(averages.Err).Msg("failed to get tank averages")
+		}
+
+		stats := current.Data
+		if options.withWN8 {
+			stats.AddWN8(averages.Data)
+		}
+		return stats, nil
+	}
+
+	group.Add(1)
+	go func() {
+		defer group.Done()
+		s, err := c.database.GetAccountSnapshot(ctx, id, id, database.SnapshotTypeDaily, database.WithCreatedAfter(sessionStart))
+		accountSnapshot = retry.DataWithErr[database.AccountSnapshot]{Data: s, Err: err}
+
+		v, err := c.database.GetVehicleSnapshots(ctx, id, id, database.SnapshotTypeDaily, database.WithCreatedAfter(sessionStart))
+		vehiclesSnapshots = retry.DataWithErr[[]database.VehicleSnapshot]{Data: v, Err: err}
+	}()
+
+	// wait for all requests to finish and check errors
+	group.Wait()
+	if current.Err != nil {
+		return AccountStatsOverPeriod{}, current.Err
+	}
+	if accountSnapshot.Err != nil {
+		if !db.IsErrNotFound(accountSnapshot.Err) {
+			return AccountStatsOverPeriod{}, accountSnapshot.Err
+		}
+		// if there is no snapshot, we just return 0 battles
+		stats := current.Data
+		stats.PeriodEnd = time.Now()
+		stats.PeriodStart = sessionStart
+		stats.RatingBattles.StatsFrame = frame.StatsFrame{}
+		stats.RegularBattles.StatsFrame = frame.StatsFrame{}
+		stats.RegularBattles.Vehicles = make(map[string]frame.VehicleStatsFrame, 0)
+		return stats, nil
+	}
+	if averages.Err != nil {
+		// not critical, this will only affect WN8
+		log.Err(averages.Err).Msg("failed to get tank averages")
+	}
+
+	stats := current.Data
+	stats.PeriodEnd = time.Now()
+	stats.PeriodStart = sessionStart
+	stats.RatingBattles.StatsFrame.Subtract(accountSnapshot.Data.RatingBattles)
+	stats.RegularBattles.StatsFrame.Subtract(accountSnapshot.Data.RegularBattles)
+
+	snapshotsMap := make(map[string]int, len(vehiclesSnapshots.Data))
+	for i, data := range vehiclesSnapshots.Data {
+		snapshotsMap[data.VehicleID] = i
+	}
+
+	stats.RegularBattles.Vehicles = make(map[string]frame.VehicleStatsFrame, len(current.Data.RegularBattles.Vehicles))
+	for id, current := range current.Data.RegularBattles.Vehicles {
+		snapshotIndex, exists := snapshotsMap[id]
+		if !exists {
+			stats.RegularBattles.Vehicles[id] = current
+			continue
+		}
+
+		snapshot := vehiclesSnapshots.Data[snapshotIndex]
+		if current.Battles == 0 || current.Battles == snapshot.Stats.Battles {
+			continue
+		}
+		current.StatsFrame.Subtract(snapshot.Stats)
+		stats.RegularBattles.Vehicles[id] = current
+	}
+
+	if options.withWN8 {
+		stats.AddWN8(averages.Data)
+	}
+	return stats, nil
+
+}
+
 func (c *multiSourceClient) CurrentTankAverages(ctx context.Context) (map[string]frame.StatsFrame, error) {
 	return c.blitzstars.CurrentTankAverages(ctx)
 }
diff --git a/internal/stats/fetch/multisource_test.go b/internal/stats/fetch/multisource_test.go
new file mode 100644
index 00000000..b3718416
--- /dev/null
+++ b/internal/stats/fetch/multisource_test.go
@@ -0,0 +1,27 @@
+package fetch
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/cufee/aftermath/internal/database"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSessionStats(t *testing.T) {
+	db, err := database.NewClient()
+	assert.NoError(t, err, "failed to create a database client")
+	defer db.Prisma().Disconnect()
+
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*15)
+	defer cancel()
+
+	sessionStartTime := time.Date(2023, 6, 1, 0, 0, 0, 0, time.UTC)
+
+	client := &multiSourceClient{database: db}
+	stats, err := client.SessionStats(ctx, "", sessionStartTime.Add(time.Hour*-1))
+	assert.NoError(t, err, "failed to get session stats")
+
+	_ = stats
+}
diff --git a/internal/stats/frame/frame.go b/internal/stats/frame/frame.go
index 7889ecae..b35b5be5 100644
--- a/internal/stats/frame/frame.go
+++ b/internal/stats/frame/frame.go
@@ -207,6 +207,15 @@ func (r *StatsFrame) Add(other StatsFrame) {
 	r.EnemiesSpotted += other.EnemiesSpotted
 	r.CapturePoints += other.CapturePoints
 	r.DroppedCapturePoints += other.DroppedCapturePoints
+
+	// Reset cache
+	r.wn8 = 0
+	r.winRate = 0
+	r.accuracy = 0
+	r.avgDamage = 0
+	r.damageRatio = 0
+	r.survivalRatio = 0
+	r.survivalPercent = 0
 }
 
 /*
@@ -230,6 +239,15 @@ func (r *StatsFrame) Subtract(other StatsFrame) {
 	r.EnemiesSpotted -= other.EnemiesSpotted
 	r.CapturePoints -= other.CapturePoints
 	r.DroppedCapturePoints -= other.DroppedCapturePoints
+
+	// Reset cache
+	r.wn8 = 0
+	r.winRate = 0
+	r.accuracy = 0
+	r.avgDamage = 0
+	r.damageRatio = 0
+	r.survivalRatio = 0
+	r.survivalPercent = 0
 }
 
 /*
diff --git a/internal/stats/period.go b/internal/stats/period.go
index aeb41fdb..f99c7749 100644
--- a/internal/stats/period.go
+++ b/internal/stats/period.go
@@ -5,21 +5,13 @@ import (
 	"slices"
 	"time"
 
-	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/localization"
 	"github.com/cufee/aftermath/internal/stats/fetch"
 	prepare "github.com/cufee/aftermath/internal/stats/prepare/period"
 	options "github.com/cufee/aftermath/internal/stats/render"
 	render "github.com/cufee/aftermath/internal/stats/render/period"
-	"golang.org/x/text/language"
 )
 
-type renderer struct {
-	fetchClient fetch.Client
-	database    database.Client
-	locale      language.Tag
-}
-
 func (r *renderer) Period(ctx context.Context, accountId string, from time.Time, opts ...options.Option) (Image, Metadata, error) {
 	meta := Metadata{}
 
diff --git a/internal/stats/render/common/player-title.go b/internal/stats/render/common/player_title.go
similarity index 95%
rename from internal/stats/render/common/player-title.go
rename to internal/stats/render/common/player_title.go
index 07bf771c..1160b8a2 100644
--- a/internal/stats/render/common/player-title.go
+++ b/internal/stats/render/common/player_title.go
@@ -14,7 +14,7 @@ type TitleCardStyle struct {
 }
 
 func (style TitleCardStyle) TotalPaddingAndGaps() float64 {
-	return style.Container.PaddingX*2 + style.Container.Gap + style.Nickname.PaddingX*2 + style.ClanTag.PaddingX*2
+	return style.Container.PaddingX*2 + style.Container.Gap*2 + style.Nickname.PaddingX*2 + style.ClanTag.PaddingX*2
 }
 
 func DefaultPlayerTitleStyle(containerStyle Style) TitleCardStyle {
diff --git a/internal/stats/render/common/tier-percentage.go b/internal/stats/render/common/tier_percentage.go
similarity index 100%
rename from internal/stats/render/common/tier-percentage.go
rename to internal/stats/render/common/tier_percentage.go
diff --git a/internal/stats/render/period/constants.go b/internal/stats/render/period/constants.go
index d50686ee..cc9f101f 100644
--- a/internal/stats/render/period/constants.go
+++ b/internal/stats/render/period/constants.go
@@ -65,6 +65,7 @@ func defaultCardStyle(width float64) common.Style {
 func titleCardStyle(width float64) common.Style {
 	style := defaultCardStyle(width)
 	style.PaddingX = style.PaddingY
+	style.Gap = style.PaddingY * 2
 	// style.Debug = true
 	return style
 }
diff --git a/internal/stats/renderer.go b/internal/stats/renderer.go
index 3bd2e7ad..ac0639c4 100644
--- a/internal/stats/renderer.go
+++ b/internal/stats/renderer.go
@@ -12,11 +12,17 @@ import (
 
 var _ Renderer = &renderer{}
 
+type renderer struct {
+	fetchClient fetch.Client
+	database    database.Client
+	locale      language.Tag
+}
+
 type Renderer interface {
 	Period(ctx context.Context, accountId string, from time.Time, opts ...render.Option) (Image, Metadata, error)
+	Session(ctx context.Context, accountId string, from time.Time, opts ...render.Option) (Image, Metadata, error)
 
 	// Replay(accountId string, from time.Time) (image.Image, error)
-	// Session(accountId string, from time.Time) (image.Image, error)
 }
 
 func NewRenderer(fetch fetch.Client, database database.Client, locale language.Tag) *renderer {
diff --git a/internal/stats/session.go b/internal/stats/session.go
index 43b4fd56..67e75340 100644
--- a/internal/stats/session.go
+++ b/internal/stats/session.go
@@ -1 +1,63 @@
 package stats
+
+import (
+	"context"
+	"slices"
+	"time"
+
+	"github.com/cufee/aftermath/internal/localization"
+	"github.com/cufee/aftermath/internal/stats/fetch"
+	prepare "github.com/cufee/aftermath/internal/stats/prepare/period"
+	options "github.com/cufee/aftermath/internal/stats/render"
+	render "github.com/cufee/aftermath/internal/stats/render/period"
+)
+
+func (r *renderer) Session(ctx context.Context, accountId string, from time.Time, opts ...options.Option) (Image, Metadata, error) {
+	meta := Metadata{}
+
+	printer, err := localization.NewPrinter("stats", r.locale)
+	if err != nil {
+		return nil, meta, err
+	}
+
+	stop := meta.Timer("fetchClient#SessionStats")
+	stats, err := r.fetchClient.SessionStats(ctx, accountId, from, fetch.WithWN8())
+	stop()
+	if err != nil {
+		return nil, meta, err
+	}
+	meta.Stats = stats
+
+	stop = meta.Timer("prepare#GetVehicles")
+	var vehicles []string
+	for id := range stats.RegularBattles.Vehicles {
+		vehicles = append(vehicles, id)
+	}
+	for id := range stats.RatingBattles.Vehicles {
+		if !slices.Contains(vehicles, id) {
+			vehicles = append(vehicles, id)
+		}
+	}
+
+	glossary, err := r.database.GetVehicles(ctx, vehicles)
+	if err != nil {
+		return nil, meta, err
+	}
+	stop()
+
+	stop = meta.Timer("prepare#NewCards")
+	cards, err := prepare.NewCards(stats, glossary, prepare.WithPrinter(printer, r.locale))
+	stop()
+	if err != nil {
+		return nil, meta, err
+	}
+
+	stop = meta.Timer("render#CardsToImage")
+	image, err := render.CardsToImage(stats, cards, nil, opts...)
+	stop()
+	if err != nil {
+		return nil, meta, err
+	}
+
+	return &imageImp{image}, meta, err
+}
diff --git a/main.go b/main.go
index ee853493..cba576bb 100644
--- a/main.go
+++ b/main.go
@@ -92,7 +92,7 @@ func startSchedulerFromEnvAsync() {
 	queue.StartCronJobsAsync()
 	// Some tasks should run on startup
 	// scheduler.UpdateAveragesWorker(coreClient)()
-	// scheduler.CreateSessionTasksWorker(coreClient, "NA")()
+	// scheduler.CreateSessionTasksWorker(coreClient, "AS")()
 }
 
 func coreClientFromEnv() core.Client {

From 7c2624c58fcaf9978d282a547c9457742dee8544 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Wed, 12 Jun 2024 19:17:21 -0400
Subject: [PATCH 038/341] refactored sessions

---
 cmds/core/client.go                    |   2 +-
 cmds/core/scheduler/tasks/sessions.go  | 134 ++-----------------
 cmds/discord/commands/options.go       |   2 +
 cmds/discord/commands/session.go       |   5 +
 internal/database/client.go            |   1 +
 internal/database/prisma/schema.prisma |   1 +
 internal/database/snapshots.go         | 103 +++++++++++++--
 internal/logic/sessions.go             | 174 +++++++++++++++++++++++++
 internal/stats/errors.go               |   7 +
 internal/stats/fetch/client.go         |   1 +
 internal/stats/fetch/errors.go         |   8 ++
 internal/stats/fetch/multisource.go    |  95 +++++++++-----
 internal/stats/renderer.go             |   6 +-
 internal/stats/session.go              |  46 ++++++-
 static/localization/en/discord.yaml    |   8 +-
 15 files changed, 418 insertions(+), 175 deletions(-)
 create mode 100644 internal/logic/sessions.go
 create mode 100644 internal/stats/errors.go
 create mode 100644 internal/stats/fetch/errors.go

diff --git a/cmds/core/client.go b/cmds/core/client.go
index db5ca9b7..05d6060a 100644
--- a/cmds/core/client.go
+++ b/cmds/core/client.go
@@ -37,7 +37,7 @@ func (c *client) Fetch() fetch.Client {
 }
 
 func (c *client) Render(locale language.Tag) stats.Renderer {
-	return stats.NewRenderer(c.fetch, c.db, locale)
+	return stats.NewRenderer(c.fetch, c.db, c.wargaming, locale)
 }
 
 func NewClient(fetch fetch.Client, wargaming wargaming.Client, database database.Client) *client {
diff --git a/cmds/core/scheduler/tasks/sessions.go b/cmds/core/scheduler/tasks/sessions.go
index 3a731bd0..f5147654 100644
--- a/cmds/core/scheduler/tasks/sessions.go
+++ b/cmds/core/scheduler/tasks/sessions.go
@@ -3,21 +3,16 @@ package tasks
 import (
 	"context"
 	"strings"
-	"sync"
 	"time"
 
 	"github.com/pkg/errors"
 
 	"github.com/cufee/aftermath/cmds/core"
 	"github.com/cufee/aftermath/internal/database"
-	"github.com/cufee/aftermath/internal/retry"
-	"github.com/cufee/aftermath/internal/stats/fetch"
-	"github.com/cufee/am-wg-proxy-next/v2/types"
+	"github.com/cufee/aftermath/internal/logic"
 	"github.com/rs/zerolog/log"
 )
 
-type vehicleResponseData map[string][]types.VehicleStatsFrame
-
 func init() {
 	defaultHandlers[database.TaskTypeRecordSessions] = TaskHandler{
 		Process: func(client core.Client, task database.Task) (string, error) {
@@ -41,136 +36,23 @@ func init() {
 
 			log.Debug().Str("taskId", task.ID).Any("targets", task.Targets).Msg("started working on a session refresh task")
 
-			createdAt := time.Now()
 			ctx, cancel := context.WithTimeout(context.Background(), time.Second*60)
 			defer cancel()
 
-			accounts, err := client.Wargaming().BatchAccountByID(ctx, realm, task.Targets)
-			if err != nil {
-				return "failed to fetch accounts", err
-			}
-
-			// Make a new slice just in case some accounts were not returned/are private
-			var validAccouts []string
-			for _, id := range task.Targets {
-				data, ok := accounts[id]
-				if !ok {
-					go func(id string) {
-						log.Debug().Str("accountId", id).Str("taskId", task.ID).Msg("account is private")
-						// update account cache (if it exists) to set account as private
-						ctx, cancel := context.WithTimeout(context.Background(), time.Second)
-						defer cancel()
-						err := client.Database().AccountSetPrivate(ctx, id, true)
-						if err != nil {
-							log.Err(err).Str("accountId", id).Msg("failed to set account status as private")
-						}
-					}(id)
-					continue
-				}
-				if !forceUpdate && data.LastBattleTime < int(createdAt.Add(time.Hour*-25).Unix()) {
-					// if the last battle was played 25+ hours ago, there is nothing for us to update
-					log.Debug().Str("accountId", id).Str("taskId", task.ID).Msg("account played no battles")
-					continue
-				}
-				validAccouts = append(validAccouts, id)
-			}
-
-			if len(validAccouts) == 0 {
-				return "no updates required due to last battle or private accounts status", nil
-			}
-
-			// clans are options-ish
-			clans, err := client.Wargaming().BatchAccountClan(ctx, realm, validAccouts)
+			accountErrors, err := logic.RecordAccountSnapshots(ctx, client.Wargaming(), client.Database(), realm, forceUpdate, task.Targets...)
 			if err != nil {
-				log.Err(err).Msg("failed to get batch account clans")
-				clans = make(map[string]types.ClanMember)
-			}
-
-			vehicleCh := make(chan retry.DataWithErr[vehicleResponseData], len(validAccouts))
-			var group sync.WaitGroup
-			group.Add(len(validAccouts))
-			for _, id := range validAccouts {
-				go func(id string) {
-					defer group.Done()
-					data, err := client.Wargaming().AccountVehicles(ctx, realm, id)
-					vehicleCh <- retry.DataWithErr[vehicleResponseData]{Data: vehicleResponseData{id: data}, Err: err}
-				}(id)
+				return "failed to record sessions", err
 			}
-			group.Wait()
-			close(vehicleCh)
-
-			var withErrors []string
-			var accountUpdates []database.Account
-			var snapshots []database.AccountSnapshot
-			var vehicleSnapshots []database.VehicleSnapshot
-			for result := range vehicleCh {
-				// there is only 1 key in this map
-				for id, vehicles := range result.Data {
-					if result.Err != nil {
-						withErrors = append(withErrors, id)
-						continue
-					}
-
-					stats := fetch.WargamingToStats(realm, accounts[id], clans[id], vehicles)
-					accountUpdates = append(accountUpdates, database.Account{
-						Realm:    stats.Realm,
-						ID:       stats.Account.ID,
-						Nickname: stats.Account.Nickname,
 
-						Private:        false,
-						CreatedAt:      stats.Account.CreatedAt,
-						LastBattleTime: stats.LastBattleTime,
-
-						ClanID:  stats.Account.ClanID,
-						ClanTag: stats.Account.ClanTag,
-					})
-					snapshots = append(snapshots, database.AccountSnapshot{
-						Type:           database.SnapshotTypeDaily,
-						CreatedAt:      createdAt,
-						AccountID:      stats.Account.ID,
-						ReferenceID:    stats.Account.ID,
-						LastBattleTime: stats.LastBattleTime,
-						RatingBattles:  stats.RatingBattles.StatsFrame,
-						RegularBattles: stats.RegularBattles.StatsFrame,
-					})
-
-					if len(vehicles) < 1 {
-						continue
-					}
-					vehicleStats := fetch.WargamingVehiclesToFrame(vehicles)
-					for _, vehicle := range vehicleStats {
-						if vehicle.LastBattleTime.IsZero() {
-							continue
-						}
-						vehicleSnapshots = append(vehicleSnapshots, database.VehicleSnapshot{
-							CreatedAt:      createdAt,
-							Type:           database.SnapshotTypeDaily,
-							LastBattleTime: vehicle.LastBattleTime,
-							AccountID:      stats.Account.ID,
-							VehicleID:      vehicle.VehicleID,
-							ReferenceID:    stats.Account.ID,
-							Stats:          *vehicle.StatsFrame,
-						})
-					}
-				}
-			}
-
-			err = client.Database().CreateAccountSnapshots(ctx, snapshots...)
-			if err != nil {
-				return "failed to save account snapshots to database", err
-			}
-
-			err = client.Database().CreateVehicleSnapshots(ctx, vehicleSnapshots...)
-			if err != nil {
-				return "failed to save vehicle snapshots to database", err
-			}
-
-			if len(withErrors) == 0 {
+			if len(accountErrors) == 0 {
 				return "finished session update on all accounts", nil
 			}
 
 			// Retry failed accounts
-			task.Targets = withErrors
+			task.Targets = make([]string, len(accountErrors))
+			for id := range accountErrors {
+				task.Targets = append(task.Targets, id)
+			}
 			return "retrying failed accounts", errors.New("some accounts failed")
 		},
 		ShouldRetry: func(task *database.Task) bool {
diff --git a/cmds/discord/commands/options.go b/cmds/discord/commands/options.go
index fa4de325..3ee45d2b 100644
--- a/cmds/discord/commands/options.go
+++ b/cmds/discord/commands/options.go
@@ -50,6 +50,7 @@ var defaultStatsOptions = append([]builder.Option{
 
 type statsOptions struct {
 	PeriodStart time.Time
+	Days        int
 	Server      string
 	Nickname    string
 	UserID      string
@@ -84,6 +85,7 @@ func getDefaultStatsOptions(ctx *common.Context) statsOptions {
 	options.UserID, _ = common.GetOption[string](ctx, "user")
 
 	if days, _ := common.GetOption[float64](ctx, "days"); days > 0 {
+		options.Days = int(days)
 		options.PeriodStart = time.Now().Add(time.Hour * 24 * time.Duration(days) * -1)
 	}
 
diff --git a/cmds/discord/commands/session.go b/cmds/discord/commands/session.go
index b8fbd348..b8de76a2 100644
--- a/cmds/discord/commands/session.go
+++ b/cmds/discord/commands/session.go
@@ -9,8 +9,10 @@ import (
 	"github.com/cufee/aftermath/cmds/discord/commands/builder"
 	"github.com/cufee/aftermath/cmds/discord/common"
 	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/stats"
 	"github.com/cufee/aftermath/internal/stats/render"
 	"github.com/cufee/aftermath/internal/stats/render/assets"
+	"github.com/pkg/errors"
 )
 
 func init() {
@@ -61,6 +63,9 @@ func init() {
 
 				image, _, err := ctx.Core.Render(ctx.Locale).Session(context.Background(), accountID, options.PeriodStart, render.WithBackground(background))
 				if err != nil {
+					if errors.Is(err, stats.ErrAccountNotTracked) {
+						return ctx.Reply("session_error_account_was_not_tracked")
+					}
 					return ctx.Err(err)
 				}
 
diff --git a/internal/database/client.go b/internal/database/client.go
index 748a5c69..a4e69e3a 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -30,6 +30,7 @@ type Client interface {
 
 	CreateAccountSnapshots(ctx context.Context, snapshots ...AccountSnapshot) error
 	GetAccountSnapshot(ctx context.Context, accountID, referenceID string, kind snapshotType, options ...SnapshotQuery) (AccountSnapshot, error)
+	GetManyAccountSnapshots(ctx context.Context, accountIDs []string, kind snapshotType, options ...SnapshotQuery) ([]AccountSnapshot, error)
 	CreateVehicleSnapshots(ctx context.Context, snapshots ...VehicleSnapshot) error
 	GetVehicleSnapshots(ctx context.Context, accountID, referenceID string, kind snapshotType, options ...SnapshotQuery) ([]VehicleSnapshot, error)
 
diff --git a/internal/database/prisma/schema.prisma b/internal/database/prisma/schema.prisma
index 791b59a2..5885f1b8 100644
--- a/internal/database/prisma/schema.prisma
+++ b/internal/database/prisma/schema.prisma
@@ -215,6 +215,7 @@ model AccountSnapshot {
   regularFrameEncoded Bytes
 
   @@index([createdAt])
+  @@index([type, accountId, createdAt])
   @@index([type, accountId, referenceId])
   @@index([type, accountId, referenceId, createdAt])
   @@map("account_snapshots")
diff --git a/internal/database/snapshots.go b/internal/database/snapshots.go
index dd525cb4..5d1d661f 100644
--- a/internal/database/snapshots.go
+++ b/internal/database/snapshots.go
@@ -70,9 +70,9 @@ func (s getSnapshotQuery) vehiclesQuery(accountID, referenceID string, kind snap
 	}
 
 	// Determine the order by clause
-	var orderBy string = "createdAt ASC"
-	if s.createdBefore != nil {
-		orderBy = "createdAt DESC"
+	var orderBy string = "createdAt DESC"
+	if s.createdAfter != nil {
+		orderBy = "createdAt ASC"
 	}
 
 	// Base query
@@ -103,17 +103,72 @@ func (s getSnapshotQuery) vehiclesQuery(accountID, referenceID string, kind snap
 	return query, args
 }
 
-func (s getSnapshotQuery) accountOrder() []db.AccountSnapshotOrderByParam {
-	var order []db.AccountSnapshotOrderByParam
+func (s getSnapshotQuery) manyAccountsQuery(accountIDs []string, kind snapshotType) (query string, params []interface{}) {
+	var conditions []string
+	var args []interface{}
+
+	// Mandatory conditions
+	conditions = append(conditions, "type = ?")
+	args = append(args, kind)
 
-	switch {
-	case s.createdAfter != nil:
-		order = append(order, db.AccountSnapshot.CreatedAt.Order(db.ASC))
-	default:
-		order = append(order, db.AccountSnapshot.CreatedAt.Order(db.DESC))
+	// Optional conditions
+	if s.createdAfter != nil {
+		conditions = append(conditions, "createdAt > ?")
+		args = append(args, *s.createdAfter)
 	}
+	if s.createdBefore != nil {
+		conditions = append(conditions, "createdAt < ?")
+		args = append(args, *s.createdBefore)
+	}
+
+	// Filter by account IDs
+	placeholders := make([]string, len(accountIDs))
+	for i := range accountIDs {
+		placeholders[i] = "?"
+	}
+	conditions = append(conditions, fmt.Sprintf("accountId IN (%s)", strings.Join(placeholders, ",")))
+	for _, id := range accountIDs {
+		args = append(args, id)
+	}
+
+	// Determine the order by clause
+	var orderBy string = "createdAt DESC"
+	if s.createdAfter != nil {
+		orderBy = "createdAt ASC"
+	}
+
+	// Combine conditions into a single string
+	conditionsStr := strings.Join(conditions, " AND ")
 
-	return order
+	// Base query
+	query = fmt.Sprintf(`
+			SELECT
+				id, createdAt, type, lastBattleTime, accountId, referenceId, ratingBattles, ratingFrameEncoded, regularBattles, regularFrameEncoded
+			FROM
+				account_snapshots
+			WHERE
+				%s
+			ORDER BY
+				%s
+		`, conditionsStr, orderBy)
+
+	// Wrap the query to select the latest snapshot per accountId
+	wrappedQuery := fmt.Sprintf(`
+			SELECT * FROM (
+				%s
+			) AS ordered_snapshots
+			GROUP BY accountId
+		`, query)
+
+	return wrappedQuery, args
+}
+
+func (s getSnapshotQuery) accountOrder() []db.AccountSnapshotOrderByParam {
+	order := db.DESC
+	if s.createdAfter != nil {
+		order = db.ASC
+	}
+	return []db.AccountSnapshotOrderByParam{db.AccountSnapshot.CreatedAt.Order(order)}
 }
 
 type SnapshotQuery func(*getSnapshotQuery)
@@ -311,3 +366,29 @@ func (c *client) GetAccountSnapshot(ctx context.Context, accountID, referenceID
 
 	return AccountSnapshot{}.FromModel(model)
 }
+
+func (c *client) GetManyAccountSnapshots(ctx context.Context, accountIDs []string, kind snapshotType, options ...SnapshotQuery) ([]AccountSnapshot, error) {
+	var query getSnapshotQuery
+	for _, apply := range options {
+		apply(&query)
+	}
+
+	var models []db.AccountSnapshotModel
+	raw, args := query.manyAccountsQuery(accountIDs, kind)
+	err := c.prisma.Prisma.Raw.QueryRaw(raw, args...).Exec(ctx, &models)
+	if err != nil {
+		return nil, err
+	}
+
+	var snapshots []AccountSnapshot
+	for _, model := range models {
+		snapshot, err := AccountSnapshot{}.FromModel(&model)
+		if err != nil {
+			return nil, err
+		}
+		snapshots = append(snapshots, snapshot)
+	}
+
+	return snapshots, nil
+
+}
diff --git a/internal/logic/sessions.go b/internal/logic/sessions.go
new file mode 100644
index 00000000..3630b1a3
--- /dev/null
+++ b/internal/logic/sessions.go
@@ -0,0 +1,174 @@
+package logic
+
+import (
+	"context"
+	"sync"
+	"time"
+
+	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/prisma/db"
+	"github.com/cufee/aftermath/internal/external/wargaming"
+	"github.com/cufee/aftermath/internal/retry"
+	"github.com/cufee/aftermath/internal/stats/fetch"
+	"github.com/cufee/am-wg-proxy-next/v2/types"
+	"github.com/pkg/errors"
+	"github.com/rs/zerolog/log"
+)
+
+type vehicleResponseData map[string][]types.VehicleStatsFrame
+
+func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbClient database.Client, realm string, force bool, accountIDs ...string) (map[string]error, error) {
+	if len(accountIDs) < 1 {
+		return nil, nil
+	}
+
+	createdAt := time.Now()
+	accounts, err := wgClient.BatchAccountByID(ctx, realm, accountIDs)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to fetch accounts")
+	}
+
+	// existing snaphsots for accounts
+	existingSnapshots, err := dbClient.GetManyAccountSnapshots(ctx, accountIDs, database.SnapshotTypeDaily)
+	if err != nil && !db.IsErrNotFound(err) {
+		return nil, errors.Wrap(err, "failed to get existing snapshots")
+	}
+	existingSnapshotsMap := make(map[string]*database.AccountSnapshot)
+	for _, snapshot := range existingSnapshots {
+		existingSnapshotsMap[snapshot.AccountID] = &snapshot
+	}
+
+	// make a new slice just in case some accounts were not returned/are private
+	var validAccouts []string
+	for _, id := range accountIDs {
+		data, ok := accounts[id]
+		if !ok {
+			go func(id string) {
+				log.Debug().Str("accountId", id).Msg("account is private")
+				// update account cache (if it exists) to set account as private
+				ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+				defer cancel()
+				err := dbClient.AccountSetPrivate(ctx, id, true)
+				if err != nil {
+					log.Err(err).Str("accountId", id).Msg("failed to set account status as private")
+				}
+			}(id)
+			continue
+		}
+		if data.LastBattleTime == 0 {
+			continue
+		}
+		if s, ok := existingSnapshotsMap[id]; !force && ok && data.LastBattleTime == int(s.LastBattleTime.Unix()) {
+			// last snapshot is the same, we can skip it
+			continue
+		}
+		validAccouts = append(validAccouts, id)
+	}
+
+	if len(validAccouts) == 0 {
+		return nil, nil
+	}
+
+	// clans are options-ish
+	clans, err := wgClient.BatchAccountClan(ctx, realm, validAccouts)
+	if err != nil {
+		log.Err(err).Msg("failed to get batch account clans")
+		clans = make(map[string]types.ClanMember)
+	}
+
+	vehicleCh := make(chan retry.DataWithErr[vehicleResponseData], len(validAccouts))
+	var group sync.WaitGroup
+	group.Add(len(validAccouts))
+	for _, id := range validAccouts {
+		go func(id string) {
+			defer group.Done()
+			data, err := wgClient.AccountVehicles(ctx, realm, id)
+			vehicleCh <- retry.DataWithErr[vehicleResponseData]{Data: vehicleResponseData{id: data}, Err: err}
+		}(id)
+	}
+	group.Wait()
+	close(vehicleCh)
+
+	var accountErrors = make(map[string]error)
+	var accountUpdates []database.Account
+	var snapshots []database.AccountSnapshot
+	var vehicleSnapshots []database.VehicleSnapshot
+	for result := range vehicleCh {
+		// there is only 1 key in this map
+		for id, vehicles := range result.Data {
+			if result.Err != nil {
+				accountErrors[id] = result.Err
+				continue
+			}
+			existingSnapshots, err := dbClient.GetVehicleSnapshots(ctx, id, id, database.SnapshotTypeDaily)
+			if err != nil && !db.IsErrNotFound(err) {
+				accountErrors[id] = err
+				continue
+			}
+			existingSnapshotsMap := make(map[string]*database.VehicleSnapshot)
+			for _, snapshot := range existingSnapshots {
+				existingSnapshotsMap[snapshot.VehicleID] = &snapshot
+			}
+
+			stats := fetch.WargamingToStats(realm, accounts[id], clans[id], vehicles)
+			accountUpdates = append(accountUpdates, database.Account{
+				Realm:    stats.Realm,
+				ID:       stats.Account.ID,
+				Nickname: stats.Account.Nickname,
+
+				Private:        false,
+				CreatedAt:      stats.Account.CreatedAt,
+				LastBattleTime: stats.LastBattleTime,
+
+				ClanID:  stats.Account.ClanID,
+				ClanTag: stats.Account.ClanTag,
+			})
+			snapshots = append(snapshots, database.AccountSnapshot{
+				Type:           database.SnapshotTypeDaily,
+				CreatedAt:      createdAt,
+				AccountID:      stats.Account.ID,
+				ReferenceID:    stats.Account.ID,
+				LastBattleTime: stats.LastBattleTime,
+				RatingBattles:  stats.RatingBattles.StatsFrame,
+				RegularBattles: stats.RegularBattles.StatsFrame,
+			})
+
+			if len(vehicles) < 1 {
+				continue
+			}
+			vehicleStats := fetch.WargamingVehiclesToFrame(vehicles)
+			for id, vehicle := range vehicleStats {
+				if vehicle.LastBattleTime.IsZero() {
+					// vehicle was never played
+					continue
+				}
+				if s, ok := existingSnapshotsMap[id]; !force && ok && s.Stats.Battles == vehicle.Battles {
+					// last snapshot is the same, we can skip it
+					continue
+				}
+
+				vehicleSnapshots = append(vehicleSnapshots, database.VehicleSnapshot{
+					CreatedAt:      createdAt,
+					Type:           database.SnapshotTypeDaily,
+					LastBattleTime: vehicle.LastBattleTime,
+					AccountID:      stats.Account.ID,
+					VehicleID:      vehicle.VehicleID,
+					ReferenceID:    stats.Account.ID,
+					Stats:          *vehicle.StatsFrame,
+				})
+			}
+		}
+	}
+
+	err = dbClient.CreateAccountSnapshots(ctx, snapshots...)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to save account snapshots to database")
+	}
+
+	err = dbClient.CreateVehicleSnapshots(ctx, vehicleSnapshots...)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to save vehicle snapshots to database")
+	}
+
+	return accountErrors, nil
+}
diff --git a/internal/stats/errors.go b/internal/stats/errors.go
new file mode 100644
index 00000000..be6b8daa
--- /dev/null
+++ b/internal/stats/errors.go
@@ -0,0 +1,7 @@
+package stats
+
+import "github.com/pkg/errors"
+
+var (
+	ErrAccountNotTracked = errors.New("account not tracked")
+)
diff --git a/internal/stats/fetch/client.go b/internal/stats/fetch/client.go
index 7cfa4506..60e65777 100644
--- a/internal/stats/fetch/client.go
+++ b/internal/stats/fetch/client.go
@@ -47,6 +47,7 @@ type StatsWithVehicles struct {
 }
 
 type Client interface {
+	Account(ctx context.Context, id string) (database.Account, error)
 	Search(ctx context.Context, nickname, realm string) (types.Account, error)
 	CurrentStats(ctx context.Context, id string, opts ...statsOption) (AccountStatsOverPeriod, error)
 
diff --git a/internal/stats/fetch/errors.go b/internal/stats/fetch/errors.go
new file mode 100644
index 00000000..995c2692
--- /dev/null
+++ b/internal/stats/fetch/errors.go
@@ -0,0 +1,8 @@
+package fetch
+
+import "github.com/pkg/errors"
+
+var (
+	ErrSessionNotFound     = errors.New("account sessions not found")
+	ErrInvalidSessionStart = errors.New("invalid session start provided")
+)
diff --git a/internal/stats/fetch/multisource.go b/internal/stats/fetch/multisource.go
index 3dd3c7a7..fb95ad9d 100644
--- a/internal/stats/fetch/multisource.go
+++ b/internal/stats/fetch/multisource.go
@@ -52,6 +52,51 @@ func (c *multiSourceClient) Search(ctx context.Context, nickname, realm string)
 	return accounts[0], nil
 }
 
+/*
+Gets account info from wg and updates cache
+*/
+func (c *multiSourceClient) Account(ctx context.Context, id string) (database.Account, error) {
+	realm := c.wargaming.RealmFromAccountID(id)
+
+	var group sync.WaitGroup
+	group.Add(2)
+
+	var clan types.ClanMember
+	var wgAccount retry.DataWithErr[types.ExtendedAccount]
+
+	go func() {
+		defer group.Done()
+
+		wgAccount = retry.Retry(func() (types.ExtendedAccount, error) {
+			return c.wargaming.AccountByID(ctx, realm, id)
+		}, c.retriesPerRequest, c.retrySleepInterval)
+	}()
+	go func() {
+		defer group.Done()
+		// we should not retry this request since it is not critical and will fail on accounts without a clan
+		clan, _ = c.wargaming.AccountClan(ctx, realm, id)
+	}()
+
+	group.Wait()
+
+	if wgAccount.Err != nil {
+		return database.Account{}, wgAccount.Err
+	}
+
+	account := wargamingToAccount(realm, wgAccount.Data, clan, false)
+	go func() {
+		ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+		defer cancel()
+
+		errMap := c.database.UpsertAccounts(ctx, []database.Account{account})
+		if err := errMap[id]; err != nil {
+			log.Err(err).Msg("failed to update account cache")
+		}
+	}()
+
+	return account, nil
+}
+
 /*
 Get live account stats from wargaming
   - Each request will be retried c.retriesPerRequest times
@@ -224,8 +269,20 @@ func (c *multiSourceClient) SessionStats(ctx context.Context, id string, session
 	for _, apply := range opts {
 		apply(&options)
 	}
+
+	// sessions and period stats are tracked differenttly
+	// we look up the latest session _before_ sessionBefore, not after sessionStart
 	if sessionStart.IsZero() {
-		sessionStart = time.Now().Add(time.Hour * 25 * -1)
+		sessionStart = time.Now()
+	}
+	if days := time.Since(sessionStart).Hours() / 24; days > 90 {
+		return AccountStatsOverPeriod{}, ErrInvalidSessionStart
+	}
+
+	sessionBefore := sessionStart
+	if time.Since(sessionStart).Hours() >= 24 {
+		// 3 days would mean today and yest, so before the reset 2 days ago and so on
+		sessionBefore = sessionBefore.Add(time.Hour * 24 * -1)
 	}
 
 	var accountSnapshot retry.DataWithErr[database.AccountSnapshot]
@@ -253,31 +310,12 @@ func (c *multiSourceClient) SessionStats(ctx context.Context, id string, session
 		averages = retry.DataWithErr[map[string]frame.StatsFrame]{Data: a, Err: err}
 	}()
 
-	// return career stats if stats are requested for 0 or 90+ days, we do not track that far
-	if days := time.Since(sessionStart).Hours() / 24; days > 90 || days < 1 {
-		group.Wait()
-		if current.Err != nil {
-			return AccountStatsOverPeriod{}, current.Err
-		}
-		if averages.Err != nil {
-			// not critical, this will only affect WN8
-			log.Err(averages.Err).Msg("failed to get tank averages")
-		}
-
-		stats := current.Data
-		if options.withWN8 {
-			stats.AddWN8(averages.Data)
-		}
-		return stats, nil
-	}
-
 	group.Add(1)
 	go func() {
 		defer group.Done()
-		s, err := c.database.GetAccountSnapshot(ctx, id, id, database.SnapshotTypeDaily, database.WithCreatedAfter(sessionStart))
+		s, err := c.database.GetAccountSnapshot(ctx, id, id, database.SnapshotTypeDaily, database.WithCreatedBefore(sessionBefore))
 		accountSnapshot = retry.DataWithErr[database.AccountSnapshot]{Data: s, Err: err}
-
-		v, err := c.database.GetVehicleSnapshots(ctx, id, id, database.SnapshotTypeDaily, database.WithCreatedAfter(sessionStart))
+		v, err := c.database.GetVehicleSnapshots(ctx, id, id, database.SnapshotTypeDaily, database.WithCreatedBefore(sessionBefore))
 		vehiclesSnapshots = retry.DataWithErr[[]database.VehicleSnapshot]{Data: v, Err: err}
 	}()
 
@@ -287,17 +325,10 @@ func (c *multiSourceClient) SessionStats(ctx context.Context, id string, session
 		return AccountStatsOverPeriod{}, current.Err
 	}
 	if accountSnapshot.Err != nil {
-		if !db.IsErrNotFound(accountSnapshot.Err) {
-			return AccountStatsOverPeriod{}, accountSnapshot.Err
+		if db.IsErrNotFound(accountSnapshot.Err) {
+			return AccountStatsOverPeriod{}, ErrSessionNotFound
 		}
-		// if there is no snapshot, we just return 0 battles
-		stats := current.Data
-		stats.PeriodEnd = time.Now()
-		stats.PeriodStart = sessionStart
-		stats.RatingBattles.StatsFrame = frame.StatsFrame{}
-		stats.RegularBattles.StatsFrame = frame.StatsFrame{}
-		stats.RegularBattles.Vehicles = make(map[string]frame.VehicleStatsFrame, 0)
-		return stats, nil
+		return AccountStatsOverPeriod{}, accountSnapshot.Err
 	}
 	if averages.Err != nil {
 		// not critical, this will only affect WN8
diff --git a/internal/stats/renderer.go b/internal/stats/renderer.go
index ac0639c4..9c144826 100644
--- a/internal/stats/renderer.go
+++ b/internal/stats/renderer.go
@@ -5,6 +5,7 @@ import (
 	"time"
 
 	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/external/wargaming"
 	"github.com/cufee/aftermath/internal/stats/fetch"
 	"github.com/cufee/aftermath/internal/stats/render"
 	"golang.org/x/text/language"
@@ -14,6 +15,7 @@ var _ Renderer = &renderer{}
 
 type renderer struct {
 	fetchClient fetch.Client
+	wargaming   wargaming.Client
 	database    database.Client
 	locale      language.Tag
 }
@@ -25,6 +27,6 @@ type Renderer interface {
 	// Replay(accountId string, from time.Time) (image.Image, error)
 }
 
-func NewRenderer(fetch fetch.Client, database database.Client, locale language.Tag) *renderer {
-	return &renderer{fetch, database, locale}
+func NewRenderer(fetch fetch.Client, database database.Client, wargaming wargaming.Client, locale language.Tag) *renderer {
+	return &renderer{fetch, wargaming, database, locale}
 }
diff --git a/internal/stats/session.go b/internal/stats/session.go
index 67e75340..5cdd86b5 100644
--- a/internal/stats/session.go
+++ b/internal/stats/session.go
@@ -5,24 +5,68 @@ import (
 	"slices"
 	"time"
 
+	"github.com/cufee/aftermath/internal/database/prisma/db"
 	"github.com/cufee/aftermath/internal/localization"
+	"github.com/cufee/aftermath/internal/logic"
 	"github.com/cufee/aftermath/internal/stats/fetch"
 	prepare "github.com/cufee/aftermath/internal/stats/prepare/period"
 	options "github.com/cufee/aftermath/internal/stats/render"
 	render "github.com/cufee/aftermath/internal/stats/render/period"
+	"github.com/pkg/errors"
+	"github.com/rs/zerolog/log"
 )
 
 func (r *renderer) Session(ctx context.Context, accountId string, from time.Time, opts ...options.Option) (Image, Metadata, error) {
 	meta := Metadata{}
+	stop := meta.Timer("database#GetAccountByID")
+	_, err := r.database.GetAccountByID(ctx, accountId)
+	stop()
+	if err != nil {
+		if db.IsErrNotFound(err) {
+			_, err := r.fetchClient.Account(ctx, accountId) // this will cache the account
+			if err != nil {
+				return nil, meta, err
+			}
+			go func() {
+				// record a session in the background
+				ctx, cancel := context.WithTimeout(context.Background(), time.Second*15)
+				defer cancel()
+
+				_, err := logic.RecordAccountSnapshots(ctx, r.wargaming, r.database, r.wargaming.RealmFromAccountID(accountId), false, accountId)
+				if err != nil {
+					log.Err(err).Str("accountId", accountId).Msg("failed to record account snapshot")
+				}
+			}()
+			return nil, meta, ErrAccountNotTracked
+		}
+		return nil, meta, err
+	}
 
 	printer, err := localization.NewPrinter("stats", r.locale)
 	if err != nil {
 		return nil, meta, err
 	}
 
-	stop := meta.Timer("fetchClient#SessionStats")
+	stop = meta.Timer("fetchClient#SessionStats")
 	stats, err := r.fetchClient.SessionStats(ctx, accountId, from, fetch.WithWN8())
 	stop()
+	if errors.Is(err, fetch.ErrSessionNotFound) && time.Since(from).Hours()/24 <= 90 {
+		// we dont have a session, but one might be available from blitzstars
+		stats, err = r.fetchClient.PeriodStats(ctx, accountId, from, fetch.WithWN8())
+		// the error will be checked below
+	}
+	if errors.Is(err, fetch.ErrSessionNotFound) {
+		// Get account info and return a blank session
+		current, err := r.fetchClient.CurrentStats(ctx, accountId)
+		if err != nil {
+			return nil, meta, err
+		}
+		current.PeriodEnd = time.Now()
+		current.PeriodStart = current.PeriodEnd
+		current.RatingBattles = fetch.StatsWithVehicles{}
+		current.RegularBattles = fetch.StatsWithVehicles{}
+		stats = current
+	}
 	if err != nil {
 		return nil, meta, err
 	}
diff --git a/static/localization/en/discord.yaml b/static/localization/en/discord.yaml
index fb009c7f..86c74f1e 100755
--- a/static/localization/en/discord.yaml
+++ b/static/localization/en/discord.yaml
@@ -131,6 +131,10 @@
   value: "I was not able to find a player named **%s** on **%s**. Was the name spelled correctly?"
   context: Invalid Blitz username provided
 
+- key: session_error_account_was_not_tracked
+  value: "Aftermath just started tracking this account. Please play a few battles before using this command again."
+  context: We were not tracking this account, but successfully started tracking it just now
+
 # /background errors
 - key: background_error_payment_required
   value: "This feature of Aftermath is only available for users with an active subscription.\nYou can subscribe by using the `/subscribe` command or pick a background using `/fancy` instead."
@@ -152,7 +156,7 @@
 - key: replay_error_missing_attachment
   value: "You need to provide a link or attach a WoT Blitz replay file."
   context: Invalid file attached
-  
+
   # /link errors
 - key: link_error_missing_input
   value: "I need both the nickname and server to find your account."
@@ -162,7 +166,7 @@
 - key: verify_error_missing_server
   value: "Please select a server your account is registered on."
   context: Server not selected
-  
+
   # Wargaming specific errors
 - key: wargaming_error_private_account
   value: "This account is marked private by Wargaming and no stats are available for it at this time."

From 7f9335ac3ed1b8b459956fe5f87255ab360ae21e Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Wed, 12 Jun 2024 19:23:56 -0400
Subject: [PATCH 039/341] resetting error

---
 internal/stats/session.go | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/internal/stats/session.go b/internal/stats/session.go
index 5cdd86b5..4d7a3a6a 100644
--- a/internal/stats/session.go
+++ b/internal/stats/session.go
@@ -19,7 +19,7 @@ import (
 func (r *renderer) Session(ctx context.Context, accountId string, from time.Time, opts ...options.Option) (Image, Metadata, error) {
 	meta := Metadata{}
 	stop := meta.Timer("database#GetAccountByID")
-	_, err := r.database.GetAccountByID(ctx, accountId)
+	account, err := r.database.GetAccountByID(ctx, accountId)
 	stop()
 	if err != nil {
 		if db.IsErrNotFound(err) {
@@ -56,17 +56,16 @@ func (r *renderer) Session(ctx context.Context, accountId string, from time.Time
 		// the error will be checked below
 	}
 	if errors.Is(err, fetch.ErrSessionNotFound) {
-		// Get account info and return a blank session
-		current, err := r.fetchClient.CurrentStats(ctx, accountId)
-		if err != nil {
-			return nil, meta, err
+		// blank session
+		err = nil
+		stats = fetch.AccountStatsOverPeriod{
+			Account:        account,
+			LastBattleTime: account.LastBattleTime,
+			PeriodStart:    time.Now(),
+			PeriodEnd:      time.Now(),
 		}
-		current.PeriodEnd = time.Now()
-		current.PeriodStart = current.PeriodEnd
-		current.RatingBattles = fetch.StatsWithVehicles{}
-		current.RegularBattles = fetch.StatsWithVehicles{}
-		stats = current
 	}
+
 	if err != nil {
 		return nil, meta, err
 	}

From 4f7e1de592cbee20ef6842cf33a451a3358fff14 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Wed, 12 Jun 2024 19:24:28 -0400
Subject: [PATCH 040/341] missing realm

---
 internal/stats/session.go | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/internal/stats/session.go b/internal/stats/session.go
index 4d7a3a6a..c3e66ce9 100644
--- a/internal/stats/session.go
+++ b/internal/stats/session.go
@@ -59,10 +59,11 @@ func (r *renderer) Session(ctx context.Context, accountId string, from time.Time
 		// blank session
 		err = nil
 		stats = fetch.AccountStatsOverPeriod{
+			Realm:          account.Realm,
 			Account:        account,
-			LastBattleTime: account.LastBattleTime,
-			PeriodStart:    time.Now(),
 			PeriodEnd:      time.Now(),
+			PeriodStart:    time.Now(),
+			LastBattleTime: account.LastBattleTime,
 		}
 	}
 

From 33f0fdd2cf6c9738ad72dabcdef793ca23c7f193 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 13 Jun 2024 15:37:32 -0400
Subject: [PATCH 041/341] removed fly workflow

---
 .github/workflows/canary_fly.yml | 38 ++++++++++++++++----------------
 internal/stats/session.go        |  1 -
 2 files changed, 19 insertions(+), 20 deletions(-)

diff --git a/.github/workflows/canary_fly.yml b/.github/workflows/canary_fly.yml
index 41ce70af..353e70cb 100644
--- a/.github/workflows/canary_fly.yml
+++ b/.github/workflows/canary_fly.yml
@@ -1,21 +1,21 @@
-name: Fly Deploy to Canary
+# name: Fly Deploy to Canary
 
-on:
-  push:
-    branches:
-      - canary
-  workflow_dispatch: {}
+# on:
+#   push:
+#     branches:
+#       - canary
+#   workflow_dispatch: {}
 
-jobs:
-  deploy:
-    name: Deploy app to canary
-    runs-on: ubuntu-latest
-    environment: Fly Canary
-    concurrency: deploy-group
-    timeout-minutes: 3
-    steps:
-      - uses: actions/checkout@v4
-      - uses: superfly/flyctl-actions/setup-flyctl@master
-      - run: flyctl deploy --remote-only -c fly.canary.toml
-        env:
-          FLY_API_TOKEN: ${{ secrets.FLY_API_TOKEN }}
+# jobs:
+#   deploy:
+#     name: Deploy app to canary
+#     runs-on: ubuntu-latest
+#     environment: Fly Canary
+#     concurrency: deploy-group
+#     timeout-minutes: 3
+#     steps:
+#       - uses: actions/checkout@v4
+#       - uses: superfly/flyctl-actions/setup-flyctl@master
+#       - run: flyctl deploy --remote-only -c fly.canary.toml
+#         env:
+#           FLY_API_TOKEN: ${{ secrets.FLY_API_TOKEN }}
diff --git a/internal/stats/session.go b/internal/stats/session.go
index c3e66ce9..7a1d5990 100644
--- a/internal/stats/session.go
+++ b/internal/stats/session.go
@@ -66,7 +66,6 @@ func (r *renderer) Session(ctx context.Context, accountId string, from time.Time
 			LastBattleTime: account.LastBattleTime,
 		}
 	}
-
 	if err != nil {
 		return nil, meta, err
 	}

From cff6da1b94d96cde432dd35099046008e9329986 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 13 Jun 2024 19:49:25 -0400
Subject: [PATCH 042/341] added some debug/manage commands

---
 .env.example                             |  36 +++++++-
 .github/workflows/canary_fly.yml         |  21 -----
 cmds/discord/commands/builder/command.go |  31 ++++++-
 cmds/discord/commands/builder/option.go  |   7 ++
 cmds/discord/commands/manage.go          | 107 +++++++++++++++++++++++
 cmds/discord/commands/options.go         |  12 +--
 cmds/discord/common/context.go           |  31 +++++--
 cmds/discord/middleware/middleware.go    |  14 ++-
 cmds/discord/router/handler.go           |   7 +-
 internal/database/client.go              |   3 +
 internal/database/snapshots.go           |  17 ++++
 internal/database/users.go               |  14 +++
 internal/logic/init.go                   |  25 ++++++
 internal/stats/session.go                |   5 --
 main.go                                  |   6 +-
 15 files changed, 293 insertions(+), 43 deletions(-)
 delete mode 100644 .github/workflows/canary_fly.yml
 create mode 100644 cmds/discord/commands/manage.go
 create mode 100644 internal/logic/init.go

diff --git a/.env.example b/.env.example
index dde0d0aa..483f66e7 100644
--- a/.env.example
+++ b/.env.example
@@ -1 +1,35 @@
-DATABASE_URL="file:/tmp/dev_local.db" # This should be an absolute path, otherwise prisma fails to run correctly
\ No newline at end of file
+# Path to a .db file where SQLite database will be created
+DATABASE_URL="file:/tmp/dev_local.db" # This should be an absolute path, otherwise prisma fails to run correctly
+
+# Init
+INIT_GLOBAL_ADMIN_USER="" # Discord user ID for a user who will be assigned permissions.GlobalAdmin on startup, can be left blank
+
+# Wargaming API
+WG_AUTH_APP_ID="" # Used to verify WG accounts, this app id will be exposed to the end user
+
+# Requests initiated by a user will always go through the "primary" wg app id and proxy
+WG_PRIMARY_APP_ID=""
+WG_PRIMARY_APP_RPS="10"
+WG_PRIMARY_REQUEST_TIMEOUT_SEC="5"
+WG_PROXY_HOST_LIST="" # can be left blank to disable proxy
+
+# Requests initiated from tasks during cache updates and etc will always go through this wg app id and proxy
+WG_CACHE_APP_ID=""
+WG_CACHE_APP_RPS="10"
+WG_CACHE_REQUEST_TIMEOUT_SEC="15"
+WG_CACHE_PROXY_HOST_LIST="" # can be left blank to disable proxy
+
+# Discord
+DISCORD_TOKEN=""
+DISCORD_PUBLIC_KEY=""
+DISCORD_PRIMARY_GUILD_ID="" # Discord ID of the primary guild, some features will be locked to this guild only
+DISCORD_ERROR_REPORT_WEBHOOK_URL="" # A Discord webhook URL for a channel where the bot should report errors
+
+# Optional components
+SCHEDULER_ENABLED="true"
+SCHEDULER_CONCURRENT_WORKERS="10"
+
+# Misc configuration
+LOG_LEVEL="debug"
+NETWORK="tcp"
+PORT="9092"
diff --git a/.github/workflows/canary_fly.yml b/.github/workflows/canary_fly.yml
deleted file mode 100644
index 353e70cb..00000000
--- a/.github/workflows/canary_fly.yml
+++ /dev/null
@@ -1,21 +0,0 @@
-# name: Fly Deploy to Canary
-
-# on:
-#   push:
-#     branches:
-#       - canary
-#   workflow_dispatch: {}
-
-# jobs:
-#   deploy:
-#     name: Deploy app to canary
-#     runs-on: ubuntu-latest
-#     environment: Fly Canary
-#     concurrency: deploy-group
-#     timeout-minutes: 3
-#     steps:
-#       - uses: actions/checkout@v4
-#       - uses: superfly/flyctl-actions/setup-flyctl@master
-#       - run: flyctl deploy --remote-only -c fly.canary.toml
-#         env:
-#           FLY_API_TOKEN: ${{ secrets.FLY_API_TOKEN }}
diff --git a/cmds/discord/commands/builder/command.go b/cmds/discord/commands/builder/command.go
index 8ed9a206..97e15aa2 100644
--- a/cmds/discord/commands/builder/command.go
+++ b/cmds/discord/commands/builder/command.go
@@ -21,6 +21,10 @@ type CommandHandler func(*common.Context) error
 type Command struct {
 	discordgo.ApplicationCommand
 
+	DMOnly    bool
+	GuildIDs  []string
+	GuildOnly bool
+
 	Type       commandType
 	Match      func(string) bool
 	Handler    CommandHandler
@@ -33,6 +37,10 @@ type Builder struct {
 	kind   commandType
 	params parameters
 
+	dmOnly    bool
+	guildOnly bool
+	guilds    []string
+
 	match      func(string) bool
 	handler    CommandHandler
 	middleware []middleware.MiddlewareFunc
@@ -70,7 +78,11 @@ func (c Builder) Build() Command {
 			DescriptionLocalizations: &descLocalized,
 			Options:                  options,
 			Type:                     discordgo.ChatApplicationCommand,
+			DMPermission:             &c.dmOnly,
 		},
+		c.dmOnly,
+		c.guilds,
+		c.guildOnly,
 		c.kind,
 		c.match,
 		c.handler,
@@ -91,12 +103,27 @@ func (c Builder) Params(params ...Param) Builder {
 	return c
 }
 
-func (c Builder) IsEphemeral() Builder {
+func (c Builder) DMOnly() Builder {
+	c.dmOnly = true
+	return c
+}
+
+func (c Builder) GuildOnly() Builder {
+	c.guildOnly = true
+	return c
+}
+
+func (c Builder) ExclusiveToGuilds(guilds ...string) Builder {
+	c.guilds = append(c.guilds, guilds...)
+	return c
+}
+
+func (c Builder) Ephemeral() Builder {
 	c.ephemeral = true
 	return c
 }
 
-func (c Builder) IsComponentType() Builder {
+func (c Builder) ComponentType() Builder {
 	c.kind = CommandTypeComponent
 	return c
 }
diff --git a/cmds/discord/commands/builder/option.go b/cmds/discord/commands/builder/option.go
index 2b259aa4..e3133179 100644
--- a/cmds/discord/commands/builder/option.go
+++ b/cmds/discord/commands/builder/option.go
@@ -86,6 +86,12 @@ func (o Option) Build(command string) discordgo.ApplicationCommandOption {
 		panic("option type is not set")
 	}
 
+	var options []*discordgo.ApplicationCommandOption
+	for _, option := range o.options {
+		opt := option.Build(command + "_" + o.name)
+		options = append(options, &opt)
+	}
+
 	nameLocalized := common.LocalizeKey(o.nameKey(command))
 	descLocalized := common.LocalizeKey(o.descKey(command))
 
@@ -106,6 +112,7 @@ func (o Option) Build(command string) discordgo.ApplicationCommandOption {
 		MaxValue:                 o.maxValue,
 		Required:                 o.required,
 		Choices:                  choices,
+		Options:                  options,
 		Type:                     o.kind,
 	}
 }
diff --git a/cmds/discord/commands/manage.go b/cmds/discord/commands/manage.go
new file mode 100644
index 00000000..8994b7b2
--- /dev/null
+++ b/cmds/discord/commands/manage.go
@@ -0,0 +1,107 @@
+package commands
+
+import (
+	"encoding/json"
+	"os"
+
+	"github.com/bwmarrin/discordgo"
+	"github.com/cufee/aftermath/cmds/discord/commands/builder"
+	"github.com/cufee/aftermath/cmds/discord/common"
+	"github.com/cufee/aftermath/cmds/discord/middleware"
+	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/permissions"
+)
+
+func init() {
+	Loaded.add(
+		builder.NewCommand("manage").
+			ExclusiveToGuilds(os.Getenv("DISCORD_PRIMARY_GUILD_ID")).
+			Middleware(middleware.RequirePermissions(permissions.GlobalAdmin)).
+			Options(
+				builder.NewOption("users", discordgo.ApplicationCommandOptionSubCommandGroup).Options(
+					builder.NewOption("lookup", discordgo.ApplicationCommandOptionSubCommand).Options(
+						userOption,
+					),
+				),
+				builder.NewOption("accounts", discordgo.ApplicationCommandOptionSubCommandGroup).Options(
+					builder.NewOption("search", discordgo.ApplicationCommandOptionSubCommand).Options(
+						nicknameAndServerOptions...,
+					),
+				),
+				builder.NewOption("tasks", discordgo.ApplicationCommandOptionSubCommandGroup).Options(
+					builder.NewOption("view", discordgo.ApplicationCommandOptionSubCommand),
+				),
+				builder.NewOption("snapshots", discordgo.ApplicationCommandOptionSubCommandGroup).Options(
+					builder.NewOption("view", discordgo.ApplicationCommandOptionSubCommand).Options(
+						builder.NewOption("account_id", discordgo.ApplicationCommandOptionString).Required(),
+					),
+				),
+			).
+			Handler(func(ctx *common.Context) error {
+				command, opts, _ := ctx.Options().Subcommand()
+
+				switch command {
+				case "users_lookup":
+					userID, _ := opts.Value("user").(string)
+					result, err := ctx.Core.Database().GetUserByID(ctx.Context, userID, database.WithConnections())
+					if err != nil {
+						return ctx.Reply("Database#GetUserByID: " + err.Error())
+					}
+
+					data, err := json.MarshalIndent(result, "", "  ")
+					if err != nil {
+						return ctx.Reply("MarshalIndent: " + err.Error())
+					}
+					return ctx.Reply("```" + string(data) + "```")
+
+				case "accounts_search":
+					nickname, _ := opts.Value("nickname").(string)
+					server, _ := opts.Value("server").(string)
+					result, err := ctx.Core.Fetch().Search(ctx.Context, nickname, server)
+					if err != nil {
+						return ctx.Reply("Fetch#Search: " + err.Error())
+					}
+					data, err := json.MarshalIndent(result, "", "  ")
+					if err != nil {
+						return ctx.Reply("MarshalIndent: " + err.Error())
+					}
+					return ctx.Reply("```" + string(data) + "```")
+
+				case "snapshots_view":
+					accountId, ok := opts.Value("account_id").(string)
+					if !ok {
+						return ctx.Reply("invalid accountId, failed to cast to string")
+					}
+					snapshots, err := ctx.Core.Database().GetLastAccountSnapshots(ctx.Context, accountId, 3)
+					if err != nil {
+						return ctx.Reply("GetLastAccountSnapshots: " + err.Error())
+					}
+
+					var data []map[string]string
+					for _, snapshot := range snapshots {
+						data = append(data, map[string]string{
+							"id":             snapshot.ID,
+							"type":           string(snapshot.Type),
+							"referenceId":    snapshot.ReferenceID,
+							"createdAt":      snapshot.CreatedAt.String(),
+							"lastBattleTime": snapshot.LastBattleTime.String(),
+							"battlesRating":  snapshot.RatingBattles.Battles.String(),
+							"battlesRegular": snapshot.RegularBattles.Battles.String(),
+						})
+					}
+
+					bytes, err := json.MarshalIndent(data, "", "  ")
+					if err != nil {
+						return ctx.Reply("json.Marshal: " + err.Error())
+					}
+					return ctx.Reply("```" + string(bytes) + "```")
+
+				case "tasks_view":
+					return ctx.Reply("tasks view")
+
+				default:
+					return ctx.Reply("invalid subcommand, thought this should never happen")
+				}
+			}),
+	)
+}
diff --git a/cmds/discord/commands/options.go b/cmds/discord/commands/options.go
index 3ee45d2b..0511a87e 100644
--- a/cmds/discord/commands/options.go
+++ b/cmds/discord/commands/options.go
@@ -39,13 +39,15 @@ var nicknameAndServerOptions = []builder.Option{
 		),
 }
 
+var userOption = builder.NewOption("user", discordgo.ApplicationCommandOptionUser).
+	Params(
+		builder.SetNameKey("common_option_stats_user_name"),
+		builder.SetDescKey("common_option_stats_user_description"),
+	)
+
 var defaultStatsOptions = append([]builder.Option{
 	daysOption,
-	builder.NewOption("user", discordgo.ApplicationCommandOptionUser).
-		Params(
-			builder.SetNameKey("common_option_stats_user_name"),
-			builder.SetDescKey("common_option_stats_user_description"),
-		),
+	userOption,
 }, nicknameAndServerOptions...)
 
 type statsOptions struct {
diff --git a/cmds/discord/common/context.go b/cmds/discord/common/context.go
index 48f745f4..fea2b00f 100644
--- a/cmds/discord/common/context.go
+++ b/cmds/discord/common/context.go
@@ -130,18 +130,37 @@ func (c *Context) ID() string {
 	return ""
 }
 
-func (c *Context) Option(name string) any {
+func (c *Context) Options() options {
 	if data, ok := c.CommandData(); ok {
-		for _, opt := range data.Options {
-			fmt.Printf("%+v", opt)
-			if opt.Name == name {
-				return opt.Value
-			}
+		return data.Options
+	}
+	return options{}
+}
+
+type options []*discordgo.ApplicationCommandInteractionDataOption
+
+func (o options) Value(name string) any {
+	for _, opt := range o {
+		if opt.Name == name {
+			return opt.Value
 		}
 	}
 	return nil
 }
 
+func (o options) Subcommand() (string, options, bool) {
+	for _, opt := range o {
+		if opt.Type == discordgo.ApplicationCommandOptionSubCommandGroup {
+			name, opts, ok := options(opt.Options).Subcommand()
+			return opt.Name + "_" + name, opts, ok
+		}
+		if opt.Type == discordgo.ApplicationCommandOptionSubCommand {
+			return opt.Name, opt.Options, true
+		}
+	}
+	return "", options{}, false
+}
+
 func GetOption[T any](c *Context, name string) (T, bool) {
 	var v T
 	if data, ok := c.CommandData(); ok {
diff --git a/cmds/discord/middleware/middleware.go b/cmds/discord/middleware/middleware.go
index 691eb6eb..2ceb941d 100644
--- a/cmds/discord/middleware/middleware.go
+++ b/cmds/discord/middleware/middleware.go
@@ -2,6 +2,18 @@ package middleware
 
 import (
 	"github.com/cufee/aftermath/cmds/discord/common"
+	"github.com/cufee/aftermath/internal/permissions"
 )
 
-type MiddlewareFunc func(*common.Context, func(*common.Context)) func(*common.Context)
+type MiddlewareFunc func(*common.Context, func(*common.Context) error) func(*common.Context) error
+
+func RequirePermissions(required permissions.Permissions) MiddlewareFunc {
+	return func(ctx *common.Context, next func(*common.Context) error) func(*common.Context) error {
+		if !ctx.User.Permissions.Has(required) {
+			return func(ctx *common.Context) error {
+				return ctx.Reply("common_error_command_missing_permissions")
+			}
+		}
+		return next
+	}
+}
diff --git a/cmds/discord/router/handler.go b/cmds/discord/router/handler.go
index c84fb04a..142782a0 100644
--- a/cmds/discord/router/handler.go
+++ b/cmds/discord/router/handler.go
@@ -178,7 +178,12 @@ func (r *Router) handleInteraction(ctx context.Context, cancel context.CancelFun
 		return
 	}
 
-	err = command.Handler(cCtx)
+	handler := command.Handler
+	for i := len(command.Middleware) - 1; i >= 0; i-- {
+		handler = command.Middleware[i](cCtx, handler)
+	}
+
+	err = handler(cCtx)
 	if err != nil {
 		log.Err(err).Msg("handler returned an error")
 		reply <- discordgo.InteractionResponseData{Content: cCtx.Localize("common_error_unhandled_not_reported")}
diff --git a/internal/database/client.go b/internal/database/client.go
index a4e69e3a..6ee91676 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -5,6 +5,7 @@ import (
 	"time"
 
 	"github.com/cufee/aftermath/internal/database/prisma/db"
+	"github.com/cufee/aftermath/internal/permissions"
 	"github.com/cufee/aftermath/internal/stats/frame"
 	"golang.org/x/sync/semaphore"
 )
@@ -27,8 +28,10 @@ type Client interface {
 	GetOrCreateUserByID(ctx context.Context, id string, opts ...userGetOption) (User, error)
 	UpdateConnection(ctx context.Context, connection UserConnection) (UserConnection, error)
 	UpsertConnection(ctx context.Context, connection UserConnection) (UserConnection, error)
+	UpsertUserWithPermissions(ctx context.Context, userID string, perms permissions.Permissions) (User, error)
 
 	CreateAccountSnapshots(ctx context.Context, snapshots ...AccountSnapshot) error
+	GetLastAccountSnapshots(ctx context.Context, accountID string, limit int) ([]AccountSnapshot, error)
 	GetAccountSnapshot(ctx context.Context, accountID, referenceID string, kind snapshotType, options ...SnapshotQuery) (AccountSnapshot, error)
 	GetManyAccountSnapshots(ctx context.Context, accountIDs []string, kind snapshotType, options ...SnapshotQuery) ([]AccountSnapshot, error)
 	CreateVehicleSnapshots(ctx context.Context, snapshots ...VehicleSnapshot) error
diff --git a/internal/database/snapshots.go b/internal/database/snapshots.go
index 5d1d661f..671e3ba6 100644
--- a/internal/database/snapshots.go
+++ b/internal/database/snapshots.go
@@ -353,6 +353,23 @@ func (c *client) CreateAccountSnapshots(ctx context.Context, snapshots ...Accoun
 	return c.prisma.Prisma.Transaction(transactions...).Exec(ctx)
 }
 
+func (c *client) GetLastAccountSnapshots(ctx context.Context, accountID string, limit int) ([]AccountSnapshot, error) {
+	models, err := c.prisma.AccountSnapshot.FindMany(db.AccountSnapshot.AccountID.Equals(accountID)).OrderBy(db.AccountSnapshot.CreatedAt.Order(db.DESC)).Take(limit).Exec(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	var snapshots []AccountSnapshot
+	for _, model := range models {
+		s, err := AccountSnapshot{}.FromModel(&model)
+		if err != nil {
+			return nil, err
+		}
+		snapshots = append(snapshots, s)
+	}
+	return snapshots, nil
+}
+
 func (c *client) GetAccountSnapshot(ctx context.Context, accountID, referenceID string, kind snapshotType, options ...SnapshotQuery) (AccountSnapshot, error) {
 	var query getSnapshotQuery
 	for _, apply := range options {
diff --git a/internal/database/users.go b/internal/database/users.go
index 24d89cee..ed953375 100644
--- a/internal/database/users.go
+++ b/internal/database/users.go
@@ -215,6 +215,20 @@ func (c *client) GetUserByID(ctx context.Context, id string, opts ...userGetOpti
 	return user, nil
 }
 
+func (c *client) UpsertUserWithPermissions(ctx context.Context, userID string, perms permissions.Permissions) (User, error) {
+	model, err := c.prisma.User.UpsertOne(db.User.ID.Equals(userID)).
+		Create(db.User.ID.Set(userID), db.User.Permissions.Set(perms.String())).
+		Update(db.User.Permissions.Set(perms.String())).Exec(ctx)
+	if err != nil {
+		return User{}, err
+	}
+
+	var user User
+	user.ID = model.ID
+	user.Permissions = permissions.Parse(model.Permissions, permissions.User)
+	return user, nil
+}
+
 func (c *client) UpdateConnection(ctx context.Context, connection UserConnection) (UserConnection, error) {
 	if connection.ReferenceID == "" {
 		return UserConnection{}, errors.New("connection referenceID cannot be left blank")
diff --git a/internal/logic/init.go b/internal/logic/init.go
new file mode 100644
index 00000000..bf4d01e3
--- /dev/null
+++ b/internal/logic/init.go
@@ -0,0 +1,25 @@
+package logic
+
+import (
+	"context"
+	"os"
+	"time"
+
+	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/permissions"
+	"github.com/pkg/errors"
+)
+
+func ApplyInitOptions(database database.Client) error {
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*15)
+	defer cancel()
+
+	if id := os.Getenv("INIT_GLOBAL_ADMIN_USER"); id != "" {
+		_, err := database.UpsertUserWithPermissions(ctx, id, permissions.GlobalAdmin)
+		if err != nil {
+			return errors.Wrap(err, "failed to upsert a user with permissions")
+		}
+	}
+
+	return nil
+}
diff --git a/internal/stats/session.go b/internal/stats/session.go
index 7a1d5990..4c463f64 100644
--- a/internal/stats/session.go
+++ b/internal/stats/session.go
@@ -50,11 +50,6 @@ func (r *renderer) Session(ctx context.Context, accountId string, from time.Time
 	stop = meta.Timer("fetchClient#SessionStats")
 	stats, err := r.fetchClient.SessionStats(ctx, accountId, from, fetch.WithWN8())
 	stop()
-	if errors.Is(err, fetch.ErrSessionNotFound) && time.Since(from).Hours()/24 <= 90 {
-		// we dont have a session, but one might be available from blitzstars
-		stats, err = r.fetchClient.PeriodStats(ctx, accountId, from, fetch.WithWN8())
-		// the error will be checked below
-	}
 	if errors.Is(err, fetch.ErrSessionNotFound) {
 		// blank session
 		err = nil
diff --git a/main.go b/main.go
index cba576bb..ed76a496 100644
--- a/main.go
+++ b/main.go
@@ -17,6 +17,7 @@ import (
 	"github.com/cufee/aftermath/internal/external/blitzstars"
 	"github.com/cufee/aftermath/internal/external/wargaming"
 	"github.com/cufee/aftermath/internal/localization"
+	"github.com/cufee/aftermath/internal/logic"
 	"github.com/cufee/aftermath/internal/stats/fetch"
 
 	"github.com/cufee/aftermath/internal/stats/render/assets"
@@ -41,6 +42,9 @@ func main() {
 	coreClient := coreClientFromEnv()
 	startSchedulerFromEnvAsync()
 
+	// Load some init options to registed admin accounts and etc
+	logic.ApplyInitOptions(coreClient.Database())
+
 	discordHandler, err := discord.NewRouterHandler(coreClient, os.Getenv("DISCORD_TOKEN"), os.Getenv("DISCORD_PUBLIC_KEY"))
 	if err != nil {
 		panic(err)
@@ -97,7 +101,7 @@ func startSchedulerFromEnvAsync() {
 
 func coreClientFromEnv() core.Client {
 	// Dependencies
-	wgClient, err := wargaming.NewClientFromEnv(os.Getenv("WG_PRIMARY_APP_ID"), os.Getenv("WG_PRIMARY_APP_RPS"), os.Getenv("WG_REQUEST_TIMEOUT_SEC"), os.Getenv("WG_PROXY_HOST_LIST"))
+	wgClient, err := wargaming.NewClientFromEnv(os.Getenv("WG_PRIMARY_APP_ID"), os.Getenv("WG_PRIMARY_APP_RPS"), os.Getenv("WG_PRIMARY_REQUEST_TIMEOUT_SEC"), os.Getenv("WG_PROXY_HOST_LIST"))
 	if err != nil {
 		log.Fatal().Msgf("wgClient: wargaming#NewClientFromEnv failed %s", err)
 	}

From 2f58c0da571d5303472b56b9267469a879479c15 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 13 Jun 2024 19:50:46 -0400
Subject: [PATCH 043/341] updated required pems

---
 cmds/discord/commands/manage.go | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/cmds/discord/commands/manage.go b/cmds/discord/commands/manage.go
index 8994b7b2..a8be285f 100644
--- a/cmds/discord/commands/manage.go
+++ b/cmds/discord/commands/manage.go
@@ -2,7 +2,6 @@ package commands
 
 import (
 	"encoding/json"
-	"os"
 
 	"github.com/bwmarrin/discordgo"
 	"github.com/cufee/aftermath/cmds/discord/commands/builder"
@@ -15,8 +14,8 @@ import (
 func init() {
 	Loaded.add(
 		builder.NewCommand("manage").
-			ExclusiveToGuilds(os.Getenv("DISCORD_PRIMARY_GUILD_ID")).
-			Middleware(middleware.RequirePermissions(permissions.GlobalAdmin)).
+			// ExclusiveToGuilds(os.Getenv("DISCORD_PRIMARY_GUILD_ID")).
+			Middleware(middleware.RequirePermissions(permissions.ContentModerator)).
 			Options(
 				builder.NewOption("users", discordgo.ApplicationCommandOptionSubCommandGroup).Options(
 					builder.NewOption("lookup", discordgo.ApplicationCommandOptionSubCommand).Options(

From 32061fdba1b07eccca8582902fd3962afe86367c Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 13 Jun 2024 21:14:49 -0400
Subject: [PATCH 044/341] added smart command updates

---
 cmds/discord/commands/builder/command.go      |  10 +-
 cmds/discord/rest/commands.go                 |  26 +++-
 cmds/discord/router/router.go                 | 128 +++++++++++-------
 internal/database/client.go                   |   3 +
 internal/database/discord.go                  |  81 +++++++++++
 .../migration.sql                             |  11 ++
 .../20240614000247_added_index/migration.sql  |   2 +
 .../20240614002652_added_name/migration.sql   |  22 +++
 internal/database/prisma/schema.prisma        |  13 ++
 internal/logic/hash.go                        |  29 ++++
 10 files changed, 265 insertions(+), 60 deletions(-)
 create mode 100644 internal/database/discord.go
 create mode 100644 internal/database/prisma/migrations/20240614000132_added_app_commands/migration.sql
 create mode 100644 internal/database/prisma/migrations/20240614000247_added_index/migration.sql
 create mode 100644 internal/database/prisma/migrations/20240614002652_added_name/migration.sql
 create mode 100644 internal/logic/hash.go

diff --git a/cmds/discord/commands/builder/command.go b/cmds/discord/commands/builder/command.go
index 97e15aa2..976db0cc 100644
--- a/cmds/discord/commands/builder/command.go
+++ b/cmds/discord/commands/builder/command.go
@@ -21,7 +21,6 @@ type CommandHandler func(*common.Context) error
 type Command struct {
 	discordgo.ApplicationCommand
 
-	DMOnly    bool
 	GuildIDs  []string
 	GuildOnly bool
 
@@ -37,9 +36,9 @@ type Builder struct {
 	kind   commandType
 	params parameters
 
-	dmOnly    bool
-	guildOnly bool
+	dmOnly    *bool
 	guilds    []string
+	guildOnly bool
 
 	match      func(string) bool
 	handler    CommandHandler
@@ -76,11 +75,10 @@ func (c Builder) Build() Command {
 			Description:              stringOr(descLocalized[discordgo.EnglishUS], c.name),
 			NameLocalizations:        &nameLocalized,
 			DescriptionLocalizations: &descLocalized,
+			DMPermission:             c.dmOnly,
 			Options:                  options,
 			Type:                     discordgo.ChatApplicationCommand,
-			DMPermission:             &c.dmOnly,
 		},
-		c.dmOnly,
 		c.guilds,
 		c.guildOnly,
 		c.kind,
@@ -104,7 +102,7 @@ func (c Builder) Params(params ...Param) Builder {
 }
 
 func (c Builder) DMOnly() Builder {
-	c.dmOnly = true
+	c.dmOnly = common.Pointer(true)
 	return c
 }
 
diff --git a/cmds/discord/rest/commands.go b/cmds/discord/rest/commands.go
index d72e12a0..1a6599e2 100644
--- a/cmds/discord/rest/commands.go
+++ b/cmds/discord/rest/commands.go
@@ -2,6 +2,23 @@ package rest
 
 import "github.com/bwmarrin/discordgo"
 
+func (c *Client) OverwriteGlobalApplicationCommands(data []discordgo.ApplicationCommand) error {
+	req, err := c.request("PUT", discordgo.EndpointApplicationGlobalCommands(c.applicationID), data)
+	if err != nil {
+		return err
+	}
+	return c.do(req, nil)
+}
+
+func (c *Client) CreateGlobalApplicationCommand(data discordgo.ApplicationCommand) (discordgo.ApplicationCommand, error) {
+	req, err := c.request("POST", discordgo.EndpointApplicationGlobalCommands(c.applicationID), data)
+	if err != nil {
+		return discordgo.ApplicationCommand{}, err
+	}
+	var command discordgo.ApplicationCommand
+	return command, c.do(req, &command)
+}
+
 func (c *Client) GetGlobalApplicationCommands() ([]discordgo.ApplicationCommand, error) {
 	req, err := c.request("GET", discordgo.EndpointApplicationGlobalCommands(c.applicationID), nil)
 	if err != nil {
@@ -12,12 +29,13 @@ func (c *Client) GetGlobalApplicationCommands() ([]discordgo.ApplicationCommand,
 	return data, c.do(req, &data)
 }
 
-func (c *Client) OverwriteGlobalApplicationCommands(data []discordgo.ApplicationCommand) error {
-	req, err := c.request("PUT", discordgo.EndpointApplicationGlobalCommands(c.applicationID), data)
+func (c *Client) UpdateGlobalApplicationCommand(id string, data discordgo.ApplicationCommand) (discordgo.ApplicationCommand, error) {
+	req, err := c.request("PATCH", discordgo.EndpointApplicationGlobalCommand(c.applicationID, id), data)
 	if err != nil {
-		return err
+		return discordgo.ApplicationCommand{}, err
 	}
-	return c.do(req, nil)
+	var command discordgo.ApplicationCommand
+	return command, c.do(req, &command)
 }
 
 func (c *Client) DeleteGlobalApplicationCommand(id string) error {
diff --git a/cmds/discord/router/router.go b/cmds/discord/router/router.go
index 00ed8674..3c24cfb8 100644
--- a/cmds/discord/router/router.go
+++ b/cmds/discord/router/router.go
@@ -1,14 +1,16 @@
 package router
 
 import (
+	"context"
 	"fmt"
-	"slices"
 
 	"github.com/bwmarrin/discordgo"
 	"github.com/cufee/aftermath/cmds/core"
 	"github.com/cufee/aftermath/cmds/discord/commands/builder"
 	"github.com/cufee/aftermath/cmds/discord/middleware"
 	"github.com/cufee/aftermath/cmds/discord/rest"
+	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/logic"
 	"github.com/rs/zerolog/log"
 )
 
@@ -51,19 +53,22 @@ func (r *Router) LoadMiddleware(middleware ...middleware.MiddlewareFunc) {
 	r.middleware = append(r.middleware, middleware...)
 }
 
+type command struct {
+	requested *builder.Command
+	current   *discordgo.ApplicationCommand
+	cached    *database.ApplicationCommand
+	action    string
+}
+
 /*
 Updates all loaded commands using the Discord REST API
   - any commands that are loaded will be created/updated
   - any commands that were not loaded will be deleted
 */
 func (r *Router) UpdateLoadedCommands() error {
-	toOverwrite := make(map[string]discordgo.ApplicationCommand)
-
+	var commandByName = make(map[string]command)
 	for _, cmd := range r.commands {
-		if cmd.Type != builder.CommandTypeChat {
-			continue
-		}
-		toOverwrite[cmd.Name] = cmd.ApplicationCommand
+		commandByName[cmd.Name] = command{requested: &cmd}
 	}
 
 	current, err := r.restClient.GetGlobalApplicationCommands()
@@ -71,57 +76,80 @@ func (r *Router) UpdateLoadedCommands() error {
 		return err
 	}
 
-	var toDelete []string
-	var currentCommands []string
-	for _, command := range current {
-		currentCommands = append(currentCommands, command.Name)
-		if _, ok := toOverwrite[command.Name]; !ok {
-			toDelete = append(toDelete, command.ID)
-			continue
-		}
-
-		newCmd := toOverwrite[command.Name]
-		newCmd.ID = command.ID
-
-		toOverwrite[command.Name] = newCmd
-	}
-	log.Debug().Any("commands", currentCommands).Msg("current application commands")
-
-	for _, cmd := range r.commands {
-		if cmd.Type != builder.CommandTypeChat {
-			continue
-		}
-		if !slices.Contains(currentCommands, cmd.Name) {
-			// it will be created during the bulk overwrite call
-			continue
-		}
-	}
+	var currentIDs []string
+	for _, cmd := range current {
+		command := commandByName[cmd.Name]
+		command.current = &cmd
+		commandByName[cmd.Name] = command
 
-	for _, id := range toDelete {
-		log.Debug().Str("id", id).Msg("deleting old application command")
-		err := r.restClient.DeleteGlobalApplicationCommand(id)
-		if err != nil {
-			return fmt.Errorf("failed to delete a command: %w", err)
-		}
-		log.Debug().Str("id", id).Msg("deleted old application command")
+		currentIDs = append(currentIDs, cmd.ID)
 	}
 
-	if len(toOverwrite) < 1 || len(currentCommands) == len(toOverwrite) {
-		log.Debug().Msg("no application commands need an update")
-		return nil
+	cachedCommands, err := r.core.Database().GetCommandsByID(context.Background(), currentIDs...)
+	if err != nil {
+		return err
 	}
 
-	var commandUpdates []discordgo.ApplicationCommand
-	for _, cmd := range toOverwrite {
-		commandUpdates = append(commandUpdates, cmd)
+	for _, cmd := range cachedCommands {
+		command := commandByName[cmd.Name]
+		command.cached = &cmd
+		commandByName[cmd.Name] = command
 	}
 
-	log.Debug().Msg("updating application commands")
-	err = r.restClient.OverwriteGlobalApplicationCommands(commandUpdates)
-	if err != nil {
-		return fmt.Errorf("failed to bulk update application commands: %w", err)
+	for _, data := range commandByName {
+		switch {
+		case data.requested != nil && data.current == nil:
+			log.Debug().Str("name", data.requested.Name).Msg("creating a global command")
+			hash, err := logic.HashAny(data.requested.ApplicationCommand)
+			if err != nil {
+				return err
+			}
+			command, err := r.restClient.CreateGlobalApplicationCommand(data.requested.ApplicationCommand)
+			if err != nil {
+				return err
+			}
+			err = r.core.Database().UpsertCommands(context.Background(), database.ApplicationCommand{ID: command.ID, Name: command.Name, Hash: hash, Version: command.Version})
+			if err != nil {
+				return err
+			}
+			log.Debug().Str("name", data.requested.Name).Str("id", command.ID).Msg("created and cached a global command")
+
+		case data.requested == nil && data.current != nil:
+			log.Debug().Str("name", data.current.Name).Str("id", data.current.ID).Msg("deleting a global command")
+			err := r.restClient.DeleteGlobalApplicationCommand(data.current.ID)
+			if err != nil {
+				return err
+			}
+			log.Debug().Str("name", data.current.Name).Str("id", data.current.ID).Msg("deleted a global command")
+
+		case data.current != nil && data.requested != nil:
+			hash, err := logic.HashAny(data.requested.ApplicationCommand)
+			if err != nil {
+				return err
+			}
+			if data.cached == nil || data.cached.Hash != hash {
+				log.Debug().Str("name", data.current.Name).Str("id", data.current.ID).Msg("updating a global command")
+				hash, err := logic.HashAny(data.requested.ApplicationCommand)
+				if err != nil {
+					return err
+				}
+				command, err := r.restClient.UpdateGlobalApplicationCommand(data.current.ID, data.requested.ApplicationCommand)
+				if err != nil {
+					return err
+				}
+				err = r.core.Database().UpsertCommands(context.Background(), database.ApplicationCommand{ID: command.ID, Name: command.Name, Hash: hash, Version: command.Version})
+				if err != nil {
+					return err
+				}
+				log.Debug().Str("name", data.current.Name).Str("id", data.current.ID).Msg("updated global command")
+			} else {
+				log.Debug().Str("name", data.current.Name).Str("id", data.current.ID).Msg("global command is up to date")
+			}
+
+		default:
+			log.Debug().Str("name", data.current.Name).Str("id", data.current.ID).Msg("global command does not require any action")
+		}
 	}
-	log.Debug().Msg("updated application commands")
 
 	return nil
 }
diff --git a/internal/database/client.go b/internal/database/client.go
index 6ee91676..65557e0e 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -45,6 +45,9 @@ type Client interface {
 
 	DeleteExpiredTasks(ctx context.Context, expiration time.Time) error
 	DeleteExpiredSnapshots(ctx context.Context, expiration time.Time) error
+
+	UpsertCommands(ctx context.Context, commands ...ApplicationCommand) error
+	GetCommandsByID(ctx context.Context, commandIDs ...string) ([]ApplicationCommand, error)
 }
 
 type client struct {
diff --git a/internal/database/discord.go b/internal/database/discord.go
new file mode 100644
index 00000000..ac1a925d
--- /dev/null
+++ b/internal/database/discord.go
@@ -0,0 +1,81 @@
+package database
+
+import (
+	"context"
+
+	"github.com/cufee/aftermath/internal/database/prisma/db"
+)
+
+type ApplicationCommand struct {
+	ID      string
+	Hash    string
+	Name    string
+	Version string
+}
+
+func (c ApplicationCommand) fromModel(model db.ApplicationCommandModel) ApplicationCommand {
+	return ApplicationCommand{
+		ID:      model.ID,
+		Name:    model.Name,
+		Hash:    model.OptionsHash,
+		Version: model.Version,
+	}
+}
+
+func (c *client) GetCommandsByID(ctx context.Context, commandIDs ...string) ([]ApplicationCommand, error) {
+	if len(commandIDs) < 1 {
+		return nil, nil
+	}
+
+	models, err := c.prisma.ApplicationCommand.FindMany(db.ApplicationCommand.ID.In(commandIDs)).Exec(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	var commands []ApplicationCommand
+	for _, model := range models {
+		commands = append(commands, ApplicationCommand{}.fromModel(model))
+	}
+	return commands, nil
+}
+
+func (c *client) GetCommandsByHash(ctx context.Context, commandHashes ...string) ([]ApplicationCommand, error) {
+	if len(commandHashes) < 1 {
+		return nil, nil
+	}
+
+	models, err := c.prisma.ApplicationCommand.FindMany(db.ApplicationCommand.OptionsHash.In(commandHashes)).Exec(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	var commands []ApplicationCommand
+	for _, model := range models {
+		commands = append(commands, ApplicationCommand{}.fromModel(model))
+	}
+	return commands, nil
+}
+
+func (c *client) UpsertCommands(ctx context.Context, commands ...ApplicationCommand) error {
+	if len(commands) < 1 {
+		return nil
+	}
+
+	var tx []db.PrismaTransaction
+	for _, cmd := range commands {
+		tx = append(tx, c.prisma.ApplicationCommand.UpsertOne(db.ApplicationCommand.ID.Equals(cmd.ID)).
+			Create(
+				db.ApplicationCommand.ID.Set(cmd.ID),
+				db.ApplicationCommand.Name.Set(cmd.Name),
+				db.ApplicationCommand.Version.Set(cmd.Version),
+				db.ApplicationCommand.OptionsHash.Set(cmd.Hash),
+			).
+			Update(
+				db.ApplicationCommand.Name.Set(cmd.Name),
+				db.ApplicationCommand.Version.Set(cmd.Version),
+				db.ApplicationCommand.OptionsHash.Set(cmd.Hash),
+			).Tx(),
+		)
+	}
+	return c.prisma.Prisma.Transaction(tx...).Exec(ctx)
+}
diff --git a/internal/database/prisma/migrations/20240614000132_added_app_commands/migration.sql b/internal/database/prisma/migrations/20240614000132_added_app_commands/migration.sql
new file mode 100644
index 00000000..b8a4abf1
--- /dev/null
+++ b/internal/database/prisma/migrations/20240614000132_added_app_commands/migration.sql
@@ -0,0 +1,11 @@
+-- CreateTable
+CREATE TABLE "application_commands" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    "version" TEXT NOT NULL,
+    "optionsHash" TEXT NOT NULL
+);
+
+-- CreateIndex
+CREATE INDEX "account_snapshots_type_accountId_createdAt_idx" ON "account_snapshots"("type", "accountId", "createdAt");
diff --git a/internal/database/prisma/migrations/20240614000247_added_index/migration.sql b/internal/database/prisma/migrations/20240614000247_added_index/migration.sql
new file mode 100644
index 00000000..428604b0
--- /dev/null
+++ b/internal/database/prisma/migrations/20240614000247_added_index/migration.sql
@@ -0,0 +1,2 @@
+-- CreateIndex
+CREATE INDEX "application_commands_optionsHash_idx" ON "application_commands"("optionsHash");
diff --git a/internal/database/prisma/migrations/20240614002652_added_name/migration.sql b/internal/database/prisma/migrations/20240614002652_added_name/migration.sql
new file mode 100644
index 00000000..c7c9687b
--- /dev/null
+++ b/internal/database/prisma/migrations/20240614002652_added_name/migration.sql
@@ -0,0 +1,22 @@
+/*
+  Warnings:
+
+  - Added the required column `name` to the `application_commands` table without a default value. This is not possible if the table is not empty.
+
+*/
+-- RedefineTables
+PRAGMA foreign_keys=OFF;
+CREATE TABLE "new_application_commands" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    "name" TEXT NOT NULL,
+    "version" TEXT NOT NULL,
+    "optionsHash" TEXT NOT NULL
+);
+INSERT INTO "new_application_commands" ("createdAt", "id", "optionsHash", "updatedAt", "version") SELECT "createdAt", "id", "optionsHash", "updatedAt", "version" FROM "application_commands";
+DROP TABLE "application_commands";
+ALTER TABLE "new_application_commands" RENAME TO "application_commands";
+CREATE INDEX "application_commands_optionsHash_idx" ON "application_commands"("optionsHash");
+PRAGMA foreign_key_check;
+PRAGMA foreign_keys=ON;
diff --git a/internal/database/prisma/schema.prisma b/internal/database/prisma/schema.prisma
index 5885f1b8..04274134 100644
--- a/internal/database/prisma/schema.prisma
+++ b/internal/database/prisma/schema.prisma
@@ -325,6 +325,19 @@ model Vehicle {
 // === Discord Data ===
 //
 
+model ApplicationCommand {
+  id        String   @id
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  name        String
+  version     String
+  optionsHash String
+
+  @@index([optionsHash])
+  @@map("application_commands")
+}
+
 // // A log of a user interaction with the bot
 // model DiscordInteraction {
 //   id        String   @id @default(cuid())
diff --git a/internal/logic/hash.go b/internal/logic/hash.go
new file mode 100644
index 00000000..ce8b2634
--- /dev/null
+++ b/internal/logic/hash.go
@@ -0,0 +1,29 @@
+package logic
+
+import (
+	"crypto/sha256"
+	"fmt"
+
+	"github.com/cufee/aftermath/internal/encoding"
+)
+
+/*
+returns a sha256 hash of the input string
+*/
+func HashString(input string) string {
+	hash := sha256.New()
+	hash.Write([]byte(input))
+	sum := hash.Sum(nil)
+	return fmt.Sprintf("%x", sum)
+}
+
+/*
+gob encode the input and sha256 hashes the resulting string
+*/
+func HashAny(input any) (string, error) {
+	data, err := encoding.EncodeGob(input)
+	if err != nil {
+		return "", err
+	}
+	return HashString(string(data)), nil
+}

From f42832d87a360f806df13905eaef46be7cefa77f Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 13 Jun 2024 21:43:18 -0400
Subject: [PATCH 045/341] added command to view tasks

---
 cmds/discord/commands/manage.go | 27 ++++++++++++++++++++--
 internal/database/client.go     | 28 +++++++++++++++++++---
 internal/database/tasks.go      | 41 +++++++++++++++++++++++++++------
 3 files changed, 84 insertions(+), 12 deletions(-)

diff --git a/cmds/discord/commands/manage.go b/cmds/discord/commands/manage.go
index a8be285f..1c872bf8 100644
--- a/cmds/discord/commands/manage.go
+++ b/cmds/discord/commands/manage.go
@@ -2,6 +2,7 @@ package commands
 
 import (
 	"encoding/json"
+	"time"
 
 	"github.com/bwmarrin/discordgo"
 	"github.com/cufee/aftermath/cmds/discord/commands/builder"
@@ -28,7 +29,13 @@ func init() {
 					),
 				),
 				builder.NewOption("tasks", discordgo.ApplicationCommandOptionSubCommandGroup).Options(
-					builder.NewOption("view", discordgo.ApplicationCommandOptionSubCommand),
+					builder.NewOption("view", discordgo.ApplicationCommandOptionSubCommand).Options(
+						builder.NewOption("status", discordgo.ApplicationCommandOptionString).Choices(
+							builder.NewChoice("failed", string(database.TaskStatusFailed)),
+							builder.NewChoice("complete", string(database.TaskStatusComplete)),
+							builder.NewChoice("in-progress", string(database.TaskStatusInProgress)),
+						).Required(),
+					),
 				),
 				builder.NewOption("snapshots", discordgo.ApplicationCommandOptionSubCommandGroup).Options(
 					builder.NewOption("view", discordgo.ApplicationCommandOptionSubCommand).Options(
@@ -96,7 +103,23 @@ func init() {
 					return ctx.Reply("```" + string(bytes) + "```")
 
 				case "tasks_view":
-					return ctx.Reply("tasks view")
+					status, _ := opts.Value("status").(string)
+					tasks, err := ctx.Core.Database().GetRecentTasks(ctx.Context, time.Now().Add(time.Hour*24*-1), database.TaskStatus(status))
+					if err != nil {
+						return ctx.Reply("Database#GetRecentTasks: " + err.Error())
+					}
+					if len(tasks) < 1 {
+						return ctx.Reply("No recent tasks with status " + status)
+					}
+
+					bytes, err := json.MarshalIndent(tasks, "", "  ")
+					if err != nil {
+						return ctx.Reply("json.Marshal: " + err.Error())
+					}
+					if len(string(bytes)) > 1990 {
+						return ctx.ReplyFmt("Too many tasks to show - %d", len(tasks))
+					}
+					return ctx.Reply("```" + string(bytes) + "```")
 
 				default:
 					return ctx.Reply("invalid subcommand, thought this should never happen")
diff --git a/internal/database/client.go b/internal/database/client.go
index 65557e0e..f8b63e7c 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -12,44 +12,66 @@ import (
 
 var _ Client = &client{}
 
-type Client interface {
+type AccountsClient interface {
 	GetAccountByID(ctx context.Context, id string) (Account, error)
 	GetAccounts(ctx context.Context, ids []string) ([]Account, error)
 	GetRealmAccounts(ctx context.Context, realm string) ([]Account, error)
 	UpsertAccounts(ctx context.Context, accounts []Account) map[string]error
 	AccountSetPrivate(ctx context.Context, id string, value bool) error
+}
 
+type GlossaryClient interface {
 	GetVehicleAverages(ctx context.Context, ids []string) (map[string]frame.StatsFrame, error)
 	UpsertVehicleAverages(ctx context.Context, averages map[string]frame.StatsFrame) error
 	GetVehicles(ctx context.Context, ids []string) (map[string]Vehicle, error)
 	UpsertVehicles(ctx context.Context, vehicles map[string]Vehicle) error
+}
 
+type UsersClient interface {
 	GetUserByID(ctx context.Context, id string, opts ...userGetOption) (User, error)
 	GetOrCreateUserByID(ctx context.Context, id string, opts ...userGetOption) (User, error)
 	UpdateConnection(ctx context.Context, connection UserConnection) (UserConnection, error)
 	UpsertConnection(ctx context.Context, connection UserConnection) (UserConnection, error)
 	UpsertUserWithPermissions(ctx context.Context, userID string, perms permissions.Permissions) (User, error)
+}
 
+type SnapshotsClient interface {
 	CreateAccountSnapshots(ctx context.Context, snapshots ...AccountSnapshot) error
 	GetLastAccountSnapshots(ctx context.Context, accountID string, limit int) ([]AccountSnapshot, error)
 	GetAccountSnapshot(ctx context.Context, accountID, referenceID string, kind snapshotType, options ...SnapshotQuery) (AccountSnapshot, error)
 	GetManyAccountSnapshots(ctx context.Context, accountIDs []string, kind snapshotType, options ...SnapshotQuery) ([]AccountSnapshot, error)
 	CreateVehicleSnapshots(ctx context.Context, snapshots ...VehicleSnapshot) error
 	GetVehicleSnapshots(ctx context.Context, accountID, referenceID string, kind snapshotType, options ...SnapshotQuery) ([]VehicleSnapshot, error)
+	DeleteExpiredSnapshots(ctx context.Context, expiration time.Time) error
+}
 
+type TasksClient interface {
 	CreateTasks(ctx context.Context, tasks ...Task) error
 	UpdateTasks(ctx context.Context, tasks ...Task) error
 	DeleteTasks(ctx context.Context, ids ...string) error
 	GetStaleTasks(ctx context.Context, limit int) ([]Task, error)
 	GetAndStartTasks(ctx context.Context, limit int) ([]Task, error)
-
 	DeleteExpiredTasks(ctx context.Context, expiration time.Time) error
-	DeleteExpiredSnapshots(ctx context.Context, expiration time.Time) error
+	GetRecentTasks(ctx context.Context, createdAfter time.Time, status ...TaskStatus) ([]Task, error)
+}
 
+type DiscordDataClient interface {
 	UpsertCommands(ctx context.Context, commands ...ApplicationCommand) error
 	GetCommandsByID(ctx context.Context, commandIDs ...string) ([]ApplicationCommand, error)
 }
 
+type Client interface {
+	UsersClient
+
+	GlossaryClient
+	AccountsClient
+	SnapshotsClient
+
+	TasksClient
+
+	DiscordDataClient
+}
+
 type client struct {
 	prisma *db.PrismaClient
 	// Prisma does not currently support updateManyAndReturn
diff --git a/internal/database/tasks.go b/internal/database/tasks.go
index b87fcfed..8bef200a 100644
--- a/internal/database/tasks.go
+++ b/internal/database/tasks.go
@@ -22,13 +22,13 @@ const (
 )
 
 // Task statuses
-type taskStatus string
+type TaskStatus string
 
 const (
-	TaskStatusScheduled  taskStatus = "TASK_SCHEDULED"
-	TaskStatusInProgress taskStatus = "TASK_IN_PROGRESS"
-	TaskStatusComplete   taskStatus = "TASK_COMPLETE"
-	TaskStatusFailed     taskStatus = "TASK_FAILED"
+	TaskStatusScheduled  TaskStatus = "TASK_SCHEDULED"
+	TaskStatusInProgress TaskStatus = "TASK_IN_PROGRESS"
+	TaskStatusComplete   TaskStatus = "TASK_COMPLETE"
+	TaskStatusFailed     TaskStatus = "TASK_FAILED"
 )
 
 type Task struct {
@@ -42,7 +42,7 @@ type Task struct {
 
 	Logs []TaskLog `json:"logs"`
 
-	Status         taskStatus `json:"status"`
+	Status         TaskStatus `json:"status"`
 	ScheduledAfter time.Time  `json:"scheduledAfter"`
 	LastRun        time.Time  `json:"lastRun"`
 
@@ -53,7 +53,7 @@ func (t Task) FromModel(model db.CronTaskModel) Task {
 	t.ID = model.ID
 	t.Type = TaskType(model.Type)
 
-	t.Status = taskStatus(model.Status)
+	t.Status = TaskStatus(model.Status)
 	t.ReferenceID = model.ReferenceID
 
 	t.LastRun = model.LastRun
@@ -148,6 +148,33 @@ func (c *client) GetStaleTasks(ctx context.Context, limit int) ([]Task, error) {
 	return tasks, nil
 }
 
+/*
+Returns all tasks that were created after createdAfter, sorted by ScheduledAfter (DESC)
+*/
+func (c *client) GetRecentTasks(ctx context.Context, createdAfter time.Time, status ...TaskStatus) ([]Task, error) {
+	var statusStr []string
+	for _, s := range status {
+		statusStr = append(statusStr, string(s))
+	}
+
+	params := []db.CronTaskWhereParam{db.CronTask.CreatedAt.After(createdAfter)}
+	if len(statusStr) > 0 {
+		params = append(params, db.CronTask.Status.In(statusStr))
+	}
+
+	models, err := c.prisma.CronTask.FindMany(params...).OrderBy(db.CronTask.ScheduledAfter.Order(db.DESC)).Exec(ctx)
+	if err != nil && !db.IsErrNotFound(err) {
+		return nil, err
+	}
+
+	var tasks []Task
+	for _, model := range models {
+		tasks = append(tasks, Task{}.FromModel(model))
+	}
+
+	return tasks, nil
+}
+
 /*
 GetAndStartTasks retrieves up to limit number of tasks matching the referenceId and updates their status to in progress
   - this func will block until all other calls to task update funcs are done

From f738239daefa67abec7f5b3dec61f59e7f863eee Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 13 Jun 2024 21:45:04 -0400
Subject: [PATCH 046/341] added hours as arg

---
 cmds/discord/commands/manage.go | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/cmds/discord/commands/manage.go b/cmds/discord/commands/manage.go
index 1c872bf8..6f863c53 100644
--- a/cmds/discord/commands/manage.go
+++ b/cmds/discord/commands/manage.go
@@ -35,6 +35,7 @@ func init() {
 							builder.NewChoice("complete", string(database.TaskStatusComplete)),
 							builder.NewChoice("in-progress", string(database.TaskStatusInProgress)),
 						).Required(),
+						builder.NewOption("hours", discordgo.ApplicationCommandOptionNumber).Required(),
 					),
 				),
 				builder.NewOption("snapshots", discordgo.ApplicationCommandOptionSubCommandGroup).Options(
@@ -103,8 +104,13 @@ func init() {
 					return ctx.Reply("```" + string(bytes) + "```")
 
 				case "tasks_view":
+					hours, _ := opts.Value("status").(float64)
 					status, _ := opts.Value("status").(string)
-					tasks, err := ctx.Core.Database().GetRecentTasks(ctx.Context, time.Now().Add(time.Hour*24*-1), database.TaskStatus(status))
+					if hours < 1 {
+						hours = 1
+					}
+
+					tasks, err := ctx.Core.Database().GetRecentTasks(ctx.Context, time.Now().Add(time.Hour*time.Duration(hours)*-1), database.TaskStatus(status))
 					if err != nil {
 						return ctx.Reply("Database#GetRecentTasks: " + err.Error())
 					}

From f9f582b6d9920a25df6280e510e3bf53e4780706 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 13 Jun 2024 21:46:47 -0400
Subject: [PATCH 047/341] fixed hours arg

---
 cmds/discord/commands/manage.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cmds/discord/commands/manage.go b/cmds/discord/commands/manage.go
index 6f863c53..97f2aa4b 100644
--- a/cmds/discord/commands/manage.go
+++ b/cmds/discord/commands/manage.go
@@ -104,7 +104,7 @@ func init() {
 					return ctx.Reply("```" + string(bytes) + "```")
 
 				case "tasks_view":
-					hours, _ := opts.Value("status").(float64)
+					hours, _ := opts.Value("hours").(float64)
 					status, _ := opts.Value("status").(string)
 					if hours < 1 {
 						hours = 1

From bfba7c335f7cd88bdd9c2906aafe07da53cf89a9 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 14 Jun 2024 13:27:27 -0400
Subject: [PATCH 048/341] upgrade, guild only support

---
 cmds/discord/commands/builder/command.go | 23 +++--------------------
 cmds/discord/commands/ping.go            | 16 ----------------
 go.mod                                   | 20 ++++++++++----------
 go.sum                                   | 18 ++++++++++++++++++
 4 files changed, 31 insertions(+), 46 deletions(-)
 delete mode 100644 cmds/discord/commands/ping.go

diff --git a/cmds/discord/commands/builder/command.go b/cmds/discord/commands/builder/command.go
index 976db0cc..691f95b5 100644
--- a/cmds/discord/commands/builder/command.go
+++ b/cmds/discord/commands/builder/command.go
@@ -21,9 +21,6 @@ type CommandHandler func(*common.Context) error
 type Command struct {
 	discordgo.ApplicationCommand
 
-	GuildIDs  []string
-	GuildOnly bool
-
 	Type       commandType
 	Match      func(string) bool
 	Handler    CommandHandler
@@ -36,8 +33,6 @@ type Builder struct {
 	kind   commandType
 	params parameters
 
-	dmOnly    *bool
-	guilds    []string
 	guildOnly bool
 
 	match      func(string) bool
@@ -75,12 +70,10 @@ func (c Builder) Build() Command {
 			Description:              stringOr(descLocalized[discordgo.EnglishUS], c.name),
 			NameLocalizations:        &nameLocalized,
 			DescriptionLocalizations: &descLocalized,
-			DMPermission:             c.dmOnly,
 			Options:                  options,
+			DMPermission:             common.Pointer(!c.guildOnly),
 			Type:                     discordgo.ChatApplicationCommand,
 		},
-		c.guilds,
-		c.guildOnly,
 		c.kind,
 		c.match,
 		c.handler,
@@ -101,8 +94,8 @@ func (c Builder) Params(params ...Param) Builder {
 	return c
 }
 
-func (c Builder) DMOnly() Builder {
-	c.dmOnly = common.Pointer(true)
+func (c Builder) Ephemeral() Builder {
+	c.ephemeral = true
 	return c
 }
 
@@ -111,16 +104,6 @@ func (c Builder) GuildOnly() Builder {
 	return c
 }
 
-func (c Builder) ExclusiveToGuilds(guilds ...string) Builder {
-	c.guilds = append(c.guilds, guilds...)
-	return c
-}
-
-func (c Builder) Ephemeral() Builder {
-	c.ephemeral = true
-	return c
-}
-
 func (c Builder) ComponentType() Builder {
 	c.kind = CommandTypeComponent
 	return c
diff --git a/cmds/discord/commands/ping.go b/cmds/discord/commands/ping.go
deleted file mode 100644
index 7e062030..00000000
--- a/cmds/discord/commands/ping.go
+++ /dev/null
@@ -1,16 +0,0 @@
-package commands
-
-import (
-	"github.com/cufee/aftermath/cmds/discord/commands/builder"
-	"github.com/cufee/aftermath/cmds/discord/common"
-)
-
-func init() {
-	Loaded.add(
-		builder.NewCommand("ping").
-			Params(builder.SetDescKey("Pong!")).
-			Handler(func(ctx *common.Context) error {
-				return ctx.Reply("Pong!")
-			}),
-	)
-}
diff --git a/go.mod b/go.mod
index 06d528a3..0232d5a1 100644
--- a/go.mod
+++ b/go.mod
@@ -11,29 +11,29 @@ require (
 	github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0
 	github.com/joho/godotenv v1.5.1
 	github.com/nlpodyssey/gopickle v0.3.0
+	github.com/pkg/errors v0.9.1
 	github.com/rs/zerolog v1.33.0
 	github.com/shopspring/decimal v1.4.0
 	github.com/steebchen/prisma-client-go v0.37.0
 	github.com/stretchr/testify v1.9.0
 	go.dedis.ch/protobuf v1.0.11
-	golang.org/x/exp v0.0.0-20240530194437-404ba88c7ed0
-	golang.org/x/image v0.16.0
+	golang.org/x/exp v0.0.0-20240613232115-7f521ea00fb8
+	golang.org/x/image v0.17.0
 	golang.org/x/sync v0.7.0
-	golang.org/x/text v0.15.0
+	golang.org/x/text v0.16.0
 	gopkg.in/yaml.v3 v3.0.1
 )
 
 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/google/uuid v1.5.0 // indirect
-	github.com/gorilla/websocket v1.5.1 // indirect
+	github.com/google/uuid v1.6.0 // indirect
+	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
-	github.com/pkg/errors v0.9.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/robfig/cron/v3 v3.0.1 // indirect
-	go.uber.org/atomic v1.9.0 // indirect
-	golang.org/x/crypto v0.19.0 // indirect
-	golang.org/x/net v0.21.0 // indirect
-	golang.org/x/sys v0.17.0 // indirect
+	go.uber.org/atomic v1.11.0 // indirect
+	golang.org/x/crypto v0.24.0 // indirect
+	golang.org/x/net v0.26.0 // indirect
+	golang.org/x/sys v0.21.0 // indirect
 )
diff --git a/go.sum b/go.sum
index 4b57b235..4a980a34 100644
--- a/go.sum
+++ b/go.sum
@@ -19,9 +19,13 @@ github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGw
 github.com/google/uuid v1.4.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.5.0 h1:1p67kYwdtXjb0gL0BPiP1Av9wiZPo5A8z2cWkTZ+eyU=
 github.com/google/uuid v1.5.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/gorilla/websocket v1.5.1 h1:gmztn0JnHVt9JZquRuzLw3g4wouNVzKL15iLr/zn/QY=
 github.com/gorilla/websocket v1.5.1/go.mod h1:x3kM2JMyaluk02fnUJpQuwD2dCS5NDG2ZHL0uE0tcaY=
+github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
+github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
 github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
@@ -77,18 +81,28 @@ go.dedis.ch/protobuf v1.0.11 h1:FTYVIEzY/bfl37lu3pR4lIj+F9Vp1jE8oh91VmxKgLo=
 go.dedis.ch/protobuf v1.0.11/go.mod h1:97QR256dnkimeNdfmURz0wAMNVbd1VmLXhG1CrTYrJ4=
 go.uber.org/atomic v1.9.0 h1:ECmE8Bn/WFTYwEW/bpKD3M8VtR/zQVbavAoalC1PYyE=
 go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
+go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE=
+go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0=
 golang.org/x/crypto v0.0.0-20190123085648-057139ce5d2b/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
 golang.org/x/crypto v0.19.0 h1:ENy+Az/9Y1vSrlrvBSyna3PITt4tiZLf7sgCjZBX7Wo=
 golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
+golang.org/x/crypto v0.24.0 h1:mnl8DM0o513X8fdIkmyFE/5hTYxbwYOjDS/+rK6qpRI=
+golang.org/x/crypto v0.24.0/go.mod h1:Z1PMYSOR5nyMcyAVAIQSKCDwalqy85Aqn1x3Ws4L5DM=
 golang.org/x/exp v0.0.0-20240530194437-404ba88c7ed0 h1:Mi0bCswbz+9cXmwFAdxoo5GPFMKONUpua6iUdtQS7lk=
 golang.org/x/exp v0.0.0-20240530194437-404ba88c7ed0/go.mod h1:XtvwrStGgqGPLc4cjQfWqZHG1YFdYs6swckp8vpsjnc=
+golang.org/x/exp v0.0.0-20240613232115-7f521ea00fb8 h1:yixxcjnhBmY0nkL253HFVIm0JsFHwrHdT3Yh6szTnfY=
+golang.org/x/exp v0.0.0-20240613232115-7f521ea00fb8/go.mod h1:jj3sYF3dwk5D+ghuXyeI3r5MFf+NT2An6/9dOA95KSI=
 golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
 golang.org/x/image v0.16.0 h1:9kloLAKhUufZhA12l5fwnx2NZW39/we1UhBesW433jw=
 golang.org/x/image v0.16.0/go.mod h1:ugSZItdV4nOxyqp56HmXwH0Ry0nBCpjnZdpDaIHdoPs=
+golang.org/x/image v0.17.0 h1:nTRVVdajgB8zCMZVsViyzhnMKPwYeroEERRC64JuLco=
+golang.org/x/image v0.17.0/go.mod h1:4yyo5vMFQjVjUcVk4jEQcU9MGy/rulF5WvUILseCM2E=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.21.0 h1:AQyQV4dYCvJ7vGmJyKki9+PBdyvhkSd8EIx/qb0AYv4=
 golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
+golang.org/x/net v0.26.0 h1:soB7SVo0PWrY4vPW/+ay0jKDNScG2X9wFeYlXIvJsOQ=
+golang.org/x/net v0.26.0/go.mod h1:5YKkiSynbBIh3p6iOc/vibscux0x38BZDkn8sCUPxHE=
 golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
 golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20190124100055-b90733256f2e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
@@ -98,11 +112,15 @@ golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.17.0 h1:25cE3gD+tdBA7lp7QfhuV+rJiE9YXTcS3VG1SqssI/Y=
 golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.21.0 h1:rF+pYz3DAGSQAxAu1CbC7catZg4ebC4UIeIhKxBZvws=
+golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.15.0 h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk=
 golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
+golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=

From 4c11ebc9db657f41d8085ae7111d4696b2594e6e Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 14 Jun 2024 14:11:51 -0400
Subject: [PATCH 049/341] split migration and service containers

---
 Dockerfile          | 28 ++++++++--------------------
 Dockerfile.migrate  | 17 +++++++++++++++++
 docker-compose.yaml | 25 +++++++++++++++++++++++++
 3 files changed, 50 insertions(+), 20 deletions(-)
 create mode 100644 Dockerfile.migrate
 create mode 100644 docker-compose.yaml

diff --git a/Dockerfile b/Dockerfile
index 993f4f5e..990393ba 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -16,27 +16,15 @@ RUN go generate ./...
 # build a fully standalone binary with zero dependencies
 RUN CGO_ENABLED=0 GOOS=linux go build -o app .
 
+# Make a scratch container with required files and binary
+FROM scratch
 
-# <!> railway.app does not really have a way to run a migration container on the volume, so we have to improvise here
-# in order to run migrations, we need to have go and prisma installed
-FROM golang:1.22.3-alpine
+WORKDIR /app
 
-# set timezone
 ENV TZ=Europe/Berlin
+ENV ZONEINFO=/zoneinfo.zip
+COPY --from=builder /workspace/app /usr/bin/
+COPY --from=builder /usr/local/go/lib/time/zoneinfo.zip /
+COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
 
-# copy final binary
-COPY --from=builder /workspace/app /app
-
-# copy migrations and schema
-COPY --from=builder /workspace/internal/database/prisma/migrations /prisma/migrations
-COPY --from=builder /workspace/internal/database/prisma/schema.prisma /prisma/schema.prisma
-COPY --from=builder /workspace/docker-entrypoint.sh /docker-entrypoint.sh
-COPY --from=builder /workspace/go.mod /go.mod
-COPY --from=builder /workspace/go.sum /go.sum
-
-# install prisma and prefetch binaries
-RUN go install github.com/steebchen/prisma-client-go
-RUN go run github.com/steebchen/prisma-client-go prefetch
-RUN chmod +x /docker-entrypoint.sh
-
-ENTRYPOINT ["/docker-entrypoint.sh"]
+ENTRYPOINT ["app"]
diff --git a/Dockerfile.migrate b/Dockerfile.migrate
new file mode 100644
index 00000000..3764f1af
--- /dev/null
+++ b/Dockerfile.migrate
@@ -0,0 +1,17 @@
+FROM golang:1.22.3-alpine
+
+WORKDIR /migrate
+
+# copy migrations and schema
+COPY ./internal/database/prisma/migrations /prisma/migrations
+COPY ./internal/database/prisma/schema.prisma /prisma/schema.prisma
+
+# copy go.mod
+COPY ./go.mod /go.mod
+COPY ./go.sum /go.sum
+
+# install prisma and prefetch binaries
+RUN go install github.com/steebchen/prisma-client-go@latest
+RUN go run github.com/steebchen/prisma-client-go prefetch
+
+ENTRYPOINT ["sh", "-c", "go run github.com/steebchen/prisma-client-go migrate deploy --schema /prisma/schema.prisma"]
diff --git a/docker-compose.yaml b/docker-compose.yaml
new file mode 100644
index 00000000..c4741b78
--- /dev/null
+++ b/docker-compose.yaml
@@ -0,0 +1,25 @@
+services:
+  apply-migrations:
+    image: aftermath-prisma-migrate
+    build:
+      dockerfile: Dockerfile.migrate
+    environment:
+      - DATABASE_URL=file:/database/${DATABASE_NAME}
+    volumes:
+      - ${DATABASE_DIR}:/database
+    command: sh -c "go run github.com/steebchen/prisma-client-go migrate deploy --schema /prisma/schema.prisma"
+
+  aftermath-service:
+    image: aftermath-service
+    build:
+      dockerfile: Dockerfile
+    env_file:
+      - .env
+    environment:
+      - DATABASE_URL=file:/database/${DATABASE_NAME}
+    volumes:
+      - ${DATABASE_DIR}:/database
+    depends_on:
+      apply-migrations:
+        condition: service_completed_successfully
+    entrypoint: ["app"]

From 9ff5d01fd7a7714cda198be31f2557442da5aa38 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 14 Jun 2024 14:29:57 -0400
Subject: [PATCH 050/341] added traefik labels

---
 docker-compose.yaml | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/docker-compose.yaml b/docker-compose.yaml
index c4741b78..e54819aa 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -16,6 +16,7 @@ services:
     env_file:
       - .env
     environment:
+      - PORT=3000
       - DATABASE_URL=file:/database/${DATABASE_NAME}
     volumes:
       - ${DATABASE_DIR}:/database
@@ -23,3 +24,18 @@ services:
       apply-migrations:
         condition: service_completed_successfully
     entrypoint: ["app"]
+    restart: always
+    ports:
+      - 3000
+    networks:
+      - dokploy-network
+    labels:
+      - "traefik.enable=true"
+      - "traefik.http.routers.aftermath-monorepo-compose.rule=Host(`${TRAEFIK_HOST}`)"
+      - "traefik.http.routers.aftermath-monorepo-compose.entrypoints=websecure"
+      - "traefik.http.routers.aftermath-monorepo-compose.tls.certResolver=letsencrypt"
+      - "traefik.http.services.aftermath-monorepo-compose.loadbalancer.server.port=3000"
+
+networks:
+  dokploy-network:
+    external: true

From cea4268d8d87eacc7f8626d5344786ff58954429 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 14 Jun 2024 15:01:35 -0400
Subject: [PATCH 051/341] added memory limit and reservation

---
 docker-compose.yaml | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/docker-compose.yaml b/docker-compose.yaml
index e54819aa..1f203e05 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -25,6 +25,12 @@ services:
         condition: service_completed_successfully
     entrypoint: ["app"]
     restart: always
+    deploy:
+      resources:
+        reservations:
+          memory: 128m
+        limits:
+          memory: 256m
     ports:
       - 3000
     networks:

From 75f153ae6dee1fd78efe4a2e279563eda449ebf8 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 14 Jun 2024 15:38:08 -0400
Subject: [PATCH 052/341] added readme

---
 .env.example | 16 ++++++++++++----
 README.md    | 25 +++++++++++++++++++++++--
 2 files changed, 35 insertions(+), 6 deletions(-)

diff --git a/.env.example b/.env.example
index 483f66e7..5f143144 100644
--- a/.env.example
+++ b/.env.example
@@ -1,5 +1,11 @@
-# Path to a .db file where SQLite database will be created
-DATABASE_URL="file:/tmp/dev_local.db" # This should be an absolute path, otherwise prisma fails to run correctly
+# This is not required for local deployment. When deploying with Dokploy, this is the domain aftermath service will be available on.
+TRAEFIK_HOST="local.amth.one"
+
+# Database configuration for compose
+DATABASE_NAME="dev_local.db"
+DATABASE_DIR="/tmp"
+# This should be an absolute path, otherwise prisma fails to run correctly. This variable is only used when developing locally or deploying without Compose.
+DATABASE_URL="file:/tmp/dev_local.db"
 
 # Init
 INIT_GLOBAL_ADMIN_USER="" # Discord user ID for a user who will be assigned permissions.GlobalAdmin on startup, can be left blank
@@ -11,13 +17,15 @@ WG_AUTH_APP_ID="" # Used to verify WG accounts, this app id will be exposed to t
 WG_PRIMARY_APP_ID=""
 WG_PRIMARY_APP_RPS="10"
 WG_PRIMARY_REQUEST_TIMEOUT_SEC="5"
-WG_PROXY_HOST_LIST="" # can be left blank to disable proxy
+# List of proxy hosts separated by comma in the format user:password@host:port?wgAppId=your_app_id&maxRps=20, this can be left blank to disable proxying
+WG_PROXY_HOST_LIST=""
 
 # Requests initiated from tasks during cache updates and etc will always go through this wg app id and proxy
 WG_CACHE_APP_ID=""
 WG_CACHE_APP_RPS="10"
 WG_CACHE_REQUEST_TIMEOUT_SEC="15"
-WG_CACHE_PROXY_HOST_LIST="" # can be left blank to disable proxy
+# List of proxy hosts separated by comma in the format user:password@host:port?wgAppId=your_app_id&maxRps=20, this can be left blank to disable proxying
+WG_CACHE_PROXY_HOST_LIST=""
 
 # Discord
 DISCORD_TOKEN=""
diff --git a/README.md b/README.md
index cd4a7b9e..bbff7d4b 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,24 @@
-# Thank you for checking out Afteramth!
+# Aftermath
+This is the most recent revision/rewrite of Aftermath. The main goal of this project is to simplify deployment and make it significantly cheaper to host.
 
-[Here is a link to the Wiki page](https://github.com/Cufee/aftermath/wiki) where you can learn how to setup and use the bot.
+## Deploying
+Deploying Aftermath is relatively simple. You can build the binary manually, use Docker Compose, or build a Docker image.
+
+### Docker Compose with [Dokploy](https://dokploy.com/)
+- Get a VPS instalnce. Purchase a domain and point it to this instance.
+- Create a new Bot Application in Discord
+- [Install Dokploy and Docker](https://docs.dokploy.com/get-started/installation).
+- Create a new Project and add a new Compose service.
+- In Service settings > General > Provider, select your forked repository or Git > `git@github.com:Cufee/aftermath.git`. The branch should be `master`, but you can pick something different.
+- Change the Compose Path to `./docker-compose.yaml`.
+- If you are using your own repository, [setup a webhook under Deployments](https://docs.dokploy.com/application/overview#github).
+- Add your environment configuration under Environment, you can start by copying `.env.example`.
+  - Set `TRAEFIK_HOST` to your domain. For example, `amth.one`.
+  - Add a Discord Bot token and public key
+  - Ensure the `DATABASE_DIR` and `DATABASE_NAME` are set correctly, this will be the path **on your host**. If this is misconfigured, you will lose data on restart.
+  - Add Wargaming App IDs, not that one of them will be public.
+  - If you are planning to track a lot of users, add proxies for Wargaming API in the following format: `user:password@host:port?wgAppId=your_app_id&maxRps=20`
+  - Read through all variables prefixed with `INIT_`. Those will allow you to create admin user accounts and etc.
+- Head over to General and click on Deploy.
+- Once the app is deployed and everything looks good in Logs, set the INTERACTIONS ENDPOINT URL under General Information in Discord Application settings to `https://yourdomain/discord/callback`. For example, `https://amth.one/discord/callback`.
+- You can start using Discord commands now!

From 2fd9f58edbf84ade0e7265f9b64664c09693d001 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sat, 15 Jun 2024 12:27:41 -0400
Subject: [PATCH 053/341] work towards sessions

---
 cmds/discord/commands/session.go              |   6 +-
 cmds/discord/common/context.go                |  16 +-
 cmds/discord/rest/client.go                   |  12 +-
 cmds/discord/router/handler.go                |  42 ++--
 internal/logic/sessions.go                    |   2 +-
 internal/stats/errors.go                      |   4 +-
 internal/stats/fetch/client.go                |   2 +-
 internal/stats/fetch/multisource.go           |  51 +++--
 internal/stats/metadata.go                    |   2 +-
 internal/stats/period.go                      |   7 +-
 internal/stats/prepare/common/card.go         |  54 +++--
 internal/stats/prepare/common/highlights.go   |  62 +++++
 internal/stats/prepare/common/options.go      |  30 +++
 internal/stats/prepare/period/card.go         |  44 ++--
 internal/stats/prepare/period/constants.go    |   4 +-
 internal/stats/prepare/period/highlight.go    |  60 -----
 internal/stats/prepare/period/options.go      |  16 --
 internal/stats/prepare/period/preset.go       |   7 +-
 internal/stats/prepare/session/card.go        | 152 +++++++++++++
 internal/stats/prepare/session/constants.go   |  35 +++
 internal/stats/prepare/session/preset.go      |  28 +++
 internal/stats/render/common/header.go        |  47 ++++
 internal/stats/render/period/cards.go         |  44 +---
 .../render/period/{render.go => image.go}     |   0
 internal/stats/render/session/blocks.go       | 145 ++++++++++++
 internal/stats/render/session/cards.go        | 215 ++++++++++++++++++
 internal/stats/render/session/constants.go    | 120 ++++++++++
 internal/stats/render/session/image.go        |  24 ++
 internal/stats/session.go                     |  45 ++--
 render_test.go                                |  34 +++
 static/localization/en/discord.yaml           |   4 +
 31 files changed, 1072 insertions(+), 242 deletions(-)
 create mode 100644 internal/stats/prepare/common/highlights.go
 create mode 100644 internal/stats/prepare/common/options.go
 delete mode 100644 internal/stats/prepare/period/highlight.go
 delete mode 100644 internal/stats/prepare/period/options.go
 create mode 100644 internal/stats/prepare/session/card.go
 create mode 100644 internal/stats/prepare/session/constants.go
 create mode 100644 internal/stats/prepare/session/preset.go
 create mode 100644 internal/stats/render/common/header.go
 rename internal/stats/render/period/{render.go => image.go} (100%)
 create mode 100644 internal/stats/render/session/blocks.go
 create mode 100644 internal/stats/render/session/cards.go
 create mode 100644 internal/stats/render/session/constants.go
 create mode 100644 internal/stats/render/session/image.go
 create mode 100644 render_test.go

diff --git a/cmds/discord/commands/session.go b/cmds/discord/commands/session.go
index b8de76a2..4c11f155 100644
--- a/cmds/discord/commands/session.go
+++ b/cmds/discord/commands/session.go
@@ -10,6 +10,7 @@ import (
 	"github.com/cufee/aftermath/cmds/discord/common"
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/stats"
+	"github.com/cufee/aftermath/internal/stats/fetch"
 	"github.com/cufee/aftermath/internal/stats/render"
 	"github.com/cufee/aftermath/internal/stats/render/assets"
 	"github.com/pkg/errors"
@@ -63,9 +64,12 @@ func init() {
 
 				image, _, err := ctx.Core.Render(ctx.Locale).Session(context.Background(), accountID, options.PeriodStart, render.WithBackground(background))
 				if err != nil {
-					if errors.Is(err, stats.ErrAccountNotTracked) {
+					if errors.Is(err, stats.ErrAccountNotTracked) || (errors.Is(err, fetch.ErrSessionNotFound) && options.Days < 1) {
 						return ctx.Reply("session_error_account_was_not_tracked")
 					}
+					if errors.Is(err, fetch.ErrSessionNotFound) {
+						return ctx.Reply("session_error_no_session_for_period")
+					}
 					return ctx.Err(err)
 				}
 
diff --git a/cmds/discord/common/context.go b/cmds/discord/common/context.go
index fea2b00f..02e6bcf5 100644
--- a/cmds/discord/common/context.go
+++ b/cmds/discord/common/context.go
@@ -76,12 +76,21 @@ func NewContext(ctx context.Context, interaction discordgo.Interaction, respondC
 	return c, nil
 }
 
+func (c *Context) respond(data discordgo.InteractionResponseData) error {
+	select {
+	case <-c.Context.Done():
+		return c.Context.Err()
+	default:
+		c.respondCh <- data
+	}
+	return nil
+}
+
 func (c *Context) Message(message string) error {
 	if message == "" {
 		return errors.New("bad reply call with blank message")
 	}
-	c.respondCh <- discordgo.InteractionResponseData{Content: message}
-	return nil
+	return c.respond(discordgo.InteractionResponseData{Content: message})
 }
 
 func (c *Context) Reply(key string) error {
@@ -106,8 +115,7 @@ func (c *Context) File(r io.Reader, name string) error {
 	if r == nil {
 		return errors.New("bad Context#File call with nil io.Reader")
 	}
-	c.respondCh <- discordgo.InteractionResponseData{Files: []*discordgo.File{{Reader: r, Name: name}}}
-	return nil
+	return c.respond(discordgo.InteractionResponseData{Files: []*discordgo.File{{Reader: r, Name: name}}})
 }
 
 func (c *Context) isCommand() bool {
diff --git a/cmds/discord/rest/client.go b/cmds/discord/rest/client.go
index a58c9061..2802913c 100644
--- a/cmds/discord/rest/client.go
+++ b/cmds/discord/rest/client.go
@@ -11,6 +11,7 @@ import (
 	"time"
 
 	"github.com/pkg/errors"
+	"github.com/rs/zerolog/log"
 
 	"github.com/bwmarrin/discordgo"
 	"github.com/cufee/aftermath/internal/retry"
@@ -110,6 +111,7 @@ func partHeader(contentDisposition string, contentType string) textproto.MIMEHea
 }
 
 func (c *Client) do(req *http.Request, target any) error {
+	log.Debug().Str("url", req.URL.String()).Str("contentType", req.Header.Get("Content-Type")).Msg("sending a request to Discord API")
 	result := retry.Retry(func() (any, error) {
 		res, err := c.http.Do(req)
 		if err != nil {
@@ -127,9 +129,8 @@ func (c *Client) do(req *http.Request, target any) error {
 			_ = json.Unmarshal(data, &body)
 			message := body.Message
 			if message == "" {
-				message = res.Status
+				message = res.Status + ", response was not valid json"
 			}
-
 			println(string(data))
 
 			return nil, errors.New("discord error: " + message)
@@ -145,7 +146,12 @@ func (c *Client) do(req *http.Request, target any) error {
 		return nil, nil
 	}, 3, time.Millisecond*150)
 
-	return result.Err
+	if result.Err != nil {
+		log.Debug().Err(result.Err).Str("url", req.URL.String()).Str("contentType", req.Header.Get("Content-Type")).Msg("request finished with error")
+		return result.Err
+	}
+	log.Debug().Str("url", req.URL.String()).Str("contentType", req.Header.Get("Content-Type")).Msg("request finished successfully")
+	return nil
 }
 
 func (c *Client) lookupApplicationID() (string, error) {
diff --git a/cmds/discord/router/handler.go b/cmds/discord/router/handler.go
index 142782a0..7d91f37a 100644
--- a/cmds/discord/router/handler.go
+++ b/cmds/discord/router/handler.go
@@ -20,9 +20,6 @@ import (
 	"github.com/rs/zerolog/log"
 )
 
-// we need to respond within 15 minutes of the initial interaction
-var interactionTimeout = time.Minute*14 + time.Second*45
-
 type interactionState struct {
 	mx      *sync.Mutex
 	acked   bool
@@ -163,18 +160,17 @@ func (r *Router) routeInteraction(interaction discordgo.Interaction) (*builder.C
 }
 
 func (r *Router) handleInteraction(ctx context.Context, cancel context.CancelFunc, interaction discordgo.Interaction, command *builder.Command, reply chan<- discordgo.InteractionResponseData) {
-	defer func() {
-		if r := recover(); r != nil {
-			log.Error().Interface("error", r).Msg("interaction handler panic")
-			reply <- discordgo.InteractionResponseData{Content: "Something went really wrong while working on your command. Please try again later."}
-		}
-		cancel()
-	}()
+	defer cancel()
 
 	cCtx, err := common.NewContext(ctx, interaction, reply, r.restClient, r.core)
 	if err != nil {
 		log.Err(err).Msg("failed to create a common.Context for a handler")
-		reply <- discordgo.InteractionResponseData{Content: cCtx.Localize("common_error_unhandled_not_reported")}
+		select {
+		case <-ctx.Done():
+			return
+		default:
+			reply <- discordgo.InteractionResponseData{Content: cCtx.Localize("common_error_unhandled_not_reported")}
+		}
 		return
 	}
 
@@ -186,7 +182,12 @@ func (r *Router) handleInteraction(ctx context.Context, cancel context.CancelFun
 	err = handler(cCtx)
 	if err != nil {
 		log.Err(err).Msg("handler returned an error")
-		reply <- discordgo.InteractionResponseData{Content: cCtx.Localize("common_error_unhandled_not_reported")}
+		select {
+		case <-ctx.Done():
+			return
+		default:
+			reply <- discordgo.InteractionResponseData{Content: cCtx.Localize("common_error_unhandled_not_reported")}
+		}
 		return
 	}
 }
@@ -202,12 +203,9 @@ func sendPingReply(w http.ResponseWriter) {
 func (router *Router) startInteractionHandlerAsync(interaction discordgo.Interaction, state *interactionState, command *builder.Command) {
 	log.Info().Str("id", interaction.ID).Msg("started handling an interaction")
 
-	// create a timer for the interaction response
-	responseTimer := time.NewTimer(interactionTimeout)
-	defer responseTimer.Stop()
-
 	// create a new context and cancel it on reply
-	workerCtx, cancelWorker := context.WithCancel(context.Background())
+	// we need to respond within 15 minutes, but it's safe to assume something failed if we did not reply quickly
+	workerCtx, cancelWorker := context.WithTimeout(context.Background(), time.Second*10)
 
 	// handle the interaction
 	responseCh := make(chan discordgo.InteractionResponseData)
@@ -215,21 +213,15 @@ func (router *Router) startInteractionHandlerAsync(interaction discordgo.Interac
 
 	go func() {
 		defer close(responseCh)
+		defer cancelWorker()
 
 		for {
 			select {
-			case <-responseTimer.C:
-				state.mx.Lock()
-				// discord will handle the user-facing error, so we just log it
-				log.Error().Any("interaction", interaction).Msg("interaction response timed out")
-				defer state.mx.Unlock()
-				return
-
 			case <-workerCtx.Done():
 				state.mx.Lock()
+				defer state.mx.Unlock()
 				// we are done, there is nothing else we should do here
 				// lock in case responseCh is still busy sending some data over
-				defer state.mx.Unlock()
 				log.Info().Str("id", interaction.ID).Msg("finished handling an interaction")
 				return
 
diff --git a/internal/logic/sessions.go b/internal/logic/sessions.go
index 3630b1a3..d5e75343 100644
--- a/internal/logic/sessions.go
+++ b/internal/logic/sessions.go
@@ -138,7 +138,7 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 			}
 			vehicleStats := fetch.WargamingVehiclesToFrame(vehicles)
 			for id, vehicle := range vehicleStats {
-				if vehicle.LastBattleTime.IsZero() {
+				if vehicle.LastBattleTime.Unix() < 1 {
 					// vehicle was never played
 					continue
 				}
diff --git a/internal/stats/errors.go b/internal/stats/errors.go
index be6b8daa..4bcd0ddf 100644
--- a/internal/stats/errors.go
+++ b/internal/stats/errors.go
@@ -1,6 +1,8 @@
 package stats
 
-import "github.com/pkg/errors"
+import (
+	"github.com/pkg/errors"
+)
 
 var (
 	ErrAccountNotTracked = errors.New("account not tracked")
diff --git a/internal/stats/fetch/client.go b/internal/stats/fetch/client.go
index 60e65777..7844d93f 100644
--- a/internal/stats/fetch/client.go
+++ b/internal/stats/fetch/client.go
@@ -52,7 +52,7 @@ type Client interface {
 	CurrentStats(ctx context.Context, id string, opts ...statsOption) (AccountStatsOverPeriod, error)
 
 	PeriodStats(ctx context.Context, id string, from time.Time, opts ...statsOption) (AccountStatsOverPeriod, error)
-	SessionStats(ctx context.Context, id string, sessionStart time.Time, opts ...statsOption) (AccountStatsOverPeriod, error)
+	SessionStats(ctx context.Context, id string, sessionStart time.Time, opts ...statsOption) (AccountStatsOverPeriod, AccountStatsOverPeriod, error)
 
 	CurrentTankAverages(ctx context.Context) (map[string]frame.StatsFrame, error)
 }
diff --git a/internal/stats/fetch/multisource.go b/internal/stats/fetch/multisource.go
index fb95ad9d..f01ab0be 100644
--- a/internal/stats/fetch/multisource.go
+++ b/internal/stats/fetch/multisource.go
@@ -264,7 +264,7 @@ func (c *multiSourceClient) PeriodStats(ctx context.Context, id string, periodSt
 	return stats, nil
 }
 
-func (c *multiSourceClient) SessionStats(ctx context.Context, id string, sessionStart time.Time, opts ...statsOption) (AccountStatsOverPeriod, error) {
+func (c *multiSourceClient) SessionStats(ctx context.Context, id string, sessionStart time.Time, opts ...statsOption) (AccountStatsOverPeriod, AccountStatsOverPeriod, error) {
 	var options statsOptions
 	for _, apply := range opts {
 		apply(&options)
@@ -276,7 +276,7 @@ func (c *multiSourceClient) SessionStats(ctx context.Context, id string, session
 		sessionStart = time.Now()
 	}
 	if days := time.Since(sessionStart).Hours() / 24; days > 90 {
-		return AccountStatsOverPeriod{}, ErrInvalidSessionStart
+		return AccountStatsOverPeriod{}, AccountStatsOverPeriod{}, ErrInvalidSessionStart
 	}
 
 	sessionBefore := sessionStart
@@ -322,35 +322,54 @@ func (c *multiSourceClient) SessionStats(ctx context.Context, id string, session
 	// wait for all requests to finish and check errors
 	group.Wait()
 	if current.Err != nil {
-		return AccountStatsOverPeriod{}, current.Err
+		return AccountStatsOverPeriod{}, AccountStatsOverPeriod{}, current.Err
 	}
 	if accountSnapshot.Err != nil {
 		if db.IsErrNotFound(accountSnapshot.Err) {
-			return AccountStatsOverPeriod{}, ErrSessionNotFound
+			return AccountStatsOverPeriod{}, AccountStatsOverPeriod{}, ErrSessionNotFound
 		}
-		return AccountStatsOverPeriod{}, accountSnapshot.Err
+		return AccountStatsOverPeriod{}, AccountStatsOverPeriod{}, accountSnapshot.Err
 	}
 	if averages.Err != nil {
 		// not critical, this will only affect WN8
 		log.Err(averages.Err).Msg("failed to get tank averages")
 	}
 
-	stats := current.Data
-	stats.PeriodEnd = time.Now()
-	stats.PeriodStart = sessionStart
-	stats.RatingBattles.StatsFrame.Subtract(accountSnapshot.Data.RatingBattles)
-	stats.RegularBattles.StatsFrame.Subtract(accountSnapshot.Data.RegularBattles)
+	session := current.Data
+	session.PeriodEnd = time.Now()
+	session.PeriodStart = sessionStart
+	session.RatingBattles.StatsFrame.Subtract(accountSnapshot.Data.RatingBattles)
+	session.RegularBattles.StatsFrame.Subtract(accountSnapshot.Data.RegularBattles)
+	session.RegularBattles.Vehicles = make(map[string]frame.VehicleStatsFrame, len(current.Data.RegularBattles.Vehicles))
+
+	career := AccountStatsOverPeriod{
+		Realm:          current.Data.Realm,
+		Account:        current.Data.Account,
+		LastBattleTime: accountSnapshot.Data.LastBattleTime,
+		PeriodStart:    current.Data.Account.CreatedAt,
+		PeriodEnd:      sessionStart,
+	}
+	career.Account.LastBattleTime = accountSnapshot.Data.LastBattleTime
+	career.RatingBattles.StatsFrame = accountSnapshot.Data.RatingBattles
+	career.RegularBattles.StatsFrame = accountSnapshot.Data.RegularBattles
+	career.RatingBattles.Vehicles = make(map[string]frame.VehicleStatsFrame, 0)
+	career.RegularBattles.Vehicles = make(map[string]frame.VehicleStatsFrame, len(vehiclesSnapshots.Data))
 
 	snapshotsMap := make(map[string]int, len(vehiclesSnapshots.Data))
 	for i, data := range vehiclesSnapshots.Data {
 		snapshotsMap[data.VehicleID] = i
+
+		career.RegularBattles.Vehicles[data.VehicleID] = frame.VehicleStatsFrame{
+			LastBattleTime: data.LastBattleTime,
+			VehicleID:      data.VehicleID,
+			StatsFrame:     &data.Stats,
+		}
 	}
 
-	stats.RegularBattles.Vehicles = make(map[string]frame.VehicleStatsFrame, len(current.Data.RegularBattles.Vehicles))
 	for id, current := range current.Data.RegularBattles.Vehicles {
 		snapshotIndex, exists := snapshotsMap[id]
 		if !exists {
-			stats.RegularBattles.Vehicles[id] = current
+			session.RegularBattles.Vehicles[id] = current
 			continue
 		}
 
@@ -359,13 +378,15 @@ func (c *multiSourceClient) SessionStats(ctx context.Context, id string, session
 			continue
 		}
 		current.StatsFrame.Subtract(snapshot.Stats)
-		stats.RegularBattles.Vehicles[id] = current
+		session.RegularBattles.Vehicles[id] = current
 	}
 
 	if options.withWN8 {
-		stats.AddWN8(averages.Data)
+		career.AddWN8(averages.Data)
+		session.AddWN8(averages.Data)
 	}
-	return stats, nil
+
+	return session, career, nil
 
 }
 
diff --git a/internal/stats/metadata.go b/internal/stats/metadata.go
index 498ab10a..78c6a2a8 100644
--- a/internal/stats/metadata.go
+++ b/internal/stats/metadata.go
@@ -7,7 +7,7 @@ import (
 )
 
 type Metadata struct {
-	Stats   fetch.AccountStatsOverPeriod
+	Stats   map[string]fetch.AccountStatsOverPeriod
 	Timings map[string]time.Duration
 	timers  map[string]time.Time
 }
diff --git a/internal/stats/period.go b/internal/stats/period.go
index f99c7749..96b518f7 100644
--- a/internal/stats/period.go
+++ b/internal/stats/period.go
@@ -7,13 +7,14 @@ import (
 
 	"github.com/cufee/aftermath/internal/localization"
 	"github.com/cufee/aftermath/internal/stats/fetch"
+	"github.com/cufee/aftermath/internal/stats/prepare/common"
 	prepare "github.com/cufee/aftermath/internal/stats/prepare/period"
 	options "github.com/cufee/aftermath/internal/stats/render"
 	render "github.com/cufee/aftermath/internal/stats/render/period"
 )
 
 func (r *renderer) Period(ctx context.Context, accountId string, from time.Time, opts ...options.Option) (Image, Metadata, error) {
-	meta := Metadata{}
+	meta := Metadata{Stats: make(map[string]fetch.AccountStatsOverPeriod)}
 
 	printer, err := localization.NewPrinter("stats", r.locale)
 	if err != nil {
@@ -26,7 +27,7 @@ func (r *renderer) Period(ctx context.Context, accountId string, from time.Time,
 	if err != nil {
 		return nil, meta, err
 	}
-	meta.Stats = stats
+	meta.Stats["period"] = stats
 
 	stop = meta.Timer("prepare#GetVehicles")
 	var vehicles []string
@@ -46,7 +47,7 @@ func (r *renderer) Period(ctx context.Context, accountId string, from time.Time,
 	stop()
 
 	stop = meta.Timer("prepare#NewCards")
-	cards, err := prepare.NewCards(stats, glossary, prepare.WithPrinter(printer, r.locale))
+	cards, err := prepare.NewCards(stats, glossary, common.WithPrinter(printer, r.locale))
 	stop()
 	if err != nil {
 		return nil, meta, err
diff --git a/internal/stats/prepare/common/card.go b/internal/stats/prepare/common/card.go
index bfae299f..f9826112 100644
--- a/internal/stats/prepare/common/card.go
+++ b/internal/stats/prepare/common/card.go
@@ -6,18 +6,18 @@ import (
 	"github.com/cufee/aftermath/internal/stats/frame"
 )
 
-type cardType string
+type CardType string
 
 const (
-	CardTypeVehicle        cardType = "vehicle"
-	CardTypeRatingVehicle  cardType = "ratingVehicle"
-	CardTypeOverview       cardType = "overview"
-	CardTypeHighlight      cardType = "overview"
-	CardTypeTierPercentage cardType = "tierPercentage"
+	CardTypeVehicle        CardType = "vehicle"
+	CardTypeRatingVehicle  CardType = "ratingVehicle"
+	CardTypeOverview       CardType = "overview"
+	CardTypeHighlight      CardType = "overview"
+	CardTypeTierPercentage CardType = "tierPercentage"
 )
 
 type StatsCard[B, M any] struct {
-	Type   cardType `json:"type"`
+	Type   CardType `json:"type"`
 	Title  string   `json:"title"`
 	Blocks []B      `json:"blocks"`
 	Meta   M        `json:"meta,omitempty"`
@@ -39,31 +39,40 @@ func (block *StatsBlock[D]) Localize(printer func(string) string) {
 }
 
 func (block *StatsBlock[D]) FillValue(stats frame.StatsFrame, args ...any) error {
-	switch block.Tag {
+	value, err := PresetValue(block.Tag, stats)
+	if err != nil {
+		return err
+	}
+	block.Value = value
+	return nil
+}
+
+func PresetValue(preset Tag, stats frame.StatsFrame, args ...any) (frame.Value, error) {
+	switch preset {
 	case TagWN8:
-		block.Value = stats.WN8(args...)
+		return stats.WN8(args...), nil
 	case TagFrags:
-		block.Value = stats.Frags
+		return stats.Frags, nil
 	case TagBattles:
-		block.Value = stats.Battles
+		return stats.Battles, nil
 	case TagWinrate:
-		block.Value = stats.WinRate(args...)
+		return stats.WinRate(args...), nil
 	case TagAccuracy:
-		block.Value = stats.Accuracy(args...)
+		return stats.Accuracy(args...), nil
 	case TagRankedRating:
-		block.Value = stats.Rating
+		return stats.Rating, nil
 	case TagAvgDamage:
-		block.Value = stats.AvgDamage(args...)
+		return stats.AvgDamage(args...), nil
 	case TagDamageRatio:
-		block.Value = stats.DamageRatio(args...)
+		return stats.DamageRatio(args...), nil
 	case TagSurvivalRatio:
-		block.Value = stats.SurvivalRatio(args...)
+		return stats.SurvivalRatio(args...), nil
 	case TagSurvivalPercent:
-		block.Value = stats.Survival(args...)
+		return stats.Survival(args...), nil
 	case TagDamageDealt:
-		block.Value = stats.DamageDealt
+		return stats.DamageDealt, nil
 	case TagDamageTaken:
-		block.Value = stats.DamageReceived
+		return stats.DamageReceived, nil
 
 	// Some tags cannot be parsed here and should be implemented by the package
 	// TagAvgTier - period
@@ -71,9 +80,6 @@ func (block *StatsBlock[D]) FillValue(stats frame.StatsFrame, args ...any) error
 	// TagDamageAssisted - replay
 	// TagDamageAssistedCombined - replay
 	default:
-		return errors.New("invalid preset")
+		return frame.InvalidValue, errors.New("invalid preset " + preset.String())
 	}
-
-	return nil
-
 }
diff --git a/internal/stats/prepare/common/highlights.go b/internal/stats/prepare/common/highlights.go
new file mode 100644
index 00000000..451aad56
--- /dev/null
+++ b/internal/stats/prepare/common/highlights.go
@@ -0,0 +1,62 @@
+package common
+
+import (
+	"github.com/cufee/aftermath/internal/stats/frame"
+)
+
+type Highlight struct {
+	CompareWith Tag
+	Blocks      []Tag
+	Label       string
+}
+
+var (
+	HighlightAvgDamage = Highlight{TagAvgDamage, []Tag{TagBattles, TagAvgDamage,TagWN8}, "label_highlight_avg_damage"}
+	HighlightBattles   = Highlight{TagBattles, []Tag{TagBattles, TagAvgDamage, TagWN8}, "label_highlight_battles"}
+	HighlightWN8       = Highlight{TagWN8, []Tag{TagBattles, TagAvgDamage,TagWN8}, "label_highlight_wn8"}
+)
+
+type highlightedVehicle struct {
+	Highlight Highlight
+	Vehicle   frame.VehicleStatsFrame
+	Value     frame.Value
+}
+
+func GetHighlightedVehicles(highlights []Highlight, vehicles map[string]frame.VehicleStatsFrame, minBattles int) ([]highlightedVehicle, error) {
+	leadersMap := make(map[string]highlightedVehicle)
+	for _, vehicle := range vehicles {
+		if int(vehicle.Battles.Float()) < minBattles {
+			continue
+		}
+
+		for _, highlight := range highlights {
+			currentLeader, leaderExists := leadersMap[highlight.Label]
+			value, err := PresetValue(highlight.CompareWith, *vehicle.StatsFrame)
+			if err != nil {
+				return nil, err
+			}
+
+			if !frame.InvalidValue.Equals(value) && (!leaderExists || value.Float() > currentLeader.Value.Float()) {
+				currentLeader.Highlight = highlight
+				currentLeader.Vehicle = vehicle
+				currentLeader.Value = value
+				leadersMap[highlight.Label] = currentLeader
+			}
+		}
+	}
+
+	nominateVehicles := make(map[string]struct{})
+	var highlightedVehicles []highlightedVehicle
+	for _, highlight := range highlights {
+		leader, leaderExists := leadersMap[highlight.Label]
+		if !leaderExists {
+			continue
+		}
+		if _, nominated := nominateVehicles[leader.Vehicle.VehicleID]; nominated {
+			continue
+		}
+		highlightedVehicles = append(highlightedVehicles, leader)
+		nominateVehicles[leader.Vehicle.VehicleID] = struct{}{}
+	}
+	return highlightedVehicles, nil
+}
diff --git a/internal/stats/prepare/common/options.go b/internal/stats/prepare/common/options.go
new file mode 100644
index 00000000..e27fba12
--- /dev/null
+++ b/internal/stats/prepare/common/options.go
@@ -0,0 +1,30 @@
+package common
+
+import "golang.org/x/text/language"
+
+var DefaultOptions = options{}
+
+type options struct {
+	localePrinter func(string) string
+	locale        *language.Tag
+}
+
+func (o options) Printer() func(s string) string {
+	if o.localePrinter != nil {
+		return o.localePrinter
+	}
+	return func(s string) string { return s }
+}
+
+func (o options) Locale() language.Tag {
+	if o.locale != nil {
+		return *o.locale
+	}
+	return language.English
+}
+
+type Option func(*options)
+
+func WithPrinter(printer func(string) string, locale language.Tag) func(*options) {
+	return func(o *options) { o.localePrinter = printer; o.locale = &locale }
+}
diff --git a/internal/stats/prepare/period/card.go b/internal/stats/prepare/period/card.go
index 1b43c812..65488820 100644
--- a/internal/stats/prepare/period/card.go
+++ b/internal/stats/prepare/period/card.go
@@ -9,8 +9,8 @@ import (
 	"github.com/cufee/aftermath/internal/stats/prepare/common"
 )
 
-func NewCards(stats fetch.AccountStatsOverPeriod, glossary map[string]database.Vehicle, opts ...Option) (Cards, error) {
-	options := defaultOptions
+func NewCards(stats fetch.AccountStatsOverPeriod, glossary map[string]database.Vehicle, opts ...common.Option) (Cards, error) {
+	options := common.DefaultOptions
 	for _, apply := range opts {
 		apply(&options)
 	}
@@ -21,15 +21,20 @@ func NewCards(stats fetch.AccountStatsOverPeriod, glossary map[string]database.V
 	var cards Cards
 
 	// Overview Card
-	for _, column := range selectedBlocks {
+	for _, column := range overviewBlocks {
 		var columnBlocks []common.StatsBlock[BlockData]
 		for _, preset := range column {
-			block := presetToBlock(preset, stats.RegularBattles.StatsFrame)
+			var block common.StatsBlock[BlockData]
 			if preset == TagAvgTier {
 				block = avgTierBlock(stats.RegularBattles.Vehicles, glossary)
+			} else {
+				b, err := presetToBlock(preset, stats.RegularBattles.StatsFrame)
+				if err != nil {
+					return Cards{}, err
+				}
+				block = b
 			}
-
-			block.Localize(options.localePrinter)
+			block.Localize(options.Printer())
 			columnBlocks = append(columnBlocks, block)
 		}
 
@@ -37,7 +42,7 @@ func NewCards(stats fetch.AccountStatsOverPeriod, glossary map[string]database.V
 		cards.Overview.Blocks = append(cards.Overview.Blocks, columnBlocks)
 	}
 
-	if len(stats.RegularBattles.Vehicles) < 1 || len(selectedHighlights) < 1 {
+	if len(stats.RegularBattles.Vehicles) < 1 || len(highlights) < 1 {
 		return cards, nil
 	}
 
@@ -45,7 +50,7 @@ func NewCards(stats fetch.AccountStatsOverPeriod, glossary map[string]database.V
 	var minimumBattles float64 = 5
 	periodDays := stats.PeriodEnd.Sub(stats.PeriodStart).Hours() / 24
 	withFallback := func(battles float64) float64 {
-		return math.Min(battles, float64(stats.RegularBattles.Battles.Float())/float64(len(selectedHighlights)))
+		return math.Min(battles, float64(stats.RegularBattles.Battles.Float())/float64(len(highlights)))
 	}
 	if periodDays > 90 {
 		minimumBattles = withFallback(100)
@@ -59,24 +64,31 @@ func NewCards(stats fetch.AccountStatsOverPeriod, glossary map[string]database.V
 		minimumBattles = withFallback(10)
 	}
 
-	highlightedVehicles := getHighlightedVehicles(selectedHighlights, stats.RegularBattles.Vehicles, int(minimumBattles))
+	highlightedVehicles, err := common.GetHighlightedVehicles(highlights, stats.RegularBattles.Vehicles, int(minimumBattles))
+	if err != nil {
+		return Cards{}, err
+	}
+
 	for _, data := range highlightedVehicles {
 		var vehicleBlocks []common.StatsBlock[BlockData]
 
-		for _, preset := range data.highlight.blocks {
-			block := presetToBlock(preset, *data.vehicle.StatsFrame)
-			block.Localize(options.localePrinter)
+		for _, preset := range data.Highlight.Blocks {
+			block, err := presetToBlock(preset, *data.Vehicle.StatsFrame)
+			if err != nil {
+				return Cards{}, err
+			}
+			block.Localize(options.Printer())
 			vehicleBlocks = append(vehicleBlocks, block)
 		}
 
-		glossary := glossary[data.vehicle.VehicleID]
-		glossary.ID = data.vehicle.VehicleID
+		glossary := glossary[data.Vehicle.VehicleID]
+		glossary.ID = data.Vehicle.VehicleID
 
 		cards.Highlights = append(cards.Highlights, VehicleCard{
-			Title:  fmt.Sprintf("%s %s", common.IntToRoman(glossary.Tier), glossary.Name(options.locale)),
+			Title:  fmt.Sprintf("%s %s", common.IntToRoman(glossary.Tier), glossary.Name(options.Locale())),
+			Meta:   options.Printer()(data.Highlight.Label),
 			Type:   common.CardTypeVehicle,
 			Blocks: vehicleBlocks,
-			Meta:   options.localePrinter(data.highlight.label),
 		})
 	}
 
diff --git a/internal/stats/prepare/period/constants.go b/internal/stats/prepare/period/constants.go
index 0997fa59..7b4a70c2 100644
--- a/internal/stats/prepare/period/constants.go
+++ b/internal/stats/prepare/period/constants.go
@@ -6,8 +6,8 @@ import (
 
 const TagAvgTier common.Tag = "avg_tier"
 
-var selectedBlocks = [][]common.Tag{{common.TagDamageRatio, common.TagAvgDamage, common.TagAccuracy}, {common.TagWN8, common.TagBattles}, {TagAvgTier, common.TagWinrate, common.TagSurvivalPercent}}
-var selectedHighlights = []highlight{HighlightBattles, HighlightWN8, HighlightAvgDamage}
+var overviewBlocks = [][]common.Tag{{common.TagDamageRatio, common.TagAvgDamage, common.TagAccuracy}, {common.TagWN8, common.TagBattles}, {TagAvgTier, common.TagWinrate, common.TagSurvivalPercent}}
+var highlights = []common.Highlight{common.HighlightBattles, common.HighlightWN8, common.HighlightAvgDamage}
 
 type Cards struct {
 	Overview   OverviewCard  `json:"overview"`
diff --git a/internal/stats/prepare/period/highlight.go b/internal/stats/prepare/period/highlight.go
deleted file mode 100644
index 003a274e..00000000
--- a/internal/stats/prepare/period/highlight.go
+++ /dev/null
@@ -1,60 +0,0 @@
-package period
-
-import (
-	"github.com/cufee/aftermath/internal/stats/frame"
-	"github.com/cufee/aftermath/internal/stats/prepare/common"
-)
-
-type highlight struct {
-	compareWith common.Tag
-	blocks      []common.Tag
-	label       string
-}
-
-var (
-	HighlightAvgDamage = highlight{common.TagAvgDamage, []common.Tag{common.TagBattles, common.TagAvgDamage, common.TagWN8}, "label_highlight_avg_damage"}
-	HighlightBattles   = highlight{common.TagBattles, []common.Tag{common.TagBattles, common.TagAvgDamage, common.TagWN8}, "label_highlight_battles"}
-	HighlightWN8       = highlight{common.TagWN8, []common.Tag{common.TagBattles, common.TagAvgDamage, common.TagWN8}, "label_highlight_wn8"}
-)
-
-type highlightedVehicle struct {
-	highlight highlight
-	vehicle   frame.VehicleStatsFrame
-	value     frame.Value
-}
-
-func getHighlightedVehicles(highlights []highlight, vehicles map[string]frame.VehicleStatsFrame, minBattles int) []highlightedVehicle {
-	leadersMap := make(map[string]highlightedVehicle)
-	for _, vehicle := range vehicles {
-		if int(vehicle.Battles.Float()) < minBattles {
-			continue
-		}
-
-		for _, highlight := range highlights {
-			currentLeader, leaderExists := leadersMap[highlight.label]
-			block := presetToBlock(highlight.compareWith, *vehicle.StatsFrame)
-
-			if !frame.InvalidValue.Equals(block.Value) && (!leaderExists || block.Value.Float() > currentLeader.value.Float()) {
-				currentLeader.highlight = highlight
-				currentLeader.value = block.Value
-				currentLeader.vehicle = vehicle
-				leadersMap[highlight.label] = currentLeader
-			}
-		}
-	}
-
-	nominateVehicles := make(map[string]struct{})
-	var highlightedVehicles []highlightedVehicle
-	for _, highlight := range highlights {
-		leader, leaderExists := leadersMap[highlight.label]
-		if !leaderExists {
-			continue
-		}
-		if _, nominated := nominateVehicles[leader.vehicle.VehicleID]; nominated {
-			continue
-		}
-		highlightedVehicles = append(highlightedVehicles, leader)
-		nominateVehicles[leader.vehicle.VehicleID] = struct{}{}
-	}
-	return highlightedVehicles
-}
diff --git a/internal/stats/prepare/period/options.go b/internal/stats/prepare/period/options.go
deleted file mode 100644
index a7a3f1d8..00000000
--- a/internal/stats/prepare/period/options.go
+++ /dev/null
@@ -1,16 +0,0 @@
-package period
-
-import "golang.org/x/text/language"
-
-var defaultOptions = options{localePrinter: func(s string) string { return s }, locale: language.English}
-
-type options struct {
-	localePrinter func(string) string
-	locale        language.Tag
-}
-
-type Option func(*options)
-
-func WithPrinter(printer func(string) string, locale language.Tag) func(*options) {
-	return func(o *options) { o.localePrinter = printer; o.locale = locale }
-}
diff --git a/internal/stats/prepare/period/preset.go b/internal/stats/prepare/period/preset.go
index 781aaaec..2251369b 100644
--- a/internal/stats/prepare/period/preset.go
+++ b/internal/stats/prepare/period/preset.go
@@ -5,10 +5,9 @@ import (
 	"github.com/cufee/aftermath/internal/stats/prepare/common"
 )
 
-func presetToBlock(preset common.Tag, stats frame.StatsFrame) common.StatsBlock[BlockData] {
+func presetToBlock(preset common.Tag, stats frame.StatsFrame) (common.StatsBlock[BlockData], error) {
 	block := common.StatsBlock[BlockData](common.NewBlock(preset, BlockData{}))
 
-	var args []any
 	switch preset {
 	case common.TagWN8:
 		block.Data.Flavor = BlockFlavorSpecial
@@ -32,6 +31,6 @@ func presetToBlock(preset common.Tag, stats frame.StatsFrame) common.StatsBlock[
 		block.Data.Flavor = BlockFlavorDefault
 	}
 
-	block.FillValue(stats, args...)
-	return block
+	err := block.FillValue(stats)
+	return block, err
 }
diff --git a/internal/stats/prepare/session/card.go b/internal/stats/prepare/session/card.go
new file mode 100644
index 00000000..81d3bd45
--- /dev/null
+++ b/internal/stats/prepare/session/card.go
@@ -0,0 +1,152 @@
+package session
+
+import (
+	"fmt"
+
+	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/stats/fetch"
+	"github.com/cufee/aftermath/internal/stats/frame"
+	"github.com/cufee/aftermath/internal/stats/prepare/common"
+	"golang.org/x/text/language"
+)
+
+func NewCards(session, career fetch.AccountStatsOverPeriod, glossary map[string]database.Vehicle, opts ...common.Option) (Cards, error) {
+	options := common.DefaultOptions
+	for _, apply := range opts {
+		apply(&options)
+	}
+	if glossary == nil {
+		glossary = make(map[string]database.Vehicle)
+	}
+
+	var cards Cards
+
+	// Rating battles overview
+	if session.RatingBattles.Battles > 0 {
+		card, err := makeOverviewCard(
+			ratingOverviewBlocks,
+			session.RatingBattles.StatsFrame,
+			career.RatingBattles.StatsFrame,
+			"label_overview_rating",
+			options.Printer(),
+			func(t common.Tag) common.Tag {
+				if t == common.TagWN8 {
+					return common.TagRankedRating
+				}
+				return t
+			},
+		)
+		if err != nil {
+			return Cards{}, err
+		}
+		cards.Rating.Overview = card
+	}
+	// Regular battles overview
+	if session.RegularBattles.Battles > 0 {
+		card, err := makeOverviewCard(
+			unratedOverviewBlocks,
+			session.RatingBattles.StatsFrame,
+			career.RatingBattles.StatsFrame,
+			"label_overview_unrated",
+			options.Printer(),
+			nil,
+		)
+		if err != nil {
+			return Cards{}, err
+		}
+		cards.Unrated.Overview = card
+	}
+
+	// Rating battles vehicles
+	for id, data := range session.RatingBattles.Vehicles {
+		var careerFrame frame.StatsFrame
+		if frame, ok := career.RatingBattles.Vehicles[id]; ok {
+			careerFrame = *frame.StatsFrame
+		}
+
+		glossary := glossary[id]
+		glossary.ID = id
+
+		card, err := makeVehicleCard(
+			[]common.Tag{common.TagWN8},
+			common.CardTypeRatingVehicle,
+			*data.StatsFrame,
+			careerFrame,
+			options.Printer(),
+			options.Locale(),
+			glossary,
+		)
+		if err != nil {
+			return Cards{}, err
+		}
+		cards.Rating.Vehicles = append(cards.Rating.Vehicles, card)
+	}
+	// Regular battles vehicles
+	for id, data := range session.RegularBattles.Vehicles {
+		var careerFrame frame.StatsFrame
+		if frame, ok := career.RegularBattles.Vehicles[id]; ok {
+			careerFrame = *frame.StatsFrame
+		}
+		glossary := glossary[id]
+		glossary.ID = id
+
+		card, err := makeVehicleCard(
+			vehicleBlocks,
+			common.CardTypeVehicle,
+			*data.StatsFrame,
+			careerFrame,
+			options.Printer(),
+			options.Locale(),
+			glossary,
+		)
+		if err != nil {
+			return Cards{}, err
+		}
+		cards.Unrated.Vehicles = append(cards.Unrated.Vehicles, card)
+	}
+
+	return cards, nil
+}
+
+func makeVehicleCard(presets []common.Tag, cardType common.CardType, session, career frame.StatsFrame, printer func(string) string, locale language.Tag, glossary database.Vehicle) (VehicleCard, error) {
+	var blocks []common.StatsBlock[BlockData]
+	for _, preset := range presets {
+		block, err := presetToBlock(preset, session, career)
+		if err != nil {
+			return VehicleCard{}, err
+		}
+		block.Localize(printer)
+		blocks = append(blocks, block)
+	}
+
+	return VehicleCard{
+		Title:  fmt.Sprintf("%s %s", common.IntToRoman(glossary.Tier), glossary.Name(locale)),
+		Type:   cardType,
+		Blocks: blocks,
+	}, nil
+}
+
+func makeOverviewCard(columns [][]common.Tag, session, career frame.StatsFrame, label string, printer func(string) string, replace func(common.Tag) common.Tag) (OverviewCard, error) {
+	var blocks [][]common.StatsBlock[BlockData]
+	for _, presets := range columns {
+		var column []common.StatsBlock[BlockData]
+		for _, p := range presets {
+			preset := p
+			if replace != nil {
+				preset = replace(p)
+			}
+			block, err := presetToBlock(preset, session, career)
+			if err != nil {
+				return OverviewCard{}, err
+			}
+			block.Localize(printer)
+			column = append(column, block)
+		}
+		blocks = append(blocks, column)
+	}
+	return OverviewCard{
+		Type:   common.CardTypeOverview,
+		Title:  printer(label),
+		Blocks: blocks,
+	}, nil
+}
diff --git a/internal/stats/prepare/session/constants.go b/internal/stats/prepare/session/constants.go
new file mode 100644
index 00000000..c49fa6b2
--- /dev/null
+++ b/internal/stats/prepare/session/constants.go
@@ -0,0 +1,35 @@
+package session
+
+import (
+	"github.com/cufee/aftermath/internal/stats/frame"
+	"github.com/cufee/aftermath/internal/stats/prepare/common"
+)
+
+var unratedOverviewBlocks = [][]common.Tag{{common.TagBattles, common.TagAvgDamage}, {common.TagWinrate, common.TagDamageRatio}, {common.TagWN8}}
+var ratingOverviewBlocks = [][]common.Tag{{common.TagBattles, common.TagAvgDamage}, {common.TagWinrate, common.TagDamageRatio}, {common.TagRankedRating}}
+var vehicleBlocks = []common.Tag{common.TagBattles, common.TagAvgDamage, common.TagDamageRatio, common.TagWinrate, common.TagWN8}
+var highlights = []common.Highlight{common.HighlightBattles, common.HighlightWN8, common.HighlightAvgDamage}
+
+type Cards struct {
+	Unrated UnratedCards `json:"unrated"`
+	Rating  RatingCards  `json:"rating"`
+}
+
+type UnratedCards struct {
+	Overview   OverviewCard
+	Vehicles   []VehicleCard
+	Highlights []VehicleCard
+}
+
+type RatingCards struct {
+	Overview OverviewCard
+	Vehicles []VehicleCard
+}
+
+type OverviewCard common.StatsCard[[]common.StatsBlock[BlockData], string]
+type VehicleCard common.StatsCard[common.StatsBlock[BlockData], string]
+
+type BlockData struct {
+	Session frame.Value
+	Career  frame.Value
+}
diff --git a/internal/stats/prepare/session/preset.go b/internal/stats/prepare/session/preset.go
new file mode 100644
index 00000000..5c496b0c
--- /dev/null
+++ b/internal/stats/prepare/session/preset.go
@@ -0,0 +1,28 @@
+package session
+
+import (
+	"github.com/cufee/aftermath/internal/stats/frame"
+	"github.com/cufee/aftermath/internal/stats/prepare/common"
+)
+
+func presetToBlock(preset common.Tag, session, career frame.StatsFrame) (common.StatsBlock[BlockData], error) {
+	// create blocks from stats
+	// this module has no special blocks, so we can just use the common.Block#FillValue
+	sessionBlock := common.StatsBlock[BlockData](common.NewBlock(preset, BlockData{}))
+	err := sessionBlock.FillValue(session)
+	if err != nil {
+		return common.StatsBlock[BlockData]{}, nil
+	}
+	careerBlock := common.StatsBlock[BlockData](common.NewBlock(preset, BlockData{}))
+	err = careerBlock.FillValue(career)
+	if err != nil {
+		return common.StatsBlock[BlockData]{}, nil
+	}
+
+	block := common.StatsBlock[BlockData](common.NewBlock(preset, BlockData{
+		Session: sessionBlock.Value,
+		Career:  careerBlock.Value,
+	}))
+	block.Value = sessionBlock.Value
+	return block, nil
+}
diff --git a/internal/stats/render/common/header.go b/internal/stats/render/common/header.go
new file mode 100644
index 00000000..e28f925b
--- /dev/null
+++ b/internal/stats/render/common/header.go
@@ -0,0 +1,47 @@
+package common
+
+import (
+	"github.com/cufee/aftermath/internal/database"
+)
+
+func NewHeaderCard(width float64, subscriptions []database.UserSubscription, promoText []string) (Block, bool) {
+	var cards []Block
+
+	var addPromoText = len(promoText) > 0
+	for _, sub := range subscriptions {
+		switch sub.Type {
+		case database.SubscriptionTypePro, database.SubscriptionTypePlus, database.SubscriptionTypeDeveloper:
+			addPromoText = false
+		}
+		if !addPromoText {
+			break
+		}
+	}
+
+	if addPromoText {
+		// Users without a subscription get promo text
+		var textBlocks []Block
+		for _, text := range promoText {
+			textBlocks = append(textBlocks, NewTextContent(Style{Font: &FontMedium, FontColor: TextPrimary}, text))
+		}
+		cards = append(cards, NewBlocksContent(Style{
+			Direction:  DirectionVertical,
+			AlignItems: AlignItemsCenter,
+		},
+			textBlocks...,
+		))
+	}
+
+	// User Subscription Badge and promo text
+	if badges, _ := SubscriptionsBadges(subscriptions); len(badges) > 0 {
+		cards = append(cards, NewBlocksContent(Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, Gap: 10},
+			badges...,
+		))
+	}
+
+	if len(cards) < 1 {
+		return Block{}, false
+	}
+
+	return NewBlocksContent(Style{Direction: DirectionVertical, AlignItems: AlignItemsCenter, JustifyContent: JustifyContentCenter, Gap: 10, Width: width}, cards...), true
+}
diff --git a/internal/stats/render/period/cards.go b/internal/stats/render/period/cards.go
index 107a5f02..57918453 100644
--- a/internal/stats/render/period/cards.go
+++ b/internal/stats/render/period/cards.go
@@ -110,7 +110,7 @@ func generateCards(stats fetch.AccountStatsOverPeriod, cards period.Cards, subs
 	}
 
 	// Header card
-	if headerCard, headerCardExists := newHeaderCard(cardWidth, subs, opts); headerCardExists {
+	if headerCard, headerCardExists := common.NewHeaderCard(cardWidth, subs, opts.PromoText); headerCardExists {
 		segments.AddHeader(headerCard)
 	}
 
@@ -138,48 +138,6 @@ func generateCards(stats fetch.AccountStatsOverPeriod, cards period.Cards, subs
 	return segments, nil
 }
 
-func newHeaderCard(width float64, subscriptions []database.UserSubscription, options render.Options) (common.Block, bool) {
-	var cards []common.Block
-
-	var addPromoText = true
-	for _, sub := range subscriptions {
-		switch sub.Type {
-		case database.SubscriptionTypePro, database.SubscriptionTypePlus, database.SubscriptionTypeDeveloper:
-			addPromoText = false
-		}
-		if !addPromoText {
-			break
-		}
-	}
-
-	if addPromoText && options.PromoText != nil {
-		// Users without a subscription get promo text
-		var textBlocks []common.Block
-		for _, text := range options.PromoText {
-			textBlocks = append(textBlocks, common.NewTextContent(common.Style{Font: &common.FontMedium, FontColor: common.TextPrimary}, text))
-		}
-		cards = append(cards, common.NewBlocksContent(common.Style{
-			Direction:  common.DirectionVertical,
-			AlignItems: common.AlignItemsCenter,
-		},
-			textBlocks...,
-		))
-	}
-
-	// User Subscription Badge and promo text
-	if badges, _ := common.SubscriptionsBadges(subscriptions); len(badges) > 0 {
-		cards = append(cards, common.NewBlocksContent(common.Style{Direction: common.DirectionHorizontal, AlignItems: common.AlignItemsCenter, Gap: 10},
-			badges...,
-		))
-	}
-
-	if len(cards) < 1 {
-		return common.Block{}, false
-	}
-
-	return common.NewBlocksContent(common.Style{Direction: common.DirectionVertical, AlignItems: common.AlignItemsCenter, JustifyContent: common.JustifyContentCenter, Gap: 10, Width: width}, cards...), true
-}
-
 func newHighlightCard(style highlightStyle, card period.VehicleCard) common.Block {
 	titleBlock :=
 		common.NewBlocksContent(common.Style{
diff --git a/internal/stats/render/period/render.go b/internal/stats/render/period/image.go
similarity index 100%
rename from internal/stats/render/period/render.go
rename to internal/stats/render/period/image.go
diff --git a/internal/stats/render/session/blocks.go b/internal/stats/render/session/blocks.go
new file mode 100644
index 00000000..85ea47e8
--- /dev/null
+++ b/internal/stats/render/session/blocks.go
@@ -0,0 +1,145 @@
+package session
+
+// type convertOptions struct {
+// 	showSessionStats    bool
+// 	showCareerStats     bool
+// 	showLabels          bool
+// 	showIcons           bool
+// 	highlightBlockIndex int
+// }
+
+// func newVehicleCard(style render.Style, card session.Card, sizes map[int]float64, opts convertOptions) (render.Block, error) {
+// 	if card.Type == dataprep.CardTypeRatingVehicle {
+// 		return slimVehicleCard(style, card, sizes, opts)
+// 	}
+
+// 	return defaultVehicleCard(style, card, sizes, opts)
+// }
+
+// func defaultVehicleCard(style render.Style, card session.Card, sizes map[int]float64, opts convertOptions) (render.Block, error) {
+// 	blocks, err := statsBlocksToCardBlocks(card.Blocks, sizes, opts)
+// 	if err != nil {
+// 		return render.Block{}, err
+// 	}
+
+// 	cardContentBlocks := []render.Block{newCardTitle(card.Title)}
+// 	contentWidth := style.Width - style.PaddingX*2
+
+// 	statsRowBlock := render.NewBlocksContent(statsRowStyle(contentWidth), blocks...)
+// 	cardContentBlocks = append(cardContentBlocks, statsRowBlock)
+
+// 	return render.NewBlocksContent(style, cardContentBlocks...), nil
+// }
+
+// func slimVehicleCard(style render.Style, card session.Card, sizes map[int]float64, opts convertOptions) (render.Block, error) {
+// 	opts.highlightBlockIndex = -1
+// 	opts.showCareerStats = false
+// 	opts.showLabels = false
+// 	opts.showIcons = true
+
+// 	blocks, err := statsBlocksToCardBlocks(card.Blocks, sizes, opts)
+// 	if err != nil {
+// 		return render.Block{}, err
+// 	}
+
+// 	titleBlock := render.NewTextContent(ratingVehicleTitleStyle, card.Title)
+// 	statsRowBlock := render.NewBlocksContent(statsRowStyle(0), blocks...)
+
+// 	containerStyle := style
+// 	containerStyle.Direction = render.DirectionHorizontal
+// 	containerStyle.JustifyContent = render.JustifyContentSpaceBetween
+
+// 	return render.NewBlocksContent(containerStyle, titleBlock, statsRowBlock), nil
+// }
+
+// func statsBlocksToCardBlocks(stats []session.StatsBlock, blockWidth map[int]float64, opts ...convertOptions) ([]render.Block, error) {
+// 	var options convertOptions = convertOptions{
+// 		showSessionStats:    true,
+// 		showCareerStats:     true,
+// 		showLabels:          true,
+// 		showIcons:           true,
+// 		highlightBlockIndex: 0,
+// 	}
+// 	if len(opts) > 0 {
+// 		options = opts[0]
+// 	}
+
+// 	var content []render.Block
+// 	for index, statsBlock := range stats {
+// 		blocks := make([]render.Block, 0, 3)
+// 		if options.showSessionStats {
+// 			if options.showIcons && statsBlock.Tag != dataprep.TagBattles {
+// 				blocks = append(blocks, newStatsBlockRow(defaultBlockStyle.session, statsBlock.Session.String, comparisonIconFromBlock(statsBlock)))
+// 			} else {
+// 				blocks = append(blocks, render.NewTextContent(defaultBlockStyle.session, statsBlock.Session.String))
+// 			}
+// 		}
+// 		if options.showCareerStats && statsBlock.Career.String != "" {
+// 			if options.showIcons && statsBlock.Tag != dataprep.TagBattles {
+// 				blocks = append(blocks, newStatsBlockRow(defaultBlockStyle.career, statsBlock.Career.String, blockToWN8Icon(statsBlock.Career, statsBlock.Tag)))
+// 			} else {
+// 				blocks = append(blocks, render.NewTextContent(defaultBlockStyle.career, statsBlock.Career.String))
+// 			}
+// 		}
+// 		if options.showLabels && statsBlock.Tag != dataprep.TagBattles {
+// 			if options.showIcons {
+// 				blocks = append(blocks, newStatsBlockRow(defaultBlockStyle.label, statsBlock.Label, blankIconBlock))
+// 			} else {
+// 				blocks = append(blocks, render.NewTextContent(defaultBlockStyle.label, statsBlock.Label))
+// 			}
+// 		}
+
+// 		containerStyle := defaultStatsBlockStyle(blockWidth[index])
+// 		if index == options.highlightBlockIndex {
+// 			containerStyle = highlightStatsBlockStyle(blockWidth[index])
+// 		}
+// 		content = append(content, render.NewBlocksContent(containerStyle, blocks...))
+// 	}
+// 	return content, nil
+// }
+
+// func newStatsBlockRow(style render.Style, value string, icon render.Block) render.Block {
+// 	return render.NewBlocksContent(
+// 		render.Style{Direction: render.DirectionHorizontal, AlignItems: render.AlignItemsCenter},
+// 		icon,
+// 		render.NewTextContent(style, value),
+// 	)
+// }
+
+// func newCardTitle(label string) render.Block {
+// 	return render.NewTextContent(defaultBlockStyle.career, label)
+// }
+
+// func comparisonIconFromBlock(block session.StatsBlock) render.Block {
+// 	if !stats.ValueValid(block.Session.Value) || !stats.ValueValid(block.Career.Value) {
+// 		return blankIconBlock
+// 	}
+
+// 	if block.Tag == dataprep.TagWN8 {
+// 		// WN8 icons need to show the color
+// 		return blockToWN8Icon(block.Session, block.Tag)
+// 	}
+
+// 	var icon image.Image
+// 	var iconColor color.Color
+// 	if block.Session.Value > block.Career.Value {
+// 		icon, _ = assets.GetImage("images/icons/chevron-up-single")
+// 		iconColor = color.RGBA{R: 0, G: 255, B: 0, A: 255}
+// 	}
+// 	if block.Session.Value < block.Career.Value {
+// 		icon, _ = assets.GetImage("images/icons/chevron-down-single")
+// 		iconColor = color.RGBA{R: 255, G: 0, B: 0, A: 255}
+// 	}
+// 	if icon == nil {
+// 		return blankIconBlock
+// 	}
+
+// 	return render.NewImageContent(render.Style{Width: float64(iconSize), Height: float64(iconSize), BackgroundColor: iconColor}, icon)
+// }
+
+// func blockToWN8Icon(value dataprep.Value, tag dataprep.Tag) render.Block {
+// 	if tag != dataprep.TagWN8 || !stats.ValueValid(value.Value) {
+// 		return blankIconBlock
+// 	}
+// 	return render.NewImageContent(render.Style{Width: float64(iconSize), Height: float64(iconSize), BackgroundColor: shared.GetWN8Colors(int(value.Value)).Background}, wn8Icon)
+// }
diff --git a/internal/stats/render/session/cards.go b/internal/stats/render/session/cards.go
new file mode 100644
index 00000000..b41a141d
--- /dev/null
+++ b/internal/stats/render/session/cards.go
@@ -0,0 +1,215 @@
+package session
+
+import (
+	"strings"
+
+	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/stats/fetch"
+	"github.com/cufee/aftermath/internal/stats/prepare/session"
+	"github.com/cufee/aftermath/internal/stats/render/common"
+
+	"github.com/cufee/aftermath/internal/stats/render"
+)
+
+func cardsToSegments(session, career fetch.AccountStatsOverPeriod, cards session.Cards, subs []database.UserSubscription, opts render.Options) (render.Segments, error) {
+	var segments render.Segments
+	var primaryColumn []common.Block
+	var secondaryColumn []common.Block
+
+	// Calculate minimal card width to fit all the content
+	primaryCardBlockSizes := make(map[string]float64)
+	secondaryCardBlockSizes := make(map[string]float64)
+	var primaryCardWidth, secondaryCardWidth, totalFrameWidth float64
+	// rating and unrated battles > 0	 	   unrated battles > 0		   rating battles > 0
+	// [title card		] | [vehicle]    [title card	  ] | [vehicle]    [title card	  	]
+	// [overview unrated] | [vehicle] OR [overview unrated] | [vehicle] OR [overview rating ]
+	// [overview rating ] | [...    ]    [highlight       ] | [...    ]    [vehicle			]
+
+	{
+		titleStyle := common.DefaultPlayerTitleStyle(playerNameCardStyle(0))
+		clanSize := common.MeasureString(session.Account.ClanTag, *titleStyle.ClanTag.Font)
+		nameSize := common.MeasureString(session.Account.Nickname, *titleStyle.Nickname.Font)
+		primaryCardWidth = common.Max(primaryCardWidth, titleStyle.TotalPaddingAndGaps()+nameSize.TotalWidth+clanSize.TotalWidth*2)
+	}
+	{
+		for _, text := range opts.PromoText {
+			size := common.MeasureString(text, *promoTextStyle.Font)
+			totalFrameWidth = common.Max(size.TotalWidth, totalFrameWidth)
+		}
+	}
+
+	// unrated overview - show if there are no rating battles (so the card is not empty), or there are battles
+	if session.RegularBattles.Battles > 0 || session.RatingBattles.Battles == 0 {
+		//
+	}
+	// rating overview
+	if session.RatingBattles.Battles > 0 {
+		//
+	}
+	// rating vehicle cards go on the primary block - only show if there are no highlights
+	if len(cards.Unrated.Highlights) == 0 {
+		for _, card := range cards.Rating.Vehicles {
+			// [title]	[session]
+			titleSize := common.MeasureString(card.Title, *ratingVehicleCardTitleStyle.Font)
+			presetBlockWidth, contentWidth := vehicleBlocksWidth(card, ratingVehicleBlockStyle.session, ratingVehicleBlockStyle.career, ratingVehicleBlockStyle.label, ratingVehicleBlockStyle.container)
+			// add the gap and card padding, the gap here accounts for title being inline with content
+			contentWidth += ratingVehicleBlocksRowStyle(0).Gap*float64(len(card.Blocks)) + ratingVehicleCardStyle(0).PaddingX*2 + titleSize.TotalWidth
+
+			primaryCardWidth = common.Max(primaryCardWidth, contentWidth)
+			for key, width := range presetBlockWidth {
+				primaryCardBlockSizes[key] = common.Max(primaryCardBlockSizes[key], width)
+			}
+		}
+	}
+	// highlighted vehicles go on the primary block
+	{
+		for _, card := range cards.Unrated.Highlights {
+			// [card label]	[session]
+			// [title]  	 [label]
+			labelSize := common.MeasureString(card.Meta, *vehicleCardTitleStyle.Font)
+			titleSize := common.MeasureString(card.Title, *vehicleCardTitleStyle.Font)
+			presetBlockWidth, contentWidth := vehicleBlocksWidth(card, vehicleBlockStyle.session, vehicleBlockStyle.career, vehicleBlockStyle.label, vehicleBlockStyle.container)
+			// add the gap and card padding, the gap here accounts for title/label being inline with content
+			contentWidth += vehicleBlocksRowStyle(0).Gap*float64(len(card.Blocks)) + highlightCardStyle(0).PaddingX*2 + common.Max(titleSize.TotalWidth, labelSize.TotalWidth)
+			primaryCardWidth = common.Max(primaryCardWidth, contentWidth)
+
+			for key, width := range presetBlockWidth {
+				primaryCardBlockSizes[key] = common.Max(primaryCardBlockSizes[key], width)
+			}
+		}
+	}
+	{ // unrated vehicles go on the secondary block
+		for _, card := range cards.Unrated.Vehicles {
+			// 		[ label ]
+			// [session]
+			// [career ]
+			// [label  ] ...
+			presetBlockWidth, contentWidth := vehicleBlocksWidth(card, vehicleBlockStyle.session, vehicleBlockStyle.career, vehicleBlockStyle.label, vehicleBlockStyle.container)
+			contentWidth += vehicleBlocksRowStyle(0).Gap*float64(len(card.Blocks)-1) + vehicleCardStyle(0).PaddingX*2
+
+			titleSize := common.MeasureString(card.Title, *vehicleCardTitleStyle.Font)
+			secondaryCardWidth = common.Max(secondaryCardWidth, contentWidth, titleSize.TotalWidth+vehicleCardStyle(0).PaddingX*2)
+
+			for key, width := range presetBlockWidth {
+				secondaryCardBlockSizes[key] = common.Max(secondaryCardBlockSizes[key], width)
+			}
+		}
+	}
+
+	frameWidth := secondaryCardWidth + primaryCardWidth
+	if secondaryCardWidth > 0 && primaryCardWidth > 0 {
+		frameWidth += frameStyle().Gap
+	}
+	totalFrameWidth = common.Max(totalFrameWidth, frameWidth)
+
+	// Header card
+	if headerCard, headerCardExists := common.NewHeaderCard(totalFrameWidth, subs, opts.PromoText); headerCardExists {
+		segments.AddHeader(headerCard)
+	}
+
+	// // User Subscription Badge and promo text
+	// if addPromoText && opts.PromoText != nil {
+	// 	// Users without a subscription get promo text
+	// 	var textBlocks []common.Block
+	// 	for _, text := range opts.PromoText {
+	// 		textBlocks = append(textBlocks, render.NewTextContent(promoTextStyle, text))
+	// 	}
+	// 	cards = append(cards, common.NewBlocksContent(render.Style{
+	// 		Direction:  render.DirectionVertical,
+	// 		AlignItems: render.AlignItemsCenter,
+	// 	},
+	// 		textBlocks...,
+	// 	))
+	// }
+	// if badges, _ := badges.SubscriptionsBadges(player.Subscriptions); len(badges) > 0 {
+	// 	cards = append(cards, render.NewBlocksContent(render.Style{Direction: render.DirectionHorizontal, AlignItems: render.AlignItemsCenter, Gap: 10},
+	// 		badges...,
+	// 	))
+	// }
+
+	primaryColumn = append(primaryColumn,
+		common.NewPlayerTitleCard(common.DefaultPlayerTitleStyle(playerNameCardStyle(primaryCardWidth)), session.Account.Nickname, session.Account.ClanTag, subs),
+	)
+
+	// // Rating Cards
+	// if len(player.Cards.Rating) > 0 {
+	// 	ratingGroup, err := makeCardsGroup(player.Cards.Rating, cardWidth, cardBlockSizes)
+	// 	if err != nil {
+	// 		return nil, err
+	// 	}
+	// 	cards = append(cards, ratingGroup)
+	// }
+
+	// // Unrated Cards
+	// if len(player.Cards.Unrated) > 0 {
+	// 	unratedGroup, err := makeCardsGroup(player.Cards.Unrated, cardWidth, cardBlockSizes)
+	// 	if err != nil {
+	// 		return nil, err
+	// 	}
+	// 	cards = append(cards, unratedGroup)
+	// }
+
+	columns := []common.Block{common.NewBlocksContent(columnStyle(primaryCardWidth), primaryColumn...)}
+	if len(secondaryColumn) > 0 {
+		columns = append(columns, common.NewBlocksContent(columnStyle(secondaryCardWidth), secondaryColumn...))
+	}
+	segments.AddContent(common.NewBlocksContent(frameStyle(), columns...))
+
+	var footer []string
+	switch session.Realm {
+	case "na":
+		footer = append(footer, "North America")
+	case "eu":
+		footer = append(footer, "Europe")
+	case "as":
+		footer = append(footer, "Asia")
+	}
+	if session.LastBattleTime.Unix() > 1 {
+		sessionTo := session.PeriodEnd.Format("Jan 2")
+		sessionFrom := session.PeriodStart.Format("Jan 2")
+		if sessionFrom == sessionTo {
+			footer = append(footer, sessionTo)
+		} else {
+			footer = append(footer, sessionFrom+" - "+sessionTo)
+		}
+	}
+
+	if len(footer) > 0 {
+		segments.AddFooter(common.NewFooterCard(strings.Join(footer, " • ")))
+	}
+
+	return segments, nil
+}
+
+func vehicleBlocksWidth(card session.VehicleCard, sessionStyle, careerStyle, labelStyle, containerStyle common.Style) (map[string]float64, float64) {
+	presetBlockWidth := make(map[string]float64)
+	var contentWidth, maxBlockWidth float64
+	for _, block := range card.Blocks {
+		var width float64
+		{
+			size := common.MeasureString(block.Data.Session.String(), *sessionStyle.Font)
+			width = common.Max(width, size.TotalWidth+sessionStyle.PaddingX*2)
+		}
+		{
+			size := common.MeasureString(block.Data.Career.String(), *careerStyle.Font)
+			width = common.Max(width, size.TotalWidth+careerStyle.PaddingX*2)
+		}
+		{
+			size := common.MeasureString(block.Label, *labelStyle.Font)
+			width = common.Max(width, size.TotalWidth+labelStyle.PaddingX*2)
+		}
+		w := width + float64(iconSize)
+		maxBlockWidth = common.Max(maxBlockWidth, w)
+		presetBlockWidth[block.Tag.String()] = common.Max(presetBlockWidth[block.Tag.String()], w) // add space for comparison icons
+	}
+
+	if containerStyle.Direction == common.DirectionHorizontal {
+		for _, w := range presetBlockWidth {
+			contentWidth += w
+		}
+	} else {
+		contentWidth = maxBlockWidth
+	}
+
+	return presetBlockWidth, contentWidth
+}
diff --git a/internal/stats/render/session/constants.go b/internal/stats/render/session/constants.go
new file mode 100644
index 00000000..4282e434
--- /dev/null
+++ b/internal/stats/render/session/constants.go
@@ -0,0 +1,120 @@
+package session
+
+import (
+	"image"
+	"image/color"
+
+	"github.com/cufee/aftermath/internal/stats/render/common"
+	"github.com/fogleman/gg"
+)
+
+type blockStyle struct {
+	container common.Style
+	session   common.Style
+	career    common.Style
+	label     common.Style
+}
+
+func init() {
+	{
+		ctx := gg.NewContext(iconSize, iconSize)
+		ctx.DrawRoundedRectangle(13, 2.5, 6, 17.5, 3)
+		ctx.SetColor(color.RGBA{R: 255, G: 255, B: 255, A: 255})
+		ctx.Fill()
+		wn8Icon = ctx.Image()
+	}
+
+	{
+		ctx := gg.NewContext(iconSize, 1)
+		blankIconBlock = common.NewImageContent(common.Style{Width: float64(iconSize), Height: 1}, ctx.Image())
+	}
+}
+
+var (
+	iconSize       = 25
+	wn8Icon        image.Image
+	blankIconBlock common.Block
+)
+
+var (
+	promoTextStyle = common.Style{Font: &common.FontMedium, FontColor: common.TextPrimary}
+)
+
+func frameStyle() common.Style {
+	return common.Style{Gap: 10, Direction: common.DirectionHorizontal}
+}
+
+func columnStyle(width float64) common.Style {
+	return common.Style{Gap: 10, Direction: common.DirectionVertical, Width: width}
+}
+
+var (
+	vehicleCardTitleStyle = common.Style{Font: &common.FontLarge, FontColor: common.TextSecondary, PaddingX: 5}
+	vehicleBlockStyle     = blockStyle{
+		common.Style{Direction: common.DirectionVertical, AlignItems: common.AlignItemsCenter},
+		common.Style{Font: &common.FontLarge, FontColor: common.TextPrimary},
+		common.Style{Font: &common.FontMedium, FontColor: common.TextSecondary},
+		common.Style{Font: &common.FontSmall, FontColor: common.TextAlt},
+	}
+)
+
+func vehicleCardStyle(width float64) common.Style {
+	return defaultCardStyle(width)
+}
+
+func vehicleBlocksRowStyle(width float64) common.Style {
+	return common.Style{
+		JustifyContent: common.JustifyContentSpaceBetween,
+		Direction:      common.DirectionHorizontal,
+		AlignItems:     common.AlignItemsCenter,
+		Width:          width,
+		Gap:            10,
+	}
+}
+
+var (
+	ratingVehicleCardTitleStyle = common.Style{Font: &common.FontMedium, FontColor: common.TextSecondary, PaddingX: 5}
+	ratingVehicleBlockStyle     = blockStyle{
+		common.Style{Direction: common.DirectionVertical, AlignItems: common.AlignItemsCenter},
+		common.Style{Font: &common.FontLarge, FontColor: common.TextPrimary},
+		common.Style{Font: &common.FontMedium, FontColor: common.TextSecondary},
+		common.Style{Font: &common.FontSmall, FontColor: common.TextAlt},
+	}
+)
+
+func ratingVehicleCardStyle(width float64) common.Style {
+	return defaultCardStyle(width)
+}
+
+func ratingVehicleBlocksRowStyle(width float64) common.Style {
+	return vehicleBlocksRowStyle(width)
+}
+
+func highlightCardStyle(width float64) common.Style {
+	return defaultCardStyle(width)
+}
+
+func highlightedVehicleCardStyle(width float64) common.Style {
+	return vehicleCardStyle(width)
+}
+
+func defaultCardStyle(width float64) common.Style {
+	style := common.Style{
+		JustifyContent:  common.JustifyContentCenter,
+		AlignItems:      common.AlignItemsCenter,
+		Direction:       common.DirectionVertical,
+		PaddingX:        20,
+		PaddingY:        20,
+		BackgroundColor: common.DefaultCardColor,
+		BorderRadius:    20,
+		Width:           width,
+		// Debug:           true,
+	}
+	return style
+}
+
+func playerNameCardStyle(width float64) common.Style {
+	style := defaultCardStyle(width)
+	style.PaddingX, style.PaddingY = 10, 10
+	return style
+}
diff --git a/internal/stats/render/session/image.go b/internal/stats/render/session/image.go
new file mode 100644
index 00000000..dd19c6c7
--- /dev/null
+++ b/internal/stats/render/session/image.go
@@ -0,0 +1,24 @@
+package session
+
+import (
+	"image"
+
+	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/stats/fetch"
+	"github.com/cufee/aftermath/internal/stats/prepare/session"
+	"github.com/cufee/aftermath/internal/stats/render"
+)
+
+func CardsToImage(session, career fetch.AccountStatsOverPeriod, cards session.Cards, subs []database.UserSubscription, opts ...render.Option) (image.Image, error) {
+	o := render.DefaultOptions()
+	for _, apply := range opts {
+		apply(&o)
+	}
+
+	segments, err := cardsToSegments(session, career, cards, subs, o)
+	if err != nil {
+		return nil, err
+	}
+
+	return segments.Render(opts...)
+}
diff --git a/internal/stats/session.go b/internal/stats/session.go
index 4c463f64..bedbd34d 100644
--- a/internal/stats/session.go
+++ b/internal/stats/session.go
@@ -9,17 +9,18 @@ import (
 	"github.com/cufee/aftermath/internal/localization"
 	"github.com/cufee/aftermath/internal/logic"
 	"github.com/cufee/aftermath/internal/stats/fetch"
-	prepare "github.com/cufee/aftermath/internal/stats/prepare/period"
+	"github.com/cufee/aftermath/internal/stats/prepare/common"
+	prepare "github.com/cufee/aftermath/internal/stats/prepare/session"
 	options "github.com/cufee/aftermath/internal/stats/render"
-	render "github.com/cufee/aftermath/internal/stats/render/period"
-	"github.com/pkg/errors"
+	render "github.com/cufee/aftermath/internal/stats/render/session"
 	"github.com/rs/zerolog/log"
 )
 
 func (r *renderer) Session(ctx context.Context, accountId string, from time.Time, opts ...options.Option) (Image, Metadata, error) {
-	meta := Metadata{}
+	meta := Metadata{Stats: make(map[string]fetch.AccountStatsOverPeriod)}
+
 	stop := meta.Timer("database#GetAccountByID")
-	account, err := r.database.GetAccountByID(ctx, accountId)
+	_, err := r.database.GetAccountByID(ctx, accountId)
 	stop()
 	if err != nil {
 		if db.IsErrNotFound(err) {
@@ -48,30 +49,30 @@ func (r *renderer) Session(ctx context.Context, accountId string, from time.Time
 	}
 
 	stop = meta.Timer("fetchClient#SessionStats")
-	stats, err := r.fetchClient.SessionStats(ctx, accountId, from, fetch.WithWN8())
+	session, career, err := r.fetchClient.SessionStats(ctx, accountId, from, fetch.WithWN8())
 	stop()
-	if errors.Is(err, fetch.ErrSessionNotFound) {
-		// blank session
-		err = nil
-		stats = fetch.AccountStatsOverPeriod{
-			Realm:          account.Realm,
-			Account:        account,
-			PeriodEnd:      time.Now(),
-			PeriodStart:    time.Now(),
-			LastBattleTime: account.LastBattleTime,
-		}
-	}
 	if err != nil {
 		return nil, meta, err
 	}
-	meta.Stats = stats
+	meta.Stats["career"] = career
+	meta.Stats["session"] = session
 
 	stop = meta.Timer("prepare#GetVehicles")
 	var vehicles []string
-	for id := range stats.RegularBattles.Vehicles {
+	for id := range session.RegularBattles.Vehicles {
 		vehicles = append(vehicles, id)
 	}
-	for id := range stats.RatingBattles.Vehicles {
+	for id := range session.RatingBattles.Vehicles {
+		if !slices.Contains(vehicles, id) {
+			vehicles = append(vehicles, id)
+		}
+	}
+	for id := range career.RegularBattles.Vehicles {
+		if !slices.Contains(vehicles, id) {
+			vehicles = append(vehicles, id)
+		}
+	}
+	for id := range career.RatingBattles.Vehicles {
 		if !slices.Contains(vehicles, id) {
 			vehicles = append(vehicles, id)
 		}
@@ -84,14 +85,14 @@ func (r *renderer) Session(ctx context.Context, accountId string, from time.Time
 	stop()
 
 	stop = meta.Timer("prepare#NewCards")
-	cards, err := prepare.NewCards(stats, glossary, prepare.WithPrinter(printer, r.locale))
+	cards, err := prepare.NewCards(session, career, glossary, common.WithPrinter(printer, r.locale))
 	stop()
 	if err != nil {
 		return nil, meta, err
 	}
 
 	stop = meta.Timer("render#CardsToImage")
-	image, err := render.CardsToImage(stats, cards, nil, opts...)
+	image, err := render.CardsToImage(session, career, cards, nil, opts...)
 	stop()
 	if err != nil {
 		return nil, meta, err
diff --git a/render_test.go b/render_test.go
new file mode 100644
index 00000000..7d74d107
--- /dev/null
+++ b/render_test.go
@@ -0,0 +1,34 @@
+package main
+
+import (
+	"context"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/cufee/aftermath/internal/stats"
+	"github.com/rs/zerolog"
+	"github.com/stretchr/testify/assert"
+	"golang.org/x/text/language"
+)
+
+func TestRenderSession(t *testing.T) {
+	// Logger
+	level, _ := zerolog.ParseLevel(os.Getenv("LOG_LEVEL"))
+	zerolog.SetGlobalLevel(level)
+
+	loadStaticAssets(static)
+	coreClient := coreClientFromEnv()
+
+	renderer := stats.NewRenderer(coreClient.Fetch(), coreClient.Database(), coreClient.Wargaming(), language.English)
+	image, _, err := renderer.Session(context.Background(), "1013072123", time.Now())
+	assert.NoError(t, err, "failed to render a session image")
+	assert.NotNil(t, image, "image is nil")
+
+	f, err := os.Open("render_test_session.png")
+	assert.NoError(t, err, "failed to open a file")
+	defer f.Close()
+
+	err = image.PNG(f)
+	assert.NoError(t, err, "failed to encode a png image")
+}
diff --git a/static/localization/en/discord.yaml b/static/localization/en/discord.yaml
index 86c74f1e..c62ca987 100755
--- a/static/localization/en/discord.yaml
+++ b/static/localization/en/discord.yaml
@@ -135,6 +135,10 @@
   value: "Aftermath just started tracking this account. Please play a few battles before using this command again."
   context: We were not tracking this account, but successfully started tracking it just now
 
+- key: session_error_no_session_for_period
+  value: "Aftermath does not yet have a session for this period. Try changing the number of days or using `/stats` instead."
+  context: This account is being tracked, but there is no session available
+
 # /background errors
 - key: background_error_payment_required
   value: "This feature of Aftermath is only available for users with an active subscription.\nYou can subscribe by using the `/subscribe` command or pick a background using `/fancy` instead."

From f7200337636269b8d697a67ad5a9af77cd63a66a Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 16 Jun 2024 12:35:36 -0400
Subject: [PATCH 054/341] added session-specific UI

---
 go.mod                                       |   1 -
 go.sum                                       |  19 --
 internal/database/client.go                  |   6 +
 internal/stats/fetch/multisource.go          |   4 +-
 internal/stats/fetch/multisource_test.go     |  27 ---
 internal/stats/frame/value.go                |  13 +-
 internal/stats/prepare/common/card.go        |  31 ++-
 internal/stats/prepare/common/highlights.go  |   4 +-
 internal/stats/prepare/period/card.go        |  15 +-
 internal/stats/prepare/period/preset.go      |   8 +-
 internal/stats/prepare/period/tier.go        |  27 ---
 internal/stats/prepare/session/card.go       |  30 +--
 internal/stats/prepare/session/constants.go  |   4 +-
 internal/stats/render/common/constants.go    |   5 +
 internal/stats/render/common/footer.go       |   2 +-
 internal/stats/render/common/player_title.go |   4 +-
 internal/stats/render/period/constants.go    |   2 +-
 internal/stats/render/segments.go            |   2 +-
 internal/stats/render/session/cards.go       | 230 +++++++++++++++----
 internal/stats/render/session/constants.go   | 102 ++++++--
 main.go                                      |   1 +
 render_test.go                               |  12 +-
 22 files changed, 354 insertions(+), 195 deletions(-)
 delete mode 100644 internal/stats/fetch/multisource_test.go
 delete mode 100644 internal/stats/prepare/period/tier.go

diff --git a/go.mod b/go.mod
index 0232d5a1..6a0e992e 100644
--- a/go.mod
+++ b/go.mod
@@ -34,6 +34,5 @@ require (
 	github.com/robfig/cron/v3 v3.0.1 // indirect
 	go.uber.org/atomic v1.11.0 // indirect
 	golang.org/x/crypto v0.24.0 // indirect
-	golang.org/x/net v0.26.0 // indirect
 	golang.org/x/sys v0.21.0 // indirect
 )
diff --git a/go.sum b/go.sum
index 4a980a34..fb439afa 100644
--- a/go.sum
+++ b/go.sum
@@ -17,13 +17,9 @@ github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5x
 github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 h1:DACJavvAHhabrF08vX0COfcOBJRhZ8lUbR+ZWIs0Y5g=
 github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k=
 github.com/google/uuid v1.4.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/google/uuid v1.5.0 h1:1p67kYwdtXjb0gL0BPiP1Av9wiZPo5A8z2cWkTZ+eyU=
-github.com/google/uuid v1.5.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
-github.com/gorilla/websocket v1.5.1 h1:gmztn0JnHVt9JZquRuzLw3g4wouNVzKL15iLr/zn/QY=
-github.com/gorilla/websocket v1.5.1/go.mod h1:x3kM2JMyaluk02fnUJpQuwD2dCS5NDG2ZHL0uE0tcaY=
 github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
 github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
@@ -79,30 +75,19 @@ go.dedis.ch/protobuf v1.0.5/go.mod h1:eIV4wicvi6JK0q/QnfIEGeSFNG0ZeB24kzut5+HaRL
 go.dedis.ch/protobuf v1.0.7/go.mod h1:pv5ysfkDX/EawiPqcW3ikOxsL5t+BqnV6xHSmE79KI4=
 go.dedis.ch/protobuf v1.0.11 h1:FTYVIEzY/bfl37lu3pR4lIj+F9Vp1jE8oh91VmxKgLo=
 go.dedis.ch/protobuf v1.0.11/go.mod h1:97QR256dnkimeNdfmURz0wAMNVbd1VmLXhG1CrTYrJ4=
-go.uber.org/atomic v1.9.0 h1:ECmE8Bn/WFTYwEW/bpKD3M8VtR/zQVbavAoalC1PYyE=
 go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
 go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE=
 go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0=
 golang.org/x/crypto v0.0.0-20190123085648-057139ce5d2b/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
-golang.org/x/crypto v0.19.0 h1:ENy+Az/9Y1vSrlrvBSyna3PITt4tiZLf7sgCjZBX7Wo=
-golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
 golang.org/x/crypto v0.24.0 h1:mnl8DM0o513X8fdIkmyFE/5hTYxbwYOjDS/+rK6qpRI=
 golang.org/x/crypto v0.24.0/go.mod h1:Z1PMYSOR5nyMcyAVAIQSKCDwalqy85Aqn1x3Ws4L5DM=
-golang.org/x/exp v0.0.0-20240530194437-404ba88c7ed0 h1:Mi0bCswbz+9cXmwFAdxoo5GPFMKONUpua6iUdtQS7lk=
-golang.org/x/exp v0.0.0-20240530194437-404ba88c7ed0/go.mod h1:XtvwrStGgqGPLc4cjQfWqZHG1YFdYs6swckp8vpsjnc=
 golang.org/x/exp v0.0.0-20240613232115-7f521ea00fb8 h1:yixxcjnhBmY0nkL253HFVIm0JsFHwrHdT3Yh6szTnfY=
 golang.org/x/exp v0.0.0-20240613232115-7f521ea00fb8/go.mod h1:jj3sYF3dwk5D+ghuXyeI3r5MFf+NT2An6/9dOA95KSI=
 golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
-golang.org/x/image v0.16.0 h1:9kloLAKhUufZhA12l5fwnx2NZW39/we1UhBesW433jw=
-golang.org/x/image v0.16.0/go.mod h1:ugSZItdV4nOxyqp56HmXwH0Ry0nBCpjnZdpDaIHdoPs=
 golang.org/x/image v0.17.0 h1:nTRVVdajgB8zCMZVsViyzhnMKPwYeroEERRC64JuLco=
 golang.org/x/image v0.17.0/go.mod h1:4yyo5vMFQjVjUcVk4jEQcU9MGy/rulF5WvUILseCM2E=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
-golang.org/x/net v0.21.0 h1:AQyQV4dYCvJ7vGmJyKki9+PBdyvhkSd8EIx/qb0AYv4=
-golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
-golang.org/x/net v0.26.0 h1:soB7SVo0PWrY4vPW/+ay0jKDNScG2X9wFeYlXIvJsOQ=
-golang.org/x/net v0.26.0/go.mod h1:5YKkiSynbBIh3p6iOc/vibscux0x38BZDkn8sCUPxHE=
 golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
 golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20190124100055-b90733256f2e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
@@ -110,15 +95,11 @@ golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.17.0 h1:25cE3gD+tdBA7lp7QfhuV+rJiE9YXTcS3VG1SqssI/Y=
-golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.21.0 h1:rF+pYz3DAGSQAxAu1CbC7catZg4ebC4UIeIhKxBZvws=
 golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.15.0 h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk=
-golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
 golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
diff --git a/internal/database/client.go b/internal/database/client.go
index f8b63e7c..464988ce 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -70,6 +70,8 @@ type Client interface {
 	TasksClient
 
 	DiscordDataClient
+
+	Disconnect() error
 }
 
 type client struct {
@@ -79,6 +81,10 @@ type client struct {
 	tasksUpdateSem *semaphore.Weighted
 }
 
+func (c *client) Disconnect() error {
+	return c.prisma.Disconnect()
+}
+
 func (c *client) Prisma() *db.PrismaClient {
 	return c.prisma
 }
diff --git a/internal/stats/fetch/multisource.go b/internal/stats/fetch/multisource.go
index f01ab0be..ddb62321 100644
--- a/internal/stats/fetch/multisource.go
+++ b/internal/stats/fetch/multisource.go
@@ -337,7 +337,7 @@ func (c *multiSourceClient) SessionStats(ctx context.Context, id string, session
 
 	session := current.Data
 	session.PeriodEnd = time.Now()
-	session.PeriodStart = sessionStart
+	session.PeriodStart = accountSnapshot.Data.LastBattleTime
 	session.RatingBattles.StatsFrame.Subtract(accountSnapshot.Data.RatingBattles)
 	session.RegularBattles.StatsFrame.Subtract(accountSnapshot.Data.RegularBattles)
 	session.RegularBattles.Vehicles = make(map[string]frame.VehicleStatsFrame, len(current.Data.RegularBattles.Vehicles))
@@ -347,7 +347,7 @@ func (c *multiSourceClient) SessionStats(ctx context.Context, id string, session
 		Account:        current.Data.Account,
 		LastBattleTime: accountSnapshot.Data.LastBattleTime,
 		PeriodStart:    current.Data.Account.CreatedAt,
-		PeriodEnd:      sessionStart,
+		PeriodEnd:      accountSnapshot.Data.LastBattleTime,
 	}
 	career.Account.LastBattleTime = accountSnapshot.Data.LastBattleTime
 	career.RatingBattles.StatsFrame = accountSnapshot.Data.RatingBattles
diff --git a/internal/stats/fetch/multisource_test.go b/internal/stats/fetch/multisource_test.go
deleted file mode 100644
index b3718416..00000000
--- a/internal/stats/fetch/multisource_test.go
+++ /dev/null
@@ -1,27 +0,0 @@
-package fetch
-
-import (
-	"context"
-	"testing"
-	"time"
-
-	"github.com/cufee/aftermath/internal/database"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestSessionStats(t *testing.T) {
-	db, err := database.NewClient()
-	assert.NoError(t, err, "failed to create a database client")
-	defer db.Prisma().Disconnect()
-
-	ctx, cancel := context.WithTimeout(context.Background(), time.Second*15)
-	defer cancel()
-
-	sessionStartTime := time.Date(2023, 6, 1, 0, 0, 0, 0, time.UTC)
-
-	client := &multiSourceClient{database: db}
-	stats, err := client.SessionStats(ctx, "", sessionStartTime.Add(time.Hour*-1))
-	assert.NoError(t, err, "failed to get session stats")
-
-	_ = stats
-}
diff --git a/internal/stats/frame/value.go b/internal/stats/frame/value.go
index 6b15afbe..c5e136e1 100644
--- a/internal/stats/frame/value.go
+++ b/internal/stats/frame/value.go
@@ -54,15 +54,18 @@ var InvalidValue = valueInvalid{}
 
 type ValueSpecialRating float32
 
-func (value ValueSpecialRating) int() uint32 {
-	if value <= 0 {
-		return uint32(InvalidValue.Float())
+func (value ValueSpecialRating) int() int {
+	if value >= 0 {
+		return int((value * 10) + 3000)
 	}
-	return uint32((value * 10) + 3000)
+	return int(InvalidValue.Float())
 }
 
 func (value ValueSpecialRating) String() string {
-	return fmt.Sprintf("%d", int(value.int()))
+	if value > 1 {
+		return fmt.Sprintf("%d", value.int())
+	}
+	return InvalidValue.String()
 }
 
 func (value ValueSpecialRating) Float() float32 {
diff --git a/internal/stats/prepare/common/card.go b/internal/stats/prepare/common/card.go
index f9826112..38eb4b89 100644
--- a/internal/stats/prepare/common/card.go
+++ b/internal/stats/prepare/common/card.go
@@ -3,6 +3,7 @@ package common
 import (
 	"github.com/pkg/errors"
 
+	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/stats/frame"
 )
 
@@ -39,7 +40,7 @@ func (block *StatsBlock[D]) Localize(printer func(string) string) {
 }
 
 func (block *StatsBlock[D]) FillValue(stats frame.StatsFrame, args ...any) error {
-	value, err := PresetValue(block.Tag, stats)
+	value, err := PresetValue(block.Tag, stats, args...)
 	if err != nil {
 		return err
 	}
@@ -73,9 +74,21 @@ func PresetValue(preset Tag, stats frame.StatsFrame, args ...any) (frame.Value,
 		return stats.DamageDealt, nil
 	case TagDamageTaken:
 		return stats.DamageReceived, nil
+	case TagAvgTier:
+		if len(args) != 2 {
+			return frame.InvalidValue, errors.New("invalid args length for avg_tier")
+		}
+		vehicles, ok := args[0].(map[string]frame.VehicleStatsFrame)
+		if !ok {
+			return frame.InvalidValue, errors.New("invalid args for avg_tier, first arg should be vehicles")
+		}
+		glossary, ok := args[1].(map[string]database.Vehicle)
+		if !ok {
+			return frame.InvalidValue, errors.New("invalid args for avg_tier, second arg should be glossary")
+		}
+		return avgTierValue(vehicles, glossary), nil
 
 	// Some tags cannot be parsed here and should be implemented by the package
-	// TagAvgTier - period
 	// TagDamageBlocked - replay
 	// TagDamageAssisted - replay
 	// TagDamageAssistedCombined - replay
@@ -83,3 +96,17 @@ func PresetValue(preset Tag, stats frame.StatsFrame, args ...any) (frame.Value,
 		return frame.InvalidValue, errors.New("invalid preset " + preset.String())
 	}
 }
+
+func avgTierValue(vehicles map[string]frame.VehicleStatsFrame, glossary map[string]database.Vehicle) frame.Value {
+	var weightedTotal, battlesTotal float32
+	for _, vehicle := range vehicles {
+		if data, ok := glossary[vehicle.VehicleID]; ok && data.Tier > 0 {
+			battlesTotal += vehicle.Battles.Float()
+			weightedTotal += vehicle.Battles.Float() * float32(data.Tier)
+		}
+	}
+	if battlesTotal == 0 {
+		return frame.InvalidValue
+	}
+	return frame.ValueFloatDecimal(weightedTotal / battlesTotal)
+}
diff --git a/internal/stats/prepare/common/highlights.go b/internal/stats/prepare/common/highlights.go
index 451aad56..151879a3 100644
--- a/internal/stats/prepare/common/highlights.go
+++ b/internal/stats/prepare/common/highlights.go
@@ -11,9 +11,9 @@ type Highlight struct {
 }
 
 var (
-	HighlightAvgDamage = Highlight{TagAvgDamage, []Tag{TagBattles, TagAvgDamage,TagWN8}, "label_highlight_avg_damage"}
+	HighlightAvgDamage = Highlight{TagAvgDamage, []Tag{TagBattles, TagAvgDamage, TagWN8}, "label_highlight_avg_damage"}
 	HighlightBattles   = Highlight{TagBattles, []Tag{TagBattles, TagAvgDamage, TagWN8}, "label_highlight_battles"}
-	HighlightWN8       = Highlight{TagWN8, []Tag{TagBattles, TagAvgDamage,TagWN8}, "label_highlight_wn8"}
+	HighlightWN8       = Highlight{TagWN8, []Tag{TagBattles, TagAvgDamage, TagWN8}, "label_highlight_wn8"}
 )
 
 type highlightedVehicle struct {
diff --git a/internal/stats/prepare/period/card.go b/internal/stats/prepare/period/card.go
index 65488820..d8511cb1 100644
--- a/internal/stats/prepare/period/card.go
+++ b/internal/stats/prepare/period/card.go
@@ -25,15 +25,12 @@ func NewCards(stats fetch.AccountStatsOverPeriod, glossary map[string]database.V
 		var columnBlocks []common.StatsBlock[BlockData]
 		for _, preset := range column {
 			var block common.StatsBlock[BlockData]
-			if preset == TagAvgTier {
-				block = avgTierBlock(stats.RegularBattles.Vehicles, glossary)
-			} else {
-				b, err := presetToBlock(preset, stats.RegularBattles.StatsFrame)
-				if err != nil {
-					return Cards{}, err
-				}
-				block = b
+			b, err := presetToBlock(preset, stats.RegularBattles.StatsFrame, stats.RegularBattles.Vehicles, glossary)
+			if err != nil {
+				return Cards{}, err
 			}
+			block = b
+
 			block.Localize(options.Printer())
 			columnBlocks = append(columnBlocks, block)
 		}
@@ -73,7 +70,7 @@ func NewCards(stats fetch.AccountStatsOverPeriod, glossary map[string]database.V
 		var vehicleBlocks []common.StatsBlock[BlockData]
 
 		for _, preset := range data.Highlight.Blocks {
-			block, err := presetToBlock(preset, *data.Vehicle.StatsFrame)
+			block, err := presetToBlock(preset, *data.Vehicle.StatsFrame, nil, nil)
 			if err != nil {
 				return Cards{}, err
 			}
diff --git a/internal/stats/prepare/period/preset.go b/internal/stats/prepare/period/preset.go
index 2251369b..3a64bbc6 100644
--- a/internal/stats/prepare/period/preset.go
+++ b/internal/stats/prepare/period/preset.go
@@ -1,11 +1,12 @@
 package period
 
 import (
+	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/stats/frame"
 	"github.com/cufee/aftermath/internal/stats/prepare/common"
 )
 
-func presetToBlock(preset common.Tag, stats frame.StatsFrame) (common.StatsBlock[BlockData], error) {
+func presetToBlock(preset common.Tag, stats frame.StatsFrame, vehicles map[string]frame.VehicleStatsFrame, glossary map[string]database.Vehicle) (common.StatsBlock[BlockData], error) {
 	block := common.StatsBlock[BlockData](common.NewBlock(preset, BlockData{}))
 
 	switch preset {
@@ -18,6 +19,11 @@ func presetToBlock(preset common.Tag, stats frame.StatsFrame) (common.StatsBlock
 	case common.TagSurvivalRatio:
 		block.Data.Flavor = BlockFlavorSecondary
 
+	case common.TagAvgTier:
+		block.Data.Flavor = BlockFlavorSecondary
+		err := block.FillValue(frame.StatsFrame{}, vehicles, glossary)
+		return block, err
+
 	case common.TagSurvivalPercent:
 		block.Data.Flavor = BlockFlavorSecondary
 
diff --git a/internal/stats/prepare/period/tier.go b/internal/stats/prepare/period/tier.go
deleted file mode 100644
index 5b085788..00000000
--- a/internal/stats/prepare/period/tier.go
+++ /dev/null
@@ -1,27 +0,0 @@
-package period
-
-import (
-	"github.com/cufee/aftermath/internal/database"
-	"github.com/cufee/aftermath/internal/stats/frame"
-	"github.com/cufee/aftermath/internal/stats/prepare/common"
-)
-
-func avgTierBlock(vehicles map[string]frame.VehicleStatsFrame, glossary map[string]database.Vehicle) common.StatsBlock[BlockData] {
-	block := common.StatsBlock[BlockData](common.NewBlock(common.TagAvgTier, BlockData{Flavor: BlockFlavorSecondary}))
-
-	var weightedTotal, battlesTotal float32
-
-	for _, vehicle := range vehicles {
-		if data, ok := glossary[vehicle.VehicleID]; ok && data.Tier > 0 {
-			battlesTotal += vehicle.Battles.Float()
-			weightedTotal += vehicle.Battles.Float() * float32(data.Tier)
-		}
-	}
-	if battlesTotal == 0 {
-		block.Value = frame.InvalidValue
-		return block
-	}
-
-	block.Value = frame.ValueFloatDecimal(weightedTotal / battlesTotal)
-	return block
-}
diff --git a/internal/stats/prepare/session/card.go b/internal/stats/prepare/session/card.go
index 81d3bd45..c2f80ffb 100644
--- a/internal/stats/prepare/session/card.go
+++ b/internal/stats/prepare/session/card.go
@@ -1,8 +1,6 @@
 package session
 
 import (
-	"fmt"
-
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/stats/fetch"
 	"github.com/cufee/aftermath/internal/stats/frame"
@@ -45,8 +43,8 @@ func NewCards(session, career fetch.AccountStatsOverPeriod, glossary map[string]
 	if session.RegularBattles.Battles > 0 {
 		card, err := makeOverviewCard(
 			unratedOverviewBlocks,
-			session.RatingBattles.StatsFrame,
-			career.RatingBattles.StatsFrame,
+			session.RegularBattles.StatsFrame,
+			career.RegularBattles.StatsFrame,
 			"label_overview_unrated",
 			options.Printer(),
 			nil,
@@ -59,19 +57,14 @@ func NewCards(session, career fetch.AccountStatsOverPeriod, glossary map[string]
 
 	// Rating battles vehicles
 	for id, data := range session.RatingBattles.Vehicles {
-		var careerFrame frame.StatsFrame
-		if frame, ok := career.RatingBattles.Vehicles[id]; ok {
-			careerFrame = *frame.StatsFrame
-		}
-
 		glossary := glossary[id]
 		glossary.ID = id
 
 		card, err := makeVehicleCard(
 			[]common.Tag{common.TagWN8},
 			common.CardTypeRatingVehicle,
-			*data.StatsFrame,
-			careerFrame,
+			data,
+			career.RatingBattles.Vehicles[id],
 			options.Printer(),
 			options.Locale(),
 			glossary,
@@ -83,18 +76,14 @@ func NewCards(session, career fetch.AccountStatsOverPeriod, glossary map[string]
 	}
 	// Regular battles vehicles
 	for id, data := range session.RegularBattles.Vehicles {
-		var careerFrame frame.StatsFrame
-		if frame, ok := career.RegularBattles.Vehicles[id]; ok {
-			careerFrame = *frame.StatsFrame
-		}
 		glossary := glossary[id]
 		glossary.ID = id
 
 		card, err := makeVehicleCard(
 			vehicleBlocks,
 			common.CardTypeVehicle,
-			*data.StatsFrame,
-			careerFrame,
+			data,
+			career.RegularBattles.Vehicles[id],
 			options.Printer(),
 			options.Locale(),
 			glossary,
@@ -108,10 +97,10 @@ func NewCards(session, career fetch.AccountStatsOverPeriod, glossary map[string]
 	return cards, nil
 }
 
-func makeVehicleCard(presets []common.Tag, cardType common.CardType, session, career frame.StatsFrame, printer func(string) string, locale language.Tag, glossary database.Vehicle) (VehicleCard, error) {
+func makeVehicleCard(presets []common.Tag, cardType common.CardType, session, career frame.VehicleStatsFrame, printer func(string) string, locale language.Tag, glossary database.Vehicle) (VehicleCard, error) {
 	var blocks []common.StatsBlock[BlockData]
 	for _, preset := range presets {
-		block, err := presetToBlock(preset, session, career)
+		block, err := presetToBlock(preset, *session.StatsFrame, *career.StatsFrame)
 		if err != nil {
 			return VehicleCard{}, err
 		}
@@ -120,7 +109,8 @@ func makeVehicleCard(presets []common.Tag, cardType common.CardType, session, ca
 	}
 
 	return VehicleCard{
-		Title:  fmt.Sprintf("%s %s", common.IntToRoman(glossary.Tier), glossary.Name(locale)),
+		Meta:   common.IntToRoman(glossary.Tier),
+		Title:  glossary.Name(locale),
 		Type:   cardType,
 		Blocks: blocks,
 	}, nil
diff --git a/internal/stats/prepare/session/constants.go b/internal/stats/prepare/session/constants.go
index c49fa6b2..4c3e404b 100644
--- a/internal/stats/prepare/session/constants.go
+++ b/internal/stats/prepare/session/constants.go
@@ -5,8 +5,8 @@ import (
 	"github.com/cufee/aftermath/internal/stats/prepare/common"
 )
 
-var unratedOverviewBlocks = [][]common.Tag{{common.TagBattles, common.TagAvgDamage}, {common.TagWinrate, common.TagDamageRatio}, {common.TagWN8}}
-var ratingOverviewBlocks = [][]common.Tag{{common.TagBattles, common.TagAvgDamage}, {common.TagWinrate, common.TagDamageRatio}, {common.TagRankedRating}}
+var unratedOverviewBlocks = [][]common.Tag{{common.TagBattles, common.TagWinrate}, {common.TagWN8}, {common.TagAvgDamage, common.TagDamageRatio}}
+var ratingOverviewBlocks = [][]common.Tag{{common.TagBattles, common.TagWinrate}, {common.TagRankedRating}, {common.TagAvgDamage, common.TagDamageRatio}}
 var vehicleBlocks = []common.Tag{common.TagBattles, common.TagAvgDamage, common.TagDamageRatio, common.TagWinrate, common.TagWN8}
 var highlights = []common.Highlight{common.HighlightBattles, common.HighlightWN8, common.HighlightAvgDamage}
 
diff --git a/internal/stats/render/common/constants.go b/internal/stats/render/common/constants.go
index 05e81b19..e637e251 100644
--- a/internal/stats/render/common/constants.go
+++ b/internal/stats/render/common/constants.go
@@ -30,6 +30,11 @@ var (
 
 	ColorAftermathRed  = color.RGBA{255, 0, 120, 255}
 	ColorAftermathBlue = color.RGBA{90, 90, 255, 255}
+
+	BorderRadiusLG = 25.0
+	BorderRadiusMD = 20.0
+	BorderRadiusSM = 15.0
+	BorderRadiusXS = 10.0
 )
 
 var fontCache map[float64]font.Face
diff --git a/internal/stats/render/common/footer.go b/internal/stats/render/common/footer.go
index 53055e89..99051184 100644
--- a/internal/stats/render/common/footer.go
+++ b/internal/stats/render/common/footer.go
@@ -10,7 +10,7 @@ func NewFooterCard(text string) Block {
 		PaddingX:        12.5,
 		PaddingY:        5,
 		BackgroundColor: backgroundColor,
-		BorderRadius:    15,
+		BorderRadius:    BorderRadiusSM,
 		// Debug:           true,
 	}, NewTextContent(Style{Font: &FontSmall, FontColor: TextSecondary}, text))
 }
diff --git a/internal/stats/render/common/player_title.go b/internal/stats/render/common/player_title.go
index 1160b8a2..d77c6a07 100644
--- a/internal/stats/render/common/player_title.go
+++ b/internal/stats/render/common/player_title.go
@@ -14,7 +14,7 @@ type TitleCardStyle struct {
 }
 
 func (style TitleCardStyle) TotalPaddingAndGaps() float64 {
-	return style.Container.PaddingX*2 + style.Container.Gap*2 + style.Nickname.PaddingX*2 + style.ClanTag.PaddingX*2
+	return style.Container.PaddingX*2 + style.Container.Gap*2 + style.Nickname.PaddingX*2 + style.ClanTag.PaddingX*4
 }
 
 func DefaultPlayerTitleStyle(containerStyle Style) TitleCardStyle {
@@ -30,7 +30,7 @@ func DefaultPlayerTitleStyle(containerStyle Style) TitleCardStyle {
 	return TitleCardStyle{
 		Container: containerStyle,
 		Nickname:  Style{Font: &FontLarge, FontColor: TextPrimary},
-		ClanTag:   Style{Font: &FontMedium, FontColor: TextSecondary, PaddingX: 10, PaddingY: 5, BackgroundColor: clanTagBackgroundColor, BorderRadius: 15},
+		ClanTag:   Style{Font: &FontMedium, FontColor: TextSecondary, PaddingX: 10, PaddingY: 5, BackgroundColor: clanTagBackgroundColor, BorderRadius: BorderRadiusSM},
 	}
 }
 
diff --git a/internal/stats/render/period/constants.go b/internal/stats/render/period/constants.go
index cc9f101f..74837a58 100644
--- a/internal/stats/render/period/constants.go
+++ b/internal/stats/render/period/constants.go
@@ -52,7 +52,7 @@ func defaultCardStyle(width float64) common.Style {
 		AlignItems:      common.AlignItemsCenter,
 		Direction:       common.DirectionVertical,
 		BackgroundColor: common.DefaultCardColor,
-		BorderRadius:    25,
+		BorderRadius:    common.BorderRadiusLG,
 		PaddingY:        10,
 		PaddingX:        20,
 		Gap:             20,
diff --git a/internal/stats/render/segments.go b/internal/stats/render/segments.go
index e3135c50..222d8eaf 100644
--- a/internal/stats/render/segments.go
+++ b/internal/stats/render/segments.go
@@ -74,7 +74,7 @@ func (s *Segments) Render(opts ...Option) (image.Image, error) {
 		common.Style{
 			Direction:  common.DirectionVertical,
 			AlignItems: common.AlignItemsCenter,
-			Gap:        10,
+			Gap:        5,
 		},
 		frameParts...,
 	)
diff --git a/internal/stats/render/session/cards.go b/internal/stats/render/session/cards.go
index b41a141d..97db342c 100644
--- a/internal/stats/render/session/cards.go
+++ b/internal/stats/render/session/cards.go
@@ -5,6 +5,7 @@ import (
 
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/stats/fetch"
+	prepare "github.com/cufee/aftermath/internal/stats/prepare/common"
 	"github.com/cufee/aftermath/internal/stats/prepare/session"
 	"github.com/cufee/aftermath/internal/stats/render/common"
 
@@ -40,18 +41,23 @@ func cardsToSegments(session, career fetch.AccountStatsOverPeriod, cards session
 
 	// unrated overview - show if there are no rating battles (so the card is not empty), or there are battles
 	if session.RegularBattles.Battles > 0 || session.RatingBattles.Battles == 0 {
-		//
+		for _, column := range cards.Unrated.Overview.Blocks {
+			presetBlockWidth, _ := overviewColumnBlocksWidth(column, overviewStatsBlockStyle.session, overviewStatsBlockStyle.career, overviewStatsBlockStyle.label, overviewColumnStyle(0))
+			for key, width := range presetBlockWidth {
+				primaryCardBlockSizes[key] = common.Max(primaryCardBlockSizes[key], width)
+			}
+		}
 	}
 	// rating overview
 	if session.RatingBattles.Battles > 0 {
 		//
 	}
-	// rating vehicle cards go on the primary block - only show if there are no highlights
-	if len(cards.Unrated.Highlights) == 0 {
+	// rating vehicle cards go on the primary block - only show if there are no unrated battles/vehicles
+	if len(cards.Unrated.Vehicles) == 0 {
 		for _, card := range cards.Rating.Vehicles {
 			// [title]	[session]
 			titleSize := common.MeasureString(card.Title, *ratingVehicleCardTitleStyle.Font)
-			presetBlockWidth, contentWidth := vehicleBlocksWidth(card, ratingVehicleBlockStyle.session, ratingVehicleBlockStyle.career, ratingVehicleBlockStyle.label, ratingVehicleBlockStyle.container)
+			presetBlockWidth, contentWidth := vehicleBlocksWidth(card.Blocks, ratingVehicleBlockStyle.session, ratingVehicleBlockStyle.career, ratingVehicleBlockStyle.label, ratingVehicleBlocksRowStyle(0))
 			// add the gap and card padding, the gap here accounts for title being inline with content
 			contentWidth += ratingVehicleBlocksRowStyle(0).Gap*float64(len(card.Blocks)) + ratingVehicleCardStyle(0).PaddingX*2 + titleSize.TotalWidth
 
@@ -62,13 +68,13 @@ func cardsToSegments(session, career fetch.AccountStatsOverPeriod, cards session
 		}
 	}
 	// highlighted vehicles go on the primary block
-	{
+	if len(cards.Unrated.Highlights) > len(cards.Unrated.Vehicles) {
 		for _, card := range cards.Unrated.Highlights {
 			// [card label]	[session]
 			// [title]  	 [label]
 			labelSize := common.MeasureString(card.Meta, *vehicleCardTitleStyle.Font)
 			titleSize := common.MeasureString(card.Title, *vehicleCardTitleStyle.Font)
-			presetBlockWidth, contentWidth := vehicleBlocksWidth(card, vehicleBlockStyle.session, vehicleBlockStyle.career, vehicleBlockStyle.label, vehicleBlockStyle.container)
+			presetBlockWidth, contentWidth := vehicleBlocksWidth(card.Blocks, vehicleBlockStyle.session, vehicleBlockStyle.career, vehicleBlockStyle.label, vehicleBlocksRowStyle(0))
 			// add the gap and card padding, the gap here accounts for title/label being inline with content
 			contentWidth += vehicleBlocksRowStyle(0).Gap*float64(len(card.Blocks)) + highlightCardStyle(0).PaddingX*2 + common.Max(titleSize.TotalWidth, labelSize.TotalWidth)
 			primaryCardWidth = common.Max(primaryCardWidth, contentWidth)
@@ -84,7 +90,7 @@ func cardsToSegments(session, career fetch.AccountStatsOverPeriod, cards session
 			// [session]
 			// [career ]
 			// [label  ] ...
-			presetBlockWidth, contentWidth := vehicleBlocksWidth(card, vehicleBlockStyle.session, vehicleBlockStyle.career, vehicleBlockStyle.label, vehicleBlockStyle.container)
+			presetBlockWidth, contentWidth := vehicleBlocksWidth(card.Blocks, vehicleBlockStyle.session, vehicleBlockStyle.career, vehicleBlockStyle.label, vehicleBlocksRowStyle(0))
 			contentWidth += vehicleBlocksRowStyle(0).Gap*float64(len(card.Blocks)-1) + vehicleCardStyle(0).PaddingX*2
 
 			titleSize := common.MeasureString(card.Title, *vehicleCardTitleStyle.Font)
@@ -102,56 +108,44 @@ func cardsToSegments(session, career fetch.AccountStatsOverPeriod, cards session
 	}
 	totalFrameWidth = common.Max(totalFrameWidth, frameWidth)
 
-	// Header card
+	// header card
 	if headerCard, headerCardExists := common.NewHeaderCard(totalFrameWidth, subs, opts.PromoText); headerCardExists {
 		segments.AddHeader(headerCard)
 	}
 
-	// // User Subscription Badge and promo text
-	// if addPromoText && opts.PromoText != nil {
-	// 	// Users without a subscription get promo text
-	// 	var textBlocks []common.Block
-	// 	for _, text := range opts.PromoText {
-	// 		textBlocks = append(textBlocks, render.NewTextContent(promoTextStyle, text))
-	// 	}
-	// 	cards = append(cards, common.NewBlocksContent(render.Style{
-	// 		Direction:  render.DirectionVertical,
-	// 		AlignItems: render.AlignItemsCenter,
-	// 	},
-	// 		textBlocks...,
-	// 	))
-	// }
-	// if badges, _ := badges.SubscriptionsBadges(player.Subscriptions); len(badges) > 0 {
-	// 	cards = append(cards, render.NewBlocksContent(render.Style{Direction: render.DirectionHorizontal, AlignItems: render.AlignItemsCenter, Gap: 10},
-	// 		badges...,
-	// 	))
-	// }
-
+	// player title
 	primaryColumn = append(primaryColumn,
 		common.NewPlayerTitleCard(common.DefaultPlayerTitleStyle(playerNameCardStyle(primaryCardWidth)), session.Account.Nickname, session.Account.ClanTag, subs),
 	)
 
-	// // Rating Cards
-	// if len(player.Cards.Rating) > 0 {
-	// 	ratingGroup, err := makeCardsGroup(player.Cards.Rating, cardWidth, cardBlockSizes)
-	// 	if err != nil {
-	// 		return nil, err
-	// 	}
-	// 	cards = append(cards, ratingGroup)
-	// }
-
-	// // Unrated Cards
-	// if len(player.Cards.Unrated) > 0 {
-	// 	unratedGroup, err := makeCardsGroup(player.Cards.Unrated, cardWidth, cardBlockSizes)
-	// 	if err != nil {
-	// 		return nil, err
-	// 	}
-	// 	cards = append(cards, unratedGroup)
-	// }
-
-	columns := []common.Block{common.NewBlocksContent(columnStyle(primaryCardWidth), primaryColumn...)}
+	// overview cards
+	if len(cards.Unrated.Overview.Blocks) > 0 {
+		primaryColumn = append(primaryColumn, makeOverviewCard(cards.Unrated.Overview, primaryCardBlockSizes, primaryCardWidth))
+	}
+	if len(cards.Rating.Overview.Blocks) > 0 {
+		primaryColumn = append(primaryColumn, makeOverviewCard(cards.Rating.Overview, primaryCardBlockSizes, primaryCardWidth))
+	}
+
+	// highlights
+	if len(cards.Unrated.Highlights) > len(cards.Unrated.Vehicles) {
+		//
+	}
+	// rating vehicle cards
+	if len(cards.Unrated.Vehicles) == 0 {
+		//
+	}
+
+	// unrated vehicles
+	for i, vehicle := range cards.Unrated.Vehicles {
+		if i == 0 {
+			secondaryColumn = append(secondaryColumn, makeVehicleLegendCard(cards.Unrated.Vehicles[0], secondaryCardBlockSizes, secondaryCardWidth))
+		}
+		secondaryColumn = append(secondaryColumn, makeVehicleCard(vehicle, secondaryCardBlockSizes, secondaryCardWidth))
+	}
+
+	columns := []common.Block{common.NewBlocksContent(overviewColumnStyle(primaryCardWidth), primaryColumn...)}
 	if len(secondaryColumn) > 0 {
-		columns = append(columns, common.NewBlocksContent(columnStyle(secondaryCardWidth), secondaryColumn...))
+		columns = append(columns, common.NewBlocksContent(overviewColumnStyle(secondaryCardWidth), secondaryColumn...))
 	}
 	segments.AddContent(common.NewBlocksContent(frameStyle(), columns...))
 
@@ -181,10 +175,10 @@ func cardsToSegments(session, career fetch.AccountStatsOverPeriod, cards session
 	return segments, nil
 }
 
-func vehicleBlocksWidth(card session.VehicleCard, sessionStyle, careerStyle, labelStyle, containerStyle common.Style) (map[string]float64, float64) {
+func vehicleBlocksWidth(blocks []prepare.StatsBlock[session.BlockData], sessionStyle, careerStyle, labelStyle, containerStyle common.Style) (map[string]float64, float64) {
 	presetBlockWidth := make(map[string]float64)
 	var contentWidth, maxBlockWidth float64
-	for _, block := range card.Blocks {
+	for _, block := range blocks {
 		var width float64
 		{
 			size := common.MeasureString(block.Data.Session.String(), *sessionStyle.Font)
@@ -213,3 +207,139 @@ func vehicleBlocksWidth(card session.VehicleCard, sessionStyle, careerStyle, lab
 
 	return presetBlockWidth, contentWidth
 }
+
+func overviewColumnBlocksWidth(blocks []prepare.StatsBlock[session.BlockData], sessionStyle, careerStyle, labelStyle, containerStyle common.Style) (map[string]float64, float64) {
+	presetBlockWidth, contentWidth := vehicleBlocksWidth(blocks, sessionStyle, careerStyle, labelStyle, containerStyle)
+	for _, block := range blocks {
+		// adjust width if this column includes a special icon
+		if block.Tag == prepare.TagWN8 || block.Tag == prepare.TagRankedRating {
+			tierNameSize := common.MeasureString(common.GetWN8TierName(block.Value.Float()), *overviewSpecialRatingLabelStyle(nil).Font)
+			tierNameWithPadding := tierNameSize.TotalWidth + overviewSpecialRatingPillStyle(nil).PaddingX*2
+			presetBlockWidth[block.Tag.String()] = common.Max(presetBlockWidth[block.Tag.String()], specialRatingIconSize, tierNameWithPadding)
+		}
+	}
+	return presetBlockWidth, contentWidth
+}
+
+func makeVehicleCard(vehicle session.VehicleCard, blockSizes map[string]float64, cardWidth float64) common.Block {
+	var content []common.Block
+	for _, block := range vehicle.Blocks {
+		content = append(content,
+			common.NewBlocksContent(statsBlockStyle(blockSizes[block.Tag.String()]),
+				common.NewTextContent(vehicleBlockStyle.session, block.Data.Session.String()),
+				common.NewTextContent(vehicleBlockStyle.career, block.Data.Career.String()),
+			),
+		)
+	}
+	return common.NewBlocksContent(vehicleCardStyle(cardWidth),
+		common.NewBlocksContent(vehicleCardTitleContainerStyle(cardWidth),
+			common.NewTextContent(vehicleCardTitleStyle, vehicle.Title), // vehicle name
+			common.NewTextContent(vehicleCardTitleStyle, vehicle.Meta),  // tier
+		),
+		common.NewBlocksContent(vehicleBlocksRowStyle(0), content...),
+	)
+}
+
+func makeVehicleLegendCard(reference session.VehicleCard, blockSizes map[string]float64, cardWidth float64) common.Block {
+	var content []common.Block
+	for _, block := range reference.Blocks {
+		style := statsBlockStyle(blockSizes[block.Tag.String()])
+		style.BackgroundColor = common.DefaultCardColor
+		style.BorderRadius = common.BorderRadiusSM
+		style.PaddingY = 5
+		content = append(content,
+			common.NewBlocksContent(style,
+				common.NewTextContent(vehicleBlockStyle.label, block.Label),
+			),
+		)
+	}
+	style := vehicleCardStyle(cardWidth)
+	style.BackgroundColor = nil
+	style.PaddingY = 0
+	style.PaddingX = 0
+	return common.NewBlocksContent(style, common.NewBlocksContent(vehicleBlocksRowStyle(0), content...))
+}
+
+func makeOverviewCard(card session.OverviewCard, blockSizes map[string]float64, cardWidth float64) common.Block {
+	var content []common.Block
+	for _, column := range card.Blocks {
+		var columnContent []common.Block
+		for _, block := range column {
+			var col common.Block
+			if block.Tag == prepare.TagWN8 || block.Tag == prepare.TagRankedRating {
+				col = makeSpecialRatingColumn(block, blockSizes[block.Tag.String()])
+			} else {
+				col = common.NewBlocksContent(statsBlockStyle(blockSizes[block.Tag.String()]),
+					common.NewTextContent(vehicleBlockStyle.session, block.Data.Session.String()),
+					// common.NewTextContent(vehicleBlockStyle.career, block.Data.Career.String()),
+					common.NewTextContent(vehicleBlockStyle.label, block.Label),
+				)
+			}
+			columnContent = append(columnContent, col)
+		}
+		content = append(content, common.NewBlocksContent(overviewColumnStyle(0), columnContent...))
+	}
+	return common.NewBlocksContent(overviewCardStyle(cardWidth), content...)
+}
+
+func makeSpecialRatingColumn(block prepare.StatsBlock[session.BlockData], width float64) common.Block {
+	switch block.Tag {
+	case prepare.TagWN8:
+		ratingColors := common.GetWN8Colors(block.Value.Float())
+		if block.Value.Float() <= 0 {
+			ratingColors.Content = common.TextAlt
+			ratingColors.Background = common.TextAlt
+		}
+
+		var column []common.Block
+		iconTop := common.AftermathLogo(ratingColors.Background, common.DefaultLogoOptions())
+		column = append(column, common.NewImageContent(common.Style{Width: specialRatingIconSize, Height: specialRatingIconSize}, iconTop))
+
+		column = append(column, common.NewBlocksContent(overviewColumnStyle(width),
+			common.NewTextContent(vehicleBlockStyle.session, block.Data.Session.String()),
+			common.NewBlocksContent(
+				overviewSpecialRatingPillStyle(ratingColors.Background),
+				common.NewTextContent(overviewSpecialRatingLabelStyle(ratingColors.Content), common.GetWN8TierName(block.Value.Float())),
+			),
+		))
+		return common.NewBlocksContent(specialRatingColumnStyle, column...)
+
+	default:
+		return common.NewBlocksContent(statsBlockStyle(width),
+			common.NewTextContent(vehicleBlockStyle.session, block.Data.Session.String()),
+			// common.NewTextContent(vehicleBlockStyle.career, block.Data.Career.String()),
+			common.NewTextContent(vehicleBlockStyle.label, block.Label),
+		)
+	}
+}
+
+// func uniqueBlockWN8(stats prepare.StatsBlock[period.BlockData]) common.Block {
+// 	var blocks []common.Block
+
+// 	valueStyle, labelStyle := style.block(stats)
+// 	valueBlock := common.NewTextContent(valueStyle, stats.Value.String())
+
+// 	ratingColors := common.GetWN8Colors(stats.Value.Float())
+// 	if stats.Value.Float() <= 0 {
+// 		ratingColors.Content = common.TextAlt
+// 		ratingColors.Background = common.TextAlt
+// 	}
+
+// 	iconTop := common.AftermathLogo(ratingColors.Background, common.DefaultLogoOptions())
+// 	iconBlockTop := common.NewImageContent(common.Style{Width: float64(iconTop.Bounds().Dx()), Height: float64(iconTop.Bounds().Dy())}, iconTop)
+
+// 	style.blockContainer.Gap = 10
+// 	blocks = append(blocks, common.NewBlocksContent(style.blockContainer, iconBlockTop, valueBlock))
+
+// 	if stats.Value.Float() >= 0 {
+// 		labelStyle.FontColor = ratingColors.Content
+// 		blocks = append(blocks, common.NewBlocksContent(common.Style{
+// 			PaddingY:        5,
+// 			PaddingX:        10,
+// 			BorderRadius:    15,
+// 			BackgroundColor: ratingColors.Background,
+// 		}, common.NewTextContent(labelStyle, common.GetWN8TierName(stats.Value.Float()))))
+// 	}
+
+// 	return common.NewBlocksContent(common.Style{Direction: common.DirectionVertical, AlignItems: common.AlignItemsCenter, Gap: 10, PaddingY: 5}, blocks...)
+// }
diff --git a/internal/stats/render/session/constants.go b/internal/stats/render/session/constants.go
index 4282e434..6ad909f1 100644
--- a/internal/stats/render/session/constants.go
+++ b/internal/stats/render/session/constants.go
@@ -9,10 +9,9 @@ import (
 )
 
 type blockStyle struct {
-	container common.Style
-	session   common.Style
-	career    common.Style
-	label     common.Style
+	session common.Style
+	career  common.Style
+	label   common.Style
 }
 
 func init() {
@@ -31,35 +30,97 @@ func init() {
 }
 
 var (
-	iconSize       = 25
-	wn8Icon        image.Image
-	blankIconBlock common.Block
+	iconSize              = 25
+	specialRatingIconSize = 60.0
+	wn8Icon               image.Image
+	blankIconBlock        common.Block
 )
 
 var (
-	promoTextStyle = common.Style{Font: &common.FontMedium, FontColor: common.TextPrimary}
+	specialRatingColumnStyle = common.Style{Direction: common.DirectionVertical, AlignItems: common.AlignItemsCenter, Gap: 5}
+	promoTextStyle           = common.Style{Font: &common.FontMedium, FontColor: common.TextPrimary}
 )
 
 func frameStyle() common.Style {
-	return common.Style{Gap: 10, Direction: common.DirectionHorizontal}
+	return common.Style{Gap: 20, Direction: common.DirectionHorizontal}
 }
 
-func columnStyle(width float64) common.Style {
-	return common.Style{Gap: 10, Direction: common.DirectionVertical, Width: width}
+var (
+	overviewCardTitleStyle  = common.Style{Font: &common.FontMedium, FontColor: common.TextAlt, PaddingX: 5}
+	overviewStatsBlockStyle = blockStyle{
+		common.Style{Font: &common.FontLarge, FontColor: common.TextPrimary},
+		common.Style{Font: &common.FontMedium, FontColor: common.TextSecondary},
+		common.Style{Font: &common.FontSmall, FontColor: common.TextAlt},
+	}
+)
+
+func overviewSpecialRatingLabelStyle(color color.Color) common.Style {
+	return common.Style{FontColor: color, Font: &common.FontSmall}
+}
+
+func overviewSpecialRatingPillStyle(color color.Color) common.Style {
+	return common.Style{
+		PaddingY:        2,
+		PaddingX:        7.5,
+		BorderRadius:    common.BorderRadiusXS,
+		BackgroundColor: color,
+	}
+}
+
+func overviewColumnStyle(width float64) common.Style {
+	return common.Style{
+		Gap:            5,
+		Width:          width,
+		AlignItems:     common.AlignItemsCenter,
+		Direction:      common.DirectionVertical,
+		JustifyContent: common.JustifyContentCenter,
+	}
+}
+
+func overviewCardStyle(width float64) common.Style {
+	style := defaultCardStyle(width)
+	style.JustifyContent = common.JustifyContentSpaceAround
+	style.Direction = common.DirectionHorizontal
+	style.AlignItems = common.AlignItemsEnd
+	style.PaddingY = 20
+	style.PaddingX = 10
+	style.Gap = 5
+	// style.Debug = true
+	return style
+}
+
+func statsBlockStyle(width float64) common.Style {
+	return common.Style{
+		JustifyContent: common.JustifyContentCenter,
+		Direction:      common.DirectionVertical,
+		AlignItems:     common.AlignItemsCenter,
+		Width:          width,
+	}
 }
 
 var (
-	vehicleCardTitleStyle = common.Style{Font: &common.FontLarge, FontColor: common.TextSecondary, PaddingX: 5}
+	vehicleCardTitleStyle = common.Style{Font: &common.FontMedium, FontColor: common.TextAlt, PaddingX: 5}
 	vehicleBlockStyle     = blockStyle{
-		common.Style{Direction: common.DirectionVertical, AlignItems: common.AlignItemsCenter},
 		common.Style{Font: &common.FontLarge, FontColor: common.TextPrimary},
 		common.Style{Font: &common.FontMedium, FontColor: common.TextSecondary},
 		common.Style{Font: &common.FontSmall, FontColor: common.TextAlt},
 	}
 )
 
+func vehicleCardTitleContainerStyle(width float64) common.Style {
+	return common.Style{
+		JustifyContent: common.JustifyContentSpaceBetween,
+		Direction:      common.DirectionHorizontal,
+		PaddingX:       defaultCardStyle(0).PaddingX * 2,
+		Width:          width,
+		Gap:            10,
+	}
+}
+
 func vehicleCardStyle(width float64) common.Style {
-	return defaultCardStyle(width)
+	style := defaultCardStyle(width)
+	style.Gap = 5
+	return style
 }
 
 func vehicleBlocksRowStyle(width float64) common.Style {
@@ -73,9 +134,9 @@ func vehicleBlocksRowStyle(width float64) common.Style {
 }
 
 var (
-	ratingVehicleCardTitleStyle = common.Style{Font: &common.FontMedium, FontColor: common.TextSecondary, PaddingX: 5}
-	ratingVehicleBlockStyle     = blockStyle{
-		common.Style{Direction: common.DirectionVertical, AlignItems: common.AlignItemsCenter},
+	ratingVehicleCardTitleContainerStyle = common.Style{Direction: common.DirectionHorizontal, Gap: 10, JustifyContent: common.JustifyContentSpaceBetween}
+	ratingVehicleCardTitleStyle          = common.Style{Font: &common.FontMedium, FontColor: common.TextSecondary, PaddingX: 5}
+	ratingVehicleBlockStyle              = blockStyle{
 		common.Style{Font: &common.FontLarge, FontColor: common.TextPrimary},
 		common.Style{Font: &common.FontMedium, FontColor: common.TextSecondary},
 		common.Style{Font: &common.FontSmall, FontColor: common.TextAlt},
@@ -103,10 +164,10 @@ func defaultCardStyle(width float64) common.Style {
 		JustifyContent:  common.JustifyContentCenter,
 		AlignItems:      common.AlignItemsCenter,
 		Direction:       common.DirectionVertical,
-		PaddingX:        20,
-		PaddingY:        20,
+		PaddingX:        10,
+		PaddingY:        15,
 		BackgroundColor: common.DefaultCardColor,
-		BorderRadius:    20,
+		BorderRadius:    common.BorderRadiusLG,
 		Width:           width,
 		// Debug:           true,
 	}
@@ -116,5 +177,6 @@ func defaultCardStyle(width float64) common.Style {
 func playerNameCardStyle(width float64) common.Style {
 	style := defaultCardStyle(width)
 	style.PaddingX, style.PaddingY = 10, 10
+	style.Gap = 10
 	return style
 }
diff --git a/main.go b/main.go
index ed76a496..be6bd79a 100644
--- a/main.go
+++ b/main.go
@@ -95,6 +95,7 @@ func startSchedulerFromEnvAsync() {
 
 	queue.StartCronJobsAsync()
 	// Some tasks should run on startup
+	// scheduler.UpdateGlossaryWorker(coreClient)()
 	// scheduler.UpdateAveragesWorker(coreClient)()
 	// scheduler.CreateSessionTasksWorker(coreClient, "AS")()
 }
diff --git a/render_test.go b/render_test.go
index 7d74d107..fe9ff97c 100644
--- a/render_test.go
+++ b/render_test.go
@@ -7,6 +7,8 @@ import (
 	"time"
 
 	"github.com/cufee/aftermath/internal/stats"
+	"github.com/cufee/aftermath/internal/stats/render"
+	"github.com/cufee/aftermath/internal/stats/render/assets"
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/assert"
 	"golang.org/x/text/language"
@@ -19,14 +21,18 @@ func TestRenderSession(t *testing.T) {
 
 	loadStaticAssets(static)
 	coreClient := coreClientFromEnv()
+	defer coreClient.Database().Disconnect()
+
+	bgImage, ok := assets.GetLoadedImage("bg-default")
+	assert.True(t, ok, "failed to load a background image")
 
 	renderer := stats.NewRenderer(coreClient.Fetch(), coreClient.Database(), coreClient.Wargaming(), language.English)
-	image, _, err := renderer.Session(context.Background(), "1013072123", time.Now())
+	image, _, err := renderer.Session(context.Background(), "1013072123", time.Now(), render.WithBackground(bgImage))
 	assert.NoError(t, err, "failed to render a session image")
 	assert.NotNil(t, image, "image is nil")
 
-	f, err := os.Open("render_test_session.png")
-	assert.NoError(t, err, "failed to open a file")
+	f, err := os.Create("tmp/render_test_session.png")
+	assert.NoError(t, err, "failed to create a file")
 	defer f.Close()
 
 	err = image.PNG(f)

From 98df6feae176bd67bc0a50a994cc4c668085c47e Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 16 Jun 2024 12:45:43 -0400
Subject: [PATCH 055/341] fixed panic, added panic recovery

---
 cmds/discord/router/handler.go         | 13 ++++++++++++-
 internal/stats/prepare/session/card.go | 10 +++++++++-
 internal/stats/render/session/cards.go |  9 ++++-----
 3 files changed, 25 insertions(+), 7 deletions(-)

diff --git a/cmds/discord/router/handler.go b/cmds/discord/router/handler.go
index 7d91f37a..1c2e26fd 100644
--- a/cmds/discord/router/handler.go
+++ b/cmds/discord/router/handler.go
@@ -209,7 +209,18 @@ func (router *Router) startInteractionHandlerAsync(interaction discordgo.Interac
 
 	// handle the interaction
 	responseCh := make(chan discordgo.InteractionResponseData)
-	go router.handleInteraction(workerCtx, cancelWorker, interaction, command, responseCh)
+
+	go func() {
+		defer func() {
+			if r := recover(); r != nil {
+				log.Error().Stack().Any("recover", r).Msg("panic in interaction handler")
+				state.mx.Lock()
+				router.sendInteractionReply(interaction, state, discordgo.InteractionResponseData{Content: "Something unexpected happened and your command failed. Please try again in a few seconds."})
+				state.mx.Unlock()
+			}
+		}()
+		router.handleInteraction(workerCtx, cancelWorker, interaction, command, responseCh)
+	}()
 
 	go func() {
 		defer close(responseCh)
diff --git a/internal/stats/prepare/session/card.go b/internal/stats/prepare/session/card.go
index c2f80ffb..f1e7f992 100644
--- a/internal/stats/prepare/session/card.go
+++ b/internal/stats/prepare/session/card.go
@@ -98,9 +98,17 @@ func NewCards(session, career fetch.AccountStatsOverPeriod, glossary map[string]
 }
 
 func makeVehicleCard(presets []common.Tag, cardType common.CardType, session, career frame.VehicleStatsFrame, printer func(string) string, locale language.Tag, glossary database.Vehicle) (VehicleCard, error) {
+	var sFrame, cFrame frame.StatsFrame
+	if session.StatsFrame != nil {
+		sFrame = *session.StatsFrame
+	}
+	if career.StatsFrame != nil {
+		sFrame = *career.StatsFrame
+	}
+
 	var blocks []common.StatsBlock[BlockData]
 	for _, preset := range presets {
-		block, err := presetToBlock(preset, *session.StatsFrame, *career.StatsFrame)
+		block, err := presetToBlock(preset, sFrame, cFrame)
 		if err != nil {
 			return VehicleCard{}, err
 		}
diff --git a/internal/stats/render/session/cards.go b/internal/stats/render/session/cards.go
index 97db342c..ccd76e16 100644
--- a/internal/stats/render/session/cards.go
+++ b/internal/stats/render/session/cards.go
@@ -12,7 +12,7 @@ import (
 	"github.com/cufee/aftermath/internal/stats/render"
 )
 
-func cardsToSegments(session, career fetch.AccountStatsOverPeriod, cards session.Cards, subs []database.UserSubscription, opts render.Options) (render.Segments, error) {
+func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Cards, subs []database.UserSubscription, opts render.Options) (render.Segments, error) {
 	var segments render.Segments
 	var primaryColumn []common.Block
 	var secondaryColumn []common.Block
@@ -55,7 +55,7 @@ func cardsToSegments(session, career fetch.AccountStatsOverPeriod, cards session
 	// rating vehicle cards go on the primary block - only show if there are no unrated battles/vehicles
 	if len(cards.Unrated.Vehicles) == 0 {
 		for _, card := range cards.Rating.Vehicles {
-			// [title]	[session]
+			// [title] [session]
 			titleSize := common.MeasureString(card.Title, *ratingVehicleCardTitleStyle.Font)
 			presetBlockWidth, contentWidth := vehicleBlocksWidth(card.Blocks, ratingVehicleBlockStyle.session, ratingVehicleBlockStyle.career, ratingVehicleBlockStyle.label, ratingVehicleBlocksRowStyle(0))
 			// add the gap and card padding, the gap here accounts for title being inline with content
@@ -70,8 +70,8 @@ func cardsToSegments(session, career fetch.AccountStatsOverPeriod, cards session
 	// highlighted vehicles go on the primary block
 	if len(cards.Unrated.Highlights) > len(cards.Unrated.Vehicles) {
 		for _, card := range cards.Unrated.Highlights {
-			// [card label]	[session]
-			// [title]  	 [label]
+			// [card label] [session]
+			// [title]  	  [label]
 			labelSize := common.MeasureString(card.Meta, *vehicleCardTitleStyle.Font)
 			titleSize := common.MeasureString(card.Title, *vehicleCardTitleStyle.Font)
 			presetBlockWidth, contentWidth := vehicleBlocksWidth(card.Blocks, vehicleBlockStyle.session, vehicleBlockStyle.career, vehicleBlockStyle.label, vehicleBlocksRowStyle(0))
@@ -89,7 +89,6 @@ func cardsToSegments(session, career fetch.AccountStatsOverPeriod, cards session
 			// 		[ label ]
 			// [session]
 			// [career ]
-			// [label  ] ...
 			presetBlockWidth, contentWidth := vehicleBlocksWidth(card.Blocks, vehicleBlockStyle.session, vehicleBlockStyle.career, vehicleBlockStyle.label, vehicleBlocksRowStyle(0))
 			contentWidth += vehicleBlocksRowStyle(0).Gap*float64(len(card.Blocks)-1) + vehicleCardStyle(0).PaddingX*2
 

From d3af8c45d2a1e12fda9c9046c30c2cfb6af4ac3e Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 16 Jun 2024 13:38:32 -0400
Subject: [PATCH 056/341] rating icons

---
 cmds/discord/router/router.go              |   1 -
 internal/stats/frame/value.go              |   2 +-
 internal/stats/prepare/session/card.go     |   4 +++
 internal/stats/render/session/cards.go     |  40 ++++++++++++++-------
 internal/stats/render/session/constants.go |   1 -
 internal/stats/render/session/icons.go     |  40 +++++++++++++++++++++
 render_test.go                             |  12 +++++++
 static/images/game/rating-bronze.png       | Bin 0 -> 52350 bytes
 static/images/game/rating-calibration.png  | Bin 0 -> 2231 bytes
 static/images/game/rating-diamond.png      | Bin 0 -> 58867 bytes
 static/images/game/rating-gold.png         | Bin 0 -> 57541 bytes
 static/images/game/rating-platinum.png     | Bin 0 -> 68497 bytes
 static/images/game/rating-silver.png       | Bin 0 -> 56479 bytes
 13 files changed, 85 insertions(+), 15 deletions(-)
 create mode 100644 internal/stats/render/session/icons.go
 create mode 100644 static/images/game/rating-bronze.png
 create mode 100644 static/images/game/rating-calibration.png
 create mode 100644 static/images/game/rating-diamond.png
 create mode 100644 static/images/game/rating-gold.png
 create mode 100644 static/images/game/rating-platinum.png
 create mode 100644 static/images/game/rating-silver.png

diff --git a/cmds/discord/router/router.go b/cmds/discord/router/router.go
index 3c24cfb8..12aa0072 100644
--- a/cmds/discord/router/router.go
+++ b/cmds/discord/router/router.go
@@ -57,7 +57,6 @@ type command struct {
 	requested *builder.Command
 	current   *discordgo.ApplicationCommand
 	cached    *database.ApplicationCommand
-	action    string
 }
 
 /*
diff --git a/internal/stats/frame/value.go b/internal/stats/frame/value.go
index c5e136e1..b14a2148 100644
--- a/internal/stats/frame/value.go
+++ b/internal/stats/frame/value.go
@@ -55,7 +55,7 @@ var InvalidValue = valueInvalid{}
 type ValueSpecialRating float32
 
 func (value ValueSpecialRating) int() int {
-	if value >= 0 {
+	if value > 0 {
 		return int((value * 10) + 3000)
 	}
 	return int(InvalidValue.Float())
diff --git a/internal/stats/prepare/session/card.go b/internal/stats/prepare/session/card.go
index f1e7f992..e4aaef91 100644
--- a/internal/stats/prepare/session/card.go
+++ b/internal/stats/prepare/session/card.go
@@ -76,6 +76,10 @@ func NewCards(session, career fetch.AccountStatsOverPeriod, glossary map[string]
 	}
 	// Regular battles vehicles
 	for id, data := range session.RegularBattles.Vehicles {
+		if data.Battles < 1 {
+			continue
+		}
+
 		glossary := glossary[id]
 		glossary.ID = id
 
diff --git a/internal/stats/render/session/cards.go b/internal/stats/render/session/cards.go
index ccd76e16..7d18674f 100644
--- a/internal/stats/render/session/cards.go
+++ b/internal/stats/render/session/cards.go
@@ -136,10 +136,10 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 
 	// unrated vehicles
 	for i, vehicle := range cards.Unrated.Vehicles {
-		if i == 0 {
+		secondaryColumn = append(secondaryColumn, makeVehicleCard(vehicle, secondaryCardBlockSizes, secondaryCardWidth))
+		if i == len(cards.Unrated.Vehicles)-1 {
 			secondaryColumn = append(secondaryColumn, makeVehicleLegendCard(cards.Unrated.Vehicles[0], secondaryCardBlockSizes, secondaryCardWidth))
 		}
-		secondaryColumn = append(secondaryColumn, makeVehicleCard(vehicle, secondaryCardBlockSizes, secondaryCardWidth))
 	}
 
 	columns := []common.Block{common.NewBlocksContent(overviewColumnStyle(primaryCardWidth), primaryColumn...)}
@@ -223,11 +223,14 @@ func overviewColumnBlocksWidth(blocks []prepare.StatsBlock[session.BlockData], s
 func makeVehicleCard(vehicle session.VehicleCard, blockSizes map[string]float64, cardWidth float64) common.Block {
 	var content []common.Block
 	for _, block := range vehicle.Blocks {
+		var blockContent []common.Block
+		blockContent = append(blockContent, common.NewTextContent(vehicleBlockStyle.session, block.Data.Session.String()))
+		if block.Data.Career.Float() > 0 {
+			blockContent = append(blockContent, common.NewTextContent(vehicleBlockStyle.career, block.Data.Career.String()))
+		}
+
 		content = append(content,
-			common.NewBlocksContent(statsBlockStyle(blockSizes[block.Tag.String()]),
-				common.NewTextContent(vehicleBlockStyle.session, block.Data.Session.String()),
-				common.NewTextContent(vehicleBlockStyle.career, block.Data.Career.String()),
-			),
+			common.NewBlocksContent(statsBlockStyle(blockSizes[block.Tag.String()]), blockContent...),
 		)
 	}
 	return common.NewBlocksContent(vehicleCardStyle(cardWidth),
@@ -242,13 +245,15 @@ func makeVehicleCard(vehicle session.VehicleCard, blockSizes map[string]float64,
 func makeVehicleLegendCard(reference session.VehicleCard, blockSizes map[string]float64, cardWidth float64) common.Block {
 	var content []common.Block
 	for _, block := range reference.Blocks {
-		style := statsBlockStyle(blockSizes[block.Tag.String()])
-		style.BackgroundColor = common.DefaultCardColor
-		style.BorderRadius = common.BorderRadiusSM
-		style.PaddingY = 5
+		labelContainer := common.Style{
+			BackgroundColor: common.DefaultCardColor,
+			BorderRadius:    common.BorderRadiusSM,
+			PaddingY:        5,
+			PaddingX:        10,
+		}
 		content = append(content,
-			common.NewBlocksContent(style,
-				common.NewTextContent(vehicleBlockStyle.label, block.Label),
+			common.NewBlocksContent(statsBlockStyle(blockSizes[block.Tag.String()]),
+				common.NewBlocksContent(labelContainer, common.NewTextContent(vehicleBlockStyle.label, block.Label)),
 			),
 		)
 	}
@@ -303,6 +308,17 @@ func makeSpecialRatingColumn(block prepare.StatsBlock[session.BlockData], width
 		))
 		return common.NewBlocksContent(specialRatingColumnStyle, column...)
 
+	case prepare.TagRankedRating:
+		var column []common.Block
+		icon, ok := getRatingIcon(block.Value)
+		if ok {
+			column = append(column, icon)
+		}
+		column = append(column, common.NewBlocksContent(overviewColumnStyle(width),
+			common.NewTextContent(vehicleBlockStyle.session, block.Data.Session.String()),
+		))
+		return common.NewBlocksContent(specialRatingColumnStyle, column...)
+
 	default:
 		return common.NewBlocksContent(statsBlockStyle(width),
 			common.NewTextContent(vehicleBlockStyle.session, block.Data.Session.String()),
diff --git a/internal/stats/render/session/constants.go b/internal/stats/render/session/constants.go
index 6ad909f1..5c550a43 100644
--- a/internal/stats/render/session/constants.go
+++ b/internal/stats/render/session/constants.go
@@ -129,7 +129,6 @@ func vehicleBlocksRowStyle(width float64) common.Style {
 		Direction:      common.DirectionHorizontal,
 		AlignItems:     common.AlignItemsCenter,
 		Width:          width,
-		Gap:            10,
 	}
 }
 
diff --git a/internal/stats/render/session/icons.go b/internal/stats/render/session/icons.go
new file mode 100644
index 00000000..33a87c4e
--- /dev/null
+++ b/internal/stats/render/session/icons.go
@@ -0,0 +1,40 @@
+package session
+
+import (
+	"github.com/cufee/aftermath/internal/stats/frame"
+	"github.com/cufee/aftermath/internal/stats/render/assets"
+	"github.com/cufee/aftermath/internal/stats/render/common"
+)
+
+var iconsCache = make(map[string]common.Block, 6)
+
+func getRatingIcon(rating frame.Value) (common.Block, bool) {
+	style := common.Style{Width: specialRatingIconSize, Height: specialRatingIconSize}
+	name := "rating-"
+	switch {
+	case rating.Float() > 5000:
+		name += "diamond"
+	case rating.Float() > 4000:
+		name += "platinum"
+	case rating.Float() > 3000:
+		name += "gold"
+	case rating.Float() > 2000:
+		name += "silver"
+	case rating.Float() > 0:
+		name += "bronze"
+	default:
+		name += "calibration"
+		style.BackgroundColor = common.TextAlt
+	}
+	if b, ok := iconsCache[name]; ok {
+		return b, true
+	}
+
+	img, ok := assets.GetLoadedImage(name)
+	if !ok {
+		return common.Block{}, false
+	}
+
+	iconsCache[name] = common.NewImageContent(style, img)
+	return iconsCache[name], true
+}
diff --git a/render_test.go b/render_test.go
index fe9ff97c..c014682e 100644
--- a/render_test.go
+++ b/render_test.go
@@ -2,6 +2,7 @@ package main
 
 import (
 	"context"
+	"image/png"
 	"os"
 	"testing"
 	"time"
@@ -9,6 +10,8 @@ import (
 	"github.com/cufee/aftermath/internal/stats"
 	"github.com/cufee/aftermath/internal/stats/render"
 	"github.com/cufee/aftermath/internal/stats/render/assets"
+	"github.com/disintegration/imaging"
+	"github.com/fogleman/gg"
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/assert"
 	"golang.org/x/text/language"
@@ -23,6 +26,15 @@ func TestRenderSession(t *testing.T) {
 	coreClient := coreClientFromEnv()
 	defer coreClient.Database().Disconnect()
 
+	rating, _ := assets.GetLoadedImage("rating-calibration")
+	c := imaging.PasteCenter(gg.NewContext(int(float64(rating.Bounds().Dx())*1.5), int(float64(rating.Bounds().Dy())*1.5)).Image(), rating)
+
+	fc, err := os.Create("tmp/rating-calibration.png")
+	assert.NoError(t, err, "failed to create a file")
+	defer fc.Close()
+
+	png.Encode(fc, c)
+
 	bgImage, ok := assets.GetLoadedImage("bg-default")
 	assert.True(t, ok, "failed to load a background image")
 
diff --git a/static/images/game/rating-bronze.png b/static/images/game/rating-bronze.png
new file mode 100644
index 0000000000000000000000000000000000000000..9c9759bb506c9e79f0dcc30f336429b5ddd50e44
GIT binary patch
literal 52350
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
LNkvXXu0mjfTChFp

literal 0
HcmV?d00001

diff --git a/static/images/game/rating-calibration.png b/static/images/game/rating-calibration.png
new file mode 100644
index 0000000000000000000000000000000000000000..5cb133a82817b856c40187e40ae193d01fb45ef0
GIT binary patch
literal 2231
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
N0O7oYHOq>4^Zy4%*~|a{

literal 0
HcmV?d00001

diff --git a/static/images/game/rating-diamond.png b/static/images/game/rating-diamond.png
new file mode 100644
index 0000000000000000000000000000000000000000..8ae642921cf8723d44e57f9d9c65dd14c87b3402
GIT binary patch
literal 58867
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

literal 0
HcmV?d00001

diff --git a/static/images/game/rating-gold.png b/static/images/game/rating-gold.png
new file mode 100644
index 0000000000000000000000000000000000000000..deb5feb38ed4582fd50b3b4e101dff6669852343
GIT binary patch
literal 57541
zcmV)NK)1h%P)<h;3K|Lk000e1NJLTq005-`007Mh1^@s6*^IF500001b5ch_0Itp)
z=>Px#L}ge>W=%~1DgXcg2mk?xX#fNO00031000^Q000001E2u_0{{R30RRC20H6W@
z1ONa40RR91rJw@<1ONa40RR91%>V!Z05af4`2YYw07*naRCodGy$76SXLTodUe2-V
zRj%r)uCA``R;yb%3y=tsWw3!2VQk}FjJ<<{jLj^|IN@PE2#?2Uj3Zt!>lwgfu>uQ`
zl~9&i>Y&b{x~eO`daqv2>CXTE-S<`9F10|w?vBRmQ@>aDzMI|+|L^2;u1)@hUez7A
z_uk*=5h?Xo3fVrpk(=rrbWIft%^lpiU2R<(O4Q5i>E5i*TU`l-UFXs(&9fa_^sGM|
zTN4Q;fAcp#x&Eqt=wCJx+rQic^A2nUU90UK4TNiZt2N(XPj5OVO=CJ&vWwf}lX}}N
zL9b)u)-_re-^NC(C2prve9ns0nj(Hz+1%D;J6$OSPH50_;lBWP<2G*0Tzoe-7XR~`
zx%b|C_Gm6gzzvMFz2tNRo!cmmI0B9lebru<C@}H6%jFY-P6LfoO;+F;How}2>$u!z
zR74+#Q%wXZi9oG11Dk;5!Y*hztAXqA@65Se&Ex-n;<o=RK)IF6@u6z*>JOIp@H;sj
zL7<5s3i=_CD|*T1R0B_gi=2`3n)G^p_c$7gb8@|Pxn8ID(E!!oc}(uh<<*u6XnyB;
zk;9Vg(&ez254ha;);z6MgmS@q%;~5t{Bs2D{}7<u3OWLg4~?9Tp!0b`)Ao9ei=^0e
zNn3p4c7wY$3~@L;Qmr)rDnqT;|F(+U&E=-(wSMQk2IW@Z>Fr)=8;W`U7CGmoh~Oj<
zkR&TtRSUZRcugdI-dm5?s8_|&axXS)p+&9Nt}Z%i1g=&Qe)Bg!b)tK?*YxBy4@!#N
z*WcPX{?tQXlyKiI8#l9QcsAx6b@RcxJ?4Ye-#0eEjKglOvo0fOw~_|4UQQ5bKx;s}
z5->Gq)%$X)IpJ0iX-;VcB~^uHv-&b%Qsi?xJuvj~x1NVy&*hp6b6*0M)Nc1Y`|t0)
z??%1<YjtXWt)7@ZulL^l_IKWR^PkDYW$%%>bL--8L*{m=-PO+sI4kJ%cY>7j8mxLh
zP6<c?P=QeCjMN)#N}O+kZ*$D*W!7VCohKMH$n=z=nMAQnfLb}B-bQoDQmw7F<MsrT
z)<3zgCW4!vt$^fuF0(Gr*W5}crg4^wTqec%zzrY&_=n%6kM&xeZYoNz(KC$pZT~-b
zYIncuHzb$;-(~&GSqW_0E*g+}>gXC1`aAd0^PFCaD^i~%7i_fJ-25VHbnO`eri6$4
zYKhxxu4c%lo~ePSfu_G}VDk8CnbA;S<Z``@$*IjprH?JLX>eK3O>@gSR&#&)2y&r8
z=+rQkTq%h~>eph?eb#+mYxA#ZPD#-ni#TjH+maZ@u>Abb|A7MJ(#*01g3#5#?b;m^
zFcjGugaoJtDR20tj2Y{L&<~PR{o#5()R%$Ax+CTbmBz-0tE}7WO?gamJ94f|t-sVV
z?#q1$Vk?*Cv8>#X=cvzFujBfNx1lWiRT+?S)29GwNKn?+oVV)pdaX`3<<o2M49}l=
z__rsfrhd;nwKOKZYW8pb@>gVKwIm~BeNwBp6&N)q^aX6{y9TA^k`&Wc(%b6?{{8eu
zg6~q)8}>_opXswK6dcN^N*7*k)FeXY-UOfqJEvCC;MB|coj{|w*7LN?Y4q^Cxt!_%
zzf%|0`}3GQM$R=L4ToRc?TWa(=JgYx{SCS7wQTfU{G_aR=ru4uf9^Zg(aCAA2m#3t
zX_xwc?<amyDexMYTu1;Cj8=|WEt|R{mp96li*!;AOl{myr_*EwA%W-fx+NTLOVm@B
z7=Z7?L-smL5|3@VnYeEOHbt`&mR!p%P5fS_BvPriq+Dt%j=dGI8mwB^Bxls~+T!MM
z0e4O|NUyV=vtCI+Rze{uH4|_pZSF@vs_zTA-@Eq@zw|M^{cCOdn$;=k1~LJuZ<)y@
zMNVPCF8Re@`E%nx{m}<(i}P#JpBRxw8!iz5&+BnW+lEL=!((z#TF;R1E?ZsNFp>zw
zmpw?+n<R-Ir`q4|b4olIkg(q+9+x35dqKj!s>Hp^>SWdnn`7B%6ePD?#4%fl@;D_N
z?1()ak*OZjvgfuoH*`7>0h>yDq=IuQ0w9@OT@4hjBN#QOOBEXuaaUoWnE=%Q47r+;
zs^B6)E=&kiT<*(Aamc3sB0yR<vb$|>#`o7OC^zq}^{ih5^P8eui*3y*d2*cJCB@2$
z{L%0Kh6?@l^@o%wCn&8VeXCfDhn-3f_4Ea$-(#0p438YF$<r!JPoSW#JTYkAmUebY
zeJ8Lwg}f9HW-LiSS{1uE?OCbRz2a^arC6)0?Lyv7H<emo`R5F{E&^>&*bp9<fNp!k
z=I_)4(g2qwSwTy{riyB@`WN<JY<Q6~63|wWZRL>MiCmJz<(&Ud|J$ctv(NrDabnsz
z-fX%qYgf)h83z2|2mkd)HbpmYrv@cC=6NmvT_+1Or)!`2zdq@u+k<{S67?;LTMaxe
zBlr^TG&r7!&l43_z%L%p3Relir@0@&M<M_T7Duh1xFDAigrrs(DCrWxR;A8Yafrv?
z7FU;(>GgW*_n7QhA0r&!R26u<XpedBn$vQ>^^6TVYFjF{Fmy%?wiaAFb&nc!sr60k
zo2mvmtIOLXDbIk?A>H1x(6HG`aC(U|fNhq~eOZSxP3QXP(br1S$p0sxq!rDZqd~`r
zOky~AIhS>6uIYTXHBoJXW4Rnss#YYH7?YoW|F2=K2BMyllWn&w$1IGW!$(iaxx@EK
zY%s9_yr#WRhWb<70LH?sR8yPWMFUW+#J|Pmj+zZ3kVi4BL8k#!l8&?t7!2U7od%Rd
zklh`Wjw6f#-~>oaQC)5}By5M{+6kir0OGXSY>Cg^P=IZ=BI0jcYy@erHk=`GV^CFc
zCbw2Uf`433z!Iz^ss<ziwk9T5EyLJ5n~ci2+JLgM)drS-8k_;2`P&WL8+T_-dYUDr
z>vB_uG>bX!BD0-z(g>IT_sDkoe*}~|*}>)OOT;3x^n(dON5FAjY>kOp&Ey0{xNcmC
z<GP*ZPd8cy9-L`~Mk5hfyl_^o*>|Pf@z$Tgj?^DXTAwt(ZT=@%d%+Q2kmAwLiX%3x
zxZdV^h`mMgA(Qj*!E#DkUWPl#Fu9_`W<F>xuUMS(jkZ@h_D#pNy;DIFg-?YtDN;#{
zmXJ%+I4P9OdA*!duG`2GDkIkIMi|orE)Kvtsr#1O;tiOJVGz*xengO3RRM1A>B-Al
zZm;~q;SnK++)4x`Ii%lb7XngKIByPGYZzAR+qPDI<GL8I@Ve{5P_B-@m$S{YzJPO1
zhcS7~fB*ac<uQHiA7%O@gYv+^Km4=xrN%u=$ys$C1RcTEY?$JTpxa6Wp$4YC1D(tQ
z)Z?d5%m4h-KP^{WPAgk;NPPr?(*&Y9H92Qy=CiW;;%CJ-ykF^ldTXTvS~wq<Te%;<
zw;Y>*CjiOyIv%fj09?;lI>~B?SjA;LWDYiRdQI(C9RqDMTu4J@tM$xn$(^=l3VE9*
zHzNpaIEK+xNjOjNI?7e)iC=8p@S28(Z1Q4$ugqP{i1jHcKyG~L&ctd?;d!g5m*eHv
zVFfF9VIF}dUL&uGfX!yiR8fX8{lS3`{HX4xAIbVAhdg}l$URa@$Y}qBI^Ts<T9V1E
zn)i6^3Vfwv*Sy72E+Y|`O<J6|F~ESLg@svh#Rs~8<e~z&U<RXnT&*|%X%KO0f;4;P
z5m~Q~f&D?m)gWrSI-dzZK0v4i77<Ji=!8kWRrFSx=Iv-?OJX=9%16jdA~znG56>(T
z???!Sf*%jZ<%vij;FgKepqw~yPF^@!gAw6YfaZBR+#zXJO_jmrqa+B4-DWx~>lM>5
zs=^v4hi!Hx0fF3cnJ%W90gmU4!Gn%%6i|^^Qo=mWyInUWi_a)Zqr!8h+JS4zo|N`V
zP&`48;&MC>Qcn!`0QZ{t0tL4@$hbV~g{rYqYnOr!Y+$;MsEbpLG6}y0@TqWY7qnEb
z2u>5A@NnRk`=irP16HM!I&uTj0KbKON4p33p(Z~Pr~I=&ea9bkTtgqJ0|*4$uCZZt
z5(FjzM#nENQj^0Q1qeIp0=UlQH38-X_&6%*!@KjAn<2Wd!LyhXqXSOZ&gk8xo-c_v
zz9^OD&C^b;KzM)WptJ*sT7dTue4J7YJMjP-Z91Aa^*$bqx}Q$i<#!rLL7!g;9@8Df
zrMTJ7jx-^%Jnf=*Ar^~ENu}RKhq|6{Y~ymx%d-!;WO*$pZeLn#0F@^cRQq?jAawZy
zQW2BO=-9mmC^zf?TqJ^+t}Rj<x+l3aK})ixvGF@~S4~=XJuzqMol!fi`i?1~IPdV8
z2l4pKbEsGAQuRhu@PWUXEv#=OZSa^hn9T6&=6$w;RZE3dSEtP`z9hA33S7J)cKAnQ
zBX9VTobx{tr|jv8-JJq%G)J6SNlC!(lhH)4`kb0yl1!Q*!2xyuyx=6I+@hK%Ae%K)
zJmcO2I4#8`i`4~bu6{|J&J$A4K>1%Yxe9k8ym{Ljh0RDv+qPYzqnF8gwFW@)I8IrH
z2rd>kIf8z;3{4Ugeegq$fRhE?Mdgc(d7#%~V3^d9kYi=T1w`F5TRsDkIi^Iv6E2}P
zj0{pw+>p<IX+W0GUyzCIFg!2-qR{#38}1vP5x}Mojro=bRTUPZerX`;LY0A%Is)L(
z*>1NDsjW0uZ9}!7^Pfb37CM$k*9fUW)`TiSE1Y*nYr@46?jP{mt{0Hn<~66Du!NxN
z(xFcdN#J|CY6A6QMvC0HPxS9HM9XK>D7D~?!2JW4BquE*H+5xgUL=23j4V`*m`4H9
z1#p%!EAPdDKZef_MV2f3!S?^{fBQ3UsMQ@4+)L|+%4mTuIkQq#;3Vf<g?>qKP5?H&
zeTqB!6lY8;E=ukhLN*WeN^;TEY8f{{9afw$F3VWHl^mOPiP+)mi#u8}b1tA9=G4Xf
zjJou~n1HqH!p+x2&gX;^z0=NNo0OFEIdR(^;`JL+ru!wAQNUY=?~%qt1;5=k(&F~_
zOCA#Likqe-y}GL0G!xqv<>1pcSvXOZx4enJ(Uj$63xm#(mb-&%+ca8?rfGb%Tz%A6
z#05~1s#G<=5uH9b*uh~5SdCwTl^m9mwC;u&uTq6DuY~|5F>>XHu|~buaJnTTrs2kQ
zG_YudZHn?J7Xy4zal;+v==hYUgDQh|rEz^M?pIuz^CUbz1RmPz-V&fLJd{i^E%~KG
zQctdnCjkl3V|oG1J@^}?_hbHt2BlUW^zmNx^cO$0|F4SG=#EYYiZUJ;bqjLIP8%Z%
z^K^w|aTP&;W1^>5+IE*@)8IfY#A|~P58i;-o!}1Oo>dHOPHpy%R2nWBfRz}G;O2B<
zV$_Pts`iG~;afy%muF1uzVOD!=!}3X+TnsRWLv_J>2bU4+~yXq0}q=3Xs<}bm4{WH
zf%spM%IcapDr<0ctRTt5BmSUEGFhk}frwOb90$Teq5h!MDqe8BDtv@)Y1upya>H1u
zrDS!!hVwGSTV0Z4=Ug(mZ%q6)r_4Z~z3GkQ*de)a;<yZs^gtY!#OA<t;nQ*eSRf6^
zCOEDgTnDJZZ+36H(=WFAy4WDX+ohybldIB!+oqAvOA{%0ZCJ#C&brtQ46b%v4dw>!
zp$%Nl>*Bcsv;eHni*v<w*uc;oP5>5(9c~v?DIe~O8~4tDZxsfP-R_iT8+Atr9n~8h
zJcqVa>m2~kEwx%zGOH<RK-IB3dvLED(n2;>VfCD(PQ3)K4Zs7CF1x7`bgw|_4krg%
z`1Uux<-3nR`O=(T{)0?^C{9UdcPTe}Cx3`wB54<op4V3Q+I&vdB&YOEigoInnXIWd
z1w*EVLk?N5nZ{7M)sW*!Bn=EhVTW^@ZXOc3XDJhrr4>^oI(;oEB#XFtHRyW{8IP6~
zr^~k^vW|!g{e9JPS$qNLbKrWUKqMhe7o5lTw!|<{BK^a7;HxS^Q$Z}d0j}YX@FqJp
z_U{`W6sMn@&ml8Mm!;Hb%HHkUB)K#w<!n|$!w{<wx#Lq!Y%?g&KKFv`07I-<;^+jR
zvun*YyV^(#gN;Ov%Jl?m3xfz}skUuliiNaK)Vd%M2C5fIYWrXai6;=t2EwU)h<<R^
zwhJ5-`%o1iHQ`&eCOnf_6g#FNMLnLhsVl-whk;F(5V<FbT$cJJbw`To#@e#@T3H1~
zwZSF+5u_C19e?e1tbXhgn|$9zKNKjN&HC+B)ZGr7l%X^em@c<h$`$zO;D6MBq=l`G
zAgjLVa+i=BnHO5+)JF+Ua@l}83)i??MPE*xUQ-DVnIz)T09~_ElG#*J`S<9=CRMU|
z=>_2UoXeQD$_|L#x&j{s97QmRPHB>X2N4;JN@^ZAy<V5X@@ciae>;E-uB502ak$=u
zMcHTWUtNRSCIsO6B-9s`et>p8S&=?Cw0j0>a`c%Q*>we-_AdDk|MtH~6zcP~ojYY^
zsfGt0Pypg_O~B!tw5tKjG}qKq_50mzxy*n#=YC!c2%0UWA~H0w%zS82LzE%a*f@3z
zdLv2y2DfVwsGtr(4)VZ}PZfujI7K))CiO!;2OkVNhm(3H#5>fgD4uIJwI~;kJu9B-
zvbduWNT?7bMR#Oj%O>Wxa!dZsk0Qd&;m4!=0QANC-uI1CF`+mmK^f>;bp)dZr4^8x
zn`#i!k2w$tiqCdT?41lmbXJCfCg;euqEgHllCHGGmQAU%Dif%F*ssA}72%+(hi)Hj
zVHc8V<->~x;0gf%UH+i5mbr7ShKGTNS_bGCr*?uvR`PY3n=eZLs6%?9rdVyQrxgf!
z+%@QuJXUTtE51Zqh9<|PcVIxWb7y2NkJvfD=BSmWFVd3SdR68Y=V3I&rG)V2uKi(2
zE^PWN$pu@spg0Ya!}FZBf{@F&9Z7G?ZS*p7MG})tG;IYrb<hS}MKyqsE+noeIQ4dV
zKQ1FEc`WWjDipy&LB9T8wLDWW>y%0`QuFh(YF)73G|&jbt#m0+avM*0|7|~vLtSe#
zTYu*jzf*Kag85IE>vS}mPH-=Dm|DH5e2>&!9B@OFN)$X8wcwo8ISEo9z)Kx;W<4)E
zBj+XBI036JBSDPL<VsD_%QMpBPeZZqlSCX3A7Ye$;g}Zy>J^*QE~_~hL>&jX5IlcK
zfS^6mgbqZ#tquJu6bwQH+p#VDdS#d5upJDXb_cpHL`yYOgPzur(H&zFkGjO$DoJJC
z<S<;$aG%$0@}fpCEMwzwWo37=OXBNAEW8Pwvf-B8D%@T$${v2KB+njb$+6iM^f5%`
z&tX0Mp#Ct*XG0zdfV%`3g+Ye9+hY@ty{2@{8hxTp=#zk+1|RPiVlF0_pz9HsT;Fa$
zpTwtyWp=pINYvdGfE_TF0Kh7AaVO@T9rM0(J-6kj(Lv$}qzk9qriKCUXd_}{LvqH-
zGSs9d?qy91=NILcYi%;HeL|jk5Qfb9S@HJA#RoSJ!Pqen+s8fR)Jpu$j{~~3CR_O|
zT*hOLXJ0t=WxedxPB)M8D)*@6kG?ZkncCP|>yiYW7UP$4o>M$<+Y(0QbrWtWWLM?r
zd{_p?;*zI<0T)DNfnxTgOx<8dY}XXKISA(=JXDGla=5T5ktJPnNYrNPjR=;5OW=WE
z;D?bdL|v0aalM>v$xzI#L^{8V(izQl)tqUqGPcZ^w=Ze}koz*WjN~<N?Y!Lgxl@us
zVx%V!mJ17I@x&23MmAC~6cbmUORl~uCZSfeoy?zg<kk$CT`tSwYLbTm=Qg>00KUSw
z-ytDCU0;0?hQ&(G=0Wl?`5z-TML56}7p<2u-6UG+PH$*q9mRPSNhKaggmxvTHe~ox
zb4M<?h)aS~*BVa6t>Ft-$Kl{8rlC)}$HWtxlq!x>hWMtGy5WuM^5En)DbMgoP@OKp
z9l2&JSw*?i9u>Pc^*(I#vs<_Oe&2s!@lDa4Tnpc+MKX0k>XIbRQ&-e_r1i%s;wkF6
zZr@~4=8m1&5FfFG7y4mVB{7_S=D6H^Ye0!il_3KlQtXPa4_powplwb?G3x#v=?%6O
zIBDrmjzcevL?yohpkh0pB@2gXW+Z~nN;(6mfbFS&&L-WGU&}z8m81j_R<41&fg97x
z^!gIgA2MWc*eAPpAzyOO2!6x#mv-9baqSM%(cfHqULO7Y5&7=%gtR&)Xqxp1{Ey&F
z$R@IL^njWj<UGQC<?iX1K@2=s$PX6`fD12!j*IK_tr}5fnd|RX?y3REsV0JuM72S$
zSKqM>Eqr%pUafD~$CPU-nh3+&0KI*tD(`uFT&mG)<#V4tAc0=<8r8=5M^5?uK&r(#
z4Ia<<PrdthfA^2?)BC@g=?}yyDY`59^qmA2N08Pf`9m6<TLG!Jp&?X<)lH6B&8<T3
zS(3r&J$NVx0d{)ftBc4jx9*aUzpx;WesfWN;_cuc0Af$SAEVc&bj*egqZWR^c(f({
zUN7{y3=ELA^o=3I8agTgNqw?sA|&}F#4R`qshEi&VIe1}vzvNdF4dF^%O<C+0W5V`
zogQaRR?;rGup08Nw{~RDtpm_Gp>|ACpX$K1GN_JcGgdIg2i6Cd*&J(dIK#yxn8(!B
zlaiWaP@-cM8H-J*3?c4Vuf%0OOAcy^*zzjsd-6z4%go4J3oaZ7c_xfDq^FUBA@FJ+
zvfCqJ3Btt%pSLo4{IQ6V3`H1rT9;HibpI)iiFt~5O&YLV7X+7FUkix?8Ascu`=LT*
zVOiT`=gvO4?AnNY<3B$nuY2E!1i&pF%f}HdGY1imrMcnv0;b+ZZC_vbFsA?Sfimbn
z_0eK|2*BdcVbpXjZVgCn$f$L&+_Y%tcP41i-Lnlzw&R{vL{paKNcB3bDM`>s$_Rke
zsM+M<XA1J;H(-Q=b5-E{wR`%Z3p&9`q2C}Op?4&q+%`6d^YHc%3?DO`rU6OuO*hY@
z-$+65!#e=|sa$PJ5jt+R2q$okd55O;&hrYv-4jF}qzA(@5cUFAHQ9d!Y}GKtcN&QX
zQG^sbi`*1P!_+>a=J{^}r0oN0xlQ`83@h@7z|E<5g-j5djGDVB>T~z1Y2@ne0=T^s
z$Pq0U3|Yz|UQ_8HD;?nMxFio9I=N~N9&*@n)g!TR38B0mBqc+St`;Od;FVY(V)c%i
z0&5d0feXIeBBTsptbT-GBuF9GaPM7mGF6dgz9N&?3`!Qi*+dj;V$XJ&Pe$a4!*;p#
zZF917_&PZ>6GV)^f#U`+08FR<_X4E8B5u>fDDqa9Zy+=KL2@;JAWo^niu#AO*yeW)
zNX;p!W4d8%XqOSc_u{6;Y$zRow$`cI<iJ-RlUwh;UhI(oe3vEpli&Ia7(0gC4y>+&
z8@nn^=^$q3g|$05wM`i<k-@Oyh!@t@kRTDj18d1SxQ|k4Q-yFLCcL_C$Xc?5RJBdb
zjNpqPo)#H!!4-n2PY4D8jI&l_Q-jGs`i3wV&dqi35xMK;ro1s+7b9L28+@FGO7%*q
zd0w+^6Wd*Yu5mF!ZdW2J{soLI_4Q@{)*5Dbb#2L9)eH5c<>z_WFh~T>e|=7jZ(~q(
z!J2}TpR~MUld~^oWe(u-KpJ@G;ZB3jT4{$Q5voeKm(iPw1iWx<g~47y42hOYW$3Pu
zOs=5px!NuN@VPmxc~Y*wZLhdv{VH1Z$$#@8H<ugU?3bR>q#Szup!%)>slMRf_Y&h;
zd~;iSZboYE*gG-%xBUKU=oN0;%Xei)P_15@;2KkW<HYdH$tB4JDV8-LIn|DF>Ym!b
z8R;)dk0&Xoa}yHktjbGAS7d(SVTj*|9DWHS7|!*te<7mWEGJ$vN4R5&qn#h*My{?)
zrE)>iYbBJcnx~#kn<AM2Y!b*g4=>y~<0D=rj@=$4WdMA2#C<h6-Kh260!VHLrwhW8
zUMYebg?w;zfm;?3XD|N~+(gKN>FXxi1_n*zC3>AXC16dFzR5kw?Yj92>Sv8q9!U%4
z8NgX_5tWs+wktq#1wlwE)J@cfAq@!DVbgmh+lLWaJx5&+K1UoYlP<{88uabPsuWjn
z6(^P<#av={;W~n81y~&lbXD8ne1;$<Aa}fdSn|ttxjg!e%)eBZw|$U_CVsj1qp<q>
zeoFQXj6;M!ubk!@lp2g$L~rGqRzUI^NF9go=P-HIpwvTB?fkv|F(ati_J2fYh7g20
zZ;}xjie_>`F4uab_F>Y0Nlr=wCzsAi8VSEF<jS2sA;*r+tDo(i9+&sMV?uGpe|PVx
zjZ>+WO+XTGBm^I!f1*YP@!}#PHw2)|=yFLs2rH3`P*>ba<dn6R`M|x1hsQ#QVnB6B
zSDn&}NRi8HU>JC0+aRreJoFp{b9eZr0GRCqBIzZ&^bU7qH{4nA%b|x(nfj}DM@VK5
zm*tax4Xc05uEcK>nc)OE$%{fX62jVw;$&)F3i#~+o_U>m8G#x0Y%V)|9#RCZuF<%u
zmufLzhhY|v8nT=T0Ms>vAUnt>Ft4!$<BHU(8e;g74FxYq1_6L~ynR4^`NJ`lmH*;X
zDS6`gIoWsPq`dtDw}ZvK3GTZ&`Sw>2%isUiQ_?@-+HjI<AZmc>bJbHTFu5&_#Bk!O
zSDiWZsySu5llzI)R$PXICP(B6P<#_?1SE-o)K)nGsY!`$IGRg^vdkca*c&w?3O$!!
zBX60W1XqQR&Et`SdA~gUgdzSCGFkvSQg6_Fh{#7%R7V0u4Nhu;2?&MA!s2eOA7VOc
z8yYO+jM{i17o<_pM2L|3BiDJIrU<XVMa75bhG_2v=LzCrCg7|t*lLnpM$RD;K4K{H
z5^zldvW{?Hv4ZmgAd3~7Jds6A|3pVt5p6LkE2p7?M0*hLMrMu9Q>?fhG7!XfBsgdy
zAPGb(SwTonjdY+5j(L6wKE^J$UC5XNFrCz{W@PSQT@h*@_2U(s7r7;`S=}rAhzC}^
z%Tttm+Cb49w2Rif7(Kryp@E9rcG*F>?SG~JGma0>XbwKpb8;ozcV8Xi$bmB-0J9Rm
zUkaFdIk)Bdt_Z&wUr$)~f2H|X1xjWFIo<W?Uc<D)tl;DPa95e;k5E)=*H1jgTt+-d
zaJfXJD(kQ`sc7luRIEB=ok^uwhZ7gh+n!OZPs#vXFIgP7o&xY7QR)C8(s_7zMfxW5
zrlaZ<Nd?^%T}EjY)m%eS4MP?W1qKfQNS6!GgUf>~p;g8b1`2e#64u|b6X$C)<aEI<
zahwb3;2Bg0fkXCmK{XAahJ64GbmONNaDHbDIZ^UT3gN{)lgR5t`rLBPDMRoSpjsC-
z*tiY=+Q5|DQj2hkc@0d8Xe+IxY~Ygk9Sf(V@zaCrpk8@lnHLO|r7Iyg7@J6}Xf{ls
zQX(Kf0yhBnv3viZR;qh&<1KC3RcM2;+-$@mSzLgrJJPLHUQQvpgT&orN)o%L<w|5n
zJ@TdJ6t}b*Jl1pdcSD>N7&j3lDChB$nq%^L*na>Ku7{cR_%EBk`|inKsy6#>CP(yi
zAUXj&MrNuoL~14E&z17x^TW9d{ZU7A2v+zw)Un(cx(WZfq;fDa5P1=J|B>i|6E%Oz
zfz&7;A~EaWK&giwK)M**KD`F~dWfUrCNg8oiDjzEKpXL2eDAcGK!MT)8=^9>HWeXr
zhS4KUd`Kj6O60*H2^Z;J7+4gg5je54Ifo1mvdR(rLu3yC6x*ip+j!Q&1T6iSO(yyc
z>4PpeIAE7Cl-}+cHRL)hgXdl%C5V1RYFgl+-#zbugWWE--x83i9SBh(V$(!jcMJEx
zgX||H=!oBe{agSVY!4*wsKJB)7@}PUz}~$EoUaGR)cT~Juj6{N;Kp`jRpb%9DOZsj
z35UPe3+@SjYQ4ieM`ZNiCt4lzSe!bsAc$+TwE$j3l&Uz_;c*y~)42a7Lslv_+r<8#
z#c=$(x>x+?^piP&H)fDkgkVD-5;LBCdJ!pnh}t+Ysw~7vPTn;xC3iofxg8bNY1)x3
z){XLT>ccttjl#&A-u~|U9)9?FQxUfuW9#gz;*`yL<0J8ePg=|KvXX%$L)|g!RJ@HG
zEGw{fBzm$BV{~|@a-J(dT7Ic7ih`p;9SNhz@b;Uco{a;T!NQJcjKeznhoo}uv>MfI
zs0igO#5hFY+HxCGT8m|JHQaCjG~I$?4;{&cCINK&k!O%&kUP+jA@xK%T^+71VfbpC
zNNv;Ag9E*GdBapo`V#P)BA=3$Z!Cf?7~t9_b)=t;$S(E6QLm}EioDM`o509NeTq|_
zST(o1>kc@-;qp2%3;&@bFOxe%vXrh!G7bG3`W{=Sgux{%7-;-ZucSC8*IZ3+a!l&V
zByvuIlj}&-B}vpDG1N9Z2)ynfx^-+NN|d0B+4JW4kxNo7+TGugNq8d!iOGeTKSPS!
zhv7ZAN@e;}WRuK5fKz4r5AO)d_!Zk^?(hZWOt*4N&g<|~Gc+c7Fe*ixyaAxa7)~95
z-+1M{Sobk=gIE6leL+dleZx%=$t;|Z{;7bxbk45I7R+`dNEk&Ce4~MsFoel;v6$8?
z_0M{YHCcsm!!#)eMl*?q4&!UO)e4uDP9EY!Dd`os=KS6|^i7AX7oE`c=u1R~c=rZV
zH>6Ifm3V$<d>2(CGB8L7yE>E*d=!6(5Q0n&LhubLOM3Ipg~J$Vu(X34x}mv00eArb
zB%ND#$gv_gRv9jtv_lHeQ%S><F4=Q4;=`DqQ@S4F)C}!mFvVktIm7>%O9FlCCa^si
zR4DP;Agw1-6l<bLw*r;R1NNr!U3vg~a0T2yrlwIfX=7?igc8&Nt=_1?*&SC@f!Y|v
zLsKF*f!mMw+hi^Y&Wi!X+WFDRYcOO!jWgJRU&<gVMpX^x;~hc1W>l`)J1@tcH~~<)
zV90V%(A{Ukr{7st%!z=EpsR=mCg(}~o=fbP*sDzb{l1{Q>}uObZ@T3+IdUv42cDfp
zGbjFxA4-2kaZHwCl5}HEZISErHLo4D#o#^-gxSaytsqpugxkUvi6hkuxr!@jRo7$Q
zMRG*sJ}Aq$1W@vZ)-lQnOs*S1_6|8s1tqF+_@Wbd_&5t#uZD8v@SF%fk_kYFqZI__
z2EkRJzls?iSL+EpIBXR72)xvKN0Km1PU3+T>&QF=_)4fD@*vTJ<d62s6<5LKggS>b
zB*y5rkgUOYAcb*_BsWsV4J1X_9A1f|_mCTE#f2q@EYEbHi$Yw3+wnSR=~J!f1Eb5p
zsMES;1+jcT2CZ@}sUxBqYlx0@WJi&i<JxI_)Kr8Mx*>E;8%jb#T?3J8*K=@+cL#9}
z9)#(=hTOTwkbUD^3rT{(fiz?}`oPD%qrd(Ib78k8%7gNcS~Ck)z6gumE?3=rjePZ=
zj$<3JTmJ6?QhmWc4MaWVay?IQMy95uwRB;GOz!(-4t-xx?z>{go&16Qdv8O0c}l+d
zjRVLCO2dFbW=<E7g<M4v&^zoXmxYg9kv4duFmRgrO+AESn?z$r>4=zj`U0}{#8V1*
zd_WB_6+SGwY509~sD+rU9kFL517pMk$1*YuCo?{@P&N3}fxG{d7{*{wBDf1c1K>+1
zJ2E$G<$AQ7oyuZ1cO@6&n;jeyM~HJ8$;P{PA__GYk{!bhNsNS%&el+Flt29wWZVZj
z$f!qlIP|&zculQMw3yec!-kY-G<L?v4CUB|vlXHkU{9MIm~O7q*o&^NAPg&t+yDj_
zT|6XuiEIF$1}MR*Nzcc-zX{z&fi?sGyceM3nNWS`@9iKMV8}JfMP`?m<}iQ&;AB65
z{=~DAdf#bD^u7}o_x)WiiHc5eUC$Uq41k*G9hci~8<+b(e^_EeYD7pim=GUq3fBM7
znoqXO<yLOlJ2DD23{s?wY%C05Tfz7_oYG_Xydr&1P=4&AZ~cYcI|kLxhRmS=Oc0a4
zSswk?Jkr7rLS&;be?6zxvnGT^P7N3`<d$?7(O>EAlx3-bl&>xAoi_m48<*uJBvGuN
zK?u<VBo9bHl9G$if%ejE!+G=O24RuLq4@X0;6mU6saPfmjC5O4D$WP412IeL11CKR
z{gZyhldE<~)|m{9<3k-F@cI$q>75SBRj)^^dxujln+|UPPaOdNba#!^B4X9gACUVO
z2ITo;c;NWi2)J<*`dxn?x>z8Rl3ZAnyo&K7($cM|;c;^C6_R@n^wgzydt8PRaJ{&h
zEssb`F)uk}O64nvc44~`&b<Zqk0vkbytRHvuxei?_2ia?yK;Milpm&%7BH|&P&LTu
zfBj##r3b%taE1O#=+~<l2m$l)lTRFZ@N4p>|Ak>{2yItf?9Gh$x{`raq@Ku}+<MDp
z^6dxCs%`j>fFzM?hVh%4G>07AF@_SBAW{QOt`I;KsK=hWO>g%~)9(q&-Pgq4iP(X1
zqN-9?M;tdcjuP0NGMMnl3&&0=P==$3L*t`WBCT6SgH>3jP3WA++JOio>GXUp%CQ0^
zv!{_X+d*ct^)yXR$tCAc*<@-LGJ+OSrhw~<Veqc!4SDL2$w}xhTwOFI1@KW!Ei2v4
zT*uM|4>E6theNXeX0O~e0Hu34AeWE8T{D?Nahhpq@^=V6wsc7?BGc*QoQiS~+^0`a
zkA$Tiu*))>?#m6kOpP)X4-Xh!+=ddU??D>cvyY#UyWVrF?1}D`NB--VVZ`L{V24q%
zkWql-Z?G0-X(f%C9k)ufpk6&NfD}HgV@@N<fXjjIvK+3pv|fkvo(&t|W`c-cg<)kS
z>e_Vokh{{yY9L%`tC-hbDTvH3Ipvq{ZpsAIf$uyHy>bG2@FHDX=qv}WY=>u|1Gn4S
zp+A@GJ3eGY{BaursfmCj(eQ~3UM7Q=Psz&Bvl8v2>+j-o(HxS~@v(8q!t0>{$z!mG
zQKnNIVT<eUl{s|rQMqTA7({>Tol|$R82~M^j$;Q3jrL)!*&txw^|#63<UaYX`!8j2
zC97KK*->C+bUW)(eAB>L$Ia9YOEq`2a?Mn(BQ$WRUp1gNQe2bFsUgVkm4#*0h|i)o
zB*fW?8R~fsIdvYuguY!@zE9IxO|G}^riR?nH!RzSnzCakBjNFwndvj(mF7B9$qEZ7
z+bu#|x8&qE5I#(06jvq4$xR79ZNv=6p}XS2-F(}yR9!83@`ak%qk}T-Od-7u{ztg6
z2K!ym74vfZrL4T;UtKA`@aw;?dK)cvI<oxDhoq26BGlK_S$JLOkj9>cOtMHWF2liY
z0*K<>4<~34MvM#kY!scig7J_HY(ujylrU&wn-|vqWHV?$umM=A1@uOk1E1Sc6-Xj5
zz+dLIed>T+21b|(MBgX5u=%?ksEs7o0`Bvv`)#r7@0RAuFG+CM?aK15p%g?>rifI%
z<8tHvfZTr+phhxCk14Iui_?psN)dSlK{;A7#q}D*b+cp+GV=hC7P+=EHJ!FI{|d|Q
z)62I`UlEkd2=XImk^V%3`GU&O)Ez7EUDD7q3Uc-KRasgefyl;?BcZSfeI!J2Ntn=u
zQk2Y4>5ps$O+ZqwBtV@I-3Dr=o2fNb+d^HEA59vdTBjTthL7-;eid^c8|bJ6o?g`V
z^pARFWIGaW(HNk<jye*gWSOn|(EI>K%k12oEPgd3r&0K&fw$Tf?*uqQa>K*mz@wwG
zeRM#sMW#{HGbTIwTkvC|s|2D}|Mk8X!Q~bakU>Qzz!(K!NoUTi$T=7<@4e?;^1)yE
zJ1jYZ0d-b}hWlmc13xWC{_!6rb#6u?u^{}ah^WBup|0tHPu1q@MZzxzRvBg%tmypd
zoGih54=d-s>4kv%7vKa~;V<+fF7F8;jEe-8=wJ^33!Mf;&=RcK9Q?+NvH`4A2Le^Q
z?4JzC*<%YbwNvDccbSG?4F+EteoKmTq?f2;tRfgtd*DCIzU$wm0BLiLWBD<Oz+X(N
z*GI%a;_mBjJ|>TR+uVoE4VYZ)K@vnc?UE^XQnn3^!>M2F_B86E7W>m3h8jwdp+TwV
z*5C2HGKXFfl#{oQ|EkRnISDeL=vI*c>hm82IB^$Ygkrn_uwRhxK3$QJ_P=1;Fh+X0
zfmABToTOp-skVITDCR$H=&(+t1+*4cjw2P#Tt^TRlv<xG)?w&C1lVEuQe5;+jLNRT
zki`3t{o<)Xp*NE(3XnF>pIVkwxg|#Kv<m+*B)GI>-aIn~4DJI?yKO2V12EV3Al)lE
z&?g-fNR32X;va}f1P!NpqMNs*fF3#D{nj!0#=}`8#untdEBcY09grN#OPS+1JD*m5
z)ZhH$k98YzJq!`Ms7iftCGygW-Pr%`ciWbpe_qaf`|AiifKw!t`$Ao?0bru46(8gb
z_`UM_54~A62src7IcXM=L{d&k1<e5}7tp{8dzjZ@-YXg|yl<{R6oVY<kuNA=xX)~k
zpbSj)NvP(M9RSV#?S_nuUr>=Jf>G<;R7=p$Ly2(CPhSp6F@Fr%Ry26-hD`r7I3x5$
zs8)6_Vs<ce*s;XhyBGEE8F}jA<8t|AOJ%epMH@zr7cCLtJ+YPLEX#>6W|DZOrk|EN
zW_}q}s{Z=zxROh9%grZXUaR`gjG#Mr`8-B*PJyr`d!SP+W8MrvQ_rLrUwYv=$r)2J
zLcdv;nz#}qqN#4R^Eo`|F5naxVVaXe5|Au^SkJ7Akvxw&>&^YWh#MC4u^@Krcv}Kv
zwUO;T%8*!0t;^THv!q-@7#3<vay|XPLQn(9UE<q%<?4MS5(h_VIR|7a6qml;rv4ZU
zFGw&NK#6S(T{vL0Atu%==b#tnAZ~GG7#Qqh`M~GT$dd<G5ur)IIgLaIbii1_KnNi1
z?eLK~<*5I}r|*@^ulqG{!7qYaoP-~5x175G)dhgKcDvXPoJY9ky6bFJFA{ve^#H<*
zK%pWu{Rf!*@Y~uDyH988a_pgJ<o&<>Q}X7w?v<6fCAHP;0-DgktFgMetn_z!IvVRq
zv?R<U!h^!K8GX09au|DY@YRrm>Hz?@qjSaNM}9+QANq=P4xN+(=*zB&I%Npz0R?mn
zoVbHd7iSNBK@xAi2X_|3z<wvfjdP|LPai|u#w7_1CFI&&L4Z;p#hfxLe{sPpQ~Q!U
znp#NiNHAK7Iwt!?IqR=1!Z*=i+4IeJZu=m`wes%UuY#;aY8rf1<eaL%4|B3Q_sa`M
zP@3r*+t`zUYye0x=ogDAq>Q0>ohl-MNKoq1PVP{T4N2<2X+&=D0C6}?^gSAAt71c9
zF2ix24C2vnU9e<e$kmqTAQ~7`?)Nms1;;qjPvnZLdnJLu^h9irw0rxM5!T-a?iNDz
zBO0FuQ2<8WxRPI%dO8hGj<+>HwOBfhbU7sPqE=t&Uhc#oLTM16*d_{B$c`u1<e8^W
zOBGE8$_ATaAwd`&Ef&tKqPE76d;j)pa5_(W2}n|G@JevXf&wJJvuDrkyCb&M831wL
z4(N<Ot@KQK8hkxF5jxE%%bnW}!lzPBE=%F$BPiUuQhbedgi_10vo9`As7CwtPeTNv
z6aig>^SKfdbK$&)uQP{4T{fZ0tgZ+FTLO3+X&5DNv~RQLkP_IDx3mXk@{ZR@=HLnb
zl%j2W5mMbhApK+ga`y3402Gda!F~4ge=nEc{6Q3;-GJXmoi_$E9sM@PDHxgiAi{^x
zfME_EikMu0ny{@0z6VrAvK98(W#n@%Ey{HR{c?DT=Xx<9^>6d#0CmIliX!}ypp5mk
z?y=i<pz057L*}5X5sUx}IH##=kgcOz#9CAmJ59Zz+=y)$DNSUIX8|T3ZXzQM)FYLV
z0|z4==JZjfVc--|PfUFdTPP6fbS_3N=p1&IU{%BLa7M#21^}j!WV;4YHiWqIK-`e`
zfBZkl_RC@$pwk!4^Q6^SMO&6;GXjpH*FgV*o5O<$1<3|ilGj!2a!UA?(5r_g1vw@`
zdDpMP0-iJE{+B#5K5D807v|RF>MOU)hyLhu2m`vjwc0<Sa|E-pO?^!r82<=JQV|*7
z1Cw64Ze^Q1kMGnoXTSX*x@auJCm9DvM$@h)YT%K~Ja$<xobkw<zpw@o3XYw}J;43y
zWM{BvLHQi*9z1v?Jtz7xkou9#0;hSs$=?o16?p)p=bl@VtE%5bD6uV{c+epy9)D1-
zddn{$8|c&0hpNlYZU<aoaq;fBURrB&Y9DRzoINA*^dk>L9l2A=i=Tk?HLcbgauWaw
z)e61T-L9+T*4L%w{x2MW#lw76zCa6ZF>uS&IxO!#_^};Rs-v)#Te7XSo5{!BmjkeW
z01kei`T@(oO<vwzs6_Xh_x!TWwg^^9J_j;zgS(!7yJI`J&WbD@eL{{dq00p7MMzDE
zHmFFdp+LQe;w!idyvU+q@&yeXw*6qCJCiSrfe9(BuZZpRL2<)kCI~|~43iYlOG!m1
z+%`0{M^^YUTr}~4giQB(<U9be0IPX=cSnBq-~6QPy>S#b18qq<N$6jw23$A;g&b*X
za1l9S<?@CE;`nXciZ;q;2|!XUTSgUN1v+wb6OdR=Ft#8S*nT=R0C;v@l)cy2P)-{a
z)VZM~V_B}caj)F-$-f04^Kg|ti(@BnUFL0cASGuZwXgw5{#F~(0xnhAK7!<lR$7W}
zhcU1l1HO%BDw(6ujaknFD;fG`4UMYWXlLy(kaLO>-XfYUl%P`@xQAuv*BMCaCI(s_
z-OW}Ov$DE0E6r9_^6-?Gas3Vysj)qvCo(Q0(=nNDpO+;3sq>Xtx%Q4XN@HwXDi1#|
zm0lYXPmt4!Do+P|l|c^%Fp_;c$mpWTIQ!BGdBZz@RouaYXmc|!F4Wr-3zVD=JJQ{3
zQ4G?CJoV%<GTFgE><FY_$i$GzGK1o~2wDsVV8o`-`bMqijQ}~AA_YRVGgK;{*vhHV
z$DcUy8MV;z5AyF~qUd%yRuu@9q0<GU=8&Dv9FF=;Sv;SGiaD-!rr6d*H&7mKAl+b7
zTip6pbWFaW8>n&mxY~tcT8Gy3F*qfctV6Urpz92dp-8@t*MFeQm7KL_cLXI0(@LG-
zwmeU75LSNwn0SG1UkqM9#BAx#s8-z2hcUV#mgyAc#|8_5pTaWS7T}KTe@-G8`LPm9
z8-Dg@;AI%k%j@3u2Kne85ReN1<VyfBey2-rmlt{^21J)bQm51(ZgPGxBV#>w7#~?%
z@r5UB(X|(m%~MbVkd=<rwyB2=4kOJAt*iNQ2V=<CfhWNMr!$&tg>hYME93B@;Xn_1
z7!B@G%X<dKQK>lqV<&;m!*SJ3?&-7W8HAv~d*9NLBZusA;lMYAp~K(=crM*^=w?@)
zIoB=YK#)P@0>IKAK?`l9tT7%gNc1IDlc$yL&A7N38&`{EKcv)rH(7+$lXZw|a?9*m
zUV7?F=0=wP$^r+YAaNcHU)AqeHc_)L1LfGL^Bz8Af>7y?u(o;g^*q-Vk1xydc|<-U
zkS`XZ)4UERZJ}gl|7b_Kwz$=%Xf!~IrcNqdMSa0PCMEF07_KJz3?tE?Dmz`tw3NX!
z47bqO(3LX1V@PdQ@4lI#R?30<Km>!@C?O>goCGA7(;>`HLq~t0Qxc5)5SS#+lUqt?
z2>Wyg8j8lesL}a_U*0J{|7+jCR%!SNS1tmi+8O^;9d{RudKsq#Y7;$=nl99*<9t)k
zpvfx~exutr(%pd_3@#VzH3tW4*hwB3Z6p_T=_&?g3kJ_TI8g=f2I_&$$q!$DvJMvN
z!ZkXn*nz?jk8N9@9Lnwm$G6K6l(Yk=66Le&f7|t9ykN+~&mpV@Vi|`HAdKz9Kte)_
zCuYcF-}*yDDc>RfAyY3@{z@<?9)nmQKCZp<7Ih5$kJlfD%c=~^e|5bi6OfeDAFW{2
z+ftNQ(VDT8Ir|~KOiwQYC4=RO?u{`G8gnzvIUC?|)YlmGu;GEb(c@7Q!-{_Q8X_Df
zi>B^K?x;B=x8pK;`J?mCgWDiA9}gvm)F;Mit)z5HET|&u$BDxI0Ai+V7=5I{Ns-B`
z_9M&Pd;n_UmVX4ICL6?r{!T7QPO8PY-bRCy-;D;;3K&RgP&%&Fn@ISwE7Uw)KCeU-
zh+fSp^)~vu%Zu6{s1~z_Uy>#UCb=Z9lb>1>Y6g-##<#l^cZ~G2d;mUHs6;M=jR?Xf
zUKUwF?NHC?HavK=hFMvWB<g-h%-Sba5w2vDR}vY<;UqfLfm`0Xttrnu4zY`87rJZ+
zdUyvuTR8H;Et@H1kM~_C{Xf2cBXK1>g3O`E9+vd_BT&oUsS<wasUYzfROM`)gEG-q
zK%^}qXBWUtEX3ONdK!I+AT{~6v#kaXLCWO~#6r98^s($s1KUDB`R*&;$*=l{InR;7
zlc?9DNGP2~ROeA8x?L!JC25PB^K89L(XB&@1R+0~bjEoEC8<>yG8Em>ZrLXD3$0v|
zVM9m6Cqunxtp|6>`dR@FZe(E(T`gndWAw185o-k}!ACEF@)Q7!nq%_!ZNVuMoXC1n
z-ys%h^yv65m+5(0?0Qfd0H&&Bq!$82;MwVi>k`Gbl_;`F1fvEdzjJwVc0tz9WyJ`Z
z9FWU-%{4S7Nc5tCRu8x{+5wU?wrfx;07%ZmQHV0*kOE(;l13~W`mQ^!midu274w-~
zkKB}>BI1kVF|_h4#AL2GBCo#@+4iu=zy0-j+_yft;tnL4K)?U;<0xT12N4eUj|*XA
zO>hdRur1@^ZrAIS<xLFeW(%CM;Q}r4%dgt0e5%}+BAnbZ1QmnSf}fSi7$hq&^*q5@
zkAxw@@7bd^>i)Y3l$T9)?$HlJImxk+`VJ9JosCHu99i@E1OR&R=!p7LXd7ZSPU6W_
z;Tqvb6Tz8=6LzqEUWo`MtTN?{+)|4%GkFyc9`_gmLc+u33b4Af6&2Hl7fHtV?!*K1
z<6Lm(aHBYYc#b?jg0YUw7IJiw=8*avs!7u)NsdXE5dD*;j}oI9BAoO7&~9Z(DsF%W
z$cLzEy^Rk@t}t%|Txhgv0V4HCtxu8@UWzEXLx{#K&o0BjhaO9hd6zgaJuE#&Un5PG
zd|By{J`Yq2l*Ez~vH>i~aIjS%lA^oI2*MOp8xprCaUZ&qdQlhk^z7&cw><dJOG+(q
zT#qIMNbqeSpOQJGw7{ufGN-f`nM}-rX9Vb}hyD=&N0Wv2E_Gb~)4+80jjMaZ8lIlf
zh%AFM>OshQ^8^x9;CoZAMxhATqyeeFbK33vyRm2klnjzPJVS~zQgqqv_)&04e$>2-
zD*((NLM@Fkp+q;iWD!l8NX!PhfZmY?8bKxCieTq2vTy>^$}Pv;^J;t6nP{R2BQTk~
z%K18^lDE%~QI?R>B6{4wf5!-h52d(M*X&ihZ44fK(|Qh9P+S|ZNUif+My^Ri$kW@a
ze3dkGnh2X&N$Hl*CkZlr^OY0XwqI@5YM$F<an>C%PY$8EqkcHtgn-ndJ3YSyofhsf
z3|c)9DY^#-oHBsxts?@axT8O;I3#t*Cfa3lu#+S5qlvmZi6Ets!_r^^l;rgHs;(nD
z2Fe(^JJd3A%lfI4a_|Tme98Ny_X@N$girav$*x80f1Q*gdsOH#gR%{#%B`PI%FN6R
zN_F3$?g!m~U-`@<@;CqPJM!)OO;1K_Vp%S~dSW9vL${0ZfD5Wlb5Ogq3rL*^{_(Xc
z<dPbok-^08=yjZKfby=l4c+Q;;RWXqi%K-&a`b}$VL+b0S6m4jlU<)%f{O)>G)b;1
zwmJWd<PSU`um7=MLYIr(C|$V#zKtgG@F|WD<0jF4fj7?1xB3wIS(illxbU5Uz9|3z
zKmbWZK~$nudKIuk5L(4HkIUjM-{1fecAb($c!d$20c1<lz!`$bB`LK69Go0opQl=;
z)?WNigOmxYBm$D;Mrs#H>y(w^N%h_OPuFvEStOEF+?U*OD^aW~V}=F|K31aWo;!J7
z8t6)a0z6ZP#C4NA=rK7l6;oEVs|!XYvayc3B%<YtE7G9J;yVFqB?486bcUipd@C8N
zMo9%ME9KVYTXUByZn+nh@sp1nRQHUfz!c%^$UzYv7(}hOXGUzjj*UV#CU89b#V?^`
z>WxZV-}iq$E3C(7AEU!h%*tQ?)>jmlebXJ+Ap3qu1vk_W;~%*t8zI0k1U!`#2=zKn
z^^2wmPS$?Wp3&>o6J~Jy>MO%abQ6FYgnA=R=>n;pdqT3d5t*JSBetEC^qCi>a^kR@
zI(<sM{;fyl$8KCxEkPD%(duvCkaBBmkIl=3cTv3$@CxsYIwUivyKn7K-w8|-r*s7|
z!IzbAWkfFWYp{kv(F9(LvS*hP(Q1MIN2R;V(Yc5^CPld>a!Gzjv><7H(>=tGCJj=4
z4<zV^H6O6zlCZwD8zh%UA56=!xxE(U6y1!rkjNQH8k`i}sSC?U21X7+6^XOmu<Ysz
z5|okfF*F1xI9_!}FjDmLL!FYO#Wv@IXfGH>c8(3AnFb{@`cv5kaxhV(21AHkliTQh
z$Ym$C!M~fwv)I*;H(uS6mFJF_c?^>~ln5^^!svnTmui_0%Xa@*RQ4xCc0l5e4~krP
z?4KMoc+Q>Khn!G1oaR1x-J5pEP1iViO0u*t4yKco+2;=_x1H|8NoP8_CELaLiwG?u
z<Vnt`Up`f?c2$k;vc7@xUFv}Nr$G7MyWjMSibLYzZg3rPOnleGdEbuz39XYea`N$K
z<&g)E$lM8Zc}4bgY;c<#`oI4`{^(<0!FyUpWam}Lr9&z{T^m>4aW?|>QRxGhoOB#i
z*(qk}f_Y?eNh_yhA_bESXy6nU@NO2g;$vNjcWf6*JV#%4P8aFEI3yzun#dtFm$d4a
z1g3Tkaa-z_6y5r5vr12e@~^q1-F~||q^rqM5AM8$7+NgB(d|bsN)o|X>9!dpK+~Ad
zq1QTzksA&^>dho_NfH}<@k3xn!NC;4z|kU`;+h<=P=s$2$r_|4GK=_H7WF}cFurtv
z(KK$$sV@vCHw>Oiy;sg3*sk0|USx4S@z^<ti~UN3Q-5TLF*%=9$K<~?mNtXx-Da&c
zc$%Ke!5B<D%$&um?f1Mv_TBzt^4EX*to+q)|AqAXVOSwRv3@=+Swy7rbMvw|4>uNS
zmHdsYIv$N4zV(cxIVI=0Y^F8x5zdno+@1E$Z^65T8%`b4T*3cZf#OXM_#c$d{_&c;
zfQSGK-B}PdhWx(>$`RT~SPhSkOJ;FhRxcDV0{ier)uim1-iB7r%W{6XDsT9S{<<uP
zhmKpF*3aM2;+s=C(J8uPlY`2@nM0=mCiU*Q5}7Vg4JHN=vxZSavJM#iojyyWMSta{
zUdeUZ3a2}WK1%|UK-5&oAlU>&$9Vt^18nRr%mv_*B*WORj2v)ReM{7G{g0x1D-oas
zCq?(!7mi7F1<5C{y1mHHAf*aOUYHEY5W=Ob0}4Y>BS~CQ0lFa_<}Bh=mNu4pVAzn#
zMI?koQ7{bPF|z4|0i^Xyb{`>7U2waxKLi{clEi=rxdL)1JuTzYi*OGW<ZIu2Ufy!o
z-4c5<k}D1`%3prRE+eDx3S4tNe3o_DJCQ*XSo{`@MvCyGFWfJ$AG|?To!Y!HG;PSr
z$Tqip_VY*O8{bUIoo@)s^!9DYcYqOyO4km0BdsE3P!~e^5`G!ki>4DX4rs7plBb&!
zhuLs6(<mf6o=~@b$4SwhsXpS(9K%VldHovvUtq0$2!<xtSB0Xue<XnBPAB9uf9I4P
z`+H>1p6=blg*TCj4IT|W!y|EY0=sbLgk<ss365`<Ck`gXSbA2XZ+efsIq_YOJ@1A!
z$Jd#lQ9f>}CJjjXE1B-ExFix(Y2ZW<60>21PVGj2Mhhp``&y?I-P!=wBAcAj$|bGa
z>v@7vJIx7tn{fodGy$o*tkKBvB9d|`eUit~qMK7DPLQ-1Up_mB2MXP-wWNyOC>dCL
zJ~%Wi=>{JZ+qs(J+Vo8#pA({&`lJ@cJRZSEuBbss3!I|d<3S7SuC5vFH4RU_4GpK!
z-Zgot6jzq^RTId5`r3>fJ&gjgJ=cO;qT#^dmYg`(lo13)5EMd-M$}9pyqP(VdY^<L
zM-IZ6xn>B@2ENY&%SgsZ$nSjk0XcnSRc^ixtPFZSBW{{n@P44h6nvcM$C<^u(y_jE
z@H=RWgVGNpgnUrEcnh-K;qR(hVYi3Q_HsV@b2!FhPA2m{`uB%X^goZb$LKeX6fP3p
z{D~WBf-mkui#h+W-1fRWoW5y@k(kQiL$_mAxhm@LrXVeUY_eD8XBN@G9l3z(4H>w4
zQu+|be)!Lis2b~?+YmWN=ZBQZ(Us^XC`q)sZ4=uSmz+7Vq70n9*BUZ9dXwxJ#RH(|
z#BUNfieo~bw2E)-3Q`BdKLS#Nlgp~;9;`$)tnN*XQg4mlhSS{6my~J_31iKOyiZ9F
zLyli`EWH;&O7Tn}Y7lZA#W$BxY}124?!lf!EC!?Ni_UWN#gcjnZ<y#IFbO(xQMjiN
zDs(wph~JywRx9z3dL%(f;=CDghc8oA7{YUbcGea2;UxK^Q3cd6qEtTUb_11wJd?Rv
z?s)xCx%I`0Jo@!#<nrm8z%38R9nUPu(`O*@77mMR&y{Fczy<_m+zBMrltr%IiR`<p
zpH)GVU;5KisHHlkx|d8stzt7UKQd{mC?sq$aiL2DB*~51X6n(b(T^MJxJD#1BW`a)
z0}BRFSjv*ZcAOvEcK!RnB!AtReBsc$dm<gVZ09cIMxt>$<z<(ccFz|RonJ;)@vt8`
zcLh1SN}+&qQzSV+Mx*Zpnt67i*}<E#O30WQL)0Y*tFVq&ePwegSwH%M%oY<eSV^f0
z#B>o3N_8swmtch88rark8~SUrF+2?%7S8*StuqESAQ0ILegd)D72gCPss>D7B_>Ql
zwj;6Om52bPaf3Hw<IE9F!ob$yMef5_G1CVr;F5||AIcQmAy={Yfw`#bG^hJVrE9@;
zw3c2J=05U8_HNXv>+~}2K#<NObVA>xm6*u9YZ_rfyaXVv+l1&1;1oyVA|9~WYFcwl
zt|sV6<ciRk6es2P4JOs0UTbn6f-`^~P0Vm-@1tQnyHkrpa@%!hVDJ>=V~-z|{QGW}
zX#cgc{l=7h>omCKQcG^efb^ksM4m9qC<b@h<sC3?R`4dczyB*pu}PO~AH@1`=$?q|
zxw<9AJP#L|AJFAxrAD~`W)y)h7QF+2S=fB&WQ^+okZtJa)H4=D`kf7x3TSp4waW`d
zym_QrX+KKQlEzyRtbnXSp=NJwFMzj-c6_NUE)rQKcH99cy3Uds$ZTmt2PE-?NC-s2
zE#Z(AoNxvW>ka5sKARUW6g4gG!{>QZIW{(ly5zzvbjd;FMZ)PyM=T>a{Rnrt{QG3b
zE(}SKiZpe1qo{5mPml>0CLlG>?rwmI=8^<t4IwzIabxvS(k0|Y=64{pYH~>e5)Vg3
zauENe)0{?*wzRjVsS%KxwD_h@Nqw?{`$jHF2}CYQ1BZs(z;@&i)cGPLTG8-v(nkrG
z&<3H{j21PCB3z4cEta+Od}DjeWK(E=&=unjG)<*5J%u8&T&AO}`8ql#A3r@Mk=KWj
zFj0^vpE#u)<I(Fxt_!#143d+pvo%=p*NR*|fNXS;H(p`#W0sj@@!Va&1Hs4-sn=(&
zFQCv(6PThR<aDb-HamRT^=>(~-iFg=3ptlCyaMQ1O7VXNi8{^dTFM@r+W$0fn)PKw
ztfnIvNvx_%gwT>0ac$Pau)BlPy=f$<jqp$DmYA}JL=y|3NL8bz-dm`b(;cL{LePn>
z=f|MCk{WnhgX-omXs9rjj^Gf4n#eKT@cEG(c()7zxb>sA)l-UYZQ!_&0HOVpG<0ee
zJPcUe7m?zY7)0O0X-?72zUTque3~NM6yrLqNYU*@LNJ}>tQuKLIgof^a=hX?)DMsr
z$(*OyrXHxmjhGUA1R_6l0g<R{>SYAACiP-c^qeP`B#7zPWQdY)rC?@J%r+zE)=)kR
z_YmXZ&wlf;Qh%5U#R$*SPoW{}40H+*yBJ@)dvmZIKV6Vj_*q*3W*t_P{`g=y2O$xt
zzHQ}_JP!S^E^tJW0wI8CB}!9L*n>BCGzZ#jRABc;CZ3|quNTk_7Q&5yB-z|}*CE6=
zbpem!1jC4F2f!^YqgibU@zJ%@H88u2)r6e1fXoxV-9XnQGsH;!O1pxTuC)!Nuz36H
z*<~ohT?5D8gObki;f=#7?g+8XP$EB?$O$!Z-uj)(30CcwwE86VKGiBx-@qwfM%_pb
z^+{UpTa6rkr-e;0T8a83qdN1aFDTJX-JE(edr1z(0<w1utxX^-JcxV+Lh$DSG=3C=
zX{R|kqyi=mN|z7;##fgRyqaqgj8({GTHt(bUJ>C!k^`<GzBH8vkOL8+3PB1m7hoCp
zqAm5o^?q48-=pH;#Zz-~5JpU=bDL~`9h~?uY7QMbD+hn~EArgaO<5_K42Ge|#}7K;
z4@GZKOM@%+-6T<;Brz~xr6N>8^gKglrO8z_IIY`o9zE{VqPnl~0B7v#h2hS~1+w2X
zs`f}4kkluGD5T<Ny@q-c6l)FiqZ1dJG`$j0uOyL6GREtG?~KHBCQTcL4HSM_+$@Pu
z920<BU&t#1XLO<?@#%f42#aEyr3_l1)Etq(WI7r}Gu=K`Fftq5O0>WUNTpY%P&xqa
zNS%_OD&AooKvkahOX~f!)12QKg0+&0cSE<-q^)m$H}y*RD!Zb)fDkNI6pC&-%iZYs
z#{TU-)L~F`^CQr`NlheEG$_j9ucR}ap+mR50BaU6LG9MglVcK~K6Jn;!DmSjdI4+_
zm$Tnze!Z;3c?BtA9lWox<1m@Y06Nhfo-rdlw+`6k+uu5^xFzG^cT9KW%we+yB5QZD
zd8DEt9!_u;szK>TUr|lum=xv8$blr(L<7g!F`0xNZ+4Br4@$Zem*nzB2Wo~BJ=Iay
z(=v8`k;~LjpkC>~!F))GB9TM#-7RV!U@hekEdW4CiNGdDX`=|rp~@LHxux0&|2%Me
z5ST7EPuSeo=}D+a4j&Ms8qAKNIP0MC)!=1sQduUflQs>Ui0qv1!#SBQ4jz{vyc8!S
z7o!L#(GS^%C(VhbOWf89P6CoOIwTr44U~D1e0bM)e8L<|+6Bb^=GtklHoC;WWF9Xb
zMayft(ySDO=Yq>9x*hmUJqV3fSd|4=A=3CpGm^^*D;*!c#f*_0a?EJlu5`dw6;6Go
ztRX>zAx8p~Vw=FzoU#T0^F!YxKjfa|j-)mQq6RCw-m&3+$d-~bD?J+#p5<qrRri(g
za5lSI!)?$`bGE~2^dY+`Gbl@VlLq@DF?oc5Bt_64iK4rS)`TRwf;3T|q?$*4Qgz4c
zitw%6(u+6#lGasrRP#9J6(}S7-}QC24k7W)0h;)_Uw+7bd0@UC&VkX&n;XJNCRMS#
zjpzXl9Ex!*!s`%M1SW|hyp3!af}SE=lh<C6;Y3@tac+W*{N!6u_&=K2FmPgn$kJg{
z3Gr>MH|l*kCC60R<NzW8NI+_EYKJ);+jIpnL#Wivrs2L6*KRbZ%0Rhx>VejE1#KER
zrqkSN<Zxe26w#*DO+C^q>e3vO89@vyHsEpKAf!Z~DC-U3b;J<cRha(;yb{?B#~?W-
z4IMjPu0&#pQMreZL%=+O27&?94H?&_8236&PDC&gbo>yg+B&BQCwFw<evk;(SbtP~
z{75fcg=PQbqx+S?Gu@k$M`u^+xp{M7?HEV@%GjoA#GFf(GQ07twCLv4K-mbdheUnS
zK!UfG%6R6Ks9Qluj%g*Xr#@M1h8LC8#!3~@ak)H?7%1~(F?$uSy~tNkY!8Pgt#7LV
z#De#Wg(7YsOGdj!5rL^mrDt_dnj*Z@LKofICYL4m7y;fG=6doB+zV?bW&WI3GMK;l
zJyUY|kKcxN%rHJ+(3tw;rryZkAP5OcD``NYbCB4;IrA$?B$6T-0OhpW+GZuAfI||H
zbeLCBOO!xDEh<^MnlX+|g)e@WI<(92sLf`HlXD?OH=|tCCu!u6wAD>FP<CZamR~$8
z4RC=L1}0M&NK}2`oWb>&2A~IZK8$dXOZs7m5RBxCB<h(I>n7MBs-ZkGx<iejfdSrD
z#^|QU!Q`AU8Ua+CjXDMm9}=TH9x@xanqtw8OrTb#xa+36eej6KF>A;p|MANnw|h?3
zP_GkEZ>carsk_z9%%b8HK4@}Dk~xLI#j`W@NmI(u>Q;clHdTN&3Wh?4mR%>Pk%tOb
z5IsGbJ9h92LXVg3K_;mL|BlBdDNf0Eoa8#OXV?X-i~zrf{b{<y*QJrv!2wztJADaL
zPhb%|iLRlF4yE9G6U_*$L=oOH%#o;DDU*AU9(~CsPdyJ2g!v<fGjiX7kQ{iis+`Ug
z-SkIl9nv~2)=&%vJyMl9P+tT<wP+{DBp^v{FOJb|mZh_T)G~|czLY*$%Z#Y~$!Q7p
ztws))Tg5iZ97wdfSJ3r?&8w)s&{0mq&JjTEICOKqnwf)}H8|vuB))u<IwiRy!Klk1
zxGvF$)Io623+LBVEL(F!azb)IExHLjQg5$Y>6DD@Q0L?}Zdmk6_r&oTF><z6#c}$W
z=P&MU%HJHbNq%8TK7A%EUwskf2}sb;o$Tl;T0wQe<42Hw=)n6N@w{nu^G$3die{@T
zNb8am-7rTLXdO)$kr<rZmZSm6dA*GKq$f0Xl*>q_d4(DO@a~7mg83Gz5%|;8>wLSG
zxONY52flPEjOsT2up5qF4NR`1_~wT%0M+gwEyBq;`Ht&)+tmH&20EPd%IrG2w4q~f
z8GgyZSW|XR)a5&0TaX7n_1B6+(&Dy~))T|1@1Wn2nLh*}mlLS`Xfe$QjV5x;1`Hem
zlI|dKO6rv)opH`yLz;ZOZ`HGK%Evb5^$cA>Rk$<gkJQ#Txg|yV(%A(xCV&fN74HCo
z2vare7+^FYHFX-OAcP24fW$)1YckNuj>{(}(YF)%1P^}xIjIy7t^>y=$7$i^p;UKB
z1R=Sp1|Yd1-AW{KPp+dBBse+sL;Ye~n9qFtQTfEDLb81d_p51#epppavbZ00$%!kV
zx*_C5|6~<Syx0SYQjuJ;*@0mNaZXZ^JT<rZuZEV|G;-**DM6aN64~&sN{a3UL<=dc
z^>!Pe48{llfhK(&y>)15Q*77q)>D3H=+rR6xGslRh{WPR<Q8HVF-=;p<ag?pI@6l_
z6X4V<=?<!(!vkNs6pu3z!{oYbC>n&}v%Ut0{=%|4q_(WJ$fglPVquuFrU_2y#6~f#
zJ{pY9{5cgm<hJxf7Em8ea8iV8BZvB=H@?VCR7n6+xJb+)q|=<o&`xu;0{_T0>Gq*M
zsk48ypOVoXrfX$eXe~W!-X|x-Sj3M6Xbf^6Txtw2($HzP@W25^e#kZHx}ooq?;mH?
z;^PmUkw+gmq<)s=tGVPEW$;jE^vBG|O#`p+Blt7`+4P>4H!XC!i@037jp#ZuT>Ub0
z6zU1+iiwJPMGIfw!se<>8D!XxSwo88r!BzpW;Zw*IpmULLhS58|KlqWyNyKAOVmmf
z+gmBnwK=L4|FhONl5K2BCDV@A3TsP>);B+u3@#WgRtP8t(yNHlwCR-HLLIc1-bw^x
zt=q1d#tz*@1UZQ=Ahthdzi#$kY{6H`9ztvyN?Jr8ptU3%dmx=qL93cXkkWW5l+acg
zfYd%nt|K5rUbI5NlzJqAN+5<&d%@2u5{w)I(&;<_>vE6Uj85~deogHPB6p-d$q)5N
zigI$w>`F?Cs|B1t+-bNLW|q^zJcQOX1SH8-0l+Z0D@b>veo1hW0)e7TqEQ!La{u5z
zoRQ-P7FDZkw##PgY&yW{ztlzzMLD@2iOZNvN#ZM=N$GTVP{0At2oIg;)dIM1m&<V*
zwhwID$VvIOvyh5Gb9wEYX>={aZ_M_EVYI68`%r|(_o+iY<@}|H5|qSiW@wQFxB5k5
zTQ5^9@vqY`zN6<k-2f%Oq}SV@bGec02OzS07hf$$7E7X@nLvw<<RW?}Vw8`LLTtbv
zMG<}}vUlAB+GXTLZl2<rFqNoR>L`w*I|D(c4#Pf+BsTh-pE;xEwJu2mhTM`sq@Jj(
zVu&;yJ|qyij9imb%`qvmtwhnSi4Co``X^h?Th!`8{l!Z<&8bgn!$zm5>Eo@Qok0&t
zv{k`-Ao+grRwIHWUcBNtiT8mcV}``ObR=?2TH>DiisF`6T(MVXR($fs&mKctlcMau
z5=;R?!R<%h05Y&N(SgozB0mIX5PnZCV-6*COL9wcMQxR92R!|sBr*rxdx`l5HZ*1+
zI2orVjUf3Yc-0;?NS7B(U6o+uM-x-jG*Ru-2^d^P(M?yF4lQEn>P<JMdRYN4N44sc
zYX6O`FvF0e(T48T6~)%~y0Eb6{BbthN9SAUl>;mcdKsBwRqK|fUWrIWH{3|hNhdn>
zN*X$<Weco2O?-O+MTn-;ht4CZqbp9kE*}Dp_0!A{Cor|&k^2yc+Nj}oa!E}}rv%5;
zL~%~i`XuLdMV})A4Ijje@vTmCE~h?8B8Q{}PJl)S;P=F|fb1t)%5BW^O%=O#=A@^$
zU%A6nPy$AdCOaJWt<<b^5PQG;uAh_B$!p}P&poC}KZd{^RX7%$HWo*7E%=LdsV)7N
z)E%v)!;sV+2~2WO8ao8*@+vabu@93qXuU6>+b{<`8(}dwwkKffpkbtaO~JmS)y;ds
zCbBcAyCRp=#3r#!YoWn%DUr;<6ac^px=Xo#=mO%0{!LQBy|=x!f$AnAumMAkF6a$f
zgmWiyOCR2evpffP1oXoo;^0i)pcPIQO>U{&LfDo*OHG^ZA-t&yVAOgg*Hb?w>Hd?{
zX{bwTy%G)16s<0&H>_xaksOhLB>0-e8Hi5QLtBc!G$1)G<;($M9%=JGxg>Q<9adx~
zF-6@tH|JSaN}?LDm8@1c0cj;wtyo@z-j-2|$@TemicAju(D5LRE~m*Mr7v~i40`{B
zBzE2V<>q(%1z!I=CXf8xe-ysLhFS&%2tPEG;)Cd92VL9)V?;%J7#k;9fT?v##W@kt
z;gm7()O=EblVU#t2}d0miA~DbVWU?4dKB}3xMoCh%DpC6W_|zZd2nM$OM;QqfNM`1
zx3nFs{z-~%W<b$@sU@uTQ|hVy9ZqTF=+L5d`9+|lUYRY2FK`1dvNSnDnIu6=+!saF
zU7uG0lo>?Ta#_7IhQQ=W5}4`(5kgXqbbyhhIVR_uh&T}Bn)Eww_?>zsiG~k}{mzpM
zCpHo<xQu`#;Alw`e6*yQWWjlILjtt`Pc=ohp67QGx#JQ>esO(PN{9s$n5qMW#c57`
z(lCbcZkZ)z)mx1mtxxJ)Np(>CqkhR{Ge_rDpn$KYqXE~C&bFn7Y2lw+uF2VxCAokG
zs?E}zOx<+5OyB-Ha@|cIkd>L2<i0=oFf8EW1|WHC<^*_Q%n{h+lyv8~q08y)Ap(sC
z4Qq60%#bUp@7;0<Wo^SC%Hc%;+$Rq`Hos;L7^+K@N_@AaCU(Z~!O#i&MpZkPxpO!s
zB$?kLs=2L><mmmZqMOTz2}8Y~5IE>2T<9<(r+OJ(LFIz?m_Cl4Zla^Rgds=jl{_eY
zlmz5z(gX`PVYrde9TI()Oy;n<hS>X?L{6#2HowzXNnNK}hkOIk0@nppY61Rfy^^IC
zB)0rxJqV*Z+L$5u2sqo&KDCW<hO0TKA8?X$Jq;S_lLW3N0<u*`^D2fEkreUYh<gwC
zxbExD_Y5!q2Ed^AMu1=eyGW4~)hOAjwu&uTmK}TJL}~lUW;eTuca!(t=EW(S_}OWj
zO|jz^+p(XkY^&L_)e9|=k|>J3qW9iAX7GOB|D8WDgeaM$w4ZlAxHE%0_uiSg_uSLZ
z?|4eKCxg++!8?G5LdlYm|FI__R5y#KfzCcndk~|`b{^6QWWrl()=XGSk2%o(<0mv;
zZlu*V?!MA)_~>8RwRil5z-HTQr1jf&;@GpQNEP&9<+9!Ak6WjrX<86a-M&b}y{8Nh
zwU(ZUL!!bVDqLYiq$SMitI@GRXH}~TS}+qSAcn2t<UkbKMl{le=@*=rjx&LPac?F)
zU{4b2NsdkPHmVzYl6<(AjO4bH3Dc1HWJG0kqpE);>XZCFua|#S;vMYD^ob)6Abxw~
zz0GKpLY`2?!ou`JJWr_AQ^MI|*&6(*SA&_%I}Bo$QsjZuL|V!o3xep&YSfRVqeYWE
zcxbv`M<740T<)}*;<f4Uplqlj>`1NC|E;IHm+VTdTq5sPFRd7-U_<Q+3irUYgX*$e
zN*^w5M4VN2qRQ~6Rgh7r_}ogG%lv>lDL6Sf(Kj;*U5i0VF|Z}EBMAqcIxU^39Di17
zzZ?(!Ce=*7bTr)#EBsQVv&<Od>pya@=9d5NVmPfY)N}Hy*3{gnW-d)>lS<|0R!Pix
zUk5m6W|~997XdhfV9pukpUHDmd;voyQ>6wljSR@Um-@!zUJwc%q<OL$f{G$kY*_Z>
zxaNaL;uFrviRoTjw@WIuuE5fYgz0{w$_^Y>Q<X*-qPkJr;q>%`JsFnThjjv5lw(7v
zZZrf8>FvoJHIzaA|MXZOw9?h*GrX{|<5SYkZiA$UH(ixT-qs&Z$>mF#3r>b`%Veah
zjZ@6Xf&n|C#D0JCkfhgwQ{mW^NJtEPPpEGwq+oKgO*x?q$GmE|GE!C5qZ&h;9VV?p
z*pk#y`qw-+H;wDF8r?dipeIx{1Orm(Lk^qDAJj7HI+-E8{m43`CEJYl2+g-Ja9I2?
zdCt!JfcrP9;C3WZk^GjEnshCC2?;|I5}H&~SpTVZU65dN#_t`MlxbFf)BV2^wg2+h
zAF+S;hhMaYO&?V&$iIb-KKEC4?ASTSkX_wz>uVfXs;2QDi0THEpX|=q=(u0)p1p)5
zV4hG+E;vq3JYQo|P~l{8aBRHCT~<-yK&P0>OYj_fa#$d#$;70HqI@xp?Cbsx1^*|7
zyD8HQN*7Keb8!4M#+H<#bY3^Y%7=omCt<(~IYAtU)M9Elke<UMk!M-AlHSCW1ThC@
z%3n@SACY>bnj9yHm{Z*<6*1@=VZeLBu5^{?vMpiIS>ZCG!l^tDiZ+%%3Z};cC;yGJ
zgE@db$pCpDs=)DqhJ+|aywb-i{pSTXBPqmyIayC#WHK|tfa5BPfC(Y~hbUFct59)B
zr9LBJPc8?|6P=4mQ2_SAo}}*^PaE<nMx<t2TfbXZmOtnUFX&sjVb_fP!KbdZ|MExw
zVDJ0jr<IO7XfOTb|F-rw_DLL-3zDYZN!aQBCg}<R@hAGB+=29f)WM$5$q1wod2#GQ
zg5@wG_9IN_vpMWXsT*M-)OK-k-cl7hxI<8QV#p18;<b-*Fu@I?Yq2<-xJEiBhYqO#
zBSorRG08=#tQ3u!<|c#@A!G-(q-RD{H#5@H5^+<ufdL_GNSKrb)$L2w^2_TVbsMaB
zKnA~wNI9mCzIM%GOa&4;CrE%|m%388LI1-<12cjeDNyWE(x*p^3VAQwduOZ*>`K}u
z_)q_5Y1of4-Ci+bSLPSRZDde!HvLdS6*R50Zb<VF@f5oyiFRadkyMh0zQU`<R+RR4
z%!owvp&l3z=7V^~-}h+hQ)A<ns|gTGB*_pCA96u+PRPW-x!I_yzLwrkyg+qxVdkW6
zA<~RW`&dugkZiOO>pmmo4~0bUyL-Dey!UP^jDB?S#Hp7<Q|-TRXO5q<njL#=&(&Ak
zsZ+-U8at}8H`&cC0yt0-VRCL+Y7?8xEiBd43;lj!l+#`7s)qFC=)2(>P{a$9E;zNS
z;$KN9>_`YHxgZIPnoraAlNtox-l6Isr9UCYnTTavd@?tis7H#`OYLHoL9|31KcQf}
zp!_1L2AcsXSlmZ-5H%SyN}#};wBz_np>f^!3`__Lea~krXG11pvzUdEG~wMRm8!W9
zO?o(g@5CD^;m9*;k@(|Kc9l4AMyR){LY6h*)zc^{SU<q!#1rO>3!*D*fwXk5WjoBO
zNJ9LQU`&6FB}tu%*8buYIq|Ytf|HRclwXDGH6=?nlwgZFaWHAiNnw>!OX+&G1Dlbr
zij;J!StrahB+Q7kWC;RKY#A^l;QB&=am4E-Cnq5-37T_4GV+c`(j_8RIyuQ0LBUai
z$6l$ys{9dKwXMQxZ~25(mfs{VUr~bLFNV(Ud&<JmGTZy{kJ*~4wXV^u<z%x}uC8>I
z={QFM8$OT70@VrGg0eO$g`}Wdk*;{mk<V>U=-kXmY*Ge0t=J?nN+c)Yp;-j1<2~K9
z3MCDUMP0iqHhiX_bce^~Cy2AC{f+88lU{_t;v9KJs(qnMIc^n>D2$cvI_JdrdOs^G
zOHAoDebYlmwo<4PGFY!vg+WNkxp=0FYa%&w)hC2KIk>QH|6g3do@Ad3G9`TypZ={n
z6}f60iL;Z$klL6IMeItV^<K_osvfdH&dH1%A%WNF?1)+PV<4D<%#I7DOPymdM^ZJ>
zR4Qn6N`M7&mS(%Tdjq?LeXuKuS4Q10558V^hdkSU_2f`Fo)Uz9*w&NJWAnea8=Z8N
zr|qR>rqXQsSdpr@RhCy$p^M;Ew+b=BVa*tfY-a-p-k+9H>|XPL>ZVj}q`5`EK{j%R
zfLsOU3S!4I-+RX5LkI1i-zm3@`mYKid+p-Mqkj|XJ$*=clBu@ieRpZR-sYuawY9YA
z*Q!KN7YhkX@rsv{+@wA>2^s~`5he?WFE1aRqF>pJ&gpPf{c<$bu8^Y&@e(!m0pr3x
z!viV|R-p>eDOnoGni?B1>`5OqCpHXNKN+18T~jG(H)1+|D&39^Rtm5xh%(G4bz(*Y
za}D|024_DeF=&ZE5~MGeLO#9<2t|tOCQm|ak}OU<bbe~l9XRojFd~vy1+Pgt`n52l
z?@;8K_+>It4T1_Hznz?Rr1%$xWV!-BE;~!9F@*%EG?`AsGdWIHB4dDENvL8eUYP(<
z=;<C0Vvo8Rk_o#KqV#Mf5&H2I&QuSzBqxM~46A-|CCv=w2+;o)x7vq&lDA<UK=&{t
zgc_%AvhV0Y`^W>oWO-YD=;Dn{hyE<odGr;_)%b;5f9XEQkVsq>7<;s>#fl1ZopUy&
zbR<<jo?u8HoAh3{dk<BY=yb$!fgvHH8A!*1Vx?|nNA|R}x)uyq2rTstL$WQ+XH*$6
zq|`e(<hvQZO1;6DLNlZC#OcQeSLoDXNzMsjm`4U3!Z0Yq6k~W*?LIv55DKf_HDOP#
z?9o9o;y;l6p*b<=^^)9DPtVHKV)8NHk|`tgd)i4kGAxL8SqdwVnuLcK!3LxDXh7%i
zlmI^y7u-w8<PYFAgNLvsQQP4}NMLL<U?d-_M3q3;J3d~SUxuue-PJg+!1Gb}+7$YM
zU`X%e_*f+>+&eR#2|aU8E7O8a+0moao(g+G8S}(wJRp_{n)`NI{~l73-tKd!&bq1~
zzh1q)cJA;QyZv{5)pow;<JQ#lkR5&XA^XZ_ziF#?@3ot6`LLB1S372Oed0P!n>>Cx
z471A0W&e%1fl>ZK`Qy?ek}s*ZR8uL2Tq4CLbFyZfT}fXKEww&qPWXoo$ZSpSq#Yt9
zF6bB4TvFzS{n@RWg(20;LbRXED3I<W9oUov?iFEj)UQhO_<X_%&>FrIO=1MaA)o8^
zP7bpmGgU=|VDf=+x1k;=^6?IjFVL7440dv<n%~wxza>**SK@8Q^o5{mscDUzu~DgE
zPy7g1j-~fvsmiS;IXuY{b8<>Hs3fId7m|*~R+*X>gojiJ5GGJyfCopX#?Q?$)W4{l
zrZeL~;f3%cA;Lb+$w^2{UbCRCS(0r_wqKx-Rx~fbEDHrr1;KJ(Lpisw+PzO@kPp;*
zwT;S6CfDaJNxX5-R##8?uYdFB_U!kcx96U06v)5^+qLVL#f(D6kYt2>pEzkryk<Oh
zR4&qEXe@|LqPlT#=%WUV-#IqyoM?&QCAK8%DNRE{QocrvvhjGgLOA_wq6~=w<Z={Y
zNNO&Tl&JjP1bQ7II0n}z6U7)1LWgECV0R$mq%3GQ-z4VVSn+@fkSeLn4Yu+oBTnfY
z9Wks|-4ki`=as6hINbSFLdkDpSCVo}C6<`DS?Sk_$OeKLk)Hb5ZkIU)QnS*E-JL{L
z5V0&THBsT&St{GoI#f3cYTVl@RKO7afV{NiHRFZx<~$Ab4F>7OL<ndqqrf>gNJ~OK
zUPAiq9dk-Lrp1NBE{052*#+6bNvDX_(_HEX_mXy6D$PAZ9(m)S8>YmY#3X6?#g-&s
zzW;^e_T@kRoSjkO$brXSb!Zg7`#%r6<HTmWmY9(hFeqW9qRMjDY&O)=<RpvRSPw4O
zEe9v3RG+P>5ZI$QEG!U6YcLnm(5YnEjYvtdH`%gph0Ws_7?llCkscs<s2xEP6<9@x
zraUrhX|ic~?L$Lkb1F*2%#pROb1_4iJO%8W+D3JgT7<9-lhri+S`a;3NJ$o$kPsIO
z|05}b)(^Mon@ZJ!wabrhDJj{6lp_E?i)wG+;J%}gFb^2rMVjF1ihy<EDD}^k?SWkh
z<9Vsbafnyar$g}7*IhFIdQz@8<^l07YAQVuuk?0hrpA0g?X4qAk`alRrF13FLy6)J
zwqda6qS9BW?3`jvwGcB7^z=xbsa{jBy|gUSa7^#yupbmo1kHI(&>R~OhQuMksi6vp
zMz*%&XPtBNwSWGB?R)4&O(4@idU?Rl9a5dZO&?)*6-fVFmht(HlDAV~=&m!Zazqq&
zB)*bFNF~6;yy_mG6pXZ-J31W6%s7$?C;v@PH&QZBLI5WxyP&`^ERq$*q-+iBact23
zKDC$h1@TCN=2P<m_m{gxj1rrY>LB1*pvFeU8z+SZqDpg^$vZ3Fp2W$C3HoNi&sfqv
z$?-`Tk^NBRkY`RZc+ilr+tI@ApSO6pp!e;!b?6yG#~w)0Sh{%)wQTPVL_CEV0jV!p
zg}_A#yzV~z;Kd$^Jpp@q3i`g~*~!^S)6YrQARx*L(^62`s8rdT3MGZ5QWg>g!Gwm?
z8Kb*4MW_;~nv$zA#j-2=HQ%Ljt!75I2VoziWBTNBep_Xln!u%NBO4b9DRe3^NWknc
zCej((Hg}VxhF1Gg%Y4^p<}PPX3QtH^zuHcoKJFwV%;@3#zzlC{?$l(1QQKIi!dt~+
z4xUw2l|G}s)a+v){1DN3cXGVS=Gc%gcOxT&TFuirN?B}oVKJm6svG2t?5NJqfDR*x
zh<Xky`4F4Y*gXj<3Nk>)KzhdLq|6H#KPFEZY)V=Dma0q(bucM&fmx6)2dH0dz?eXO
zIxf9_KKIRcqYxuELxBEb;*QsIb#wQr-(DSxx=G~HDH<YsQkCyPCPu9%`V0t0Wfplz
z`R=Hi`~uazY#NXQhhWkI)s|9#F&8fB_>2GNo6os7-s0hHnUa)ayzk{NF2<{*=XF6{
zU8G`(x(Fk(iBRQ8I_V8}_|zDc#(^_46O%`-@DGfq>~J7C6LCzKGa`>0HA3+)Hj7G!
zU8Oc^+o^Fbl-eaSR2)Lch?B~g4zsNmRrjIK(!hiv@QvhQt9wYbe=7Qr+8&o=OvHk<
zk4WlB;=zT3f)&e;evS+|X)Kb)&T~?0!Hq|I!)s3*v~#Z>alI^I#pzi1T@0HV6Y?;*
z?bX}j8t;5lgz6#+ku9mO2dV4ZCb}Ejb%V*Pl|4xiJehEC9Kn!crmSo^BQwK^z_~tC
zQWA!wUNY(?vCcbbN&GUVdP(fakWzTFa$+)6rJk<NRLGl3*z9qghx8#O6C`0N#0c!k
zgcR1cDM}}%g`^e5kf?2sg5ep=J2{%;s;OZVJ1es!-h(00rVvFKL>0(^vkrel;!Gxm
z<a1v5RkzXGJOncPEjA$KI6a@!%G)qsvBsN01MLFm)a{4|P8Bm{S#;?^U=flF4;WG>
zOX?g#VvbA(c8$l<A#Mqri_ZZ0GB#i1M=XsochH3FONxFSB1XcYVLj3j!lNFZ5b(bk
z5;cuvWPus8atrjm2&+VwDuld)!@lE_*YYIWx!pNagnFL%;j;pq|GItupT1+q-e__j
zE8p+*xk-Ed$c#PslDY<UVXI10t!q%d>szmI$1ni&l3IVUO-WCZ!NCq~S6AYNnyqqF
zz~PZ{eaMG)TZf(@CQT-s98!%QbO28rhJ<)sP!h2`O^DCTR~M$#H>p}EDgiJ#r`WAV
z5+)P&Bpr-^4lphndva(@+sed(a71CSWb`;fK@c|S%6^=nomOU<7!vi3zX4tVp`h7G
zd))2#HV<zrDcKLZG7_DCASy$8RAtrk=^FT6N03yZ9wAe7pNpB`aI9AIvomF@^iOw4
zRp*KcRrQjvFV*7bw$B&tH4adpfc0}FHPxFY^j}5!^TKi_ltDoP=)_61O6t+KBaV})
z<m^gyJ)V`lb5@YnNJJm%ao-~mB#+1#M@UVLsVZ7sjUm+vW~K&Gz}u59Xzsqv@<V#r
zmF}PRll$x||Lgn8#wbZJIOx_D$(}^ww07!y2<CW=^5v|fy80uVX6>c+Iop3Q$98Vo
z>$b=1b^}C{t~=?;T%jH#eQ`KIsGAq!uqRY^d2Oy!-7Z)j4!$!W1nH8>FczVmtUM;^
zN{vdK!;~<h5B<QX5K@%wZGj{~ww#=Cm#XDGSJbO#oE(|)?xteBr@<lBDQRX=Sy7<9
z5EfI@F^3jMIA<^^kdA``RuDv}$V*9oEL1iGYDS4V73k~gPRY}?Uj1{w&09Uct)yh9
zto1j3Jv6KEhK%9tV!@6`#ZWm8+65htHDv<jPXyDs8+>0k`@(=YHaz=YohhYND5qEC
z!i{fB&zf?_^kE9-R70qmvFYIAlnAB{NlBgJm_`W~3dhhB>YK$oI8(ZDQk3p0s40;%
zrgP8m?_WUK*}tlRRnN@)+DE_Sde51qT~;bECrQRpop`?6*2)>XreVSE-WjvIwvVWx
zOCy;zNr4Fqx9^^?hP`(>T^WxB^`ibGQQb&hJogia)a)i4_mFB!VZ>xYV=QHF2m^^o
z54z`slS47anC$9d6{ygIgNKb&O=d`5(<BB&3q>3Q9ZEbT>`CI2G=V{!7DgtQNJ27?
zk+#|nnbY$c8cO>tz1`!Il&J6Qbah=OK&;%(dhn8x`bnIc<WLaO(Nid0j);gXPF5sm
z2?fKyf1&5)t9zk$wJs~SCK0vPh4<CON&~`>4nac<+NQwlnXcdfgpbNH1m%}d+slVl
z0j`)6`w=41U!s0*%HW{vTzQo`p;0wbL3rQPQ({-b9JJjI4XM7evERMF@*zz&3}K+S
zLQGId<Lr>A5ccMjrod8!LD1Y+1Q9fktljGv@)P&}a-^bIGqNj@H1js7K?20|>NQ?v
zqh|Q*ZV0IsvPwfzt1MQs!3rxQZph~FP}p`|Ell<#d(t~OUUf5{8|r92>7J=2@C0+B
zx}z!%P7VRl`ry5AwnbXQT%L$W;$fq%k&d2tO`Rn{bcT$MXu2&ow2uK#Aw@+Rxggs&
z5za|i2Xw4b^gE$uw+U&fIeA1rhU`^$a%B+5@v3{Jq~txA6NdKmR;6nGegFImnbMcC
zu>&zGs4z`^Cp|IQA97;!Lx#svth+BTsx!0KJ17<y(31}j@r+7f;We2aza1@`URt8U
zIf*V0PR$=LMD(_R!A`E*XKZkCAQ*5ahMg-!Gh%A;ys<H7CFz{%)=fl;F_}QDo$3nN
zZ~w}#M@r`hrIzCgGOLP31qd)A9(Kc~MaPWkWz`lfjk+ZiFR)dGa`+Mz`Rg`qO&oUF
zo+L&H;dOh&V1`|x830gCIHqo!a87|`rU%=z0_Ma6_W^Wr-E*qgDlP=QA~2nNJd*8^
zj>IfIm6pa`=^B$H+FEoci)ap;Qv`*EHf}cNUZQ@nC!vg-ItSUv>uiOT$_1WJZw^FQ
zXeIU}MI%tQOt_VViRTHRT{I|@Bi^c1&2Q_Ue<4${A*E~~A-@tDg7^UcdQ7m+oF_bS
zh~AwsO}rwzlbJ{zvYsHiSK)DBtQE^7OhmaGjE!CCtA)g|>>?X1cqV3+;7jZ399asM
zd$sL0)`Mfl#6QE6fm1duH8it8gkYKI)MI(*Ynj4vf7Igry~6R9xgl-2wK8T`Tv6y4
zv0{CV<<&P>X-!x`ZNekmAA#-0>&&v?`&DfH1pm4$jz@VzT6(V=WDD9Q=ucWHB>^hP
z&y&r#i0w$W#j96II!Qtp($m!Nu+EWk(Bf$C3`JG2i*zJrNy%D4!LsV?RiW;9kD?mV
zG7!?w*^_#WlLi1TM9>@}^X6Mos5Bo}N!3c&N1s~cToL0WE47kHMf><Bp`htW^$Dex
zy=`hS`53>@(P3j>%0_5tW~xt_6!ieBGCd<VU_=_hP~mvtYo*q5HPo_9ajzb$v-l#+
zv8-NTKGL+KN@t}ZF~dPvC_NV3l`tk@A;`rmWmo3wq!$*-iJ44ypVK8slvT9~3?}e2
zk%rUiS;otTW>VyNMgs2;XG|EzvT3GN85F210_VT?(QbS8`9<3ywG7ZaR9aQ-?rL7s
ztqB9ByADK!IJ7Q3KM=KDp=qlt?6xw+RSP6BE7ojd7d4s<%LEC&1FD;x`NGJQWtA7$
zsY9=8fWfFxk(na4Owl6sSPSBJJ`o>EOIyAq&huUfm~?rM;1y~cCY%D>GU4!~Q+O#F
z5F_RlsdTt+$OXxXPZIv|W9P6Z378X~l>g=E)R~Y&>dns)o{&_2NM;Md0Mo)#a)THQ
zSy-qUIl4i-Q{%Vee{WYJC1(_Z3TLi++ti}pm*<O;l%yPeXb7hUCZsYQ#$+LGIXRVK
zeS`WTYLTefwbu0y7p4!p-VS1xNJi{TLP_Hakz}RKS)~Blxg)_;$40}saBZo&&_3me
zT?wQ5j1P9@P_Jx36<?sbVaTaLnGVDuMKB~x=m-!iz2^ON4Vc27>^RtF_wF6AR}ZAw
zZ{BTo+wOoFYqwW8)$Ce_6AT#~<ow6!A@xhE3OiR4tVIJi3%9BdzUZd&Hu9?5O(9eK
zj*22wH!$74OwI4W`2_vKGb68Ycu?UG{}V{}gvae28yFKJ7|+-_yzc3dL7gzoH;<`}
zWO%`uJZyuLL(m+eI%rm=fO{=l7AL29P|QfPU?R`Wdn7e*V(7<lC9rM}?XRjJ7Ygzm
zomlUmJVOSxm4x#&4{`+xhTrx=&lkm%?C5}1<&}ZtfBNi%BKboOSq$bRkiKz!*h-5+
z)_6{H74r*S|8ToNt0whBCk0)HWW?hpU>;Q+C3Yp#X=#RHJspz-Y>Q+MF-yloxuCX*
zSNifc?8@G5LB}ap2`wzD7`Bj5L*l}T3FDHQsBPw7dn#4Y?2F$Twm<k!eVR}au|N6b
zoWY2w=ls<|{Ss&wlF_T@1@*Q=VONo@3#1q)l&&^|T-`Jf(SdlqxLOnnJ?)-(@Qx1I
z8;UpR2d9`9mFB%}o>AR6i(X~3@8rbXc`DnzCnj^usrT`?y<<Z-Xg*Q*NahJ*d$z?U
z_4cH9a=blBdXe!k*poP>#3x%?q-oMr@S%V?j2TLm`JiV4;X?@r7u5}T70AoEO4SlY
z7#v(y-!S92s%WXVB@{&J8Pz=*lU7YaRdZkTZ620&#oKJeTdtICdY>)CWRxdt#r^@!
z&8b#qM<IQfs<B;aTz%C8Q%zQpt3glw3(Bxa%c?dnCmPsd1k9sCb{m$xLNNvC3uE%I
zXEjM{U3IFRYYS929=AK0vR!Dun9EWrz95;w45a9n6eD3E+LmW!bT7<ELbzQOwAHk(
zeAO&EwJzp_2AjL>=%KLPaqDKQ+dzA0Eup%EdUl&EJ)oxN64*!!Q<7q0NS_s9qhSpq
z+Oj@P4Q=yQS$dz_kNBh~U(7-FhWI4?;MmWD>exKb!AaamFcHk;rDdSXRpg?qj^v<o
za!4IglAW8bRBZysXJVWxZ~>0VK2BF{r76BSEM(-&sUQYAEkS@i8C9PTG0!w56{h7E
z<jIjt&(?)eGB;PY<+vnyS05EVVmSQ9ESxU2JfsfmdD$L^A!9n9RB)wfTw&)h8Jn1`
zSLC#a5qJ82IKzuVQ3<DuJ?DW6RCq}h^tnl>YC7oK(nT{R{kgHT^M9NoX;PBo-B?sW
zfSz$mJs^X_fpj^1a?VcZ1i^5=7nuemI^qJ7n9zR2?x<Aeu8a%u&8zI>s-d(+;+68;
zv?U+~Xs4z#DyJXqkv&xIJnRMC%`+(~>X(G%M5ie%G~M6n0_a-d2*%pFBanQdNVyW9
zBArmrY+e#NGeGM}NqX`*bN-+17`38kk6uYLl&Fv)VNV7sTdFv)B3$hxU{Vg>M-C2J
zWQ6K@?TM7cdo53-6_Jj3-(Xe-w0v2>D$fGQRMIl299s6$$#)|mfn<?@bK4Xs1)H5y
zXy*={UW)S;6e(~$5!9&?3c?m7^G5!kOitHGk>bgkBvv4%bT_f$%ApBoPf~!965@IV
z3<(%2Cf2~D`nF|PW~ubBdjtfOafe$P(QiQAXG^F+sP1rH<we_*>~qoT8}tlsS5gPr
z(IXWgulewaX?x|Q0<@BLF43<JIEWx@991AGz=E2_euOCY#TbT3XN2<&!;<9z@s*-q
zRD(}1;_N`)uH??|>QjraOarJOs*3S6RW~aPM9>^5Ij5RQpV2|JXB8<#At{ii*Qwdn
z>WmCROzh9Pl?>^baA`doia6$MZrp0GD03H?#(i&30=|_@AZC=6msn$q5aJTyA*7^d
zNG6Vf&jcVpg!k=(=SWVZr1!i_3RTr38#YV%ZoF<haL_LR`u90+Y|UB0PxBu0b6VPH
z#uJdfoE!q&#3y|b20&I!{Gu-hdvdH(#o7Yo!la@(3`}#M^CtU5C6o`{`QJ!ev^H1b
zBGV-`2rsosb0R6}&Lo&l0S0s__9WY1G*hxMb|s-9nu1CS!b-g<<|Z|aM07t|9v;8~
zX_AuIC&@%0))NK3*ekScE=x~+8L5^H)k<qA6H}5K*o=N3SE!M=`<z|b6SO!C_DUiu
zKAB9U7g?ZrrTDNfXPIs*2^d!uHvjY5k$=`dGb1Dglp#sjk4#MT1f$Lkj9PK}P|zE#
zH!`cPaBqh~hy7+tb(jt@LqYPXc6nwh-T?bNnXu(xNT3zH+Qzv-YNE;s2i2}Ak<B+F
zSimFJey&ptrgJ9L02mWyOp(LEYaAUGAG_?)u=wGz;QV0%A>FViJyB^+`$JfvAmWo`
z>tHZq$Jo7SuH>TLkSdS~-EkZUEK5(GF#$HfYwuOWfnF`rk`!P}hw@$Y#&3Ty&zHoM
zeh?ISYZwwICL;T$XCSz1_`vzapvq+Bhtt#!1BTNBn~}SccqP)4><*F?ND(d;kS?e<
z?{RZ1Utj6tmF<mf&aNbblblL)As}tPs7e_Yh}nc0@<x%O{(qifG`B9{xkvJ2fmC%{
zVWKKXpKx>%t2FlZNzVWPKmbWZK~&6CRWa)L1DPzp{s4ABiN7YddT#!NE5h&&4s8z*
zqmZc?&0i(ETNaO(l4t|GZlog&84d-G3^R4|N=p<oEp&w#Z#;cSg&_y*_^}~t*ikQu
z3n)L8LekYz=ajDT8s^MU4>$yqGNxoqMHqoSsc45XL6p})1ks66(*Cebf(%epzGG2=
z5H}>zxfa<f?50k^L$72}K%5{7uV=-)4%1TEAB0by3U&IZ_)Ab*$MOvj%c<-jdgI@_
znCDAkN=n%f``lRtN{?VKwsos{Np~625u)tL(|l~%HuCE-6j){P&Jyb#bLvjS%NrOM
zNI|0XCvbMe8VO(mw)IHAc$TCUOQ;4BkxGQ7)RPS}A}LYbZk<9x#4yQ)dkKlEkLOgl
z_nj1lF}>7GFez`sn2?j6k}M@m4-iGx3NfwXM)#WdWHJP`1HclzA034_I4dbLQX~oG
z?MHpA-~oY~1{9U_;@N#i?4^fax5I}uT|&IJ_xj+R4s>+8bR!IjswUM4!N}pnL|B}l
zq3%KJ3+@X+;K*B-pn$v=PK*-I8$^te!D*Rd6E0p!r8$J4pwbIzhfRqJr*nWloMeJA
zQR6IGGTVkGBG%fKX4^Hr476wPDN{3laj9DJF?oGSOi9XdDx<m;^<AL~={2fsfoMX)
zhJ;em0=3C&nvc>_meshIlKepI${E!PLLe~ske6yk9f8kCy3do(`)0}pf&eM#LK?`h
zCtgYE8sybB(vg%S<e77<SGF%I#ToN~1Z6u2#)MHFB{3(`)Jw}8O<~R5(CIcoS^`16
zR6iN)>DnIVlzAbw*x%Hn*lQr2DdhD;QA<eP{e<9a`n!g7{2Wcg_$7PoOuqf}bNj8M
zTjgWApVn<sct;X8H&^qAWK*&a1Ot+8WI;00|Lqx+&P9rPUA|j3Y+Uvw*9Lo%es6;4
zLC{=zX*oHB!0-n=VdKwEj>^`gdR>xS42fBlEG^mA0b?Zu5zI-s;gArB3AbIjy}*Tn
zm?U;FrE31O{qrR;B|A;!Y=0rFP{Bz5yp>5>-gHf&U|fVufvTKWK}1p)9NPohj_O7w
zI4LRb5At>;DM~PNkeo0r*&?sPeZ11w|KaT9$Z&_KVWfcyq%}fAEW|7!m=I5#R3n+6
zY}sPG?w2|xhz=vdn5camq%^4~)?sh5AB^Zo%n3sxEm>DB=x0yNGla&cx}EBF{V>Yn
zFz|`q@czzz*MOB$Fl3p^<e<JWNkH}mq@VFH(b7r>dUf^v_uF&Nj@ZBpKXmw%K5W$0
zEe7J;s3OZbKN=c^`u436I6Ev5_9P4nvf9W{aA$iB!?p2Jl5NLAs<BkY1}EpG*8+z0
z=q9|6J?X1{vSnX0@D=7vm+t@(H-^xPjv*y&spPunwi3JHhDu541sfQZCR5iUn5S;z
zOL%y*e*FbIXXi!#HP$=-2|`0-O8-$3zin-WB!bk=xqc%y=A{{j!UIneqrq@UNQmm@
z42?dU(0g8La#E%govkhp7z-3zpLfLrPs@%g{fJj8NrCe$o4dcQ!=YxN?P;H_P<Ui)
zTnyNbQ^9A=TF0@&dX_ZS4DFosfT_sv;F0^Vk$Vl3CLE?1^R^=a^Ji;7JrzcCqtjNT
zN~T~US-+cSsPan7NINTL)~6+Y8v*kvT{PfWxCxVq%A=zEQCq)zhik*Ft$V*riX!{+
zSHEeG{`EiGHP;7QV|zNrR1IPd87dJDkaLK1#k^M@SD7EF#*{b!1nScfM9Zj(iF=e;
zgIrOsE7T2s%e1!7lf=wjREkim2%3}iK}(^!$vi<tFr`$tuODC?z1uiKWQI&3I>(G7
zY#+00b{E*@x*&Mp)lMu;j*_ORO{n$ZLa1sS@9pT4nUYercyDk>a4bRnRl&QHn%P&>
zIn~pCRw{{3IeFp`4o<$ZIG#}dFeAn^X3^Y?hO+BUUlia_Tf16$vr45ddIU45{aw@;
zh>@U~j397srW&Diur{3lkk+K&B$0D%VL*4M>M27mFdTf^$auD*14tSQWK|rXEDts(
z5)oCNk=Qm+<GC&+=|V`_9mxqpLQHD_w~-SLrKG(_>YHs;B(V_0Cn>;iSm?4RnXrb}
zJ<!5MQs}5I%RY4F23xb`KHIkEejy~Ew$_%%)tsgwo<DxfcJ9oUBQ)kB4=^PQ<QuSf
zO;9~s^D&W@o^W(vNTes-j>CPU0t6GhA3<|DH3KTbz{w%r&R_tBf(DgAnx7*rF{+!5
zFi=De7p*rW9CBrHpt`4%hRV~Qlb1bV{X=L6jyY|s>LPZ-wi3&#&QVFBx+9hGtBXoJ
zsCE*%*itqBTm17St8eVeq0y|b@dfA!N9sWyrEP;e$K5+CrIH1XrJyPi|3Z~O`R$fI
zSo@I=C!_>J!laxWuSP(xbu$eU6+`UjKni4kB8fTa&CLP00A*}QOYUqJ(oqdxnwEJD
zeag%)cdubc)GEy9)VsX)XhE&}->ZE-1BQedQR}2GUHVeLVRlAo$kIA-p`Qc3Y)>L3
zeeERDrdPHVc40++zhlPt-uq#D;6HuW?){B_QoUz|y|nMMcHqgswYk1lJNn`=v8*(P
zZaSnRwx?I$JV#3l94s|bGEK$1gp0B=6(vy2l8PYL%aa&9&-Vv(V0KhyhxSFP`S>I$
z(Sn>nV#?HY>YK?Fqr(%f*PQbnBs0#x5jZ9&X;8K7cgo*j^7p-`%zo+4O2@p-r-hR#
zlnqK6Aqs*=W(zO6RL$*_^l-_Nl6^@z#z$Wh=o0E%eZ4xZ5E4+>SE?k>vfZ1q?4a;@
z!i!2J3VvlJuqWHoa+|H9-b`gCe1MtU>xANkQE3C_W0O6QUz+GEQQ_}|)T}xjQ8;**
z{ep$7T^o_)8FJqB1dIb1fh2HNYVf`ItTDw5NrNRbAnUO$lYBE)x!^jn&j`(DqS3A{
ztJqkrSAhg@L)!Hp(k{9zv|Q~Z7q)5NL8~k4wVQtDQ&v;?J`Q2cNB2o8p0<+o0UPgA
zd{G6s(;5ZS(R|QK$s;SOk(AMM`_L1Q-Ra5MjP4&Xm+;Of6WyP48s~?kL?iUczJt6y
zNqiDk@qu&f$)2GU`@s5Ds{9wOsLZXYD%rWxR+K?fY)z~(S#|rWbK;KcstfGO^$XUp
zrrORmtBf$FaVAptL}U_`jgE<ja;s(9WIW@(%q2ctvZUnriBh(={3xU*UvlUA5?jB%
z!XaU-+!&Ap!b)TgP~q4#1l0Mzr*}>&LMKS#j{*%$0iW3c{AxiXHjo5(n4OJ5&KV}6
zRf1A67*JyXmx$MC0((MQdLpRKf|KI|?4Dtfl1R&BT3aEeNzkHQ>s|p|K$Dm+Q==!m
zrCF1^R+rg*|NSp*Re6nL#;3mjN7ixnhYrYK+YP_%z*4j1IMDyijY+WCIUkDkxuI8y
zkB$lsknj(SSJ6C^ZltynM)V6vzr-==v4MP1FH#K+Q>LP2Jo)~yh?U^9q_*0jb4mf~
z+)^2jwjx%{HSm)gyo7WI)C0^}q3lwz0JF}i4<AB8CO@OP2?fPsMVFLXbO%X1TozOM
zQZ{c>CLhqhc2ZLehRw<Am4wZetrD>u1%L_I0`^WUkjYjvX?eQXx*#G{*vcR}($g0J
zpExn#ihf<1F@d~GQ7w|v?XOzK3{6<@LG^H6fn!e8I}8c&%mUML90;`ys)n~IQws#n
zFC6e-<nl*ck2nz502hFM@%qnSbNgj1_6b~nvm1x^H~;OA?O#9pe^|qHd+m;2{u6;+
zU88jB2^;L{aiI9EN86meJuFoZ6$<j1k$HIOZkD6U%3N`VO4ndMh-XxGURjCzpKuUN
z%k+r8&I#-69CxM-p&v{q2q{Uq8r3}nzt^qDRIhcZ;-X@;<?5Ux6lT-|L?i@z@~sHQ
zOqQZ=wcVwr7L$*2Sxm_RNICj}^Zd`e@QWdDTY5&tD<?MQiIk=HS|=$j7ZF5<U_|bE
zs#L(%hK3cBV>1vjV7}~Vur2R}^Ht3)yNxO$$T6x^JB0K^Lc)lIjJy=}DN9-?d>chx
zy<l1@#RN<CWR*KcuHgEh1N-;8><!YmDo;bHPPf_*|Moj};^)0~{l|Vw%y_q}N|zDg
zRD4!pkyNiLbNbbGD+n7T7&jkM5+dpV0*SLDWlLg1QY-1Y6x|m3?s95^GC&oy#8scF
zqUtea#LlxP)m;ih`fw1L9EvfR98BjT$q&vqCI?cIrl_cju2&LT?-x<BR3$$7i%>A$
z?s&iW)81llpK|nX$C6-${kjW1!;CPdXHEz5F1u%9Ofb+|pur&lj*j&>^-X+_o)U;s
zeu{oo9pI#=FU}YkP+nL?!^s3gW@uw7h&-__nUJ25xUw$eJ-W)ubF)wwoJ5lX!KxBA
z`l1D9g109D!iq%m?eMXKZuA`>sL+#7H`?iEU$@p%=WO-PuzmRcd$qR7y@z++-O_29
z8f^?VB@WKyNFXKgwv(k~NoAq#93*6LiI9+ld>lG22)$Z>0z_>Ct{R^mx0chL);E^p
z>`A9_h#e=0_F5=1CdX#gqMN@t&@X3I4vtSPQUpWj$CI}uy^8khFZ9f|v9zF8fL7Y%
zhQkYO|90yxn<+086#Yfg(ler$lGv3HZJ*dOkoUf4r-BqAd2l3&FKc5P+HjMLetTq_
z(M;wl(Fss<EhG_>C8S@+{!1h#9O{#|s%#DpkGCm#-veUJP7J7+wPI-(Z%<}M+U4lT
zhLfbO+ql{Q)PMAQ2d(`?i`({<BXO(S`4PR|;MBYK&Uq7@%YI?t__!@<8<h=tDG4(&
zn;UXf=u*-1Qv~+aE2TVsnoJ&2lC;r6?Yd{qwW@q9SL$2!lJw*Fd^hKgA__oLp^{Y_
zt#MF8>Lnp5Rio{htQy7F*pn;ObFvh42hhXHb^Om5W$ekEf`T6rrSaQd>honYWpXJS
z%t&uI^j3`Nyz~`PGE*U%;sSw-D~RT2NaKA&R4{wHlKd}rC29x<XGW?A;x%;UTyTd1
zP=E@DU_utuv|s!>w}BpDMADMpru6H{qocY(*hmfKIn-YdMV*pzli$o?R`SojNB7%v
zU;mzEh{=J(d*+oOeR|zhSGaBc)Ll9osYGvXp(0=NvlAKswe1rHb16Yd8=;?J1>1>9
zQd3EM7RkxN`jH_4ktPaE$eHv0c*66h@h&;D7EyXpI9ZMyZjg#e;^Sgq-3*Ych!?Io
z$Y~d{C%wdU8|wiEOkS7FpiG9i(7-0Y@5MY{R!GPn7`rk%bNT^tqbV767FPxCVupsM
z`wfzwGpSnk(+85)BRxq$s_MyNN)u9CO1tfZCcR3ZIu)KyK}I4cPN)Nb{(R+Ya|BI7
z85_kJv`3H!59@hRDEh<;@x(o2@{uqnM7&a8)WtE~3VE%buruRGA9<~)?kqvAxG53|
zQ+09i3YYJ0di^mwesIFNkDk+Z3ZSc-v$<biQ*#i7WMi8)hHdrMM2f~AT+g7mHNW&~
zP+OW%-KcE{X<1Q|<KmJyI2sZn9;CckU)PyOiWW$1dmGz911hgwrYifBN4wp*z@!PQ
zI(=vYdr}bw-2^72;~X%MggaR$SnaNXxSO(DSt{oyVb7De@Sv#f1NE?y`TY81hGgA<
z+F`(<Bnvd>;=gYm*yQ)UnCA=e&&BNLw!yBP5eivaRf84W^kFMdo;h<-qkF|<$qO5k
z2leFDHtTrp3pFVAg(0aLB2+Rm6{vKIGw`?}U&6*~%BHvoZ5?thTKiP(ED5JJi87@m
zG2XEu9V1GDo=0Lx*5jqKtn|Vu0tOcys#{B?P^oiryghm1+*j>$fA^Ffe)^!Qc!sTK
zI^9m55D0)`en@kijc8GkE);72l=8?KPK5)S+TYqG6(^i{6$?XNLh?GAk)t}wKnqZo
z7PLcf6M@DXIFc|Tl|a;0;`o4sF(k~P6DI;~;gQvdPvR8%P#T538>B_BCy%$~nztwU
zTvs-zOb(riD^)k|ucTzjIIQ?^{pL)ouU%&|1C0(<4K2EIpG*1w9Wf=PY^a0iw(C_D
zBOv?Q9jfHcw{#V>0-xu}Ga>)`*Z!I9@V2>ANk?MeP&&nln%0~iiZdX(=N!(EUb`5j
z+HmP9fsmH10*+!fH`yKL?u0Zm21*xhqsvqzF(wS@q@~*;c<_uF4r#)wJa}(Ymey7-
zIXR(}kGqZk`O^<6psqf4sp>PGG3yi_Qlb13s8=2^6cgq-aMd$2r^VETZhRh~sZDRR
zxf_lusbq#kN&=V)iZ28sqLP7b@i9slvvlw3hLTpm`Jo4#VNYX2z3v_7X?wdyYp4w3
zhNfH%Vph(mZW`=KU#iA>g64kc68}RhC1S94d3~31j+uGAcGrEItZc_x#g^40^cDk~
z{Jt0S{EnCsW48VyANwgEv`ArVrjUMxKE|w+*^#~_#`Fy88FA$o!{8@)3o}xR4-qp{
z-Gr#h75(yxz`08`>a~-YGS2<^?-xc76UmU2vs&q#9639bk)g^RW3peu)<k`~*HY!E
z>}0~8BoGgwy1hMVc9nhmOP{x6`%YQusyyrKp}2O&Y84@(xs6m_ouo9hIU02$&w~@t
zZcC^L=w@QFGc+3|5mK_eO#LwGaUq=u!I%WfeT>rCmAs*B&OB;Y(14^G!5BjFp*6U1
ziBIC>5Do&ZmrxK?A^_S@WrH;~&uR#1aGtsOIoBSk*KPPV57UdP<k!-x^sp`T+WjBD
zN+o!CR$VCYuUl@^#J1?azRm6z_0~IL%1?j#|0=Sw^|#Ltv{*<{{)~9Ps*;r&+kL%&
zMO6`<z|KydKa(8^>?i;2crQ)j5FB*Zx1&24!ugpF7r4*`nH~Ce@FF?UES@=iI_=Dv
zZij<T%#u(Lgp@2PlqA;wFsHXKy>00>(u0$dsC1bVzKR`e^lSm<J7Tm+>Ydi!czWjV
zKl4e|3@$i$J)cYN>yo+_Gu*y?-fq3U-YNwIP*Hc26XQ5J9^?us>EI7_ZumW(kdk2q
z>$6mvMxPF98|mnueSFe&F^UoSAGm1%R11Zy)^bjDnVrFnl_h*8ih4N(NKFqIR;I$1
z`5Ln$0(l)$>0E&%ql-=IOQb0BLA95&A;oYj2_}pQ#f@i@A#@1DCR^;z5AU*Y;T~&L
zGu^aOomcK$w{q9Z`u`m<<?3}E-yG~44)xE<GZf9vO4m*+v{0ZjvF+DdO0Js55^9|1
zl?+K%$1f|tJ@)0?V6W>lPkzs-C#~S56Fm0C86f>)SB8tR<3v)|DT5sj{g=uY$TOp7
zPPa0_jP5;o&uok84yO#Oj7~QT_GC)628^Z~AXrF3>O3I|jZ-C&c5N-R`|hc-owsdq
z-Yap{O{z1c02rdyl1UO2X%H-*neKDz{R92(#Zuicq?d+1CJ7_5IKZoryn0DVW-hV-
z2}oRZaB?n)Ppa0Gf{F3bWyWGwj#u3cvSY_*gqJxu=z8%nnK;i-dS*fJLXR*X#It|R
z^jVT6L|3LJTkYCwDs1zWyH!5e<+g3>3(%7{ZchLIPg4HbpMCOvHCMl{UxPYJ^2OUy
z-B3oxlnsJk)3AB5T+k`8-cxQpGh<X$=8A*C)M24Fgk?css(|$qn(*Ws%D6KjhKu@i
zqw^@WjxzkzxP}EO3qjHEfEv3h%FCSkMmkQ+(+9IG{W#7_TatC22obSN2%UF4R1^$=
zO1$~&_k6(?l};>HT}ESL*fHZ3yYuX>yQ*!M>Ip&C7?@B`ql#Orsurzw)isWDadIa6
zo7^;BFPZ%3@tejJJ0!JNRzVe0phdhSWV<W@mS%_<J=hg0J4;{!0aC7zj^(@zcLb(@
zPcopoy;(yj2)iEwy0A^PmN~+?gc-@^Ky(LC#OrNHm~UiEab7Y+TKJ#E&%@buMUCyb
z={8B|K6Q}DX;VijS+Ta>JiE4GWc5G%{k?zX4t$vpmn|uG-MjdW!BGM7!;lFoRNH8@
zeEnikZS`XH$j?L3sdh`B8MW|OvtvHSjF4IbQ-`V`yikY%P|4&Ol6Ag%s3=>N+6fOF
zkCKy)9S78Np=t~v#&+aJWrK+kuqly#oGc$i=K}h4qT3<y0Hb;|4NBW60w(t7Qj4)4
z+i%}@+)kWaaB3S2ovT&*2s3WorY=7PoaY6U00HO1Fr(_aJXK1q(vJ$VHG_h!0U-mZ
z8m9Q-;J}cCf&j5+Fep;ex7czlUr|nQe0)lIdG!+!mqcZcNit$nR#d1gPY{S_P7b@E
zIrbxcQD_lN9Ek5btDHCX<YeI*2guK0dCoCW4sI0ec^D3<=tm#3FY~-vM)i3ty($PE
z=n^*P)(w_kQlSu%;=-!BrofuS#Z*iXij%nlkj?*tPk;J%H*t*1q2N}z#67?L{ZBkT
z+DfivS`49}tt4D-_QK*|Ye%U6m9wF)lYMsAbt9HjU1vq(GVYnN;~+gU96}pC#3^D(
z>?@6vULsBu&JN_C2{JSBwxnRty13&5r`qMg0VyaI2$L_)c;QDUtf2IJcJ;k?YRuY{
zbqn5wfDX(EV|wP)8I*k)*si>$QXF~gTO!8gv2Izt)_L9k=Wq4f%P-E`M{kyQtb992
zY()awqCi%GCo!TVTms^S@12%8Vq11><)v)N6HX$%ap0^&1Su8J{;=k76ChWOxQk2H
z)aF~w`f?`;acZ=em{SgmFqsJd%xTb)Q`eG?0@bwwR}Ca|G?^*0%I<vSU-vJ^C*@mB
zBtTIyb13R{PL4e9f<gsPMNEDuROce+*PU;r8FS>A;(5o_@-cIPDD$F<JRMw%w8$!D
zQyY&q*>gW>wbh%8tz0z$w497eIONKqoK$Q$KX=qtuUq(Aecb!qhhE}C5=&g%p4<Vs
z4dM58bkc$umC@Xyi2~2r{6J@j-jD@32)$}bAKp=Cm1~Nv`(*3Vfqg?eW%ZmQRQ5{Z
z&Q*Naov?ZR<2-Un#Dx?lsuIi7ASwN?wtMTGRM1@*-Z@zlHZ9Lna>2g&4+re*u_n9i
zzS|ty84eD2vAV*XqZ53d7*foL2hQSP7}c=9uqaPlqjZ6qS-Ydp{^rl0vwcs7?6dzt
zDzLg%(pe!ZF$p=Rz=~e}_PiGx56q8}n)U7tY)RB)`{9!=0)Q#PNVzoKiL;WJWU4l9
z3_NXG99%<~^4n0rkQ((OPn?NiV^W_njr&MT8@E+eIo8(MZD07zbBfUlI!2BaZ3#%N
z_O8UJI~8cG*O$ytb69?_1VA~EII=&7`(!JJRCftLL?8gX=j}Te`FyXvxMndWKA@0d
zotxIC$oY)fk$p{q!Z{=RT6jn*q%KzV`8w5{ItE>=v-hqac^@X;pZv++ec$bT2@h}P
zieIqv6?cVSZ$3Pg(V>jS%yhqvslXs6#4k#vveoPnT2*DS=$Hdk-Mm!*>_Wa>?Cem9
z7mUQ5Mpe5YDTCkXRJgASTKUmjP<qQ5Qko(m2`CeV1scxh7?bT&(xP_b?dz=R$phA-
z*d=xq)j2c6|7IWf)q5<xwALn6Z{eLB{~4%p9G)fS)Jq>40*C0qFC4e#17r4?&#ZNT
zUDLV{Q~I4i1JX<e#*oJw;+ROw5kUk(;ru=BIXk*wC(m_Tx4`YO-<;}}{RqL3Ibxy=
z6*&X>7X-?gpG_M{P;en5Ti;vEGpl{{8l;gN&1ih#sk8Ru@0@bTzN@O!Tr6_$PE|;4
z*=Q&Kr;3J!s8%A$s-4_t^$JU7WA!Rky687b+5&RRxrHaOC)3qKh3dwxgfWxJ6>Mlw
zD3X#`aV&eC^7cZitCfkO0inPH!kn$AQmpy)vsP78CAjK*n`wyJo-5aWPZ65pOU;8P
zSR?ssy!Gq<{@*_Q=jWby=BCrnzi5*!9kN$6%w3@LnaZ5Zf#sv-beY(S>%|4nENP=I
z$J`v<;p&T#va(cFl1%GI^Ft|qnbrkJ5m0_OB{&i3uADxISI#K+OKBsLE0Ph_zDnUK
z?6IJ>PW%C2FLRkkEqf+a7qNOrgVkkqnA)e+R;uGF!O_!q%0Uult=^)Or&dvk+7wmj
z#N`~Nq-vsqo?*mP)f2+BA&qlmX3V(kCs51Y^ZpHry9w`G`DcoGXJSZfeZJITni_O6
zgyl$4a*8fG%S5McyvzaHdB-Oei(IYX`SbS3kB->M*G>rDMLjV3P2mJ$@7$ycHa3)L
zuDQ&BxT?MRvE;T@crl|fAPfji3F}-+O458sh9@3du%G_$pgsPBHX-*aJEQi7Jms<1
zZ!ERp;;nYzg?7tZq}N(@aa`v>zd0^PC#?AC_Pyoy;?V`=$Au9TrQu9m849YciiH_U
z!G@QVaqT;&^8$tS*&f)ctXvLkPQGTB4>(xqITe<q=t86`vQoeZ6)|{UN2fJu6!xhj
zgO)P#sz9(J75iU1^`p1usyDxL{%!H*_s?4sPMvA*Jk_ac@CqwlTkQ&T$(@pgA!qFg
zM}uDCmbP)7^gz*N2BAaO5l2iCY3b98em^FYp|0H>oVb%cKo)~1Wlr0uFo%G$laO%>
zfK8pJT3y*ztaguG_ugt-UmYB==~T#`_{J+X-~7Cls3wu`<q9@X+X<qN2g2C_g9yqK
zL#*AnN{o{2P=K@20~L$&<H<`)|G$5(Dv*>?ha%yi(cWP@^}>FcDU$Y5*Pwzxqa%t7
z3XGKO&7$l}$c2K$kT7Gu0?`h%O3*A&S!InIF#3&udeV;X?@}q9Q0$};@bVkBR9jzq
znZ5j+a`2r!mRBrqUfRT$s-a!*zGIPG=j2qBfzY;`+Vz!6D<!1+U_AiY0?kTw*HkL*
zDUC6aI8WG`o;((Mx_alUt4bWxHl7+#R3hBsx4GEoOJd4D|LkL5ise<bg8@Wt+B1;P
z!o(JtEQ?(x38z8<kAps>@CqrY<j%b0FPQ9wdxoUe(8bXtB7qHrV8F_CX7wBBs|h^z
zew-A&j;r0a``AhAoy>92&{S8~$|>mSSagipbK*J6lk>9}Ep$>5CPanPmVgRhVn|gD
z&1*UY5|r=|MA&0e5)sPHQ@x^=3sHLMtX0>*@WuMQ-S+y+Cta~fG&jgWre%yeTQWs9
z?&|s+H-iyoqzZ_vO)~I)I5W>Ry@dtU{mQ=6_T4W%?VzGzMkL|t^*L6uZnHHHN7WN_
z+`w#KR~&rDOi5(gNEk4$6uF8pl>TfQbwP8oNl>!Ml$>6KIlVo}cAoK2-9^P^vSFq2
z^<Bpkg&bg3`h@^IBnwR%M<B8KexLrE2R{|8z4*sVVoDCXap$)GL5d9Kfv`;gM1mnb
z0cKSo&krQEzR|E7y-Zstlc#btgxmpJ;q1u!hB!emCXzBwor)ZrQnp0_DpeJX2{Nx&
zDyQ9wH<(eJ(bFB&2Xb<dniG=3TmTAK2alh&)7`2fs@m#6^vkOQ#(e7E8m;-cFDWnI
z;xauh%_zp?83s&-dGWtv<ufe@o<flV*S<mPEep10rZ9Z~y&~t$ps15?oO9p_ejerg
ztW=!HOG#b>U<E@`tm{kB2=^4}bOIyz!*9M}Kl}D;F8l>U5+~iVMeVMVp2yCPTlblB
zuKxxJ3Biz@i@`o6F7$D{rU)Y@wVpE2<v<k>Cfw+pXYu!&i0c4(#}rJ;a-H|MT8Dvn
z$&fUJQ0vLhFek)*j9Z?Jtp6XunoE0JKFb%m-}65|^ZK^6nSYwDVo-=5hD6hYTRb90
zSlrsFAbOcvW$PPs;fDleqQuIq&=z8<A9P<lBzseFHEhXPTqi=dCHCc{Jk2p>CHB-z
z+a338v{;rVGgR-8Z(U?Zf8Hg7Ta8hrQsLPOdFaH)6z)mYNtjnzTdpd-=6mI6&7@g*
zd97{UE)2)?Q5)<J*^$EvI**>Qk{a2+Ib}+YC~k=@Da$mj-;gRB4&vD_nYs`Y@{F@H
zWmjsh<f3fSC2~+T`t6Fvs`bV4)0%9}uH8zq+;1lve_${D_%$5|bv+?97M!nv!C9+c
zt>L2U<q(DxO-$hYq^T_=Rj3uQkibV3vpjUL$A0|1{WdHFwOrYa>ALwURtw5y%?4{x
z`|44FUS&*nDa|Nm(Wy_BtsT+%5bnLsv5uwB9oAI86vZGL-g}cOu5xtF6c!unH7ez%
zW&j+Ua)YX-biR`bNx3NdHAQF}(8Sod00%Uze!kL<yxyho5>qDhS^CTc5E(=~FD=UT
z=9CMfv3k$%JpJ@5{ceLxc(`Oq$+7dZ3cp64dWj(u9|%K2NJ<vqLQvt+h%U0ca0nF+
zcoKnIPsAc2uf};@l{IPGZ(e67=eAq_oC35$<6wkv#npS<T}w|3kb%`YtXEZ}(+Ct7
zS1EoO@3dpGHIJUkw2jwqun$}<>7AWo`(IT(=J$SPncdI3(l$CDQQyf`LVP~b6ZJkR
zr^nOE4o5IA9YusYkq8H6mNmFlN1lJxNh54-U{DByVS7`Jv*8L=Xv?u!n9}$aJ(EIY
z<Q;)>vNf;mZ?&f%dR<(lA`6AU&<04y`c)h3Sf@Z34xY5i^qv5`O8cWRe9;9T&eVtS
zsK(Qk3%%s}E3NtTsP*@&mAP)KMGDGQgsYlSIWUBRsD({d*U7KFJ;|}dC95@WNT_Tw
zcVNh5TKRvPrm3Y=>{U18<(05q7E>1Qy63O?VW@6To+17JJd@69Zev=QjC`pl2o=64
zZw(a=V<tO0-p&Dzy0}szPZxW!|D;{DrAQ}z+^R|@?e1I31v0f)KnH3#OW4^B>p;{E
z40;$6!d$4%8FT9V!N-N0Sa_{{@Gi3tY!X1|kZztQj@#nNFQ~VN(lG2md78v7MKB~x
z>YO6|&uh<+4xvr!@cN-l&zSB%Nel}T8K+)7<m_u~Y+5}Q(}o-~Y~QH98}-z9=oL!S
zm`;m>GqqT1kBb?9^3Vy#jM$E#rfs;gSms5Qy>NKUsq30br3Gc<iKmws5>=hN)L*~K
zZvLeY>KbIYW#iUtD@!}&a_qy?jP_F)N;!3(#^vjKhGe`9ggpruYC)ym6L7)VR<Jpj
z%`}*CB}4N6qL7EvGHU+L9po||E{iF-17=gp+mV*gg&30cQH5-%H9T=vU|2O$f3o*s
zBtMM|#`Jb2+j~h##-U{}!^Rb#130u-Dvyg+wfzP=^U8kv_^;n%TkihPLS4%ibF!z(
zvI<m5RDJ#(OxNDtT1nW6R(s+=yN%}WviClaYuk6l?A)LL4h|^gclHsf@ot+}*lA3-
zjyN|kVX~C;%!)To)`!kPNAg5HEvkS6z^L@J8(jNs<C%Wv?PC{5q7ydWyP%sYX65x7
zQKxVdJviV|GCvWgrn@I@4}NW*^R6rN1I<xXnrj;xHdy<VP&HoDOiGQBh9OBEvJ|M&
z2q^{=KvWyCl<(YY<+pvnqSIY&ej_o^lSe0Q=k<5khWeXa+XT{kC3#zt^_W-KjC>AW
zH#Mt7RG3Lg9jT|}*Q|?c>~u7{y7h8`=Kh$M#gy!f!-KT+42e2mA%wFW#tGaprb#3d
z>YG?43r4pmFDU^js4JS4*V$rBkV_MY)9%fc_WyqVG5g66dabnh2K&ul`(?ZFH-Fbg
zri(SLf{`hz-cgAga|U5X7Klv7?G16eE81!U55H>Pdc5B1Z^*H0?vytv+beWTP%jVv
z)Y69!2SYv85AOEE2}+Rn!jYCN42w!p{Ub=f1l0+od&0?i<gqV>CLFL7k}SCR<3i7^
zt1pqHQQx_u002PY#b-)t9y~T|k9_R~8*RrCq=`;b&elY&a&^^`x~_;wVo7Q`=_o1b
znGxwoE}g;-5ZX50a))JYyWM@A)2EtkQ1FK^eQmv(Bh)JLy&peiH(x)eRH-VU1c|{!
zUC)e2N-rgSn?$nLEiXw?2xdMm-~7q1m(D@?u7C5dFX#Eqx64Hy1&3!-RrpU+QEg&I
zPjLa~Ltz=gj${C{Zgr(>nzRCeP^oDurh(*fVPh+9x1i@(oXH3Rv67R+2|CfNMyJXW
zyZz3+cJjqjcJN@QJ^b)td+Esz`}^<ym6cVm)}aS%>-t^lX{oZqXFDZ{`W5q&mngvd
z)M&`^^qSy2m2*=%*{fB7wz(p1?MDXena(w~=kC>3vq9>xSCUlTdst3GdbWy!(~F(d
zOjXSz5^_QT|A+$Pb2=6dT3ApuI6G>`*84mwvm@zGIa=LTB@3#4-=6-?=VN{CXHru1
zewG|UCNAV=&e@i$%57>cs&k{FjdG=6N3!jQ-#u+7gxH&%8rY6G)fu*aU4@*bQhWW_
zh|RV&E1oIoq|fu}n%DXh$IH=BpnGaEWUG|YZMg9+o3Fakbpd3Fac2d*b@r7vWK#~P
zRU>9k{b;{6T)Wze*6*=1FC4Vuk{ku@m!+P3X6N8A_lRqvyU%iRX5_tB+WtcV!BV@4
z0@5x;j4bCn5Mt+<WJXLu(OjW=<kntwSq_d4<LI)PlD%)+U0F9VF|b|f40&P#0+lhZ
zq?pjRgz2c)5UDZXr;CfS#F#>H=ooQK857PAl2Ywt$^xY-3zTAo@}37K;?~qPE443)
zB!hj|&G*^5ZM&?pY|Q@j3%_Ue>))fJHfceU3GJ<Vvu)UL!%XYQK)B;nqovD{QmweE
z-vh?fMvf$GEkjat*Lq2tre1sKRYu#D*cIESW$UTxrbC-)7-?=zqokX#b<#?ef)iw+
zkke9Bl>`78YCTW6WU;6_W=O94qL_C=;g#u;X4`uG&Cc`w+86#(j%i?X<`$~pLohVk
zwinxmja6b4sommoJ8^p69(nMv^=Z<ok3E(M)2DV#t#zs{74JH0rpI~QGZP9IX}^ff
zIT#X01_=p6LR)s!TKVlCvhhg0Y7koVhWdpjG!m~?qe7I(Ul{FFOf=8x@3>Z}(5U_B
z^UoLwovchbVTp(X$MH<Lpn2enQ?hjxFyFCVQ!Qr7?7*QB*ZoL4bl8upW+xF$3C(FF
zOWxMo_W#MBe)TiKn#+59M@)J5Cw}#8^RYMnV?<#Sq~)UQ5Xz!v=9n_TiBy1HHV$gO
zv^34?%EQ*7*yV%<63wX<(-VxDsk?qMo@%FC;!;iOtWzn~D^H!Xj+Vpr>%V`qU47%{
zWvk$^!;qdhhEkn{#o;YG_FBtWnl-(CP*DM;CS~`)m=X2cP_v4kl`2m)UsANLMqp67
zIUag?*k-bK+U{#dEUvcNsSX+LP2#?kR;#R4>P;c2VX5H^1@NP}xnc&zSXDm94LBi$
zH>4#@Io>C)Ii=qkZvLPhIni(5{o=o=O+iDf)ReX$p#Aj7jNN!crLrnz3Y&y&|1&-I
z<fBKW4F&Ke37INXjoSKRId|pOBHQxZ(MGFCAJPAcH>#bMi;fzF8B_U9N-Tj1l&4Cf
z9q+l;BAf5DAt0*9&X2ypm}$AGw&9N5vt?J*#@=}JSoo=bepbCrO0`OBrOKwy6?3L4
zlrf`}q*vWj^AakG8)phKdc!sKcC0zo#?<hZp$-AAaZKq}&zM{Zz8?~kNxOM<w|(-t
z=UzU+`pczv#FWIKwr;Hajnu_yXNcj^P0lKXri(~iZIRrlE^S0QG^_x7i4619G^r9X
zM>wunm!#z)@kvok@yoU@g-M9HN$o-9Ravh0<X=Ah6W!KLwtLUjT3euHn72hpOO|1I
z%Efl|?knY`)~Idaq>T%w8pf2E6HtL#w^a9;p_4rum3dL2k~6iyuFagccBSnOjWpO5
zx7SJ?cUybAdRzLHx;)fwh2>|gVpXm6Efi}|5w@ASB?V(07Z|{NOwNY#*YgYN2~t5t
zZgkLA?f!T6?86iG$_r2E^K?;l6ZLkD+4jw<PQPxgHFbvVsYlM*>-$>7+<}xUmYuk9
zn;Od^#dhNOsEu^ATYZ(x0^NT|$Yh4}(h+rCTM@Ml@4we3tFKdBS8li}{ykA>4Xh$d
z<%Z(fu2TaU-}%&o;S>AXEWfT;Dp{z<I?pj(gB*=}Nt4+0Qj%lLCy+IYmFq68U2psM
zNos3ccCO;5^SY*J!BpkVJ?S=f6+|WF)vbU250C$Qzy5Nc-w{*tp&$Cl-G>Gm4?hrA
z<#{|L`zuw=T#6MT=K1m&Y6_D-A-iYFYU*;WwoEBC75R>;7$P2*YEcRg+p<^r;1LCB
z^VDv@od|I^W~n4BQyAgT{NPnP^x8hV`lcJ?&|IN+6|hs{QOYc_$Z(U?T)X}z%dg#F
zZ=CA3DV4Jjlt-P1<v@fLzL}J5I5H%O*gh|~zL0H@IzRVPzdiPbiaNGb+SPjnts*<K
zyG{14%!o))tEz4^-mhO%$0QCi6`F#Ol4)Xk?8>P@0V<?-*s7hMu&+FKP+_PyR8vU2
zRwhZV5&-wghHDMkcfWbUI%VHc>qwVj?OM&`Szl-ElSRt@v@1$I;=F5)kJpQIL|uar
zf^@{0QB2#`Z>_Oa_uPM;x@I3wF>J#0d{yy8?Bp|N!;gOMarLI_#;H<ZR|G?5Dp)_R
zivQU~4PuhnME^YjbL`2u8rD$Vt5-{S;D{-ZU#`#+(h&b38OPooP!A!&if6CC=^tNw
z>BO^s-Q_;NW2Ssz-;tKh>k9uAX5`1hkfa^4D;LyI&;O~Zf?FPlSzVn*7H=rD!KO|d
zl3BK>z;dcY!pNlT&i+ZICWEg7GbXDCGCl>Rg?41Wic25*u5G!pT(;zG`ppAcu-%ZB
z-W(WESKyU)#m=qPr0J>cjpx)5rSOIV>oDeo+5x5&(t$x$qbrLs<m}9XE_uMm!~q5C
zY|m~DClUv?sO_Qum?U0$x7BXYoS20YNhOVWQ?nZdC{sdESP&!4Di(QVo#5{(Zm}=?
z(Z8q)T(fR6)KRG$^X6M?g`t^ZU;G!vMW<ClD+x(Je4UP0R9R__T@k0Qt0Gf!JS2I=
zjM$HO*Qja_u{o;x$4sT%ufF{n%iZ%HO<YrT(F%2~li-LBfUM}O9r(fHw(m!WZ84(k
ziah<0aFarE(pVN`TIsSl(1KKHwQQkdK-iNZ_4Ul_H(s@;+|D*;SjV{@jei!%f!@!M
zghVoWBIK2#uF))&Ef%i1^}eT{-j|3T`z<d0`5iMQA9?$ZqPnq(vF#c1G+{`xIhiW=
zPm!ZQ`{shY1Z>L`g@V?ulM|tf6d%)&D2aekg>qW^Bw+<Ckj#iHf6BZPtHl*Xnl?6W
zkNn_i1#~BE)8>1%8O(?}PiD*}Nz*F3>Z-jq5YD$Ijf9J-M?ghpmZyptC`)SHk7|Q4
z>#NObvc~OaFLqnoP=l@7Q>a1)LH!9HW&b{fkLEkAW{0LOOcz@JgzQ9BbvjZ}=9B`=
zn{TbN7hYOrKlt(^R#U55O@-HMDpB<zd-TC3Im*H3f*V=Arc_`B6?XKD25z>tSxu3)
zmJ>tRhzsw-J;4XyKq!k=6}D^cxYHIZb~*bIb&Z-vDkf7=xe$~U;dtU7zh|9q^lHB{
zr?D31Cmj<qS_a43Q%Fok2#>0I2|;O<ux66aS$@H^RjIV@S@9TQutn7;L{>OB93!MU
z&xHx8`CadqgY$)d^v8WC&+iIT-u;RHxUc!xD}R`+*)T9<j_T?NgkyKXjEH=s-ME0|
ztL1@bst93JiTx=V+ATdAsiBx)mLwPWHzD-Z3R=*pwK=I2?(QN%{)yM^C*OEUjY<b>
z&)!>|J$XK3!l*r3VlHe{RKL?+6Rb&pZ;y_l@RK3}5#i{}NkYSz*&1gzEU&*>jIm8E
z1+PEbX9v2Yw(06}Yq)CG#@lD?$RUMGTE=8!b&2V6RVAa0lkCX_Rlbk5PujZcZnH<8
z85Uf$LM`foEY_UEtn9EIIM8o%YQ923mg=_??wMBE+Ch1<^FzH(T_YJa+Cz>UIGTZ~
z77w^k59%7vecg>8v-zA=N)|{v$h(Fip(Uo2`BbFFu#+#f*^6I((1ook)~^%Jms&q0
z1mkg{BC^+YGqS*#Fer;MxH5ADZ!PDN{QmUtfb+WJX{+q{mj;!X2<+cknN=)aco3sT
z8%7oG$|~Fb3ACpBQt$BLU13T@_WN#VxIMNoP?Mr=yO{1C87S@x!;n6V!2Cb*t!rw8
zI;Kgh&CRMrSBeckH$6qRsM39?eP_4GS>hRr)5k1^gyt11%$DPnRghx`pFU|XKl>wF
zt5(nQvTO8iVDGsNm(=-`-dkl2Yxm5w4)le)+FC7@;t@&Bm_DmS4#m6}5<+683BG#E
z8qK(F9=E4Y0c*X%uG-tD31g}cO{nvN+5wplV`~4+waMPFYDQJqP_@>+^|N!9HmoXp
zP3)z0qqzl;0AWH(U01Ej5i?g>>rli_pHLWRa?r&ei9J$KLDwO+BjjU`{J-PIt1ai+
zTb2J8vj9PzAe<Noru6Fi#c#b}#~%B+aMtq$>0PZt5@`o9Q8H7)jGiIcpRpt4vnMrh
zU|uE;^%ZFv5PIEJwRW;CVl9NM)Qp!*o+)v5W;I&5YE^aXUw-a|-%H-+oxDE()84_6
zZn^9B#_`5C9>~%KNmH0(LTVXrd|oHbhY$!2WeX2|%jOJgYf_)bNfk-ROARfG;Z*nw
zvO`RjH|m?xe#;UwMb$)#hPacNE@n;9-OPzDtIXA$>Op(z!AGqoXWr_!->qNZ?M!cD
z@}q*V(KXlIWTW!HPaZj<o^TyN7s5)E3F(vcRHz8js2z0zn$=gvtz3@4)30{hKzx(!
zysyqmvpWS79kLV8&s+Yi=IUG}CrU1Hxtg*X`}6FFUw_$ZDgryYr$;b>Vn|Ykt2dRp
zaL@6^DeFDeV&zdLpas&AVv0OTNbE;Xgn>%b(y;6O@3*uoZd@E3(ictguG!8xGYN*A
zoNlwHKmV|G2<)JszRKOi6XTj9q3^gT2^m+|3MuKOBKBg6L~*v5FGV*fiwpJ0L>e0q
zT1HOXuD-d!9(qipS=3g{O_oet&!|*6wq=Uy1PZoZ`-db`lDBy$uirJMM0BrNTm2iA
zIWu{aD(@$Y0YgIk2$l?03(e`h24yYiEg4XH?)Y)Vwm^%}$%{!H0E0p>-b+bTH})jt
zRF9Y!f+^E<VoJ*L9J24j-+N9OkCxcAH@{D(zd&1{zRzb&*lpA1+bte0uveSgEF!$2
zIeD~m$^vC*W_E^9Bw$V$)0CdX&McG^Z9LRxKOZc$hHZJar$RVMs$y+yl_!5<)HZMK
zx5`_?_Uxk*n)=YLQoU3g8V?KXX+|g+Spvu^cb@IBGs0qT>vr{!WFDyjWuTSwuoDc4
z?TEVGx})0aZ@k0C%XZ2kAAA!->f1S@mAT{4@z7&me!`{{dV(RR<uy;sp$Z(CfYH6m
z9-h>oD8*UV%3PULa9rp#s^O$uP%2qV-+*Gpqal0XS4ypKw%ne5UR?&dfnq5dEHAB+
zOoWCO)s#mELT>fVzxHl8IR5zW8dGw>dp>k)!DRoD8)uZ>nv>`0iGCYY1}CSlW7zVl
zDs01+JS$QcVy9w)-F;GB5|54{*(t%4sQa)y!BjCKcRZ9XPa1WenFgMY0`>}NWQo~P
z=P&;3wUpOidc>}|_4Y*A2&tJ&*kJ=MY*b!bZ-+XE%=%iK#9WXxMwRzzfaaVM0N9#~
z3S=`41a&@gyx*zwf-6?3989rEO%K4%JofXLUD>c`k3Tu7s%$Z}Iu+-n5h}|hC2PyA
ze>~I9H3`n9cgQg$Q`6>@JEmO$hD1frX!Hx9Q{=p_x@oiJ?Yhr~)w=7v>qKpUk3BjY
zGGRZy{@`PwXCFKuqeB2zWu;Cs@@pf~CTRl5N4+|nN}ap$2@L{O57kxM6q-|vGhG8i
z=QZSsuodP)mqJ!iK?wfNzh`vx9((Ag1J<X>xdkPl;3*}%f+>kZ$0czit8VzlUw-z>
z-{N!MEqYg(^8I&x@JQ1e2mUZ!J;2FK=~XXGIi%v<0@*05)si`*lXuMqd5gLrZJl$D
zF=uqa<`mS;(*UOiIR^bmGC4UoLf#BOonxm$Fe{9jD(|OAG0-z-`s}f9e_vHe`HuO5
z6BRfG!D}9yWM{6koqOJE$5e<s(09a2wYE<cM=2$$<y6RMx>wEl3b6L7iA!dzUA;q6
zrAJ<^oEfq}JMPw$wOEHWH45HYQ(K=IRJY>1fc#~jRh0_Cta_bw3z@A$-JWT(hYQPP
z+le6|!YX*%o*^-7Rw-O|?FVkQlr1+e4vncTGf7>0rv_LY?8o?gxBc{=pR}Vdw7J+L
za}>Qcaii(fSr?~iObaxmd#^k?uav58==5?M>{ccxM^G>-+e;U-jR;O~{n`cl=x?r8
z4t<?8SeosBzRSinV<%N{=1egwnL5tDr&-ynQ88@grW-zfIfcCbI2U?;SD6wKPCk5e
za%#J7q9rel9|J=|F_nMK&df+sN<b-vHyM*hx=QgwWhsV-XRM)i&gvCot1VFOwnnKv
z>AKcd&3u#v4r4-|A$iTo;(sqe>8>0fp0p=^{HzKyMs3HH?`JbnGGhkbIa#3Hd+xHf
z#Y}tg`BQ4fS5d9byR?{%$SbWZmZz%h6O<|ks6tjjg@Pv7nP)n3t>OA&+gvYP9?kW6
z_<$TX73rpC7l}F3#poJLs@`mda%L$wO=u`X9!*$xD0U=Xwv&(oC)g@1qRqG58+g~f
zJu=n;t>8Xb58i%6T@Ri)5&GFzp0KXd!vaPqaT)_@h*V?&%El82A|v8&0J%1Ak8473
zu?znc=tquEj<_<n@j=~$>h1Z^J#}i7i`t+Va#T<}&+qF|kX&BAv=BjcmjUqy*7KB*
z5lTwyUjEDf_1I^UR=+DR-&LmM8{PcD4~(|FapZv%-C^EKOIF|E6d~SrELy!%eKi$A
z;vG@@XxhA07e_2IJz@<NQbr2b42!AzhjIk72lh>dV@xtX91|v|F%3rdcQ5Oape#8G
z^kxaJ<)`0zSw+TA+STv9OHyIAzFo39hcN?nzIFZktgK;^ooZ~h@ow3o@+%fJiDFEj
zQJ~Mt6hvQ#I2DPxeuGk$vNI2z9kyc~*|znr_o$V3#vXn`ZKowsg~D`EHAgY5&`qRF
z-~sa2a3p}7aV-mykOhVM?s6VN3WaUov(YMVzw1rjHRp1P66*TYvj;*y{>n2FqN-0_
zt#QiAO((-hdxiu~dPYHb;1bubiP@@}JPmXL9XW0V8A_GvcTGwAKttW8#DL<UtBTYz
zGH+Ft8TP_!<7yod)0YK40nCmA8dgOVgcF*kf`XboAN#NGG|%l0xZ>emXG$ENE4C^h
z9-GSZF~>O-NI)=Apu!hb6PaNf*B01pTy`Ozx{3>CRMOVlEtuk5rE=x(j0wp%Cbhh#
zN(H<sa5#5v!bwby;cZkTB@F4qPX70?jx5mO*IEUT|9#tf^%j@uIiE58)?|TJsVL&Q
znWF;(;hwH@mM4J&W8$zas<i;fL6~!(SD^VyFK(2Y9y+I7^}#dthNR6KjcIBU69Z0;
z>bosiesOvry_8OcA+aBkjwPCnNY`If5_Ri!yDe+aofq`3ePA4QJuOMK|LafL{zr~j
zs(=zoG%6*TAp!Y<@x$`|sQ#Hq)OW7iAlO9pn~#nw)TSGniY>C-_>HP$bwPO{zu1P&
zO4ycw5~tCBCFOSDr7=lj>`58fBAAkq+1|EXRN|vRDa*h9+!G)1XYk#8e%G0jFZbd5
z_fB*-p1T`N9Edoibi<N#3+c?ob!N70(r93TK9v;7aZ&4MNGfhnc3Z!~jV*n-)~}Wa
z5Q{RhBDPixkrPok=d{`vq*4fPKuAiaxH6m+#^irvy!RCV03ZuVL_t&-5<+Sgl@?o9
z`=CAgorf$WD7-6o+~wZ8kazB@jXK1HP4blUX9Nc$J8)2vGq+4&16?Y>)kUZLj5hZy
zNxW*cT|7CEZ#h%LwoQZAPY<XcN3-!#6_3qIQz%NA67m5#WeKzkrSXbOs;zR@d&Hqz
zY^D8}0j3{W;P`T`m?FP=^<s0&+0ec({J_qh?zW<uQiYFnoFoYeLqg6pkRWUC4{J8$
zynd&m9V+^zgEFF2Zw$j;B)3t;zUnj-V+xDkR<DWM`)}W<bDFC{jSPWQrQ1_ac8bZ>
zf~@n*&Cj*t93y0Kc;=<X3OBv?8<z?);J&~`Jp6BA%G>X}ul3ZSSN@P<3J63A)UA>|
zj?$4b0*Ws$W1?5oUVnYU4xgB_SB?pkN{}Lb<JoGl4ZO&ZVE)pTY3S3WhE+<n5#;Ue
zm{ws#P-v@5E+&z;EQX~3#51IqoQpb{FlJcZ;*;Ng-erMqx&01(k9As-)j40S$1&ZG
zD>o}?S#4*UnstK=EBGC<0cA2_&O~}%VIP?o>h;;NDQ-`7=2(GRLuRBA`cew4Qge$7
z@)lfSFS%=^m8XU+yR2l>bvBTe9|Xf!*pF;Sst`;{)b&$ee9}3GB^70IN>u%`IOP%z
zgwJ3|m{DM7Hmd5Sll`*Sg+P4WRl1q=nZBiWPC!|cv#JeMg*r5;o0n>?NtsS5!YXR(
z*1nyDsIu+Mi7|WeWmWelR5#ZQ0f4lGDHnC4MoVORZF|qV?%=pDr-wkK`2XI;=TCm9
z=BrJe0}o_qeDZ|wfL0Pe7W->Zy&uW6u~wd*92x@Ys0?ULt%^}q{T-2)oi7#Gd}h`T
zo>f3th!<I67znSE?P12`*Qj@hcxSqtrsJ=+*;Ut<*{A;Q>oYZL8l<02x%ZbJg5q3-
z&+Uz)r|h}Mzi4BpUbM9uNyp&!wM5oM;U0y8R_nXSJO8ggE>So~uzvbI8&)a!oPYjr
z0uh6CSKoY#%@kZ=Lo{Y3dDp=agGU$=B0ID1;UiWe6peg=`jflocfp8$It0U0f!qex
z`b=|%)e8(^@AWc=RCmB<dc041sQ`>{)5Ub-jwmTGDJPS2%%tJo(LkeRs;DND9CyAN
z*(9#K5aBgL4>-S}aX|sDUH|gmfBX2g!8d;QAOE*VO1|d**WQ^2$623u{3m&JTlZo4
zkS)a**ccm|!vPzx!&zV&D1=N>3Nsy;l1yhx+D=m@?&O$ZrcIazlHre(78;Y8lm-Y;
zj*?(%urUy0d|*qqY}v97>$GHPb*(IKzn|akW4|nGgK=bAvY#30efNF$efNFe{qA!g
z7(C6@JMK%D{574D?fmKx38Yb`$XlFW5K`^3k|X3mE|!ZTO@NFl1&#=V>7+$M;sm*m
zsFfK|W>JMQ$d%3J8V*E!M=%~3EtTPt{BbOQa8cu&xJ<~?oK#Wj_SJT{m!JEuP;$2s
zKLkW#mv<Y@zhtG`BNxifz11#Hh6DYE5a}6mxKF!0!#(r9N-P?WXb3y=5fxG_A<hva
zI8|7{nYk$B7GHUT8z`$(GpiQQ?fe+&cyPhq@2%^mgDEdR`fImkUA-%xnJ?XwoKs1K
zI3VGSINx!6H+P5Jfxax|fKG6Ws`}kcw<u9r&!MwJ1#arEB#lNPLgEr~8R@ce1y%~e
zqB4RM#r8f*nP%!!q%O;P{-{t{`aGgP21u@r*CxUh%5YPbesfd|9D5F<21+w{qLIFQ
zZpiB<{sv<S0B{uw@F8v*kVcd&ktO2-Fd87?vblOtg?ez(7^S3ZTCKj2ifJlm(6)yC
za=qY;mLY<gfKCY*5jQ4s;GUjT{GTH6m#?IbL48Xv{KsqYD9|0c0&)!z=f){zZN<g;
zWml|J6lkg<9(y!cO1(B^=qUW|w(W?zmpA3R#TU!kmJ!jf1dnXFTe32X#hH{Hr3R`C
z7EEz-7OR3Vzubkp<S>jAK1VZVgapOTCq?VtelO*v$A9a^_2jC_K68q<1ITRk8OqWR
z5evRUqPku|hrRV#D%ExF)@7<xTzW(nc8QD{RYxiVoQ`NDgbb@)PS2o1iu%FiiRJZ6
zlv7W0SpRUGN3o35h=Ct9#P`7WVc&^ugP9N%D5#p_9)04)Q894*1?b<Xfszlv;A!}{
z_BPx@W_hDqa^s;ugn$P?JQl)bWCoIVcL>no0g?`4BJqeohbW&QP!~&gn^TeQnp%~0
zq%Q|x0z^QG;bXuCsEBcMy2CLGWCUPczWK`L)Q>j4;jX=PW!!Bf<;oKrlRrQ@;vMms
z<+I&;GB`rr8bmLS`F6d^0~AXyEF5ta1^N06@+iynBat~ST71<NE^Em(u4zC8S_83d
zZ1=t4wfsaf#p>5n)~K*6O~rGCiq4=vdhW=NOClRUlG3(chD=>YmTPHB^WA&zyd|RX
z)lnHZu>@Z9#yrG`sJB;%)4fs^WSP@u8>>G};yI$eNd2mHMlXeMvZu)?HSWmw!(WiR
zgi|`vmzG@lqd!I>Z}8lS>!S)vg7g(-8Q;eN3k8iG^b~HKC3IL%gq%JD6Yh%%ipOHS
z^r`;4xlM@+>hV~l1_x9brb*O<lp>d{wssfH%2Jd2VXq&-X)%0I88A3aq{lubX05Xg
zphCEf_SZJL*Pngb&0Ao}!$SB`0+>)N3bb&ErXeUDY)9=b&2<z9Q~WwFFW)Vh)#0Xy
z*)*#r*t>g{uQ;0f$kdD=ndnAb_jT8$y!z7@+@`hrTwZyxy6nQ`kBMtsJ&0^LB!Jx4
zouwAf^7Bf6yzLf+4hu@%ZW&r3>AOZpQq)~pzEmm_X+P6DD8o@4GpweqMTNtzNZI`Z
zN>x*;t9Q2JWKY$zl+ySqFxolkc7h*v`usmmBCnk{*>Y4t$p_xPth}=QK=&fJC3$<0
z0TEDoE-9lYDjyraa$G5Rk^p1BM4ZLBm80)kW$ij;6y-}q`mA=HAfl%8=>p>HstniO
zbwoovm8Bzn3Oy5!X)Yp~t73_pjv2d>nA-?(-qsv;&;R%D;!&VKi|=mH(m**RJ#3G3
zuL8Gt@g+(gp5nUeR12hbEAk1r+0$hjiTk%_SGkFoU#m7J<vtlV5s>z|(=W;&s(xdO
zFIA{lqpE2aOp&grUYYX2!Xcrc(|vEJB*LLg4@lD=BdO)CzDfFcX3UVJ<49Nl8xkkX
zRilGp{m{F^(&_aYBM<8CO;e9aHOf-Vo&J|Y`hgwNkDk0&o?D{m<`}-O0gXtRGiRD2
zIM4r_ZKFw}4oWH>H*VPY?T|ppXg0tXmCk75At<_wi`Bi1>~#ThSV;;VQ1Zz^fQk5a
zeT&lh1vVNxb*iu`Mcc{pKCEAI<@Av25|iuhLdTQ1(wA$%v|==Sm{{Y8b2u_>0Rg6Z
zSotVWPv=^<@T!~jBe_6tKc;6&lhkX}j0`0Y$D%;{>Z{#IxWj|8J@Z0$aLz3<zH(G@
zs~~_{)EFVM;gF1T!QHdrnKwf({@Vrx2WVV1*^6rfq!-spH$!C8%yds{nyaZzKdL`2
zzeXX$aH$v1=|YS=vuYeGE+=dbOE1q=KTL}A>JP}mmOh=>#ybYgELWb3YYiXfpxj%E
zh-rObSjLb-zay$F#SrEDLW;quFSz>dQ8jSvS&f=Y$UcDOUDr+Df3UT)A|qE{yo?*%
z8<24X!ef)l<wsNLYB%xl0ksy?d%PYf4hJ0>4*Mnlc+g}H&8=ckr4lJrcT=oN!wD*B
zohW}~t+I8t?;4OHq<%oe#^nM*Ex@HgrKRO+avt^rOiBXarqJ$PP3nx6@4oxf$K0X?
z%d`cz5xOPD4`k~l;>?|H?OV?)X{6V6WtRE9$K#Fw5@Y9`r`~Xz-|tXewkFo9Ji^GH
z2SyF?@vsb$JrdOo4KY8|y?69F`X=q%Tk5T7j!RVwLWq8$P@Wk3ezm-5R_r}TsOEVa
z8Mn08)76EfRLuqk<xObUgx!`y3hs+6bcykU%GK5yc9&f{-#zh^(xOfSot6(_GFg95
z!-DL*!Zz-y;lt;)(-ak=4<&UyjPn4HzU@mKEdC8i{?Vg|dDgj#AD0!!ENk;)^7bGw
z@nz;`9{b|)ff^`zFC3Ey3BZIq1Af*IHXZW*zkB}iLA8h>sTz)1#~~uXc?_5X9Z$Pw
zR@b;lX_b!c_wPvj$0(P&n(CA_KYP(n2gBWiSj2#U0His?0VEdo?gKG#%?$5veqEoM
zSL$}{JEl7VNLt;{wa(h#v?*JuL%rDnq|xz!iCCYd-b4U1kr*}8JM-ojQbJYV>+k6*
z<GcH!UDOiK{aLS13n&vW0>^sa$f5gi?$S<>x}IcU1TYYwfr}Zp1dNKD>C1@eQdJV$
z(4e9$G-ZWj;$-iW7=M3<M%KweY(^Bnez;?hV{)u<N!AUR1K|O;b9<k={oB{L@Bi>8
z?2@S5DD|PzuOB(G)vf>4lkSP1?NM97iEi%9a#y-wwwq9@+J-p69ic6+Zd7}}KlpW`
zGgKBrfYJa-j2v;@C_NB|HU<s)<1M!;lRr}GB?5`TOj`5f^uz^OW~!Bp(mUOby4dpw
z0@8m-{2$;9a!Wu788G3PK^m#N_iLxps494_lUbKD=JXRInQ35e1cw5Eh-4#PBf<eB
z1W*7DT+FCIx)Xm*2gsV%m!qi5u$ndv9#+&sx@Asbx?6cww!8Y$7$*Rn008ksG$Tj`
zc((C5TvLAGL}l@mxL2Q9=k8Y@!G=AZay#Focfcj_Q+B#XepKh?FPY`8x@NZ8w;XbN
zw(s@(_-BB8=_fC_SO4=pH7rO|pYm9#EBk|h<Tc_NKyI&AR=xmv<7HuY_cv75J5r^Y
z+8X&srn=l=a7SyQ$XGq~);|hJ&eNy%Df}fPfM|a?nq~$_x9ywY8oG0R?@*4Bd89HA
zwXI3ZSd;7=qrL6eH$2*(6gYooe%1PjOmRP<K-)>-2Yd!V-fDX1QOCEorO9^}B%ML=
z1!b(u`AZ*2fN2CU2UU~?&6`!>mMzMXuT!N80;boM#4+vM26j8Y0Td37A+b=SSD5Pc
ztvhbZ{NMk1MrXWSe?9Jl-+kz2s`q%+Ty->ygxrc1Wp4gdjpf^W(08T??`w5WJ-ph7
zHWAmE^i!9P1_8*-sFG;o2^CTjr3b1!M1X|uzAdb&W+|%n)F(*-O!QODG)6f>sYy&7
zVcXv3Ecf2#*bmnq82<;i3<5JK!g&i|<c9}9akaInF35lxk^vbloY8o)qeg<Ce=6&v
zZha@aI5L&z&YJp{vVQZsdKBbW7|mQYa7f%hB<-3%ktHIV7BC?q5F&Ywyyz!VMD-+5
zjIdJv4=dL%UE@UvOFCJwQYjT*SBY=BI<iTR&zDZwDa*M3a4gdZ3m?ney2RPKZ`3c~
z&`5#y*(GI);p@1UUwkW`ZB*e>8(((22d23)C0|749AA9xHR>hQ>vHE#b$i}z4E^fy
zSCo+x@z!<F`Zqw@vl*0MwN2UI#IMmG|Ke*AH$%;-w(eCr86Dn~kP=q%E!{qP!$ab@
z${AH2+}53k<uC1V#hP53NW-$4A%0X4FR5vQOoRhS)^nutpl5d}=|w3Tn!2IR85s*7
z8*L}KznCQd&Il;EjvH@WamoH|+ZL++$R`SzGaEMze?|t@42i9D)xTt_Lee8rZvdDU
zzErh~bVYGYd4vzN4k+hPy^Bh+6(5%Yq3#b6)uAv*bIOc#H@QI39i_=ND>;{GT3J#F
z_<TU`WA1WE8At&Fd4%lCEy`6SNMlfbyWTZ*wz{d6^Bg@OTMsIcR`V6#eXHJ84+=;U
z<G*?QP5(n8I%E1H_hcd)A0!l3W;hWV;@5MkhTLD>Cp9EnoLL4<rb=_AgviyS1_5y&
zT4BB%-x}ffQO%I6s}Cmyq(3o7#<?ZH401~D)t>hRCGMKx$9j8xyVRZ{S6I39l-l{(
zHGGlf83QG`cz53O)d}5Awbx)!5L!f>8VK!XFi4od1;+w}@}PO&BL>n@K#G&msR3a6
z#3zLSySkWwApKC5eX61z^uatL|7cf_yn5me(<_wFs<(Hv3@DZ!>t_@pPci^Vy9Sm9
z%rxn&<&&~q_5an#XFBATUcX3@jw;us!mxd6O%vYN>^8k#<BDcz=#^sjaJnEdnmAoQ
zI=CZA6&9hn_KE>_-(4dL7Z%Gsqgc4+ln=!x_*#eK(n2L*s6)q=tzDWY)S*sxa-GSa
zcsvSnOE_haTiP)I5%PLwxXmq?S6-hp_wEN)t$J*&z2|f<kAFv};Ytt>cYNcnwOySZ
zU+Hh}$`6)M@bLf=OBs=kwT&AI9TEbNh*iKyY}fwi+CZh9oJ#^591n|GCA%_gqKYF=
zRyi+R6ZcbDfm$a|Mz@l&)F6ku!l88XfQwiwL*tzOGvgeS&nlUk=bCDpR6-DOmoF`m
zA=2meY;AQ-buB(SoKn_AN>eo<MD<{=vctDjE2&ln8UDxXma9Ex>kQS-kf<WVO!^*i
zY8rsiOtwhv0_i)neqDo_WA%w^D|b@y|Ib4v!g;TWaMlssfU&c!Ln(k#85Ul@x?t9d
zJ65gw@kaKaDf*-j;7nbGKKG#qzxvC@kJsFTBb^*f$Uw>HUn6hae3JS2T^J=$Vn;AD
zW=f@Zne|FuW@fgs-sMtC3n@QQR&A%UwKwiyjB%<m!(+~BEPd-zOi#)n`I&}NSjkn~
zEmustM)Z;Uh+h<nt8%gRI2du@bAMD9n*NCYu}mS!+Woo~sVGKSnhuPC!$h#O^kMgh
zt;%Yz>-FNA+)e27g3``ut|AlV19B$~^&WIf7nati&%WdD&xHHOt}VDc_7s9!&%iq3
z+_+{W+?|g&_hOqY8L61QeX%;{rpn63unErYfpZ~VAzw$LV~kJ-;F?GD9z}PRKpZc=
z7wbKw`7vtiq+Xe_Ze^Lzs*>A92R5sVu=u8rLvub8-H3K0|9MLJ4yCINpz;*cB&vh4
zV|yRmk+NHg{YesOYE$8yQqD-I_}2aU?DP^>vtP3fWxSwbK%o@1gV7HLK=$Zf*RJo<
zblL&clIso>Uk8jV`8$#LwrgN%fMgvp-q)>PhK^sbbmdvW9l0)}V=TzFoCQm`W_!)6
z_i!nhxh4LJ5Z?guu(*Vc-3wkSVjJ#d%iuoNX;}xAPnLtbgid4X6Qm6Aa;2T&I_g%7
z>B@3d_9^pwXMLYr|NcRDphLxA3RRM^jdLG@dqc)K5smynIu+(NcaMLA{uv;7jX`7j
z<MIo_?&d#LH;QnP%0D!sTH=~KQ8*<o9|%D1SG~_JwY(-fA3#DU%N_ke@qcFc^mli;
z%9-U27cIZ@Z_gI)7`)E25|muv_rCk**G3!HJzd|_JcBvb4Esc<98zI_GEmx0B?F~3
zgW@>ASy)=?N|h#-p^5f@GecJHG?n!>s!$D)UNl96JR^Ndf>8WsTP&%<L^_|72uwzK
z91oBfG^hkY|KqYtQ{3)m=2hxk0g-L@fapel-0(q@qeP*wB&N==KM|BxhGEB^XbBi8
zcUW@WjjKy5E_~=r`5{kqjqE#XL1`DB$Ti_gfb2xT<XFI$qLIl#^37aThDbCiBS%f|
z)xO#YU>ZQ#7K*4_TbXhf)hKGs`u<p`Qe2aW5b<*eSBmMKM2Px_W8qFSXn2q5kE}oR
zK(D(%tpK;~R0rdz8b?XD1(-2X2}4|e+_H1TZL99~`r||u$i>y=q=4kuM4-k`cys}$
zO;w|+xr?WswcPRO#cJiO2PGH#gCBh7uEuR|JUh_2OK8dQ7CGC4z)J>H<B+^JIM9^W
zG;@V6y0F+U+q;yQAeT#iwnp5iDfLV~%}h-Ln=&Z|v^Uocx?Ni}TfBJU(IP4iG*EU)
zJVVI<i9`Hv9+XqMbe4+z)#h2@P$P^PTt0*jhqJQX_RZa{{Xnbdju=acfDCd*Gk7@H
z@qh^+;kL_e`jfMoJKFPLdF<%~x1NRTWE!<MRR62#nyE~YC0jZ`fRtfMa6%iZWV=HW
z-HG}rmN~lNv~taSl=Hh!<*DeIh)*~tS?ob@*4Fg9->*?a1SMaPd1M?DF6p~dq>1xt
z01}zpraxXfZ_wR)_lP)du`<M&81ZS>0iQ>o_08(+8x=<@k{=XxAQ>RJ9|PctK*@QS
z5;j)2qkT^-#|$X#qT!kccRcrOYon?H)kq6JW{`|~2DxN#KVm<qcLGd6HG7uyOc_9l
zgh-E$gniagNp7aA-{0fjUmr`z$e64_rV`;f>HTh+blnfbO14lxA_L^@*M;56<uUz{
zoX@;`wc-;1A#?W>l%}aq=MitvgyddAcjcP;l`RzHl)>vt21@qZ_OYTn2Jb1jKITBl
z#V2x23?U;x387CW0yC(G0!$-(k%-^P>XtTtZiX_CB0dp<RJaK$)*_J@zviHNI!;!j
zR*axcZ?q^SBSlj#($rrl>Molz;{N5y6om_8dg_Ds^tweCPj;JX#PQ;mHJ@jo^g65~
zI&;wLk672#uqPT!#x3nygG)eY+%gErv)Qr^UjOmd$0R82X5gAFTYvp*S4*do2q?=v
zX4sf02Z+h^P4-9Bq9jNp4r|DPn>H=e1BrcD#~37J9huX;a&|0|^3k(<U3E*;U46a!
zrfV+b!~dM)6DrUji%TYXKynTPBI{6rN;$d*3*6i5+r0i*Hc4(FC4VFX<ng#A=P@9%
z4tFFq?&4+Fj~U&O>rO^v8kF2nBG<&P=^g9ZXPh#~AvwmlDeFOCq6+l%#5!%zm7`SE
zRfum05e~OR&x8sTAxcf3=r;a-x7)g{&xbV2G?eo@50tu28A&^~W~$P$_vrDC$xNDE
zn3JFFy4Brm!`841w|BVQ;+Q!1C)K~>fz$Q}mw*!8aX^OBSm%zx`x^70w43>-f4KGj
zrjIxLqE98R468RXE@?&$#*u*%K+>1pfQiw=e%_0&I8##~Fn|sZDnK14K$)So6GOeR
znjzLdmM?SG)IoRYm0wbu!(mrfqX}pQW&Q|;Y#vr$a43|KskxH_?t=|&>W~)pj`>9H
z$ol{$Wc!kdZ~!^hbw_`bN&bx+P;zgNJo4A``ok^%zI*LUOX;_hOxH932A_oi(?H2S
zfQdMtH@m=9%v8sVII!3UxOlD3;U1u6YS+vR@5a3v3MH#Oq+v?gn&sG|Q6)xzbK9O_
zxqLL^P=3~+{s`z0(*{O-p;okI#|ME)RcKFmcwBKuyHA$m3Y2zZaLwlGO}_{q&>(n~
z&O#V7fX^rqoQUqA@nak_tX3s6D$Cr(mnx|@+AGo9<3)HhBj(@C&5_gnu;%;>Mcm+_
zb`MBC1K^U4?#B`9^`_1JZs(Rgu87N#>&Unu?==FHTnFVE=7={inr_+E5gs?XquqDn
za$JIvn}ln&ZCmqX%kEuYR#CM}&nq~Z@nf8k_aUY&8;RFY5S+a3IVd0&l)Ec0*El&j
zzQeN03yV}vAus~eG}`rwdX*}duBZ$ImjsXibKTpG@)>p>b@v1TX<X7Dl;of7XE~_M
z_enEK$3#>n$*p|uP2(1n_5>dOyE}i_xc!|~0Bd62G3(s+vxGY(Bfv=_2B2+ITpVt7
z>#eg?qaJci%K8SNM^a+$sD5>~g*yUD)(gw>U3>e8d+oIv--KbR#+h+0Yl|4<fQg@-
zXzcWM(v2>4Tv*nL_nPeWxCbRSZCrC-UEP;`8kwB#iS&7Zi74+^4bk!?lYFt*usXLH
zDB+lc5zS<ju8BVR;f_A{@wyt{mbze)8t925djl$7IF|VNybgjfnkoZJ^Ar)+<H@p4
zcHfEH&IwT3O~W<oHoUxw%$;Oh(|`$w42Cex8s|K$_iF6QqD7^eJQ33?5!;!n5AtF>
zl<nSCXX2e3clla#OIWsJ5#1(|*%n;qH3T4W7oAJoF?Q#%|K}7axn)w~!u20L0@oxH
z+~U{lO9n~+YT4(ee-f6YRJU?^rdx5-JV!!upSl60W#_ne-fD82)ttXl4tVP<Z09vj
zX`-9YG(t6i*mthzj<Gxb^#5}Xl=cYVn)^R|X;oOYI&d@eMzhX?k)a@$v|}xwvRhS?
zh~^bH%=d=P+BG{p7q#3=jx|7X?1@0he!$2SirH7)H0Gl++|L)Ka~705uw+~lU<N^H
zoDwc+gv-V_EP7_1#)weZ-+MsAoJw*%_;@e=MhK1x0ZI}rEIep&>+$Y)^f!MJ|ITSp
z+H-<y?s(^wRivE3`GVZ-vq0(3q4qNL_c3ve-bjB;$a)vCj^!QJl!hRU*QiYJ9#3}t
zJSgK&46eCz<J-R+?rpD_sQyG24GMx1u?@$xR(TxCkkfSab;Q_#0AY{};E7xkFb-)Z
z<yg#j4Bp>pte*#E!c#R1oy|DhAq<_M_y%A`zC1#}gi}HWO1Py(Xo9*VqPwfUL-`pK
z##A=A-S6pGo(E-;r%X!R$M5{+(FunRRM6s&n7CCl^7ddD5a5~a$Uci%v)#xdIP?u4
z&oOJe-&0*4dvd3Grg3(BFeQ$W$WaDH2FSP{n{1Ac?KUpS(%e7iLd@Fk|5TUfLHQX^
z5Uv@ieg4PWYg=bni)s!Df-)G139g&ZalGX_e#Rp^<=t_Y?J1vU+@65Z!8d>X!PV(G
z`I9>vcP$)}lbk7P^c%7UTQty5TnCVFN9N)zz2WB7GZ(GA{Y>}h87p7Xc}{r}-<0W^
z18r>;^dB15yc)n~X=N<ol=vdg#hCR;JjxTk^*ks~_;^0O({#<+^{?N<piaseOmF1f
zIKt_#UbXn_?n3eDJ3GH+%s&CRCZkv`t4fdFa9L6GD+_X>th0@MWBvxu-@w>>0&q>*
z$^gczXJ<uOXWQ7koAXyauATr6cS<nE)lHqjoB4mJ!sPbh9w1);0000<MNUMnLSTYz
C(8Q?#

literal 0
HcmV?d00001

diff --git a/static/images/game/rating-platinum.png b/static/images/game/rating-platinum.png
new file mode 100644
index 0000000000000000000000000000000000000000..9ae479a44195c6af49e768d01435b3214b19ccda
GIT binary patch
literal 68497
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

literal 0
HcmV?d00001

diff --git a/static/images/game/rating-silver.png b/static/images/game/rating-silver.png
new file mode 100644
index 0000000000000000000000000000000000000000..4643af0b30bbf7b56ffd4701bdd95b018830b08e
GIT binary patch
literal 56479
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

literal 0
HcmV?d00001


From 6c6adbd0d9d25292461ee810ee2ade4e0aece182 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 16 Jun 2024 13:44:20 -0400
Subject: [PATCH 057/341] fixed incorrect frame assigned

---
 internal/stats/prepare/session/card.go      | 2 +-
 internal/stats/prepare/session/constants.go | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/internal/stats/prepare/session/card.go b/internal/stats/prepare/session/card.go
index e4aaef91..91d09af0 100644
--- a/internal/stats/prepare/session/card.go
+++ b/internal/stats/prepare/session/card.go
@@ -107,7 +107,7 @@ func makeVehicleCard(presets []common.Tag, cardType common.CardType, session, ca
 		sFrame = *session.StatsFrame
 	}
 	if career.StatsFrame != nil {
-		sFrame = *career.StatsFrame
+		cFrame = *career.StatsFrame
 	}
 
 	var blocks []common.StatsBlock[BlockData]
diff --git a/internal/stats/prepare/session/constants.go b/internal/stats/prepare/session/constants.go
index 4c3e404b..6e8a4533 100644
--- a/internal/stats/prepare/session/constants.go
+++ b/internal/stats/prepare/session/constants.go
@@ -7,7 +7,7 @@ import (
 
 var unratedOverviewBlocks = [][]common.Tag{{common.TagBattles, common.TagWinrate}, {common.TagWN8}, {common.TagAvgDamage, common.TagDamageRatio}}
 var ratingOverviewBlocks = [][]common.Tag{{common.TagBattles, common.TagWinrate}, {common.TagRankedRating}, {common.TagAvgDamage, common.TagDamageRatio}}
-var vehicleBlocks = []common.Tag{common.TagBattles, common.TagAvgDamage, common.TagDamageRatio, common.TagWinrate, common.TagWN8}
+var vehicleBlocks = []common.Tag{common.TagBattles, common.TagWinrate, common.TagAvgDamage, common.TagWN8}
 var highlights = []common.Highlight{common.HighlightBattles, common.HighlightWN8, common.HighlightAvgDamage}
 
 type Cards struct {

From cf9e89707cbf3528280d5529bd6d575c950a1114 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 16 Jun 2024 13:54:31 -0400
Subject: [PATCH 058/341] fixed realm

---
 internal/stats/render/session/cards.go | 79 ++++++++------------------
 1 file changed, 25 insertions(+), 54 deletions(-)

diff --git a/internal/stats/render/session/cards.go b/internal/stats/render/session/cards.go
index 7d18674f..146d4ae9 100644
--- a/internal/stats/render/session/cards.go
+++ b/internal/stats/render/session/cards.go
@@ -101,6 +101,31 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 		}
 	}
 
+	{ // render the footer first to make sure the card is wide enough
+		var footer []string
+		switch strings.ToLower(session.Realm) {
+		case "na":
+			footer = append(footer, "North America")
+		case "eu":
+			footer = append(footer, "Europe")
+		case "as":
+			footer = append(footer, "Asia")
+		}
+		if session.LastBattleTime.Unix() > 1 {
+			sessionTo := session.PeriodEnd.Format("Jan 2")
+			sessionFrom := session.PeriodStart.Format("Jan 2")
+			if sessionFrom == sessionTo {
+				footer = append(footer, sessionTo)
+			} else {
+				footer = append(footer, sessionFrom+" - "+sessionTo)
+			}
+		}
+
+		if len(footer) > 0 {
+			segments.AddFooter(common.NewFooterCard(strings.Join(footer, " • ")))
+		}
+	}
+
 	frameWidth := secondaryCardWidth + primaryCardWidth
 	if secondaryCardWidth > 0 && primaryCardWidth > 0 {
 		frameWidth += frameStyle().Gap
@@ -148,29 +173,6 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 	}
 	segments.AddContent(common.NewBlocksContent(frameStyle(), columns...))
 
-	var footer []string
-	switch session.Realm {
-	case "na":
-		footer = append(footer, "North America")
-	case "eu":
-		footer = append(footer, "Europe")
-	case "as":
-		footer = append(footer, "Asia")
-	}
-	if session.LastBattleTime.Unix() > 1 {
-		sessionTo := session.PeriodEnd.Format("Jan 2")
-		sessionFrom := session.PeriodStart.Format("Jan 2")
-		if sessionFrom == sessionTo {
-			footer = append(footer, sessionTo)
-		} else {
-			footer = append(footer, sessionFrom+" - "+sessionTo)
-		}
-	}
-
-	if len(footer) > 0 {
-		segments.AddFooter(common.NewFooterCard(strings.Join(footer, " • ")))
-	}
-
 	return segments, nil
 }
 
@@ -327,34 +329,3 @@ func makeSpecialRatingColumn(block prepare.StatsBlock[session.BlockData], width
 		)
 	}
 }
-
-// func uniqueBlockWN8(stats prepare.StatsBlock[period.BlockData]) common.Block {
-// 	var blocks []common.Block
-
-// 	valueStyle, labelStyle := style.block(stats)
-// 	valueBlock := common.NewTextContent(valueStyle, stats.Value.String())
-
-// 	ratingColors := common.GetWN8Colors(stats.Value.Float())
-// 	if stats.Value.Float() <= 0 {
-// 		ratingColors.Content = common.TextAlt
-// 		ratingColors.Background = common.TextAlt
-// 	}
-
-// 	iconTop := common.AftermathLogo(ratingColors.Background, common.DefaultLogoOptions())
-// 	iconBlockTop := common.NewImageContent(common.Style{Width: float64(iconTop.Bounds().Dx()), Height: float64(iconTop.Bounds().Dy())}, iconTop)
-
-// 	style.blockContainer.Gap = 10
-// 	blocks = append(blocks, common.NewBlocksContent(style.blockContainer, iconBlockTop, valueBlock))
-
-// 	if stats.Value.Float() >= 0 {
-// 		labelStyle.FontColor = ratingColors.Content
-// 		blocks = append(blocks, common.NewBlocksContent(common.Style{
-// 			PaddingY:        5,
-// 			PaddingX:        10,
-// 			BorderRadius:    15,
-// 			BackgroundColor: ratingColors.Background,
-// 		}, common.NewTextContent(labelStyle, common.GetWN8TierName(stats.Value.Float()))))
-// 	}
-
-// 	return common.NewBlocksContent(common.Style{Direction: common.DirectionVertical, AlignItems: common.AlignItemsCenter, Gap: 10, PaddingY: 5}, blocks...)
-// }

From 02d61919c2ece4b6374e72d69344f9a44de67f45 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 16 Jun 2024 13:55:08 -0400
Subject: [PATCH 059/341] removed comment

---
 internal/stats/render/session/cards.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/internal/stats/render/session/cards.go b/internal/stats/render/session/cards.go
index 146d4ae9..a481f897 100644
--- a/internal/stats/render/session/cards.go
+++ b/internal/stats/render/session/cards.go
@@ -101,7 +101,7 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 		}
 	}
 
-	{ // render the footer first to make sure the card is wide enough
+	{
 		var footer []string
 		switch strings.ToLower(session.Realm) {
 		case "na":

From 2171d0fa711a9052a8026d731a646db6d9b3bfc8 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 16 Jun 2024 13:59:01 -0400
Subject: [PATCH 060/341] tweaked the rating card style

---
 internal/stats/render/session/cards.go     | 8 ++++----
 internal/stats/render/session/constants.go | 6 ++++++
 2 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/internal/stats/render/session/cards.go b/internal/stats/render/session/cards.go
index a481f897..9d3138de 100644
--- a/internal/stats/render/session/cards.go
+++ b/internal/stats/render/session/cards.go
@@ -144,10 +144,10 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 
 	// overview cards
 	if len(cards.Unrated.Overview.Blocks) > 0 {
-		primaryColumn = append(primaryColumn, makeOverviewCard(cards.Unrated.Overview, primaryCardBlockSizes, primaryCardWidth))
+		primaryColumn = append(primaryColumn, makeOverviewCard(cards.Unrated.Overview, primaryCardBlockSizes, primaryCardWidth, overviewCardStyle(primaryCardWidth)))
 	}
 	if len(cards.Rating.Overview.Blocks) > 0 {
-		primaryColumn = append(primaryColumn, makeOverviewCard(cards.Rating.Overview, primaryCardBlockSizes, primaryCardWidth))
+		primaryColumn = append(primaryColumn, makeOverviewCard(cards.Rating.Overview, primaryCardBlockSizes, primaryCardWidth, overviewRatingCardStyle(primaryCardWidth)))
 	}
 
 	// highlights
@@ -266,7 +266,7 @@ func makeVehicleLegendCard(reference session.VehicleCard, blockSizes map[string]
 	return common.NewBlocksContent(style, common.NewBlocksContent(vehicleBlocksRowStyle(0), content...))
 }
 
-func makeOverviewCard(card session.OverviewCard, blockSizes map[string]float64, cardWidth float64) common.Block {
+func makeOverviewCard(card session.OverviewCard, blockSizes map[string]float64, cardWidth float64, style common.Style) common.Block {
 	var content []common.Block
 	for _, column := range card.Blocks {
 		var columnContent []common.Block
@@ -285,7 +285,7 @@ func makeOverviewCard(card session.OverviewCard, blockSizes map[string]float64,
 		}
 		content = append(content, common.NewBlocksContent(overviewColumnStyle(0), columnContent...))
 	}
-	return common.NewBlocksContent(overviewCardStyle(cardWidth), content...)
+	return common.NewBlocksContent(style, content...)
 }
 
 func makeSpecialRatingColumn(block prepare.StatsBlock[session.BlockData], width float64) common.Block {
diff --git a/internal/stats/render/session/constants.go b/internal/stats/render/session/constants.go
index 5c550a43..1a61b939 100644
--- a/internal/stats/render/session/constants.go
+++ b/internal/stats/render/session/constants.go
@@ -89,6 +89,12 @@ func overviewCardStyle(width float64) common.Style {
 	return style
 }
 
+func overviewRatingCardStyle(width float64) common.Style {
+	style := overviewCardStyle(width)
+	style.AlignItems = common.AlignItemsCenter
+	return style
+}
+
 func statsBlockStyle(width float64) common.Style {
 	return common.Style{
 		JustifyContent: common.JustifyContentCenter,

From 8f8e82985b44a4be6e28e84f3d13802913b298ef Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 16 Jun 2024 14:01:08 -0400
Subject: [PATCH 061/341] een gaps

---
 internal/stats/render/session/constants.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/internal/stats/render/session/constants.go b/internal/stats/render/session/constants.go
index 1a61b939..ff4e50eb 100644
--- a/internal/stats/render/session/constants.go
+++ b/internal/stats/render/session/constants.go
@@ -42,7 +42,7 @@ var (
 )
 
 func frameStyle() common.Style {
-	return common.Style{Gap: 20, Direction: common.DirectionHorizontal}
+	return common.Style{Gap: 10, Direction: common.DirectionHorizontal}
 }
 
 var (
@@ -69,7 +69,7 @@ func overviewSpecialRatingPillStyle(color color.Color) common.Style {
 
 func overviewColumnStyle(width float64) common.Style {
 	return common.Style{
-		Gap:            5,
+		Gap:            10,
 		Width:          width,
 		AlignItems:     common.AlignItemsCenter,
 		Direction:      common.DirectionVertical,

From 93d1e1b7da899058d39c5463d5c7961f04eeb208 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 16 Jun 2024 14:06:22 -0400
Subject: [PATCH 062/341] sorting vehicles

---
 internal/stats/prepare/session/card.go | 33 +++++++++++++++++++-------
 1 file changed, 25 insertions(+), 8 deletions(-)

diff --git a/internal/stats/prepare/session/card.go b/internal/stats/prepare/session/card.go
index 91d09af0..584d6aa6 100644
--- a/internal/stats/prepare/session/card.go
+++ b/internal/stats/prepare/session/card.go
@@ -1,6 +1,8 @@
 package session
 
 import (
+	"slices"
+
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/stats/fetch"
 	"github.com/cufee/aftermath/internal/stats/frame"
@@ -56,15 +58,22 @@ func NewCards(session, career fetch.AccountStatsOverPeriod, glossary map[string]
 	}
 
 	// Rating battles vehicles
-	for id, data := range session.RatingBattles.Vehicles {
-		glossary := glossary[id]
-		glossary.ID = id
+	var ratingVehicles []frame.VehicleStatsFrame
+	for _, vehicle := range session.RatingBattles.Vehicles {
+		ratingVehicles = append(ratingVehicles, vehicle)
+	}
+	slices.SortFunc(ratingVehicles, func(a, b frame.VehicleStatsFrame) int {
+		return int(b.LastBattleTime.Unix() - a.LastBattleTime.Unix())
+	})
+	for _, data := range ratingVehicles {
+		glossary := glossary[data.VehicleID]
+		glossary.ID = data.VehicleID
 
 		card, err := makeVehicleCard(
 			[]common.Tag{common.TagWN8},
 			common.CardTypeRatingVehicle,
 			data,
-			career.RatingBattles.Vehicles[id],
+			career.RatingBattles.Vehicles[data.VehicleID],
 			options.Printer(),
 			options.Locale(),
 			glossary,
@@ -74,20 +83,28 @@ func NewCards(session, career fetch.AccountStatsOverPeriod, glossary map[string]
 		}
 		cards.Rating.Vehicles = append(cards.Rating.Vehicles, card)
 	}
+
 	// Regular battles vehicles
-	for id, data := range session.RegularBattles.Vehicles {
+	var unratedVehicles []frame.VehicleStatsFrame
+	for _, vehicle := range session.RegularBattles.Vehicles {
+		unratedVehicles = append(unratedVehicles, vehicle)
+	}
+	slices.SortFunc(unratedVehicles, func(a, b frame.VehicleStatsFrame) int {
+		return int(b.LastBattleTime.Unix() - a.LastBattleTime.Unix())
+	})
+	for _, data := range unratedVehicles {
 		if data.Battles < 1 {
 			continue
 		}
 
-		glossary := glossary[id]
-		glossary.ID = id
+		glossary := glossary[data.VehicleID]
+		glossary.ID = data.VehicleID
 
 		card, err := makeVehicleCard(
 			vehicleBlocks,
 			common.CardTypeVehicle,
 			data,
-			career.RegularBattles.Vehicles[id],
+			career.RegularBattles.Vehicles[data.VehicleID],
 			options.Printer(),
 			options.Locale(),
 			glossary,

From 59ea850555de25de1d4e5a500887036a1a8fe882 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 16 Jun 2024 14:07:46 -0400
Subject: [PATCH 063/341] added vehicle limits

---
 internal/stats/prepare/session/card.go | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/internal/stats/prepare/session/card.go b/internal/stats/prepare/session/card.go
index 584d6aa6..9debc390 100644
--- a/internal/stats/prepare/session/card.go
+++ b/internal/stats/prepare/session/card.go
@@ -66,6 +66,10 @@ func NewCards(session, career fetch.AccountStatsOverPeriod, glossary map[string]
 		return int(b.LastBattleTime.Unix() - a.LastBattleTime.Unix())
 	})
 	for _, data := range ratingVehicles {
+		if len(cards.Rating.Vehicles) >= 5 {
+			break
+		}
+
 		glossary := glossary[data.VehicleID]
 		glossary.ID = data.VehicleID
 
@@ -93,6 +97,9 @@ func NewCards(session, career fetch.AccountStatsOverPeriod, glossary map[string]
 		return int(b.LastBattleTime.Unix() - a.LastBattleTime.Unix())
 	})
 	for _, data := range unratedVehicles {
+		if len(cards.Unrated.Vehicles) >= 5 {
+			break
+		}
 		if data.Battles < 1 {
 			continue
 		}

From ff5f362a0f51d4e19570c73dd71f26b0e3a47b19 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 16 Jun 2024 14:16:43 -0400
Subject: [PATCH 064/341] adjusted session lookup, added blank overview card

---
 internal/stats/fetch/multisource.go    | 4 +++-
 internal/stats/prepare/session/card.go | 2 +-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/internal/stats/fetch/multisource.go b/internal/stats/fetch/multisource.go
index ddb62321..8f91295b 100644
--- a/internal/stats/fetch/multisource.go
+++ b/internal/stats/fetch/multisource.go
@@ -280,9 +280,11 @@ func (c *multiSourceClient) SessionStats(ctx context.Context, id string, session
 	}
 
 	sessionBefore := sessionStart
-	if time.Since(sessionStart).Hours() >= 24 {
+	if time.Since(sessionStart).Hours() >= 48 {
 		// 3 days would mean today and yest, so before the reset 2 days ago and so on
 		sessionBefore = sessionBefore.Add(time.Hour * 24 * -1)
+	} else {
+		sessionStart = time.Now()
 	}
 
 	var accountSnapshot retry.DataWithErr[database.AccountSnapshot]
diff --git a/internal/stats/prepare/session/card.go b/internal/stats/prepare/session/card.go
index 9debc390..9eace0ea 100644
--- a/internal/stats/prepare/session/card.go
+++ b/internal/stats/prepare/session/card.go
@@ -42,7 +42,7 @@ func NewCards(session, career fetch.AccountStatsOverPeriod, glossary map[string]
 		cards.Rating.Overview = card
 	}
 	// Regular battles overview
-	if session.RegularBattles.Battles > 0 {
+	if session.RegularBattles.Battles > 0 || session.RatingBattles.Battles == 0 {
 		card, err := makeOverviewCard(
 			unratedOverviewBlocks,
 			session.RegularBattles.StatsFrame,

From bb00947971631c68277af71fa11c026fdb6b9028 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 16 Jun 2024 14:17:33 -0400
Subject: [PATCH 065/341] typo

---
 internal/stats/fetch/multisource.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/internal/stats/fetch/multisource.go b/internal/stats/fetch/multisource.go
index 8f91295b..2f7e144b 100644
--- a/internal/stats/fetch/multisource.go
+++ b/internal/stats/fetch/multisource.go
@@ -284,7 +284,7 @@ func (c *multiSourceClient) SessionStats(ctx context.Context, id string, session
 		// 3 days would mean today and yest, so before the reset 2 days ago and so on
 		sessionBefore = sessionBefore.Add(time.Hour * 24 * -1)
 	} else {
-		sessionStart = time.Now()
+		sessionBefore = time.Now()
 	}
 
 	var accountSnapshot retry.DataWithErr[database.AccountSnapshot]

From a2702e690cc7ad49d049d00b7fa08cdcad05e0ff Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 16 Jun 2024 14:22:17 -0400
Subject: [PATCH 066/341] moved code, removed color from empty pill

---
 internal/stats/fetch/multisource.go     |   2 +-
 internal/stats/render/session/blocks.go | 196 +++++++-----------------
 internal/stats/render/session/cards.go  |  42 -----
 3 files changed, 54 insertions(+), 186 deletions(-)

diff --git a/internal/stats/fetch/multisource.go b/internal/stats/fetch/multisource.go
index 2f7e144b..0da01e5f 100644
--- a/internal/stats/fetch/multisource.go
+++ b/internal/stats/fetch/multisource.go
@@ -270,7 +270,7 @@ func (c *multiSourceClient) SessionStats(ctx context.Context, id string, session
 		apply(&options)
 	}
 
-	// sessions and period stats are tracked differenttly
+	// sessions and period stats are tracked differently
 	// we look up the latest session _before_ sessionBefore, not after sessionStart
 	if sessionStart.IsZero() {
 		sessionStart = time.Now()
diff --git a/internal/stats/render/session/blocks.go b/internal/stats/render/session/blocks.go
index 85ea47e8..1034bbc6 100644
--- a/internal/stats/render/session/blocks.go
+++ b/internal/stats/render/session/blocks.go
@@ -1,145 +1,55 @@
 package session
 
-// type convertOptions struct {
-// 	showSessionStats    bool
-// 	showCareerStats     bool
-// 	showLabels          bool
-// 	showIcons           bool
-// 	highlightBlockIndex int
-// }
-
-// func newVehicleCard(style render.Style, card session.Card, sizes map[int]float64, opts convertOptions) (render.Block, error) {
-// 	if card.Type == dataprep.CardTypeRatingVehicle {
-// 		return slimVehicleCard(style, card, sizes, opts)
-// 	}
-
-// 	return defaultVehicleCard(style, card, sizes, opts)
-// }
-
-// func defaultVehicleCard(style render.Style, card session.Card, sizes map[int]float64, opts convertOptions) (render.Block, error) {
-// 	blocks, err := statsBlocksToCardBlocks(card.Blocks, sizes, opts)
-// 	if err != nil {
-// 		return render.Block{}, err
-// 	}
-
-// 	cardContentBlocks := []render.Block{newCardTitle(card.Title)}
-// 	contentWidth := style.Width - style.PaddingX*2
-
-// 	statsRowBlock := render.NewBlocksContent(statsRowStyle(contentWidth), blocks...)
-// 	cardContentBlocks = append(cardContentBlocks, statsRowBlock)
-
-// 	return render.NewBlocksContent(style, cardContentBlocks...), nil
-// }
-
-// func slimVehicleCard(style render.Style, card session.Card, sizes map[int]float64, opts convertOptions) (render.Block, error) {
-// 	opts.highlightBlockIndex = -1
-// 	opts.showCareerStats = false
-// 	opts.showLabels = false
-// 	opts.showIcons = true
-
-// 	blocks, err := statsBlocksToCardBlocks(card.Blocks, sizes, opts)
-// 	if err != nil {
-// 		return render.Block{}, err
-// 	}
-
-// 	titleBlock := render.NewTextContent(ratingVehicleTitleStyle, card.Title)
-// 	statsRowBlock := render.NewBlocksContent(statsRowStyle(0), blocks...)
-
-// 	containerStyle := style
-// 	containerStyle.Direction = render.DirectionHorizontal
-// 	containerStyle.JustifyContent = render.JustifyContentSpaceBetween
-
-// 	return render.NewBlocksContent(containerStyle, titleBlock, statsRowBlock), nil
-// }
-
-// func statsBlocksToCardBlocks(stats []session.StatsBlock, blockWidth map[int]float64, opts ...convertOptions) ([]render.Block, error) {
-// 	var options convertOptions = convertOptions{
-// 		showSessionStats:    true,
-// 		showCareerStats:     true,
-// 		showLabels:          true,
-// 		showIcons:           true,
-// 		highlightBlockIndex: 0,
-// 	}
-// 	if len(opts) > 0 {
-// 		options = opts[0]
-// 	}
-
-// 	var content []render.Block
-// 	for index, statsBlock := range stats {
-// 		blocks := make([]render.Block, 0, 3)
-// 		if options.showSessionStats {
-// 			if options.showIcons && statsBlock.Tag != dataprep.TagBattles {
-// 				blocks = append(blocks, newStatsBlockRow(defaultBlockStyle.session, statsBlock.Session.String, comparisonIconFromBlock(statsBlock)))
-// 			} else {
-// 				blocks = append(blocks, render.NewTextContent(defaultBlockStyle.session, statsBlock.Session.String))
-// 			}
-// 		}
-// 		if options.showCareerStats && statsBlock.Career.String != "" {
-// 			if options.showIcons && statsBlock.Tag != dataprep.TagBattles {
-// 				blocks = append(blocks, newStatsBlockRow(defaultBlockStyle.career, statsBlock.Career.String, blockToWN8Icon(statsBlock.Career, statsBlock.Tag)))
-// 			} else {
-// 				blocks = append(blocks, render.NewTextContent(defaultBlockStyle.career, statsBlock.Career.String))
-// 			}
-// 		}
-// 		if options.showLabels && statsBlock.Tag != dataprep.TagBattles {
-// 			if options.showIcons {
-// 				blocks = append(blocks, newStatsBlockRow(defaultBlockStyle.label, statsBlock.Label, blankIconBlock))
-// 			} else {
-// 				blocks = append(blocks, render.NewTextContent(defaultBlockStyle.label, statsBlock.Label))
-// 			}
-// 		}
-
-// 		containerStyle := defaultStatsBlockStyle(blockWidth[index])
-// 		if index == options.highlightBlockIndex {
-// 			containerStyle = highlightStatsBlockStyle(blockWidth[index])
-// 		}
-// 		content = append(content, render.NewBlocksContent(containerStyle, blocks...))
-// 	}
-// 	return content, nil
-// }
-
-// func newStatsBlockRow(style render.Style, value string, icon render.Block) render.Block {
-// 	return render.NewBlocksContent(
-// 		render.Style{Direction: render.DirectionHorizontal, AlignItems: render.AlignItemsCenter},
-// 		icon,
-// 		render.NewTextContent(style, value),
-// 	)
-// }
-
-// func newCardTitle(label string) render.Block {
-// 	return render.NewTextContent(defaultBlockStyle.career, label)
-// }
-
-// func comparisonIconFromBlock(block session.StatsBlock) render.Block {
-// 	if !stats.ValueValid(block.Session.Value) || !stats.ValueValid(block.Career.Value) {
-// 		return blankIconBlock
-// 	}
-
-// 	if block.Tag == dataprep.TagWN8 {
-// 		// WN8 icons need to show the color
-// 		return blockToWN8Icon(block.Session, block.Tag)
-// 	}
-
-// 	var icon image.Image
-// 	var iconColor color.Color
-// 	if block.Session.Value > block.Career.Value {
-// 		icon, _ = assets.GetImage("images/icons/chevron-up-single")
-// 		iconColor = color.RGBA{R: 0, G: 255, B: 0, A: 255}
-// 	}
-// 	if block.Session.Value < block.Career.Value {
-// 		icon, _ = assets.GetImage("images/icons/chevron-down-single")
-// 		iconColor = color.RGBA{R: 255, G: 0, B: 0, A: 255}
-// 	}
-// 	if icon == nil {
-// 		return blankIconBlock
-// 	}
-
-// 	return render.NewImageContent(render.Style{Width: float64(iconSize), Height: float64(iconSize), BackgroundColor: iconColor}, icon)
-// }
-
-// func blockToWN8Icon(value dataprep.Value, tag dataprep.Tag) render.Block {
-// 	if tag != dataprep.TagWN8 || !stats.ValueValid(value.Value) {
-// 		return blankIconBlock
-// 	}
-// 	return render.NewImageContent(render.Style{Width: float64(iconSize), Height: float64(iconSize), BackgroundColor: shared.GetWN8Colors(int(value.Value)).Background}, wn8Icon)
-// }
+import (
+	"image/color"
+
+	prepare "github.com/cufee/aftermath/internal/stats/prepare/common"
+	"github.com/cufee/aftermath/internal/stats/prepare/session"
+	"github.com/cufee/aftermath/internal/stats/render/common"
+)
+
+func makeSpecialRatingColumn(block prepare.StatsBlock[session.BlockData], width float64) common.Block {
+	switch block.Tag {
+	case prepare.TagWN8:
+		ratingColors := common.GetWN8Colors(block.Value.Float())
+		if block.Value.Float() <= 0 {
+			ratingColors.Content = common.TextAlt
+			ratingColors.Background = common.TextAlt
+		}
+
+		var column []common.Block
+		iconTop := common.AftermathLogo(ratingColors.Background, common.DefaultLogoOptions())
+		column = append(column, common.NewImageContent(common.Style{Width: specialRatingIconSize, Height: specialRatingIconSize}, iconTop))
+
+		pillColor := ratingColors.Background
+		if block.Value.Float() < 0 {
+			pillColor = color.Transparent
+		}
+		column = append(column, common.NewBlocksContent(overviewColumnStyle(width),
+			common.NewTextContent(vehicleBlockStyle.session, block.Data.Session.String()),
+			common.NewBlocksContent(
+				overviewSpecialRatingPillStyle(pillColor),
+				common.NewTextContent(overviewSpecialRatingLabelStyle(ratingColors.Content), common.GetWN8TierName(block.Value.Float())),
+			),
+		))
+		return common.NewBlocksContent(specialRatingColumnStyle, column...)
+
+	case prepare.TagRankedRating:
+		var column []common.Block
+		icon, ok := getRatingIcon(block.Value)
+		if ok {
+			column = append(column, icon)
+		}
+		column = append(column, common.NewBlocksContent(overviewColumnStyle(width),
+			common.NewTextContent(vehicleBlockStyle.session, block.Data.Session.String()),
+		))
+		return common.NewBlocksContent(specialRatingColumnStyle, column...)
+
+	default:
+		return common.NewBlocksContent(statsBlockStyle(width),
+			common.NewTextContent(vehicleBlockStyle.session, block.Data.Session.String()),
+			// common.NewTextContent(vehicleBlockStyle.career, block.Data.Career.String()),
+			common.NewTextContent(vehicleBlockStyle.label, block.Label),
+		)
+	}
+}
diff --git a/internal/stats/render/session/cards.go b/internal/stats/render/session/cards.go
index 9d3138de..2f2ac043 100644
--- a/internal/stats/render/session/cards.go
+++ b/internal/stats/render/session/cards.go
@@ -287,45 +287,3 @@ func makeOverviewCard(card session.OverviewCard, blockSizes map[string]float64,
 	}
 	return common.NewBlocksContent(style, content...)
 }
-
-func makeSpecialRatingColumn(block prepare.StatsBlock[session.BlockData], width float64) common.Block {
-	switch block.Tag {
-	case prepare.TagWN8:
-		ratingColors := common.GetWN8Colors(block.Value.Float())
-		if block.Value.Float() <= 0 {
-			ratingColors.Content = common.TextAlt
-			ratingColors.Background = common.TextAlt
-		}
-
-		var column []common.Block
-		iconTop := common.AftermathLogo(ratingColors.Background, common.DefaultLogoOptions())
-		column = append(column, common.NewImageContent(common.Style{Width: specialRatingIconSize, Height: specialRatingIconSize}, iconTop))
-
-		column = append(column, common.NewBlocksContent(overviewColumnStyle(width),
-			common.NewTextContent(vehicleBlockStyle.session, block.Data.Session.String()),
-			common.NewBlocksContent(
-				overviewSpecialRatingPillStyle(ratingColors.Background),
-				common.NewTextContent(overviewSpecialRatingLabelStyle(ratingColors.Content), common.GetWN8TierName(block.Value.Float())),
-			),
-		))
-		return common.NewBlocksContent(specialRatingColumnStyle, column...)
-
-	case prepare.TagRankedRating:
-		var column []common.Block
-		icon, ok := getRatingIcon(block.Value)
-		if ok {
-			column = append(column, icon)
-		}
-		column = append(column, common.NewBlocksContent(overviewColumnStyle(width),
-			common.NewTextContent(vehicleBlockStyle.session, block.Data.Session.String()),
-		))
-		return common.NewBlocksContent(specialRatingColumnStyle, column...)
-
-	default:
-		return common.NewBlocksContent(statsBlockStyle(width),
-			common.NewTextContent(vehicleBlockStyle.session, block.Data.Session.String()),
-			// common.NewTextContent(vehicleBlockStyle.career, block.Data.Career.String()),
-			common.NewTextContent(vehicleBlockStyle.label, block.Label),
-		)
-	}
-}

From eed1923e6d7885439516f19075d464f1ce2f4343 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Mon, 17 Jun 2024 13:06:15 -0400
Subject: [PATCH 067/341] added secondary WN8 icon

---
 internal/stats/render/common/logo.go       | 10 +++
 internal/stats/render/session/blocks.go    | 11 +++
 internal/stats/render/session/cards.go     | 91 +++++++++++++---------
 internal/stats/render/session/constants.go | 35 +++------
 4 files changed, 88 insertions(+), 59 deletions(-)

diff --git a/internal/stats/render/common/logo.go b/internal/stats/render/common/logo.go
index 07713e31..8de5033e 100644
--- a/internal/stats/render/common/logo.go
+++ b/internal/stats/render/common/logo.go
@@ -33,6 +33,16 @@ func DefaultLogoOptions() LogoSizingOptions {
 	}
 }
 
+func SmallLogoOptions() LogoSizingOptions {
+	return LogoSizingOptions{
+		Gap:       2,
+		Jump:      6,
+		Lines:     5,
+		LineStep:  8,
+		LineWidth: 6,
+	}
+}
+
 func AftermathLogo(fillColor color.Color, opts LogoSizingOptions) image.Image {
 	ctx := gg.NewContext(opts.Width(), opts.Height())
 	for line := range opts.Lines {
diff --git a/internal/stats/render/session/blocks.go b/internal/stats/render/session/blocks.go
index 1034bbc6..cc360907 100644
--- a/internal/stats/render/session/blocks.go
+++ b/internal/stats/render/session/blocks.go
@@ -3,6 +3,7 @@ package session
 import (
 	"image/color"
 
+	"github.com/cufee/aftermath/internal/stats/frame"
 	prepare "github.com/cufee/aftermath/internal/stats/prepare/common"
 	"github.com/cufee/aftermath/internal/stats/prepare/session"
 	"github.com/cufee/aftermath/internal/stats/render/common"
@@ -53,3 +54,13 @@ func makeSpecialRatingColumn(block prepare.StatsBlock[session.BlockData], width
 		)
 	}
 }
+
+func vehicleWN8Icon(wn8 frame.Value) common.Block {
+	ratingColors := common.GetWN8Colors(wn8.Float())
+	if wn8.Float() <= 0 {
+		ratingColors.Content = common.TextAlt
+		ratingColors.Background = common.TextAlt
+	}
+	iconTop := common.AftermathLogo(ratingColors.Background, common.SmallLogoOptions())
+	return common.NewImageContent(common.Style{Width: vehicleWN8IconSize, Height: vehicleWN8IconSize}, iconTop)
+}
diff --git a/internal/stats/render/session/cards.go b/internal/stats/render/session/cards.go
index 2f2ac043..d5949d10 100644
--- a/internal/stats/render/session/cards.go
+++ b/internal/stats/render/session/cards.go
@@ -1,10 +1,12 @@
 package session
 
 import (
+	"fmt"
 	"strings"
 
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/stats/fetch"
+	"github.com/cufee/aftermath/internal/stats/frame"
 	prepare "github.com/cufee/aftermath/internal/stats/prepare/common"
 	"github.com/cufee/aftermath/internal/stats/prepare/session"
 	"github.com/cufee/aftermath/internal/stats/render/common"
@@ -13,6 +15,16 @@ import (
 )
 
 func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Cards, subs []database.UserSubscription, opts render.Options) (render.Segments, error) {
+	var (
+		// primary card
+		shouldRenderUnratedOverview   = session.RegularBattles.Battles > 0 || session.RatingBattles.Battles == 0
+		shouldRenderUnratedHighlights = len(session.RegularBattles.Vehicles) > 3
+		shouldRenderRatingOverview    = session.RatingBattles.Battles > 0
+		shouldRenderRatingVehicles    = len(cards.Unrated.Vehicles) == 0
+		// secondary card
+		shouldRenderUnratedVehicles = len(cards.Unrated.Vehicles) > 0
+	)
+
 	var segments render.Segments
 	var primaryColumn []common.Block
 	var secondaryColumn []common.Block
@@ -20,7 +32,8 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 	// Calculate minimal card width to fit all the content
 	primaryCardBlockSizes := make(map[string]float64)
 	secondaryCardBlockSizes := make(map[string]float64)
-	var primaryCardWidth, secondaryCardWidth, totalFrameWidth float64
+	var primaryCardWidth float64 = minPrimaryCardWidth
+	var secondaryCardWidth, totalFrameWidth float64
 	// rating and unrated battles > 0	 	   unrated battles > 0		   rating battles > 0
 	// [title card		] | [vehicle]    [title card	  ] | [vehicle]    [title card	  	]
 	// [overview unrated] | [vehicle] OR [overview unrated] | [vehicle] OR [overview rating ]
@@ -39,8 +52,7 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 		}
 	}
 
-	// unrated overview - show if there are no rating battles (so the card is not empty), or there are battles
-	if session.RegularBattles.Battles > 0 || session.RatingBattles.Battles == 0 {
+	if shouldRenderUnratedOverview {
 		for _, column := range cards.Unrated.Overview.Blocks {
 			presetBlockWidth, _ := overviewColumnBlocksWidth(column, overviewStatsBlockStyle.session, overviewStatsBlockStyle.career, overviewStatsBlockStyle.label, overviewColumnStyle(0))
 			for key, width := range presetBlockWidth {
@@ -48,12 +60,17 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 			}
 		}
 	}
-	// rating overview
-	if session.RatingBattles.Battles > 0 {
-		//
+
+	if shouldRenderRatingOverview {
+		for _, column := range cards.Unrated.Overview.Blocks {
+			presetBlockWidth, _ := overviewColumnBlocksWidth(column, overviewStatsBlockStyle.session, overviewStatsBlockStyle.career, overviewStatsBlockStyle.label, overviewColumnStyle(0))
+			for key, width := range presetBlockWidth {
+				primaryCardBlockSizes[key] = common.Max(primaryCardBlockSizes[key], width)
+			}
+		}
 	}
 	// rating vehicle cards go on the primary block - only show if there are no unrated battles/vehicles
-	if len(cards.Unrated.Vehicles) == 0 {
+	if shouldRenderRatingVehicles {
 		for _, card := range cards.Rating.Vehicles {
 			// [title] [session]
 			titleSize := common.MeasureString(card.Title, *ratingVehicleCardTitleStyle.Font)
@@ -68,12 +85,12 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 		}
 	}
 	// highlighted vehicles go on the primary block
-	if len(cards.Unrated.Highlights) > len(cards.Unrated.Vehicles) {
+	if shouldRenderUnratedHighlights {
 		for _, card := range cards.Unrated.Highlights {
 			// [card label] [session]
 			// [title]  	  [label]
-			labelSize := common.MeasureString(card.Meta, *vehicleCardTitleStyle.Font)
-			titleSize := common.MeasureString(card.Title, *vehicleCardTitleStyle.Font)
+			labelSize := common.MeasureString(card.Meta, *vehicleCardTitleTextStyle.Font)
+			titleSize := common.MeasureString(card.Title, *vehicleCardTitleTextStyle.Font)
 			presetBlockWidth, contentWidth := vehicleBlocksWidth(card.Blocks, vehicleBlockStyle.session, vehicleBlockStyle.career, vehicleBlockStyle.label, vehicleBlocksRowStyle(0))
 			// add the gap and card padding, the gap here accounts for title/label being inline with content
 			contentWidth += vehicleBlocksRowStyle(0).Gap*float64(len(card.Blocks)) + highlightCardStyle(0).PaddingX*2 + common.Max(titleSize.TotalWidth, labelSize.TotalWidth)
@@ -84,7 +101,7 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 			}
 		}
 	}
-	{ // unrated vehicles go on the secondary block
+	if shouldRenderUnratedVehicles { // unrated vehicles go on the secondary block
 		for _, card := range cards.Unrated.Vehicles {
 			// 		[ label ]
 			// [session]
@@ -92,7 +109,7 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 			presetBlockWidth, contentWidth := vehicleBlocksWidth(card.Blocks, vehicleBlockStyle.session, vehicleBlockStyle.career, vehicleBlockStyle.label, vehicleBlocksRowStyle(0))
 			contentWidth += vehicleBlocksRowStyle(0).Gap*float64(len(card.Blocks)-1) + vehicleCardStyle(0).PaddingX*2
 
-			titleSize := common.MeasureString(card.Title, *vehicleCardTitleStyle.Font)
+			titleSize := common.MeasureString(card.Title, *vehicleCardTitleTextStyle.Font)
 			secondaryCardWidth = common.Max(secondaryCardWidth, contentWidth, titleSize.TotalWidth+vehicleCardStyle(0).PaddingX*2)
 
 			for key, width := range presetBlockWidth {
@@ -143,27 +160,29 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 	)
 
 	// overview cards
-	if len(cards.Unrated.Overview.Blocks) > 0 {
+	if shouldRenderUnratedOverview {
 		primaryColumn = append(primaryColumn, makeOverviewCard(cards.Unrated.Overview, primaryCardBlockSizes, primaryCardWidth, overviewCardStyle(primaryCardWidth)))
 	}
-	if len(cards.Rating.Overview.Blocks) > 0 {
+	if shouldRenderRatingOverview {
 		primaryColumn = append(primaryColumn, makeOverviewCard(cards.Rating.Overview, primaryCardBlockSizes, primaryCardWidth, overviewRatingCardStyle(primaryCardWidth)))
 	}
 
 	// highlights
-	if len(cards.Unrated.Highlights) > len(cards.Unrated.Vehicles) {
+	if shouldRenderUnratedHighlights {
 		//
 	}
 	// rating vehicle cards
-	if len(cards.Unrated.Vehicles) == 0 {
+	if shouldRenderRatingVehicles {
 		//
 	}
 
 	// unrated vehicles
-	for i, vehicle := range cards.Unrated.Vehicles {
-		secondaryColumn = append(secondaryColumn, makeVehicleCard(vehicle, secondaryCardBlockSizes, secondaryCardWidth))
-		if i == len(cards.Unrated.Vehicles)-1 {
-			secondaryColumn = append(secondaryColumn, makeVehicleLegendCard(cards.Unrated.Vehicles[0], secondaryCardBlockSizes, secondaryCardWidth))
+	if shouldRenderUnratedVehicles {
+		for i, vehicle := range cards.Unrated.Vehicles {
+			secondaryColumn = append(secondaryColumn, makeVehicleCard(vehicle, secondaryCardBlockSizes, secondaryCardWidth))
+			if i == len(cards.Unrated.Vehicles)-1 {
+				secondaryColumn = append(secondaryColumn, makeVehicleLegendCard(cards.Unrated.Vehicles[0], secondaryCardBlockSizes, secondaryCardWidth))
+			}
 		}
 	}
 
@@ -178,7 +197,8 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 
 func vehicleBlocksWidth(blocks []prepare.StatsBlock[session.BlockData], sessionStyle, careerStyle, labelStyle, containerStyle common.Style) (map[string]float64, float64) {
 	presetBlockWidth := make(map[string]float64)
-	var contentWidth, maxBlockWidth float64
+	var contentWidth float64
+	var maxBlockWidth float64
 	for _, block := range blocks {
 		var width float64
 		{
@@ -191,11 +211,10 @@ func vehicleBlocksWidth(blocks []prepare.StatsBlock[session.BlockData], sessionS
 		}
 		{
 			size := common.MeasureString(block.Label, *labelStyle.Font)
-			width = common.Max(width, size.TotalWidth+labelStyle.PaddingX*2)
+			width = common.Max(width, size.TotalWidth+labelStyle.PaddingX*2+vehicleLegendLabelContainer.PaddingX*2)
 		}
-		w := width + float64(iconSize)
-		maxBlockWidth = common.Max(maxBlockWidth, w)
-		presetBlockWidth[block.Tag.String()] = common.Max(presetBlockWidth[block.Tag.String()], w) // add space for comparison icons
+		maxBlockWidth = common.Max(maxBlockWidth, width)
+		presetBlockWidth[block.Tag.String()] = common.Max(presetBlockWidth[block.Tag.String()], width) // add space for comparison icons
 	}
 
 	if containerStyle.Direction == common.DirectionHorizontal {
@@ -223,6 +242,7 @@ func overviewColumnBlocksWidth(blocks []prepare.StatsBlock[session.BlockData], s
 }
 
 func makeVehicleCard(vehicle session.VehicleCard, blockSizes map[string]float64, cardWidth float64) common.Block {
+	var vehicleWN8 frame.Value = frame.InvalidValue
 	var content []common.Block
 	for _, block := range vehicle.Blocks {
 		var blockContent []common.Block
@@ -230,15 +250,20 @@ func makeVehicleCard(vehicle session.VehicleCard, blockSizes map[string]float64,
 		if block.Data.Career.Float() > 0 {
 			blockContent = append(blockContent, common.NewTextContent(vehicleBlockStyle.career, block.Data.Career.String()))
 		}
-
 		content = append(content,
 			common.NewBlocksContent(statsBlockStyle(blockSizes[block.Tag.String()]), blockContent...),
 		)
+		if block.Tag == prepare.TagWN8 {
+			vehicleWN8 = block.Value
+		}
 	}
+
+	titleStyle := vehicleCardTitleContainerStyle(cardWidth)
+	titleStyle.Width -= vehicleCardStyle(0).PaddingX * 2
 	return common.NewBlocksContent(vehicleCardStyle(cardWidth),
-		common.NewBlocksContent(vehicleCardTitleContainerStyle(cardWidth),
-			common.NewTextContent(vehicleCardTitleStyle, vehicle.Title), // vehicle name
-			common.NewTextContent(vehicleCardTitleStyle, vehicle.Meta),  // tier
+		common.NewBlocksContent(titleStyle,
+			common.NewTextContent(vehicleCardTitleTextStyle, fmt.Sprintf("%s %s", vehicle.Meta, vehicle.Title)), // name and tier
+			vehicleWN8Icon(vehicleWN8),
 		),
 		common.NewBlocksContent(vehicleBlocksRowStyle(0), content...),
 	)
@@ -247,15 +272,9 @@ func makeVehicleCard(vehicle session.VehicleCard, blockSizes map[string]float64,
 func makeVehicleLegendCard(reference session.VehicleCard, blockSizes map[string]float64, cardWidth float64) common.Block {
 	var content []common.Block
 	for _, block := range reference.Blocks {
-		labelContainer := common.Style{
-			BackgroundColor: common.DefaultCardColor,
-			BorderRadius:    common.BorderRadiusSM,
-			PaddingY:        5,
-			PaddingX:        10,
-		}
 		content = append(content,
 			common.NewBlocksContent(statsBlockStyle(blockSizes[block.Tag.String()]),
-				common.NewBlocksContent(labelContainer, common.NewTextContent(vehicleBlockStyle.label, block.Label)),
+				common.NewBlocksContent(vehicleLegendLabelContainer, common.NewTextContent(vehicleBlockStyle.label, block.Label)),
 			),
 		)
 	}
diff --git a/internal/stats/render/session/constants.go b/internal/stats/render/session/constants.go
index ff4e50eb..375d88f3 100644
--- a/internal/stats/render/session/constants.go
+++ b/internal/stats/render/session/constants.go
@@ -1,11 +1,9 @@
 package session
 
 import (
-	"image"
 	"image/color"
 
 	"github.com/cufee/aftermath/internal/stats/render/common"
-	"github.com/fogleman/gg"
 )
 
 type blockStyle struct {
@@ -14,26 +12,10 @@ type blockStyle struct {
 	label   common.Style
 }
 
-func init() {
-	{
-		ctx := gg.NewContext(iconSize, iconSize)
-		ctx.DrawRoundedRectangle(13, 2.5, 6, 17.5, 3)
-		ctx.SetColor(color.RGBA{R: 255, G: 255, B: 255, A: 255})
-		ctx.Fill()
-		wn8Icon = ctx.Image()
-	}
-
-	{
-		ctx := gg.NewContext(iconSize, 1)
-		blankIconBlock = common.NewImageContent(common.Style{Width: float64(iconSize), Height: 1}, ctx.Image())
-	}
-}
-
 var (
-	iconSize              = 25
+	vehicleWN8IconSize    = 20.0
 	specialRatingIconSize = 60.0
-	wn8Icon               image.Image
-	blankIconBlock        common.Block
+	minPrimaryCardWidth   = 300.0 // making the primary card too small looks bad if there are no battles in a session
 )
 
 var (
@@ -105,8 +87,14 @@ func statsBlockStyle(width float64) common.Style {
 }
 
 var (
-	vehicleCardTitleStyle = common.Style{Font: &common.FontMedium, FontColor: common.TextAlt, PaddingX: 5}
-	vehicleBlockStyle     = blockStyle{
+	vehicleLegendLabelContainer = common.Style{
+		BackgroundColor: common.DefaultCardColor,
+		BorderRadius:    common.BorderRadiusSM,
+		PaddingY:        5,
+		PaddingX:        10,
+	}
+	vehicleCardTitleTextStyle = common.Style{Font: &common.FontMedium, FontColor: common.TextAlt}
+	vehicleBlockStyle         = blockStyle{
 		common.Style{Font: &common.FontLarge, FontColor: common.TextPrimary},
 		common.Style{Font: &common.FontMedium, FontColor: common.TextSecondary},
 		common.Style{Font: &common.FontSmall, FontColor: common.TextAlt},
@@ -117,7 +105,6 @@ func vehicleCardTitleContainerStyle(width float64) common.Style {
 	return common.Style{
 		JustifyContent: common.JustifyContentSpaceBetween,
 		Direction:      common.DirectionHorizontal,
-		PaddingX:       defaultCardStyle(0).PaddingX * 2,
 		Width:          width,
 		Gap:            10,
 	}
@@ -125,6 +112,7 @@ func vehicleCardTitleContainerStyle(width float64) common.Style {
 
 func vehicleCardStyle(width float64) common.Style {
 	style := defaultCardStyle(width)
+	style.PaddingX, style.PaddingY = 20, 15
 	style.Gap = 5
 	return style
 }
@@ -135,6 +123,7 @@ func vehicleBlocksRowStyle(width float64) common.Style {
 		Direction:      common.DirectionHorizontal,
 		AlignItems:     common.AlignItemsCenter,
 		Width:          width,
+		Gap:            10,
 	}
 }
 

From 7e84327353e57f8c3bab1b06f11e5526e7e443a3 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Mon, 17 Jun 2024 13:15:29 -0400
Subject: [PATCH 068/341] more consistent session time calc

---
 internal/stats/fetch/multisource.go | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/internal/stats/fetch/multisource.go b/internal/stats/fetch/multisource.go
index 0da01e5f..a43c82d5 100644
--- a/internal/stats/fetch/multisource.go
+++ b/internal/stats/fetch/multisource.go
@@ -279,12 +279,10 @@ func (c *multiSourceClient) SessionStats(ctx context.Context, id string, session
 		return AccountStatsOverPeriod{}, AccountStatsOverPeriod{}, ErrInvalidSessionStart
 	}
 
-	sessionBefore := sessionStart
-	if time.Since(sessionStart).Hours() >= 48 {
+	sessionBefore := time.Now()
+	if time.Since(sessionStart).Hours() >= 24 {
 		// 3 days would mean today and yest, so before the reset 2 days ago and so on
-		sessionBefore = sessionBefore.Add(time.Hour * 24 * -1)
-	} else {
-		sessionBefore = time.Now()
+		sessionBefore = sessionStart.Add(time.Hour * 24 * -1)
 	}
 
 	var accountSnapshot retry.DataWithErr[database.AccountSnapshot]

From 1c9f189480856c5e8fd7736f687a782a0043df28 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Mon, 17 Jun 2024 13:17:02 -0400
Subject: [PATCH 069/341] cleaned up logic

---
 internal/stats/fetch/multisource.go | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/internal/stats/fetch/multisource.go b/internal/stats/fetch/multisource.go
index a43c82d5..d40f2d6e 100644
--- a/internal/stats/fetch/multisource.go
+++ b/internal/stats/fetch/multisource.go
@@ -270,16 +270,13 @@ func (c *multiSourceClient) SessionStats(ctx context.Context, id string, session
 		apply(&options)
 	}
 
-	// sessions and period stats are tracked differently
-	// we look up the latest session _before_ sessionBefore, not after sessionStart
-	if sessionStart.IsZero() {
-		sessionStart = time.Now()
-	}
-	if days := time.Since(sessionStart).Hours() / 24; days > 90 {
+	if days := time.Since(sessionStart).Hours() / 24; sessionStart.IsZero() || days > 90 {
 		return AccountStatsOverPeriod{}, AccountStatsOverPeriod{}, ErrInvalidSessionStart
 	}
 
-	sessionBefore := time.Now()
+	// sessions and period stats are tracked differently
+	// we look up the latest session _before_ sessionBefore, not after sessionStart
+	sessionBefore := time.Now() // current session
 	if time.Since(sessionStart).Hours() >= 24 {
 		// 3 days would mean today and yest, so before the reset 2 days ago and so on
 		sessionBefore = sessionStart.Add(time.Hour * 24 * -1)

From 9e30aaa32f23d5839ab111fb93844cca0f6a5941 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Mon, 17 Jun 2024 13:23:50 -0400
Subject: [PATCH 070/341] calculating session time only on 2+ days

---
 internal/stats/fetch/multisource.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/internal/stats/fetch/multisource.go b/internal/stats/fetch/multisource.go
index d40f2d6e..5868e23f 100644
--- a/internal/stats/fetch/multisource.go
+++ b/internal/stats/fetch/multisource.go
@@ -277,7 +277,7 @@ func (c *multiSourceClient) SessionStats(ctx context.Context, id string, session
 	// sessions and period stats are tracked differently
 	// we look up the latest session _before_ sessionBefore, not after sessionStart
 	sessionBefore := time.Now() // current session
-	if time.Since(sessionStart).Hours() >= 24 {
+	if time.Since(sessionStart).Hours() >= 48 {
 		// 3 days would mean today and yest, so before the reset 2 days ago and so on
 		sessionBefore = sessionStart.Add(time.Hour * 24 * -1)
 	}

From b125dc01fc921283a584d36ef282757fe6ca8b27 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Mon, 17 Jun 2024 13:27:11 -0400
Subject: [PATCH 071/341] removed discord retry

---
 cmds/discord/rest/client.go | 56 ++++++++++++++++---------------------
 1 file changed, 24 insertions(+), 32 deletions(-)

diff --git a/cmds/discord/rest/client.go b/cmds/discord/rest/client.go
index 2802913c..730af69c 100644
--- a/cmds/discord/rest/client.go
+++ b/cmds/discord/rest/client.go
@@ -14,7 +14,6 @@ import (
 	"github.com/rs/zerolog/log"
 
 	"github.com/bwmarrin/discordgo"
-	"github.com/cufee/aftermath/internal/retry"
 )
 
 type Client struct {
@@ -112,44 +111,37 @@ func partHeader(contentDisposition string, contentType string) textproto.MIMEHea
 
 func (c *Client) do(req *http.Request, target any) error {
 	log.Debug().Str("url", req.URL.String()).Str("contentType", req.Header.Get("Content-Type")).Msg("sending a request to Discord API")
-	result := retry.Retry(func() (any, error) {
-		res, err := c.http.Do(req)
+
+	res, err := c.http.Do(req)
+	if err != nil {
+		return err
+	}
+	defer res.Body.Close()
+
+	if res.StatusCode > 299 {
+		var body discordgo.APIErrorMessage
+		data, err := io.ReadAll(res.Body)
 		if err != nil {
-			return nil, err
-		}
-		defer res.Body.Close()
-
-		if res.StatusCode > 299 {
-			var body discordgo.APIErrorMessage
-			data, err := io.ReadAll(res.Body)
-			if err != nil {
-				return nil, fmt.Errorf("failed to read body: %w", err)
-			}
-
-			_ = json.Unmarshal(data, &body)
-			message := body.Message
-			if message == "" {
-				message = res.Status + ", response was not valid json"
-			}
-			println(string(data))
-
-			return nil, errors.New("discord error: " + message)
+			return fmt.Errorf("failed to read body: %w", err)
 		}
 
-		if target != nil {
-			err = json.NewDecoder(res.Body).Decode(target)
-			if err != nil {
-				return nil, fmt.Errorf("failed to decode response body :%w", err)
-			}
+		_ = json.Unmarshal(data, &body)
+		message := body.Message
+		if message == "" {
+			message = res.Status + ", response was not valid json"
 		}
+		println(string(data))
 
-		return nil, nil
-	}, 3, time.Millisecond*150)
+		return errors.New("discord error: " + message)
+	}
 
-	if result.Err != nil {
-		log.Debug().Err(result.Err).Str("url", req.URL.String()).Str("contentType", req.Header.Get("Content-Type")).Msg("request finished with error")
-		return result.Err
+	if target != nil {
+		err = json.NewDecoder(res.Body).Decode(target)
+		if err != nil {
+			return fmt.Errorf("failed to decode response body :%w", err)
+		}
 	}
+
 	log.Debug().Str("url", req.URL.String()).Str("contentType", req.Header.Get("Content-Type")).Msg("request finished successfully")
 	return nil
 }

From 5d59df212a2e40aebfab50d13c5f73a5c983988b Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Mon, 17 Jun 2024 13:29:10 -0400
Subject: [PATCH 072/341] handling 0 time correctly

---
 internal/stats/session.go | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/internal/stats/session.go b/internal/stats/session.go
index bedbd34d..aa079f46 100644
--- a/internal/stats/session.go
+++ b/internal/stats/session.go
@@ -49,6 +49,9 @@ func (r *renderer) Session(ctx context.Context, accountId string, from time.Time
 	}
 
 	stop = meta.Timer("fetchClient#SessionStats")
+	if from.IsZero() {
+		from = time.Now()
+	}
 	session, career, err := r.fetchClient.SessionStats(ctx, accountId, from, fetch.WithWN8())
 	stop()
 	if err != nil {

From f6ec227fed5d29b77d6f7bbc0bc3178e8a4d6659 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Mon, 17 Jun 2024 16:05:21 -0400
Subject: [PATCH 073/341] adjusted session start time again

---
 internal/stats/fetch/multisource.go | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/internal/stats/fetch/multisource.go b/internal/stats/fetch/multisource.go
index 5868e23f..d82c9328 100644
--- a/internal/stats/fetch/multisource.go
+++ b/internal/stats/fetch/multisource.go
@@ -274,12 +274,10 @@ func (c *multiSourceClient) SessionStats(ctx context.Context, id string, session
 		return AccountStatsOverPeriod{}, AccountStatsOverPeriod{}, ErrInvalidSessionStart
 	}
 
-	// sessions and period stats are tracked differently
-	// we look up the latest session _before_ sessionBefore, not after sessionStart
-	sessionBefore := time.Now() // current session
-	if time.Since(sessionStart).Hours() >= 48 {
-		// 3 days would mean today and yest, so before the reset 2 days ago and so on
-		sessionBefore = sessionStart.Add(time.Hour * 24 * -1)
+	// 1 day should be the same as today
+	sessionBefore := time.Now()
+	if time.Since(sessionStart).Hours() >= 24 {
+		sessionBefore = sessionStart
 	}
 
 	var accountSnapshot retry.DataWithErr[database.AccountSnapshot]

From 35c778e1195549a13b35d0f378bc1fb9b52bc01c Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Mon, 17 Jun 2024 16:05:59 -0400
Subject: [PATCH 074/341] simplified session times even further

---
 internal/stats/fetch/multisource.go | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/internal/stats/fetch/multisource.go b/internal/stats/fetch/multisource.go
index d82c9328..1f1a50c9 100644
--- a/internal/stats/fetch/multisource.go
+++ b/internal/stats/fetch/multisource.go
@@ -274,11 +274,7 @@ func (c *multiSourceClient) SessionStats(ctx context.Context, id string, session
 		return AccountStatsOverPeriod{}, AccountStatsOverPeriod{}, ErrInvalidSessionStart
 	}
 
-	// 1 day should be the same as today
-	sessionBefore := time.Now()
-	if time.Since(sessionStart).Hours() >= 24 {
-		sessionBefore = sessionStart
-	}
+	sessionBefore := sessionStart
 
 	var accountSnapshot retry.DataWithErr[database.AccountSnapshot]
 	var vehiclesSnapshots retry.DataWithErr[[]database.VehicleSnapshot]

From 75d8bcc11699cb8efd0776b69f08989cf9c9bc34 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Tue, 18 Jun 2024 13:11:36 -0400
Subject: [PATCH 075/341] added highlight cards

---
 internal/stats/prepare/session/card.go     | 69 ++++++++++++++++++++++
 internal/stats/render/common/images.go     | 10 ++--
 internal/stats/render/session/cards.go     | 66 ++++++++++++++++++---
 internal/stats/render/session/constants.go | 28 +++++++--
 4 files changed, 158 insertions(+), 15 deletions(-)

diff --git a/internal/stats/prepare/session/card.go b/internal/stats/prepare/session/card.go
index 9eace0ea..b81b8cc4 100644
--- a/internal/stats/prepare/session/card.go
+++ b/internal/stats/prepare/session/card.go
@@ -1,6 +1,7 @@
 package session
 
 import (
+	"math"
 	"slices"
 
 	"github.com/cufee/aftermath/internal/database"
@@ -122,6 +123,47 @@ func NewCards(session, career fetch.AccountStatsOverPeriod, glossary map[string]
 		cards.Unrated.Vehicles = append(cards.Unrated.Vehicles, card)
 	}
 
+	// Vehicle Highlights
+	var minimumBattles float64 = 5
+	periodDays := session.PeriodEnd.Sub(session.PeriodStart).Hours() / 24
+	withFallback := func(battles float64) float64 {
+		return math.Min(battles, float64(session.RegularBattles.Battles.Float())/float64(len(highlights)))
+	}
+	if periodDays > 90 {
+		minimumBattles = withFallback(100)
+	} else if periodDays > 60 {
+		minimumBattles = withFallback(75)
+	} else if periodDays > 30 {
+		minimumBattles = withFallback(50)
+	} else if periodDays > 14 {
+		minimumBattles = withFallback(25)
+	} else if periodDays > 7 {
+		minimumBattles = withFallback(10)
+	}
+
+	highlightedVehicles, err := common.GetHighlightedVehicles(highlights, session.RegularBattles.Vehicles, int(minimumBattles))
+	if err != nil {
+		return Cards{}, err
+	}
+
+	for _, data := range highlightedVehicles {
+		glossary := glossary[data.Vehicle.VehicleID]
+		glossary.ID = data.Vehicle.VehicleID
+
+		card, err := makeHighlightCard(
+			data.Highlight,
+			data.Vehicle,
+			frame.VehicleStatsFrame{},
+			options.Printer(),
+			options.Locale(),
+			glossary,
+		)
+		if err != nil {
+			return Cards{}, err
+		}
+		cards.Unrated.Highlights = append(cards.Unrated.Highlights, card)
+	}
+
 	return cards, nil
 }
 
@@ -152,6 +194,33 @@ func makeVehicleCard(presets []common.Tag, cardType common.CardType, session, ca
 	}, nil
 }
 
+func makeHighlightCard(highlight common.Highlight, session, career frame.VehicleStatsFrame, printer func(string) string, locale language.Tag, glossary database.Vehicle) (VehicleCard, error) {
+	var sFrame, cFrame frame.StatsFrame
+	if session.StatsFrame != nil {
+		sFrame = *session.StatsFrame
+	}
+	if career.StatsFrame != nil {
+		cFrame = *career.StatsFrame
+	}
+
+	var blocks []common.StatsBlock[BlockData]
+	for _, preset := range highlight.Blocks {
+		block, err := presetToBlock(preset, sFrame, cFrame)
+		if err != nil {
+			return VehicleCard{}, err
+		}
+		block.Localize(printer)
+		blocks = append(blocks, block)
+	}
+
+	return VehicleCard{
+		Meta:   printer(highlight.Label),
+		Title:  common.IntToRoman(glossary.Tier) + " " + glossary.Name(locale),
+		Type:   common.CardTypeHighlight,
+		Blocks: blocks,
+	}, nil
+}
+
 func makeOverviewCard(columns [][]common.Tag, session, career frame.StatsFrame, label string, printer func(string) string, replace func(common.Tag) common.Tag) (OverviewCard, error) {
 	var blocks [][]common.StatsBlock[BlockData]
 	for _, presets := range columns {
diff --git a/internal/stats/render/common/images.go b/internal/stats/render/common/images.go
index bda0c696..4074fb5e 100644
--- a/internal/stats/render/common/images.go
+++ b/internal/stats/render/common/images.go
@@ -57,8 +57,10 @@ func renderImages(images []image.Image, style Style) (image.Image, error) {
 		lastX += float64(imageSize.extraSpacingX)
 		lastY += float64(imageSize.extraSpacingY)
 	case JustifyContentSpaceBetween:
-		justifyOffsetX = float64(imageSize.extraSpacingX / float64(len(images)-1))
-		justifyOffsetY = float64(imageSize.extraSpacingY / float64(len(images)-1))
+		if len(images) > 0 {
+			justifyOffsetX = float64(imageSize.extraSpacingX / float64(len(images)-1))
+			justifyOffsetY = float64(imageSize.extraSpacingY / float64(len(images)-1))
+		}
 	case JustifyContentSpaceAround:
 		spacingX := float64(imageSize.extraSpacingX / float64(len(images)+1))
 		spacingY := float64(imageSize.extraSpacingY / float64(len(images)+1))
@@ -188,8 +190,8 @@ func getDetailedSize(images []image.Image, style Style) imageSize {
 		imageHeight = totalHeight
 	}
 
-	extraSpacingX := imageWidth - totalWidth
-	extraSpacingY := imageHeight - totalHeight
+	extraSpacingX := max(0, imageWidth-totalWidth)
+	extraSpacingY := max(0, imageHeight-totalHeight)
 
 	return imageSize{
 		width:            imageWidth,
diff --git a/internal/stats/render/session/cards.go b/internal/stats/render/session/cards.go
index d5949d10..0df453bb 100644
--- a/internal/stats/render/session/cards.go
+++ b/internal/stats/render/session/cards.go
@@ -32,6 +32,7 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 	// Calculate minimal card width to fit all the content
 	primaryCardBlockSizes := make(map[string]float64)
 	secondaryCardBlockSizes := make(map[string]float64)
+	highlightCardBlockSizes := make(map[string]float64)
 	var primaryCardWidth float64 = minPrimaryCardWidth
 	var secondaryCardWidth, totalFrameWidth float64
 	// rating and unrated battles > 0	 	   unrated battles > 0		   rating battles > 0
@@ -89,15 +90,15 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 		for _, card := range cards.Unrated.Highlights {
 			// [card label] [session]
 			// [title]  	  [label]
-			labelSize := common.MeasureString(card.Meta, *vehicleCardTitleTextStyle.Font)
-			titleSize := common.MeasureString(card.Title, *vehicleCardTitleTextStyle.Font)
-			presetBlockWidth, contentWidth := vehicleBlocksWidth(card.Blocks, vehicleBlockStyle.session, vehicleBlockStyle.career, vehicleBlockStyle.label, vehicleBlocksRowStyle(0))
+			labelSize := common.MeasureString(card.Meta, *highlightCardTitleTextStyle.Font)
+			titleSize := common.MeasureString(card.Title, *highlightVehicleNameTextStyle.Font)
+			presetBlockWidth, contentWidth := highlightedVehicleBlocksWidth(card.Blocks, vehicleBlockStyle.session, vehicleBlockStyle.career, vehicleBlockStyle.label, highlightedVehicleBlockRowStyle(0))
 			// add the gap and card padding, the gap here accounts for title/label being inline with content
-			contentWidth += vehicleBlocksRowStyle(0).Gap*float64(len(card.Blocks)) + highlightCardStyle(0).PaddingX*2 + common.Max(titleSize.TotalWidth, labelSize.TotalWidth)
+			contentWidth += highlightedVehicleBlockRowStyle(0).Gap*float64(len(card.Blocks)) + highlightedVehicleCardStyle(0).Gap + highlightedVehicleCardStyle(0).PaddingX*2 + common.Max(titleSize.TotalWidth, labelSize.TotalWidth)
 			primaryCardWidth = common.Max(primaryCardWidth, contentWidth)
 
 			for key, width := range presetBlockWidth {
-				primaryCardBlockSizes[key] = common.Max(primaryCardBlockSizes[key], width)
+				highlightCardBlockSizes[key] = common.Max(highlightCardBlockSizes[key], width)
 			}
 		}
 	}
@@ -169,7 +170,9 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 
 	// highlights
 	if shouldRenderUnratedHighlights {
-		//
+		for _, vehicle := range cards.Unrated.Highlights {
+			primaryColumn = append(primaryColumn, makeVehicleHighlightCard(vehicle, highlightCardBlockSizes, primaryCardWidth))
+		}
 	}
 	// rating vehicle cards
 	if shouldRenderRatingVehicles {
@@ -214,7 +217,36 @@ func vehicleBlocksWidth(blocks []prepare.StatsBlock[session.BlockData], sessionS
 			width = common.Max(width, size.TotalWidth+labelStyle.PaddingX*2+vehicleLegendLabelContainer.PaddingX*2)
 		}
 		maxBlockWidth = common.Max(maxBlockWidth, width)
-		presetBlockWidth[block.Tag.String()] = common.Max(presetBlockWidth[block.Tag.String()], width) // add space for comparison icons
+		presetBlockWidth[block.Tag.String()] = common.Max(presetBlockWidth[block.Tag.String()], width)
+	}
+
+	if containerStyle.Direction == common.DirectionHorizontal {
+		for _, w := range presetBlockWidth {
+			contentWidth += w
+		}
+	} else {
+		contentWidth = maxBlockWidth
+	}
+
+	return presetBlockWidth, contentWidth
+}
+
+func highlightedVehicleBlocksWidth(blocks []prepare.StatsBlock[session.BlockData], sessionStyle, _, labelStyle, containerStyle common.Style) (map[string]float64, float64) {
+	presetBlockWidth := make(map[string]float64)
+	var contentWidth float64
+	var maxBlockWidth float64
+	for _, block := range blocks {
+		var width float64
+		{
+			size := common.MeasureString(block.Data.Session.String(), *sessionStyle.Font)
+			width = common.Max(width, size.TotalWidth+sessionStyle.PaddingX*2)
+		}
+		{
+			size := common.MeasureString(block.Label, *labelStyle.Font)
+			width = common.Max(width, size.TotalWidth+labelStyle.PaddingX*2)
+		}
+		maxBlockWidth = common.Max(maxBlockWidth, width)
+		presetBlockWidth[block.Tag.String()] = common.Max(presetBlockWidth[block.Tag.String()], width)
 	}
 
 	if containerStyle.Direction == common.DirectionHorizontal {
@@ -269,6 +301,26 @@ func makeVehicleCard(vehicle session.VehicleCard, blockSizes map[string]float64,
 	)
 }
 
+func makeVehicleHighlightCard(vehicle session.VehicleCard, blockSizes map[string]float64, cardWidth float64) common.Block {
+	var content []common.Block
+	for _, block := range vehicle.Blocks {
+		content = append(content,
+			common.NewBlocksContent(statsBlockStyle(blockSizes[block.Tag.String()]),
+				common.NewTextContent(vehicleBlockStyle.session, block.Data.Session.String()),
+				common.NewTextContent(vehicleBlockStyle.label, block.Label),
+			),
+		)
+	}
+
+	return common.NewBlocksContent(highlightedVehicleCardStyle(cardWidth),
+		common.NewBlocksContent(common.Style{Direction: common.DirectionVertical},
+			common.NewTextContent(highlightCardTitleTextStyle, vehicle.Meta),
+			common.NewTextContent(highlightVehicleNameTextStyle, vehicle.Title),
+		),
+		common.NewBlocksContent(highlightedVehicleBlockRowStyle(0), content...),
+	)
+}
+
 func makeVehicleLegendCard(reference session.VehicleCard, blockSizes map[string]float64, cardWidth float64) common.Block {
 	var content []common.Block
 	for _, block := range reference.Blocks {
diff --git a/internal/stats/render/session/constants.go b/internal/stats/render/session/constants.go
index 375d88f3..fbcfc71b 100644
--- a/internal/stats/render/session/constants.go
+++ b/internal/stats/render/session/constants.go
@@ -124,6 +124,7 @@ func vehicleBlocksRowStyle(width float64) common.Style {
 		AlignItems:     common.AlignItemsCenter,
 		Width:          width,
 		Gap:            10,
+		// Debug:          true,
 	}
 }
 
@@ -145,12 +146,31 @@ func ratingVehicleBlocksRowStyle(width float64) common.Style {
 	return vehicleBlocksRowStyle(width)
 }
 
-func highlightCardStyle(width float64) common.Style {
-	return defaultCardStyle(width)
-}
+var (
+	highlightCardTitleTextStyle   = common.Style{Font: &common.FontSmall, FontColor: common.TextSecondary}
+	highlightVehicleNameTextStyle = common.Style{Font: &common.FontMedium, FontColor: common.TextPrimary}
+)
 
 func highlightedVehicleCardStyle(width float64) common.Style {
-	return vehicleCardStyle(width)
+	style := defaultCardStyle(width)
+	style.JustifyContent = common.JustifyContentSpaceBetween
+	style.Direction = common.DirectionHorizontal
+	style.AlignItems = common.AlignItemsCenter
+	style.PaddingX, style.PaddingY = 20, 15
+	style.Gap = 15
+	// style.Debug = true
+	return style
+}
+
+func highlightedVehicleBlockRowStyle(width float64) common.Style {
+	return common.Style{
+		JustifyContent: common.JustifyContentSpaceBetween,
+		Direction:      common.DirectionHorizontal,
+		AlignItems:     common.AlignItemsCenter,
+		Width:          width,
+		Gap:            10,
+		// Debug:          true,
+	}
 }
 
 func defaultCardStyle(width float64) common.Style {

From a4bf6d63a9a7f340db59949ab09eeb302d10da2a Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 20 Jun 2024 16:53:44 -0400
Subject: [PATCH 076/341] added internal API

---
 cmds/core/server/handlers/private/accounts.go | 112 ++++++++++++++++++
 cmds/core/server/server.go                    |  27 +++++
 docker-entrypoint.sh                          |   2 -
 internal/stats/fetch/convert.go               |   4 +-
 internal/stats/fetch/multisource.go           |   2 +-
 internal/stats/render/session/cards.go        |   6 +-
 internal/stats/render/session/constants.go    |   1 -
 main.go                                       |  67 +++++++----
 8 files changed, 191 insertions(+), 30 deletions(-)
 create mode 100644 cmds/core/server/handlers/private/accounts.go
 create mode 100644 cmds/core/server/server.go
 delete mode 100755 docker-entrypoint.sh

diff --git a/cmds/core/server/handlers/private/accounts.go b/cmds/core/server/handlers/private/accounts.go
new file mode 100644
index 00000000..ab8f0547
--- /dev/null
+++ b/cmds/core/server/handlers/private/accounts.go
@@ -0,0 +1,112 @@
+package private
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"sync"
+
+	"github.com/cufee/aftermath/cmds/core"
+	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/stats/fetch"
+	"github.com/cufee/am-wg-proxy-next/v2/types"
+	"github.com/rs/zerolog/log"
+	"golang.org/x/sync/semaphore"
+)
+
+/*
+This function is temporary and does not need to be good :D
+*/
+func LoadAccountsHandler(client core.Client) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		payload, err := io.ReadAll(r.Body)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+		defer r.Body.Close()
+
+		var accounts []string
+		err = json.Unmarshal(payload, &accounts)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		existing, err := client.Database().GetAccounts(context.Background(), accounts)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		w.Write([]byte(fmt.Sprintf("working on %d accounts", len(accounts)-len(existing))))
+		log.Info().Int("count", len(accounts)-len(existing)).Msg("importing accounts")
+
+		go func() {
+			existingMap := make(map[string]struct{})
+			for _, a := range existing {
+				existingMap[a.ID] = struct{}{}
+			}
+
+			accountsByRealm := make(map[string][]string)
+			for _, a := range accounts {
+				if _, ok := existingMap[a]; ok {
+					continue
+				}
+
+				id := client.Wargaming().RealmFromAccountID(a)
+				accountsByRealm[id] = append(accountsByRealm[id], a)
+			}
+
+			batchSize := 50
+			var wg sync.WaitGroup
+			sem := semaphore.NewWeighted(5)
+
+			for realm, accounts := range accountsByRealm {
+				for i := 0; i < len(accounts); i += batchSize {
+					end := i + batchSize
+					if end > len(accounts) {
+						end = len(accounts)
+					}
+
+					wg.Add(1)
+					go func(accounts []string, realm string) {
+						defer wg.Done()
+
+						ctx, cancel := context.WithCancel(context.Background())
+						defer cancel()
+
+						err := sem.Acquire(ctx, 1)
+						if err != nil {
+							log.Err(err).Msg("failed to acquire a semaphore")
+							return
+						}
+						defer sem.Release(1)
+
+						data, err := client.Wargaming().BatchAccountByID(ctx, realm, accounts)
+						if err != nil {
+							log.Err(err).Msg("failed to get accounts from wg")
+							return
+						}
+
+						var inserts []database.Account
+						for _, account := range data {
+							inserts = append(inserts, fetch.WargamingToAccount(realm, account, types.ClanMember{}, false))
+						}
+
+						errors := client.Database().UpsertAccounts(ctx, inserts)
+						if len(errors) > 0 {
+							log.Error().Any("errors", errors).Msg("failed to upsert some accounts")
+							return
+						}
+
+					}(accounts[i:end], realm)
+				}
+			}
+			wg.Wait()
+			log.Info().Int("count", len(accounts)-len(existing)).Msg("finished importing accounts")
+		}()
+	}
+}
diff --git a/cmds/core/server/server.go b/cmds/core/server/server.go
new file mode 100644
index 00000000..ffc6827c
--- /dev/null
+++ b/cmds/core/server/server.go
@@ -0,0 +1,27 @@
+package server
+
+import (
+	"net/http"
+	"time"
+)
+
+type Handler struct {
+	Path string
+	Func http.HandlerFunc
+}
+
+func NewServer(port string, handlers ...Handler) func() {
+	mux := http.NewServeMux()
+	for _, h := range handlers {
+		mux.Handle(h.Path, h.Func)
+	}
+	srv := &http.Server{
+		Addr:         "127.0.0.1:" + port,
+		WriteTimeout: 15 * time.Second,
+		ReadTimeout:  5 * time.Second,
+		Handler:      mux,
+	}
+	return func() {
+		panic(srv.ListenAndServe())
+	}
+}
diff --git a/docker-entrypoint.sh b/docker-entrypoint.sh
deleted file mode 100755
index e03049b6..00000000
--- a/docker-entrypoint.sh
+++ /dev/null
@@ -1,2 +0,0 @@
-#!/bin/sh
-go run github.com/steebchen/prisma-client-go migrate deploy --schema /prisma/schema.prisma && /app
diff --git a/internal/stats/fetch/convert.go b/internal/stats/fetch/convert.go
index 342d1a18..39fa8c39 100644
--- a/internal/stats/fetch/convert.go
+++ b/internal/stats/fetch/convert.go
@@ -15,7 +15,7 @@ func timestampToTime(timestamp int) time.Time {
 	return time.Unix(int64(timestamp), 0)
 }
 
-func wargamingToAccount(realm string, account types.ExtendedAccount, clan types.ClanMember, private bool) database.Account {
+func WargamingToAccount(realm string, account types.ExtendedAccount, clan types.ClanMember, private bool) database.Account {
 	a := database.Account{
 		ID:       strconv.Itoa(account.ID),
 		Realm:    realm,
@@ -36,7 +36,7 @@ func WargamingToStats(realm string, accountData types.ExtendedAccount, clanMembe
 	stats := AccountStatsOverPeriod{
 		Realm: realm,
 		// we got the stats, so the account is obv not private at this point
-		Account: wargamingToAccount(realm, accountData, clanMember, false),
+		Account: WargamingToAccount(realm, accountData, clanMember, false),
 		RegularBattles: StatsWithVehicles{
 			StatsFrame: WargamingToFrame(accountData.Statistics.All),
 			Vehicles:   WargamingVehiclesToFrame(vehicleData),
diff --git a/internal/stats/fetch/multisource.go b/internal/stats/fetch/multisource.go
index 1f1a50c9..b893916f 100644
--- a/internal/stats/fetch/multisource.go
+++ b/internal/stats/fetch/multisource.go
@@ -83,7 +83,7 @@ func (c *multiSourceClient) Account(ctx context.Context, id string) (database.Ac
 		return database.Account{}, wgAccount.Err
 	}
 
-	account := wargamingToAccount(realm, wgAccount.Data, clan, false)
+	account := WargamingToAccount(realm, wgAccount.Data, clan, false)
 	go func() {
 		ctx, cancel := context.WithTimeout(context.Background(), time.Second)
 		defer cancel()
diff --git a/internal/stats/render/session/cards.go b/internal/stats/render/session/cards.go
index 0df453bb..00738329 100644
--- a/internal/stats/render/session/cards.go
+++ b/internal/stats/render/session/cards.go
@@ -162,10 +162,10 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 
 	// overview cards
 	if shouldRenderUnratedOverview {
-		primaryColumn = append(primaryColumn, makeOverviewCard(cards.Unrated.Overview, primaryCardBlockSizes, primaryCardWidth, overviewCardStyle(primaryCardWidth)))
+		primaryColumn = append(primaryColumn, makeOverviewCard(cards.Unrated.Overview, primaryCardBlockSizes, overviewCardStyle(primaryCardWidth)))
 	}
 	if shouldRenderRatingOverview {
-		primaryColumn = append(primaryColumn, makeOverviewCard(cards.Rating.Overview, primaryCardBlockSizes, primaryCardWidth, overviewRatingCardStyle(primaryCardWidth)))
+		primaryColumn = append(primaryColumn, makeOverviewCard(cards.Rating.Overview, primaryCardBlockSizes, overviewRatingCardStyle(primaryCardWidth)))
 	}
 
 	// highlights
@@ -337,7 +337,7 @@ func makeVehicleLegendCard(reference session.VehicleCard, blockSizes map[string]
 	return common.NewBlocksContent(style, common.NewBlocksContent(vehicleBlocksRowStyle(0), content...))
 }
 
-func makeOverviewCard(card session.OverviewCard, blockSizes map[string]float64, cardWidth float64, style common.Style) common.Block {
+func makeOverviewCard(card session.OverviewCard, blockSizes map[string]float64, style common.Style) common.Block {
 	var content []common.Block
 	for _, column := range card.Blocks {
 		var columnContent []common.Block
diff --git a/internal/stats/render/session/constants.go b/internal/stats/render/session/constants.go
index fbcfc71b..54230f80 100644
--- a/internal/stats/render/session/constants.go
+++ b/internal/stats/render/session/constants.go
@@ -28,7 +28,6 @@ func frameStyle() common.Style {
 }
 
 var (
-	overviewCardTitleStyle  = common.Style{Font: &common.FontMedium, FontColor: common.TextAlt, PaddingX: 5}
 	overviewStatsBlockStyle = blockStyle{
 		common.Style{Font: &common.FontLarge, FontColor: common.TextPrimary},
 		common.Style{Font: &common.FontMedium, FontColor: common.TextSecondary},
diff --git a/main.go b/main.go
index be6bd79a..cd67cab4 100644
--- a/main.go
+++ b/main.go
@@ -4,7 +4,6 @@ import (
 	"embed"
 	"io/fs"
 
-	"net/http"
 	"os"
 	"strconv"
 	"time"
@@ -12,6 +11,8 @@ import (
 	"github.com/cufee/aftermath/cmds/core"
 	"github.com/cufee/aftermath/cmds/core/scheduler"
 	"github.com/cufee/aftermath/cmds/core/scheduler/tasks"
+	"github.com/cufee/aftermath/cmds/core/server"
+	"github.com/cufee/aftermath/cmds/core/server/handlers/private"
 	"github.com/cufee/aftermath/cmds/discord"
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/external/blitzstars"
@@ -39,31 +40,42 @@ func main() {
 	zerolog.SetGlobalLevel(level)
 
 	loadStaticAssets(static)
-	coreClient := coreClientFromEnv()
-	startSchedulerFromEnvAsync()
 
-	// Load some init options to registed admin accounts and etc
-	logic.ApplyInitOptions(coreClient.Database())
+	liveCoreClient, cacheCoreClient := coreClientsFromEnv()
+	startSchedulerFromEnvAsync(cacheCoreClient.Wargaming())
 
-	discordHandler, err := discord.NewRouterHandler(coreClient, os.Getenv("DISCORD_TOKEN"), os.Getenv("DISCORD_PUBLIC_KEY"))
+	// Load some init options to registered admin accounts and etc
+	logic.ApplyInitOptions(liveCoreClient.Database())
+
+	discordHandler, err := discord.NewRouterHandler(liveCoreClient, os.Getenv("DISCORD_TOKEN"), os.Getenv("DISCORD_PUBLIC_KEY"))
 	if err != nil {
 		panic(err)
 	}
 
-	http.Handle("/discord/callback", discordHandler)
-	panic(http.ListenAndServe(":"+os.Getenv("PORT"), nil))
+	if e := os.Getenv("PRIVATE_SERVER_ENABLED"); e == "true" {
+		port := os.Getenv("PRIVATE_SERVER_PORT")
+		servePrivate := server.NewServer(port, server.Handler{
+			Path: "POST /accounts/load",
+			Func: private.LoadAccountsHandler(cacheCoreClient),
+		})
+		log.Info().Str("port", port).Msg("starting a private server")
+		go servePrivate()
+	}
+
+	port := os.Getenv("PORT")
+	servePublic := server.NewServer(port, server.Handler{
+		Path: "POST /discord/callback",
+		Func: discordHandler,
+	})
+	log.Info().Str("port", port).Msg("starting a public server")
+	servePublic()
 }
 
-func startSchedulerFromEnvAsync() {
+func startSchedulerFromEnvAsync(wgClient wargaming.Client) {
 	if os.Getenv("SCHEDULER_ENABLED") != "true" {
 		return
 	}
 
-	// This wargaming client is using a different proxy as it needs a lot higher rps, but can be slow
-	wgClient, err := wargaming.NewClientFromEnv(os.Getenv("WG_CACHE_APP_ID"), os.Getenv("WG_CACHE_APP_RPS"), os.Getenv("WG_CACHE_REQUEST_TIMEOUT_SEC"), os.Getenv("WG_CACHE_PROXY_HOST_LIST"))
-	if err != nil {
-		log.Fatal().Msgf("wgClient: wargaming#NewClientFromEnv failed %s", err)
-	}
 	dbClient, err := database.NewClient()
 	if err != nil {
 		log.Fatal().Msgf("database#NewClient failed %s", err)
@@ -100,12 +112,8 @@ func startSchedulerFromEnvAsync() {
 	// scheduler.CreateSessionTasksWorker(coreClient, "AS")()
 }
 
-func coreClientFromEnv() core.Client {
+func coreClientsFromEnv() (core.Client, core.Client) {
 	// Dependencies
-	wgClient, err := wargaming.NewClientFromEnv(os.Getenv("WG_PRIMARY_APP_ID"), os.Getenv("WG_PRIMARY_APP_RPS"), os.Getenv("WG_PRIMARY_REQUEST_TIMEOUT_SEC"), os.Getenv("WG_PROXY_HOST_LIST"))
-	if err != nil {
-		log.Fatal().Msgf("wgClient: wargaming#NewClientFromEnv failed %s", err)
-	}
 	dbClient, err := database.NewClient()
 	if err != nil {
 		log.Fatal().Msgf("database#NewClient failed %s", err)
@@ -115,13 +123,15 @@ func coreClientFromEnv() core.Client {
 		log.Fatal().Msgf("failed to init a blitzstars client %s", err)
 	}
 
+	liveClient, cacheClient := wargamingClientsFromEnv()
+
 	// Fetch client
-	client, err := fetch.NewMultiSourceClient(wgClient, bsClient, dbClient)
+	fetchClient, err := fetch.NewMultiSourceClient(cacheClient, bsClient, dbClient)
 	if err != nil {
 		log.Fatal().Msgf("fetch#NewMultiSourceClient failed %s", err)
 	}
 
-	return core.NewClient(client, wgClient, dbClient)
+	return core.NewClient(fetchClient, liveClient, dbClient), core.NewClient(fetchClient, cacheClient, dbClient)
 }
 
 func loadStaticAssets(static fs.FS) {
@@ -139,3 +149,18 @@ func loadStaticAssets(static fs.FS) {
 		log.Fatal().Msgf("localization#LoadAssets failed %s", err)
 	}
 }
+
+func wargamingClientsFromEnv() (wargaming.Client, wargaming.Client) {
+	liveClient, err := wargaming.NewClientFromEnv(os.Getenv("WG_PRIMARY_APP_ID"), os.Getenv("WG_PRIMARY_APP_RPS"), os.Getenv("WG_PRIMARY_REQUEST_TIMEOUT_SEC"), os.Getenv("WG_PROXY_HOST_LIST"))
+	if err != nil {
+		log.Fatal().Msgf("wargamingClientsFromEnv#NewClientFromEnv failed %s", err)
+	}
+
+	// This wargaming client is using a different proxy as it needs a lot higher rps, but can be slow
+	cacheClient, err := wargaming.NewClientFromEnv(os.Getenv("WG_CACHE_APP_ID"), os.Getenv("WG_CACHE_APP_RPS"), os.Getenv("WG_CACHE_REQUEST_TIMEOUT_SEC"), os.Getenv("WG_CACHE_PROXY_HOST_LIST"))
+	if err != nil {
+		log.Fatal().Msgf("wargamingClientsFromEnv#NewClientFromEnv failed %s", err)
+	}
+
+	return liveClient, cacheClient
+}

From f757dbeb5740391404ec3c01d932eda4eff770c7 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 20 Jun 2024 17:08:08 -0400
Subject: [PATCH 077/341] added second port

---
 .env.example        | 6 ++++--
 docker-compose.yaml | 1 +
 render_test.go      | 2 +-
 3 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/.env.example b/.env.example
index 5f143144..6c94cc36 100644
--- a/.env.example
+++ b/.env.example
@@ -34,8 +34,10 @@ DISCORD_PRIMARY_GUILD_ID="" # Discord ID of the primary guild, some features wil
 DISCORD_ERROR_REPORT_WEBHOOK_URL="" # A Discord webhook URL for a channel where the bot should report errors
 
 # Optional components
-SCHEDULER_ENABLED="true"
-SCHEDULER_CONCURRENT_WORKERS="10"
+SCHEDULER_ENABLED="true" # Scheduler is responsible for refreshing glossary cache and recording sessions
+SCHEDULER_CONCURRENT_WORKERS="10" 
+PRIVATE_SERVER_ENABLED="true" # A private server can be used to access some managemenet endpoints
+PRIVATE_SERVER_PORT="9093"
 
 # Misc configuration
 LOG_LEVEL="debug"
diff --git a/docker-compose.yaml b/docker-compose.yaml
index 1f203e05..844cb133 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -33,6 +33,7 @@ services:
           memory: 256m
     ports:
       - 3000
+      - ${PRIVATE_SERVER_PORT}
     networks:
       - dokploy-network
     labels:
diff --git a/render_test.go b/render_test.go
index c014682e..a6770d64 100644
--- a/render_test.go
+++ b/render_test.go
@@ -23,7 +23,7 @@ func TestRenderSession(t *testing.T) {
 	zerolog.SetGlobalLevel(level)
 
 	loadStaticAssets(static)
-	coreClient := coreClientFromEnv()
+	coreClient, _ := coreClientsFromEnv()
 	defer coreClient.Database().Disconnect()
 
 	rating, _ := assets.GetLoadedImage("rating-calibration")

From fd5eb5fc46dfaa9c3fe2695e4765c346601d5d75 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 20 Jun 2024 17:19:49 -0400
Subject: [PATCH 078/341] exposing the sane port on host

---
 docker-compose.yaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docker-compose.yaml b/docker-compose.yaml
index 844cb133..5651e7cb 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -33,7 +33,7 @@ services:
           memory: 256m
     ports:
       - 3000
-      - ${PRIVATE_SERVER_PORT}
+      - ${PRIVATE_SERVER_PORT}:${PRIVATE_SERVER_PORT}
     networks:
       - dokploy-network
     labels:

From 22cf22143169748d5e4d9305061fdaa1245cd06f Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 20 Jun 2024 17:32:41 -0400
Subject: [PATCH 079/341] fixed addr

---
 cmds/core/server/server.go | 2 +-
 docker-compose.yaml        | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/cmds/core/server/server.go b/cmds/core/server/server.go
index ffc6827c..8c272295 100644
--- a/cmds/core/server/server.go
+++ b/cmds/core/server/server.go
@@ -16,7 +16,7 @@ func NewServer(port string, handlers ...Handler) func() {
 		mux.Handle(h.Path, h.Func)
 	}
 	srv := &http.Server{
-		Addr:         "127.0.0.1:" + port,
+		Addr:         ":" + port,
 		WriteTimeout: 15 * time.Second,
 		ReadTimeout:  5 * time.Second,
 		Handler:      mux,
diff --git a/docker-compose.yaml b/docker-compose.yaml
index 5651e7cb..6362e4ff 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -33,7 +33,7 @@ services:
           memory: 256m
     ports:
       - 3000
-      - ${PRIVATE_SERVER_PORT}:${PRIVATE_SERVER_PORT}
+      - "${PRIVATE_SERVER_PORT}"
     networks:
       - dokploy-network
     labels:

From 2021d67399d72ccb14a5905ec9d73a9fef07eed4 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 20 Jun 2024 17:46:39 -0400
Subject: [PATCH 080/341] fixed highlights on no battles

---
 internal/stats/render/session/cards.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/internal/stats/render/session/cards.go b/internal/stats/render/session/cards.go
index 00738329..3d0e8eb6 100644
--- a/internal/stats/render/session/cards.go
+++ b/internal/stats/render/session/cards.go
@@ -16,12 +16,12 @@ import (
 
 func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Cards, subs []database.UserSubscription, opts render.Options) (render.Segments, error) {
 	var (
-		// primary card
+		// primary cards
 		shouldRenderUnratedOverview   = session.RegularBattles.Battles > 0 || session.RatingBattles.Battles == 0
-		shouldRenderUnratedHighlights = len(session.RegularBattles.Vehicles) > 3
+		shouldRenderUnratedHighlights = session.RegularBattles.Battles > 0 && len(session.RegularBattles.Vehicles) > 3
 		shouldRenderRatingOverview    = session.RatingBattles.Battles > 0
 		shouldRenderRatingVehicles    = len(cards.Unrated.Vehicles) == 0
-		// secondary card
+		// secondary cards
 		shouldRenderUnratedVehicles = len(cards.Unrated.Vehicles) > 0
 	)
 

From 99ab616ae94fc400248d983e3da6b62fe6183de9 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 21 Jun 2024 01:08:10 -0400
Subject: [PATCH 081/341] minor task fixes

---
 cmds/core/scheduler/tasks/cleanup.go | 12 ++++++------
 internal/database/tasks.go           |  6 +++---
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/cmds/core/scheduler/tasks/cleanup.go b/cmds/core/scheduler/tasks/cleanup.go
index 47177792..b753c59d 100644
--- a/cmds/core/scheduler/tasks/cleanup.go
+++ b/cmds/core/scheduler/tasks/cleanup.go
@@ -16,11 +16,11 @@ func init() {
 			if task.Data == nil {
 				return "no data provided", errors.New("no data provided")
 			}
-			snapshotExpiration, ok := task.Data["expiration_snapshots"].(time.Time)
+			snapshotExpiration, ok := task.Data["expiration_snapshots"].(int64)
 			if !ok {
 				return "invalid expiration_snapshots", errors.New("failed to cast expiration_snapshots to time")
 			}
-			taskExpiration, ok := task.Data["expiration_tasks"].(time.Time)
+			taskExpiration, ok := task.Data["expiration_tasks"].(int64)
 			if !ok {
 				task.Data["triesLeft"] = int(0) // do not retry
 				return "invalid expiration_tasks", errors.New("failed to cast expiration_tasks to time")
@@ -29,12 +29,12 @@ func init() {
 			ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 			defer cancel()
 
-			err := client.Database().DeleteExpiredTasks(ctx, taskExpiration)
+			err := client.Database().DeleteExpiredTasks(ctx, time.Unix(taskExpiration, 0))
 			if err != nil {
 				return "failed to delete expired tasks", err
 			}
 
-			err = client.Database().DeleteExpiredSnapshots(ctx, snapshotExpiration)
+			err = client.Database().DeleteExpiredSnapshots(ctx, time.Unix(snapshotExpiration, 0))
 			if err != nil {
 				return "failed to delete expired snapshots", err
 			}
@@ -55,8 +55,8 @@ func CreateCleanupTasks(client core.Client) error {
 		ReferenceID:    "database_cleanup",
 		ScheduledAfter: now,
 		Data: map[string]any{
-			"expiration_snapshots": now.Add(-1 * time.Hour * 24 * 90), // 90 days
-			"expiration_tasks":     now.Add(-1 * time.Hour * 24 * 7),  // 7 days
+			"expiration_snapshots": now.Add(-1 * time.Hour * 24 * 90).Unix(), // 90 days
+			"expiration_tasks":     now.Add(-1 * time.Hour * 24 * 7).Unix(),  // 7 days
 		},
 	}
 
diff --git a/internal/database/tasks.go b/internal/database/tasks.go
index 8bef200a..1301dbcb 100644
--- a/internal/database/tasks.go
+++ b/internal/database/tasks.go
@@ -132,10 +132,10 @@ func NewAttemptLog(task Task, comment, err string) TaskLog {
 Returns up limit tasks that have TaskStatusInProgress and were last updates 1+ hours ago
 */
 func (c *client) GetStaleTasks(ctx context.Context, limit int) ([]Task, error) {
-	models, err := c.prisma.CronTask.FindMany(db.CronTask.And(
+	models, err := c.prisma.CronTask.FindMany(
 		db.CronTask.Status.Equals(string(TaskStatusInProgress)),
-		db.CronTask.UpdatedAt.Before(time.Now().Add(time.Hour*-1)),
-	)).OrderBy(db.CronTask.ScheduledAfter.Order(db.ASC)).Take(limit).Exec(ctx)
+		db.CronTask.LastRun.Before(time.Now().Add(time.Hour*-1)),
+	).OrderBy(db.CronTask.ScheduledAfter.Order(db.ASC)).Take(limit).Exec(ctx)
 	if err != nil && !db.IsErrNotFound(err) {
 		return nil, err
 	}

From 0b2b26ceed0fc29a303992799f52c4a3af9e8a16 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 21 Jun 2024 01:15:15 -0400
Subject: [PATCH 082/341] updating last run

---
 cmds/core/scheduler/queue.go   | 1 +
 cmds/core/scheduler/workers.go | 3 +++
 2 files changed, 4 insertions(+)

diff --git a/cmds/core/scheduler/queue.go b/cmds/core/scheduler/queue.go
index b724ee11..faf92a8a 100644
--- a/cmds/core/scheduler/queue.go
+++ b/cmds/core/scheduler/queue.go
@@ -78,6 +78,7 @@ func (q *Queue) Process(callback func(error), tasks ...database.Task) {
 				})
 				return
 			}
+			t.LastRun = time.Now()
 
 			attempt := database.TaskLog{
 				Targets:   t.Targets,
diff --git a/cmds/core/scheduler/workers.go b/cmds/core/scheduler/workers.go
index 65ffb35b..1a9900d8 100644
--- a/cmds/core/scheduler/workers.go
+++ b/cmds/core/scheduler/workers.go
@@ -82,6 +82,7 @@ func RestartTasksWorker(queue *Queue) func() {
 		staleTasks, err := queue.core.Database().GetStaleTasks(ctx, 100)
 		if err != nil {
 			log.Err(err).Msg("failed to reschedule stale tasks")
+			return
 		}
 
 		if len(staleTasks) < 1 {
@@ -97,6 +98,8 @@ func RestartTasksWorker(queue *Queue) func() {
 		err = queue.core.Database().UpdateTasks(ctx, staleTasks...)
 		if err != nil {
 			log.Err(err).Msg("failed to update stale tasks")
+			return
 		}
+		log.Debug().Int("count", len(staleTasks)).Msg("rescheduled stale tasks")
 	}
 }

From 560ec3614ba586239eedf2a6b3c03565a9d24afa Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 21 Jun 2024 01:16:18 -0400
Subject: [PATCH 083/341] typo

---
 cmds/core/scheduler/tasks/sessions.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cmds/core/scheduler/tasks/sessions.go b/cmds/core/scheduler/tasks/sessions.go
index f5147654..8e430cce 100644
--- a/cmds/core/scheduler/tasks/sessions.go
+++ b/cmds/core/scheduler/tasks/sessions.go
@@ -30,7 +30,7 @@ func init() {
 			}
 			if len(task.Targets) < 1 {
 				task.Data["triesLeft"] = int(0) // do not retry
-				return "targed ids cannot be left blank", errors.New("invalid targets length")
+				return "target ids cannot be left blank", errors.New("invalid targets length")
 			}
 			forceUpdate, _ := task.Data["force"].(bool)
 

From 5fa08b42cfa32081f6be513bc7fdee2059e75a42 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 21 Jun 2024 12:02:51 -0400
Subject: [PATCH 084/341] fixed tasks

---
 cmds/core/scheduler/workers.go | 5 ++++-
 internal/database/tasks.go     | 2 +-
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/cmds/core/scheduler/workers.go b/cmds/core/scheduler/workers.go
index 1a9900d8..c23f2f78 100644
--- a/cmds/core/scheduler/workers.go
+++ b/cmds/core/scheduler/workers.go
@@ -84,17 +84,20 @@ func RestartTasksWorker(queue *Queue) func() {
 			log.Err(err).Msg("failed to reschedule stale tasks")
 			return
 		}
+		log.Debug().Int("count", len(staleTasks)).Msg("fetched stale tasks from database")
 
 		if len(staleTasks) < 1 {
 			return
 		}
 
 		now := time.Now()
-		for _, task := range staleTasks {
+		for i, task := range staleTasks {
 			task.Status = database.TaskStatusScheduled
 			task.ScheduledAfter = now
+			staleTasks[i] = task
 		}
 
+		log.Debug().Int("count", len(staleTasks)).Msg("updating stale tasks")
 		err = queue.core.Database().UpdateTasks(ctx, staleTasks...)
 		if err != nil {
 			log.Err(err).Msg("failed to update stale tasks")
diff --git a/internal/database/tasks.go b/internal/database/tasks.go
index 1301dbcb..a2d64be9 100644
--- a/internal/database/tasks.go
+++ b/internal/database/tasks.go
@@ -215,7 +215,7 @@ func (c *client) GetAndStartTasks(ctx context.Context, limit int) ([]Task, error
 
 	_, err = c.prisma.CronTask.
 		FindMany(db.CronTask.ID.In(ids)).
-		Update(db.CronTask.Status.Set(string(TaskStatusInProgress))).
+		Update(db.CronTask.Status.Set(string(TaskStatusInProgress)), db.CronTask.LastRun.Set(time.Now())).
 		Exec(ctx)
 	if err != nil {
 		return nil, err

From 86171d67d69aec8b3bea3fed06e56310c3424226 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 21 Jun 2024 13:10:32 -0400
Subject: [PATCH 085/341] added indicator icons

---
 internal/stats/render/session/blocks.go    | 35 ++++++++++++++++++++++
 internal/stats/render/session/cards.go     | 21 ++++++++-----
 internal/stats/render/session/constants.go | 13 +++++---
 3 files changed, 58 insertions(+), 11 deletions(-)

diff --git a/internal/stats/render/session/blocks.go b/internal/stats/render/session/blocks.go
index cc360907..197187ed 100644
--- a/internal/stats/render/session/blocks.go
+++ b/internal/stats/render/session/blocks.go
@@ -6,7 +6,10 @@ import (
 	"github.com/cufee/aftermath/internal/stats/frame"
 	prepare "github.com/cufee/aftermath/internal/stats/prepare/common"
 	"github.com/cufee/aftermath/internal/stats/prepare/session"
+	"github.com/cufee/aftermath/internal/stats/render/assets"
 	"github.com/cufee/aftermath/internal/stats/render/common"
+	"github.com/disintegration/imaging"
+	"github.com/fogleman/gg"
 )
 
 func makeSpecialRatingColumn(block prepare.StatsBlock[session.BlockData], width float64) common.Block {
@@ -55,6 +58,10 @@ func makeSpecialRatingColumn(block prepare.StatsBlock[session.BlockData], width
 	}
 }
 
+func blankBlock(width, height float64) common.Block {
+	return common.NewImageContent(common.Style{Width: width, Height: height}, gg.NewContext(int(width), int(height)).Image())
+}
+
 func vehicleWN8Icon(wn8 frame.Value) common.Block {
 	ratingColors := common.GetWN8Colors(wn8.Float())
 	if wn8.Float() <= 0 {
@@ -64,3 +71,31 @@ func vehicleWN8Icon(wn8 frame.Value) common.Block {
 	iconTop := common.AftermathLogo(ratingColors.Background, common.SmallLogoOptions())
 	return common.NewImageContent(common.Style{Width: vehicleWN8IconSize, Height: vehicleWN8IconSize}, iconTop)
 }
+
+func vehicleComparisonIcon(session, career frame.Value) common.Block {
+	ctx := gg.NewContext(int(vehicleComparisonIconSize), int(vehicleComparisonIconSize))
+	switch {
+	case session.Float() > career.Float()*1.05:
+		icon, _ := assets.GetLoadedImage("triangle-up-solid")
+		ctx.DrawImage(imaging.Fill(icon, int(vehicleComparisonIconSize), int(vehicleComparisonIconSize), imaging.Center, imaging.Linear), 0, 0)
+		return common.NewImageContent(common.Style{BackgroundColor: color.RGBA{3, 201, 169, 255}}, ctx.Image())
+		// return common.NewImageContent(common.Style{BackgroundColor: common.TextPrimary}, ctx.Image())
+
+	case session.Float() < career.Float()*0.95:
+		icon, _ := assets.GetLoadedImage("triangle-down-solid")
+		ctx.DrawImage(imaging.Fill(icon, int(vehicleComparisonIconSize), int(vehicleComparisonIconSize), imaging.Center, imaging.Linear), 0, 0)
+		return common.NewImageContent(common.Style{BackgroundColor: color.RGBA{231, 130, 141, 255}}, ctx.Image())
+		// return common.NewImageContent(common.Style{BackgroundColor: common.TextPrimary}, ctx.Image())
+
+	default:
+		return common.NewImageContent(common.Style{}, ctx.Image())
+	}
+}
+
+func blockWithVehicleIcon(block common.Block, session, career frame.Value) common.Block {
+	return common.NewBlocksContent(common.Style{}, block, vehicleComparisonIcon(session, career))
+}
+
+func blockShouldHaveCompareIcon(block prepare.StatsBlock[session.BlockData]) bool {
+	return block.Tag != prepare.TagBattles
+}
diff --git a/internal/stats/render/session/cards.go b/internal/stats/render/session/cards.go
index 3d0e8eb6..453244c4 100644
--- a/internal/stats/render/session/cards.go
+++ b/internal/stats/render/session/cards.go
@@ -216,6 +216,7 @@ func vehicleBlocksWidth(blocks []prepare.StatsBlock[session.BlockData], sessionS
 			size := common.MeasureString(block.Label, *labelStyle.Font)
 			width = common.Max(width, size.TotalWidth+labelStyle.PaddingX*2+vehicleLegendLabelContainer.PaddingX*2)
 		}
+		width += vehicleComparisonIconSize
 		maxBlockWidth = common.Max(maxBlockWidth, width)
 		presetBlockWidth[block.Tag.String()] = common.Max(presetBlockWidth[block.Tag.String()], width)
 	}
@@ -278,13 +279,17 @@ func makeVehicleCard(vehicle session.VehicleCard, blockSizes map[string]float64,
 	var content []common.Block
 	for _, block := range vehicle.Blocks {
 		var blockContent []common.Block
-		blockContent = append(blockContent, common.NewTextContent(vehicleBlockStyle.session, block.Data.Session.String()))
-		if block.Data.Career.Float() > 0 {
-			blockContent = append(blockContent, common.NewTextContent(vehicleBlockStyle.career, block.Data.Career.String()))
+		if blockShouldHaveCompareIcon(block) {
+			blockContent = append(blockContent, blockWithVehicleIcon(common.NewTextContent(vehicleBlockStyle.session, block.Data.Session.String()), block.Data.Session, block.Data.Career))
+		} else {
+			blockContent = append(blockContent, common.NewTextContent(vehicleBlockStyle.session, block.Data.Session.String()))
 		}
+
+		style := statsBlockStyle(blockSizes[block.Tag.String()])
 		content = append(content,
-			common.NewBlocksContent(statsBlockStyle(blockSizes[block.Tag.String()]), blockContent...),
+			common.NewBlocksContent(style, blockContent...),
 		)
+
 		if block.Tag == prepare.TagWN8 {
 			vehicleWN8 = block.Value
 		}
@@ -324,10 +329,12 @@ func makeVehicleHighlightCard(vehicle session.VehicleCard, blockSizes map[string
 func makeVehicleLegendCard(reference session.VehicleCard, blockSizes map[string]float64, cardWidth float64) common.Block {
 	var content []common.Block
 	for _, block := range reference.Blocks {
+		containerStyle := statsBlockStyle(blockSizes[block.Tag.String()])
+		if blockShouldHaveCompareIcon(block) {
+			containerStyle.AlignItems = common.AlignItemsStart
+		}
 		content = append(content,
-			common.NewBlocksContent(statsBlockStyle(blockSizes[block.Tag.String()]),
-				common.NewBlocksContent(vehicleLegendLabelContainer, common.NewTextContent(vehicleBlockStyle.label, block.Label)),
-			),
+			common.NewBlocksContent(containerStyle, common.NewBlocksContent(vehicleLegendLabelContainer, common.NewTextContent(vehicleBlockStyle.label, block.Label))),
 		)
 	}
 	style := vehicleCardStyle(cardWidth)
diff --git a/internal/stats/render/session/constants.go b/internal/stats/render/session/constants.go
index 54230f80..9b1f2d96 100644
--- a/internal/stats/render/session/constants.go
+++ b/internal/stats/render/session/constants.go
@@ -13,9 +13,10 @@ type blockStyle struct {
 }
 
 var (
-	vehicleWN8IconSize    = 20.0
-	specialRatingIconSize = 60.0
-	minPrimaryCardWidth   = 300.0 // making the primary card too small looks bad if there are no battles in a session
+	vehicleWN8IconSize        = 20.0
+	specialRatingIconSize     = 60.0
+	vehicleComparisonIconSize = 10.0
+	minPrimaryCardWidth       = 300.0 // making the primary card too small looks bad if there are no battles in a session
 )
 
 var (
@@ -104,15 +105,19 @@ func vehicleCardTitleContainerStyle(width float64) common.Style {
 	return common.Style{
 		JustifyContent: common.JustifyContentSpaceBetween,
 		Direction:      common.DirectionHorizontal,
+		AlignItems:     common.AlignItemsCenter,
 		Width:          width,
+		PaddingX:       2.5,
+		PaddingY:       2.5,
 		Gap:            10,
 	}
 }
 
 func vehicleCardStyle(width float64) common.Style {
 	style := defaultCardStyle(width)
-	style.PaddingX, style.PaddingY = 20, 15
+	style.PaddingX, style.PaddingY = 15, 10
 	style.Gap = 5
+	// style.Debug = true
 	return style
 }
 

From 18ce916699a1709df58ecadba1f2a6caf03e74d7 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 21 Jun 2024 13:14:37 -0400
Subject: [PATCH 086/341] fixed horizontal alignment

---
 internal/stats/render/session/cards.go | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/internal/stats/render/session/cards.go b/internal/stats/render/session/cards.go
index 453244c4..09c6d854 100644
--- a/internal/stats/render/session/cards.go
+++ b/internal/stats/render/session/cards.go
@@ -329,12 +329,13 @@ func makeVehicleHighlightCard(vehicle session.VehicleCard, blockSizes map[string
 func makeVehicleLegendCard(reference session.VehicleCard, blockSizes map[string]float64, cardWidth float64) common.Block {
 	var content []common.Block
 	for _, block := range reference.Blocks {
-		containerStyle := statsBlockStyle(blockSizes[block.Tag.String()])
+		label := common.NewBlocksContent(vehicleLegendLabelContainer, common.NewTextContent(vehicleBlockStyle.label, block.Label))
 		if blockShouldHaveCompareIcon(block) {
-			containerStyle.AlignItems = common.AlignItemsStart
+			label = common.NewBlocksContent(vehicleLegendLabelContainer, blockWithVehicleIcon(common.NewTextContent(vehicleBlockStyle.label, block.Label), frame.InvalidValue, frame.InvalidValue))
 		}
+		containerStyle := statsBlockStyle(blockSizes[block.Tag.String()])
 		content = append(content,
-			common.NewBlocksContent(containerStyle, common.NewBlocksContent(vehicleLegendLabelContainer, common.NewTextContent(vehicleBlockStyle.label, block.Label))),
+			common.NewBlocksContent(containerStyle, label),
 		)
 	}
 	style := vehicleCardStyle(cardWidth)

From 044f684ddb34339295a6709dfcdd0737fc1ea740 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 21 Jun 2024 13:17:49 -0400
Subject: [PATCH 087/341] moved the icon outside the pill

---
 internal/stats/render/session/blocks.go | 9 +++++----
 internal/stats/render/session/cards.go  | 3 +--
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/internal/stats/render/session/blocks.go b/internal/stats/render/session/blocks.go
index 197187ed..ed30dae9 100644
--- a/internal/stats/render/session/blocks.go
+++ b/internal/stats/render/session/blocks.go
@@ -75,20 +75,21 @@ func vehicleWN8Icon(wn8 frame.Value) common.Block {
 func vehicleComparisonIcon(session, career frame.Value) common.Block {
 	ctx := gg.NewContext(int(vehicleComparisonIconSize), int(vehicleComparisonIconSize))
 	switch {
+	case session.Float() < 0, career.Float() < 0:
+		fallthrough
+	default:
+		return common.NewImageContent(common.Style{}, ctx.Image())
+
 	case session.Float() > career.Float()*1.05:
 		icon, _ := assets.GetLoadedImage("triangle-up-solid")
 		ctx.DrawImage(imaging.Fill(icon, int(vehicleComparisonIconSize), int(vehicleComparisonIconSize), imaging.Center, imaging.Linear), 0, 0)
 		return common.NewImageContent(common.Style{BackgroundColor: color.RGBA{3, 201, 169, 255}}, ctx.Image())
-		// return common.NewImageContent(common.Style{BackgroundColor: common.TextPrimary}, ctx.Image())
 
 	case session.Float() < career.Float()*0.95:
 		icon, _ := assets.GetLoadedImage("triangle-down-solid")
 		ctx.DrawImage(imaging.Fill(icon, int(vehicleComparisonIconSize), int(vehicleComparisonIconSize), imaging.Center, imaging.Linear), 0, 0)
 		return common.NewImageContent(common.Style{BackgroundColor: color.RGBA{231, 130, 141, 255}}, ctx.Image())
-		// return common.NewImageContent(common.Style{BackgroundColor: common.TextPrimary}, ctx.Image())
 
-	default:
-		return common.NewImageContent(common.Style{}, ctx.Image())
 	}
 }
 
diff --git a/internal/stats/render/session/cards.go b/internal/stats/render/session/cards.go
index 09c6d854..540f521b 100644
--- a/internal/stats/render/session/cards.go
+++ b/internal/stats/render/session/cards.go
@@ -331,7 +331,7 @@ func makeVehicleLegendCard(reference session.VehicleCard, blockSizes map[string]
 	for _, block := range reference.Blocks {
 		label := common.NewBlocksContent(vehicleLegendLabelContainer, common.NewTextContent(vehicleBlockStyle.label, block.Label))
 		if blockShouldHaveCompareIcon(block) {
-			label = common.NewBlocksContent(vehicleLegendLabelContainer, blockWithVehicleIcon(common.NewTextContent(vehicleBlockStyle.label, block.Label), frame.InvalidValue, frame.InvalidValue))
+			label = blockWithVehicleIcon(common.NewBlocksContent(vehicleLegendLabelContainer, common.NewTextContent(vehicleBlockStyle.label, block.Label)), frame.InvalidValue, frame.InvalidValue)
 		}
 		containerStyle := statsBlockStyle(blockSizes[block.Tag.String()])
 		content = append(content,
@@ -356,7 +356,6 @@ func makeOverviewCard(card session.OverviewCard, blockSizes map[string]float64,
 			} else {
 				col = common.NewBlocksContent(statsBlockStyle(blockSizes[block.Tag.String()]),
 					common.NewTextContent(vehicleBlockStyle.session, block.Data.Session.String()),
-					// common.NewTextContent(vehicleBlockStyle.career, block.Data.Career.String()),
 					common.NewTextContent(vehicleBlockStyle.label, block.Label),
 				)
 			}

From ecdb55c5d66599736deab1dc141eca8c5d47e815 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 21 Jun 2024 13:27:53 -0400
Subject: [PATCH 088/341] proactively acking interaction

---
 cmds/discord/rest/interactions.go       |  6 +++++-
 cmds/discord/router/handler.go          | 23 ++++++++++-------------
 internal/stats/render/session/blocks.go |  1 -
 3 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/cmds/discord/rest/interactions.go b/cmds/discord/rest/interactions.go
index 1c87c2d6..692b2b7d 100644
--- a/cmds/discord/rest/interactions.go
+++ b/cmds/discord/rest/interactions.go
@@ -7,7 +7,11 @@ import (
 )
 
 func (c *Client) SendInteractionResponse(id, token string, data discordgo.InteractionResponse) error {
-	req, err := c.interactionRequest("POST", discordgo.EndpointInteractionResponse(id, token), data, data.Data.Files)
+	var files []*discordgo.File
+	if data.Data != nil {
+		files = data.Data.Files
+	}
+	req, err := c.interactionRequest("POST", discordgo.EndpointInteractionResponse(id, token), data, files)
 	if err != nil {
 		return err
 	}
diff --git a/cmds/discord/router/handler.go b/cmds/discord/router/handler.go
index 1c2e26fd..327f1858 100644
--- a/cmds/discord/router/handler.go
+++ b/cmds/discord/router/handler.go
@@ -111,26 +111,23 @@ func (router *Router) HTTPHandler() (http.HandlerFunc, error) {
 			return
 		}
 
-		// ack the interaction
-		err = writeDeferredInteractionResponseAck(w, data.Type, command.Ephemeral)
+		// ack the interaction proactively
+		err = router.restClient.SendInteractionResponse(data.ID, data.Token, discordgo.InteractionResponse{Type: discordgo.InteractionResponseDeferredChannelMessageWithSource})
 		if err != nil {
 			http.Error(w, err.Error(), http.StatusInternalServerError)
 			log.Err(err).Str("id", data.ID).Msg("failed to ack an interaction")
 			return
 		}
+		// write the ack into response
+		err = writeDeferredInteractionResponseAck(w, data.Type, command.Ephemeral)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			log.Err(err).Str("id", data.ID).Msg("failed to write an interaction ack response")
+			return
+		}
 
 		// route the interaction to a proper handler for a later reply
-		state := &interactionState{mx: &sync.Mutex{}}
-		state.mx.Lock()
-		go func() {
-			// unlock once this context is done and the ack is delivered
-			<-r.Context().Done()
-			log.Debug().Str("id", data.ID).Msg("sent an interaction ack")
-
-			state.acked = true
-			state.mx.Unlock()
-		}()
-
+		state := &interactionState{mx: &sync.Mutex{}, acked: true}
 		router.startInteractionHandlerAsync(data, state, command)
 	}, nil
 }
diff --git a/internal/stats/render/session/blocks.go b/internal/stats/render/session/blocks.go
index ed30dae9..47540f1e 100644
--- a/internal/stats/render/session/blocks.go
+++ b/internal/stats/render/session/blocks.go
@@ -89,7 +89,6 @@ func vehicleComparisonIcon(session, career frame.Value) common.Block {
 		icon, _ := assets.GetLoadedImage("triangle-down-solid")
 		ctx.DrawImage(imaging.Fill(icon, int(vehicleComparisonIconSize), int(vehicleComparisonIconSize), imaging.Center, imaging.Linear), 0, 0)
 		return common.NewImageContent(common.Style{BackgroundColor: color.RGBA{231, 130, 141, 255}}, ctx.Image())
-
 	}
 }
 

From 9210fcef67a3f16076f3555f5f25d05877113d17 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 21 Jun 2024 16:26:37 -0400
Subject: [PATCH 089/341] comparison icons on overview cards

---
 internal/stats/prepare/session/card.go     |  2 +-
 internal/stats/render/session/blocks.go    | 16 +++++--
 internal/stats/render/session/cards.go     | 53 +++++++++++++++++-----
 internal/stats/render/session/constants.go |  4 +-
 4 files changed, 57 insertions(+), 18 deletions(-)

diff --git a/internal/stats/prepare/session/card.go b/internal/stats/prepare/session/card.go
index b81b8cc4..fc3f947d 100644
--- a/internal/stats/prepare/session/card.go
+++ b/internal/stats/prepare/session/card.go
@@ -98,7 +98,7 @@ func NewCards(session, career fetch.AccountStatsOverPeriod, glossary map[string]
 		return int(b.LastBattleTime.Unix() - a.LastBattleTime.Unix())
 	})
 	for _, data := range unratedVehicles {
-		if len(cards.Unrated.Vehicles) >= 5 {
+		if len(cards.Unrated.Vehicles) >= 10 {
 			break
 		}
 		if data.Battles < 1 {
diff --git a/internal/stats/render/session/blocks.go b/internal/stats/render/session/blocks.go
index 47540f1e..8f7bc811 100644
--- a/internal/stats/render/session/blocks.go
+++ b/internal/stats/render/session/blocks.go
@@ -45,7 +45,7 @@ func makeSpecialRatingColumn(block prepare.StatsBlock[session.BlockData], width
 			column = append(column, icon)
 		}
 		column = append(column, common.NewBlocksContent(overviewColumnStyle(width),
-			common.NewTextContent(vehicleBlockStyle.session, block.Data.Session.String()),
+			blockWithDoubleVehicleIcon(common.NewTextContent(vehicleBlockStyle.session, block.Data.Session.String()), block.Data.Session, block.Data.Career),
 		))
 		return common.NewBlocksContent(specialRatingColumnStyle, column...)
 
@@ -80,15 +80,21 @@ func vehicleComparisonIcon(session, career frame.Value) common.Block {
 	default:
 		return common.NewImageContent(common.Style{}, ctx.Image())
 
-	case session.Float() > career.Float()*1.05:
+	case session.Float() > career.Float():
 		icon, _ := assets.GetLoadedImage("triangle-up-solid")
 		ctx.DrawImage(imaging.Fill(icon, int(vehicleComparisonIconSize), int(vehicleComparisonIconSize), imaging.Center, imaging.Linear), 0, 0)
 		return common.NewImageContent(common.Style{BackgroundColor: color.RGBA{3, 201, 169, 255}}, ctx.Image())
 
-	case session.Float() < career.Float()*0.95:
+	case session.Float() < career.Float():
 		icon, _ := assets.GetLoadedImage("triangle-down-solid")
 		ctx.DrawImage(imaging.Fill(icon, int(vehicleComparisonIconSize), int(vehicleComparisonIconSize), imaging.Center, imaging.Linear), 0, 0)
 		return common.NewImageContent(common.Style{BackgroundColor: color.RGBA{231, 130, 141, 255}}, ctx.Image())
+
+	case session.Float() == career.Float():
+		ctx.DrawRectangle(vehicleComparisonIconSize*0.2, (vehicleComparisonIconSize-2)/2, vehicleComparisonIconSize*0.8, 2)
+		ctx.SetColor(common.TextAlt)
+		ctx.Fill()
+		return common.NewImageContent(common.Style{}, ctx.Image())
 	}
 }
 
@@ -96,6 +102,10 @@ func blockWithVehicleIcon(block common.Block, session, career frame.Value) commo
 	return common.NewBlocksContent(common.Style{}, block, vehicleComparisonIcon(session, career))
 }
 
+func blockWithDoubleVehicleIcon(block common.Block, session, career frame.Value) common.Block {
+	return common.NewBlocksContent(common.Style{}, blankBlock(vehicleComparisonIconSize, 1), block, vehicleComparisonIcon(session, career))
+}
+
 func blockShouldHaveCompareIcon(block prepare.StatsBlock[session.BlockData]) bool {
 	return block.Tag != prepare.TagBattles
 }
diff --git a/internal/stats/render/session/cards.go b/internal/stats/render/session/cards.go
index 540f521b..c09ec22e 100644
--- a/internal/stats/render/session/cards.go
+++ b/internal/stats/render/session/cards.go
@@ -17,10 +17,13 @@ import (
 func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Cards, subs []database.UserSubscription, opts render.Options) (render.Segments, error) {
 	var (
 		// primary cards
-		shouldRenderUnratedOverview   = session.RegularBattles.Battles > 0 || session.RatingBattles.Battles == 0
-		shouldRenderUnratedHighlights = session.RegularBattles.Battles > 0 && len(session.RegularBattles.Vehicles) > 3
-		shouldRenderRatingOverview    = session.RatingBattles.Battles > 0
-		shouldRenderRatingVehicles    = len(cards.Unrated.Vehicles) == 0
+		// when there are some unrated battles or no battles at all
+		shouldRenderUnratedOverview = session.RegularBattles.Battles > 0 || session.RatingBattles.Battles == 0
+		// when there are 3 vehicle cards and no rating overview cards or there are 6 vehicle cards and some rating battles
+		shouldRenderUnratedHighlights = (session.RegularBattles.Battles > 0 && session.RatingBattles.Battles < 1 && len(cards.Unrated.Vehicles) > 3) ||
+			(session.RegularBattles.Battles > 0 && len(cards.Unrated.Vehicles) > 6)
+		shouldRenderRatingOverview = session.RatingBattles.Battles > 0
+		shouldRenderRatingVehicles = len(cards.Unrated.Vehicles) == 0
 		// secondary cards
 		shouldRenderUnratedVehicles = len(cards.Unrated.Vehicles) > 0
 	)
@@ -54,21 +57,33 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 	}
 
 	if shouldRenderUnratedOverview {
+		var totalContentWidth float64 = overviewCardStyle(0).Gap * float64(len(cards.Unrated.Overview.Blocks)-1)
 		for _, column := range cards.Unrated.Overview.Blocks {
-			presetBlockWidth, _ := overviewColumnBlocksWidth(column, overviewStatsBlockStyle.session, overviewStatsBlockStyle.career, overviewStatsBlockStyle.label, overviewColumnStyle(0))
+			styleWithIconOffset := overviewStatsBlockStyle
+			styleWithIconOffset.session.PaddingX += vehicleComparisonIconSize
+
+			presetBlockWidth, contentWidth := overviewColumnBlocksWidth(column, styleWithIconOffset.session, styleWithIconOffset.career, styleWithIconOffset.label, overviewColumnStyle(0))
+			totalContentWidth += contentWidth
 			for key, width := range presetBlockWidth {
 				primaryCardBlockSizes[key] = common.Max(primaryCardBlockSizes[key], width)
 			}
 		}
+		primaryCardWidth = common.Max(primaryCardWidth, totalContentWidth)
 	}
 
 	if shouldRenderRatingOverview {
+		var totalContentWidth float64 = overviewCardStyle(0).Gap * float64(len(cards.Rating.Overview.Blocks)-1)
 		for _, column := range cards.Unrated.Overview.Blocks {
-			presetBlockWidth, _ := overviewColumnBlocksWidth(column, overviewStatsBlockStyle.session, overviewStatsBlockStyle.career, overviewStatsBlockStyle.label, overviewColumnStyle(0))
+			styleWithIconOffset := overviewStatsBlockStyle
+			styleWithIconOffset.session.PaddingX += vehicleComparisonIconSize
+
+			presetBlockWidth, contentWidth := overviewColumnBlocksWidth(column, styleWithIconOffset.session, styleWithIconOffset.career, styleWithIconOffset.label, overviewColumnStyle(0))
+			totalContentWidth += contentWidth
 			for key, width := range presetBlockWidth {
 				primaryCardBlockSizes[key] = common.Max(primaryCardBlockSizes[key], width)
 			}
 		}
+		primaryCardWidth = common.Max(primaryCardWidth, totalContentWidth)
 	}
 	// rating vehicle cards go on the primary block - only show if there are no unrated battles/vehicles
 	if shouldRenderRatingVehicles {
@@ -92,6 +107,7 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 			// [title]  	  [label]
 			labelSize := common.MeasureString(card.Meta, *highlightCardTitleTextStyle.Font)
 			titleSize := common.MeasureString(card.Title, *highlightVehicleNameTextStyle.Font)
+
 			presetBlockWidth, contentWidth := highlightedVehicleBlocksWidth(card.Blocks, vehicleBlockStyle.session, vehicleBlockStyle.career, vehicleBlockStyle.label, highlightedVehicleBlockRowStyle(0))
 			// add the gap and card padding, the gap here accounts for title/label being inline with content
 			contentWidth += highlightedVehicleBlockRowStyle(0).Gap*float64(len(card.Blocks)) + highlightedVehicleCardStyle(0).Gap + highlightedVehicleCardStyle(0).PaddingX*2 + common.Max(titleSize.TotalWidth, labelSize.TotalWidth)
@@ -107,7 +123,13 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 			// 		[ label ]
 			// [session]
 			// [career ]
-			presetBlockWidth, contentWidth := vehicleBlocksWidth(card.Blocks, vehicleBlockStyle.session, vehicleBlockStyle.career, vehicleBlockStyle.label, vehicleBlocksRowStyle(0))
+
+			styleWithIconOffset := vehicleBlockStyle
+			// icon is only on one side, so we divide by 2
+			styleWithIconOffset.label.PaddingX += vehicleComparisonIconSize / 2
+			styleWithIconOffset.session.PaddingX += vehicleComparisonIconSize / 2
+
+			presetBlockWidth, contentWidth := vehicleBlocksWidth(card.Blocks, styleWithIconOffset.session, styleWithIconOffset.career, styleWithIconOffset.label, vehicleBlocksRowStyle(0))
 			contentWidth += vehicleBlocksRowStyle(0).Gap*float64(len(card.Blocks)-1) + vehicleCardStyle(0).PaddingX*2
 
 			titleSize := common.MeasureString(card.Title, *vehicleCardTitleTextStyle.Font)
@@ -216,7 +238,6 @@ func vehicleBlocksWidth(blocks []prepare.StatsBlock[session.BlockData], sessionS
 			size := common.MeasureString(block.Label, *labelStyle.Font)
 			width = common.Max(width, size.TotalWidth+labelStyle.PaddingX*2+vehicleLegendLabelContainer.PaddingX*2)
 		}
-		width += vehicleComparisonIconSize
 		maxBlockWidth = common.Max(maxBlockWidth, width)
 		presetBlockWidth[block.Tag.String()] = common.Max(presetBlockWidth[block.Tag.String()], width)
 	}
@@ -265,11 +286,14 @@ func overviewColumnBlocksWidth(blocks []prepare.StatsBlock[session.BlockData], s
 	presetBlockWidth, contentWidth := vehicleBlocksWidth(blocks, sessionStyle, careerStyle, labelStyle, containerStyle)
 	for _, block := range blocks {
 		// adjust width if this column includes a special icon
-		if block.Tag == prepare.TagWN8 || block.Tag == prepare.TagRankedRating {
+		if block.Tag == prepare.TagWN8 {
 			tierNameSize := common.MeasureString(common.GetWN8TierName(block.Value.Float()), *overviewSpecialRatingLabelStyle(nil).Font)
 			tierNameWithPadding := tierNameSize.TotalWidth + overviewSpecialRatingPillStyle(nil).PaddingX*2
 			presetBlockWidth[block.Tag.String()] = common.Max(presetBlockWidth[block.Tag.String()], specialRatingIconSize, tierNameWithPadding)
 		}
+		if block.Tag == prepare.TagRankedRating {
+			presetBlockWidth[block.Tag.String()] = common.Max(presetBlockWidth[block.Tag.String()], specialRatingIconSize)
+		}
 	}
 	return presetBlockWidth, contentWidth
 }
@@ -346,13 +370,20 @@ func makeVehicleLegendCard(reference session.VehicleCard, blockSizes map[string]
 }
 
 func makeOverviewCard(card session.OverviewCard, blockSizes map[string]float64, style common.Style) common.Block {
-	var content []common.Block
+	// made all columns the same width for things to be centered
+	columnWidth := (style.Width - style.Gap*float64(len(card.Blocks)-1) - style.PaddingX*2) / float64(len(card.Blocks))
+	var content []common.Block // add a blank block to balance the offset added from icons
 	for _, column := range card.Blocks {
 		var columnContent []common.Block
 		for _, block := range column {
 			var col common.Block
 			if block.Tag == prepare.TagWN8 || block.Tag == prepare.TagRankedRating {
 				col = makeSpecialRatingColumn(block, blockSizes[block.Tag.String()])
+			} else if blockShouldHaveCompareIcon(block) {
+				col = common.NewBlocksContent(statsBlockStyle(blockSizes[block.Tag.String()]),
+					blockWithDoubleVehicleIcon(common.NewTextContent(vehicleBlockStyle.session, block.Data.Session.String()), block.Data.Session, block.Data.Career),
+					common.NewTextContent(vehicleBlockStyle.label, block.Label),
+				)
 			} else {
 				col = common.NewBlocksContent(statsBlockStyle(blockSizes[block.Tag.String()]),
 					common.NewTextContent(vehicleBlockStyle.session, block.Data.Session.String()),
@@ -361,7 +392,7 @@ func makeOverviewCard(card session.OverviewCard, blockSizes map[string]float64,
 			}
 			columnContent = append(columnContent, col)
 		}
-		content = append(content, common.NewBlocksContent(overviewColumnStyle(0), columnContent...))
+		content = append(content, common.NewBlocksContent(overviewColumnStyle(columnWidth), columnContent...))
 	}
 	return common.NewBlocksContent(style, content...)
 }
diff --git a/internal/stats/render/session/constants.go b/internal/stats/render/session/constants.go
index 9b1f2d96..e85ffc62 100644
--- a/internal/stats/render/session/constants.go
+++ b/internal/stats/render/session/constants.go
@@ -61,12 +61,10 @@ func overviewColumnStyle(width float64) common.Style {
 
 func overviewCardStyle(width float64) common.Style {
 	style := defaultCardStyle(width)
-	style.JustifyContent = common.JustifyContentSpaceAround
+	style.JustifyContent = common.JustifyContentSpaceBetween
 	style.Direction = common.DirectionHorizontal
 	style.AlignItems = common.AlignItemsEnd
 	style.PaddingY = 20
-	style.PaddingX = 10
-	style.Gap = 5
 	// style.Debug = true
 	return style
 }

From 19fef9e57fcb6da6a8f8298824fb034dbbad39ec Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sat, 22 Jun 2024 18:11:18 -0400
Subject: [PATCH 090/341] initial rewrite

---
 .env.example                                  |    14 +-
 Dockerfile                                    |     3 -
 Dockerfile.migrate                            |    19 +-
 Taskfile.yaml                                 |    41 +-
 cmds/core/scheduler/glossary.go               |     6 +-
 cmds/core/scheduler/queue.go                  |    28 +-
 cmds/core/scheduler/tasks/cleanup.go          |    12 +-
 cmds/core/scheduler/tasks/handler.go          |    10 +-
 cmds/core/scheduler/tasks/sessions.go         |    18 +-
 cmds/core/scheduler/tasks/split.go            |     8 +-
 cmds/core/scheduler/workers.go                |     6 +-
 cmds/core/server/handlers/private/accounts.go |     4 +-
 cmds/discord/commands/link.go                 |     6 +-
 cmds/discord/commands/manage.go               |     9 +-
 cmds/discord/commands/session.go              |     7 +-
 cmds/discord/commands/stats.go                |     7 +-
 cmds/discord/common/context.go                |     3 +-
 cmds/discord/router/router.go                 |     8 +-
 docker-compose.yaml                           |    39 +-
 go.mod                                        |    18 +-
 go.sum                                        |    56 +-
 internal/database/accounts.go                 |   209 +-
 internal/database/averages.go                 |   119 +-
 internal/database/cleanup.go                  |    30 +-
 internal/database/client.go                   |    84 +-
 internal/database/discord.go                  |   109 +-
 internal/database/ent/db/account.go           |   259 +
 internal/database/ent/db/account/account.go   |   232 +
 internal/database/ent/db/account/where.go     |   586 +
 internal/database/ent/db/account_create.go    |   457 +
 internal/database/ent/db/account_delete.go    |    88 +
 internal/database/ent/db/account_query.go     |   830 ++
 internal/database/ent/db/account_update.go    |  1087 ++
 internal/database/ent/db/accountsnapshot.go   |   240 +
 .../ent/db/accountsnapshot/accountsnapshot.go |   161 +
 .../database/ent/db/accountsnapshot/where.go  |   498 +
 .../database/ent/db/accountsnapshot_create.go |   392 +
 .../database/ent/db/accountsnapshot_delete.go |    88 +
 .../database/ent/db/accountsnapshot_query.go  |   605 +
 .../database/ent/db/accountsnapshot_update.go |   573 +
 .../database/ent/db/achievementssnapshot.go   |   216 +
 .../achievementssnapshot.go                   |   150 +
 .../ent/db/achievementssnapshot/where.go      |   453 +
 .../ent/db/achievementssnapshot_create.go     |   366 +
 .../ent/db/achievementssnapshot_delete.go     |    88 +
 .../ent/db/achievementssnapshot_query.go      |   605 +
 .../ent/db/achievementssnapshot_update.go     |   485 +
 internal/database/ent/db/appconfiguration.go  |   154 +
 .../db/appconfiguration/appconfiguration.go   |    82 +
 .../database/ent/db/appconfiguration/where.go |   248 +
 .../ent/db/appconfiguration_create.go         |   290 +
 .../ent/db/appconfiguration_delete.go         |    88 +
 .../database/ent/db/appconfiguration_query.go |   526 +
 .../ent/db/appconfiguration_update.go         |   345 +
 .../database/ent/db/applicationcommand.go     |   147 +
 .../applicationcommand/applicationcommand.go  |    96 +
 .../ent/db/applicationcommand/where.go        |   378 +
 .../ent/db/applicationcommand_create.go       |   303 +
 .../ent/db/applicationcommand_delete.go       |    88 +
 .../ent/db/applicationcommand_query.go        |   526 +
 .../ent/db/applicationcommand_update.go       |   379 +
 internal/database/ent/db/clan.go              |   189 +
 internal/database/ent/db/clan/clan.go         |   128 +
 internal/database/ent/db/clan/where.go        |   412 +
 internal/database/ent/db/clan_create.go       |   340 +
 internal/database/ent/db/clan_delete.go       |    88 +
 internal/database/ent/db/clan_query.go        |   605 +
 internal/database/ent/db/clan_update.go       |   591 +
 internal/database/ent/db/client.go            |  2416 ++++
 internal/database/ent/db/crontask.go          |   212 +
 internal/database/ent/db/crontask/crontask.go |   121 +
 internal/database/ent/db/crontask/where.go    |   468 +
 internal/database/ent/db/crontask_create.go   |   369 +
 internal/database/ent/db/crontask_delete.go   |    88 +
 internal/database/ent/db/crontask_query.go    |   526 +
 internal/database/ent/db/crontask_update.go   |   587 +
 internal/database/ent/db/ent.go               |   634 +
 internal/database/ent/db/enttest/enttest.go   |    84 +
 internal/database/ent/db/hook/hook.go         |   355 +
 internal/database/ent/db/migrate/migrate.go   |    96 +
 internal/database/ent/db/migrate/schema.go    |   524 +
 internal/database/ent/db/mutation.go          | 11540 ++++++++++++++++
 .../database/ent/db/predicate/predicate.go    |    49 +
 internal/database/ent/db/runtime.go           |   363 +
 internal/database/ent/db/runtime/runtime.go   |    10 +
 internal/database/ent/db/tx.go                |   249 +
 internal/database/ent/db/user.go              |   199 +
 internal/database/ent/db/user/user.go         |   168 +
 internal/database/ent/db/user/where.go        |   318 +
 internal/database/ent/db/user_create.go       |   368 +
 internal/database/ent/db/user_delete.go       |    88 +
 internal/database/ent/db/user_query.go        |   753 +
 internal/database/ent/db/user_update.go       |   813 ++
 internal/database/ent/db/userconnection.go    |   204 +
 .../ent/db/userconnection/userconnection.go   |   140 +
 .../database/ent/db/userconnection/where.go   |   453 +
 .../database/ent/db/userconnection_create.go  |   348 +
 .../database/ent/db/userconnection_delete.go  |    88 +
 .../database/ent/db/userconnection_query.go   |   605 +
 .../database/ent/db/userconnection_update.go  |   420 +
 internal/database/ent/db/usercontent.go       |   206 +
 .../ent/db/usercontent/usercontent.go         |   133 +
 internal/database/ent/db/usercontent/where.go |   363 +
 .../database/ent/db/usercontent_create.go     |   342 +
 .../database/ent/db/usercontent_delete.go     |    88 +
 internal/database/ent/db/usercontent_query.go |   605 +
 .../database/ent/db/usercontent_update.go     |   368 +
 internal/database/ent/db/usersubscription.go  |   199 +
 .../db/usersubscription/usersubscription.go   |   149 +
 .../database/ent/db/usersubscription/where.go |   478 +
 .../ent/db/usersubscription_create.go         |   357 +
 .../ent/db/usersubscription_delete.go         |    88 +
 .../database/ent/db/usersubscription_query.go |   605 +
 .../ent/db/usersubscription_update.go         |   440 +
 internal/database/ent/db/vehicle.go           |   141 +
 internal/database/ent/db/vehicle/vehicle.go   |    77 +
 internal/database/ent/db/vehicle/where.go     |   213 +
 internal/database/ent/db/vehicle_create.go    |   268 +
 internal/database/ent/db/vehicle_delete.go    |    88 +
 internal/database/ent/db/vehicle_query.go     |   526 +
 internal/database/ent/db/vehicle_update.go    |   329 +
 internal/database/ent/db/vehicleaverage.go    |   131 +
 .../ent/db/vehicleaverage/vehicleaverage.go   |    67 +
 .../database/ent/db/vehicleaverage/where.go   |   168 +
 .../database/ent/db/vehicleaverage_create.go  |   251 +
 .../database/ent/db/vehicleaverage_delete.go  |    88 +
 .../database/ent/db/vehicleaverage_query.go   |   526 +
 .../database/ent/db/vehicleaverage_update.go  |   250 +
 internal/database/ent/db/vehiclesnapshot.go   |   227 +
 .../ent/db/vehiclesnapshot/vehiclesnapshot.go |   160 +
 .../database/ent/db/vehiclesnapshot/where.go  |   523 +
 .../database/ent/db/vehiclesnapshot_create.go |   384 +
 .../database/ent/db/vehiclesnapshot_delete.go |    88 +
 .../database/ent/db/vehiclesnapshot_query.go  |   605 +
 .../database/ent/db/vehiclesnapshot_update.go |   485 +
 internal/database/ent/generate.go             |     3 +
 internal/database/ent/migrate.go              |    63 +
 internal/database/ent/migrate/main.go         |    40 +
 .../migrations/20240622203812_init.sql        |   102 +
 .../database/ent/migrate/migrations/atlas.sum |     2 +
 internal/database/ent/schema/account.go       |    57 +
 .../database/ent/schema/accountsnapshot.go    |    49 +
 .../ent/schema/achievementssnapshot.go        |    44 +
 .../database/ent/schema/appconfiguration.go   |    33 +
 .../database/ent/schema/applicationcommand.go |    45 +
 internal/database/ent/schema/clan.go          |    65 +
 internal/database/ent/schema/crontask.go      |    43 +
 internal/database/ent/schema/defaults.go      |    24 +
 internal/database/ent/schema/user.go          |    43 +
 .../database/ent/schema/userconnection.go     |    64 +
 internal/database/ent/schema/usercontent.go   |    43 +
 .../database/ent/schema/usersubscription.go   |    43 +
 internal/database/ent/schema/vehicle.go       |    41 +
 .../database/ent/schema/vehicleaverage.go     |    38 +
 .../database/ent/schema/vehiclesnapshot.go    |    47 +
 internal/database/errors.go                   |     7 +
 internal/database/models/account.go           |    16 +
 internal/database/models/account_snapshot.go  |    18 +
 .../database/models/application_command.go    |     8 +
 internal/database/models/task.go              |   139 +
 internal/database/models/user.go              |    30 +
 internal/database/models/user_connection.go   |    32 +
 internal/database/models/user_subscription.go |   106 +
 internal/database/models/vehicle.go           |    23 +
 internal/database/models/vehicle_snapshot.go  |    40 +
 internal/database/prisma/db/.gitignore        |     2 -
 .../20240608224040_init/migration.sql         |   210 -
 .../migration.sql                             |    48 -
 .../20240612202803_sessions/migration.sql     |    50 -
 .../migration.sql                             |    11 -
 .../20240614000247_added_index/migration.sql  |     2 -
 .../20240614002652_added_name/migration.sql   |    22 -
 .../prisma/migrations/migration_lock.toml     |     3 -
 internal/database/prisma/schema.prisma        |   398 -
 internal/database/snapshots.go                |   693 +-
 internal/database/snapshots_test.go           |   206 +-
 internal/database/tasks.go                    |   417 +-
 internal/database/users.go                    |   356 +-
 internal/database/vehicles.go                 |   139 +-
 internal/logic/sessions.go                    |    31 +-
 internal/stats/fetch/client.go                |     6 +-
 internal/stats/fetch/convert.go               |     6 +-
 internal/stats/fetch/multisource.go           |    25 +-
 internal/stats/prepare/common/card.go         |     6 +-
 internal/stats/prepare/period/card.go         |     6 +-
 internal/stats/prepare/period/preset.go       |     4 +-
 internal/stats/prepare/session/card.go        |    10 +-
 internal/stats/render/common/badges.go        |    48 +-
 internal/stats/render/common/header.go        |     6 +-
 internal/stats/render/common/player_title.go  |     6 +-
 .../stats/render/common/tier_percentage.go    |     4 +-
 internal/stats/render/period/cards.go         |     4 +-
 internal/stats/render/period/image.go         |     4 +-
 internal/stats/render/session/cards.go        |     4 +-
 internal/stats/render/session/image.go        |     4 +-
 internal/stats/session.go                     |     4 +-
 main.go                                       |    12 +-
 197 files changed, 50758 insertions(+), 2304 deletions(-)
 create mode 100644 internal/database/ent/db/account.go
 create mode 100644 internal/database/ent/db/account/account.go
 create mode 100644 internal/database/ent/db/account/where.go
 create mode 100644 internal/database/ent/db/account_create.go
 create mode 100644 internal/database/ent/db/account_delete.go
 create mode 100644 internal/database/ent/db/account_query.go
 create mode 100644 internal/database/ent/db/account_update.go
 create mode 100644 internal/database/ent/db/accountsnapshot.go
 create mode 100644 internal/database/ent/db/accountsnapshot/accountsnapshot.go
 create mode 100644 internal/database/ent/db/accountsnapshot/where.go
 create mode 100644 internal/database/ent/db/accountsnapshot_create.go
 create mode 100644 internal/database/ent/db/accountsnapshot_delete.go
 create mode 100644 internal/database/ent/db/accountsnapshot_query.go
 create mode 100644 internal/database/ent/db/accountsnapshot_update.go
 create mode 100644 internal/database/ent/db/achievementssnapshot.go
 create mode 100644 internal/database/ent/db/achievementssnapshot/achievementssnapshot.go
 create mode 100644 internal/database/ent/db/achievementssnapshot/where.go
 create mode 100644 internal/database/ent/db/achievementssnapshot_create.go
 create mode 100644 internal/database/ent/db/achievementssnapshot_delete.go
 create mode 100644 internal/database/ent/db/achievementssnapshot_query.go
 create mode 100644 internal/database/ent/db/achievementssnapshot_update.go
 create mode 100644 internal/database/ent/db/appconfiguration.go
 create mode 100644 internal/database/ent/db/appconfiguration/appconfiguration.go
 create mode 100644 internal/database/ent/db/appconfiguration/where.go
 create mode 100644 internal/database/ent/db/appconfiguration_create.go
 create mode 100644 internal/database/ent/db/appconfiguration_delete.go
 create mode 100644 internal/database/ent/db/appconfiguration_query.go
 create mode 100644 internal/database/ent/db/appconfiguration_update.go
 create mode 100644 internal/database/ent/db/applicationcommand.go
 create mode 100644 internal/database/ent/db/applicationcommand/applicationcommand.go
 create mode 100644 internal/database/ent/db/applicationcommand/where.go
 create mode 100644 internal/database/ent/db/applicationcommand_create.go
 create mode 100644 internal/database/ent/db/applicationcommand_delete.go
 create mode 100644 internal/database/ent/db/applicationcommand_query.go
 create mode 100644 internal/database/ent/db/applicationcommand_update.go
 create mode 100644 internal/database/ent/db/clan.go
 create mode 100644 internal/database/ent/db/clan/clan.go
 create mode 100644 internal/database/ent/db/clan/where.go
 create mode 100644 internal/database/ent/db/clan_create.go
 create mode 100644 internal/database/ent/db/clan_delete.go
 create mode 100644 internal/database/ent/db/clan_query.go
 create mode 100644 internal/database/ent/db/clan_update.go
 create mode 100644 internal/database/ent/db/client.go
 create mode 100644 internal/database/ent/db/crontask.go
 create mode 100644 internal/database/ent/db/crontask/crontask.go
 create mode 100644 internal/database/ent/db/crontask/where.go
 create mode 100644 internal/database/ent/db/crontask_create.go
 create mode 100644 internal/database/ent/db/crontask_delete.go
 create mode 100644 internal/database/ent/db/crontask_query.go
 create mode 100644 internal/database/ent/db/crontask_update.go
 create mode 100644 internal/database/ent/db/ent.go
 create mode 100644 internal/database/ent/db/enttest/enttest.go
 create mode 100644 internal/database/ent/db/hook/hook.go
 create mode 100644 internal/database/ent/db/migrate/migrate.go
 create mode 100644 internal/database/ent/db/migrate/schema.go
 create mode 100644 internal/database/ent/db/mutation.go
 create mode 100644 internal/database/ent/db/predicate/predicate.go
 create mode 100644 internal/database/ent/db/runtime.go
 create mode 100644 internal/database/ent/db/runtime/runtime.go
 create mode 100644 internal/database/ent/db/tx.go
 create mode 100644 internal/database/ent/db/user.go
 create mode 100644 internal/database/ent/db/user/user.go
 create mode 100644 internal/database/ent/db/user/where.go
 create mode 100644 internal/database/ent/db/user_create.go
 create mode 100644 internal/database/ent/db/user_delete.go
 create mode 100644 internal/database/ent/db/user_query.go
 create mode 100644 internal/database/ent/db/user_update.go
 create mode 100644 internal/database/ent/db/userconnection.go
 create mode 100644 internal/database/ent/db/userconnection/userconnection.go
 create mode 100644 internal/database/ent/db/userconnection/where.go
 create mode 100644 internal/database/ent/db/userconnection_create.go
 create mode 100644 internal/database/ent/db/userconnection_delete.go
 create mode 100644 internal/database/ent/db/userconnection_query.go
 create mode 100644 internal/database/ent/db/userconnection_update.go
 create mode 100644 internal/database/ent/db/usercontent.go
 create mode 100644 internal/database/ent/db/usercontent/usercontent.go
 create mode 100644 internal/database/ent/db/usercontent/where.go
 create mode 100644 internal/database/ent/db/usercontent_create.go
 create mode 100644 internal/database/ent/db/usercontent_delete.go
 create mode 100644 internal/database/ent/db/usercontent_query.go
 create mode 100644 internal/database/ent/db/usercontent_update.go
 create mode 100644 internal/database/ent/db/usersubscription.go
 create mode 100644 internal/database/ent/db/usersubscription/usersubscription.go
 create mode 100644 internal/database/ent/db/usersubscription/where.go
 create mode 100644 internal/database/ent/db/usersubscription_create.go
 create mode 100644 internal/database/ent/db/usersubscription_delete.go
 create mode 100644 internal/database/ent/db/usersubscription_query.go
 create mode 100644 internal/database/ent/db/usersubscription_update.go
 create mode 100644 internal/database/ent/db/vehicle.go
 create mode 100644 internal/database/ent/db/vehicle/vehicle.go
 create mode 100644 internal/database/ent/db/vehicle/where.go
 create mode 100644 internal/database/ent/db/vehicle_create.go
 create mode 100644 internal/database/ent/db/vehicle_delete.go
 create mode 100644 internal/database/ent/db/vehicle_query.go
 create mode 100644 internal/database/ent/db/vehicle_update.go
 create mode 100644 internal/database/ent/db/vehicleaverage.go
 create mode 100644 internal/database/ent/db/vehicleaverage/vehicleaverage.go
 create mode 100644 internal/database/ent/db/vehicleaverage/where.go
 create mode 100644 internal/database/ent/db/vehicleaverage_create.go
 create mode 100644 internal/database/ent/db/vehicleaverage_delete.go
 create mode 100644 internal/database/ent/db/vehicleaverage_query.go
 create mode 100644 internal/database/ent/db/vehicleaverage_update.go
 create mode 100644 internal/database/ent/db/vehiclesnapshot.go
 create mode 100644 internal/database/ent/db/vehiclesnapshot/vehiclesnapshot.go
 create mode 100644 internal/database/ent/db/vehiclesnapshot/where.go
 create mode 100644 internal/database/ent/db/vehiclesnapshot_create.go
 create mode 100644 internal/database/ent/db/vehiclesnapshot_delete.go
 create mode 100644 internal/database/ent/db/vehiclesnapshot_query.go
 create mode 100644 internal/database/ent/db/vehiclesnapshot_update.go
 create mode 100644 internal/database/ent/generate.go
 create mode 100644 internal/database/ent/migrate.go
 create mode 100644 internal/database/ent/migrate/main.go
 create mode 100644 internal/database/ent/migrate/migrations/20240622203812_init.sql
 create mode 100644 internal/database/ent/migrate/migrations/atlas.sum
 create mode 100644 internal/database/ent/schema/account.go
 create mode 100644 internal/database/ent/schema/accountsnapshot.go
 create mode 100644 internal/database/ent/schema/achievementssnapshot.go
 create mode 100644 internal/database/ent/schema/appconfiguration.go
 create mode 100644 internal/database/ent/schema/applicationcommand.go
 create mode 100644 internal/database/ent/schema/clan.go
 create mode 100644 internal/database/ent/schema/crontask.go
 create mode 100644 internal/database/ent/schema/defaults.go
 create mode 100644 internal/database/ent/schema/user.go
 create mode 100644 internal/database/ent/schema/userconnection.go
 create mode 100644 internal/database/ent/schema/usercontent.go
 create mode 100644 internal/database/ent/schema/usersubscription.go
 create mode 100644 internal/database/ent/schema/vehicle.go
 create mode 100644 internal/database/ent/schema/vehicleaverage.go
 create mode 100644 internal/database/ent/schema/vehiclesnapshot.go
 create mode 100644 internal/database/errors.go
 create mode 100644 internal/database/models/account.go
 create mode 100644 internal/database/models/account_snapshot.go
 create mode 100644 internal/database/models/application_command.go
 create mode 100644 internal/database/models/task.go
 create mode 100644 internal/database/models/user.go
 create mode 100644 internal/database/models/user_connection.go
 create mode 100644 internal/database/models/user_subscription.go
 create mode 100644 internal/database/models/vehicle.go
 create mode 100644 internal/database/models/vehicle_snapshot.go
 delete mode 100644 internal/database/prisma/db/.gitignore
 delete mode 100644 internal/database/prisma/migrations/20240608224040_init/migration.sql
 delete mode 100644 internal/database/prisma/migrations/20240611180703_added_snapshots/migration.sql
 delete mode 100644 internal/database/prisma/migrations/20240612202803_sessions/migration.sql
 delete mode 100644 internal/database/prisma/migrations/20240614000132_added_app_commands/migration.sql
 delete mode 100644 internal/database/prisma/migrations/20240614000247_added_index/migration.sql
 delete mode 100644 internal/database/prisma/migrations/20240614002652_added_name/migration.sql
 delete mode 100644 internal/database/prisma/migrations/migration_lock.toml
 delete mode 100644 internal/database/prisma/schema.prisma

diff --git a/.env.example b/.env.example
index 6c94cc36..d205038b 100644
--- a/.env.example
+++ b/.env.example
@@ -1,11 +1,15 @@
+# Atlas is currently broken for libsql
+# You need to clone and build https://github.com/Cufee/atlas-libsql
+ATLAS_TEMP_DIR="path/to/atlas-libsql/cmd/atlas/binary"
+
 # This is not required for local deployment. When deploying with Dokploy, this is the domain aftermath service will be available on.
 TRAEFIK_HOST="local.amth.one"
 
-# Database configuration for compose
-DATABASE_NAME="dev_local.db"
-DATABASE_DIR="/tmp"
-# This should be an absolute path, otherwise prisma fails to run correctly. This variable is only used when developing locally or deploying without Compose.
-DATABASE_URL="file:/tmp/dev_local.db"
+# Path for a bind volume when running with compose
+DATABASE_DIR="tmp/"
+# URL to a libsql instance
+# https://github.com/tursodatabase/libsql/blob/main/docs/DOCKER.md
+DATABASE_URL="libsql://0.0.0.0:8080"
 
 # Init
 INIT_GLOBAL_ADMIN_USER="" # Discord user ID for a user who will be assigned permissions.GlobalAdmin on startup, can be left blank
diff --git a/Dockerfile b/Dockerfile
index 990393ba..ddcfd59f 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -6,9 +6,6 @@ WORKDIR /workspace
 COPY go.mod go.sum ./
 RUN go mod download
 
-# prefetch the binaries, so that they will be cached and not downloaded on each change
-RUN go run github.com/steebchen/prisma-client-go prefetch
-
 COPY ./ ./
 # generate the Prisma Client Go client
 RUN go generate ./...
diff --git a/Dockerfile.migrate b/Dockerfile.migrate
index 3764f1af..16909e31 100644
--- a/Dockerfile.migrate
+++ b/Dockerfile.migrate
@@ -1,17 +1,14 @@
-FROM golang:1.22.3-alpine
+FROM golang:1.22.3-bookworm
 
 WORKDIR /migrate
 
 # copy migrations and schema
-COPY ./internal/database/prisma/migrations /prisma/migrations
-COPY ./internal/database/prisma/schema.prisma /prisma/schema.prisma
+COPY ./internal/database/ent/migrate/migrations /migrations
 
-# copy go.mod
-COPY ./go.mod /go.mod
-COPY ./go.sum /go.sum
+RUN git clone https://github.com/Cufee/atlas-libsql.git
+WORKDIR /migrate/atlas-libsql/cmd/atlas
+RUN go mod download
+RUN go generate ./...
+RUN CGO_ENABLED=1 GOOS=linux go build -o /bin/atlas
 
-# install prisma and prefetch binaries
-RUN go install github.com/steebchen/prisma-client-go@latest
-RUN go run github.com/steebchen/prisma-client-go prefetch
-
-ENTRYPOINT ["sh", "-c", "go run github.com/steebchen/prisma-client-go migrate deploy --schema /prisma/schema.prisma"]
+ENTRYPOINT ["sh", "-c", 'atlas migrate apply --allow-dirty --dir "file:///migrations" --tx-mode all --url "libsql+ws://0.0.0.0:8080']
diff --git a/Taskfile.yaml b/Taskfile.yaml
index 8f01f48b..8cbe17a8 100644
--- a/Taskfile.yaml
+++ b/Taskfile.yaml
@@ -4,14 +4,12 @@ dotenv:
   - ".env"
 
 vars:
-  PRISMA_CLIENT: github.com/steebchen/prisma-client-go@v0.37.0
-  PRISMA_SCHEMA: --schema ./internal/database/prisma/schema.prisma
+  ENT_CMD: go run -mod=mod entgo.io/ent/cmd/ent
+  ENT_DIRECTORY: internal/database/ent/schema
 
 tasks:
   test:
     desc: runs tests
-    env:
-      DATABASE_URL: "file:{{.USER_WORKING_DIR}}/tmp/local_test.db"
     cmds:
       - go run {{ .PRISMA_CLIENT }} db push {{ .PRISMA_SCHEMA }}
       - |
@@ -21,33 +19,22 @@ tasks:
           go test -timeout 30s --count=1 -v -run {{ .CLI_ARGS }}
         fi
 
-  prisma-install:
-    desc: installs the correct version of prisma
-    cmd: go get {{ .PRISMA_CLIENT }}
+  ent-new:
+    desc: init a new schema with a given name
+    cmd: '{{.ENT_CMD}} new --target {{.ENT_DIRECTORY}} {{.CLI_ARGS}}'
 
-  prisma:
-    desc: run a custom prisma command by adding `-- some command` to this task
-    cmd: go run {{ .PRISMA_CLIENT }} {{ .PRISMA_SCHEMA }} {{ .CLI_ARGS }}
+  ent-generate:
+    desc: generate go code for the ent schema directory
+    cmd: go generate internal/database/ent
 
-  db-push:
-    desc: sync the database with the schema for development
-    cmd: go run {{ .PRISMA_CLIENT }} db push {{ .PRISMA_SCHEMA }}
-
-  db-generate:
-    desc: re-generate the Go client
-    cmd: go run {{ .PRISMA_CLIENT }} generate {{ .PRISMA_SCHEMA }}
-
-  db-migrate-dev:
-    desc: for production use, create a migration locally
-    cmd: go run {{ .PRISMA_CLIENT }} migrate dev {{ .PRISMA_SCHEMA }}
-
-  db-migrate-deploy:
-    desc: sync production database with migrations
-    cmd: go run {{ .PRISMA_CLIENT }} migrate deploy {{ .PRISMA_SCHEMA }}
+  db-migrate:
+    desc: generate migrations
+    cmd: atlas migrate diff init --dir "file://internal/database/ent/migrate/migrations" --to "ent://internal/database/ent/schema" --dev-url "sqlite://tmp/file?mode=memory&_fk=1"
+  db-migrate-apply:
+    desc: apply migrations using atlas
+    cmd: ${ATLAS_TEMP_DIR} migrate apply --allow-dirty --dir "file://internal/database/ent/migrate/migrations" --tx-mode all --url "libsql+ws://0.0.0.0:8080"
 
   dev:
     desc: Start a local dev server
-    deps:
-      - db-push
     cmds:
       - air
diff --git a/cmds/core/scheduler/glossary.go b/cmds/core/scheduler/glossary.go
index b6961d73..89f5d23e 100644
--- a/cmds/core/scheduler/glossary.go
+++ b/cmds/core/scheduler/glossary.go
@@ -5,7 +5,7 @@ import (
 	"time"
 
 	"github.com/cufee/aftermath/cmds/core"
-	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/rs/zerolog/log"
 	"golang.org/x/text/language"
 )
@@ -48,9 +48,9 @@ func UpdateGlossaryWorker(client core.Client) func() {
 			return
 		}
 
-		vehicles := make(map[string]database.Vehicle)
+		vehicles := make(map[string]models.Vehicle)
 		for id, data := range glossary {
-			vehicles[id] = database.Vehicle{
+			vehicles[id] = models.Vehicle{
 				ID:   id,
 				Tier: data.Tier,
 				Type: data.Type,
diff --git a/cmds/core/scheduler/queue.go b/cmds/core/scheduler/queue.go
index faf92a8a..d0bd8c8d 100644
--- a/cmds/core/scheduler/queue.go
+++ b/cmds/core/scheduler/queue.go
@@ -7,7 +7,7 @@ import (
 
 	"github.com/cufee/aftermath/cmds/core"
 	"github.com/cufee/aftermath/cmds/core/scheduler/tasks"
-	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/rs/zerolog/log"
 )
 
@@ -16,7 +16,7 @@ type Queue struct {
 	concurrencyLimit int
 	lastTaskRun      time.Time
 
-	handlers map[database.TaskType]tasks.TaskHandler
+	handlers map[models.TaskType]tasks.TaskHandler
 	core     core.Client
 }
 
@@ -32,7 +32,7 @@ func (q *Queue) LastTaskRun() time.Time {
 	return q.lastTaskRun
 }
 
-func NewQueue(client core.Client, handlers map[database.TaskType]tasks.TaskHandler, concurrencyLimit int) *Queue {
+func NewQueue(client core.Client, handlers map[models.TaskType]tasks.TaskHandler, concurrencyLimit int) *Queue {
 	return &Queue{
 		core:             client,
 		handlers:         handlers,
@@ -41,7 +41,7 @@ func NewQueue(client core.Client, handlers map[database.TaskType]tasks.TaskHandl
 	}
 }
 
-func (q *Queue) Process(callback func(error), tasks ...database.Task) {
+func (q *Queue) Process(callback func(error), tasks ...models.Task) {
 	var err error
 	if callback != nil {
 		defer callback(err)
@@ -55,10 +55,10 @@ func (q *Queue) Process(callback func(error), tasks ...database.Task) {
 
 	var wg sync.WaitGroup
 	q.lastTaskRun = time.Now()
-	processedTasks := make(chan database.Task, len(tasks))
+	processedTasks := make(chan models.Task, len(tasks))
 	for _, task := range tasks {
 		wg.Add(1)
-		go func(t database.Task) {
+		go func(t models.Task) {
 			q.limiter <- struct{}{}
 			defer func() {
 				processedTasks <- t
@@ -70,8 +70,8 @@ func (q *Queue) Process(callback func(error), tasks ...database.Task) {
 
 			handler, ok := q.handlers[t.Type]
 			if !ok {
-				t.Status = database.TaskStatusFailed
-				t.LogAttempt(database.TaskLog{
+				t.Status = models.TaskStatusFailed
+				t.LogAttempt(models.TaskLog{
 					Targets:   t.Targets,
 					Timestamp: time.Now(),
 					Error:     "missing task type handler",
@@ -80,7 +80,7 @@ func (q *Queue) Process(callback func(error), tasks ...database.Task) {
 			}
 			t.LastRun = time.Now()
 
-			attempt := database.TaskLog{
+			attempt := models.TaskLog{
 				Targets:   t.Targets,
 				Timestamp: time.Now(),
 			}
@@ -89,9 +89,9 @@ func (q *Queue) Process(callback func(error), tasks ...database.Task) {
 			attempt.Comment = message
 			if err != nil {
 				attempt.Error = err.Error()
-				t.Status = database.TaskStatusFailed
+				t.Status = models.TaskStatusFailed
 			} else {
-				t.Status = database.TaskStatusComplete
+				t.Status = models.TaskStatusComplete
 			}
 			t.LogAttempt(attempt)
 		}(task)
@@ -101,16 +101,16 @@ func (q *Queue) Process(callback func(error), tasks ...database.Task) {
 	close(processedTasks)
 
 	rescheduledCount := 0
-	processedSlice := make([]database.Task, 0, len(processedTasks))
+	processedSlice := make([]models.Task, 0, len(processedTasks))
 	for task := range processedTasks {
 		handler, ok := q.handlers[task.Type]
 		if !ok {
 			continue
 		}
 
-		if task.Status == database.TaskStatusFailed && handler.ShouldRetry(&task) {
+		if task.Status == models.TaskStatusFailed && handler.ShouldRetry(&task) {
 			rescheduledCount++
-			task.Status = database.TaskStatusScheduled
+			task.Status = models.TaskStatusScheduled
 		}
 		processedSlice = append(processedSlice, task)
 	}
diff --git a/cmds/core/scheduler/tasks/cleanup.go b/cmds/core/scheduler/tasks/cleanup.go
index b753c59d..18b28de1 100644
--- a/cmds/core/scheduler/tasks/cleanup.go
+++ b/cmds/core/scheduler/tasks/cleanup.go
@@ -7,12 +7,12 @@ import (
 	"github.com/pkg/errors"
 
 	"github.com/cufee/aftermath/cmds/core"
-	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/models"
 )
 
 func init() {
-	defaultHandlers[database.TaskTypeDatabaseCleanup] = TaskHandler{
-		Process: func(client core.Client, task database.Task) (string, error) {
+	defaultHandlers[models.TaskTypeDatabaseCleanup] = TaskHandler{
+		Process: func(client core.Client, task models.Task) (string, error) {
 			if task.Data == nil {
 				return "no data provided", errors.New("no data provided")
 			}
@@ -41,7 +41,7 @@ func init() {
 
 			return "cleanup complete", nil
 		},
-		ShouldRetry: func(task *database.Task) bool {
+		ShouldRetry: func(task *models.Task) bool {
 			return false
 		},
 	}
@@ -50,8 +50,8 @@ func init() {
 func CreateCleanupTasks(client core.Client) error {
 	now := time.Now()
 
-	task := database.Task{
-		Type:           database.TaskTypeDatabaseCleanup,
+	task := models.Task{
+		Type:           models.TaskTypeDatabaseCleanup,
 		ReferenceID:    "database_cleanup",
 		ScheduledAfter: now,
 		Data: map[string]any{
diff --git a/cmds/core/scheduler/tasks/handler.go b/cmds/core/scheduler/tasks/handler.go
index fa3d0e6d..11e49bb1 100644
--- a/cmds/core/scheduler/tasks/handler.go
+++ b/cmds/core/scheduler/tasks/handler.go
@@ -2,16 +2,16 @@ package tasks
 
 import (
 	"github.com/cufee/aftermath/cmds/core"
-	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/models"
 )
 
 type TaskHandler struct {
-	Process     func(client core.Client, task database.Task) (string, error)
-	ShouldRetry func(task *database.Task) bool
+	Process     func(client core.Client, task models.Task) (string, error)
+	ShouldRetry func(task *models.Task) bool
 }
 
-var defaultHandlers = make(map[database.TaskType]TaskHandler)
+var defaultHandlers = make(map[models.TaskType]TaskHandler)
 
-func DefaultHandlers() map[database.TaskType]TaskHandler {
+func DefaultHandlers() map[models.TaskType]TaskHandler {
 	return defaultHandlers
 }
diff --git a/cmds/core/scheduler/tasks/sessions.go b/cmds/core/scheduler/tasks/sessions.go
index 8e430cce..93ea0273 100644
--- a/cmds/core/scheduler/tasks/sessions.go
+++ b/cmds/core/scheduler/tasks/sessions.go
@@ -8,14 +8,14 @@ import (
 	"github.com/pkg/errors"
 
 	"github.com/cufee/aftermath/cmds/core"
-	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/logic"
 	"github.com/rs/zerolog/log"
 )
 
 func init() {
-	defaultHandlers[database.TaskTypeRecordSessions] = TaskHandler{
-		Process: func(client core.Client, task database.Task) (string, error) {
+	defaultHandlers[models.TaskTypeRecordSessions] = TaskHandler{
+		Process: func(client core.Client, task models.Task) (string, error) {
 			if task.Data == nil {
 				return "no data provided", errors.New("no data provided")
 			}
@@ -55,7 +55,7 @@ func init() {
 			}
 			return "retrying failed accounts", errors.New("some accounts failed")
 		},
-		ShouldRetry: func(task *database.Task) bool {
+		ShouldRetry: func(task *models.Task) bool {
 			triesLeft, ok := task.Data["triesLeft"].(int)
 			if !ok {
 				return false
@@ -74,8 +74,8 @@ func init() {
 
 func CreateSessionUpdateTasks(client core.Client, realm string) error {
 	realm = strings.ToUpper(realm)
-	task := database.Task{
-		Type:           database.TaskTypeRecordSessions,
+	task := models.Task{
+		Type:           models.TaskTypeRecordSessions,
 		ReferenceID:    "realm_" + realm,
 		ScheduledAfter: time.Now(),
 		Data: map[string]any{
@@ -87,16 +87,14 @@ func CreateSessionUpdateTasks(client core.Client, realm string) error {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
 
-	accounts, err := client.Database().GetRealmAccounts(ctx, realm)
+	accounts, err := client.Database().GetRealmAccountIDs(ctx, realm)
 	if err != nil {
 		return err
 	}
 	if len(accounts) < 1 {
 		return nil
 	}
-	for _, account := range accounts {
-		task.Targets = append(task.Targets, account.ID)
-	}
+	task.Targets = append(task.Targets, accounts...)
 
 	// This update requires (2 + n) requests per n players
 	return client.Database().CreateTasks(ctx, splitTaskByTargets(task, 90)...)
diff --git a/cmds/core/scheduler/tasks/split.go b/cmds/core/scheduler/tasks/split.go
index 38a9df21..1414d306 100644
--- a/cmds/core/scheduler/tasks/split.go
+++ b/cmds/core/scheduler/tasks/split.go
@@ -1,13 +1,13 @@
 package tasks
 
-import "github.com/cufee/aftermath/internal/database"
+import "github.com/cufee/aftermath/internal/database/models"
 
-func splitTaskByTargets(task database.Task, batchSize int) []database.Task {
+func splitTaskByTargets(task models.Task, batchSize int) []models.Task {
 	if len(task.Targets) <= batchSize {
-		return []database.Task{task}
+		return []models.Task{task}
 	}
 
-	var tasks []database.Task
+	var tasks []models.Task
 	subTasks := len(task.Targets) / batchSize
 
 	for i := 0; i <= subTasks; i++ {
diff --git a/cmds/core/scheduler/workers.go b/cmds/core/scheduler/workers.go
index c23f2f78..683027be 100644
--- a/cmds/core/scheduler/workers.go
+++ b/cmds/core/scheduler/workers.go
@@ -6,7 +6,7 @@ import (
 
 	"github.com/cufee/aftermath/cmds/core"
 	"github.com/cufee/aftermath/cmds/core/scheduler/tasks"
-	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/rs/zerolog/log"
 )
 
@@ -28,7 +28,7 @@ func RotateBackgroundPresetsWorker(client core.Client) func() {
 		// 	log.Err(err).Msg("failed to pick random background images")
 		// 	return
 		// }
-		// err = database.UpdateAppConfiguration[[]string]("backgroundImagesSelection", images, nil, true)
+		// err = models.UpdateAppConfiguration[[]string]("backgroundImagesSelection", images, nil, true)
 		// if err != nil {
 		// 	log.Err(err).Msg("failed to update background images selection")
 		// }
@@ -92,7 +92,7 @@ func RestartTasksWorker(queue *Queue) func() {
 
 		now := time.Now()
 		for i, task := range staleTasks {
-			task.Status = database.TaskStatusScheduled
+			task.Status = models.TaskStatusScheduled
 			task.ScheduledAfter = now
 			staleTasks[i] = task
 		}
diff --git a/cmds/core/server/handlers/private/accounts.go b/cmds/core/server/handlers/private/accounts.go
index ab8f0547..2afb639b 100644
--- a/cmds/core/server/handlers/private/accounts.go
+++ b/cmds/core/server/handlers/private/accounts.go
@@ -9,7 +9,7 @@ import (
 	"sync"
 
 	"github.com/cufee/aftermath/cmds/core"
-	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/stats/fetch"
 	"github.com/cufee/am-wg-proxy-next/v2/types"
 	"github.com/rs/zerolog/log"
@@ -91,7 +91,7 @@ func LoadAccountsHandler(client core.Client) http.HandlerFunc {
 							return
 						}
 
-						var inserts []database.Account
+						var inserts []models.Account
 						for _, account := range data {
 							inserts = append(inserts, fetch.WargamingToAccount(realm, account, types.ClanMember{}, false))
 						}
diff --git a/cmds/discord/commands/link.go b/cmds/discord/commands/link.go
index 0eb0c5d2..ea4c873b 100644
--- a/cmds/discord/commands/link.go
+++ b/cmds/discord/commands/link.go
@@ -7,7 +7,7 @@ import (
 	"github.com/bwmarrin/discordgo"
 	"github.com/cufee/aftermath/cmds/discord/commands/builder"
 	"github.com/cufee/aftermath/cmds/discord/common"
-	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/models"
 )
 
 func init() {
@@ -49,11 +49,11 @@ func init() {
 					return ctx.Err(err)
 				}
 
-				currentConnection, exists := ctx.User.Connection(database.ConnectionTypeWargaming)
+				currentConnection, exists := ctx.User.Connection(models.ConnectionTypeWargaming)
 				if !exists {
 					currentConnection.UserID = ctx.User.ID
 					currentConnection.Metadata = make(map[string]any)
-					currentConnection.Type = database.ConnectionTypeWargaming
+					currentConnection.Type = models.ConnectionTypeWargaming
 				}
 
 				currentConnection.Metadata["verified"] = false
diff --git a/cmds/discord/commands/manage.go b/cmds/discord/commands/manage.go
index 97f2aa4b..34f9d6a6 100644
--- a/cmds/discord/commands/manage.go
+++ b/cmds/discord/commands/manage.go
@@ -9,6 +9,7 @@ import (
 	"github.com/cufee/aftermath/cmds/discord/common"
 	"github.com/cufee/aftermath/cmds/discord/middleware"
 	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/permissions"
 )
 
@@ -31,9 +32,9 @@ func init() {
 				builder.NewOption("tasks", discordgo.ApplicationCommandOptionSubCommandGroup).Options(
 					builder.NewOption("view", discordgo.ApplicationCommandOptionSubCommand).Options(
 						builder.NewOption("status", discordgo.ApplicationCommandOptionString).Choices(
-							builder.NewChoice("failed", string(database.TaskStatusFailed)),
-							builder.NewChoice("complete", string(database.TaskStatusComplete)),
-							builder.NewChoice("in-progress", string(database.TaskStatusInProgress)),
+							builder.NewChoice("failed", string(models.TaskStatusFailed)),
+							builder.NewChoice("complete", string(models.TaskStatusComplete)),
+							builder.NewChoice("in-progress", string(models.TaskStatusInProgress)),
 						).Required(),
 						builder.NewOption("hours", discordgo.ApplicationCommandOptionNumber).Required(),
 					),
@@ -110,7 +111,7 @@ func init() {
 						hours = 1
 					}
 
-					tasks, err := ctx.Core.Database().GetRecentTasks(ctx.Context, time.Now().Add(time.Hour*time.Duration(hours)*-1), database.TaskStatus(status))
+					tasks, err := ctx.Core.Database().GetRecentTasks(ctx.Context, time.Now().Add(time.Hour*time.Duration(hours)*-1), models.TaskStatus(status))
 					if err != nil {
 						return ctx.Reply("Database#GetRecentTasks: " + err.Error())
 					}
diff --git a/cmds/discord/commands/session.go b/cmds/discord/commands/session.go
index 4c11f155..591b7267 100644
--- a/cmds/discord/commands/session.go
+++ b/cmds/discord/commands/session.go
@@ -9,6 +9,7 @@ import (
 	"github.com/cufee/aftermath/cmds/discord/commands/builder"
 	"github.com/cufee/aftermath/cmds/discord/common"
 	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/stats"
 	"github.com/cufee/aftermath/internal/stats/fetch"
 	"github.com/cufee/aftermath/internal/stats/render"
@@ -33,8 +34,8 @@ func init() {
 				switch {
 				case options.UserID != "":
 					// mentioned another user, check if the user has an account linked
-					mentionedUser, _ := ctx.Core.Database().GetUserByID(ctx.Context, options.UserID, database.WithConnections(), database.WithContent())
-					defaultAccount, hasDefaultAccount := mentionedUser.Connection(database.ConnectionTypeWargaming)
+					mentionedUser, _ := ctx.Core.Database().GetUserByID(ctx.Context, options.UserID, database.WithConnections(), database.WithSubscriptions(), database.WithContent())
+					defaultAccount, hasDefaultAccount := mentionedUser.Connection(models.ConnectionTypeWargaming)
 					if !hasDefaultAccount {
 						return ctx.Reply("stats_error_connection_not_found_vague")
 					}
@@ -53,7 +54,7 @@ func init() {
 					accountID = fmt.Sprint(account.ID)
 
 				default:
-					defaultAccount, hasDefaultAccount := ctx.User.Connection(database.ConnectionTypeWargaming)
+					defaultAccount, hasDefaultAccount := ctx.User.Connection(models.ConnectionTypeWargaming)
 					if !hasDefaultAccount {
 						return ctx.Reply("stats_error_nickname_or_server_missing")
 					}
diff --git a/cmds/discord/commands/stats.go b/cmds/discord/commands/stats.go
index 9af35d25..70f57879 100644
--- a/cmds/discord/commands/stats.go
+++ b/cmds/discord/commands/stats.go
@@ -9,6 +9,7 @@ import (
 	"github.com/cufee/aftermath/cmds/discord/commands/builder"
 	"github.com/cufee/aftermath/cmds/discord/common"
 	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/stats/render"
 	"github.com/cufee/aftermath/internal/stats/render/assets"
 )
@@ -30,8 +31,8 @@ func init() {
 				switch {
 				case options.UserID != "":
 					// mentioned another user, check if the user has an account linked
-					mentionedUser, _ := ctx.Core.Database().GetUserByID(ctx.Context, options.UserID, database.WithConnections(), database.WithContent())
-					defaultAccount, hasDefaultAccount := mentionedUser.Connection(database.ConnectionTypeWargaming)
+					mentionedUser, _ := ctx.Core.Database().GetUserByID(ctx.Context, options.UserID, database.WithConnections(), database.WithSubscriptions(), database.WithContent())
+					defaultAccount, hasDefaultAccount := mentionedUser.Connection(models.ConnectionTypeWargaming)
 					if !hasDefaultAccount {
 						return ctx.Reply("stats_error_connection_not_found_vague")
 					}
@@ -50,7 +51,7 @@ func init() {
 					accountID = fmt.Sprint(account.ID)
 
 				default:
-					defaultAccount, hasDefaultAccount := ctx.User.Connection(database.ConnectionTypeWargaming)
+					defaultAccount, hasDefaultAccount := ctx.User.Connection(models.ConnectionTypeWargaming)
 					if !hasDefaultAccount {
 						return ctx.Reply("stats_error_nickname_or_server_missing")
 					}
diff --git a/cmds/discord/common/context.go b/cmds/discord/common/context.go
index 02e6bcf5..4fa0c75d 100644
--- a/cmds/discord/common/context.go
+++ b/cmds/discord/common/context.go
@@ -12,6 +12,7 @@ import (
 	"github.com/cufee/aftermath/cmds/discord/rest"
 
 	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/localization"
 
 	"github.com/rs/zerolog/log"
@@ -28,7 +29,7 @@ const (
 
 type Context struct {
 	context.Context
-	User   database.User
+	User   models.User
 	Member discordgo.User
 
 	Locale   language.Tag
diff --git a/cmds/discord/router/router.go b/cmds/discord/router/router.go
index 12aa0072..ef30be48 100644
--- a/cmds/discord/router/router.go
+++ b/cmds/discord/router/router.go
@@ -9,7 +9,7 @@ import (
 	"github.com/cufee/aftermath/cmds/discord/commands/builder"
 	"github.com/cufee/aftermath/cmds/discord/middleware"
 	"github.com/cufee/aftermath/cmds/discord/rest"
-	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/logic"
 	"github.com/rs/zerolog/log"
 )
@@ -56,7 +56,7 @@ func (r *Router) LoadMiddleware(middleware ...middleware.MiddlewareFunc) {
 type command struct {
 	requested *builder.Command
 	current   *discordgo.ApplicationCommand
-	cached    *database.ApplicationCommand
+	cached    *models.ApplicationCommand
 }
 
 /*
@@ -107,7 +107,7 @@ func (r *Router) UpdateLoadedCommands() error {
 			if err != nil {
 				return err
 			}
-			err = r.core.Database().UpsertCommands(context.Background(), database.ApplicationCommand{ID: command.ID, Name: command.Name, Hash: hash, Version: command.Version})
+			err = r.core.Database().UpsertCommands(context.Background(), models.ApplicationCommand{ID: command.ID, Name: command.Name, Hash: hash, Version: command.Version})
 			if err != nil {
 				return err
 			}
@@ -136,7 +136,7 @@ func (r *Router) UpdateLoadedCommands() error {
 				if err != nil {
 					return err
 				}
-				err = r.core.Database().UpsertCommands(context.Background(), database.ApplicationCommand{ID: command.ID, Name: command.Name, Hash: hash, Version: command.Version})
+				err = r.core.Database().UpsertCommands(context.Background(), models.ApplicationCommand{ID: command.ID, Name: command.Name, Hash: hash, Version: command.Version})
 				if err != nil {
 					return err
 				}
diff --git a/docker-compose.yaml b/docker-compose.yaml
index 6362e4ff..57f25438 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -1,13 +1,26 @@
 services:
-  apply-migrations:
-    image: aftermath-prisma-migrate
-    build:
-      dockerfile: Dockerfile.migrate
+  aftermath-database:
+    image: ghcr.io/tursodatabase/libsql-server:latest
+    platform: linux/amd64
+    restart: always
     environment:
-      - DATABASE_URL=file:/database/${DATABASE_NAME}
+      - SQLD_NODE=primary
     volumes:
-      - ${DATABASE_DIR}:/database
-    command: sh -c "go run github.com/steebchen/prisma-client-go migrate deploy --schema /prisma/schema.prisma"
+      - ${DATABASE_DIR}:/var/lib/sqld
+    networks:
+      - dokploy-network
+    hostname: aftermath-database
+
+  aftermath-migrate:
+    image: aftermath-migrate
+    build:
+      dockerfile: Dockerfile.migrate
+    depends_on:
+      aftermath-database:
+        condition: service_started
+    command: sh -c 'migrate apply --allow-dirty --dir "file:///migrations" --tx-mode all --url "libsql+ws://aftermath-database:8080"'
+    networks:
+      - dokploy-network
 
   aftermath-service:
     image: aftermath-service
@@ -17,11 +30,11 @@ services:
       - .env
     environment:
       - PORT=3000
-      - DATABASE_URL=file:/database/${DATABASE_NAME}
-    volumes:
-      - ${DATABASE_DIR}:/database
+      - DATABASE_URL=libsql://aftermath-database:8080
     depends_on:
-      apply-migrations:
+      aftermath-database:
+        condition: service_started
+      aftermath-migrate:
         condition: service_completed_successfully
     entrypoint: ["app"]
     restart: always
@@ -31,11 +44,9 @@ services:
           memory: 128m
         limits:
           memory: 256m
-    ports:
-      - 3000
-      - "${PRIVATE_SERVER_PORT}"
     networks:
       - dokploy-network
+    hostname: aftermath-service
     labels:
       - "traefik.enable=true"
       - "traefik.http.routers.aftermath-monorepo-compose.rule=Host(`${TRAEFIK_HOST}`)"
diff --git a/go.mod b/go.mod
index 6a0e992e..330fc17a 100644
--- a/go.mod
+++ b/go.mod
@@ -3,6 +3,8 @@ module github.com/cufee/aftermath
 go 1.22.3
 
 require (
+	ariga.io/atlas v0.19.1-0.20240203083654-5948b60a8e43
+	entgo.io/ent v0.13.1
 	github.com/bwmarrin/discordgo v0.28.1
 	github.com/cufee/am-wg-proxy-next/v2 v2.1.3
 	github.com/disintegration/imaging v1.6.2
@@ -10,12 +12,12 @@ require (
 	github.com/go-co-op/gocron v1.37.0
 	github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0
 	github.com/joho/godotenv v1.5.1
+	github.com/lucsky/cuid v1.2.1
 	github.com/nlpodyssey/gopickle v0.3.0
 	github.com/pkg/errors v0.9.1
 	github.com/rs/zerolog v1.33.0
-	github.com/shopspring/decimal v1.4.0
-	github.com/steebchen/prisma-client-go v0.37.0
 	github.com/stretchr/testify v1.9.0
+	github.com/tursodatabase/libsql-client-go v0.0.0-20240416075003-747366ff79c4
 	go.dedis.ch/protobuf v1.0.11
 	golang.org/x/exp v0.0.0-20240613232115-7f521ea00fb8
 	golang.org/x/image v0.17.0
@@ -25,14 +27,26 @@ require (
 )
 
 require (
+	github.com/agext/levenshtein v1.2.1 // indirect
+	github.com/antlr4-go/antlr/v4 v4.13.0 // indirect
+	github.com/apparentlymart/go-textseg/v13 v13.0.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/go-openapi/inflect v0.19.0 // indirect
+	github.com/google/go-cmp v0.6.0 // indirect
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/gorilla/websocket v1.5.3 // indirect
+	github.com/hashicorp/hcl/v2 v2.13.0 // indirect
+	github.com/libsql/sqlite-antlr4-parser v0.0.0-20240327125255-dbf53b6cbf06 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/mattn/go-sqlite3 v1.14.22 // indirect
+	github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/robfig/cron/v3 v3.0.1 // indirect
+	github.com/zclconf/go-cty v1.8.0 // indirect
 	go.uber.org/atomic v1.11.0 // indirect
 	golang.org/x/crypto v0.24.0 // indirect
+	golang.org/x/mod v0.18.0 // indirect
 	golang.org/x/sys v0.21.0 // indirect
+	nhooyr.io/websocket v1.8.10 // indirect
 )
diff --git a/go.sum b/go.sum
index fb439afa..24ee26f5 100644
--- a/go.sum
+++ b/go.sum
@@ -1,3 +1,15 @@
+ariga.io/atlas v0.19.1-0.20240203083654-5948b60a8e43 h1:GwdJbXydHCYPedeeLt4x/lrlIISQ4JTH1mRWuE5ZZ14=
+ariga.io/atlas v0.19.1-0.20240203083654-5948b60a8e43/go.mod h1:uj3pm+hUTVN/X5yfdBexHlZv+1Xu5u5ZbZx7+CDavNU=
+entgo.io/ent v0.13.1 h1:uD8QwN1h6SNphdCCzmkMN3feSUzNnVvV/WIkHKMbzOE=
+entgo.io/ent v0.13.1/go.mod h1:qCEmo+biw3ccBn9OyL4ZK5dfpwg++l1Gxwac5B1206A=
+github.com/DATA-DOG/go-sqlmock v1.5.0 h1:Shsta01QNfFxHCfpW6YH2STWB0MudeXXEWMr20OEh60=
+github.com/DATA-DOG/go-sqlmock v1.5.0/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM=
+github.com/agext/levenshtein v1.2.1 h1:QmvMAjj2aEICytGiWzmxoE0x2KZvE0fvmqMOfy2tjT8=
+github.com/agext/levenshtein v1.2.1/go.mod h1:JEDfjyjHDjOF/1e4FlBE/PkbqA9OfWu2ki2W0IB5558=
+github.com/antlr4-go/antlr/v4 v4.13.0 h1:lxCg3LAv+EUK6t1i0y1V6/SLeUi0eKEKdhQAlS8TVTI=
+github.com/antlr4-go/antlr/v4 v4.13.0/go.mod h1:pfChB/xh/Unjila75QW7+VU4TSnWnnk9UTnmpPaOR2g=
+github.com/apparentlymart/go-textseg/v13 v13.0.0 h1:Y+KvPE1NYz0xl601PVImeQfFyEy6iT90AvPUL1NNfNw=
+github.com/apparentlymart/go-textseg/v13 v13.0.0/go.mod h1:ZK2fH7c4NqDTLtiYLvIkEghdlcqw7yxLeM89kiTRPUo=
 github.com/bwmarrin/discordgo v0.28.1 h1:gXsuo2GBO7NbR6uqmrrBDplPUx2T3nzu775q/Rd1aG4=
 github.com/bwmarrin/discordgo v0.28.1/go.mod h1:NJZpH+1AfhIcyQsPeuBKsUtYrRnjkyu0kIVMCHkZtRY=
 github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
@@ -13,15 +25,26 @@ github.com/fogleman/gg v1.3.0 h1:/7zJX8F6AaYQc57WQCyN9cAIz+4bCJGO9B+dyW29am8=
 github.com/fogleman/gg v1.3.0/go.mod h1:R/bRT+9gY/C5z7JzPU0zXsXHKM4/ayA+zqcVNZzPa1k=
 github.com/go-co-op/gocron v1.37.0 h1:ZYDJGtQ4OMhTLKOKMIch+/CY70Brbb1dGdooLEhh7b0=
 github.com/go-co-op/gocron v1.37.0/go.mod h1:3L/n6BkO7ABj+TrfSVXLRzsP26zmikL4ISkLQ0O8iNY=
+github.com/go-openapi/inflect v0.19.0 h1:9jCH9scKIbHeV9m12SmPilScz6krDxKRasNNSNPXu/4=
+github.com/go-openapi/inflect v0.19.0/go.mod h1:lHpZVlpIQqLyKwJ4N+YSc9hchQy/i12fJykb83CRBH4=
+github.com/go-test/deep v1.0.3 h1:ZrJSEWsXzPOxaZnFteGEfooLba+ju3FYIbOrS+rQd68=
+github.com/go-test/deep v1.0.3/go.mod h1:wGDj63lr65AM2AQyKZd/NYHGb0R+1RLqB8NKt3aSFNA=
 github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
 github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 h1:DACJavvAHhabrF08vX0COfcOBJRhZ8lUbR+ZWIs0Y5g=
 github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k=
+github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
+github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/google/uuid v1.4.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
 github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/hashicorp/hcl/v2 v2.13.0 h1:0Apadu1w6M11dyGFxWnmhhcMjkbAiKCv7G1r/2QgCNc=
+github.com/hashicorp/hcl/v2 v2.13.0/go.mod h1:e4z5nxYlWNPdDSNYX+ph14EvWYMFm3eP0zIUqPc2jr0=
 github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
 github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
@@ -32,12 +55,22 @@ github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
+github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
+github.com/libsql/sqlite-antlr4-parser v0.0.0-20240327125255-dbf53b6cbf06 h1:JLvn7D+wXjH9g4Jsjo+VqmzTUpl/LX7vfr6VOfSWTdM=
+github.com/libsql/sqlite-antlr4-parser v0.0.0-20240327125255-dbf53b6cbf06/go.mod h1:FUkZ5OHjlGPjnM2UyGJz9TypXQFgYqw6AFNO1UiROTM=
+github.com/lucsky/cuid v1.2.1 h1:MtJrL2OFhvYufUIn48d35QGXyeTC8tn0upumW9WwTHg=
+github.com/lucsky/cuid v1.2.1/go.mod h1:QaaJqckboimOmhRSJXSx/+IT+VTfxfPGSo/6mfgUfmE=
 github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
 github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
 github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o4kU=
+github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
+github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7 h1:DpOJ2HYzCv8LZP15IdmG+YdwD2luVPHITV96TkirNBM=
+github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7/go.mod h1:ZXFpozHsX6DPmq2I0TCekCxypsnAUbP2oI0UX1GXzOo=
 github.com/nlpodyssey/gopickle v0.3.0 h1:BLUE5gxFLyyNOPzlXxt6GoHEMMxD0qhsE4p0CIQyoLw=
 github.com/nlpodyssey/gopickle v0.3.0/go.mod h1:f070HJ/yR+eLi5WmM1OXJEGaTpuJEUiib19olXgYha0=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
@@ -53,10 +86,8 @@ github.com/rogpeppe/go-internal v1.8.1/go.mod h1:JeRgkft04UBgHMgCIwADu4Pn6Mtm5d4
 github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
 github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8=
 github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
-github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k=
-github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME=
-github.com/steebchen/prisma-client-go v0.37.0 h1:CYfRxUnIsJRlCvPM4Yw2fElB7Y9rC4f2/PPmHliqyTc=
-github.com/steebchen/prisma-client-go v0.37.0/go.mod h1:wp2xU9HO5WIefc65vcl1HOiFUzaHKyOhHw5atrzs8hc=
+github.com/sergi/go-diff v1.0.0 h1:Kpca3qRNrduNnOQeazBd0ysaKrUJiIuISHxogkT9RPQ=
+github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
@@ -66,6 +97,12 @@ github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO
 github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
 github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/tursodatabase/libsql-client-go v0.0.0-20240416075003-747366ff79c4 h1:wNN8t3qiLLzFiETD4jL086WemAgQLfARClUx2Jfk78w=
+github.com/tursodatabase/libsql-client-go v0.0.0-20240416075003-747366ff79c4/go.mod h1:2Fu26tjM011BLeR5+jwTfs6DX/fNMEWV/3CBZvggrA4=
+github.com/vmihailenco/msgpack/v4 v4.3.12/go.mod h1:gborTTJjAo/GWTqqRjrLCn9pgNN+NXzzngzBKDPIqw4=
+github.com/vmihailenco/tagparser v0.1.1/go.mod h1:OeAg3pn3UbLjkWt+rN9oFYB6u/cQgqMEUPoW2WPyhdI=
+github.com/zclconf/go-cty v1.8.0 h1:s4AvqaeQzJIu3ndv4gVIhplVD0krU+bgrcLSVUnaWuA=
+github.com/zclconf/go-cty v1.8.0/go.mod h1:vVKLxnk3puL4qRAv72AO+W99LUD4da90g3uUAzyuvAk=
 go.dedis.ch/fixbuf v1.0.3 h1:hGcV9Cd/znUxlusJ64eAlExS+5cJDIyTyEG+otu5wQs=
 go.dedis.ch/fixbuf v1.0.3/go.mod h1:yzJMt34Wa5xD37V5RTdmp38cz3QhMagdGoem9anUalw=
 go.dedis.ch/kyber/v3 v3.0.4/go.mod h1:OzvaEnPvKlyrWyp3kGXlFdp7ap1VC6RkZDTaPikqhsQ=
@@ -79,6 +116,7 @@ go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
 go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE=
 go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0=
 golang.org/x/crypto v0.0.0-20190123085648-057139ce5d2b/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
 golang.org/x/crypto v0.24.0 h1:mnl8DM0o513X8fdIkmyFE/5hTYxbwYOjDS/+rK6qpRI=
 golang.org/x/crypto v0.24.0/go.mod h1:Z1PMYSOR5nyMcyAVAIQSKCDwalqy85Aqn1x3Ws4L5DM=
@@ -87,10 +125,15 @@ golang.org/x/exp v0.0.0-20240613232115-7f521ea00fb8/go.mod h1:jj3sYF3dwk5D+ghuXy
 golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
 golang.org/x/image v0.17.0 h1:nTRVVdajgB8zCMZVsViyzhnMKPwYeroEERRC64JuLco=
 golang.org/x/image v0.17.0/go.mod h1:4yyo5vMFQjVjUcVk4jEQcU9MGy/rulF5WvUILseCM2E=
+golang.org/x/mod v0.18.0 h1:5+9lSbEzPSdWkH32vYPBwEpX8KwDbM52Ud9xBUvNlb0=
+golang.org/x/mod v0.18.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
+golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
+golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
 golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20190124100055-b90733256f2e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@@ -99,10 +142,13 @@ golang.org/x/sys v0.21.0 h1:rF+pYz3DAGSQAxAu1CbC7catZg4ebC4UIeIhKxBZvws=
 golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
 golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
@@ -111,3 +157,5 @@ gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+nhooyr.io/websocket v1.8.10 h1:mv4p+MnGrLDcPlBoWsvPP7XCzTYMXP9F9eIGoKbgx7Q=
+nhooyr.io/websocket v1.8.10/go.mod h1:rN9OFWIUwuxg4fR5tELlYC04bXYowCP9GX47ivo2l+c=
diff --git a/internal/database/accounts.go b/internal/database/accounts.go
index 98867e6e..79f5a55e 100644
--- a/internal/database/accounts.go
+++ b/internal/database/accounts.go
@@ -2,149 +2,130 @@ package database
 
 import (
 	"context"
-	"sync"
+	"strings"
 	"time"
 
-	"github.com/cufee/aftermath/internal/database/prisma/db"
+	"github.com/cufee/aftermath/internal/database/ent/db"
+	"github.com/cufee/aftermath/internal/database/ent/db/account"
+	"github.com/cufee/aftermath/internal/database/models"
 )
 
-type Account struct {
-	ID       string
-	Realm    string
-	Nickname string
-
-	Private        bool
-	CreatedAt      time.Time
-	LastBattleTime time.Time
-
-	ClanID  string
-	ClanTag string
-}
-
-func (a Account) FromModel(model db.AccountModel) Account {
-	a.ID = model.ID
-	a.Realm = model.Realm
-	a.Nickname = model.Nickname
-	a.Private = model.Private
-	a.CreatedAt = model.CreatedAt
-	a.LastBattleTime = model.LastBattleTime
-	return a
-}
-
-func (a *Account) AddClan(model *db.ClanModel) {
-	a.ClanID = model.ID
-	a.ClanTag = model.Tag
+func toAccount(model db.Account) models.Account {
+	return models.Account{
+		ID:             model.ID,
+		Realm:          model.Realm,
+		Nickname:       model.Nickname,
+		Private:        model.Private,
+		CreatedAt:      time.Unix(int64(model.AccountCreatedAt), 0),
+		LastBattleTime: time.Unix(int64(model.LastBattleTime), 0),
+	}
 }
 
-func (c *client) GetRealmAccounts(ctx context.Context, realm string) ([]Account, error) {
-	models, err := c.prisma.Account.FindMany(db.Account.Realm.Equals(realm)).With(db.Account.Clan.Fetch()).Exec(ctx)
+func (c *libsqlClient) GetRealmAccountIDs(ctx context.Context, realm string) ([]string, error) {
+	result, err := c.db.Account.Query().Where(account.Realm(strings.ToLower(realm))).Select(account.FieldID).All(ctx)
 	if err != nil {
 		return nil, err
 	}
 
-	var accounts []Account
-	for _, model := range models {
-		account := Account{}.FromModel(model)
-		if clan, ok := model.Clan(); ok {
-			account.AddClan(clan)
-		}
-		accounts = append(accounts, account)
+	var accounts []string
+	for _, model := range result {
+		accounts = append(accounts, model.ID)
 	}
 
 	return accounts, nil
 }
 
-func (c *client) GetAccountByID(ctx context.Context, id string) (Account, error) {
-	model, err := c.prisma.Account.FindUnique(db.Account.ID.Equals(id)).With(db.Account.Clan.Fetch()).Exec(ctx)
-	if err != nil {
-		return Account{}, err
-	}
+func (c *libsqlClient) GetAccountByID(ctx context.Context, id string) (models.Account, error) {
+	// model, err := c.prisma.Account.FindUnique(db.Account.ID.Equals(id)).With(db.Account.Clan.Fetch()).Exec(ctx)
+	// if err != nil {
+	// 	return Account{}, err
+	// }
 
-	account := Account{}.FromModel(*model)
-	if clan, ok := model.Clan(); ok {
-		account.AddClan(clan)
-	}
+	// account := Account{}.FromModel(*model)
+	// if clan, ok := model.Clan(); ok {
+	// 	account.AddClan(clan)
+	// }
 
-	return account, nil
+	return models.Account{}, nil
 }
 
-func (c *client) GetAccounts(ctx context.Context, ids []string) ([]Account, error) {
-	if len(ids) < 1 {
-		return nil, nil
-	}
-
-	models, err := c.prisma.Account.FindMany(db.Account.ID.In(ids)).With(db.Account.Clan.Fetch()).Exec(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	var accounts []Account
-	for _, model := range models {
-		account := Account{}.FromModel(model)
-		if clan, ok := model.Clan(); ok {
-			account.AddClan(clan)
-		}
-		accounts = append(accounts, account)
-	}
+func (c *libsqlClient) GetAccounts(ctx context.Context, ids []string) ([]models.Account, error) {
+	// if len(ids) < 1 {
+	// 	return nil, nil
+	// }
+
+	// models, err := c.prisma.Account.FindMany(db.Account.ID.In(ids)).With(db.Account.Clan.Fetch()).Exec(ctx)
+	// if err != nil {
+	// 	return nil, err
+	// }
+
+	var accounts []models.Account
+	// for _, model := range models {
+	// 	account := Account{}.FromModel(model)
+	// 	if clan, ok := model.Clan(); ok {
+	// 		account.AddClan(clan)
+	// 	}
+	// 	accounts = append(accounts, account)
+	// }
 
 	return accounts, nil
 }
 
-func (c *client) UpsertAccounts(ctx context.Context, accounts []Account) map[string]error {
-	if len(accounts) < 1 {
-		return nil
-	}
+func (c *libsqlClient) UpsertAccounts(ctx context.Context, accounts []models.Account) map[string]error {
+	// if len(accounts) < 1 {
+	// 	return nil
+	// }
 
-	var mx sync.Mutex
-	var wg sync.WaitGroup
+	// var mx sync.Mutex
+	// var wg sync.WaitGroup
 	errors := make(map[string]error, len(accounts))
 
-	// we don't really want to exit if one fails
-	for _, account := range accounts {
-		wg.Add(1)
-		go func(account Account) {
-			defer wg.Done()
-			optional := []db.AccountSetParam{db.Account.Private.Set(account.Private)}
-			if account.ClanID != "" {
-				clan, err := c.prisma.Clan.FindUnique(db.Clan.ID.Equals(account.ClanID)).Exec(ctx)
-				if err == nil {
-					optional = append(optional, db.Account.Clan.Link(db.Clan.ID.Equals(clan.ID)))
-				}
-			}
-
-			_, err := c.prisma.Account.
-				UpsertOne(db.Account.ID.Equals(account.ID)).
-				Create(db.Account.ID.Set(account.ID),
-					db.Account.LastBattleTime.Set(account.LastBattleTime),
-					db.Account.AccountCreatedAt.Set(account.CreatedAt),
-					db.Account.Realm.Set(account.Realm),
-					db.Account.Nickname.Set(account.Nickname),
-					optional...,
-				).
-				Update(
-					append(optional,
-						db.Account.Nickname.Set(account.Nickname),
-						db.Account.LastBattleTime.Set(account.LastBattleTime),
-					)...,
-				).
-				Exec(ctx)
-			if err != nil {
-				mx.Lock()
-				errors[account.ID] = err
-				mx.Unlock()
-				return
-			}
-		}(account)
-	}
-	wg.Wait()
+	// // we don't really want to exit if one fails
+	// for _, account := range accounts {
+	// 	wg.Add(1)
+	// 	go func(account Account) {
+	// 		defer wg.Done()
+	// 		optional := []db.AccountSetParam{db.Account.Private.Set(account.Private)}
+	// 		if account.ClanID != "" {
+	// 			clan, err := c.prisma.Clan.FindUnique(db.Clan.ID.Equals(account.ClanID)).Exec(ctx)
+	// 			if err == nil {
+	// 				optional = append(optional, db.Account.Clan.Link(db.Clan.ID.Equals(clan.ID)))
+	// 			}
+	// 		}
+
+	// 		_, err := c.prisma.Account.
+	// 			UpsertOne(db.Account.ID.Equals(account.ID)).
+	// 			Create(db.Account.ID.Set(account.ID),
+	// 				db.Account.LastBattleTime.Set(account.LastBattleTime),
+	// 				db.Account.AccountCreatedAt.Set(account.CreatedAt),
+	// 				db.Account.Realm.Set(account.Realm),
+	// 				db.Account.Nickname.Set(account.Nickname),
+	// 				optional...,
+	// 			).
+	// 			Update(
+	// 				append(optional,
+	// 					db.Account.Nickname.Set(account.Nickname),
+	// 					db.Account.LastBattleTime.Set(account.LastBattleTime),
+	// 				)...,
+	// 			).
+	// 			Exec(ctx)
+	// 		if err != nil {
+	// 			mx.Lock()
+	// 			errors[account.ID] = err
+	// 			mx.Unlock()
+	// 			return
+	// 		}
+	// 	}(account)
+	// }
+	// wg.Wait()
 
 	return errors
 }
 
-func (c *client) AccountSetPrivate(ctx context.Context, id string, value bool) error {
-	_, err := c.prisma.Account.FindUnique(db.Account.ID.Equals(id)).Update(db.Account.Private.Set(value)).Exec(ctx)
-	if err != nil && !db.IsErrNotFound(err) {
-		return err
-	}
+func (c *libsqlClient) AccountSetPrivate(ctx context.Context, id string, value bool) error {
+	// _, err := c.prisma.Account.FindUnique(db.Account.ID.Equals(id)).Update(db.Account.Private.Set(value)).Exec(ctx)
+	// if err != nil && !database.IsNotFound(err) {
+	// 	return err
+	// }
 	return nil
 }
diff --git a/internal/database/averages.go b/internal/database/averages.go
index a2e59a64..b798fe9b 100644
--- a/internal/database/averages.go
+++ b/internal/database/averages.go
@@ -2,82 +2,79 @@ package database
 
 import (
 	"context"
-	"time"
 
-	"github.com/cufee/aftermath/internal/database/prisma/db"
 	"github.com/cufee/aftermath/internal/stats/frame"
-	"github.com/rs/zerolog/log"
-	"github.com/steebchen/prisma-client-go/runtime/transaction"
 )
 
-func (c *client) UpsertVehicleAverages(ctx context.Context, averages map[string]frame.StatsFrame) error {
-	if len(averages) < 1 {
-		return nil
-	}
+func (c *libsqlClient) UpsertVehicleAverages(ctx context.Context, averages map[string]frame.StatsFrame) error {
+	// if len(averages) < 1 {
+	// 	return nil
+	// }
 
-	var transactions []transaction.Transaction
-	for id, data := range averages {
-		encoded, err := data.Encode()
-		if err != nil {
-			log.Err(err).Str("id", id).Msg("failed to encode a stats frame for vehicle averages")
-			continue
-		}
+	// var transactions []transaction.Transaction
+	// for id, data := range averages {
+	// 	encoded, err := data.Encode()
+	// 	if err != nil {
+	// 		log.Err(err).Str("id", id).Msg("failed to encode a stats frame for vehicle averages")
+	// 		continue
+	// 	}
 
-		transactions = append(transactions, c.prisma.VehicleAverage.
-			UpsertOne(db.VehicleAverage.ID.Equals(id)).
-			Create(
-				db.VehicleAverage.ID.Set(id),
-				db.VehicleAverage.DataEncoded.Set(encoded),
-			).
-			Update(
-				db.VehicleAverage.DataEncoded.Set(encoded),
-			).Tx(),
-		)
-	}
+	// 	transactions = append(transactions, c.prisma.VehicleAverage.
+	// 		UpsertOne(db.VehicleAverage.ID.Equals(id)).
+	// 		Create(
+	// 			db.VehicleAverage.ID.Set(id),
+	// 			db.VehicleAverage.DataEncoded.Set(encoded),
+	// 		).
+	// 		Update(
+	// 			db.VehicleAverage.DataEncoded.Set(encoded),
+	// 		).Tx(),
+	// 	)
+	// }
 
-	return c.prisma.Prisma.Transaction(transactions...).Exec(ctx)
+	// return c.prisma.Prisma.Transaction(transactions...).Exec(ctx)
+	return nil
 }
 
-func (c *client) GetVehicleAverages(ctx context.Context, ids []string) (map[string]frame.StatsFrame, error) {
-	if len(ids) < 1 {
-		return nil, nil
-	}
+func (c *libsqlClient) GetVehicleAverages(ctx context.Context, ids []string) (map[string]frame.StatsFrame, error) {
+	// if len(ids) < 1 {
+	// 	return nil, nil
+	// }
 
-	qCtx, cancel := context.WithTimeout(ctx, time.Second)
-	defer cancel()
-	records, err := c.prisma.VehicleAverage.FindMany(db.VehicleAverage.ID.In(ids)).Exec(qCtx)
-	if err != nil {
-		return nil, err
-	}
+	// qCtx, cancel := context.WithTimeout(ctx, time.Second)
+	// defer cancel()
+	// records, err := c.prisma.VehicleAverage.FindMany(db.VehicleAverage.ID.In(ids)).Exec(qCtx)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
 	averages := make(map[string]frame.StatsFrame)
-	var badRecords []string
-	var lastErr error
+	// var badRecords []string
+	// var lastErr error
 
-	for _, record := range records {
-		parsed, err := frame.DecodeStatsFrame(record.DataEncoded)
-		lastErr = err
-		if err != nil {
-			badRecords = append(badRecords, record.ID)
-			continue
-		}
-		averages[record.ID] = parsed
-	}
+	// for _, record := range records {
+	// 	parsed, err := frame.DecodeStatsFrame(record.DataEncoded)
+	// 	lastErr = err
+	// 	if err != nil {
+	// 		badRecords = append(badRecords, record.ID)
+	// 		continue
+	// 	}
+	// 	averages[record.ID] = parsed
+	// }
 
-	if len(badRecords) == len(ids) || len(badRecords) == 0 {
-		return averages, lastErr
-	}
+	// if len(badRecords) == len(ids) || len(badRecords) == 0 {
+	// 	return averages, lastErr
+	// }
 
-	go func() {
-		// one bad record should not break the whole query since this data is optional
-		// we can just delete the record and move on
-		ctx, cancel := context.WithCancel(context.Background())
-		defer cancel()
-		_, err := c.prisma.VehicleAverage.FindMany(db.VehicleAverage.ID.In(badRecords)).Delete().Exec(ctx)
-		if err != nil {
-			log.Err(err).Strs("ids", badRecords).Msg("failed to delete a bad vehicle average records")
-		}
-	}()
+	// go func() {
+	// 	// one bad record should not break the whole query since this data is optional
+	// 	// we can just delete the record and move on
+	// 	ctx, cancel := context.WithCancel(context.Background())
+	// 	defer cancel()
+	// 	_, err := c.prisma.VehicleAverage.FindMany(db.VehicleAverage.ID.In(badRecords)).Delete().Exec(ctx)
+	// 	if err != nil {
+	// 		log.Err(err).Strs("ids", badRecords).Msg("failed to delete a bad vehicle average records")
+	// 	}
+	// }()
 
 	return averages, nil
 }
diff --git a/internal/database/cleanup.go b/internal/database/cleanup.go
index 4f045503..22eae805 100644
--- a/internal/database/cleanup.go
+++ b/internal/database/cleanup.go
@@ -3,26 +3,24 @@ package database
 import (
 	"context"
 	"time"
-
-	"github.com/cufee/aftermath/internal/database/prisma/db"
 )
 
-func (c *client) DeleteExpiredTasks(ctx context.Context, expiration time.Time) error {
-	_, err := c.prisma.CronTask.FindMany(db.CronTask.CreatedAt.Before(expiration)).Delete().Exec(ctx)
-	if err != nil && !db.IsErrNotFound(err) {
-		return err
-	}
+func (c *libsqlClient) DeleteExpiredTasks(ctx context.Context, expiration time.Time) error {
+	// _, err := c.prisma.CronTask.FindMany(db.CronTask.CreatedAt.Before(expiration)).Delete().Exec(ctx)
+	// if err != nil && !database.IsNotFound(err) {
+	// 	return err
+	// }
 	return nil
 }
 
-func (c *client) DeleteExpiredSnapshots(ctx context.Context, expiration time.Time) error {
-	_, err := c.prisma.AccountSnapshot.FindMany(db.AccountSnapshot.CreatedAt.Before(expiration)).Delete().Exec(ctx)
-	if err != nil && !db.IsErrNotFound(err) {
-		return err
-	}
-	_, err = c.prisma.VehicleSnapshot.FindMany(db.VehicleSnapshot.CreatedAt.Before(expiration)).Delete().Exec(ctx)
-	if err != nil && !db.IsErrNotFound(err) {
-		return err
-	}
+func (c *libsqlClient) DeleteExpiredSnapshots(ctx context.Context, expiration time.Time) error {
+	// _, err := c.prisma.AccountSnapshot.FindMany(db.AccountSnapshot.CreatedAt.Before(expiration)).Delete().Exec(ctx)
+	// if err != nil && !database.IsNotFound(err) {
+	// 	return err
+	// }
+	// _, err = c.prisma.VehicleSnapshot.FindMany(db.VehicleSnapshot.CreatedAt.Before(expiration)).Delete().Exec(ctx)
+	// if err != nil && !database.IsNotFound(err) {
+	// 	return err
+	// }
 	return nil
 }
diff --git a/internal/database/client.go b/internal/database/client.go
index 464988ce..3166f44b 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -2,62 +2,68 @@ package database
 
 import (
 	"context"
+	"database/sql"
 	"time"
 
-	"github.com/cufee/aftermath/internal/database/prisma/db"
+	"github.com/cufee/aftermath/internal/database/ent/db"
+	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/permissions"
 	"github.com/cufee/aftermath/internal/stats/frame"
 	"golang.org/x/sync/semaphore"
+
+	"entgo.io/ent/dialect"
+	entsql "entgo.io/ent/dialect/sql"
+	_ "github.com/tursodatabase/libsql-client-go/libsql"
 )
 
-var _ Client = &client{}
+var _ Client = &libsqlClient{}
 
 type AccountsClient interface {
-	GetAccountByID(ctx context.Context, id string) (Account, error)
-	GetAccounts(ctx context.Context, ids []string) ([]Account, error)
-	GetRealmAccounts(ctx context.Context, realm string) ([]Account, error)
-	UpsertAccounts(ctx context.Context, accounts []Account) map[string]error
+	GetAccountByID(ctx context.Context, id string) (models.Account, error)
+	GetRealmAccountIDs(ctx context.Context, realm string) ([]string, error)
+	GetAccounts(ctx context.Context, ids []string) ([]models.Account, error)
+	UpsertAccounts(ctx context.Context, accounts []models.Account) map[string]error
 	AccountSetPrivate(ctx context.Context, id string, value bool) error
 }
 
 type GlossaryClient interface {
 	GetVehicleAverages(ctx context.Context, ids []string) (map[string]frame.StatsFrame, error)
 	UpsertVehicleAverages(ctx context.Context, averages map[string]frame.StatsFrame) error
-	GetVehicles(ctx context.Context, ids []string) (map[string]Vehicle, error)
-	UpsertVehicles(ctx context.Context, vehicles map[string]Vehicle) error
+	GetVehicles(ctx context.Context, ids []string) (map[string]models.Vehicle, error)
+	UpsertVehicles(ctx context.Context, vehicles map[string]models.Vehicle) error
 }
 
 type UsersClient interface {
-	GetUserByID(ctx context.Context, id string, opts ...userGetOption) (User, error)
-	GetOrCreateUserByID(ctx context.Context, id string, opts ...userGetOption) (User, error)
-	UpdateConnection(ctx context.Context, connection UserConnection) (UserConnection, error)
-	UpsertConnection(ctx context.Context, connection UserConnection) (UserConnection, error)
-	UpsertUserWithPermissions(ctx context.Context, userID string, perms permissions.Permissions) (User, error)
+	GetUserByID(ctx context.Context, id string, opts ...userGetOption) (models.User, error)
+	GetOrCreateUserByID(ctx context.Context, id string, opts ...userGetOption) (models.User, error)
+	UpdateConnection(ctx context.Context, connection models.UserConnection) (models.UserConnection, error)
+	UpsertConnection(ctx context.Context, connection models.UserConnection) (models.UserConnection, error)
+	UpsertUserWithPermissions(ctx context.Context, userID string, perms permissions.Permissions) (models.User, error)
 }
 
 type SnapshotsClient interface {
-	CreateAccountSnapshots(ctx context.Context, snapshots ...AccountSnapshot) error
-	GetLastAccountSnapshots(ctx context.Context, accountID string, limit int) ([]AccountSnapshot, error)
-	GetAccountSnapshot(ctx context.Context, accountID, referenceID string, kind snapshotType, options ...SnapshotQuery) (AccountSnapshot, error)
-	GetManyAccountSnapshots(ctx context.Context, accountIDs []string, kind snapshotType, options ...SnapshotQuery) ([]AccountSnapshot, error)
-	CreateVehicleSnapshots(ctx context.Context, snapshots ...VehicleSnapshot) error
-	GetVehicleSnapshots(ctx context.Context, accountID, referenceID string, kind snapshotType, options ...SnapshotQuery) ([]VehicleSnapshot, error)
+	CreateAccountSnapshots(ctx context.Context, snapshots ...models.AccountSnapshot) error
+	GetLastAccountSnapshots(ctx context.Context, accountID string, limit int) ([]models.AccountSnapshot, error)
+	GetAccountSnapshot(ctx context.Context, accountID, referenceID string, kind models.SnapshotType, options ...SnapshotQuery) (models.AccountSnapshot, error)
+	GetManyAccountSnapshots(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.AccountSnapshot, error)
+	CreateVehicleSnapshots(ctx context.Context, snapshots ...models.VehicleSnapshot) error
+	GetVehicleSnapshots(ctx context.Context, accountID, referenceID string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.VehicleSnapshot, error)
 	DeleteExpiredSnapshots(ctx context.Context, expiration time.Time) error
 }
 
 type TasksClient interface {
-	CreateTasks(ctx context.Context, tasks ...Task) error
-	UpdateTasks(ctx context.Context, tasks ...Task) error
+	CreateTasks(ctx context.Context, tasks ...models.Task) error
+	UpdateTasks(ctx context.Context, tasks ...models.Task) error
 	DeleteTasks(ctx context.Context, ids ...string) error
-	GetStaleTasks(ctx context.Context, limit int) ([]Task, error)
-	GetAndStartTasks(ctx context.Context, limit int) ([]Task, error)
+	GetStaleTasks(ctx context.Context, limit int) ([]models.Task, error)
+	GetAndStartTasks(ctx context.Context, limit int) ([]models.Task, error)
 	DeleteExpiredTasks(ctx context.Context, expiration time.Time) error
-	GetRecentTasks(ctx context.Context, createdAfter time.Time, status ...TaskStatus) ([]Task, error)
+	GetRecentTasks(ctx context.Context, createdAfter time.Time, status ...models.TaskStatus) ([]models.Task, error)
 }
 
 type DiscordDataClient interface {
-	UpsertCommands(ctx context.Context, commands ...ApplicationCommand) error
-	GetCommandsByID(ctx context.Context, commandIDs ...string) ([]ApplicationCommand, error)
+	UpsertCommands(ctx context.Context, commands ...models.ApplicationCommand) error
+	GetCommandsByID(ctx context.Context, commandIDs ...string) ([]models.ApplicationCommand, error)
 }
 
 type Client interface {
@@ -74,27 +80,25 @@ type Client interface {
 	Disconnect() error
 }
 
-type client struct {
-	prisma *db.PrismaClient
-	// Prisma does not currently support updateManyAndReturn
-	// in order to avoid a case where we
+type libsqlClient struct {
+	db             *db.Client
 	tasksUpdateSem *semaphore.Weighted
 }
 
-func (c *client) Disconnect() error {
-	return c.prisma.Disconnect()
-}
-
-func (c *client) Prisma() *db.PrismaClient {
-	return c.prisma
+func (c *libsqlClient) Disconnect() error {
+	return c.db.Close()
 }
 
-func NewClient() (*client, error) {
-	prisma := db.NewClient()
-	err := prisma.Connect()
+func NewLibSQLClient(primaryUrl string) (*libsqlClient, error) {
+	driver, err := sql.Open("libsql", primaryUrl)
 	if err != nil {
 		return nil, err
 	}
 
-	return &client{prisma: prisma, tasksUpdateSem: semaphore.NewWeighted(1)}, nil
+	dbClient := db.NewClient(db.Driver(entsql.OpenDB(dialect.SQLite, driver)))
+
+	return &libsqlClient{
+		db:             dbClient,
+		tasksUpdateSem: semaphore.NewWeighted(1),
+	}, nil
 }
diff --git a/internal/database/discord.go b/internal/database/discord.go
index ac1a925d..c9d368ba 100644
--- a/internal/database/discord.go
+++ b/internal/database/discord.go
@@ -3,79 +3,64 @@ package database
 import (
 	"context"
 
-	"github.com/cufee/aftermath/internal/database/prisma/db"
+	"github.com/cufee/aftermath/internal/database/models"
 )
 
-type ApplicationCommand struct {
-	ID      string
-	Hash    string
-	Name    string
-	Version string
-}
-
-func (c ApplicationCommand) fromModel(model db.ApplicationCommandModel) ApplicationCommand {
-	return ApplicationCommand{
-		ID:      model.ID,
-		Name:    model.Name,
-		Hash:    model.OptionsHash,
-		Version: model.Version,
-	}
-}
-
-func (c *client) GetCommandsByID(ctx context.Context, commandIDs ...string) ([]ApplicationCommand, error) {
-	if len(commandIDs) < 1 {
-		return nil, nil
-	}
+func (c *libsqlClient) GetCommandsByID(ctx context.Context, commandIDs ...string) ([]models.ApplicationCommand, error) {
+	// if len(commandIDs) < 1 {
+	// 	return nil, nil
+	// }
 
-	models, err := c.prisma.ApplicationCommand.FindMany(db.ApplicationCommand.ID.In(commandIDs)).Exec(ctx)
-	if err != nil {
-		return nil, err
-	}
+	// models, err := c.prisma.models.ApplicationCommand.FindMany(db.models.ApplicationCommand.ID.In(commandIDs)).Exec(ctx)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
-	var commands []ApplicationCommand
-	for _, model := range models {
-		commands = append(commands, ApplicationCommand{}.fromModel(model))
-	}
+	var commands []models.ApplicationCommand
+	// for _, model := range models {
+	// 	commands = append(commands, models.ApplicationCommand{}.fromModel(model))
+	// }
 	return commands, nil
 }
 
-func (c *client) GetCommandsByHash(ctx context.Context, commandHashes ...string) ([]ApplicationCommand, error) {
-	if len(commandHashes) < 1 {
-		return nil, nil
-	}
+func (c *libsqlClient) GetCommandsByHash(ctx context.Context, commandHashes ...string) ([]models.ApplicationCommand, error) {
+	// if len(commandHashes) < 1 {
+	// 	return nil, nil
+	// }
 
-	models, err := c.prisma.ApplicationCommand.FindMany(db.ApplicationCommand.OptionsHash.In(commandHashes)).Exec(ctx)
-	if err != nil {
-		return nil, err
-	}
+	// models, err := c.prisma.models.ApplicationCommand.FindMany(db.models.ApplicationCommand.OptionsHash.In(commandHashes)).Exec(ctx)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
-	var commands []ApplicationCommand
-	for _, model := range models {
-		commands = append(commands, ApplicationCommand{}.fromModel(model))
-	}
+	var commands []models.ApplicationCommand
+	// for _, model := range models {
+	// 	commands = append(commands, models.ApplicationCommand{}.fromModel(model))
+	// }
 	return commands, nil
 }
 
-func (c *client) UpsertCommands(ctx context.Context, commands ...ApplicationCommand) error {
-	if len(commands) < 1 {
-		return nil
-	}
+func (c *libsqlClient) UpsertCommands(ctx context.Context, commands ...models.ApplicationCommand) error {
+	// if len(commands) < 1 {
+	// 	return nil
+	// }
 
-	var tx []db.PrismaTransaction
-	for _, cmd := range commands {
-		tx = append(tx, c.prisma.ApplicationCommand.UpsertOne(db.ApplicationCommand.ID.Equals(cmd.ID)).
-			Create(
-				db.ApplicationCommand.ID.Set(cmd.ID),
-				db.ApplicationCommand.Name.Set(cmd.Name),
-				db.ApplicationCommand.Version.Set(cmd.Version),
-				db.ApplicationCommand.OptionsHash.Set(cmd.Hash),
-			).
-			Update(
-				db.ApplicationCommand.Name.Set(cmd.Name),
-				db.ApplicationCommand.Version.Set(cmd.Version),
-				db.ApplicationCommand.OptionsHash.Set(cmd.Hash),
-			).Tx(),
-		)
-	}
-	return c.prisma.Prisma.Transaction(tx...).Exec(ctx)
+	// var tx []db.PrismaTransaction
+	// for _, cmd := range commands {
+	// 	tx = append(tx, c.prisma.models.ApplicationCommand.UpsertOne(db.models.ApplicationCommand.ID.Equals(cmd.ID)).
+	// 		Create(
+	// 			db.models.ApplicationCommand.ID.Set(cmd.ID),
+	// 			db.models.ApplicationCommand.Name.Set(cmd.Name),
+	// 			db.models.ApplicationCommand.Version.Set(cmd.Version),
+	// 			db.models.ApplicationCommand.OptionsHash.Set(cmd.Hash),
+	// 		).
+	// 		Update(
+	// 			db.models.ApplicationCommand.Name.Set(cmd.Name),
+	// 			db.models.ApplicationCommand.Version.Set(cmd.Version),
+	// 			db.models.ApplicationCommand.OptionsHash.Set(cmd.Hash),
+	// 		).Tx(),
+	// 	)
+	// }
+	// return c.prisma.Prisma.Transaction(tx...).Exec(ctx)
+	return nil
 }
diff --git a/internal/database/ent/db/account.go b/internal/database/ent/db/account.go
new file mode 100644
index 00000000..7cdf8b15
--- /dev/null
+++ b/internal/database/ent/db/account.go
@@ -0,0 +1,259 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"fmt"
+	"strings"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+	"github.com/cufee/aftermath/internal/database/ent/db/account"
+	"github.com/cufee/aftermath/internal/database/ent/db/clan"
+)
+
+// Account is the model entity for the Account schema.
+type Account struct {
+	config `json:"-"`
+	// ID of the ent.
+	ID string `json:"id,omitempty"`
+	// CreatedAt holds the value of the "created_at" field.
+	CreatedAt int `json:"created_at,omitempty"`
+	// UpdatedAt holds the value of the "updated_at" field.
+	UpdatedAt int `json:"updated_at,omitempty"`
+	// LastBattleTime holds the value of the "last_battle_time" field.
+	LastBattleTime int `json:"last_battle_time,omitempty"`
+	// AccountCreatedAt holds the value of the "account_created_at" field.
+	AccountCreatedAt int `json:"account_created_at,omitempty"`
+	// Realm holds the value of the "realm" field.
+	Realm string `json:"realm,omitempty"`
+	// Nickname holds the value of the "nickname" field.
+	Nickname string `json:"nickname,omitempty"`
+	// Private holds the value of the "private" field.
+	Private bool `json:"private,omitempty"`
+	// ClanID holds the value of the "clan_id" field.
+	ClanID string `json:"clan_id,omitempty"`
+	// Edges holds the relations/edges for other nodes in the graph.
+	// The values are being populated by the AccountQuery when eager-loading is set.
+	Edges        AccountEdges `json:"edges"`
+	selectValues sql.SelectValues
+}
+
+// AccountEdges holds the relations/edges for other nodes in the graph.
+type AccountEdges struct {
+	// Clan holds the value of the clan edge.
+	Clan *Clan `json:"clan,omitempty"`
+	// Snapshots holds the value of the snapshots edge.
+	Snapshots []*AccountSnapshot `json:"snapshots,omitempty"`
+	// VehicleSnapshots holds the value of the vehicle_snapshots edge.
+	VehicleSnapshots []*VehicleSnapshot `json:"vehicle_snapshots,omitempty"`
+	// AchievementSnapshots holds the value of the achievement_snapshots edge.
+	AchievementSnapshots []*AchievementsSnapshot `json:"achievement_snapshots,omitempty"`
+	// loadedTypes holds the information for reporting if a
+	// type was loaded (or requested) in eager-loading or not.
+	loadedTypes [4]bool
+}
+
+// ClanOrErr returns the Clan value or an error if the edge
+// was not loaded in eager-loading, or loaded but was not found.
+func (e AccountEdges) ClanOrErr() (*Clan, error) {
+	if e.Clan != nil {
+		return e.Clan, nil
+	} else if e.loadedTypes[0] {
+		return nil, &NotFoundError{label: clan.Label}
+	}
+	return nil, &NotLoadedError{edge: "clan"}
+}
+
+// SnapshotsOrErr returns the Snapshots value or an error if the edge
+// was not loaded in eager-loading.
+func (e AccountEdges) SnapshotsOrErr() ([]*AccountSnapshot, error) {
+	if e.loadedTypes[1] {
+		return e.Snapshots, nil
+	}
+	return nil, &NotLoadedError{edge: "snapshots"}
+}
+
+// VehicleSnapshotsOrErr returns the VehicleSnapshots value or an error if the edge
+// was not loaded in eager-loading.
+func (e AccountEdges) VehicleSnapshotsOrErr() ([]*VehicleSnapshot, error) {
+	if e.loadedTypes[2] {
+		return e.VehicleSnapshots, nil
+	}
+	return nil, &NotLoadedError{edge: "vehicle_snapshots"}
+}
+
+// AchievementSnapshotsOrErr returns the AchievementSnapshots value or an error if the edge
+// was not loaded in eager-loading.
+func (e AccountEdges) AchievementSnapshotsOrErr() ([]*AchievementsSnapshot, error) {
+	if e.loadedTypes[3] {
+		return e.AchievementSnapshots, nil
+	}
+	return nil, &NotLoadedError{edge: "achievement_snapshots"}
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*Account) scanValues(columns []string) ([]any, error) {
+	values := make([]any, len(columns))
+	for i := range columns {
+		switch columns[i] {
+		case account.FieldPrivate:
+			values[i] = new(sql.NullBool)
+		case account.FieldCreatedAt, account.FieldUpdatedAt, account.FieldLastBattleTime, account.FieldAccountCreatedAt:
+			values[i] = new(sql.NullInt64)
+		case account.FieldID, account.FieldRealm, account.FieldNickname, account.FieldClanID:
+			values[i] = new(sql.NullString)
+		default:
+			values[i] = new(sql.UnknownType)
+		}
+	}
+	return values, nil
+}
+
+// assignValues assigns the values that were returned from sql.Rows (after scanning)
+// to the Account fields.
+func (a *Account) assignValues(columns []string, values []any) error {
+	if m, n := len(values), len(columns); m < n {
+		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
+	}
+	for i := range columns {
+		switch columns[i] {
+		case account.FieldID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field id", values[i])
+			} else if value.Valid {
+				a.ID = value.String
+			}
+		case account.FieldCreatedAt:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field created_at", values[i])
+			} else if value.Valid {
+				a.CreatedAt = int(value.Int64)
+			}
+		case account.FieldUpdatedAt:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
+			} else if value.Valid {
+				a.UpdatedAt = int(value.Int64)
+			}
+		case account.FieldLastBattleTime:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field last_battle_time", values[i])
+			} else if value.Valid {
+				a.LastBattleTime = int(value.Int64)
+			}
+		case account.FieldAccountCreatedAt:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field account_created_at", values[i])
+			} else if value.Valid {
+				a.AccountCreatedAt = int(value.Int64)
+			}
+		case account.FieldRealm:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field realm", values[i])
+			} else if value.Valid {
+				a.Realm = value.String
+			}
+		case account.FieldNickname:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field nickname", values[i])
+			} else if value.Valid {
+				a.Nickname = value.String
+			}
+		case account.FieldPrivate:
+			if value, ok := values[i].(*sql.NullBool); !ok {
+				return fmt.Errorf("unexpected type %T for field private", values[i])
+			} else if value.Valid {
+				a.Private = value.Bool
+			}
+		case account.FieldClanID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field clan_id", values[i])
+			} else if value.Valid {
+				a.ClanID = value.String
+			}
+		default:
+			a.selectValues.Set(columns[i], values[i])
+		}
+	}
+	return nil
+}
+
+// Value returns the ent.Value that was dynamically selected and assigned to the Account.
+// This includes values selected through modifiers, order, etc.
+func (a *Account) Value(name string) (ent.Value, error) {
+	return a.selectValues.Get(name)
+}
+
+// QueryClan queries the "clan" edge of the Account entity.
+func (a *Account) QueryClan() *ClanQuery {
+	return NewAccountClient(a.config).QueryClan(a)
+}
+
+// QuerySnapshots queries the "snapshots" edge of the Account entity.
+func (a *Account) QuerySnapshots() *AccountSnapshotQuery {
+	return NewAccountClient(a.config).QuerySnapshots(a)
+}
+
+// QueryVehicleSnapshots queries the "vehicle_snapshots" edge of the Account entity.
+func (a *Account) QueryVehicleSnapshots() *VehicleSnapshotQuery {
+	return NewAccountClient(a.config).QueryVehicleSnapshots(a)
+}
+
+// QueryAchievementSnapshots queries the "achievement_snapshots" edge of the Account entity.
+func (a *Account) QueryAchievementSnapshots() *AchievementsSnapshotQuery {
+	return NewAccountClient(a.config).QueryAchievementSnapshots(a)
+}
+
+// Update returns a builder for updating this Account.
+// Note that you need to call Account.Unwrap() before calling this method if this Account
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (a *Account) Update() *AccountUpdateOne {
+	return NewAccountClient(a.config).UpdateOne(a)
+}
+
+// Unwrap unwraps the Account entity that was returned from a transaction after it was closed,
+// so that all future queries will be executed through the driver which created the transaction.
+func (a *Account) Unwrap() *Account {
+	_tx, ok := a.config.driver.(*txDriver)
+	if !ok {
+		panic("db: Account is not a transactional entity")
+	}
+	a.config.driver = _tx.drv
+	return a
+}
+
+// String implements the fmt.Stringer.
+func (a *Account) String() string {
+	var builder strings.Builder
+	builder.WriteString("Account(")
+	builder.WriteString(fmt.Sprintf("id=%v, ", a.ID))
+	builder.WriteString("created_at=")
+	builder.WriteString(fmt.Sprintf("%v", a.CreatedAt))
+	builder.WriteString(", ")
+	builder.WriteString("updated_at=")
+	builder.WriteString(fmt.Sprintf("%v", a.UpdatedAt))
+	builder.WriteString(", ")
+	builder.WriteString("last_battle_time=")
+	builder.WriteString(fmt.Sprintf("%v", a.LastBattleTime))
+	builder.WriteString(", ")
+	builder.WriteString("account_created_at=")
+	builder.WriteString(fmt.Sprintf("%v", a.AccountCreatedAt))
+	builder.WriteString(", ")
+	builder.WriteString("realm=")
+	builder.WriteString(a.Realm)
+	builder.WriteString(", ")
+	builder.WriteString("nickname=")
+	builder.WriteString(a.Nickname)
+	builder.WriteString(", ")
+	builder.WriteString("private=")
+	builder.WriteString(fmt.Sprintf("%v", a.Private))
+	builder.WriteString(", ")
+	builder.WriteString("clan_id=")
+	builder.WriteString(a.ClanID)
+	builder.WriteByte(')')
+	return builder.String()
+}
+
+// Accounts is a parsable slice of Account.
+type Accounts []*Account
diff --git a/internal/database/ent/db/account/account.go b/internal/database/ent/db/account/account.go
new file mode 100644
index 00000000..d2979c1d
--- /dev/null
+++ b/internal/database/ent/db/account/account.go
@@ -0,0 +1,232 @@
+// Code generated by ent, DO NOT EDIT.
+
+package account
+
+import (
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+)
+
+const (
+	// Label holds the string label denoting the account type in the database.
+	Label = "account"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// FieldLastBattleTime holds the string denoting the last_battle_time field in the database.
+	FieldLastBattleTime = "last_battle_time"
+	// FieldAccountCreatedAt holds the string denoting the account_created_at field in the database.
+	FieldAccountCreatedAt = "account_created_at"
+	// FieldRealm holds the string denoting the realm field in the database.
+	FieldRealm = "realm"
+	// FieldNickname holds the string denoting the nickname field in the database.
+	FieldNickname = "nickname"
+	// FieldPrivate holds the string denoting the private field in the database.
+	FieldPrivate = "private"
+	// FieldClanID holds the string denoting the clan_id field in the database.
+	FieldClanID = "clan_id"
+	// EdgeClan holds the string denoting the clan edge name in mutations.
+	EdgeClan = "clan"
+	// EdgeSnapshots holds the string denoting the snapshots edge name in mutations.
+	EdgeSnapshots = "snapshots"
+	// EdgeVehicleSnapshots holds the string denoting the vehicle_snapshots edge name in mutations.
+	EdgeVehicleSnapshots = "vehicle_snapshots"
+	// EdgeAchievementSnapshots holds the string denoting the achievement_snapshots edge name in mutations.
+	EdgeAchievementSnapshots = "achievement_snapshots"
+	// Table holds the table name of the account in the database.
+	Table = "accounts"
+	// ClanTable is the table that holds the clan relation/edge.
+	ClanTable = "accounts"
+	// ClanInverseTable is the table name for the Clan entity.
+	// It exists in this package in order to avoid circular dependency with the "clan" package.
+	ClanInverseTable = "clans"
+	// ClanColumn is the table column denoting the clan relation/edge.
+	ClanColumn = "clan_id"
+	// SnapshotsTable is the table that holds the snapshots relation/edge.
+	SnapshotsTable = "account_snapshots"
+	// SnapshotsInverseTable is the table name for the AccountSnapshot entity.
+	// It exists in this package in order to avoid circular dependency with the "accountsnapshot" package.
+	SnapshotsInverseTable = "account_snapshots"
+	// SnapshotsColumn is the table column denoting the snapshots relation/edge.
+	SnapshotsColumn = "account_id"
+	// VehicleSnapshotsTable is the table that holds the vehicle_snapshots relation/edge.
+	VehicleSnapshotsTable = "vehicle_snapshots"
+	// VehicleSnapshotsInverseTable is the table name for the VehicleSnapshot entity.
+	// It exists in this package in order to avoid circular dependency with the "vehiclesnapshot" package.
+	VehicleSnapshotsInverseTable = "vehicle_snapshots"
+	// VehicleSnapshotsColumn is the table column denoting the vehicle_snapshots relation/edge.
+	VehicleSnapshotsColumn = "account_id"
+	// AchievementSnapshotsTable is the table that holds the achievement_snapshots relation/edge.
+	AchievementSnapshotsTable = "achievements_snapshots"
+	// AchievementSnapshotsInverseTable is the table name for the AchievementsSnapshot entity.
+	// It exists in this package in order to avoid circular dependency with the "achievementssnapshot" package.
+	AchievementSnapshotsInverseTable = "achievements_snapshots"
+	// AchievementSnapshotsColumn is the table column denoting the achievement_snapshots relation/edge.
+	AchievementSnapshotsColumn = "account_id"
+)
+
+// Columns holds all SQL columns for account fields.
+var Columns = []string{
+	FieldID,
+	FieldCreatedAt,
+	FieldUpdatedAt,
+	FieldLastBattleTime,
+	FieldAccountCreatedAt,
+	FieldRealm,
+	FieldNickname,
+	FieldPrivate,
+	FieldClanID,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() int
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() int
+	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
+	UpdateDefaultUpdatedAt func() int
+	// RealmValidator is a validator for the "realm" field. It is called by the builders before save.
+	RealmValidator func(string) error
+	// NicknameValidator is a validator for the "nickname" field. It is called by the builders before save.
+	NicknameValidator func(string) error
+	// DefaultPrivate holds the default value on creation for the "private" field.
+	DefaultPrivate bool
+)
+
+// OrderOption defines the ordering options for the Account queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByLastBattleTime orders the results by the last_battle_time field.
+func ByLastBattleTime(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldLastBattleTime, opts...).ToFunc()
+}
+
+// ByAccountCreatedAt orders the results by the account_created_at field.
+func ByAccountCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldAccountCreatedAt, opts...).ToFunc()
+}
+
+// ByRealm orders the results by the realm field.
+func ByRealm(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldRealm, opts...).ToFunc()
+}
+
+// ByNickname orders the results by the nickname field.
+func ByNickname(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldNickname, opts...).ToFunc()
+}
+
+// ByPrivate orders the results by the private field.
+func ByPrivate(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldPrivate, opts...).ToFunc()
+}
+
+// ByClanID orders the results by the clan_id field.
+func ByClanID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldClanID, opts...).ToFunc()
+}
+
+// ByClanField orders the results by clan field.
+func ByClanField(field string, opts ...sql.OrderTermOption) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborTerms(s, newClanStep(), sql.OrderByField(field, opts...))
+	}
+}
+
+// BySnapshotsCount orders the results by snapshots count.
+func BySnapshotsCount(opts ...sql.OrderTermOption) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborsCount(s, newSnapshotsStep(), opts...)
+	}
+}
+
+// BySnapshots orders the results by snapshots terms.
+func BySnapshots(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborTerms(s, newSnapshotsStep(), append([]sql.OrderTerm{term}, terms...)...)
+	}
+}
+
+// ByVehicleSnapshotsCount orders the results by vehicle_snapshots count.
+func ByVehicleSnapshotsCount(opts ...sql.OrderTermOption) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborsCount(s, newVehicleSnapshotsStep(), opts...)
+	}
+}
+
+// ByVehicleSnapshots orders the results by vehicle_snapshots terms.
+func ByVehicleSnapshots(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborTerms(s, newVehicleSnapshotsStep(), append([]sql.OrderTerm{term}, terms...)...)
+	}
+}
+
+// ByAchievementSnapshotsCount orders the results by achievement_snapshots count.
+func ByAchievementSnapshotsCount(opts ...sql.OrderTermOption) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborsCount(s, newAchievementSnapshotsStep(), opts...)
+	}
+}
+
+// ByAchievementSnapshots orders the results by achievement_snapshots terms.
+func ByAchievementSnapshots(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborTerms(s, newAchievementSnapshotsStep(), append([]sql.OrderTerm{term}, terms...)...)
+	}
+}
+func newClanStep() *sqlgraph.Step {
+	return sqlgraph.NewStep(
+		sqlgraph.From(Table, FieldID),
+		sqlgraph.To(ClanInverseTable, FieldID),
+		sqlgraph.Edge(sqlgraph.M2O, true, ClanTable, ClanColumn),
+	)
+}
+func newSnapshotsStep() *sqlgraph.Step {
+	return sqlgraph.NewStep(
+		sqlgraph.From(Table, FieldID),
+		sqlgraph.To(SnapshotsInverseTable, FieldID),
+		sqlgraph.Edge(sqlgraph.O2M, false, SnapshotsTable, SnapshotsColumn),
+	)
+}
+func newVehicleSnapshotsStep() *sqlgraph.Step {
+	return sqlgraph.NewStep(
+		sqlgraph.From(Table, FieldID),
+		sqlgraph.To(VehicleSnapshotsInverseTable, FieldID),
+		sqlgraph.Edge(sqlgraph.O2M, false, VehicleSnapshotsTable, VehicleSnapshotsColumn),
+	)
+}
+func newAchievementSnapshotsStep() *sqlgraph.Step {
+	return sqlgraph.NewStep(
+		sqlgraph.From(Table, FieldID),
+		sqlgraph.To(AchievementSnapshotsInverseTable, FieldID),
+		sqlgraph.Edge(sqlgraph.O2M, false, AchievementSnapshotsTable, AchievementSnapshotsColumn),
+	)
+}
diff --git a/internal/database/ent/db/account/where.go b/internal/database/ent/db/account/where.go
new file mode 100644
index 00000000..a6b0cd6d
--- /dev/null
+++ b/internal/database/ent/db/account/where.go
@@ -0,0 +1,586 @@
+// Code generated by ent, DO NOT EDIT.
+
+package account
+
+import (
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id string) predicate.Account {
+	return predicate.Account(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id string) predicate.Account {
+	return predicate.Account(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id string) predicate.Account {
+	return predicate.Account(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...string) predicate.Account {
+	return predicate.Account(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...string) predicate.Account {
+	return predicate.Account(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id string) predicate.Account {
+	return predicate.Account(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id string) predicate.Account {
+	return predicate.Account(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id string) predicate.Account {
+	return predicate.Account(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id string) predicate.Account {
+	return predicate.Account(sql.FieldLTE(FieldID, id))
+}
+
+// IDEqualFold applies the EqualFold predicate on the ID field.
+func IDEqualFold(id string) predicate.Account {
+	return predicate.Account(sql.FieldEqualFold(FieldID, id))
+}
+
+// IDContainsFold applies the ContainsFold predicate on the ID field.
+func IDContainsFold(id string) predicate.Account {
+	return predicate.Account(sql.FieldContainsFold(FieldID, id))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v int) predicate.Account {
+	return predicate.Account(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v int) predicate.Account {
+	return predicate.Account(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// LastBattleTime applies equality check predicate on the "last_battle_time" field. It's identical to LastBattleTimeEQ.
+func LastBattleTime(v int) predicate.Account {
+	return predicate.Account(sql.FieldEQ(FieldLastBattleTime, v))
+}
+
+// AccountCreatedAt applies equality check predicate on the "account_created_at" field. It's identical to AccountCreatedAtEQ.
+func AccountCreatedAt(v int) predicate.Account {
+	return predicate.Account(sql.FieldEQ(FieldAccountCreatedAt, v))
+}
+
+// Realm applies equality check predicate on the "realm" field. It's identical to RealmEQ.
+func Realm(v string) predicate.Account {
+	return predicate.Account(sql.FieldEQ(FieldRealm, v))
+}
+
+// Nickname applies equality check predicate on the "nickname" field. It's identical to NicknameEQ.
+func Nickname(v string) predicate.Account {
+	return predicate.Account(sql.FieldEQ(FieldNickname, v))
+}
+
+// Private applies equality check predicate on the "private" field. It's identical to PrivateEQ.
+func Private(v bool) predicate.Account {
+	return predicate.Account(sql.FieldEQ(FieldPrivate, v))
+}
+
+// ClanID applies equality check predicate on the "clan_id" field. It's identical to ClanIDEQ.
+func ClanID(v string) predicate.Account {
+	return predicate.Account(sql.FieldEQ(FieldClanID, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v int) predicate.Account {
+	return predicate.Account(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v int) predicate.Account {
+	return predicate.Account(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...int) predicate.Account {
+	return predicate.Account(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...int) predicate.Account {
+	return predicate.Account(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v int) predicate.Account {
+	return predicate.Account(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v int) predicate.Account {
+	return predicate.Account(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v int) predicate.Account {
+	return predicate.Account(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v int) predicate.Account {
+	return predicate.Account(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v int) predicate.Account {
+	return predicate.Account(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v int) predicate.Account {
+	return predicate.Account(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...int) predicate.Account {
+	return predicate.Account(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...int) predicate.Account {
+	return predicate.Account(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v int) predicate.Account {
+	return predicate.Account(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v int) predicate.Account {
+	return predicate.Account(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v int) predicate.Account {
+	return predicate.Account(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v int) predicate.Account {
+	return predicate.Account(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// LastBattleTimeEQ applies the EQ predicate on the "last_battle_time" field.
+func LastBattleTimeEQ(v int) predicate.Account {
+	return predicate.Account(sql.FieldEQ(FieldLastBattleTime, v))
+}
+
+// LastBattleTimeNEQ applies the NEQ predicate on the "last_battle_time" field.
+func LastBattleTimeNEQ(v int) predicate.Account {
+	return predicate.Account(sql.FieldNEQ(FieldLastBattleTime, v))
+}
+
+// LastBattleTimeIn applies the In predicate on the "last_battle_time" field.
+func LastBattleTimeIn(vs ...int) predicate.Account {
+	return predicate.Account(sql.FieldIn(FieldLastBattleTime, vs...))
+}
+
+// LastBattleTimeNotIn applies the NotIn predicate on the "last_battle_time" field.
+func LastBattleTimeNotIn(vs ...int) predicate.Account {
+	return predicate.Account(sql.FieldNotIn(FieldLastBattleTime, vs...))
+}
+
+// LastBattleTimeGT applies the GT predicate on the "last_battle_time" field.
+func LastBattleTimeGT(v int) predicate.Account {
+	return predicate.Account(sql.FieldGT(FieldLastBattleTime, v))
+}
+
+// LastBattleTimeGTE applies the GTE predicate on the "last_battle_time" field.
+func LastBattleTimeGTE(v int) predicate.Account {
+	return predicate.Account(sql.FieldGTE(FieldLastBattleTime, v))
+}
+
+// LastBattleTimeLT applies the LT predicate on the "last_battle_time" field.
+func LastBattleTimeLT(v int) predicate.Account {
+	return predicate.Account(sql.FieldLT(FieldLastBattleTime, v))
+}
+
+// LastBattleTimeLTE applies the LTE predicate on the "last_battle_time" field.
+func LastBattleTimeLTE(v int) predicate.Account {
+	return predicate.Account(sql.FieldLTE(FieldLastBattleTime, v))
+}
+
+// AccountCreatedAtEQ applies the EQ predicate on the "account_created_at" field.
+func AccountCreatedAtEQ(v int) predicate.Account {
+	return predicate.Account(sql.FieldEQ(FieldAccountCreatedAt, v))
+}
+
+// AccountCreatedAtNEQ applies the NEQ predicate on the "account_created_at" field.
+func AccountCreatedAtNEQ(v int) predicate.Account {
+	return predicate.Account(sql.FieldNEQ(FieldAccountCreatedAt, v))
+}
+
+// AccountCreatedAtIn applies the In predicate on the "account_created_at" field.
+func AccountCreatedAtIn(vs ...int) predicate.Account {
+	return predicate.Account(sql.FieldIn(FieldAccountCreatedAt, vs...))
+}
+
+// AccountCreatedAtNotIn applies the NotIn predicate on the "account_created_at" field.
+func AccountCreatedAtNotIn(vs ...int) predicate.Account {
+	return predicate.Account(sql.FieldNotIn(FieldAccountCreatedAt, vs...))
+}
+
+// AccountCreatedAtGT applies the GT predicate on the "account_created_at" field.
+func AccountCreatedAtGT(v int) predicate.Account {
+	return predicate.Account(sql.FieldGT(FieldAccountCreatedAt, v))
+}
+
+// AccountCreatedAtGTE applies the GTE predicate on the "account_created_at" field.
+func AccountCreatedAtGTE(v int) predicate.Account {
+	return predicate.Account(sql.FieldGTE(FieldAccountCreatedAt, v))
+}
+
+// AccountCreatedAtLT applies the LT predicate on the "account_created_at" field.
+func AccountCreatedAtLT(v int) predicate.Account {
+	return predicate.Account(sql.FieldLT(FieldAccountCreatedAt, v))
+}
+
+// AccountCreatedAtLTE applies the LTE predicate on the "account_created_at" field.
+func AccountCreatedAtLTE(v int) predicate.Account {
+	return predicate.Account(sql.FieldLTE(FieldAccountCreatedAt, v))
+}
+
+// RealmEQ applies the EQ predicate on the "realm" field.
+func RealmEQ(v string) predicate.Account {
+	return predicate.Account(sql.FieldEQ(FieldRealm, v))
+}
+
+// RealmNEQ applies the NEQ predicate on the "realm" field.
+func RealmNEQ(v string) predicate.Account {
+	return predicate.Account(sql.FieldNEQ(FieldRealm, v))
+}
+
+// RealmIn applies the In predicate on the "realm" field.
+func RealmIn(vs ...string) predicate.Account {
+	return predicate.Account(sql.FieldIn(FieldRealm, vs...))
+}
+
+// RealmNotIn applies the NotIn predicate on the "realm" field.
+func RealmNotIn(vs ...string) predicate.Account {
+	return predicate.Account(sql.FieldNotIn(FieldRealm, vs...))
+}
+
+// RealmGT applies the GT predicate on the "realm" field.
+func RealmGT(v string) predicate.Account {
+	return predicate.Account(sql.FieldGT(FieldRealm, v))
+}
+
+// RealmGTE applies the GTE predicate on the "realm" field.
+func RealmGTE(v string) predicate.Account {
+	return predicate.Account(sql.FieldGTE(FieldRealm, v))
+}
+
+// RealmLT applies the LT predicate on the "realm" field.
+func RealmLT(v string) predicate.Account {
+	return predicate.Account(sql.FieldLT(FieldRealm, v))
+}
+
+// RealmLTE applies the LTE predicate on the "realm" field.
+func RealmLTE(v string) predicate.Account {
+	return predicate.Account(sql.FieldLTE(FieldRealm, v))
+}
+
+// RealmContains applies the Contains predicate on the "realm" field.
+func RealmContains(v string) predicate.Account {
+	return predicate.Account(sql.FieldContains(FieldRealm, v))
+}
+
+// RealmHasPrefix applies the HasPrefix predicate on the "realm" field.
+func RealmHasPrefix(v string) predicate.Account {
+	return predicate.Account(sql.FieldHasPrefix(FieldRealm, v))
+}
+
+// RealmHasSuffix applies the HasSuffix predicate on the "realm" field.
+func RealmHasSuffix(v string) predicate.Account {
+	return predicate.Account(sql.FieldHasSuffix(FieldRealm, v))
+}
+
+// RealmEqualFold applies the EqualFold predicate on the "realm" field.
+func RealmEqualFold(v string) predicate.Account {
+	return predicate.Account(sql.FieldEqualFold(FieldRealm, v))
+}
+
+// RealmContainsFold applies the ContainsFold predicate on the "realm" field.
+func RealmContainsFold(v string) predicate.Account {
+	return predicate.Account(sql.FieldContainsFold(FieldRealm, v))
+}
+
+// NicknameEQ applies the EQ predicate on the "nickname" field.
+func NicknameEQ(v string) predicate.Account {
+	return predicate.Account(sql.FieldEQ(FieldNickname, v))
+}
+
+// NicknameNEQ applies the NEQ predicate on the "nickname" field.
+func NicknameNEQ(v string) predicate.Account {
+	return predicate.Account(sql.FieldNEQ(FieldNickname, v))
+}
+
+// NicknameIn applies the In predicate on the "nickname" field.
+func NicknameIn(vs ...string) predicate.Account {
+	return predicate.Account(sql.FieldIn(FieldNickname, vs...))
+}
+
+// NicknameNotIn applies the NotIn predicate on the "nickname" field.
+func NicknameNotIn(vs ...string) predicate.Account {
+	return predicate.Account(sql.FieldNotIn(FieldNickname, vs...))
+}
+
+// NicknameGT applies the GT predicate on the "nickname" field.
+func NicknameGT(v string) predicate.Account {
+	return predicate.Account(sql.FieldGT(FieldNickname, v))
+}
+
+// NicknameGTE applies the GTE predicate on the "nickname" field.
+func NicknameGTE(v string) predicate.Account {
+	return predicate.Account(sql.FieldGTE(FieldNickname, v))
+}
+
+// NicknameLT applies the LT predicate on the "nickname" field.
+func NicknameLT(v string) predicate.Account {
+	return predicate.Account(sql.FieldLT(FieldNickname, v))
+}
+
+// NicknameLTE applies the LTE predicate on the "nickname" field.
+func NicknameLTE(v string) predicate.Account {
+	return predicate.Account(sql.FieldLTE(FieldNickname, v))
+}
+
+// NicknameContains applies the Contains predicate on the "nickname" field.
+func NicknameContains(v string) predicate.Account {
+	return predicate.Account(sql.FieldContains(FieldNickname, v))
+}
+
+// NicknameHasPrefix applies the HasPrefix predicate on the "nickname" field.
+func NicknameHasPrefix(v string) predicate.Account {
+	return predicate.Account(sql.FieldHasPrefix(FieldNickname, v))
+}
+
+// NicknameHasSuffix applies the HasSuffix predicate on the "nickname" field.
+func NicknameHasSuffix(v string) predicate.Account {
+	return predicate.Account(sql.FieldHasSuffix(FieldNickname, v))
+}
+
+// NicknameEqualFold applies the EqualFold predicate on the "nickname" field.
+func NicknameEqualFold(v string) predicate.Account {
+	return predicate.Account(sql.FieldEqualFold(FieldNickname, v))
+}
+
+// NicknameContainsFold applies the ContainsFold predicate on the "nickname" field.
+func NicknameContainsFold(v string) predicate.Account {
+	return predicate.Account(sql.FieldContainsFold(FieldNickname, v))
+}
+
+// PrivateEQ applies the EQ predicate on the "private" field.
+func PrivateEQ(v bool) predicate.Account {
+	return predicate.Account(sql.FieldEQ(FieldPrivate, v))
+}
+
+// PrivateNEQ applies the NEQ predicate on the "private" field.
+func PrivateNEQ(v bool) predicate.Account {
+	return predicate.Account(sql.FieldNEQ(FieldPrivate, v))
+}
+
+// ClanIDEQ applies the EQ predicate on the "clan_id" field.
+func ClanIDEQ(v string) predicate.Account {
+	return predicate.Account(sql.FieldEQ(FieldClanID, v))
+}
+
+// ClanIDNEQ applies the NEQ predicate on the "clan_id" field.
+func ClanIDNEQ(v string) predicate.Account {
+	return predicate.Account(sql.FieldNEQ(FieldClanID, v))
+}
+
+// ClanIDIn applies the In predicate on the "clan_id" field.
+func ClanIDIn(vs ...string) predicate.Account {
+	return predicate.Account(sql.FieldIn(FieldClanID, vs...))
+}
+
+// ClanIDNotIn applies the NotIn predicate on the "clan_id" field.
+func ClanIDNotIn(vs ...string) predicate.Account {
+	return predicate.Account(sql.FieldNotIn(FieldClanID, vs...))
+}
+
+// ClanIDGT applies the GT predicate on the "clan_id" field.
+func ClanIDGT(v string) predicate.Account {
+	return predicate.Account(sql.FieldGT(FieldClanID, v))
+}
+
+// ClanIDGTE applies the GTE predicate on the "clan_id" field.
+func ClanIDGTE(v string) predicate.Account {
+	return predicate.Account(sql.FieldGTE(FieldClanID, v))
+}
+
+// ClanIDLT applies the LT predicate on the "clan_id" field.
+func ClanIDLT(v string) predicate.Account {
+	return predicate.Account(sql.FieldLT(FieldClanID, v))
+}
+
+// ClanIDLTE applies the LTE predicate on the "clan_id" field.
+func ClanIDLTE(v string) predicate.Account {
+	return predicate.Account(sql.FieldLTE(FieldClanID, v))
+}
+
+// ClanIDContains applies the Contains predicate on the "clan_id" field.
+func ClanIDContains(v string) predicate.Account {
+	return predicate.Account(sql.FieldContains(FieldClanID, v))
+}
+
+// ClanIDHasPrefix applies the HasPrefix predicate on the "clan_id" field.
+func ClanIDHasPrefix(v string) predicate.Account {
+	return predicate.Account(sql.FieldHasPrefix(FieldClanID, v))
+}
+
+// ClanIDHasSuffix applies the HasSuffix predicate on the "clan_id" field.
+func ClanIDHasSuffix(v string) predicate.Account {
+	return predicate.Account(sql.FieldHasSuffix(FieldClanID, v))
+}
+
+// ClanIDIsNil applies the IsNil predicate on the "clan_id" field.
+func ClanIDIsNil() predicate.Account {
+	return predicate.Account(sql.FieldIsNull(FieldClanID))
+}
+
+// ClanIDNotNil applies the NotNil predicate on the "clan_id" field.
+func ClanIDNotNil() predicate.Account {
+	return predicate.Account(sql.FieldNotNull(FieldClanID))
+}
+
+// ClanIDEqualFold applies the EqualFold predicate on the "clan_id" field.
+func ClanIDEqualFold(v string) predicate.Account {
+	return predicate.Account(sql.FieldEqualFold(FieldClanID, v))
+}
+
+// ClanIDContainsFold applies the ContainsFold predicate on the "clan_id" field.
+func ClanIDContainsFold(v string) predicate.Account {
+	return predicate.Account(sql.FieldContainsFold(FieldClanID, v))
+}
+
+// HasClan applies the HasEdge predicate on the "clan" edge.
+func HasClan() predicate.Account {
+	return predicate.Account(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, ClanTable, ClanColumn),
+		)
+		sqlgraph.HasNeighbors(s, step)
+	})
+}
+
+// HasClanWith applies the HasEdge predicate on the "clan" edge with a given conditions (other predicates).
+func HasClanWith(preds ...predicate.Clan) predicate.Account {
+	return predicate.Account(func(s *sql.Selector) {
+		step := newClanStep()
+		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+			for _, p := range preds {
+				p(s)
+			}
+		})
+	})
+}
+
+// HasSnapshots applies the HasEdge predicate on the "snapshots" edge.
+func HasSnapshots() predicate.Account {
+	return predicate.Account(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, SnapshotsTable, SnapshotsColumn),
+		)
+		sqlgraph.HasNeighbors(s, step)
+	})
+}
+
+// HasSnapshotsWith applies the HasEdge predicate on the "snapshots" edge with a given conditions (other predicates).
+func HasSnapshotsWith(preds ...predicate.AccountSnapshot) predicate.Account {
+	return predicate.Account(func(s *sql.Selector) {
+		step := newSnapshotsStep()
+		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+			for _, p := range preds {
+				p(s)
+			}
+		})
+	})
+}
+
+// HasVehicleSnapshots applies the HasEdge predicate on the "vehicle_snapshots" edge.
+func HasVehicleSnapshots() predicate.Account {
+	return predicate.Account(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, VehicleSnapshotsTable, VehicleSnapshotsColumn),
+		)
+		sqlgraph.HasNeighbors(s, step)
+	})
+}
+
+// HasVehicleSnapshotsWith applies the HasEdge predicate on the "vehicle_snapshots" edge with a given conditions (other predicates).
+func HasVehicleSnapshotsWith(preds ...predicate.VehicleSnapshot) predicate.Account {
+	return predicate.Account(func(s *sql.Selector) {
+		step := newVehicleSnapshotsStep()
+		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+			for _, p := range preds {
+				p(s)
+			}
+		})
+	})
+}
+
+// HasAchievementSnapshots applies the HasEdge predicate on the "achievement_snapshots" edge.
+func HasAchievementSnapshots() predicate.Account {
+	return predicate.Account(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, AchievementSnapshotsTable, AchievementSnapshotsColumn),
+		)
+		sqlgraph.HasNeighbors(s, step)
+	})
+}
+
+// HasAchievementSnapshotsWith applies the HasEdge predicate on the "achievement_snapshots" edge with a given conditions (other predicates).
+func HasAchievementSnapshotsWith(preds ...predicate.AchievementsSnapshot) predicate.Account {
+	return predicate.Account(func(s *sql.Selector) {
+		step := newAchievementSnapshotsStep()
+		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+			for _, p := range preds {
+				p(s)
+			}
+		})
+	})
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.Account) predicate.Account {
+	return predicate.Account(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.Account) predicate.Account {
+	return predicate.Account(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.Account) predicate.Account {
+	return predicate.Account(sql.NotPredicates(p))
+}
diff --git a/internal/database/ent/db/account_create.go b/internal/database/ent/db/account_create.go
new file mode 100644
index 00000000..4afd1e09
--- /dev/null
+++ b/internal/database/ent/db/account_create.go
@@ -0,0 +1,457 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/account"
+	"github.com/cufee/aftermath/internal/database/ent/db/accountsnapshot"
+	"github.com/cufee/aftermath/internal/database/ent/db/achievementssnapshot"
+	"github.com/cufee/aftermath/internal/database/ent/db/clan"
+	"github.com/cufee/aftermath/internal/database/ent/db/vehiclesnapshot"
+)
+
+// AccountCreate is the builder for creating a Account entity.
+type AccountCreate struct {
+	config
+	mutation *AccountMutation
+	hooks    []Hook
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (ac *AccountCreate) SetCreatedAt(i int) *AccountCreate {
+	ac.mutation.SetCreatedAt(i)
+	return ac
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (ac *AccountCreate) SetNillableCreatedAt(i *int) *AccountCreate {
+	if i != nil {
+		ac.SetCreatedAt(*i)
+	}
+	return ac
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (ac *AccountCreate) SetUpdatedAt(i int) *AccountCreate {
+	ac.mutation.SetUpdatedAt(i)
+	return ac
+}
+
+// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
+func (ac *AccountCreate) SetNillableUpdatedAt(i *int) *AccountCreate {
+	if i != nil {
+		ac.SetUpdatedAt(*i)
+	}
+	return ac
+}
+
+// SetLastBattleTime sets the "last_battle_time" field.
+func (ac *AccountCreate) SetLastBattleTime(i int) *AccountCreate {
+	ac.mutation.SetLastBattleTime(i)
+	return ac
+}
+
+// SetAccountCreatedAt sets the "account_created_at" field.
+func (ac *AccountCreate) SetAccountCreatedAt(i int) *AccountCreate {
+	ac.mutation.SetAccountCreatedAt(i)
+	return ac
+}
+
+// SetRealm sets the "realm" field.
+func (ac *AccountCreate) SetRealm(s string) *AccountCreate {
+	ac.mutation.SetRealm(s)
+	return ac
+}
+
+// SetNickname sets the "nickname" field.
+func (ac *AccountCreate) SetNickname(s string) *AccountCreate {
+	ac.mutation.SetNickname(s)
+	return ac
+}
+
+// SetPrivate sets the "private" field.
+func (ac *AccountCreate) SetPrivate(b bool) *AccountCreate {
+	ac.mutation.SetPrivate(b)
+	return ac
+}
+
+// SetNillablePrivate sets the "private" field if the given value is not nil.
+func (ac *AccountCreate) SetNillablePrivate(b *bool) *AccountCreate {
+	if b != nil {
+		ac.SetPrivate(*b)
+	}
+	return ac
+}
+
+// SetClanID sets the "clan_id" field.
+func (ac *AccountCreate) SetClanID(s string) *AccountCreate {
+	ac.mutation.SetClanID(s)
+	return ac
+}
+
+// SetNillableClanID sets the "clan_id" field if the given value is not nil.
+func (ac *AccountCreate) SetNillableClanID(s *string) *AccountCreate {
+	if s != nil {
+		ac.SetClanID(*s)
+	}
+	return ac
+}
+
+// SetID sets the "id" field.
+func (ac *AccountCreate) SetID(s string) *AccountCreate {
+	ac.mutation.SetID(s)
+	return ac
+}
+
+// SetClan sets the "clan" edge to the Clan entity.
+func (ac *AccountCreate) SetClan(c *Clan) *AccountCreate {
+	return ac.SetClanID(c.ID)
+}
+
+// AddSnapshotIDs adds the "snapshots" edge to the AccountSnapshot entity by IDs.
+func (ac *AccountCreate) AddSnapshotIDs(ids ...string) *AccountCreate {
+	ac.mutation.AddSnapshotIDs(ids...)
+	return ac
+}
+
+// AddSnapshots adds the "snapshots" edges to the AccountSnapshot entity.
+func (ac *AccountCreate) AddSnapshots(a ...*AccountSnapshot) *AccountCreate {
+	ids := make([]string, len(a))
+	for i := range a {
+		ids[i] = a[i].ID
+	}
+	return ac.AddSnapshotIDs(ids...)
+}
+
+// AddVehicleSnapshotIDs adds the "vehicle_snapshots" edge to the VehicleSnapshot entity by IDs.
+func (ac *AccountCreate) AddVehicleSnapshotIDs(ids ...string) *AccountCreate {
+	ac.mutation.AddVehicleSnapshotIDs(ids...)
+	return ac
+}
+
+// AddVehicleSnapshots adds the "vehicle_snapshots" edges to the VehicleSnapshot entity.
+func (ac *AccountCreate) AddVehicleSnapshots(v ...*VehicleSnapshot) *AccountCreate {
+	ids := make([]string, len(v))
+	for i := range v {
+		ids[i] = v[i].ID
+	}
+	return ac.AddVehicleSnapshotIDs(ids...)
+}
+
+// AddAchievementSnapshotIDs adds the "achievement_snapshots" edge to the AchievementsSnapshot entity by IDs.
+func (ac *AccountCreate) AddAchievementSnapshotIDs(ids ...string) *AccountCreate {
+	ac.mutation.AddAchievementSnapshotIDs(ids...)
+	return ac
+}
+
+// AddAchievementSnapshots adds the "achievement_snapshots" edges to the AchievementsSnapshot entity.
+func (ac *AccountCreate) AddAchievementSnapshots(a ...*AchievementsSnapshot) *AccountCreate {
+	ids := make([]string, len(a))
+	for i := range a {
+		ids[i] = a[i].ID
+	}
+	return ac.AddAchievementSnapshotIDs(ids...)
+}
+
+// Mutation returns the AccountMutation object of the builder.
+func (ac *AccountCreate) Mutation() *AccountMutation {
+	return ac.mutation
+}
+
+// Save creates the Account in the database.
+func (ac *AccountCreate) Save(ctx context.Context) (*Account, error) {
+	ac.defaults()
+	return withHooks(ctx, ac.sqlSave, ac.mutation, ac.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (ac *AccountCreate) SaveX(ctx context.Context) *Account {
+	v, err := ac.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (ac *AccountCreate) Exec(ctx context.Context) error {
+	_, err := ac.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (ac *AccountCreate) ExecX(ctx context.Context) {
+	if err := ac.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (ac *AccountCreate) defaults() {
+	if _, ok := ac.mutation.CreatedAt(); !ok {
+		v := account.DefaultCreatedAt()
+		ac.mutation.SetCreatedAt(v)
+	}
+	if _, ok := ac.mutation.UpdatedAt(); !ok {
+		v := account.DefaultUpdatedAt()
+		ac.mutation.SetUpdatedAt(v)
+	}
+	if _, ok := ac.mutation.Private(); !ok {
+		v := account.DefaultPrivate
+		ac.mutation.SetPrivate(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (ac *AccountCreate) check() error {
+	if _, ok := ac.mutation.CreatedAt(); !ok {
+		return &ValidationError{Name: "created_at", err: errors.New(`db: missing required field "Account.created_at"`)}
+	}
+	if _, ok := ac.mutation.UpdatedAt(); !ok {
+		return &ValidationError{Name: "updated_at", err: errors.New(`db: missing required field "Account.updated_at"`)}
+	}
+	if _, ok := ac.mutation.LastBattleTime(); !ok {
+		return &ValidationError{Name: "last_battle_time", err: errors.New(`db: missing required field "Account.last_battle_time"`)}
+	}
+	if _, ok := ac.mutation.AccountCreatedAt(); !ok {
+		return &ValidationError{Name: "account_created_at", err: errors.New(`db: missing required field "Account.account_created_at"`)}
+	}
+	if _, ok := ac.mutation.Realm(); !ok {
+		return &ValidationError{Name: "realm", err: errors.New(`db: missing required field "Account.realm"`)}
+	}
+	if v, ok := ac.mutation.Realm(); ok {
+		if err := account.RealmValidator(v); err != nil {
+			return &ValidationError{Name: "realm", err: fmt.Errorf(`db: validator failed for field "Account.realm": %w`, err)}
+		}
+	}
+	if _, ok := ac.mutation.Nickname(); !ok {
+		return &ValidationError{Name: "nickname", err: errors.New(`db: missing required field "Account.nickname"`)}
+	}
+	if v, ok := ac.mutation.Nickname(); ok {
+		if err := account.NicknameValidator(v); err != nil {
+			return &ValidationError{Name: "nickname", err: fmt.Errorf(`db: validator failed for field "Account.nickname": %w`, err)}
+		}
+	}
+	if _, ok := ac.mutation.Private(); !ok {
+		return &ValidationError{Name: "private", err: errors.New(`db: missing required field "Account.private"`)}
+	}
+	return nil
+}
+
+func (ac *AccountCreate) sqlSave(ctx context.Context) (*Account, error) {
+	if err := ac.check(); err != nil {
+		return nil, err
+	}
+	_node, _spec := ac.createSpec()
+	if err := sqlgraph.CreateNode(ctx, ac.driver, _spec); err != nil {
+		if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	if _spec.ID.Value != nil {
+		if id, ok := _spec.ID.Value.(string); ok {
+			_node.ID = id
+		} else {
+			return nil, fmt.Errorf("unexpected Account.ID type: %T", _spec.ID.Value)
+		}
+	}
+	ac.mutation.id = &_node.ID
+	ac.mutation.done = true
+	return _node, nil
+}
+
+func (ac *AccountCreate) createSpec() (*Account, *sqlgraph.CreateSpec) {
+	var (
+		_node = &Account{config: ac.config}
+		_spec = sqlgraph.NewCreateSpec(account.Table, sqlgraph.NewFieldSpec(account.FieldID, field.TypeString))
+	)
+	if id, ok := ac.mutation.ID(); ok {
+		_node.ID = id
+		_spec.ID.Value = id
+	}
+	if value, ok := ac.mutation.CreatedAt(); ok {
+		_spec.SetField(account.FieldCreatedAt, field.TypeInt, value)
+		_node.CreatedAt = value
+	}
+	if value, ok := ac.mutation.UpdatedAt(); ok {
+		_spec.SetField(account.FieldUpdatedAt, field.TypeInt, value)
+		_node.UpdatedAt = value
+	}
+	if value, ok := ac.mutation.LastBattleTime(); ok {
+		_spec.SetField(account.FieldLastBattleTime, field.TypeInt, value)
+		_node.LastBattleTime = value
+	}
+	if value, ok := ac.mutation.AccountCreatedAt(); ok {
+		_spec.SetField(account.FieldAccountCreatedAt, field.TypeInt, value)
+		_node.AccountCreatedAt = value
+	}
+	if value, ok := ac.mutation.Realm(); ok {
+		_spec.SetField(account.FieldRealm, field.TypeString, value)
+		_node.Realm = value
+	}
+	if value, ok := ac.mutation.Nickname(); ok {
+		_spec.SetField(account.FieldNickname, field.TypeString, value)
+		_node.Nickname = value
+	}
+	if value, ok := ac.mutation.Private(); ok {
+		_spec.SetField(account.FieldPrivate, field.TypeBool, value)
+		_node.Private = value
+	}
+	if nodes := ac.mutation.ClanIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   account.ClanTable,
+			Columns: []string{account.ClanColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(clan.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_node.ClanID = nodes[0]
+		_spec.Edges = append(_spec.Edges, edge)
+	}
+	if nodes := ac.mutation.SnapshotsIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   account.SnapshotsTable,
+			Columns: []string{account.SnapshotsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(accountsnapshot.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges = append(_spec.Edges, edge)
+	}
+	if nodes := ac.mutation.VehicleSnapshotsIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   account.VehicleSnapshotsTable,
+			Columns: []string{account.VehicleSnapshotsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(vehiclesnapshot.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges = append(_spec.Edges, edge)
+	}
+	if nodes := ac.mutation.AchievementSnapshotsIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   account.AchievementSnapshotsTable,
+			Columns: []string{account.AchievementSnapshotsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges = append(_spec.Edges, edge)
+	}
+	return _node, _spec
+}
+
+// AccountCreateBulk is the builder for creating many Account entities in bulk.
+type AccountCreateBulk struct {
+	config
+	err      error
+	builders []*AccountCreate
+}
+
+// Save creates the Account entities in the database.
+func (acb *AccountCreateBulk) Save(ctx context.Context) ([]*Account, error) {
+	if acb.err != nil {
+		return nil, acb.err
+	}
+	specs := make([]*sqlgraph.CreateSpec, len(acb.builders))
+	nodes := make([]*Account, len(acb.builders))
+	mutators := make([]Mutator, len(acb.builders))
+	for i := range acb.builders {
+		func(i int, root context.Context) {
+			builder := acb.builders[i]
+			builder.defaults()
+			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+				mutation, ok := m.(*AccountMutation)
+				if !ok {
+					return nil, fmt.Errorf("unexpected mutation type %T", m)
+				}
+				if err := builder.check(); err != nil {
+					return nil, err
+				}
+				builder.mutation = mutation
+				var err error
+				nodes[i], specs[i] = builder.createSpec()
+				if i < len(mutators)-1 {
+					_, err = mutators[i+1].Mutate(root, acb.builders[i+1].mutation)
+				} else {
+					spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
+					// Invoke the actual operation on the latest mutation in the chain.
+					if err = sqlgraph.BatchCreate(ctx, acb.driver, spec); err != nil {
+						if sqlgraph.IsConstraintError(err) {
+							err = &ConstraintError{msg: err.Error(), wrap: err}
+						}
+					}
+				}
+				if err != nil {
+					return nil, err
+				}
+				mutation.id = &nodes[i].ID
+				mutation.done = true
+				return nodes[i], nil
+			})
+			for i := len(builder.hooks) - 1; i >= 0; i-- {
+				mut = builder.hooks[i](mut)
+			}
+			mutators[i] = mut
+		}(i, ctx)
+	}
+	if len(mutators) > 0 {
+		if _, err := mutators[0].Mutate(ctx, acb.builders[0].mutation); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (acb *AccountCreateBulk) SaveX(ctx context.Context) []*Account {
+	v, err := acb.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (acb *AccountCreateBulk) Exec(ctx context.Context) error {
+	_, err := acb.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (acb *AccountCreateBulk) ExecX(ctx context.Context) {
+	if err := acb.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/database/ent/db/account_delete.go b/internal/database/ent/db/account_delete.go
new file mode 100644
index 00000000..df490811
--- /dev/null
+++ b/internal/database/ent/db/account_delete.go
@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/account"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+)
+
+// AccountDelete is the builder for deleting a Account entity.
+type AccountDelete struct {
+	config
+	hooks    []Hook
+	mutation *AccountMutation
+}
+
+// Where appends a list predicates to the AccountDelete builder.
+func (ad *AccountDelete) Where(ps ...predicate.Account) *AccountDelete {
+	ad.mutation.Where(ps...)
+	return ad
+}
+
+// Exec executes the deletion query and returns how many vertices were deleted.
+func (ad *AccountDelete) Exec(ctx context.Context) (int, error) {
+	return withHooks(ctx, ad.sqlExec, ad.mutation, ad.hooks)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (ad *AccountDelete) ExecX(ctx context.Context) int {
+	n, err := ad.Exec(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return n
+}
+
+func (ad *AccountDelete) sqlExec(ctx context.Context) (int, error) {
+	_spec := sqlgraph.NewDeleteSpec(account.Table, sqlgraph.NewFieldSpec(account.FieldID, field.TypeString))
+	if ps := ad.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	affected, err := sqlgraph.DeleteNodes(ctx, ad.driver, _spec)
+	if err != nil && sqlgraph.IsConstraintError(err) {
+		err = &ConstraintError{msg: err.Error(), wrap: err}
+	}
+	ad.mutation.done = true
+	return affected, err
+}
+
+// AccountDeleteOne is the builder for deleting a single Account entity.
+type AccountDeleteOne struct {
+	ad *AccountDelete
+}
+
+// Where appends a list predicates to the AccountDelete builder.
+func (ado *AccountDeleteOne) Where(ps ...predicate.Account) *AccountDeleteOne {
+	ado.ad.mutation.Where(ps...)
+	return ado
+}
+
+// Exec executes the deletion query.
+func (ado *AccountDeleteOne) Exec(ctx context.Context) error {
+	n, err := ado.ad.Exec(ctx)
+	switch {
+	case err != nil:
+		return err
+	case n == 0:
+		return &NotFoundError{account.Label}
+	default:
+		return nil
+	}
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (ado *AccountDeleteOne) ExecX(ctx context.Context) {
+	if err := ado.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/database/ent/db/account_query.go b/internal/database/ent/db/account_query.go
new file mode 100644
index 00000000..9dce0052
--- /dev/null
+++ b/internal/database/ent/db/account_query.go
@@ -0,0 +1,830 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"database/sql/driver"
+	"fmt"
+	"math"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/account"
+	"github.com/cufee/aftermath/internal/database/ent/db/accountsnapshot"
+	"github.com/cufee/aftermath/internal/database/ent/db/achievementssnapshot"
+	"github.com/cufee/aftermath/internal/database/ent/db/clan"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/ent/db/vehiclesnapshot"
+)
+
+// AccountQuery is the builder for querying Account entities.
+type AccountQuery struct {
+	config
+	ctx                      *QueryContext
+	order                    []account.OrderOption
+	inters                   []Interceptor
+	predicates               []predicate.Account
+	withClan                 *ClanQuery
+	withSnapshots            *AccountSnapshotQuery
+	withVehicleSnapshots     *VehicleSnapshotQuery
+	withAchievementSnapshots *AchievementsSnapshotQuery
+	// intermediate query (i.e. traversal path).
+	sql  *sql.Selector
+	path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the AccountQuery builder.
+func (aq *AccountQuery) Where(ps ...predicate.Account) *AccountQuery {
+	aq.predicates = append(aq.predicates, ps...)
+	return aq
+}
+
+// Limit the number of records to be returned by this query.
+func (aq *AccountQuery) Limit(limit int) *AccountQuery {
+	aq.ctx.Limit = &limit
+	return aq
+}
+
+// Offset to start from.
+func (aq *AccountQuery) Offset(offset int) *AccountQuery {
+	aq.ctx.Offset = &offset
+	return aq
+}
+
+// Unique configures the query builder to filter duplicate records on query.
+// By default, unique is set to true, and can be disabled using this method.
+func (aq *AccountQuery) Unique(unique bool) *AccountQuery {
+	aq.ctx.Unique = &unique
+	return aq
+}
+
+// Order specifies how the records should be ordered.
+func (aq *AccountQuery) Order(o ...account.OrderOption) *AccountQuery {
+	aq.order = append(aq.order, o...)
+	return aq
+}
+
+// QueryClan chains the current query on the "clan" edge.
+func (aq *AccountQuery) QueryClan() *ClanQuery {
+	query := (&ClanClient{config: aq.config}).Query()
+	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+		if err := aq.prepareQuery(ctx); err != nil {
+			return nil, err
+		}
+		selector := aq.sqlQuery(ctx)
+		if err := selector.Err(); err != nil {
+			return nil, err
+		}
+		step := sqlgraph.NewStep(
+			sqlgraph.From(account.Table, account.FieldID, selector),
+			sqlgraph.To(clan.Table, clan.FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, account.ClanTable, account.ClanColumn),
+		)
+		fromU = sqlgraph.SetNeighbors(aq.driver.Dialect(), step)
+		return fromU, nil
+	}
+	return query
+}
+
+// QuerySnapshots chains the current query on the "snapshots" edge.
+func (aq *AccountQuery) QuerySnapshots() *AccountSnapshotQuery {
+	query := (&AccountSnapshotClient{config: aq.config}).Query()
+	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+		if err := aq.prepareQuery(ctx); err != nil {
+			return nil, err
+		}
+		selector := aq.sqlQuery(ctx)
+		if err := selector.Err(); err != nil {
+			return nil, err
+		}
+		step := sqlgraph.NewStep(
+			sqlgraph.From(account.Table, account.FieldID, selector),
+			sqlgraph.To(accountsnapshot.Table, accountsnapshot.FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, account.SnapshotsTable, account.SnapshotsColumn),
+		)
+		fromU = sqlgraph.SetNeighbors(aq.driver.Dialect(), step)
+		return fromU, nil
+	}
+	return query
+}
+
+// QueryVehicleSnapshots chains the current query on the "vehicle_snapshots" edge.
+func (aq *AccountQuery) QueryVehicleSnapshots() *VehicleSnapshotQuery {
+	query := (&VehicleSnapshotClient{config: aq.config}).Query()
+	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+		if err := aq.prepareQuery(ctx); err != nil {
+			return nil, err
+		}
+		selector := aq.sqlQuery(ctx)
+		if err := selector.Err(); err != nil {
+			return nil, err
+		}
+		step := sqlgraph.NewStep(
+			sqlgraph.From(account.Table, account.FieldID, selector),
+			sqlgraph.To(vehiclesnapshot.Table, vehiclesnapshot.FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, account.VehicleSnapshotsTable, account.VehicleSnapshotsColumn),
+		)
+		fromU = sqlgraph.SetNeighbors(aq.driver.Dialect(), step)
+		return fromU, nil
+	}
+	return query
+}
+
+// QueryAchievementSnapshots chains the current query on the "achievement_snapshots" edge.
+func (aq *AccountQuery) QueryAchievementSnapshots() *AchievementsSnapshotQuery {
+	query := (&AchievementsSnapshotClient{config: aq.config}).Query()
+	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+		if err := aq.prepareQuery(ctx); err != nil {
+			return nil, err
+		}
+		selector := aq.sqlQuery(ctx)
+		if err := selector.Err(); err != nil {
+			return nil, err
+		}
+		step := sqlgraph.NewStep(
+			sqlgraph.From(account.Table, account.FieldID, selector),
+			sqlgraph.To(achievementssnapshot.Table, achievementssnapshot.FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, account.AchievementSnapshotsTable, account.AchievementSnapshotsColumn),
+		)
+		fromU = sqlgraph.SetNeighbors(aq.driver.Dialect(), step)
+		return fromU, nil
+	}
+	return query
+}
+
+// First returns the first Account entity from the query.
+// Returns a *NotFoundError when no Account was found.
+func (aq *AccountQuery) First(ctx context.Context) (*Account, error) {
+	nodes, err := aq.Limit(1).All(setContextOp(ctx, aq.ctx, "First"))
+	if err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nil, &NotFoundError{account.Label}
+	}
+	return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (aq *AccountQuery) FirstX(ctx context.Context) *Account {
+	node, err := aq.First(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return node
+}
+
+// FirstID returns the first Account ID from the query.
+// Returns a *NotFoundError when no Account ID was found.
+func (aq *AccountQuery) FirstID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = aq.Limit(1).IDs(setContextOp(ctx, aq.ctx, "FirstID")); err != nil {
+		return
+	}
+	if len(ids) == 0 {
+		err = &NotFoundError{account.Label}
+		return
+	}
+	return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (aq *AccountQuery) FirstIDX(ctx context.Context) string {
+	id, err := aq.FirstID(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return id
+}
+
+// Only returns a single Account entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one Account entity is found.
+// Returns a *NotFoundError when no Account entities are found.
+func (aq *AccountQuery) Only(ctx context.Context) (*Account, error) {
+	nodes, err := aq.Limit(2).All(setContextOp(ctx, aq.ctx, "Only"))
+	if err != nil {
+		return nil, err
+	}
+	switch len(nodes) {
+	case 1:
+		return nodes[0], nil
+	case 0:
+		return nil, &NotFoundError{account.Label}
+	default:
+		return nil, &NotSingularError{account.Label}
+	}
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (aq *AccountQuery) OnlyX(ctx context.Context) *Account {
+	node, err := aq.Only(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// OnlyID is like Only, but returns the only Account ID in the query.
+// Returns a *NotSingularError when more than one Account ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (aq *AccountQuery) OnlyID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = aq.Limit(2).IDs(setContextOp(ctx, aq.ctx, "OnlyID")); err != nil {
+		return
+	}
+	switch len(ids) {
+	case 1:
+		id = ids[0]
+	case 0:
+		err = &NotFoundError{account.Label}
+	default:
+		err = &NotSingularError{account.Label}
+	}
+	return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (aq *AccountQuery) OnlyIDX(ctx context.Context) string {
+	id, err := aq.OnlyID(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return id
+}
+
+// All executes the query and returns a list of Accounts.
+func (aq *AccountQuery) All(ctx context.Context) ([]*Account, error) {
+	ctx = setContextOp(ctx, aq.ctx, "All")
+	if err := aq.prepareQuery(ctx); err != nil {
+		return nil, err
+	}
+	qr := querierAll[[]*Account, *AccountQuery]()
+	return withInterceptors[[]*Account](ctx, aq, qr, aq.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (aq *AccountQuery) AllX(ctx context.Context) []*Account {
+	nodes, err := aq.All(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return nodes
+}
+
+// IDs executes the query and returns a list of Account IDs.
+func (aq *AccountQuery) IDs(ctx context.Context) (ids []string, err error) {
+	if aq.ctx.Unique == nil && aq.path != nil {
+		aq.Unique(true)
+	}
+	ctx = setContextOp(ctx, aq.ctx, "IDs")
+	if err = aq.Select(account.FieldID).Scan(ctx, &ids); err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (aq *AccountQuery) IDsX(ctx context.Context) []string {
+	ids, err := aq.IDs(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return ids
+}
+
+// Count returns the count of the given query.
+func (aq *AccountQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, aq.ctx, "Count")
+	if err := aq.prepareQuery(ctx); err != nil {
+		return 0, err
+	}
+	return withInterceptors[int](ctx, aq, querierCount[*AccountQuery](), aq.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (aq *AccountQuery) CountX(ctx context.Context) int {
+	count, err := aq.Count(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (aq *AccountQuery) Exist(ctx context.Context) (bool, error) {
+	ctx = setContextOp(ctx, aq.ctx, "Exist")
+	switch _, err := aq.FirstID(ctx); {
+	case IsNotFound(err):
+		return false, nil
+	case err != nil:
+		return false, fmt.Errorf("db: check existence: %w", err)
+	default:
+		return true, nil
+	}
+}
+
+// ExistX is like Exist, but panics if an error occurs.
+func (aq *AccountQuery) ExistX(ctx context.Context) bool {
+	exist, err := aq.Exist(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return exist
+}
+
+// Clone returns a duplicate of the AccountQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (aq *AccountQuery) Clone() *AccountQuery {
+	if aq == nil {
+		return nil
+	}
+	return &AccountQuery{
+		config:                   aq.config,
+		ctx:                      aq.ctx.Clone(),
+		order:                    append([]account.OrderOption{}, aq.order...),
+		inters:                   append([]Interceptor{}, aq.inters...),
+		predicates:               append([]predicate.Account{}, aq.predicates...),
+		withClan:                 aq.withClan.Clone(),
+		withSnapshots:            aq.withSnapshots.Clone(),
+		withVehicleSnapshots:     aq.withVehicleSnapshots.Clone(),
+		withAchievementSnapshots: aq.withAchievementSnapshots.Clone(),
+		// clone intermediate query.
+		sql:  aq.sql.Clone(),
+		path: aq.path,
+	}
+}
+
+// WithClan tells the query-builder to eager-load the nodes that are connected to
+// the "clan" edge. The optional arguments are used to configure the query builder of the edge.
+func (aq *AccountQuery) WithClan(opts ...func(*ClanQuery)) *AccountQuery {
+	query := (&ClanClient{config: aq.config}).Query()
+	for _, opt := range opts {
+		opt(query)
+	}
+	aq.withClan = query
+	return aq
+}
+
+// WithSnapshots tells the query-builder to eager-load the nodes that are connected to
+// the "snapshots" edge. The optional arguments are used to configure the query builder of the edge.
+func (aq *AccountQuery) WithSnapshots(opts ...func(*AccountSnapshotQuery)) *AccountQuery {
+	query := (&AccountSnapshotClient{config: aq.config}).Query()
+	for _, opt := range opts {
+		opt(query)
+	}
+	aq.withSnapshots = query
+	return aq
+}
+
+// WithVehicleSnapshots tells the query-builder to eager-load the nodes that are connected to
+// the "vehicle_snapshots" edge. The optional arguments are used to configure the query builder of the edge.
+func (aq *AccountQuery) WithVehicleSnapshots(opts ...func(*VehicleSnapshotQuery)) *AccountQuery {
+	query := (&VehicleSnapshotClient{config: aq.config}).Query()
+	for _, opt := range opts {
+		opt(query)
+	}
+	aq.withVehicleSnapshots = query
+	return aq
+}
+
+// WithAchievementSnapshots tells the query-builder to eager-load the nodes that are connected to
+// the "achievement_snapshots" edge. The optional arguments are used to configure the query builder of the edge.
+func (aq *AccountQuery) WithAchievementSnapshots(opts ...func(*AchievementsSnapshotQuery)) *AccountQuery {
+	query := (&AchievementsSnapshotClient{config: aq.config}).Query()
+	for _, opt := range opts {
+		opt(query)
+	}
+	aq.withAchievementSnapshots = query
+	return aq
+}
+
+// GroupBy is used to group vertices by one or more fields/columns.
+// It is often used with aggregate functions, like: count, max, mean, min, sum.
+//
+// Example:
+//
+//	var v []struct {
+//		CreatedAt int `json:"created_at,omitempty"`
+//		Count int `json:"count,omitempty"`
+//	}
+//
+//	client.Account.Query().
+//		GroupBy(account.FieldCreatedAt).
+//		Aggregate(db.Count()).
+//		Scan(ctx, &v)
+func (aq *AccountQuery) GroupBy(field string, fields ...string) *AccountGroupBy {
+	aq.ctx.Fields = append([]string{field}, fields...)
+	grbuild := &AccountGroupBy{build: aq}
+	grbuild.flds = &aq.ctx.Fields
+	grbuild.label = account.Label
+	grbuild.scan = grbuild.Scan
+	return grbuild
+}
+
+// Select allows the selection one or more fields/columns for the given query,
+// instead of selecting all fields in the entity.
+//
+// Example:
+//
+//	var v []struct {
+//		CreatedAt int `json:"created_at,omitempty"`
+//	}
+//
+//	client.Account.Query().
+//		Select(account.FieldCreatedAt).
+//		Scan(ctx, &v)
+func (aq *AccountQuery) Select(fields ...string) *AccountSelect {
+	aq.ctx.Fields = append(aq.ctx.Fields, fields...)
+	sbuild := &AccountSelect{AccountQuery: aq}
+	sbuild.label = account.Label
+	sbuild.flds, sbuild.scan = &aq.ctx.Fields, sbuild.Scan
+	return sbuild
+}
+
+// Aggregate returns a AccountSelect configured with the given aggregations.
+func (aq *AccountQuery) Aggregate(fns ...AggregateFunc) *AccountSelect {
+	return aq.Select().Aggregate(fns...)
+}
+
+func (aq *AccountQuery) prepareQuery(ctx context.Context) error {
+	for _, inter := range aq.inters {
+		if inter == nil {
+			return fmt.Errorf("db: uninitialized interceptor (forgotten import db/runtime?)")
+		}
+		if trv, ok := inter.(Traverser); ok {
+			if err := trv.Traverse(ctx, aq); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range aq.ctx.Fields {
+		if !account.ValidColumn(f) {
+			return &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+		}
+	}
+	if aq.path != nil {
+		prev, err := aq.path(ctx)
+		if err != nil {
+			return err
+		}
+		aq.sql = prev
+	}
+	return nil
+}
+
+func (aq *AccountQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Account, error) {
+	var (
+		nodes       = []*Account{}
+		_spec       = aq.querySpec()
+		loadedTypes = [4]bool{
+			aq.withClan != nil,
+			aq.withSnapshots != nil,
+			aq.withVehicleSnapshots != nil,
+			aq.withAchievementSnapshots != nil,
+		}
+	)
+	_spec.ScanValues = func(columns []string) ([]any, error) {
+		return (*Account).scanValues(nil, columns)
+	}
+	_spec.Assign = func(columns []string, values []any) error {
+		node := &Account{config: aq.config}
+		nodes = append(nodes, node)
+		node.Edges.loadedTypes = loadedTypes
+		return node.assignValues(columns, values)
+	}
+	for i := range hooks {
+		hooks[i](ctx, _spec)
+	}
+	if err := sqlgraph.QueryNodes(ctx, aq.driver, _spec); err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nodes, nil
+	}
+	if query := aq.withClan; query != nil {
+		if err := aq.loadClan(ctx, query, nodes, nil,
+			func(n *Account, e *Clan) { n.Edges.Clan = e }); err != nil {
+			return nil, err
+		}
+	}
+	if query := aq.withSnapshots; query != nil {
+		if err := aq.loadSnapshots(ctx, query, nodes,
+			func(n *Account) { n.Edges.Snapshots = []*AccountSnapshot{} },
+			func(n *Account, e *AccountSnapshot) { n.Edges.Snapshots = append(n.Edges.Snapshots, e) }); err != nil {
+			return nil, err
+		}
+	}
+	if query := aq.withVehicleSnapshots; query != nil {
+		if err := aq.loadVehicleSnapshots(ctx, query, nodes,
+			func(n *Account) { n.Edges.VehicleSnapshots = []*VehicleSnapshot{} },
+			func(n *Account, e *VehicleSnapshot) { n.Edges.VehicleSnapshots = append(n.Edges.VehicleSnapshots, e) }); err != nil {
+			return nil, err
+		}
+	}
+	if query := aq.withAchievementSnapshots; query != nil {
+		if err := aq.loadAchievementSnapshots(ctx, query, nodes,
+			func(n *Account) { n.Edges.AchievementSnapshots = []*AchievementsSnapshot{} },
+			func(n *Account, e *AchievementsSnapshot) {
+				n.Edges.AchievementSnapshots = append(n.Edges.AchievementSnapshots, e)
+			}); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+func (aq *AccountQuery) loadClan(ctx context.Context, query *ClanQuery, nodes []*Account, init func(*Account), assign func(*Account, *Clan)) error {
+	ids := make([]string, 0, len(nodes))
+	nodeids := make(map[string][]*Account)
+	for i := range nodes {
+		fk := nodes[i].ClanID
+		if _, ok := nodeids[fk]; !ok {
+			ids = append(ids, fk)
+		}
+		nodeids[fk] = append(nodeids[fk], nodes[i])
+	}
+	if len(ids) == 0 {
+		return nil
+	}
+	query.Where(clan.IDIn(ids...))
+	neighbors, err := query.All(ctx)
+	if err != nil {
+		return err
+	}
+	for _, n := range neighbors {
+		nodes, ok := nodeids[n.ID]
+		if !ok {
+			return fmt.Errorf(`unexpected foreign-key "clan_id" returned %v`, n.ID)
+		}
+		for i := range nodes {
+			assign(nodes[i], n)
+		}
+	}
+	return nil
+}
+func (aq *AccountQuery) loadSnapshots(ctx context.Context, query *AccountSnapshotQuery, nodes []*Account, init func(*Account), assign func(*Account, *AccountSnapshot)) error {
+	fks := make([]driver.Value, 0, len(nodes))
+	nodeids := make(map[string]*Account)
+	for i := range nodes {
+		fks = append(fks, nodes[i].ID)
+		nodeids[nodes[i].ID] = nodes[i]
+		if init != nil {
+			init(nodes[i])
+		}
+	}
+	if len(query.ctx.Fields) > 0 {
+		query.ctx.AppendFieldOnce(accountsnapshot.FieldAccountID)
+	}
+	query.Where(predicate.AccountSnapshot(func(s *sql.Selector) {
+		s.Where(sql.InValues(s.C(account.SnapshotsColumn), fks...))
+	}))
+	neighbors, err := query.All(ctx)
+	if err != nil {
+		return err
+	}
+	for _, n := range neighbors {
+		fk := n.AccountID
+		node, ok := nodeids[fk]
+		if !ok {
+			return fmt.Errorf(`unexpected referenced foreign-key "account_id" returned %v for node %v`, fk, n.ID)
+		}
+		assign(node, n)
+	}
+	return nil
+}
+func (aq *AccountQuery) loadVehicleSnapshots(ctx context.Context, query *VehicleSnapshotQuery, nodes []*Account, init func(*Account), assign func(*Account, *VehicleSnapshot)) error {
+	fks := make([]driver.Value, 0, len(nodes))
+	nodeids := make(map[string]*Account)
+	for i := range nodes {
+		fks = append(fks, nodes[i].ID)
+		nodeids[nodes[i].ID] = nodes[i]
+		if init != nil {
+			init(nodes[i])
+		}
+	}
+	if len(query.ctx.Fields) > 0 {
+		query.ctx.AppendFieldOnce(vehiclesnapshot.FieldAccountID)
+	}
+	query.Where(predicate.VehicleSnapshot(func(s *sql.Selector) {
+		s.Where(sql.InValues(s.C(account.VehicleSnapshotsColumn), fks...))
+	}))
+	neighbors, err := query.All(ctx)
+	if err != nil {
+		return err
+	}
+	for _, n := range neighbors {
+		fk := n.AccountID
+		node, ok := nodeids[fk]
+		if !ok {
+			return fmt.Errorf(`unexpected referenced foreign-key "account_id" returned %v for node %v`, fk, n.ID)
+		}
+		assign(node, n)
+	}
+	return nil
+}
+func (aq *AccountQuery) loadAchievementSnapshots(ctx context.Context, query *AchievementsSnapshotQuery, nodes []*Account, init func(*Account), assign func(*Account, *AchievementsSnapshot)) error {
+	fks := make([]driver.Value, 0, len(nodes))
+	nodeids := make(map[string]*Account)
+	for i := range nodes {
+		fks = append(fks, nodes[i].ID)
+		nodeids[nodes[i].ID] = nodes[i]
+		if init != nil {
+			init(nodes[i])
+		}
+	}
+	if len(query.ctx.Fields) > 0 {
+		query.ctx.AppendFieldOnce(achievementssnapshot.FieldAccountID)
+	}
+	query.Where(predicate.AchievementsSnapshot(func(s *sql.Selector) {
+		s.Where(sql.InValues(s.C(account.AchievementSnapshotsColumn), fks...))
+	}))
+	neighbors, err := query.All(ctx)
+	if err != nil {
+		return err
+	}
+	for _, n := range neighbors {
+		fk := n.AccountID
+		node, ok := nodeids[fk]
+		if !ok {
+			return fmt.Errorf(`unexpected referenced foreign-key "account_id" returned %v for node %v`, fk, n.ID)
+		}
+		assign(node, n)
+	}
+	return nil
+}
+
+func (aq *AccountQuery) sqlCount(ctx context.Context) (int, error) {
+	_spec := aq.querySpec()
+	_spec.Node.Columns = aq.ctx.Fields
+	if len(aq.ctx.Fields) > 0 {
+		_spec.Unique = aq.ctx.Unique != nil && *aq.ctx.Unique
+	}
+	return sqlgraph.CountNodes(ctx, aq.driver, _spec)
+}
+
+func (aq *AccountQuery) querySpec() *sqlgraph.QuerySpec {
+	_spec := sqlgraph.NewQuerySpec(account.Table, account.Columns, sqlgraph.NewFieldSpec(account.FieldID, field.TypeString))
+	_spec.From = aq.sql
+	if unique := aq.ctx.Unique; unique != nil {
+		_spec.Unique = *unique
+	} else if aq.path != nil {
+		_spec.Unique = true
+	}
+	if fields := aq.ctx.Fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, account.FieldID)
+		for i := range fields {
+			if fields[i] != account.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+			}
+		}
+		if aq.withClan != nil {
+			_spec.Node.AddColumnOnce(account.FieldClanID)
+		}
+	}
+	if ps := aq.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if limit := aq.ctx.Limit; limit != nil {
+		_spec.Limit = *limit
+	}
+	if offset := aq.ctx.Offset; offset != nil {
+		_spec.Offset = *offset
+	}
+	if ps := aq.order; len(ps) > 0 {
+		_spec.Order = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	return _spec
+}
+
+func (aq *AccountQuery) sqlQuery(ctx context.Context) *sql.Selector {
+	builder := sql.Dialect(aq.driver.Dialect())
+	t1 := builder.Table(account.Table)
+	columns := aq.ctx.Fields
+	if len(columns) == 0 {
+		columns = account.Columns
+	}
+	selector := builder.Select(t1.Columns(columns...)...).From(t1)
+	if aq.sql != nil {
+		selector = aq.sql
+		selector.Select(selector.Columns(columns...)...)
+	}
+	if aq.ctx.Unique != nil && *aq.ctx.Unique {
+		selector.Distinct()
+	}
+	for _, p := range aq.predicates {
+		p(selector)
+	}
+	for _, p := range aq.order {
+		p(selector)
+	}
+	if offset := aq.ctx.Offset; offset != nil {
+		// limit is mandatory for offset clause. We start
+		// with default value, and override it below if needed.
+		selector.Offset(*offset).Limit(math.MaxInt32)
+	}
+	if limit := aq.ctx.Limit; limit != nil {
+		selector.Limit(*limit)
+	}
+	return selector
+}
+
+// AccountGroupBy is the group-by builder for Account entities.
+type AccountGroupBy struct {
+	selector
+	build *AccountQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (agb *AccountGroupBy) Aggregate(fns ...AggregateFunc) *AccountGroupBy {
+	agb.fns = append(agb.fns, fns...)
+	return agb
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (agb *AccountGroupBy) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, agb.build.ctx, "GroupBy")
+	if err := agb.build.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*AccountQuery, *AccountGroupBy](ctx, agb.build, agb, agb.build.inters, v)
+}
+
+func (agb *AccountGroupBy) sqlScan(ctx context.Context, root *AccountQuery, v any) error {
+	selector := root.sqlQuery(ctx).Select()
+	aggregation := make([]string, 0, len(agb.fns))
+	for _, fn := range agb.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*agb.flds)+len(agb.fns))
+		for _, f := range *agb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*agb.flds...)...)
+	if err := selector.Err(); err != nil {
+		return err
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := agb.build.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
+
+// AccountSelect is the builder for selecting fields of Account entities.
+type AccountSelect struct {
+	*AccountQuery
+	selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (as *AccountSelect) Aggregate(fns ...AggregateFunc) *AccountSelect {
+	as.fns = append(as.fns, fns...)
+	return as
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (as *AccountSelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, as.ctx, "Select")
+	if err := as.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*AccountQuery, *AccountSelect](ctx, as.AccountQuery, as, as.inters, v)
+}
+
+func (as *AccountSelect) sqlScan(ctx context.Context, root *AccountQuery, v any) error {
+	selector := root.sqlQuery(ctx)
+	aggregation := make([]string, 0, len(as.fns))
+	for _, fn := range as.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	switch n := len(*as.selector.flds); {
+	case n == 0 && len(aggregation) > 0:
+		selector.Select(aggregation...)
+	case n != 0 && len(aggregation) > 0:
+		selector.AppendSelect(aggregation...)
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := as.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
diff --git a/internal/database/ent/db/account_update.go b/internal/database/ent/db/account_update.go
new file mode 100644
index 00000000..c58f930b
--- /dev/null
+++ b/internal/database/ent/db/account_update.go
@@ -0,0 +1,1087 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/account"
+	"github.com/cufee/aftermath/internal/database/ent/db/accountsnapshot"
+	"github.com/cufee/aftermath/internal/database/ent/db/achievementssnapshot"
+	"github.com/cufee/aftermath/internal/database/ent/db/clan"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/ent/db/vehiclesnapshot"
+)
+
+// AccountUpdate is the builder for updating Account entities.
+type AccountUpdate struct {
+	config
+	hooks    []Hook
+	mutation *AccountMutation
+}
+
+// Where appends a list predicates to the AccountUpdate builder.
+func (au *AccountUpdate) Where(ps ...predicate.Account) *AccountUpdate {
+	au.mutation.Where(ps...)
+	return au
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (au *AccountUpdate) SetUpdatedAt(i int) *AccountUpdate {
+	au.mutation.ResetUpdatedAt()
+	au.mutation.SetUpdatedAt(i)
+	return au
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (au *AccountUpdate) AddUpdatedAt(i int) *AccountUpdate {
+	au.mutation.AddUpdatedAt(i)
+	return au
+}
+
+// SetLastBattleTime sets the "last_battle_time" field.
+func (au *AccountUpdate) SetLastBattleTime(i int) *AccountUpdate {
+	au.mutation.ResetLastBattleTime()
+	au.mutation.SetLastBattleTime(i)
+	return au
+}
+
+// SetNillableLastBattleTime sets the "last_battle_time" field if the given value is not nil.
+func (au *AccountUpdate) SetNillableLastBattleTime(i *int) *AccountUpdate {
+	if i != nil {
+		au.SetLastBattleTime(*i)
+	}
+	return au
+}
+
+// AddLastBattleTime adds i to the "last_battle_time" field.
+func (au *AccountUpdate) AddLastBattleTime(i int) *AccountUpdate {
+	au.mutation.AddLastBattleTime(i)
+	return au
+}
+
+// SetAccountCreatedAt sets the "account_created_at" field.
+func (au *AccountUpdate) SetAccountCreatedAt(i int) *AccountUpdate {
+	au.mutation.ResetAccountCreatedAt()
+	au.mutation.SetAccountCreatedAt(i)
+	return au
+}
+
+// SetNillableAccountCreatedAt sets the "account_created_at" field if the given value is not nil.
+func (au *AccountUpdate) SetNillableAccountCreatedAt(i *int) *AccountUpdate {
+	if i != nil {
+		au.SetAccountCreatedAt(*i)
+	}
+	return au
+}
+
+// AddAccountCreatedAt adds i to the "account_created_at" field.
+func (au *AccountUpdate) AddAccountCreatedAt(i int) *AccountUpdate {
+	au.mutation.AddAccountCreatedAt(i)
+	return au
+}
+
+// SetRealm sets the "realm" field.
+func (au *AccountUpdate) SetRealm(s string) *AccountUpdate {
+	au.mutation.SetRealm(s)
+	return au
+}
+
+// SetNillableRealm sets the "realm" field if the given value is not nil.
+func (au *AccountUpdate) SetNillableRealm(s *string) *AccountUpdate {
+	if s != nil {
+		au.SetRealm(*s)
+	}
+	return au
+}
+
+// SetNickname sets the "nickname" field.
+func (au *AccountUpdate) SetNickname(s string) *AccountUpdate {
+	au.mutation.SetNickname(s)
+	return au
+}
+
+// SetNillableNickname sets the "nickname" field if the given value is not nil.
+func (au *AccountUpdate) SetNillableNickname(s *string) *AccountUpdate {
+	if s != nil {
+		au.SetNickname(*s)
+	}
+	return au
+}
+
+// SetPrivate sets the "private" field.
+func (au *AccountUpdate) SetPrivate(b bool) *AccountUpdate {
+	au.mutation.SetPrivate(b)
+	return au
+}
+
+// SetNillablePrivate sets the "private" field if the given value is not nil.
+func (au *AccountUpdate) SetNillablePrivate(b *bool) *AccountUpdate {
+	if b != nil {
+		au.SetPrivate(*b)
+	}
+	return au
+}
+
+// SetClanID sets the "clan_id" field.
+func (au *AccountUpdate) SetClanID(s string) *AccountUpdate {
+	au.mutation.SetClanID(s)
+	return au
+}
+
+// SetNillableClanID sets the "clan_id" field if the given value is not nil.
+func (au *AccountUpdate) SetNillableClanID(s *string) *AccountUpdate {
+	if s != nil {
+		au.SetClanID(*s)
+	}
+	return au
+}
+
+// ClearClanID clears the value of the "clan_id" field.
+func (au *AccountUpdate) ClearClanID() *AccountUpdate {
+	au.mutation.ClearClanID()
+	return au
+}
+
+// SetClan sets the "clan" edge to the Clan entity.
+func (au *AccountUpdate) SetClan(c *Clan) *AccountUpdate {
+	return au.SetClanID(c.ID)
+}
+
+// AddSnapshotIDs adds the "snapshots" edge to the AccountSnapshot entity by IDs.
+func (au *AccountUpdate) AddSnapshotIDs(ids ...string) *AccountUpdate {
+	au.mutation.AddSnapshotIDs(ids...)
+	return au
+}
+
+// AddSnapshots adds the "snapshots" edges to the AccountSnapshot entity.
+func (au *AccountUpdate) AddSnapshots(a ...*AccountSnapshot) *AccountUpdate {
+	ids := make([]string, len(a))
+	for i := range a {
+		ids[i] = a[i].ID
+	}
+	return au.AddSnapshotIDs(ids...)
+}
+
+// AddVehicleSnapshotIDs adds the "vehicle_snapshots" edge to the VehicleSnapshot entity by IDs.
+func (au *AccountUpdate) AddVehicleSnapshotIDs(ids ...string) *AccountUpdate {
+	au.mutation.AddVehicleSnapshotIDs(ids...)
+	return au
+}
+
+// AddVehicleSnapshots adds the "vehicle_snapshots" edges to the VehicleSnapshot entity.
+func (au *AccountUpdate) AddVehicleSnapshots(v ...*VehicleSnapshot) *AccountUpdate {
+	ids := make([]string, len(v))
+	for i := range v {
+		ids[i] = v[i].ID
+	}
+	return au.AddVehicleSnapshotIDs(ids...)
+}
+
+// AddAchievementSnapshotIDs adds the "achievement_snapshots" edge to the AchievementsSnapshot entity by IDs.
+func (au *AccountUpdate) AddAchievementSnapshotIDs(ids ...string) *AccountUpdate {
+	au.mutation.AddAchievementSnapshotIDs(ids...)
+	return au
+}
+
+// AddAchievementSnapshots adds the "achievement_snapshots" edges to the AchievementsSnapshot entity.
+func (au *AccountUpdate) AddAchievementSnapshots(a ...*AchievementsSnapshot) *AccountUpdate {
+	ids := make([]string, len(a))
+	for i := range a {
+		ids[i] = a[i].ID
+	}
+	return au.AddAchievementSnapshotIDs(ids...)
+}
+
+// Mutation returns the AccountMutation object of the builder.
+func (au *AccountUpdate) Mutation() *AccountMutation {
+	return au.mutation
+}
+
+// ClearClan clears the "clan" edge to the Clan entity.
+func (au *AccountUpdate) ClearClan() *AccountUpdate {
+	au.mutation.ClearClan()
+	return au
+}
+
+// ClearSnapshots clears all "snapshots" edges to the AccountSnapshot entity.
+func (au *AccountUpdate) ClearSnapshots() *AccountUpdate {
+	au.mutation.ClearSnapshots()
+	return au
+}
+
+// RemoveSnapshotIDs removes the "snapshots" edge to AccountSnapshot entities by IDs.
+func (au *AccountUpdate) RemoveSnapshotIDs(ids ...string) *AccountUpdate {
+	au.mutation.RemoveSnapshotIDs(ids...)
+	return au
+}
+
+// RemoveSnapshots removes "snapshots" edges to AccountSnapshot entities.
+func (au *AccountUpdate) RemoveSnapshots(a ...*AccountSnapshot) *AccountUpdate {
+	ids := make([]string, len(a))
+	for i := range a {
+		ids[i] = a[i].ID
+	}
+	return au.RemoveSnapshotIDs(ids...)
+}
+
+// ClearVehicleSnapshots clears all "vehicle_snapshots" edges to the VehicleSnapshot entity.
+func (au *AccountUpdate) ClearVehicleSnapshots() *AccountUpdate {
+	au.mutation.ClearVehicleSnapshots()
+	return au
+}
+
+// RemoveVehicleSnapshotIDs removes the "vehicle_snapshots" edge to VehicleSnapshot entities by IDs.
+func (au *AccountUpdate) RemoveVehicleSnapshotIDs(ids ...string) *AccountUpdate {
+	au.mutation.RemoveVehicleSnapshotIDs(ids...)
+	return au
+}
+
+// RemoveVehicleSnapshots removes "vehicle_snapshots" edges to VehicleSnapshot entities.
+func (au *AccountUpdate) RemoveVehicleSnapshots(v ...*VehicleSnapshot) *AccountUpdate {
+	ids := make([]string, len(v))
+	for i := range v {
+		ids[i] = v[i].ID
+	}
+	return au.RemoveVehicleSnapshotIDs(ids...)
+}
+
+// ClearAchievementSnapshots clears all "achievement_snapshots" edges to the AchievementsSnapshot entity.
+func (au *AccountUpdate) ClearAchievementSnapshots() *AccountUpdate {
+	au.mutation.ClearAchievementSnapshots()
+	return au
+}
+
+// RemoveAchievementSnapshotIDs removes the "achievement_snapshots" edge to AchievementsSnapshot entities by IDs.
+func (au *AccountUpdate) RemoveAchievementSnapshotIDs(ids ...string) *AccountUpdate {
+	au.mutation.RemoveAchievementSnapshotIDs(ids...)
+	return au
+}
+
+// RemoveAchievementSnapshots removes "achievement_snapshots" edges to AchievementsSnapshot entities.
+func (au *AccountUpdate) RemoveAchievementSnapshots(a ...*AchievementsSnapshot) *AccountUpdate {
+	ids := make([]string, len(a))
+	for i := range a {
+		ids[i] = a[i].ID
+	}
+	return au.RemoveAchievementSnapshotIDs(ids...)
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (au *AccountUpdate) Save(ctx context.Context) (int, error) {
+	au.defaults()
+	return withHooks(ctx, au.sqlSave, au.mutation, au.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (au *AccountUpdate) SaveX(ctx context.Context) int {
+	affected, err := au.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return affected
+}
+
+// Exec executes the query.
+func (au *AccountUpdate) Exec(ctx context.Context) error {
+	_, err := au.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (au *AccountUpdate) ExecX(ctx context.Context) {
+	if err := au.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (au *AccountUpdate) defaults() {
+	if _, ok := au.mutation.UpdatedAt(); !ok {
+		v := account.UpdateDefaultUpdatedAt()
+		au.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (au *AccountUpdate) check() error {
+	if v, ok := au.mutation.Realm(); ok {
+		if err := account.RealmValidator(v); err != nil {
+			return &ValidationError{Name: "realm", err: fmt.Errorf(`db: validator failed for field "Account.realm": %w`, err)}
+		}
+	}
+	if v, ok := au.mutation.Nickname(); ok {
+		if err := account.NicknameValidator(v); err != nil {
+			return &ValidationError{Name: "nickname", err: fmt.Errorf(`db: validator failed for field "Account.nickname": %w`, err)}
+		}
+	}
+	return nil
+}
+
+func (au *AccountUpdate) sqlSave(ctx context.Context) (n int, err error) {
+	if err := au.check(); err != nil {
+		return n, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(account.Table, account.Columns, sqlgraph.NewFieldSpec(account.FieldID, field.TypeString))
+	if ps := au.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := au.mutation.UpdatedAt(); ok {
+		_spec.SetField(account.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := au.mutation.AddedUpdatedAt(); ok {
+		_spec.AddField(account.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := au.mutation.LastBattleTime(); ok {
+		_spec.SetField(account.FieldLastBattleTime, field.TypeInt, value)
+	}
+	if value, ok := au.mutation.AddedLastBattleTime(); ok {
+		_spec.AddField(account.FieldLastBattleTime, field.TypeInt, value)
+	}
+	if value, ok := au.mutation.AccountCreatedAt(); ok {
+		_spec.SetField(account.FieldAccountCreatedAt, field.TypeInt, value)
+	}
+	if value, ok := au.mutation.AddedAccountCreatedAt(); ok {
+		_spec.AddField(account.FieldAccountCreatedAt, field.TypeInt, value)
+	}
+	if value, ok := au.mutation.Realm(); ok {
+		_spec.SetField(account.FieldRealm, field.TypeString, value)
+	}
+	if value, ok := au.mutation.Nickname(); ok {
+		_spec.SetField(account.FieldNickname, field.TypeString, value)
+	}
+	if value, ok := au.mutation.Private(); ok {
+		_spec.SetField(account.FieldPrivate, field.TypeBool, value)
+	}
+	if au.mutation.ClanCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   account.ClanTable,
+			Columns: []string{account.ClanColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(clan.FieldID, field.TypeString),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := au.mutation.ClanIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   account.ClanTable,
+			Columns: []string{account.ClanColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(clan.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
+	if au.mutation.SnapshotsCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   account.SnapshotsTable,
+			Columns: []string{account.SnapshotsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(accountsnapshot.FieldID, field.TypeString),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := au.mutation.RemovedSnapshotsIDs(); len(nodes) > 0 && !au.mutation.SnapshotsCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   account.SnapshotsTable,
+			Columns: []string{account.SnapshotsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(accountsnapshot.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := au.mutation.SnapshotsIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   account.SnapshotsTable,
+			Columns: []string{account.SnapshotsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(accountsnapshot.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
+	if au.mutation.VehicleSnapshotsCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   account.VehicleSnapshotsTable,
+			Columns: []string{account.VehicleSnapshotsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(vehiclesnapshot.FieldID, field.TypeString),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := au.mutation.RemovedVehicleSnapshotsIDs(); len(nodes) > 0 && !au.mutation.VehicleSnapshotsCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   account.VehicleSnapshotsTable,
+			Columns: []string{account.VehicleSnapshotsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(vehiclesnapshot.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := au.mutation.VehicleSnapshotsIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   account.VehicleSnapshotsTable,
+			Columns: []string{account.VehicleSnapshotsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(vehiclesnapshot.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
+	if au.mutation.AchievementSnapshotsCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   account.AchievementSnapshotsTable,
+			Columns: []string{account.AchievementSnapshotsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := au.mutation.RemovedAchievementSnapshotsIDs(); len(nodes) > 0 && !au.mutation.AchievementSnapshotsCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   account.AchievementSnapshotsTable,
+			Columns: []string{account.AchievementSnapshotsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := au.mutation.AchievementSnapshotsIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   account.AchievementSnapshotsTable,
+			Columns: []string{account.AchievementSnapshotsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
+	if n, err = sqlgraph.UpdateNodes(ctx, au.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{account.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return 0, err
+	}
+	au.mutation.done = true
+	return n, nil
+}
+
+// AccountUpdateOne is the builder for updating a single Account entity.
+type AccountUpdateOne struct {
+	config
+	fields   []string
+	hooks    []Hook
+	mutation *AccountMutation
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (auo *AccountUpdateOne) SetUpdatedAt(i int) *AccountUpdateOne {
+	auo.mutation.ResetUpdatedAt()
+	auo.mutation.SetUpdatedAt(i)
+	return auo
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (auo *AccountUpdateOne) AddUpdatedAt(i int) *AccountUpdateOne {
+	auo.mutation.AddUpdatedAt(i)
+	return auo
+}
+
+// SetLastBattleTime sets the "last_battle_time" field.
+func (auo *AccountUpdateOne) SetLastBattleTime(i int) *AccountUpdateOne {
+	auo.mutation.ResetLastBattleTime()
+	auo.mutation.SetLastBattleTime(i)
+	return auo
+}
+
+// SetNillableLastBattleTime sets the "last_battle_time" field if the given value is not nil.
+func (auo *AccountUpdateOne) SetNillableLastBattleTime(i *int) *AccountUpdateOne {
+	if i != nil {
+		auo.SetLastBattleTime(*i)
+	}
+	return auo
+}
+
+// AddLastBattleTime adds i to the "last_battle_time" field.
+func (auo *AccountUpdateOne) AddLastBattleTime(i int) *AccountUpdateOne {
+	auo.mutation.AddLastBattleTime(i)
+	return auo
+}
+
+// SetAccountCreatedAt sets the "account_created_at" field.
+func (auo *AccountUpdateOne) SetAccountCreatedAt(i int) *AccountUpdateOne {
+	auo.mutation.ResetAccountCreatedAt()
+	auo.mutation.SetAccountCreatedAt(i)
+	return auo
+}
+
+// SetNillableAccountCreatedAt sets the "account_created_at" field if the given value is not nil.
+func (auo *AccountUpdateOne) SetNillableAccountCreatedAt(i *int) *AccountUpdateOne {
+	if i != nil {
+		auo.SetAccountCreatedAt(*i)
+	}
+	return auo
+}
+
+// AddAccountCreatedAt adds i to the "account_created_at" field.
+func (auo *AccountUpdateOne) AddAccountCreatedAt(i int) *AccountUpdateOne {
+	auo.mutation.AddAccountCreatedAt(i)
+	return auo
+}
+
+// SetRealm sets the "realm" field.
+func (auo *AccountUpdateOne) SetRealm(s string) *AccountUpdateOne {
+	auo.mutation.SetRealm(s)
+	return auo
+}
+
+// SetNillableRealm sets the "realm" field if the given value is not nil.
+func (auo *AccountUpdateOne) SetNillableRealm(s *string) *AccountUpdateOne {
+	if s != nil {
+		auo.SetRealm(*s)
+	}
+	return auo
+}
+
+// SetNickname sets the "nickname" field.
+func (auo *AccountUpdateOne) SetNickname(s string) *AccountUpdateOne {
+	auo.mutation.SetNickname(s)
+	return auo
+}
+
+// SetNillableNickname sets the "nickname" field if the given value is not nil.
+func (auo *AccountUpdateOne) SetNillableNickname(s *string) *AccountUpdateOne {
+	if s != nil {
+		auo.SetNickname(*s)
+	}
+	return auo
+}
+
+// SetPrivate sets the "private" field.
+func (auo *AccountUpdateOne) SetPrivate(b bool) *AccountUpdateOne {
+	auo.mutation.SetPrivate(b)
+	return auo
+}
+
+// SetNillablePrivate sets the "private" field if the given value is not nil.
+func (auo *AccountUpdateOne) SetNillablePrivate(b *bool) *AccountUpdateOne {
+	if b != nil {
+		auo.SetPrivate(*b)
+	}
+	return auo
+}
+
+// SetClanID sets the "clan_id" field.
+func (auo *AccountUpdateOne) SetClanID(s string) *AccountUpdateOne {
+	auo.mutation.SetClanID(s)
+	return auo
+}
+
+// SetNillableClanID sets the "clan_id" field if the given value is not nil.
+func (auo *AccountUpdateOne) SetNillableClanID(s *string) *AccountUpdateOne {
+	if s != nil {
+		auo.SetClanID(*s)
+	}
+	return auo
+}
+
+// ClearClanID clears the value of the "clan_id" field.
+func (auo *AccountUpdateOne) ClearClanID() *AccountUpdateOne {
+	auo.mutation.ClearClanID()
+	return auo
+}
+
+// SetClan sets the "clan" edge to the Clan entity.
+func (auo *AccountUpdateOne) SetClan(c *Clan) *AccountUpdateOne {
+	return auo.SetClanID(c.ID)
+}
+
+// AddSnapshotIDs adds the "snapshots" edge to the AccountSnapshot entity by IDs.
+func (auo *AccountUpdateOne) AddSnapshotIDs(ids ...string) *AccountUpdateOne {
+	auo.mutation.AddSnapshotIDs(ids...)
+	return auo
+}
+
+// AddSnapshots adds the "snapshots" edges to the AccountSnapshot entity.
+func (auo *AccountUpdateOne) AddSnapshots(a ...*AccountSnapshot) *AccountUpdateOne {
+	ids := make([]string, len(a))
+	for i := range a {
+		ids[i] = a[i].ID
+	}
+	return auo.AddSnapshotIDs(ids...)
+}
+
+// AddVehicleSnapshotIDs adds the "vehicle_snapshots" edge to the VehicleSnapshot entity by IDs.
+func (auo *AccountUpdateOne) AddVehicleSnapshotIDs(ids ...string) *AccountUpdateOne {
+	auo.mutation.AddVehicleSnapshotIDs(ids...)
+	return auo
+}
+
+// AddVehicleSnapshots adds the "vehicle_snapshots" edges to the VehicleSnapshot entity.
+func (auo *AccountUpdateOne) AddVehicleSnapshots(v ...*VehicleSnapshot) *AccountUpdateOne {
+	ids := make([]string, len(v))
+	for i := range v {
+		ids[i] = v[i].ID
+	}
+	return auo.AddVehicleSnapshotIDs(ids...)
+}
+
+// AddAchievementSnapshotIDs adds the "achievement_snapshots" edge to the AchievementsSnapshot entity by IDs.
+func (auo *AccountUpdateOne) AddAchievementSnapshotIDs(ids ...string) *AccountUpdateOne {
+	auo.mutation.AddAchievementSnapshotIDs(ids...)
+	return auo
+}
+
+// AddAchievementSnapshots adds the "achievement_snapshots" edges to the AchievementsSnapshot entity.
+func (auo *AccountUpdateOne) AddAchievementSnapshots(a ...*AchievementsSnapshot) *AccountUpdateOne {
+	ids := make([]string, len(a))
+	for i := range a {
+		ids[i] = a[i].ID
+	}
+	return auo.AddAchievementSnapshotIDs(ids...)
+}
+
+// Mutation returns the AccountMutation object of the builder.
+func (auo *AccountUpdateOne) Mutation() *AccountMutation {
+	return auo.mutation
+}
+
+// ClearClan clears the "clan" edge to the Clan entity.
+func (auo *AccountUpdateOne) ClearClan() *AccountUpdateOne {
+	auo.mutation.ClearClan()
+	return auo
+}
+
+// ClearSnapshots clears all "snapshots" edges to the AccountSnapshot entity.
+func (auo *AccountUpdateOne) ClearSnapshots() *AccountUpdateOne {
+	auo.mutation.ClearSnapshots()
+	return auo
+}
+
+// RemoveSnapshotIDs removes the "snapshots" edge to AccountSnapshot entities by IDs.
+func (auo *AccountUpdateOne) RemoveSnapshotIDs(ids ...string) *AccountUpdateOne {
+	auo.mutation.RemoveSnapshotIDs(ids...)
+	return auo
+}
+
+// RemoveSnapshots removes "snapshots" edges to AccountSnapshot entities.
+func (auo *AccountUpdateOne) RemoveSnapshots(a ...*AccountSnapshot) *AccountUpdateOne {
+	ids := make([]string, len(a))
+	for i := range a {
+		ids[i] = a[i].ID
+	}
+	return auo.RemoveSnapshotIDs(ids...)
+}
+
+// ClearVehicleSnapshots clears all "vehicle_snapshots" edges to the VehicleSnapshot entity.
+func (auo *AccountUpdateOne) ClearVehicleSnapshots() *AccountUpdateOne {
+	auo.mutation.ClearVehicleSnapshots()
+	return auo
+}
+
+// RemoveVehicleSnapshotIDs removes the "vehicle_snapshots" edge to VehicleSnapshot entities by IDs.
+func (auo *AccountUpdateOne) RemoveVehicleSnapshotIDs(ids ...string) *AccountUpdateOne {
+	auo.mutation.RemoveVehicleSnapshotIDs(ids...)
+	return auo
+}
+
+// RemoveVehicleSnapshots removes "vehicle_snapshots" edges to VehicleSnapshot entities.
+func (auo *AccountUpdateOne) RemoveVehicleSnapshots(v ...*VehicleSnapshot) *AccountUpdateOne {
+	ids := make([]string, len(v))
+	for i := range v {
+		ids[i] = v[i].ID
+	}
+	return auo.RemoveVehicleSnapshotIDs(ids...)
+}
+
+// ClearAchievementSnapshots clears all "achievement_snapshots" edges to the AchievementsSnapshot entity.
+func (auo *AccountUpdateOne) ClearAchievementSnapshots() *AccountUpdateOne {
+	auo.mutation.ClearAchievementSnapshots()
+	return auo
+}
+
+// RemoveAchievementSnapshotIDs removes the "achievement_snapshots" edge to AchievementsSnapshot entities by IDs.
+func (auo *AccountUpdateOne) RemoveAchievementSnapshotIDs(ids ...string) *AccountUpdateOne {
+	auo.mutation.RemoveAchievementSnapshotIDs(ids...)
+	return auo
+}
+
+// RemoveAchievementSnapshots removes "achievement_snapshots" edges to AchievementsSnapshot entities.
+func (auo *AccountUpdateOne) RemoveAchievementSnapshots(a ...*AchievementsSnapshot) *AccountUpdateOne {
+	ids := make([]string, len(a))
+	for i := range a {
+		ids[i] = a[i].ID
+	}
+	return auo.RemoveAchievementSnapshotIDs(ids...)
+}
+
+// Where appends a list predicates to the AccountUpdate builder.
+func (auo *AccountUpdateOne) Where(ps ...predicate.Account) *AccountUpdateOne {
+	auo.mutation.Where(ps...)
+	return auo
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (auo *AccountUpdateOne) Select(field string, fields ...string) *AccountUpdateOne {
+	auo.fields = append([]string{field}, fields...)
+	return auo
+}
+
+// Save executes the query and returns the updated Account entity.
+func (auo *AccountUpdateOne) Save(ctx context.Context) (*Account, error) {
+	auo.defaults()
+	return withHooks(ctx, auo.sqlSave, auo.mutation, auo.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (auo *AccountUpdateOne) SaveX(ctx context.Context) *Account {
+	node, err := auo.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// Exec executes the query on the entity.
+func (auo *AccountUpdateOne) Exec(ctx context.Context) error {
+	_, err := auo.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (auo *AccountUpdateOne) ExecX(ctx context.Context) {
+	if err := auo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (auo *AccountUpdateOne) defaults() {
+	if _, ok := auo.mutation.UpdatedAt(); !ok {
+		v := account.UpdateDefaultUpdatedAt()
+		auo.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (auo *AccountUpdateOne) check() error {
+	if v, ok := auo.mutation.Realm(); ok {
+		if err := account.RealmValidator(v); err != nil {
+			return &ValidationError{Name: "realm", err: fmt.Errorf(`db: validator failed for field "Account.realm": %w`, err)}
+		}
+	}
+	if v, ok := auo.mutation.Nickname(); ok {
+		if err := account.NicknameValidator(v); err != nil {
+			return &ValidationError{Name: "nickname", err: fmt.Errorf(`db: validator failed for field "Account.nickname": %w`, err)}
+		}
+	}
+	return nil
+}
+
+func (auo *AccountUpdateOne) sqlSave(ctx context.Context) (_node *Account, err error) {
+	if err := auo.check(); err != nil {
+		return _node, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(account.Table, account.Columns, sqlgraph.NewFieldSpec(account.FieldID, field.TypeString))
+	id, ok := auo.mutation.ID()
+	if !ok {
+		return nil, &ValidationError{Name: "id", err: errors.New(`db: missing "Account.id" for update`)}
+	}
+	_spec.Node.ID.Value = id
+	if fields := auo.fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, account.FieldID)
+		for _, f := range fields {
+			if !account.ValidColumn(f) {
+				return nil, &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+			}
+			if f != account.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, f)
+			}
+		}
+	}
+	if ps := auo.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := auo.mutation.UpdatedAt(); ok {
+		_spec.SetField(account.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := auo.mutation.AddedUpdatedAt(); ok {
+		_spec.AddField(account.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := auo.mutation.LastBattleTime(); ok {
+		_spec.SetField(account.FieldLastBattleTime, field.TypeInt, value)
+	}
+	if value, ok := auo.mutation.AddedLastBattleTime(); ok {
+		_spec.AddField(account.FieldLastBattleTime, field.TypeInt, value)
+	}
+	if value, ok := auo.mutation.AccountCreatedAt(); ok {
+		_spec.SetField(account.FieldAccountCreatedAt, field.TypeInt, value)
+	}
+	if value, ok := auo.mutation.AddedAccountCreatedAt(); ok {
+		_spec.AddField(account.FieldAccountCreatedAt, field.TypeInt, value)
+	}
+	if value, ok := auo.mutation.Realm(); ok {
+		_spec.SetField(account.FieldRealm, field.TypeString, value)
+	}
+	if value, ok := auo.mutation.Nickname(); ok {
+		_spec.SetField(account.FieldNickname, field.TypeString, value)
+	}
+	if value, ok := auo.mutation.Private(); ok {
+		_spec.SetField(account.FieldPrivate, field.TypeBool, value)
+	}
+	if auo.mutation.ClanCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   account.ClanTable,
+			Columns: []string{account.ClanColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(clan.FieldID, field.TypeString),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := auo.mutation.ClanIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   account.ClanTable,
+			Columns: []string{account.ClanColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(clan.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
+	if auo.mutation.SnapshotsCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   account.SnapshotsTable,
+			Columns: []string{account.SnapshotsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(accountsnapshot.FieldID, field.TypeString),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := auo.mutation.RemovedSnapshotsIDs(); len(nodes) > 0 && !auo.mutation.SnapshotsCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   account.SnapshotsTable,
+			Columns: []string{account.SnapshotsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(accountsnapshot.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := auo.mutation.SnapshotsIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   account.SnapshotsTable,
+			Columns: []string{account.SnapshotsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(accountsnapshot.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
+	if auo.mutation.VehicleSnapshotsCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   account.VehicleSnapshotsTable,
+			Columns: []string{account.VehicleSnapshotsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(vehiclesnapshot.FieldID, field.TypeString),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := auo.mutation.RemovedVehicleSnapshotsIDs(); len(nodes) > 0 && !auo.mutation.VehicleSnapshotsCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   account.VehicleSnapshotsTable,
+			Columns: []string{account.VehicleSnapshotsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(vehiclesnapshot.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := auo.mutation.VehicleSnapshotsIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   account.VehicleSnapshotsTable,
+			Columns: []string{account.VehicleSnapshotsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(vehiclesnapshot.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
+	if auo.mutation.AchievementSnapshotsCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   account.AchievementSnapshotsTable,
+			Columns: []string{account.AchievementSnapshotsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := auo.mutation.RemovedAchievementSnapshotsIDs(); len(nodes) > 0 && !auo.mutation.AchievementSnapshotsCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   account.AchievementSnapshotsTable,
+			Columns: []string{account.AchievementSnapshotsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := auo.mutation.AchievementSnapshotsIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   account.AchievementSnapshotsTable,
+			Columns: []string{account.AchievementSnapshotsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
+	_node = &Account{config: auo.config}
+	_spec.Assign = _node.assignValues
+	_spec.ScanValues = _node.scanValues
+	if err = sqlgraph.UpdateNode(ctx, auo.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{account.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	auo.mutation.done = true
+	return _node, nil
+}
diff --git a/internal/database/ent/db/accountsnapshot.go b/internal/database/ent/db/accountsnapshot.go
new file mode 100644
index 00000000..d0dd7952
--- /dev/null
+++ b/internal/database/ent/db/accountsnapshot.go
@@ -0,0 +1,240 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+	"github.com/cufee/aftermath/internal/database/ent/db/account"
+	"github.com/cufee/aftermath/internal/database/ent/db/accountsnapshot"
+	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/stats/frame"
+)
+
+// AccountSnapshot is the model entity for the AccountSnapshot schema.
+type AccountSnapshot struct {
+	config `json:"-"`
+	// ID of the ent.
+	ID string `json:"id,omitempty"`
+	// CreatedAt holds the value of the "created_at" field.
+	CreatedAt int `json:"created_at,omitempty"`
+	// UpdatedAt holds the value of the "updated_at" field.
+	UpdatedAt int `json:"updated_at,omitempty"`
+	// Type holds the value of the "type" field.
+	Type models.SnapshotType `json:"type,omitempty"`
+	// LastBattleTime holds the value of the "last_battle_time" field.
+	LastBattleTime int `json:"last_battle_time,omitempty"`
+	// AccountID holds the value of the "account_id" field.
+	AccountID string `json:"account_id,omitempty"`
+	// ReferenceID holds the value of the "reference_id" field.
+	ReferenceID string `json:"reference_id,omitempty"`
+	// RatingBattles holds the value of the "rating_battles" field.
+	RatingBattles int `json:"rating_battles,omitempty"`
+	// RatingFrame holds the value of the "rating_frame" field.
+	RatingFrame frame.StatsFrame `json:"rating_frame,omitempty"`
+	// RegularBattles holds the value of the "regular_battles" field.
+	RegularBattles int `json:"regular_battles,omitempty"`
+	// RegularFrame holds the value of the "regular_frame" field.
+	RegularFrame frame.StatsFrame `json:"regular_frame,omitempty"`
+	// Edges holds the relations/edges for other nodes in the graph.
+	// The values are being populated by the AccountSnapshotQuery when eager-loading is set.
+	Edges        AccountSnapshotEdges `json:"edges"`
+	selectValues sql.SelectValues
+}
+
+// AccountSnapshotEdges holds the relations/edges for other nodes in the graph.
+type AccountSnapshotEdges struct {
+	// Account holds the value of the account edge.
+	Account *Account `json:"account,omitempty"`
+	// loadedTypes holds the information for reporting if a
+	// type was loaded (or requested) in eager-loading or not.
+	loadedTypes [1]bool
+}
+
+// AccountOrErr returns the Account value or an error if the edge
+// was not loaded in eager-loading, or loaded but was not found.
+func (e AccountSnapshotEdges) AccountOrErr() (*Account, error) {
+	if e.Account != nil {
+		return e.Account, nil
+	} else if e.loadedTypes[0] {
+		return nil, &NotFoundError{label: account.Label}
+	}
+	return nil, &NotLoadedError{edge: "account"}
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*AccountSnapshot) scanValues(columns []string) ([]any, error) {
+	values := make([]any, len(columns))
+	for i := range columns {
+		switch columns[i] {
+		case accountsnapshot.FieldRatingFrame, accountsnapshot.FieldRegularFrame:
+			values[i] = new([]byte)
+		case accountsnapshot.FieldCreatedAt, accountsnapshot.FieldUpdatedAt, accountsnapshot.FieldLastBattleTime, accountsnapshot.FieldRatingBattles, accountsnapshot.FieldRegularBattles:
+			values[i] = new(sql.NullInt64)
+		case accountsnapshot.FieldID, accountsnapshot.FieldType, accountsnapshot.FieldAccountID, accountsnapshot.FieldReferenceID:
+			values[i] = new(sql.NullString)
+		default:
+			values[i] = new(sql.UnknownType)
+		}
+	}
+	return values, nil
+}
+
+// assignValues assigns the values that were returned from sql.Rows (after scanning)
+// to the AccountSnapshot fields.
+func (as *AccountSnapshot) assignValues(columns []string, values []any) error {
+	if m, n := len(values), len(columns); m < n {
+		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
+	}
+	for i := range columns {
+		switch columns[i] {
+		case accountsnapshot.FieldID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field id", values[i])
+			} else if value.Valid {
+				as.ID = value.String
+			}
+		case accountsnapshot.FieldCreatedAt:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field created_at", values[i])
+			} else if value.Valid {
+				as.CreatedAt = int(value.Int64)
+			}
+		case accountsnapshot.FieldUpdatedAt:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
+			} else if value.Valid {
+				as.UpdatedAt = int(value.Int64)
+			}
+		case accountsnapshot.FieldType:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field type", values[i])
+			} else if value.Valid {
+				as.Type = models.SnapshotType(value.String)
+			}
+		case accountsnapshot.FieldLastBattleTime:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field last_battle_time", values[i])
+			} else if value.Valid {
+				as.LastBattleTime = int(value.Int64)
+			}
+		case accountsnapshot.FieldAccountID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field account_id", values[i])
+			} else if value.Valid {
+				as.AccountID = value.String
+			}
+		case accountsnapshot.FieldReferenceID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field reference_id", values[i])
+			} else if value.Valid {
+				as.ReferenceID = value.String
+			}
+		case accountsnapshot.FieldRatingBattles:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field rating_battles", values[i])
+			} else if value.Valid {
+				as.RatingBattles = int(value.Int64)
+			}
+		case accountsnapshot.FieldRatingFrame:
+			if value, ok := values[i].(*[]byte); !ok {
+				return fmt.Errorf("unexpected type %T for field rating_frame", values[i])
+			} else if value != nil && len(*value) > 0 {
+				if err := json.Unmarshal(*value, &as.RatingFrame); err != nil {
+					return fmt.Errorf("unmarshal field rating_frame: %w", err)
+				}
+			}
+		case accountsnapshot.FieldRegularBattles:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field regular_battles", values[i])
+			} else if value.Valid {
+				as.RegularBattles = int(value.Int64)
+			}
+		case accountsnapshot.FieldRegularFrame:
+			if value, ok := values[i].(*[]byte); !ok {
+				return fmt.Errorf("unexpected type %T for field regular_frame", values[i])
+			} else if value != nil && len(*value) > 0 {
+				if err := json.Unmarshal(*value, &as.RegularFrame); err != nil {
+					return fmt.Errorf("unmarshal field regular_frame: %w", err)
+				}
+			}
+		default:
+			as.selectValues.Set(columns[i], values[i])
+		}
+	}
+	return nil
+}
+
+// Value returns the ent.Value that was dynamically selected and assigned to the AccountSnapshot.
+// This includes values selected through modifiers, order, etc.
+func (as *AccountSnapshot) Value(name string) (ent.Value, error) {
+	return as.selectValues.Get(name)
+}
+
+// QueryAccount queries the "account" edge of the AccountSnapshot entity.
+func (as *AccountSnapshot) QueryAccount() *AccountQuery {
+	return NewAccountSnapshotClient(as.config).QueryAccount(as)
+}
+
+// Update returns a builder for updating this AccountSnapshot.
+// Note that you need to call AccountSnapshot.Unwrap() before calling this method if this AccountSnapshot
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (as *AccountSnapshot) Update() *AccountSnapshotUpdateOne {
+	return NewAccountSnapshotClient(as.config).UpdateOne(as)
+}
+
+// Unwrap unwraps the AccountSnapshot entity that was returned from a transaction after it was closed,
+// so that all future queries will be executed through the driver which created the transaction.
+func (as *AccountSnapshot) Unwrap() *AccountSnapshot {
+	_tx, ok := as.config.driver.(*txDriver)
+	if !ok {
+		panic("db: AccountSnapshot is not a transactional entity")
+	}
+	as.config.driver = _tx.drv
+	return as
+}
+
+// String implements the fmt.Stringer.
+func (as *AccountSnapshot) String() string {
+	var builder strings.Builder
+	builder.WriteString("AccountSnapshot(")
+	builder.WriteString(fmt.Sprintf("id=%v, ", as.ID))
+	builder.WriteString("created_at=")
+	builder.WriteString(fmt.Sprintf("%v", as.CreatedAt))
+	builder.WriteString(", ")
+	builder.WriteString("updated_at=")
+	builder.WriteString(fmt.Sprintf("%v", as.UpdatedAt))
+	builder.WriteString(", ")
+	builder.WriteString("type=")
+	builder.WriteString(fmt.Sprintf("%v", as.Type))
+	builder.WriteString(", ")
+	builder.WriteString("last_battle_time=")
+	builder.WriteString(fmt.Sprintf("%v", as.LastBattleTime))
+	builder.WriteString(", ")
+	builder.WriteString("account_id=")
+	builder.WriteString(as.AccountID)
+	builder.WriteString(", ")
+	builder.WriteString("reference_id=")
+	builder.WriteString(as.ReferenceID)
+	builder.WriteString(", ")
+	builder.WriteString("rating_battles=")
+	builder.WriteString(fmt.Sprintf("%v", as.RatingBattles))
+	builder.WriteString(", ")
+	builder.WriteString("rating_frame=")
+	builder.WriteString(fmt.Sprintf("%v", as.RatingFrame))
+	builder.WriteString(", ")
+	builder.WriteString("regular_battles=")
+	builder.WriteString(fmt.Sprintf("%v", as.RegularBattles))
+	builder.WriteString(", ")
+	builder.WriteString("regular_frame=")
+	builder.WriteString(fmt.Sprintf("%v", as.RegularFrame))
+	builder.WriteByte(')')
+	return builder.String()
+}
+
+// AccountSnapshots is a parsable slice of AccountSnapshot.
+type AccountSnapshots []*AccountSnapshot
diff --git a/internal/database/ent/db/accountsnapshot/accountsnapshot.go b/internal/database/ent/db/accountsnapshot/accountsnapshot.go
new file mode 100644
index 00000000..d99d867d
--- /dev/null
+++ b/internal/database/ent/db/accountsnapshot/accountsnapshot.go
@@ -0,0 +1,161 @@
+// Code generated by ent, DO NOT EDIT.
+
+package accountsnapshot
+
+import (
+	"fmt"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+const (
+	// Label holds the string label denoting the accountsnapshot type in the database.
+	Label = "account_snapshot"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// FieldType holds the string denoting the type field in the database.
+	FieldType = "type"
+	// FieldLastBattleTime holds the string denoting the last_battle_time field in the database.
+	FieldLastBattleTime = "last_battle_time"
+	// FieldAccountID holds the string denoting the account_id field in the database.
+	FieldAccountID = "account_id"
+	// FieldReferenceID holds the string denoting the reference_id field in the database.
+	FieldReferenceID = "reference_id"
+	// FieldRatingBattles holds the string denoting the rating_battles field in the database.
+	FieldRatingBattles = "rating_battles"
+	// FieldRatingFrame holds the string denoting the rating_frame field in the database.
+	FieldRatingFrame = "rating_frame"
+	// FieldRegularBattles holds the string denoting the regular_battles field in the database.
+	FieldRegularBattles = "regular_battles"
+	// FieldRegularFrame holds the string denoting the regular_frame field in the database.
+	FieldRegularFrame = "regular_frame"
+	// EdgeAccount holds the string denoting the account edge name in mutations.
+	EdgeAccount = "account"
+	// Table holds the table name of the accountsnapshot in the database.
+	Table = "account_snapshots"
+	// AccountTable is the table that holds the account relation/edge.
+	AccountTable = "account_snapshots"
+	// AccountInverseTable is the table name for the Account entity.
+	// It exists in this package in order to avoid circular dependency with the "account" package.
+	AccountInverseTable = "accounts"
+	// AccountColumn is the table column denoting the account relation/edge.
+	AccountColumn = "account_id"
+)
+
+// Columns holds all SQL columns for accountsnapshot fields.
+var Columns = []string{
+	FieldID,
+	FieldCreatedAt,
+	FieldUpdatedAt,
+	FieldType,
+	FieldLastBattleTime,
+	FieldAccountID,
+	FieldReferenceID,
+	FieldRatingBattles,
+	FieldRatingFrame,
+	FieldRegularBattles,
+	FieldRegularFrame,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() int
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() int
+	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
+	UpdateDefaultUpdatedAt func() int
+	// AccountIDValidator is a validator for the "account_id" field. It is called by the builders before save.
+	AccountIDValidator func(string) error
+	// ReferenceIDValidator is a validator for the "reference_id" field. It is called by the builders before save.
+	ReferenceIDValidator func(string) error
+	// DefaultID holds the default value on creation for the "id" field.
+	DefaultID func() string
+)
+
+// TypeValidator is a validator for the "type" field enum values. It is called by the builders before save.
+func TypeValidator(_type models.SnapshotType) error {
+	switch _type {
+	case "live", "daily":
+		return nil
+	default:
+		return fmt.Errorf("accountsnapshot: invalid enum value for type field: %q", _type)
+	}
+}
+
+// OrderOption defines the ordering options for the AccountSnapshot queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByType orders the results by the type field.
+func ByType(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldType, opts...).ToFunc()
+}
+
+// ByLastBattleTime orders the results by the last_battle_time field.
+func ByLastBattleTime(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldLastBattleTime, opts...).ToFunc()
+}
+
+// ByAccountID orders the results by the account_id field.
+func ByAccountID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldAccountID, opts...).ToFunc()
+}
+
+// ByReferenceID orders the results by the reference_id field.
+func ByReferenceID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldReferenceID, opts...).ToFunc()
+}
+
+// ByRatingBattles orders the results by the rating_battles field.
+func ByRatingBattles(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldRatingBattles, opts...).ToFunc()
+}
+
+// ByRegularBattles orders the results by the regular_battles field.
+func ByRegularBattles(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldRegularBattles, opts...).ToFunc()
+}
+
+// ByAccountField orders the results by account field.
+func ByAccountField(field string, opts ...sql.OrderTermOption) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborTerms(s, newAccountStep(), sql.OrderByField(field, opts...))
+	}
+}
+func newAccountStep() *sqlgraph.Step {
+	return sqlgraph.NewStep(
+		sqlgraph.From(Table, FieldID),
+		sqlgraph.To(AccountInverseTable, FieldID),
+		sqlgraph.Edge(sqlgraph.M2O, true, AccountTable, AccountColumn),
+	)
+}
diff --git a/internal/database/ent/db/accountsnapshot/where.go b/internal/database/ent/db/accountsnapshot/where.go
new file mode 100644
index 00000000..16101ea9
--- /dev/null
+++ b/internal/database/ent/db/accountsnapshot/where.go
@@ -0,0 +1,498 @@
+// Code generated by ent, DO NOT EDIT.
+
+package accountsnapshot
+
+import (
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldLTE(FieldID, id))
+}
+
+// IDEqualFold applies the EqualFold predicate on the ID field.
+func IDEqualFold(id string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldEqualFold(FieldID, id))
+}
+
+// IDContainsFold applies the ContainsFold predicate on the ID field.
+func IDContainsFold(id string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldContainsFold(FieldID, id))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// LastBattleTime applies equality check predicate on the "last_battle_time" field. It's identical to LastBattleTimeEQ.
+func LastBattleTime(v int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldEQ(FieldLastBattleTime, v))
+}
+
+// AccountID applies equality check predicate on the "account_id" field. It's identical to AccountIDEQ.
+func AccountID(v string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldEQ(FieldAccountID, v))
+}
+
+// ReferenceID applies equality check predicate on the "reference_id" field. It's identical to ReferenceIDEQ.
+func ReferenceID(v string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldEQ(FieldReferenceID, v))
+}
+
+// RatingBattles applies equality check predicate on the "rating_battles" field. It's identical to RatingBattlesEQ.
+func RatingBattles(v int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldEQ(FieldRatingBattles, v))
+}
+
+// RegularBattles applies equality check predicate on the "regular_battles" field. It's identical to RegularBattlesEQ.
+func RegularBattles(v int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldEQ(FieldRegularBattles, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// TypeEQ applies the EQ predicate on the "type" field.
+func TypeEQ(v models.SnapshotType) predicate.AccountSnapshot {
+	vc := v
+	return predicate.AccountSnapshot(sql.FieldEQ(FieldType, vc))
+}
+
+// TypeNEQ applies the NEQ predicate on the "type" field.
+func TypeNEQ(v models.SnapshotType) predicate.AccountSnapshot {
+	vc := v
+	return predicate.AccountSnapshot(sql.FieldNEQ(FieldType, vc))
+}
+
+// TypeIn applies the In predicate on the "type" field.
+func TypeIn(vs ...models.SnapshotType) predicate.AccountSnapshot {
+	v := make([]any, len(vs))
+	for i := range v {
+		v[i] = vs[i]
+	}
+	return predicate.AccountSnapshot(sql.FieldIn(FieldType, v...))
+}
+
+// TypeNotIn applies the NotIn predicate on the "type" field.
+func TypeNotIn(vs ...models.SnapshotType) predicate.AccountSnapshot {
+	v := make([]any, len(vs))
+	for i := range v {
+		v[i] = vs[i]
+	}
+	return predicate.AccountSnapshot(sql.FieldNotIn(FieldType, v...))
+}
+
+// LastBattleTimeEQ applies the EQ predicate on the "last_battle_time" field.
+func LastBattleTimeEQ(v int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldEQ(FieldLastBattleTime, v))
+}
+
+// LastBattleTimeNEQ applies the NEQ predicate on the "last_battle_time" field.
+func LastBattleTimeNEQ(v int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldNEQ(FieldLastBattleTime, v))
+}
+
+// LastBattleTimeIn applies the In predicate on the "last_battle_time" field.
+func LastBattleTimeIn(vs ...int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldIn(FieldLastBattleTime, vs...))
+}
+
+// LastBattleTimeNotIn applies the NotIn predicate on the "last_battle_time" field.
+func LastBattleTimeNotIn(vs ...int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldNotIn(FieldLastBattleTime, vs...))
+}
+
+// LastBattleTimeGT applies the GT predicate on the "last_battle_time" field.
+func LastBattleTimeGT(v int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldGT(FieldLastBattleTime, v))
+}
+
+// LastBattleTimeGTE applies the GTE predicate on the "last_battle_time" field.
+func LastBattleTimeGTE(v int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldGTE(FieldLastBattleTime, v))
+}
+
+// LastBattleTimeLT applies the LT predicate on the "last_battle_time" field.
+func LastBattleTimeLT(v int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldLT(FieldLastBattleTime, v))
+}
+
+// LastBattleTimeLTE applies the LTE predicate on the "last_battle_time" field.
+func LastBattleTimeLTE(v int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldLTE(FieldLastBattleTime, v))
+}
+
+// AccountIDEQ applies the EQ predicate on the "account_id" field.
+func AccountIDEQ(v string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldEQ(FieldAccountID, v))
+}
+
+// AccountIDNEQ applies the NEQ predicate on the "account_id" field.
+func AccountIDNEQ(v string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldNEQ(FieldAccountID, v))
+}
+
+// AccountIDIn applies the In predicate on the "account_id" field.
+func AccountIDIn(vs ...string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldIn(FieldAccountID, vs...))
+}
+
+// AccountIDNotIn applies the NotIn predicate on the "account_id" field.
+func AccountIDNotIn(vs ...string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldNotIn(FieldAccountID, vs...))
+}
+
+// AccountIDGT applies the GT predicate on the "account_id" field.
+func AccountIDGT(v string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldGT(FieldAccountID, v))
+}
+
+// AccountIDGTE applies the GTE predicate on the "account_id" field.
+func AccountIDGTE(v string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldGTE(FieldAccountID, v))
+}
+
+// AccountIDLT applies the LT predicate on the "account_id" field.
+func AccountIDLT(v string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldLT(FieldAccountID, v))
+}
+
+// AccountIDLTE applies the LTE predicate on the "account_id" field.
+func AccountIDLTE(v string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldLTE(FieldAccountID, v))
+}
+
+// AccountIDContains applies the Contains predicate on the "account_id" field.
+func AccountIDContains(v string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldContains(FieldAccountID, v))
+}
+
+// AccountIDHasPrefix applies the HasPrefix predicate on the "account_id" field.
+func AccountIDHasPrefix(v string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldHasPrefix(FieldAccountID, v))
+}
+
+// AccountIDHasSuffix applies the HasSuffix predicate on the "account_id" field.
+func AccountIDHasSuffix(v string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldHasSuffix(FieldAccountID, v))
+}
+
+// AccountIDEqualFold applies the EqualFold predicate on the "account_id" field.
+func AccountIDEqualFold(v string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldEqualFold(FieldAccountID, v))
+}
+
+// AccountIDContainsFold applies the ContainsFold predicate on the "account_id" field.
+func AccountIDContainsFold(v string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldContainsFold(FieldAccountID, v))
+}
+
+// ReferenceIDEQ applies the EQ predicate on the "reference_id" field.
+func ReferenceIDEQ(v string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldEQ(FieldReferenceID, v))
+}
+
+// ReferenceIDNEQ applies the NEQ predicate on the "reference_id" field.
+func ReferenceIDNEQ(v string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldNEQ(FieldReferenceID, v))
+}
+
+// ReferenceIDIn applies the In predicate on the "reference_id" field.
+func ReferenceIDIn(vs ...string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldIn(FieldReferenceID, vs...))
+}
+
+// ReferenceIDNotIn applies the NotIn predicate on the "reference_id" field.
+func ReferenceIDNotIn(vs ...string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldNotIn(FieldReferenceID, vs...))
+}
+
+// ReferenceIDGT applies the GT predicate on the "reference_id" field.
+func ReferenceIDGT(v string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldGT(FieldReferenceID, v))
+}
+
+// ReferenceIDGTE applies the GTE predicate on the "reference_id" field.
+func ReferenceIDGTE(v string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldGTE(FieldReferenceID, v))
+}
+
+// ReferenceIDLT applies the LT predicate on the "reference_id" field.
+func ReferenceIDLT(v string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldLT(FieldReferenceID, v))
+}
+
+// ReferenceIDLTE applies the LTE predicate on the "reference_id" field.
+func ReferenceIDLTE(v string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldLTE(FieldReferenceID, v))
+}
+
+// ReferenceIDContains applies the Contains predicate on the "reference_id" field.
+func ReferenceIDContains(v string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldContains(FieldReferenceID, v))
+}
+
+// ReferenceIDHasPrefix applies the HasPrefix predicate on the "reference_id" field.
+func ReferenceIDHasPrefix(v string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldHasPrefix(FieldReferenceID, v))
+}
+
+// ReferenceIDHasSuffix applies the HasSuffix predicate on the "reference_id" field.
+func ReferenceIDHasSuffix(v string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldHasSuffix(FieldReferenceID, v))
+}
+
+// ReferenceIDEqualFold applies the EqualFold predicate on the "reference_id" field.
+func ReferenceIDEqualFold(v string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldEqualFold(FieldReferenceID, v))
+}
+
+// ReferenceIDContainsFold applies the ContainsFold predicate on the "reference_id" field.
+func ReferenceIDContainsFold(v string) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldContainsFold(FieldReferenceID, v))
+}
+
+// RatingBattlesEQ applies the EQ predicate on the "rating_battles" field.
+func RatingBattlesEQ(v int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldEQ(FieldRatingBattles, v))
+}
+
+// RatingBattlesNEQ applies the NEQ predicate on the "rating_battles" field.
+func RatingBattlesNEQ(v int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldNEQ(FieldRatingBattles, v))
+}
+
+// RatingBattlesIn applies the In predicate on the "rating_battles" field.
+func RatingBattlesIn(vs ...int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldIn(FieldRatingBattles, vs...))
+}
+
+// RatingBattlesNotIn applies the NotIn predicate on the "rating_battles" field.
+func RatingBattlesNotIn(vs ...int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldNotIn(FieldRatingBattles, vs...))
+}
+
+// RatingBattlesGT applies the GT predicate on the "rating_battles" field.
+func RatingBattlesGT(v int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldGT(FieldRatingBattles, v))
+}
+
+// RatingBattlesGTE applies the GTE predicate on the "rating_battles" field.
+func RatingBattlesGTE(v int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldGTE(FieldRatingBattles, v))
+}
+
+// RatingBattlesLT applies the LT predicate on the "rating_battles" field.
+func RatingBattlesLT(v int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldLT(FieldRatingBattles, v))
+}
+
+// RatingBattlesLTE applies the LTE predicate on the "rating_battles" field.
+func RatingBattlesLTE(v int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldLTE(FieldRatingBattles, v))
+}
+
+// RegularBattlesEQ applies the EQ predicate on the "regular_battles" field.
+func RegularBattlesEQ(v int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldEQ(FieldRegularBattles, v))
+}
+
+// RegularBattlesNEQ applies the NEQ predicate on the "regular_battles" field.
+func RegularBattlesNEQ(v int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldNEQ(FieldRegularBattles, v))
+}
+
+// RegularBattlesIn applies the In predicate on the "regular_battles" field.
+func RegularBattlesIn(vs ...int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldIn(FieldRegularBattles, vs...))
+}
+
+// RegularBattlesNotIn applies the NotIn predicate on the "regular_battles" field.
+func RegularBattlesNotIn(vs ...int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldNotIn(FieldRegularBattles, vs...))
+}
+
+// RegularBattlesGT applies the GT predicate on the "regular_battles" field.
+func RegularBattlesGT(v int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldGT(FieldRegularBattles, v))
+}
+
+// RegularBattlesGTE applies the GTE predicate on the "regular_battles" field.
+func RegularBattlesGTE(v int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldGTE(FieldRegularBattles, v))
+}
+
+// RegularBattlesLT applies the LT predicate on the "regular_battles" field.
+func RegularBattlesLT(v int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldLT(FieldRegularBattles, v))
+}
+
+// RegularBattlesLTE applies the LTE predicate on the "regular_battles" field.
+func RegularBattlesLTE(v int) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.FieldLTE(FieldRegularBattles, v))
+}
+
+// HasAccount applies the HasEdge predicate on the "account" edge.
+func HasAccount() predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, AccountTable, AccountColumn),
+		)
+		sqlgraph.HasNeighbors(s, step)
+	})
+}
+
+// HasAccountWith applies the HasEdge predicate on the "account" edge with a given conditions (other predicates).
+func HasAccountWith(preds ...predicate.Account) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(func(s *sql.Selector) {
+		step := newAccountStep()
+		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+			for _, p := range preds {
+				p(s)
+			}
+		})
+	})
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.AccountSnapshot) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.AccountSnapshot) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.AccountSnapshot) predicate.AccountSnapshot {
+	return predicate.AccountSnapshot(sql.NotPredicates(p))
+}
diff --git a/internal/database/ent/db/accountsnapshot_create.go b/internal/database/ent/db/accountsnapshot_create.go
new file mode 100644
index 00000000..c4059901
--- /dev/null
+++ b/internal/database/ent/db/accountsnapshot_create.go
@@ -0,0 +1,392 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/account"
+	"github.com/cufee/aftermath/internal/database/ent/db/accountsnapshot"
+	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/stats/frame"
+)
+
+// AccountSnapshotCreate is the builder for creating a AccountSnapshot entity.
+type AccountSnapshotCreate struct {
+	config
+	mutation *AccountSnapshotMutation
+	hooks    []Hook
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (asc *AccountSnapshotCreate) SetCreatedAt(i int) *AccountSnapshotCreate {
+	asc.mutation.SetCreatedAt(i)
+	return asc
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (asc *AccountSnapshotCreate) SetNillableCreatedAt(i *int) *AccountSnapshotCreate {
+	if i != nil {
+		asc.SetCreatedAt(*i)
+	}
+	return asc
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (asc *AccountSnapshotCreate) SetUpdatedAt(i int) *AccountSnapshotCreate {
+	asc.mutation.SetUpdatedAt(i)
+	return asc
+}
+
+// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
+func (asc *AccountSnapshotCreate) SetNillableUpdatedAt(i *int) *AccountSnapshotCreate {
+	if i != nil {
+		asc.SetUpdatedAt(*i)
+	}
+	return asc
+}
+
+// SetType sets the "type" field.
+func (asc *AccountSnapshotCreate) SetType(mt models.SnapshotType) *AccountSnapshotCreate {
+	asc.mutation.SetType(mt)
+	return asc
+}
+
+// SetLastBattleTime sets the "last_battle_time" field.
+func (asc *AccountSnapshotCreate) SetLastBattleTime(i int) *AccountSnapshotCreate {
+	asc.mutation.SetLastBattleTime(i)
+	return asc
+}
+
+// SetAccountID sets the "account_id" field.
+func (asc *AccountSnapshotCreate) SetAccountID(s string) *AccountSnapshotCreate {
+	asc.mutation.SetAccountID(s)
+	return asc
+}
+
+// SetReferenceID sets the "reference_id" field.
+func (asc *AccountSnapshotCreate) SetReferenceID(s string) *AccountSnapshotCreate {
+	asc.mutation.SetReferenceID(s)
+	return asc
+}
+
+// SetRatingBattles sets the "rating_battles" field.
+func (asc *AccountSnapshotCreate) SetRatingBattles(i int) *AccountSnapshotCreate {
+	asc.mutation.SetRatingBattles(i)
+	return asc
+}
+
+// SetRatingFrame sets the "rating_frame" field.
+func (asc *AccountSnapshotCreate) SetRatingFrame(ff frame.StatsFrame) *AccountSnapshotCreate {
+	asc.mutation.SetRatingFrame(ff)
+	return asc
+}
+
+// SetRegularBattles sets the "regular_battles" field.
+func (asc *AccountSnapshotCreate) SetRegularBattles(i int) *AccountSnapshotCreate {
+	asc.mutation.SetRegularBattles(i)
+	return asc
+}
+
+// SetRegularFrame sets the "regular_frame" field.
+func (asc *AccountSnapshotCreate) SetRegularFrame(ff frame.StatsFrame) *AccountSnapshotCreate {
+	asc.mutation.SetRegularFrame(ff)
+	return asc
+}
+
+// SetID sets the "id" field.
+func (asc *AccountSnapshotCreate) SetID(s string) *AccountSnapshotCreate {
+	asc.mutation.SetID(s)
+	return asc
+}
+
+// SetNillableID sets the "id" field if the given value is not nil.
+func (asc *AccountSnapshotCreate) SetNillableID(s *string) *AccountSnapshotCreate {
+	if s != nil {
+		asc.SetID(*s)
+	}
+	return asc
+}
+
+// SetAccount sets the "account" edge to the Account entity.
+func (asc *AccountSnapshotCreate) SetAccount(a *Account) *AccountSnapshotCreate {
+	return asc.SetAccountID(a.ID)
+}
+
+// Mutation returns the AccountSnapshotMutation object of the builder.
+func (asc *AccountSnapshotCreate) Mutation() *AccountSnapshotMutation {
+	return asc.mutation
+}
+
+// Save creates the AccountSnapshot in the database.
+func (asc *AccountSnapshotCreate) Save(ctx context.Context) (*AccountSnapshot, error) {
+	asc.defaults()
+	return withHooks(ctx, asc.sqlSave, asc.mutation, asc.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (asc *AccountSnapshotCreate) SaveX(ctx context.Context) *AccountSnapshot {
+	v, err := asc.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (asc *AccountSnapshotCreate) Exec(ctx context.Context) error {
+	_, err := asc.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (asc *AccountSnapshotCreate) ExecX(ctx context.Context) {
+	if err := asc.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (asc *AccountSnapshotCreate) defaults() {
+	if _, ok := asc.mutation.CreatedAt(); !ok {
+		v := accountsnapshot.DefaultCreatedAt()
+		asc.mutation.SetCreatedAt(v)
+	}
+	if _, ok := asc.mutation.UpdatedAt(); !ok {
+		v := accountsnapshot.DefaultUpdatedAt()
+		asc.mutation.SetUpdatedAt(v)
+	}
+	if _, ok := asc.mutation.ID(); !ok {
+		v := accountsnapshot.DefaultID()
+		asc.mutation.SetID(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (asc *AccountSnapshotCreate) check() error {
+	if _, ok := asc.mutation.CreatedAt(); !ok {
+		return &ValidationError{Name: "created_at", err: errors.New(`db: missing required field "AccountSnapshot.created_at"`)}
+	}
+	if _, ok := asc.mutation.UpdatedAt(); !ok {
+		return &ValidationError{Name: "updated_at", err: errors.New(`db: missing required field "AccountSnapshot.updated_at"`)}
+	}
+	if _, ok := asc.mutation.GetType(); !ok {
+		return &ValidationError{Name: "type", err: errors.New(`db: missing required field "AccountSnapshot.type"`)}
+	}
+	if v, ok := asc.mutation.GetType(); ok {
+		if err := accountsnapshot.TypeValidator(v); err != nil {
+			return &ValidationError{Name: "type", err: fmt.Errorf(`db: validator failed for field "AccountSnapshot.type": %w`, err)}
+		}
+	}
+	if _, ok := asc.mutation.LastBattleTime(); !ok {
+		return &ValidationError{Name: "last_battle_time", err: errors.New(`db: missing required field "AccountSnapshot.last_battle_time"`)}
+	}
+	if _, ok := asc.mutation.AccountID(); !ok {
+		return &ValidationError{Name: "account_id", err: errors.New(`db: missing required field "AccountSnapshot.account_id"`)}
+	}
+	if v, ok := asc.mutation.AccountID(); ok {
+		if err := accountsnapshot.AccountIDValidator(v); err != nil {
+			return &ValidationError{Name: "account_id", err: fmt.Errorf(`db: validator failed for field "AccountSnapshot.account_id": %w`, err)}
+		}
+	}
+	if _, ok := asc.mutation.ReferenceID(); !ok {
+		return &ValidationError{Name: "reference_id", err: errors.New(`db: missing required field "AccountSnapshot.reference_id"`)}
+	}
+	if v, ok := asc.mutation.ReferenceID(); ok {
+		if err := accountsnapshot.ReferenceIDValidator(v); err != nil {
+			return &ValidationError{Name: "reference_id", err: fmt.Errorf(`db: validator failed for field "AccountSnapshot.reference_id": %w`, err)}
+		}
+	}
+	if _, ok := asc.mutation.RatingBattles(); !ok {
+		return &ValidationError{Name: "rating_battles", err: errors.New(`db: missing required field "AccountSnapshot.rating_battles"`)}
+	}
+	if _, ok := asc.mutation.RatingFrame(); !ok {
+		return &ValidationError{Name: "rating_frame", err: errors.New(`db: missing required field "AccountSnapshot.rating_frame"`)}
+	}
+	if _, ok := asc.mutation.RegularBattles(); !ok {
+		return &ValidationError{Name: "regular_battles", err: errors.New(`db: missing required field "AccountSnapshot.regular_battles"`)}
+	}
+	if _, ok := asc.mutation.RegularFrame(); !ok {
+		return &ValidationError{Name: "regular_frame", err: errors.New(`db: missing required field "AccountSnapshot.regular_frame"`)}
+	}
+	if _, ok := asc.mutation.AccountID(); !ok {
+		return &ValidationError{Name: "account", err: errors.New(`db: missing required edge "AccountSnapshot.account"`)}
+	}
+	return nil
+}
+
+func (asc *AccountSnapshotCreate) sqlSave(ctx context.Context) (*AccountSnapshot, error) {
+	if err := asc.check(); err != nil {
+		return nil, err
+	}
+	_node, _spec := asc.createSpec()
+	if err := sqlgraph.CreateNode(ctx, asc.driver, _spec); err != nil {
+		if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	if _spec.ID.Value != nil {
+		if id, ok := _spec.ID.Value.(string); ok {
+			_node.ID = id
+		} else {
+			return nil, fmt.Errorf("unexpected AccountSnapshot.ID type: %T", _spec.ID.Value)
+		}
+	}
+	asc.mutation.id = &_node.ID
+	asc.mutation.done = true
+	return _node, nil
+}
+
+func (asc *AccountSnapshotCreate) createSpec() (*AccountSnapshot, *sqlgraph.CreateSpec) {
+	var (
+		_node = &AccountSnapshot{config: asc.config}
+		_spec = sqlgraph.NewCreateSpec(accountsnapshot.Table, sqlgraph.NewFieldSpec(accountsnapshot.FieldID, field.TypeString))
+	)
+	if id, ok := asc.mutation.ID(); ok {
+		_node.ID = id
+		_spec.ID.Value = id
+	}
+	if value, ok := asc.mutation.CreatedAt(); ok {
+		_spec.SetField(accountsnapshot.FieldCreatedAt, field.TypeInt, value)
+		_node.CreatedAt = value
+	}
+	if value, ok := asc.mutation.UpdatedAt(); ok {
+		_spec.SetField(accountsnapshot.FieldUpdatedAt, field.TypeInt, value)
+		_node.UpdatedAt = value
+	}
+	if value, ok := asc.mutation.GetType(); ok {
+		_spec.SetField(accountsnapshot.FieldType, field.TypeEnum, value)
+		_node.Type = value
+	}
+	if value, ok := asc.mutation.LastBattleTime(); ok {
+		_spec.SetField(accountsnapshot.FieldLastBattleTime, field.TypeInt, value)
+		_node.LastBattleTime = value
+	}
+	if value, ok := asc.mutation.ReferenceID(); ok {
+		_spec.SetField(accountsnapshot.FieldReferenceID, field.TypeString, value)
+		_node.ReferenceID = value
+	}
+	if value, ok := asc.mutation.RatingBattles(); ok {
+		_spec.SetField(accountsnapshot.FieldRatingBattles, field.TypeInt, value)
+		_node.RatingBattles = value
+	}
+	if value, ok := asc.mutation.RatingFrame(); ok {
+		_spec.SetField(accountsnapshot.FieldRatingFrame, field.TypeJSON, value)
+		_node.RatingFrame = value
+	}
+	if value, ok := asc.mutation.RegularBattles(); ok {
+		_spec.SetField(accountsnapshot.FieldRegularBattles, field.TypeInt, value)
+		_node.RegularBattles = value
+	}
+	if value, ok := asc.mutation.RegularFrame(); ok {
+		_spec.SetField(accountsnapshot.FieldRegularFrame, field.TypeJSON, value)
+		_node.RegularFrame = value
+	}
+	if nodes := asc.mutation.AccountIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   accountsnapshot.AccountTable,
+			Columns: []string{accountsnapshot.AccountColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(account.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_node.AccountID = nodes[0]
+		_spec.Edges = append(_spec.Edges, edge)
+	}
+	return _node, _spec
+}
+
+// AccountSnapshotCreateBulk is the builder for creating many AccountSnapshot entities in bulk.
+type AccountSnapshotCreateBulk struct {
+	config
+	err      error
+	builders []*AccountSnapshotCreate
+}
+
+// Save creates the AccountSnapshot entities in the database.
+func (ascb *AccountSnapshotCreateBulk) Save(ctx context.Context) ([]*AccountSnapshot, error) {
+	if ascb.err != nil {
+		return nil, ascb.err
+	}
+	specs := make([]*sqlgraph.CreateSpec, len(ascb.builders))
+	nodes := make([]*AccountSnapshot, len(ascb.builders))
+	mutators := make([]Mutator, len(ascb.builders))
+	for i := range ascb.builders {
+		func(i int, root context.Context) {
+			builder := ascb.builders[i]
+			builder.defaults()
+			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+				mutation, ok := m.(*AccountSnapshotMutation)
+				if !ok {
+					return nil, fmt.Errorf("unexpected mutation type %T", m)
+				}
+				if err := builder.check(); err != nil {
+					return nil, err
+				}
+				builder.mutation = mutation
+				var err error
+				nodes[i], specs[i] = builder.createSpec()
+				if i < len(mutators)-1 {
+					_, err = mutators[i+1].Mutate(root, ascb.builders[i+1].mutation)
+				} else {
+					spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
+					// Invoke the actual operation on the latest mutation in the chain.
+					if err = sqlgraph.BatchCreate(ctx, ascb.driver, spec); err != nil {
+						if sqlgraph.IsConstraintError(err) {
+							err = &ConstraintError{msg: err.Error(), wrap: err}
+						}
+					}
+				}
+				if err != nil {
+					return nil, err
+				}
+				mutation.id = &nodes[i].ID
+				mutation.done = true
+				return nodes[i], nil
+			})
+			for i := len(builder.hooks) - 1; i >= 0; i-- {
+				mut = builder.hooks[i](mut)
+			}
+			mutators[i] = mut
+		}(i, ctx)
+	}
+	if len(mutators) > 0 {
+		if _, err := mutators[0].Mutate(ctx, ascb.builders[0].mutation); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (ascb *AccountSnapshotCreateBulk) SaveX(ctx context.Context) []*AccountSnapshot {
+	v, err := ascb.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (ascb *AccountSnapshotCreateBulk) Exec(ctx context.Context) error {
+	_, err := ascb.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (ascb *AccountSnapshotCreateBulk) ExecX(ctx context.Context) {
+	if err := ascb.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/database/ent/db/accountsnapshot_delete.go b/internal/database/ent/db/accountsnapshot_delete.go
new file mode 100644
index 00000000..b218aa4c
--- /dev/null
+++ b/internal/database/ent/db/accountsnapshot_delete.go
@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/accountsnapshot"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+)
+
+// AccountSnapshotDelete is the builder for deleting a AccountSnapshot entity.
+type AccountSnapshotDelete struct {
+	config
+	hooks    []Hook
+	mutation *AccountSnapshotMutation
+}
+
+// Where appends a list predicates to the AccountSnapshotDelete builder.
+func (asd *AccountSnapshotDelete) Where(ps ...predicate.AccountSnapshot) *AccountSnapshotDelete {
+	asd.mutation.Where(ps...)
+	return asd
+}
+
+// Exec executes the deletion query and returns how many vertices were deleted.
+func (asd *AccountSnapshotDelete) Exec(ctx context.Context) (int, error) {
+	return withHooks(ctx, asd.sqlExec, asd.mutation, asd.hooks)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (asd *AccountSnapshotDelete) ExecX(ctx context.Context) int {
+	n, err := asd.Exec(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return n
+}
+
+func (asd *AccountSnapshotDelete) sqlExec(ctx context.Context) (int, error) {
+	_spec := sqlgraph.NewDeleteSpec(accountsnapshot.Table, sqlgraph.NewFieldSpec(accountsnapshot.FieldID, field.TypeString))
+	if ps := asd.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	affected, err := sqlgraph.DeleteNodes(ctx, asd.driver, _spec)
+	if err != nil && sqlgraph.IsConstraintError(err) {
+		err = &ConstraintError{msg: err.Error(), wrap: err}
+	}
+	asd.mutation.done = true
+	return affected, err
+}
+
+// AccountSnapshotDeleteOne is the builder for deleting a single AccountSnapshot entity.
+type AccountSnapshotDeleteOne struct {
+	asd *AccountSnapshotDelete
+}
+
+// Where appends a list predicates to the AccountSnapshotDelete builder.
+func (asdo *AccountSnapshotDeleteOne) Where(ps ...predicate.AccountSnapshot) *AccountSnapshotDeleteOne {
+	asdo.asd.mutation.Where(ps...)
+	return asdo
+}
+
+// Exec executes the deletion query.
+func (asdo *AccountSnapshotDeleteOne) Exec(ctx context.Context) error {
+	n, err := asdo.asd.Exec(ctx)
+	switch {
+	case err != nil:
+		return err
+	case n == 0:
+		return &NotFoundError{accountsnapshot.Label}
+	default:
+		return nil
+	}
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (asdo *AccountSnapshotDeleteOne) ExecX(ctx context.Context) {
+	if err := asdo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/database/ent/db/accountsnapshot_query.go b/internal/database/ent/db/accountsnapshot_query.go
new file mode 100644
index 00000000..af3bf5f9
--- /dev/null
+++ b/internal/database/ent/db/accountsnapshot_query.go
@@ -0,0 +1,605 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"fmt"
+	"math"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/account"
+	"github.com/cufee/aftermath/internal/database/ent/db/accountsnapshot"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+)
+
+// AccountSnapshotQuery is the builder for querying AccountSnapshot entities.
+type AccountSnapshotQuery struct {
+	config
+	ctx         *QueryContext
+	order       []accountsnapshot.OrderOption
+	inters      []Interceptor
+	predicates  []predicate.AccountSnapshot
+	withAccount *AccountQuery
+	// intermediate query (i.e. traversal path).
+	sql  *sql.Selector
+	path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the AccountSnapshotQuery builder.
+func (asq *AccountSnapshotQuery) Where(ps ...predicate.AccountSnapshot) *AccountSnapshotQuery {
+	asq.predicates = append(asq.predicates, ps...)
+	return asq
+}
+
+// Limit the number of records to be returned by this query.
+func (asq *AccountSnapshotQuery) Limit(limit int) *AccountSnapshotQuery {
+	asq.ctx.Limit = &limit
+	return asq
+}
+
+// Offset to start from.
+func (asq *AccountSnapshotQuery) Offset(offset int) *AccountSnapshotQuery {
+	asq.ctx.Offset = &offset
+	return asq
+}
+
+// Unique configures the query builder to filter duplicate records on query.
+// By default, unique is set to true, and can be disabled using this method.
+func (asq *AccountSnapshotQuery) Unique(unique bool) *AccountSnapshotQuery {
+	asq.ctx.Unique = &unique
+	return asq
+}
+
+// Order specifies how the records should be ordered.
+func (asq *AccountSnapshotQuery) Order(o ...accountsnapshot.OrderOption) *AccountSnapshotQuery {
+	asq.order = append(asq.order, o...)
+	return asq
+}
+
+// QueryAccount chains the current query on the "account" edge.
+func (asq *AccountSnapshotQuery) QueryAccount() *AccountQuery {
+	query := (&AccountClient{config: asq.config}).Query()
+	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+		if err := asq.prepareQuery(ctx); err != nil {
+			return nil, err
+		}
+		selector := asq.sqlQuery(ctx)
+		if err := selector.Err(); err != nil {
+			return nil, err
+		}
+		step := sqlgraph.NewStep(
+			sqlgraph.From(accountsnapshot.Table, accountsnapshot.FieldID, selector),
+			sqlgraph.To(account.Table, account.FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, accountsnapshot.AccountTable, accountsnapshot.AccountColumn),
+		)
+		fromU = sqlgraph.SetNeighbors(asq.driver.Dialect(), step)
+		return fromU, nil
+	}
+	return query
+}
+
+// First returns the first AccountSnapshot entity from the query.
+// Returns a *NotFoundError when no AccountSnapshot was found.
+func (asq *AccountSnapshotQuery) First(ctx context.Context) (*AccountSnapshot, error) {
+	nodes, err := asq.Limit(1).All(setContextOp(ctx, asq.ctx, "First"))
+	if err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nil, &NotFoundError{accountsnapshot.Label}
+	}
+	return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (asq *AccountSnapshotQuery) FirstX(ctx context.Context) *AccountSnapshot {
+	node, err := asq.First(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return node
+}
+
+// FirstID returns the first AccountSnapshot ID from the query.
+// Returns a *NotFoundError when no AccountSnapshot ID was found.
+func (asq *AccountSnapshotQuery) FirstID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = asq.Limit(1).IDs(setContextOp(ctx, asq.ctx, "FirstID")); err != nil {
+		return
+	}
+	if len(ids) == 0 {
+		err = &NotFoundError{accountsnapshot.Label}
+		return
+	}
+	return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (asq *AccountSnapshotQuery) FirstIDX(ctx context.Context) string {
+	id, err := asq.FirstID(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return id
+}
+
+// Only returns a single AccountSnapshot entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one AccountSnapshot entity is found.
+// Returns a *NotFoundError when no AccountSnapshot entities are found.
+func (asq *AccountSnapshotQuery) Only(ctx context.Context) (*AccountSnapshot, error) {
+	nodes, err := asq.Limit(2).All(setContextOp(ctx, asq.ctx, "Only"))
+	if err != nil {
+		return nil, err
+	}
+	switch len(nodes) {
+	case 1:
+		return nodes[0], nil
+	case 0:
+		return nil, &NotFoundError{accountsnapshot.Label}
+	default:
+		return nil, &NotSingularError{accountsnapshot.Label}
+	}
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (asq *AccountSnapshotQuery) OnlyX(ctx context.Context) *AccountSnapshot {
+	node, err := asq.Only(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// OnlyID is like Only, but returns the only AccountSnapshot ID in the query.
+// Returns a *NotSingularError when more than one AccountSnapshot ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (asq *AccountSnapshotQuery) OnlyID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = asq.Limit(2).IDs(setContextOp(ctx, asq.ctx, "OnlyID")); err != nil {
+		return
+	}
+	switch len(ids) {
+	case 1:
+		id = ids[0]
+	case 0:
+		err = &NotFoundError{accountsnapshot.Label}
+	default:
+		err = &NotSingularError{accountsnapshot.Label}
+	}
+	return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (asq *AccountSnapshotQuery) OnlyIDX(ctx context.Context) string {
+	id, err := asq.OnlyID(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return id
+}
+
+// All executes the query and returns a list of AccountSnapshots.
+func (asq *AccountSnapshotQuery) All(ctx context.Context) ([]*AccountSnapshot, error) {
+	ctx = setContextOp(ctx, asq.ctx, "All")
+	if err := asq.prepareQuery(ctx); err != nil {
+		return nil, err
+	}
+	qr := querierAll[[]*AccountSnapshot, *AccountSnapshotQuery]()
+	return withInterceptors[[]*AccountSnapshot](ctx, asq, qr, asq.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (asq *AccountSnapshotQuery) AllX(ctx context.Context) []*AccountSnapshot {
+	nodes, err := asq.All(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return nodes
+}
+
+// IDs executes the query and returns a list of AccountSnapshot IDs.
+func (asq *AccountSnapshotQuery) IDs(ctx context.Context) (ids []string, err error) {
+	if asq.ctx.Unique == nil && asq.path != nil {
+		asq.Unique(true)
+	}
+	ctx = setContextOp(ctx, asq.ctx, "IDs")
+	if err = asq.Select(accountsnapshot.FieldID).Scan(ctx, &ids); err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (asq *AccountSnapshotQuery) IDsX(ctx context.Context) []string {
+	ids, err := asq.IDs(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return ids
+}
+
+// Count returns the count of the given query.
+func (asq *AccountSnapshotQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, asq.ctx, "Count")
+	if err := asq.prepareQuery(ctx); err != nil {
+		return 0, err
+	}
+	return withInterceptors[int](ctx, asq, querierCount[*AccountSnapshotQuery](), asq.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (asq *AccountSnapshotQuery) CountX(ctx context.Context) int {
+	count, err := asq.Count(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (asq *AccountSnapshotQuery) Exist(ctx context.Context) (bool, error) {
+	ctx = setContextOp(ctx, asq.ctx, "Exist")
+	switch _, err := asq.FirstID(ctx); {
+	case IsNotFound(err):
+		return false, nil
+	case err != nil:
+		return false, fmt.Errorf("db: check existence: %w", err)
+	default:
+		return true, nil
+	}
+}
+
+// ExistX is like Exist, but panics if an error occurs.
+func (asq *AccountSnapshotQuery) ExistX(ctx context.Context) bool {
+	exist, err := asq.Exist(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return exist
+}
+
+// Clone returns a duplicate of the AccountSnapshotQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (asq *AccountSnapshotQuery) Clone() *AccountSnapshotQuery {
+	if asq == nil {
+		return nil
+	}
+	return &AccountSnapshotQuery{
+		config:      asq.config,
+		ctx:         asq.ctx.Clone(),
+		order:       append([]accountsnapshot.OrderOption{}, asq.order...),
+		inters:      append([]Interceptor{}, asq.inters...),
+		predicates:  append([]predicate.AccountSnapshot{}, asq.predicates...),
+		withAccount: asq.withAccount.Clone(),
+		// clone intermediate query.
+		sql:  asq.sql.Clone(),
+		path: asq.path,
+	}
+}
+
+// WithAccount tells the query-builder to eager-load the nodes that are connected to
+// the "account" edge. The optional arguments are used to configure the query builder of the edge.
+func (asq *AccountSnapshotQuery) WithAccount(opts ...func(*AccountQuery)) *AccountSnapshotQuery {
+	query := (&AccountClient{config: asq.config}).Query()
+	for _, opt := range opts {
+		opt(query)
+	}
+	asq.withAccount = query
+	return asq
+}
+
+// GroupBy is used to group vertices by one or more fields/columns.
+// It is often used with aggregate functions, like: count, max, mean, min, sum.
+//
+// Example:
+//
+//	var v []struct {
+//		CreatedAt int `json:"created_at,omitempty"`
+//		Count int `json:"count,omitempty"`
+//	}
+//
+//	client.AccountSnapshot.Query().
+//		GroupBy(accountsnapshot.FieldCreatedAt).
+//		Aggregate(db.Count()).
+//		Scan(ctx, &v)
+func (asq *AccountSnapshotQuery) GroupBy(field string, fields ...string) *AccountSnapshotGroupBy {
+	asq.ctx.Fields = append([]string{field}, fields...)
+	grbuild := &AccountSnapshotGroupBy{build: asq}
+	grbuild.flds = &asq.ctx.Fields
+	grbuild.label = accountsnapshot.Label
+	grbuild.scan = grbuild.Scan
+	return grbuild
+}
+
+// Select allows the selection one or more fields/columns for the given query,
+// instead of selecting all fields in the entity.
+//
+// Example:
+//
+//	var v []struct {
+//		CreatedAt int `json:"created_at,omitempty"`
+//	}
+//
+//	client.AccountSnapshot.Query().
+//		Select(accountsnapshot.FieldCreatedAt).
+//		Scan(ctx, &v)
+func (asq *AccountSnapshotQuery) Select(fields ...string) *AccountSnapshotSelect {
+	asq.ctx.Fields = append(asq.ctx.Fields, fields...)
+	sbuild := &AccountSnapshotSelect{AccountSnapshotQuery: asq}
+	sbuild.label = accountsnapshot.Label
+	sbuild.flds, sbuild.scan = &asq.ctx.Fields, sbuild.Scan
+	return sbuild
+}
+
+// Aggregate returns a AccountSnapshotSelect configured with the given aggregations.
+func (asq *AccountSnapshotQuery) Aggregate(fns ...AggregateFunc) *AccountSnapshotSelect {
+	return asq.Select().Aggregate(fns...)
+}
+
+func (asq *AccountSnapshotQuery) prepareQuery(ctx context.Context) error {
+	for _, inter := range asq.inters {
+		if inter == nil {
+			return fmt.Errorf("db: uninitialized interceptor (forgotten import db/runtime?)")
+		}
+		if trv, ok := inter.(Traverser); ok {
+			if err := trv.Traverse(ctx, asq); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range asq.ctx.Fields {
+		if !accountsnapshot.ValidColumn(f) {
+			return &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+		}
+	}
+	if asq.path != nil {
+		prev, err := asq.path(ctx)
+		if err != nil {
+			return err
+		}
+		asq.sql = prev
+	}
+	return nil
+}
+
+func (asq *AccountSnapshotQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*AccountSnapshot, error) {
+	var (
+		nodes       = []*AccountSnapshot{}
+		_spec       = asq.querySpec()
+		loadedTypes = [1]bool{
+			asq.withAccount != nil,
+		}
+	)
+	_spec.ScanValues = func(columns []string) ([]any, error) {
+		return (*AccountSnapshot).scanValues(nil, columns)
+	}
+	_spec.Assign = func(columns []string, values []any) error {
+		node := &AccountSnapshot{config: asq.config}
+		nodes = append(nodes, node)
+		node.Edges.loadedTypes = loadedTypes
+		return node.assignValues(columns, values)
+	}
+	for i := range hooks {
+		hooks[i](ctx, _spec)
+	}
+	if err := sqlgraph.QueryNodes(ctx, asq.driver, _spec); err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nodes, nil
+	}
+	if query := asq.withAccount; query != nil {
+		if err := asq.loadAccount(ctx, query, nodes, nil,
+			func(n *AccountSnapshot, e *Account) { n.Edges.Account = e }); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+func (asq *AccountSnapshotQuery) loadAccount(ctx context.Context, query *AccountQuery, nodes []*AccountSnapshot, init func(*AccountSnapshot), assign func(*AccountSnapshot, *Account)) error {
+	ids := make([]string, 0, len(nodes))
+	nodeids := make(map[string][]*AccountSnapshot)
+	for i := range nodes {
+		fk := nodes[i].AccountID
+		if _, ok := nodeids[fk]; !ok {
+			ids = append(ids, fk)
+		}
+		nodeids[fk] = append(nodeids[fk], nodes[i])
+	}
+	if len(ids) == 0 {
+		return nil
+	}
+	query.Where(account.IDIn(ids...))
+	neighbors, err := query.All(ctx)
+	if err != nil {
+		return err
+	}
+	for _, n := range neighbors {
+		nodes, ok := nodeids[n.ID]
+		if !ok {
+			return fmt.Errorf(`unexpected foreign-key "account_id" returned %v`, n.ID)
+		}
+		for i := range nodes {
+			assign(nodes[i], n)
+		}
+	}
+	return nil
+}
+
+func (asq *AccountSnapshotQuery) sqlCount(ctx context.Context) (int, error) {
+	_spec := asq.querySpec()
+	_spec.Node.Columns = asq.ctx.Fields
+	if len(asq.ctx.Fields) > 0 {
+		_spec.Unique = asq.ctx.Unique != nil && *asq.ctx.Unique
+	}
+	return sqlgraph.CountNodes(ctx, asq.driver, _spec)
+}
+
+func (asq *AccountSnapshotQuery) querySpec() *sqlgraph.QuerySpec {
+	_spec := sqlgraph.NewQuerySpec(accountsnapshot.Table, accountsnapshot.Columns, sqlgraph.NewFieldSpec(accountsnapshot.FieldID, field.TypeString))
+	_spec.From = asq.sql
+	if unique := asq.ctx.Unique; unique != nil {
+		_spec.Unique = *unique
+	} else if asq.path != nil {
+		_spec.Unique = true
+	}
+	if fields := asq.ctx.Fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, accountsnapshot.FieldID)
+		for i := range fields {
+			if fields[i] != accountsnapshot.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+			}
+		}
+		if asq.withAccount != nil {
+			_spec.Node.AddColumnOnce(accountsnapshot.FieldAccountID)
+		}
+	}
+	if ps := asq.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if limit := asq.ctx.Limit; limit != nil {
+		_spec.Limit = *limit
+	}
+	if offset := asq.ctx.Offset; offset != nil {
+		_spec.Offset = *offset
+	}
+	if ps := asq.order; len(ps) > 0 {
+		_spec.Order = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	return _spec
+}
+
+func (asq *AccountSnapshotQuery) sqlQuery(ctx context.Context) *sql.Selector {
+	builder := sql.Dialect(asq.driver.Dialect())
+	t1 := builder.Table(accountsnapshot.Table)
+	columns := asq.ctx.Fields
+	if len(columns) == 0 {
+		columns = accountsnapshot.Columns
+	}
+	selector := builder.Select(t1.Columns(columns...)...).From(t1)
+	if asq.sql != nil {
+		selector = asq.sql
+		selector.Select(selector.Columns(columns...)...)
+	}
+	if asq.ctx.Unique != nil && *asq.ctx.Unique {
+		selector.Distinct()
+	}
+	for _, p := range asq.predicates {
+		p(selector)
+	}
+	for _, p := range asq.order {
+		p(selector)
+	}
+	if offset := asq.ctx.Offset; offset != nil {
+		// limit is mandatory for offset clause. We start
+		// with default value, and override it below if needed.
+		selector.Offset(*offset).Limit(math.MaxInt32)
+	}
+	if limit := asq.ctx.Limit; limit != nil {
+		selector.Limit(*limit)
+	}
+	return selector
+}
+
+// AccountSnapshotGroupBy is the group-by builder for AccountSnapshot entities.
+type AccountSnapshotGroupBy struct {
+	selector
+	build *AccountSnapshotQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (asgb *AccountSnapshotGroupBy) Aggregate(fns ...AggregateFunc) *AccountSnapshotGroupBy {
+	asgb.fns = append(asgb.fns, fns...)
+	return asgb
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (asgb *AccountSnapshotGroupBy) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, asgb.build.ctx, "GroupBy")
+	if err := asgb.build.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*AccountSnapshotQuery, *AccountSnapshotGroupBy](ctx, asgb.build, asgb, asgb.build.inters, v)
+}
+
+func (asgb *AccountSnapshotGroupBy) sqlScan(ctx context.Context, root *AccountSnapshotQuery, v any) error {
+	selector := root.sqlQuery(ctx).Select()
+	aggregation := make([]string, 0, len(asgb.fns))
+	for _, fn := range asgb.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*asgb.flds)+len(asgb.fns))
+		for _, f := range *asgb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*asgb.flds...)...)
+	if err := selector.Err(); err != nil {
+		return err
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := asgb.build.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
+
+// AccountSnapshotSelect is the builder for selecting fields of AccountSnapshot entities.
+type AccountSnapshotSelect struct {
+	*AccountSnapshotQuery
+	selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (ass *AccountSnapshotSelect) Aggregate(fns ...AggregateFunc) *AccountSnapshotSelect {
+	ass.fns = append(ass.fns, fns...)
+	return ass
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (ass *AccountSnapshotSelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, ass.ctx, "Select")
+	if err := ass.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*AccountSnapshotQuery, *AccountSnapshotSelect](ctx, ass.AccountSnapshotQuery, ass, ass.inters, v)
+}
+
+func (ass *AccountSnapshotSelect) sqlScan(ctx context.Context, root *AccountSnapshotQuery, v any) error {
+	selector := root.sqlQuery(ctx)
+	aggregation := make([]string, 0, len(ass.fns))
+	for _, fn := range ass.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	switch n := len(*ass.selector.flds); {
+	case n == 0 && len(aggregation) > 0:
+		selector.Select(aggregation...)
+	case n != 0 && len(aggregation) > 0:
+		selector.AppendSelect(aggregation...)
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := ass.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
diff --git a/internal/database/ent/db/accountsnapshot_update.go b/internal/database/ent/db/accountsnapshot_update.go
new file mode 100644
index 00000000..0d1dcb15
--- /dev/null
+++ b/internal/database/ent/db/accountsnapshot_update.go
@@ -0,0 +1,573 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/accountsnapshot"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/stats/frame"
+)
+
+// AccountSnapshotUpdate is the builder for updating AccountSnapshot entities.
+type AccountSnapshotUpdate struct {
+	config
+	hooks    []Hook
+	mutation *AccountSnapshotMutation
+}
+
+// Where appends a list predicates to the AccountSnapshotUpdate builder.
+func (asu *AccountSnapshotUpdate) Where(ps ...predicate.AccountSnapshot) *AccountSnapshotUpdate {
+	asu.mutation.Where(ps...)
+	return asu
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (asu *AccountSnapshotUpdate) SetUpdatedAt(i int) *AccountSnapshotUpdate {
+	asu.mutation.ResetUpdatedAt()
+	asu.mutation.SetUpdatedAt(i)
+	return asu
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (asu *AccountSnapshotUpdate) AddUpdatedAt(i int) *AccountSnapshotUpdate {
+	asu.mutation.AddUpdatedAt(i)
+	return asu
+}
+
+// SetType sets the "type" field.
+func (asu *AccountSnapshotUpdate) SetType(mt models.SnapshotType) *AccountSnapshotUpdate {
+	asu.mutation.SetType(mt)
+	return asu
+}
+
+// SetNillableType sets the "type" field if the given value is not nil.
+func (asu *AccountSnapshotUpdate) SetNillableType(mt *models.SnapshotType) *AccountSnapshotUpdate {
+	if mt != nil {
+		asu.SetType(*mt)
+	}
+	return asu
+}
+
+// SetLastBattleTime sets the "last_battle_time" field.
+func (asu *AccountSnapshotUpdate) SetLastBattleTime(i int) *AccountSnapshotUpdate {
+	asu.mutation.ResetLastBattleTime()
+	asu.mutation.SetLastBattleTime(i)
+	return asu
+}
+
+// SetNillableLastBattleTime sets the "last_battle_time" field if the given value is not nil.
+func (asu *AccountSnapshotUpdate) SetNillableLastBattleTime(i *int) *AccountSnapshotUpdate {
+	if i != nil {
+		asu.SetLastBattleTime(*i)
+	}
+	return asu
+}
+
+// AddLastBattleTime adds i to the "last_battle_time" field.
+func (asu *AccountSnapshotUpdate) AddLastBattleTime(i int) *AccountSnapshotUpdate {
+	asu.mutation.AddLastBattleTime(i)
+	return asu
+}
+
+// SetReferenceID sets the "reference_id" field.
+func (asu *AccountSnapshotUpdate) SetReferenceID(s string) *AccountSnapshotUpdate {
+	asu.mutation.SetReferenceID(s)
+	return asu
+}
+
+// SetNillableReferenceID sets the "reference_id" field if the given value is not nil.
+func (asu *AccountSnapshotUpdate) SetNillableReferenceID(s *string) *AccountSnapshotUpdate {
+	if s != nil {
+		asu.SetReferenceID(*s)
+	}
+	return asu
+}
+
+// SetRatingBattles sets the "rating_battles" field.
+func (asu *AccountSnapshotUpdate) SetRatingBattles(i int) *AccountSnapshotUpdate {
+	asu.mutation.ResetRatingBattles()
+	asu.mutation.SetRatingBattles(i)
+	return asu
+}
+
+// SetNillableRatingBattles sets the "rating_battles" field if the given value is not nil.
+func (asu *AccountSnapshotUpdate) SetNillableRatingBattles(i *int) *AccountSnapshotUpdate {
+	if i != nil {
+		asu.SetRatingBattles(*i)
+	}
+	return asu
+}
+
+// AddRatingBattles adds i to the "rating_battles" field.
+func (asu *AccountSnapshotUpdate) AddRatingBattles(i int) *AccountSnapshotUpdate {
+	asu.mutation.AddRatingBattles(i)
+	return asu
+}
+
+// SetRatingFrame sets the "rating_frame" field.
+func (asu *AccountSnapshotUpdate) SetRatingFrame(ff frame.StatsFrame) *AccountSnapshotUpdate {
+	asu.mutation.SetRatingFrame(ff)
+	return asu
+}
+
+// SetNillableRatingFrame sets the "rating_frame" field if the given value is not nil.
+func (asu *AccountSnapshotUpdate) SetNillableRatingFrame(ff *frame.StatsFrame) *AccountSnapshotUpdate {
+	if ff != nil {
+		asu.SetRatingFrame(*ff)
+	}
+	return asu
+}
+
+// SetRegularBattles sets the "regular_battles" field.
+func (asu *AccountSnapshotUpdate) SetRegularBattles(i int) *AccountSnapshotUpdate {
+	asu.mutation.ResetRegularBattles()
+	asu.mutation.SetRegularBattles(i)
+	return asu
+}
+
+// SetNillableRegularBattles sets the "regular_battles" field if the given value is not nil.
+func (asu *AccountSnapshotUpdate) SetNillableRegularBattles(i *int) *AccountSnapshotUpdate {
+	if i != nil {
+		asu.SetRegularBattles(*i)
+	}
+	return asu
+}
+
+// AddRegularBattles adds i to the "regular_battles" field.
+func (asu *AccountSnapshotUpdate) AddRegularBattles(i int) *AccountSnapshotUpdate {
+	asu.mutation.AddRegularBattles(i)
+	return asu
+}
+
+// SetRegularFrame sets the "regular_frame" field.
+func (asu *AccountSnapshotUpdate) SetRegularFrame(ff frame.StatsFrame) *AccountSnapshotUpdate {
+	asu.mutation.SetRegularFrame(ff)
+	return asu
+}
+
+// SetNillableRegularFrame sets the "regular_frame" field if the given value is not nil.
+func (asu *AccountSnapshotUpdate) SetNillableRegularFrame(ff *frame.StatsFrame) *AccountSnapshotUpdate {
+	if ff != nil {
+		asu.SetRegularFrame(*ff)
+	}
+	return asu
+}
+
+// Mutation returns the AccountSnapshotMutation object of the builder.
+func (asu *AccountSnapshotUpdate) Mutation() *AccountSnapshotMutation {
+	return asu.mutation
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (asu *AccountSnapshotUpdate) Save(ctx context.Context) (int, error) {
+	asu.defaults()
+	return withHooks(ctx, asu.sqlSave, asu.mutation, asu.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (asu *AccountSnapshotUpdate) SaveX(ctx context.Context) int {
+	affected, err := asu.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return affected
+}
+
+// Exec executes the query.
+func (asu *AccountSnapshotUpdate) Exec(ctx context.Context) error {
+	_, err := asu.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (asu *AccountSnapshotUpdate) ExecX(ctx context.Context) {
+	if err := asu.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (asu *AccountSnapshotUpdate) defaults() {
+	if _, ok := asu.mutation.UpdatedAt(); !ok {
+		v := accountsnapshot.UpdateDefaultUpdatedAt()
+		asu.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (asu *AccountSnapshotUpdate) check() error {
+	if v, ok := asu.mutation.GetType(); ok {
+		if err := accountsnapshot.TypeValidator(v); err != nil {
+			return &ValidationError{Name: "type", err: fmt.Errorf(`db: validator failed for field "AccountSnapshot.type": %w`, err)}
+		}
+	}
+	if v, ok := asu.mutation.ReferenceID(); ok {
+		if err := accountsnapshot.ReferenceIDValidator(v); err != nil {
+			return &ValidationError{Name: "reference_id", err: fmt.Errorf(`db: validator failed for field "AccountSnapshot.reference_id": %w`, err)}
+		}
+	}
+	if _, ok := asu.mutation.AccountID(); asu.mutation.AccountCleared() && !ok {
+		return errors.New(`db: clearing a required unique edge "AccountSnapshot.account"`)
+	}
+	return nil
+}
+
+func (asu *AccountSnapshotUpdate) sqlSave(ctx context.Context) (n int, err error) {
+	if err := asu.check(); err != nil {
+		return n, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(accountsnapshot.Table, accountsnapshot.Columns, sqlgraph.NewFieldSpec(accountsnapshot.FieldID, field.TypeString))
+	if ps := asu.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := asu.mutation.UpdatedAt(); ok {
+		_spec.SetField(accountsnapshot.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := asu.mutation.AddedUpdatedAt(); ok {
+		_spec.AddField(accountsnapshot.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := asu.mutation.GetType(); ok {
+		_spec.SetField(accountsnapshot.FieldType, field.TypeEnum, value)
+	}
+	if value, ok := asu.mutation.LastBattleTime(); ok {
+		_spec.SetField(accountsnapshot.FieldLastBattleTime, field.TypeInt, value)
+	}
+	if value, ok := asu.mutation.AddedLastBattleTime(); ok {
+		_spec.AddField(accountsnapshot.FieldLastBattleTime, field.TypeInt, value)
+	}
+	if value, ok := asu.mutation.ReferenceID(); ok {
+		_spec.SetField(accountsnapshot.FieldReferenceID, field.TypeString, value)
+	}
+	if value, ok := asu.mutation.RatingBattles(); ok {
+		_spec.SetField(accountsnapshot.FieldRatingBattles, field.TypeInt, value)
+	}
+	if value, ok := asu.mutation.AddedRatingBattles(); ok {
+		_spec.AddField(accountsnapshot.FieldRatingBattles, field.TypeInt, value)
+	}
+	if value, ok := asu.mutation.RatingFrame(); ok {
+		_spec.SetField(accountsnapshot.FieldRatingFrame, field.TypeJSON, value)
+	}
+	if value, ok := asu.mutation.RegularBattles(); ok {
+		_spec.SetField(accountsnapshot.FieldRegularBattles, field.TypeInt, value)
+	}
+	if value, ok := asu.mutation.AddedRegularBattles(); ok {
+		_spec.AddField(accountsnapshot.FieldRegularBattles, field.TypeInt, value)
+	}
+	if value, ok := asu.mutation.RegularFrame(); ok {
+		_spec.SetField(accountsnapshot.FieldRegularFrame, field.TypeJSON, value)
+	}
+	if n, err = sqlgraph.UpdateNodes(ctx, asu.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{accountsnapshot.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return 0, err
+	}
+	asu.mutation.done = true
+	return n, nil
+}
+
+// AccountSnapshotUpdateOne is the builder for updating a single AccountSnapshot entity.
+type AccountSnapshotUpdateOne struct {
+	config
+	fields   []string
+	hooks    []Hook
+	mutation *AccountSnapshotMutation
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (asuo *AccountSnapshotUpdateOne) SetUpdatedAt(i int) *AccountSnapshotUpdateOne {
+	asuo.mutation.ResetUpdatedAt()
+	asuo.mutation.SetUpdatedAt(i)
+	return asuo
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (asuo *AccountSnapshotUpdateOne) AddUpdatedAt(i int) *AccountSnapshotUpdateOne {
+	asuo.mutation.AddUpdatedAt(i)
+	return asuo
+}
+
+// SetType sets the "type" field.
+func (asuo *AccountSnapshotUpdateOne) SetType(mt models.SnapshotType) *AccountSnapshotUpdateOne {
+	asuo.mutation.SetType(mt)
+	return asuo
+}
+
+// SetNillableType sets the "type" field if the given value is not nil.
+func (asuo *AccountSnapshotUpdateOne) SetNillableType(mt *models.SnapshotType) *AccountSnapshotUpdateOne {
+	if mt != nil {
+		asuo.SetType(*mt)
+	}
+	return asuo
+}
+
+// SetLastBattleTime sets the "last_battle_time" field.
+func (asuo *AccountSnapshotUpdateOne) SetLastBattleTime(i int) *AccountSnapshotUpdateOne {
+	asuo.mutation.ResetLastBattleTime()
+	asuo.mutation.SetLastBattleTime(i)
+	return asuo
+}
+
+// SetNillableLastBattleTime sets the "last_battle_time" field if the given value is not nil.
+func (asuo *AccountSnapshotUpdateOne) SetNillableLastBattleTime(i *int) *AccountSnapshotUpdateOne {
+	if i != nil {
+		asuo.SetLastBattleTime(*i)
+	}
+	return asuo
+}
+
+// AddLastBattleTime adds i to the "last_battle_time" field.
+func (asuo *AccountSnapshotUpdateOne) AddLastBattleTime(i int) *AccountSnapshotUpdateOne {
+	asuo.mutation.AddLastBattleTime(i)
+	return asuo
+}
+
+// SetReferenceID sets the "reference_id" field.
+func (asuo *AccountSnapshotUpdateOne) SetReferenceID(s string) *AccountSnapshotUpdateOne {
+	asuo.mutation.SetReferenceID(s)
+	return asuo
+}
+
+// SetNillableReferenceID sets the "reference_id" field if the given value is not nil.
+func (asuo *AccountSnapshotUpdateOne) SetNillableReferenceID(s *string) *AccountSnapshotUpdateOne {
+	if s != nil {
+		asuo.SetReferenceID(*s)
+	}
+	return asuo
+}
+
+// SetRatingBattles sets the "rating_battles" field.
+func (asuo *AccountSnapshotUpdateOne) SetRatingBattles(i int) *AccountSnapshotUpdateOne {
+	asuo.mutation.ResetRatingBattles()
+	asuo.mutation.SetRatingBattles(i)
+	return asuo
+}
+
+// SetNillableRatingBattles sets the "rating_battles" field if the given value is not nil.
+func (asuo *AccountSnapshotUpdateOne) SetNillableRatingBattles(i *int) *AccountSnapshotUpdateOne {
+	if i != nil {
+		asuo.SetRatingBattles(*i)
+	}
+	return asuo
+}
+
+// AddRatingBattles adds i to the "rating_battles" field.
+func (asuo *AccountSnapshotUpdateOne) AddRatingBattles(i int) *AccountSnapshotUpdateOne {
+	asuo.mutation.AddRatingBattles(i)
+	return asuo
+}
+
+// SetRatingFrame sets the "rating_frame" field.
+func (asuo *AccountSnapshotUpdateOne) SetRatingFrame(ff frame.StatsFrame) *AccountSnapshotUpdateOne {
+	asuo.mutation.SetRatingFrame(ff)
+	return asuo
+}
+
+// SetNillableRatingFrame sets the "rating_frame" field if the given value is not nil.
+func (asuo *AccountSnapshotUpdateOne) SetNillableRatingFrame(ff *frame.StatsFrame) *AccountSnapshotUpdateOne {
+	if ff != nil {
+		asuo.SetRatingFrame(*ff)
+	}
+	return asuo
+}
+
+// SetRegularBattles sets the "regular_battles" field.
+func (asuo *AccountSnapshotUpdateOne) SetRegularBattles(i int) *AccountSnapshotUpdateOne {
+	asuo.mutation.ResetRegularBattles()
+	asuo.mutation.SetRegularBattles(i)
+	return asuo
+}
+
+// SetNillableRegularBattles sets the "regular_battles" field if the given value is not nil.
+func (asuo *AccountSnapshotUpdateOne) SetNillableRegularBattles(i *int) *AccountSnapshotUpdateOne {
+	if i != nil {
+		asuo.SetRegularBattles(*i)
+	}
+	return asuo
+}
+
+// AddRegularBattles adds i to the "regular_battles" field.
+func (asuo *AccountSnapshotUpdateOne) AddRegularBattles(i int) *AccountSnapshotUpdateOne {
+	asuo.mutation.AddRegularBattles(i)
+	return asuo
+}
+
+// SetRegularFrame sets the "regular_frame" field.
+func (asuo *AccountSnapshotUpdateOne) SetRegularFrame(ff frame.StatsFrame) *AccountSnapshotUpdateOne {
+	asuo.mutation.SetRegularFrame(ff)
+	return asuo
+}
+
+// SetNillableRegularFrame sets the "regular_frame" field if the given value is not nil.
+func (asuo *AccountSnapshotUpdateOne) SetNillableRegularFrame(ff *frame.StatsFrame) *AccountSnapshotUpdateOne {
+	if ff != nil {
+		asuo.SetRegularFrame(*ff)
+	}
+	return asuo
+}
+
+// Mutation returns the AccountSnapshotMutation object of the builder.
+func (asuo *AccountSnapshotUpdateOne) Mutation() *AccountSnapshotMutation {
+	return asuo.mutation
+}
+
+// Where appends a list predicates to the AccountSnapshotUpdate builder.
+func (asuo *AccountSnapshotUpdateOne) Where(ps ...predicate.AccountSnapshot) *AccountSnapshotUpdateOne {
+	asuo.mutation.Where(ps...)
+	return asuo
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (asuo *AccountSnapshotUpdateOne) Select(field string, fields ...string) *AccountSnapshotUpdateOne {
+	asuo.fields = append([]string{field}, fields...)
+	return asuo
+}
+
+// Save executes the query and returns the updated AccountSnapshot entity.
+func (asuo *AccountSnapshotUpdateOne) Save(ctx context.Context) (*AccountSnapshot, error) {
+	asuo.defaults()
+	return withHooks(ctx, asuo.sqlSave, asuo.mutation, asuo.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (asuo *AccountSnapshotUpdateOne) SaveX(ctx context.Context) *AccountSnapshot {
+	node, err := asuo.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// Exec executes the query on the entity.
+func (asuo *AccountSnapshotUpdateOne) Exec(ctx context.Context) error {
+	_, err := asuo.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (asuo *AccountSnapshotUpdateOne) ExecX(ctx context.Context) {
+	if err := asuo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (asuo *AccountSnapshotUpdateOne) defaults() {
+	if _, ok := asuo.mutation.UpdatedAt(); !ok {
+		v := accountsnapshot.UpdateDefaultUpdatedAt()
+		asuo.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (asuo *AccountSnapshotUpdateOne) check() error {
+	if v, ok := asuo.mutation.GetType(); ok {
+		if err := accountsnapshot.TypeValidator(v); err != nil {
+			return &ValidationError{Name: "type", err: fmt.Errorf(`db: validator failed for field "AccountSnapshot.type": %w`, err)}
+		}
+	}
+	if v, ok := asuo.mutation.ReferenceID(); ok {
+		if err := accountsnapshot.ReferenceIDValidator(v); err != nil {
+			return &ValidationError{Name: "reference_id", err: fmt.Errorf(`db: validator failed for field "AccountSnapshot.reference_id": %w`, err)}
+		}
+	}
+	if _, ok := asuo.mutation.AccountID(); asuo.mutation.AccountCleared() && !ok {
+		return errors.New(`db: clearing a required unique edge "AccountSnapshot.account"`)
+	}
+	return nil
+}
+
+func (asuo *AccountSnapshotUpdateOne) sqlSave(ctx context.Context) (_node *AccountSnapshot, err error) {
+	if err := asuo.check(); err != nil {
+		return _node, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(accountsnapshot.Table, accountsnapshot.Columns, sqlgraph.NewFieldSpec(accountsnapshot.FieldID, field.TypeString))
+	id, ok := asuo.mutation.ID()
+	if !ok {
+		return nil, &ValidationError{Name: "id", err: errors.New(`db: missing "AccountSnapshot.id" for update`)}
+	}
+	_spec.Node.ID.Value = id
+	if fields := asuo.fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, accountsnapshot.FieldID)
+		for _, f := range fields {
+			if !accountsnapshot.ValidColumn(f) {
+				return nil, &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+			}
+			if f != accountsnapshot.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, f)
+			}
+		}
+	}
+	if ps := asuo.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := asuo.mutation.UpdatedAt(); ok {
+		_spec.SetField(accountsnapshot.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := asuo.mutation.AddedUpdatedAt(); ok {
+		_spec.AddField(accountsnapshot.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := asuo.mutation.GetType(); ok {
+		_spec.SetField(accountsnapshot.FieldType, field.TypeEnum, value)
+	}
+	if value, ok := asuo.mutation.LastBattleTime(); ok {
+		_spec.SetField(accountsnapshot.FieldLastBattleTime, field.TypeInt, value)
+	}
+	if value, ok := asuo.mutation.AddedLastBattleTime(); ok {
+		_spec.AddField(accountsnapshot.FieldLastBattleTime, field.TypeInt, value)
+	}
+	if value, ok := asuo.mutation.ReferenceID(); ok {
+		_spec.SetField(accountsnapshot.FieldReferenceID, field.TypeString, value)
+	}
+	if value, ok := asuo.mutation.RatingBattles(); ok {
+		_spec.SetField(accountsnapshot.FieldRatingBattles, field.TypeInt, value)
+	}
+	if value, ok := asuo.mutation.AddedRatingBattles(); ok {
+		_spec.AddField(accountsnapshot.FieldRatingBattles, field.TypeInt, value)
+	}
+	if value, ok := asuo.mutation.RatingFrame(); ok {
+		_spec.SetField(accountsnapshot.FieldRatingFrame, field.TypeJSON, value)
+	}
+	if value, ok := asuo.mutation.RegularBattles(); ok {
+		_spec.SetField(accountsnapshot.FieldRegularBattles, field.TypeInt, value)
+	}
+	if value, ok := asuo.mutation.AddedRegularBattles(); ok {
+		_spec.AddField(accountsnapshot.FieldRegularBattles, field.TypeInt, value)
+	}
+	if value, ok := asuo.mutation.RegularFrame(); ok {
+		_spec.SetField(accountsnapshot.FieldRegularFrame, field.TypeJSON, value)
+	}
+	_node = &AccountSnapshot{config: asuo.config}
+	_spec.Assign = _node.assignValues
+	_spec.ScanValues = _node.scanValues
+	if err = sqlgraph.UpdateNode(ctx, asuo.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{accountsnapshot.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	asuo.mutation.done = true
+	return _node, nil
+}
diff --git a/internal/database/ent/db/achievementssnapshot.go b/internal/database/ent/db/achievementssnapshot.go
new file mode 100644
index 00000000..b26ece54
--- /dev/null
+++ b/internal/database/ent/db/achievementssnapshot.go
@@ -0,0 +1,216 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+	"github.com/cufee/aftermath/internal/database/ent/db/account"
+	"github.com/cufee/aftermath/internal/database/ent/db/achievementssnapshot"
+	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/am-wg-proxy-next/v2/types"
+)
+
+// AchievementsSnapshot is the model entity for the AchievementsSnapshot schema.
+type AchievementsSnapshot struct {
+	config `json:"-"`
+	// ID of the ent.
+	ID string `json:"id,omitempty"`
+	// CreatedAt holds the value of the "created_at" field.
+	CreatedAt int `json:"created_at,omitempty"`
+	// UpdatedAt holds the value of the "updated_at" field.
+	UpdatedAt int `json:"updated_at,omitempty"`
+	// Type holds the value of the "type" field.
+	Type models.SnapshotType `json:"type,omitempty"`
+	// AccountID holds the value of the "account_id" field.
+	AccountID string `json:"account_id,omitempty"`
+	// ReferenceID holds the value of the "reference_id" field.
+	ReferenceID string `json:"reference_id,omitempty"`
+	// Battles holds the value of the "battles" field.
+	Battles int `json:"battles,omitempty"`
+	// LastBattleTime holds the value of the "last_battle_time" field.
+	LastBattleTime int `json:"last_battle_time,omitempty"`
+	// Data holds the value of the "data" field.
+	Data types.AchievementsFrame `json:"data,omitempty"`
+	// Edges holds the relations/edges for other nodes in the graph.
+	// The values are being populated by the AchievementsSnapshotQuery when eager-loading is set.
+	Edges        AchievementsSnapshotEdges `json:"edges"`
+	selectValues sql.SelectValues
+}
+
+// AchievementsSnapshotEdges holds the relations/edges for other nodes in the graph.
+type AchievementsSnapshotEdges struct {
+	// Account holds the value of the account edge.
+	Account *Account `json:"account,omitempty"`
+	// loadedTypes holds the information for reporting if a
+	// type was loaded (or requested) in eager-loading or not.
+	loadedTypes [1]bool
+}
+
+// AccountOrErr returns the Account value or an error if the edge
+// was not loaded in eager-loading, or loaded but was not found.
+func (e AchievementsSnapshotEdges) AccountOrErr() (*Account, error) {
+	if e.Account != nil {
+		return e.Account, nil
+	} else if e.loadedTypes[0] {
+		return nil, &NotFoundError{label: account.Label}
+	}
+	return nil, &NotLoadedError{edge: "account"}
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*AchievementsSnapshot) scanValues(columns []string) ([]any, error) {
+	values := make([]any, len(columns))
+	for i := range columns {
+		switch columns[i] {
+		case achievementssnapshot.FieldData:
+			values[i] = new([]byte)
+		case achievementssnapshot.FieldCreatedAt, achievementssnapshot.FieldUpdatedAt, achievementssnapshot.FieldBattles, achievementssnapshot.FieldLastBattleTime:
+			values[i] = new(sql.NullInt64)
+		case achievementssnapshot.FieldID, achievementssnapshot.FieldType, achievementssnapshot.FieldAccountID, achievementssnapshot.FieldReferenceID:
+			values[i] = new(sql.NullString)
+		default:
+			values[i] = new(sql.UnknownType)
+		}
+	}
+	return values, nil
+}
+
+// assignValues assigns the values that were returned from sql.Rows (after scanning)
+// to the AchievementsSnapshot fields.
+func (as *AchievementsSnapshot) assignValues(columns []string, values []any) error {
+	if m, n := len(values), len(columns); m < n {
+		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
+	}
+	for i := range columns {
+		switch columns[i] {
+		case achievementssnapshot.FieldID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field id", values[i])
+			} else if value.Valid {
+				as.ID = value.String
+			}
+		case achievementssnapshot.FieldCreatedAt:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field created_at", values[i])
+			} else if value.Valid {
+				as.CreatedAt = int(value.Int64)
+			}
+		case achievementssnapshot.FieldUpdatedAt:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
+			} else if value.Valid {
+				as.UpdatedAt = int(value.Int64)
+			}
+		case achievementssnapshot.FieldType:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field type", values[i])
+			} else if value.Valid {
+				as.Type = models.SnapshotType(value.String)
+			}
+		case achievementssnapshot.FieldAccountID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field account_id", values[i])
+			} else if value.Valid {
+				as.AccountID = value.String
+			}
+		case achievementssnapshot.FieldReferenceID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field reference_id", values[i])
+			} else if value.Valid {
+				as.ReferenceID = value.String
+			}
+		case achievementssnapshot.FieldBattles:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field battles", values[i])
+			} else if value.Valid {
+				as.Battles = int(value.Int64)
+			}
+		case achievementssnapshot.FieldLastBattleTime:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field last_battle_time", values[i])
+			} else if value.Valid {
+				as.LastBattleTime = int(value.Int64)
+			}
+		case achievementssnapshot.FieldData:
+			if value, ok := values[i].(*[]byte); !ok {
+				return fmt.Errorf("unexpected type %T for field data", values[i])
+			} else if value != nil && len(*value) > 0 {
+				if err := json.Unmarshal(*value, &as.Data); err != nil {
+					return fmt.Errorf("unmarshal field data: %w", err)
+				}
+			}
+		default:
+			as.selectValues.Set(columns[i], values[i])
+		}
+	}
+	return nil
+}
+
+// Value returns the ent.Value that was dynamically selected and assigned to the AchievementsSnapshot.
+// This includes values selected through modifiers, order, etc.
+func (as *AchievementsSnapshot) Value(name string) (ent.Value, error) {
+	return as.selectValues.Get(name)
+}
+
+// QueryAccount queries the "account" edge of the AchievementsSnapshot entity.
+func (as *AchievementsSnapshot) QueryAccount() *AccountQuery {
+	return NewAchievementsSnapshotClient(as.config).QueryAccount(as)
+}
+
+// Update returns a builder for updating this AchievementsSnapshot.
+// Note that you need to call AchievementsSnapshot.Unwrap() before calling this method if this AchievementsSnapshot
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (as *AchievementsSnapshot) Update() *AchievementsSnapshotUpdateOne {
+	return NewAchievementsSnapshotClient(as.config).UpdateOne(as)
+}
+
+// Unwrap unwraps the AchievementsSnapshot entity that was returned from a transaction after it was closed,
+// so that all future queries will be executed through the driver which created the transaction.
+func (as *AchievementsSnapshot) Unwrap() *AchievementsSnapshot {
+	_tx, ok := as.config.driver.(*txDriver)
+	if !ok {
+		panic("db: AchievementsSnapshot is not a transactional entity")
+	}
+	as.config.driver = _tx.drv
+	return as
+}
+
+// String implements the fmt.Stringer.
+func (as *AchievementsSnapshot) String() string {
+	var builder strings.Builder
+	builder.WriteString("AchievementsSnapshot(")
+	builder.WriteString(fmt.Sprintf("id=%v, ", as.ID))
+	builder.WriteString("created_at=")
+	builder.WriteString(fmt.Sprintf("%v", as.CreatedAt))
+	builder.WriteString(", ")
+	builder.WriteString("updated_at=")
+	builder.WriteString(fmt.Sprintf("%v", as.UpdatedAt))
+	builder.WriteString(", ")
+	builder.WriteString("type=")
+	builder.WriteString(fmt.Sprintf("%v", as.Type))
+	builder.WriteString(", ")
+	builder.WriteString("account_id=")
+	builder.WriteString(as.AccountID)
+	builder.WriteString(", ")
+	builder.WriteString("reference_id=")
+	builder.WriteString(as.ReferenceID)
+	builder.WriteString(", ")
+	builder.WriteString("battles=")
+	builder.WriteString(fmt.Sprintf("%v", as.Battles))
+	builder.WriteString(", ")
+	builder.WriteString("last_battle_time=")
+	builder.WriteString(fmt.Sprintf("%v", as.LastBattleTime))
+	builder.WriteString(", ")
+	builder.WriteString("data=")
+	builder.WriteString(fmt.Sprintf("%v", as.Data))
+	builder.WriteByte(')')
+	return builder.String()
+}
+
+// AchievementsSnapshots is a parsable slice of AchievementsSnapshot.
+type AchievementsSnapshots []*AchievementsSnapshot
diff --git a/internal/database/ent/db/achievementssnapshot/achievementssnapshot.go b/internal/database/ent/db/achievementssnapshot/achievementssnapshot.go
new file mode 100644
index 00000000..e6c64d4f
--- /dev/null
+++ b/internal/database/ent/db/achievementssnapshot/achievementssnapshot.go
@@ -0,0 +1,150 @@
+// Code generated by ent, DO NOT EDIT.
+
+package achievementssnapshot
+
+import (
+	"fmt"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+const (
+	// Label holds the string label denoting the achievementssnapshot type in the database.
+	Label = "achievements_snapshot"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// FieldType holds the string denoting the type field in the database.
+	FieldType = "type"
+	// FieldAccountID holds the string denoting the account_id field in the database.
+	FieldAccountID = "account_id"
+	// FieldReferenceID holds the string denoting the reference_id field in the database.
+	FieldReferenceID = "reference_id"
+	// FieldBattles holds the string denoting the battles field in the database.
+	FieldBattles = "battles"
+	// FieldLastBattleTime holds the string denoting the last_battle_time field in the database.
+	FieldLastBattleTime = "last_battle_time"
+	// FieldData holds the string denoting the data field in the database.
+	FieldData = "data"
+	// EdgeAccount holds the string denoting the account edge name in mutations.
+	EdgeAccount = "account"
+	// Table holds the table name of the achievementssnapshot in the database.
+	Table = "achievements_snapshots"
+	// AccountTable is the table that holds the account relation/edge.
+	AccountTable = "achievements_snapshots"
+	// AccountInverseTable is the table name for the Account entity.
+	// It exists in this package in order to avoid circular dependency with the "account" package.
+	AccountInverseTable = "accounts"
+	// AccountColumn is the table column denoting the account relation/edge.
+	AccountColumn = "account_id"
+)
+
+// Columns holds all SQL columns for achievementssnapshot fields.
+var Columns = []string{
+	FieldID,
+	FieldCreatedAt,
+	FieldUpdatedAt,
+	FieldType,
+	FieldAccountID,
+	FieldReferenceID,
+	FieldBattles,
+	FieldLastBattleTime,
+	FieldData,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() int
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() int
+	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
+	UpdateDefaultUpdatedAt func() int
+	// AccountIDValidator is a validator for the "account_id" field. It is called by the builders before save.
+	AccountIDValidator func(string) error
+	// ReferenceIDValidator is a validator for the "reference_id" field. It is called by the builders before save.
+	ReferenceIDValidator func(string) error
+	// DefaultID holds the default value on creation for the "id" field.
+	DefaultID func() string
+)
+
+// TypeValidator is a validator for the "type" field enum values. It is called by the builders before save.
+func TypeValidator(_type models.SnapshotType) error {
+	switch _type {
+	case "live", "daily":
+		return nil
+	default:
+		return fmt.Errorf("achievementssnapshot: invalid enum value for type field: %q", _type)
+	}
+}
+
+// OrderOption defines the ordering options for the AchievementsSnapshot queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByType orders the results by the type field.
+func ByType(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldType, opts...).ToFunc()
+}
+
+// ByAccountID orders the results by the account_id field.
+func ByAccountID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldAccountID, opts...).ToFunc()
+}
+
+// ByReferenceID orders the results by the reference_id field.
+func ByReferenceID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldReferenceID, opts...).ToFunc()
+}
+
+// ByBattles orders the results by the battles field.
+func ByBattles(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldBattles, opts...).ToFunc()
+}
+
+// ByLastBattleTime orders the results by the last_battle_time field.
+func ByLastBattleTime(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldLastBattleTime, opts...).ToFunc()
+}
+
+// ByAccountField orders the results by account field.
+func ByAccountField(field string, opts ...sql.OrderTermOption) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborTerms(s, newAccountStep(), sql.OrderByField(field, opts...))
+	}
+}
+func newAccountStep() *sqlgraph.Step {
+	return sqlgraph.NewStep(
+		sqlgraph.From(Table, FieldID),
+		sqlgraph.To(AccountInverseTable, FieldID),
+		sqlgraph.Edge(sqlgraph.M2O, true, AccountTable, AccountColumn),
+	)
+}
diff --git a/internal/database/ent/db/achievementssnapshot/where.go b/internal/database/ent/db/achievementssnapshot/where.go
new file mode 100644
index 00000000..d7b2035f
--- /dev/null
+++ b/internal/database/ent/db/achievementssnapshot/where.go
@@ -0,0 +1,453 @@
+// Code generated by ent, DO NOT EDIT.
+
+package achievementssnapshot
+
+import (
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldLTE(FieldID, id))
+}
+
+// IDEqualFold applies the EqualFold predicate on the ID field.
+func IDEqualFold(id string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldEqualFold(FieldID, id))
+}
+
+// IDContainsFold applies the ContainsFold predicate on the ID field.
+func IDContainsFold(id string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldContainsFold(FieldID, id))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v int) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v int) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// AccountID applies equality check predicate on the "account_id" field. It's identical to AccountIDEQ.
+func AccountID(v string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldAccountID, v))
+}
+
+// ReferenceID applies equality check predicate on the "reference_id" field. It's identical to ReferenceIDEQ.
+func ReferenceID(v string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldReferenceID, v))
+}
+
+// Battles applies equality check predicate on the "battles" field. It's identical to BattlesEQ.
+func Battles(v int) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldBattles, v))
+}
+
+// LastBattleTime applies equality check predicate on the "last_battle_time" field. It's identical to LastBattleTimeEQ.
+func LastBattleTime(v int) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldLastBattleTime, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v int) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v int) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...int) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...int) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v int) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v int) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v int) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v int) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v int) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v int) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...int) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...int) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v int) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v int) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v int) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v int) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// TypeEQ applies the EQ predicate on the "type" field.
+func TypeEQ(v models.SnapshotType) predicate.AchievementsSnapshot {
+	vc := v
+	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldType, vc))
+}
+
+// TypeNEQ applies the NEQ predicate on the "type" field.
+func TypeNEQ(v models.SnapshotType) predicate.AchievementsSnapshot {
+	vc := v
+	return predicate.AchievementsSnapshot(sql.FieldNEQ(FieldType, vc))
+}
+
+// TypeIn applies the In predicate on the "type" field.
+func TypeIn(vs ...models.SnapshotType) predicate.AchievementsSnapshot {
+	v := make([]any, len(vs))
+	for i := range v {
+		v[i] = vs[i]
+	}
+	return predicate.AchievementsSnapshot(sql.FieldIn(FieldType, v...))
+}
+
+// TypeNotIn applies the NotIn predicate on the "type" field.
+func TypeNotIn(vs ...models.SnapshotType) predicate.AchievementsSnapshot {
+	v := make([]any, len(vs))
+	for i := range v {
+		v[i] = vs[i]
+	}
+	return predicate.AchievementsSnapshot(sql.FieldNotIn(FieldType, v...))
+}
+
+// AccountIDEQ applies the EQ predicate on the "account_id" field.
+func AccountIDEQ(v string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldAccountID, v))
+}
+
+// AccountIDNEQ applies the NEQ predicate on the "account_id" field.
+func AccountIDNEQ(v string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldNEQ(FieldAccountID, v))
+}
+
+// AccountIDIn applies the In predicate on the "account_id" field.
+func AccountIDIn(vs ...string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldIn(FieldAccountID, vs...))
+}
+
+// AccountIDNotIn applies the NotIn predicate on the "account_id" field.
+func AccountIDNotIn(vs ...string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldNotIn(FieldAccountID, vs...))
+}
+
+// AccountIDGT applies the GT predicate on the "account_id" field.
+func AccountIDGT(v string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldGT(FieldAccountID, v))
+}
+
+// AccountIDGTE applies the GTE predicate on the "account_id" field.
+func AccountIDGTE(v string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldGTE(FieldAccountID, v))
+}
+
+// AccountIDLT applies the LT predicate on the "account_id" field.
+func AccountIDLT(v string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldLT(FieldAccountID, v))
+}
+
+// AccountIDLTE applies the LTE predicate on the "account_id" field.
+func AccountIDLTE(v string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldLTE(FieldAccountID, v))
+}
+
+// AccountIDContains applies the Contains predicate on the "account_id" field.
+func AccountIDContains(v string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldContains(FieldAccountID, v))
+}
+
+// AccountIDHasPrefix applies the HasPrefix predicate on the "account_id" field.
+func AccountIDHasPrefix(v string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldHasPrefix(FieldAccountID, v))
+}
+
+// AccountIDHasSuffix applies the HasSuffix predicate on the "account_id" field.
+func AccountIDHasSuffix(v string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldHasSuffix(FieldAccountID, v))
+}
+
+// AccountIDEqualFold applies the EqualFold predicate on the "account_id" field.
+func AccountIDEqualFold(v string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldEqualFold(FieldAccountID, v))
+}
+
+// AccountIDContainsFold applies the ContainsFold predicate on the "account_id" field.
+func AccountIDContainsFold(v string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldContainsFold(FieldAccountID, v))
+}
+
+// ReferenceIDEQ applies the EQ predicate on the "reference_id" field.
+func ReferenceIDEQ(v string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldReferenceID, v))
+}
+
+// ReferenceIDNEQ applies the NEQ predicate on the "reference_id" field.
+func ReferenceIDNEQ(v string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldNEQ(FieldReferenceID, v))
+}
+
+// ReferenceIDIn applies the In predicate on the "reference_id" field.
+func ReferenceIDIn(vs ...string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldIn(FieldReferenceID, vs...))
+}
+
+// ReferenceIDNotIn applies the NotIn predicate on the "reference_id" field.
+func ReferenceIDNotIn(vs ...string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldNotIn(FieldReferenceID, vs...))
+}
+
+// ReferenceIDGT applies the GT predicate on the "reference_id" field.
+func ReferenceIDGT(v string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldGT(FieldReferenceID, v))
+}
+
+// ReferenceIDGTE applies the GTE predicate on the "reference_id" field.
+func ReferenceIDGTE(v string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldGTE(FieldReferenceID, v))
+}
+
+// ReferenceIDLT applies the LT predicate on the "reference_id" field.
+func ReferenceIDLT(v string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldLT(FieldReferenceID, v))
+}
+
+// ReferenceIDLTE applies the LTE predicate on the "reference_id" field.
+func ReferenceIDLTE(v string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldLTE(FieldReferenceID, v))
+}
+
+// ReferenceIDContains applies the Contains predicate on the "reference_id" field.
+func ReferenceIDContains(v string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldContains(FieldReferenceID, v))
+}
+
+// ReferenceIDHasPrefix applies the HasPrefix predicate on the "reference_id" field.
+func ReferenceIDHasPrefix(v string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldHasPrefix(FieldReferenceID, v))
+}
+
+// ReferenceIDHasSuffix applies the HasSuffix predicate on the "reference_id" field.
+func ReferenceIDHasSuffix(v string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldHasSuffix(FieldReferenceID, v))
+}
+
+// ReferenceIDEqualFold applies the EqualFold predicate on the "reference_id" field.
+func ReferenceIDEqualFold(v string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldEqualFold(FieldReferenceID, v))
+}
+
+// ReferenceIDContainsFold applies the ContainsFold predicate on the "reference_id" field.
+func ReferenceIDContainsFold(v string) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldContainsFold(FieldReferenceID, v))
+}
+
+// BattlesEQ applies the EQ predicate on the "battles" field.
+func BattlesEQ(v int) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldBattles, v))
+}
+
+// BattlesNEQ applies the NEQ predicate on the "battles" field.
+func BattlesNEQ(v int) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldNEQ(FieldBattles, v))
+}
+
+// BattlesIn applies the In predicate on the "battles" field.
+func BattlesIn(vs ...int) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldIn(FieldBattles, vs...))
+}
+
+// BattlesNotIn applies the NotIn predicate on the "battles" field.
+func BattlesNotIn(vs ...int) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldNotIn(FieldBattles, vs...))
+}
+
+// BattlesGT applies the GT predicate on the "battles" field.
+func BattlesGT(v int) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldGT(FieldBattles, v))
+}
+
+// BattlesGTE applies the GTE predicate on the "battles" field.
+func BattlesGTE(v int) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldGTE(FieldBattles, v))
+}
+
+// BattlesLT applies the LT predicate on the "battles" field.
+func BattlesLT(v int) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldLT(FieldBattles, v))
+}
+
+// BattlesLTE applies the LTE predicate on the "battles" field.
+func BattlesLTE(v int) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldLTE(FieldBattles, v))
+}
+
+// LastBattleTimeEQ applies the EQ predicate on the "last_battle_time" field.
+func LastBattleTimeEQ(v int) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldLastBattleTime, v))
+}
+
+// LastBattleTimeNEQ applies the NEQ predicate on the "last_battle_time" field.
+func LastBattleTimeNEQ(v int) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldNEQ(FieldLastBattleTime, v))
+}
+
+// LastBattleTimeIn applies the In predicate on the "last_battle_time" field.
+func LastBattleTimeIn(vs ...int) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldIn(FieldLastBattleTime, vs...))
+}
+
+// LastBattleTimeNotIn applies the NotIn predicate on the "last_battle_time" field.
+func LastBattleTimeNotIn(vs ...int) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldNotIn(FieldLastBattleTime, vs...))
+}
+
+// LastBattleTimeGT applies the GT predicate on the "last_battle_time" field.
+func LastBattleTimeGT(v int) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldGT(FieldLastBattleTime, v))
+}
+
+// LastBattleTimeGTE applies the GTE predicate on the "last_battle_time" field.
+func LastBattleTimeGTE(v int) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldGTE(FieldLastBattleTime, v))
+}
+
+// LastBattleTimeLT applies the LT predicate on the "last_battle_time" field.
+func LastBattleTimeLT(v int) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldLT(FieldLastBattleTime, v))
+}
+
+// LastBattleTimeLTE applies the LTE predicate on the "last_battle_time" field.
+func LastBattleTimeLTE(v int) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.FieldLTE(FieldLastBattleTime, v))
+}
+
+// HasAccount applies the HasEdge predicate on the "account" edge.
+func HasAccount() predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, AccountTable, AccountColumn),
+		)
+		sqlgraph.HasNeighbors(s, step)
+	})
+}
+
+// HasAccountWith applies the HasEdge predicate on the "account" edge with a given conditions (other predicates).
+func HasAccountWith(preds ...predicate.Account) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(func(s *sql.Selector) {
+		step := newAccountStep()
+		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+			for _, p := range preds {
+				p(s)
+			}
+		})
+	})
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.AchievementsSnapshot) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.AchievementsSnapshot) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.AchievementsSnapshot) predicate.AchievementsSnapshot {
+	return predicate.AchievementsSnapshot(sql.NotPredicates(p))
+}
diff --git a/internal/database/ent/db/achievementssnapshot_create.go b/internal/database/ent/db/achievementssnapshot_create.go
new file mode 100644
index 00000000..26b95982
--- /dev/null
+++ b/internal/database/ent/db/achievementssnapshot_create.go
@@ -0,0 +1,366 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/account"
+	"github.com/cufee/aftermath/internal/database/ent/db/achievementssnapshot"
+	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/am-wg-proxy-next/v2/types"
+)
+
+// AchievementsSnapshotCreate is the builder for creating a AchievementsSnapshot entity.
+type AchievementsSnapshotCreate struct {
+	config
+	mutation *AchievementsSnapshotMutation
+	hooks    []Hook
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (asc *AchievementsSnapshotCreate) SetCreatedAt(i int) *AchievementsSnapshotCreate {
+	asc.mutation.SetCreatedAt(i)
+	return asc
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (asc *AchievementsSnapshotCreate) SetNillableCreatedAt(i *int) *AchievementsSnapshotCreate {
+	if i != nil {
+		asc.SetCreatedAt(*i)
+	}
+	return asc
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (asc *AchievementsSnapshotCreate) SetUpdatedAt(i int) *AchievementsSnapshotCreate {
+	asc.mutation.SetUpdatedAt(i)
+	return asc
+}
+
+// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
+func (asc *AchievementsSnapshotCreate) SetNillableUpdatedAt(i *int) *AchievementsSnapshotCreate {
+	if i != nil {
+		asc.SetUpdatedAt(*i)
+	}
+	return asc
+}
+
+// SetType sets the "type" field.
+func (asc *AchievementsSnapshotCreate) SetType(mt models.SnapshotType) *AchievementsSnapshotCreate {
+	asc.mutation.SetType(mt)
+	return asc
+}
+
+// SetAccountID sets the "account_id" field.
+func (asc *AchievementsSnapshotCreate) SetAccountID(s string) *AchievementsSnapshotCreate {
+	asc.mutation.SetAccountID(s)
+	return asc
+}
+
+// SetReferenceID sets the "reference_id" field.
+func (asc *AchievementsSnapshotCreate) SetReferenceID(s string) *AchievementsSnapshotCreate {
+	asc.mutation.SetReferenceID(s)
+	return asc
+}
+
+// SetBattles sets the "battles" field.
+func (asc *AchievementsSnapshotCreate) SetBattles(i int) *AchievementsSnapshotCreate {
+	asc.mutation.SetBattles(i)
+	return asc
+}
+
+// SetLastBattleTime sets the "last_battle_time" field.
+func (asc *AchievementsSnapshotCreate) SetLastBattleTime(i int) *AchievementsSnapshotCreate {
+	asc.mutation.SetLastBattleTime(i)
+	return asc
+}
+
+// SetData sets the "data" field.
+func (asc *AchievementsSnapshotCreate) SetData(tf types.AchievementsFrame) *AchievementsSnapshotCreate {
+	asc.mutation.SetData(tf)
+	return asc
+}
+
+// SetID sets the "id" field.
+func (asc *AchievementsSnapshotCreate) SetID(s string) *AchievementsSnapshotCreate {
+	asc.mutation.SetID(s)
+	return asc
+}
+
+// SetNillableID sets the "id" field if the given value is not nil.
+func (asc *AchievementsSnapshotCreate) SetNillableID(s *string) *AchievementsSnapshotCreate {
+	if s != nil {
+		asc.SetID(*s)
+	}
+	return asc
+}
+
+// SetAccount sets the "account" edge to the Account entity.
+func (asc *AchievementsSnapshotCreate) SetAccount(a *Account) *AchievementsSnapshotCreate {
+	return asc.SetAccountID(a.ID)
+}
+
+// Mutation returns the AchievementsSnapshotMutation object of the builder.
+func (asc *AchievementsSnapshotCreate) Mutation() *AchievementsSnapshotMutation {
+	return asc.mutation
+}
+
+// Save creates the AchievementsSnapshot in the database.
+func (asc *AchievementsSnapshotCreate) Save(ctx context.Context) (*AchievementsSnapshot, error) {
+	asc.defaults()
+	return withHooks(ctx, asc.sqlSave, asc.mutation, asc.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (asc *AchievementsSnapshotCreate) SaveX(ctx context.Context) *AchievementsSnapshot {
+	v, err := asc.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (asc *AchievementsSnapshotCreate) Exec(ctx context.Context) error {
+	_, err := asc.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (asc *AchievementsSnapshotCreate) ExecX(ctx context.Context) {
+	if err := asc.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (asc *AchievementsSnapshotCreate) defaults() {
+	if _, ok := asc.mutation.CreatedAt(); !ok {
+		v := achievementssnapshot.DefaultCreatedAt()
+		asc.mutation.SetCreatedAt(v)
+	}
+	if _, ok := asc.mutation.UpdatedAt(); !ok {
+		v := achievementssnapshot.DefaultUpdatedAt()
+		asc.mutation.SetUpdatedAt(v)
+	}
+	if _, ok := asc.mutation.ID(); !ok {
+		v := achievementssnapshot.DefaultID()
+		asc.mutation.SetID(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (asc *AchievementsSnapshotCreate) check() error {
+	if _, ok := asc.mutation.CreatedAt(); !ok {
+		return &ValidationError{Name: "created_at", err: errors.New(`db: missing required field "AchievementsSnapshot.created_at"`)}
+	}
+	if _, ok := asc.mutation.UpdatedAt(); !ok {
+		return &ValidationError{Name: "updated_at", err: errors.New(`db: missing required field "AchievementsSnapshot.updated_at"`)}
+	}
+	if _, ok := asc.mutation.GetType(); !ok {
+		return &ValidationError{Name: "type", err: errors.New(`db: missing required field "AchievementsSnapshot.type"`)}
+	}
+	if v, ok := asc.mutation.GetType(); ok {
+		if err := achievementssnapshot.TypeValidator(v); err != nil {
+			return &ValidationError{Name: "type", err: fmt.Errorf(`db: validator failed for field "AchievementsSnapshot.type": %w`, err)}
+		}
+	}
+	if _, ok := asc.mutation.AccountID(); !ok {
+		return &ValidationError{Name: "account_id", err: errors.New(`db: missing required field "AchievementsSnapshot.account_id"`)}
+	}
+	if v, ok := asc.mutation.AccountID(); ok {
+		if err := achievementssnapshot.AccountIDValidator(v); err != nil {
+			return &ValidationError{Name: "account_id", err: fmt.Errorf(`db: validator failed for field "AchievementsSnapshot.account_id": %w`, err)}
+		}
+	}
+	if _, ok := asc.mutation.ReferenceID(); !ok {
+		return &ValidationError{Name: "reference_id", err: errors.New(`db: missing required field "AchievementsSnapshot.reference_id"`)}
+	}
+	if v, ok := asc.mutation.ReferenceID(); ok {
+		if err := achievementssnapshot.ReferenceIDValidator(v); err != nil {
+			return &ValidationError{Name: "reference_id", err: fmt.Errorf(`db: validator failed for field "AchievementsSnapshot.reference_id": %w`, err)}
+		}
+	}
+	if _, ok := asc.mutation.Battles(); !ok {
+		return &ValidationError{Name: "battles", err: errors.New(`db: missing required field "AchievementsSnapshot.battles"`)}
+	}
+	if _, ok := asc.mutation.LastBattleTime(); !ok {
+		return &ValidationError{Name: "last_battle_time", err: errors.New(`db: missing required field "AchievementsSnapshot.last_battle_time"`)}
+	}
+	if _, ok := asc.mutation.Data(); !ok {
+		return &ValidationError{Name: "data", err: errors.New(`db: missing required field "AchievementsSnapshot.data"`)}
+	}
+	if _, ok := asc.mutation.AccountID(); !ok {
+		return &ValidationError{Name: "account", err: errors.New(`db: missing required edge "AchievementsSnapshot.account"`)}
+	}
+	return nil
+}
+
+func (asc *AchievementsSnapshotCreate) sqlSave(ctx context.Context) (*AchievementsSnapshot, error) {
+	if err := asc.check(); err != nil {
+		return nil, err
+	}
+	_node, _spec := asc.createSpec()
+	if err := sqlgraph.CreateNode(ctx, asc.driver, _spec); err != nil {
+		if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	if _spec.ID.Value != nil {
+		if id, ok := _spec.ID.Value.(string); ok {
+			_node.ID = id
+		} else {
+			return nil, fmt.Errorf("unexpected AchievementsSnapshot.ID type: %T", _spec.ID.Value)
+		}
+	}
+	asc.mutation.id = &_node.ID
+	asc.mutation.done = true
+	return _node, nil
+}
+
+func (asc *AchievementsSnapshotCreate) createSpec() (*AchievementsSnapshot, *sqlgraph.CreateSpec) {
+	var (
+		_node = &AchievementsSnapshot{config: asc.config}
+		_spec = sqlgraph.NewCreateSpec(achievementssnapshot.Table, sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString))
+	)
+	if id, ok := asc.mutation.ID(); ok {
+		_node.ID = id
+		_spec.ID.Value = id
+	}
+	if value, ok := asc.mutation.CreatedAt(); ok {
+		_spec.SetField(achievementssnapshot.FieldCreatedAt, field.TypeInt, value)
+		_node.CreatedAt = value
+	}
+	if value, ok := asc.mutation.UpdatedAt(); ok {
+		_spec.SetField(achievementssnapshot.FieldUpdatedAt, field.TypeInt, value)
+		_node.UpdatedAt = value
+	}
+	if value, ok := asc.mutation.GetType(); ok {
+		_spec.SetField(achievementssnapshot.FieldType, field.TypeEnum, value)
+		_node.Type = value
+	}
+	if value, ok := asc.mutation.ReferenceID(); ok {
+		_spec.SetField(achievementssnapshot.FieldReferenceID, field.TypeString, value)
+		_node.ReferenceID = value
+	}
+	if value, ok := asc.mutation.Battles(); ok {
+		_spec.SetField(achievementssnapshot.FieldBattles, field.TypeInt, value)
+		_node.Battles = value
+	}
+	if value, ok := asc.mutation.LastBattleTime(); ok {
+		_spec.SetField(achievementssnapshot.FieldLastBattleTime, field.TypeInt, value)
+		_node.LastBattleTime = value
+	}
+	if value, ok := asc.mutation.Data(); ok {
+		_spec.SetField(achievementssnapshot.FieldData, field.TypeJSON, value)
+		_node.Data = value
+	}
+	if nodes := asc.mutation.AccountIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   achievementssnapshot.AccountTable,
+			Columns: []string{achievementssnapshot.AccountColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(account.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_node.AccountID = nodes[0]
+		_spec.Edges = append(_spec.Edges, edge)
+	}
+	return _node, _spec
+}
+
+// AchievementsSnapshotCreateBulk is the builder for creating many AchievementsSnapshot entities in bulk.
+type AchievementsSnapshotCreateBulk struct {
+	config
+	err      error
+	builders []*AchievementsSnapshotCreate
+}
+
+// Save creates the AchievementsSnapshot entities in the database.
+func (ascb *AchievementsSnapshotCreateBulk) Save(ctx context.Context) ([]*AchievementsSnapshot, error) {
+	if ascb.err != nil {
+		return nil, ascb.err
+	}
+	specs := make([]*sqlgraph.CreateSpec, len(ascb.builders))
+	nodes := make([]*AchievementsSnapshot, len(ascb.builders))
+	mutators := make([]Mutator, len(ascb.builders))
+	for i := range ascb.builders {
+		func(i int, root context.Context) {
+			builder := ascb.builders[i]
+			builder.defaults()
+			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+				mutation, ok := m.(*AchievementsSnapshotMutation)
+				if !ok {
+					return nil, fmt.Errorf("unexpected mutation type %T", m)
+				}
+				if err := builder.check(); err != nil {
+					return nil, err
+				}
+				builder.mutation = mutation
+				var err error
+				nodes[i], specs[i] = builder.createSpec()
+				if i < len(mutators)-1 {
+					_, err = mutators[i+1].Mutate(root, ascb.builders[i+1].mutation)
+				} else {
+					spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
+					// Invoke the actual operation on the latest mutation in the chain.
+					if err = sqlgraph.BatchCreate(ctx, ascb.driver, spec); err != nil {
+						if sqlgraph.IsConstraintError(err) {
+							err = &ConstraintError{msg: err.Error(), wrap: err}
+						}
+					}
+				}
+				if err != nil {
+					return nil, err
+				}
+				mutation.id = &nodes[i].ID
+				mutation.done = true
+				return nodes[i], nil
+			})
+			for i := len(builder.hooks) - 1; i >= 0; i-- {
+				mut = builder.hooks[i](mut)
+			}
+			mutators[i] = mut
+		}(i, ctx)
+	}
+	if len(mutators) > 0 {
+		if _, err := mutators[0].Mutate(ctx, ascb.builders[0].mutation); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (ascb *AchievementsSnapshotCreateBulk) SaveX(ctx context.Context) []*AchievementsSnapshot {
+	v, err := ascb.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (ascb *AchievementsSnapshotCreateBulk) Exec(ctx context.Context) error {
+	_, err := ascb.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (ascb *AchievementsSnapshotCreateBulk) ExecX(ctx context.Context) {
+	if err := ascb.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/database/ent/db/achievementssnapshot_delete.go b/internal/database/ent/db/achievementssnapshot_delete.go
new file mode 100644
index 00000000..e79eb3c4
--- /dev/null
+++ b/internal/database/ent/db/achievementssnapshot_delete.go
@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/achievementssnapshot"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+)
+
+// AchievementsSnapshotDelete is the builder for deleting a AchievementsSnapshot entity.
+type AchievementsSnapshotDelete struct {
+	config
+	hooks    []Hook
+	mutation *AchievementsSnapshotMutation
+}
+
+// Where appends a list predicates to the AchievementsSnapshotDelete builder.
+func (asd *AchievementsSnapshotDelete) Where(ps ...predicate.AchievementsSnapshot) *AchievementsSnapshotDelete {
+	asd.mutation.Where(ps...)
+	return asd
+}
+
+// Exec executes the deletion query and returns how many vertices were deleted.
+func (asd *AchievementsSnapshotDelete) Exec(ctx context.Context) (int, error) {
+	return withHooks(ctx, asd.sqlExec, asd.mutation, asd.hooks)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (asd *AchievementsSnapshotDelete) ExecX(ctx context.Context) int {
+	n, err := asd.Exec(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return n
+}
+
+func (asd *AchievementsSnapshotDelete) sqlExec(ctx context.Context) (int, error) {
+	_spec := sqlgraph.NewDeleteSpec(achievementssnapshot.Table, sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString))
+	if ps := asd.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	affected, err := sqlgraph.DeleteNodes(ctx, asd.driver, _spec)
+	if err != nil && sqlgraph.IsConstraintError(err) {
+		err = &ConstraintError{msg: err.Error(), wrap: err}
+	}
+	asd.mutation.done = true
+	return affected, err
+}
+
+// AchievementsSnapshotDeleteOne is the builder for deleting a single AchievementsSnapshot entity.
+type AchievementsSnapshotDeleteOne struct {
+	asd *AchievementsSnapshotDelete
+}
+
+// Where appends a list predicates to the AchievementsSnapshotDelete builder.
+func (asdo *AchievementsSnapshotDeleteOne) Where(ps ...predicate.AchievementsSnapshot) *AchievementsSnapshotDeleteOne {
+	asdo.asd.mutation.Where(ps...)
+	return asdo
+}
+
+// Exec executes the deletion query.
+func (asdo *AchievementsSnapshotDeleteOne) Exec(ctx context.Context) error {
+	n, err := asdo.asd.Exec(ctx)
+	switch {
+	case err != nil:
+		return err
+	case n == 0:
+		return &NotFoundError{achievementssnapshot.Label}
+	default:
+		return nil
+	}
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (asdo *AchievementsSnapshotDeleteOne) ExecX(ctx context.Context) {
+	if err := asdo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/database/ent/db/achievementssnapshot_query.go b/internal/database/ent/db/achievementssnapshot_query.go
new file mode 100644
index 00000000..fed3275c
--- /dev/null
+++ b/internal/database/ent/db/achievementssnapshot_query.go
@@ -0,0 +1,605 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"fmt"
+	"math"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/account"
+	"github.com/cufee/aftermath/internal/database/ent/db/achievementssnapshot"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+)
+
+// AchievementsSnapshotQuery is the builder for querying AchievementsSnapshot entities.
+type AchievementsSnapshotQuery struct {
+	config
+	ctx         *QueryContext
+	order       []achievementssnapshot.OrderOption
+	inters      []Interceptor
+	predicates  []predicate.AchievementsSnapshot
+	withAccount *AccountQuery
+	// intermediate query (i.e. traversal path).
+	sql  *sql.Selector
+	path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the AchievementsSnapshotQuery builder.
+func (asq *AchievementsSnapshotQuery) Where(ps ...predicate.AchievementsSnapshot) *AchievementsSnapshotQuery {
+	asq.predicates = append(asq.predicates, ps...)
+	return asq
+}
+
+// Limit the number of records to be returned by this query.
+func (asq *AchievementsSnapshotQuery) Limit(limit int) *AchievementsSnapshotQuery {
+	asq.ctx.Limit = &limit
+	return asq
+}
+
+// Offset to start from.
+func (asq *AchievementsSnapshotQuery) Offset(offset int) *AchievementsSnapshotQuery {
+	asq.ctx.Offset = &offset
+	return asq
+}
+
+// Unique configures the query builder to filter duplicate records on query.
+// By default, unique is set to true, and can be disabled using this method.
+func (asq *AchievementsSnapshotQuery) Unique(unique bool) *AchievementsSnapshotQuery {
+	asq.ctx.Unique = &unique
+	return asq
+}
+
+// Order specifies how the records should be ordered.
+func (asq *AchievementsSnapshotQuery) Order(o ...achievementssnapshot.OrderOption) *AchievementsSnapshotQuery {
+	asq.order = append(asq.order, o...)
+	return asq
+}
+
+// QueryAccount chains the current query on the "account" edge.
+func (asq *AchievementsSnapshotQuery) QueryAccount() *AccountQuery {
+	query := (&AccountClient{config: asq.config}).Query()
+	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+		if err := asq.prepareQuery(ctx); err != nil {
+			return nil, err
+		}
+		selector := asq.sqlQuery(ctx)
+		if err := selector.Err(); err != nil {
+			return nil, err
+		}
+		step := sqlgraph.NewStep(
+			sqlgraph.From(achievementssnapshot.Table, achievementssnapshot.FieldID, selector),
+			sqlgraph.To(account.Table, account.FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, achievementssnapshot.AccountTable, achievementssnapshot.AccountColumn),
+		)
+		fromU = sqlgraph.SetNeighbors(asq.driver.Dialect(), step)
+		return fromU, nil
+	}
+	return query
+}
+
+// First returns the first AchievementsSnapshot entity from the query.
+// Returns a *NotFoundError when no AchievementsSnapshot was found.
+func (asq *AchievementsSnapshotQuery) First(ctx context.Context) (*AchievementsSnapshot, error) {
+	nodes, err := asq.Limit(1).All(setContextOp(ctx, asq.ctx, "First"))
+	if err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nil, &NotFoundError{achievementssnapshot.Label}
+	}
+	return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (asq *AchievementsSnapshotQuery) FirstX(ctx context.Context) *AchievementsSnapshot {
+	node, err := asq.First(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return node
+}
+
+// FirstID returns the first AchievementsSnapshot ID from the query.
+// Returns a *NotFoundError when no AchievementsSnapshot ID was found.
+func (asq *AchievementsSnapshotQuery) FirstID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = asq.Limit(1).IDs(setContextOp(ctx, asq.ctx, "FirstID")); err != nil {
+		return
+	}
+	if len(ids) == 0 {
+		err = &NotFoundError{achievementssnapshot.Label}
+		return
+	}
+	return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (asq *AchievementsSnapshotQuery) FirstIDX(ctx context.Context) string {
+	id, err := asq.FirstID(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return id
+}
+
+// Only returns a single AchievementsSnapshot entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one AchievementsSnapshot entity is found.
+// Returns a *NotFoundError when no AchievementsSnapshot entities are found.
+func (asq *AchievementsSnapshotQuery) Only(ctx context.Context) (*AchievementsSnapshot, error) {
+	nodes, err := asq.Limit(2).All(setContextOp(ctx, asq.ctx, "Only"))
+	if err != nil {
+		return nil, err
+	}
+	switch len(nodes) {
+	case 1:
+		return nodes[0], nil
+	case 0:
+		return nil, &NotFoundError{achievementssnapshot.Label}
+	default:
+		return nil, &NotSingularError{achievementssnapshot.Label}
+	}
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (asq *AchievementsSnapshotQuery) OnlyX(ctx context.Context) *AchievementsSnapshot {
+	node, err := asq.Only(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// OnlyID is like Only, but returns the only AchievementsSnapshot ID in the query.
+// Returns a *NotSingularError when more than one AchievementsSnapshot ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (asq *AchievementsSnapshotQuery) OnlyID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = asq.Limit(2).IDs(setContextOp(ctx, asq.ctx, "OnlyID")); err != nil {
+		return
+	}
+	switch len(ids) {
+	case 1:
+		id = ids[0]
+	case 0:
+		err = &NotFoundError{achievementssnapshot.Label}
+	default:
+		err = &NotSingularError{achievementssnapshot.Label}
+	}
+	return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (asq *AchievementsSnapshotQuery) OnlyIDX(ctx context.Context) string {
+	id, err := asq.OnlyID(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return id
+}
+
+// All executes the query and returns a list of AchievementsSnapshots.
+func (asq *AchievementsSnapshotQuery) All(ctx context.Context) ([]*AchievementsSnapshot, error) {
+	ctx = setContextOp(ctx, asq.ctx, "All")
+	if err := asq.prepareQuery(ctx); err != nil {
+		return nil, err
+	}
+	qr := querierAll[[]*AchievementsSnapshot, *AchievementsSnapshotQuery]()
+	return withInterceptors[[]*AchievementsSnapshot](ctx, asq, qr, asq.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (asq *AchievementsSnapshotQuery) AllX(ctx context.Context) []*AchievementsSnapshot {
+	nodes, err := asq.All(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return nodes
+}
+
+// IDs executes the query and returns a list of AchievementsSnapshot IDs.
+func (asq *AchievementsSnapshotQuery) IDs(ctx context.Context) (ids []string, err error) {
+	if asq.ctx.Unique == nil && asq.path != nil {
+		asq.Unique(true)
+	}
+	ctx = setContextOp(ctx, asq.ctx, "IDs")
+	if err = asq.Select(achievementssnapshot.FieldID).Scan(ctx, &ids); err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (asq *AchievementsSnapshotQuery) IDsX(ctx context.Context) []string {
+	ids, err := asq.IDs(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return ids
+}
+
+// Count returns the count of the given query.
+func (asq *AchievementsSnapshotQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, asq.ctx, "Count")
+	if err := asq.prepareQuery(ctx); err != nil {
+		return 0, err
+	}
+	return withInterceptors[int](ctx, asq, querierCount[*AchievementsSnapshotQuery](), asq.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (asq *AchievementsSnapshotQuery) CountX(ctx context.Context) int {
+	count, err := asq.Count(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (asq *AchievementsSnapshotQuery) Exist(ctx context.Context) (bool, error) {
+	ctx = setContextOp(ctx, asq.ctx, "Exist")
+	switch _, err := asq.FirstID(ctx); {
+	case IsNotFound(err):
+		return false, nil
+	case err != nil:
+		return false, fmt.Errorf("db: check existence: %w", err)
+	default:
+		return true, nil
+	}
+}
+
+// ExistX is like Exist, but panics if an error occurs.
+func (asq *AchievementsSnapshotQuery) ExistX(ctx context.Context) bool {
+	exist, err := asq.Exist(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return exist
+}
+
+// Clone returns a duplicate of the AchievementsSnapshotQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (asq *AchievementsSnapshotQuery) Clone() *AchievementsSnapshotQuery {
+	if asq == nil {
+		return nil
+	}
+	return &AchievementsSnapshotQuery{
+		config:      asq.config,
+		ctx:         asq.ctx.Clone(),
+		order:       append([]achievementssnapshot.OrderOption{}, asq.order...),
+		inters:      append([]Interceptor{}, asq.inters...),
+		predicates:  append([]predicate.AchievementsSnapshot{}, asq.predicates...),
+		withAccount: asq.withAccount.Clone(),
+		// clone intermediate query.
+		sql:  asq.sql.Clone(),
+		path: asq.path,
+	}
+}
+
+// WithAccount tells the query-builder to eager-load the nodes that are connected to
+// the "account" edge. The optional arguments are used to configure the query builder of the edge.
+func (asq *AchievementsSnapshotQuery) WithAccount(opts ...func(*AccountQuery)) *AchievementsSnapshotQuery {
+	query := (&AccountClient{config: asq.config}).Query()
+	for _, opt := range opts {
+		opt(query)
+	}
+	asq.withAccount = query
+	return asq
+}
+
+// GroupBy is used to group vertices by one or more fields/columns.
+// It is often used with aggregate functions, like: count, max, mean, min, sum.
+//
+// Example:
+//
+//	var v []struct {
+//		CreatedAt int `json:"created_at,omitempty"`
+//		Count int `json:"count,omitempty"`
+//	}
+//
+//	client.AchievementsSnapshot.Query().
+//		GroupBy(achievementssnapshot.FieldCreatedAt).
+//		Aggregate(db.Count()).
+//		Scan(ctx, &v)
+func (asq *AchievementsSnapshotQuery) GroupBy(field string, fields ...string) *AchievementsSnapshotGroupBy {
+	asq.ctx.Fields = append([]string{field}, fields...)
+	grbuild := &AchievementsSnapshotGroupBy{build: asq}
+	grbuild.flds = &asq.ctx.Fields
+	grbuild.label = achievementssnapshot.Label
+	grbuild.scan = grbuild.Scan
+	return grbuild
+}
+
+// Select allows the selection one or more fields/columns for the given query,
+// instead of selecting all fields in the entity.
+//
+// Example:
+//
+//	var v []struct {
+//		CreatedAt int `json:"created_at,omitempty"`
+//	}
+//
+//	client.AchievementsSnapshot.Query().
+//		Select(achievementssnapshot.FieldCreatedAt).
+//		Scan(ctx, &v)
+func (asq *AchievementsSnapshotQuery) Select(fields ...string) *AchievementsSnapshotSelect {
+	asq.ctx.Fields = append(asq.ctx.Fields, fields...)
+	sbuild := &AchievementsSnapshotSelect{AchievementsSnapshotQuery: asq}
+	sbuild.label = achievementssnapshot.Label
+	sbuild.flds, sbuild.scan = &asq.ctx.Fields, sbuild.Scan
+	return sbuild
+}
+
+// Aggregate returns a AchievementsSnapshotSelect configured with the given aggregations.
+func (asq *AchievementsSnapshotQuery) Aggregate(fns ...AggregateFunc) *AchievementsSnapshotSelect {
+	return asq.Select().Aggregate(fns...)
+}
+
+func (asq *AchievementsSnapshotQuery) prepareQuery(ctx context.Context) error {
+	for _, inter := range asq.inters {
+		if inter == nil {
+			return fmt.Errorf("db: uninitialized interceptor (forgotten import db/runtime?)")
+		}
+		if trv, ok := inter.(Traverser); ok {
+			if err := trv.Traverse(ctx, asq); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range asq.ctx.Fields {
+		if !achievementssnapshot.ValidColumn(f) {
+			return &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+		}
+	}
+	if asq.path != nil {
+		prev, err := asq.path(ctx)
+		if err != nil {
+			return err
+		}
+		asq.sql = prev
+	}
+	return nil
+}
+
+func (asq *AchievementsSnapshotQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*AchievementsSnapshot, error) {
+	var (
+		nodes       = []*AchievementsSnapshot{}
+		_spec       = asq.querySpec()
+		loadedTypes = [1]bool{
+			asq.withAccount != nil,
+		}
+	)
+	_spec.ScanValues = func(columns []string) ([]any, error) {
+		return (*AchievementsSnapshot).scanValues(nil, columns)
+	}
+	_spec.Assign = func(columns []string, values []any) error {
+		node := &AchievementsSnapshot{config: asq.config}
+		nodes = append(nodes, node)
+		node.Edges.loadedTypes = loadedTypes
+		return node.assignValues(columns, values)
+	}
+	for i := range hooks {
+		hooks[i](ctx, _spec)
+	}
+	if err := sqlgraph.QueryNodes(ctx, asq.driver, _spec); err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nodes, nil
+	}
+	if query := asq.withAccount; query != nil {
+		if err := asq.loadAccount(ctx, query, nodes, nil,
+			func(n *AchievementsSnapshot, e *Account) { n.Edges.Account = e }); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+func (asq *AchievementsSnapshotQuery) loadAccount(ctx context.Context, query *AccountQuery, nodes []*AchievementsSnapshot, init func(*AchievementsSnapshot), assign func(*AchievementsSnapshot, *Account)) error {
+	ids := make([]string, 0, len(nodes))
+	nodeids := make(map[string][]*AchievementsSnapshot)
+	for i := range nodes {
+		fk := nodes[i].AccountID
+		if _, ok := nodeids[fk]; !ok {
+			ids = append(ids, fk)
+		}
+		nodeids[fk] = append(nodeids[fk], nodes[i])
+	}
+	if len(ids) == 0 {
+		return nil
+	}
+	query.Where(account.IDIn(ids...))
+	neighbors, err := query.All(ctx)
+	if err != nil {
+		return err
+	}
+	for _, n := range neighbors {
+		nodes, ok := nodeids[n.ID]
+		if !ok {
+			return fmt.Errorf(`unexpected foreign-key "account_id" returned %v`, n.ID)
+		}
+		for i := range nodes {
+			assign(nodes[i], n)
+		}
+	}
+	return nil
+}
+
+func (asq *AchievementsSnapshotQuery) sqlCount(ctx context.Context) (int, error) {
+	_spec := asq.querySpec()
+	_spec.Node.Columns = asq.ctx.Fields
+	if len(asq.ctx.Fields) > 0 {
+		_spec.Unique = asq.ctx.Unique != nil && *asq.ctx.Unique
+	}
+	return sqlgraph.CountNodes(ctx, asq.driver, _spec)
+}
+
+func (asq *AchievementsSnapshotQuery) querySpec() *sqlgraph.QuerySpec {
+	_spec := sqlgraph.NewQuerySpec(achievementssnapshot.Table, achievementssnapshot.Columns, sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString))
+	_spec.From = asq.sql
+	if unique := asq.ctx.Unique; unique != nil {
+		_spec.Unique = *unique
+	} else if asq.path != nil {
+		_spec.Unique = true
+	}
+	if fields := asq.ctx.Fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, achievementssnapshot.FieldID)
+		for i := range fields {
+			if fields[i] != achievementssnapshot.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+			}
+		}
+		if asq.withAccount != nil {
+			_spec.Node.AddColumnOnce(achievementssnapshot.FieldAccountID)
+		}
+	}
+	if ps := asq.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if limit := asq.ctx.Limit; limit != nil {
+		_spec.Limit = *limit
+	}
+	if offset := asq.ctx.Offset; offset != nil {
+		_spec.Offset = *offset
+	}
+	if ps := asq.order; len(ps) > 0 {
+		_spec.Order = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	return _spec
+}
+
+func (asq *AchievementsSnapshotQuery) sqlQuery(ctx context.Context) *sql.Selector {
+	builder := sql.Dialect(asq.driver.Dialect())
+	t1 := builder.Table(achievementssnapshot.Table)
+	columns := asq.ctx.Fields
+	if len(columns) == 0 {
+		columns = achievementssnapshot.Columns
+	}
+	selector := builder.Select(t1.Columns(columns...)...).From(t1)
+	if asq.sql != nil {
+		selector = asq.sql
+		selector.Select(selector.Columns(columns...)...)
+	}
+	if asq.ctx.Unique != nil && *asq.ctx.Unique {
+		selector.Distinct()
+	}
+	for _, p := range asq.predicates {
+		p(selector)
+	}
+	for _, p := range asq.order {
+		p(selector)
+	}
+	if offset := asq.ctx.Offset; offset != nil {
+		// limit is mandatory for offset clause. We start
+		// with default value, and override it below if needed.
+		selector.Offset(*offset).Limit(math.MaxInt32)
+	}
+	if limit := asq.ctx.Limit; limit != nil {
+		selector.Limit(*limit)
+	}
+	return selector
+}
+
+// AchievementsSnapshotGroupBy is the group-by builder for AchievementsSnapshot entities.
+type AchievementsSnapshotGroupBy struct {
+	selector
+	build *AchievementsSnapshotQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (asgb *AchievementsSnapshotGroupBy) Aggregate(fns ...AggregateFunc) *AchievementsSnapshotGroupBy {
+	asgb.fns = append(asgb.fns, fns...)
+	return asgb
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (asgb *AchievementsSnapshotGroupBy) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, asgb.build.ctx, "GroupBy")
+	if err := asgb.build.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*AchievementsSnapshotQuery, *AchievementsSnapshotGroupBy](ctx, asgb.build, asgb, asgb.build.inters, v)
+}
+
+func (asgb *AchievementsSnapshotGroupBy) sqlScan(ctx context.Context, root *AchievementsSnapshotQuery, v any) error {
+	selector := root.sqlQuery(ctx).Select()
+	aggregation := make([]string, 0, len(asgb.fns))
+	for _, fn := range asgb.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*asgb.flds)+len(asgb.fns))
+		for _, f := range *asgb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*asgb.flds...)...)
+	if err := selector.Err(); err != nil {
+		return err
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := asgb.build.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
+
+// AchievementsSnapshotSelect is the builder for selecting fields of AchievementsSnapshot entities.
+type AchievementsSnapshotSelect struct {
+	*AchievementsSnapshotQuery
+	selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (ass *AchievementsSnapshotSelect) Aggregate(fns ...AggregateFunc) *AchievementsSnapshotSelect {
+	ass.fns = append(ass.fns, fns...)
+	return ass
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (ass *AchievementsSnapshotSelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, ass.ctx, "Select")
+	if err := ass.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*AchievementsSnapshotQuery, *AchievementsSnapshotSelect](ctx, ass.AchievementsSnapshotQuery, ass, ass.inters, v)
+}
+
+func (ass *AchievementsSnapshotSelect) sqlScan(ctx context.Context, root *AchievementsSnapshotQuery, v any) error {
+	selector := root.sqlQuery(ctx)
+	aggregation := make([]string, 0, len(ass.fns))
+	for _, fn := range ass.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	switch n := len(*ass.selector.flds); {
+	case n == 0 && len(aggregation) > 0:
+		selector.Select(aggregation...)
+	case n != 0 && len(aggregation) > 0:
+		selector.AppendSelect(aggregation...)
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := ass.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
diff --git a/internal/database/ent/db/achievementssnapshot_update.go b/internal/database/ent/db/achievementssnapshot_update.go
new file mode 100644
index 00000000..10f05608
--- /dev/null
+++ b/internal/database/ent/db/achievementssnapshot_update.go
@@ -0,0 +1,485 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/achievementssnapshot"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/am-wg-proxy-next/v2/types"
+)
+
+// AchievementsSnapshotUpdate is the builder for updating AchievementsSnapshot entities.
+type AchievementsSnapshotUpdate struct {
+	config
+	hooks    []Hook
+	mutation *AchievementsSnapshotMutation
+}
+
+// Where appends a list predicates to the AchievementsSnapshotUpdate builder.
+func (asu *AchievementsSnapshotUpdate) Where(ps ...predicate.AchievementsSnapshot) *AchievementsSnapshotUpdate {
+	asu.mutation.Where(ps...)
+	return asu
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (asu *AchievementsSnapshotUpdate) SetUpdatedAt(i int) *AchievementsSnapshotUpdate {
+	asu.mutation.ResetUpdatedAt()
+	asu.mutation.SetUpdatedAt(i)
+	return asu
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (asu *AchievementsSnapshotUpdate) AddUpdatedAt(i int) *AchievementsSnapshotUpdate {
+	asu.mutation.AddUpdatedAt(i)
+	return asu
+}
+
+// SetType sets the "type" field.
+func (asu *AchievementsSnapshotUpdate) SetType(mt models.SnapshotType) *AchievementsSnapshotUpdate {
+	asu.mutation.SetType(mt)
+	return asu
+}
+
+// SetNillableType sets the "type" field if the given value is not nil.
+func (asu *AchievementsSnapshotUpdate) SetNillableType(mt *models.SnapshotType) *AchievementsSnapshotUpdate {
+	if mt != nil {
+		asu.SetType(*mt)
+	}
+	return asu
+}
+
+// SetReferenceID sets the "reference_id" field.
+func (asu *AchievementsSnapshotUpdate) SetReferenceID(s string) *AchievementsSnapshotUpdate {
+	asu.mutation.SetReferenceID(s)
+	return asu
+}
+
+// SetNillableReferenceID sets the "reference_id" field if the given value is not nil.
+func (asu *AchievementsSnapshotUpdate) SetNillableReferenceID(s *string) *AchievementsSnapshotUpdate {
+	if s != nil {
+		asu.SetReferenceID(*s)
+	}
+	return asu
+}
+
+// SetBattles sets the "battles" field.
+func (asu *AchievementsSnapshotUpdate) SetBattles(i int) *AchievementsSnapshotUpdate {
+	asu.mutation.ResetBattles()
+	asu.mutation.SetBattles(i)
+	return asu
+}
+
+// SetNillableBattles sets the "battles" field if the given value is not nil.
+func (asu *AchievementsSnapshotUpdate) SetNillableBattles(i *int) *AchievementsSnapshotUpdate {
+	if i != nil {
+		asu.SetBattles(*i)
+	}
+	return asu
+}
+
+// AddBattles adds i to the "battles" field.
+func (asu *AchievementsSnapshotUpdate) AddBattles(i int) *AchievementsSnapshotUpdate {
+	asu.mutation.AddBattles(i)
+	return asu
+}
+
+// SetLastBattleTime sets the "last_battle_time" field.
+func (asu *AchievementsSnapshotUpdate) SetLastBattleTime(i int) *AchievementsSnapshotUpdate {
+	asu.mutation.ResetLastBattleTime()
+	asu.mutation.SetLastBattleTime(i)
+	return asu
+}
+
+// SetNillableLastBattleTime sets the "last_battle_time" field if the given value is not nil.
+func (asu *AchievementsSnapshotUpdate) SetNillableLastBattleTime(i *int) *AchievementsSnapshotUpdate {
+	if i != nil {
+		asu.SetLastBattleTime(*i)
+	}
+	return asu
+}
+
+// AddLastBattleTime adds i to the "last_battle_time" field.
+func (asu *AchievementsSnapshotUpdate) AddLastBattleTime(i int) *AchievementsSnapshotUpdate {
+	asu.mutation.AddLastBattleTime(i)
+	return asu
+}
+
+// SetData sets the "data" field.
+func (asu *AchievementsSnapshotUpdate) SetData(tf types.AchievementsFrame) *AchievementsSnapshotUpdate {
+	asu.mutation.SetData(tf)
+	return asu
+}
+
+// SetNillableData sets the "data" field if the given value is not nil.
+func (asu *AchievementsSnapshotUpdate) SetNillableData(tf *types.AchievementsFrame) *AchievementsSnapshotUpdate {
+	if tf != nil {
+		asu.SetData(*tf)
+	}
+	return asu
+}
+
+// Mutation returns the AchievementsSnapshotMutation object of the builder.
+func (asu *AchievementsSnapshotUpdate) Mutation() *AchievementsSnapshotMutation {
+	return asu.mutation
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (asu *AchievementsSnapshotUpdate) Save(ctx context.Context) (int, error) {
+	asu.defaults()
+	return withHooks(ctx, asu.sqlSave, asu.mutation, asu.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (asu *AchievementsSnapshotUpdate) SaveX(ctx context.Context) int {
+	affected, err := asu.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return affected
+}
+
+// Exec executes the query.
+func (asu *AchievementsSnapshotUpdate) Exec(ctx context.Context) error {
+	_, err := asu.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (asu *AchievementsSnapshotUpdate) ExecX(ctx context.Context) {
+	if err := asu.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (asu *AchievementsSnapshotUpdate) defaults() {
+	if _, ok := asu.mutation.UpdatedAt(); !ok {
+		v := achievementssnapshot.UpdateDefaultUpdatedAt()
+		asu.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (asu *AchievementsSnapshotUpdate) check() error {
+	if v, ok := asu.mutation.GetType(); ok {
+		if err := achievementssnapshot.TypeValidator(v); err != nil {
+			return &ValidationError{Name: "type", err: fmt.Errorf(`db: validator failed for field "AchievementsSnapshot.type": %w`, err)}
+		}
+	}
+	if v, ok := asu.mutation.ReferenceID(); ok {
+		if err := achievementssnapshot.ReferenceIDValidator(v); err != nil {
+			return &ValidationError{Name: "reference_id", err: fmt.Errorf(`db: validator failed for field "AchievementsSnapshot.reference_id": %w`, err)}
+		}
+	}
+	if _, ok := asu.mutation.AccountID(); asu.mutation.AccountCleared() && !ok {
+		return errors.New(`db: clearing a required unique edge "AchievementsSnapshot.account"`)
+	}
+	return nil
+}
+
+func (asu *AchievementsSnapshotUpdate) sqlSave(ctx context.Context) (n int, err error) {
+	if err := asu.check(); err != nil {
+		return n, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(achievementssnapshot.Table, achievementssnapshot.Columns, sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString))
+	if ps := asu.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := asu.mutation.UpdatedAt(); ok {
+		_spec.SetField(achievementssnapshot.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := asu.mutation.AddedUpdatedAt(); ok {
+		_spec.AddField(achievementssnapshot.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := asu.mutation.GetType(); ok {
+		_spec.SetField(achievementssnapshot.FieldType, field.TypeEnum, value)
+	}
+	if value, ok := asu.mutation.ReferenceID(); ok {
+		_spec.SetField(achievementssnapshot.FieldReferenceID, field.TypeString, value)
+	}
+	if value, ok := asu.mutation.Battles(); ok {
+		_spec.SetField(achievementssnapshot.FieldBattles, field.TypeInt, value)
+	}
+	if value, ok := asu.mutation.AddedBattles(); ok {
+		_spec.AddField(achievementssnapshot.FieldBattles, field.TypeInt, value)
+	}
+	if value, ok := asu.mutation.LastBattleTime(); ok {
+		_spec.SetField(achievementssnapshot.FieldLastBattleTime, field.TypeInt, value)
+	}
+	if value, ok := asu.mutation.AddedLastBattleTime(); ok {
+		_spec.AddField(achievementssnapshot.FieldLastBattleTime, field.TypeInt, value)
+	}
+	if value, ok := asu.mutation.Data(); ok {
+		_spec.SetField(achievementssnapshot.FieldData, field.TypeJSON, value)
+	}
+	if n, err = sqlgraph.UpdateNodes(ctx, asu.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{achievementssnapshot.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return 0, err
+	}
+	asu.mutation.done = true
+	return n, nil
+}
+
+// AchievementsSnapshotUpdateOne is the builder for updating a single AchievementsSnapshot entity.
+type AchievementsSnapshotUpdateOne struct {
+	config
+	fields   []string
+	hooks    []Hook
+	mutation *AchievementsSnapshotMutation
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (asuo *AchievementsSnapshotUpdateOne) SetUpdatedAt(i int) *AchievementsSnapshotUpdateOne {
+	asuo.mutation.ResetUpdatedAt()
+	asuo.mutation.SetUpdatedAt(i)
+	return asuo
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (asuo *AchievementsSnapshotUpdateOne) AddUpdatedAt(i int) *AchievementsSnapshotUpdateOne {
+	asuo.mutation.AddUpdatedAt(i)
+	return asuo
+}
+
+// SetType sets the "type" field.
+func (asuo *AchievementsSnapshotUpdateOne) SetType(mt models.SnapshotType) *AchievementsSnapshotUpdateOne {
+	asuo.mutation.SetType(mt)
+	return asuo
+}
+
+// SetNillableType sets the "type" field if the given value is not nil.
+func (asuo *AchievementsSnapshotUpdateOne) SetNillableType(mt *models.SnapshotType) *AchievementsSnapshotUpdateOne {
+	if mt != nil {
+		asuo.SetType(*mt)
+	}
+	return asuo
+}
+
+// SetReferenceID sets the "reference_id" field.
+func (asuo *AchievementsSnapshotUpdateOne) SetReferenceID(s string) *AchievementsSnapshotUpdateOne {
+	asuo.mutation.SetReferenceID(s)
+	return asuo
+}
+
+// SetNillableReferenceID sets the "reference_id" field if the given value is not nil.
+func (asuo *AchievementsSnapshotUpdateOne) SetNillableReferenceID(s *string) *AchievementsSnapshotUpdateOne {
+	if s != nil {
+		asuo.SetReferenceID(*s)
+	}
+	return asuo
+}
+
+// SetBattles sets the "battles" field.
+func (asuo *AchievementsSnapshotUpdateOne) SetBattles(i int) *AchievementsSnapshotUpdateOne {
+	asuo.mutation.ResetBattles()
+	asuo.mutation.SetBattles(i)
+	return asuo
+}
+
+// SetNillableBattles sets the "battles" field if the given value is not nil.
+func (asuo *AchievementsSnapshotUpdateOne) SetNillableBattles(i *int) *AchievementsSnapshotUpdateOne {
+	if i != nil {
+		asuo.SetBattles(*i)
+	}
+	return asuo
+}
+
+// AddBattles adds i to the "battles" field.
+func (asuo *AchievementsSnapshotUpdateOne) AddBattles(i int) *AchievementsSnapshotUpdateOne {
+	asuo.mutation.AddBattles(i)
+	return asuo
+}
+
+// SetLastBattleTime sets the "last_battle_time" field.
+func (asuo *AchievementsSnapshotUpdateOne) SetLastBattleTime(i int) *AchievementsSnapshotUpdateOne {
+	asuo.mutation.ResetLastBattleTime()
+	asuo.mutation.SetLastBattleTime(i)
+	return asuo
+}
+
+// SetNillableLastBattleTime sets the "last_battle_time" field if the given value is not nil.
+func (asuo *AchievementsSnapshotUpdateOne) SetNillableLastBattleTime(i *int) *AchievementsSnapshotUpdateOne {
+	if i != nil {
+		asuo.SetLastBattleTime(*i)
+	}
+	return asuo
+}
+
+// AddLastBattleTime adds i to the "last_battle_time" field.
+func (asuo *AchievementsSnapshotUpdateOne) AddLastBattleTime(i int) *AchievementsSnapshotUpdateOne {
+	asuo.mutation.AddLastBattleTime(i)
+	return asuo
+}
+
+// SetData sets the "data" field.
+func (asuo *AchievementsSnapshotUpdateOne) SetData(tf types.AchievementsFrame) *AchievementsSnapshotUpdateOne {
+	asuo.mutation.SetData(tf)
+	return asuo
+}
+
+// SetNillableData sets the "data" field if the given value is not nil.
+func (asuo *AchievementsSnapshotUpdateOne) SetNillableData(tf *types.AchievementsFrame) *AchievementsSnapshotUpdateOne {
+	if tf != nil {
+		asuo.SetData(*tf)
+	}
+	return asuo
+}
+
+// Mutation returns the AchievementsSnapshotMutation object of the builder.
+func (asuo *AchievementsSnapshotUpdateOne) Mutation() *AchievementsSnapshotMutation {
+	return asuo.mutation
+}
+
+// Where appends a list predicates to the AchievementsSnapshotUpdate builder.
+func (asuo *AchievementsSnapshotUpdateOne) Where(ps ...predicate.AchievementsSnapshot) *AchievementsSnapshotUpdateOne {
+	asuo.mutation.Where(ps...)
+	return asuo
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (asuo *AchievementsSnapshotUpdateOne) Select(field string, fields ...string) *AchievementsSnapshotUpdateOne {
+	asuo.fields = append([]string{field}, fields...)
+	return asuo
+}
+
+// Save executes the query and returns the updated AchievementsSnapshot entity.
+func (asuo *AchievementsSnapshotUpdateOne) Save(ctx context.Context) (*AchievementsSnapshot, error) {
+	asuo.defaults()
+	return withHooks(ctx, asuo.sqlSave, asuo.mutation, asuo.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (asuo *AchievementsSnapshotUpdateOne) SaveX(ctx context.Context) *AchievementsSnapshot {
+	node, err := asuo.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// Exec executes the query on the entity.
+func (asuo *AchievementsSnapshotUpdateOne) Exec(ctx context.Context) error {
+	_, err := asuo.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (asuo *AchievementsSnapshotUpdateOne) ExecX(ctx context.Context) {
+	if err := asuo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (asuo *AchievementsSnapshotUpdateOne) defaults() {
+	if _, ok := asuo.mutation.UpdatedAt(); !ok {
+		v := achievementssnapshot.UpdateDefaultUpdatedAt()
+		asuo.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (asuo *AchievementsSnapshotUpdateOne) check() error {
+	if v, ok := asuo.mutation.GetType(); ok {
+		if err := achievementssnapshot.TypeValidator(v); err != nil {
+			return &ValidationError{Name: "type", err: fmt.Errorf(`db: validator failed for field "AchievementsSnapshot.type": %w`, err)}
+		}
+	}
+	if v, ok := asuo.mutation.ReferenceID(); ok {
+		if err := achievementssnapshot.ReferenceIDValidator(v); err != nil {
+			return &ValidationError{Name: "reference_id", err: fmt.Errorf(`db: validator failed for field "AchievementsSnapshot.reference_id": %w`, err)}
+		}
+	}
+	if _, ok := asuo.mutation.AccountID(); asuo.mutation.AccountCleared() && !ok {
+		return errors.New(`db: clearing a required unique edge "AchievementsSnapshot.account"`)
+	}
+	return nil
+}
+
+func (asuo *AchievementsSnapshotUpdateOne) sqlSave(ctx context.Context) (_node *AchievementsSnapshot, err error) {
+	if err := asuo.check(); err != nil {
+		return _node, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(achievementssnapshot.Table, achievementssnapshot.Columns, sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString))
+	id, ok := asuo.mutation.ID()
+	if !ok {
+		return nil, &ValidationError{Name: "id", err: errors.New(`db: missing "AchievementsSnapshot.id" for update`)}
+	}
+	_spec.Node.ID.Value = id
+	if fields := asuo.fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, achievementssnapshot.FieldID)
+		for _, f := range fields {
+			if !achievementssnapshot.ValidColumn(f) {
+				return nil, &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+			}
+			if f != achievementssnapshot.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, f)
+			}
+		}
+	}
+	if ps := asuo.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := asuo.mutation.UpdatedAt(); ok {
+		_spec.SetField(achievementssnapshot.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := asuo.mutation.AddedUpdatedAt(); ok {
+		_spec.AddField(achievementssnapshot.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := asuo.mutation.GetType(); ok {
+		_spec.SetField(achievementssnapshot.FieldType, field.TypeEnum, value)
+	}
+	if value, ok := asuo.mutation.ReferenceID(); ok {
+		_spec.SetField(achievementssnapshot.FieldReferenceID, field.TypeString, value)
+	}
+	if value, ok := asuo.mutation.Battles(); ok {
+		_spec.SetField(achievementssnapshot.FieldBattles, field.TypeInt, value)
+	}
+	if value, ok := asuo.mutation.AddedBattles(); ok {
+		_spec.AddField(achievementssnapshot.FieldBattles, field.TypeInt, value)
+	}
+	if value, ok := asuo.mutation.LastBattleTime(); ok {
+		_spec.SetField(achievementssnapshot.FieldLastBattleTime, field.TypeInt, value)
+	}
+	if value, ok := asuo.mutation.AddedLastBattleTime(); ok {
+		_spec.AddField(achievementssnapshot.FieldLastBattleTime, field.TypeInt, value)
+	}
+	if value, ok := asuo.mutation.Data(); ok {
+		_spec.SetField(achievementssnapshot.FieldData, field.TypeJSON, value)
+	}
+	_node = &AchievementsSnapshot{config: asuo.config}
+	_spec.Assign = _node.assignValues
+	_spec.ScanValues = _node.scanValues
+	if err = sqlgraph.UpdateNode(ctx, asuo.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{achievementssnapshot.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	asuo.mutation.done = true
+	return _node, nil
+}
diff --git a/internal/database/ent/db/appconfiguration.go b/internal/database/ent/db/appconfiguration.go
new file mode 100644
index 00000000..8dbdef16
--- /dev/null
+++ b/internal/database/ent/db/appconfiguration.go
@@ -0,0 +1,154 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+	"github.com/cufee/aftermath/internal/database/ent/db/appconfiguration"
+)
+
+// AppConfiguration is the model entity for the AppConfiguration schema.
+type AppConfiguration struct {
+	config `json:"-"`
+	// ID of the ent.
+	ID string `json:"id,omitempty"`
+	// CreatedAt holds the value of the "created_at" field.
+	CreatedAt int `json:"created_at,omitempty"`
+	// UpdatedAt holds the value of the "updated_at" field.
+	UpdatedAt int `json:"updated_at,omitempty"`
+	// Key holds the value of the "key" field.
+	Key string `json:"key,omitempty"`
+	// Value holds the value of the "value" field.
+	Value any `json:"value,omitempty"`
+	// Metadata holds the value of the "metadata" field.
+	Metadata     map[string]interface{} `json:"metadata,omitempty"`
+	selectValues sql.SelectValues
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*AppConfiguration) scanValues(columns []string) ([]any, error) {
+	values := make([]any, len(columns))
+	for i := range columns {
+		switch columns[i] {
+		case appconfiguration.FieldValue, appconfiguration.FieldMetadata:
+			values[i] = new([]byte)
+		case appconfiguration.FieldCreatedAt, appconfiguration.FieldUpdatedAt:
+			values[i] = new(sql.NullInt64)
+		case appconfiguration.FieldID, appconfiguration.FieldKey:
+			values[i] = new(sql.NullString)
+		default:
+			values[i] = new(sql.UnknownType)
+		}
+	}
+	return values, nil
+}
+
+// assignValues assigns the values that were returned from sql.Rows (after scanning)
+// to the AppConfiguration fields.
+func (ac *AppConfiguration) assignValues(columns []string, values []any) error {
+	if m, n := len(values), len(columns); m < n {
+		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
+	}
+	for i := range columns {
+		switch columns[i] {
+		case appconfiguration.FieldID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field id", values[i])
+			} else if value.Valid {
+				ac.ID = value.String
+			}
+		case appconfiguration.FieldCreatedAt:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field created_at", values[i])
+			} else if value.Valid {
+				ac.CreatedAt = int(value.Int64)
+			}
+		case appconfiguration.FieldUpdatedAt:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
+			} else if value.Valid {
+				ac.UpdatedAt = int(value.Int64)
+			}
+		case appconfiguration.FieldKey:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field key", values[i])
+			} else if value.Valid {
+				ac.Key = value.String
+			}
+		case appconfiguration.FieldValue:
+			if value, ok := values[i].(*[]byte); !ok {
+				return fmt.Errorf("unexpected type %T for field value", values[i])
+			} else if value != nil && len(*value) > 0 {
+				if err := json.Unmarshal(*value, &ac.Value); err != nil {
+					return fmt.Errorf("unmarshal field value: %w", err)
+				}
+			}
+		case appconfiguration.FieldMetadata:
+			if value, ok := values[i].(*[]byte); !ok {
+				return fmt.Errorf("unexpected type %T for field metadata", values[i])
+			} else if value != nil && len(*value) > 0 {
+				if err := json.Unmarshal(*value, &ac.Metadata); err != nil {
+					return fmt.Errorf("unmarshal field metadata: %w", err)
+				}
+			}
+		default:
+			ac.selectValues.Set(columns[i], values[i])
+		}
+	}
+	return nil
+}
+
+// GetValue returns the ent.Value that was dynamically selected and assigned to the AppConfiguration.
+// This includes values selected through modifiers, order, etc.
+func (ac *AppConfiguration) GetValue(name string) (ent.Value, error) {
+	return ac.selectValues.Get(name)
+}
+
+// Update returns a builder for updating this AppConfiguration.
+// Note that you need to call AppConfiguration.Unwrap() before calling this method if this AppConfiguration
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (ac *AppConfiguration) Update() *AppConfigurationUpdateOne {
+	return NewAppConfigurationClient(ac.config).UpdateOne(ac)
+}
+
+// Unwrap unwraps the AppConfiguration entity that was returned from a transaction after it was closed,
+// so that all future queries will be executed through the driver which created the transaction.
+func (ac *AppConfiguration) Unwrap() *AppConfiguration {
+	_tx, ok := ac.config.driver.(*txDriver)
+	if !ok {
+		panic("db: AppConfiguration is not a transactional entity")
+	}
+	ac.config.driver = _tx.drv
+	return ac
+}
+
+// String implements the fmt.Stringer.
+func (ac *AppConfiguration) String() string {
+	var builder strings.Builder
+	builder.WriteString("AppConfiguration(")
+	builder.WriteString(fmt.Sprintf("id=%v, ", ac.ID))
+	builder.WriteString("created_at=")
+	builder.WriteString(fmt.Sprintf("%v", ac.CreatedAt))
+	builder.WriteString(", ")
+	builder.WriteString("updated_at=")
+	builder.WriteString(fmt.Sprintf("%v", ac.UpdatedAt))
+	builder.WriteString(", ")
+	builder.WriteString("key=")
+	builder.WriteString(ac.Key)
+	builder.WriteString(", ")
+	builder.WriteString("value=")
+	builder.WriteString(fmt.Sprintf("%v", ac.Value))
+	builder.WriteString(", ")
+	builder.WriteString("metadata=")
+	builder.WriteString(fmt.Sprintf("%v", ac.Metadata))
+	builder.WriteByte(')')
+	return builder.String()
+}
+
+// AppConfigurations is a parsable slice of AppConfiguration.
+type AppConfigurations []*AppConfiguration
diff --git a/internal/database/ent/db/appconfiguration/appconfiguration.go b/internal/database/ent/db/appconfiguration/appconfiguration.go
new file mode 100644
index 00000000..02f8ba48
--- /dev/null
+++ b/internal/database/ent/db/appconfiguration/appconfiguration.go
@@ -0,0 +1,82 @@
+// Code generated by ent, DO NOT EDIT.
+
+package appconfiguration
+
+import (
+	"entgo.io/ent/dialect/sql"
+)
+
+const (
+	// Label holds the string label denoting the appconfiguration type in the database.
+	Label = "app_configuration"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// FieldKey holds the string denoting the key field in the database.
+	FieldKey = "key"
+	// FieldValue holds the string denoting the value field in the database.
+	FieldValue = "value"
+	// FieldMetadata holds the string denoting the metadata field in the database.
+	FieldMetadata = "metadata"
+	// Table holds the table name of the appconfiguration in the database.
+	Table = "app_configurations"
+)
+
+// Columns holds all SQL columns for appconfiguration fields.
+var Columns = []string{
+	FieldID,
+	FieldCreatedAt,
+	FieldUpdatedAt,
+	FieldKey,
+	FieldValue,
+	FieldMetadata,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() int
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() int
+	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
+	UpdateDefaultUpdatedAt func() int
+	// KeyValidator is a validator for the "key" field. It is called by the builders before save.
+	KeyValidator func(string) error
+	// DefaultID holds the default value on creation for the "id" field.
+	DefaultID func() string
+)
+
+// OrderOption defines the ordering options for the AppConfiguration queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByKey orders the results by the key field.
+func ByKey(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldKey, opts...).ToFunc()
+}
diff --git a/internal/database/ent/db/appconfiguration/where.go b/internal/database/ent/db/appconfiguration/where.go
new file mode 100644
index 00000000..ffb17f2d
--- /dev/null
+++ b/internal/database/ent/db/appconfiguration/where.go
@@ -0,0 +1,248 @@
+// Code generated by ent, DO NOT EDIT.
+
+package appconfiguration
+
+import (
+	"entgo.io/ent/dialect/sql"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id string) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id string) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id string) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...string) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...string) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id string) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id string) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id string) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id string) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldLTE(FieldID, id))
+}
+
+// IDEqualFold applies the EqualFold predicate on the ID field.
+func IDEqualFold(id string) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldEqualFold(FieldID, id))
+}
+
+// IDContainsFold applies the ContainsFold predicate on the ID field.
+func IDContainsFold(id string) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldContainsFold(FieldID, id))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v int) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v int) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// Key applies equality check predicate on the "key" field. It's identical to KeyEQ.
+func Key(v string) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldEQ(FieldKey, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v int) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v int) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...int) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...int) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v int) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v int) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v int) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v int) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v int) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v int) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...int) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...int) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v int) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v int) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v int) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v int) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// KeyEQ applies the EQ predicate on the "key" field.
+func KeyEQ(v string) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldEQ(FieldKey, v))
+}
+
+// KeyNEQ applies the NEQ predicate on the "key" field.
+func KeyNEQ(v string) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldNEQ(FieldKey, v))
+}
+
+// KeyIn applies the In predicate on the "key" field.
+func KeyIn(vs ...string) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldIn(FieldKey, vs...))
+}
+
+// KeyNotIn applies the NotIn predicate on the "key" field.
+func KeyNotIn(vs ...string) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldNotIn(FieldKey, vs...))
+}
+
+// KeyGT applies the GT predicate on the "key" field.
+func KeyGT(v string) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldGT(FieldKey, v))
+}
+
+// KeyGTE applies the GTE predicate on the "key" field.
+func KeyGTE(v string) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldGTE(FieldKey, v))
+}
+
+// KeyLT applies the LT predicate on the "key" field.
+func KeyLT(v string) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldLT(FieldKey, v))
+}
+
+// KeyLTE applies the LTE predicate on the "key" field.
+func KeyLTE(v string) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldLTE(FieldKey, v))
+}
+
+// KeyContains applies the Contains predicate on the "key" field.
+func KeyContains(v string) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldContains(FieldKey, v))
+}
+
+// KeyHasPrefix applies the HasPrefix predicate on the "key" field.
+func KeyHasPrefix(v string) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldHasPrefix(FieldKey, v))
+}
+
+// KeyHasSuffix applies the HasSuffix predicate on the "key" field.
+func KeyHasSuffix(v string) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldHasSuffix(FieldKey, v))
+}
+
+// KeyEqualFold applies the EqualFold predicate on the "key" field.
+func KeyEqualFold(v string) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldEqualFold(FieldKey, v))
+}
+
+// KeyContainsFold applies the ContainsFold predicate on the "key" field.
+func KeyContainsFold(v string) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldContainsFold(FieldKey, v))
+}
+
+// MetadataIsNil applies the IsNil predicate on the "metadata" field.
+func MetadataIsNil() predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldIsNull(FieldMetadata))
+}
+
+// MetadataNotNil applies the NotNil predicate on the "metadata" field.
+func MetadataNotNil() predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.FieldNotNull(FieldMetadata))
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.AppConfiguration) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.AppConfiguration) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.AppConfiguration) predicate.AppConfiguration {
+	return predicate.AppConfiguration(sql.NotPredicates(p))
+}
diff --git a/internal/database/ent/db/appconfiguration_create.go b/internal/database/ent/db/appconfiguration_create.go
new file mode 100644
index 00000000..2cf22a7b
--- /dev/null
+++ b/internal/database/ent/db/appconfiguration_create.go
@@ -0,0 +1,290 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/appconfiguration"
+)
+
+// AppConfigurationCreate is the builder for creating a AppConfiguration entity.
+type AppConfigurationCreate struct {
+	config
+	mutation *AppConfigurationMutation
+	hooks    []Hook
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (acc *AppConfigurationCreate) SetCreatedAt(i int) *AppConfigurationCreate {
+	acc.mutation.SetCreatedAt(i)
+	return acc
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (acc *AppConfigurationCreate) SetNillableCreatedAt(i *int) *AppConfigurationCreate {
+	if i != nil {
+		acc.SetCreatedAt(*i)
+	}
+	return acc
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (acc *AppConfigurationCreate) SetUpdatedAt(i int) *AppConfigurationCreate {
+	acc.mutation.SetUpdatedAt(i)
+	return acc
+}
+
+// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
+func (acc *AppConfigurationCreate) SetNillableUpdatedAt(i *int) *AppConfigurationCreate {
+	if i != nil {
+		acc.SetUpdatedAt(*i)
+	}
+	return acc
+}
+
+// SetKey sets the "key" field.
+func (acc *AppConfigurationCreate) SetKey(s string) *AppConfigurationCreate {
+	acc.mutation.SetKey(s)
+	return acc
+}
+
+// SetValue sets the "value" field.
+func (acc *AppConfigurationCreate) SetValue(a any) *AppConfigurationCreate {
+	acc.mutation.SetValue(a)
+	return acc
+}
+
+// SetMetadata sets the "metadata" field.
+func (acc *AppConfigurationCreate) SetMetadata(m map[string]interface{}) *AppConfigurationCreate {
+	acc.mutation.SetMetadata(m)
+	return acc
+}
+
+// SetID sets the "id" field.
+func (acc *AppConfigurationCreate) SetID(s string) *AppConfigurationCreate {
+	acc.mutation.SetID(s)
+	return acc
+}
+
+// SetNillableID sets the "id" field if the given value is not nil.
+func (acc *AppConfigurationCreate) SetNillableID(s *string) *AppConfigurationCreate {
+	if s != nil {
+		acc.SetID(*s)
+	}
+	return acc
+}
+
+// Mutation returns the AppConfigurationMutation object of the builder.
+func (acc *AppConfigurationCreate) Mutation() *AppConfigurationMutation {
+	return acc.mutation
+}
+
+// Save creates the AppConfiguration in the database.
+func (acc *AppConfigurationCreate) Save(ctx context.Context) (*AppConfiguration, error) {
+	acc.defaults()
+	return withHooks(ctx, acc.sqlSave, acc.mutation, acc.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (acc *AppConfigurationCreate) SaveX(ctx context.Context) *AppConfiguration {
+	v, err := acc.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (acc *AppConfigurationCreate) Exec(ctx context.Context) error {
+	_, err := acc.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (acc *AppConfigurationCreate) ExecX(ctx context.Context) {
+	if err := acc.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (acc *AppConfigurationCreate) defaults() {
+	if _, ok := acc.mutation.CreatedAt(); !ok {
+		v := appconfiguration.DefaultCreatedAt()
+		acc.mutation.SetCreatedAt(v)
+	}
+	if _, ok := acc.mutation.UpdatedAt(); !ok {
+		v := appconfiguration.DefaultUpdatedAt()
+		acc.mutation.SetUpdatedAt(v)
+	}
+	if _, ok := acc.mutation.ID(); !ok {
+		v := appconfiguration.DefaultID()
+		acc.mutation.SetID(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (acc *AppConfigurationCreate) check() error {
+	if _, ok := acc.mutation.CreatedAt(); !ok {
+		return &ValidationError{Name: "created_at", err: errors.New(`db: missing required field "AppConfiguration.created_at"`)}
+	}
+	if _, ok := acc.mutation.UpdatedAt(); !ok {
+		return &ValidationError{Name: "updated_at", err: errors.New(`db: missing required field "AppConfiguration.updated_at"`)}
+	}
+	if _, ok := acc.mutation.Key(); !ok {
+		return &ValidationError{Name: "key", err: errors.New(`db: missing required field "AppConfiguration.key"`)}
+	}
+	if v, ok := acc.mutation.Key(); ok {
+		if err := appconfiguration.KeyValidator(v); err != nil {
+			return &ValidationError{Name: "key", err: fmt.Errorf(`db: validator failed for field "AppConfiguration.key": %w`, err)}
+		}
+	}
+	if _, ok := acc.mutation.Value(); !ok {
+		return &ValidationError{Name: "value", err: errors.New(`db: missing required field "AppConfiguration.value"`)}
+	}
+	return nil
+}
+
+func (acc *AppConfigurationCreate) sqlSave(ctx context.Context) (*AppConfiguration, error) {
+	if err := acc.check(); err != nil {
+		return nil, err
+	}
+	_node, _spec := acc.createSpec()
+	if err := sqlgraph.CreateNode(ctx, acc.driver, _spec); err != nil {
+		if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	if _spec.ID.Value != nil {
+		if id, ok := _spec.ID.Value.(string); ok {
+			_node.ID = id
+		} else {
+			return nil, fmt.Errorf("unexpected AppConfiguration.ID type: %T", _spec.ID.Value)
+		}
+	}
+	acc.mutation.id = &_node.ID
+	acc.mutation.done = true
+	return _node, nil
+}
+
+func (acc *AppConfigurationCreate) createSpec() (*AppConfiguration, *sqlgraph.CreateSpec) {
+	var (
+		_node = &AppConfiguration{config: acc.config}
+		_spec = sqlgraph.NewCreateSpec(appconfiguration.Table, sqlgraph.NewFieldSpec(appconfiguration.FieldID, field.TypeString))
+	)
+	if id, ok := acc.mutation.ID(); ok {
+		_node.ID = id
+		_spec.ID.Value = id
+	}
+	if value, ok := acc.mutation.CreatedAt(); ok {
+		_spec.SetField(appconfiguration.FieldCreatedAt, field.TypeInt, value)
+		_node.CreatedAt = value
+	}
+	if value, ok := acc.mutation.UpdatedAt(); ok {
+		_spec.SetField(appconfiguration.FieldUpdatedAt, field.TypeInt, value)
+		_node.UpdatedAt = value
+	}
+	if value, ok := acc.mutation.Key(); ok {
+		_spec.SetField(appconfiguration.FieldKey, field.TypeString, value)
+		_node.Key = value
+	}
+	if value, ok := acc.mutation.Value(); ok {
+		_spec.SetField(appconfiguration.FieldValue, field.TypeJSON, value)
+		_node.Value = value
+	}
+	if value, ok := acc.mutation.Metadata(); ok {
+		_spec.SetField(appconfiguration.FieldMetadata, field.TypeJSON, value)
+		_node.Metadata = value
+	}
+	return _node, _spec
+}
+
+// AppConfigurationCreateBulk is the builder for creating many AppConfiguration entities in bulk.
+type AppConfigurationCreateBulk struct {
+	config
+	err      error
+	builders []*AppConfigurationCreate
+}
+
+// Save creates the AppConfiguration entities in the database.
+func (accb *AppConfigurationCreateBulk) Save(ctx context.Context) ([]*AppConfiguration, error) {
+	if accb.err != nil {
+		return nil, accb.err
+	}
+	specs := make([]*sqlgraph.CreateSpec, len(accb.builders))
+	nodes := make([]*AppConfiguration, len(accb.builders))
+	mutators := make([]Mutator, len(accb.builders))
+	for i := range accb.builders {
+		func(i int, root context.Context) {
+			builder := accb.builders[i]
+			builder.defaults()
+			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+				mutation, ok := m.(*AppConfigurationMutation)
+				if !ok {
+					return nil, fmt.Errorf("unexpected mutation type %T", m)
+				}
+				if err := builder.check(); err != nil {
+					return nil, err
+				}
+				builder.mutation = mutation
+				var err error
+				nodes[i], specs[i] = builder.createSpec()
+				if i < len(mutators)-1 {
+					_, err = mutators[i+1].Mutate(root, accb.builders[i+1].mutation)
+				} else {
+					spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
+					// Invoke the actual operation on the latest mutation in the chain.
+					if err = sqlgraph.BatchCreate(ctx, accb.driver, spec); err != nil {
+						if sqlgraph.IsConstraintError(err) {
+							err = &ConstraintError{msg: err.Error(), wrap: err}
+						}
+					}
+				}
+				if err != nil {
+					return nil, err
+				}
+				mutation.id = &nodes[i].ID
+				mutation.done = true
+				return nodes[i], nil
+			})
+			for i := len(builder.hooks) - 1; i >= 0; i-- {
+				mut = builder.hooks[i](mut)
+			}
+			mutators[i] = mut
+		}(i, ctx)
+	}
+	if len(mutators) > 0 {
+		if _, err := mutators[0].Mutate(ctx, accb.builders[0].mutation); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (accb *AppConfigurationCreateBulk) SaveX(ctx context.Context) []*AppConfiguration {
+	v, err := accb.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (accb *AppConfigurationCreateBulk) Exec(ctx context.Context) error {
+	_, err := accb.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (accb *AppConfigurationCreateBulk) ExecX(ctx context.Context) {
+	if err := accb.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/database/ent/db/appconfiguration_delete.go b/internal/database/ent/db/appconfiguration_delete.go
new file mode 100644
index 00000000..f93b6397
--- /dev/null
+++ b/internal/database/ent/db/appconfiguration_delete.go
@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/appconfiguration"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+)
+
+// AppConfigurationDelete is the builder for deleting a AppConfiguration entity.
+type AppConfigurationDelete struct {
+	config
+	hooks    []Hook
+	mutation *AppConfigurationMutation
+}
+
+// Where appends a list predicates to the AppConfigurationDelete builder.
+func (acd *AppConfigurationDelete) Where(ps ...predicate.AppConfiguration) *AppConfigurationDelete {
+	acd.mutation.Where(ps...)
+	return acd
+}
+
+// Exec executes the deletion query and returns how many vertices were deleted.
+func (acd *AppConfigurationDelete) Exec(ctx context.Context) (int, error) {
+	return withHooks(ctx, acd.sqlExec, acd.mutation, acd.hooks)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (acd *AppConfigurationDelete) ExecX(ctx context.Context) int {
+	n, err := acd.Exec(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return n
+}
+
+func (acd *AppConfigurationDelete) sqlExec(ctx context.Context) (int, error) {
+	_spec := sqlgraph.NewDeleteSpec(appconfiguration.Table, sqlgraph.NewFieldSpec(appconfiguration.FieldID, field.TypeString))
+	if ps := acd.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	affected, err := sqlgraph.DeleteNodes(ctx, acd.driver, _spec)
+	if err != nil && sqlgraph.IsConstraintError(err) {
+		err = &ConstraintError{msg: err.Error(), wrap: err}
+	}
+	acd.mutation.done = true
+	return affected, err
+}
+
+// AppConfigurationDeleteOne is the builder for deleting a single AppConfiguration entity.
+type AppConfigurationDeleteOne struct {
+	acd *AppConfigurationDelete
+}
+
+// Where appends a list predicates to the AppConfigurationDelete builder.
+func (acdo *AppConfigurationDeleteOne) Where(ps ...predicate.AppConfiguration) *AppConfigurationDeleteOne {
+	acdo.acd.mutation.Where(ps...)
+	return acdo
+}
+
+// Exec executes the deletion query.
+func (acdo *AppConfigurationDeleteOne) Exec(ctx context.Context) error {
+	n, err := acdo.acd.Exec(ctx)
+	switch {
+	case err != nil:
+		return err
+	case n == 0:
+		return &NotFoundError{appconfiguration.Label}
+	default:
+		return nil
+	}
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (acdo *AppConfigurationDeleteOne) ExecX(ctx context.Context) {
+	if err := acdo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/database/ent/db/appconfiguration_query.go b/internal/database/ent/db/appconfiguration_query.go
new file mode 100644
index 00000000..549a21e4
--- /dev/null
+++ b/internal/database/ent/db/appconfiguration_query.go
@@ -0,0 +1,526 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"fmt"
+	"math"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/appconfiguration"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+)
+
+// AppConfigurationQuery is the builder for querying AppConfiguration entities.
+type AppConfigurationQuery struct {
+	config
+	ctx        *QueryContext
+	order      []appconfiguration.OrderOption
+	inters     []Interceptor
+	predicates []predicate.AppConfiguration
+	// intermediate query (i.e. traversal path).
+	sql  *sql.Selector
+	path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the AppConfigurationQuery builder.
+func (acq *AppConfigurationQuery) Where(ps ...predicate.AppConfiguration) *AppConfigurationQuery {
+	acq.predicates = append(acq.predicates, ps...)
+	return acq
+}
+
+// Limit the number of records to be returned by this query.
+func (acq *AppConfigurationQuery) Limit(limit int) *AppConfigurationQuery {
+	acq.ctx.Limit = &limit
+	return acq
+}
+
+// Offset to start from.
+func (acq *AppConfigurationQuery) Offset(offset int) *AppConfigurationQuery {
+	acq.ctx.Offset = &offset
+	return acq
+}
+
+// Unique configures the query builder to filter duplicate records on query.
+// By default, unique is set to true, and can be disabled using this method.
+func (acq *AppConfigurationQuery) Unique(unique bool) *AppConfigurationQuery {
+	acq.ctx.Unique = &unique
+	return acq
+}
+
+// Order specifies how the records should be ordered.
+func (acq *AppConfigurationQuery) Order(o ...appconfiguration.OrderOption) *AppConfigurationQuery {
+	acq.order = append(acq.order, o...)
+	return acq
+}
+
+// First returns the first AppConfiguration entity from the query.
+// Returns a *NotFoundError when no AppConfiguration was found.
+func (acq *AppConfigurationQuery) First(ctx context.Context) (*AppConfiguration, error) {
+	nodes, err := acq.Limit(1).All(setContextOp(ctx, acq.ctx, "First"))
+	if err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nil, &NotFoundError{appconfiguration.Label}
+	}
+	return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (acq *AppConfigurationQuery) FirstX(ctx context.Context) *AppConfiguration {
+	node, err := acq.First(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return node
+}
+
+// FirstID returns the first AppConfiguration ID from the query.
+// Returns a *NotFoundError when no AppConfiguration ID was found.
+func (acq *AppConfigurationQuery) FirstID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = acq.Limit(1).IDs(setContextOp(ctx, acq.ctx, "FirstID")); err != nil {
+		return
+	}
+	if len(ids) == 0 {
+		err = &NotFoundError{appconfiguration.Label}
+		return
+	}
+	return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (acq *AppConfigurationQuery) FirstIDX(ctx context.Context) string {
+	id, err := acq.FirstID(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return id
+}
+
+// Only returns a single AppConfiguration entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one AppConfiguration entity is found.
+// Returns a *NotFoundError when no AppConfiguration entities are found.
+func (acq *AppConfigurationQuery) Only(ctx context.Context) (*AppConfiguration, error) {
+	nodes, err := acq.Limit(2).All(setContextOp(ctx, acq.ctx, "Only"))
+	if err != nil {
+		return nil, err
+	}
+	switch len(nodes) {
+	case 1:
+		return nodes[0], nil
+	case 0:
+		return nil, &NotFoundError{appconfiguration.Label}
+	default:
+		return nil, &NotSingularError{appconfiguration.Label}
+	}
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (acq *AppConfigurationQuery) OnlyX(ctx context.Context) *AppConfiguration {
+	node, err := acq.Only(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// OnlyID is like Only, but returns the only AppConfiguration ID in the query.
+// Returns a *NotSingularError when more than one AppConfiguration ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (acq *AppConfigurationQuery) OnlyID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = acq.Limit(2).IDs(setContextOp(ctx, acq.ctx, "OnlyID")); err != nil {
+		return
+	}
+	switch len(ids) {
+	case 1:
+		id = ids[0]
+	case 0:
+		err = &NotFoundError{appconfiguration.Label}
+	default:
+		err = &NotSingularError{appconfiguration.Label}
+	}
+	return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (acq *AppConfigurationQuery) OnlyIDX(ctx context.Context) string {
+	id, err := acq.OnlyID(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return id
+}
+
+// All executes the query and returns a list of AppConfigurations.
+func (acq *AppConfigurationQuery) All(ctx context.Context) ([]*AppConfiguration, error) {
+	ctx = setContextOp(ctx, acq.ctx, "All")
+	if err := acq.prepareQuery(ctx); err != nil {
+		return nil, err
+	}
+	qr := querierAll[[]*AppConfiguration, *AppConfigurationQuery]()
+	return withInterceptors[[]*AppConfiguration](ctx, acq, qr, acq.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (acq *AppConfigurationQuery) AllX(ctx context.Context) []*AppConfiguration {
+	nodes, err := acq.All(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return nodes
+}
+
+// IDs executes the query and returns a list of AppConfiguration IDs.
+func (acq *AppConfigurationQuery) IDs(ctx context.Context) (ids []string, err error) {
+	if acq.ctx.Unique == nil && acq.path != nil {
+		acq.Unique(true)
+	}
+	ctx = setContextOp(ctx, acq.ctx, "IDs")
+	if err = acq.Select(appconfiguration.FieldID).Scan(ctx, &ids); err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (acq *AppConfigurationQuery) IDsX(ctx context.Context) []string {
+	ids, err := acq.IDs(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return ids
+}
+
+// Count returns the count of the given query.
+func (acq *AppConfigurationQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, acq.ctx, "Count")
+	if err := acq.prepareQuery(ctx); err != nil {
+		return 0, err
+	}
+	return withInterceptors[int](ctx, acq, querierCount[*AppConfigurationQuery](), acq.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (acq *AppConfigurationQuery) CountX(ctx context.Context) int {
+	count, err := acq.Count(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (acq *AppConfigurationQuery) Exist(ctx context.Context) (bool, error) {
+	ctx = setContextOp(ctx, acq.ctx, "Exist")
+	switch _, err := acq.FirstID(ctx); {
+	case IsNotFound(err):
+		return false, nil
+	case err != nil:
+		return false, fmt.Errorf("db: check existence: %w", err)
+	default:
+		return true, nil
+	}
+}
+
+// ExistX is like Exist, but panics if an error occurs.
+func (acq *AppConfigurationQuery) ExistX(ctx context.Context) bool {
+	exist, err := acq.Exist(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return exist
+}
+
+// Clone returns a duplicate of the AppConfigurationQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (acq *AppConfigurationQuery) Clone() *AppConfigurationQuery {
+	if acq == nil {
+		return nil
+	}
+	return &AppConfigurationQuery{
+		config:     acq.config,
+		ctx:        acq.ctx.Clone(),
+		order:      append([]appconfiguration.OrderOption{}, acq.order...),
+		inters:     append([]Interceptor{}, acq.inters...),
+		predicates: append([]predicate.AppConfiguration{}, acq.predicates...),
+		// clone intermediate query.
+		sql:  acq.sql.Clone(),
+		path: acq.path,
+	}
+}
+
+// GroupBy is used to group vertices by one or more fields/columns.
+// It is often used with aggregate functions, like: count, max, mean, min, sum.
+//
+// Example:
+//
+//	var v []struct {
+//		CreatedAt int `json:"created_at,omitempty"`
+//		Count int `json:"count,omitempty"`
+//	}
+//
+//	client.AppConfiguration.Query().
+//		GroupBy(appconfiguration.FieldCreatedAt).
+//		Aggregate(db.Count()).
+//		Scan(ctx, &v)
+func (acq *AppConfigurationQuery) GroupBy(field string, fields ...string) *AppConfigurationGroupBy {
+	acq.ctx.Fields = append([]string{field}, fields...)
+	grbuild := &AppConfigurationGroupBy{build: acq}
+	grbuild.flds = &acq.ctx.Fields
+	grbuild.label = appconfiguration.Label
+	grbuild.scan = grbuild.Scan
+	return grbuild
+}
+
+// Select allows the selection one or more fields/columns for the given query,
+// instead of selecting all fields in the entity.
+//
+// Example:
+//
+//	var v []struct {
+//		CreatedAt int `json:"created_at,omitempty"`
+//	}
+//
+//	client.AppConfiguration.Query().
+//		Select(appconfiguration.FieldCreatedAt).
+//		Scan(ctx, &v)
+func (acq *AppConfigurationQuery) Select(fields ...string) *AppConfigurationSelect {
+	acq.ctx.Fields = append(acq.ctx.Fields, fields...)
+	sbuild := &AppConfigurationSelect{AppConfigurationQuery: acq}
+	sbuild.label = appconfiguration.Label
+	sbuild.flds, sbuild.scan = &acq.ctx.Fields, sbuild.Scan
+	return sbuild
+}
+
+// Aggregate returns a AppConfigurationSelect configured with the given aggregations.
+func (acq *AppConfigurationQuery) Aggregate(fns ...AggregateFunc) *AppConfigurationSelect {
+	return acq.Select().Aggregate(fns...)
+}
+
+func (acq *AppConfigurationQuery) prepareQuery(ctx context.Context) error {
+	for _, inter := range acq.inters {
+		if inter == nil {
+			return fmt.Errorf("db: uninitialized interceptor (forgotten import db/runtime?)")
+		}
+		if trv, ok := inter.(Traverser); ok {
+			if err := trv.Traverse(ctx, acq); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range acq.ctx.Fields {
+		if !appconfiguration.ValidColumn(f) {
+			return &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+		}
+	}
+	if acq.path != nil {
+		prev, err := acq.path(ctx)
+		if err != nil {
+			return err
+		}
+		acq.sql = prev
+	}
+	return nil
+}
+
+func (acq *AppConfigurationQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*AppConfiguration, error) {
+	var (
+		nodes = []*AppConfiguration{}
+		_spec = acq.querySpec()
+	)
+	_spec.ScanValues = func(columns []string) ([]any, error) {
+		return (*AppConfiguration).scanValues(nil, columns)
+	}
+	_spec.Assign = func(columns []string, values []any) error {
+		node := &AppConfiguration{config: acq.config}
+		nodes = append(nodes, node)
+		return node.assignValues(columns, values)
+	}
+	for i := range hooks {
+		hooks[i](ctx, _spec)
+	}
+	if err := sqlgraph.QueryNodes(ctx, acq.driver, _spec); err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nodes, nil
+	}
+	return nodes, nil
+}
+
+func (acq *AppConfigurationQuery) sqlCount(ctx context.Context) (int, error) {
+	_spec := acq.querySpec()
+	_spec.Node.Columns = acq.ctx.Fields
+	if len(acq.ctx.Fields) > 0 {
+		_spec.Unique = acq.ctx.Unique != nil && *acq.ctx.Unique
+	}
+	return sqlgraph.CountNodes(ctx, acq.driver, _spec)
+}
+
+func (acq *AppConfigurationQuery) querySpec() *sqlgraph.QuerySpec {
+	_spec := sqlgraph.NewQuerySpec(appconfiguration.Table, appconfiguration.Columns, sqlgraph.NewFieldSpec(appconfiguration.FieldID, field.TypeString))
+	_spec.From = acq.sql
+	if unique := acq.ctx.Unique; unique != nil {
+		_spec.Unique = *unique
+	} else if acq.path != nil {
+		_spec.Unique = true
+	}
+	if fields := acq.ctx.Fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, appconfiguration.FieldID)
+		for i := range fields {
+			if fields[i] != appconfiguration.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+			}
+		}
+	}
+	if ps := acq.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if limit := acq.ctx.Limit; limit != nil {
+		_spec.Limit = *limit
+	}
+	if offset := acq.ctx.Offset; offset != nil {
+		_spec.Offset = *offset
+	}
+	if ps := acq.order; len(ps) > 0 {
+		_spec.Order = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	return _spec
+}
+
+func (acq *AppConfigurationQuery) sqlQuery(ctx context.Context) *sql.Selector {
+	builder := sql.Dialect(acq.driver.Dialect())
+	t1 := builder.Table(appconfiguration.Table)
+	columns := acq.ctx.Fields
+	if len(columns) == 0 {
+		columns = appconfiguration.Columns
+	}
+	selector := builder.Select(t1.Columns(columns...)...).From(t1)
+	if acq.sql != nil {
+		selector = acq.sql
+		selector.Select(selector.Columns(columns...)...)
+	}
+	if acq.ctx.Unique != nil && *acq.ctx.Unique {
+		selector.Distinct()
+	}
+	for _, p := range acq.predicates {
+		p(selector)
+	}
+	for _, p := range acq.order {
+		p(selector)
+	}
+	if offset := acq.ctx.Offset; offset != nil {
+		// limit is mandatory for offset clause. We start
+		// with default value, and override it below if needed.
+		selector.Offset(*offset).Limit(math.MaxInt32)
+	}
+	if limit := acq.ctx.Limit; limit != nil {
+		selector.Limit(*limit)
+	}
+	return selector
+}
+
+// AppConfigurationGroupBy is the group-by builder for AppConfiguration entities.
+type AppConfigurationGroupBy struct {
+	selector
+	build *AppConfigurationQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (acgb *AppConfigurationGroupBy) Aggregate(fns ...AggregateFunc) *AppConfigurationGroupBy {
+	acgb.fns = append(acgb.fns, fns...)
+	return acgb
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (acgb *AppConfigurationGroupBy) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, acgb.build.ctx, "GroupBy")
+	if err := acgb.build.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*AppConfigurationQuery, *AppConfigurationGroupBy](ctx, acgb.build, acgb, acgb.build.inters, v)
+}
+
+func (acgb *AppConfigurationGroupBy) sqlScan(ctx context.Context, root *AppConfigurationQuery, v any) error {
+	selector := root.sqlQuery(ctx).Select()
+	aggregation := make([]string, 0, len(acgb.fns))
+	for _, fn := range acgb.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*acgb.flds)+len(acgb.fns))
+		for _, f := range *acgb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*acgb.flds...)...)
+	if err := selector.Err(); err != nil {
+		return err
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := acgb.build.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
+
+// AppConfigurationSelect is the builder for selecting fields of AppConfiguration entities.
+type AppConfigurationSelect struct {
+	*AppConfigurationQuery
+	selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (acs *AppConfigurationSelect) Aggregate(fns ...AggregateFunc) *AppConfigurationSelect {
+	acs.fns = append(acs.fns, fns...)
+	return acs
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (acs *AppConfigurationSelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, acs.ctx, "Select")
+	if err := acs.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*AppConfigurationQuery, *AppConfigurationSelect](ctx, acs.AppConfigurationQuery, acs, acs.inters, v)
+}
+
+func (acs *AppConfigurationSelect) sqlScan(ctx context.Context, root *AppConfigurationQuery, v any) error {
+	selector := root.sqlQuery(ctx)
+	aggregation := make([]string, 0, len(acs.fns))
+	for _, fn := range acs.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	switch n := len(*acs.selector.flds); {
+	case n == 0 && len(aggregation) > 0:
+		selector.Select(aggregation...)
+	case n != 0 && len(aggregation) > 0:
+		selector.AppendSelect(aggregation...)
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := acs.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
diff --git a/internal/database/ent/db/appconfiguration_update.go b/internal/database/ent/db/appconfiguration_update.go
new file mode 100644
index 00000000..168e52c4
--- /dev/null
+++ b/internal/database/ent/db/appconfiguration_update.go
@@ -0,0 +1,345 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/appconfiguration"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+)
+
+// AppConfigurationUpdate is the builder for updating AppConfiguration entities.
+type AppConfigurationUpdate struct {
+	config
+	hooks    []Hook
+	mutation *AppConfigurationMutation
+}
+
+// Where appends a list predicates to the AppConfigurationUpdate builder.
+func (acu *AppConfigurationUpdate) Where(ps ...predicate.AppConfiguration) *AppConfigurationUpdate {
+	acu.mutation.Where(ps...)
+	return acu
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (acu *AppConfigurationUpdate) SetUpdatedAt(i int) *AppConfigurationUpdate {
+	acu.mutation.ResetUpdatedAt()
+	acu.mutation.SetUpdatedAt(i)
+	return acu
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (acu *AppConfigurationUpdate) AddUpdatedAt(i int) *AppConfigurationUpdate {
+	acu.mutation.AddUpdatedAt(i)
+	return acu
+}
+
+// SetKey sets the "key" field.
+func (acu *AppConfigurationUpdate) SetKey(s string) *AppConfigurationUpdate {
+	acu.mutation.SetKey(s)
+	return acu
+}
+
+// SetNillableKey sets the "key" field if the given value is not nil.
+func (acu *AppConfigurationUpdate) SetNillableKey(s *string) *AppConfigurationUpdate {
+	if s != nil {
+		acu.SetKey(*s)
+	}
+	return acu
+}
+
+// SetValue sets the "value" field.
+func (acu *AppConfigurationUpdate) SetValue(a any) *AppConfigurationUpdate {
+	acu.mutation.SetValue(a)
+	return acu
+}
+
+// SetMetadata sets the "metadata" field.
+func (acu *AppConfigurationUpdate) SetMetadata(m map[string]interface{}) *AppConfigurationUpdate {
+	acu.mutation.SetMetadata(m)
+	return acu
+}
+
+// ClearMetadata clears the value of the "metadata" field.
+func (acu *AppConfigurationUpdate) ClearMetadata() *AppConfigurationUpdate {
+	acu.mutation.ClearMetadata()
+	return acu
+}
+
+// Mutation returns the AppConfigurationMutation object of the builder.
+func (acu *AppConfigurationUpdate) Mutation() *AppConfigurationMutation {
+	return acu.mutation
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (acu *AppConfigurationUpdate) Save(ctx context.Context) (int, error) {
+	acu.defaults()
+	return withHooks(ctx, acu.sqlSave, acu.mutation, acu.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (acu *AppConfigurationUpdate) SaveX(ctx context.Context) int {
+	affected, err := acu.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return affected
+}
+
+// Exec executes the query.
+func (acu *AppConfigurationUpdate) Exec(ctx context.Context) error {
+	_, err := acu.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (acu *AppConfigurationUpdate) ExecX(ctx context.Context) {
+	if err := acu.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (acu *AppConfigurationUpdate) defaults() {
+	if _, ok := acu.mutation.UpdatedAt(); !ok {
+		v := appconfiguration.UpdateDefaultUpdatedAt()
+		acu.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (acu *AppConfigurationUpdate) check() error {
+	if v, ok := acu.mutation.Key(); ok {
+		if err := appconfiguration.KeyValidator(v); err != nil {
+			return &ValidationError{Name: "key", err: fmt.Errorf(`db: validator failed for field "AppConfiguration.key": %w`, err)}
+		}
+	}
+	return nil
+}
+
+func (acu *AppConfigurationUpdate) sqlSave(ctx context.Context) (n int, err error) {
+	if err := acu.check(); err != nil {
+		return n, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(appconfiguration.Table, appconfiguration.Columns, sqlgraph.NewFieldSpec(appconfiguration.FieldID, field.TypeString))
+	if ps := acu.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := acu.mutation.UpdatedAt(); ok {
+		_spec.SetField(appconfiguration.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := acu.mutation.AddedUpdatedAt(); ok {
+		_spec.AddField(appconfiguration.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := acu.mutation.Key(); ok {
+		_spec.SetField(appconfiguration.FieldKey, field.TypeString, value)
+	}
+	if value, ok := acu.mutation.Value(); ok {
+		_spec.SetField(appconfiguration.FieldValue, field.TypeJSON, value)
+	}
+	if value, ok := acu.mutation.Metadata(); ok {
+		_spec.SetField(appconfiguration.FieldMetadata, field.TypeJSON, value)
+	}
+	if acu.mutation.MetadataCleared() {
+		_spec.ClearField(appconfiguration.FieldMetadata, field.TypeJSON)
+	}
+	if n, err = sqlgraph.UpdateNodes(ctx, acu.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{appconfiguration.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return 0, err
+	}
+	acu.mutation.done = true
+	return n, nil
+}
+
+// AppConfigurationUpdateOne is the builder for updating a single AppConfiguration entity.
+type AppConfigurationUpdateOne struct {
+	config
+	fields   []string
+	hooks    []Hook
+	mutation *AppConfigurationMutation
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (acuo *AppConfigurationUpdateOne) SetUpdatedAt(i int) *AppConfigurationUpdateOne {
+	acuo.mutation.ResetUpdatedAt()
+	acuo.mutation.SetUpdatedAt(i)
+	return acuo
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (acuo *AppConfigurationUpdateOne) AddUpdatedAt(i int) *AppConfigurationUpdateOne {
+	acuo.mutation.AddUpdatedAt(i)
+	return acuo
+}
+
+// SetKey sets the "key" field.
+func (acuo *AppConfigurationUpdateOne) SetKey(s string) *AppConfigurationUpdateOne {
+	acuo.mutation.SetKey(s)
+	return acuo
+}
+
+// SetNillableKey sets the "key" field if the given value is not nil.
+func (acuo *AppConfigurationUpdateOne) SetNillableKey(s *string) *AppConfigurationUpdateOne {
+	if s != nil {
+		acuo.SetKey(*s)
+	}
+	return acuo
+}
+
+// SetValue sets the "value" field.
+func (acuo *AppConfigurationUpdateOne) SetValue(a any) *AppConfigurationUpdateOne {
+	acuo.mutation.SetValue(a)
+	return acuo
+}
+
+// SetMetadata sets the "metadata" field.
+func (acuo *AppConfigurationUpdateOne) SetMetadata(m map[string]interface{}) *AppConfigurationUpdateOne {
+	acuo.mutation.SetMetadata(m)
+	return acuo
+}
+
+// ClearMetadata clears the value of the "metadata" field.
+func (acuo *AppConfigurationUpdateOne) ClearMetadata() *AppConfigurationUpdateOne {
+	acuo.mutation.ClearMetadata()
+	return acuo
+}
+
+// Mutation returns the AppConfigurationMutation object of the builder.
+func (acuo *AppConfigurationUpdateOne) Mutation() *AppConfigurationMutation {
+	return acuo.mutation
+}
+
+// Where appends a list predicates to the AppConfigurationUpdate builder.
+func (acuo *AppConfigurationUpdateOne) Where(ps ...predicate.AppConfiguration) *AppConfigurationUpdateOne {
+	acuo.mutation.Where(ps...)
+	return acuo
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (acuo *AppConfigurationUpdateOne) Select(field string, fields ...string) *AppConfigurationUpdateOne {
+	acuo.fields = append([]string{field}, fields...)
+	return acuo
+}
+
+// Save executes the query and returns the updated AppConfiguration entity.
+func (acuo *AppConfigurationUpdateOne) Save(ctx context.Context) (*AppConfiguration, error) {
+	acuo.defaults()
+	return withHooks(ctx, acuo.sqlSave, acuo.mutation, acuo.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (acuo *AppConfigurationUpdateOne) SaveX(ctx context.Context) *AppConfiguration {
+	node, err := acuo.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// Exec executes the query on the entity.
+func (acuo *AppConfigurationUpdateOne) Exec(ctx context.Context) error {
+	_, err := acuo.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (acuo *AppConfigurationUpdateOne) ExecX(ctx context.Context) {
+	if err := acuo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (acuo *AppConfigurationUpdateOne) defaults() {
+	if _, ok := acuo.mutation.UpdatedAt(); !ok {
+		v := appconfiguration.UpdateDefaultUpdatedAt()
+		acuo.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (acuo *AppConfigurationUpdateOne) check() error {
+	if v, ok := acuo.mutation.Key(); ok {
+		if err := appconfiguration.KeyValidator(v); err != nil {
+			return &ValidationError{Name: "key", err: fmt.Errorf(`db: validator failed for field "AppConfiguration.key": %w`, err)}
+		}
+	}
+	return nil
+}
+
+func (acuo *AppConfigurationUpdateOne) sqlSave(ctx context.Context) (_node *AppConfiguration, err error) {
+	if err := acuo.check(); err != nil {
+		return _node, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(appconfiguration.Table, appconfiguration.Columns, sqlgraph.NewFieldSpec(appconfiguration.FieldID, field.TypeString))
+	id, ok := acuo.mutation.ID()
+	if !ok {
+		return nil, &ValidationError{Name: "id", err: errors.New(`db: missing "AppConfiguration.id" for update`)}
+	}
+	_spec.Node.ID.Value = id
+	if fields := acuo.fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, appconfiguration.FieldID)
+		for _, f := range fields {
+			if !appconfiguration.ValidColumn(f) {
+				return nil, &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+			}
+			if f != appconfiguration.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, f)
+			}
+		}
+	}
+	if ps := acuo.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := acuo.mutation.UpdatedAt(); ok {
+		_spec.SetField(appconfiguration.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := acuo.mutation.AddedUpdatedAt(); ok {
+		_spec.AddField(appconfiguration.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := acuo.mutation.Key(); ok {
+		_spec.SetField(appconfiguration.FieldKey, field.TypeString, value)
+	}
+	if value, ok := acuo.mutation.Value(); ok {
+		_spec.SetField(appconfiguration.FieldValue, field.TypeJSON, value)
+	}
+	if value, ok := acuo.mutation.Metadata(); ok {
+		_spec.SetField(appconfiguration.FieldMetadata, field.TypeJSON, value)
+	}
+	if acuo.mutation.MetadataCleared() {
+		_spec.ClearField(appconfiguration.FieldMetadata, field.TypeJSON)
+	}
+	_node = &AppConfiguration{config: acuo.config}
+	_spec.Assign = _node.assignValues
+	_spec.ScanValues = _node.scanValues
+	if err = sqlgraph.UpdateNode(ctx, acuo.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{appconfiguration.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	acuo.mutation.done = true
+	return _node, nil
+}
diff --git a/internal/database/ent/db/applicationcommand.go b/internal/database/ent/db/applicationcommand.go
new file mode 100644
index 00000000..ea3626b9
--- /dev/null
+++ b/internal/database/ent/db/applicationcommand.go
@@ -0,0 +1,147 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"fmt"
+	"strings"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+	"github.com/cufee/aftermath/internal/database/ent/db/applicationcommand"
+)
+
+// ApplicationCommand is the model entity for the ApplicationCommand schema.
+type ApplicationCommand struct {
+	config `json:"-"`
+	// ID of the ent.
+	ID string `json:"id,omitempty"`
+	// CreatedAt holds the value of the "created_at" field.
+	CreatedAt int `json:"created_at,omitempty"`
+	// UpdatedAt holds the value of the "updated_at" field.
+	UpdatedAt int `json:"updated_at,omitempty"`
+	// Name holds the value of the "name" field.
+	Name string `json:"name,omitempty"`
+	// Version holds the value of the "version" field.
+	Version string `json:"version,omitempty"`
+	// OptionsHash holds the value of the "options_hash" field.
+	OptionsHash  string `json:"options_hash,omitempty"`
+	selectValues sql.SelectValues
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*ApplicationCommand) scanValues(columns []string) ([]any, error) {
+	values := make([]any, len(columns))
+	for i := range columns {
+		switch columns[i] {
+		case applicationcommand.FieldCreatedAt, applicationcommand.FieldUpdatedAt:
+			values[i] = new(sql.NullInt64)
+		case applicationcommand.FieldID, applicationcommand.FieldName, applicationcommand.FieldVersion, applicationcommand.FieldOptionsHash:
+			values[i] = new(sql.NullString)
+		default:
+			values[i] = new(sql.UnknownType)
+		}
+	}
+	return values, nil
+}
+
+// assignValues assigns the values that were returned from sql.Rows (after scanning)
+// to the ApplicationCommand fields.
+func (ac *ApplicationCommand) assignValues(columns []string, values []any) error {
+	if m, n := len(values), len(columns); m < n {
+		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
+	}
+	for i := range columns {
+		switch columns[i] {
+		case applicationcommand.FieldID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field id", values[i])
+			} else if value.Valid {
+				ac.ID = value.String
+			}
+		case applicationcommand.FieldCreatedAt:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field created_at", values[i])
+			} else if value.Valid {
+				ac.CreatedAt = int(value.Int64)
+			}
+		case applicationcommand.FieldUpdatedAt:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
+			} else if value.Valid {
+				ac.UpdatedAt = int(value.Int64)
+			}
+		case applicationcommand.FieldName:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field name", values[i])
+			} else if value.Valid {
+				ac.Name = value.String
+			}
+		case applicationcommand.FieldVersion:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field version", values[i])
+			} else if value.Valid {
+				ac.Version = value.String
+			}
+		case applicationcommand.FieldOptionsHash:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field options_hash", values[i])
+			} else if value.Valid {
+				ac.OptionsHash = value.String
+			}
+		default:
+			ac.selectValues.Set(columns[i], values[i])
+		}
+	}
+	return nil
+}
+
+// Value returns the ent.Value that was dynamically selected and assigned to the ApplicationCommand.
+// This includes values selected through modifiers, order, etc.
+func (ac *ApplicationCommand) Value(name string) (ent.Value, error) {
+	return ac.selectValues.Get(name)
+}
+
+// Update returns a builder for updating this ApplicationCommand.
+// Note that you need to call ApplicationCommand.Unwrap() before calling this method if this ApplicationCommand
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (ac *ApplicationCommand) Update() *ApplicationCommandUpdateOne {
+	return NewApplicationCommandClient(ac.config).UpdateOne(ac)
+}
+
+// Unwrap unwraps the ApplicationCommand entity that was returned from a transaction after it was closed,
+// so that all future queries will be executed through the driver which created the transaction.
+func (ac *ApplicationCommand) Unwrap() *ApplicationCommand {
+	_tx, ok := ac.config.driver.(*txDriver)
+	if !ok {
+		panic("db: ApplicationCommand is not a transactional entity")
+	}
+	ac.config.driver = _tx.drv
+	return ac
+}
+
+// String implements the fmt.Stringer.
+func (ac *ApplicationCommand) String() string {
+	var builder strings.Builder
+	builder.WriteString("ApplicationCommand(")
+	builder.WriteString(fmt.Sprintf("id=%v, ", ac.ID))
+	builder.WriteString("created_at=")
+	builder.WriteString(fmt.Sprintf("%v", ac.CreatedAt))
+	builder.WriteString(", ")
+	builder.WriteString("updated_at=")
+	builder.WriteString(fmt.Sprintf("%v", ac.UpdatedAt))
+	builder.WriteString(", ")
+	builder.WriteString("name=")
+	builder.WriteString(ac.Name)
+	builder.WriteString(", ")
+	builder.WriteString("version=")
+	builder.WriteString(ac.Version)
+	builder.WriteString(", ")
+	builder.WriteString("options_hash=")
+	builder.WriteString(ac.OptionsHash)
+	builder.WriteByte(')')
+	return builder.String()
+}
+
+// ApplicationCommands is a parsable slice of ApplicationCommand.
+type ApplicationCommands []*ApplicationCommand
diff --git a/internal/database/ent/db/applicationcommand/applicationcommand.go b/internal/database/ent/db/applicationcommand/applicationcommand.go
new file mode 100644
index 00000000..6860891e
--- /dev/null
+++ b/internal/database/ent/db/applicationcommand/applicationcommand.go
@@ -0,0 +1,96 @@
+// Code generated by ent, DO NOT EDIT.
+
+package applicationcommand
+
+import (
+	"entgo.io/ent/dialect/sql"
+)
+
+const (
+	// Label holds the string label denoting the applicationcommand type in the database.
+	Label = "application_command"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// FieldName holds the string denoting the name field in the database.
+	FieldName = "name"
+	// FieldVersion holds the string denoting the version field in the database.
+	FieldVersion = "version"
+	// FieldOptionsHash holds the string denoting the options_hash field in the database.
+	FieldOptionsHash = "options_hash"
+	// Table holds the table name of the applicationcommand in the database.
+	Table = "application_commands"
+)
+
+// Columns holds all SQL columns for applicationcommand fields.
+var Columns = []string{
+	FieldID,
+	FieldCreatedAt,
+	FieldUpdatedAt,
+	FieldName,
+	FieldVersion,
+	FieldOptionsHash,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() int
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() int
+	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
+	UpdateDefaultUpdatedAt func() int
+	// NameValidator is a validator for the "name" field. It is called by the builders before save.
+	NameValidator func(string) error
+	// VersionValidator is a validator for the "version" field. It is called by the builders before save.
+	VersionValidator func(string) error
+	// OptionsHashValidator is a validator for the "options_hash" field. It is called by the builders before save.
+	OptionsHashValidator func(string) error
+	// DefaultID holds the default value on creation for the "id" field.
+	DefaultID func() string
+)
+
+// OrderOption defines the ordering options for the ApplicationCommand queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByName orders the results by the name field.
+func ByName(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldName, opts...).ToFunc()
+}
+
+// ByVersion orders the results by the version field.
+func ByVersion(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldVersion, opts...).ToFunc()
+}
+
+// ByOptionsHash orders the results by the options_hash field.
+func ByOptionsHash(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldOptionsHash, opts...).ToFunc()
+}
diff --git a/internal/database/ent/db/applicationcommand/where.go b/internal/database/ent/db/applicationcommand/where.go
new file mode 100644
index 00000000..d281b98f
--- /dev/null
+++ b/internal/database/ent/db/applicationcommand/where.go
@@ -0,0 +1,378 @@
+// Code generated by ent, DO NOT EDIT.
+
+package applicationcommand
+
+import (
+	"entgo.io/ent/dialect/sql"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldLTE(FieldID, id))
+}
+
+// IDEqualFold applies the EqualFold predicate on the ID field.
+func IDEqualFold(id string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldEqualFold(FieldID, id))
+}
+
+// IDContainsFold applies the ContainsFold predicate on the ID field.
+func IDContainsFold(id string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldContainsFold(FieldID, id))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v int) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v int) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// Name applies equality check predicate on the "name" field. It's identical to NameEQ.
+func Name(v string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldEQ(FieldName, v))
+}
+
+// Version applies equality check predicate on the "version" field. It's identical to VersionEQ.
+func Version(v string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldEQ(FieldVersion, v))
+}
+
+// OptionsHash applies equality check predicate on the "options_hash" field. It's identical to OptionsHashEQ.
+func OptionsHash(v string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldEQ(FieldOptionsHash, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v int) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v int) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...int) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...int) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v int) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v int) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v int) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v int) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v int) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v int) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...int) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...int) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v int) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v int) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v int) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v int) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// NameEQ applies the EQ predicate on the "name" field.
+func NameEQ(v string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldEQ(FieldName, v))
+}
+
+// NameNEQ applies the NEQ predicate on the "name" field.
+func NameNEQ(v string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldNEQ(FieldName, v))
+}
+
+// NameIn applies the In predicate on the "name" field.
+func NameIn(vs ...string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldIn(FieldName, vs...))
+}
+
+// NameNotIn applies the NotIn predicate on the "name" field.
+func NameNotIn(vs ...string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldNotIn(FieldName, vs...))
+}
+
+// NameGT applies the GT predicate on the "name" field.
+func NameGT(v string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldGT(FieldName, v))
+}
+
+// NameGTE applies the GTE predicate on the "name" field.
+func NameGTE(v string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldGTE(FieldName, v))
+}
+
+// NameLT applies the LT predicate on the "name" field.
+func NameLT(v string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldLT(FieldName, v))
+}
+
+// NameLTE applies the LTE predicate on the "name" field.
+func NameLTE(v string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldLTE(FieldName, v))
+}
+
+// NameContains applies the Contains predicate on the "name" field.
+func NameContains(v string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldContains(FieldName, v))
+}
+
+// NameHasPrefix applies the HasPrefix predicate on the "name" field.
+func NameHasPrefix(v string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldHasPrefix(FieldName, v))
+}
+
+// NameHasSuffix applies the HasSuffix predicate on the "name" field.
+func NameHasSuffix(v string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldHasSuffix(FieldName, v))
+}
+
+// NameEqualFold applies the EqualFold predicate on the "name" field.
+func NameEqualFold(v string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldEqualFold(FieldName, v))
+}
+
+// NameContainsFold applies the ContainsFold predicate on the "name" field.
+func NameContainsFold(v string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldContainsFold(FieldName, v))
+}
+
+// VersionEQ applies the EQ predicate on the "version" field.
+func VersionEQ(v string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldEQ(FieldVersion, v))
+}
+
+// VersionNEQ applies the NEQ predicate on the "version" field.
+func VersionNEQ(v string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldNEQ(FieldVersion, v))
+}
+
+// VersionIn applies the In predicate on the "version" field.
+func VersionIn(vs ...string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldIn(FieldVersion, vs...))
+}
+
+// VersionNotIn applies the NotIn predicate on the "version" field.
+func VersionNotIn(vs ...string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldNotIn(FieldVersion, vs...))
+}
+
+// VersionGT applies the GT predicate on the "version" field.
+func VersionGT(v string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldGT(FieldVersion, v))
+}
+
+// VersionGTE applies the GTE predicate on the "version" field.
+func VersionGTE(v string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldGTE(FieldVersion, v))
+}
+
+// VersionLT applies the LT predicate on the "version" field.
+func VersionLT(v string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldLT(FieldVersion, v))
+}
+
+// VersionLTE applies the LTE predicate on the "version" field.
+func VersionLTE(v string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldLTE(FieldVersion, v))
+}
+
+// VersionContains applies the Contains predicate on the "version" field.
+func VersionContains(v string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldContains(FieldVersion, v))
+}
+
+// VersionHasPrefix applies the HasPrefix predicate on the "version" field.
+func VersionHasPrefix(v string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldHasPrefix(FieldVersion, v))
+}
+
+// VersionHasSuffix applies the HasSuffix predicate on the "version" field.
+func VersionHasSuffix(v string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldHasSuffix(FieldVersion, v))
+}
+
+// VersionEqualFold applies the EqualFold predicate on the "version" field.
+func VersionEqualFold(v string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldEqualFold(FieldVersion, v))
+}
+
+// VersionContainsFold applies the ContainsFold predicate on the "version" field.
+func VersionContainsFold(v string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldContainsFold(FieldVersion, v))
+}
+
+// OptionsHashEQ applies the EQ predicate on the "options_hash" field.
+func OptionsHashEQ(v string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldEQ(FieldOptionsHash, v))
+}
+
+// OptionsHashNEQ applies the NEQ predicate on the "options_hash" field.
+func OptionsHashNEQ(v string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldNEQ(FieldOptionsHash, v))
+}
+
+// OptionsHashIn applies the In predicate on the "options_hash" field.
+func OptionsHashIn(vs ...string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldIn(FieldOptionsHash, vs...))
+}
+
+// OptionsHashNotIn applies the NotIn predicate on the "options_hash" field.
+func OptionsHashNotIn(vs ...string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldNotIn(FieldOptionsHash, vs...))
+}
+
+// OptionsHashGT applies the GT predicate on the "options_hash" field.
+func OptionsHashGT(v string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldGT(FieldOptionsHash, v))
+}
+
+// OptionsHashGTE applies the GTE predicate on the "options_hash" field.
+func OptionsHashGTE(v string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldGTE(FieldOptionsHash, v))
+}
+
+// OptionsHashLT applies the LT predicate on the "options_hash" field.
+func OptionsHashLT(v string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldLT(FieldOptionsHash, v))
+}
+
+// OptionsHashLTE applies the LTE predicate on the "options_hash" field.
+func OptionsHashLTE(v string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldLTE(FieldOptionsHash, v))
+}
+
+// OptionsHashContains applies the Contains predicate on the "options_hash" field.
+func OptionsHashContains(v string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldContains(FieldOptionsHash, v))
+}
+
+// OptionsHashHasPrefix applies the HasPrefix predicate on the "options_hash" field.
+func OptionsHashHasPrefix(v string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldHasPrefix(FieldOptionsHash, v))
+}
+
+// OptionsHashHasSuffix applies the HasSuffix predicate on the "options_hash" field.
+func OptionsHashHasSuffix(v string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldHasSuffix(FieldOptionsHash, v))
+}
+
+// OptionsHashEqualFold applies the EqualFold predicate on the "options_hash" field.
+func OptionsHashEqualFold(v string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldEqualFold(FieldOptionsHash, v))
+}
+
+// OptionsHashContainsFold applies the ContainsFold predicate on the "options_hash" field.
+func OptionsHashContainsFold(v string) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.FieldContainsFold(FieldOptionsHash, v))
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.ApplicationCommand) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.ApplicationCommand) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.ApplicationCommand) predicate.ApplicationCommand {
+	return predicate.ApplicationCommand(sql.NotPredicates(p))
+}
diff --git a/internal/database/ent/db/applicationcommand_create.go b/internal/database/ent/db/applicationcommand_create.go
new file mode 100644
index 00000000..14f3abb9
--- /dev/null
+++ b/internal/database/ent/db/applicationcommand_create.go
@@ -0,0 +1,303 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/applicationcommand"
+)
+
+// ApplicationCommandCreate is the builder for creating a ApplicationCommand entity.
+type ApplicationCommandCreate struct {
+	config
+	mutation *ApplicationCommandMutation
+	hooks    []Hook
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (acc *ApplicationCommandCreate) SetCreatedAt(i int) *ApplicationCommandCreate {
+	acc.mutation.SetCreatedAt(i)
+	return acc
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (acc *ApplicationCommandCreate) SetNillableCreatedAt(i *int) *ApplicationCommandCreate {
+	if i != nil {
+		acc.SetCreatedAt(*i)
+	}
+	return acc
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (acc *ApplicationCommandCreate) SetUpdatedAt(i int) *ApplicationCommandCreate {
+	acc.mutation.SetUpdatedAt(i)
+	return acc
+}
+
+// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
+func (acc *ApplicationCommandCreate) SetNillableUpdatedAt(i *int) *ApplicationCommandCreate {
+	if i != nil {
+		acc.SetUpdatedAt(*i)
+	}
+	return acc
+}
+
+// SetName sets the "name" field.
+func (acc *ApplicationCommandCreate) SetName(s string) *ApplicationCommandCreate {
+	acc.mutation.SetName(s)
+	return acc
+}
+
+// SetVersion sets the "version" field.
+func (acc *ApplicationCommandCreate) SetVersion(s string) *ApplicationCommandCreate {
+	acc.mutation.SetVersion(s)
+	return acc
+}
+
+// SetOptionsHash sets the "options_hash" field.
+func (acc *ApplicationCommandCreate) SetOptionsHash(s string) *ApplicationCommandCreate {
+	acc.mutation.SetOptionsHash(s)
+	return acc
+}
+
+// SetID sets the "id" field.
+func (acc *ApplicationCommandCreate) SetID(s string) *ApplicationCommandCreate {
+	acc.mutation.SetID(s)
+	return acc
+}
+
+// SetNillableID sets the "id" field if the given value is not nil.
+func (acc *ApplicationCommandCreate) SetNillableID(s *string) *ApplicationCommandCreate {
+	if s != nil {
+		acc.SetID(*s)
+	}
+	return acc
+}
+
+// Mutation returns the ApplicationCommandMutation object of the builder.
+func (acc *ApplicationCommandCreate) Mutation() *ApplicationCommandMutation {
+	return acc.mutation
+}
+
+// Save creates the ApplicationCommand in the database.
+func (acc *ApplicationCommandCreate) Save(ctx context.Context) (*ApplicationCommand, error) {
+	acc.defaults()
+	return withHooks(ctx, acc.sqlSave, acc.mutation, acc.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (acc *ApplicationCommandCreate) SaveX(ctx context.Context) *ApplicationCommand {
+	v, err := acc.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (acc *ApplicationCommandCreate) Exec(ctx context.Context) error {
+	_, err := acc.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (acc *ApplicationCommandCreate) ExecX(ctx context.Context) {
+	if err := acc.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (acc *ApplicationCommandCreate) defaults() {
+	if _, ok := acc.mutation.CreatedAt(); !ok {
+		v := applicationcommand.DefaultCreatedAt()
+		acc.mutation.SetCreatedAt(v)
+	}
+	if _, ok := acc.mutation.UpdatedAt(); !ok {
+		v := applicationcommand.DefaultUpdatedAt()
+		acc.mutation.SetUpdatedAt(v)
+	}
+	if _, ok := acc.mutation.ID(); !ok {
+		v := applicationcommand.DefaultID()
+		acc.mutation.SetID(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (acc *ApplicationCommandCreate) check() error {
+	if _, ok := acc.mutation.CreatedAt(); !ok {
+		return &ValidationError{Name: "created_at", err: errors.New(`db: missing required field "ApplicationCommand.created_at"`)}
+	}
+	if _, ok := acc.mutation.UpdatedAt(); !ok {
+		return &ValidationError{Name: "updated_at", err: errors.New(`db: missing required field "ApplicationCommand.updated_at"`)}
+	}
+	if _, ok := acc.mutation.Name(); !ok {
+		return &ValidationError{Name: "name", err: errors.New(`db: missing required field "ApplicationCommand.name"`)}
+	}
+	if v, ok := acc.mutation.Name(); ok {
+		if err := applicationcommand.NameValidator(v); err != nil {
+			return &ValidationError{Name: "name", err: fmt.Errorf(`db: validator failed for field "ApplicationCommand.name": %w`, err)}
+		}
+	}
+	if _, ok := acc.mutation.Version(); !ok {
+		return &ValidationError{Name: "version", err: errors.New(`db: missing required field "ApplicationCommand.version"`)}
+	}
+	if v, ok := acc.mutation.Version(); ok {
+		if err := applicationcommand.VersionValidator(v); err != nil {
+			return &ValidationError{Name: "version", err: fmt.Errorf(`db: validator failed for field "ApplicationCommand.version": %w`, err)}
+		}
+	}
+	if _, ok := acc.mutation.OptionsHash(); !ok {
+		return &ValidationError{Name: "options_hash", err: errors.New(`db: missing required field "ApplicationCommand.options_hash"`)}
+	}
+	if v, ok := acc.mutation.OptionsHash(); ok {
+		if err := applicationcommand.OptionsHashValidator(v); err != nil {
+			return &ValidationError{Name: "options_hash", err: fmt.Errorf(`db: validator failed for field "ApplicationCommand.options_hash": %w`, err)}
+		}
+	}
+	return nil
+}
+
+func (acc *ApplicationCommandCreate) sqlSave(ctx context.Context) (*ApplicationCommand, error) {
+	if err := acc.check(); err != nil {
+		return nil, err
+	}
+	_node, _spec := acc.createSpec()
+	if err := sqlgraph.CreateNode(ctx, acc.driver, _spec); err != nil {
+		if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	if _spec.ID.Value != nil {
+		if id, ok := _spec.ID.Value.(string); ok {
+			_node.ID = id
+		} else {
+			return nil, fmt.Errorf("unexpected ApplicationCommand.ID type: %T", _spec.ID.Value)
+		}
+	}
+	acc.mutation.id = &_node.ID
+	acc.mutation.done = true
+	return _node, nil
+}
+
+func (acc *ApplicationCommandCreate) createSpec() (*ApplicationCommand, *sqlgraph.CreateSpec) {
+	var (
+		_node = &ApplicationCommand{config: acc.config}
+		_spec = sqlgraph.NewCreateSpec(applicationcommand.Table, sqlgraph.NewFieldSpec(applicationcommand.FieldID, field.TypeString))
+	)
+	if id, ok := acc.mutation.ID(); ok {
+		_node.ID = id
+		_spec.ID.Value = id
+	}
+	if value, ok := acc.mutation.CreatedAt(); ok {
+		_spec.SetField(applicationcommand.FieldCreatedAt, field.TypeInt, value)
+		_node.CreatedAt = value
+	}
+	if value, ok := acc.mutation.UpdatedAt(); ok {
+		_spec.SetField(applicationcommand.FieldUpdatedAt, field.TypeInt, value)
+		_node.UpdatedAt = value
+	}
+	if value, ok := acc.mutation.Name(); ok {
+		_spec.SetField(applicationcommand.FieldName, field.TypeString, value)
+		_node.Name = value
+	}
+	if value, ok := acc.mutation.Version(); ok {
+		_spec.SetField(applicationcommand.FieldVersion, field.TypeString, value)
+		_node.Version = value
+	}
+	if value, ok := acc.mutation.OptionsHash(); ok {
+		_spec.SetField(applicationcommand.FieldOptionsHash, field.TypeString, value)
+		_node.OptionsHash = value
+	}
+	return _node, _spec
+}
+
+// ApplicationCommandCreateBulk is the builder for creating many ApplicationCommand entities in bulk.
+type ApplicationCommandCreateBulk struct {
+	config
+	err      error
+	builders []*ApplicationCommandCreate
+}
+
+// Save creates the ApplicationCommand entities in the database.
+func (accb *ApplicationCommandCreateBulk) Save(ctx context.Context) ([]*ApplicationCommand, error) {
+	if accb.err != nil {
+		return nil, accb.err
+	}
+	specs := make([]*sqlgraph.CreateSpec, len(accb.builders))
+	nodes := make([]*ApplicationCommand, len(accb.builders))
+	mutators := make([]Mutator, len(accb.builders))
+	for i := range accb.builders {
+		func(i int, root context.Context) {
+			builder := accb.builders[i]
+			builder.defaults()
+			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+				mutation, ok := m.(*ApplicationCommandMutation)
+				if !ok {
+					return nil, fmt.Errorf("unexpected mutation type %T", m)
+				}
+				if err := builder.check(); err != nil {
+					return nil, err
+				}
+				builder.mutation = mutation
+				var err error
+				nodes[i], specs[i] = builder.createSpec()
+				if i < len(mutators)-1 {
+					_, err = mutators[i+1].Mutate(root, accb.builders[i+1].mutation)
+				} else {
+					spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
+					// Invoke the actual operation on the latest mutation in the chain.
+					if err = sqlgraph.BatchCreate(ctx, accb.driver, spec); err != nil {
+						if sqlgraph.IsConstraintError(err) {
+							err = &ConstraintError{msg: err.Error(), wrap: err}
+						}
+					}
+				}
+				if err != nil {
+					return nil, err
+				}
+				mutation.id = &nodes[i].ID
+				mutation.done = true
+				return nodes[i], nil
+			})
+			for i := len(builder.hooks) - 1; i >= 0; i-- {
+				mut = builder.hooks[i](mut)
+			}
+			mutators[i] = mut
+		}(i, ctx)
+	}
+	if len(mutators) > 0 {
+		if _, err := mutators[0].Mutate(ctx, accb.builders[0].mutation); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (accb *ApplicationCommandCreateBulk) SaveX(ctx context.Context) []*ApplicationCommand {
+	v, err := accb.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (accb *ApplicationCommandCreateBulk) Exec(ctx context.Context) error {
+	_, err := accb.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (accb *ApplicationCommandCreateBulk) ExecX(ctx context.Context) {
+	if err := accb.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/database/ent/db/applicationcommand_delete.go b/internal/database/ent/db/applicationcommand_delete.go
new file mode 100644
index 00000000..547e4399
--- /dev/null
+++ b/internal/database/ent/db/applicationcommand_delete.go
@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/applicationcommand"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+)
+
+// ApplicationCommandDelete is the builder for deleting a ApplicationCommand entity.
+type ApplicationCommandDelete struct {
+	config
+	hooks    []Hook
+	mutation *ApplicationCommandMutation
+}
+
+// Where appends a list predicates to the ApplicationCommandDelete builder.
+func (acd *ApplicationCommandDelete) Where(ps ...predicate.ApplicationCommand) *ApplicationCommandDelete {
+	acd.mutation.Where(ps...)
+	return acd
+}
+
+// Exec executes the deletion query and returns how many vertices were deleted.
+func (acd *ApplicationCommandDelete) Exec(ctx context.Context) (int, error) {
+	return withHooks(ctx, acd.sqlExec, acd.mutation, acd.hooks)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (acd *ApplicationCommandDelete) ExecX(ctx context.Context) int {
+	n, err := acd.Exec(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return n
+}
+
+func (acd *ApplicationCommandDelete) sqlExec(ctx context.Context) (int, error) {
+	_spec := sqlgraph.NewDeleteSpec(applicationcommand.Table, sqlgraph.NewFieldSpec(applicationcommand.FieldID, field.TypeString))
+	if ps := acd.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	affected, err := sqlgraph.DeleteNodes(ctx, acd.driver, _spec)
+	if err != nil && sqlgraph.IsConstraintError(err) {
+		err = &ConstraintError{msg: err.Error(), wrap: err}
+	}
+	acd.mutation.done = true
+	return affected, err
+}
+
+// ApplicationCommandDeleteOne is the builder for deleting a single ApplicationCommand entity.
+type ApplicationCommandDeleteOne struct {
+	acd *ApplicationCommandDelete
+}
+
+// Where appends a list predicates to the ApplicationCommandDelete builder.
+func (acdo *ApplicationCommandDeleteOne) Where(ps ...predicate.ApplicationCommand) *ApplicationCommandDeleteOne {
+	acdo.acd.mutation.Where(ps...)
+	return acdo
+}
+
+// Exec executes the deletion query.
+func (acdo *ApplicationCommandDeleteOne) Exec(ctx context.Context) error {
+	n, err := acdo.acd.Exec(ctx)
+	switch {
+	case err != nil:
+		return err
+	case n == 0:
+		return &NotFoundError{applicationcommand.Label}
+	default:
+		return nil
+	}
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (acdo *ApplicationCommandDeleteOne) ExecX(ctx context.Context) {
+	if err := acdo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/database/ent/db/applicationcommand_query.go b/internal/database/ent/db/applicationcommand_query.go
new file mode 100644
index 00000000..5c45967e
--- /dev/null
+++ b/internal/database/ent/db/applicationcommand_query.go
@@ -0,0 +1,526 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"fmt"
+	"math"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/applicationcommand"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+)
+
+// ApplicationCommandQuery is the builder for querying ApplicationCommand entities.
+type ApplicationCommandQuery struct {
+	config
+	ctx        *QueryContext
+	order      []applicationcommand.OrderOption
+	inters     []Interceptor
+	predicates []predicate.ApplicationCommand
+	// intermediate query (i.e. traversal path).
+	sql  *sql.Selector
+	path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the ApplicationCommandQuery builder.
+func (acq *ApplicationCommandQuery) Where(ps ...predicate.ApplicationCommand) *ApplicationCommandQuery {
+	acq.predicates = append(acq.predicates, ps...)
+	return acq
+}
+
+// Limit the number of records to be returned by this query.
+func (acq *ApplicationCommandQuery) Limit(limit int) *ApplicationCommandQuery {
+	acq.ctx.Limit = &limit
+	return acq
+}
+
+// Offset to start from.
+func (acq *ApplicationCommandQuery) Offset(offset int) *ApplicationCommandQuery {
+	acq.ctx.Offset = &offset
+	return acq
+}
+
+// Unique configures the query builder to filter duplicate records on query.
+// By default, unique is set to true, and can be disabled using this method.
+func (acq *ApplicationCommandQuery) Unique(unique bool) *ApplicationCommandQuery {
+	acq.ctx.Unique = &unique
+	return acq
+}
+
+// Order specifies how the records should be ordered.
+func (acq *ApplicationCommandQuery) Order(o ...applicationcommand.OrderOption) *ApplicationCommandQuery {
+	acq.order = append(acq.order, o...)
+	return acq
+}
+
+// First returns the first ApplicationCommand entity from the query.
+// Returns a *NotFoundError when no ApplicationCommand was found.
+func (acq *ApplicationCommandQuery) First(ctx context.Context) (*ApplicationCommand, error) {
+	nodes, err := acq.Limit(1).All(setContextOp(ctx, acq.ctx, "First"))
+	if err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nil, &NotFoundError{applicationcommand.Label}
+	}
+	return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (acq *ApplicationCommandQuery) FirstX(ctx context.Context) *ApplicationCommand {
+	node, err := acq.First(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return node
+}
+
+// FirstID returns the first ApplicationCommand ID from the query.
+// Returns a *NotFoundError when no ApplicationCommand ID was found.
+func (acq *ApplicationCommandQuery) FirstID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = acq.Limit(1).IDs(setContextOp(ctx, acq.ctx, "FirstID")); err != nil {
+		return
+	}
+	if len(ids) == 0 {
+		err = &NotFoundError{applicationcommand.Label}
+		return
+	}
+	return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (acq *ApplicationCommandQuery) FirstIDX(ctx context.Context) string {
+	id, err := acq.FirstID(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return id
+}
+
+// Only returns a single ApplicationCommand entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one ApplicationCommand entity is found.
+// Returns a *NotFoundError when no ApplicationCommand entities are found.
+func (acq *ApplicationCommandQuery) Only(ctx context.Context) (*ApplicationCommand, error) {
+	nodes, err := acq.Limit(2).All(setContextOp(ctx, acq.ctx, "Only"))
+	if err != nil {
+		return nil, err
+	}
+	switch len(nodes) {
+	case 1:
+		return nodes[0], nil
+	case 0:
+		return nil, &NotFoundError{applicationcommand.Label}
+	default:
+		return nil, &NotSingularError{applicationcommand.Label}
+	}
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (acq *ApplicationCommandQuery) OnlyX(ctx context.Context) *ApplicationCommand {
+	node, err := acq.Only(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// OnlyID is like Only, but returns the only ApplicationCommand ID in the query.
+// Returns a *NotSingularError when more than one ApplicationCommand ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (acq *ApplicationCommandQuery) OnlyID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = acq.Limit(2).IDs(setContextOp(ctx, acq.ctx, "OnlyID")); err != nil {
+		return
+	}
+	switch len(ids) {
+	case 1:
+		id = ids[0]
+	case 0:
+		err = &NotFoundError{applicationcommand.Label}
+	default:
+		err = &NotSingularError{applicationcommand.Label}
+	}
+	return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (acq *ApplicationCommandQuery) OnlyIDX(ctx context.Context) string {
+	id, err := acq.OnlyID(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return id
+}
+
+// All executes the query and returns a list of ApplicationCommands.
+func (acq *ApplicationCommandQuery) All(ctx context.Context) ([]*ApplicationCommand, error) {
+	ctx = setContextOp(ctx, acq.ctx, "All")
+	if err := acq.prepareQuery(ctx); err != nil {
+		return nil, err
+	}
+	qr := querierAll[[]*ApplicationCommand, *ApplicationCommandQuery]()
+	return withInterceptors[[]*ApplicationCommand](ctx, acq, qr, acq.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (acq *ApplicationCommandQuery) AllX(ctx context.Context) []*ApplicationCommand {
+	nodes, err := acq.All(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return nodes
+}
+
+// IDs executes the query and returns a list of ApplicationCommand IDs.
+func (acq *ApplicationCommandQuery) IDs(ctx context.Context) (ids []string, err error) {
+	if acq.ctx.Unique == nil && acq.path != nil {
+		acq.Unique(true)
+	}
+	ctx = setContextOp(ctx, acq.ctx, "IDs")
+	if err = acq.Select(applicationcommand.FieldID).Scan(ctx, &ids); err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (acq *ApplicationCommandQuery) IDsX(ctx context.Context) []string {
+	ids, err := acq.IDs(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return ids
+}
+
+// Count returns the count of the given query.
+func (acq *ApplicationCommandQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, acq.ctx, "Count")
+	if err := acq.prepareQuery(ctx); err != nil {
+		return 0, err
+	}
+	return withInterceptors[int](ctx, acq, querierCount[*ApplicationCommandQuery](), acq.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (acq *ApplicationCommandQuery) CountX(ctx context.Context) int {
+	count, err := acq.Count(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (acq *ApplicationCommandQuery) Exist(ctx context.Context) (bool, error) {
+	ctx = setContextOp(ctx, acq.ctx, "Exist")
+	switch _, err := acq.FirstID(ctx); {
+	case IsNotFound(err):
+		return false, nil
+	case err != nil:
+		return false, fmt.Errorf("db: check existence: %w", err)
+	default:
+		return true, nil
+	}
+}
+
+// ExistX is like Exist, but panics if an error occurs.
+func (acq *ApplicationCommandQuery) ExistX(ctx context.Context) bool {
+	exist, err := acq.Exist(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return exist
+}
+
+// Clone returns a duplicate of the ApplicationCommandQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (acq *ApplicationCommandQuery) Clone() *ApplicationCommandQuery {
+	if acq == nil {
+		return nil
+	}
+	return &ApplicationCommandQuery{
+		config:     acq.config,
+		ctx:        acq.ctx.Clone(),
+		order:      append([]applicationcommand.OrderOption{}, acq.order...),
+		inters:     append([]Interceptor{}, acq.inters...),
+		predicates: append([]predicate.ApplicationCommand{}, acq.predicates...),
+		// clone intermediate query.
+		sql:  acq.sql.Clone(),
+		path: acq.path,
+	}
+}
+
+// GroupBy is used to group vertices by one or more fields/columns.
+// It is often used with aggregate functions, like: count, max, mean, min, sum.
+//
+// Example:
+//
+//	var v []struct {
+//		CreatedAt int `json:"created_at,omitempty"`
+//		Count int `json:"count,omitempty"`
+//	}
+//
+//	client.ApplicationCommand.Query().
+//		GroupBy(applicationcommand.FieldCreatedAt).
+//		Aggregate(db.Count()).
+//		Scan(ctx, &v)
+func (acq *ApplicationCommandQuery) GroupBy(field string, fields ...string) *ApplicationCommandGroupBy {
+	acq.ctx.Fields = append([]string{field}, fields...)
+	grbuild := &ApplicationCommandGroupBy{build: acq}
+	grbuild.flds = &acq.ctx.Fields
+	grbuild.label = applicationcommand.Label
+	grbuild.scan = grbuild.Scan
+	return grbuild
+}
+
+// Select allows the selection one or more fields/columns for the given query,
+// instead of selecting all fields in the entity.
+//
+// Example:
+//
+//	var v []struct {
+//		CreatedAt int `json:"created_at,omitempty"`
+//	}
+//
+//	client.ApplicationCommand.Query().
+//		Select(applicationcommand.FieldCreatedAt).
+//		Scan(ctx, &v)
+func (acq *ApplicationCommandQuery) Select(fields ...string) *ApplicationCommandSelect {
+	acq.ctx.Fields = append(acq.ctx.Fields, fields...)
+	sbuild := &ApplicationCommandSelect{ApplicationCommandQuery: acq}
+	sbuild.label = applicationcommand.Label
+	sbuild.flds, sbuild.scan = &acq.ctx.Fields, sbuild.Scan
+	return sbuild
+}
+
+// Aggregate returns a ApplicationCommandSelect configured with the given aggregations.
+func (acq *ApplicationCommandQuery) Aggregate(fns ...AggregateFunc) *ApplicationCommandSelect {
+	return acq.Select().Aggregate(fns...)
+}
+
+func (acq *ApplicationCommandQuery) prepareQuery(ctx context.Context) error {
+	for _, inter := range acq.inters {
+		if inter == nil {
+			return fmt.Errorf("db: uninitialized interceptor (forgotten import db/runtime?)")
+		}
+		if trv, ok := inter.(Traverser); ok {
+			if err := trv.Traverse(ctx, acq); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range acq.ctx.Fields {
+		if !applicationcommand.ValidColumn(f) {
+			return &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+		}
+	}
+	if acq.path != nil {
+		prev, err := acq.path(ctx)
+		if err != nil {
+			return err
+		}
+		acq.sql = prev
+	}
+	return nil
+}
+
+func (acq *ApplicationCommandQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*ApplicationCommand, error) {
+	var (
+		nodes = []*ApplicationCommand{}
+		_spec = acq.querySpec()
+	)
+	_spec.ScanValues = func(columns []string) ([]any, error) {
+		return (*ApplicationCommand).scanValues(nil, columns)
+	}
+	_spec.Assign = func(columns []string, values []any) error {
+		node := &ApplicationCommand{config: acq.config}
+		nodes = append(nodes, node)
+		return node.assignValues(columns, values)
+	}
+	for i := range hooks {
+		hooks[i](ctx, _spec)
+	}
+	if err := sqlgraph.QueryNodes(ctx, acq.driver, _spec); err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nodes, nil
+	}
+	return nodes, nil
+}
+
+func (acq *ApplicationCommandQuery) sqlCount(ctx context.Context) (int, error) {
+	_spec := acq.querySpec()
+	_spec.Node.Columns = acq.ctx.Fields
+	if len(acq.ctx.Fields) > 0 {
+		_spec.Unique = acq.ctx.Unique != nil && *acq.ctx.Unique
+	}
+	return sqlgraph.CountNodes(ctx, acq.driver, _spec)
+}
+
+func (acq *ApplicationCommandQuery) querySpec() *sqlgraph.QuerySpec {
+	_spec := sqlgraph.NewQuerySpec(applicationcommand.Table, applicationcommand.Columns, sqlgraph.NewFieldSpec(applicationcommand.FieldID, field.TypeString))
+	_spec.From = acq.sql
+	if unique := acq.ctx.Unique; unique != nil {
+		_spec.Unique = *unique
+	} else if acq.path != nil {
+		_spec.Unique = true
+	}
+	if fields := acq.ctx.Fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, applicationcommand.FieldID)
+		for i := range fields {
+			if fields[i] != applicationcommand.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+			}
+		}
+	}
+	if ps := acq.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if limit := acq.ctx.Limit; limit != nil {
+		_spec.Limit = *limit
+	}
+	if offset := acq.ctx.Offset; offset != nil {
+		_spec.Offset = *offset
+	}
+	if ps := acq.order; len(ps) > 0 {
+		_spec.Order = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	return _spec
+}
+
+func (acq *ApplicationCommandQuery) sqlQuery(ctx context.Context) *sql.Selector {
+	builder := sql.Dialect(acq.driver.Dialect())
+	t1 := builder.Table(applicationcommand.Table)
+	columns := acq.ctx.Fields
+	if len(columns) == 0 {
+		columns = applicationcommand.Columns
+	}
+	selector := builder.Select(t1.Columns(columns...)...).From(t1)
+	if acq.sql != nil {
+		selector = acq.sql
+		selector.Select(selector.Columns(columns...)...)
+	}
+	if acq.ctx.Unique != nil && *acq.ctx.Unique {
+		selector.Distinct()
+	}
+	for _, p := range acq.predicates {
+		p(selector)
+	}
+	for _, p := range acq.order {
+		p(selector)
+	}
+	if offset := acq.ctx.Offset; offset != nil {
+		// limit is mandatory for offset clause. We start
+		// with default value, and override it below if needed.
+		selector.Offset(*offset).Limit(math.MaxInt32)
+	}
+	if limit := acq.ctx.Limit; limit != nil {
+		selector.Limit(*limit)
+	}
+	return selector
+}
+
+// ApplicationCommandGroupBy is the group-by builder for ApplicationCommand entities.
+type ApplicationCommandGroupBy struct {
+	selector
+	build *ApplicationCommandQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (acgb *ApplicationCommandGroupBy) Aggregate(fns ...AggregateFunc) *ApplicationCommandGroupBy {
+	acgb.fns = append(acgb.fns, fns...)
+	return acgb
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (acgb *ApplicationCommandGroupBy) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, acgb.build.ctx, "GroupBy")
+	if err := acgb.build.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*ApplicationCommandQuery, *ApplicationCommandGroupBy](ctx, acgb.build, acgb, acgb.build.inters, v)
+}
+
+func (acgb *ApplicationCommandGroupBy) sqlScan(ctx context.Context, root *ApplicationCommandQuery, v any) error {
+	selector := root.sqlQuery(ctx).Select()
+	aggregation := make([]string, 0, len(acgb.fns))
+	for _, fn := range acgb.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*acgb.flds)+len(acgb.fns))
+		for _, f := range *acgb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*acgb.flds...)...)
+	if err := selector.Err(); err != nil {
+		return err
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := acgb.build.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
+
+// ApplicationCommandSelect is the builder for selecting fields of ApplicationCommand entities.
+type ApplicationCommandSelect struct {
+	*ApplicationCommandQuery
+	selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (acs *ApplicationCommandSelect) Aggregate(fns ...AggregateFunc) *ApplicationCommandSelect {
+	acs.fns = append(acs.fns, fns...)
+	return acs
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (acs *ApplicationCommandSelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, acs.ctx, "Select")
+	if err := acs.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*ApplicationCommandQuery, *ApplicationCommandSelect](ctx, acs.ApplicationCommandQuery, acs, acs.inters, v)
+}
+
+func (acs *ApplicationCommandSelect) sqlScan(ctx context.Context, root *ApplicationCommandQuery, v any) error {
+	selector := root.sqlQuery(ctx)
+	aggregation := make([]string, 0, len(acs.fns))
+	for _, fn := range acs.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	switch n := len(*acs.selector.flds); {
+	case n == 0 && len(aggregation) > 0:
+		selector.Select(aggregation...)
+	case n != 0 && len(aggregation) > 0:
+		selector.AppendSelect(aggregation...)
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := acs.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
diff --git a/internal/database/ent/db/applicationcommand_update.go b/internal/database/ent/db/applicationcommand_update.go
new file mode 100644
index 00000000..ebdf0db2
--- /dev/null
+++ b/internal/database/ent/db/applicationcommand_update.go
@@ -0,0 +1,379 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/applicationcommand"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+)
+
+// ApplicationCommandUpdate is the builder for updating ApplicationCommand entities.
+type ApplicationCommandUpdate struct {
+	config
+	hooks    []Hook
+	mutation *ApplicationCommandMutation
+}
+
+// Where appends a list predicates to the ApplicationCommandUpdate builder.
+func (acu *ApplicationCommandUpdate) Where(ps ...predicate.ApplicationCommand) *ApplicationCommandUpdate {
+	acu.mutation.Where(ps...)
+	return acu
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (acu *ApplicationCommandUpdate) SetUpdatedAt(i int) *ApplicationCommandUpdate {
+	acu.mutation.ResetUpdatedAt()
+	acu.mutation.SetUpdatedAt(i)
+	return acu
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (acu *ApplicationCommandUpdate) AddUpdatedAt(i int) *ApplicationCommandUpdate {
+	acu.mutation.AddUpdatedAt(i)
+	return acu
+}
+
+// SetName sets the "name" field.
+func (acu *ApplicationCommandUpdate) SetName(s string) *ApplicationCommandUpdate {
+	acu.mutation.SetName(s)
+	return acu
+}
+
+// SetNillableName sets the "name" field if the given value is not nil.
+func (acu *ApplicationCommandUpdate) SetNillableName(s *string) *ApplicationCommandUpdate {
+	if s != nil {
+		acu.SetName(*s)
+	}
+	return acu
+}
+
+// SetVersion sets the "version" field.
+func (acu *ApplicationCommandUpdate) SetVersion(s string) *ApplicationCommandUpdate {
+	acu.mutation.SetVersion(s)
+	return acu
+}
+
+// SetNillableVersion sets the "version" field if the given value is not nil.
+func (acu *ApplicationCommandUpdate) SetNillableVersion(s *string) *ApplicationCommandUpdate {
+	if s != nil {
+		acu.SetVersion(*s)
+	}
+	return acu
+}
+
+// SetOptionsHash sets the "options_hash" field.
+func (acu *ApplicationCommandUpdate) SetOptionsHash(s string) *ApplicationCommandUpdate {
+	acu.mutation.SetOptionsHash(s)
+	return acu
+}
+
+// SetNillableOptionsHash sets the "options_hash" field if the given value is not nil.
+func (acu *ApplicationCommandUpdate) SetNillableOptionsHash(s *string) *ApplicationCommandUpdate {
+	if s != nil {
+		acu.SetOptionsHash(*s)
+	}
+	return acu
+}
+
+// Mutation returns the ApplicationCommandMutation object of the builder.
+func (acu *ApplicationCommandUpdate) Mutation() *ApplicationCommandMutation {
+	return acu.mutation
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (acu *ApplicationCommandUpdate) Save(ctx context.Context) (int, error) {
+	acu.defaults()
+	return withHooks(ctx, acu.sqlSave, acu.mutation, acu.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (acu *ApplicationCommandUpdate) SaveX(ctx context.Context) int {
+	affected, err := acu.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return affected
+}
+
+// Exec executes the query.
+func (acu *ApplicationCommandUpdate) Exec(ctx context.Context) error {
+	_, err := acu.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (acu *ApplicationCommandUpdate) ExecX(ctx context.Context) {
+	if err := acu.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (acu *ApplicationCommandUpdate) defaults() {
+	if _, ok := acu.mutation.UpdatedAt(); !ok {
+		v := applicationcommand.UpdateDefaultUpdatedAt()
+		acu.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (acu *ApplicationCommandUpdate) check() error {
+	if v, ok := acu.mutation.Name(); ok {
+		if err := applicationcommand.NameValidator(v); err != nil {
+			return &ValidationError{Name: "name", err: fmt.Errorf(`db: validator failed for field "ApplicationCommand.name": %w`, err)}
+		}
+	}
+	if v, ok := acu.mutation.Version(); ok {
+		if err := applicationcommand.VersionValidator(v); err != nil {
+			return &ValidationError{Name: "version", err: fmt.Errorf(`db: validator failed for field "ApplicationCommand.version": %w`, err)}
+		}
+	}
+	if v, ok := acu.mutation.OptionsHash(); ok {
+		if err := applicationcommand.OptionsHashValidator(v); err != nil {
+			return &ValidationError{Name: "options_hash", err: fmt.Errorf(`db: validator failed for field "ApplicationCommand.options_hash": %w`, err)}
+		}
+	}
+	return nil
+}
+
+func (acu *ApplicationCommandUpdate) sqlSave(ctx context.Context) (n int, err error) {
+	if err := acu.check(); err != nil {
+		return n, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(applicationcommand.Table, applicationcommand.Columns, sqlgraph.NewFieldSpec(applicationcommand.FieldID, field.TypeString))
+	if ps := acu.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := acu.mutation.UpdatedAt(); ok {
+		_spec.SetField(applicationcommand.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := acu.mutation.AddedUpdatedAt(); ok {
+		_spec.AddField(applicationcommand.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := acu.mutation.Name(); ok {
+		_spec.SetField(applicationcommand.FieldName, field.TypeString, value)
+	}
+	if value, ok := acu.mutation.Version(); ok {
+		_spec.SetField(applicationcommand.FieldVersion, field.TypeString, value)
+	}
+	if value, ok := acu.mutation.OptionsHash(); ok {
+		_spec.SetField(applicationcommand.FieldOptionsHash, field.TypeString, value)
+	}
+	if n, err = sqlgraph.UpdateNodes(ctx, acu.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{applicationcommand.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return 0, err
+	}
+	acu.mutation.done = true
+	return n, nil
+}
+
+// ApplicationCommandUpdateOne is the builder for updating a single ApplicationCommand entity.
+type ApplicationCommandUpdateOne struct {
+	config
+	fields   []string
+	hooks    []Hook
+	mutation *ApplicationCommandMutation
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (acuo *ApplicationCommandUpdateOne) SetUpdatedAt(i int) *ApplicationCommandUpdateOne {
+	acuo.mutation.ResetUpdatedAt()
+	acuo.mutation.SetUpdatedAt(i)
+	return acuo
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (acuo *ApplicationCommandUpdateOne) AddUpdatedAt(i int) *ApplicationCommandUpdateOne {
+	acuo.mutation.AddUpdatedAt(i)
+	return acuo
+}
+
+// SetName sets the "name" field.
+func (acuo *ApplicationCommandUpdateOne) SetName(s string) *ApplicationCommandUpdateOne {
+	acuo.mutation.SetName(s)
+	return acuo
+}
+
+// SetNillableName sets the "name" field if the given value is not nil.
+func (acuo *ApplicationCommandUpdateOne) SetNillableName(s *string) *ApplicationCommandUpdateOne {
+	if s != nil {
+		acuo.SetName(*s)
+	}
+	return acuo
+}
+
+// SetVersion sets the "version" field.
+func (acuo *ApplicationCommandUpdateOne) SetVersion(s string) *ApplicationCommandUpdateOne {
+	acuo.mutation.SetVersion(s)
+	return acuo
+}
+
+// SetNillableVersion sets the "version" field if the given value is not nil.
+func (acuo *ApplicationCommandUpdateOne) SetNillableVersion(s *string) *ApplicationCommandUpdateOne {
+	if s != nil {
+		acuo.SetVersion(*s)
+	}
+	return acuo
+}
+
+// SetOptionsHash sets the "options_hash" field.
+func (acuo *ApplicationCommandUpdateOne) SetOptionsHash(s string) *ApplicationCommandUpdateOne {
+	acuo.mutation.SetOptionsHash(s)
+	return acuo
+}
+
+// SetNillableOptionsHash sets the "options_hash" field if the given value is not nil.
+func (acuo *ApplicationCommandUpdateOne) SetNillableOptionsHash(s *string) *ApplicationCommandUpdateOne {
+	if s != nil {
+		acuo.SetOptionsHash(*s)
+	}
+	return acuo
+}
+
+// Mutation returns the ApplicationCommandMutation object of the builder.
+func (acuo *ApplicationCommandUpdateOne) Mutation() *ApplicationCommandMutation {
+	return acuo.mutation
+}
+
+// Where appends a list predicates to the ApplicationCommandUpdate builder.
+func (acuo *ApplicationCommandUpdateOne) Where(ps ...predicate.ApplicationCommand) *ApplicationCommandUpdateOne {
+	acuo.mutation.Where(ps...)
+	return acuo
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (acuo *ApplicationCommandUpdateOne) Select(field string, fields ...string) *ApplicationCommandUpdateOne {
+	acuo.fields = append([]string{field}, fields...)
+	return acuo
+}
+
+// Save executes the query and returns the updated ApplicationCommand entity.
+func (acuo *ApplicationCommandUpdateOne) Save(ctx context.Context) (*ApplicationCommand, error) {
+	acuo.defaults()
+	return withHooks(ctx, acuo.sqlSave, acuo.mutation, acuo.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (acuo *ApplicationCommandUpdateOne) SaveX(ctx context.Context) *ApplicationCommand {
+	node, err := acuo.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// Exec executes the query on the entity.
+func (acuo *ApplicationCommandUpdateOne) Exec(ctx context.Context) error {
+	_, err := acuo.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (acuo *ApplicationCommandUpdateOne) ExecX(ctx context.Context) {
+	if err := acuo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (acuo *ApplicationCommandUpdateOne) defaults() {
+	if _, ok := acuo.mutation.UpdatedAt(); !ok {
+		v := applicationcommand.UpdateDefaultUpdatedAt()
+		acuo.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (acuo *ApplicationCommandUpdateOne) check() error {
+	if v, ok := acuo.mutation.Name(); ok {
+		if err := applicationcommand.NameValidator(v); err != nil {
+			return &ValidationError{Name: "name", err: fmt.Errorf(`db: validator failed for field "ApplicationCommand.name": %w`, err)}
+		}
+	}
+	if v, ok := acuo.mutation.Version(); ok {
+		if err := applicationcommand.VersionValidator(v); err != nil {
+			return &ValidationError{Name: "version", err: fmt.Errorf(`db: validator failed for field "ApplicationCommand.version": %w`, err)}
+		}
+	}
+	if v, ok := acuo.mutation.OptionsHash(); ok {
+		if err := applicationcommand.OptionsHashValidator(v); err != nil {
+			return &ValidationError{Name: "options_hash", err: fmt.Errorf(`db: validator failed for field "ApplicationCommand.options_hash": %w`, err)}
+		}
+	}
+	return nil
+}
+
+func (acuo *ApplicationCommandUpdateOne) sqlSave(ctx context.Context) (_node *ApplicationCommand, err error) {
+	if err := acuo.check(); err != nil {
+		return _node, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(applicationcommand.Table, applicationcommand.Columns, sqlgraph.NewFieldSpec(applicationcommand.FieldID, field.TypeString))
+	id, ok := acuo.mutation.ID()
+	if !ok {
+		return nil, &ValidationError{Name: "id", err: errors.New(`db: missing "ApplicationCommand.id" for update`)}
+	}
+	_spec.Node.ID.Value = id
+	if fields := acuo.fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, applicationcommand.FieldID)
+		for _, f := range fields {
+			if !applicationcommand.ValidColumn(f) {
+				return nil, &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+			}
+			if f != applicationcommand.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, f)
+			}
+		}
+	}
+	if ps := acuo.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := acuo.mutation.UpdatedAt(); ok {
+		_spec.SetField(applicationcommand.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := acuo.mutation.AddedUpdatedAt(); ok {
+		_spec.AddField(applicationcommand.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := acuo.mutation.Name(); ok {
+		_spec.SetField(applicationcommand.FieldName, field.TypeString, value)
+	}
+	if value, ok := acuo.mutation.Version(); ok {
+		_spec.SetField(applicationcommand.FieldVersion, field.TypeString, value)
+	}
+	if value, ok := acuo.mutation.OptionsHash(); ok {
+		_spec.SetField(applicationcommand.FieldOptionsHash, field.TypeString, value)
+	}
+	_node = &ApplicationCommand{config: acuo.config}
+	_spec.Assign = _node.assignValues
+	_spec.ScanValues = _node.scanValues
+	if err = sqlgraph.UpdateNode(ctx, acuo.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{applicationcommand.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	acuo.mutation.done = true
+	return _node, nil
+}
diff --git a/internal/database/ent/db/clan.go b/internal/database/ent/db/clan.go
new file mode 100644
index 00000000..98645aef
--- /dev/null
+++ b/internal/database/ent/db/clan.go
@@ -0,0 +1,189 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+	"github.com/cufee/aftermath/internal/database/ent/db/clan"
+)
+
+// Clan is the model entity for the Clan schema.
+type Clan struct {
+	config `json:"-"`
+	// ID of the ent.
+	ID string `json:"id,omitempty"`
+	// CreatedAt holds the value of the "created_at" field.
+	CreatedAt int `json:"created_at,omitempty"`
+	// UpdatedAt holds the value of the "updated_at" field.
+	UpdatedAt int `json:"updated_at,omitempty"`
+	// Tag holds the value of the "tag" field.
+	Tag string `json:"tag,omitempty"`
+	// Name holds the value of the "name" field.
+	Name string `json:"name,omitempty"`
+	// EmblemID holds the value of the "emblem_id" field.
+	EmblemID string `json:"emblem_id,omitempty"`
+	// Members holds the value of the "members" field.
+	Members []string `json:"members,omitempty"`
+	// Edges holds the relations/edges for other nodes in the graph.
+	// The values are being populated by the ClanQuery when eager-loading is set.
+	Edges        ClanEdges `json:"edges"`
+	selectValues sql.SelectValues
+}
+
+// ClanEdges holds the relations/edges for other nodes in the graph.
+type ClanEdges struct {
+	// Accounts holds the value of the accounts edge.
+	Accounts []*Account `json:"accounts,omitempty"`
+	// loadedTypes holds the information for reporting if a
+	// type was loaded (or requested) in eager-loading or not.
+	loadedTypes [1]bool
+}
+
+// AccountsOrErr returns the Accounts value or an error if the edge
+// was not loaded in eager-loading.
+func (e ClanEdges) AccountsOrErr() ([]*Account, error) {
+	if e.loadedTypes[0] {
+		return e.Accounts, nil
+	}
+	return nil, &NotLoadedError{edge: "accounts"}
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*Clan) scanValues(columns []string) ([]any, error) {
+	values := make([]any, len(columns))
+	for i := range columns {
+		switch columns[i] {
+		case clan.FieldMembers:
+			values[i] = new([]byte)
+		case clan.FieldCreatedAt, clan.FieldUpdatedAt:
+			values[i] = new(sql.NullInt64)
+		case clan.FieldID, clan.FieldTag, clan.FieldName, clan.FieldEmblemID:
+			values[i] = new(sql.NullString)
+		default:
+			values[i] = new(sql.UnknownType)
+		}
+	}
+	return values, nil
+}
+
+// assignValues assigns the values that were returned from sql.Rows (after scanning)
+// to the Clan fields.
+func (c *Clan) assignValues(columns []string, values []any) error {
+	if m, n := len(values), len(columns); m < n {
+		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
+	}
+	for i := range columns {
+		switch columns[i] {
+		case clan.FieldID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field id", values[i])
+			} else if value.Valid {
+				c.ID = value.String
+			}
+		case clan.FieldCreatedAt:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field created_at", values[i])
+			} else if value.Valid {
+				c.CreatedAt = int(value.Int64)
+			}
+		case clan.FieldUpdatedAt:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
+			} else if value.Valid {
+				c.UpdatedAt = int(value.Int64)
+			}
+		case clan.FieldTag:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field tag", values[i])
+			} else if value.Valid {
+				c.Tag = value.String
+			}
+		case clan.FieldName:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field name", values[i])
+			} else if value.Valid {
+				c.Name = value.String
+			}
+		case clan.FieldEmblemID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field emblem_id", values[i])
+			} else if value.Valid {
+				c.EmblemID = value.String
+			}
+		case clan.FieldMembers:
+			if value, ok := values[i].(*[]byte); !ok {
+				return fmt.Errorf("unexpected type %T for field members", values[i])
+			} else if value != nil && len(*value) > 0 {
+				if err := json.Unmarshal(*value, &c.Members); err != nil {
+					return fmt.Errorf("unmarshal field members: %w", err)
+				}
+			}
+		default:
+			c.selectValues.Set(columns[i], values[i])
+		}
+	}
+	return nil
+}
+
+// Value returns the ent.Value that was dynamically selected and assigned to the Clan.
+// This includes values selected through modifiers, order, etc.
+func (c *Clan) Value(name string) (ent.Value, error) {
+	return c.selectValues.Get(name)
+}
+
+// QueryAccounts queries the "accounts" edge of the Clan entity.
+func (c *Clan) QueryAccounts() *AccountQuery {
+	return NewClanClient(c.config).QueryAccounts(c)
+}
+
+// Update returns a builder for updating this Clan.
+// Note that you need to call Clan.Unwrap() before calling this method if this Clan
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (c *Clan) Update() *ClanUpdateOne {
+	return NewClanClient(c.config).UpdateOne(c)
+}
+
+// Unwrap unwraps the Clan entity that was returned from a transaction after it was closed,
+// so that all future queries will be executed through the driver which created the transaction.
+func (c *Clan) Unwrap() *Clan {
+	_tx, ok := c.config.driver.(*txDriver)
+	if !ok {
+		panic("db: Clan is not a transactional entity")
+	}
+	c.config.driver = _tx.drv
+	return c
+}
+
+// String implements the fmt.Stringer.
+func (c *Clan) String() string {
+	var builder strings.Builder
+	builder.WriteString("Clan(")
+	builder.WriteString(fmt.Sprintf("id=%v, ", c.ID))
+	builder.WriteString("created_at=")
+	builder.WriteString(fmt.Sprintf("%v", c.CreatedAt))
+	builder.WriteString(", ")
+	builder.WriteString("updated_at=")
+	builder.WriteString(fmt.Sprintf("%v", c.UpdatedAt))
+	builder.WriteString(", ")
+	builder.WriteString("tag=")
+	builder.WriteString(c.Tag)
+	builder.WriteString(", ")
+	builder.WriteString("name=")
+	builder.WriteString(c.Name)
+	builder.WriteString(", ")
+	builder.WriteString("emblem_id=")
+	builder.WriteString(c.EmblemID)
+	builder.WriteString(", ")
+	builder.WriteString("members=")
+	builder.WriteString(fmt.Sprintf("%v", c.Members))
+	builder.WriteByte(')')
+	return builder.String()
+}
+
+// Clans is a parsable slice of Clan.
+type Clans []*Clan
diff --git a/internal/database/ent/db/clan/clan.go b/internal/database/ent/db/clan/clan.go
new file mode 100644
index 00000000..df17d622
--- /dev/null
+++ b/internal/database/ent/db/clan/clan.go
@@ -0,0 +1,128 @@
+// Code generated by ent, DO NOT EDIT.
+
+package clan
+
+import (
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+)
+
+const (
+	// Label holds the string label denoting the clan type in the database.
+	Label = "clan"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// FieldTag holds the string denoting the tag field in the database.
+	FieldTag = "tag"
+	// FieldName holds the string denoting the name field in the database.
+	FieldName = "name"
+	// FieldEmblemID holds the string denoting the emblem_id field in the database.
+	FieldEmblemID = "emblem_id"
+	// FieldMembers holds the string denoting the members field in the database.
+	FieldMembers = "members"
+	// EdgeAccounts holds the string denoting the accounts edge name in mutations.
+	EdgeAccounts = "accounts"
+	// Table holds the table name of the clan in the database.
+	Table = "clans"
+	// AccountsTable is the table that holds the accounts relation/edge.
+	AccountsTable = "accounts"
+	// AccountsInverseTable is the table name for the Account entity.
+	// It exists in this package in order to avoid circular dependency with the "account" package.
+	AccountsInverseTable = "accounts"
+	// AccountsColumn is the table column denoting the accounts relation/edge.
+	AccountsColumn = "clan_id"
+)
+
+// Columns holds all SQL columns for clan fields.
+var Columns = []string{
+	FieldID,
+	FieldCreatedAt,
+	FieldUpdatedAt,
+	FieldTag,
+	FieldName,
+	FieldEmblemID,
+	FieldMembers,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() int
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() int
+	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
+	UpdateDefaultUpdatedAt func() int
+	// TagValidator is a validator for the "tag" field. It is called by the builders before save.
+	TagValidator func(string) error
+	// NameValidator is a validator for the "name" field. It is called by the builders before save.
+	NameValidator func(string) error
+	// DefaultEmblemID holds the default value on creation for the "emblem_id" field.
+	DefaultEmblemID string
+)
+
+// OrderOption defines the ordering options for the Clan queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByTag orders the results by the tag field.
+func ByTag(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldTag, opts...).ToFunc()
+}
+
+// ByName orders the results by the name field.
+func ByName(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldName, opts...).ToFunc()
+}
+
+// ByEmblemID orders the results by the emblem_id field.
+func ByEmblemID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldEmblemID, opts...).ToFunc()
+}
+
+// ByAccountsCount orders the results by accounts count.
+func ByAccountsCount(opts ...sql.OrderTermOption) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborsCount(s, newAccountsStep(), opts...)
+	}
+}
+
+// ByAccounts orders the results by accounts terms.
+func ByAccounts(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborTerms(s, newAccountsStep(), append([]sql.OrderTerm{term}, terms...)...)
+	}
+}
+func newAccountsStep() *sqlgraph.Step {
+	return sqlgraph.NewStep(
+		sqlgraph.From(Table, FieldID),
+		sqlgraph.To(AccountsInverseTable, FieldID),
+		sqlgraph.Edge(sqlgraph.O2M, false, AccountsTable, AccountsColumn),
+	)
+}
diff --git a/internal/database/ent/db/clan/where.go b/internal/database/ent/db/clan/where.go
new file mode 100644
index 00000000..c860dc4d
--- /dev/null
+++ b/internal/database/ent/db/clan/where.go
@@ -0,0 +1,412 @@
+// Code generated by ent, DO NOT EDIT.
+
+package clan
+
+import (
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id string) predicate.Clan {
+	return predicate.Clan(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id string) predicate.Clan {
+	return predicate.Clan(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id string) predicate.Clan {
+	return predicate.Clan(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...string) predicate.Clan {
+	return predicate.Clan(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...string) predicate.Clan {
+	return predicate.Clan(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id string) predicate.Clan {
+	return predicate.Clan(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id string) predicate.Clan {
+	return predicate.Clan(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id string) predicate.Clan {
+	return predicate.Clan(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id string) predicate.Clan {
+	return predicate.Clan(sql.FieldLTE(FieldID, id))
+}
+
+// IDEqualFold applies the EqualFold predicate on the ID field.
+func IDEqualFold(id string) predicate.Clan {
+	return predicate.Clan(sql.FieldEqualFold(FieldID, id))
+}
+
+// IDContainsFold applies the ContainsFold predicate on the ID field.
+func IDContainsFold(id string) predicate.Clan {
+	return predicate.Clan(sql.FieldContainsFold(FieldID, id))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v int) predicate.Clan {
+	return predicate.Clan(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v int) predicate.Clan {
+	return predicate.Clan(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// Tag applies equality check predicate on the "tag" field. It's identical to TagEQ.
+func Tag(v string) predicate.Clan {
+	return predicate.Clan(sql.FieldEQ(FieldTag, v))
+}
+
+// Name applies equality check predicate on the "name" field. It's identical to NameEQ.
+func Name(v string) predicate.Clan {
+	return predicate.Clan(sql.FieldEQ(FieldName, v))
+}
+
+// EmblemID applies equality check predicate on the "emblem_id" field. It's identical to EmblemIDEQ.
+func EmblemID(v string) predicate.Clan {
+	return predicate.Clan(sql.FieldEQ(FieldEmblemID, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v int) predicate.Clan {
+	return predicate.Clan(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v int) predicate.Clan {
+	return predicate.Clan(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...int) predicate.Clan {
+	return predicate.Clan(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...int) predicate.Clan {
+	return predicate.Clan(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v int) predicate.Clan {
+	return predicate.Clan(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v int) predicate.Clan {
+	return predicate.Clan(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v int) predicate.Clan {
+	return predicate.Clan(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v int) predicate.Clan {
+	return predicate.Clan(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v int) predicate.Clan {
+	return predicate.Clan(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v int) predicate.Clan {
+	return predicate.Clan(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...int) predicate.Clan {
+	return predicate.Clan(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...int) predicate.Clan {
+	return predicate.Clan(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v int) predicate.Clan {
+	return predicate.Clan(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v int) predicate.Clan {
+	return predicate.Clan(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v int) predicate.Clan {
+	return predicate.Clan(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v int) predicate.Clan {
+	return predicate.Clan(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// TagEQ applies the EQ predicate on the "tag" field.
+func TagEQ(v string) predicate.Clan {
+	return predicate.Clan(sql.FieldEQ(FieldTag, v))
+}
+
+// TagNEQ applies the NEQ predicate on the "tag" field.
+func TagNEQ(v string) predicate.Clan {
+	return predicate.Clan(sql.FieldNEQ(FieldTag, v))
+}
+
+// TagIn applies the In predicate on the "tag" field.
+func TagIn(vs ...string) predicate.Clan {
+	return predicate.Clan(sql.FieldIn(FieldTag, vs...))
+}
+
+// TagNotIn applies the NotIn predicate on the "tag" field.
+func TagNotIn(vs ...string) predicate.Clan {
+	return predicate.Clan(sql.FieldNotIn(FieldTag, vs...))
+}
+
+// TagGT applies the GT predicate on the "tag" field.
+func TagGT(v string) predicate.Clan {
+	return predicate.Clan(sql.FieldGT(FieldTag, v))
+}
+
+// TagGTE applies the GTE predicate on the "tag" field.
+func TagGTE(v string) predicate.Clan {
+	return predicate.Clan(sql.FieldGTE(FieldTag, v))
+}
+
+// TagLT applies the LT predicate on the "tag" field.
+func TagLT(v string) predicate.Clan {
+	return predicate.Clan(sql.FieldLT(FieldTag, v))
+}
+
+// TagLTE applies the LTE predicate on the "tag" field.
+func TagLTE(v string) predicate.Clan {
+	return predicate.Clan(sql.FieldLTE(FieldTag, v))
+}
+
+// TagContains applies the Contains predicate on the "tag" field.
+func TagContains(v string) predicate.Clan {
+	return predicate.Clan(sql.FieldContains(FieldTag, v))
+}
+
+// TagHasPrefix applies the HasPrefix predicate on the "tag" field.
+func TagHasPrefix(v string) predicate.Clan {
+	return predicate.Clan(sql.FieldHasPrefix(FieldTag, v))
+}
+
+// TagHasSuffix applies the HasSuffix predicate on the "tag" field.
+func TagHasSuffix(v string) predicate.Clan {
+	return predicate.Clan(sql.FieldHasSuffix(FieldTag, v))
+}
+
+// TagEqualFold applies the EqualFold predicate on the "tag" field.
+func TagEqualFold(v string) predicate.Clan {
+	return predicate.Clan(sql.FieldEqualFold(FieldTag, v))
+}
+
+// TagContainsFold applies the ContainsFold predicate on the "tag" field.
+func TagContainsFold(v string) predicate.Clan {
+	return predicate.Clan(sql.FieldContainsFold(FieldTag, v))
+}
+
+// NameEQ applies the EQ predicate on the "name" field.
+func NameEQ(v string) predicate.Clan {
+	return predicate.Clan(sql.FieldEQ(FieldName, v))
+}
+
+// NameNEQ applies the NEQ predicate on the "name" field.
+func NameNEQ(v string) predicate.Clan {
+	return predicate.Clan(sql.FieldNEQ(FieldName, v))
+}
+
+// NameIn applies the In predicate on the "name" field.
+func NameIn(vs ...string) predicate.Clan {
+	return predicate.Clan(sql.FieldIn(FieldName, vs...))
+}
+
+// NameNotIn applies the NotIn predicate on the "name" field.
+func NameNotIn(vs ...string) predicate.Clan {
+	return predicate.Clan(sql.FieldNotIn(FieldName, vs...))
+}
+
+// NameGT applies the GT predicate on the "name" field.
+func NameGT(v string) predicate.Clan {
+	return predicate.Clan(sql.FieldGT(FieldName, v))
+}
+
+// NameGTE applies the GTE predicate on the "name" field.
+func NameGTE(v string) predicate.Clan {
+	return predicate.Clan(sql.FieldGTE(FieldName, v))
+}
+
+// NameLT applies the LT predicate on the "name" field.
+func NameLT(v string) predicate.Clan {
+	return predicate.Clan(sql.FieldLT(FieldName, v))
+}
+
+// NameLTE applies the LTE predicate on the "name" field.
+func NameLTE(v string) predicate.Clan {
+	return predicate.Clan(sql.FieldLTE(FieldName, v))
+}
+
+// NameContains applies the Contains predicate on the "name" field.
+func NameContains(v string) predicate.Clan {
+	return predicate.Clan(sql.FieldContains(FieldName, v))
+}
+
+// NameHasPrefix applies the HasPrefix predicate on the "name" field.
+func NameHasPrefix(v string) predicate.Clan {
+	return predicate.Clan(sql.FieldHasPrefix(FieldName, v))
+}
+
+// NameHasSuffix applies the HasSuffix predicate on the "name" field.
+func NameHasSuffix(v string) predicate.Clan {
+	return predicate.Clan(sql.FieldHasSuffix(FieldName, v))
+}
+
+// NameEqualFold applies the EqualFold predicate on the "name" field.
+func NameEqualFold(v string) predicate.Clan {
+	return predicate.Clan(sql.FieldEqualFold(FieldName, v))
+}
+
+// NameContainsFold applies the ContainsFold predicate on the "name" field.
+func NameContainsFold(v string) predicate.Clan {
+	return predicate.Clan(sql.FieldContainsFold(FieldName, v))
+}
+
+// EmblemIDEQ applies the EQ predicate on the "emblem_id" field.
+func EmblemIDEQ(v string) predicate.Clan {
+	return predicate.Clan(sql.FieldEQ(FieldEmblemID, v))
+}
+
+// EmblemIDNEQ applies the NEQ predicate on the "emblem_id" field.
+func EmblemIDNEQ(v string) predicate.Clan {
+	return predicate.Clan(sql.FieldNEQ(FieldEmblemID, v))
+}
+
+// EmblemIDIn applies the In predicate on the "emblem_id" field.
+func EmblemIDIn(vs ...string) predicate.Clan {
+	return predicate.Clan(sql.FieldIn(FieldEmblemID, vs...))
+}
+
+// EmblemIDNotIn applies the NotIn predicate on the "emblem_id" field.
+func EmblemIDNotIn(vs ...string) predicate.Clan {
+	return predicate.Clan(sql.FieldNotIn(FieldEmblemID, vs...))
+}
+
+// EmblemIDGT applies the GT predicate on the "emblem_id" field.
+func EmblemIDGT(v string) predicate.Clan {
+	return predicate.Clan(sql.FieldGT(FieldEmblemID, v))
+}
+
+// EmblemIDGTE applies the GTE predicate on the "emblem_id" field.
+func EmblemIDGTE(v string) predicate.Clan {
+	return predicate.Clan(sql.FieldGTE(FieldEmblemID, v))
+}
+
+// EmblemIDLT applies the LT predicate on the "emblem_id" field.
+func EmblemIDLT(v string) predicate.Clan {
+	return predicate.Clan(sql.FieldLT(FieldEmblemID, v))
+}
+
+// EmblemIDLTE applies the LTE predicate on the "emblem_id" field.
+func EmblemIDLTE(v string) predicate.Clan {
+	return predicate.Clan(sql.FieldLTE(FieldEmblemID, v))
+}
+
+// EmblemIDContains applies the Contains predicate on the "emblem_id" field.
+func EmblemIDContains(v string) predicate.Clan {
+	return predicate.Clan(sql.FieldContains(FieldEmblemID, v))
+}
+
+// EmblemIDHasPrefix applies the HasPrefix predicate on the "emblem_id" field.
+func EmblemIDHasPrefix(v string) predicate.Clan {
+	return predicate.Clan(sql.FieldHasPrefix(FieldEmblemID, v))
+}
+
+// EmblemIDHasSuffix applies the HasSuffix predicate on the "emblem_id" field.
+func EmblemIDHasSuffix(v string) predicate.Clan {
+	return predicate.Clan(sql.FieldHasSuffix(FieldEmblemID, v))
+}
+
+// EmblemIDIsNil applies the IsNil predicate on the "emblem_id" field.
+func EmblemIDIsNil() predicate.Clan {
+	return predicate.Clan(sql.FieldIsNull(FieldEmblemID))
+}
+
+// EmblemIDNotNil applies the NotNil predicate on the "emblem_id" field.
+func EmblemIDNotNil() predicate.Clan {
+	return predicate.Clan(sql.FieldNotNull(FieldEmblemID))
+}
+
+// EmblemIDEqualFold applies the EqualFold predicate on the "emblem_id" field.
+func EmblemIDEqualFold(v string) predicate.Clan {
+	return predicate.Clan(sql.FieldEqualFold(FieldEmblemID, v))
+}
+
+// EmblemIDContainsFold applies the ContainsFold predicate on the "emblem_id" field.
+func EmblemIDContainsFold(v string) predicate.Clan {
+	return predicate.Clan(sql.FieldContainsFold(FieldEmblemID, v))
+}
+
+// HasAccounts applies the HasEdge predicate on the "accounts" edge.
+func HasAccounts() predicate.Clan {
+	return predicate.Clan(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, AccountsTable, AccountsColumn),
+		)
+		sqlgraph.HasNeighbors(s, step)
+	})
+}
+
+// HasAccountsWith applies the HasEdge predicate on the "accounts" edge with a given conditions (other predicates).
+func HasAccountsWith(preds ...predicate.Account) predicate.Clan {
+	return predicate.Clan(func(s *sql.Selector) {
+		step := newAccountsStep()
+		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+			for _, p := range preds {
+				p(s)
+			}
+		})
+	})
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.Clan) predicate.Clan {
+	return predicate.Clan(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.Clan) predicate.Clan {
+	return predicate.Clan(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.Clan) predicate.Clan {
+	return predicate.Clan(sql.NotPredicates(p))
+}
diff --git a/internal/database/ent/db/clan_create.go b/internal/database/ent/db/clan_create.go
new file mode 100644
index 00000000..fb96c54d
--- /dev/null
+++ b/internal/database/ent/db/clan_create.go
@@ -0,0 +1,340 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/account"
+	"github.com/cufee/aftermath/internal/database/ent/db/clan"
+)
+
+// ClanCreate is the builder for creating a Clan entity.
+type ClanCreate struct {
+	config
+	mutation *ClanMutation
+	hooks    []Hook
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (cc *ClanCreate) SetCreatedAt(i int) *ClanCreate {
+	cc.mutation.SetCreatedAt(i)
+	return cc
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (cc *ClanCreate) SetNillableCreatedAt(i *int) *ClanCreate {
+	if i != nil {
+		cc.SetCreatedAt(*i)
+	}
+	return cc
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (cc *ClanCreate) SetUpdatedAt(i int) *ClanCreate {
+	cc.mutation.SetUpdatedAt(i)
+	return cc
+}
+
+// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
+func (cc *ClanCreate) SetNillableUpdatedAt(i *int) *ClanCreate {
+	if i != nil {
+		cc.SetUpdatedAt(*i)
+	}
+	return cc
+}
+
+// SetTag sets the "tag" field.
+func (cc *ClanCreate) SetTag(s string) *ClanCreate {
+	cc.mutation.SetTag(s)
+	return cc
+}
+
+// SetName sets the "name" field.
+func (cc *ClanCreate) SetName(s string) *ClanCreate {
+	cc.mutation.SetName(s)
+	return cc
+}
+
+// SetEmblemID sets the "emblem_id" field.
+func (cc *ClanCreate) SetEmblemID(s string) *ClanCreate {
+	cc.mutation.SetEmblemID(s)
+	return cc
+}
+
+// SetNillableEmblemID sets the "emblem_id" field if the given value is not nil.
+func (cc *ClanCreate) SetNillableEmblemID(s *string) *ClanCreate {
+	if s != nil {
+		cc.SetEmblemID(*s)
+	}
+	return cc
+}
+
+// SetMembers sets the "members" field.
+func (cc *ClanCreate) SetMembers(s []string) *ClanCreate {
+	cc.mutation.SetMembers(s)
+	return cc
+}
+
+// SetID sets the "id" field.
+func (cc *ClanCreate) SetID(s string) *ClanCreate {
+	cc.mutation.SetID(s)
+	return cc
+}
+
+// AddAccountIDs adds the "accounts" edge to the Account entity by IDs.
+func (cc *ClanCreate) AddAccountIDs(ids ...string) *ClanCreate {
+	cc.mutation.AddAccountIDs(ids...)
+	return cc
+}
+
+// AddAccounts adds the "accounts" edges to the Account entity.
+func (cc *ClanCreate) AddAccounts(a ...*Account) *ClanCreate {
+	ids := make([]string, len(a))
+	for i := range a {
+		ids[i] = a[i].ID
+	}
+	return cc.AddAccountIDs(ids...)
+}
+
+// Mutation returns the ClanMutation object of the builder.
+func (cc *ClanCreate) Mutation() *ClanMutation {
+	return cc.mutation
+}
+
+// Save creates the Clan in the database.
+func (cc *ClanCreate) Save(ctx context.Context) (*Clan, error) {
+	cc.defaults()
+	return withHooks(ctx, cc.sqlSave, cc.mutation, cc.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (cc *ClanCreate) SaveX(ctx context.Context) *Clan {
+	v, err := cc.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (cc *ClanCreate) Exec(ctx context.Context) error {
+	_, err := cc.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (cc *ClanCreate) ExecX(ctx context.Context) {
+	if err := cc.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (cc *ClanCreate) defaults() {
+	if _, ok := cc.mutation.CreatedAt(); !ok {
+		v := clan.DefaultCreatedAt()
+		cc.mutation.SetCreatedAt(v)
+	}
+	if _, ok := cc.mutation.UpdatedAt(); !ok {
+		v := clan.DefaultUpdatedAt()
+		cc.mutation.SetUpdatedAt(v)
+	}
+	if _, ok := cc.mutation.EmblemID(); !ok {
+		v := clan.DefaultEmblemID
+		cc.mutation.SetEmblemID(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (cc *ClanCreate) check() error {
+	if _, ok := cc.mutation.CreatedAt(); !ok {
+		return &ValidationError{Name: "created_at", err: errors.New(`db: missing required field "Clan.created_at"`)}
+	}
+	if _, ok := cc.mutation.UpdatedAt(); !ok {
+		return &ValidationError{Name: "updated_at", err: errors.New(`db: missing required field "Clan.updated_at"`)}
+	}
+	if _, ok := cc.mutation.Tag(); !ok {
+		return &ValidationError{Name: "tag", err: errors.New(`db: missing required field "Clan.tag"`)}
+	}
+	if v, ok := cc.mutation.Tag(); ok {
+		if err := clan.TagValidator(v); err != nil {
+			return &ValidationError{Name: "tag", err: fmt.Errorf(`db: validator failed for field "Clan.tag": %w`, err)}
+		}
+	}
+	if _, ok := cc.mutation.Name(); !ok {
+		return &ValidationError{Name: "name", err: errors.New(`db: missing required field "Clan.name"`)}
+	}
+	if v, ok := cc.mutation.Name(); ok {
+		if err := clan.NameValidator(v); err != nil {
+			return &ValidationError{Name: "name", err: fmt.Errorf(`db: validator failed for field "Clan.name": %w`, err)}
+		}
+	}
+	if _, ok := cc.mutation.Members(); !ok {
+		return &ValidationError{Name: "members", err: errors.New(`db: missing required field "Clan.members"`)}
+	}
+	return nil
+}
+
+func (cc *ClanCreate) sqlSave(ctx context.Context) (*Clan, error) {
+	if err := cc.check(); err != nil {
+		return nil, err
+	}
+	_node, _spec := cc.createSpec()
+	if err := sqlgraph.CreateNode(ctx, cc.driver, _spec); err != nil {
+		if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	if _spec.ID.Value != nil {
+		if id, ok := _spec.ID.Value.(string); ok {
+			_node.ID = id
+		} else {
+			return nil, fmt.Errorf("unexpected Clan.ID type: %T", _spec.ID.Value)
+		}
+	}
+	cc.mutation.id = &_node.ID
+	cc.mutation.done = true
+	return _node, nil
+}
+
+func (cc *ClanCreate) createSpec() (*Clan, *sqlgraph.CreateSpec) {
+	var (
+		_node = &Clan{config: cc.config}
+		_spec = sqlgraph.NewCreateSpec(clan.Table, sqlgraph.NewFieldSpec(clan.FieldID, field.TypeString))
+	)
+	if id, ok := cc.mutation.ID(); ok {
+		_node.ID = id
+		_spec.ID.Value = id
+	}
+	if value, ok := cc.mutation.CreatedAt(); ok {
+		_spec.SetField(clan.FieldCreatedAt, field.TypeInt, value)
+		_node.CreatedAt = value
+	}
+	if value, ok := cc.mutation.UpdatedAt(); ok {
+		_spec.SetField(clan.FieldUpdatedAt, field.TypeInt, value)
+		_node.UpdatedAt = value
+	}
+	if value, ok := cc.mutation.Tag(); ok {
+		_spec.SetField(clan.FieldTag, field.TypeString, value)
+		_node.Tag = value
+	}
+	if value, ok := cc.mutation.Name(); ok {
+		_spec.SetField(clan.FieldName, field.TypeString, value)
+		_node.Name = value
+	}
+	if value, ok := cc.mutation.EmblemID(); ok {
+		_spec.SetField(clan.FieldEmblemID, field.TypeString, value)
+		_node.EmblemID = value
+	}
+	if value, ok := cc.mutation.Members(); ok {
+		_spec.SetField(clan.FieldMembers, field.TypeJSON, value)
+		_node.Members = value
+	}
+	if nodes := cc.mutation.AccountsIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   clan.AccountsTable,
+			Columns: []string{clan.AccountsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(account.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges = append(_spec.Edges, edge)
+	}
+	return _node, _spec
+}
+
+// ClanCreateBulk is the builder for creating many Clan entities in bulk.
+type ClanCreateBulk struct {
+	config
+	err      error
+	builders []*ClanCreate
+}
+
+// Save creates the Clan entities in the database.
+func (ccb *ClanCreateBulk) Save(ctx context.Context) ([]*Clan, error) {
+	if ccb.err != nil {
+		return nil, ccb.err
+	}
+	specs := make([]*sqlgraph.CreateSpec, len(ccb.builders))
+	nodes := make([]*Clan, len(ccb.builders))
+	mutators := make([]Mutator, len(ccb.builders))
+	for i := range ccb.builders {
+		func(i int, root context.Context) {
+			builder := ccb.builders[i]
+			builder.defaults()
+			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+				mutation, ok := m.(*ClanMutation)
+				if !ok {
+					return nil, fmt.Errorf("unexpected mutation type %T", m)
+				}
+				if err := builder.check(); err != nil {
+					return nil, err
+				}
+				builder.mutation = mutation
+				var err error
+				nodes[i], specs[i] = builder.createSpec()
+				if i < len(mutators)-1 {
+					_, err = mutators[i+1].Mutate(root, ccb.builders[i+1].mutation)
+				} else {
+					spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
+					// Invoke the actual operation on the latest mutation in the chain.
+					if err = sqlgraph.BatchCreate(ctx, ccb.driver, spec); err != nil {
+						if sqlgraph.IsConstraintError(err) {
+							err = &ConstraintError{msg: err.Error(), wrap: err}
+						}
+					}
+				}
+				if err != nil {
+					return nil, err
+				}
+				mutation.id = &nodes[i].ID
+				mutation.done = true
+				return nodes[i], nil
+			})
+			for i := len(builder.hooks) - 1; i >= 0; i-- {
+				mut = builder.hooks[i](mut)
+			}
+			mutators[i] = mut
+		}(i, ctx)
+	}
+	if len(mutators) > 0 {
+		if _, err := mutators[0].Mutate(ctx, ccb.builders[0].mutation); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (ccb *ClanCreateBulk) SaveX(ctx context.Context) []*Clan {
+	v, err := ccb.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (ccb *ClanCreateBulk) Exec(ctx context.Context) error {
+	_, err := ccb.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (ccb *ClanCreateBulk) ExecX(ctx context.Context) {
+	if err := ccb.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/database/ent/db/clan_delete.go b/internal/database/ent/db/clan_delete.go
new file mode 100644
index 00000000..23f8393b
--- /dev/null
+++ b/internal/database/ent/db/clan_delete.go
@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/clan"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+)
+
+// ClanDelete is the builder for deleting a Clan entity.
+type ClanDelete struct {
+	config
+	hooks    []Hook
+	mutation *ClanMutation
+}
+
+// Where appends a list predicates to the ClanDelete builder.
+func (cd *ClanDelete) Where(ps ...predicate.Clan) *ClanDelete {
+	cd.mutation.Where(ps...)
+	return cd
+}
+
+// Exec executes the deletion query and returns how many vertices were deleted.
+func (cd *ClanDelete) Exec(ctx context.Context) (int, error) {
+	return withHooks(ctx, cd.sqlExec, cd.mutation, cd.hooks)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (cd *ClanDelete) ExecX(ctx context.Context) int {
+	n, err := cd.Exec(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return n
+}
+
+func (cd *ClanDelete) sqlExec(ctx context.Context) (int, error) {
+	_spec := sqlgraph.NewDeleteSpec(clan.Table, sqlgraph.NewFieldSpec(clan.FieldID, field.TypeString))
+	if ps := cd.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	affected, err := sqlgraph.DeleteNodes(ctx, cd.driver, _spec)
+	if err != nil && sqlgraph.IsConstraintError(err) {
+		err = &ConstraintError{msg: err.Error(), wrap: err}
+	}
+	cd.mutation.done = true
+	return affected, err
+}
+
+// ClanDeleteOne is the builder for deleting a single Clan entity.
+type ClanDeleteOne struct {
+	cd *ClanDelete
+}
+
+// Where appends a list predicates to the ClanDelete builder.
+func (cdo *ClanDeleteOne) Where(ps ...predicate.Clan) *ClanDeleteOne {
+	cdo.cd.mutation.Where(ps...)
+	return cdo
+}
+
+// Exec executes the deletion query.
+func (cdo *ClanDeleteOne) Exec(ctx context.Context) error {
+	n, err := cdo.cd.Exec(ctx)
+	switch {
+	case err != nil:
+		return err
+	case n == 0:
+		return &NotFoundError{clan.Label}
+	default:
+		return nil
+	}
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (cdo *ClanDeleteOne) ExecX(ctx context.Context) {
+	if err := cdo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/database/ent/db/clan_query.go b/internal/database/ent/db/clan_query.go
new file mode 100644
index 00000000..274928c5
--- /dev/null
+++ b/internal/database/ent/db/clan_query.go
@@ -0,0 +1,605 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"database/sql/driver"
+	"fmt"
+	"math"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/account"
+	"github.com/cufee/aftermath/internal/database/ent/db/clan"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+)
+
+// ClanQuery is the builder for querying Clan entities.
+type ClanQuery struct {
+	config
+	ctx          *QueryContext
+	order        []clan.OrderOption
+	inters       []Interceptor
+	predicates   []predicate.Clan
+	withAccounts *AccountQuery
+	// intermediate query (i.e. traversal path).
+	sql  *sql.Selector
+	path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the ClanQuery builder.
+func (cq *ClanQuery) Where(ps ...predicate.Clan) *ClanQuery {
+	cq.predicates = append(cq.predicates, ps...)
+	return cq
+}
+
+// Limit the number of records to be returned by this query.
+func (cq *ClanQuery) Limit(limit int) *ClanQuery {
+	cq.ctx.Limit = &limit
+	return cq
+}
+
+// Offset to start from.
+func (cq *ClanQuery) Offset(offset int) *ClanQuery {
+	cq.ctx.Offset = &offset
+	return cq
+}
+
+// Unique configures the query builder to filter duplicate records on query.
+// By default, unique is set to true, and can be disabled using this method.
+func (cq *ClanQuery) Unique(unique bool) *ClanQuery {
+	cq.ctx.Unique = &unique
+	return cq
+}
+
+// Order specifies how the records should be ordered.
+func (cq *ClanQuery) Order(o ...clan.OrderOption) *ClanQuery {
+	cq.order = append(cq.order, o...)
+	return cq
+}
+
+// QueryAccounts chains the current query on the "accounts" edge.
+func (cq *ClanQuery) QueryAccounts() *AccountQuery {
+	query := (&AccountClient{config: cq.config}).Query()
+	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+		if err := cq.prepareQuery(ctx); err != nil {
+			return nil, err
+		}
+		selector := cq.sqlQuery(ctx)
+		if err := selector.Err(); err != nil {
+			return nil, err
+		}
+		step := sqlgraph.NewStep(
+			sqlgraph.From(clan.Table, clan.FieldID, selector),
+			sqlgraph.To(account.Table, account.FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, clan.AccountsTable, clan.AccountsColumn),
+		)
+		fromU = sqlgraph.SetNeighbors(cq.driver.Dialect(), step)
+		return fromU, nil
+	}
+	return query
+}
+
+// First returns the first Clan entity from the query.
+// Returns a *NotFoundError when no Clan was found.
+func (cq *ClanQuery) First(ctx context.Context) (*Clan, error) {
+	nodes, err := cq.Limit(1).All(setContextOp(ctx, cq.ctx, "First"))
+	if err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nil, &NotFoundError{clan.Label}
+	}
+	return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (cq *ClanQuery) FirstX(ctx context.Context) *Clan {
+	node, err := cq.First(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return node
+}
+
+// FirstID returns the first Clan ID from the query.
+// Returns a *NotFoundError when no Clan ID was found.
+func (cq *ClanQuery) FirstID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = cq.Limit(1).IDs(setContextOp(ctx, cq.ctx, "FirstID")); err != nil {
+		return
+	}
+	if len(ids) == 0 {
+		err = &NotFoundError{clan.Label}
+		return
+	}
+	return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (cq *ClanQuery) FirstIDX(ctx context.Context) string {
+	id, err := cq.FirstID(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return id
+}
+
+// Only returns a single Clan entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one Clan entity is found.
+// Returns a *NotFoundError when no Clan entities are found.
+func (cq *ClanQuery) Only(ctx context.Context) (*Clan, error) {
+	nodes, err := cq.Limit(2).All(setContextOp(ctx, cq.ctx, "Only"))
+	if err != nil {
+		return nil, err
+	}
+	switch len(nodes) {
+	case 1:
+		return nodes[0], nil
+	case 0:
+		return nil, &NotFoundError{clan.Label}
+	default:
+		return nil, &NotSingularError{clan.Label}
+	}
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (cq *ClanQuery) OnlyX(ctx context.Context) *Clan {
+	node, err := cq.Only(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// OnlyID is like Only, but returns the only Clan ID in the query.
+// Returns a *NotSingularError when more than one Clan ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (cq *ClanQuery) OnlyID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = cq.Limit(2).IDs(setContextOp(ctx, cq.ctx, "OnlyID")); err != nil {
+		return
+	}
+	switch len(ids) {
+	case 1:
+		id = ids[0]
+	case 0:
+		err = &NotFoundError{clan.Label}
+	default:
+		err = &NotSingularError{clan.Label}
+	}
+	return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (cq *ClanQuery) OnlyIDX(ctx context.Context) string {
+	id, err := cq.OnlyID(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return id
+}
+
+// All executes the query and returns a list of Clans.
+func (cq *ClanQuery) All(ctx context.Context) ([]*Clan, error) {
+	ctx = setContextOp(ctx, cq.ctx, "All")
+	if err := cq.prepareQuery(ctx); err != nil {
+		return nil, err
+	}
+	qr := querierAll[[]*Clan, *ClanQuery]()
+	return withInterceptors[[]*Clan](ctx, cq, qr, cq.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (cq *ClanQuery) AllX(ctx context.Context) []*Clan {
+	nodes, err := cq.All(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return nodes
+}
+
+// IDs executes the query and returns a list of Clan IDs.
+func (cq *ClanQuery) IDs(ctx context.Context) (ids []string, err error) {
+	if cq.ctx.Unique == nil && cq.path != nil {
+		cq.Unique(true)
+	}
+	ctx = setContextOp(ctx, cq.ctx, "IDs")
+	if err = cq.Select(clan.FieldID).Scan(ctx, &ids); err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (cq *ClanQuery) IDsX(ctx context.Context) []string {
+	ids, err := cq.IDs(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return ids
+}
+
+// Count returns the count of the given query.
+func (cq *ClanQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, cq.ctx, "Count")
+	if err := cq.prepareQuery(ctx); err != nil {
+		return 0, err
+	}
+	return withInterceptors[int](ctx, cq, querierCount[*ClanQuery](), cq.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (cq *ClanQuery) CountX(ctx context.Context) int {
+	count, err := cq.Count(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (cq *ClanQuery) Exist(ctx context.Context) (bool, error) {
+	ctx = setContextOp(ctx, cq.ctx, "Exist")
+	switch _, err := cq.FirstID(ctx); {
+	case IsNotFound(err):
+		return false, nil
+	case err != nil:
+		return false, fmt.Errorf("db: check existence: %w", err)
+	default:
+		return true, nil
+	}
+}
+
+// ExistX is like Exist, but panics if an error occurs.
+func (cq *ClanQuery) ExistX(ctx context.Context) bool {
+	exist, err := cq.Exist(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return exist
+}
+
+// Clone returns a duplicate of the ClanQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (cq *ClanQuery) Clone() *ClanQuery {
+	if cq == nil {
+		return nil
+	}
+	return &ClanQuery{
+		config:       cq.config,
+		ctx:          cq.ctx.Clone(),
+		order:        append([]clan.OrderOption{}, cq.order...),
+		inters:       append([]Interceptor{}, cq.inters...),
+		predicates:   append([]predicate.Clan{}, cq.predicates...),
+		withAccounts: cq.withAccounts.Clone(),
+		// clone intermediate query.
+		sql:  cq.sql.Clone(),
+		path: cq.path,
+	}
+}
+
+// WithAccounts tells the query-builder to eager-load the nodes that are connected to
+// the "accounts" edge. The optional arguments are used to configure the query builder of the edge.
+func (cq *ClanQuery) WithAccounts(opts ...func(*AccountQuery)) *ClanQuery {
+	query := (&AccountClient{config: cq.config}).Query()
+	for _, opt := range opts {
+		opt(query)
+	}
+	cq.withAccounts = query
+	return cq
+}
+
+// GroupBy is used to group vertices by one or more fields/columns.
+// It is often used with aggregate functions, like: count, max, mean, min, sum.
+//
+// Example:
+//
+//	var v []struct {
+//		CreatedAt int `json:"created_at,omitempty"`
+//		Count int `json:"count,omitempty"`
+//	}
+//
+//	client.Clan.Query().
+//		GroupBy(clan.FieldCreatedAt).
+//		Aggregate(db.Count()).
+//		Scan(ctx, &v)
+func (cq *ClanQuery) GroupBy(field string, fields ...string) *ClanGroupBy {
+	cq.ctx.Fields = append([]string{field}, fields...)
+	grbuild := &ClanGroupBy{build: cq}
+	grbuild.flds = &cq.ctx.Fields
+	grbuild.label = clan.Label
+	grbuild.scan = grbuild.Scan
+	return grbuild
+}
+
+// Select allows the selection one or more fields/columns for the given query,
+// instead of selecting all fields in the entity.
+//
+// Example:
+//
+//	var v []struct {
+//		CreatedAt int `json:"created_at,omitempty"`
+//	}
+//
+//	client.Clan.Query().
+//		Select(clan.FieldCreatedAt).
+//		Scan(ctx, &v)
+func (cq *ClanQuery) Select(fields ...string) *ClanSelect {
+	cq.ctx.Fields = append(cq.ctx.Fields, fields...)
+	sbuild := &ClanSelect{ClanQuery: cq}
+	sbuild.label = clan.Label
+	sbuild.flds, sbuild.scan = &cq.ctx.Fields, sbuild.Scan
+	return sbuild
+}
+
+// Aggregate returns a ClanSelect configured with the given aggregations.
+func (cq *ClanQuery) Aggregate(fns ...AggregateFunc) *ClanSelect {
+	return cq.Select().Aggregate(fns...)
+}
+
+func (cq *ClanQuery) prepareQuery(ctx context.Context) error {
+	for _, inter := range cq.inters {
+		if inter == nil {
+			return fmt.Errorf("db: uninitialized interceptor (forgotten import db/runtime?)")
+		}
+		if trv, ok := inter.(Traverser); ok {
+			if err := trv.Traverse(ctx, cq); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range cq.ctx.Fields {
+		if !clan.ValidColumn(f) {
+			return &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+		}
+	}
+	if cq.path != nil {
+		prev, err := cq.path(ctx)
+		if err != nil {
+			return err
+		}
+		cq.sql = prev
+	}
+	return nil
+}
+
+func (cq *ClanQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Clan, error) {
+	var (
+		nodes       = []*Clan{}
+		_spec       = cq.querySpec()
+		loadedTypes = [1]bool{
+			cq.withAccounts != nil,
+		}
+	)
+	_spec.ScanValues = func(columns []string) ([]any, error) {
+		return (*Clan).scanValues(nil, columns)
+	}
+	_spec.Assign = func(columns []string, values []any) error {
+		node := &Clan{config: cq.config}
+		nodes = append(nodes, node)
+		node.Edges.loadedTypes = loadedTypes
+		return node.assignValues(columns, values)
+	}
+	for i := range hooks {
+		hooks[i](ctx, _spec)
+	}
+	if err := sqlgraph.QueryNodes(ctx, cq.driver, _spec); err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nodes, nil
+	}
+	if query := cq.withAccounts; query != nil {
+		if err := cq.loadAccounts(ctx, query, nodes,
+			func(n *Clan) { n.Edges.Accounts = []*Account{} },
+			func(n *Clan, e *Account) { n.Edges.Accounts = append(n.Edges.Accounts, e) }); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+func (cq *ClanQuery) loadAccounts(ctx context.Context, query *AccountQuery, nodes []*Clan, init func(*Clan), assign func(*Clan, *Account)) error {
+	fks := make([]driver.Value, 0, len(nodes))
+	nodeids := make(map[string]*Clan)
+	for i := range nodes {
+		fks = append(fks, nodes[i].ID)
+		nodeids[nodes[i].ID] = nodes[i]
+		if init != nil {
+			init(nodes[i])
+		}
+	}
+	if len(query.ctx.Fields) > 0 {
+		query.ctx.AppendFieldOnce(account.FieldClanID)
+	}
+	query.Where(predicate.Account(func(s *sql.Selector) {
+		s.Where(sql.InValues(s.C(clan.AccountsColumn), fks...))
+	}))
+	neighbors, err := query.All(ctx)
+	if err != nil {
+		return err
+	}
+	for _, n := range neighbors {
+		fk := n.ClanID
+		node, ok := nodeids[fk]
+		if !ok {
+			return fmt.Errorf(`unexpected referenced foreign-key "clan_id" returned %v for node %v`, fk, n.ID)
+		}
+		assign(node, n)
+	}
+	return nil
+}
+
+func (cq *ClanQuery) sqlCount(ctx context.Context) (int, error) {
+	_spec := cq.querySpec()
+	_spec.Node.Columns = cq.ctx.Fields
+	if len(cq.ctx.Fields) > 0 {
+		_spec.Unique = cq.ctx.Unique != nil && *cq.ctx.Unique
+	}
+	return sqlgraph.CountNodes(ctx, cq.driver, _spec)
+}
+
+func (cq *ClanQuery) querySpec() *sqlgraph.QuerySpec {
+	_spec := sqlgraph.NewQuerySpec(clan.Table, clan.Columns, sqlgraph.NewFieldSpec(clan.FieldID, field.TypeString))
+	_spec.From = cq.sql
+	if unique := cq.ctx.Unique; unique != nil {
+		_spec.Unique = *unique
+	} else if cq.path != nil {
+		_spec.Unique = true
+	}
+	if fields := cq.ctx.Fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, clan.FieldID)
+		for i := range fields {
+			if fields[i] != clan.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+			}
+		}
+	}
+	if ps := cq.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if limit := cq.ctx.Limit; limit != nil {
+		_spec.Limit = *limit
+	}
+	if offset := cq.ctx.Offset; offset != nil {
+		_spec.Offset = *offset
+	}
+	if ps := cq.order; len(ps) > 0 {
+		_spec.Order = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	return _spec
+}
+
+func (cq *ClanQuery) sqlQuery(ctx context.Context) *sql.Selector {
+	builder := sql.Dialect(cq.driver.Dialect())
+	t1 := builder.Table(clan.Table)
+	columns := cq.ctx.Fields
+	if len(columns) == 0 {
+		columns = clan.Columns
+	}
+	selector := builder.Select(t1.Columns(columns...)...).From(t1)
+	if cq.sql != nil {
+		selector = cq.sql
+		selector.Select(selector.Columns(columns...)...)
+	}
+	if cq.ctx.Unique != nil && *cq.ctx.Unique {
+		selector.Distinct()
+	}
+	for _, p := range cq.predicates {
+		p(selector)
+	}
+	for _, p := range cq.order {
+		p(selector)
+	}
+	if offset := cq.ctx.Offset; offset != nil {
+		// limit is mandatory for offset clause. We start
+		// with default value, and override it below if needed.
+		selector.Offset(*offset).Limit(math.MaxInt32)
+	}
+	if limit := cq.ctx.Limit; limit != nil {
+		selector.Limit(*limit)
+	}
+	return selector
+}
+
+// ClanGroupBy is the group-by builder for Clan entities.
+type ClanGroupBy struct {
+	selector
+	build *ClanQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (cgb *ClanGroupBy) Aggregate(fns ...AggregateFunc) *ClanGroupBy {
+	cgb.fns = append(cgb.fns, fns...)
+	return cgb
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (cgb *ClanGroupBy) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, cgb.build.ctx, "GroupBy")
+	if err := cgb.build.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*ClanQuery, *ClanGroupBy](ctx, cgb.build, cgb, cgb.build.inters, v)
+}
+
+func (cgb *ClanGroupBy) sqlScan(ctx context.Context, root *ClanQuery, v any) error {
+	selector := root.sqlQuery(ctx).Select()
+	aggregation := make([]string, 0, len(cgb.fns))
+	for _, fn := range cgb.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*cgb.flds)+len(cgb.fns))
+		for _, f := range *cgb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*cgb.flds...)...)
+	if err := selector.Err(); err != nil {
+		return err
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := cgb.build.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
+
+// ClanSelect is the builder for selecting fields of Clan entities.
+type ClanSelect struct {
+	*ClanQuery
+	selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (cs *ClanSelect) Aggregate(fns ...AggregateFunc) *ClanSelect {
+	cs.fns = append(cs.fns, fns...)
+	return cs
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (cs *ClanSelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, cs.ctx, "Select")
+	if err := cs.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*ClanQuery, *ClanSelect](ctx, cs.ClanQuery, cs, cs.inters, v)
+}
+
+func (cs *ClanSelect) sqlScan(ctx context.Context, root *ClanQuery, v any) error {
+	selector := root.sqlQuery(ctx)
+	aggregation := make([]string, 0, len(cs.fns))
+	for _, fn := range cs.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	switch n := len(*cs.selector.flds); {
+	case n == 0 && len(aggregation) > 0:
+		selector.Select(aggregation...)
+	case n != 0 && len(aggregation) > 0:
+		selector.AppendSelect(aggregation...)
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := cs.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
diff --git a/internal/database/ent/db/clan_update.go b/internal/database/ent/db/clan_update.go
new file mode 100644
index 00000000..85b62c7a
--- /dev/null
+++ b/internal/database/ent/db/clan_update.go
@@ -0,0 +1,591 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/dialect/sql/sqljson"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/account"
+	"github.com/cufee/aftermath/internal/database/ent/db/clan"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+)
+
+// ClanUpdate is the builder for updating Clan entities.
+type ClanUpdate struct {
+	config
+	hooks    []Hook
+	mutation *ClanMutation
+}
+
+// Where appends a list predicates to the ClanUpdate builder.
+func (cu *ClanUpdate) Where(ps ...predicate.Clan) *ClanUpdate {
+	cu.mutation.Where(ps...)
+	return cu
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (cu *ClanUpdate) SetUpdatedAt(i int) *ClanUpdate {
+	cu.mutation.ResetUpdatedAt()
+	cu.mutation.SetUpdatedAt(i)
+	return cu
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (cu *ClanUpdate) AddUpdatedAt(i int) *ClanUpdate {
+	cu.mutation.AddUpdatedAt(i)
+	return cu
+}
+
+// SetTag sets the "tag" field.
+func (cu *ClanUpdate) SetTag(s string) *ClanUpdate {
+	cu.mutation.SetTag(s)
+	return cu
+}
+
+// SetNillableTag sets the "tag" field if the given value is not nil.
+func (cu *ClanUpdate) SetNillableTag(s *string) *ClanUpdate {
+	if s != nil {
+		cu.SetTag(*s)
+	}
+	return cu
+}
+
+// SetName sets the "name" field.
+func (cu *ClanUpdate) SetName(s string) *ClanUpdate {
+	cu.mutation.SetName(s)
+	return cu
+}
+
+// SetNillableName sets the "name" field if the given value is not nil.
+func (cu *ClanUpdate) SetNillableName(s *string) *ClanUpdate {
+	if s != nil {
+		cu.SetName(*s)
+	}
+	return cu
+}
+
+// SetEmblemID sets the "emblem_id" field.
+func (cu *ClanUpdate) SetEmblemID(s string) *ClanUpdate {
+	cu.mutation.SetEmblemID(s)
+	return cu
+}
+
+// SetNillableEmblemID sets the "emblem_id" field if the given value is not nil.
+func (cu *ClanUpdate) SetNillableEmblemID(s *string) *ClanUpdate {
+	if s != nil {
+		cu.SetEmblemID(*s)
+	}
+	return cu
+}
+
+// ClearEmblemID clears the value of the "emblem_id" field.
+func (cu *ClanUpdate) ClearEmblemID() *ClanUpdate {
+	cu.mutation.ClearEmblemID()
+	return cu
+}
+
+// SetMembers sets the "members" field.
+func (cu *ClanUpdate) SetMembers(s []string) *ClanUpdate {
+	cu.mutation.SetMembers(s)
+	return cu
+}
+
+// AppendMembers appends s to the "members" field.
+func (cu *ClanUpdate) AppendMembers(s []string) *ClanUpdate {
+	cu.mutation.AppendMembers(s)
+	return cu
+}
+
+// AddAccountIDs adds the "accounts" edge to the Account entity by IDs.
+func (cu *ClanUpdate) AddAccountIDs(ids ...string) *ClanUpdate {
+	cu.mutation.AddAccountIDs(ids...)
+	return cu
+}
+
+// AddAccounts adds the "accounts" edges to the Account entity.
+func (cu *ClanUpdate) AddAccounts(a ...*Account) *ClanUpdate {
+	ids := make([]string, len(a))
+	for i := range a {
+		ids[i] = a[i].ID
+	}
+	return cu.AddAccountIDs(ids...)
+}
+
+// Mutation returns the ClanMutation object of the builder.
+func (cu *ClanUpdate) Mutation() *ClanMutation {
+	return cu.mutation
+}
+
+// ClearAccounts clears all "accounts" edges to the Account entity.
+func (cu *ClanUpdate) ClearAccounts() *ClanUpdate {
+	cu.mutation.ClearAccounts()
+	return cu
+}
+
+// RemoveAccountIDs removes the "accounts" edge to Account entities by IDs.
+func (cu *ClanUpdate) RemoveAccountIDs(ids ...string) *ClanUpdate {
+	cu.mutation.RemoveAccountIDs(ids...)
+	return cu
+}
+
+// RemoveAccounts removes "accounts" edges to Account entities.
+func (cu *ClanUpdate) RemoveAccounts(a ...*Account) *ClanUpdate {
+	ids := make([]string, len(a))
+	for i := range a {
+		ids[i] = a[i].ID
+	}
+	return cu.RemoveAccountIDs(ids...)
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (cu *ClanUpdate) Save(ctx context.Context) (int, error) {
+	cu.defaults()
+	return withHooks(ctx, cu.sqlSave, cu.mutation, cu.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (cu *ClanUpdate) SaveX(ctx context.Context) int {
+	affected, err := cu.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return affected
+}
+
+// Exec executes the query.
+func (cu *ClanUpdate) Exec(ctx context.Context) error {
+	_, err := cu.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (cu *ClanUpdate) ExecX(ctx context.Context) {
+	if err := cu.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (cu *ClanUpdate) defaults() {
+	if _, ok := cu.mutation.UpdatedAt(); !ok {
+		v := clan.UpdateDefaultUpdatedAt()
+		cu.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (cu *ClanUpdate) check() error {
+	if v, ok := cu.mutation.Tag(); ok {
+		if err := clan.TagValidator(v); err != nil {
+			return &ValidationError{Name: "tag", err: fmt.Errorf(`db: validator failed for field "Clan.tag": %w`, err)}
+		}
+	}
+	if v, ok := cu.mutation.Name(); ok {
+		if err := clan.NameValidator(v); err != nil {
+			return &ValidationError{Name: "name", err: fmt.Errorf(`db: validator failed for field "Clan.name": %w`, err)}
+		}
+	}
+	return nil
+}
+
+func (cu *ClanUpdate) sqlSave(ctx context.Context) (n int, err error) {
+	if err := cu.check(); err != nil {
+		return n, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(clan.Table, clan.Columns, sqlgraph.NewFieldSpec(clan.FieldID, field.TypeString))
+	if ps := cu.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := cu.mutation.UpdatedAt(); ok {
+		_spec.SetField(clan.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := cu.mutation.AddedUpdatedAt(); ok {
+		_spec.AddField(clan.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := cu.mutation.Tag(); ok {
+		_spec.SetField(clan.FieldTag, field.TypeString, value)
+	}
+	if value, ok := cu.mutation.Name(); ok {
+		_spec.SetField(clan.FieldName, field.TypeString, value)
+	}
+	if value, ok := cu.mutation.EmblemID(); ok {
+		_spec.SetField(clan.FieldEmblemID, field.TypeString, value)
+	}
+	if cu.mutation.EmblemIDCleared() {
+		_spec.ClearField(clan.FieldEmblemID, field.TypeString)
+	}
+	if value, ok := cu.mutation.Members(); ok {
+		_spec.SetField(clan.FieldMembers, field.TypeJSON, value)
+	}
+	if value, ok := cu.mutation.AppendedMembers(); ok {
+		_spec.AddModifier(func(u *sql.UpdateBuilder) {
+			sqljson.Append(u, clan.FieldMembers, value)
+		})
+	}
+	if cu.mutation.AccountsCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   clan.AccountsTable,
+			Columns: []string{clan.AccountsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(account.FieldID, field.TypeString),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := cu.mutation.RemovedAccountsIDs(); len(nodes) > 0 && !cu.mutation.AccountsCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   clan.AccountsTable,
+			Columns: []string{clan.AccountsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(account.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := cu.mutation.AccountsIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   clan.AccountsTable,
+			Columns: []string{clan.AccountsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(account.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
+	if n, err = sqlgraph.UpdateNodes(ctx, cu.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{clan.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return 0, err
+	}
+	cu.mutation.done = true
+	return n, nil
+}
+
+// ClanUpdateOne is the builder for updating a single Clan entity.
+type ClanUpdateOne struct {
+	config
+	fields   []string
+	hooks    []Hook
+	mutation *ClanMutation
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (cuo *ClanUpdateOne) SetUpdatedAt(i int) *ClanUpdateOne {
+	cuo.mutation.ResetUpdatedAt()
+	cuo.mutation.SetUpdatedAt(i)
+	return cuo
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (cuo *ClanUpdateOne) AddUpdatedAt(i int) *ClanUpdateOne {
+	cuo.mutation.AddUpdatedAt(i)
+	return cuo
+}
+
+// SetTag sets the "tag" field.
+func (cuo *ClanUpdateOne) SetTag(s string) *ClanUpdateOne {
+	cuo.mutation.SetTag(s)
+	return cuo
+}
+
+// SetNillableTag sets the "tag" field if the given value is not nil.
+func (cuo *ClanUpdateOne) SetNillableTag(s *string) *ClanUpdateOne {
+	if s != nil {
+		cuo.SetTag(*s)
+	}
+	return cuo
+}
+
+// SetName sets the "name" field.
+func (cuo *ClanUpdateOne) SetName(s string) *ClanUpdateOne {
+	cuo.mutation.SetName(s)
+	return cuo
+}
+
+// SetNillableName sets the "name" field if the given value is not nil.
+func (cuo *ClanUpdateOne) SetNillableName(s *string) *ClanUpdateOne {
+	if s != nil {
+		cuo.SetName(*s)
+	}
+	return cuo
+}
+
+// SetEmblemID sets the "emblem_id" field.
+func (cuo *ClanUpdateOne) SetEmblemID(s string) *ClanUpdateOne {
+	cuo.mutation.SetEmblemID(s)
+	return cuo
+}
+
+// SetNillableEmblemID sets the "emblem_id" field if the given value is not nil.
+func (cuo *ClanUpdateOne) SetNillableEmblemID(s *string) *ClanUpdateOne {
+	if s != nil {
+		cuo.SetEmblemID(*s)
+	}
+	return cuo
+}
+
+// ClearEmblemID clears the value of the "emblem_id" field.
+func (cuo *ClanUpdateOne) ClearEmblemID() *ClanUpdateOne {
+	cuo.mutation.ClearEmblemID()
+	return cuo
+}
+
+// SetMembers sets the "members" field.
+func (cuo *ClanUpdateOne) SetMembers(s []string) *ClanUpdateOne {
+	cuo.mutation.SetMembers(s)
+	return cuo
+}
+
+// AppendMembers appends s to the "members" field.
+func (cuo *ClanUpdateOne) AppendMembers(s []string) *ClanUpdateOne {
+	cuo.mutation.AppendMembers(s)
+	return cuo
+}
+
+// AddAccountIDs adds the "accounts" edge to the Account entity by IDs.
+func (cuo *ClanUpdateOne) AddAccountIDs(ids ...string) *ClanUpdateOne {
+	cuo.mutation.AddAccountIDs(ids...)
+	return cuo
+}
+
+// AddAccounts adds the "accounts" edges to the Account entity.
+func (cuo *ClanUpdateOne) AddAccounts(a ...*Account) *ClanUpdateOne {
+	ids := make([]string, len(a))
+	for i := range a {
+		ids[i] = a[i].ID
+	}
+	return cuo.AddAccountIDs(ids...)
+}
+
+// Mutation returns the ClanMutation object of the builder.
+func (cuo *ClanUpdateOne) Mutation() *ClanMutation {
+	return cuo.mutation
+}
+
+// ClearAccounts clears all "accounts" edges to the Account entity.
+func (cuo *ClanUpdateOne) ClearAccounts() *ClanUpdateOne {
+	cuo.mutation.ClearAccounts()
+	return cuo
+}
+
+// RemoveAccountIDs removes the "accounts" edge to Account entities by IDs.
+func (cuo *ClanUpdateOne) RemoveAccountIDs(ids ...string) *ClanUpdateOne {
+	cuo.mutation.RemoveAccountIDs(ids...)
+	return cuo
+}
+
+// RemoveAccounts removes "accounts" edges to Account entities.
+func (cuo *ClanUpdateOne) RemoveAccounts(a ...*Account) *ClanUpdateOne {
+	ids := make([]string, len(a))
+	for i := range a {
+		ids[i] = a[i].ID
+	}
+	return cuo.RemoveAccountIDs(ids...)
+}
+
+// Where appends a list predicates to the ClanUpdate builder.
+func (cuo *ClanUpdateOne) Where(ps ...predicate.Clan) *ClanUpdateOne {
+	cuo.mutation.Where(ps...)
+	return cuo
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (cuo *ClanUpdateOne) Select(field string, fields ...string) *ClanUpdateOne {
+	cuo.fields = append([]string{field}, fields...)
+	return cuo
+}
+
+// Save executes the query and returns the updated Clan entity.
+func (cuo *ClanUpdateOne) Save(ctx context.Context) (*Clan, error) {
+	cuo.defaults()
+	return withHooks(ctx, cuo.sqlSave, cuo.mutation, cuo.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (cuo *ClanUpdateOne) SaveX(ctx context.Context) *Clan {
+	node, err := cuo.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// Exec executes the query on the entity.
+func (cuo *ClanUpdateOne) Exec(ctx context.Context) error {
+	_, err := cuo.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (cuo *ClanUpdateOne) ExecX(ctx context.Context) {
+	if err := cuo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (cuo *ClanUpdateOne) defaults() {
+	if _, ok := cuo.mutation.UpdatedAt(); !ok {
+		v := clan.UpdateDefaultUpdatedAt()
+		cuo.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (cuo *ClanUpdateOne) check() error {
+	if v, ok := cuo.mutation.Tag(); ok {
+		if err := clan.TagValidator(v); err != nil {
+			return &ValidationError{Name: "tag", err: fmt.Errorf(`db: validator failed for field "Clan.tag": %w`, err)}
+		}
+	}
+	if v, ok := cuo.mutation.Name(); ok {
+		if err := clan.NameValidator(v); err != nil {
+			return &ValidationError{Name: "name", err: fmt.Errorf(`db: validator failed for field "Clan.name": %w`, err)}
+		}
+	}
+	return nil
+}
+
+func (cuo *ClanUpdateOne) sqlSave(ctx context.Context) (_node *Clan, err error) {
+	if err := cuo.check(); err != nil {
+		return _node, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(clan.Table, clan.Columns, sqlgraph.NewFieldSpec(clan.FieldID, field.TypeString))
+	id, ok := cuo.mutation.ID()
+	if !ok {
+		return nil, &ValidationError{Name: "id", err: errors.New(`db: missing "Clan.id" for update`)}
+	}
+	_spec.Node.ID.Value = id
+	if fields := cuo.fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, clan.FieldID)
+		for _, f := range fields {
+			if !clan.ValidColumn(f) {
+				return nil, &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+			}
+			if f != clan.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, f)
+			}
+		}
+	}
+	if ps := cuo.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := cuo.mutation.UpdatedAt(); ok {
+		_spec.SetField(clan.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := cuo.mutation.AddedUpdatedAt(); ok {
+		_spec.AddField(clan.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := cuo.mutation.Tag(); ok {
+		_spec.SetField(clan.FieldTag, field.TypeString, value)
+	}
+	if value, ok := cuo.mutation.Name(); ok {
+		_spec.SetField(clan.FieldName, field.TypeString, value)
+	}
+	if value, ok := cuo.mutation.EmblemID(); ok {
+		_spec.SetField(clan.FieldEmblemID, field.TypeString, value)
+	}
+	if cuo.mutation.EmblemIDCleared() {
+		_spec.ClearField(clan.FieldEmblemID, field.TypeString)
+	}
+	if value, ok := cuo.mutation.Members(); ok {
+		_spec.SetField(clan.FieldMembers, field.TypeJSON, value)
+	}
+	if value, ok := cuo.mutation.AppendedMembers(); ok {
+		_spec.AddModifier(func(u *sql.UpdateBuilder) {
+			sqljson.Append(u, clan.FieldMembers, value)
+		})
+	}
+	if cuo.mutation.AccountsCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   clan.AccountsTable,
+			Columns: []string{clan.AccountsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(account.FieldID, field.TypeString),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := cuo.mutation.RemovedAccountsIDs(); len(nodes) > 0 && !cuo.mutation.AccountsCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   clan.AccountsTable,
+			Columns: []string{clan.AccountsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(account.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := cuo.mutation.AccountsIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   clan.AccountsTable,
+			Columns: []string{clan.AccountsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(account.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
+	_node = &Clan{config: cuo.config}
+	_spec.Assign = _node.assignValues
+	_spec.ScanValues = _node.scanValues
+	if err = sqlgraph.UpdateNode(ctx, cuo.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{clan.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	cuo.mutation.done = true
+	return _node, nil
+}
diff --git a/internal/database/ent/db/client.go b/internal/database/ent/db/client.go
new file mode 100644
index 00000000..4b53ddbc
--- /dev/null
+++ b/internal/database/ent/db/client.go
@@ -0,0 +1,2416 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log"
+	"reflect"
+
+	"github.com/cufee/aftermath/internal/database/ent/db/migrate"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect"
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"github.com/cufee/aftermath/internal/database/ent/db/account"
+	"github.com/cufee/aftermath/internal/database/ent/db/accountsnapshot"
+	"github.com/cufee/aftermath/internal/database/ent/db/achievementssnapshot"
+	"github.com/cufee/aftermath/internal/database/ent/db/appconfiguration"
+	"github.com/cufee/aftermath/internal/database/ent/db/applicationcommand"
+	"github.com/cufee/aftermath/internal/database/ent/db/clan"
+	"github.com/cufee/aftermath/internal/database/ent/db/crontask"
+	"github.com/cufee/aftermath/internal/database/ent/db/user"
+	"github.com/cufee/aftermath/internal/database/ent/db/userconnection"
+	"github.com/cufee/aftermath/internal/database/ent/db/usercontent"
+	"github.com/cufee/aftermath/internal/database/ent/db/usersubscription"
+	"github.com/cufee/aftermath/internal/database/ent/db/vehicle"
+	"github.com/cufee/aftermath/internal/database/ent/db/vehicleaverage"
+	"github.com/cufee/aftermath/internal/database/ent/db/vehiclesnapshot"
+)
+
+// Client is the client that holds all ent builders.
+type Client struct {
+	config
+	// Schema is the client for creating, migrating and dropping schema.
+	Schema *migrate.Schema
+	// Account is the client for interacting with the Account builders.
+	Account *AccountClient
+	// AccountSnapshot is the client for interacting with the AccountSnapshot builders.
+	AccountSnapshot *AccountSnapshotClient
+	// AchievementsSnapshot is the client for interacting with the AchievementsSnapshot builders.
+	AchievementsSnapshot *AchievementsSnapshotClient
+	// AppConfiguration is the client for interacting with the AppConfiguration builders.
+	AppConfiguration *AppConfigurationClient
+	// ApplicationCommand is the client for interacting with the ApplicationCommand builders.
+	ApplicationCommand *ApplicationCommandClient
+	// Clan is the client for interacting with the Clan builders.
+	Clan *ClanClient
+	// CronTask is the client for interacting with the CronTask builders.
+	CronTask *CronTaskClient
+	// User is the client for interacting with the User builders.
+	User *UserClient
+	// UserConnection is the client for interacting with the UserConnection builders.
+	UserConnection *UserConnectionClient
+	// UserContent is the client for interacting with the UserContent builders.
+	UserContent *UserContentClient
+	// UserSubscription is the client for interacting with the UserSubscription builders.
+	UserSubscription *UserSubscriptionClient
+	// Vehicle is the client for interacting with the Vehicle builders.
+	Vehicle *VehicleClient
+	// VehicleAverage is the client for interacting with the VehicleAverage builders.
+	VehicleAverage *VehicleAverageClient
+	// VehicleSnapshot is the client for interacting with the VehicleSnapshot builders.
+	VehicleSnapshot *VehicleSnapshotClient
+}
+
+// NewClient creates a new client configured with the given options.
+func NewClient(opts ...Option) *Client {
+	client := &Client{config: newConfig(opts...)}
+	client.init()
+	return client
+}
+
+func (c *Client) init() {
+	c.Schema = migrate.NewSchema(c.driver)
+	c.Account = NewAccountClient(c.config)
+	c.AccountSnapshot = NewAccountSnapshotClient(c.config)
+	c.AchievementsSnapshot = NewAchievementsSnapshotClient(c.config)
+	c.AppConfiguration = NewAppConfigurationClient(c.config)
+	c.ApplicationCommand = NewApplicationCommandClient(c.config)
+	c.Clan = NewClanClient(c.config)
+	c.CronTask = NewCronTaskClient(c.config)
+	c.User = NewUserClient(c.config)
+	c.UserConnection = NewUserConnectionClient(c.config)
+	c.UserContent = NewUserContentClient(c.config)
+	c.UserSubscription = NewUserSubscriptionClient(c.config)
+	c.Vehicle = NewVehicleClient(c.config)
+	c.VehicleAverage = NewVehicleAverageClient(c.config)
+	c.VehicleSnapshot = NewVehicleSnapshotClient(c.config)
+}
+
+type (
+	// config is the configuration for the client and its builder.
+	config struct {
+		// driver used for executing database requests.
+		driver dialect.Driver
+		// debug enable a debug logging.
+		debug bool
+		// log used for logging on debug mode.
+		log func(...any)
+		// hooks to execute on mutations.
+		hooks *hooks
+		// interceptors to execute on queries.
+		inters *inters
+	}
+	// Option function to configure the client.
+	Option func(*config)
+)
+
+// newConfig creates a new config for the client.
+func newConfig(opts ...Option) config {
+	cfg := config{log: log.Println, hooks: &hooks{}, inters: &inters{}}
+	cfg.options(opts...)
+	return cfg
+}
+
+// options applies the options on the config object.
+func (c *config) options(opts ...Option) {
+	for _, opt := range opts {
+		opt(c)
+	}
+	if c.debug {
+		c.driver = dialect.Debug(c.driver, c.log)
+	}
+}
+
+// Debug enables debug logging on the ent.Driver.
+func Debug() Option {
+	return func(c *config) {
+		c.debug = true
+	}
+}
+
+// Log sets the logging function for debug mode.
+func Log(fn func(...any)) Option {
+	return func(c *config) {
+		c.log = fn
+	}
+}
+
+// Driver configures the client driver.
+func Driver(driver dialect.Driver) Option {
+	return func(c *config) {
+		c.driver = driver
+	}
+}
+
+// Open opens a database/sql.DB specified by the driver name and
+// the data source name, and returns a new client attached to it.
+// Optional parameters can be added for configuring the client.
+func Open(driverName, dataSourceName string, options ...Option) (*Client, error) {
+	switch driverName {
+	case dialect.MySQL, dialect.Postgres, dialect.SQLite:
+		drv, err := sql.Open(driverName, dataSourceName)
+		if err != nil {
+			return nil, err
+		}
+		return NewClient(append(options, Driver(drv))...), nil
+	default:
+		return nil, fmt.Errorf("unsupported driver: %q", driverName)
+	}
+}
+
+// ErrTxStarted is returned when trying to start a new transaction from a transactional client.
+var ErrTxStarted = errors.New("db: cannot start a transaction within a transaction")
+
+// Tx returns a new transactional client. The provided context
+// is used until the transaction is committed or rolled back.
+func (c *Client) Tx(ctx context.Context) (*Tx, error) {
+	if _, ok := c.driver.(*txDriver); ok {
+		return nil, ErrTxStarted
+	}
+	tx, err := newTx(ctx, c.driver)
+	if err != nil {
+		return nil, fmt.Errorf("db: starting a transaction: %w", err)
+	}
+	cfg := c.config
+	cfg.driver = tx
+	return &Tx{
+		ctx:                  ctx,
+		config:               cfg,
+		Account:              NewAccountClient(cfg),
+		AccountSnapshot:      NewAccountSnapshotClient(cfg),
+		AchievementsSnapshot: NewAchievementsSnapshotClient(cfg),
+		AppConfiguration:     NewAppConfigurationClient(cfg),
+		ApplicationCommand:   NewApplicationCommandClient(cfg),
+		Clan:                 NewClanClient(cfg),
+		CronTask:             NewCronTaskClient(cfg),
+		User:                 NewUserClient(cfg),
+		UserConnection:       NewUserConnectionClient(cfg),
+		UserContent:          NewUserContentClient(cfg),
+		UserSubscription:     NewUserSubscriptionClient(cfg),
+		Vehicle:              NewVehicleClient(cfg),
+		VehicleAverage:       NewVehicleAverageClient(cfg),
+		VehicleSnapshot:      NewVehicleSnapshotClient(cfg),
+	}, nil
+}
+
+// BeginTx returns a transactional client with specified options.
+func (c *Client) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error) {
+	if _, ok := c.driver.(*txDriver); ok {
+		return nil, errors.New("ent: cannot start a transaction within a transaction")
+	}
+	tx, err := c.driver.(interface {
+		BeginTx(context.Context, *sql.TxOptions) (dialect.Tx, error)
+	}).BeginTx(ctx, opts)
+	if err != nil {
+		return nil, fmt.Errorf("ent: starting a transaction: %w", err)
+	}
+	cfg := c.config
+	cfg.driver = &txDriver{tx: tx, drv: c.driver}
+	return &Tx{
+		ctx:                  ctx,
+		config:               cfg,
+		Account:              NewAccountClient(cfg),
+		AccountSnapshot:      NewAccountSnapshotClient(cfg),
+		AchievementsSnapshot: NewAchievementsSnapshotClient(cfg),
+		AppConfiguration:     NewAppConfigurationClient(cfg),
+		ApplicationCommand:   NewApplicationCommandClient(cfg),
+		Clan:                 NewClanClient(cfg),
+		CronTask:             NewCronTaskClient(cfg),
+		User:                 NewUserClient(cfg),
+		UserConnection:       NewUserConnectionClient(cfg),
+		UserContent:          NewUserContentClient(cfg),
+		UserSubscription:     NewUserSubscriptionClient(cfg),
+		Vehicle:              NewVehicleClient(cfg),
+		VehicleAverage:       NewVehicleAverageClient(cfg),
+		VehicleSnapshot:      NewVehicleSnapshotClient(cfg),
+	}, nil
+}
+
+// Debug returns a new debug-client. It's used to get verbose logging on specific operations.
+//
+//	client.Debug().
+//		Account.
+//		Query().
+//		Count(ctx)
+func (c *Client) Debug() *Client {
+	if c.debug {
+		return c
+	}
+	cfg := c.config
+	cfg.driver = dialect.Debug(c.driver, c.log)
+	client := &Client{config: cfg}
+	client.init()
+	return client
+}
+
+// Close closes the database connection and prevents new queries from starting.
+func (c *Client) Close() error {
+	return c.driver.Close()
+}
+
+// Use adds the mutation hooks to all the entity clients.
+// In order to add hooks to a specific client, call: `client.Node.Use(...)`.
+func (c *Client) Use(hooks ...Hook) {
+	for _, n := range []interface{ Use(...Hook) }{
+		c.Account, c.AccountSnapshot, c.AchievementsSnapshot, c.AppConfiguration,
+		c.ApplicationCommand, c.Clan, c.CronTask, c.User, c.UserConnection,
+		c.UserContent, c.UserSubscription, c.Vehicle, c.VehicleAverage,
+		c.VehicleSnapshot,
+	} {
+		n.Use(hooks...)
+	}
+}
+
+// Intercept adds the query interceptors to all the entity clients.
+// In order to add interceptors to a specific client, call: `client.Node.Intercept(...)`.
+func (c *Client) Intercept(interceptors ...Interceptor) {
+	for _, n := range []interface{ Intercept(...Interceptor) }{
+		c.Account, c.AccountSnapshot, c.AchievementsSnapshot, c.AppConfiguration,
+		c.ApplicationCommand, c.Clan, c.CronTask, c.User, c.UserConnection,
+		c.UserContent, c.UserSubscription, c.Vehicle, c.VehicleAverage,
+		c.VehicleSnapshot,
+	} {
+		n.Intercept(interceptors...)
+	}
+}
+
+// Mutate implements the ent.Mutator interface.
+func (c *Client) Mutate(ctx context.Context, m Mutation) (Value, error) {
+	switch m := m.(type) {
+	case *AccountMutation:
+		return c.Account.mutate(ctx, m)
+	case *AccountSnapshotMutation:
+		return c.AccountSnapshot.mutate(ctx, m)
+	case *AchievementsSnapshotMutation:
+		return c.AchievementsSnapshot.mutate(ctx, m)
+	case *AppConfigurationMutation:
+		return c.AppConfiguration.mutate(ctx, m)
+	case *ApplicationCommandMutation:
+		return c.ApplicationCommand.mutate(ctx, m)
+	case *ClanMutation:
+		return c.Clan.mutate(ctx, m)
+	case *CronTaskMutation:
+		return c.CronTask.mutate(ctx, m)
+	case *UserMutation:
+		return c.User.mutate(ctx, m)
+	case *UserConnectionMutation:
+		return c.UserConnection.mutate(ctx, m)
+	case *UserContentMutation:
+		return c.UserContent.mutate(ctx, m)
+	case *UserSubscriptionMutation:
+		return c.UserSubscription.mutate(ctx, m)
+	case *VehicleMutation:
+		return c.Vehicle.mutate(ctx, m)
+	case *VehicleAverageMutation:
+		return c.VehicleAverage.mutate(ctx, m)
+	case *VehicleSnapshotMutation:
+		return c.VehicleSnapshot.mutate(ctx, m)
+	default:
+		return nil, fmt.Errorf("db: unknown mutation type %T", m)
+	}
+}
+
+// AccountClient is a client for the Account schema.
+type AccountClient struct {
+	config
+}
+
+// NewAccountClient returns a client for the Account from the given config.
+func NewAccountClient(c config) *AccountClient {
+	return &AccountClient{config: c}
+}
+
+// Use adds a list of mutation hooks to the hooks stack.
+// A call to `Use(f, g, h)` equals to `account.Hooks(f(g(h())))`.
+func (c *AccountClient) Use(hooks ...Hook) {
+	c.hooks.Account = append(c.hooks.Account, hooks...)
+}
+
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `account.Intercept(f(g(h())))`.
+func (c *AccountClient) Intercept(interceptors ...Interceptor) {
+	c.inters.Account = append(c.inters.Account, interceptors...)
+}
+
+// Create returns a builder for creating a Account entity.
+func (c *AccountClient) Create() *AccountCreate {
+	mutation := newAccountMutation(c.config, OpCreate)
+	return &AccountCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// CreateBulk returns a builder for creating a bulk of Account entities.
+func (c *AccountClient) CreateBulk(builders ...*AccountCreate) *AccountCreateBulk {
+	return &AccountCreateBulk{config: c.config, builders: builders}
+}
+
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *AccountClient) MapCreateBulk(slice any, setFunc func(*AccountCreate, int)) *AccountCreateBulk {
+	rv := reflect.ValueOf(slice)
+	if rv.Kind() != reflect.Slice {
+		return &AccountCreateBulk{err: fmt.Errorf("calling to AccountClient.MapCreateBulk with wrong type %T, need slice", slice)}
+	}
+	builders := make([]*AccountCreate, rv.Len())
+	for i := 0; i < rv.Len(); i++ {
+		builders[i] = c.Create()
+		setFunc(builders[i], i)
+	}
+	return &AccountCreateBulk{config: c.config, builders: builders}
+}
+
+// Update returns an update builder for Account.
+func (c *AccountClient) Update() *AccountUpdate {
+	mutation := newAccountMutation(c.config, OpUpdate)
+	return &AccountUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOne returns an update builder for the given entity.
+func (c *AccountClient) UpdateOne(a *Account) *AccountUpdateOne {
+	mutation := newAccountMutation(c.config, OpUpdateOne, withAccount(a))
+	return &AccountUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOneID returns an update builder for the given id.
+func (c *AccountClient) UpdateOneID(id string) *AccountUpdateOne {
+	mutation := newAccountMutation(c.config, OpUpdateOne, withAccountID(id))
+	return &AccountUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// Delete returns a delete builder for Account.
+func (c *AccountClient) Delete() *AccountDelete {
+	mutation := newAccountMutation(c.config, OpDelete)
+	return &AccountDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// DeleteOne returns a builder for deleting the given entity.
+func (c *AccountClient) DeleteOne(a *Account) *AccountDeleteOne {
+	return c.DeleteOneID(a.ID)
+}
+
+// DeleteOneID returns a builder for deleting the given entity by its id.
+func (c *AccountClient) DeleteOneID(id string) *AccountDeleteOne {
+	builder := c.Delete().Where(account.ID(id))
+	builder.mutation.id = &id
+	builder.mutation.op = OpDeleteOne
+	return &AccountDeleteOne{builder}
+}
+
+// Query returns a query builder for Account.
+func (c *AccountClient) Query() *AccountQuery {
+	return &AccountQuery{
+		config: c.config,
+		ctx:    &QueryContext{Type: TypeAccount},
+		inters: c.Interceptors(),
+	}
+}
+
+// Get returns a Account entity by its id.
+func (c *AccountClient) Get(ctx context.Context, id string) (*Account, error) {
+	return c.Query().Where(account.ID(id)).Only(ctx)
+}
+
+// GetX is like Get, but panics if an error occurs.
+func (c *AccountClient) GetX(ctx context.Context, id string) *Account {
+	obj, err := c.Get(ctx, id)
+	if err != nil {
+		panic(err)
+	}
+	return obj
+}
+
+// QueryClan queries the clan edge of a Account.
+func (c *AccountClient) QueryClan(a *Account) *ClanQuery {
+	query := (&ClanClient{config: c.config}).Query()
+	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+		id := a.ID
+		step := sqlgraph.NewStep(
+			sqlgraph.From(account.Table, account.FieldID, id),
+			sqlgraph.To(clan.Table, clan.FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, account.ClanTable, account.ClanColumn),
+		)
+		fromV = sqlgraph.Neighbors(a.driver.Dialect(), step)
+		return fromV, nil
+	}
+	return query
+}
+
+// QuerySnapshots queries the snapshots edge of a Account.
+func (c *AccountClient) QuerySnapshots(a *Account) *AccountSnapshotQuery {
+	query := (&AccountSnapshotClient{config: c.config}).Query()
+	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+		id := a.ID
+		step := sqlgraph.NewStep(
+			sqlgraph.From(account.Table, account.FieldID, id),
+			sqlgraph.To(accountsnapshot.Table, accountsnapshot.FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, account.SnapshotsTable, account.SnapshotsColumn),
+		)
+		fromV = sqlgraph.Neighbors(a.driver.Dialect(), step)
+		return fromV, nil
+	}
+	return query
+}
+
+// QueryVehicleSnapshots queries the vehicle_snapshots edge of a Account.
+func (c *AccountClient) QueryVehicleSnapshots(a *Account) *VehicleSnapshotQuery {
+	query := (&VehicleSnapshotClient{config: c.config}).Query()
+	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+		id := a.ID
+		step := sqlgraph.NewStep(
+			sqlgraph.From(account.Table, account.FieldID, id),
+			sqlgraph.To(vehiclesnapshot.Table, vehiclesnapshot.FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, account.VehicleSnapshotsTable, account.VehicleSnapshotsColumn),
+		)
+		fromV = sqlgraph.Neighbors(a.driver.Dialect(), step)
+		return fromV, nil
+	}
+	return query
+}
+
+// QueryAchievementSnapshots queries the achievement_snapshots edge of a Account.
+func (c *AccountClient) QueryAchievementSnapshots(a *Account) *AchievementsSnapshotQuery {
+	query := (&AchievementsSnapshotClient{config: c.config}).Query()
+	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+		id := a.ID
+		step := sqlgraph.NewStep(
+			sqlgraph.From(account.Table, account.FieldID, id),
+			sqlgraph.To(achievementssnapshot.Table, achievementssnapshot.FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, account.AchievementSnapshotsTable, account.AchievementSnapshotsColumn),
+		)
+		fromV = sqlgraph.Neighbors(a.driver.Dialect(), step)
+		return fromV, nil
+	}
+	return query
+}
+
+// Hooks returns the client hooks.
+func (c *AccountClient) Hooks() []Hook {
+	return c.hooks.Account
+}
+
+// Interceptors returns the client interceptors.
+func (c *AccountClient) Interceptors() []Interceptor {
+	return c.inters.Account
+}
+
+func (c *AccountClient) mutate(ctx context.Context, m *AccountMutation) (Value, error) {
+	switch m.Op() {
+	case OpCreate:
+		return (&AccountCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdate:
+		return (&AccountUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdateOne:
+		return (&AccountUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpDelete, OpDeleteOne:
+		return (&AccountDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+	default:
+		return nil, fmt.Errorf("db: unknown Account mutation op: %q", m.Op())
+	}
+}
+
+// AccountSnapshotClient is a client for the AccountSnapshot schema.
+type AccountSnapshotClient struct {
+	config
+}
+
+// NewAccountSnapshotClient returns a client for the AccountSnapshot from the given config.
+func NewAccountSnapshotClient(c config) *AccountSnapshotClient {
+	return &AccountSnapshotClient{config: c}
+}
+
+// Use adds a list of mutation hooks to the hooks stack.
+// A call to `Use(f, g, h)` equals to `accountsnapshot.Hooks(f(g(h())))`.
+func (c *AccountSnapshotClient) Use(hooks ...Hook) {
+	c.hooks.AccountSnapshot = append(c.hooks.AccountSnapshot, hooks...)
+}
+
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `accountsnapshot.Intercept(f(g(h())))`.
+func (c *AccountSnapshotClient) Intercept(interceptors ...Interceptor) {
+	c.inters.AccountSnapshot = append(c.inters.AccountSnapshot, interceptors...)
+}
+
+// Create returns a builder for creating a AccountSnapshot entity.
+func (c *AccountSnapshotClient) Create() *AccountSnapshotCreate {
+	mutation := newAccountSnapshotMutation(c.config, OpCreate)
+	return &AccountSnapshotCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// CreateBulk returns a builder for creating a bulk of AccountSnapshot entities.
+func (c *AccountSnapshotClient) CreateBulk(builders ...*AccountSnapshotCreate) *AccountSnapshotCreateBulk {
+	return &AccountSnapshotCreateBulk{config: c.config, builders: builders}
+}
+
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *AccountSnapshotClient) MapCreateBulk(slice any, setFunc func(*AccountSnapshotCreate, int)) *AccountSnapshotCreateBulk {
+	rv := reflect.ValueOf(slice)
+	if rv.Kind() != reflect.Slice {
+		return &AccountSnapshotCreateBulk{err: fmt.Errorf("calling to AccountSnapshotClient.MapCreateBulk with wrong type %T, need slice", slice)}
+	}
+	builders := make([]*AccountSnapshotCreate, rv.Len())
+	for i := 0; i < rv.Len(); i++ {
+		builders[i] = c.Create()
+		setFunc(builders[i], i)
+	}
+	return &AccountSnapshotCreateBulk{config: c.config, builders: builders}
+}
+
+// Update returns an update builder for AccountSnapshot.
+func (c *AccountSnapshotClient) Update() *AccountSnapshotUpdate {
+	mutation := newAccountSnapshotMutation(c.config, OpUpdate)
+	return &AccountSnapshotUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOne returns an update builder for the given entity.
+func (c *AccountSnapshotClient) UpdateOne(as *AccountSnapshot) *AccountSnapshotUpdateOne {
+	mutation := newAccountSnapshotMutation(c.config, OpUpdateOne, withAccountSnapshot(as))
+	return &AccountSnapshotUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOneID returns an update builder for the given id.
+func (c *AccountSnapshotClient) UpdateOneID(id string) *AccountSnapshotUpdateOne {
+	mutation := newAccountSnapshotMutation(c.config, OpUpdateOne, withAccountSnapshotID(id))
+	return &AccountSnapshotUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// Delete returns a delete builder for AccountSnapshot.
+func (c *AccountSnapshotClient) Delete() *AccountSnapshotDelete {
+	mutation := newAccountSnapshotMutation(c.config, OpDelete)
+	return &AccountSnapshotDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// DeleteOne returns a builder for deleting the given entity.
+func (c *AccountSnapshotClient) DeleteOne(as *AccountSnapshot) *AccountSnapshotDeleteOne {
+	return c.DeleteOneID(as.ID)
+}
+
+// DeleteOneID returns a builder for deleting the given entity by its id.
+func (c *AccountSnapshotClient) DeleteOneID(id string) *AccountSnapshotDeleteOne {
+	builder := c.Delete().Where(accountsnapshot.ID(id))
+	builder.mutation.id = &id
+	builder.mutation.op = OpDeleteOne
+	return &AccountSnapshotDeleteOne{builder}
+}
+
+// Query returns a query builder for AccountSnapshot.
+func (c *AccountSnapshotClient) Query() *AccountSnapshotQuery {
+	return &AccountSnapshotQuery{
+		config: c.config,
+		ctx:    &QueryContext{Type: TypeAccountSnapshot},
+		inters: c.Interceptors(),
+	}
+}
+
+// Get returns a AccountSnapshot entity by its id.
+func (c *AccountSnapshotClient) Get(ctx context.Context, id string) (*AccountSnapshot, error) {
+	return c.Query().Where(accountsnapshot.ID(id)).Only(ctx)
+}
+
+// GetX is like Get, but panics if an error occurs.
+func (c *AccountSnapshotClient) GetX(ctx context.Context, id string) *AccountSnapshot {
+	obj, err := c.Get(ctx, id)
+	if err != nil {
+		panic(err)
+	}
+	return obj
+}
+
+// QueryAccount queries the account edge of a AccountSnapshot.
+func (c *AccountSnapshotClient) QueryAccount(as *AccountSnapshot) *AccountQuery {
+	query := (&AccountClient{config: c.config}).Query()
+	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+		id := as.ID
+		step := sqlgraph.NewStep(
+			sqlgraph.From(accountsnapshot.Table, accountsnapshot.FieldID, id),
+			sqlgraph.To(account.Table, account.FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, accountsnapshot.AccountTable, accountsnapshot.AccountColumn),
+		)
+		fromV = sqlgraph.Neighbors(as.driver.Dialect(), step)
+		return fromV, nil
+	}
+	return query
+}
+
+// Hooks returns the client hooks.
+func (c *AccountSnapshotClient) Hooks() []Hook {
+	return c.hooks.AccountSnapshot
+}
+
+// Interceptors returns the client interceptors.
+func (c *AccountSnapshotClient) Interceptors() []Interceptor {
+	return c.inters.AccountSnapshot
+}
+
+func (c *AccountSnapshotClient) mutate(ctx context.Context, m *AccountSnapshotMutation) (Value, error) {
+	switch m.Op() {
+	case OpCreate:
+		return (&AccountSnapshotCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdate:
+		return (&AccountSnapshotUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdateOne:
+		return (&AccountSnapshotUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpDelete, OpDeleteOne:
+		return (&AccountSnapshotDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+	default:
+		return nil, fmt.Errorf("db: unknown AccountSnapshot mutation op: %q", m.Op())
+	}
+}
+
+// AchievementsSnapshotClient is a client for the AchievementsSnapshot schema.
+type AchievementsSnapshotClient struct {
+	config
+}
+
+// NewAchievementsSnapshotClient returns a client for the AchievementsSnapshot from the given config.
+func NewAchievementsSnapshotClient(c config) *AchievementsSnapshotClient {
+	return &AchievementsSnapshotClient{config: c}
+}
+
+// Use adds a list of mutation hooks to the hooks stack.
+// A call to `Use(f, g, h)` equals to `achievementssnapshot.Hooks(f(g(h())))`.
+func (c *AchievementsSnapshotClient) Use(hooks ...Hook) {
+	c.hooks.AchievementsSnapshot = append(c.hooks.AchievementsSnapshot, hooks...)
+}
+
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `achievementssnapshot.Intercept(f(g(h())))`.
+func (c *AchievementsSnapshotClient) Intercept(interceptors ...Interceptor) {
+	c.inters.AchievementsSnapshot = append(c.inters.AchievementsSnapshot, interceptors...)
+}
+
+// Create returns a builder for creating a AchievementsSnapshot entity.
+func (c *AchievementsSnapshotClient) Create() *AchievementsSnapshotCreate {
+	mutation := newAchievementsSnapshotMutation(c.config, OpCreate)
+	return &AchievementsSnapshotCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// CreateBulk returns a builder for creating a bulk of AchievementsSnapshot entities.
+func (c *AchievementsSnapshotClient) CreateBulk(builders ...*AchievementsSnapshotCreate) *AchievementsSnapshotCreateBulk {
+	return &AchievementsSnapshotCreateBulk{config: c.config, builders: builders}
+}
+
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *AchievementsSnapshotClient) MapCreateBulk(slice any, setFunc func(*AchievementsSnapshotCreate, int)) *AchievementsSnapshotCreateBulk {
+	rv := reflect.ValueOf(slice)
+	if rv.Kind() != reflect.Slice {
+		return &AchievementsSnapshotCreateBulk{err: fmt.Errorf("calling to AchievementsSnapshotClient.MapCreateBulk with wrong type %T, need slice", slice)}
+	}
+	builders := make([]*AchievementsSnapshotCreate, rv.Len())
+	for i := 0; i < rv.Len(); i++ {
+		builders[i] = c.Create()
+		setFunc(builders[i], i)
+	}
+	return &AchievementsSnapshotCreateBulk{config: c.config, builders: builders}
+}
+
+// Update returns an update builder for AchievementsSnapshot.
+func (c *AchievementsSnapshotClient) Update() *AchievementsSnapshotUpdate {
+	mutation := newAchievementsSnapshotMutation(c.config, OpUpdate)
+	return &AchievementsSnapshotUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOne returns an update builder for the given entity.
+func (c *AchievementsSnapshotClient) UpdateOne(as *AchievementsSnapshot) *AchievementsSnapshotUpdateOne {
+	mutation := newAchievementsSnapshotMutation(c.config, OpUpdateOne, withAchievementsSnapshot(as))
+	return &AchievementsSnapshotUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOneID returns an update builder for the given id.
+func (c *AchievementsSnapshotClient) UpdateOneID(id string) *AchievementsSnapshotUpdateOne {
+	mutation := newAchievementsSnapshotMutation(c.config, OpUpdateOne, withAchievementsSnapshotID(id))
+	return &AchievementsSnapshotUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// Delete returns a delete builder for AchievementsSnapshot.
+func (c *AchievementsSnapshotClient) Delete() *AchievementsSnapshotDelete {
+	mutation := newAchievementsSnapshotMutation(c.config, OpDelete)
+	return &AchievementsSnapshotDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// DeleteOne returns a builder for deleting the given entity.
+func (c *AchievementsSnapshotClient) DeleteOne(as *AchievementsSnapshot) *AchievementsSnapshotDeleteOne {
+	return c.DeleteOneID(as.ID)
+}
+
+// DeleteOneID returns a builder for deleting the given entity by its id.
+func (c *AchievementsSnapshotClient) DeleteOneID(id string) *AchievementsSnapshotDeleteOne {
+	builder := c.Delete().Where(achievementssnapshot.ID(id))
+	builder.mutation.id = &id
+	builder.mutation.op = OpDeleteOne
+	return &AchievementsSnapshotDeleteOne{builder}
+}
+
+// Query returns a query builder for AchievementsSnapshot.
+func (c *AchievementsSnapshotClient) Query() *AchievementsSnapshotQuery {
+	return &AchievementsSnapshotQuery{
+		config: c.config,
+		ctx:    &QueryContext{Type: TypeAchievementsSnapshot},
+		inters: c.Interceptors(),
+	}
+}
+
+// Get returns a AchievementsSnapshot entity by its id.
+func (c *AchievementsSnapshotClient) Get(ctx context.Context, id string) (*AchievementsSnapshot, error) {
+	return c.Query().Where(achievementssnapshot.ID(id)).Only(ctx)
+}
+
+// GetX is like Get, but panics if an error occurs.
+func (c *AchievementsSnapshotClient) GetX(ctx context.Context, id string) *AchievementsSnapshot {
+	obj, err := c.Get(ctx, id)
+	if err != nil {
+		panic(err)
+	}
+	return obj
+}
+
+// QueryAccount queries the account edge of a AchievementsSnapshot.
+func (c *AchievementsSnapshotClient) QueryAccount(as *AchievementsSnapshot) *AccountQuery {
+	query := (&AccountClient{config: c.config}).Query()
+	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+		id := as.ID
+		step := sqlgraph.NewStep(
+			sqlgraph.From(achievementssnapshot.Table, achievementssnapshot.FieldID, id),
+			sqlgraph.To(account.Table, account.FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, achievementssnapshot.AccountTable, achievementssnapshot.AccountColumn),
+		)
+		fromV = sqlgraph.Neighbors(as.driver.Dialect(), step)
+		return fromV, nil
+	}
+	return query
+}
+
+// Hooks returns the client hooks.
+func (c *AchievementsSnapshotClient) Hooks() []Hook {
+	return c.hooks.AchievementsSnapshot
+}
+
+// Interceptors returns the client interceptors.
+func (c *AchievementsSnapshotClient) Interceptors() []Interceptor {
+	return c.inters.AchievementsSnapshot
+}
+
+func (c *AchievementsSnapshotClient) mutate(ctx context.Context, m *AchievementsSnapshotMutation) (Value, error) {
+	switch m.Op() {
+	case OpCreate:
+		return (&AchievementsSnapshotCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdate:
+		return (&AchievementsSnapshotUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdateOne:
+		return (&AchievementsSnapshotUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpDelete, OpDeleteOne:
+		return (&AchievementsSnapshotDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+	default:
+		return nil, fmt.Errorf("db: unknown AchievementsSnapshot mutation op: %q", m.Op())
+	}
+}
+
+// AppConfigurationClient is a client for the AppConfiguration schema.
+type AppConfigurationClient struct {
+	config
+}
+
+// NewAppConfigurationClient returns a client for the AppConfiguration from the given config.
+func NewAppConfigurationClient(c config) *AppConfigurationClient {
+	return &AppConfigurationClient{config: c}
+}
+
+// Use adds a list of mutation hooks to the hooks stack.
+// A call to `Use(f, g, h)` equals to `appconfiguration.Hooks(f(g(h())))`.
+func (c *AppConfigurationClient) Use(hooks ...Hook) {
+	c.hooks.AppConfiguration = append(c.hooks.AppConfiguration, hooks...)
+}
+
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `appconfiguration.Intercept(f(g(h())))`.
+func (c *AppConfigurationClient) Intercept(interceptors ...Interceptor) {
+	c.inters.AppConfiguration = append(c.inters.AppConfiguration, interceptors...)
+}
+
+// Create returns a builder for creating a AppConfiguration entity.
+func (c *AppConfigurationClient) Create() *AppConfigurationCreate {
+	mutation := newAppConfigurationMutation(c.config, OpCreate)
+	return &AppConfigurationCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// CreateBulk returns a builder for creating a bulk of AppConfiguration entities.
+func (c *AppConfigurationClient) CreateBulk(builders ...*AppConfigurationCreate) *AppConfigurationCreateBulk {
+	return &AppConfigurationCreateBulk{config: c.config, builders: builders}
+}
+
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *AppConfigurationClient) MapCreateBulk(slice any, setFunc func(*AppConfigurationCreate, int)) *AppConfigurationCreateBulk {
+	rv := reflect.ValueOf(slice)
+	if rv.Kind() != reflect.Slice {
+		return &AppConfigurationCreateBulk{err: fmt.Errorf("calling to AppConfigurationClient.MapCreateBulk with wrong type %T, need slice", slice)}
+	}
+	builders := make([]*AppConfigurationCreate, rv.Len())
+	for i := 0; i < rv.Len(); i++ {
+		builders[i] = c.Create()
+		setFunc(builders[i], i)
+	}
+	return &AppConfigurationCreateBulk{config: c.config, builders: builders}
+}
+
+// Update returns an update builder for AppConfiguration.
+func (c *AppConfigurationClient) Update() *AppConfigurationUpdate {
+	mutation := newAppConfigurationMutation(c.config, OpUpdate)
+	return &AppConfigurationUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOne returns an update builder for the given entity.
+func (c *AppConfigurationClient) UpdateOne(ac *AppConfiguration) *AppConfigurationUpdateOne {
+	mutation := newAppConfigurationMutation(c.config, OpUpdateOne, withAppConfiguration(ac))
+	return &AppConfigurationUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOneID returns an update builder for the given id.
+func (c *AppConfigurationClient) UpdateOneID(id string) *AppConfigurationUpdateOne {
+	mutation := newAppConfigurationMutation(c.config, OpUpdateOne, withAppConfigurationID(id))
+	return &AppConfigurationUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// Delete returns a delete builder for AppConfiguration.
+func (c *AppConfigurationClient) Delete() *AppConfigurationDelete {
+	mutation := newAppConfigurationMutation(c.config, OpDelete)
+	return &AppConfigurationDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// DeleteOne returns a builder for deleting the given entity.
+func (c *AppConfigurationClient) DeleteOne(ac *AppConfiguration) *AppConfigurationDeleteOne {
+	return c.DeleteOneID(ac.ID)
+}
+
+// DeleteOneID returns a builder for deleting the given entity by its id.
+func (c *AppConfigurationClient) DeleteOneID(id string) *AppConfigurationDeleteOne {
+	builder := c.Delete().Where(appconfiguration.ID(id))
+	builder.mutation.id = &id
+	builder.mutation.op = OpDeleteOne
+	return &AppConfigurationDeleteOne{builder}
+}
+
+// Query returns a query builder for AppConfiguration.
+func (c *AppConfigurationClient) Query() *AppConfigurationQuery {
+	return &AppConfigurationQuery{
+		config: c.config,
+		ctx:    &QueryContext{Type: TypeAppConfiguration},
+		inters: c.Interceptors(),
+	}
+}
+
+// Get returns a AppConfiguration entity by its id.
+func (c *AppConfigurationClient) Get(ctx context.Context, id string) (*AppConfiguration, error) {
+	return c.Query().Where(appconfiguration.ID(id)).Only(ctx)
+}
+
+// GetX is like Get, but panics if an error occurs.
+func (c *AppConfigurationClient) GetX(ctx context.Context, id string) *AppConfiguration {
+	obj, err := c.Get(ctx, id)
+	if err != nil {
+		panic(err)
+	}
+	return obj
+}
+
+// Hooks returns the client hooks.
+func (c *AppConfigurationClient) Hooks() []Hook {
+	return c.hooks.AppConfiguration
+}
+
+// Interceptors returns the client interceptors.
+func (c *AppConfigurationClient) Interceptors() []Interceptor {
+	return c.inters.AppConfiguration
+}
+
+func (c *AppConfigurationClient) mutate(ctx context.Context, m *AppConfigurationMutation) (Value, error) {
+	switch m.Op() {
+	case OpCreate:
+		return (&AppConfigurationCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdate:
+		return (&AppConfigurationUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdateOne:
+		return (&AppConfigurationUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpDelete, OpDeleteOne:
+		return (&AppConfigurationDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+	default:
+		return nil, fmt.Errorf("db: unknown AppConfiguration mutation op: %q", m.Op())
+	}
+}
+
+// ApplicationCommandClient is a client for the ApplicationCommand schema.
+type ApplicationCommandClient struct {
+	config
+}
+
+// NewApplicationCommandClient returns a client for the ApplicationCommand from the given config.
+func NewApplicationCommandClient(c config) *ApplicationCommandClient {
+	return &ApplicationCommandClient{config: c}
+}
+
+// Use adds a list of mutation hooks to the hooks stack.
+// A call to `Use(f, g, h)` equals to `applicationcommand.Hooks(f(g(h())))`.
+func (c *ApplicationCommandClient) Use(hooks ...Hook) {
+	c.hooks.ApplicationCommand = append(c.hooks.ApplicationCommand, hooks...)
+}
+
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `applicationcommand.Intercept(f(g(h())))`.
+func (c *ApplicationCommandClient) Intercept(interceptors ...Interceptor) {
+	c.inters.ApplicationCommand = append(c.inters.ApplicationCommand, interceptors...)
+}
+
+// Create returns a builder for creating a ApplicationCommand entity.
+func (c *ApplicationCommandClient) Create() *ApplicationCommandCreate {
+	mutation := newApplicationCommandMutation(c.config, OpCreate)
+	return &ApplicationCommandCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// CreateBulk returns a builder for creating a bulk of ApplicationCommand entities.
+func (c *ApplicationCommandClient) CreateBulk(builders ...*ApplicationCommandCreate) *ApplicationCommandCreateBulk {
+	return &ApplicationCommandCreateBulk{config: c.config, builders: builders}
+}
+
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *ApplicationCommandClient) MapCreateBulk(slice any, setFunc func(*ApplicationCommandCreate, int)) *ApplicationCommandCreateBulk {
+	rv := reflect.ValueOf(slice)
+	if rv.Kind() != reflect.Slice {
+		return &ApplicationCommandCreateBulk{err: fmt.Errorf("calling to ApplicationCommandClient.MapCreateBulk with wrong type %T, need slice", slice)}
+	}
+	builders := make([]*ApplicationCommandCreate, rv.Len())
+	for i := 0; i < rv.Len(); i++ {
+		builders[i] = c.Create()
+		setFunc(builders[i], i)
+	}
+	return &ApplicationCommandCreateBulk{config: c.config, builders: builders}
+}
+
+// Update returns an update builder for ApplicationCommand.
+func (c *ApplicationCommandClient) Update() *ApplicationCommandUpdate {
+	mutation := newApplicationCommandMutation(c.config, OpUpdate)
+	return &ApplicationCommandUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOne returns an update builder for the given entity.
+func (c *ApplicationCommandClient) UpdateOne(ac *ApplicationCommand) *ApplicationCommandUpdateOne {
+	mutation := newApplicationCommandMutation(c.config, OpUpdateOne, withApplicationCommand(ac))
+	return &ApplicationCommandUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOneID returns an update builder for the given id.
+func (c *ApplicationCommandClient) UpdateOneID(id string) *ApplicationCommandUpdateOne {
+	mutation := newApplicationCommandMutation(c.config, OpUpdateOne, withApplicationCommandID(id))
+	return &ApplicationCommandUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// Delete returns a delete builder for ApplicationCommand.
+func (c *ApplicationCommandClient) Delete() *ApplicationCommandDelete {
+	mutation := newApplicationCommandMutation(c.config, OpDelete)
+	return &ApplicationCommandDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// DeleteOne returns a builder for deleting the given entity.
+func (c *ApplicationCommandClient) DeleteOne(ac *ApplicationCommand) *ApplicationCommandDeleteOne {
+	return c.DeleteOneID(ac.ID)
+}
+
+// DeleteOneID returns a builder for deleting the given entity by its id.
+func (c *ApplicationCommandClient) DeleteOneID(id string) *ApplicationCommandDeleteOne {
+	builder := c.Delete().Where(applicationcommand.ID(id))
+	builder.mutation.id = &id
+	builder.mutation.op = OpDeleteOne
+	return &ApplicationCommandDeleteOne{builder}
+}
+
+// Query returns a query builder for ApplicationCommand.
+func (c *ApplicationCommandClient) Query() *ApplicationCommandQuery {
+	return &ApplicationCommandQuery{
+		config: c.config,
+		ctx:    &QueryContext{Type: TypeApplicationCommand},
+		inters: c.Interceptors(),
+	}
+}
+
+// Get returns a ApplicationCommand entity by its id.
+func (c *ApplicationCommandClient) Get(ctx context.Context, id string) (*ApplicationCommand, error) {
+	return c.Query().Where(applicationcommand.ID(id)).Only(ctx)
+}
+
+// GetX is like Get, but panics if an error occurs.
+func (c *ApplicationCommandClient) GetX(ctx context.Context, id string) *ApplicationCommand {
+	obj, err := c.Get(ctx, id)
+	if err != nil {
+		panic(err)
+	}
+	return obj
+}
+
+// Hooks returns the client hooks.
+func (c *ApplicationCommandClient) Hooks() []Hook {
+	return c.hooks.ApplicationCommand
+}
+
+// Interceptors returns the client interceptors.
+func (c *ApplicationCommandClient) Interceptors() []Interceptor {
+	return c.inters.ApplicationCommand
+}
+
+func (c *ApplicationCommandClient) mutate(ctx context.Context, m *ApplicationCommandMutation) (Value, error) {
+	switch m.Op() {
+	case OpCreate:
+		return (&ApplicationCommandCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdate:
+		return (&ApplicationCommandUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdateOne:
+		return (&ApplicationCommandUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpDelete, OpDeleteOne:
+		return (&ApplicationCommandDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+	default:
+		return nil, fmt.Errorf("db: unknown ApplicationCommand mutation op: %q", m.Op())
+	}
+}
+
+// ClanClient is a client for the Clan schema.
+type ClanClient struct {
+	config
+}
+
+// NewClanClient returns a client for the Clan from the given config.
+func NewClanClient(c config) *ClanClient {
+	return &ClanClient{config: c}
+}
+
+// Use adds a list of mutation hooks to the hooks stack.
+// A call to `Use(f, g, h)` equals to `clan.Hooks(f(g(h())))`.
+func (c *ClanClient) Use(hooks ...Hook) {
+	c.hooks.Clan = append(c.hooks.Clan, hooks...)
+}
+
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `clan.Intercept(f(g(h())))`.
+func (c *ClanClient) Intercept(interceptors ...Interceptor) {
+	c.inters.Clan = append(c.inters.Clan, interceptors...)
+}
+
+// Create returns a builder for creating a Clan entity.
+func (c *ClanClient) Create() *ClanCreate {
+	mutation := newClanMutation(c.config, OpCreate)
+	return &ClanCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// CreateBulk returns a builder for creating a bulk of Clan entities.
+func (c *ClanClient) CreateBulk(builders ...*ClanCreate) *ClanCreateBulk {
+	return &ClanCreateBulk{config: c.config, builders: builders}
+}
+
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *ClanClient) MapCreateBulk(slice any, setFunc func(*ClanCreate, int)) *ClanCreateBulk {
+	rv := reflect.ValueOf(slice)
+	if rv.Kind() != reflect.Slice {
+		return &ClanCreateBulk{err: fmt.Errorf("calling to ClanClient.MapCreateBulk with wrong type %T, need slice", slice)}
+	}
+	builders := make([]*ClanCreate, rv.Len())
+	for i := 0; i < rv.Len(); i++ {
+		builders[i] = c.Create()
+		setFunc(builders[i], i)
+	}
+	return &ClanCreateBulk{config: c.config, builders: builders}
+}
+
+// Update returns an update builder for Clan.
+func (c *ClanClient) Update() *ClanUpdate {
+	mutation := newClanMutation(c.config, OpUpdate)
+	return &ClanUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOne returns an update builder for the given entity.
+func (c *ClanClient) UpdateOne(cl *Clan) *ClanUpdateOne {
+	mutation := newClanMutation(c.config, OpUpdateOne, withClan(cl))
+	return &ClanUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOneID returns an update builder for the given id.
+func (c *ClanClient) UpdateOneID(id string) *ClanUpdateOne {
+	mutation := newClanMutation(c.config, OpUpdateOne, withClanID(id))
+	return &ClanUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// Delete returns a delete builder for Clan.
+func (c *ClanClient) Delete() *ClanDelete {
+	mutation := newClanMutation(c.config, OpDelete)
+	return &ClanDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// DeleteOne returns a builder for deleting the given entity.
+func (c *ClanClient) DeleteOne(cl *Clan) *ClanDeleteOne {
+	return c.DeleteOneID(cl.ID)
+}
+
+// DeleteOneID returns a builder for deleting the given entity by its id.
+func (c *ClanClient) DeleteOneID(id string) *ClanDeleteOne {
+	builder := c.Delete().Where(clan.ID(id))
+	builder.mutation.id = &id
+	builder.mutation.op = OpDeleteOne
+	return &ClanDeleteOne{builder}
+}
+
+// Query returns a query builder for Clan.
+func (c *ClanClient) Query() *ClanQuery {
+	return &ClanQuery{
+		config: c.config,
+		ctx:    &QueryContext{Type: TypeClan},
+		inters: c.Interceptors(),
+	}
+}
+
+// Get returns a Clan entity by its id.
+func (c *ClanClient) Get(ctx context.Context, id string) (*Clan, error) {
+	return c.Query().Where(clan.ID(id)).Only(ctx)
+}
+
+// GetX is like Get, but panics if an error occurs.
+func (c *ClanClient) GetX(ctx context.Context, id string) *Clan {
+	obj, err := c.Get(ctx, id)
+	if err != nil {
+		panic(err)
+	}
+	return obj
+}
+
+// QueryAccounts queries the accounts edge of a Clan.
+func (c *ClanClient) QueryAccounts(cl *Clan) *AccountQuery {
+	query := (&AccountClient{config: c.config}).Query()
+	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+		id := cl.ID
+		step := sqlgraph.NewStep(
+			sqlgraph.From(clan.Table, clan.FieldID, id),
+			sqlgraph.To(account.Table, account.FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, clan.AccountsTable, clan.AccountsColumn),
+		)
+		fromV = sqlgraph.Neighbors(cl.driver.Dialect(), step)
+		return fromV, nil
+	}
+	return query
+}
+
+// Hooks returns the client hooks.
+func (c *ClanClient) Hooks() []Hook {
+	return c.hooks.Clan
+}
+
+// Interceptors returns the client interceptors.
+func (c *ClanClient) Interceptors() []Interceptor {
+	return c.inters.Clan
+}
+
+func (c *ClanClient) mutate(ctx context.Context, m *ClanMutation) (Value, error) {
+	switch m.Op() {
+	case OpCreate:
+		return (&ClanCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdate:
+		return (&ClanUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdateOne:
+		return (&ClanUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpDelete, OpDeleteOne:
+		return (&ClanDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+	default:
+		return nil, fmt.Errorf("db: unknown Clan mutation op: %q", m.Op())
+	}
+}
+
+// CronTaskClient is a client for the CronTask schema.
+type CronTaskClient struct {
+	config
+}
+
+// NewCronTaskClient returns a client for the CronTask from the given config.
+func NewCronTaskClient(c config) *CronTaskClient {
+	return &CronTaskClient{config: c}
+}
+
+// Use adds a list of mutation hooks to the hooks stack.
+// A call to `Use(f, g, h)` equals to `crontask.Hooks(f(g(h())))`.
+func (c *CronTaskClient) Use(hooks ...Hook) {
+	c.hooks.CronTask = append(c.hooks.CronTask, hooks...)
+}
+
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `crontask.Intercept(f(g(h())))`.
+func (c *CronTaskClient) Intercept(interceptors ...Interceptor) {
+	c.inters.CronTask = append(c.inters.CronTask, interceptors...)
+}
+
+// Create returns a builder for creating a CronTask entity.
+func (c *CronTaskClient) Create() *CronTaskCreate {
+	mutation := newCronTaskMutation(c.config, OpCreate)
+	return &CronTaskCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// CreateBulk returns a builder for creating a bulk of CronTask entities.
+func (c *CronTaskClient) CreateBulk(builders ...*CronTaskCreate) *CronTaskCreateBulk {
+	return &CronTaskCreateBulk{config: c.config, builders: builders}
+}
+
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *CronTaskClient) MapCreateBulk(slice any, setFunc func(*CronTaskCreate, int)) *CronTaskCreateBulk {
+	rv := reflect.ValueOf(slice)
+	if rv.Kind() != reflect.Slice {
+		return &CronTaskCreateBulk{err: fmt.Errorf("calling to CronTaskClient.MapCreateBulk with wrong type %T, need slice", slice)}
+	}
+	builders := make([]*CronTaskCreate, rv.Len())
+	for i := 0; i < rv.Len(); i++ {
+		builders[i] = c.Create()
+		setFunc(builders[i], i)
+	}
+	return &CronTaskCreateBulk{config: c.config, builders: builders}
+}
+
+// Update returns an update builder for CronTask.
+func (c *CronTaskClient) Update() *CronTaskUpdate {
+	mutation := newCronTaskMutation(c.config, OpUpdate)
+	return &CronTaskUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOne returns an update builder for the given entity.
+func (c *CronTaskClient) UpdateOne(ct *CronTask) *CronTaskUpdateOne {
+	mutation := newCronTaskMutation(c.config, OpUpdateOne, withCronTask(ct))
+	return &CronTaskUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOneID returns an update builder for the given id.
+func (c *CronTaskClient) UpdateOneID(id string) *CronTaskUpdateOne {
+	mutation := newCronTaskMutation(c.config, OpUpdateOne, withCronTaskID(id))
+	return &CronTaskUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// Delete returns a delete builder for CronTask.
+func (c *CronTaskClient) Delete() *CronTaskDelete {
+	mutation := newCronTaskMutation(c.config, OpDelete)
+	return &CronTaskDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// DeleteOne returns a builder for deleting the given entity.
+func (c *CronTaskClient) DeleteOne(ct *CronTask) *CronTaskDeleteOne {
+	return c.DeleteOneID(ct.ID)
+}
+
+// DeleteOneID returns a builder for deleting the given entity by its id.
+func (c *CronTaskClient) DeleteOneID(id string) *CronTaskDeleteOne {
+	builder := c.Delete().Where(crontask.ID(id))
+	builder.mutation.id = &id
+	builder.mutation.op = OpDeleteOne
+	return &CronTaskDeleteOne{builder}
+}
+
+// Query returns a query builder for CronTask.
+func (c *CronTaskClient) Query() *CronTaskQuery {
+	return &CronTaskQuery{
+		config: c.config,
+		ctx:    &QueryContext{Type: TypeCronTask},
+		inters: c.Interceptors(),
+	}
+}
+
+// Get returns a CronTask entity by its id.
+func (c *CronTaskClient) Get(ctx context.Context, id string) (*CronTask, error) {
+	return c.Query().Where(crontask.ID(id)).Only(ctx)
+}
+
+// GetX is like Get, but panics if an error occurs.
+func (c *CronTaskClient) GetX(ctx context.Context, id string) *CronTask {
+	obj, err := c.Get(ctx, id)
+	if err != nil {
+		panic(err)
+	}
+	return obj
+}
+
+// Hooks returns the client hooks.
+func (c *CronTaskClient) Hooks() []Hook {
+	return c.hooks.CronTask
+}
+
+// Interceptors returns the client interceptors.
+func (c *CronTaskClient) Interceptors() []Interceptor {
+	return c.inters.CronTask
+}
+
+func (c *CronTaskClient) mutate(ctx context.Context, m *CronTaskMutation) (Value, error) {
+	switch m.Op() {
+	case OpCreate:
+		return (&CronTaskCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdate:
+		return (&CronTaskUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdateOne:
+		return (&CronTaskUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpDelete, OpDeleteOne:
+		return (&CronTaskDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+	default:
+		return nil, fmt.Errorf("db: unknown CronTask mutation op: %q", m.Op())
+	}
+}
+
+// UserClient is a client for the User schema.
+type UserClient struct {
+	config
+}
+
+// NewUserClient returns a client for the User from the given config.
+func NewUserClient(c config) *UserClient {
+	return &UserClient{config: c}
+}
+
+// Use adds a list of mutation hooks to the hooks stack.
+// A call to `Use(f, g, h)` equals to `user.Hooks(f(g(h())))`.
+func (c *UserClient) Use(hooks ...Hook) {
+	c.hooks.User = append(c.hooks.User, hooks...)
+}
+
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `user.Intercept(f(g(h())))`.
+func (c *UserClient) Intercept(interceptors ...Interceptor) {
+	c.inters.User = append(c.inters.User, interceptors...)
+}
+
+// Create returns a builder for creating a User entity.
+func (c *UserClient) Create() *UserCreate {
+	mutation := newUserMutation(c.config, OpCreate)
+	return &UserCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// CreateBulk returns a builder for creating a bulk of User entities.
+func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk {
+	return &UserCreateBulk{config: c.config, builders: builders}
+}
+
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk {
+	rv := reflect.ValueOf(slice)
+	if rv.Kind() != reflect.Slice {
+		return &UserCreateBulk{err: fmt.Errorf("calling to UserClient.MapCreateBulk with wrong type %T, need slice", slice)}
+	}
+	builders := make([]*UserCreate, rv.Len())
+	for i := 0; i < rv.Len(); i++ {
+		builders[i] = c.Create()
+		setFunc(builders[i], i)
+	}
+	return &UserCreateBulk{config: c.config, builders: builders}
+}
+
+// Update returns an update builder for User.
+func (c *UserClient) Update() *UserUpdate {
+	mutation := newUserMutation(c.config, OpUpdate)
+	return &UserUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOne returns an update builder for the given entity.
+func (c *UserClient) UpdateOne(u *User) *UserUpdateOne {
+	mutation := newUserMutation(c.config, OpUpdateOne, withUser(u))
+	return &UserUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOneID returns an update builder for the given id.
+func (c *UserClient) UpdateOneID(id string) *UserUpdateOne {
+	mutation := newUserMutation(c.config, OpUpdateOne, withUserID(id))
+	return &UserUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// Delete returns a delete builder for User.
+func (c *UserClient) Delete() *UserDelete {
+	mutation := newUserMutation(c.config, OpDelete)
+	return &UserDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// DeleteOne returns a builder for deleting the given entity.
+func (c *UserClient) DeleteOne(u *User) *UserDeleteOne {
+	return c.DeleteOneID(u.ID)
+}
+
+// DeleteOneID returns a builder for deleting the given entity by its id.
+func (c *UserClient) DeleteOneID(id string) *UserDeleteOne {
+	builder := c.Delete().Where(user.ID(id))
+	builder.mutation.id = &id
+	builder.mutation.op = OpDeleteOne
+	return &UserDeleteOne{builder}
+}
+
+// Query returns a query builder for User.
+func (c *UserClient) Query() *UserQuery {
+	return &UserQuery{
+		config: c.config,
+		ctx:    &QueryContext{Type: TypeUser},
+		inters: c.Interceptors(),
+	}
+}
+
+// Get returns a User entity by its id.
+func (c *UserClient) Get(ctx context.Context, id string) (*User, error) {
+	return c.Query().Where(user.ID(id)).Only(ctx)
+}
+
+// GetX is like Get, but panics if an error occurs.
+func (c *UserClient) GetX(ctx context.Context, id string) *User {
+	obj, err := c.Get(ctx, id)
+	if err != nil {
+		panic(err)
+	}
+	return obj
+}
+
+// QuerySubscriptions queries the subscriptions edge of a User.
+func (c *UserClient) QuerySubscriptions(u *User) *UserSubscriptionQuery {
+	query := (&UserSubscriptionClient{config: c.config}).Query()
+	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+		id := u.ID
+		step := sqlgraph.NewStep(
+			sqlgraph.From(user.Table, user.FieldID, id),
+			sqlgraph.To(usersubscription.Table, usersubscription.FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, user.SubscriptionsTable, user.SubscriptionsColumn),
+		)
+		fromV = sqlgraph.Neighbors(u.driver.Dialect(), step)
+		return fromV, nil
+	}
+	return query
+}
+
+// QueryConnections queries the connections edge of a User.
+func (c *UserClient) QueryConnections(u *User) *UserConnectionQuery {
+	query := (&UserConnectionClient{config: c.config}).Query()
+	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+		id := u.ID
+		step := sqlgraph.NewStep(
+			sqlgraph.From(user.Table, user.FieldID, id),
+			sqlgraph.To(userconnection.Table, userconnection.FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, user.ConnectionsTable, user.ConnectionsColumn),
+		)
+		fromV = sqlgraph.Neighbors(u.driver.Dialect(), step)
+		return fromV, nil
+	}
+	return query
+}
+
+// QueryContent queries the content edge of a User.
+func (c *UserClient) QueryContent(u *User) *UserContentQuery {
+	query := (&UserContentClient{config: c.config}).Query()
+	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+		id := u.ID
+		step := sqlgraph.NewStep(
+			sqlgraph.From(user.Table, user.FieldID, id),
+			sqlgraph.To(usercontent.Table, usercontent.FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, user.ContentTable, user.ContentColumn),
+		)
+		fromV = sqlgraph.Neighbors(u.driver.Dialect(), step)
+		return fromV, nil
+	}
+	return query
+}
+
+// Hooks returns the client hooks.
+func (c *UserClient) Hooks() []Hook {
+	return c.hooks.User
+}
+
+// Interceptors returns the client interceptors.
+func (c *UserClient) Interceptors() []Interceptor {
+	return c.inters.User
+}
+
+func (c *UserClient) mutate(ctx context.Context, m *UserMutation) (Value, error) {
+	switch m.Op() {
+	case OpCreate:
+		return (&UserCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdate:
+		return (&UserUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdateOne:
+		return (&UserUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpDelete, OpDeleteOne:
+		return (&UserDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+	default:
+		return nil, fmt.Errorf("db: unknown User mutation op: %q", m.Op())
+	}
+}
+
+// UserConnectionClient is a client for the UserConnection schema.
+type UserConnectionClient struct {
+	config
+}
+
+// NewUserConnectionClient returns a client for the UserConnection from the given config.
+func NewUserConnectionClient(c config) *UserConnectionClient {
+	return &UserConnectionClient{config: c}
+}
+
+// Use adds a list of mutation hooks to the hooks stack.
+// A call to `Use(f, g, h)` equals to `userconnection.Hooks(f(g(h())))`.
+func (c *UserConnectionClient) Use(hooks ...Hook) {
+	c.hooks.UserConnection = append(c.hooks.UserConnection, hooks...)
+}
+
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `userconnection.Intercept(f(g(h())))`.
+func (c *UserConnectionClient) Intercept(interceptors ...Interceptor) {
+	c.inters.UserConnection = append(c.inters.UserConnection, interceptors...)
+}
+
+// Create returns a builder for creating a UserConnection entity.
+func (c *UserConnectionClient) Create() *UserConnectionCreate {
+	mutation := newUserConnectionMutation(c.config, OpCreate)
+	return &UserConnectionCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// CreateBulk returns a builder for creating a bulk of UserConnection entities.
+func (c *UserConnectionClient) CreateBulk(builders ...*UserConnectionCreate) *UserConnectionCreateBulk {
+	return &UserConnectionCreateBulk{config: c.config, builders: builders}
+}
+
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *UserConnectionClient) MapCreateBulk(slice any, setFunc func(*UserConnectionCreate, int)) *UserConnectionCreateBulk {
+	rv := reflect.ValueOf(slice)
+	if rv.Kind() != reflect.Slice {
+		return &UserConnectionCreateBulk{err: fmt.Errorf("calling to UserConnectionClient.MapCreateBulk with wrong type %T, need slice", slice)}
+	}
+	builders := make([]*UserConnectionCreate, rv.Len())
+	for i := 0; i < rv.Len(); i++ {
+		builders[i] = c.Create()
+		setFunc(builders[i], i)
+	}
+	return &UserConnectionCreateBulk{config: c.config, builders: builders}
+}
+
+// Update returns an update builder for UserConnection.
+func (c *UserConnectionClient) Update() *UserConnectionUpdate {
+	mutation := newUserConnectionMutation(c.config, OpUpdate)
+	return &UserConnectionUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOne returns an update builder for the given entity.
+func (c *UserConnectionClient) UpdateOne(uc *UserConnection) *UserConnectionUpdateOne {
+	mutation := newUserConnectionMutation(c.config, OpUpdateOne, withUserConnection(uc))
+	return &UserConnectionUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOneID returns an update builder for the given id.
+func (c *UserConnectionClient) UpdateOneID(id string) *UserConnectionUpdateOne {
+	mutation := newUserConnectionMutation(c.config, OpUpdateOne, withUserConnectionID(id))
+	return &UserConnectionUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// Delete returns a delete builder for UserConnection.
+func (c *UserConnectionClient) Delete() *UserConnectionDelete {
+	mutation := newUserConnectionMutation(c.config, OpDelete)
+	return &UserConnectionDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// DeleteOne returns a builder for deleting the given entity.
+func (c *UserConnectionClient) DeleteOne(uc *UserConnection) *UserConnectionDeleteOne {
+	return c.DeleteOneID(uc.ID)
+}
+
+// DeleteOneID returns a builder for deleting the given entity by its id.
+func (c *UserConnectionClient) DeleteOneID(id string) *UserConnectionDeleteOne {
+	builder := c.Delete().Where(userconnection.ID(id))
+	builder.mutation.id = &id
+	builder.mutation.op = OpDeleteOne
+	return &UserConnectionDeleteOne{builder}
+}
+
+// Query returns a query builder for UserConnection.
+func (c *UserConnectionClient) Query() *UserConnectionQuery {
+	return &UserConnectionQuery{
+		config: c.config,
+		ctx:    &QueryContext{Type: TypeUserConnection},
+		inters: c.Interceptors(),
+	}
+}
+
+// Get returns a UserConnection entity by its id.
+func (c *UserConnectionClient) Get(ctx context.Context, id string) (*UserConnection, error) {
+	return c.Query().Where(userconnection.ID(id)).Only(ctx)
+}
+
+// GetX is like Get, but panics if an error occurs.
+func (c *UserConnectionClient) GetX(ctx context.Context, id string) *UserConnection {
+	obj, err := c.Get(ctx, id)
+	if err != nil {
+		panic(err)
+	}
+	return obj
+}
+
+// QueryUser queries the user edge of a UserConnection.
+func (c *UserConnectionClient) QueryUser(uc *UserConnection) *UserQuery {
+	query := (&UserClient{config: c.config}).Query()
+	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+		id := uc.ID
+		step := sqlgraph.NewStep(
+			sqlgraph.From(userconnection.Table, userconnection.FieldID, id),
+			sqlgraph.To(user.Table, user.FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, userconnection.UserTable, userconnection.UserColumn),
+		)
+		fromV = sqlgraph.Neighbors(uc.driver.Dialect(), step)
+		return fromV, nil
+	}
+	return query
+}
+
+// Hooks returns the client hooks.
+func (c *UserConnectionClient) Hooks() []Hook {
+	return c.hooks.UserConnection
+}
+
+// Interceptors returns the client interceptors.
+func (c *UserConnectionClient) Interceptors() []Interceptor {
+	return c.inters.UserConnection
+}
+
+func (c *UserConnectionClient) mutate(ctx context.Context, m *UserConnectionMutation) (Value, error) {
+	switch m.Op() {
+	case OpCreate:
+		return (&UserConnectionCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdate:
+		return (&UserConnectionUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdateOne:
+		return (&UserConnectionUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpDelete, OpDeleteOne:
+		return (&UserConnectionDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+	default:
+		return nil, fmt.Errorf("db: unknown UserConnection mutation op: %q", m.Op())
+	}
+}
+
+// UserContentClient is a client for the UserContent schema.
+type UserContentClient struct {
+	config
+}
+
+// NewUserContentClient returns a client for the UserContent from the given config.
+func NewUserContentClient(c config) *UserContentClient {
+	return &UserContentClient{config: c}
+}
+
+// Use adds a list of mutation hooks to the hooks stack.
+// A call to `Use(f, g, h)` equals to `usercontent.Hooks(f(g(h())))`.
+func (c *UserContentClient) Use(hooks ...Hook) {
+	c.hooks.UserContent = append(c.hooks.UserContent, hooks...)
+}
+
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `usercontent.Intercept(f(g(h())))`.
+func (c *UserContentClient) Intercept(interceptors ...Interceptor) {
+	c.inters.UserContent = append(c.inters.UserContent, interceptors...)
+}
+
+// Create returns a builder for creating a UserContent entity.
+func (c *UserContentClient) Create() *UserContentCreate {
+	mutation := newUserContentMutation(c.config, OpCreate)
+	return &UserContentCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// CreateBulk returns a builder for creating a bulk of UserContent entities.
+func (c *UserContentClient) CreateBulk(builders ...*UserContentCreate) *UserContentCreateBulk {
+	return &UserContentCreateBulk{config: c.config, builders: builders}
+}
+
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *UserContentClient) MapCreateBulk(slice any, setFunc func(*UserContentCreate, int)) *UserContentCreateBulk {
+	rv := reflect.ValueOf(slice)
+	if rv.Kind() != reflect.Slice {
+		return &UserContentCreateBulk{err: fmt.Errorf("calling to UserContentClient.MapCreateBulk with wrong type %T, need slice", slice)}
+	}
+	builders := make([]*UserContentCreate, rv.Len())
+	for i := 0; i < rv.Len(); i++ {
+		builders[i] = c.Create()
+		setFunc(builders[i], i)
+	}
+	return &UserContentCreateBulk{config: c.config, builders: builders}
+}
+
+// Update returns an update builder for UserContent.
+func (c *UserContentClient) Update() *UserContentUpdate {
+	mutation := newUserContentMutation(c.config, OpUpdate)
+	return &UserContentUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOne returns an update builder for the given entity.
+func (c *UserContentClient) UpdateOne(uc *UserContent) *UserContentUpdateOne {
+	mutation := newUserContentMutation(c.config, OpUpdateOne, withUserContent(uc))
+	return &UserContentUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOneID returns an update builder for the given id.
+func (c *UserContentClient) UpdateOneID(id string) *UserContentUpdateOne {
+	mutation := newUserContentMutation(c.config, OpUpdateOne, withUserContentID(id))
+	return &UserContentUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// Delete returns a delete builder for UserContent.
+func (c *UserContentClient) Delete() *UserContentDelete {
+	mutation := newUserContentMutation(c.config, OpDelete)
+	return &UserContentDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// DeleteOne returns a builder for deleting the given entity.
+func (c *UserContentClient) DeleteOne(uc *UserContent) *UserContentDeleteOne {
+	return c.DeleteOneID(uc.ID)
+}
+
+// DeleteOneID returns a builder for deleting the given entity by its id.
+func (c *UserContentClient) DeleteOneID(id string) *UserContentDeleteOne {
+	builder := c.Delete().Where(usercontent.ID(id))
+	builder.mutation.id = &id
+	builder.mutation.op = OpDeleteOne
+	return &UserContentDeleteOne{builder}
+}
+
+// Query returns a query builder for UserContent.
+func (c *UserContentClient) Query() *UserContentQuery {
+	return &UserContentQuery{
+		config: c.config,
+		ctx:    &QueryContext{Type: TypeUserContent},
+		inters: c.Interceptors(),
+	}
+}
+
+// Get returns a UserContent entity by its id.
+func (c *UserContentClient) Get(ctx context.Context, id string) (*UserContent, error) {
+	return c.Query().Where(usercontent.ID(id)).Only(ctx)
+}
+
+// GetX is like Get, but panics if an error occurs.
+func (c *UserContentClient) GetX(ctx context.Context, id string) *UserContent {
+	obj, err := c.Get(ctx, id)
+	if err != nil {
+		panic(err)
+	}
+	return obj
+}
+
+// QueryUser queries the user edge of a UserContent.
+func (c *UserContentClient) QueryUser(uc *UserContent) *UserQuery {
+	query := (&UserClient{config: c.config}).Query()
+	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+		id := uc.ID
+		step := sqlgraph.NewStep(
+			sqlgraph.From(usercontent.Table, usercontent.FieldID, id),
+			sqlgraph.To(user.Table, user.FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, usercontent.UserTable, usercontent.UserColumn),
+		)
+		fromV = sqlgraph.Neighbors(uc.driver.Dialect(), step)
+		return fromV, nil
+	}
+	return query
+}
+
+// Hooks returns the client hooks.
+func (c *UserContentClient) Hooks() []Hook {
+	return c.hooks.UserContent
+}
+
+// Interceptors returns the client interceptors.
+func (c *UserContentClient) Interceptors() []Interceptor {
+	return c.inters.UserContent
+}
+
+func (c *UserContentClient) mutate(ctx context.Context, m *UserContentMutation) (Value, error) {
+	switch m.Op() {
+	case OpCreate:
+		return (&UserContentCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdate:
+		return (&UserContentUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdateOne:
+		return (&UserContentUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpDelete, OpDeleteOne:
+		return (&UserContentDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+	default:
+		return nil, fmt.Errorf("db: unknown UserContent mutation op: %q", m.Op())
+	}
+}
+
+// UserSubscriptionClient is a client for the UserSubscription schema.
+type UserSubscriptionClient struct {
+	config
+}
+
+// NewUserSubscriptionClient returns a client for the UserSubscription from the given config.
+func NewUserSubscriptionClient(c config) *UserSubscriptionClient {
+	return &UserSubscriptionClient{config: c}
+}
+
+// Use adds a list of mutation hooks to the hooks stack.
+// A call to `Use(f, g, h)` equals to `usersubscription.Hooks(f(g(h())))`.
+func (c *UserSubscriptionClient) Use(hooks ...Hook) {
+	c.hooks.UserSubscription = append(c.hooks.UserSubscription, hooks...)
+}
+
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `usersubscription.Intercept(f(g(h())))`.
+func (c *UserSubscriptionClient) Intercept(interceptors ...Interceptor) {
+	c.inters.UserSubscription = append(c.inters.UserSubscription, interceptors...)
+}
+
+// Create returns a builder for creating a UserSubscription entity.
+func (c *UserSubscriptionClient) Create() *UserSubscriptionCreate {
+	mutation := newUserSubscriptionMutation(c.config, OpCreate)
+	return &UserSubscriptionCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// CreateBulk returns a builder for creating a bulk of UserSubscription entities.
+func (c *UserSubscriptionClient) CreateBulk(builders ...*UserSubscriptionCreate) *UserSubscriptionCreateBulk {
+	return &UserSubscriptionCreateBulk{config: c.config, builders: builders}
+}
+
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *UserSubscriptionClient) MapCreateBulk(slice any, setFunc func(*UserSubscriptionCreate, int)) *UserSubscriptionCreateBulk {
+	rv := reflect.ValueOf(slice)
+	if rv.Kind() != reflect.Slice {
+		return &UserSubscriptionCreateBulk{err: fmt.Errorf("calling to UserSubscriptionClient.MapCreateBulk with wrong type %T, need slice", slice)}
+	}
+	builders := make([]*UserSubscriptionCreate, rv.Len())
+	for i := 0; i < rv.Len(); i++ {
+		builders[i] = c.Create()
+		setFunc(builders[i], i)
+	}
+	return &UserSubscriptionCreateBulk{config: c.config, builders: builders}
+}
+
+// Update returns an update builder for UserSubscription.
+func (c *UserSubscriptionClient) Update() *UserSubscriptionUpdate {
+	mutation := newUserSubscriptionMutation(c.config, OpUpdate)
+	return &UserSubscriptionUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOne returns an update builder for the given entity.
+func (c *UserSubscriptionClient) UpdateOne(us *UserSubscription) *UserSubscriptionUpdateOne {
+	mutation := newUserSubscriptionMutation(c.config, OpUpdateOne, withUserSubscription(us))
+	return &UserSubscriptionUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOneID returns an update builder for the given id.
+func (c *UserSubscriptionClient) UpdateOneID(id string) *UserSubscriptionUpdateOne {
+	mutation := newUserSubscriptionMutation(c.config, OpUpdateOne, withUserSubscriptionID(id))
+	return &UserSubscriptionUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// Delete returns a delete builder for UserSubscription.
+func (c *UserSubscriptionClient) Delete() *UserSubscriptionDelete {
+	mutation := newUserSubscriptionMutation(c.config, OpDelete)
+	return &UserSubscriptionDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// DeleteOne returns a builder for deleting the given entity.
+func (c *UserSubscriptionClient) DeleteOne(us *UserSubscription) *UserSubscriptionDeleteOne {
+	return c.DeleteOneID(us.ID)
+}
+
+// DeleteOneID returns a builder for deleting the given entity by its id.
+func (c *UserSubscriptionClient) DeleteOneID(id string) *UserSubscriptionDeleteOne {
+	builder := c.Delete().Where(usersubscription.ID(id))
+	builder.mutation.id = &id
+	builder.mutation.op = OpDeleteOne
+	return &UserSubscriptionDeleteOne{builder}
+}
+
+// Query returns a query builder for UserSubscription.
+func (c *UserSubscriptionClient) Query() *UserSubscriptionQuery {
+	return &UserSubscriptionQuery{
+		config: c.config,
+		ctx:    &QueryContext{Type: TypeUserSubscription},
+		inters: c.Interceptors(),
+	}
+}
+
+// Get returns a UserSubscription entity by its id.
+func (c *UserSubscriptionClient) Get(ctx context.Context, id string) (*UserSubscription, error) {
+	return c.Query().Where(usersubscription.ID(id)).Only(ctx)
+}
+
+// GetX is like Get, but panics if an error occurs.
+func (c *UserSubscriptionClient) GetX(ctx context.Context, id string) *UserSubscription {
+	obj, err := c.Get(ctx, id)
+	if err != nil {
+		panic(err)
+	}
+	return obj
+}
+
+// QueryUser queries the user edge of a UserSubscription.
+func (c *UserSubscriptionClient) QueryUser(us *UserSubscription) *UserQuery {
+	query := (&UserClient{config: c.config}).Query()
+	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+		id := us.ID
+		step := sqlgraph.NewStep(
+			sqlgraph.From(usersubscription.Table, usersubscription.FieldID, id),
+			sqlgraph.To(user.Table, user.FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, usersubscription.UserTable, usersubscription.UserColumn),
+		)
+		fromV = sqlgraph.Neighbors(us.driver.Dialect(), step)
+		return fromV, nil
+	}
+	return query
+}
+
+// Hooks returns the client hooks.
+func (c *UserSubscriptionClient) Hooks() []Hook {
+	return c.hooks.UserSubscription
+}
+
+// Interceptors returns the client interceptors.
+func (c *UserSubscriptionClient) Interceptors() []Interceptor {
+	return c.inters.UserSubscription
+}
+
+func (c *UserSubscriptionClient) mutate(ctx context.Context, m *UserSubscriptionMutation) (Value, error) {
+	switch m.Op() {
+	case OpCreate:
+		return (&UserSubscriptionCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdate:
+		return (&UserSubscriptionUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdateOne:
+		return (&UserSubscriptionUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpDelete, OpDeleteOne:
+		return (&UserSubscriptionDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+	default:
+		return nil, fmt.Errorf("db: unknown UserSubscription mutation op: %q", m.Op())
+	}
+}
+
+// VehicleClient is a client for the Vehicle schema.
+type VehicleClient struct {
+	config
+}
+
+// NewVehicleClient returns a client for the Vehicle from the given config.
+func NewVehicleClient(c config) *VehicleClient {
+	return &VehicleClient{config: c}
+}
+
+// Use adds a list of mutation hooks to the hooks stack.
+// A call to `Use(f, g, h)` equals to `vehicle.Hooks(f(g(h())))`.
+func (c *VehicleClient) Use(hooks ...Hook) {
+	c.hooks.Vehicle = append(c.hooks.Vehicle, hooks...)
+}
+
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `vehicle.Intercept(f(g(h())))`.
+func (c *VehicleClient) Intercept(interceptors ...Interceptor) {
+	c.inters.Vehicle = append(c.inters.Vehicle, interceptors...)
+}
+
+// Create returns a builder for creating a Vehicle entity.
+func (c *VehicleClient) Create() *VehicleCreate {
+	mutation := newVehicleMutation(c.config, OpCreate)
+	return &VehicleCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// CreateBulk returns a builder for creating a bulk of Vehicle entities.
+func (c *VehicleClient) CreateBulk(builders ...*VehicleCreate) *VehicleCreateBulk {
+	return &VehicleCreateBulk{config: c.config, builders: builders}
+}
+
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *VehicleClient) MapCreateBulk(slice any, setFunc func(*VehicleCreate, int)) *VehicleCreateBulk {
+	rv := reflect.ValueOf(slice)
+	if rv.Kind() != reflect.Slice {
+		return &VehicleCreateBulk{err: fmt.Errorf("calling to VehicleClient.MapCreateBulk with wrong type %T, need slice", slice)}
+	}
+	builders := make([]*VehicleCreate, rv.Len())
+	for i := 0; i < rv.Len(); i++ {
+		builders[i] = c.Create()
+		setFunc(builders[i], i)
+	}
+	return &VehicleCreateBulk{config: c.config, builders: builders}
+}
+
+// Update returns an update builder for Vehicle.
+func (c *VehicleClient) Update() *VehicleUpdate {
+	mutation := newVehicleMutation(c.config, OpUpdate)
+	return &VehicleUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOne returns an update builder for the given entity.
+func (c *VehicleClient) UpdateOne(v *Vehicle) *VehicleUpdateOne {
+	mutation := newVehicleMutation(c.config, OpUpdateOne, withVehicle(v))
+	return &VehicleUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOneID returns an update builder for the given id.
+func (c *VehicleClient) UpdateOneID(id string) *VehicleUpdateOne {
+	mutation := newVehicleMutation(c.config, OpUpdateOne, withVehicleID(id))
+	return &VehicleUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// Delete returns a delete builder for Vehicle.
+func (c *VehicleClient) Delete() *VehicleDelete {
+	mutation := newVehicleMutation(c.config, OpDelete)
+	return &VehicleDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// DeleteOne returns a builder for deleting the given entity.
+func (c *VehicleClient) DeleteOne(v *Vehicle) *VehicleDeleteOne {
+	return c.DeleteOneID(v.ID)
+}
+
+// DeleteOneID returns a builder for deleting the given entity by its id.
+func (c *VehicleClient) DeleteOneID(id string) *VehicleDeleteOne {
+	builder := c.Delete().Where(vehicle.ID(id))
+	builder.mutation.id = &id
+	builder.mutation.op = OpDeleteOne
+	return &VehicleDeleteOne{builder}
+}
+
+// Query returns a query builder for Vehicle.
+func (c *VehicleClient) Query() *VehicleQuery {
+	return &VehicleQuery{
+		config: c.config,
+		ctx:    &QueryContext{Type: TypeVehicle},
+		inters: c.Interceptors(),
+	}
+}
+
+// Get returns a Vehicle entity by its id.
+func (c *VehicleClient) Get(ctx context.Context, id string) (*Vehicle, error) {
+	return c.Query().Where(vehicle.ID(id)).Only(ctx)
+}
+
+// GetX is like Get, but panics if an error occurs.
+func (c *VehicleClient) GetX(ctx context.Context, id string) *Vehicle {
+	obj, err := c.Get(ctx, id)
+	if err != nil {
+		panic(err)
+	}
+	return obj
+}
+
+// Hooks returns the client hooks.
+func (c *VehicleClient) Hooks() []Hook {
+	return c.hooks.Vehicle
+}
+
+// Interceptors returns the client interceptors.
+func (c *VehicleClient) Interceptors() []Interceptor {
+	return c.inters.Vehicle
+}
+
+func (c *VehicleClient) mutate(ctx context.Context, m *VehicleMutation) (Value, error) {
+	switch m.Op() {
+	case OpCreate:
+		return (&VehicleCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdate:
+		return (&VehicleUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdateOne:
+		return (&VehicleUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpDelete, OpDeleteOne:
+		return (&VehicleDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+	default:
+		return nil, fmt.Errorf("db: unknown Vehicle mutation op: %q", m.Op())
+	}
+}
+
+// VehicleAverageClient is a client for the VehicleAverage schema.
+type VehicleAverageClient struct {
+	config
+}
+
+// NewVehicleAverageClient returns a client for the VehicleAverage from the given config.
+func NewVehicleAverageClient(c config) *VehicleAverageClient {
+	return &VehicleAverageClient{config: c}
+}
+
+// Use adds a list of mutation hooks to the hooks stack.
+// A call to `Use(f, g, h)` equals to `vehicleaverage.Hooks(f(g(h())))`.
+func (c *VehicleAverageClient) Use(hooks ...Hook) {
+	c.hooks.VehicleAverage = append(c.hooks.VehicleAverage, hooks...)
+}
+
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `vehicleaverage.Intercept(f(g(h())))`.
+func (c *VehicleAverageClient) Intercept(interceptors ...Interceptor) {
+	c.inters.VehicleAverage = append(c.inters.VehicleAverage, interceptors...)
+}
+
+// Create returns a builder for creating a VehicleAverage entity.
+func (c *VehicleAverageClient) Create() *VehicleAverageCreate {
+	mutation := newVehicleAverageMutation(c.config, OpCreate)
+	return &VehicleAverageCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// CreateBulk returns a builder for creating a bulk of VehicleAverage entities.
+func (c *VehicleAverageClient) CreateBulk(builders ...*VehicleAverageCreate) *VehicleAverageCreateBulk {
+	return &VehicleAverageCreateBulk{config: c.config, builders: builders}
+}
+
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *VehicleAverageClient) MapCreateBulk(slice any, setFunc func(*VehicleAverageCreate, int)) *VehicleAverageCreateBulk {
+	rv := reflect.ValueOf(slice)
+	if rv.Kind() != reflect.Slice {
+		return &VehicleAverageCreateBulk{err: fmt.Errorf("calling to VehicleAverageClient.MapCreateBulk with wrong type %T, need slice", slice)}
+	}
+	builders := make([]*VehicleAverageCreate, rv.Len())
+	for i := 0; i < rv.Len(); i++ {
+		builders[i] = c.Create()
+		setFunc(builders[i], i)
+	}
+	return &VehicleAverageCreateBulk{config: c.config, builders: builders}
+}
+
+// Update returns an update builder for VehicleAverage.
+func (c *VehicleAverageClient) Update() *VehicleAverageUpdate {
+	mutation := newVehicleAverageMutation(c.config, OpUpdate)
+	return &VehicleAverageUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOne returns an update builder for the given entity.
+func (c *VehicleAverageClient) UpdateOne(va *VehicleAverage) *VehicleAverageUpdateOne {
+	mutation := newVehicleAverageMutation(c.config, OpUpdateOne, withVehicleAverage(va))
+	return &VehicleAverageUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOneID returns an update builder for the given id.
+func (c *VehicleAverageClient) UpdateOneID(id string) *VehicleAverageUpdateOne {
+	mutation := newVehicleAverageMutation(c.config, OpUpdateOne, withVehicleAverageID(id))
+	return &VehicleAverageUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// Delete returns a delete builder for VehicleAverage.
+func (c *VehicleAverageClient) Delete() *VehicleAverageDelete {
+	mutation := newVehicleAverageMutation(c.config, OpDelete)
+	return &VehicleAverageDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// DeleteOne returns a builder for deleting the given entity.
+func (c *VehicleAverageClient) DeleteOne(va *VehicleAverage) *VehicleAverageDeleteOne {
+	return c.DeleteOneID(va.ID)
+}
+
+// DeleteOneID returns a builder for deleting the given entity by its id.
+func (c *VehicleAverageClient) DeleteOneID(id string) *VehicleAverageDeleteOne {
+	builder := c.Delete().Where(vehicleaverage.ID(id))
+	builder.mutation.id = &id
+	builder.mutation.op = OpDeleteOne
+	return &VehicleAverageDeleteOne{builder}
+}
+
+// Query returns a query builder for VehicleAverage.
+func (c *VehicleAverageClient) Query() *VehicleAverageQuery {
+	return &VehicleAverageQuery{
+		config: c.config,
+		ctx:    &QueryContext{Type: TypeVehicleAverage},
+		inters: c.Interceptors(),
+	}
+}
+
+// Get returns a VehicleAverage entity by its id.
+func (c *VehicleAverageClient) Get(ctx context.Context, id string) (*VehicleAverage, error) {
+	return c.Query().Where(vehicleaverage.ID(id)).Only(ctx)
+}
+
+// GetX is like Get, but panics if an error occurs.
+func (c *VehicleAverageClient) GetX(ctx context.Context, id string) *VehicleAverage {
+	obj, err := c.Get(ctx, id)
+	if err != nil {
+		panic(err)
+	}
+	return obj
+}
+
+// Hooks returns the client hooks.
+func (c *VehicleAverageClient) Hooks() []Hook {
+	return c.hooks.VehicleAverage
+}
+
+// Interceptors returns the client interceptors.
+func (c *VehicleAverageClient) Interceptors() []Interceptor {
+	return c.inters.VehicleAverage
+}
+
+func (c *VehicleAverageClient) mutate(ctx context.Context, m *VehicleAverageMutation) (Value, error) {
+	switch m.Op() {
+	case OpCreate:
+		return (&VehicleAverageCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdate:
+		return (&VehicleAverageUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdateOne:
+		return (&VehicleAverageUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpDelete, OpDeleteOne:
+		return (&VehicleAverageDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+	default:
+		return nil, fmt.Errorf("db: unknown VehicleAverage mutation op: %q", m.Op())
+	}
+}
+
+// VehicleSnapshotClient is a client for the VehicleSnapshot schema.
+type VehicleSnapshotClient struct {
+	config
+}
+
+// NewVehicleSnapshotClient returns a client for the VehicleSnapshot from the given config.
+func NewVehicleSnapshotClient(c config) *VehicleSnapshotClient {
+	return &VehicleSnapshotClient{config: c}
+}
+
+// Use adds a list of mutation hooks to the hooks stack.
+// A call to `Use(f, g, h)` equals to `vehiclesnapshot.Hooks(f(g(h())))`.
+func (c *VehicleSnapshotClient) Use(hooks ...Hook) {
+	c.hooks.VehicleSnapshot = append(c.hooks.VehicleSnapshot, hooks...)
+}
+
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `vehiclesnapshot.Intercept(f(g(h())))`.
+func (c *VehicleSnapshotClient) Intercept(interceptors ...Interceptor) {
+	c.inters.VehicleSnapshot = append(c.inters.VehicleSnapshot, interceptors...)
+}
+
+// Create returns a builder for creating a VehicleSnapshot entity.
+func (c *VehicleSnapshotClient) Create() *VehicleSnapshotCreate {
+	mutation := newVehicleSnapshotMutation(c.config, OpCreate)
+	return &VehicleSnapshotCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// CreateBulk returns a builder for creating a bulk of VehicleSnapshot entities.
+func (c *VehicleSnapshotClient) CreateBulk(builders ...*VehicleSnapshotCreate) *VehicleSnapshotCreateBulk {
+	return &VehicleSnapshotCreateBulk{config: c.config, builders: builders}
+}
+
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *VehicleSnapshotClient) MapCreateBulk(slice any, setFunc func(*VehicleSnapshotCreate, int)) *VehicleSnapshotCreateBulk {
+	rv := reflect.ValueOf(slice)
+	if rv.Kind() != reflect.Slice {
+		return &VehicleSnapshotCreateBulk{err: fmt.Errorf("calling to VehicleSnapshotClient.MapCreateBulk with wrong type %T, need slice", slice)}
+	}
+	builders := make([]*VehicleSnapshotCreate, rv.Len())
+	for i := 0; i < rv.Len(); i++ {
+		builders[i] = c.Create()
+		setFunc(builders[i], i)
+	}
+	return &VehicleSnapshotCreateBulk{config: c.config, builders: builders}
+}
+
+// Update returns an update builder for VehicleSnapshot.
+func (c *VehicleSnapshotClient) Update() *VehicleSnapshotUpdate {
+	mutation := newVehicleSnapshotMutation(c.config, OpUpdate)
+	return &VehicleSnapshotUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOne returns an update builder for the given entity.
+func (c *VehicleSnapshotClient) UpdateOne(vs *VehicleSnapshot) *VehicleSnapshotUpdateOne {
+	mutation := newVehicleSnapshotMutation(c.config, OpUpdateOne, withVehicleSnapshot(vs))
+	return &VehicleSnapshotUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOneID returns an update builder for the given id.
+func (c *VehicleSnapshotClient) UpdateOneID(id string) *VehicleSnapshotUpdateOne {
+	mutation := newVehicleSnapshotMutation(c.config, OpUpdateOne, withVehicleSnapshotID(id))
+	return &VehicleSnapshotUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// Delete returns a delete builder for VehicleSnapshot.
+func (c *VehicleSnapshotClient) Delete() *VehicleSnapshotDelete {
+	mutation := newVehicleSnapshotMutation(c.config, OpDelete)
+	return &VehicleSnapshotDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// DeleteOne returns a builder for deleting the given entity.
+func (c *VehicleSnapshotClient) DeleteOne(vs *VehicleSnapshot) *VehicleSnapshotDeleteOne {
+	return c.DeleteOneID(vs.ID)
+}
+
+// DeleteOneID returns a builder for deleting the given entity by its id.
+func (c *VehicleSnapshotClient) DeleteOneID(id string) *VehicleSnapshotDeleteOne {
+	builder := c.Delete().Where(vehiclesnapshot.ID(id))
+	builder.mutation.id = &id
+	builder.mutation.op = OpDeleteOne
+	return &VehicleSnapshotDeleteOne{builder}
+}
+
+// Query returns a query builder for VehicleSnapshot.
+func (c *VehicleSnapshotClient) Query() *VehicleSnapshotQuery {
+	return &VehicleSnapshotQuery{
+		config: c.config,
+		ctx:    &QueryContext{Type: TypeVehicleSnapshot},
+		inters: c.Interceptors(),
+	}
+}
+
+// Get returns a VehicleSnapshot entity by its id.
+func (c *VehicleSnapshotClient) Get(ctx context.Context, id string) (*VehicleSnapshot, error) {
+	return c.Query().Where(vehiclesnapshot.ID(id)).Only(ctx)
+}
+
+// GetX is like Get, but panics if an error occurs.
+func (c *VehicleSnapshotClient) GetX(ctx context.Context, id string) *VehicleSnapshot {
+	obj, err := c.Get(ctx, id)
+	if err != nil {
+		panic(err)
+	}
+	return obj
+}
+
+// QueryAccount queries the account edge of a VehicleSnapshot.
+func (c *VehicleSnapshotClient) QueryAccount(vs *VehicleSnapshot) *AccountQuery {
+	query := (&AccountClient{config: c.config}).Query()
+	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+		id := vs.ID
+		step := sqlgraph.NewStep(
+			sqlgraph.From(vehiclesnapshot.Table, vehiclesnapshot.FieldID, id),
+			sqlgraph.To(account.Table, account.FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, vehiclesnapshot.AccountTable, vehiclesnapshot.AccountColumn),
+		)
+		fromV = sqlgraph.Neighbors(vs.driver.Dialect(), step)
+		return fromV, nil
+	}
+	return query
+}
+
+// Hooks returns the client hooks.
+func (c *VehicleSnapshotClient) Hooks() []Hook {
+	return c.hooks.VehicleSnapshot
+}
+
+// Interceptors returns the client interceptors.
+func (c *VehicleSnapshotClient) Interceptors() []Interceptor {
+	return c.inters.VehicleSnapshot
+}
+
+func (c *VehicleSnapshotClient) mutate(ctx context.Context, m *VehicleSnapshotMutation) (Value, error) {
+	switch m.Op() {
+	case OpCreate:
+		return (&VehicleSnapshotCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdate:
+		return (&VehicleSnapshotUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdateOne:
+		return (&VehicleSnapshotUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpDelete, OpDeleteOne:
+		return (&VehicleSnapshotDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+	default:
+		return nil, fmt.Errorf("db: unknown VehicleSnapshot mutation op: %q", m.Op())
+	}
+}
+
+// hooks and interceptors per client, for fast access.
+type (
+	hooks struct {
+		Account, AccountSnapshot, AchievementsSnapshot, AppConfiguration,
+		ApplicationCommand, Clan, CronTask, User, UserConnection, UserContent,
+		UserSubscription, Vehicle, VehicleAverage, VehicleSnapshot []ent.Hook
+	}
+	inters struct {
+		Account, AccountSnapshot, AchievementsSnapshot, AppConfiguration,
+		ApplicationCommand, Clan, CronTask, User, UserConnection, UserContent,
+		UserSubscription, Vehicle, VehicleAverage, VehicleSnapshot []ent.Interceptor
+	}
+)
diff --git a/internal/database/ent/db/crontask.go b/internal/database/ent/db/crontask.go
new file mode 100644
index 00000000..c7580c3c
--- /dev/null
+++ b/internal/database/ent/db/crontask.go
@@ -0,0 +1,212 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+	"github.com/cufee/aftermath/internal/database/ent/db/crontask"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+// CronTask is the model entity for the CronTask schema.
+type CronTask struct {
+	config `json:"-"`
+	// ID of the ent.
+	ID string `json:"id,omitempty"`
+	// CreatedAt holds the value of the "created_at" field.
+	CreatedAt int `json:"created_at,omitempty"`
+	// UpdatedAt holds the value of the "updated_at" field.
+	UpdatedAt int `json:"updated_at,omitempty"`
+	// Type holds the value of the "type" field.
+	Type string `json:"type,omitempty"`
+	// ReferenceID holds the value of the "reference_id" field.
+	ReferenceID string `json:"reference_id,omitempty"`
+	// Targets holds the value of the "targets" field.
+	Targets []string `json:"targets,omitempty"`
+	// Status holds the value of the "status" field.
+	Status string `json:"status,omitempty"`
+	// ScheduledAfter holds the value of the "scheduled_after" field.
+	ScheduledAfter int `json:"scheduled_after,omitempty"`
+	// LastRun holds the value of the "last_run" field.
+	LastRun int `json:"last_run,omitempty"`
+	// Logs holds the value of the "logs" field.
+	Logs []models.TaskLog `json:"logs,omitempty"`
+	// Data holds the value of the "data" field.
+	Data         map[string]interface{} `json:"data,omitempty"`
+	selectValues sql.SelectValues
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*CronTask) scanValues(columns []string) ([]any, error) {
+	values := make([]any, len(columns))
+	for i := range columns {
+		switch columns[i] {
+		case crontask.FieldTargets, crontask.FieldLogs, crontask.FieldData:
+			values[i] = new([]byte)
+		case crontask.FieldCreatedAt, crontask.FieldUpdatedAt, crontask.FieldScheduledAfter, crontask.FieldLastRun:
+			values[i] = new(sql.NullInt64)
+		case crontask.FieldID, crontask.FieldType, crontask.FieldReferenceID, crontask.FieldStatus:
+			values[i] = new(sql.NullString)
+		default:
+			values[i] = new(sql.UnknownType)
+		}
+	}
+	return values, nil
+}
+
+// assignValues assigns the values that were returned from sql.Rows (after scanning)
+// to the CronTask fields.
+func (ct *CronTask) assignValues(columns []string, values []any) error {
+	if m, n := len(values), len(columns); m < n {
+		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
+	}
+	for i := range columns {
+		switch columns[i] {
+		case crontask.FieldID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field id", values[i])
+			} else if value.Valid {
+				ct.ID = value.String
+			}
+		case crontask.FieldCreatedAt:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field created_at", values[i])
+			} else if value.Valid {
+				ct.CreatedAt = int(value.Int64)
+			}
+		case crontask.FieldUpdatedAt:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
+			} else if value.Valid {
+				ct.UpdatedAt = int(value.Int64)
+			}
+		case crontask.FieldType:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field type", values[i])
+			} else if value.Valid {
+				ct.Type = value.String
+			}
+		case crontask.FieldReferenceID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field reference_id", values[i])
+			} else if value.Valid {
+				ct.ReferenceID = value.String
+			}
+		case crontask.FieldTargets:
+			if value, ok := values[i].(*[]byte); !ok {
+				return fmt.Errorf("unexpected type %T for field targets", values[i])
+			} else if value != nil && len(*value) > 0 {
+				if err := json.Unmarshal(*value, &ct.Targets); err != nil {
+					return fmt.Errorf("unmarshal field targets: %w", err)
+				}
+			}
+		case crontask.FieldStatus:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field status", values[i])
+			} else if value.Valid {
+				ct.Status = value.String
+			}
+		case crontask.FieldScheduledAfter:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field scheduled_after", values[i])
+			} else if value.Valid {
+				ct.ScheduledAfter = int(value.Int64)
+			}
+		case crontask.FieldLastRun:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field last_run", values[i])
+			} else if value.Valid {
+				ct.LastRun = int(value.Int64)
+			}
+		case crontask.FieldLogs:
+			if value, ok := values[i].(*[]byte); !ok {
+				return fmt.Errorf("unexpected type %T for field logs", values[i])
+			} else if value != nil && len(*value) > 0 {
+				if err := json.Unmarshal(*value, &ct.Logs); err != nil {
+					return fmt.Errorf("unmarshal field logs: %w", err)
+				}
+			}
+		case crontask.FieldData:
+			if value, ok := values[i].(*[]byte); !ok {
+				return fmt.Errorf("unexpected type %T for field data", values[i])
+			} else if value != nil && len(*value) > 0 {
+				if err := json.Unmarshal(*value, &ct.Data); err != nil {
+					return fmt.Errorf("unmarshal field data: %w", err)
+				}
+			}
+		default:
+			ct.selectValues.Set(columns[i], values[i])
+		}
+	}
+	return nil
+}
+
+// Value returns the ent.Value that was dynamically selected and assigned to the CronTask.
+// This includes values selected through modifiers, order, etc.
+func (ct *CronTask) Value(name string) (ent.Value, error) {
+	return ct.selectValues.Get(name)
+}
+
+// Update returns a builder for updating this CronTask.
+// Note that you need to call CronTask.Unwrap() before calling this method if this CronTask
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (ct *CronTask) Update() *CronTaskUpdateOne {
+	return NewCronTaskClient(ct.config).UpdateOne(ct)
+}
+
+// Unwrap unwraps the CronTask entity that was returned from a transaction after it was closed,
+// so that all future queries will be executed through the driver which created the transaction.
+func (ct *CronTask) Unwrap() *CronTask {
+	_tx, ok := ct.config.driver.(*txDriver)
+	if !ok {
+		panic("db: CronTask is not a transactional entity")
+	}
+	ct.config.driver = _tx.drv
+	return ct
+}
+
+// String implements the fmt.Stringer.
+func (ct *CronTask) String() string {
+	var builder strings.Builder
+	builder.WriteString("CronTask(")
+	builder.WriteString(fmt.Sprintf("id=%v, ", ct.ID))
+	builder.WriteString("created_at=")
+	builder.WriteString(fmt.Sprintf("%v", ct.CreatedAt))
+	builder.WriteString(", ")
+	builder.WriteString("updated_at=")
+	builder.WriteString(fmt.Sprintf("%v", ct.UpdatedAt))
+	builder.WriteString(", ")
+	builder.WriteString("type=")
+	builder.WriteString(ct.Type)
+	builder.WriteString(", ")
+	builder.WriteString("reference_id=")
+	builder.WriteString(ct.ReferenceID)
+	builder.WriteString(", ")
+	builder.WriteString("targets=")
+	builder.WriteString(fmt.Sprintf("%v", ct.Targets))
+	builder.WriteString(", ")
+	builder.WriteString("status=")
+	builder.WriteString(ct.Status)
+	builder.WriteString(", ")
+	builder.WriteString("scheduled_after=")
+	builder.WriteString(fmt.Sprintf("%v", ct.ScheduledAfter))
+	builder.WriteString(", ")
+	builder.WriteString("last_run=")
+	builder.WriteString(fmt.Sprintf("%v", ct.LastRun))
+	builder.WriteString(", ")
+	builder.WriteString("logs=")
+	builder.WriteString(fmt.Sprintf("%v", ct.Logs))
+	builder.WriteString(", ")
+	builder.WriteString("data=")
+	builder.WriteString(fmt.Sprintf("%v", ct.Data))
+	builder.WriteByte(')')
+	return builder.String()
+}
+
+// CronTasks is a parsable slice of CronTask.
+type CronTasks []*CronTask
diff --git a/internal/database/ent/db/crontask/crontask.go b/internal/database/ent/db/crontask/crontask.go
new file mode 100644
index 00000000..eec007e1
--- /dev/null
+++ b/internal/database/ent/db/crontask/crontask.go
@@ -0,0 +1,121 @@
+// Code generated by ent, DO NOT EDIT.
+
+package crontask
+
+import (
+	"entgo.io/ent/dialect/sql"
+)
+
+const (
+	// Label holds the string label denoting the crontask type in the database.
+	Label = "cron_task"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// FieldType holds the string denoting the type field in the database.
+	FieldType = "type"
+	// FieldReferenceID holds the string denoting the reference_id field in the database.
+	FieldReferenceID = "reference_id"
+	// FieldTargets holds the string denoting the targets field in the database.
+	FieldTargets = "targets"
+	// FieldStatus holds the string denoting the status field in the database.
+	FieldStatus = "status"
+	// FieldScheduledAfter holds the string denoting the scheduled_after field in the database.
+	FieldScheduledAfter = "scheduled_after"
+	// FieldLastRun holds the string denoting the last_run field in the database.
+	FieldLastRun = "last_run"
+	// FieldLogs holds the string denoting the logs field in the database.
+	FieldLogs = "logs"
+	// FieldData holds the string denoting the data field in the database.
+	FieldData = "data"
+	// Table holds the table name of the crontask in the database.
+	Table = "cron_tasks"
+)
+
+// Columns holds all SQL columns for crontask fields.
+var Columns = []string{
+	FieldID,
+	FieldCreatedAt,
+	FieldUpdatedAt,
+	FieldType,
+	FieldReferenceID,
+	FieldTargets,
+	FieldStatus,
+	FieldScheduledAfter,
+	FieldLastRun,
+	FieldLogs,
+	FieldData,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() int
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() int
+	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
+	UpdateDefaultUpdatedAt func() int
+	// TypeValidator is a validator for the "type" field. It is called by the builders before save.
+	TypeValidator func(string) error
+	// ReferenceIDValidator is a validator for the "reference_id" field. It is called by the builders before save.
+	ReferenceIDValidator func(string) error
+	// StatusValidator is a validator for the "status" field. It is called by the builders before save.
+	StatusValidator func(string) error
+	// DefaultID holds the default value on creation for the "id" field.
+	DefaultID func() string
+)
+
+// OrderOption defines the ordering options for the CronTask queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByType orders the results by the type field.
+func ByType(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldType, opts...).ToFunc()
+}
+
+// ByReferenceID orders the results by the reference_id field.
+func ByReferenceID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldReferenceID, opts...).ToFunc()
+}
+
+// ByStatus orders the results by the status field.
+func ByStatus(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldStatus, opts...).ToFunc()
+}
+
+// ByScheduledAfter orders the results by the scheduled_after field.
+func ByScheduledAfter(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldScheduledAfter, opts...).ToFunc()
+}
+
+// ByLastRun orders the results by the last_run field.
+func ByLastRun(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldLastRun, opts...).ToFunc()
+}
diff --git a/internal/database/ent/db/crontask/where.go b/internal/database/ent/db/crontask/where.go
new file mode 100644
index 00000000..a3da3987
--- /dev/null
+++ b/internal/database/ent/db/crontask/where.go
@@ -0,0 +1,468 @@
+// Code generated by ent, DO NOT EDIT.
+
+package crontask
+
+import (
+	"entgo.io/ent/dialect/sql"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldLTE(FieldID, id))
+}
+
+// IDEqualFold applies the EqualFold predicate on the ID field.
+func IDEqualFold(id string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldEqualFold(FieldID, id))
+}
+
+// IDContainsFold applies the ContainsFold predicate on the ID field.
+func IDContainsFold(id string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldContainsFold(FieldID, id))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// Type applies equality check predicate on the "type" field. It's identical to TypeEQ.
+func Type(v string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldEQ(FieldType, v))
+}
+
+// ReferenceID applies equality check predicate on the "reference_id" field. It's identical to ReferenceIDEQ.
+func ReferenceID(v string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldEQ(FieldReferenceID, v))
+}
+
+// Status applies equality check predicate on the "status" field. It's identical to StatusEQ.
+func Status(v string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldEQ(FieldStatus, v))
+}
+
+// ScheduledAfter applies equality check predicate on the "scheduled_after" field. It's identical to ScheduledAfterEQ.
+func ScheduledAfter(v int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldEQ(FieldScheduledAfter, v))
+}
+
+// LastRun applies equality check predicate on the "last_run" field. It's identical to LastRunEQ.
+func LastRun(v int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldEQ(FieldLastRun, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// TypeEQ applies the EQ predicate on the "type" field.
+func TypeEQ(v string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldEQ(FieldType, v))
+}
+
+// TypeNEQ applies the NEQ predicate on the "type" field.
+func TypeNEQ(v string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldNEQ(FieldType, v))
+}
+
+// TypeIn applies the In predicate on the "type" field.
+func TypeIn(vs ...string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldIn(FieldType, vs...))
+}
+
+// TypeNotIn applies the NotIn predicate on the "type" field.
+func TypeNotIn(vs ...string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldNotIn(FieldType, vs...))
+}
+
+// TypeGT applies the GT predicate on the "type" field.
+func TypeGT(v string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldGT(FieldType, v))
+}
+
+// TypeGTE applies the GTE predicate on the "type" field.
+func TypeGTE(v string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldGTE(FieldType, v))
+}
+
+// TypeLT applies the LT predicate on the "type" field.
+func TypeLT(v string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldLT(FieldType, v))
+}
+
+// TypeLTE applies the LTE predicate on the "type" field.
+func TypeLTE(v string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldLTE(FieldType, v))
+}
+
+// TypeContains applies the Contains predicate on the "type" field.
+func TypeContains(v string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldContains(FieldType, v))
+}
+
+// TypeHasPrefix applies the HasPrefix predicate on the "type" field.
+func TypeHasPrefix(v string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldHasPrefix(FieldType, v))
+}
+
+// TypeHasSuffix applies the HasSuffix predicate on the "type" field.
+func TypeHasSuffix(v string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldHasSuffix(FieldType, v))
+}
+
+// TypeEqualFold applies the EqualFold predicate on the "type" field.
+func TypeEqualFold(v string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldEqualFold(FieldType, v))
+}
+
+// TypeContainsFold applies the ContainsFold predicate on the "type" field.
+func TypeContainsFold(v string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldContainsFold(FieldType, v))
+}
+
+// ReferenceIDEQ applies the EQ predicate on the "reference_id" field.
+func ReferenceIDEQ(v string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldEQ(FieldReferenceID, v))
+}
+
+// ReferenceIDNEQ applies the NEQ predicate on the "reference_id" field.
+func ReferenceIDNEQ(v string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldNEQ(FieldReferenceID, v))
+}
+
+// ReferenceIDIn applies the In predicate on the "reference_id" field.
+func ReferenceIDIn(vs ...string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldIn(FieldReferenceID, vs...))
+}
+
+// ReferenceIDNotIn applies the NotIn predicate on the "reference_id" field.
+func ReferenceIDNotIn(vs ...string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldNotIn(FieldReferenceID, vs...))
+}
+
+// ReferenceIDGT applies the GT predicate on the "reference_id" field.
+func ReferenceIDGT(v string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldGT(FieldReferenceID, v))
+}
+
+// ReferenceIDGTE applies the GTE predicate on the "reference_id" field.
+func ReferenceIDGTE(v string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldGTE(FieldReferenceID, v))
+}
+
+// ReferenceIDLT applies the LT predicate on the "reference_id" field.
+func ReferenceIDLT(v string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldLT(FieldReferenceID, v))
+}
+
+// ReferenceIDLTE applies the LTE predicate on the "reference_id" field.
+func ReferenceIDLTE(v string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldLTE(FieldReferenceID, v))
+}
+
+// ReferenceIDContains applies the Contains predicate on the "reference_id" field.
+func ReferenceIDContains(v string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldContains(FieldReferenceID, v))
+}
+
+// ReferenceIDHasPrefix applies the HasPrefix predicate on the "reference_id" field.
+func ReferenceIDHasPrefix(v string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldHasPrefix(FieldReferenceID, v))
+}
+
+// ReferenceIDHasSuffix applies the HasSuffix predicate on the "reference_id" field.
+func ReferenceIDHasSuffix(v string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldHasSuffix(FieldReferenceID, v))
+}
+
+// ReferenceIDEqualFold applies the EqualFold predicate on the "reference_id" field.
+func ReferenceIDEqualFold(v string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldEqualFold(FieldReferenceID, v))
+}
+
+// ReferenceIDContainsFold applies the ContainsFold predicate on the "reference_id" field.
+func ReferenceIDContainsFold(v string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldContainsFold(FieldReferenceID, v))
+}
+
+// StatusEQ applies the EQ predicate on the "status" field.
+func StatusEQ(v string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldEQ(FieldStatus, v))
+}
+
+// StatusNEQ applies the NEQ predicate on the "status" field.
+func StatusNEQ(v string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldNEQ(FieldStatus, v))
+}
+
+// StatusIn applies the In predicate on the "status" field.
+func StatusIn(vs ...string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldIn(FieldStatus, vs...))
+}
+
+// StatusNotIn applies the NotIn predicate on the "status" field.
+func StatusNotIn(vs ...string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldNotIn(FieldStatus, vs...))
+}
+
+// StatusGT applies the GT predicate on the "status" field.
+func StatusGT(v string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldGT(FieldStatus, v))
+}
+
+// StatusGTE applies the GTE predicate on the "status" field.
+func StatusGTE(v string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldGTE(FieldStatus, v))
+}
+
+// StatusLT applies the LT predicate on the "status" field.
+func StatusLT(v string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldLT(FieldStatus, v))
+}
+
+// StatusLTE applies the LTE predicate on the "status" field.
+func StatusLTE(v string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldLTE(FieldStatus, v))
+}
+
+// StatusContains applies the Contains predicate on the "status" field.
+func StatusContains(v string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldContains(FieldStatus, v))
+}
+
+// StatusHasPrefix applies the HasPrefix predicate on the "status" field.
+func StatusHasPrefix(v string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldHasPrefix(FieldStatus, v))
+}
+
+// StatusHasSuffix applies the HasSuffix predicate on the "status" field.
+func StatusHasSuffix(v string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldHasSuffix(FieldStatus, v))
+}
+
+// StatusEqualFold applies the EqualFold predicate on the "status" field.
+func StatusEqualFold(v string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldEqualFold(FieldStatus, v))
+}
+
+// StatusContainsFold applies the ContainsFold predicate on the "status" field.
+func StatusContainsFold(v string) predicate.CronTask {
+	return predicate.CronTask(sql.FieldContainsFold(FieldStatus, v))
+}
+
+// ScheduledAfterEQ applies the EQ predicate on the "scheduled_after" field.
+func ScheduledAfterEQ(v int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldEQ(FieldScheduledAfter, v))
+}
+
+// ScheduledAfterNEQ applies the NEQ predicate on the "scheduled_after" field.
+func ScheduledAfterNEQ(v int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldNEQ(FieldScheduledAfter, v))
+}
+
+// ScheduledAfterIn applies the In predicate on the "scheduled_after" field.
+func ScheduledAfterIn(vs ...int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldIn(FieldScheduledAfter, vs...))
+}
+
+// ScheduledAfterNotIn applies the NotIn predicate on the "scheduled_after" field.
+func ScheduledAfterNotIn(vs ...int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldNotIn(FieldScheduledAfter, vs...))
+}
+
+// ScheduledAfterGT applies the GT predicate on the "scheduled_after" field.
+func ScheduledAfterGT(v int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldGT(FieldScheduledAfter, v))
+}
+
+// ScheduledAfterGTE applies the GTE predicate on the "scheduled_after" field.
+func ScheduledAfterGTE(v int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldGTE(FieldScheduledAfter, v))
+}
+
+// ScheduledAfterLT applies the LT predicate on the "scheduled_after" field.
+func ScheduledAfterLT(v int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldLT(FieldScheduledAfter, v))
+}
+
+// ScheduledAfterLTE applies the LTE predicate on the "scheduled_after" field.
+func ScheduledAfterLTE(v int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldLTE(FieldScheduledAfter, v))
+}
+
+// LastRunEQ applies the EQ predicate on the "last_run" field.
+func LastRunEQ(v int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldEQ(FieldLastRun, v))
+}
+
+// LastRunNEQ applies the NEQ predicate on the "last_run" field.
+func LastRunNEQ(v int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldNEQ(FieldLastRun, v))
+}
+
+// LastRunIn applies the In predicate on the "last_run" field.
+func LastRunIn(vs ...int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldIn(FieldLastRun, vs...))
+}
+
+// LastRunNotIn applies the NotIn predicate on the "last_run" field.
+func LastRunNotIn(vs ...int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldNotIn(FieldLastRun, vs...))
+}
+
+// LastRunGT applies the GT predicate on the "last_run" field.
+func LastRunGT(v int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldGT(FieldLastRun, v))
+}
+
+// LastRunGTE applies the GTE predicate on the "last_run" field.
+func LastRunGTE(v int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldGTE(FieldLastRun, v))
+}
+
+// LastRunLT applies the LT predicate on the "last_run" field.
+func LastRunLT(v int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldLT(FieldLastRun, v))
+}
+
+// LastRunLTE applies the LTE predicate on the "last_run" field.
+func LastRunLTE(v int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldLTE(FieldLastRun, v))
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.CronTask) predicate.CronTask {
+	return predicate.CronTask(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.CronTask) predicate.CronTask {
+	return predicate.CronTask(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.CronTask) predicate.CronTask {
+	return predicate.CronTask(sql.NotPredicates(p))
+}
diff --git a/internal/database/ent/db/crontask_create.go b/internal/database/ent/db/crontask_create.go
new file mode 100644
index 00000000..40345b5d
--- /dev/null
+++ b/internal/database/ent/db/crontask_create.go
@@ -0,0 +1,369 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/crontask"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+// CronTaskCreate is the builder for creating a CronTask entity.
+type CronTaskCreate struct {
+	config
+	mutation *CronTaskMutation
+	hooks    []Hook
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (ctc *CronTaskCreate) SetCreatedAt(i int) *CronTaskCreate {
+	ctc.mutation.SetCreatedAt(i)
+	return ctc
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (ctc *CronTaskCreate) SetNillableCreatedAt(i *int) *CronTaskCreate {
+	if i != nil {
+		ctc.SetCreatedAt(*i)
+	}
+	return ctc
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (ctc *CronTaskCreate) SetUpdatedAt(i int) *CronTaskCreate {
+	ctc.mutation.SetUpdatedAt(i)
+	return ctc
+}
+
+// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
+func (ctc *CronTaskCreate) SetNillableUpdatedAt(i *int) *CronTaskCreate {
+	if i != nil {
+		ctc.SetUpdatedAt(*i)
+	}
+	return ctc
+}
+
+// SetType sets the "type" field.
+func (ctc *CronTaskCreate) SetType(s string) *CronTaskCreate {
+	ctc.mutation.SetType(s)
+	return ctc
+}
+
+// SetReferenceID sets the "reference_id" field.
+func (ctc *CronTaskCreate) SetReferenceID(s string) *CronTaskCreate {
+	ctc.mutation.SetReferenceID(s)
+	return ctc
+}
+
+// SetTargets sets the "targets" field.
+func (ctc *CronTaskCreate) SetTargets(s []string) *CronTaskCreate {
+	ctc.mutation.SetTargets(s)
+	return ctc
+}
+
+// SetStatus sets the "status" field.
+func (ctc *CronTaskCreate) SetStatus(s string) *CronTaskCreate {
+	ctc.mutation.SetStatus(s)
+	return ctc
+}
+
+// SetScheduledAfter sets the "scheduled_after" field.
+func (ctc *CronTaskCreate) SetScheduledAfter(i int) *CronTaskCreate {
+	ctc.mutation.SetScheduledAfter(i)
+	return ctc
+}
+
+// SetLastRun sets the "last_run" field.
+func (ctc *CronTaskCreate) SetLastRun(i int) *CronTaskCreate {
+	ctc.mutation.SetLastRun(i)
+	return ctc
+}
+
+// SetLogs sets the "logs" field.
+func (ctc *CronTaskCreate) SetLogs(ml []models.TaskLog) *CronTaskCreate {
+	ctc.mutation.SetLogs(ml)
+	return ctc
+}
+
+// SetData sets the "data" field.
+func (ctc *CronTaskCreate) SetData(m map[string]interface{}) *CronTaskCreate {
+	ctc.mutation.SetData(m)
+	return ctc
+}
+
+// SetID sets the "id" field.
+func (ctc *CronTaskCreate) SetID(s string) *CronTaskCreate {
+	ctc.mutation.SetID(s)
+	return ctc
+}
+
+// SetNillableID sets the "id" field if the given value is not nil.
+func (ctc *CronTaskCreate) SetNillableID(s *string) *CronTaskCreate {
+	if s != nil {
+		ctc.SetID(*s)
+	}
+	return ctc
+}
+
+// Mutation returns the CronTaskMutation object of the builder.
+func (ctc *CronTaskCreate) Mutation() *CronTaskMutation {
+	return ctc.mutation
+}
+
+// Save creates the CronTask in the database.
+func (ctc *CronTaskCreate) Save(ctx context.Context) (*CronTask, error) {
+	ctc.defaults()
+	return withHooks(ctx, ctc.sqlSave, ctc.mutation, ctc.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (ctc *CronTaskCreate) SaveX(ctx context.Context) *CronTask {
+	v, err := ctc.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (ctc *CronTaskCreate) Exec(ctx context.Context) error {
+	_, err := ctc.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (ctc *CronTaskCreate) ExecX(ctx context.Context) {
+	if err := ctc.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (ctc *CronTaskCreate) defaults() {
+	if _, ok := ctc.mutation.CreatedAt(); !ok {
+		v := crontask.DefaultCreatedAt()
+		ctc.mutation.SetCreatedAt(v)
+	}
+	if _, ok := ctc.mutation.UpdatedAt(); !ok {
+		v := crontask.DefaultUpdatedAt()
+		ctc.mutation.SetUpdatedAt(v)
+	}
+	if _, ok := ctc.mutation.ID(); !ok {
+		v := crontask.DefaultID()
+		ctc.mutation.SetID(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (ctc *CronTaskCreate) check() error {
+	if _, ok := ctc.mutation.CreatedAt(); !ok {
+		return &ValidationError{Name: "created_at", err: errors.New(`db: missing required field "CronTask.created_at"`)}
+	}
+	if _, ok := ctc.mutation.UpdatedAt(); !ok {
+		return &ValidationError{Name: "updated_at", err: errors.New(`db: missing required field "CronTask.updated_at"`)}
+	}
+	if _, ok := ctc.mutation.GetType(); !ok {
+		return &ValidationError{Name: "type", err: errors.New(`db: missing required field "CronTask.type"`)}
+	}
+	if v, ok := ctc.mutation.GetType(); ok {
+		if err := crontask.TypeValidator(v); err != nil {
+			return &ValidationError{Name: "type", err: fmt.Errorf(`db: validator failed for field "CronTask.type": %w`, err)}
+		}
+	}
+	if _, ok := ctc.mutation.ReferenceID(); !ok {
+		return &ValidationError{Name: "reference_id", err: errors.New(`db: missing required field "CronTask.reference_id"`)}
+	}
+	if v, ok := ctc.mutation.ReferenceID(); ok {
+		if err := crontask.ReferenceIDValidator(v); err != nil {
+			return &ValidationError{Name: "reference_id", err: fmt.Errorf(`db: validator failed for field "CronTask.reference_id": %w`, err)}
+		}
+	}
+	if _, ok := ctc.mutation.Targets(); !ok {
+		return &ValidationError{Name: "targets", err: errors.New(`db: missing required field "CronTask.targets"`)}
+	}
+	if _, ok := ctc.mutation.Status(); !ok {
+		return &ValidationError{Name: "status", err: errors.New(`db: missing required field "CronTask.status"`)}
+	}
+	if v, ok := ctc.mutation.Status(); ok {
+		if err := crontask.StatusValidator(v); err != nil {
+			return &ValidationError{Name: "status", err: fmt.Errorf(`db: validator failed for field "CronTask.status": %w`, err)}
+		}
+	}
+	if _, ok := ctc.mutation.ScheduledAfter(); !ok {
+		return &ValidationError{Name: "scheduled_after", err: errors.New(`db: missing required field "CronTask.scheduled_after"`)}
+	}
+	if _, ok := ctc.mutation.LastRun(); !ok {
+		return &ValidationError{Name: "last_run", err: errors.New(`db: missing required field "CronTask.last_run"`)}
+	}
+	if _, ok := ctc.mutation.Logs(); !ok {
+		return &ValidationError{Name: "logs", err: errors.New(`db: missing required field "CronTask.logs"`)}
+	}
+	if _, ok := ctc.mutation.Data(); !ok {
+		return &ValidationError{Name: "data", err: errors.New(`db: missing required field "CronTask.data"`)}
+	}
+	return nil
+}
+
+func (ctc *CronTaskCreate) sqlSave(ctx context.Context) (*CronTask, error) {
+	if err := ctc.check(); err != nil {
+		return nil, err
+	}
+	_node, _spec := ctc.createSpec()
+	if err := sqlgraph.CreateNode(ctx, ctc.driver, _spec); err != nil {
+		if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	if _spec.ID.Value != nil {
+		if id, ok := _spec.ID.Value.(string); ok {
+			_node.ID = id
+		} else {
+			return nil, fmt.Errorf("unexpected CronTask.ID type: %T", _spec.ID.Value)
+		}
+	}
+	ctc.mutation.id = &_node.ID
+	ctc.mutation.done = true
+	return _node, nil
+}
+
+func (ctc *CronTaskCreate) createSpec() (*CronTask, *sqlgraph.CreateSpec) {
+	var (
+		_node = &CronTask{config: ctc.config}
+		_spec = sqlgraph.NewCreateSpec(crontask.Table, sqlgraph.NewFieldSpec(crontask.FieldID, field.TypeString))
+	)
+	if id, ok := ctc.mutation.ID(); ok {
+		_node.ID = id
+		_spec.ID.Value = id
+	}
+	if value, ok := ctc.mutation.CreatedAt(); ok {
+		_spec.SetField(crontask.FieldCreatedAt, field.TypeInt, value)
+		_node.CreatedAt = value
+	}
+	if value, ok := ctc.mutation.UpdatedAt(); ok {
+		_spec.SetField(crontask.FieldUpdatedAt, field.TypeInt, value)
+		_node.UpdatedAt = value
+	}
+	if value, ok := ctc.mutation.GetType(); ok {
+		_spec.SetField(crontask.FieldType, field.TypeString, value)
+		_node.Type = value
+	}
+	if value, ok := ctc.mutation.ReferenceID(); ok {
+		_spec.SetField(crontask.FieldReferenceID, field.TypeString, value)
+		_node.ReferenceID = value
+	}
+	if value, ok := ctc.mutation.Targets(); ok {
+		_spec.SetField(crontask.FieldTargets, field.TypeJSON, value)
+		_node.Targets = value
+	}
+	if value, ok := ctc.mutation.Status(); ok {
+		_spec.SetField(crontask.FieldStatus, field.TypeString, value)
+		_node.Status = value
+	}
+	if value, ok := ctc.mutation.ScheduledAfter(); ok {
+		_spec.SetField(crontask.FieldScheduledAfter, field.TypeInt, value)
+		_node.ScheduledAfter = value
+	}
+	if value, ok := ctc.mutation.LastRun(); ok {
+		_spec.SetField(crontask.FieldLastRun, field.TypeInt, value)
+		_node.LastRun = value
+	}
+	if value, ok := ctc.mutation.Logs(); ok {
+		_spec.SetField(crontask.FieldLogs, field.TypeJSON, value)
+		_node.Logs = value
+	}
+	if value, ok := ctc.mutation.Data(); ok {
+		_spec.SetField(crontask.FieldData, field.TypeJSON, value)
+		_node.Data = value
+	}
+	return _node, _spec
+}
+
+// CronTaskCreateBulk is the builder for creating many CronTask entities in bulk.
+type CronTaskCreateBulk struct {
+	config
+	err      error
+	builders []*CronTaskCreate
+}
+
+// Save creates the CronTask entities in the database.
+func (ctcb *CronTaskCreateBulk) Save(ctx context.Context) ([]*CronTask, error) {
+	if ctcb.err != nil {
+		return nil, ctcb.err
+	}
+	specs := make([]*sqlgraph.CreateSpec, len(ctcb.builders))
+	nodes := make([]*CronTask, len(ctcb.builders))
+	mutators := make([]Mutator, len(ctcb.builders))
+	for i := range ctcb.builders {
+		func(i int, root context.Context) {
+			builder := ctcb.builders[i]
+			builder.defaults()
+			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+				mutation, ok := m.(*CronTaskMutation)
+				if !ok {
+					return nil, fmt.Errorf("unexpected mutation type %T", m)
+				}
+				if err := builder.check(); err != nil {
+					return nil, err
+				}
+				builder.mutation = mutation
+				var err error
+				nodes[i], specs[i] = builder.createSpec()
+				if i < len(mutators)-1 {
+					_, err = mutators[i+1].Mutate(root, ctcb.builders[i+1].mutation)
+				} else {
+					spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
+					// Invoke the actual operation on the latest mutation in the chain.
+					if err = sqlgraph.BatchCreate(ctx, ctcb.driver, spec); err != nil {
+						if sqlgraph.IsConstraintError(err) {
+							err = &ConstraintError{msg: err.Error(), wrap: err}
+						}
+					}
+				}
+				if err != nil {
+					return nil, err
+				}
+				mutation.id = &nodes[i].ID
+				mutation.done = true
+				return nodes[i], nil
+			})
+			for i := len(builder.hooks) - 1; i >= 0; i-- {
+				mut = builder.hooks[i](mut)
+			}
+			mutators[i] = mut
+		}(i, ctx)
+	}
+	if len(mutators) > 0 {
+		if _, err := mutators[0].Mutate(ctx, ctcb.builders[0].mutation); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (ctcb *CronTaskCreateBulk) SaveX(ctx context.Context) []*CronTask {
+	v, err := ctcb.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (ctcb *CronTaskCreateBulk) Exec(ctx context.Context) error {
+	_, err := ctcb.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (ctcb *CronTaskCreateBulk) ExecX(ctx context.Context) {
+	if err := ctcb.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/database/ent/db/crontask_delete.go b/internal/database/ent/db/crontask_delete.go
new file mode 100644
index 00000000..31943730
--- /dev/null
+++ b/internal/database/ent/db/crontask_delete.go
@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/crontask"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+)
+
+// CronTaskDelete is the builder for deleting a CronTask entity.
+type CronTaskDelete struct {
+	config
+	hooks    []Hook
+	mutation *CronTaskMutation
+}
+
+// Where appends a list predicates to the CronTaskDelete builder.
+func (ctd *CronTaskDelete) Where(ps ...predicate.CronTask) *CronTaskDelete {
+	ctd.mutation.Where(ps...)
+	return ctd
+}
+
+// Exec executes the deletion query and returns how many vertices were deleted.
+func (ctd *CronTaskDelete) Exec(ctx context.Context) (int, error) {
+	return withHooks(ctx, ctd.sqlExec, ctd.mutation, ctd.hooks)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (ctd *CronTaskDelete) ExecX(ctx context.Context) int {
+	n, err := ctd.Exec(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return n
+}
+
+func (ctd *CronTaskDelete) sqlExec(ctx context.Context) (int, error) {
+	_spec := sqlgraph.NewDeleteSpec(crontask.Table, sqlgraph.NewFieldSpec(crontask.FieldID, field.TypeString))
+	if ps := ctd.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	affected, err := sqlgraph.DeleteNodes(ctx, ctd.driver, _spec)
+	if err != nil && sqlgraph.IsConstraintError(err) {
+		err = &ConstraintError{msg: err.Error(), wrap: err}
+	}
+	ctd.mutation.done = true
+	return affected, err
+}
+
+// CronTaskDeleteOne is the builder for deleting a single CronTask entity.
+type CronTaskDeleteOne struct {
+	ctd *CronTaskDelete
+}
+
+// Where appends a list predicates to the CronTaskDelete builder.
+func (ctdo *CronTaskDeleteOne) Where(ps ...predicate.CronTask) *CronTaskDeleteOne {
+	ctdo.ctd.mutation.Where(ps...)
+	return ctdo
+}
+
+// Exec executes the deletion query.
+func (ctdo *CronTaskDeleteOne) Exec(ctx context.Context) error {
+	n, err := ctdo.ctd.Exec(ctx)
+	switch {
+	case err != nil:
+		return err
+	case n == 0:
+		return &NotFoundError{crontask.Label}
+	default:
+		return nil
+	}
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (ctdo *CronTaskDeleteOne) ExecX(ctx context.Context) {
+	if err := ctdo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/database/ent/db/crontask_query.go b/internal/database/ent/db/crontask_query.go
new file mode 100644
index 00000000..2ff7de14
--- /dev/null
+++ b/internal/database/ent/db/crontask_query.go
@@ -0,0 +1,526 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"fmt"
+	"math"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/crontask"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+)
+
+// CronTaskQuery is the builder for querying CronTask entities.
+type CronTaskQuery struct {
+	config
+	ctx        *QueryContext
+	order      []crontask.OrderOption
+	inters     []Interceptor
+	predicates []predicate.CronTask
+	// intermediate query (i.e. traversal path).
+	sql  *sql.Selector
+	path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the CronTaskQuery builder.
+func (ctq *CronTaskQuery) Where(ps ...predicate.CronTask) *CronTaskQuery {
+	ctq.predicates = append(ctq.predicates, ps...)
+	return ctq
+}
+
+// Limit the number of records to be returned by this query.
+func (ctq *CronTaskQuery) Limit(limit int) *CronTaskQuery {
+	ctq.ctx.Limit = &limit
+	return ctq
+}
+
+// Offset to start from.
+func (ctq *CronTaskQuery) Offset(offset int) *CronTaskQuery {
+	ctq.ctx.Offset = &offset
+	return ctq
+}
+
+// Unique configures the query builder to filter duplicate records on query.
+// By default, unique is set to true, and can be disabled using this method.
+func (ctq *CronTaskQuery) Unique(unique bool) *CronTaskQuery {
+	ctq.ctx.Unique = &unique
+	return ctq
+}
+
+// Order specifies how the records should be ordered.
+func (ctq *CronTaskQuery) Order(o ...crontask.OrderOption) *CronTaskQuery {
+	ctq.order = append(ctq.order, o...)
+	return ctq
+}
+
+// First returns the first CronTask entity from the query.
+// Returns a *NotFoundError when no CronTask was found.
+func (ctq *CronTaskQuery) First(ctx context.Context) (*CronTask, error) {
+	nodes, err := ctq.Limit(1).All(setContextOp(ctx, ctq.ctx, "First"))
+	if err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nil, &NotFoundError{crontask.Label}
+	}
+	return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (ctq *CronTaskQuery) FirstX(ctx context.Context) *CronTask {
+	node, err := ctq.First(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return node
+}
+
+// FirstID returns the first CronTask ID from the query.
+// Returns a *NotFoundError when no CronTask ID was found.
+func (ctq *CronTaskQuery) FirstID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = ctq.Limit(1).IDs(setContextOp(ctx, ctq.ctx, "FirstID")); err != nil {
+		return
+	}
+	if len(ids) == 0 {
+		err = &NotFoundError{crontask.Label}
+		return
+	}
+	return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (ctq *CronTaskQuery) FirstIDX(ctx context.Context) string {
+	id, err := ctq.FirstID(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return id
+}
+
+// Only returns a single CronTask entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one CronTask entity is found.
+// Returns a *NotFoundError when no CronTask entities are found.
+func (ctq *CronTaskQuery) Only(ctx context.Context) (*CronTask, error) {
+	nodes, err := ctq.Limit(2).All(setContextOp(ctx, ctq.ctx, "Only"))
+	if err != nil {
+		return nil, err
+	}
+	switch len(nodes) {
+	case 1:
+		return nodes[0], nil
+	case 0:
+		return nil, &NotFoundError{crontask.Label}
+	default:
+		return nil, &NotSingularError{crontask.Label}
+	}
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (ctq *CronTaskQuery) OnlyX(ctx context.Context) *CronTask {
+	node, err := ctq.Only(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// OnlyID is like Only, but returns the only CronTask ID in the query.
+// Returns a *NotSingularError when more than one CronTask ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (ctq *CronTaskQuery) OnlyID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = ctq.Limit(2).IDs(setContextOp(ctx, ctq.ctx, "OnlyID")); err != nil {
+		return
+	}
+	switch len(ids) {
+	case 1:
+		id = ids[0]
+	case 0:
+		err = &NotFoundError{crontask.Label}
+	default:
+		err = &NotSingularError{crontask.Label}
+	}
+	return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (ctq *CronTaskQuery) OnlyIDX(ctx context.Context) string {
+	id, err := ctq.OnlyID(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return id
+}
+
+// All executes the query and returns a list of CronTasks.
+func (ctq *CronTaskQuery) All(ctx context.Context) ([]*CronTask, error) {
+	ctx = setContextOp(ctx, ctq.ctx, "All")
+	if err := ctq.prepareQuery(ctx); err != nil {
+		return nil, err
+	}
+	qr := querierAll[[]*CronTask, *CronTaskQuery]()
+	return withInterceptors[[]*CronTask](ctx, ctq, qr, ctq.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (ctq *CronTaskQuery) AllX(ctx context.Context) []*CronTask {
+	nodes, err := ctq.All(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return nodes
+}
+
+// IDs executes the query and returns a list of CronTask IDs.
+func (ctq *CronTaskQuery) IDs(ctx context.Context) (ids []string, err error) {
+	if ctq.ctx.Unique == nil && ctq.path != nil {
+		ctq.Unique(true)
+	}
+	ctx = setContextOp(ctx, ctq.ctx, "IDs")
+	if err = ctq.Select(crontask.FieldID).Scan(ctx, &ids); err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (ctq *CronTaskQuery) IDsX(ctx context.Context) []string {
+	ids, err := ctq.IDs(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return ids
+}
+
+// Count returns the count of the given query.
+func (ctq *CronTaskQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, ctq.ctx, "Count")
+	if err := ctq.prepareQuery(ctx); err != nil {
+		return 0, err
+	}
+	return withInterceptors[int](ctx, ctq, querierCount[*CronTaskQuery](), ctq.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (ctq *CronTaskQuery) CountX(ctx context.Context) int {
+	count, err := ctq.Count(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (ctq *CronTaskQuery) Exist(ctx context.Context) (bool, error) {
+	ctx = setContextOp(ctx, ctq.ctx, "Exist")
+	switch _, err := ctq.FirstID(ctx); {
+	case IsNotFound(err):
+		return false, nil
+	case err != nil:
+		return false, fmt.Errorf("db: check existence: %w", err)
+	default:
+		return true, nil
+	}
+}
+
+// ExistX is like Exist, but panics if an error occurs.
+func (ctq *CronTaskQuery) ExistX(ctx context.Context) bool {
+	exist, err := ctq.Exist(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return exist
+}
+
+// Clone returns a duplicate of the CronTaskQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (ctq *CronTaskQuery) Clone() *CronTaskQuery {
+	if ctq == nil {
+		return nil
+	}
+	return &CronTaskQuery{
+		config:     ctq.config,
+		ctx:        ctq.ctx.Clone(),
+		order:      append([]crontask.OrderOption{}, ctq.order...),
+		inters:     append([]Interceptor{}, ctq.inters...),
+		predicates: append([]predicate.CronTask{}, ctq.predicates...),
+		// clone intermediate query.
+		sql:  ctq.sql.Clone(),
+		path: ctq.path,
+	}
+}
+
+// GroupBy is used to group vertices by one or more fields/columns.
+// It is often used with aggregate functions, like: count, max, mean, min, sum.
+//
+// Example:
+//
+//	var v []struct {
+//		CreatedAt int `json:"created_at,omitempty"`
+//		Count int `json:"count,omitempty"`
+//	}
+//
+//	client.CronTask.Query().
+//		GroupBy(crontask.FieldCreatedAt).
+//		Aggregate(db.Count()).
+//		Scan(ctx, &v)
+func (ctq *CronTaskQuery) GroupBy(field string, fields ...string) *CronTaskGroupBy {
+	ctq.ctx.Fields = append([]string{field}, fields...)
+	grbuild := &CronTaskGroupBy{build: ctq}
+	grbuild.flds = &ctq.ctx.Fields
+	grbuild.label = crontask.Label
+	grbuild.scan = grbuild.Scan
+	return grbuild
+}
+
+// Select allows the selection one or more fields/columns for the given query,
+// instead of selecting all fields in the entity.
+//
+// Example:
+//
+//	var v []struct {
+//		CreatedAt int `json:"created_at,omitempty"`
+//	}
+//
+//	client.CronTask.Query().
+//		Select(crontask.FieldCreatedAt).
+//		Scan(ctx, &v)
+func (ctq *CronTaskQuery) Select(fields ...string) *CronTaskSelect {
+	ctq.ctx.Fields = append(ctq.ctx.Fields, fields...)
+	sbuild := &CronTaskSelect{CronTaskQuery: ctq}
+	sbuild.label = crontask.Label
+	sbuild.flds, sbuild.scan = &ctq.ctx.Fields, sbuild.Scan
+	return sbuild
+}
+
+// Aggregate returns a CronTaskSelect configured with the given aggregations.
+func (ctq *CronTaskQuery) Aggregate(fns ...AggregateFunc) *CronTaskSelect {
+	return ctq.Select().Aggregate(fns...)
+}
+
+func (ctq *CronTaskQuery) prepareQuery(ctx context.Context) error {
+	for _, inter := range ctq.inters {
+		if inter == nil {
+			return fmt.Errorf("db: uninitialized interceptor (forgotten import db/runtime?)")
+		}
+		if trv, ok := inter.(Traverser); ok {
+			if err := trv.Traverse(ctx, ctq); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range ctq.ctx.Fields {
+		if !crontask.ValidColumn(f) {
+			return &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+		}
+	}
+	if ctq.path != nil {
+		prev, err := ctq.path(ctx)
+		if err != nil {
+			return err
+		}
+		ctq.sql = prev
+	}
+	return nil
+}
+
+func (ctq *CronTaskQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*CronTask, error) {
+	var (
+		nodes = []*CronTask{}
+		_spec = ctq.querySpec()
+	)
+	_spec.ScanValues = func(columns []string) ([]any, error) {
+		return (*CronTask).scanValues(nil, columns)
+	}
+	_spec.Assign = func(columns []string, values []any) error {
+		node := &CronTask{config: ctq.config}
+		nodes = append(nodes, node)
+		return node.assignValues(columns, values)
+	}
+	for i := range hooks {
+		hooks[i](ctx, _spec)
+	}
+	if err := sqlgraph.QueryNodes(ctx, ctq.driver, _spec); err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nodes, nil
+	}
+	return nodes, nil
+}
+
+func (ctq *CronTaskQuery) sqlCount(ctx context.Context) (int, error) {
+	_spec := ctq.querySpec()
+	_spec.Node.Columns = ctq.ctx.Fields
+	if len(ctq.ctx.Fields) > 0 {
+		_spec.Unique = ctq.ctx.Unique != nil && *ctq.ctx.Unique
+	}
+	return sqlgraph.CountNodes(ctx, ctq.driver, _spec)
+}
+
+func (ctq *CronTaskQuery) querySpec() *sqlgraph.QuerySpec {
+	_spec := sqlgraph.NewQuerySpec(crontask.Table, crontask.Columns, sqlgraph.NewFieldSpec(crontask.FieldID, field.TypeString))
+	_spec.From = ctq.sql
+	if unique := ctq.ctx.Unique; unique != nil {
+		_spec.Unique = *unique
+	} else if ctq.path != nil {
+		_spec.Unique = true
+	}
+	if fields := ctq.ctx.Fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, crontask.FieldID)
+		for i := range fields {
+			if fields[i] != crontask.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+			}
+		}
+	}
+	if ps := ctq.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if limit := ctq.ctx.Limit; limit != nil {
+		_spec.Limit = *limit
+	}
+	if offset := ctq.ctx.Offset; offset != nil {
+		_spec.Offset = *offset
+	}
+	if ps := ctq.order; len(ps) > 0 {
+		_spec.Order = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	return _spec
+}
+
+func (ctq *CronTaskQuery) sqlQuery(ctx context.Context) *sql.Selector {
+	builder := sql.Dialect(ctq.driver.Dialect())
+	t1 := builder.Table(crontask.Table)
+	columns := ctq.ctx.Fields
+	if len(columns) == 0 {
+		columns = crontask.Columns
+	}
+	selector := builder.Select(t1.Columns(columns...)...).From(t1)
+	if ctq.sql != nil {
+		selector = ctq.sql
+		selector.Select(selector.Columns(columns...)...)
+	}
+	if ctq.ctx.Unique != nil && *ctq.ctx.Unique {
+		selector.Distinct()
+	}
+	for _, p := range ctq.predicates {
+		p(selector)
+	}
+	for _, p := range ctq.order {
+		p(selector)
+	}
+	if offset := ctq.ctx.Offset; offset != nil {
+		// limit is mandatory for offset clause. We start
+		// with default value, and override it below if needed.
+		selector.Offset(*offset).Limit(math.MaxInt32)
+	}
+	if limit := ctq.ctx.Limit; limit != nil {
+		selector.Limit(*limit)
+	}
+	return selector
+}
+
+// CronTaskGroupBy is the group-by builder for CronTask entities.
+type CronTaskGroupBy struct {
+	selector
+	build *CronTaskQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (ctgb *CronTaskGroupBy) Aggregate(fns ...AggregateFunc) *CronTaskGroupBy {
+	ctgb.fns = append(ctgb.fns, fns...)
+	return ctgb
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (ctgb *CronTaskGroupBy) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, ctgb.build.ctx, "GroupBy")
+	if err := ctgb.build.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*CronTaskQuery, *CronTaskGroupBy](ctx, ctgb.build, ctgb, ctgb.build.inters, v)
+}
+
+func (ctgb *CronTaskGroupBy) sqlScan(ctx context.Context, root *CronTaskQuery, v any) error {
+	selector := root.sqlQuery(ctx).Select()
+	aggregation := make([]string, 0, len(ctgb.fns))
+	for _, fn := range ctgb.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*ctgb.flds)+len(ctgb.fns))
+		for _, f := range *ctgb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*ctgb.flds...)...)
+	if err := selector.Err(); err != nil {
+		return err
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := ctgb.build.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
+
+// CronTaskSelect is the builder for selecting fields of CronTask entities.
+type CronTaskSelect struct {
+	*CronTaskQuery
+	selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (cts *CronTaskSelect) Aggregate(fns ...AggregateFunc) *CronTaskSelect {
+	cts.fns = append(cts.fns, fns...)
+	return cts
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (cts *CronTaskSelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, cts.ctx, "Select")
+	if err := cts.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*CronTaskQuery, *CronTaskSelect](ctx, cts.CronTaskQuery, cts, cts.inters, v)
+}
+
+func (cts *CronTaskSelect) sqlScan(ctx context.Context, root *CronTaskQuery, v any) error {
+	selector := root.sqlQuery(ctx)
+	aggregation := make([]string, 0, len(cts.fns))
+	for _, fn := range cts.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	switch n := len(*cts.selector.flds); {
+	case n == 0 && len(aggregation) > 0:
+		selector.Select(aggregation...)
+	case n != 0 && len(aggregation) > 0:
+		selector.AppendSelect(aggregation...)
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := cts.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
diff --git a/internal/database/ent/db/crontask_update.go b/internal/database/ent/db/crontask_update.go
new file mode 100644
index 00000000..1d3bd10f
--- /dev/null
+++ b/internal/database/ent/db/crontask_update.go
@@ -0,0 +1,587 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/dialect/sql/sqljson"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/crontask"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+// CronTaskUpdate is the builder for updating CronTask entities.
+type CronTaskUpdate struct {
+	config
+	hooks    []Hook
+	mutation *CronTaskMutation
+}
+
+// Where appends a list predicates to the CronTaskUpdate builder.
+func (ctu *CronTaskUpdate) Where(ps ...predicate.CronTask) *CronTaskUpdate {
+	ctu.mutation.Where(ps...)
+	return ctu
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (ctu *CronTaskUpdate) SetUpdatedAt(i int) *CronTaskUpdate {
+	ctu.mutation.ResetUpdatedAt()
+	ctu.mutation.SetUpdatedAt(i)
+	return ctu
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (ctu *CronTaskUpdate) AddUpdatedAt(i int) *CronTaskUpdate {
+	ctu.mutation.AddUpdatedAt(i)
+	return ctu
+}
+
+// SetType sets the "type" field.
+func (ctu *CronTaskUpdate) SetType(s string) *CronTaskUpdate {
+	ctu.mutation.SetType(s)
+	return ctu
+}
+
+// SetNillableType sets the "type" field if the given value is not nil.
+func (ctu *CronTaskUpdate) SetNillableType(s *string) *CronTaskUpdate {
+	if s != nil {
+		ctu.SetType(*s)
+	}
+	return ctu
+}
+
+// SetReferenceID sets the "reference_id" field.
+func (ctu *CronTaskUpdate) SetReferenceID(s string) *CronTaskUpdate {
+	ctu.mutation.SetReferenceID(s)
+	return ctu
+}
+
+// SetNillableReferenceID sets the "reference_id" field if the given value is not nil.
+func (ctu *CronTaskUpdate) SetNillableReferenceID(s *string) *CronTaskUpdate {
+	if s != nil {
+		ctu.SetReferenceID(*s)
+	}
+	return ctu
+}
+
+// SetTargets sets the "targets" field.
+func (ctu *CronTaskUpdate) SetTargets(s []string) *CronTaskUpdate {
+	ctu.mutation.SetTargets(s)
+	return ctu
+}
+
+// AppendTargets appends s to the "targets" field.
+func (ctu *CronTaskUpdate) AppendTargets(s []string) *CronTaskUpdate {
+	ctu.mutation.AppendTargets(s)
+	return ctu
+}
+
+// SetStatus sets the "status" field.
+func (ctu *CronTaskUpdate) SetStatus(s string) *CronTaskUpdate {
+	ctu.mutation.SetStatus(s)
+	return ctu
+}
+
+// SetNillableStatus sets the "status" field if the given value is not nil.
+func (ctu *CronTaskUpdate) SetNillableStatus(s *string) *CronTaskUpdate {
+	if s != nil {
+		ctu.SetStatus(*s)
+	}
+	return ctu
+}
+
+// SetScheduledAfter sets the "scheduled_after" field.
+func (ctu *CronTaskUpdate) SetScheduledAfter(i int) *CronTaskUpdate {
+	ctu.mutation.ResetScheduledAfter()
+	ctu.mutation.SetScheduledAfter(i)
+	return ctu
+}
+
+// SetNillableScheduledAfter sets the "scheduled_after" field if the given value is not nil.
+func (ctu *CronTaskUpdate) SetNillableScheduledAfter(i *int) *CronTaskUpdate {
+	if i != nil {
+		ctu.SetScheduledAfter(*i)
+	}
+	return ctu
+}
+
+// AddScheduledAfter adds i to the "scheduled_after" field.
+func (ctu *CronTaskUpdate) AddScheduledAfter(i int) *CronTaskUpdate {
+	ctu.mutation.AddScheduledAfter(i)
+	return ctu
+}
+
+// SetLastRun sets the "last_run" field.
+func (ctu *CronTaskUpdate) SetLastRun(i int) *CronTaskUpdate {
+	ctu.mutation.ResetLastRun()
+	ctu.mutation.SetLastRun(i)
+	return ctu
+}
+
+// SetNillableLastRun sets the "last_run" field if the given value is not nil.
+func (ctu *CronTaskUpdate) SetNillableLastRun(i *int) *CronTaskUpdate {
+	if i != nil {
+		ctu.SetLastRun(*i)
+	}
+	return ctu
+}
+
+// AddLastRun adds i to the "last_run" field.
+func (ctu *CronTaskUpdate) AddLastRun(i int) *CronTaskUpdate {
+	ctu.mutation.AddLastRun(i)
+	return ctu
+}
+
+// SetLogs sets the "logs" field.
+func (ctu *CronTaskUpdate) SetLogs(ml []models.TaskLog) *CronTaskUpdate {
+	ctu.mutation.SetLogs(ml)
+	return ctu
+}
+
+// AppendLogs appends ml to the "logs" field.
+func (ctu *CronTaskUpdate) AppendLogs(ml []models.TaskLog) *CronTaskUpdate {
+	ctu.mutation.AppendLogs(ml)
+	return ctu
+}
+
+// SetData sets the "data" field.
+func (ctu *CronTaskUpdate) SetData(m map[string]interface{}) *CronTaskUpdate {
+	ctu.mutation.SetData(m)
+	return ctu
+}
+
+// Mutation returns the CronTaskMutation object of the builder.
+func (ctu *CronTaskUpdate) Mutation() *CronTaskMutation {
+	return ctu.mutation
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (ctu *CronTaskUpdate) Save(ctx context.Context) (int, error) {
+	ctu.defaults()
+	return withHooks(ctx, ctu.sqlSave, ctu.mutation, ctu.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (ctu *CronTaskUpdate) SaveX(ctx context.Context) int {
+	affected, err := ctu.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return affected
+}
+
+// Exec executes the query.
+func (ctu *CronTaskUpdate) Exec(ctx context.Context) error {
+	_, err := ctu.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (ctu *CronTaskUpdate) ExecX(ctx context.Context) {
+	if err := ctu.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (ctu *CronTaskUpdate) defaults() {
+	if _, ok := ctu.mutation.UpdatedAt(); !ok {
+		v := crontask.UpdateDefaultUpdatedAt()
+		ctu.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (ctu *CronTaskUpdate) check() error {
+	if v, ok := ctu.mutation.GetType(); ok {
+		if err := crontask.TypeValidator(v); err != nil {
+			return &ValidationError{Name: "type", err: fmt.Errorf(`db: validator failed for field "CronTask.type": %w`, err)}
+		}
+	}
+	if v, ok := ctu.mutation.ReferenceID(); ok {
+		if err := crontask.ReferenceIDValidator(v); err != nil {
+			return &ValidationError{Name: "reference_id", err: fmt.Errorf(`db: validator failed for field "CronTask.reference_id": %w`, err)}
+		}
+	}
+	if v, ok := ctu.mutation.Status(); ok {
+		if err := crontask.StatusValidator(v); err != nil {
+			return &ValidationError{Name: "status", err: fmt.Errorf(`db: validator failed for field "CronTask.status": %w`, err)}
+		}
+	}
+	return nil
+}
+
+func (ctu *CronTaskUpdate) sqlSave(ctx context.Context) (n int, err error) {
+	if err := ctu.check(); err != nil {
+		return n, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(crontask.Table, crontask.Columns, sqlgraph.NewFieldSpec(crontask.FieldID, field.TypeString))
+	if ps := ctu.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := ctu.mutation.UpdatedAt(); ok {
+		_spec.SetField(crontask.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := ctu.mutation.AddedUpdatedAt(); ok {
+		_spec.AddField(crontask.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := ctu.mutation.GetType(); ok {
+		_spec.SetField(crontask.FieldType, field.TypeString, value)
+	}
+	if value, ok := ctu.mutation.ReferenceID(); ok {
+		_spec.SetField(crontask.FieldReferenceID, field.TypeString, value)
+	}
+	if value, ok := ctu.mutation.Targets(); ok {
+		_spec.SetField(crontask.FieldTargets, field.TypeJSON, value)
+	}
+	if value, ok := ctu.mutation.AppendedTargets(); ok {
+		_spec.AddModifier(func(u *sql.UpdateBuilder) {
+			sqljson.Append(u, crontask.FieldTargets, value)
+		})
+	}
+	if value, ok := ctu.mutation.Status(); ok {
+		_spec.SetField(crontask.FieldStatus, field.TypeString, value)
+	}
+	if value, ok := ctu.mutation.ScheduledAfter(); ok {
+		_spec.SetField(crontask.FieldScheduledAfter, field.TypeInt, value)
+	}
+	if value, ok := ctu.mutation.AddedScheduledAfter(); ok {
+		_spec.AddField(crontask.FieldScheduledAfter, field.TypeInt, value)
+	}
+	if value, ok := ctu.mutation.LastRun(); ok {
+		_spec.SetField(crontask.FieldLastRun, field.TypeInt, value)
+	}
+	if value, ok := ctu.mutation.AddedLastRun(); ok {
+		_spec.AddField(crontask.FieldLastRun, field.TypeInt, value)
+	}
+	if value, ok := ctu.mutation.Logs(); ok {
+		_spec.SetField(crontask.FieldLogs, field.TypeJSON, value)
+	}
+	if value, ok := ctu.mutation.AppendedLogs(); ok {
+		_spec.AddModifier(func(u *sql.UpdateBuilder) {
+			sqljson.Append(u, crontask.FieldLogs, value)
+		})
+	}
+	if value, ok := ctu.mutation.Data(); ok {
+		_spec.SetField(crontask.FieldData, field.TypeJSON, value)
+	}
+	if n, err = sqlgraph.UpdateNodes(ctx, ctu.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{crontask.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return 0, err
+	}
+	ctu.mutation.done = true
+	return n, nil
+}
+
+// CronTaskUpdateOne is the builder for updating a single CronTask entity.
+type CronTaskUpdateOne struct {
+	config
+	fields   []string
+	hooks    []Hook
+	mutation *CronTaskMutation
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (ctuo *CronTaskUpdateOne) SetUpdatedAt(i int) *CronTaskUpdateOne {
+	ctuo.mutation.ResetUpdatedAt()
+	ctuo.mutation.SetUpdatedAt(i)
+	return ctuo
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (ctuo *CronTaskUpdateOne) AddUpdatedAt(i int) *CronTaskUpdateOne {
+	ctuo.mutation.AddUpdatedAt(i)
+	return ctuo
+}
+
+// SetType sets the "type" field.
+func (ctuo *CronTaskUpdateOne) SetType(s string) *CronTaskUpdateOne {
+	ctuo.mutation.SetType(s)
+	return ctuo
+}
+
+// SetNillableType sets the "type" field if the given value is not nil.
+func (ctuo *CronTaskUpdateOne) SetNillableType(s *string) *CronTaskUpdateOne {
+	if s != nil {
+		ctuo.SetType(*s)
+	}
+	return ctuo
+}
+
+// SetReferenceID sets the "reference_id" field.
+func (ctuo *CronTaskUpdateOne) SetReferenceID(s string) *CronTaskUpdateOne {
+	ctuo.mutation.SetReferenceID(s)
+	return ctuo
+}
+
+// SetNillableReferenceID sets the "reference_id" field if the given value is not nil.
+func (ctuo *CronTaskUpdateOne) SetNillableReferenceID(s *string) *CronTaskUpdateOne {
+	if s != nil {
+		ctuo.SetReferenceID(*s)
+	}
+	return ctuo
+}
+
+// SetTargets sets the "targets" field.
+func (ctuo *CronTaskUpdateOne) SetTargets(s []string) *CronTaskUpdateOne {
+	ctuo.mutation.SetTargets(s)
+	return ctuo
+}
+
+// AppendTargets appends s to the "targets" field.
+func (ctuo *CronTaskUpdateOne) AppendTargets(s []string) *CronTaskUpdateOne {
+	ctuo.mutation.AppendTargets(s)
+	return ctuo
+}
+
+// SetStatus sets the "status" field.
+func (ctuo *CronTaskUpdateOne) SetStatus(s string) *CronTaskUpdateOne {
+	ctuo.mutation.SetStatus(s)
+	return ctuo
+}
+
+// SetNillableStatus sets the "status" field if the given value is not nil.
+func (ctuo *CronTaskUpdateOne) SetNillableStatus(s *string) *CronTaskUpdateOne {
+	if s != nil {
+		ctuo.SetStatus(*s)
+	}
+	return ctuo
+}
+
+// SetScheduledAfter sets the "scheduled_after" field.
+func (ctuo *CronTaskUpdateOne) SetScheduledAfter(i int) *CronTaskUpdateOne {
+	ctuo.mutation.ResetScheduledAfter()
+	ctuo.mutation.SetScheduledAfter(i)
+	return ctuo
+}
+
+// SetNillableScheduledAfter sets the "scheduled_after" field if the given value is not nil.
+func (ctuo *CronTaskUpdateOne) SetNillableScheduledAfter(i *int) *CronTaskUpdateOne {
+	if i != nil {
+		ctuo.SetScheduledAfter(*i)
+	}
+	return ctuo
+}
+
+// AddScheduledAfter adds i to the "scheduled_after" field.
+func (ctuo *CronTaskUpdateOne) AddScheduledAfter(i int) *CronTaskUpdateOne {
+	ctuo.mutation.AddScheduledAfter(i)
+	return ctuo
+}
+
+// SetLastRun sets the "last_run" field.
+func (ctuo *CronTaskUpdateOne) SetLastRun(i int) *CronTaskUpdateOne {
+	ctuo.mutation.ResetLastRun()
+	ctuo.mutation.SetLastRun(i)
+	return ctuo
+}
+
+// SetNillableLastRun sets the "last_run" field if the given value is not nil.
+func (ctuo *CronTaskUpdateOne) SetNillableLastRun(i *int) *CronTaskUpdateOne {
+	if i != nil {
+		ctuo.SetLastRun(*i)
+	}
+	return ctuo
+}
+
+// AddLastRun adds i to the "last_run" field.
+func (ctuo *CronTaskUpdateOne) AddLastRun(i int) *CronTaskUpdateOne {
+	ctuo.mutation.AddLastRun(i)
+	return ctuo
+}
+
+// SetLogs sets the "logs" field.
+func (ctuo *CronTaskUpdateOne) SetLogs(ml []models.TaskLog) *CronTaskUpdateOne {
+	ctuo.mutation.SetLogs(ml)
+	return ctuo
+}
+
+// AppendLogs appends ml to the "logs" field.
+func (ctuo *CronTaskUpdateOne) AppendLogs(ml []models.TaskLog) *CronTaskUpdateOne {
+	ctuo.mutation.AppendLogs(ml)
+	return ctuo
+}
+
+// SetData sets the "data" field.
+func (ctuo *CronTaskUpdateOne) SetData(m map[string]interface{}) *CronTaskUpdateOne {
+	ctuo.mutation.SetData(m)
+	return ctuo
+}
+
+// Mutation returns the CronTaskMutation object of the builder.
+func (ctuo *CronTaskUpdateOne) Mutation() *CronTaskMutation {
+	return ctuo.mutation
+}
+
+// Where appends a list predicates to the CronTaskUpdate builder.
+func (ctuo *CronTaskUpdateOne) Where(ps ...predicate.CronTask) *CronTaskUpdateOne {
+	ctuo.mutation.Where(ps...)
+	return ctuo
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (ctuo *CronTaskUpdateOne) Select(field string, fields ...string) *CronTaskUpdateOne {
+	ctuo.fields = append([]string{field}, fields...)
+	return ctuo
+}
+
+// Save executes the query and returns the updated CronTask entity.
+func (ctuo *CronTaskUpdateOne) Save(ctx context.Context) (*CronTask, error) {
+	ctuo.defaults()
+	return withHooks(ctx, ctuo.sqlSave, ctuo.mutation, ctuo.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (ctuo *CronTaskUpdateOne) SaveX(ctx context.Context) *CronTask {
+	node, err := ctuo.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// Exec executes the query on the entity.
+func (ctuo *CronTaskUpdateOne) Exec(ctx context.Context) error {
+	_, err := ctuo.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (ctuo *CronTaskUpdateOne) ExecX(ctx context.Context) {
+	if err := ctuo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (ctuo *CronTaskUpdateOne) defaults() {
+	if _, ok := ctuo.mutation.UpdatedAt(); !ok {
+		v := crontask.UpdateDefaultUpdatedAt()
+		ctuo.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (ctuo *CronTaskUpdateOne) check() error {
+	if v, ok := ctuo.mutation.GetType(); ok {
+		if err := crontask.TypeValidator(v); err != nil {
+			return &ValidationError{Name: "type", err: fmt.Errorf(`db: validator failed for field "CronTask.type": %w`, err)}
+		}
+	}
+	if v, ok := ctuo.mutation.ReferenceID(); ok {
+		if err := crontask.ReferenceIDValidator(v); err != nil {
+			return &ValidationError{Name: "reference_id", err: fmt.Errorf(`db: validator failed for field "CronTask.reference_id": %w`, err)}
+		}
+	}
+	if v, ok := ctuo.mutation.Status(); ok {
+		if err := crontask.StatusValidator(v); err != nil {
+			return &ValidationError{Name: "status", err: fmt.Errorf(`db: validator failed for field "CronTask.status": %w`, err)}
+		}
+	}
+	return nil
+}
+
+func (ctuo *CronTaskUpdateOne) sqlSave(ctx context.Context) (_node *CronTask, err error) {
+	if err := ctuo.check(); err != nil {
+		return _node, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(crontask.Table, crontask.Columns, sqlgraph.NewFieldSpec(crontask.FieldID, field.TypeString))
+	id, ok := ctuo.mutation.ID()
+	if !ok {
+		return nil, &ValidationError{Name: "id", err: errors.New(`db: missing "CronTask.id" for update`)}
+	}
+	_spec.Node.ID.Value = id
+	if fields := ctuo.fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, crontask.FieldID)
+		for _, f := range fields {
+			if !crontask.ValidColumn(f) {
+				return nil, &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+			}
+			if f != crontask.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, f)
+			}
+		}
+	}
+	if ps := ctuo.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := ctuo.mutation.UpdatedAt(); ok {
+		_spec.SetField(crontask.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := ctuo.mutation.AddedUpdatedAt(); ok {
+		_spec.AddField(crontask.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := ctuo.mutation.GetType(); ok {
+		_spec.SetField(crontask.FieldType, field.TypeString, value)
+	}
+	if value, ok := ctuo.mutation.ReferenceID(); ok {
+		_spec.SetField(crontask.FieldReferenceID, field.TypeString, value)
+	}
+	if value, ok := ctuo.mutation.Targets(); ok {
+		_spec.SetField(crontask.FieldTargets, field.TypeJSON, value)
+	}
+	if value, ok := ctuo.mutation.AppendedTargets(); ok {
+		_spec.AddModifier(func(u *sql.UpdateBuilder) {
+			sqljson.Append(u, crontask.FieldTargets, value)
+		})
+	}
+	if value, ok := ctuo.mutation.Status(); ok {
+		_spec.SetField(crontask.FieldStatus, field.TypeString, value)
+	}
+	if value, ok := ctuo.mutation.ScheduledAfter(); ok {
+		_spec.SetField(crontask.FieldScheduledAfter, field.TypeInt, value)
+	}
+	if value, ok := ctuo.mutation.AddedScheduledAfter(); ok {
+		_spec.AddField(crontask.FieldScheduledAfter, field.TypeInt, value)
+	}
+	if value, ok := ctuo.mutation.LastRun(); ok {
+		_spec.SetField(crontask.FieldLastRun, field.TypeInt, value)
+	}
+	if value, ok := ctuo.mutation.AddedLastRun(); ok {
+		_spec.AddField(crontask.FieldLastRun, field.TypeInt, value)
+	}
+	if value, ok := ctuo.mutation.Logs(); ok {
+		_spec.SetField(crontask.FieldLogs, field.TypeJSON, value)
+	}
+	if value, ok := ctuo.mutation.AppendedLogs(); ok {
+		_spec.AddModifier(func(u *sql.UpdateBuilder) {
+			sqljson.Append(u, crontask.FieldLogs, value)
+		})
+	}
+	if value, ok := ctuo.mutation.Data(); ok {
+		_spec.SetField(crontask.FieldData, field.TypeJSON, value)
+	}
+	_node = &CronTask{config: ctuo.config}
+	_spec.Assign = _node.assignValues
+	_spec.ScanValues = _node.scanValues
+	if err = sqlgraph.UpdateNode(ctx, ctuo.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{crontask.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	ctuo.mutation.done = true
+	return _node, nil
+}
diff --git a/internal/database/ent/db/ent.go b/internal/database/ent/db/ent.go
new file mode 100644
index 00000000..bcaa9136
--- /dev/null
+++ b/internal/database/ent/db/ent.go
@@ -0,0 +1,634 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"reflect"
+	"sync"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"github.com/cufee/aftermath/internal/database/ent/db/account"
+	"github.com/cufee/aftermath/internal/database/ent/db/accountsnapshot"
+	"github.com/cufee/aftermath/internal/database/ent/db/achievementssnapshot"
+	"github.com/cufee/aftermath/internal/database/ent/db/appconfiguration"
+	"github.com/cufee/aftermath/internal/database/ent/db/applicationcommand"
+	"github.com/cufee/aftermath/internal/database/ent/db/clan"
+	"github.com/cufee/aftermath/internal/database/ent/db/crontask"
+	"github.com/cufee/aftermath/internal/database/ent/db/user"
+	"github.com/cufee/aftermath/internal/database/ent/db/userconnection"
+	"github.com/cufee/aftermath/internal/database/ent/db/usercontent"
+	"github.com/cufee/aftermath/internal/database/ent/db/usersubscription"
+	"github.com/cufee/aftermath/internal/database/ent/db/vehicle"
+	"github.com/cufee/aftermath/internal/database/ent/db/vehicleaverage"
+	"github.com/cufee/aftermath/internal/database/ent/db/vehiclesnapshot"
+)
+
+// ent aliases to avoid import conflicts in user's code.
+type (
+	Op            = ent.Op
+	Hook          = ent.Hook
+	Value         = ent.Value
+	Query         = ent.Query
+	QueryContext  = ent.QueryContext
+	Querier       = ent.Querier
+	QuerierFunc   = ent.QuerierFunc
+	Interceptor   = ent.Interceptor
+	InterceptFunc = ent.InterceptFunc
+	Traverser     = ent.Traverser
+	TraverseFunc  = ent.TraverseFunc
+	Policy        = ent.Policy
+	Mutator       = ent.Mutator
+	Mutation      = ent.Mutation
+	MutateFunc    = ent.MutateFunc
+)
+
+type clientCtxKey struct{}
+
+// FromContext returns a Client stored inside a context, or nil if there isn't one.
+func FromContext(ctx context.Context) *Client {
+	c, _ := ctx.Value(clientCtxKey{}).(*Client)
+	return c
+}
+
+// NewContext returns a new context with the given Client attached.
+func NewContext(parent context.Context, c *Client) context.Context {
+	return context.WithValue(parent, clientCtxKey{}, c)
+}
+
+type txCtxKey struct{}
+
+// TxFromContext returns a Tx stored inside a context, or nil if there isn't one.
+func TxFromContext(ctx context.Context) *Tx {
+	tx, _ := ctx.Value(txCtxKey{}).(*Tx)
+	return tx
+}
+
+// NewTxContext returns a new context with the given Tx attached.
+func NewTxContext(parent context.Context, tx *Tx) context.Context {
+	return context.WithValue(parent, txCtxKey{}, tx)
+}
+
+// OrderFunc applies an ordering on the sql selector.
+// Deprecated: Use Asc/Desc functions or the package builders instead.
+type OrderFunc func(*sql.Selector)
+
+var (
+	initCheck   sync.Once
+	columnCheck sql.ColumnCheck
+)
+
+// columnChecker checks if the column exists in the given table.
+func checkColumn(table, column string) error {
+	initCheck.Do(func() {
+		columnCheck = sql.NewColumnCheck(map[string]func(string) bool{
+			account.Table:              account.ValidColumn,
+			accountsnapshot.Table:      accountsnapshot.ValidColumn,
+			achievementssnapshot.Table: achievementssnapshot.ValidColumn,
+			appconfiguration.Table:     appconfiguration.ValidColumn,
+			applicationcommand.Table:   applicationcommand.ValidColumn,
+			clan.Table:                 clan.ValidColumn,
+			crontask.Table:             crontask.ValidColumn,
+			user.Table:                 user.ValidColumn,
+			userconnection.Table:       userconnection.ValidColumn,
+			usercontent.Table:          usercontent.ValidColumn,
+			usersubscription.Table:     usersubscription.ValidColumn,
+			vehicle.Table:              vehicle.ValidColumn,
+			vehicleaverage.Table:       vehicleaverage.ValidColumn,
+			vehiclesnapshot.Table:      vehiclesnapshot.ValidColumn,
+		})
+	})
+	return columnCheck(table, column)
+}
+
+// Asc applies the given fields in ASC order.
+func Asc(fields ...string) func(*sql.Selector) {
+	return func(s *sql.Selector) {
+		for _, f := range fields {
+			if err := checkColumn(s.TableName(), f); err != nil {
+				s.AddError(&ValidationError{Name: f, err: fmt.Errorf("db: %w", err)})
+			}
+			s.OrderBy(sql.Asc(s.C(f)))
+		}
+	}
+}
+
+// Desc applies the given fields in DESC order.
+func Desc(fields ...string) func(*sql.Selector) {
+	return func(s *sql.Selector) {
+		for _, f := range fields {
+			if err := checkColumn(s.TableName(), f); err != nil {
+				s.AddError(&ValidationError{Name: f, err: fmt.Errorf("db: %w", err)})
+			}
+			s.OrderBy(sql.Desc(s.C(f)))
+		}
+	}
+}
+
+// AggregateFunc applies an aggregation step on the group-by traversal/selector.
+type AggregateFunc func(*sql.Selector) string
+
+// As is a pseudo aggregation function for renaming another other functions with custom names. For example:
+//
+//	GroupBy(field1, field2).
+//	Aggregate(db.As(db.Sum(field1), "sum_field1"), (db.As(db.Sum(field2), "sum_field2")).
+//	Scan(ctx, &v)
+func As(fn AggregateFunc, end string) AggregateFunc {
+	return func(s *sql.Selector) string {
+		return sql.As(fn(s), end)
+	}
+}
+
+// Count applies the "count" aggregation function on each group.
+func Count() AggregateFunc {
+	return func(s *sql.Selector) string {
+		return sql.Count("*")
+	}
+}
+
+// Max applies the "max" aggregation function on the given field of each group.
+func Max(field string) AggregateFunc {
+	return func(s *sql.Selector) string {
+		if err := checkColumn(s.TableName(), field); err != nil {
+			s.AddError(&ValidationError{Name: field, err: fmt.Errorf("db: %w", err)})
+			return ""
+		}
+		return sql.Max(s.C(field))
+	}
+}
+
+// Mean applies the "mean" aggregation function on the given field of each group.
+func Mean(field string) AggregateFunc {
+	return func(s *sql.Selector) string {
+		if err := checkColumn(s.TableName(), field); err != nil {
+			s.AddError(&ValidationError{Name: field, err: fmt.Errorf("db: %w", err)})
+			return ""
+		}
+		return sql.Avg(s.C(field))
+	}
+}
+
+// Min applies the "min" aggregation function on the given field of each group.
+func Min(field string) AggregateFunc {
+	return func(s *sql.Selector) string {
+		if err := checkColumn(s.TableName(), field); err != nil {
+			s.AddError(&ValidationError{Name: field, err: fmt.Errorf("db: %w", err)})
+			return ""
+		}
+		return sql.Min(s.C(field))
+	}
+}
+
+// Sum applies the "sum" aggregation function on the given field of each group.
+func Sum(field string) AggregateFunc {
+	return func(s *sql.Selector) string {
+		if err := checkColumn(s.TableName(), field); err != nil {
+			s.AddError(&ValidationError{Name: field, err: fmt.Errorf("db: %w", err)})
+			return ""
+		}
+		return sql.Sum(s.C(field))
+	}
+}
+
+// ValidationError returns when validating a field or edge fails.
+type ValidationError struct {
+	Name string // Field or edge name.
+	err  error
+}
+
+// Error implements the error interface.
+func (e *ValidationError) Error() string {
+	return e.err.Error()
+}
+
+// Unwrap implements the errors.Wrapper interface.
+func (e *ValidationError) Unwrap() error {
+	return e.err
+}
+
+// IsValidationError returns a boolean indicating whether the error is a validation error.
+func IsValidationError(err error) bool {
+	if err == nil {
+		return false
+	}
+	var e *ValidationError
+	return errors.As(err, &e)
+}
+
+// NotFoundError returns when trying to fetch a specific entity and it was not found in the database.
+type NotFoundError struct {
+	label string
+}
+
+// Error implements the error interface.
+func (e *NotFoundError) Error() string {
+	return "db: " + e.label + " not found"
+}
+
+// IsNotFound returns a boolean indicating whether the error is a not found error.
+func IsNotFound(err error) bool {
+	if err == nil {
+		return false
+	}
+	var e *NotFoundError
+	return errors.As(err, &e)
+}
+
+// MaskNotFound masks not found error.
+func MaskNotFound(err error) error {
+	if IsNotFound(err) {
+		return nil
+	}
+	return err
+}
+
+// NotSingularError returns when trying to fetch a singular entity and more then one was found in the database.
+type NotSingularError struct {
+	label string
+}
+
+// Error implements the error interface.
+func (e *NotSingularError) Error() string {
+	return "db: " + e.label + " not singular"
+}
+
+// IsNotSingular returns a boolean indicating whether the error is a not singular error.
+func IsNotSingular(err error) bool {
+	if err == nil {
+		return false
+	}
+	var e *NotSingularError
+	return errors.As(err, &e)
+}
+
+// NotLoadedError returns when trying to get a node that was not loaded by the query.
+type NotLoadedError struct {
+	edge string
+}
+
+// Error implements the error interface.
+func (e *NotLoadedError) Error() string {
+	return "db: " + e.edge + " edge was not loaded"
+}
+
+// IsNotLoaded returns a boolean indicating whether the error is a not loaded error.
+func IsNotLoaded(err error) bool {
+	if err == nil {
+		return false
+	}
+	var e *NotLoadedError
+	return errors.As(err, &e)
+}
+
+// ConstraintError returns when trying to create/update one or more entities and
+// one or more of their constraints failed. For example, violation of edge or
+// field uniqueness.
+type ConstraintError struct {
+	msg  string
+	wrap error
+}
+
+// Error implements the error interface.
+func (e ConstraintError) Error() string {
+	return "db: constraint failed: " + e.msg
+}
+
+// Unwrap implements the errors.Wrapper interface.
+func (e *ConstraintError) Unwrap() error {
+	return e.wrap
+}
+
+// IsConstraintError returns a boolean indicating whether the error is a constraint failure.
+func IsConstraintError(err error) bool {
+	if err == nil {
+		return false
+	}
+	var e *ConstraintError
+	return errors.As(err, &e)
+}
+
+// selector embedded by the different Select/GroupBy builders.
+type selector struct {
+	label string
+	flds  *[]string
+	fns   []AggregateFunc
+	scan  func(context.Context, any) error
+}
+
+// ScanX is like Scan, but panics if an error occurs.
+func (s *selector) ScanX(ctx context.Context, v any) {
+	if err := s.scan(ctx, v); err != nil {
+		panic(err)
+	}
+}
+
+// Strings returns list of strings from a selector. It is only allowed when selecting one field.
+func (s *selector) Strings(ctx context.Context) ([]string, error) {
+	if len(*s.flds) > 1 {
+		return nil, errors.New("db: Strings is not achievable when selecting more than 1 field")
+	}
+	var v []string
+	if err := s.scan(ctx, &v); err != nil {
+		return nil, err
+	}
+	return v, nil
+}
+
+// StringsX is like Strings, but panics if an error occurs.
+func (s *selector) StringsX(ctx context.Context) []string {
+	v, err := s.Strings(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// String returns a single string from a selector. It is only allowed when selecting one field.
+func (s *selector) String(ctx context.Context) (_ string, err error) {
+	var v []string
+	if v, err = s.Strings(ctx); err != nil {
+		return
+	}
+	switch len(v) {
+	case 1:
+		return v[0], nil
+	case 0:
+		err = &NotFoundError{s.label}
+	default:
+		err = fmt.Errorf("db: Strings returned %d results when one was expected", len(v))
+	}
+	return
+}
+
+// StringX is like String, but panics if an error occurs.
+func (s *selector) StringX(ctx context.Context) string {
+	v, err := s.String(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Ints returns list of ints from a selector. It is only allowed when selecting one field.
+func (s *selector) Ints(ctx context.Context) ([]int, error) {
+	if len(*s.flds) > 1 {
+		return nil, errors.New("db: Ints is not achievable when selecting more than 1 field")
+	}
+	var v []int
+	if err := s.scan(ctx, &v); err != nil {
+		return nil, err
+	}
+	return v, nil
+}
+
+// IntsX is like Ints, but panics if an error occurs.
+func (s *selector) IntsX(ctx context.Context) []int {
+	v, err := s.Ints(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Int returns a single int from a selector. It is only allowed when selecting one field.
+func (s *selector) Int(ctx context.Context) (_ int, err error) {
+	var v []int
+	if v, err = s.Ints(ctx); err != nil {
+		return
+	}
+	switch len(v) {
+	case 1:
+		return v[0], nil
+	case 0:
+		err = &NotFoundError{s.label}
+	default:
+		err = fmt.Errorf("db: Ints returned %d results when one was expected", len(v))
+	}
+	return
+}
+
+// IntX is like Int, but panics if an error occurs.
+func (s *selector) IntX(ctx context.Context) int {
+	v, err := s.Int(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Float64s returns list of float64s from a selector. It is only allowed when selecting one field.
+func (s *selector) Float64s(ctx context.Context) ([]float64, error) {
+	if len(*s.flds) > 1 {
+		return nil, errors.New("db: Float64s is not achievable when selecting more than 1 field")
+	}
+	var v []float64
+	if err := s.scan(ctx, &v); err != nil {
+		return nil, err
+	}
+	return v, nil
+}
+
+// Float64sX is like Float64s, but panics if an error occurs.
+func (s *selector) Float64sX(ctx context.Context) []float64 {
+	v, err := s.Float64s(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Float64 returns a single float64 from a selector. It is only allowed when selecting one field.
+func (s *selector) Float64(ctx context.Context) (_ float64, err error) {
+	var v []float64
+	if v, err = s.Float64s(ctx); err != nil {
+		return
+	}
+	switch len(v) {
+	case 1:
+		return v[0], nil
+	case 0:
+		err = &NotFoundError{s.label}
+	default:
+		err = fmt.Errorf("db: Float64s returned %d results when one was expected", len(v))
+	}
+	return
+}
+
+// Float64X is like Float64, but panics if an error occurs.
+func (s *selector) Float64X(ctx context.Context) float64 {
+	v, err := s.Float64(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Bools returns list of bools from a selector. It is only allowed when selecting one field.
+func (s *selector) Bools(ctx context.Context) ([]bool, error) {
+	if len(*s.flds) > 1 {
+		return nil, errors.New("db: Bools is not achievable when selecting more than 1 field")
+	}
+	var v []bool
+	if err := s.scan(ctx, &v); err != nil {
+		return nil, err
+	}
+	return v, nil
+}
+
+// BoolsX is like Bools, but panics if an error occurs.
+func (s *selector) BoolsX(ctx context.Context) []bool {
+	v, err := s.Bools(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Bool returns a single bool from a selector. It is only allowed when selecting one field.
+func (s *selector) Bool(ctx context.Context) (_ bool, err error) {
+	var v []bool
+	if v, err = s.Bools(ctx); err != nil {
+		return
+	}
+	switch len(v) {
+	case 1:
+		return v[0], nil
+	case 0:
+		err = &NotFoundError{s.label}
+	default:
+		err = fmt.Errorf("db: Bools returned %d results when one was expected", len(v))
+	}
+	return
+}
+
+// BoolX is like Bool, but panics if an error occurs.
+func (s *selector) BoolX(ctx context.Context) bool {
+	v, err := s.Bool(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// withHooks invokes the builder operation with the given hooks, if any.
+func withHooks[V Value, M any, PM interface {
+	*M
+	Mutation
+}](ctx context.Context, exec func(context.Context) (V, error), mutation PM, hooks []Hook) (value V, err error) {
+	if len(hooks) == 0 {
+		return exec(ctx)
+	}
+	var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+		mutationT, ok := any(m).(PM)
+		if !ok {
+			return nil, fmt.Errorf("unexpected mutation type %T", m)
+		}
+		// Set the mutation to the builder.
+		*mutation = *mutationT
+		return exec(ctx)
+	})
+	for i := len(hooks) - 1; i >= 0; i-- {
+		if hooks[i] == nil {
+			return value, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
+		}
+		mut = hooks[i](mut)
+	}
+	v, err := mut.Mutate(ctx, mutation)
+	if err != nil {
+		return value, err
+	}
+	nv, ok := v.(V)
+	if !ok {
+		return value, fmt.Errorf("unexpected node type %T returned from %T", v, mutation)
+	}
+	return nv, nil
+}
+
+// setContextOp returns a new context with the given QueryContext attached (including its op) in case it does not exist.
+func setContextOp(ctx context.Context, qc *QueryContext, op string) context.Context {
+	if ent.QueryFromContext(ctx) == nil {
+		qc.Op = op
+		ctx = ent.NewQueryContext(ctx, qc)
+	}
+	return ctx
+}
+
+func querierAll[V Value, Q interface {
+	sqlAll(context.Context, ...queryHook) (V, error)
+}]() Querier {
+	return QuerierFunc(func(ctx context.Context, q Query) (Value, error) {
+		query, ok := q.(Q)
+		if !ok {
+			return nil, fmt.Errorf("unexpected query type %T", q)
+		}
+		return query.sqlAll(ctx)
+	})
+}
+
+func querierCount[Q interface {
+	sqlCount(context.Context) (int, error)
+}]() Querier {
+	return QuerierFunc(func(ctx context.Context, q Query) (Value, error) {
+		query, ok := q.(Q)
+		if !ok {
+			return nil, fmt.Errorf("unexpected query type %T", q)
+		}
+		return query.sqlCount(ctx)
+	})
+}
+
+func withInterceptors[V Value](ctx context.Context, q Query, qr Querier, inters []Interceptor) (v V, err error) {
+	for i := len(inters) - 1; i >= 0; i-- {
+		qr = inters[i].Intercept(qr)
+	}
+	rv, err := qr.Query(ctx, q)
+	if err != nil {
+		return v, err
+	}
+	vt, ok := rv.(V)
+	if !ok {
+		return v, fmt.Errorf("unexpected type %T returned from %T. expected type: %T", vt, q, v)
+	}
+	return vt, nil
+}
+
+func scanWithInterceptors[Q1 ent.Query, Q2 interface {
+	sqlScan(context.Context, Q1, any) error
+}](ctx context.Context, rootQuery Q1, selectOrGroup Q2, inters []Interceptor, v any) error {
+	rv := reflect.ValueOf(v)
+	var qr Querier = QuerierFunc(func(ctx context.Context, q Query) (Value, error) {
+		query, ok := q.(Q1)
+		if !ok {
+			return nil, fmt.Errorf("unexpected query type %T", q)
+		}
+		if err := selectOrGroup.sqlScan(ctx, query, v); err != nil {
+			return nil, err
+		}
+		if k := rv.Kind(); k == reflect.Pointer && rv.Elem().CanInterface() {
+			return rv.Elem().Interface(), nil
+		}
+		return v, nil
+	})
+	for i := len(inters) - 1; i >= 0; i-- {
+		qr = inters[i].Intercept(qr)
+	}
+	vv, err := qr.Query(ctx, rootQuery)
+	if err != nil {
+		return err
+	}
+	switch rv2 := reflect.ValueOf(vv); {
+	case rv.IsNil(), rv2.IsNil(), rv.Kind() != reflect.Pointer:
+	case rv.Type() == rv2.Type():
+		rv.Elem().Set(rv2.Elem())
+	case rv.Elem().Type() == rv2.Type():
+		rv.Elem().Set(rv2)
+	}
+	return nil
+}
+
+// queryHook describes an internal hook for the different sqlAll methods.
+type queryHook func(context.Context, *sqlgraph.QuerySpec)
diff --git a/internal/database/ent/db/enttest/enttest.go b/internal/database/ent/db/enttest/enttest.go
new file mode 100644
index 00000000..4267b558
--- /dev/null
+++ b/internal/database/ent/db/enttest/enttest.go
@@ -0,0 +1,84 @@
+// Code generated by ent, DO NOT EDIT.
+
+package enttest
+
+import (
+	"context"
+
+	"github.com/cufee/aftermath/internal/database/ent/db"
+	// required by schema hooks.
+	_ "github.com/cufee/aftermath/internal/database/ent/db/runtime"
+
+	"entgo.io/ent/dialect/sql/schema"
+	"github.com/cufee/aftermath/internal/database/ent/db/migrate"
+)
+
+type (
+	// TestingT is the interface that is shared between
+	// testing.T and testing.B and used by enttest.
+	TestingT interface {
+		FailNow()
+		Error(...any)
+	}
+
+	// Option configures client creation.
+	Option func(*options)
+
+	options struct {
+		opts        []db.Option
+		migrateOpts []schema.MigrateOption
+	}
+)
+
+// WithOptions forwards options to client creation.
+func WithOptions(opts ...db.Option) Option {
+	return func(o *options) {
+		o.opts = append(o.opts, opts...)
+	}
+}
+
+// WithMigrateOptions forwards options to auto migration.
+func WithMigrateOptions(opts ...schema.MigrateOption) Option {
+	return func(o *options) {
+		o.migrateOpts = append(o.migrateOpts, opts...)
+	}
+}
+
+func newOptions(opts []Option) *options {
+	o := &options{}
+	for _, opt := range opts {
+		opt(o)
+	}
+	return o
+}
+
+// Open calls db.Open and auto-run migration.
+func Open(t TestingT, driverName, dataSourceName string, opts ...Option) *db.Client {
+	o := newOptions(opts)
+	c, err := db.Open(driverName, dataSourceName, o.opts...)
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+	migrateSchema(t, c, o)
+	return c
+}
+
+// NewClient calls db.NewClient and auto-run migration.
+func NewClient(t TestingT, opts ...Option) *db.Client {
+	o := newOptions(opts)
+	c := db.NewClient(o.opts...)
+	migrateSchema(t, c, o)
+	return c
+}
+func migrateSchema(t TestingT, c *db.Client, o *options) {
+	tables, err := schema.CopyTables(migrate.Tables)
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+	if err := migrate.Create(context.Background(), c.Schema, tables, o.migrateOpts...); err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+}
diff --git a/internal/database/ent/db/hook/hook.go b/internal/database/ent/db/hook/hook.go
new file mode 100644
index 00000000..fe0ba69f
--- /dev/null
+++ b/internal/database/ent/db/hook/hook.go
@@ -0,0 +1,355 @@
+// Code generated by ent, DO NOT EDIT.
+
+package hook
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/cufee/aftermath/internal/database/ent/db"
+)
+
+// The AccountFunc type is an adapter to allow the use of ordinary
+// function as Account mutator.
+type AccountFunc func(context.Context, *db.AccountMutation) (db.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f AccountFunc) Mutate(ctx context.Context, m db.Mutation) (db.Value, error) {
+	if mv, ok := m.(*db.AccountMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *db.AccountMutation", m)
+}
+
+// The AccountSnapshotFunc type is an adapter to allow the use of ordinary
+// function as AccountSnapshot mutator.
+type AccountSnapshotFunc func(context.Context, *db.AccountSnapshotMutation) (db.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f AccountSnapshotFunc) Mutate(ctx context.Context, m db.Mutation) (db.Value, error) {
+	if mv, ok := m.(*db.AccountSnapshotMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *db.AccountSnapshotMutation", m)
+}
+
+// The AchievementsSnapshotFunc type is an adapter to allow the use of ordinary
+// function as AchievementsSnapshot mutator.
+type AchievementsSnapshotFunc func(context.Context, *db.AchievementsSnapshotMutation) (db.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f AchievementsSnapshotFunc) Mutate(ctx context.Context, m db.Mutation) (db.Value, error) {
+	if mv, ok := m.(*db.AchievementsSnapshotMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *db.AchievementsSnapshotMutation", m)
+}
+
+// The AppConfigurationFunc type is an adapter to allow the use of ordinary
+// function as AppConfiguration mutator.
+type AppConfigurationFunc func(context.Context, *db.AppConfigurationMutation) (db.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f AppConfigurationFunc) Mutate(ctx context.Context, m db.Mutation) (db.Value, error) {
+	if mv, ok := m.(*db.AppConfigurationMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *db.AppConfigurationMutation", m)
+}
+
+// The ApplicationCommandFunc type is an adapter to allow the use of ordinary
+// function as ApplicationCommand mutator.
+type ApplicationCommandFunc func(context.Context, *db.ApplicationCommandMutation) (db.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f ApplicationCommandFunc) Mutate(ctx context.Context, m db.Mutation) (db.Value, error) {
+	if mv, ok := m.(*db.ApplicationCommandMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *db.ApplicationCommandMutation", m)
+}
+
+// The ClanFunc type is an adapter to allow the use of ordinary
+// function as Clan mutator.
+type ClanFunc func(context.Context, *db.ClanMutation) (db.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f ClanFunc) Mutate(ctx context.Context, m db.Mutation) (db.Value, error) {
+	if mv, ok := m.(*db.ClanMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *db.ClanMutation", m)
+}
+
+// The CronTaskFunc type is an adapter to allow the use of ordinary
+// function as CronTask mutator.
+type CronTaskFunc func(context.Context, *db.CronTaskMutation) (db.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f CronTaskFunc) Mutate(ctx context.Context, m db.Mutation) (db.Value, error) {
+	if mv, ok := m.(*db.CronTaskMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *db.CronTaskMutation", m)
+}
+
+// The UserFunc type is an adapter to allow the use of ordinary
+// function as User mutator.
+type UserFunc func(context.Context, *db.UserMutation) (db.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f UserFunc) Mutate(ctx context.Context, m db.Mutation) (db.Value, error) {
+	if mv, ok := m.(*db.UserMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *db.UserMutation", m)
+}
+
+// The UserConnectionFunc type is an adapter to allow the use of ordinary
+// function as UserConnection mutator.
+type UserConnectionFunc func(context.Context, *db.UserConnectionMutation) (db.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f UserConnectionFunc) Mutate(ctx context.Context, m db.Mutation) (db.Value, error) {
+	if mv, ok := m.(*db.UserConnectionMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *db.UserConnectionMutation", m)
+}
+
+// The UserContentFunc type is an adapter to allow the use of ordinary
+// function as UserContent mutator.
+type UserContentFunc func(context.Context, *db.UserContentMutation) (db.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f UserContentFunc) Mutate(ctx context.Context, m db.Mutation) (db.Value, error) {
+	if mv, ok := m.(*db.UserContentMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *db.UserContentMutation", m)
+}
+
+// The UserSubscriptionFunc type is an adapter to allow the use of ordinary
+// function as UserSubscription mutator.
+type UserSubscriptionFunc func(context.Context, *db.UserSubscriptionMutation) (db.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f UserSubscriptionFunc) Mutate(ctx context.Context, m db.Mutation) (db.Value, error) {
+	if mv, ok := m.(*db.UserSubscriptionMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *db.UserSubscriptionMutation", m)
+}
+
+// The VehicleFunc type is an adapter to allow the use of ordinary
+// function as Vehicle mutator.
+type VehicleFunc func(context.Context, *db.VehicleMutation) (db.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f VehicleFunc) Mutate(ctx context.Context, m db.Mutation) (db.Value, error) {
+	if mv, ok := m.(*db.VehicleMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *db.VehicleMutation", m)
+}
+
+// The VehicleAverageFunc type is an adapter to allow the use of ordinary
+// function as VehicleAverage mutator.
+type VehicleAverageFunc func(context.Context, *db.VehicleAverageMutation) (db.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f VehicleAverageFunc) Mutate(ctx context.Context, m db.Mutation) (db.Value, error) {
+	if mv, ok := m.(*db.VehicleAverageMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *db.VehicleAverageMutation", m)
+}
+
+// The VehicleSnapshotFunc type is an adapter to allow the use of ordinary
+// function as VehicleSnapshot mutator.
+type VehicleSnapshotFunc func(context.Context, *db.VehicleSnapshotMutation) (db.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f VehicleSnapshotFunc) Mutate(ctx context.Context, m db.Mutation) (db.Value, error) {
+	if mv, ok := m.(*db.VehicleSnapshotMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *db.VehicleSnapshotMutation", m)
+}
+
+// Condition is a hook condition function.
+type Condition func(context.Context, db.Mutation) bool
+
+// And groups conditions with the AND operator.
+func And(first, second Condition, rest ...Condition) Condition {
+	return func(ctx context.Context, m db.Mutation) bool {
+		if !first(ctx, m) || !second(ctx, m) {
+			return false
+		}
+		for _, cond := range rest {
+			if !cond(ctx, m) {
+				return false
+			}
+		}
+		return true
+	}
+}
+
+// Or groups conditions with the OR operator.
+func Or(first, second Condition, rest ...Condition) Condition {
+	return func(ctx context.Context, m db.Mutation) bool {
+		if first(ctx, m) || second(ctx, m) {
+			return true
+		}
+		for _, cond := range rest {
+			if cond(ctx, m) {
+				return true
+			}
+		}
+		return false
+	}
+}
+
+// Not negates a given condition.
+func Not(cond Condition) Condition {
+	return func(ctx context.Context, m db.Mutation) bool {
+		return !cond(ctx, m)
+	}
+}
+
+// HasOp is a condition testing mutation operation.
+func HasOp(op db.Op) Condition {
+	return func(_ context.Context, m db.Mutation) bool {
+		return m.Op().Is(op)
+	}
+}
+
+// HasAddedFields is a condition validating `.AddedField` on fields.
+func HasAddedFields(field string, fields ...string) Condition {
+	return func(_ context.Context, m db.Mutation) bool {
+		if _, exists := m.AddedField(field); !exists {
+			return false
+		}
+		for _, field := range fields {
+			if _, exists := m.AddedField(field); !exists {
+				return false
+			}
+		}
+		return true
+	}
+}
+
+// HasClearedFields is a condition validating `.FieldCleared` on fields.
+func HasClearedFields(field string, fields ...string) Condition {
+	return func(_ context.Context, m db.Mutation) bool {
+		if exists := m.FieldCleared(field); !exists {
+			return false
+		}
+		for _, field := range fields {
+			if exists := m.FieldCleared(field); !exists {
+				return false
+			}
+		}
+		return true
+	}
+}
+
+// HasFields is a condition validating `.Field` on fields.
+func HasFields(field string, fields ...string) Condition {
+	return func(_ context.Context, m db.Mutation) bool {
+		if _, exists := m.Field(field); !exists {
+			return false
+		}
+		for _, field := range fields {
+			if _, exists := m.Field(field); !exists {
+				return false
+			}
+		}
+		return true
+	}
+}
+
+// If executes the given hook under condition.
+//
+//	hook.If(ComputeAverage, And(HasFields(...), HasAddedFields(...)))
+func If(hk db.Hook, cond Condition) db.Hook {
+	return func(next db.Mutator) db.Mutator {
+		return db.MutateFunc(func(ctx context.Context, m db.Mutation) (db.Value, error) {
+			if cond(ctx, m) {
+				return hk(next).Mutate(ctx, m)
+			}
+			return next.Mutate(ctx, m)
+		})
+	}
+}
+
+// On executes the given hook only for the given operation.
+//
+//	hook.On(Log, db.Delete|db.Create)
+func On(hk db.Hook, op db.Op) db.Hook {
+	return If(hk, HasOp(op))
+}
+
+// Unless skips the given hook only for the given operation.
+//
+//	hook.Unless(Log, db.Update|db.UpdateOne)
+func Unless(hk db.Hook, op db.Op) db.Hook {
+	return If(hk, Not(HasOp(op)))
+}
+
+// FixedError is a hook returning a fixed error.
+func FixedError(err error) db.Hook {
+	return func(db.Mutator) db.Mutator {
+		return db.MutateFunc(func(context.Context, db.Mutation) (db.Value, error) {
+			return nil, err
+		})
+	}
+}
+
+// Reject returns a hook that rejects all operations that match op.
+//
+//	func (T) Hooks() []db.Hook {
+//		return []db.Hook{
+//			Reject(db.Delete|db.Update),
+//		}
+//	}
+func Reject(op db.Op) db.Hook {
+	hk := FixedError(fmt.Errorf("%s operation is not allowed", op))
+	return On(hk, op)
+}
+
+// Chain acts as a list of hooks and is effectively immutable.
+// Once created, it will always hold the same set of hooks in the same order.
+type Chain struct {
+	hooks []db.Hook
+}
+
+// NewChain creates a new chain of hooks.
+func NewChain(hooks ...db.Hook) Chain {
+	return Chain{append([]db.Hook(nil), hooks...)}
+}
+
+// Hook chains the list of hooks and returns the final hook.
+func (c Chain) Hook() db.Hook {
+	return func(mutator db.Mutator) db.Mutator {
+		for i := len(c.hooks) - 1; i >= 0; i-- {
+			mutator = c.hooks[i](mutator)
+		}
+		return mutator
+	}
+}
+
+// Append extends a chain, adding the specified hook
+// as the last ones in the mutation flow.
+func (c Chain) Append(hooks ...db.Hook) Chain {
+	newHooks := make([]db.Hook, 0, len(c.hooks)+len(hooks))
+	newHooks = append(newHooks, c.hooks...)
+	newHooks = append(newHooks, hooks...)
+	return Chain{newHooks}
+}
+
+// Extend extends a chain, adding the specified chain
+// as the last ones in the mutation flow.
+func (c Chain) Extend(chain Chain) Chain {
+	return c.Append(chain.hooks...)
+}
diff --git a/internal/database/ent/db/migrate/migrate.go b/internal/database/ent/db/migrate/migrate.go
new file mode 100644
index 00000000..d8d3bcb8
--- /dev/null
+++ b/internal/database/ent/db/migrate/migrate.go
@@ -0,0 +1,96 @@
+// Code generated by ent, DO NOT EDIT.
+
+package migrate
+
+import (
+	"context"
+	"fmt"
+	"io"
+
+	"entgo.io/ent/dialect"
+	"entgo.io/ent/dialect/sql/schema"
+)
+
+var (
+	// WithGlobalUniqueID sets the universal ids options to the migration.
+	// If this option is enabled, ent migration will allocate a 1<<32 range
+	// for the ids of each entity (table).
+	// Note that this option cannot be applied on tables that already exist.
+	WithGlobalUniqueID = schema.WithGlobalUniqueID
+	// WithDropColumn sets the drop column option to the migration.
+	// If this option is enabled, ent migration will drop old columns
+	// that were used for both fields and edges. This defaults to false.
+	WithDropColumn = schema.WithDropColumn
+	// WithDropIndex sets the drop index option to the migration.
+	// If this option is enabled, ent migration will drop old indexes
+	// that were defined in the schema. This defaults to false.
+	// Note that unique constraints are defined using `UNIQUE INDEX`,
+	// and therefore, it's recommended to enable this option to get more
+	// flexibility in the schema changes.
+	WithDropIndex = schema.WithDropIndex
+	// WithForeignKeys enables creating foreign-key in schema DDL. This defaults to true.
+	WithForeignKeys = schema.WithForeignKeys
+)
+
+// Schema is the API for creating, migrating and dropping a schema.
+type Schema struct {
+	drv dialect.Driver
+}
+
+// NewSchema creates a new schema client.
+func NewSchema(drv dialect.Driver) *Schema { return &Schema{drv: drv} }
+
+// Create creates all schema resources.
+func (s *Schema) Create(ctx context.Context, opts ...schema.MigrateOption) error {
+	return Create(ctx, s, Tables, opts...)
+}
+
+// Create creates all table resources using the given schema driver.
+func Create(ctx context.Context, s *Schema, tables []*schema.Table, opts ...schema.MigrateOption) error {
+	migrate, err := schema.NewMigrate(s.drv, opts...)
+	if err != nil {
+		return fmt.Errorf("ent/migrate: %w", err)
+	}
+	return migrate.Create(ctx, tables...)
+}
+
+// Diff compares the state read from a database connection or migration directory with
+// the state defined by the Ent schema. Changes will be written to new migration files.
+func Diff(ctx context.Context, url string, opts ...schema.MigrateOption) error {
+	return NamedDiff(ctx, url, "changes", opts...)
+}
+
+// NamedDiff compares the state read from a database connection or migration directory with
+// the state defined by the Ent schema. Changes will be written to new named migration files.
+func NamedDiff(ctx context.Context, url, name string, opts ...schema.MigrateOption) error {
+	return schema.Diff(ctx, url, name, Tables, opts...)
+}
+
+// Diff creates a migration file containing the statements to resolve the diff
+// between the Ent schema and the connected database.
+func (s *Schema) Diff(ctx context.Context, opts ...schema.MigrateOption) error {
+	migrate, err := schema.NewMigrate(s.drv, opts...)
+	if err != nil {
+		return fmt.Errorf("ent/migrate: %w", err)
+	}
+	return migrate.Diff(ctx, Tables...)
+}
+
+// NamedDiff creates a named migration file containing the statements to resolve the diff
+// between the Ent schema and the connected database.
+func (s *Schema) NamedDiff(ctx context.Context, name string, opts ...schema.MigrateOption) error {
+	migrate, err := schema.NewMigrate(s.drv, opts...)
+	if err != nil {
+		return fmt.Errorf("ent/migrate: %w", err)
+	}
+	return migrate.NamedDiff(ctx, name, Tables...)
+}
+
+// WriteTo writes the schema changes to w instead of running them against the database.
+//
+//	if err := client.Schema.WriteTo(context.Background(), os.Stdout); err != nil {
+//		log.Fatal(err)
+//	}
+func (s *Schema) WriteTo(ctx context.Context, w io.Writer, opts ...schema.MigrateOption) error {
+	return Create(ctx, &Schema{drv: &schema.WriteDriver{Writer: w, Driver: s.drv}}, Tables, opts...)
+}
diff --git a/internal/database/ent/db/migrate/schema.go b/internal/database/ent/db/migrate/schema.go
new file mode 100644
index 00000000..6496f121
--- /dev/null
+++ b/internal/database/ent/db/migrate/schema.go
@@ -0,0 +1,524 @@
+// Code generated by ent, DO NOT EDIT.
+
+package migrate
+
+import (
+	"entgo.io/ent/dialect/sql/schema"
+	"entgo.io/ent/schema/field"
+)
+
+var (
+	// AccountsColumns holds the columns for the "accounts" table.
+	AccountsColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeString, Unique: true},
+		{Name: "created_at", Type: field.TypeInt},
+		{Name: "updated_at", Type: field.TypeInt},
+		{Name: "last_battle_time", Type: field.TypeInt},
+		{Name: "account_created_at", Type: field.TypeInt},
+		{Name: "realm", Type: field.TypeString, Size: 5},
+		{Name: "nickname", Type: field.TypeString},
+		{Name: "private", Type: field.TypeBool, Default: false},
+		{Name: "clan_id", Type: field.TypeString, Nullable: true},
+	}
+	// AccountsTable holds the schema information for the "accounts" table.
+	AccountsTable = &schema.Table{
+		Name:       "accounts",
+		Columns:    AccountsColumns,
+		PrimaryKey: []*schema.Column{AccountsColumns[0]},
+		ForeignKeys: []*schema.ForeignKey{
+			{
+				Symbol:     "accounts_clans_accounts",
+				Columns:    []*schema.Column{AccountsColumns[8]},
+				RefColumns: []*schema.Column{ClansColumns[0]},
+				OnDelete:   schema.SetNull,
+			},
+		},
+		Indexes: []*schema.Index{
+			{
+				Name:    "account_id_last_battle_time",
+				Unique:  false,
+				Columns: []*schema.Column{AccountsColumns[0], AccountsColumns[3]},
+			},
+			{
+				Name:    "account_realm",
+				Unique:  false,
+				Columns: []*schema.Column{AccountsColumns[5]},
+			},
+			{
+				Name:    "account_realm_last_battle_time",
+				Unique:  false,
+				Columns: []*schema.Column{AccountsColumns[5], AccountsColumns[3]},
+			},
+			{
+				Name:    "account_clan_id",
+				Unique:  false,
+				Columns: []*schema.Column{AccountsColumns[8]},
+			},
+		},
+	}
+	// AccountSnapshotsColumns holds the columns for the "account_snapshots" table.
+	AccountSnapshotsColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeString, Unique: true},
+		{Name: "created_at", Type: field.TypeInt},
+		{Name: "updated_at", Type: field.TypeInt},
+		{Name: "type", Type: field.TypeEnum, Enums: []string{"live", "daily"}},
+		{Name: "last_battle_time", Type: field.TypeInt},
+		{Name: "reference_id", Type: field.TypeString},
+		{Name: "rating_battles", Type: field.TypeInt},
+		{Name: "rating_frame", Type: field.TypeJSON},
+		{Name: "regular_battles", Type: field.TypeInt},
+		{Name: "regular_frame", Type: field.TypeJSON},
+		{Name: "account_id", Type: field.TypeString},
+	}
+	// AccountSnapshotsTable holds the schema information for the "account_snapshots" table.
+	AccountSnapshotsTable = &schema.Table{
+		Name:       "account_snapshots",
+		Columns:    AccountSnapshotsColumns,
+		PrimaryKey: []*schema.Column{AccountSnapshotsColumns[0]},
+		ForeignKeys: []*schema.ForeignKey{
+			{
+				Symbol:     "account_snapshots_accounts_snapshots",
+				Columns:    []*schema.Column{AccountSnapshotsColumns[10]},
+				RefColumns: []*schema.Column{AccountsColumns[0]},
+				OnDelete:   schema.NoAction,
+			},
+		},
+		Indexes: []*schema.Index{
+			{
+				Name:    "accountsnapshot_created_at",
+				Unique:  false,
+				Columns: []*schema.Column{AccountSnapshotsColumns[1]},
+			},
+			{
+				Name:    "accountsnapshot_type_account_id_created_at",
+				Unique:  false,
+				Columns: []*schema.Column{AccountSnapshotsColumns[3], AccountSnapshotsColumns[10], AccountSnapshotsColumns[1]},
+			},
+			{
+				Name:    "accountsnapshot_type_account_id_reference_id",
+				Unique:  false,
+				Columns: []*schema.Column{AccountSnapshotsColumns[3], AccountSnapshotsColumns[10], AccountSnapshotsColumns[5]},
+			},
+			{
+				Name:    "accountsnapshot_type_account_id_reference_id_created_at",
+				Unique:  false,
+				Columns: []*schema.Column{AccountSnapshotsColumns[3], AccountSnapshotsColumns[10], AccountSnapshotsColumns[5], AccountSnapshotsColumns[1]},
+			},
+		},
+	}
+	// AchievementsSnapshotsColumns holds the columns for the "achievements_snapshots" table.
+	AchievementsSnapshotsColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeString, Unique: true},
+		{Name: "created_at", Type: field.TypeInt},
+		{Name: "updated_at", Type: field.TypeInt},
+		{Name: "type", Type: field.TypeEnum, Enums: []string{"live", "daily"}},
+		{Name: "reference_id", Type: field.TypeString},
+		{Name: "battles", Type: field.TypeInt},
+		{Name: "last_battle_time", Type: field.TypeInt},
+		{Name: "data", Type: field.TypeJSON},
+		{Name: "account_id", Type: field.TypeString},
+	}
+	// AchievementsSnapshotsTable holds the schema information for the "achievements_snapshots" table.
+	AchievementsSnapshotsTable = &schema.Table{
+		Name:       "achievements_snapshots",
+		Columns:    AchievementsSnapshotsColumns,
+		PrimaryKey: []*schema.Column{AchievementsSnapshotsColumns[0]},
+		ForeignKeys: []*schema.ForeignKey{
+			{
+				Symbol:     "achievements_snapshots_accounts_achievement_snapshots",
+				Columns:    []*schema.Column{AchievementsSnapshotsColumns[8]},
+				RefColumns: []*schema.Column{AccountsColumns[0]},
+				OnDelete:   schema.NoAction,
+			},
+		},
+		Indexes: []*schema.Index{
+			{
+				Name:    "achievementssnapshot_created_at",
+				Unique:  false,
+				Columns: []*schema.Column{AchievementsSnapshotsColumns[1]},
+			},
+			{
+				Name:    "achievementssnapshot_account_id_reference_id",
+				Unique:  false,
+				Columns: []*schema.Column{AchievementsSnapshotsColumns[8], AchievementsSnapshotsColumns[4]},
+			},
+			{
+				Name:    "achievementssnapshot_account_id_reference_id_created_at",
+				Unique:  false,
+				Columns: []*schema.Column{AchievementsSnapshotsColumns[8], AchievementsSnapshotsColumns[4], AchievementsSnapshotsColumns[1]},
+			},
+		},
+	}
+	// AppConfigurationsColumns holds the columns for the "app_configurations" table.
+	AppConfigurationsColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeString, Unique: true},
+		{Name: "created_at", Type: field.TypeInt},
+		{Name: "updated_at", Type: field.TypeInt},
+		{Name: "key", Type: field.TypeString, Unique: true},
+		{Name: "value", Type: field.TypeJSON},
+		{Name: "metadata", Type: field.TypeJSON, Nullable: true},
+	}
+	// AppConfigurationsTable holds the schema information for the "app_configurations" table.
+	AppConfigurationsTable = &schema.Table{
+		Name:       "app_configurations",
+		Columns:    AppConfigurationsColumns,
+		PrimaryKey: []*schema.Column{AppConfigurationsColumns[0]},
+		Indexes: []*schema.Index{
+			{
+				Name:    "appconfiguration_key",
+				Unique:  false,
+				Columns: []*schema.Column{AppConfigurationsColumns[3]},
+			},
+		},
+	}
+	// ApplicationCommandsColumns holds the columns for the "application_commands" table.
+	ApplicationCommandsColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeString, Unique: true},
+		{Name: "created_at", Type: field.TypeInt},
+		{Name: "updated_at", Type: field.TypeInt},
+		{Name: "name", Type: field.TypeString, Unique: true},
+		{Name: "version", Type: field.TypeString},
+		{Name: "options_hash", Type: field.TypeString},
+	}
+	// ApplicationCommandsTable holds the schema information for the "application_commands" table.
+	ApplicationCommandsTable = &schema.Table{
+		Name:       "application_commands",
+		Columns:    ApplicationCommandsColumns,
+		PrimaryKey: []*schema.Column{ApplicationCommandsColumns[0]},
+		Indexes: []*schema.Index{
+			{
+				Name:    "applicationcommand_options_hash",
+				Unique:  false,
+				Columns: []*schema.Column{ApplicationCommandsColumns[5]},
+			},
+		},
+	}
+	// ClansColumns holds the columns for the "clans" table.
+	ClansColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeString, Unique: true},
+		{Name: "created_at", Type: field.TypeInt},
+		{Name: "updated_at", Type: field.TypeInt},
+		{Name: "tag", Type: field.TypeString},
+		{Name: "name", Type: field.TypeString},
+		{Name: "emblem_id", Type: field.TypeString, Nullable: true, Default: ""},
+		{Name: "members", Type: field.TypeJSON},
+	}
+	// ClansTable holds the schema information for the "clans" table.
+	ClansTable = &schema.Table{
+		Name:       "clans",
+		Columns:    ClansColumns,
+		PrimaryKey: []*schema.Column{ClansColumns[0]},
+		Indexes: []*schema.Index{
+			{
+				Name:    "clan_tag",
+				Unique:  false,
+				Columns: []*schema.Column{ClansColumns[3]},
+			},
+			{
+				Name:    "clan_name",
+				Unique:  false,
+				Columns: []*schema.Column{ClansColumns[4]},
+			},
+		},
+	}
+	// CronTasksColumns holds the columns for the "cron_tasks" table.
+	CronTasksColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeString, Unique: true},
+		{Name: "created_at", Type: field.TypeInt},
+		{Name: "updated_at", Type: field.TypeInt},
+		{Name: "type", Type: field.TypeString},
+		{Name: "reference_id", Type: field.TypeString},
+		{Name: "targets", Type: field.TypeJSON},
+		{Name: "status", Type: field.TypeString},
+		{Name: "scheduled_after", Type: field.TypeInt},
+		{Name: "last_run", Type: field.TypeInt},
+		{Name: "logs", Type: field.TypeJSON},
+		{Name: "data", Type: field.TypeJSON},
+	}
+	// CronTasksTable holds the schema information for the "cron_tasks" table.
+	CronTasksTable = &schema.Table{
+		Name:       "cron_tasks",
+		Columns:    CronTasksColumns,
+		PrimaryKey: []*schema.Column{CronTasksColumns[0]},
+		Indexes: []*schema.Index{
+			{
+				Name:    "crontask_reference_id",
+				Unique:  false,
+				Columns: []*schema.Column{CronTasksColumns[4]},
+			},
+			{
+				Name:    "crontask_status_last_run",
+				Unique:  false,
+				Columns: []*schema.Column{CronTasksColumns[6], CronTasksColumns[8]},
+			},
+			{
+				Name:    "crontask_status_created_at",
+				Unique:  false,
+				Columns: []*schema.Column{CronTasksColumns[6], CronTasksColumns[1]},
+			},
+			{
+				Name:    "crontask_status_scheduled_after",
+				Unique:  false,
+				Columns: []*schema.Column{CronTasksColumns[6], CronTasksColumns[7]},
+			},
+		},
+	}
+	// UsersColumns holds the columns for the "users" table.
+	UsersColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeString, Unique: true},
+		{Name: "created_at", Type: field.TypeInt},
+		{Name: "updated_at", Type: field.TypeInt},
+		{Name: "permissions", Type: field.TypeString, Default: ""},
+		{Name: "feature_flags", Type: field.TypeJSON, Nullable: true},
+	}
+	// UsersTable holds the schema information for the "users" table.
+	UsersTable = &schema.Table{
+		Name:       "users",
+		Columns:    UsersColumns,
+		PrimaryKey: []*schema.Column{UsersColumns[0]},
+	}
+	// UserConnectionsColumns holds the columns for the "user_connections" table.
+	UserConnectionsColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeString, Unique: true},
+		{Name: "created_at", Type: field.TypeInt},
+		{Name: "updated_at", Type: field.TypeInt},
+		{Name: "type", Type: field.TypeEnum, Enums: []string{"wargaming"}},
+		{Name: "reference_id", Type: field.TypeString},
+		{Name: "permissions", Type: field.TypeString, Nullable: true, Default: ""},
+		{Name: "metadata", Type: field.TypeJSON, Nullable: true},
+		{Name: "user_id", Type: field.TypeString},
+	}
+	// UserConnectionsTable holds the schema information for the "user_connections" table.
+	UserConnectionsTable = &schema.Table{
+		Name:       "user_connections",
+		Columns:    UserConnectionsColumns,
+		PrimaryKey: []*schema.Column{UserConnectionsColumns[0]},
+		ForeignKeys: []*schema.ForeignKey{
+			{
+				Symbol:     "user_connections_users_connections",
+				Columns:    []*schema.Column{UserConnectionsColumns[7]},
+				RefColumns: []*schema.Column{UsersColumns[0]},
+				OnDelete:   schema.NoAction,
+			},
+		},
+		Indexes: []*schema.Index{
+			{
+				Name:    "userconnection_user_id",
+				Unique:  false,
+				Columns: []*schema.Column{UserConnectionsColumns[7]},
+			},
+			{
+				Name:    "userconnection_type_user_id",
+				Unique:  false,
+				Columns: []*schema.Column{UserConnectionsColumns[3], UserConnectionsColumns[7]},
+			},
+			{
+				Name:    "userconnection_reference_id",
+				Unique:  false,
+				Columns: []*schema.Column{UserConnectionsColumns[4]},
+			},
+			{
+				Name:    "userconnection_type_reference_id",
+				Unique:  false,
+				Columns: []*schema.Column{UserConnectionsColumns[3], UserConnectionsColumns[4]},
+			},
+		},
+	}
+	// UserContentsColumns holds the columns for the "user_contents" table.
+	UserContentsColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeString, Unique: true},
+		{Name: "created_at", Type: field.TypeInt},
+		{Name: "updated_at", Type: field.TypeInt},
+		{Name: "type", Type: field.TypeEnum, Enums: []string{"clan-background-image", "personal-background-image"}},
+		{Name: "reference_id", Type: field.TypeString},
+		{Name: "value", Type: field.TypeJSON},
+		{Name: "metadata", Type: field.TypeJSON},
+		{Name: "user_id", Type: field.TypeString},
+	}
+	// UserContentsTable holds the schema information for the "user_contents" table.
+	UserContentsTable = &schema.Table{
+		Name:       "user_contents",
+		Columns:    UserContentsColumns,
+		PrimaryKey: []*schema.Column{UserContentsColumns[0]},
+		ForeignKeys: []*schema.ForeignKey{
+			{
+				Symbol:     "user_contents_users_content",
+				Columns:    []*schema.Column{UserContentsColumns[7]},
+				RefColumns: []*schema.Column{UsersColumns[0]},
+				OnDelete:   schema.NoAction,
+			},
+		},
+		Indexes: []*schema.Index{
+			{
+				Name:    "usercontent_user_id",
+				Unique:  false,
+				Columns: []*schema.Column{UserContentsColumns[7]},
+			},
+			{
+				Name:    "usercontent_type_user_id",
+				Unique:  false,
+				Columns: []*schema.Column{UserContentsColumns[3], UserContentsColumns[7]},
+			},
+			{
+				Name:    "usercontent_reference_id",
+				Unique:  false,
+				Columns: []*schema.Column{UserContentsColumns[4]},
+			},
+			{
+				Name:    "usercontent_type_reference_id",
+				Unique:  false,
+				Columns: []*schema.Column{UserContentsColumns[3], UserContentsColumns[4]},
+			},
+		},
+	}
+	// UserSubscriptionsColumns holds the columns for the "user_subscriptions" table.
+	UserSubscriptionsColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeString, Unique: true},
+		{Name: "created_at", Type: field.TypeInt},
+		{Name: "updated_at", Type: field.TypeInt},
+		{Name: "type", Type: field.TypeEnum, Enums: []string{"aftermath-pro", "aftermath-pro-clan", "aftermath-plus", "supporter", "verified-clan", "server-moderator", "content-moderator", "developer", "server-booster", "content-translator"}},
+		{Name: "expires_at", Type: field.TypeInt},
+		{Name: "permissions", Type: field.TypeString},
+		{Name: "reference_id", Type: field.TypeString},
+		{Name: "user_id", Type: field.TypeString},
+	}
+	// UserSubscriptionsTable holds the schema information for the "user_subscriptions" table.
+	UserSubscriptionsTable = &schema.Table{
+		Name:       "user_subscriptions",
+		Columns:    UserSubscriptionsColumns,
+		PrimaryKey: []*schema.Column{UserSubscriptionsColumns[0]},
+		ForeignKeys: []*schema.ForeignKey{
+			{
+				Symbol:     "user_subscriptions_users_subscriptions",
+				Columns:    []*schema.Column{UserSubscriptionsColumns[7]},
+				RefColumns: []*schema.Column{UsersColumns[0]},
+				OnDelete:   schema.NoAction,
+			},
+		},
+		Indexes: []*schema.Index{
+			{
+				Name:    "usersubscription_user_id",
+				Unique:  false,
+				Columns: []*schema.Column{UserSubscriptionsColumns[7]},
+			},
+			{
+				Name:    "usersubscription_type_user_id",
+				Unique:  false,
+				Columns: []*schema.Column{UserSubscriptionsColumns[3], UserSubscriptionsColumns[7]},
+			},
+			{
+				Name:    "usersubscription_expires_at",
+				Unique:  false,
+				Columns: []*schema.Column{UserSubscriptionsColumns[4]},
+			},
+			{
+				Name:    "usersubscription_expires_at_user_id",
+				Unique:  false,
+				Columns: []*schema.Column{UserSubscriptionsColumns[4], UserSubscriptionsColumns[7]},
+			},
+		},
+	}
+	// VehiclesColumns holds the columns for the "vehicles" table.
+	VehiclesColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeString, Unique: true},
+		{Name: "created_at", Type: field.TypeInt},
+		{Name: "updated_at", Type: field.TypeInt},
+		{Name: "tier", Type: field.TypeInt},
+		{Name: "localized_names", Type: field.TypeJSON},
+	}
+	// VehiclesTable holds the schema information for the "vehicles" table.
+	VehiclesTable = &schema.Table{
+		Name:       "vehicles",
+		Columns:    VehiclesColumns,
+		PrimaryKey: []*schema.Column{VehiclesColumns[0]},
+	}
+	// VehicleAveragesColumns holds the columns for the "vehicle_averages" table.
+	VehicleAveragesColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeString, Unique: true},
+		{Name: "created_at", Type: field.TypeInt},
+		{Name: "updated_at", Type: field.TypeInt},
+		{Name: "data", Type: field.TypeJSON},
+	}
+	// VehicleAveragesTable holds the schema information for the "vehicle_averages" table.
+	VehicleAveragesTable = &schema.Table{
+		Name:       "vehicle_averages",
+		Columns:    VehicleAveragesColumns,
+		PrimaryKey: []*schema.Column{VehicleAveragesColumns[0]},
+	}
+	// VehicleSnapshotsColumns holds the columns for the "vehicle_snapshots" table.
+	VehicleSnapshotsColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeString, Unique: true},
+		{Name: "created_at", Type: field.TypeInt},
+		{Name: "updated_at", Type: field.TypeInt},
+		{Name: "type", Type: field.TypeEnum, Enums: []string{"live", "daily"}},
+		{Name: "vehicle_id", Type: field.TypeString},
+		{Name: "reference_id", Type: field.TypeString},
+		{Name: "battles", Type: field.TypeInt},
+		{Name: "last_battle_time", Type: field.TypeInt},
+		{Name: "frame", Type: field.TypeJSON},
+		{Name: "account_id", Type: field.TypeString},
+	}
+	// VehicleSnapshotsTable holds the schema information for the "vehicle_snapshots" table.
+	VehicleSnapshotsTable = &schema.Table{
+		Name:       "vehicle_snapshots",
+		Columns:    VehicleSnapshotsColumns,
+		PrimaryKey: []*schema.Column{VehicleSnapshotsColumns[0]},
+		ForeignKeys: []*schema.ForeignKey{
+			{
+				Symbol:     "vehicle_snapshots_accounts_vehicle_snapshots",
+				Columns:    []*schema.Column{VehicleSnapshotsColumns[9]},
+				RefColumns: []*schema.Column{AccountsColumns[0]},
+				OnDelete:   schema.NoAction,
+			},
+		},
+		Indexes: []*schema.Index{
+			{
+				Name:    "vehiclesnapshot_created_at",
+				Unique:  false,
+				Columns: []*schema.Column{VehicleSnapshotsColumns[1]},
+			},
+			{
+				Name:    "vehiclesnapshot_vehicle_id_created_at",
+				Unique:  false,
+				Columns: []*schema.Column{VehicleSnapshotsColumns[4], VehicleSnapshotsColumns[1]},
+			},
+			{
+				Name:    "vehiclesnapshot_account_id_created_at",
+				Unique:  false,
+				Columns: []*schema.Column{VehicleSnapshotsColumns[9], VehicleSnapshotsColumns[1]},
+			},
+			{
+				Name:    "vehiclesnapshot_account_id_type_created_at",
+				Unique:  false,
+				Columns: []*schema.Column{VehicleSnapshotsColumns[9], VehicleSnapshotsColumns[3], VehicleSnapshotsColumns[1]},
+			},
+		},
+	}
+	// Tables holds all the tables in the schema.
+	Tables = []*schema.Table{
+		AccountsTable,
+		AccountSnapshotsTable,
+		AchievementsSnapshotsTable,
+		AppConfigurationsTable,
+		ApplicationCommandsTable,
+		ClansTable,
+		CronTasksTable,
+		UsersTable,
+		UserConnectionsTable,
+		UserContentsTable,
+		UserSubscriptionsTable,
+		VehiclesTable,
+		VehicleAveragesTable,
+		VehicleSnapshotsTable,
+	}
+)
+
+func init() {
+	AccountsTable.ForeignKeys[0].RefTable = ClansTable
+	AccountSnapshotsTable.ForeignKeys[0].RefTable = AccountsTable
+	AchievementsSnapshotsTable.ForeignKeys[0].RefTable = AccountsTable
+	UserConnectionsTable.ForeignKeys[0].RefTable = UsersTable
+	UserContentsTable.ForeignKeys[0].RefTable = UsersTable
+	UserSubscriptionsTable.ForeignKeys[0].RefTable = UsersTable
+	VehicleSnapshotsTable.ForeignKeys[0].RefTable = AccountsTable
+}
diff --git a/internal/database/ent/db/mutation.go b/internal/database/ent/db/mutation.go
new file mode 100644
index 00000000..dbf6c4bc
--- /dev/null
+++ b/internal/database/ent/db/mutation.go
@@ -0,0 +1,11540 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sync"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+	"github.com/cufee/aftermath/internal/database/ent/db/account"
+	"github.com/cufee/aftermath/internal/database/ent/db/accountsnapshot"
+	"github.com/cufee/aftermath/internal/database/ent/db/achievementssnapshot"
+	"github.com/cufee/aftermath/internal/database/ent/db/appconfiguration"
+	"github.com/cufee/aftermath/internal/database/ent/db/applicationcommand"
+	"github.com/cufee/aftermath/internal/database/ent/db/clan"
+	"github.com/cufee/aftermath/internal/database/ent/db/crontask"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/ent/db/user"
+	"github.com/cufee/aftermath/internal/database/ent/db/userconnection"
+	"github.com/cufee/aftermath/internal/database/ent/db/usercontent"
+	"github.com/cufee/aftermath/internal/database/ent/db/usersubscription"
+	"github.com/cufee/aftermath/internal/database/ent/db/vehicle"
+	"github.com/cufee/aftermath/internal/database/ent/db/vehicleaverage"
+	"github.com/cufee/aftermath/internal/database/ent/db/vehiclesnapshot"
+	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/stats/frame"
+	"github.com/cufee/am-wg-proxy-next/v2/types"
+)
+
+const (
+	// Operation types.
+	OpCreate    = ent.OpCreate
+	OpDelete    = ent.OpDelete
+	OpDeleteOne = ent.OpDeleteOne
+	OpUpdate    = ent.OpUpdate
+	OpUpdateOne = ent.OpUpdateOne
+
+	// Node types.
+	TypeAccount              = "Account"
+	TypeAccountSnapshot      = "AccountSnapshot"
+	TypeAchievementsSnapshot = "AchievementsSnapshot"
+	TypeAppConfiguration     = "AppConfiguration"
+	TypeApplicationCommand   = "ApplicationCommand"
+	TypeClan                 = "Clan"
+	TypeCronTask             = "CronTask"
+	TypeUser                 = "User"
+	TypeUserConnection       = "UserConnection"
+	TypeUserContent          = "UserContent"
+	TypeUserSubscription     = "UserSubscription"
+	TypeVehicle              = "Vehicle"
+	TypeVehicleAverage       = "VehicleAverage"
+	TypeVehicleSnapshot      = "VehicleSnapshot"
+)
+
+// AccountMutation represents an operation that mutates the Account nodes in the graph.
+type AccountMutation struct {
+	config
+	op                           Op
+	typ                          string
+	id                           *string
+	created_at                   *int
+	addcreated_at                *int
+	updated_at                   *int
+	addupdated_at                *int
+	last_battle_time             *int
+	addlast_battle_time          *int
+	account_created_at           *int
+	addaccount_created_at        *int
+	realm                        *string
+	nickname                     *string
+	private                      *bool
+	clearedFields                map[string]struct{}
+	clan                         *string
+	clearedclan                  bool
+	snapshots                    map[string]struct{}
+	removedsnapshots             map[string]struct{}
+	clearedsnapshots             bool
+	vehicle_snapshots            map[string]struct{}
+	removedvehicle_snapshots     map[string]struct{}
+	clearedvehicle_snapshots     bool
+	achievement_snapshots        map[string]struct{}
+	removedachievement_snapshots map[string]struct{}
+	clearedachievement_snapshots bool
+	done                         bool
+	oldValue                     func(context.Context) (*Account, error)
+	predicates                   []predicate.Account
+}
+
+var _ ent.Mutation = (*AccountMutation)(nil)
+
+// accountOption allows management of the mutation configuration using functional options.
+type accountOption func(*AccountMutation)
+
+// newAccountMutation creates new mutation for the Account entity.
+func newAccountMutation(c config, op Op, opts ...accountOption) *AccountMutation {
+	m := &AccountMutation{
+		config:        c,
+		op:            op,
+		typ:           TypeAccount,
+		clearedFields: make(map[string]struct{}),
+	}
+	for _, opt := range opts {
+		opt(m)
+	}
+	return m
+}
+
+// withAccountID sets the ID field of the mutation.
+func withAccountID(id string) accountOption {
+	return func(m *AccountMutation) {
+		var (
+			err   error
+			once  sync.Once
+			value *Account
+		)
+		m.oldValue = func(ctx context.Context) (*Account, error) {
+			once.Do(func() {
+				if m.done {
+					err = errors.New("querying old values post mutation is not allowed")
+				} else {
+					value, err = m.Client().Account.Get(ctx, id)
+				}
+			})
+			return value, err
+		}
+		m.id = &id
+	}
+}
+
+// withAccount sets the old Account of the mutation.
+func withAccount(node *Account) accountOption {
+	return func(m *AccountMutation) {
+		m.oldValue = func(context.Context) (*Account, error) {
+			return node, nil
+		}
+		m.id = &node.ID
+	}
+}
+
+// Client returns a new `ent.Client` from the mutation. If the mutation was
+// executed in a transaction (ent.Tx), a transactional client is returned.
+func (m AccountMutation) Client() *Client {
+	client := &Client{config: m.config}
+	client.init()
+	return client
+}
+
+// Tx returns an `ent.Tx` for mutations that were executed in transactions;
+// it returns an error otherwise.
+func (m AccountMutation) Tx() (*Tx, error) {
+	if _, ok := m.driver.(*txDriver); !ok {
+		return nil, errors.New("db: mutation is not running in a transaction")
+	}
+	tx := &Tx{config: m.config}
+	tx.init()
+	return tx, nil
+}
+
+// SetID sets the value of the id field. Note that this
+// operation is only accepted on creation of Account entities.
+func (m *AccountMutation) SetID(id string) {
+	m.id = &id
+}
+
+// ID returns the ID value in the mutation. Note that the ID is only available
+// if it was provided to the builder or after it was returned from the database.
+func (m *AccountMutation) ID() (id string, exists bool) {
+	if m.id == nil {
+		return
+	}
+	return *m.id, true
+}
+
+// IDs queries the database and returns the entity ids that match the mutation's predicate.
+// That means, if the mutation is applied within a transaction with an isolation level such
+// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
+// or updated by the mutation.
+func (m *AccountMutation) IDs(ctx context.Context) ([]string, error) {
+	switch {
+	case m.op.Is(OpUpdateOne | OpDeleteOne):
+		id, exists := m.ID()
+		if exists {
+			return []string{id}, nil
+		}
+		fallthrough
+	case m.op.Is(OpUpdate | OpDelete):
+		return m.Client().Account.Query().Where(m.predicates...).IDs(ctx)
+	default:
+		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
+	}
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (m *AccountMutation) SetCreatedAt(i int) {
+	m.created_at = &i
+	m.addcreated_at = nil
+}
+
+// CreatedAt returns the value of the "created_at" field in the mutation.
+func (m *AccountMutation) CreatedAt() (r int, exists bool) {
+	v := m.created_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldCreatedAt returns the old "created_at" field's value of the Account entity.
+// If the Account object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *AccountMutation) OldCreatedAt(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldCreatedAt requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
+	}
+	return oldValue.CreatedAt, nil
+}
+
+// AddCreatedAt adds i to the "created_at" field.
+func (m *AccountMutation) AddCreatedAt(i int) {
+	if m.addcreated_at != nil {
+		*m.addcreated_at += i
+	} else {
+		m.addcreated_at = &i
+	}
+}
+
+// AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
+func (m *AccountMutation) AddedCreatedAt() (r int, exists bool) {
+	v := m.addcreated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetCreatedAt resets all changes to the "created_at" field.
+func (m *AccountMutation) ResetCreatedAt() {
+	m.created_at = nil
+	m.addcreated_at = nil
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (m *AccountMutation) SetUpdatedAt(i int) {
+	m.updated_at = &i
+	m.addupdated_at = nil
+}
+
+// UpdatedAt returns the value of the "updated_at" field in the mutation.
+func (m *AccountMutation) UpdatedAt() (r int, exists bool) {
+	v := m.updated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldUpdatedAt returns the old "updated_at" field's value of the Account entity.
+// If the Account object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *AccountMutation) OldUpdatedAt(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
+	}
+	return oldValue.UpdatedAt, nil
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (m *AccountMutation) AddUpdatedAt(i int) {
+	if m.addupdated_at != nil {
+		*m.addupdated_at += i
+	} else {
+		m.addupdated_at = &i
+	}
+}
+
+// AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
+func (m *AccountMutation) AddedUpdatedAt() (r int, exists bool) {
+	v := m.addupdated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetUpdatedAt resets all changes to the "updated_at" field.
+func (m *AccountMutation) ResetUpdatedAt() {
+	m.updated_at = nil
+	m.addupdated_at = nil
+}
+
+// SetLastBattleTime sets the "last_battle_time" field.
+func (m *AccountMutation) SetLastBattleTime(i int) {
+	m.last_battle_time = &i
+	m.addlast_battle_time = nil
+}
+
+// LastBattleTime returns the value of the "last_battle_time" field in the mutation.
+func (m *AccountMutation) LastBattleTime() (r int, exists bool) {
+	v := m.last_battle_time
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldLastBattleTime returns the old "last_battle_time" field's value of the Account entity.
+// If the Account object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *AccountMutation) OldLastBattleTime(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldLastBattleTime is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldLastBattleTime requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldLastBattleTime: %w", err)
+	}
+	return oldValue.LastBattleTime, nil
+}
+
+// AddLastBattleTime adds i to the "last_battle_time" field.
+func (m *AccountMutation) AddLastBattleTime(i int) {
+	if m.addlast_battle_time != nil {
+		*m.addlast_battle_time += i
+	} else {
+		m.addlast_battle_time = &i
+	}
+}
+
+// AddedLastBattleTime returns the value that was added to the "last_battle_time" field in this mutation.
+func (m *AccountMutation) AddedLastBattleTime() (r int, exists bool) {
+	v := m.addlast_battle_time
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetLastBattleTime resets all changes to the "last_battle_time" field.
+func (m *AccountMutation) ResetLastBattleTime() {
+	m.last_battle_time = nil
+	m.addlast_battle_time = nil
+}
+
+// SetAccountCreatedAt sets the "account_created_at" field.
+func (m *AccountMutation) SetAccountCreatedAt(i int) {
+	m.account_created_at = &i
+	m.addaccount_created_at = nil
+}
+
+// AccountCreatedAt returns the value of the "account_created_at" field in the mutation.
+func (m *AccountMutation) AccountCreatedAt() (r int, exists bool) {
+	v := m.account_created_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldAccountCreatedAt returns the old "account_created_at" field's value of the Account entity.
+// If the Account object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *AccountMutation) OldAccountCreatedAt(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldAccountCreatedAt is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldAccountCreatedAt requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldAccountCreatedAt: %w", err)
+	}
+	return oldValue.AccountCreatedAt, nil
+}
+
+// AddAccountCreatedAt adds i to the "account_created_at" field.
+func (m *AccountMutation) AddAccountCreatedAt(i int) {
+	if m.addaccount_created_at != nil {
+		*m.addaccount_created_at += i
+	} else {
+		m.addaccount_created_at = &i
+	}
+}
+
+// AddedAccountCreatedAt returns the value that was added to the "account_created_at" field in this mutation.
+func (m *AccountMutation) AddedAccountCreatedAt() (r int, exists bool) {
+	v := m.addaccount_created_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetAccountCreatedAt resets all changes to the "account_created_at" field.
+func (m *AccountMutation) ResetAccountCreatedAt() {
+	m.account_created_at = nil
+	m.addaccount_created_at = nil
+}
+
+// SetRealm sets the "realm" field.
+func (m *AccountMutation) SetRealm(s string) {
+	m.realm = &s
+}
+
+// Realm returns the value of the "realm" field in the mutation.
+func (m *AccountMutation) Realm() (r string, exists bool) {
+	v := m.realm
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldRealm returns the old "realm" field's value of the Account entity.
+// If the Account object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *AccountMutation) OldRealm(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldRealm is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldRealm requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldRealm: %w", err)
+	}
+	return oldValue.Realm, nil
+}
+
+// ResetRealm resets all changes to the "realm" field.
+func (m *AccountMutation) ResetRealm() {
+	m.realm = nil
+}
+
+// SetNickname sets the "nickname" field.
+func (m *AccountMutation) SetNickname(s string) {
+	m.nickname = &s
+}
+
+// Nickname returns the value of the "nickname" field in the mutation.
+func (m *AccountMutation) Nickname() (r string, exists bool) {
+	v := m.nickname
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldNickname returns the old "nickname" field's value of the Account entity.
+// If the Account object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *AccountMutation) OldNickname(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldNickname is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldNickname requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldNickname: %w", err)
+	}
+	return oldValue.Nickname, nil
+}
+
+// ResetNickname resets all changes to the "nickname" field.
+func (m *AccountMutation) ResetNickname() {
+	m.nickname = nil
+}
+
+// SetPrivate sets the "private" field.
+func (m *AccountMutation) SetPrivate(b bool) {
+	m.private = &b
+}
+
+// Private returns the value of the "private" field in the mutation.
+func (m *AccountMutation) Private() (r bool, exists bool) {
+	v := m.private
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldPrivate returns the old "private" field's value of the Account entity.
+// If the Account object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *AccountMutation) OldPrivate(ctx context.Context) (v bool, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldPrivate is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldPrivate requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldPrivate: %w", err)
+	}
+	return oldValue.Private, nil
+}
+
+// ResetPrivate resets all changes to the "private" field.
+func (m *AccountMutation) ResetPrivate() {
+	m.private = nil
+}
+
+// SetClanID sets the "clan_id" field.
+func (m *AccountMutation) SetClanID(s string) {
+	m.clan = &s
+}
+
+// ClanID returns the value of the "clan_id" field in the mutation.
+func (m *AccountMutation) ClanID() (r string, exists bool) {
+	v := m.clan
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldClanID returns the old "clan_id" field's value of the Account entity.
+// If the Account object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *AccountMutation) OldClanID(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldClanID is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldClanID requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldClanID: %w", err)
+	}
+	return oldValue.ClanID, nil
+}
+
+// ClearClanID clears the value of the "clan_id" field.
+func (m *AccountMutation) ClearClanID() {
+	m.clan = nil
+	m.clearedFields[account.FieldClanID] = struct{}{}
+}
+
+// ClanIDCleared returns if the "clan_id" field was cleared in this mutation.
+func (m *AccountMutation) ClanIDCleared() bool {
+	_, ok := m.clearedFields[account.FieldClanID]
+	return ok
+}
+
+// ResetClanID resets all changes to the "clan_id" field.
+func (m *AccountMutation) ResetClanID() {
+	m.clan = nil
+	delete(m.clearedFields, account.FieldClanID)
+}
+
+// ClearClan clears the "clan" edge to the Clan entity.
+func (m *AccountMutation) ClearClan() {
+	m.clearedclan = true
+	m.clearedFields[account.FieldClanID] = struct{}{}
+}
+
+// ClanCleared reports if the "clan" edge to the Clan entity was cleared.
+func (m *AccountMutation) ClanCleared() bool {
+	return m.ClanIDCleared() || m.clearedclan
+}
+
+// ClanIDs returns the "clan" edge IDs in the mutation.
+// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
+// ClanID instead. It exists only for internal usage by the builders.
+func (m *AccountMutation) ClanIDs() (ids []string) {
+	if id := m.clan; id != nil {
+		ids = append(ids, *id)
+	}
+	return
+}
+
+// ResetClan resets all changes to the "clan" edge.
+func (m *AccountMutation) ResetClan() {
+	m.clan = nil
+	m.clearedclan = false
+}
+
+// AddSnapshotIDs adds the "snapshots" edge to the AccountSnapshot entity by ids.
+func (m *AccountMutation) AddSnapshotIDs(ids ...string) {
+	if m.snapshots == nil {
+		m.snapshots = make(map[string]struct{})
+	}
+	for i := range ids {
+		m.snapshots[ids[i]] = struct{}{}
+	}
+}
+
+// ClearSnapshots clears the "snapshots" edge to the AccountSnapshot entity.
+func (m *AccountMutation) ClearSnapshots() {
+	m.clearedsnapshots = true
+}
+
+// SnapshotsCleared reports if the "snapshots" edge to the AccountSnapshot entity was cleared.
+func (m *AccountMutation) SnapshotsCleared() bool {
+	return m.clearedsnapshots
+}
+
+// RemoveSnapshotIDs removes the "snapshots" edge to the AccountSnapshot entity by IDs.
+func (m *AccountMutation) RemoveSnapshotIDs(ids ...string) {
+	if m.removedsnapshots == nil {
+		m.removedsnapshots = make(map[string]struct{})
+	}
+	for i := range ids {
+		delete(m.snapshots, ids[i])
+		m.removedsnapshots[ids[i]] = struct{}{}
+	}
+}
+
+// RemovedSnapshots returns the removed IDs of the "snapshots" edge to the AccountSnapshot entity.
+func (m *AccountMutation) RemovedSnapshotsIDs() (ids []string) {
+	for id := range m.removedsnapshots {
+		ids = append(ids, id)
+	}
+	return
+}
+
+// SnapshotsIDs returns the "snapshots" edge IDs in the mutation.
+func (m *AccountMutation) SnapshotsIDs() (ids []string) {
+	for id := range m.snapshots {
+		ids = append(ids, id)
+	}
+	return
+}
+
+// ResetSnapshots resets all changes to the "snapshots" edge.
+func (m *AccountMutation) ResetSnapshots() {
+	m.snapshots = nil
+	m.clearedsnapshots = false
+	m.removedsnapshots = nil
+}
+
+// AddVehicleSnapshotIDs adds the "vehicle_snapshots" edge to the VehicleSnapshot entity by ids.
+func (m *AccountMutation) AddVehicleSnapshotIDs(ids ...string) {
+	if m.vehicle_snapshots == nil {
+		m.vehicle_snapshots = make(map[string]struct{})
+	}
+	for i := range ids {
+		m.vehicle_snapshots[ids[i]] = struct{}{}
+	}
+}
+
+// ClearVehicleSnapshots clears the "vehicle_snapshots" edge to the VehicleSnapshot entity.
+func (m *AccountMutation) ClearVehicleSnapshots() {
+	m.clearedvehicle_snapshots = true
+}
+
+// VehicleSnapshotsCleared reports if the "vehicle_snapshots" edge to the VehicleSnapshot entity was cleared.
+func (m *AccountMutation) VehicleSnapshotsCleared() bool {
+	return m.clearedvehicle_snapshots
+}
+
+// RemoveVehicleSnapshotIDs removes the "vehicle_snapshots" edge to the VehicleSnapshot entity by IDs.
+func (m *AccountMutation) RemoveVehicleSnapshotIDs(ids ...string) {
+	if m.removedvehicle_snapshots == nil {
+		m.removedvehicle_snapshots = make(map[string]struct{})
+	}
+	for i := range ids {
+		delete(m.vehicle_snapshots, ids[i])
+		m.removedvehicle_snapshots[ids[i]] = struct{}{}
+	}
+}
+
+// RemovedVehicleSnapshots returns the removed IDs of the "vehicle_snapshots" edge to the VehicleSnapshot entity.
+func (m *AccountMutation) RemovedVehicleSnapshotsIDs() (ids []string) {
+	for id := range m.removedvehicle_snapshots {
+		ids = append(ids, id)
+	}
+	return
+}
+
+// VehicleSnapshotsIDs returns the "vehicle_snapshots" edge IDs in the mutation.
+func (m *AccountMutation) VehicleSnapshotsIDs() (ids []string) {
+	for id := range m.vehicle_snapshots {
+		ids = append(ids, id)
+	}
+	return
+}
+
+// ResetVehicleSnapshots resets all changes to the "vehicle_snapshots" edge.
+func (m *AccountMutation) ResetVehicleSnapshots() {
+	m.vehicle_snapshots = nil
+	m.clearedvehicle_snapshots = false
+	m.removedvehicle_snapshots = nil
+}
+
+// AddAchievementSnapshotIDs adds the "achievement_snapshots" edge to the AchievementsSnapshot entity by ids.
+func (m *AccountMutation) AddAchievementSnapshotIDs(ids ...string) {
+	if m.achievement_snapshots == nil {
+		m.achievement_snapshots = make(map[string]struct{})
+	}
+	for i := range ids {
+		m.achievement_snapshots[ids[i]] = struct{}{}
+	}
+}
+
+// ClearAchievementSnapshots clears the "achievement_snapshots" edge to the AchievementsSnapshot entity.
+func (m *AccountMutation) ClearAchievementSnapshots() {
+	m.clearedachievement_snapshots = true
+}
+
+// AchievementSnapshotsCleared reports if the "achievement_snapshots" edge to the AchievementsSnapshot entity was cleared.
+func (m *AccountMutation) AchievementSnapshotsCleared() bool {
+	return m.clearedachievement_snapshots
+}
+
+// RemoveAchievementSnapshotIDs removes the "achievement_snapshots" edge to the AchievementsSnapshot entity by IDs.
+func (m *AccountMutation) RemoveAchievementSnapshotIDs(ids ...string) {
+	if m.removedachievement_snapshots == nil {
+		m.removedachievement_snapshots = make(map[string]struct{})
+	}
+	for i := range ids {
+		delete(m.achievement_snapshots, ids[i])
+		m.removedachievement_snapshots[ids[i]] = struct{}{}
+	}
+}
+
+// RemovedAchievementSnapshots returns the removed IDs of the "achievement_snapshots" edge to the AchievementsSnapshot entity.
+func (m *AccountMutation) RemovedAchievementSnapshotsIDs() (ids []string) {
+	for id := range m.removedachievement_snapshots {
+		ids = append(ids, id)
+	}
+	return
+}
+
+// AchievementSnapshotsIDs returns the "achievement_snapshots" edge IDs in the mutation.
+func (m *AccountMutation) AchievementSnapshotsIDs() (ids []string) {
+	for id := range m.achievement_snapshots {
+		ids = append(ids, id)
+	}
+	return
+}
+
+// ResetAchievementSnapshots resets all changes to the "achievement_snapshots" edge.
+func (m *AccountMutation) ResetAchievementSnapshots() {
+	m.achievement_snapshots = nil
+	m.clearedachievement_snapshots = false
+	m.removedachievement_snapshots = nil
+}
+
+// Where appends a list predicates to the AccountMutation builder.
+func (m *AccountMutation) Where(ps ...predicate.Account) {
+	m.predicates = append(m.predicates, ps...)
+}
+
+// WhereP appends storage-level predicates to the AccountMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *AccountMutation) WhereP(ps ...func(*sql.Selector)) {
+	p := make([]predicate.Account, len(ps))
+	for i := range ps {
+		p[i] = ps[i]
+	}
+	m.Where(p...)
+}
+
+// Op returns the operation name.
+func (m *AccountMutation) Op() Op {
+	return m.op
+}
+
+// SetOp allows setting the mutation operation.
+func (m *AccountMutation) SetOp(op Op) {
+	m.op = op
+}
+
+// Type returns the node type of this mutation (Account).
+func (m *AccountMutation) Type() string {
+	return m.typ
+}
+
+// Fields returns all fields that were changed during this mutation. Note that in
+// order to get all numeric fields that were incremented/decremented, call
+// AddedFields().
+func (m *AccountMutation) Fields() []string {
+	fields := make([]string, 0, 8)
+	if m.created_at != nil {
+		fields = append(fields, account.FieldCreatedAt)
+	}
+	if m.updated_at != nil {
+		fields = append(fields, account.FieldUpdatedAt)
+	}
+	if m.last_battle_time != nil {
+		fields = append(fields, account.FieldLastBattleTime)
+	}
+	if m.account_created_at != nil {
+		fields = append(fields, account.FieldAccountCreatedAt)
+	}
+	if m.realm != nil {
+		fields = append(fields, account.FieldRealm)
+	}
+	if m.nickname != nil {
+		fields = append(fields, account.FieldNickname)
+	}
+	if m.private != nil {
+		fields = append(fields, account.FieldPrivate)
+	}
+	if m.clan != nil {
+		fields = append(fields, account.FieldClanID)
+	}
+	return fields
+}
+
+// Field returns the value of a field with the given name. The second boolean
+// return value indicates that this field was not set, or was not defined in the
+// schema.
+func (m *AccountMutation) Field(name string) (ent.Value, bool) {
+	switch name {
+	case account.FieldCreatedAt:
+		return m.CreatedAt()
+	case account.FieldUpdatedAt:
+		return m.UpdatedAt()
+	case account.FieldLastBattleTime:
+		return m.LastBattleTime()
+	case account.FieldAccountCreatedAt:
+		return m.AccountCreatedAt()
+	case account.FieldRealm:
+		return m.Realm()
+	case account.FieldNickname:
+		return m.Nickname()
+	case account.FieldPrivate:
+		return m.Private()
+	case account.FieldClanID:
+		return m.ClanID()
+	}
+	return nil, false
+}
+
+// OldField returns the old value of the field from the database. An error is
+// returned if the mutation operation is not UpdateOne, or the query to the
+// database failed.
+func (m *AccountMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
+	switch name {
+	case account.FieldCreatedAt:
+		return m.OldCreatedAt(ctx)
+	case account.FieldUpdatedAt:
+		return m.OldUpdatedAt(ctx)
+	case account.FieldLastBattleTime:
+		return m.OldLastBattleTime(ctx)
+	case account.FieldAccountCreatedAt:
+		return m.OldAccountCreatedAt(ctx)
+	case account.FieldRealm:
+		return m.OldRealm(ctx)
+	case account.FieldNickname:
+		return m.OldNickname(ctx)
+	case account.FieldPrivate:
+		return m.OldPrivate(ctx)
+	case account.FieldClanID:
+		return m.OldClanID(ctx)
+	}
+	return nil, fmt.Errorf("unknown Account field %s", name)
+}
+
+// SetField sets the value of a field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *AccountMutation) SetField(name string, value ent.Value) error {
+	switch name {
+	case account.FieldCreatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetCreatedAt(v)
+		return nil
+	case account.FieldUpdatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetUpdatedAt(v)
+		return nil
+	case account.FieldLastBattleTime:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetLastBattleTime(v)
+		return nil
+	case account.FieldAccountCreatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetAccountCreatedAt(v)
+		return nil
+	case account.FieldRealm:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetRealm(v)
+		return nil
+	case account.FieldNickname:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetNickname(v)
+		return nil
+	case account.FieldPrivate:
+		v, ok := value.(bool)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetPrivate(v)
+		return nil
+	case account.FieldClanID:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetClanID(v)
+		return nil
+	}
+	return fmt.Errorf("unknown Account field %s", name)
+}
+
+// AddedFields returns all numeric fields that were incremented/decremented during
+// this mutation.
+func (m *AccountMutation) AddedFields() []string {
+	var fields []string
+	if m.addcreated_at != nil {
+		fields = append(fields, account.FieldCreatedAt)
+	}
+	if m.addupdated_at != nil {
+		fields = append(fields, account.FieldUpdatedAt)
+	}
+	if m.addlast_battle_time != nil {
+		fields = append(fields, account.FieldLastBattleTime)
+	}
+	if m.addaccount_created_at != nil {
+		fields = append(fields, account.FieldAccountCreatedAt)
+	}
+	return fields
+}
+
+// AddedField returns the numeric value that was incremented/decremented on a field
+// with the given name. The second boolean return value indicates that this field
+// was not set, or was not defined in the schema.
+func (m *AccountMutation) AddedField(name string) (ent.Value, bool) {
+	switch name {
+	case account.FieldCreatedAt:
+		return m.AddedCreatedAt()
+	case account.FieldUpdatedAt:
+		return m.AddedUpdatedAt()
+	case account.FieldLastBattleTime:
+		return m.AddedLastBattleTime()
+	case account.FieldAccountCreatedAt:
+		return m.AddedAccountCreatedAt()
+	}
+	return nil, false
+}
+
+// AddField adds the value to the field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *AccountMutation) AddField(name string, value ent.Value) error {
+	switch name {
+	case account.FieldCreatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddCreatedAt(v)
+		return nil
+	case account.FieldUpdatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddUpdatedAt(v)
+		return nil
+	case account.FieldLastBattleTime:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddLastBattleTime(v)
+		return nil
+	case account.FieldAccountCreatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddAccountCreatedAt(v)
+		return nil
+	}
+	return fmt.Errorf("unknown Account numeric field %s", name)
+}
+
+// ClearedFields returns all nullable fields that were cleared during this
+// mutation.
+func (m *AccountMutation) ClearedFields() []string {
+	var fields []string
+	if m.FieldCleared(account.FieldClanID) {
+		fields = append(fields, account.FieldClanID)
+	}
+	return fields
+}
+
+// FieldCleared returns a boolean indicating if a field with the given name was
+// cleared in this mutation.
+func (m *AccountMutation) FieldCleared(name string) bool {
+	_, ok := m.clearedFields[name]
+	return ok
+}
+
+// ClearField clears the value of the field with the given name. It returns an
+// error if the field is not defined in the schema.
+func (m *AccountMutation) ClearField(name string) error {
+	switch name {
+	case account.FieldClanID:
+		m.ClearClanID()
+		return nil
+	}
+	return fmt.Errorf("unknown Account nullable field %s", name)
+}
+
+// ResetField resets all changes in the mutation for the field with the given name.
+// It returns an error if the field is not defined in the schema.
+func (m *AccountMutation) ResetField(name string) error {
+	switch name {
+	case account.FieldCreatedAt:
+		m.ResetCreatedAt()
+		return nil
+	case account.FieldUpdatedAt:
+		m.ResetUpdatedAt()
+		return nil
+	case account.FieldLastBattleTime:
+		m.ResetLastBattleTime()
+		return nil
+	case account.FieldAccountCreatedAt:
+		m.ResetAccountCreatedAt()
+		return nil
+	case account.FieldRealm:
+		m.ResetRealm()
+		return nil
+	case account.FieldNickname:
+		m.ResetNickname()
+		return nil
+	case account.FieldPrivate:
+		m.ResetPrivate()
+		return nil
+	case account.FieldClanID:
+		m.ResetClanID()
+		return nil
+	}
+	return fmt.Errorf("unknown Account field %s", name)
+}
+
+// AddedEdges returns all edge names that were set/added in this mutation.
+func (m *AccountMutation) AddedEdges() []string {
+	edges := make([]string, 0, 4)
+	if m.clan != nil {
+		edges = append(edges, account.EdgeClan)
+	}
+	if m.snapshots != nil {
+		edges = append(edges, account.EdgeSnapshots)
+	}
+	if m.vehicle_snapshots != nil {
+		edges = append(edges, account.EdgeVehicleSnapshots)
+	}
+	if m.achievement_snapshots != nil {
+		edges = append(edges, account.EdgeAchievementSnapshots)
+	}
+	return edges
+}
+
+// AddedIDs returns all IDs (to other nodes) that were added for the given edge
+// name in this mutation.
+func (m *AccountMutation) AddedIDs(name string) []ent.Value {
+	switch name {
+	case account.EdgeClan:
+		if id := m.clan; id != nil {
+			return []ent.Value{*id}
+		}
+	case account.EdgeSnapshots:
+		ids := make([]ent.Value, 0, len(m.snapshots))
+		for id := range m.snapshots {
+			ids = append(ids, id)
+		}
+		return ids
+	case account.EdgeVehicleSnapshots:
+		ids := make([]ent.Value, 0, len(m.vehicle_snapshots))
+		for id := range m.vehicle_snapshots {
+			ids = append(ids, id)
+		}
+		return ids
+	case account.EdgeAchievementSnapshots:
+		ids := make([]ent.Value, 0, len(m.achievement_snapshots))
+		for id := range m.achievement_snapshots {
+			ids = append(ids, id)
+		}
+		return ids
+	}
+	return nil
+}
+
+// RemovedEdges returns all edge names that were removed in this mutation.
+func (m *AccountMutation) RemovedEdges() []string {
+	edges := make([]string, 0, 4)
+	if m.removedsnapshots != nil {
+		edges = append(edges, account.EdgeSnapshots)
+	}
+	if m.removedvehicle_snapshots != nil {
+		edges = append(edges, account.EdgeVehicleSnapshots)
+	}
+	if m.removedachievement_snapshots != nil {
+		edges = append(edges, account.EdgeAchievementSnapshots)
+	}
+	return edges
+}
+
+// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
+// the given name in this mutation.
+func (m *AccountMutation) RemovedIDs(name string) []ent.Value {
+	switch name {
+	case account.EdgeSnapshots:
+		ids := make([]ent.Value, 0, len(m.removedsnapshots))
+		for id := range m.removedsnapshots {
+			ids = append(ids, id)
+		}
+		return ids
+	case account.EdgeVehicleSnapshots:
+		ids := make([]ent.Value, 0, len(m.removedvehicle_snapshots))
+		for id := range m.removedvehicle_snapshots {
+			ids = append(ids, id)
+		}
+		return ids
+	case account.EdgeAchievementSnapshots:
+		ids := make([]ent.Value, 0, len(m.removedachievement_snapshots))
+		for id := range m.removedachievement_snapshots {
+			ids = append(ids, id)
+		}
+		return ids
+	}
+	return nil
+}
+
+// ClearedEdges returns all edge names that were cleared in this mutation.
+func (m *AccountMutation) ClearedEdges() []string {
+	edges := make([]string, 0, 4)
+	if m.clearedclan {
+		edges = append(edges, account.EdgeClan)
+	}
+	if m.clearedsnapshots {
+		edges = append(edges, account.EdgeSnapshots)
+	}
+	if m.clearedvehicle_snapshots {
+		edges = append(edges, account.EdgeVehicleSnapshots)
+	}
+	if m.clearedachievement_snapshots {
+		edges = append(edges, account.EdgeAchievementSnapshots)
+	}
+	return edges
+}
+
+// EdgeCleared returns a boolean which indicates if the edge with the given name
+// was cleared in this mutation.
+func (m *AccountMutation) EdgeCleared(name string) bool {
+	switch name {
+	case account.EdgeClan:
+		return m.clearedclan
+	case account.EdgeSnapshots:
+		return m.clearedsnapshots
+	case account.EdgeVehicleSnapshots:
+		return m.clearedvehicle_snapshots
+	case account.EdgeAchievementSnapshots:
+		return m.clearedachievement_snapshots
+	}
+	return false
+}
+
+// ClearEdge clears the value of the edge with the given name. It returns an error
+// if that edge is not defined in the schema.
+func (m *AccountMutation) ClearEdge(name string) error {
+	switch name {
+	case account.EdgeClan:
+		m.ClearClan()
+		return nil
+	}
+	return fmt.Errorf("unknown Account unique edge %s", name)
+}
+
+// ResetEdge resets all changes to the edge with the given name in this mutation.
+// It returns an error if the edge is not defined in the schema.
+func (m *AccountMutation) ResetEdge(name string) error {
+	switch name {
+	case account.EdgeClan:
+		m.ResetClan()
+		return nil
+	case account.EdgeSnapshots:
+		m.ResetSnapshots()
+		return nil
+	case account.EdgeVehicleSnapshots:
+		m.ResetVehicleSnapshots()
+		return nil
+	case account.EdgeAchievementSnapshots:
+		m.ResetAchievementSnapshots()
+		return nil
+	}
+	return fmt.Errorf("unknown Account edge %s", name)
+}
+
+// AccountSnapshotMutation represents an operation that mutates the AccountSnapshot nodes in the graph.
+type AccountSnapshotMutation struct {
+	config
+	op                  Op
+	typ                 string
+	id                  *string
+	created_at          *int
+	addcreated_at       *int
+	updated_at          *int
+	addupdated_at       *int
+	_type               *models.SnapshotType
+	last_battle_time    *int
+	addlast_battle_time *int
+	reference_id        *string
+	rating_battles      *int
+	addrating_battles   *int
+	rating_frame        *frame.StatsFrame
+	regular_battles     *int
+	addregular_battles  *int
+	regular_frame       *frame.StatsFrame
+	clearedFields       map[string]struct{}
+	account             *string
+	clearedaccount      bool
+	done                bool
+	oldValue            func(context.Context) (*AccountSnapshot, error)
+	predicates          []predicate.AccountSnapshot
+}
+
+var _ ent.Mutation = (*AccountSnapshotMutation)(nil)
+
+// accountsnapshotOption allows management of the mutation configuration using functional options.
+type accountsnapshotOption func(*AccountSnapshotMutation)
+
+// newAccountSnapshotMutation creates new mutation for the AccountSnapshot entity.
+func newAccountSnapshotMutation(c config, op Op, opts ...accountsnapshotOption) *AccountSnapshotMutation {
+	m := &AccountSnapshotMutation{
+		config:        c,
+		op:            op,
+		typ:           TypeAccountSnapshot,
+		clearedFields: make(map[string]struct{}),
+	}
+	for _, opt := range opts {
+		opt(m)
+	}
+	return m
+}
+
+// withAccountSnapshotID sets the ID field of the mutation.
+func withAccountSnapshotID(id string) accountsnapshotOption {
+	return func(m *AccountSnapshotMutation) {
+		var (
+			err   error
+			once  sync.Once
+			value *AccountSnapshot
+		)
+		m.oldValue = func(ctx context.Context) (*AccountSnapshot, error) {
+			once.Do(func() {
+				if m.done {
+					err = errors.New("querying old values post mutation is not allowed")
+				} else {
+					value, err = m.Client().AccountSnapshot.Get(ctx, id)
+				}
+			})
+			return value, err
+		}
+		m.id = &id
+	}
+}
+
+// withAccountSnapshot sets the old AccountSnapshot of the mutation.
+func withAccountSnapshot(node *AccountSnapshot) accountsnapshotOption {
+	return func(m *AccountSnapshotMutation) {
+		m.oldValue = func(context.Context) (*AccountSnapshot, error) {
+			return node, nil
+		}
+		m.id = &node.ID
+	}
+}
+
+// Client returns a new `ent.Client` from the mutation. If the mutation was
+// executed in a transaction (ent.Tx), a transactional client is returned.
+func (m AccountSnapshotMutation) Client() *Client {
+	client := &Client{config: m.config}
+	client.init()
+	return client
+}
+
+// Tx returns an `ent.Tx` for mutations that were executed in transactions;
+// it returns an error otherwise.
+func (m AccountSnapshotMutation) Tx() (*Tx, error) {
+	if _, ok := m.driver.(*txDriver); !ok {
+		return nil, errors.New("db: mutation is not running in a transaction")
+	}
+	tx := &Tx{config: m.config}
+	tx.init()
+	return tx, nil
+}
+
+// SetID sets the value of the id field. Note that this
+// operation is only accepted on creation of AccountSnapshot entities.
+func (m *AccountSnapshotMutation) SetID(id string) {
+	m.id = &id
+}
+
+// ID returns the ID value in the mutation. Note that the ID is only available
+// if it was provided to the builder or after it was returned from the database.
+func (m *AccountSnapshotMutation) ID() (id string, exists bool) {
+	if m.id == nil {
+		return
+	}
+	return *m.id, true
+}
+
+// IDs queries the database and returns the entity ids that match the mutation's predicate.
+// That means, if the mutation is applied within a transaction with an isolation level such
+// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
+// or updated by the mutation.
+func (m *AccountSnapshotMutation) IDs(ctx context.Context) ([]string, error) {
+	switch {
+	case m.op.Is(OpUpdateOne | OpDeleteOne):
+		id, exists := m.ID()
+		if exists {
+			return []string{id}, nil
+		}
+		fallthrough
+	case m.op.Is(OpUpdate | OpDelete):
+		return m.Client().AccountSnapshot.Query().Where(m.predicates...).IDs(ctx)
+	default:
+		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
+	}
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (m *AccountSnapshotMutation) SetCreatedAt(i int) {
+	m.created_at = &i
+	m.addcreated_at = nil
+}
+
+// CreatedAt returns the value of the "created_at" field in the mutation.
+func (m *AccountSnapshotMutation) CreatedAt() (r int, exists bool) {
+	v := m.created_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldCreatedAt returns the old "created_at" field's value of the AccountSnapshot entity.
+// If the AccountSnapshot object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *AccountSnapshotMutation) OldCreatedAt(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldCreatedAt requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
+	}
+	return oldValue.CreatedAt, nil
+}
+
+// AddCreatedAt adds i to the "created_at" field.
+func (m *AccountSnapshotMutation) AddCreatedAt(i int) {
+	if m.addcreated_at != nil {
+		*m.addcreated_at += i
+	} else {
+		m.addcreated_at = &i
+	}
+}
+
+// AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
+func (m *AccountSnapshotMutation) AddedCreatedAt() (r int, exists bool) {
+	v := m.addcreated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetCreatedAt resets all changes to the "created_at" field.
+func (m *AccountSnapshotMutation) ResetCreatedAt() {
+	m.created_at = nil
+	m.addcreated_at = nil
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (m *AccountSnapshotMutation) SetUpdatedAt(i int) {
+	m.updated_at = &i
+	m.addupdated_at = nil
+}
+
+// UpdatedAt returns the value of the "updated_at" field in the mutation.
+func (m *AccountSnapshotMutation) UpdatedAt() (r int, exists bool) {
+	v := m.updated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldUpdatedAt returns the old "updated_at" field's value of the AccountSnapshot entity.
+// If the AccountSnapshot object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *AccountSnapshotMutation) OldUpdatedAt(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
+	}
+	return oldValue.UpdatedAt, nil
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (m *AccountSnapshotMutation) AddUpdatedAt(i int) {
+	if m.addupdated_at != nil {
+		*m.addupdated_at += i
+	} else {
+		m.addupdated_at = &i
+	}
+}
+
+// AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
+func (m *AccountSnapshotMutation) AddedUpdatedAt() (r int, exists bool) {
+	v := m.addupdated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetUpdatedAt resets all changes to the "updated_at" field.
+func (m *AccountSnapshotMutation) ResetUpdatedAt() {
+	m.updated_at = nil
+	m.addupdated_at = nil
+}
+
+// SetType sets the "type" field.
+func (m *AccountSnapshotMutation) SetType(mt models.SnapshotType) {
+	m._type = &mt
+}
+
+// GetType returns the value of the "type" field in the mutation.
+func (m *AccountSnapshotMutation) GetType() (r models.SnapshotType, exists bool) {
+	v := m._type
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldType returns the old "type" field's value of the AccountSnapshot entity.
+// If the AccountSnapshot object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *AccountSnapshotMutation) OldType(ctx context.Context) (v models.SnapshotType, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldType is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldType requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldType: %w", err)
+	}
+	return oldValue.Type, nil
+}
+
+// ResetType resets all changes to the "type" field.
+func (m *AccountSnapshotMutation) ResetType() {
+	m._type = nil
+}
+
+// SetLastBattleTime sets the "last_battle_time" field.
+func (m *AccountSnapshotMutation) SetLastBattleTime(i int) {
+	m.last_battle_time = &i
+	m.addlast_battle_time = nil
+}
+
+// LastBattleTime returns the value of the "last_battle_time" field in the mutation.
+func (m *AccountSnapshotMutation) LastBattleTime() (r int, exists bool) {
+	v := m.last_battle_time
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldLastBattleTime returns the old "last_battle_time" field's value of the AccountSnapshot entity.
+// If the AccountSnapshot object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *AccountSnapshotMutation) OldLastBattleTime(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldLastBattleTime is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldLastBattleTime requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldLastBattleTime: %w", err)
+	}
+	return oldValue.LastBattleTime, nil
+}
+
+// AddLastBattleTime adds i to the "last_battle_time" field.
+func (m *AccountSnapshotMutation) AddLastBattleTime(i int) {
+	if m.addlast_battle_time != nil {
+		*m.addlast_battle_time += i
+	} else {
+		m.addlast_battle_time = &i
+	}
+}
+
+// AddedLastBattleTime returns the value that was added to the "last_battle_time" field in this mutation.
+func (m *AccountSnapshotMutation) AddedLastBattleTime() (r int, exists bool) {
+	v := m.addlast_battle_time
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetLastBattleTime resets all changes to the "last_battle_time" field.
+func (m *AccountSnapshotMutation) ResetLastBattleTime() {
+	m.last_battle_time = nil
+	m.addlast_battle_time = nil
+}
+
+// SetAccountID sets the "account_id" field.
+func (m *AccountSnapshotMutation) SetAccountID(s string) {
+	m.account = &s
+}
+
+// AccountID returns the value of the "account_id" field in the mutation.
+func (m *AccountSnapshotMutation) AccountID() (r string, exists bool) {
+	v := m.account
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldAccountID returns the old "account_id" field's value of the AccountSnapshot entity.
+// If the AccountSnapshot object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *AccountSnapshotMutation) OldAccountID(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldAccountID is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldAccountID requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldAccountID: %w", err)
+	}
+	return oldValue.AccountID, nil
+}
+
+// ResetAccountID resets all changes to the "account_id" field.
+func (m *AccountSnapshotMutation) ResetAccountID() {
+	m.account = nil
+}
+
+// SetReferenceID sets the "reference_id" field.
+func (m *AccountSnapshotMutation) SetReferenceID(s string) {
+	m.reference_id = &s
+}
+
+// ReferenceID returns the value of the "reference_id" field in the mutation.
+func (m *AccountSnapshotMutation) ReferenceID() (r string, exists bool) {
+	v := m.reference_id
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldReferenceID returns the old "reference_id" field's value of the AccountSnapshot entity.
+// If the AccountSnapshot object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *AccountSnapshotMutation) OldReferenceID(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldReferenceID is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldReferenceID requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldReferenceID: %w", err)
+	}
+	return oldValue.ReferenceID, nil
+}
+
+// ResetReferenceID resets all changes to the "reference_id" field.
+func (m *AccountSnapshotMutation) ResetReferenceID() {
+	m.reference_id = nil
+}
+
+// SetRatingBattles sets the "rating_battles" field.
+func (m *AccountSnapshotMutation) SetRatingBattles(i int) {
+	m.rating_battles = &i
+	m.addrating_battles = nil
+}
+
+// RatingBattles returns the value of the "rating_battles" field in the mutation.
+func (m *AccountSnapshotMutation) RatingBattles() (r int, exists bool) {
+	v := m.rating_battles
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldRatingBattles returns the old "rating_battles" field's value of the AccountSnapshot entity.
+// If the AccountSnapshot object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *AccountSnapshotMutation) OldRatingBattles(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldRatingBattles is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldRatingBattles requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldRatingBattles: %w", err)
+	}
+	return oldValue.RatingBattles, nil
+}
+
+// AddRatingBattles adds i to the "rating_battles" field.
+func (m *AccountSnapshotMutation) AddRatingBattles(i int) {
+	if m.addrating_battles != nil {
+		*m.addrating_battles += i
+	} else {
+		m.addrating_battles = &i
+	}
+}
+
+// AddedRatingBattles returns the value that was added to the "rating_battles" field in this mutation.
+func (m *AccountSnapshotMutation) AddedRatingBattles() (r int, exists bool) {
+	v := m.addrating_battles
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetRatingBattles resets all changes to the "rating_battles" field.
+func (m *AccountSnapshotMutation) ResetRatingBattles() {
+	m.rating_battles = nil
+	m.addrating_battles = nil
+}
+
+// SetRatingFrame sets the "rating_frame" field.
+func (m *AccountSnapshotMutation) SetRatingFrame(ff frame.StatsFrame) {
+	m.rating_frame = &ff
+}
+
+// RatingFrame returns the value of the "rating_frame" field in the mutation.
+func (m *AccountSnapshotMutation) RatingFrame() (r frame.StatsFrame, exists bool) {
+	v := m.rating_frame
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldRatingFrame returns the old "rating_frame" field's value of the AccountSnapshot entity.
+// If the AccountSnapshot object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *AccountSnapshotMutation) OldRatingFrame(ctx context.Context) (v frame.StatsFrame, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldRatingFrame is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldRatingFrame requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldRatingFrame: %w", err)
+	}
+	return oldValue.RatingFrame, nil
+}
+
+// ResetRatingFrame resets all changes to the "rating_frame" field.
+func (m *AccountSnapshotMutation) ResetRatingFrame() {
+	m.rating_frame = nil
+}
+
+// SetRegularBattles sets the "regular_battles" field.
+func (m *AccountSnapshotMutation) SetRegularBattles(i int) {
+	m.regular_battles = &i
+	m.addregular_battles = nil
+}
+
+// RegularBattles returns the value of the "regular_battles" field in the mutation.
+func (m *AccountSnapshotMutation) RegularBattles() (r int, exists bool) {
+	v := m.regular_battles
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldRegularBattles returns the old "regular_battles" field's value of the AccountSnapshot entity.
+// If the AccountSnapshot object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *AccountSnapshotMutation) OldRegularBattles(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldRegularBattles is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldRegularBattles requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldRegularBattles: %w", err)
+	}
+	return oldValue.RegularBattles, nil
+}
+
+// AddRegularBattles adds i to the "regular_battles" field.
+func (m *AccountSnapshotMutation) AddRegularBattles(i int) {
+	if m.addregular_battles != nil {
+		*m.addregular_battles += i
+	} else {
+		m.addregular_battles = &i
+	}
+}
+
+// AddedRegularBattles returns the value that was added to the "regular_battles" field in this mutation.
+func (m *AccountSnapshotMutation) AddedRegularBattles() (r int, exists bool) {
+	v := m.addregular_battles
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetRegularBattles resets all changes to the "regular_battles" field.
+func (m *AccountSnapshotMutation) ResetRegularBattles() {
+	m.regular_battles = nil
+	m.addregular_battles = nil
+}
+
+// SetRegularFrame sets the "regular_frame" field.
+func (m *AccountSnapshotMutation) SetRegularFrame(ff frame.StatsFrame) {
+	m.regular_frame = &ff
+}
+
+// RegularFrame returns the value of the "regular_frame" field in the mutation.
+func (m *AccountSnapshotMutation) RegularFrame() (r frame.StatsFrame, exists bool) {
+	v := m.regular_frame
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldRegularFrame returns the old "regular_frame" field's value of the AccountSnapshot entity.
+// If the AccountSnapshot object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *AccountSnapshotMutation) OldRegularFrame(ctx context.Context) (v frame.StatsFrame, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldRegularFrame is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldRegularFrame requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldRegularFrame: %w", err)
+	}
+	return oldValue.RegularFrame, nil
+}
+
+// ResetRegularFrame resets all changes to the "regular_frame" field.
+func (m *AccountSnapshotMutation) ResetRegularFrame() {
+	m.regular_frame = nil
+}
+
+// ClearAccount clears the "account" edge to the Account entity.
+func (m *AccountSnapshotMutation) ClearAccount() {
+	m.clearedaccount = true
+	m.clearedFields[accountsnapshot.FieldAccountID] = struct{}{}
+}
+
+// AccountCleared reports if the "account" edge to the Account entity was cleared.
+func (m *AccountSnapshotMutation) AccountCleared() bool {
+	return m.clearedaccount
+}
+
+// AccountIDs returns the "account" edge IDs in the mutation.
+// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
+// AccountID instead. It exists only for internal usage by the builders.
+func (m *AccountSnapshotMutation) AccountIDs() (ids []string) {
+	if id := m.account; id != nil {
+		ids = append(ids, *id)
+	}
+	return
+}
+
+// ResetAccount resets all changes to the "account" edge.
+func (m *AccountSnapshotMutation) ResetAccount() {
+	m.account = nil
+	m.clearedaccount = false
+}
+
+// Where appends a list predicates to the AccountSnapshotMutation builder.
+func (m *AccountSnapshotMutation) Where(ps ...predicate.AccountSnapshot) {
+	m.predicates = append(m.predicates, ps...)
+}
+
+// WhereP appends storage-level predicates to the AccountSnapshotMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *AccountSnapshotMutation) WhereP(ps ...func(*sql.Selector)) {
+	p := make([]predicate.AccountSnapshot, len(ps))
+	for i := range ps {
+		p[i] = ps[i]
+	}
+	m.Where(p...)
+}
+
+// Op returns the operation name.
+func (m *AccountSnapshotMutation) Op() Op {
+	return m.op
+}
+
+// SetOp allows setting the mutation operation.
+func (m *AccountSnapshotMutation) SetOp(op Op) {
+	m.op = op
+}
+
+// Type returns the node type of this mutation (AccountSnapshot).
+func (m *AccountSnapshotMutation) Type() string {
+	return m.typ
+}
+
+// Fields returns all fields that were changed during this mutation. Note that in
+// order to get all numeric fields that were incremented/decremented, call
+// AddedFields().
+func (m *AccountSnapshotMutation) Fields() []string {
+	fields := make([]string, 0, 10)
+	if m.created_at != nil {
+		fields = append(fields, accountsnapshot.FieldCreatedAt)
+	}
+	if m.updated_at != nil {
+		fields = append(fields, accountsnapshot.FieldUpdatedAt)
+	}
+	if m._type != nil {
+		fields = append(fields, accountsnapshot.FieldType)
+	}
+	if m.last_battle_time != nil {
+		fields = append(fields, accountsnapshot.FieldLastBattleTime)
+	}
+	if m.account != nil {
+		fields = append(fields, accountsnapshot.FieldAccountID)
+	}
+	if m.reference_id != nil {
+		fields = append(fields, accountsnapshot.FieldReferenceID)
+	}
+	if m.rating_battles != nil {
+		fields = append(fields, accountsnapshot.FieldRatingBattles)
+	}
+	if m.rating_frame != nil {
+		fields = append(fields, accountsnapshot.FieldRatingFrame)
+	}
+	if m.regular_battles != nil {
+		fields = append(fields, accountsnapshot.FieldRegularBattles)
+	}
+	if m.regular_frame != nil {
+		fields = append(fields, accountsnapshot.FieldRegularFrame)
+	}
+	return fields
+}
+
+// Field returns the value of a field with the given name. The second boolean
+// return value indicates that this field was not set, or was not defined in the
+// schema.
+func (m *AccountSnapshotMutation) Field(name string) (ent.Value, bool) {
+	switch name {
+	case accountsnapshot.FieldCreatedAt:
+		return m.CreatedAt()
+	case accountsnapshot.FieldUpdatedAt:
+		return m.UpdatedAt()
+	case accountsnapshot.FieldType:
+		return m.GetType()
+	case accountsnapshot.FieldLastBattleTime:
+		return m.LastBattleTime()
+	case accountsnapshot.FieldAccountID:
+		return m.AccountID()
+	case accountsnapshot.FieldReferenceID:
+		return m.ReferenceID()
+	case accountsnapshot.FieldRatingBattles:
+		return m.RatingBattles()
+	case accountsnapshot.FieldRatingFrame:
+		return m.RatingFrame()
+	case accountsnapshot.FieldRegularBattles:
+		return m.RegularBattles()
+	case accountsnapshot.FieldRegularFrame:
+		return m.RegularFrame()
+	}
+	return nil, false
+}
+
+// OldField returns the old value of the field from the database. An error is
+// returned if the mutation operation is not UpdateOne, or the query to the
+// database failed.
+func (m *AccountSnapshotMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
+	switch name {
+	case accountsnapshot.FieldCreatedAt:
+		return m.OldCreatedAt(ctx)
+	case accountsnapshot.FieldUpdatedAt:
+		return m.OldUpdatedAt(ctx)
+	case accountsnapshot.FieldType:
+		return m.OldType(ctx)
+	case accountsnapshot.FieldLastBattleTime:
+		return m.OldLastBattleTime(ctx)
+	case accountsnapshot.FieldAccountID:
+		return m.OldAccountID(ctx)
+	case accountsnapshot.FieldReferenceID:
+		return m.OldReferenceID(ctx)
+	case accountsnapshot.FieldRatingBattles:
+		return m.OldRatingBattles(ctx)
+	case accountsnapshot.FieldRatingFrame:
+		return m.OldRatingFrame(ctx)
+	case accountsnapshot.FieldRegularBattles:
+		return m.OldRegularBattles(ctx)
+	case accountsnapshot.FieldRegularFrame:
+		return m.OldRegularFrame(ctx)
+	}
+	return nil, fmt.Errorf("unknown AccountSnapshot field %s", name)
+}
+
+// SetField sets the value of a field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *AccountSnapshotMutation) SetField(name string, value ent.Value) error {
+	switch name {
+	case accountsnapshot.FieldCreatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetCreatedAt(v)
+		return nil
+	case accountsnapshot.FieldUpdatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetUpdatedAt(v)
+		return nil
+	case accountsnapshot.FieldType:
+		v, ok := value.(models.SnapshotType)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetType(v)
+		return nil
+	case accountsnapshot.FieldLastBattleTime:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetLastBattleTime(v)
+		return nil
+	case accountsnapshot.FieldAccountID:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetAccountID(v)
+		return nil
+	case accountsnapshot.FieldReferenceID:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetReferenceID(v)
+		return nil
+	case accountsnapshot.FieldRatingBattles:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetRatingBattles(v)
+		return nil
+	case accountsnapshot.FieldRatingFrame:
+		v, ok := value.(frame.StatsFrame)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetRatingFrame(v)
+		return nil
+	case accountsnapshot.FieldRegularBattles:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetRegularBattles(v)
+		return nil
+	case accountsnapshot.FieldRegularFrame:
+		v, ok := value.(frame.StatsFrame)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetRegularFrame(v)
+		return nil
+	}
+	return fmt.Errorf("unknown AccountSnapshot field %s", name)
+}
+
+// AddedFields returns all numeric fields that were incremented/decremented during
+// this mutation.
+func (m *AccountSnapshotMutation) AddedFields() []string {
+	var fields []string
+	if m.addcreated_at != nil {
+		fields = append(fields, accountsnapshot.FieldCreatedAt)
+	}
+	if m.addupdated_at != nil {
+		fields = append(fields, accountsnapshot.FieldUpdatedAt)
+	}
+	if m.addlast_battle_time != nil {
+		fields = append(fields, accountsnapshot.FieldLastBattleTime)
+	}
+	if m.addrating_battles != nil {
+		fields = append(fields, accountsnapshot.FieldRatingBattles)
+	}
+	if m.addregular_battles != nil {
+		fields = append(fields, accountsnapshot.FieldRegularBattles)
+	}
+	return fields
+}
+
+// AddedField returns the numeric value that was incremented/decremented on a field
+// with the given name. The second boolean return value indicates that this field
+// was not set, or was not defined in the schema.
+func (m *AccountSnapshotMutation) AddedField(name string) (ent.Value, bool) {
+	switch name {
+	case accountsnapshot.FieldCreatedAt:
+		return m.AddedCreatedAt()
+	case accountsnapshot.FieldUpdatedAt:
+		return m.AddedUpdatedAt()
+	case accountsnapshot.FieldLastBattleTime:
+		return m.AddedLastBattleTime()
+	case accountsnapshot.FieldRatingBattles:
+		return m.AddedRatingBattles()
+	case accountsnapshot.FieldRegularBattles:
+		return m.AddedRegularBattles()
+	}
+	return nil, false
+}
+
+// AddField adds the value to the field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *AccountSnapshotMutation) AddField(name string, value ent.Value) error {
+	switch name {
+	case accountsnapshot.FieldCreatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddCreatedAt(v)
+		return nil
+	case accountsnapshot.FieldUpdatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddUpdatedAt(v)
+		return nil
+	case accountsnapshot.FieldLastBattleTime:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddLastBattleTime(v)
+		return nil
+	case accountsnapshot.FieldRatingBattles:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddRatingBattles(v)
+		return nil
+	case accountsnapshot.FieldRegularBattles:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddRegularBattles(v)
+		return nil
+	}
+	return fmt.Errorf("unknown AccountSnapshot numeric field %s", name)
+}
+
+// ClearedFields returns all nullable fields that were cleared during this
+// mutation.
+func (m *AccountSnapshotMutation) ClearedFields() []string {
+	return nil
+}
+
+// FieldCleared returns a boolean indicating if a field with the given name was
+// cleared in this mutation.
+func (m *AccountSnapshotMutation) FieldCleared(name string) bool {
+	_, ok := m.clearedFields[name]
+	return ok
+}
+
+// ClearField clears the value of the field with the given name. It returns an
+// error if the field is not defined in the schema.
+func (m *AccountSnapshotMutation) ClearField(name string) error {
+	return fmt.Errorf("unknown AccountSnapshot nullable field %s", name)
+}
+
+// ResetField resets all changes in the mutation for the field with the given name.
+// It returns an error if the field is not defined in the schema.
+func (m *AccountSnapshotMutation) ResetField(name string) error {
+	switch name {
+	case accountsnapshot.FieldCreatedAt:
+		m.ResetCreatedAt()
+		return nil
+	case accountsnapshot.FieldUpdatedAt:
+		m.ResetUpdatedAt()
+		return nil
+	case accountsnapshot.FieldType:
+		m.ResetType()
+		return nil
+	case accountsnapshot.FieldLastBattleTime:
+		m.ResetLastBattleTime()
+		return nil
+	case accountsnapshot.FieldAccountID:
+		m.ResetAccountID()
+		return nil
+	case accountsnapshot.FieldReferenceID:
+		m.ResetReferenceID()
+		return nil
+	case accountsnapshot.FieldRatingBattles:
+		m.ResetRatingBattles()
+		return nil
+	case accountsnapshot.FieldRatingFrame:
+		m.ResetRatingFrame()
+		return nil
+	case accountsnapshot.FieldRegularBattles:
+		m.ResetRegularBattles()
+		return nil
+	case accountsnapshot.FieldRegularFrame:
+		m.ResetRegularFrame()
+		return nil
+	}
+	return fmt.Errorf("unknown AccountSnapshot field %s", name)
+}
+
+// AddedEdges returns all edge names that were set/added in this mutation.
+func (m *AccountSnapshotMutation) AddedEdges() []string {
+	edges := make([]string, 0, 1)
+	if m.account != nil {
+		edges = append(edges, accountsnapshot.EdgeAccount)
+	}
+	return edges
+}
+
+// AddedIDs returns all IDs (to other nodes) that were added for the given edge
+// name in this mutation.
+func (m *AccountSnapshotMutation) AddedIDs(name string) []ent.Value {
+	switch name {
+	case accountsnapshot.EdgeAccount:
+		if id := m.account; id != nil {
+			return []ent.Value{*id}
+		}
+	}
+	return nil
+}
+
+// RemovedEdges returns all edge names that were removed in this mutation.
+func (m *AccountSnapshotMutation) RemovedEdges() []string {
+	edges := make([]string, 0, 1)
+	return edges
+}
+
+// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
+// the given name in this mutation.
+func (m *AccountSnapshotMutation) RemovedIDs(name string) []ent.Value {
+	return nil
+}
+
+// ClearedEdges returns all edge names that were cleared in this mutation.
+func (m *AccountSnapshotMutation) ClearedEdges() []string {
+	edges := make([]string, 0, 1)
+	if m.clearedaccount {
+		edges = append(edges, accountsnapshot.EdgeAccount)
+	}
+	return edges
+}
+
+// EdgeCleared returns a boolean which indicates if the edge with the given name
+// was cleared in this mutation.
+func (m *AccountSnapshotMutation) EdgeCleared(name string) bool {
+	switch name {
+	case accountsnapshot.EdgeAccount:
+		return m.clearedaccount
+	}
+	return false
+}
+
+// ClearEdge clears the value of the edge with the given name. It returns an error
+// if that edge is not defined in the schema.
+func (m *AccountSnapshotMutation) ClearEdge(name string) error {
+	switch name {
+	case accountsnapshot.EdgeAccount:
+		m.ClearAccount()
+		return nil
+	}
+	return fmt.Errorf("unknown AccountSnapshot unique edge %s", name)
+}
+
+// ResetEdge resets all changes to the edge with the given name in this mutation.
+// It returns an error if the edge is not defined in the schema.
+func (m *AccountSnapshotMutation) ResetEdge(name string) error {
+	switch name {
+	case accountsnapshot.EdgeAccount:
+		m.ResetAccount()
+		return nil
+	}
+	return fmt.Errorf("unknown AccountSnapshot edge %s", name)
+}
+
+// AchievementsSnapshotMutation represents an operation that mutates the AchievementsSnapshot nodes in the graph.
+type AchievementsSnapshotMutation struct {
+	config
+	op                  Op
+	typ                 string
+	id                  *string
+	created_at          *int
+	addcreated_at       *int
+	updated_at          *int
+	addupdated_at       *int
+	_type               *models.SnapshotType
+	reference_id        *string
+	battles             *int
+	addbattles          *int
+	last_battle_time    *int
+	addlast_battle_time *int
+	data                *types.AchievementsFrame
+	clearedFields       map[string]struct{}
+	account             *string
+	clearedaccount      bool
+	done                bool
+	oldValue            func(context.Context) (*AchievementsSnapshot, error)
+	predicates          []predicate.AchievementsSnapshot
+}
+
+var _ ent.Mutation = (*AchievementsSnapshotMutation)(nil)
+
+// achievementssnapshotOption allows management of the mutation configuration using functional options.
+type achievementssnapshotOption func(*AchievementsSnapshotMutation)
+
+// newAchievementsSnapshotMutation creates new mutation for the AchievementsSnapshot entity.
+func newAchievementsSnapshotMutation(c config, op Op, opts ...achievementssnapshotOption) *AchievementsSnapshotMutation {
+	m := &AchievementsSnapshotMutation{
+		config:        c,
+		op:            op,
+		typ:           TypeAchievementsSnapshot,
+		clearedFields: make(map[string]struct{}),
+	}
+	for _, opt := range opts {
+		opt(m)
+	}
+	return m
+}
+
+// withAchievementsSnapshotID sets the ID field of the mutation.
+func withAchievementsSnapshotID(id string) achievementssnapshotOption {
+	return func(m *AchievementsSnapshotMutation) {
+		var (
+			err   error
+			once  sync.Once
+			value *AchievementsSnapshot
+		)
+		m.oldValue = func(ctx context.Context) (*AchievementsSnapshot, error) {
+			once.Do(func() {
+				if m.done {
+					err = errors.New("querying old values post mutation is not allowed")
+				} else {
+					value, err = m.Client().AchievementsSnapshot.Get(ctx, id)
+				}
+			})
+			return value, err
+		}
+		m.id = &id
+	}
+}
+
+// withAchievementsSnapshot sets the old AchievementsSnapshot of the mutation.
+func withAchievementsSnapshot(node *AchievementsSnapshot) achievementssnapshotOption {
+	return func(m *AchievementsSnapshotMutation) {
+		m.oldValue = func(context.Context) (*AchievementsSnapshot, error) {
+			return node, nil
+		}
+		m.id = &node.ID
+	}
+}
+
+// Client returns a new `ent.Client` from the mutation. If the mutation was
+// executed in a transaction (ent.Tx), a transactional client is returned.
+func (m AchievementsSnapshotMutation) Client() *Client {
+	client := &Client{config: m.config}
+	client.init()
+	return client
+}
+
+// Tx returns an `ent.Tx` for mutations that were executed in transactions;
+// it returns an error otherwise.
+func (m AchievementsSnapshotMutation) Tx() (*Tx, error) {
+	if _, ok := m.driver.(*txDriver); !ok {
+		return nil, errors.New("db: mutation is not running in a transaction")
+	}
+	tx := &Tx{config: m.config}
+	tx.init()
+	return tx, nil
+}
+
+// SetID sets the value of the id field. Note that this
+// operation is only accepted on creation of AchievementsSnapshot entities.
+func (m *AchievementsSnapshotMutation) SetID(id string) {
+	m.id = &id
+}
+
+// ID returns the ID value in the mutation. Note that the ID is only available
+// if it was provided to the builder or after it was returned from the database.
+func (m *AchievementsSnapshotMutation) ID() (id string, exists bool) {
+	if m.id == nil {
+		return
+	}
+	return *m.id, true
+}
+
+// IDs queries the database and returns the entity ids that match the mutation's predicate.
+// That means, if the mutation is applied within a transaction with an isolation level such
+// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
+// or updated by the mutation.
+func (m *AchievementsSnapshotMutation) IDs(ctx context.Context) ([]string, error) {
+	switch {
+	case m.op.Is(OpUpdateOne | OpDeleteOne):
+		id, exists := m.ID()
+		if exists {
+			return []string{id}, nil
+		}
+		fallthrough
+	case m.op.Is(OpUpdate | OpDelete):
+		return m.Client().AchievementsSnapshot.Query().Where(m.predicates...).IDs(ctx)
+	default:
+		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
+	}
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (m *AchievementsSnapshotMutation) SetCreatedAt(i int) {
+	m.created_at = &i
+	m.addcreated_at = nil
+}
+
+// CreatedAt returns the value of the "created_at" field in the mutation.
+func (m *AchievementsSnapshotMutation) CreatedAt() (r int, exists bool) {
+	v := m.created_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldCreatedAt returns the old "created_at" field's value of the AchievementsSnapshot entity.
+// If the AchievementsSnapshot object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *AchievementsSnapshotMutation) OldCreatedAt(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldCreatedAt requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
+	}
+	return oldValue.CreatedAt, nil
+}
+
+// AddCreatedAt adds i to the "created_at" field.
+func (m *AchievementsSnapshotMutation) AddCreatedAt(i int) {
+	if m.addcreated_at != nil {
+		*m.addcreated_at += i
+	} else {
+		m.addcreated_at = &i
+	}
+}
+
+// AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
+func (m *AchievementsSnapshotMutation) AddedCreatedAt() (r int, exists bool) {
+	v := m.addcreated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetCreatedAt resets all changes to the "created_at" field.
+func (m *AchievementsSnapshotMutation) ResetCreatedAt() {
+	m.created_at = nil
+	m.addcreated_at = nil
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (m *AchievementsSnapshotMutation) SetUpdatedAt(i int) {
+	m.updated_at = &i
+	m.addupdated_at = nil
+}
+
+// UpdatedAt returns the value of the "updated_at" field in the mutation.
+func (m *AchievementsSnapshotMutation) UpdatedAt() (r int, exists bool) {
+	v := m.updated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldUpdatedAt returns the old "updated_at" field's value of the AchievementsSnapshot entity.
+// If the AchievementsSnapshot object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *AchievementsSnapshotMutation) OldUpdatedAt(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
+	}
+	return oldValue.UpdatedAt, nil
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (m *AchievementsSnapshotMutation) AddUpdatedAt(i int) {
+	if m.addupdated_at != nil {
+		*m.addupdated_at += i
+	} else {
+		m.addupdated_at = &i
+	}
+}
+
+// AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
+func (m *AchievementsSnapshotMutation) AddedUpdatedAt() (r int, exists bool) {
+	v := m.addupdated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetUpdatedAt resets all changes to the "updated_at" field.
+func (m *AchievementsSnapshotMutation) ResetUpdatedAt() {
+	m.updated_at = nil
+	m.addupdated_at = nil
+}
+
+// SetType sets the "type" field.
+func (m *AchievementsSnapshotMutation) SetType(mt models.SnapshotType) {
+	m._type = &mt
+}
+
+// GetType returns the value of the "type" field in the mutation.
+func (m *AchievementsSnapshotMutation) GetType() (r models.SnapshotType, exists bool) {
+	v := m._type
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldType returns the old "type" field's value of the AchievementsSnapshot entity.
+// If the AchievementsSnapshot object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *AchievementsSnapshotMutation) OldType(ctx context.Context) (v models.SnapshotType, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldType is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldType requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldType: %w", err)
+	}
+	return oldValue.Type, nil
+}
+
+// ResetType resets all changes to the "type" field.
+func (m *AchievementsSnapshotMutation) ResetType() {
+	m._type = nil
+}
+
+// SetAccountID sets the "account_id" field.
+func (m *AchievementsSnapshotMutation) SetAccountID(s string) {
+	m.account = &s
+}
+
+// AccountID returns the value of the "account_id" field in the mutation.
+func (m *AchievementsSnapshotMutation) AccountID() (r string, exists bool) {
+	v := m.account
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldAccountID returns the old "account_id" field's value of the AchievementsSnapshot entity.
+// If the AchievementsSnapshot object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *AchievementsSnapshotMutation) OldAccountID(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldAccountID is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldAccountID requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldAccountID: %w", err)
+	}
+	return oldValue.AccountID, nil
+}
+
+// ResetAccountID resets all changes to the "account_id" field.
+func (m *AchievementsSnapshotMutation) ResetAccountID() {
+	m.account = nil
+}
+
+// SetReferenceID sets the "reference_id" field.
+func (m *AchievementsSnapshotMutation) SetReferenceID(s string) {
+	m.reference_id = &s
+}
+
+// ReferenceID returns the value of the "reference_id" field in the mutation.
+func (m *AchievementsSnapshotMutation) ReferenceID() (r string, exists bool) {
+	v := m.reference_id
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldReferenceID returns the old "reference_id" field's value of the AchievementsSnapshot entity.
+// If the AchievementsSnapshot object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *AchievementsSnapshotMutation) OldReferenceID(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldReferenceID is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldReferenceID requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldReferenceID: %w", err)
+	}
+	return oldValue.ReferenceID, nil
+}
+
+// ResetReferenceID resets all changes to the "reference_id" field.
+func (m *AchievementsSnapshotMutation) ResetReferenceID() {
+	m.reference_id = nil
+}
+
+// SetBattles sets the "battles" field.
+func (m *AchievementsSnapshotMutation) SetBattles(i int) {
+	m.battles = &i
+	m.addbattles = nil
+}
+
+// Battles returns the value of the "battles" field in the mutation.
+func (m *AchievementsSnapshotMutation) Battles() (r int, exists bool) {
+	v := m.battles
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldBattles returns the old "battles" field's value of the AchievementsSnapshot entity.
+// If the AchievementsSnapshot object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *AchievementsSnapshotMutation) OldBattles(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldBattles is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldBattles requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldBattles: %w", err)
+	}
+	return oldValue.Battles, nil
+}
+
+// AddBattles adds i to the "battles" field.
+func (m *AchievementsSnapshotMutation) AddBattles(i int) {
+	if m.addbattles != nil {
+		*m.addbattles += i
+	} else {
+		m.addbattles = &i
+	}
+}
+
+// AddedBattles returns the value that was added to the "battles" field in this mutation.
+func (m *AchievementsSnapshotMutation) AddedBattles() (r int, exists bool) {
+	v := m.addbattles
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetBattles resets all changes to the "battles" field.
+func (m *AchievementsSnapshotMutation) ResetBattles() {
+	m.battles = nil
+	m.addbattles = nil
+}
+
+// SetLastBattleTime sets the "last_battle_time" field.
+func (m *AchievementsSnapshotMutation) SetLastBattleTime(i int) {
+	m.last_battle_time = &i
+	m.addlast_battle_time = nil
+}
+
+// LastBattleTime returns the value of the "last_battle_time" field in the mutation.
+func (m *AchievementsSnapshotMutation) LastBattleTime() (r int, exists bool) {
+	v := m.last_battle_time
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldLastBattleTime returns the old "last_battle_time" field's value of the AchievementsSnapshot entity.
+// If the AchievementsSnapshot object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *AchievementsSnapshotMutation) OldLastBattleTime(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldLastBattleTime is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldLastBattleTime requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldLastBattleTime: %w", err)
+	}
+	return oldValue.LastBattleTime, nil
+}
+
+// AddLastBattleTime adds i to the "last_battle_time" field.
+func (m *AchievementsSnapshotMutation) AddLastBattleTime(i int) {
+	if m.addlast_battle_time != nil {
+		*m.addlast_battle_time += i
+	} else {
+		m.addlast_battle_time = &i
+	}
+}
+
+// AddedLastBattleTime returns the value that was added to the "last_battle_time" field in this mutation.
+func (m *AchievementsSnapshotMutation) AddedLastBattleTime() (r int, exists bool) {
+	v := m.addlast_battle_time
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetLastBattleTime resets all changes to the "last_battle_time" field.
+func (m *AchievementsSnapshotMutation) ResetLastBattleTime() {
+	m.last_battle_time = nil
+	m.addlast_battle_time = nil
+}
+
+// SetData sets the "data" field.
+func (m *AchievementsSnapshotMutation) SetData(tf types.AchievementsFrame) {
+	m.data = &tf
+}
+
+// Data returns the value of the "data" field in the mutation.
+func (m *AchievementsSnapshotMutation) Data() (r types.AchievementsFrame, exists bool) {
+	v := m.data
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldData returns the old "data" field's value of the AchievementsSnapshot entity.
+// If the AchievementsSnapshot object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *AchievementsSnapshotMutation) OldData(ctx context.Context) (v types.AchievementsFrame, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldData is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldData requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldData: %w", err)
+	}
+	return oldValue.Data, nil
+}
+
+// ResetData resets all changes to the "data" field.
+func (m *AchievementsSnapshotMutation) ResetData() {
+	m.data = nil
+}
+
+// ClearAccount clears the "account" edge to the Account entity.
+func (m *AchievementsSnapshotMutation) ClearAccount() {
+	m.clearedaccount = true
+	m.clearedFields[achievementssnapshot.FieldAccountID] = struct{}{}
+}
+
+// AccountCleared reports if the "account" edge to the Account entity was cleared.
+func (m *AchievementsSnapshotMutation) AccountCleared() bool {
+	return m.clearedaccount
+}
+
+// AccountIDs returns the "account" edge IDs in the mutation.
+// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
+// AccountID instead. It exists only for internal usage by the builders.
+func (m *AchievementsSnapshotMutation) AccountIDs() (ids []string) {
+	if id := m.account; id != nil {
+		ids = append(ids, *id)
+	}
+	return
+}
+
+// ResetAccount resets all changes to the "account" edge.
+func (m *AchievementsSnapshotMutation) ResetAccount() {
+	m.account = nil
+	m.clearedaccount = false
+}
+
+// Where appends a list predicates to the AchievementsSnapshotMutation builder.
+func (m *AchievementsSnapshotMutation) Where(ps ...predicate.AchievementsSnapshot) {
+	m.predicates = append(m.predicates, ps...)
+}
+
+// WhereP appends storage-level predicates to the AchievementsSnapshotMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *AchievementsSnapshotMutation) WhereP(ps ...func(*sql.Selector)) {
+	p := make([]predicate.AchievementsSnapshot, len(ps))
+	for i := range ps {
+		p[i] = ps[i]
+	}
+	m.Where(p...)
+}
+
+// Op returns the operation name.
+func (m *AchievementsSnapshotMutation) Op() Op {
+	return m.op
+}
+
+// SetOp allows setting the mutation operation.
+func (m *AchievementsSnapshotMutation) SetOp(op Op) {
+	m.op = op
+}
+
+// Type returns the node type of this mutation (AchievementsSnapshot).
+func (m *AchievementsSnapshotMutation) Type() string {
+	return m.typ
+}
+
+// Fields returns all fields that were changed during this mutation. Note that in
+// order to get all numeric fields that were incremented/decremented, call
+// AddedFields().
+func (m *AchievementsSnapshotMutation) Fields() []string {
+	fields := make([]string, 0, 8)
+	if m.created_at != nil {
+		fields = append(fields, achievementssnapshot.FieldCreatedAt)
+	}
+	if m.updated_at != nil {
+		fields = append(fields, achievementssnapshot.FieldUpdatedAt)
+	}
+	if m._type != nil {
+		fields = append(fields, achievementssnapshot.FieldType)
+	}
+	if m.account != nil {
+		fields = append(fields, achievementssnapshot.FieldAccountID)
+	}
+	if m.reference_id != nil {
+		fields = append(fields, achievementssnapshot.FieldReferenceID)
+	}
+	if m.battles != nil {
+		fields = append(fields, achievementssnapshot.FieldBattles)
+	}
+	if m.last_battle_time != nil {
+		fields = append(fields, achievementssnapshot.FieldLastBattleTime)
+	}
+	if m.data != nil {
+		fields = append(fields, achievementssnapshot.FieldData)
+	}
+	return fields
+}
+
+// Field returns the value of a field with the given name. The second boolean
+// return value indicates that this field was not set, or was not defined in the
+// schema.
+func (m *AchievementsSnapshotMutation) Field(name string) (ent.Value, bool) {
+	switch name {
+	case achievementssnapshot.FieldCreatedAt:
+		return m.CreatedAt()
+	case achievementssnapshot.FieldUpdatedAt:
+		return m.UpdatedAt()
+	case achievementssnapshot.FieldType:
+		return m.GetType()
+	case achievementssnapshot.FieldAccountID:
+		return m.AccountID()
+	case achievementssnapshot.FieldReferenceID:
+		return m.ReferenceID()
+	case achievementssnapshot.FieldBattles:
+		return m.Battles()
+	case achievementssnapshot.FieldLastBattleTime:
+		return m.LastBattleTime()
+	case achievementssnapshot.FieldData:
+		return m.Data()
+	}
+	return nil, false
+}
+
+// OldField returns the old value of the field from the database. An error is
+// returned if the mutation operation is not UpdateOne, or the query to the
+// database failed.
+func (m *AchievementsSnapshotMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
+	switch name {
+	case achievementssnapshot.FieldCreatedAt:
+		return m.OldCreatedAt(ctx)
+	case achievementssnapshot.FieldUpdatedAt:
+		return m.OldUpdatedAt(ctx)
+	case achievementssnapshot.FieldType:
+		return m.OldType(ctx)
+	case achievementssnapshot.FieldAccountID:
+		return m.OldAccountID(ctx)
+	case achievementssnapshot.FieldReferenceID:
+		return m.OldReferenceID(ctx)
+	case achievementssnapshot.FieldBattles:
+		return m.OldBattles(ctx)
+	case achievementssnapshot.FieldLastBattleTime:
+		return m.OldLastBattleTime(ctx)
+	case achievementssnapshot.FieldData:
+		return m.OldData(ctx)
+	}
+	return nil, fmt.Errorf("unknown AchievementsSnapshot field %s", name)
+}
+
+// SetField sets the value of a field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *AchievementsSnapshotMutation) SetField(name string, value ent.Value) error {
+	switch name {
+	case achievementssnapshot.FieldCreatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetCreatedAt(v)
+		return nil
+	case achievementssnapshot.FieldUpdatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetUpdatedAt(v)
+		return nil
+	case achievementssnapshot.FieldType:
+		v, ok := value.(models.SnapshotType)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetType(v)
+		return nil
+	case achievementssnapshot.FieldAccountID:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetAccountID(v)
+		return nil
+	case achievementssnapshot.FieldReferenceID:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetReferenceID(v)
+		return nil
+	case achievementssnapshot.FieldBattles:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetBattles(v)
+		return nil
+	case achievementssnapshot.FieldLastBattleTime:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetLastBattleTime(v)
+		return nil
+	case achievementssnapshot.FieldData:
+		v, ok := value.(types.AchievementsFrame)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetData(v)
+		return nil
+	}
+	return fmt.Errorf("unknown AchievementsSnapshot field %s", name)
+}
+
+// AddedFields returns all numeric fields that were incremented/decremented during
+// this mutation.
+func (m *AchievementsSnapshotMutation) AddedFields() []string {
+	var fields []string
+	if m.addcreated_at != nil {
+		fields = append(fields, achievementssnapshot.FieldCreatedAt)
+	}
+	if m.addupdated_at != nil {
+		fields = append(fields, achievementssnapshot.FieldUpdatedAt)
+	}
+	if m.addbattles != nil {
+		fields = append(fields, achievementssnapshot.FieldBattles)
+	}
+	if m.addlast_battle_time != nil {
+		fields = append(fields, achievementssnapshot.FieldLastBattleTime)
+	}
+	return fields
+}
+
+// AddedField returns the numeric value that was incremented/decremented on a field
+// with the given name. The second boolean return value indicates that this field
+// was not set, or was not defined in the schema.
+func (m *AchievementsSnapshotMutation) AddedField(name string) (ent.Value, bool) {
+	switch name {
+	case achievementssnapshot.FieldCreatedAt:
+		return m.AddedCreatedAt()
+	case achievementssnapshot.FieldUpdatedAt:
+		return m.AddedUpdatedAt()
+	case achievementssnapshot.FieldBattles:
+		return m.AddedBattles()
+	case achievementssnapshot.FieldLastBattleTime:
+		return m.AddedLastBattleTime()
+	}
+	return nil, false
+}
+
+// AddField adds the value to the field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *AchievementsSnapshotMutation) AddField(name string, value ent.Value) error {
+	switch name {
+	case achievementssnapshot.FieldCreatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddCreatedAt(v)
+		return nil
+	case achievementssnapshot.FieldUpdatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddUpdatedAt(v)
+		return nil
+	case achievementssnapshot.FieldBattles:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddBattles(v)
+		return nil
+	case achievementssnapshot.FieldLastBattleTime:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddLastBattleTime(v)
+		return nil
+	}
+	return fmt.Errorf("unknown AchievementsSnapshot numeric field %s", name)
+}
+
+// ClearedFields returns all nullable fields that were cleared during this
+// mutation.
+func (m *AchievementsSnapshotMutation) ClearedFields() []string {
+	return nil
+}
+
+// FieldCleared returns a boolean indicating if a field with the given name was
+// cleared in this mutation.
+func (m *AchievementsSnapshotMutation) FieldCleared(name string) bool {
+	_, ok := m.clearedFields[name]
+	return ok
+}
+
+// ClearField clears the value of the field with the given name. It returns an
+// error if the field is not defined in the schema.
+func (m *AchievementsSnapshotMutation) ClearField(name string) error {
+	return fmt.Errorf("unknown AchievementsSnapshot nullable field %s", name)
+}
+
+// ResetField resets all changes in the mutation for the field with the given name.
+// It returns an error if the field is not defined in the schema.
+func (m *AchievementsSnapshotMutation) ResetField(name string) error {
+	switch name {
+	case achievementssnapshot.FieldCreatedAt:
+		m.ResetCreatedAt()
+		return nil
+	case achievementssnapshot.FieldUpdatedAt:
+		m.ResetUpdatedAt()
+		return nil
+	case achievementssnapshot.FieldType:
+		m.ResetType()
+		return nil
+	case achievementssnapshot.FieldAccountID:
+		m.ResetAccountID()
+		return nil
+	case achievementssnapshot.FieldReferenceID:
+		m.ResetReferenceID()
+		return nil
+	case achievementssnapshot.FieldBattles:
+		m.ResetBattles()
+		return nil
+	case achievementssnapshot.FieldLastBattleTime:
+		m.ResetLastBattleTime()
+		return nil
+	case achievementssnapshot.FieldData:
+		m.ResetData()
+		return nil
+	}
+	return fmt.Errorf("unknown AchievementsSnapshot field %s", name)
+}
+
+// AddedEdges returns all edge names that were set/added in this mutation.
+func (m *AchievementsSnapshotMutation) AddedEdges() []string {
+	edges := make([]string, 0, 1)
+	if m.account != nil {
+		edges = append(edges, achievementssnapshot.EdgeAccount)
+	}
+	return edges
+}
+
+// AddedIDs returns all IDs (to other nodes) that were added for the given edge
+// name in this mutation.
+func (m *AchievementsSnapshotMutation) AddedIDs(name string) []ent.Value {
+	switch name {
+	case achievementssnapshot.EdgeAccount:
+		if id := m.account; id != nil {
+			return []ent.Value{*id}
+		}
+	}
+	return nil
+}
+
+// RemovedEdges returns all edge names that were removed in this mutation.
+func (m *AchievementsSnapshotMutation) RemovedEdges() []string {
+	edges := make([]string, 0, 1)
+	return edges
+}
+
+// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
+// the given name in this mutation.
+func (m *AchievementsSnapshotMutation) RemovedIDs(name string) []ent.Value {
+	return nil
+}
+
+// ClearedEdges returns all edge names that were cleared in this mutation.
+func (m *AchievementsSnapshotMutation) ClearedEdges() []string {
+	edges := make([]string, 0, 1)
+	if m.clearedaccount {
+		edges = append(edges, achievementssnapshot.EdgeAccount)
+	}
+	return edges
+}
+
+// EdgeCleared returns a boolean which indicates if the edge with the given name
+// was cleared in this mutation.
+func (m *AchievementsSnapshotMutation) EdgeCleared(name string) bool {
+	switch name {
+	case achievementssnapshot.EdgeAccount:
+		return m.clearedaccount
+	}
+	return false
+}
+
+// ClearEdge clears the value of the edge with the given name. It returns an error
+// if that edge is not defined in the schema.
+func (m *AchievementsSnapshotMutation) ClearEdge(name string) error {
+	switch name {
+	case achievementssnapshot.EdgeAccount:
+		m.ClearAccount()
+		return nil
+	}
+	return fmt.Errorf("unknown AchievementsSnapshot unique edge %s", name)
+}
+
+// ResetEdge resets all changes to the edge with the given name in this mutation.
+// It returns an error if the edge is not defined in the schema.
+func (m *AchievementsSnapshotMutation) ResetEdge(name string) error {
+	switch name {
+	case achievementssnapshot.EdgeAccount:
+		m.ResetAccount()
+		return nil
+	}
+	return fmt.Errorf("unknown AchievementsSnapshot edge %s", name)
+}
+
+// AppConfigurationMutation represents an operation that mutates the AppConfiguration nodes in the graph.
+type AppConfigurationMutation struct {
+	config
+	op            Op
+	typ           string
+	id            *string
+	created_at    *int
+	addcreated_at *int
+	updated_at    *int
+	addupdated_at *int
+	key           *string
+	value         *any
+	metadata      *map[string]interface{}
+	clearedFields map[string]struct{}
+	done          bool
+	oldValue      func(context.Context) (*AppConfiguration, error)
+	predicates    []predicate.AppConfiguration
+}
+
+var _ ent.Mutation = (*AppConfigurationMutation)(nil)
+
+// appconfigurationOption allows management of the mutation configuration using functional options.
+type appconfigurationOption func(*AppConfigurationMutation)
+
+// newAppConfigurationMutation creates new mutation for the AppConfiguration entity.
+func newAppConfigurationMutation(c config, op Op, opts ...appconfigurationOption) *AppConfigurationMutation {
+	m := &AppConfigurationMutation{
+		config:        c,
+		op:            op,
+		typ:           TypeAppConfiguration,
+		clearedFields: make(map[string]struct{}),
+	}
+	for _, opt := range opts {
+		opt(m)
+	}
+	return m
+}
+
+// withAppConfigurationID sets the ID field of the mutation.
+func withAppConfigurationID(id string) appconfigurationOption {
+	return func(m *AppConfigurationMutation) {
+		var (
+			err   error
+			once  sync.Once
+			value *AppConfiguration
+		)
+		m.oldValue = func(ctx context.Context) (*AppConfiguration, error) {
+			once.Do(func() {
+				if m.done {
+					err = errors.New("querying old values post mutation is not allowed")
+				} else {
+					value, err = m.Client().AppConfiguration.Get(ctx, id)
+				}
+			})
+			return value, err
+		}
+		m.id = &id
+	}
+}
+
+// withAppConfiguration sets the old AppConfiguration of the mutation.
+func withAppConfiguration(node *AppConfiguration) appconfigurationOption {
+	return func(m *AppConfigurationMutation) {
+		m.oldValue = func(context.Context) (*AppConfiguration, error) {
+			return node, nil
+		}
+		m.id = &node.ID
+	}
+}
+
+// Client returns a new `ent.Client` from the mutation. If the mutation was
+// executed in a transaction (ent.Tx), a transactional client is returned.
+func (m AppConfigurationMutation) Client() *Client {
+	client := &Client{config: m.config}
+	client.init()
+	return client
+}
+
+// Tx returns an `ent.Tx` for mutations that were executed in transactions;
+// it returns an error otherwise.
+func (m AppConfigurationMutation) Tx() (*Tx, error) {
+	if _, ok := m.driver.(*txDriver); !ok {
+		return nil, errors.New("db: mutation is not running in a transaction")
+	}
+	tx := &Tx{config: m.config}
+	tx.init()
+	return tx, nil
+}
+
+// SetID sets the value of the id field. Note that this
+// operation is only accepted on creation of AppConfiguration entities.
+func (m *AppConfigurationMutation) SetID(id string) {
+	m.id = &id
+}
+
+// ID returns the ID value in the mutation. Note that the ID is only available
+// if it was provided to the builder or after it was returned from the database.
+func (m *AppConfigurationMutation) ID() (id string, exists bool) {
+	if m.id == nil {
+		return
+	}
+	return *m.id, true
+}
+
+// IDs queries the database and returns the entity ids that match the mutation's predicate.
+// That means, if the mutation is applied within a transaction with an isolation level such
+// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
+// or updated by the mutation.
+func (m *AppConfigurationMutation) IDs(ctx context.Context) ([]string, error) {
+	switch {
+	case m.op.Is(OpUpdateOne | OpDeleteOne):
+		id, exists := m.ID()
+		if exists {
+			return []string{id}, nil
+		}
+		fallthrough
+	case m.op.Is(OpUpdate | OpDelete):
+		return m.Client().AppConfiguration.Query().Where(m.predicates...).IDs(ctx)
+	default:
+		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
+	}
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (m *AppConfigurationMutation) SetCreatedAt(i int) {
+	m.created_at = &i
+	m.addcreated_at = nil
+}
+
+// CreatedAt returns the value of the "created_at" field in the mutation.
+func (m *AppConfigurationMutation) CreatedAt() (r int, exists bool) {
+	v := m.created_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldCreatedAt returns the old "created_at" field's value of the AppConfiguration entity.
+// If the AppConfiguration object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *AppConfigurationMutation) OldCreatedAt(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldCreatedAt requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
+	}
+	return oldValue.CreatedAt, nil
+}
+
+// AddCreatedAt adds i to the "created_at" field.
+func (m *AppConfigurationMutation) AddCreatedAt(i int) {
+	if m.addcreated_at != nil {
+		*m.addcreated_at += i
+	} else {
+		m.addcreated_at = &i
+	}
+}
+
+// AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
+func (m *AppConfigurationMutation) AddedCreatedAt() (r int, exists bool) {
+	v := m.addcreated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetCreatedAt resets all changes to the "created_at" field.
+func (m *AppConfigurationMutation) ResetCreatedAt() {
+	m.created_at = nil
+	m.addcreated_at = nil
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (m *AppConfigurationMutation) SetUpdatedAt(i int) {
+	m.updated_at = &i
+	m.addupdated_at = nil
+}
+
+// UpdatedAt returns the value of the "updated_at" field in the mutation.
+func (m *AppConfigurationMutation) UpdatedAt() (r int, exists bool) {
+	v := m.updated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldUpdatedAt returns the old "updated_at" field's value of the AppConfiguration entity.
+// If the AppConfiguration object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *AppConfigurationMutation) OldUpdatedAt(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
+	}
+	return oldValue.UpdatedAt, nil
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (m *AppConfigurationMutation) AddUpdatedAt(i int) {
+	if m.addupdated_at != nil {
+		*m.addupdated_at += i
+	} else {
+		m.addupdated_at = &i
+	}
+}
+
+// AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
+func (m *AppConfigurationMutation) AddedUpdatedAt() (r int, exists bool) {
+	v := m.addupdated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetUpdatedAt resets all changes to the "updated_at" field.
+func (m *AppConfigurationMutation) ResetUpdatedAt() {
+	m.updated_at = nil
+	m.addupdated_at = nil
+}
+
+// SetKey sets the "key" field.
+func (m *AppConfigurationMutation) SetKey(s string) {
+	m.key = &s
+}
+
+// Key returns the value of the "key" field in the mutation.
+func (m *AppConfigurationMutation) Key() (r string, exists bool) {
+	v := m.key
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldKey returns the old "key" field's value of the AppConfiguration entity.
+// If the AppConfiguration object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *AppConfigurationMutation) OldKey(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldKey is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldKey requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldKey: %w", err)
+	}
+	return oldValue.Key, nil
+}
+
+// ResetKey resets all changes to the "key" field.
+func (m *AppConfigurationMutation) ResetKey() {
+	m.key = nil
+}
+
+// SetValue sets the "value" field.
+func (m *AppConfigurationMutation) SetValue(a any) {
+	m.value = &a
+}
+
+// Value returns the value of the "value" field in the mutation.
+func (m *AppConfigurationMutation) Value() (r any, exists bool) {
+	v := m.value
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldValue returns the old "value" field's value of the AppConfiguration entity.
+// If the AppConfiguration object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *AppConfigurationMutation) OldValue(ctx context.Context) (v any, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldValue is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldValue requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldValue: %w", err)
+	}
+	return oldValue.Value, nil
+}
+
+// ResetValue resets all changes to the "value" field.
+func (m *AppConfigurationMutation) ResetValue() {
+	m.value = nil
+}
+
+// SetMetadata sets the "metadata" field.
+func (m *AppConfigurationMutation) SetMetadata(value map[string]interface{}) {
+	m.metadata = &value
+}
+
+// Metadata returns the value of the "metadata" field in the mutation.
+func (m *AppConfigurationMutation) Metadata() (r map[string]interface{}, exists bool) {
+	v := m.metadata
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldMetadata returns the old "metadata" field's value of the AppConfiguration entity.
+// If the AppConfiguration object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *AppConfigurationMutation) OldMetadata(ctx context.Context) (v map[string]interface{}, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldMetadata is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldMetadata requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldMetadata: %w", err)
+	}
+	return oldValue.Metadata, nil
+}
+
+// ClearMetadata clears the value of the "metadata" field.
+func (m *AppConfigurationMutation) ClearMetadata() {
+	m.metadata = nil
+	m.clearedFields[appconfiguration.FieldMetadata] = struct{}{}
+}
+
+// MetadataCleared returns if the "metadata" field was cleared in this mutation.
+func (m *AppConfigurationMutation) MetadataCleared() bool {
+	_, ok := m.clearedFields[appconfiguration.FieldMetadata]
+	return ok
+}
+
+// ResetMetadata resets all changes to the "metadata" field.
+func (m *AppConfigurationMutation) ResetMetadata() {
+	m.metadata = nil
+	delete(m.clearedFields, appconfiguration.FieldMetadata)
+}
+
+// Where appends a list predicates to the AppConfigurationMutation builder.
+func (m *AppConfigurationMutation) Where(ps ...predicate.AppConfiguration) {
+	m.predicates = append(m.predicates, ps...)
+}
+
+// WhereP appends storage-level predicates to the AppConfigurationMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *AppConfigurationMutation) WhereP(ps ...func(*sql.Selector)) {
+	p := make([]predicate.AppConfiguration, len(ps))
+	for i := range ps {
+		p[i] = ps[i]
+	}
+	m.Where(p...)
+}
+
+// Op returns the operation name.
+func (m *AppConfigurationMutation) Op() Op {
+	return m.op
+}
+
+// SetOp allows setting the mutation operation.
+func (m *AppConfigurationMutation) SetOp(op Op) {
+	m.op = op
+}
+
+// Type returns the node type of this mutation (AppConfiguration).
+func (m *AppConfigurationMutation) Type() string {
+	return m.typ
+}
+
+// Fields returns all fields that were changed during this mutation. Note that in
+// order to get all numeric fields that were incremented/decremented, call
+// AddedFields().
+func (m *AppConfigurationMutation) Fields() []string {
+	fields := make([]string, 0, 5)
+	if m.created_at != nil {
+		fields = append(fields, appconfiguration.FieldCreatedAt)
+	}
+	if m.updated_at != nil {
+		fields = append(fields, appconfiguration.FieldUpdatedAt)
+	}
+	if m.key != nil {
+		fields = append(fields, appconfiguration.FieldKey)
+	}
+	if m.value != nil {
+		fields = append(fields, appconfiguration.FieldValue)
+	}
+	if m.metadata != nil {
+		fields = append(fields, appconfiguration.FieldMetadata)
+	}
+	return fields
+}
+
+// Field returns the value of a field with the given name. The second boolean
+// return value indicates that this field was not set, or was not defined in the
+// schema.
+func (m *AppConfigurationMutation) Field(name string) (ent.Value, bool) {
+	switch name {
+	case appconfiguration.FieldCreatedAt:
+		return m.CreatedAt()
+	case appconfiguration.FieldUpdatedAt:
+		return m.UpdatedAt()
+	case appconfiguration.FieldKey:
+		return m.Key()
+	case appconfiguration.FieldValue:
+		return m.Value()
+	case appconfiguration.FieldMetadata:
+		return m.Metadata()
+	}
+	return nil, false
+}
+
+// OldField returns the old value of the field from the database. An error is
+// returned if the mutation operation is not UpdateOne, or the query to the
+// database failed.
+func (m *AppConfigurationMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
+	switch name {
+	case appconfiguration.FieldCreatedAt:
+		return m.OldCreatedAt(ctx)
+	case appconfiguration.FieldUpdatedAt:
+		return m.OldUpdatedAt(ctx)
+	case appconfiguration.FieldKey:
+		return m.OldKey(ctx)
+	case appconfiguration.FieldValue:
+		return m.OldValue(ctx)
+	case appconfiguration.FieldMetadata:
+		return m.OldMetadata(ctx)
+	}
+	return nil, fmt.Errorf("unknown AppConfiguration field %s", name)
+}
+
+// SetField sets the value of a field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *AppConfigurationMutation) SetField(name string, value ent.Value) error {
+	switch name {
+	case appconfiguration.FieldCreatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetCreatedAt(v)
+		return nil
+	case appconfiguration.FieldUpdatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetUpdatedAt(v)
+		return nil
+	case appconfiguration.FieldKey:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetKey(v)
+		return nil
+	case appconfiguration.FieldValue:
+		v, ok := value.(any)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetValue(v)
+		return nil
+	case appconfiguration.FieldMetadata:
+		v, ok := value.(map[string]interface{})
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetMetadata(v)
+		return nil
+	}
+	return fmt.Errorf("unknown AppConfiguration field %s", name)
+}
+
+// AddedFields returns all numeric fields that were incremented/decremented during
+// this mutation.
+func (m *AppConfigurationMutation) AddedFields() []string {
+	var fields []string
+	if m.addcreated_at != nil {
+		fields = append(fields, appconfiguration.FieldCreatedAt)
+	}
+	if m.addupdated_at != nil {
+		fields = append(fields, appconfiguration.FieldUpdatedAt)
+	}
+	return fields
+}
+
+// AddedField returns the numeric value that was incremented/decremented on a field
+// with the given name. The second boolean return value indicates that this field
+// was not set, or was not defined in the schema.
+func (m *AppConfigurationMutation) AddedField(name string) (ent.Value, bool) {
+	switch name {
+	case appconfiguration.FieldCreatedAt:
+		return m.AddedCreatedAt()
+	case appconfiguration.FieldUpdatedAt:
+		return m.AddedUpdatedAt()
+	}
+	return nil, false
+}
+
+// AddField adds the value to the field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *AppConfigurationMutation) AddField(name string, value ent.Value) error {
+	switch name {
+	case appconfiguration.FieldCreatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddCreatedAt(v)
+		return nil
+	case appconfiguration.FieldUpdatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddUpdatedAt(v)
+		return nil
+	}
+	return fmt.Errorf("unknown AppConfiguration numeric field %s", name)
+}
+
+// ClearedFields returns all nullable fields that were cleared during this
+// mutation.
+func (m *AppConfigurationMutation) ClearedFields() []string {
+	var fields []string
+	if m.FieldCleared(appconfiguration.FieldMetadata) {
+		fields = append(fields, appconfiguration.FieldMetadata)
+	}
+	return fields
+}
+
+// FieldCleared returns a boolean indicating if a field with the given name was
+// cleared in this mutation.
+func (m *AppConfigurationMutation) FieldCleared(name string) bool {
+	_, ok := m.clearedFields[name]
+	return ok
+}
+
+// ClearField clears the value of the field with the given name. It returns an
+// error if the field is not defined in the schema.
+func (m *AppConfigurationMutation) ClearField(name string) error {
+	switch name {
+	case appconfiguration.FieldMetadata:
+		m.ClearMetadata()
+		return nil
+	}
+	return fmt.Errorf("unknown AppConfiguration nullable field %s", name)
+}
+
+// ResetField resets all changes in the mutation for the field with the given name.
+// It returns an error if the field is not defined in the schema.
+func (m *AppConfigurationMutation) ResetField(name string) error {
+	switch name {
+	case appconfiguration.FieldCreatedAt:
+		m.ResetCreatedAt()
+		return nil
+	case appconfiguration.FieldUpdatedAt:
+		m.ResetUpdatedAt()
+		return nil
+	case appconfiguration.FieldKey:
+		m.ResetKey()
+		return nil
+	case appconfiguration.FieldValue:
+		m.ResetValue()
+		return nil
+	case appconfiguration.FieldMetadata:
+		m.ResetMetadata()
+		return nil
+	}
+	return fmt.Errorf("unknown AppConfiguration field %s", name)
+}
+
+// AddedEdges returns all edge names that were set/added in this mutation.
+func (m *AppConfigurationMutation) AddedEdges() []string {
+	edges := make([]string, 0, 0)
+	return edges
+}
+
+// AddedIDs returns all IDs (to other nodes) that were added for the given edge
+// name in this mutation.
+func (m *AppConfigurationMutation) AddedIDs(name string) []ent.Value {
+	return nil
+}
+
+// RemovedEdges returns all edge names that were removed in this mutation.
+func (m *AppConfigurationMutation) RemovedEdges() []string {
+	edges := make([]string, 0, 0)
+	return edges
+}
+
+// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
+// the given name in this mutation.
+func (m *AppConfigurationMutation) RemovedIDs(name string) []ent.Value {
+	return nil
+}
+
+// ClearedEdges returns all edge names that were cleared in this mutation.
+func (m *AppConfigurationMutation) ClearedEdges() []string {
+	edges := make([]string, 0, 0)
+	return edges
+}
+
+// EdgeCleared returns a boolean which indicates if the edge with the given name
+// was cleared in this mutation.
+func (m *AppConfigurationMutation) EdgeCleared(name string) bool {
+	return false
+}
+
+// ClearEdge clears the value of the edge with the given name. It returns an error
+// if that edge is not defined in the schema.
+func (m *AppConfigurationMutation) ClearEdge(name string) error {
+	return fmt.Errorf("unknown AppConfiguration unique edge %s", name)
+}
+
+// ResetEdge resets all changes to the edge with the given name in this mutation.
+// It returns an error if the edge is not defined in the schema.
+func (m *AppConfigurationMutation) ResetEdge(name string) error {
+	return fmt.Errorf("unknown AppConfiguration edge %s", name)
+}
+
+// ApplicationCommandMutation represents an operation that mutates the ApplicationCommand nodes in the graph.
+type ApplicationCommandMutation struct {
+	config
+	op            Op
+	typ           string
+	id            *string
+	created_at    *int
+	addcreated_at *int
+	updated_at    *int
+	addupdated_at *int
+	name          *string
+	version       *string
+	options_hash  *string
+	clearedFields map[string]struct{}
+	done          bool
+	oldValue      func(context.Context) (*ApplicationCommand, error)
+	predicates    []predicate.ApplicationCommand
+}
+
+var _ ent.Mutation = (*ApplicationCommandMutation)(nil)
+
+// applicationcommandOption allows management of the mutation configuration using functional options.
+type applicationcommandOption func(*ApplicationCommandMutation)
+
+// newApplicationCommandMutation creates new mutation for the ApplicationCommand entity.
+func newApplicationCommandMutation(c config, op Op, opts ...applicationcommandOption) *ApplicationCommandMutation {
+	m := &ApplicationCommandMutation{
+		config:        c,
+		op:            op,
+		typ:           TypeApplicationCommand,
+		clearedFields: make(map[string]struct{}),
+	}
+	for _, opt := range opts {
+		opt(m)
+	}
+	return m
+}
+
+// withApplicationCommandID sets the ID field of the mutation.
+func withApplicationCommandID(id string) applicationcommandOption {
+	return func(m *ApplicationCommandMutation) {
+		var (
+			err   error
+			once  sync.Once
+			value *ApplicationCommand
+		)
+		m.oldValue = func(ctx context.Context) (*ApplicationCommand, error) {
+			once.Do(func() {
+				if m.done {
+					err = errors.New("querying old values post mutation is not allowed")
+				} else {
+					value, err = m.Client().ApplicationCommand.Get(ctx, id)
+				}
+			})
+			return value, err
+		}
+		m.id = &id
+	}
+}
+
+// withApplicationCommand sets the old ApplicationCommand of the mutation.
+func withApplicationCommand(node *ApplicationCommand) applicationcommandOption {
+	return func(m *ApplicationCommandMutation) {
+		m.oldValue = func(context.Context) (*ApplicationCommand, error) {
+			return node, nil
+		}
+		m.id = &node.ID
+	}
+}
+
+// Client returns a new `ent.Client` from the mutation. If the mutation was
+// executed in a transaction (ent.Tx), a transactional client is returned.
+func (m ApplicationCommandMutation) Client() *Client {
+	client := &Client{config: m.config}
+	client.init()
+	return client
+}
+
+// Tx returns an `ent.Tx` for mutations that were executed in transactions;
+// it returns an error otherwise.
+func (m ApplicationCommandMutation) Tx() (*Tx, error) {
+	if _, ok := m.driver.(*txDriver); !ok {
+		return nil, errors.New("db: mutation is not running in a transaction")
+	}
+	tx := &Tx{config: m.config}
+	tx.init()
+	return tx, nil
+}
+
+// SetID sets the value of the id field. Note that this
+// operation is only accepted on creation of ApplicationCommand entities.
+func (m *ApplicationCommandMutation) SetID(id string) {
+	m.id = &id
+}
+
+// ID returns the ID value in the mutation. Note that the ID is only available
+// if it was provided to the builder or after it was returned from the database.
+func (m *ApplicationCommandMutation) ID() (id string, exists bool) {
+	if m.id == nil {
+		return
+	}
+	return *m.id, true
+}
+
+// IDs queries the database and returns the entity ids that match the mutation's predicate.
+// That means, if the mutation is applied within a transaction with an isolation level such
+// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
+// or updated by the mutation.
+func (m *ApplicationCommandMutation) IDs(ctx context.Context) ([]string, error) {
+	switch {
+	case m.op.Is(OpUpdateOne | OpDeleteOne):
+		id, exists := m.ID()
+		if exists {
+			return []string{id}, nil
+		}
+		fallthrough
+	case m.op.Is(OpUpdate | OpDelete):
+		return m.Client().ApplicationCommand.Query().Where(m.predicates...).IDs(ctx)
+	default:
+		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
+	}
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (m *ApplicationCommandMutation) SetCreatedAt(i int) {
+	m.created_at = &i
+	m.addcreated_at = nil
+}
+
+// CreatedAt returns the value of the "created_at" field in the mutation.
+func (m *ApplicationCommandMutation) CreatedAt() (r int, exists bool) {
+	v := m.created_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldCreatedAt returns the old "created_at" field's value of the ApplicationCommand entity.
+// If the ApplicationCommand object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *ApplicationCommandMutation) OldCreatedAt(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldCreatedAt requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
+	}
+	return oldValue.CreatedAt, nil
+}
+
+// AddCreatedAt adds i to the "created_at" field.
+func (m *ApplicationCommandMutation) AddCreatedAt(i int) {
+	if m.addcreated_at != nil {
+		*m.addcreated_at += i
+	} else {
+		m.addcreated_at = &i
+	}
+}
+
+// AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
+func (m *ApplicationCommandMutation) AddedCreatedAt() (r int, exists bool) {
+	v := m.addcreated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetCreatedAt resets all changes to the "created_at" field.
+func (m *ApplicationCommandMutation) ResetCreatedAt() {
+	m.created_at = nil
+	m.addcreated_at = nil
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (m *ApplicationCommandMutation) SetUpdatedAt(i int) {
+	m.updated_at = &i
+	m.addupdated_at = nil
+}
+
+// UpdatedAt returns the value of the "updated_at" field in the mutation.
+func (m *ApplicationCommandMutation) UpdatedAt() (r int, exists bool) {
+	v := m.updated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldUpdatedAt returns the old "updated_at" field's value of the ApplicationCommand entity.
+// If the ApplicationCommand object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *ApplicationCommandMutation) OldUpdatedAt(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
+	}
+	return oldValue.UpdatedAt, nil
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (m *ApplicationCommandMutation) AddUpdatedAt(i int) {
+	if m.addupdated_at != nil {
+		*m.addupdated_at += i
+	} else {
+		m.addupdated_at = &i
+	}
+}
+
+// AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
+func (m *ApplicationCommandMutation) AddedUpdatedAt() (r int, exists bool) {
+	v := m.addupdated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetUpdatedAt resets all changes to the "updated_at" field.
+func (m *ApplicationCommandMutation) ResetUpdatedAt() {
+	m.updated_at = nil
+	m.addupdated_at = nil
+}
+
+// SetName sets the "name" field.
+func (m *ApplicationCommandMutation) SetName(s string) {
+	m.name = &s
+}
+
+// Name returns the value of the "name" field in the mutation.
+func (m *ApplicationCommandMutation) Name() (r string, exists bool) {
+	v := m.name
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldName returns the old "name" field's value of the ApplicationCommand entity.
+// If the ApplicationCommand object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *ApplicationCommandMutation) OldName(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldName is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldName requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldName: %w", err)
+	}
+	return oldValue.Name, nil
+}
+
+// ResetName resets all changes to the "name" field.
+func (m *ApplicationCommandMutation) ResetName() {
+	m.name = nil
+}
+
+// SetVersion sets the "version" field.
+func (m *ApplicationCommandMutation) SetVersion(s string) {
+	m.version = &s
+}
+
+// Version returns the value of the "version" field in the mutation.
+func (m *ApplicationCommandMutation) Version() (r string, exists bool) {
+	v := m.version
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldVersion returns the old "version" field's value of the ApplicationCommand entity.
+// If the ApplicationCommand object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *ApplicationCommandMutation) OldVersion(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldVersion is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldVersion requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldVersion: %w", err)
+	}
+	return oldValue.Version, nil
+}
+
+// ResetVersion resets all changes to the "version" field.
+func (m *ApplicationCommandMutation) ResetVersion() {
+	m.version = nil
+}
+
+// SetOptionsHash sets the "options_hash" field.
+func (m *ApplicationCommandMutation) SetOptionsHash(s string) {
+	m.options_hash = &s
+}
+
+// OptionsHash returns the value of the "options_hash" field in the mutation.
+func (m *ApplicationCommandMutation) OptionsHash() (r string, exists bool) {
+	v := m.options_hash
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldOptionsHash returns the old "options_hash" field's value of the ApplicationCommand entity.
+// If the ApplicationCommand object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *ApplicationCommandMutation) OldOptionsHash(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldOptionsHash is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldOptionsHash requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldOptionsHash: %w", err)
+	}
+	return oldValue.OptionsHash, nil
+}
+
+// ResetOptionsHash resets all changes to the "options_hash" field.
+func (m *ApplicationCommandMutation) ResetOptionsHash() {
+	m.options_hash = nil
+}
+
+// Where appends a list predicates to the ApplicationCommandMutation builder.
+func (m *ApplicationCommandMutation) Where(ps ...predicate.ApplicationCommand) {
+	m.predicates = append(m.predicates, ps...)
+}
+
+// WhereP appends storage-level predicates to the ApplicationCommandMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *ApplicationCommandMutation) WhereP(ps ...func(*sql.Selector)) {
+	p := make([]predicate.ApplicationCommand, len(ps))
+	for i := range ps {
+		p[i] = ps[i]
+	}
+	m.Where(p...)
+}
+
+// Op returns the operation name.
+func (m *ApplicationCommandMutation) Op() Op {
+	return m.op
+}
+
+// SetOp allows setting the mutation operation.
+func (m *ApplicationCommandMutation) SetOp(op Op) {
+	m.op = op
+}
+
+// Type returns the node type of this mutation (ApplicationCommand).
+func (m *ApplicationCommandMutation) Type() string {
+	return m.typ
+}
+
+// Fields returns all fields that were changed during this mutation. Note that in
+// order to get all numeric fields that were incremented/decremented, call
+// AddedFields().
+func (m *ApplicationCommandMutation) Fields() []string {
+	fields := make([]string, 0, 5)
+	if m.created_at != nil {
+		fields = append(fields, applicationcommand.FieldCreatedAt)
+	}
+	if m.updated_at != nil {
+		fields = append(fields, applicationcommand.FieldUpdatedAt)
+	}
+	if m.name != nil {
+		fields = append(fields, applicationcommand.FieldName)
+	}
+	if m.version != nil {
+		fields = append(fields, applicationcommand.FieldVersion)
+	}
+	if m.options_hash != nil {
+		fields = append(fields, applicationcommand.FieldOptionsHash)
+	}
+	return fields
+}
+
+// Field returns the value of a field with the given name. The second boolean
+// return value indicates that this field was not set, or was not defined in the
+// schema.
+func (m *ApplicationCommandMutation) Field(name string) (ent.Value, bool) {
+	switch name {
+	case applicationcommand.FieldCreatedAt:
+		return m.CreatedAt()
+	case applicationcommand.FieldUpdatedAt:
+		return m.UpdatedAt()
+	case applicationcommand.FieldName:
+		return m.Name()
+	case applicationcommand.FieldVersion:
+		return m.Version()
+	case applicationcommand.FieldOptionsHash:
+		return m.OptionsHash()
+	}
+	return nil, false
+}
+
+// OldField returns the old value of the field from the database. An error is
+// returned if the mutation operation is not UpdateOne, or the query to the
+// database failed.
+func (m *ApplicationCommandMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
+	switch name {
+	case applicationcommand.FieldCreatedAt:
+		return m.OldCreatedAt(ctx)
+	case applicationcommand.FieldUpdatedAt:
+		return m.OldUpdatedAt(ctx)
+	case applicationcommand.FieldName:
+		return m.OldName(ctx)
+	case applicationcommand.FieldVersion:
+		return m.OldVersion(ctx)
+	case applicationcommand.FieldOptionsHash:
+		return m.OldOptionsHash(ctx)
+	}
+	return nil, fmt.Errorf("unknown ApplicationCommand field %s", name)
+}
+
+// SetField sets the value of a field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *ApplicationCommandMutation) SetField(name string, value ent.Value) error {
+	switch name {
+	case applicationcommand.FieldCreatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetCreatedAt(v)
+		return nil
+	case applicationcommand.FieldUpdatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetUpdatedAt(v)
+		return nil
+	case applicationcommand.FieldName:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetName(v)
+		return nil
+	case applicationcommand.FieldVersion:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetVersion(v)
+		return nil
+	case applicationcommand.FieldOptionsHash:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetOptionsHash(v)
+		return nil
+	}
+	return fmt.Errorf("unknown ApplicationCommand field %s", name)
+}
+
+// AddedFields returns all numeric fields that were incremented/decremented during
+// this mutation.
+func (m *ApplicationCommandMutation) AddedFields() []string {
+	var fields []string
+	if m.addcreated_at != nil {
+		fields = append(fields, applicationcommand.FieldCreatedAt)
+	}
+	if m.addupdated_at != nil {
+		fields = append(fields, applicationcommand.FieldUpdatedAt)
+	}
+	return fields
+}
+
+// AddedField returns the numeric value that was incremented/decremented on a field
+// with the given name. The second boolean return value indicates that this field
+// was not set, or was not defined in the schema.
+func (m *ApplicationCommandMutation) AddedField(name string) (ent.Value, bool) {
+	switch name {
+	case applicationcommand.FieldCreatedAt:
+		return m.AddedCreatedAt()
+	case applicationcommand.FieldUpdatedAt:
+		return m.AddedUpdatedAt()
+	}
+	return nil, false
+}
+
+// AddField adds the value to the field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *ApplicationCommandMutation) AddField(name string, value ent.Value) error {
+	switch name {
+	case applicationcommand.FieldCreatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddCreatedAt(v)
+		return nil
+	case applicationcommand.FieldUpdatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddUpdatedAt(v)
+		return nil
+	}
+	return fmt.Errorf("unknown ApplicationCommand numeric field %s", name)
+}
+
+// ClearedFields returns all nullable fields that were cleared during this
+// mutation.
+func (m *ApplicationCommandMutation) ClearedFields() []string {
+	return nil
+}
+
+// FieldCleared returns a boolean indicating if a field with the given name was
+// cleared in this mutation.
+func (m *ApplicationCommandMutation) FieldCleared(name string) bool {
+	_, ok := m.clearedFields[name]
+	return ok
+}
+
+// ClearField clears the value of the field with the given name. It returns an
+// error if the field is not defined in the schema.
+func (m *ApplicationCommandMutation) ClearField(name string) error {
+	return fmt.Errorf("unknown ApplicationCommand nullable field %s", name)
+}
+
+// ResetField resets all changes in the mutation for the field with the given name.
+// It returns an error if the field is not defined in the schema.
+func (m *ApplicationCommandMutation) ResetField(name string) error {
+	switch name {
+	case applicationcommand.FieldCreatedAt:
+		m.ResetCreatedAt()
+		return nil
+	case applicationcommand.FieldUpdatedAt:
+		m.ResetUpdatedAt()
+		return nil
+	case applicationcommand.FieldName:
+		m.ResetName()
+		return nil
+	case applicationcommand.FieldVersion:
+		m.ResetVersion()
+		return nil
+	case applicationcommand.FieldOptionsHash:
+		m.ResetOptionsHash()
+		return nil
+	}
+	return fmt.Errorf("unknown ApplicationCommand field %s", name)
+}
+
+// AddedEdges returns all edge names that were set/added in this mutation.
+func (m *ApplicationCommandMutation) AddedEdges() []string {
+	edges := make([]string, 0, 0)
+	return edges
+}
+
+// AddedIDs returns all IDs (to other nodes) that were added for the given edge
+// name in this mutation.
+func (m *ApplicationCommandMutation) AddedIDs(name string) []ent.Value {
+	return nil
+}
+
+// RemovedEdges returns all edge names that were removed in this mutation.
+func (m *ApplicationCommandMutation) RemovedEdges() []string {
+	edges := make([]string, 0, 0)
+	return edges
+}
+
+// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
+// the given name in this mutation.
+func (m *ApplicationCommandMutation) RemovedIDs(name string) []ent.Value {
+	return nil
+}
+
+// ClearedEdges returns all edge names that were cleared in this mutation.
+func (m *ApplicationCommandMutation) ClearedEdges() []string {
+	edges := make([]string, 0, 0)
+	return edges
+}
+
+// EdgeCleared returns a boolean which indicates if the edge with the given name
+// was cleared in this mutation.
+func (m *ApplicationCommandMutation) EdgeCleared(name string) bool {
+	return false
+}
+
+// ClearEdge clears the value of the edge with the given name. It returns an error
+// if that edge is not defined in the schema.
+func (m *ApplicationCommandMutation) ClearEdge(name string) error {
+	return fmt.Errorf("unknown ApplicationCommand unique edge %s", name)
+}
+
+// ResetEdge resets all changes to the edge with the given name in this mutation.
+// It returns an error if the edge is not defined in the schema.
+func (m *ApplicationCommandMutation) ResetEdge(name string) error {
+	return fmt.Errorf("unknown ApplicationCommand edge %s", name)
+}
+
+// ClanMutation represents an operation that mutates the Clan nodes in the graph.
+type ClanMutation struct {
+	config
+	op              Op
+	typ             string
+	id              *string
+	created_at      *int
+	addcreated_at   *int
+	updated_at      *int
+	addupdated_at   *int
+	tag             *string
+	name            *string
+	emblem_id       *string
+	members         *[]string
+	appendmembers   []string
+	clearedFields   map[string]struct{}
+	accounts        map[string]struct{}
+	removedaccounts map[string]struct{}
+	clearedaccounts bool
+	done            bool
+	oldValue        func(context.Context) (*Clan, error)
+	predicates      []predicate.Clan
+}
+
+var _ ent.Mutation = (*ClanMutation)(nil)
+
+// clanOption allows management of the mutation configuration using functional options.
+type clanOption func(*ClanMutation)
+
+// newClanMutation creates new mutation for the Clan entity.
+func newClanMutation(c config, op Op, opts ...clanOption) *ClanMutation {
+	m := &ClanMutation{
+		config:        c,
+		op:            op,
+		typ:           TypeClan,
+		clearedFields: make(map[string]struct{}),
+	}
+	for _, opt := range opts {
+		opt(m)
+	}
+	return m
+}
+
+// withClanID sets the ID field of the mutation.
+func withClanID(id string) clanOption {
+	return func(m *ClanMutation) {
+		var (
+			err   error
+			once  sync.Once
+			value *Clan
+		)
+		m.oldValue = func(ctx context.Context) (*Clan, error) {
+			once.Do(func() {
+				if m.done {
+					err = errors.New("querying old values post mutation is not allowed")
+				} else {
+					value, err = m.Client().Clan.Get(ctx, id)
+				}
+			})
+			return value, err
+		}
+		m.id = &id
+	}
+}
+
+// withClan sets the old Clan of the mutation.
+func withClan(node *Clan) clanOption {
+	return func(m *ClanMutation) {
+		m.oldValue = func(context.Context) (*Clan, error) {
+			return node, nil
+		}
+		m.id = &node.ID
+	}
+}
+
+// Client returns a new `ent.Client` from the mutation. If the mutation was
+// executed in a transaction (ent.Tx), a transactional client is returned.
+func (m ClanMutation) Client() *Client {
+	client := &Client{config: m.config}
+	client.init()
+	return client
+}
+
+// Tx returns an `ent.Tx` for mutations that were executed in transactions;
+// it returns an error otherwise.
+func (m ClanMutation) Tx() (*Tx, error) {
+	if _, ok := m.driver.(*txDriver); !ok {
+		return nil, errors.New("db: mutation is not running in a transaction")
+	}
+	tx := &Tx{config: m.config}
+	tx.init()
+	return tx, nil
+}
+
+// SetID sets the value of the id field. Note that this
+// operation is only accepted on creation of Clan entities.
+func (m *ClanMutation) SetID(id string) {
+	m.id = &id
+}
+
+// ID returns the ID value in the mutation. Note that the ID is only available
+// if it was provided to the builder or after it was returned from the database.
+func (m *ClanMutation) ID() (id string, exists bool) {
+	if m.id == nil {
+		return
+	}
+	return *m.id, true
+}
+
+// IDs queries the database and returns the entity ids that match the mutation's predicate.
+// That means, if the mutation is applied within a transaction with an isolation level such
+// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
+// or updated by the mutation.
+func (m *ClanMutation) IDs(ctx context.Context) ([]string, error) {
+	switch {
+	case m.op.Is(OpUpdateOne | OpDeleteOne):
+		id, exists := m.ID()
+		if exists {
+			return []string{id}, nil
+		}
+		fallthrough
+	case m.op.Is(OpUpdate | OpDelete):
+		return m.Client().Clan.Query().Where(m.predicates...).IDs(ctx)
+	default:
+		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
+	}
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (m *ClanMutation) SetCreatedAt(i int) {
+	m.created_at = &i
+	m.addcreated_at = nil
+}
+
+// CreatedAt returns the value of the "created_at" field in the mutation.
+func (m *ClanMutation) CreatedAt() (r int, exists bool) {
+	v := m.created_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldCreatedAt returns the old "created_at" field's value of the Clan entity.
+// If the Clan object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *ClanMutation) OldCreatedAt(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldCreatedAt requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
+	}
+	return oldValue.CreatedAt, nil
+}
+
+// AddCreatedAt adds i to the "created_at" field.
+func (m *ClanMutation) AddCreatedAt(i int) {
+	if m.addcreated_at != nil {
+		*m.addcreated_at += i
+	} else {
+		m.addcreated_at = &i
+	}
+}
+
+// AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
+func (m *ClanMutation) AddedCreatedAt() (r int, exists bool) {
+	v := m.addcreated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetCreatedAt resets all changes to the "created_at" field.
+func (m *ClanMutation) ResetCreatedAt() {
+	m.created_at = nil
+	m.addcreated_at = nil
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (m *ClanMutation) SetUpdatedAt(i int) {
+	m.updated_at = &i
+	m.addupdated_at = nil
+}
+
+// UpdatedAt returns the value of the "updated_at" field in the mutation.
+func (m *ClanMutation) UpdatedAt() (r int, exists bool) {
+	v := m.updated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldUpdatedAt returns the old "updated_at" field's value of the Clan entity.
+// If the Clan object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *ClanMutation) OldUpdatedAt(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
+	}
+	return oldValue.UpdatedAt, nil
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (m *ClanMutation) AddUpdatedAt(i int) {
+	if m.addupdated_at != nil {
+		*m.addupdated_at += i
+	} else {
+		m.addupdated_at = &i
+	}
+}
+
+// AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
+func (m *ClanMutation) AddedUpdatedAt() (r int, exists bool) {
+	v := m.addupdated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetUpdatedAt resets all changes to the "updated_at" field.
+func (m *ClanMutation) ResetUpdatedAt() {
+	m.updated_at = nil
+	m.addupdated_at = nil
+}
+
+// SetTag sets the "tag" field.
+func (m *ClanMutation) SetTag(s string) {
+	m.tag = &s
+}
+
+// Tag returns the value of the "tag" field in the mutation.
+func (m *ClanMutation) Tag() (r string, exists bool) {
+	v := m.tag
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldTag returns the old "tag" field's value of the Clan entity.
+// If the Clan object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *ClanMutation) OldTag(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldTag is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldTag requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldTag: %w", err)
+	}
+	return oldValue.Tag, nil
+}
+
+// ResetTag resets all changes to the "tag" field.
+func (m *ClanMutation) ResetTag() {
+	m.tag = nil
+}
+
+// SetName sets the "name" field.
+func (m *ClanMutation) SetName(s string) {
+	m.name = &s
+}
+
+// Name returns the value of the "name" field in the mutation.
+func (m *ClanMutation) Name() (r string, exists bool) {
+	v := m.name
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldName returns the old "name" field's value of the Clan entity.
+// If the Clan object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *ClanMutation) OldName(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldName is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldName requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldName: %w", err)
+	}
+	return oldValue.Name, nil
+}
+
+// ResetName resets all changes to the "name" field.
+func (m *ClanMutation) ResetName() {
+	m.name = nil
+}
+
+// SetEmblemID sets the "emblem_id" field.
+func (m *ClanMutation) SetEmblemID(s string) {
+	m.emblem_id = &s
+}
+
+// EmblemID returns the value of the "emblem_id" field in the mutation.
+func (m *ClanMutation) EmblemID() (r string, exists bool) {
+	v := m.emblem_id
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldEmblemID returns the old "emblem_id" field's value of the Clan entity.
+// If the Clan object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *ClanMutation) OldEmblemID(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldEmblemID is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldEmblemID requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldEmblemID: %w", err)
+	}
+	return oldValue.EmblemID, nil
+}
+
+// ClearEmblemID clears the value of the "emblem_id" field.
+func (m *ClanMutation) ClearEmblemID() {
+	m.emblem_id = nil
+	m.clearedFields[clan.FieldEmblemID] = struct{}{}
+}
+
+// EmblemIDCleared returns if the "emblem_id" field was cleared in this mutation.
+func (m *ClanMutation) EmblemIDCleared() bool {
+	_, ok := m.clearedFields[clan.FieldEmblemID]
+	return ok
+}
+
+// ResetEmblemID resets all changes to the "emblem_id" field.
+func (m *ClanMutation) ResetEmblemID() {
+	m.emblem_id = nil
+	delete(m.clearedFields, clan.FieldEmblemID)
+}
+
+// SetMembers sets the "members" field.
+func (m *ClanMutation) SetMembers(s []string) {
+	m.members = &s
+	m.appendmembers = nil
+}
+
+// Members returns the value of the "members" field in the mutation.
+func (m *ClanMutation) Members() (r []string, exists bool) {
+	v := m.members
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldMembers returns the old "members" field's value of the Clan entity.
+// If the Clan object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *ClanMutation) OldMembers(ctx context.Context) (v []string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldMembers is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldMembers requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldMembers: %w", err)
+	}
+	return oldValue.Members, nil
+}
+
+// AppendMembers adds s to the "members" field.
+func (m *ClanMutation) AppendMembers(s []string) {
+	m.appendmembers = append(m.appendmembers, s...)
+}
+
+// AppendedMembers returns the list of values that were appended to the "members" field in this mutation.
+func (m *ClanMutation) AppendedMembers() ([]string, bool) {
+	if len(m.appendmembers) == 0 {
+		return nil, false
+	}
+	return m.appendmembers, true
+}
+
+// ResetMembers resets all changes to the "members" field.
+func (m *ClanMutation) ResetMembers() {
+	m.members = nil
+	m.appendmembers = nil
+}
+
+// AddAccountIDs adds the "accounts" edge to the Account entity by ids.
+func (m *ClanMutation) AddAccountIDs(ids ...string) {
+	if m.accounts == nil {
+		m.accounts = make(map[string]struct{})
+	}
+	for i := range ids {
+		m.accounts[ids[i]] = struct{}{}
+	}
+}
+
+// ClearAccounts clears the "accounts" edge to the Account entity.
+func (m *ClanMutation) ClearAccounts() {
+	m.clearedaccounts = true
+}
+
+// AccountsCleared reports if the "accounts" edge to the Account entity was cleared.
+func (m *ClanMutation) AccountsCleared() bool {
+	return m.clearedaccounts
+}
+
+// RemoveAccountIDs removes the "accounts" edge to the Account entity by IDs.
+func (m *ClanMutation) RemoveAccountIDs(ids ...string) {
+	if m.removedaccounts == nil {
+		m.removedaccounts = make(map[string]struct{})
+	}
+	for i := range ids {
+		delete(m.accounts, ids[i])
+		m.removedaccounts[ids[i]] = struct{}{}
+	}
+}
+
+// RemovedAccounts returns the removed IDs of the "accounts" edge to the Account entity.
+func (m *ClanMutation) RemovedAccountsIDs() (ids []string) {
+	for id := range m.removedaccounts {
+		ids = append(ids, id)
+	}
+	return
+}
+
+// AccountsIDs returns the "accounts" edge IDs in the mutation.
+func (m *ClanMutation) AccountsIDs() (ids []string) {
+	for id := range m.accounts {
+		ids = append(ids, id)
+	}
+	return
+}
+
+// ResetAccounts resets all changes to the "accounts" edge.
+func (m *ClanMutation) ResetAccounts() {
+	m.accounts = nil
+	m.clearedaccounts = false
+	m.removedaccounts = nil
+}
+
+// Where appends a list predicates to the ClanMutation builder.
+func (m *ClanMutation) Where(ps ...predicate.Clan) {
+	m.predicates = append(m.predicates, ps...)
+}
+
+// WhereP appends storage-level predicates to the ClanMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *ClanMutation) WhereP(ps ...func(*sql.Selector)) {
+	p := make([]predicate.Clan, len(ps))
+	for i := range ps {
+		p[i] = ps[i]
+	}
+	m.Where(p...)
+}
+
+// Op returns the operation name.
+func (m *ClanMutation) Op() Op {
+	return m.op
+}
+
+// SetOp allows setting the mutation operation.
+func (m *ClanMutation) SetOp(op Op) {
+	m.op = op
+}
+
+// Type returns the node type of this mutation (Clan).
+func (m *ClanMutation) Type() string {
+	return m.typ
+}
+
+// Fields returns all fields that were changed during this mutation. Note that in
+// order to get all numeric fields that were incremented/decremented, call
+// AddedFields().
+func (m *ClanMutation) Fields() []string {
+	fields := make([]string, 0, 6)
+	if m.created_at != nil {
+		fields = append(fields, clan.FieldCreatedAt)
+	}
+	if m.updated_at != nil {
+		fields = append(fields, clan.FieldUpdatedAt)
+	}
+	if m.tag != nil {
+		fields = append(fields, clan.FieldTag)
+	}
+	if m.name != nil {
+		fields = append(fields, clan.FieldName)
+	}
+	if m.emblem_id != nil {
+		fields = append(fields, clan.FieldEmblemID)
+	}
+	if m.members != nil {
+		fields = append(fields, clan.FieldMembers)
+	}
+	return fields
+}
+
+// Field returns the value of a field with the given name. The second boolean
+// return value indicates that this field was not set, or was not defined in the
+// schema.
+func (m *ClanMutation) Field(name string) (ent.Value, bool) {
+	switch name {
+	case clan.FieldCreatedAt:
+		return m.CreatedAt()
+	case clan.FieldUpdatedAt:
+		return m.UpdatedAt()
+	case clan.FieldTag:
+		return m.Tag()
+	case clan.FieldName:
+		return m.Name()
+	case clan.FieldEmblemID:
+		return m.EmblemID()
+	case clan.FieldMembers:
+		return m.Members()
+	}
+	return nil, false
+}
+
+// OldField returns the old value of the field from the database. An error is
+// returned if the mutation operation is not UpdateOne, or the query to the
+// database failed.
+func (m *ClanMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
+	switch name {
+	case clan.FieldCreatedAt:
+		return m.OldCreatedAt(ctx)
+	case clan.FieldUpdatedAt:
+		return m.OldUpdatedAt(ctx)
+	case clan.FieldTag:
+		return m.OldTag(ctx)
+	case clan.FieldName:
+		return m.OldName(ctx)
+	case clan.FieldEmblemID:
+		return m.OldEmblemID(ctx)
+	case clan.FieldMembers:
+		return m.OldMembers(ctx)
+	}
+	return nil, fmt.Errorf("unknown Clan field %s", name)
+}
+
+// SetField sets the value of a field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *ClanMutation) SetField(name string, value ent.Value) error {
+	switch name {
+	case clan.FieldCreatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetCreatedAt(v)
+		return nil
+	case clan.FieldUpdatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetUpdatedAt(v)
+		return nil
+	case clan.FieldTag:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetTag(v)
+		return nil
+	case clan.FieldName:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetName(v)
+		return nil
+	case clan.FieldEmblemID:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetEmblemID(v)
+		return nil
+	case clan.FieldMembers:
+		v, ok := value.([]string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetMembers(v)
+		return nil
+	}
+	return fmt.Errorf("unknown Clan field %s", name)
+}
+
+// AddedFields returns all numeric fields that were incremented/decremented during
+// this mutation.
+func (m *ClanMutation) AddedFields() []string {
+	var fields []string
+	if m.addcreated_at != nil {
+		fields = append(fields, clan.FieldCreatedAt)
+	}
+	if m.addupdated_at != nil {
+		fields = append(fields, clan.FieldUpdatedAt)
+	}
+	return fields
+}
+
+// AddedField returns the numeric value that was incremented/decremented on a field
+// with the given name. The second boolean return value indicates that this field
+// was not set, or was not defined in the schema.
+func (m *ClanMutation) AddedField(name string) (ent.Value, bool) {
+	switch name {
+	case clan.FieldCreatedAt:
+		return m.AddedCreatedAt()
+	case clan.FieldUpdatedAt:
+		return m.AddedUpdatedAt()
+	}
+	return nil, false
+}
+
+// AddField adds the value to the field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *ClanMutation) AddField(name string, value ent.Value) error {
+	switch name {
+	case clan.FieldCreatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddCreatedAt(v)
+		return nil
+	case clan.FieldUpdatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddUpdatedAt(v)
+		return nil
+	}
+	return fmt.Errorf("unknown Clan numeric field %s", name)
+}
+
+// ClearedFields returns all nullable fields that were cleared during this
+// mutation.
+func (m *ClanMutation) ClearedFields() []string {
+	var fields []string
+	if m.FieldCleared(clan.FieldEmblemID) {
+		fields = append(fields, clan.FieldEmblemID)
+	}
+	return fields
+}
+
+// FieldCleared returns a boolean indicating if a field with the given name was
+// cleared in this mutation.
+func (m *ClanMutation) FieldCleared(name string) bool {
+	_, ok := m.clearedFields[name]
+	return ok
+}
+
+// ClearField clears the value of the field with the given name. It returns an
+// error if the field is not defined in the schema.
+func (m *ClanMutation) ClearField(name string) error {
+	switch name {
+	case clan.FieldEmblemID:
+		m.ClearEmblemID()
+		return nil
+	}
+	return fmt.Errorf("unknown Clan nullable field %s", name)
+}
+
+// ResetField resets all changes in the mutation for the field with the given name.
+// It returns an error if the field is not defined in the schema.
+func (m *ClanMutation) ResetField(name string) error {
+	switch name {
+	case clan.FieldCreatedAt:
+		m.ResetCreatedAt()
+		return nil
+	case clan.FieldUpdatedAt:
+		m.ResetUpdatedAt()
+		return nil
+	case clan.FieldTag:
+		m.ResetTag()
+		return nil
+	case clan.FieldName:
+		m.ResetName()
+		return nil
+	case clan.FieldEmblemID:
+		m.ResetEmblemID()
+		return nil
+	case clan.FieldMembers:
+		m.ResetMembers()
+		return nil
+	}
+	return fmt.Errorf("unknown Clan field %s", name)
+}
+
+// AddedEdges returns all edge names that were set/added in this mutation.
+func (m *ClanMutation) AddedEdges() []string {
+	edges := make([]string, 0, 1)
+	if m.accounts != nil {
+		edges = append(edges, clan.EdgeAccounts)
+	}
+	return edges
+}
+
+// AddedIDs returns all IDs (to other nodes) that were added for the given edge
+// name in this mutation.
+func (m *ClanMutation) AddedIDs(name string) []ent.Value {
+	switch name {
+	case clan.EdgeAccounts:
+		ids := make([]ent.Value, 0, len(m.accounts))
+		for id := range m.accounts {
+			ids = append(ids, id)
+		}
+		return ids
+	}
+	return nil
+}
+
+// RemovedEdges returns all edge names that were removed in this mutation.
+func (m *ClanMutation) RemovedEdges() []string {
+	edges := make([]string, 0, 1)
+	if m.removedaccounts != nil {
+		edges = append(edges, clan.EdgeAccounts)
+	}
+	return edges
+}
+
+// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
+// the given name in this mutation.
+func (m *ClanMutation) RemovedIDs(name string) []ent.Value {
+	switch name {
+	case clan.EdgeAccounts:
+		ids := make([]ent.Value, 0, len(m.removedaccounts))
+		for id := range m.removedaccounts {
+			ids = append(ids, id)
+		}
+		return ids
+	}
+	return nil
+}
+
+// ClearedEdges returns all edge names that were cleared in this mutation.
+func (m *ClanMutation) ClearedEdges() []string {
+	edges := make([]string, 0, 1)
+	if m.clearedaccounts {
+		edges = append(edges, clan.EdgeAccounts)
+	}
+	return edges
+}
+
+// EdgeCleared returns a boolean which indicates if the edge with the given name
+// was cleared in this mutation.
+func (m *ClanMutation) EdgeCleared(name string) bool {
+	switch name {
+	case clan.EdgeAccounts:
+		return m.clearedaccounts
+	}
+	return false
+}
+
+// ClearEdge clears the value of the edge with the given name. It returns an error
+// if that edge is not defined in the schema.
+func (m *ClanMutation) ClearEdge(name string) error {
+	switch name {
+	}
+	return fmt.Errorf("unknown Clan unique edge %s", name)
+}
+
+// ResetEdge resets all changes to the edge with the given name in this mutation.
+// It returns an error if the edge is not defined in the schema.
+func (m *ClanMutation) ResetEdge(name string) error {
+	switch name {
+	case clan.EdgeAccounts:
+		m.ResetAccounts()
+		return nil
+	}
+	return fmt.Errorf("unknown Clan edge %s", name)
+}
+
+// CronTaskMutation represents an operation that mutates the CronTask nodes in the graph.
+type CronTaskMutation struct {
+	config
+	op                 Op
+	typ                string
+	id                 *string
+	created_at         *int
+	addcreated_at      *int
+	updated_at         *int
+	addupdated_at      *int
+	_type              *string
+	reference_id       *string
+	targets            *[]string
+	appendtargets      []string
+	status             *string
+	scheduled_after    *int
+	addscheduled_after *int
+	last_run           *int
+	addlast_run        *int
+	logs               *[]models.TaskLog
+	appendlogs         []models.TaskLog
+	data               *map[string]interface{}
+	clearedFields      map[string]struct{}
+	done               bool
+	oldValue           func(context.Context) (*CronTask, error)
+	predicates         []predicate.CronTask
+}
+
+var _ ent.Mutation = (*CronTaskMutation)(nil)
+
+// crontaskOption allows management of the mutation configuration using functional options.
+type crontaskOption func(*CronTaskMutation)
+
+// newCronTaskMutation creates new mutation for the CronTask entity.
+func newCronTaskMutation(c config, op Op, opts ...crontaskOption) *CronTaskMutation {
+	m := &CronTaskMutation{
+		config:        c,
+		op:            op,
+		typ:           TypeCronTask,
+		clearedFields: make(map[string]struct{}),
+	}
+	for _, opt := range opts {
+		opt(m)
+	}
+	return m
+}
+
+// withCronTaskID sets the ID field of the mutation.
+func withCronTaskID(id string) crontaskOption {
+	return func(m *CronTaskMutation) {
+		var (
+			err   error
+			once  sync.Once
+			value *CronTask
+		)
+		m.oldValue = func(ctx context.Context) (*CronTask, error) {
+			once.Do(func() {
+				if m.done {
+					err = errors.New("querying old values post mutation is not allowed")
+				} else {
+					value, err = m.Client().CronTask.Get(ctx, id)
+				}
+			})
+			return value, err
+		}
+		m.id = &id
+	}
+}
+
+// withCronTask sets the old CronTask of the mutation.
+func withCronTask(node *CronTask) crontaskOption {
+	return func(m *CronTaskMutation) {
+		m.oldValue = func(context.Context) (*CronTask, error) {
+			return node, nil
+		}
+		m.id = &node.ID
+	}
+}
+
+// Client returns a new `ent.Client` from the mutation. If the mutation was
+// executed in a transaction (ent.Tx), a transactional client is returned.
+func (m CronTaskMutation) Client() *Client {
+	client := &Client{config: m.config}
+	client.init()
+	return client
+}
+
+// Tx returns an `ent.Tx` for mutations that were executed in transactions;
+// it returns an error otherwise.
+func (m CronTaskMutation) Tx() (*Tx, error) {
+	if _, ok := m.driver.(*txDriver); !ok {
+		return nil, errors.New("db: mutation is not running in a transaction")
+	}
+	tx := &Tx{config: m.config}
+	tx.init()
+	return tx, nil
+}
+
+// SetID sets the value of the id field. Note that this
+// operation is only accepted on creation of CronTask entities.
+func (m *CronTaskMutation) SetID(id string) {
+	m.id = &id
+}
+
+// ID returns the ID value in the mutation. Note that the ID is only available
+// if it was provided to the builder or after it was returned from the database.
+func (m *CronTaskMutation) ID() (id string, exists bool) {
+	if m.id == nil {
+		return
+	}
+	return *m.id, true
+}
+
+// IDs queries the database and returns the entity ids that match the mutation's predicate.
+// That means, if the mutation is applied within a transaction with an isolation level such
+// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
+// or updated by the mutation.
+func (m *CronTaskMutation) IDs(ctx context.Context) ([]string, error) {
+	switch {
+	case m.op.Is(OpUpdateOne | OpDeleteOne):
+		id, exists := m.ID()
+		if exists {
+			return []string{id}, nil
+		}
+		fallthrough
+	case m.op.Is(OpUpdate | OpDelete):
+		return m.Client().CronTask.Query().Where(m.predicates...).IDs(ctx)
+	default:
+		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
+	}
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (m *CronTaskMutation) SetCreatedAt(i int) {
+	m.created_at = &i
+	m.addcreated_at = nil
+}
+
+// CreatedAt returns the value of the "created_at" field in the mutation.
+func (m *CronTaskMutation) CreatedAt() (r int, exists bool) {
+	v := m.created_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldCreatedAt returns the old "created_at" field's value of the CronTask entity.
+// If the CronTask object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *CronTaskMutation) OldCreatedAt(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldCreatedAt requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
+	}
+	return oldValue.CreatedAt, nil
+}
+
+// AddCreatedAt adds i to the "created_at" field.
+func (m *CronTaskMutation) AddCreatedAt(i int) {
+	if m.addcreated_at != nil {
+		*m.addcreated_at += i
+	} else {
+		m.addcreated_at = &i
+	}
+}
+
+// AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
+func (m *CronTaskMutation) AddedCreatedAt() (r int, exists bool) {
+	v := m.addcreated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetCreatedAt resets all changes to the "created_at" field.
+func (m *CronTaskMutation) ResetCreatedAt() {
+	m.created_at = nil
+	m.addcreated_at = nil
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (m *CronTaskMutation) SetUpdatedAt(i int) {
+	m.updated_at = &i
+	m.addupdated_at = nil
+}
+
+// UpdatedAt returns the value of the "updated_at" field in the mutation.
+func (m *CronTaskMutation) UpdatedAt() (r int, exists bool) {
+	v := m.updated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldUpdatedAt returns the old "updated_at" field's value of the CronTask entity.
+// If the CronTask object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *CronTaskMutation) OldUpdatedAt(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
+	}
+	return oldValue.UpdatedAt, nil
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (m *CronTaskMutation) AddUpdatedAt(i int) {
+	if m.addupdated_at != nil {
+		*m.addupdated_at += i
+	} else {
+		m.addupdated_at = &i
+	}
+}
+
+// AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
+func (m *CronTaskMutation) AddedUpdatedAt() (r int, exists bool) {
+	v := m.addupdated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetUpdatedAt resets all changes to the "updated_at" field.
+func (m *CronTaskMutation) ResetUpdatedAt() {
+	m.updated_at = nil
+	m.addupdated_at = nil
+}
+
+// SetType sets the "type" field.
+func (m *CronTaskMutation) SetType(s string) {
+	m._type = &s
+}
+
+// GetType returns the value of the "type" field in the mutation.
+func (m *CronTaskMutation) GetType() (r string, exists bool) {
+	v := m._type
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldType returns the old "type" field's value of the CronTask entity.
+// If the CronTask object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *CronTaskMutation) OldType(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldType is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldType requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldType: %w", err)
+	}
+	return oldValue.Type, nil
+}
+
+// ResetType resets all changes to the "type" field.
+func (m *CronTaskMutation) ResetType() {
+	m._type = nil
+}
+
+// SetReferenceID sets the "reference_id" field.
+func (m *CronTaskMutation) SetReferenceID(s string) {
+	m.reference_id = &s
+}
+
+// ReferenceID returns the value of the "reference_id" field in the mutation.
+func (m *CronTaskMutation) ReferenceID() (r string, exists bool) {
+	v := m.reference_id
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldReferenceID returns the old "reference_id" field's value of the CronTask entity.
+// If the CronTask object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *CronTaskMutation) OldReferenceID(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldReferenceID is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldReferenceID requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldReferenceID: %w", err)
+	}
+	return oldValue.ReferenceID, nil
+}
+
+// ResetReferenceID resets all changes to the "reference_id" field.
+func (m *CronTaskMutation) ResetReferenceID() {
+	m.reference_id = nil
+}
+
+// SetTargets sets the "targets" field.
+func (m *CronTaskMutation) SetTargets(s []string) {
+	m.targets = &s
+	m.appendtargets = nil
+}
+
+// Targets returns the value of the "targets" field in the mutation.
+func (m *CronTaskMutation) Targets() (r []string, exists bool) {
+	v := m.targets
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldTargets returns the old "targets" field's value of the CronTask entity.
+// If the CronTask object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *CronTaskMutation) OldTargets(ctx context.Context) (v []string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldTargets is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldTargets requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldTargets: %w", err)
+	}
+	return oldValue.Targets, nil
+}
+
+// AppendTargets adds s to the "targets" field.
+func (m *CronTaskMutation) AppendTargets(s []string) {
+	m.appendtargets = append(m.appendtargets, s...)
+}
+
+// AppendedTargets returns the list of values that were appended to the "targets" field in this mutation.
+func (m *CronTaskMutation) AppendedTargets() ([]string, bool) {
+	if len(m.appendtargets) == 0 {
+		return nil, false
+	}
+	return m.appendtargets, true
+}
+
+// ResetTargets resets all changes to the "targets" field.
+func (m *CronTaskMutation) ResetTargets() {
+	m.targets = nil
+	m.appendtargets = nil
+}
+
+// SetStatus sets the "status" field.
+func (m *CronTaskMutation) SetStatus(s string) {
+	m.status = &s
+}
+
+// Status returns the value of the "status" field in the mutation.
+func (m *CronTaskMutation) Status() (r string, exists bool) {
+	v := m.status
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldStatus returns the old "status" field's value of the CronTask entity.
+// If the CronTask object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *CronTaskMutation) OldStatus(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldStatus is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldStatus requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldStatus: %w", err)
+	}
+	return oldValue.Status, nil
+}
+
+// ResetStatus resets all changes to the "status" field.
+func (m *CronTaskMutation) ResetStatus() {
+	m.status = nil
+}
+
+// SetScheduledAfter sets the "scheduled_after" field.
+func (m *CronTaskMutation) SetScheduledAfter(i int) {
+	m.scheduled_after = &i
+	m.addscheduled_after = nil
+}
+
+// ScheduledAfter returns the value of the "scheduled_after" field in the mutation.
+func (m *CronTaskMutation) ScheduledAfter() (r int, exists bool) {
+	v := m.scheduled_after
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldScheduledAfter returns the old "scheduled_after" field's value of the CronTask entity.
+// If the CronTask object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *CronTaskMutation) OldScheduledAfter(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldScheduledAfter is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldScheduledAfter requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldScheduledAfter: %w", err)
+	}
+	return oldValue.ScheduledAfter, nil
+}
+
+// AddScheduledAfter adds i to the "scheduled_after" field.
+func (m *CronTaskMutation) AddScheduledAfter(i int) {
+	if m.addscheduled_after != nil {
+		*m.addscheduled_after += i
+	} else {
+		m.addscheduled_after = &i
+	}
+}
+
+// AddedScheduledAfter returns the value that was added to the "scheduled_after" field in this mutation.
+func (m *CronTaskMutation) AddedScheduledAfter() (r int, exists bool) {
+	v := m.addscheduled_after
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetScheduledAfter resets all changes to the "scheduled_after" field.
+func (m *CronTaskMutation) ResetScheduledAfter() {
+	m.scheduled_after = nil
+	m.addscheduled_after = nil
+}
+
+// SetLastRun sets the "last_run" field.
+func (m *CronTaskMutation) SetLastRun(i int) {
+	m.last_run = &i
+	m.addlast_run = nil
+}
+
+// LastRun returns the value of the "last_run" field in the mutation.
+func (m *CronTaskMutation) LastRun() (r int, exists bool) {
+	v := m.last_run
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldLastRun returns the old "last_run" field's value of the CronTask entity.
+// If the CronTask object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *CronTaskMutation) OldLastRun(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldLastRun is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldLastRun requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldLastRun: %w", err)
+	}
+	return oldValue.LastRun, nil
+}
+
+// AddLastRun adds i to the "last_run" field.
+func (m *CronTaskMutation) AddLastRun(i int) {
+	if m.addlast_run != nil {
+		*m.addlast_run += i
+	} else {
+		m.addlast_run = &i
+	}
+}
+
+// AddedLastRun returns the value that was added to the "last_run" field in this mutation.
+func (m *CronTaskMutation) AddedLastRun() (r int, exists bool) {
+	v := m.addlast_run
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetLastRun resets all changes to the "last_run" field.
+func (m *CronTaskMutation) ResetLastRun() {
+	m.last_run = nil
+	m.addlast_run = nil
+}
+
+// SetLogs sets the "logs" field.
+func (m *CronTaskMutation) SetLogs(ml []models.TaskLog) {
+	m.logs = &ml
+	m.appendlogs = nil
+}
+
+// Logs returns the value of the "logs" field in the mutation.
+func (m *CronTaskMutation) Logs() (r []models.TaskLog, exists bool) {
+	v := m.logs
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldLogs returns the old "logs" field's value of the CronTask entity.
+// If the CronTask object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *CronTaskMutation) OldLogs(ctx context.Context) (v []models.TaskLog, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldLogs is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldLogs requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldLogs: %w", err)
+	}
+	return oldValue.Logs, nil
+}
+
+// AppendLogs adds ml to the "logs" field.
+func (m *CronTaskMutation) AppendLogs(ml []models.TaskLog) {
+	m.appendlogs = append(m.appendlogs, ml...)
+}
+
+// AppendedLogs returns the list of values that were appended to the "logs" field in this mutation.
+func (m *CronTaskMutation) AppendedLogs() ([]models.TaskLog, bool) {
+	if len(m.appendlogs) == 0 {
+		return nil, false
+	}
+	return m.appendlogs, true
+}
+
+// ResetLogs resets all changes to the "logs" field.
+func (m *CronTaskMutation) ResetLogs() {
+	m.logs = nil
+	m.appendlogs = nil
+}
+
+// SetData sets the "data" field.
+func (m *CronTaskMutation) SetData(value map[string]interface{}) {
+	m.data = &value
+}
+
+// Data returns the value of the "data" field in the mutation.
+func (m *CronTaskMutation) Data() (r map[string]interface{}, exists bool) {
+	v := m.data
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldData returns the old "data" field's value of the CronTask entity.
+// If the CronTask object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *CronTaskMutation) OldData(ctx context.Context) (v map[string]interface{}, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldData is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldData requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldData: %w", err)
+	}
+	return oldValue.Data, nil
+}
+
+// ResetData resets all changes to the "data" field.
+func (m *CronTaskMutation) ResetData() {
+	m.data = nil
+}
+
+// Where appends a list predicates to the CronTaskMutation builder.
+func (m *CronTaskMutation) Where(ps ...predicate.CronTask) {
+	m.predicates = append(m.predicates, ps...)
+}
+
+// WhereP appends storage-level predicates to the CronTaskMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *CronTaskMutation) WhereP(ps ...func(*sql.Selector)) {
+	p := make([]predicate.CronTask, len(ps))
+	for i := range ps {
+		p[i] = ps[i]
+	}
+	m.Where(p...)
+}
+
+// Op returns the operation name.
+func (m *CronTaskMutation) Op() Op {
+	return m.op
+}
+
+// SetOp allows setting the mutation operation.
+func (m *CronTaskMutation) SetOp(op Op) {
+	m.op = op
+}
+
+// Type returns the node type of this mutation (CronTask).
+func (m *CronTaskMutation) Type() string {
+	return m.typ
+}
+
+// Fields returns all fields that were changed during this mutation. Note that in
+// order to get all numeric fields that were incremented/decremented, call
+// AddedFields().
+func (m *CronTaskMutation) Fields() []string {
+	fields := make([]string, 0, 10)
+	if m.created_at != nil {
+		fields = append(fields, crontask.FieldCreatedAt)
+	}
+	if m.updated_at != nil {
+		fields = append(fields, crontask.FieldUpdatedAt)
+	}
+	if m._type != nil {
+		fields = append(fields, crontask.FieldType)
+	}
+	if m.reference_id != nil {
+		fields = append(fields, crontask.FieldReferenceID)
+	}
+	if m.targets != nil {
+		fields = append(fields, crontask.FieldTargets)
+	}
+	if m.status != nil {
+		fields = append(fields, crontask.FieldStatus)
+	}
+	if m.scheduled_after != nil {
+		fields = append(fields, crontask.FieldScheduledAfter)
+	}
+	if m.last_run != nil {
+		fields = append(fields, crontask.FieldLastRun)
+	}
+	if m.logs != nil {
+		fields = append(fields, crontask.FieldLogs)
+	}
+	if m.data != nil {
+		fields = append(fields, crontask.FieldData)
+	}
+	return fields
+}
+
+// Field returns the value of a field with the given name. The second boolean
+// return value indicates that this field was not set, or was not defined in the
+// schema.
+func (m *CronTaskMutation) Field(name string) (ent.Value, bool) {
+	switch name {
+	case crontask.FieldCreatedAt:
+		return m.CreatedAt()
+	case crontask.FieldUpdatedAt:
+		return m.UpdatedAt()
+	case crontask.FieldType:
+		return m.GetType()
+	case crontask.FieldReferenceID:
+		return m.ReferenceID()
+	case crontask.FieldTargets:
+		return m.Targets()
+	case crontask.FieldStatus:
+		return m.Status()
+	case crontask.FieldScheduledAfter:
+		return m.ScheduledAfter()
+	case crontask.FieldLastRun:
+		return m.LastRun()
+	case crontask.FieldLogs:
+		return m.Logs()
+	case crontask.FieldData:
+		return m.Data()
+	}
+	return nil, false
+}
+
+// OldField returns the old value of the field from the database. An error is
+// returned if the mutation operation is not UpdateOne, or the query to the
+// database failed.
+func (m *CronTaskMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
+	switch name {
+	case crontask.FieldCreatedAt:
+		return m.OldCreatedAt(ctx)
+	case crontask.FieldUpdatedAt:
+		return m.OldUpdatedAt(ctx)
+	case crontask.FieldType:
+		return m.OldType(ctx)
+	case crontask.FieldReferenceID:
+		return m.OldReferenceID(ctx)
+	case crontask.FieldTargets:
+		return m.OldTargets(ctx)
+	case crontask.FieldStatus:
+		return m.OldStatus(ctx)
+	case crontask.FieldScheduledAfter:
+		return m.OldScheduledAfter(ctx)
+	case crontask.FieldLastRun:
+		return m.OldLastRun(ctx)
+	case crontask.FieldLogs:
+		return m.OldLogs(ctx)
+	case crontask.FieldData:
+		return m.OldData(ctx)
+	}
+	return nil, fmt.Errorf("unknown CronTask field %s", name)
+}
+
+// SetField sets the value of a field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *CronTaskMutation) SetField(name string, value ent.Value) error {
+	switch name {
+	case crontask.FieldCreatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetCreatedAt(v)
+		return nil
+	case crontask.FieldUpdatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetUpdatedAt(v)
+		return nil
+	case crontask.FieldType:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetType(v)
+		return nil
+	case crontask.FieldReferenceID:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetReferenceID(v)
+		return nil
+	case crontask.FieldTargets:
+		v, ok := value.([]string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetTargets(v)
+		return nil
+	case crontask.FieldStatus:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetStatus(v)
+		return nil
+	case crontask.FieldScheduledAfter:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetScheduledAfter(v)
+		return nil
+	case crontask.FieldLastRun:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetLastRun(v)
+		return nil
+	case crontask.FieldLogs:
+		v, ok := value.([]models.TaskLog)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetLogs(v)
+		return nil
+	case crontask.FieldData:
+		v, ok := value.(map[string]interface{})
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetData(v)
+		return nil
+	}
+	return fmt.Errorf("unknown CronTask field %s", name)
+}
+
+// AddedFields returns all numeric fields that were incremented/decremented during
+// this mutation.
+func (m *CronTaskMutation) AddedFields() []string {
+	var fields []string
+	if m.addcreated_at != nil {
+		fields = append(fields, crontask.FieldCreatedAt)
+	}
+	if m.addupdated_at != nil {
+		fields = append(fields, crontask.FieldUpdatedAt)
+	}
+	if m.addscheduled_after != nil {
+		fields = append(fields, crontask.FieldScheduledAfter)
+	}
+	if m.addlast_run != nil {
+		fields = append(fields, crontask.FieldLastRun)
+	}
+	return fields
+}
+
+// AddedField returns the numeric value that was incremented/decremented on a field
+// with the given name. The second boolean return value indicates that this field
+// was not set, or was not defined in the schema.
+func (m *CronTaskMutation) AddedField(name string) (ent.Value, bool) {
+	switch name {
+	case crontask.FieldCreatedAt:
+		return m.AddedCreatedAt()
+	case crontask.FieldUpdatedAt:
+		return m.AddedUpdatedAt()
+	case crontask.FieldScheduledAfter:
+		return m.AddedScheduledAfter()
+	case crontask.FieldLastRun:
+		return m.AddedLastRun()
+	}
+	return nil, false
+}
+
+// AddField adds the value to the field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *CronTaskMutation) AddField(name string, value ent.Value) error {
+	switch name {
+	case crontask.FieldCreatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddCreatedAt(v)
+		return nil
+	case crontask.FieldUpdatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddUpdatedAt(v)
+		return nil
+	case crontask.FieldScheduledAfter:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddScheduledAfter(v)
+		return nil
+	case crontask.FieldLastRun:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddLastRun(v)
+		return nil
+	}
+	return fmt.Errorf("unknown CronTask numeric field %s", name)
+}
+
+// ClearedFields returns all nullable fields that were cleared during this
+// mutation.
+func (m *CronTaskMutation) ClearedFields() []string {
+	return nil
+}
+
+// FieldCleared returns a boolean indicating if a field with the given name was
+// cleared in this mutation.
+func (m *CronTaskMutation) FieldCleared(name string) bool {
+	_, ok := m.clearedFields[name]
+	return ok
+}
+
+// ClearField clears the value of the field with the given name. It returns an
+// error if the field is not defined in the schema.
+func (m *CronTaskMutation) ClearField(name string) error {
+	return fmt.Errorf("unknown CronTask nullable field %s", name)
+}
+
+// ResetField resets all changes in the mutation for the field with the given name.
+// It returns an error if the field is not defined in the schema.
+func (m *CronTaskMutation) ResetField(name string) error {
+	switch name {
+	case crontask.FieldCreatedAt:
+		m.ResetCreatedAt()
+		return nil
+	case crontask.FieldUpdatedAt:
+		m.ResetUpdatedAt()
+		return nil
+	case crontask.FieldType:
+		m.ResetType()
+		return nil
+	case crontask.FieldReferenceID:
+		m.ResetReferenceID()
+		return nil
+	case crontask.FieldTargets:
+		m.ResetTargets()
+		return nil
+	case crontask.FieldStatus:
+		m.ResetStatus()
+		return nil
+	case crontask.FieldScheduledAfter:
+		m.ResetScheduledAfter()
+		return nil
+	case crontask.FieldLastRun:
+		m.ResetLastRun()
+		return nil
+	case crontask.FieldLogs:
+		m.ResetLogs()
+		return nil
+	case crontask.FieldData:
+		m.ResetData()
+		return nil
+	}
+	return fmt.Errorf("unknown CronTask field %s", name)
+}
+
+// AddedEdges returns all edge names that were set/added in this mutation.
+func (m *CronTaskMutation) AddedEdges() []string {
+	edges := make([]string, 0, 0)
+	return edges
+}
+
+// AddedIDs returns all IDs (to other nodes) that were added for the given edge
+// name in this mutation.
+func (m *CronTaskMutation) AddedIDs(name string) []ent.Value {
+	return nil
+}
+
+// RemovedEdges returns all edge names that were removed in this mutation.
+func (m *CronTaskMutation) RemovedEdges() []string {
+	edges := make([]string, 0, 0)
+	return edges
+}
+
+// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
+// the given name in this mutation.
+func (m *CronTaskMutation) RemovedIDs(name string) []ent.Value {
+	return nil
+}
+
+// ClearedEdges returns all edge names that were cleared in this mutation.
+func (m *CronTaskMutation) ClearedEdges() []string {
+	edges := make([]string, 0, 0)
+	return edges
+}
+
+// EdgeCleared returns a boolean which indicates if the edge with the given name
+// was cleared in this mutation.
+func (m *CronTaskMutation) EdgeCleared(name string) bool {
+	return false
+}
+
+// ClearEdge clears the value of the edge with the given name. It returns an error
+// if that edge is not defined in the schema.
+func (m *CronTaskMutation) ClearEdge(name string) error {
+	return fmt.Errorf("unknown CronTask unique edge %s", name)
+}
+
+// ResetEdge resets all changes to the edge with the given name in this mutation.
+// It returns an error if the edge is not defined in the schema.
+func (m *CronTaskMutation) ResetEdge(name string) error {
+	return fmt.Errorf("unknown CronTask edge %s", name)
+}
+
+// UserMutation represents an operation that mutates the User nodes in the graph.
+type UserMutation struct {
+	config
+	op                   Op
+	typ                  string
+	id                   *string
+	created_at           *int
+	addcreated_at        *int
+	updated_at           *int
+	addupdated_at        *int
+	permissions          *string
+	feature_flags        *[]string
+	appendfeature_flags  []string
+	clearedFields        map[string]struct{}
+	subscriptions        map[string]struct{}
+	removedsubscriptions map[string]struct{}
+	clearedsubscriptions bool
+	connections          map[string]struct{}
+	removedconnections   map[string]struct{}
+	clearedconnections   bool
+	content              map[string]struct{}
+	removedcontent       map[string]struct{}
+	clearedcontent       bool
+	done                 bool
+	oldValue             func(context.Context) (*User, error)
+	predicates           []predicate.User
+}
+
+var _ ent.Mutation = (*UserMutation)(nil)
+
+// userOption allows management of the mutation configuration using functional options.
+type userOption func(*UserMutation)
+
+// newUserMutation creates new mutation for the User entity.
+func newUserMutation(c config, op Op, opts ...userOption) *UserMutation {
+	m := &UserMutation{
+		config:        c,
+		op:            op,
+		typ:           TypeUser,
+		clearedFields: make(map[string]struct{}),
+	}
+	for _, opt := range opts {
+		opt(m)
+	}
+	return m
+}
+
+// withUserID sets the ID field of the mutation.
+func withUserID(id string) userOption {
+	return func(m *UserMutation) {
+		var (
+			err   error
+			once  sync.Once
+			value *User
+		)
+		m.oldValue = func(ctx context.Context) (*User, error) {
+			once.Do(func() {
+				if m.done {
+					err = errors.New("querying old values post mutation is not allowed")
+				} else {
+					value, err = m.Client().User.Get(ctx, id)
+				}
+			})
+			return value, err
+		}
+		m.id = &id
+	}
+}
+
+// withUser sets the old User of the mutation.
+func withUser(node *User) userOption {
+	return func(m *UserMutation) {
+		m.oldValue = func(context.Context) (*User, error) {
+			return node, nil
+		}
+		m.id = &node.ID
+	}
+}
+
+// Client returns a new `ent.Client` from the mutation. If the mutation was
+// executed in a transaction (ent.Tx), a transactional client is returned.
+func (m UserMutation) Client() *Client {
+	client := &Client{config: m.config}
+	client.init()
+	return client
+}
+
+// Tx returns an `ent.Tx` for mutations that were executed in transactions;
+// it returns an error otherwise.
+func (m UserMutation) Tx() (*Tx, error) {
+	if _, ok := m.driver.(*txDriver); !ok {
+		return nil, errors.New("db: mutation is not running in a transaction")
+	}
+	tx := &Tx{config: m.config}
+	tx.init()
+	return tx, nil
+}
+
+// SetID sets the value of the id field. Note that this
+// operation is only accepted on creation of User entities.
+func (m *UserMutation) SetID(id string) {
+	m.id = &id
+}
+
+// ID returns the ID value in the mutation. Note that the ID is only available
+// if it was provided to the builder or after it was returned from the database.
+func (m *UserMutation) ID() (id string, exists bool) {
+	if m.id == nil {
+		return
+	}
+	return *m.id, true
+}
+
+// IDs queries the database and returns the entity ids that match the mutation's predicate.
+// That means, if the mutation is applied within a transaction with an isolation level such
+// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
+// or updated by the mutation.
+func (m *UserMutation) IDs(ctx context.Context) ([]string, error) {
+	switch {
+	case m.op.Is(OpUpdateOne | OpDeleteOne):
+		id, exists := m.ID()
+		if exists {
+			return []string{id}, nil
+		}
+		fallthrough
+	case m.op.Is(OpUpdate | OpDelete):
+		return m.Client().User.Query().Where(m.predicates...).IDs(ctx)
+	default:
+		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
+	}
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (m *UserMutation) SetCreatedAt(i int) {
+	m.created_at = &i
+	m.addcreated_at = nil
+}
+
+// CreatedAt returns the value of the "created_at" field in the mutation.
+func (m *UserMutation) CreatedAt() (r int, exists bool) {
+	v := m.created_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldCreatedAt returns the old "created_at" field's value of the User entity.
+// If the User object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserMutation) OldCreatedAt(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldCreatedAt requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
+	}
+	return oldValue.CreatedAt, nil
+}
+
+// AddCreatedAt adds i to the "created_at" field.
+func (m *UserMutation) AddCreatedAt(i int) {
+	if m.addcreated_at != nil {
+		*m.addcreated_at += i
+	} else {
+		m.addcreated_at = &i
+	}
+}
+
+// AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
+func (m *UserMutation) AddedCreatedAt() (r int, exists bool) {
+	v := m.addcreated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetCreatedAt resets all changes to the "created_at" field.
+func (m *UserMutation) ResetCreatedAt() {
+	m.created_at = nil
+	m.addcreated_at = nil
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (m *UserMutation) SetUpdatedAt(i int) {
+	m.updated_at = &i
+	m.addupdated_at = nil
+}
+
+// UpdatedAt returns the value of the "updated_at" field in the mutation.
+func (m *UserMutation) UpdatedAt() (r int, exists bool) {
+	v := m.updated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldUpdatedAt returns the old "updated_at" field's value of the User entity.
+// If the User object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserMutation) OldUpdatedAt(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
+	}
+	return oldValue.UpdatedAt, nil
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (m *UserMutation) AddUpdatedAt(i int) {
+	if m.addupdated_at != nil {
+		*m.addupdated_at += i
+	} else {
+		m.addupdated_at = &i
+	}
+}
+
+// AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
+func (m *UserMutation) AddedUpdatedAt() (r int, exists bool) {
+	v := m.addupdated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetUpdatedAt resets all changes to the "updated_at" field.
+func (m *UserMutation) ResetUpdatedAt() {
+	m.updated_at = nil
+	m.addupdated_at = nil
+}
+
+// SetPermissions sets the "permissions" field.
+func (m *UserMutation) SetPermissions(s string) {
+	m.permissions = &s
+}
+
+// Permissions returns the value of the "permissions" field in the mutation.
+func (m *UserMutation) Permissions() (r string, exists bool) {
+	v := m.permissions
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldPermissions returns the old "permissions" field's value of the User entity.
+// If the User object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserMutation) OldPermissions(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldPermissions is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldPermissions requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldPermissions: %w", err)
+	}
+	return oldValue.Permissions, nil
+}
+
+// ResetPermissions resets all changes to the "permissions" field.
+func (m *UserMutation) ResetPermissions() {
+	m.permissions = nil
+}
+
+// SetFeatureFlags sets the "feature_flags" field.
+func (m *UserMutation) SetFeatureFlags(s []string) {
+	m.feature_flags = &s
+	m.appendfeature_flags = nil
+}
+
+// FeatureFlags returns the value of the "feature_flags" field in the mutation.
+func (m *UserMutation) FeatureFlags() (r []string, exists bool) {
+	v := m.feature_flags
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldFeatureFlags returns the old "feature_flags" field's value of the User entity.
+// If the User object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserMutation) OldFeatureFlags(ctx context.Context) (v []string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldFeatureFlags is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldFeatureFlags requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldFeatureFlags: %w", err)
+	}
+	return oldValue.FeatureFlags, nil
+}
+
+// AppendFeatureFlags adds s to the "feature_flags" field.
+func (m *UserMutation) AppendFeatureFlags(s []string) {
+	m.appendfeature_flags = append(m.appendfeature_flags, s...)
+}
+
+// AppendedFeatureFlags returns the list of values that were appended to the "feature_flags" field in this mutation.
+func (m *UserMutation) AppendedFeatureFlags() ([]string, bool) {
+	if len(m.appendfeature_flags) == 0 {
+		return nil, false
+	}
+	return m.appendfeature_flags, true
+}
+
+// ClearFeatureFlags clears the value of the "feature_flags" field.
+func (m *UserMutation) ClearFeatureFlags() {
+	m.feature_flags = nil
+	m.appendfeature_flags = nil
+	m.clearedFields[user.FieldFeatureFlags] = struct{}{}
+}
+
+// FeatureFlagsCleared returns if the "feature_flags" field was cleared in this mutation.
+func (m *UserMutation) FeatureFlagsCleared() bool {
+	_, ok := m.clearedFields[user.FieldFeatureFlags]
+	return ok
+}
+
+// ResetFeatureFlags resets all changes to the "feature_flags" field.
+func (m *UserMutation) ResetFeatureFlags() {
+	m.feature_flags = nil
+	m.appendfeature_flags = nil
+	delete(m.clearedFields, user.FieldFeatureFlags)
+}
+
+// AddSubscriptionIDs adds the "subscriptions" edge to the UserSubscription entity by ids.
+func (m *UserMutation) AddSubscriptionIDs(ids ...string) {
+	if m.subscriptions == nil {
+		m.subscriptions = make(map[string]struct{})
+	}
+	for i := range ids {
+		m.subscriptions[ids[i]] = struct{}{}
+	}
+}
+
+// ClearSubscriptions clears the "subscriptions" edge to the UserSubscription entity.
+func (m *UserMutation) ClearSubscriptions() {
+	m.clearedsubscriptions = true
+}
+
+// SubscriptionsCleared reports if the "subscriptions" edge to the UserSubscription entity was cleared.
+func (m *UserMutation) SubscriptionsCleared() bool {
+	return m.clearedsubscriptions
+}
+
+// RemoveSubscriptionIDs removes the "subscriptions" edge to the UserSubscription entity by IDs.
+func (m *UserMutation) RemoveSubscriptionIDs(ids ...string) {
+	if m.removedsubscriptions == nil {
+		m.removedsubscriptions = make(map[string]struct{})
+	}
+	for i := range ids {
+		delete(m.subscriptions, ids[i])
+		m.removedsubscriptions[ids[i]] = struct{}{}
+	}
+}
+
+// RemovedSubscriptions returns the removed IDs of the "subscriptions" edge to the UserSubscription entity.
+func (m *UserMutation) RemovedSubscriptionsIDs() (ids []string) {
+	for id := range m.removedsubscriptions {
+		ids = append(ids, id)
+	}
+	return
+}
+
+// SubscriptionsIDs returns the "subscriptions" edge IDs in the mutation.
+func (m *UserMutation) SubscriptionsIDs() (ids []string) {
+	for id := range m.subscriptions {
+		ids = append(ids, id)
+	}
+	return
+}
+
+// ResetSubscriptions resets all changes to the "subscriptions" edge.
+func (m *UserMutation) ResetSubscriptions() {
+	m.subscriptions = nil
+	m.clearedsubscriptions = false
+	m.removedsubscriptions = nil
+}
+
+// AddConnectionIDs adds the "connections" edge to the UserConnection entity by ids.
+func (m *UserMutation) AddConnectionIDs(ids ...string) {
+	if m.connections == nil {
+		m.connections = make(map[string]struct{})
+	}
+	for i := range ids {
+		m.connections[ids[i]] = struct{}{}
+	}
+}
+
+// ClearConnections clears the "connections" edge to the UserConnection entity.
+func (m *UserMutation) ClearConnections() {
+	m.clearedconnections = true
+}
+
+// ConnectionsCleared reports if the "connections" edge to the UserConnection entity was cleared.
+func (m *UserMutation) ConnectionsCleared() bool {
+	return m.clearedconnections
+}
+
+// RemoveConnectionIDs removes the "connections" edge to the UserConnection entity by IDs.
+func (m *UserMutation) RemoveConnectionIDs(ids ...string) {
+	if m.removedconnections == nil {
+		m.removedconnections = make(map[string]struct{})
+	}
+	for i := range ids {
+		delete(m.connections, ids[i])
+		m.removedconnections[ids[i]] = struct{}{}
+	}
+}
+
+// RemovedConnections returns the removed IDs of the "connections" edge to the UserConnection entity.
+func (m *UserMutation) RemovedConnectionsIDs() (ids []string) {
+	for id := range m.removedconnections {
+		ids = append(ids, id)
+	}
+	return
+}
+
+// ConnectionsIDs returns the "connections" edge IDs in the mutation.
+func (m *UserMutation) ConnectionsIDs() (ids []string) {
+	for id := range m.connections {
+		ids = append(ids, id)
+	}
+	return
+}
+
+// ResetConnections resets all changes to the "connections" edge.
+func (m *UserMutation) ResetConnections() {
+	m.connections = nil
+	m.clearedconnections = false
+	m.removedconnections = nil
+}
+
+// AddContentIDs adds the "content" edge to the UserContent entity by ids.
+func (m *UserMutation) AddContentIDs(ids ...string) {
+	if m.content == nil {
+		m.content = make(map[string]struct{})
+	}
+	for i := range ids {
+		m.content[ids[i]] = struct{}{}
+	}
+}
+
+// ClearContent clears the "content" edge to the UserContent entity.
+func (m *UserMutation) ClearContent() {
+	m.clearedcontent = true
+}
+
+// ContentCleared reports if the "content" edge to the UserContent entity was cleared.
+func (m *UserMutation) ContentCleared() bool {
+	return m.clearedcontent
+}
+
+// RemoveContentIDs removes the "content" edge to the UserContent entity by IDs.
+func (m *UserMutation) RemoveContentIDs(ids ...string) {
+	if m.removedcontent == nil {
+		m.removedcontent = make(map[string]struct{})
+	}
+	for i := range ids {
+		delete(m.content, ids[i])
+		m.removedcontent[ids[i]] = struct{}{}
+	}
+}
+
+// RemovedContent returns the removed IDs of the "content" edge to the UserContent entity.
+func (m *UserMutation) RemovedContentIDs() (ids []string) {
+	for id := range m.removedcontent {
+		ids = append(ids, id)
+	}
+	return
+}
+
+// ContentIDs returns the "content" edge IDs in the mutation.
+func (m *UserMutation) ContentIDs() (ids []string) {
+	for id := range m.content {
+		ids = append(ids, id)
+	}
+	return
+}
+
+// ResetContent resets all changes to the "content" edge.
+func (m *UserMutation) ResetContent() {
+	m.content = nil
+	m.clearedcontent = false
+	m.removedcontent = nil
+}
+
+// Where appends a list predicates to the UserMutation builder.
+func (m *UserMutation) Where(ps ...predicate.User) {
+	m.predicates = append(m.predicates, ps...)
+}
+
+// WhereP appends storage-level predicates to the UserMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *UserMutation) WhereP(ps ...func(*sql.Selector)) {
+	p := make([]predicate.User, len(ps))
+	for i := range ps {
+		p[i] = ps[i]
+	}
+	m.Where(p...)
+}
+
+// Op returns the operation name.
+func (m *UserMutation) Op() Op {
+	return m.op
+}
+
+// SetOp allows setting the mutation operation.
+func (m *UserMutation) SetOp(op Op) {
+	m.op = op
+}
+
+// Type returns the node type of this mutation (User).
+func (m *UserMutation) Type() string {
+	return m.typ
+}
+
+// Fields returns all fields that were changed during this mutation. Note that in
+// order to get all numeric fields that were incremented/decremented, call
+// AddedFields().
+func (m *UserMutation) Fields() []string {
+	fields := make([]string, 0, 4)
+	if m.created_at != nil {
+		fields = append(fields, user.FieldCreatedAt)
+	}
+	if m.updated_at != nil {
+		fields = append(fields, user.FieldUpdatedAt)
+	}
+	if m.permissions != nil {
+		fields = append(fields, user.FieldPermissions)
+	}
+	if m.feature_flags != nil {
+		fields = append(fields, user.FieldFeatureFlags)
+	}
+	return fields
+}
+
+// Field returns the value of a field with the given name. The second boolean
+// return value indicates that this field was not set, or was not defined in the
+// schema.
+func (m *UserMutation) Field(name string) (ent.Value, bool) {
+	switch name {
+	case user.FieldCreatedAt:
+		return m.CreatedAt()
+	case user.FieldUpdatedAt:
+		return m.UpdatedAt()
+	case user.FieldPermissions:
+		return m.Permissions()
+	case user.FieldFeatureFlags:
+		return m.FeatureFlags()
+	}
+	return nil, false
+}
+
+// OldField returns the old value of the field from the database. An error is
+// returned if the mutation operation is not UpdateOne, or the query to the
+// database failed.
+func (m *UserMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
+	switch name {
+	case user.FieldCreatedAt:
+		return m.OldCreatedAt(ctx)
+	case user.FieldUpdatedAt:
+		return m.OldUpdatedAt(ctx)
+	case user.FieldPermissions:
+		return m.OldPermissions(ctx)
+	case user.FieldFeatureFlags:
+		return m.OldFeatureFlags(ctx)
+	}
+	return nil, fmt.Errorf("unknown User field %s", name)
+}
+
+// SetField sets the value of a field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *UserMutation) SetField(name string, value ent.Value) error {
+	switch name {
+	case user.FieldCreatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetCreatedAt(v)
+		return nil
+	case user.FieldUpdatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetUpdatedAt(v)
+		return nil
+	case user.FieldPermissions:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetPermissions(v)
+		return nil
+	case user.FieldFeatureFlags:
+		v, ok := value.([]string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetFeatureFlags(v)
+		return nil
+	}
+	return fmt.Errorf("unknown User field %s", name)
+}
+
+// AddedFields returns all numeric fields that were incremented/decremented during
+// this mutation.
+func (m *UserMutation) AddedFields() []string {
+	var fields []string
+	if m.addcreated_at != nil {
+		fields = append(fields, user.FieldCreatedAt)
+	}
+	if m.addupdated_at != nil {
+		fields = append(fields, user.FieldUpdatedAt)
+	}
+	return fields
+}
+
+// AddedField returns the numeric value that was incremented/decremented on a field
+// with the given name. The second boolean return value indicates that this field
+// was not set, or was not defined in the schema.
+func (m *UserMutation) AddedField(name string) (ent.Value, bool) {
+	switch name {
+	case user.FieldCreatedAt:
+		return m.AddedCreatedAt()
+	case user.FieldUpdatedAt:
+		return m.AddedUpdatedAt()
+	}
+	return nil, false
+}
+
+// AddField adds the value to the field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *UserMutation) AddField(name string, value ent.Value) error {
+	switch name {
+	case user.FieldCreatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddCreatedAt(v)
+		return nil
+	case user.FieldUpdatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddUpdatedAt(v)
+		return nil
+	}
+	return fmt.Errorf("unknown User numeric field %s", name)
+}
+
+// ClearedFields returns all nullable fields that were cleared during this
+// mutation.
+func (m *UserMutation) ClearedFields() []string {
+	var fields []string
+	if m.FieldCleared(user.FieldFeatureFlags) {
+		fields = append(fields, user.FieldFeatureFlags)
+	}
+	return fields
+}
+
+// FieldCleared returns a boolean indicating if a field with the given name was
+// cleared in this mutation.
+func (m *UserMutation) FieldCleared(name string) bool {
+	_, ok := m.clearedFields[name]
+	return ok
+}
+
+// ClearField clears the value of the field with the given name. It returns an
+// error if the field is not defined in the schema.
+func (m *UserMutation) ClearField(name string) error {
+	switch name {
+	case user.FieldFeatureFlags:
+		m.ClearFeatureFlags()
+		return nil
+	}
+	return fmt.Errorf("unknown User nullable field %s", name)
+}
+
+// ResetField resets all changes in the mutation for the field with the given name.
+// It returns an error if the field is not defined in the schema.
+func (m *UserMutation) ResetField(name string) error {
+	switch name {
+	case user.FieldCreatedAt:
+		m.ResetCreatedAt()
+		return nil
+	case user.FieldUpdatedAt:
+		m.ResetUpdatedAt()
+		return nil
+	case user.FieldPermissions:
+		m.ResetPermissions()
+		return nil
+	case user.FieldFeatureFlags:
+		m.ResetFeatureFlags()
+		return nil
+	}
+	return fmt.Errorf("unknown User field %s", name)
+}
+
+// AddedEdges returns all edge names that were set/added in this mutation.
+func (m *UserMutation) AddedEdges() []string {
+	edges := make([]string, 0, 3)
+	if m.subscriptions != nil {
+		edges = append(edges, user.EdgeSubscriptions)
+	}
+	if m.connections != nil {
+		edges = append(edges, user.EdgeConnections)
+	}
+	if m.content != nil {
+		edges = append(edges, user.EdgeContent)
+	}
+	return edges
+}
+
+// AddedIDs returns all IDs (to other nodes) that were added for the given edge
+// name in this mutation.
+func (m *UserMutation) AddedIDs(name string) []ent.Value {
+	switch name {
+	case user.EdgeSubscriptions:
+		ids := make([]ent.Value, 0, len(m.subscriptions))
+		for id := range m.subscriptions {
+			ids = append(ids, id)
+		}
+		return ids
+	case user.EdgeConnections:
+		ids := make([]ent.Value, 0, len(m.connections))
+		for id := range m.connections {
+			ids = append(ids, id)
+		}
+		return ids
+	case user.EdgeContent:
+		ids := make([]ent.Value, 0, len(m.content))
+		for id := range m.content {
+			ids = append(ids, id)
+		}
+		return ids
+	}
+	return nil
+}
+
+// RemovedEdges returns all edge names that were removed in this mutation.
+func (m *UserMutation) RemovedEdges() []string {
+	edges := make([]string, 0, 3)
+	if m.removedsubscriptions != nil {
+		edges = append(edges, user.EdgeSubscriptions)
+	}
+	if m.removedconnections != nil {
+		edges = append(edges, user.EdgeConnections)
+	}
+	if m.removedcontent != nil {
+		edges = append(edges, user.EdgeContent)
+	}
+	return edges
+}
+
+// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
+// the given name in this mutation.
+func (m *UserMutation) RemovedIDs(name string) []ent.Value {
+	switch name {
+	case user.EdgeSubscriptions:
+		ids := make([]ent.Value, 0, len(m.removedsubscriptions))
+		for id := range m.removedsubscriptions {
+			ids = append(ids, id)
+		}
+		return ids
+	case user.EdgeConnections:
+		ids := make([]ent.Value, 0, len(m.removedconnections))
+		for id := range m.removedconnections {
+			ids = append(ids, id)
+		}
+		return ids
+	case user.EdgeContent:
+		ids := make([]ent.Value, 0, len(m.removedcontent))
+		for id := range m.removedcontent {
+			ids = append(ids, id)
+		}
+		return ids
+	}
+	return nil
+}
+
+// ClearedEdges returns all edge names that were cleared in this mutation.
+func (m *UserMutation) ClearedEdges() []string {
+	edges := make([]string, 0, 3)
+	if m.clearedsubscriptions {
+		edges = append(edges, user.EdgeSubscriptions)
+	}
+	if m.clearedconnections {
+		edges = append(edges, user.EdgeConnections)
+	}
+	if m.clearedcontent {
+		edges = append(edges, user.EdgeContent)
+	}
+	return edges
+}
+
+// EdgeCleared returns a boolean which indicates if the edge with the given name
+// was cleared in this mutation.
+func (m *UserMutation) EdgeCleared(name string) bool {
+	switch name {
+	case user.EdgeSubscriptions:
+		return m.clearedsubscriptions
+	case user.EdgeConnections:
+		return m.clearedconnections
+	case user.EdgeContent:
+		return m.clearedcontent
+	}
+	return false
+}
+
+// ClearEdge clears the value of the edge with the given name. It returns an error
+// if that edge is not defined in the schema.
+func (m *UserMutation) ClearEdge(name string) error {
+	switch name {
+	}
+	return fmt.Errorf("unknown User unique edge %s", name)
+}
+
+// ResetEdge resets all changes to the edge with the given name in this mutation.
+// It returns an error if the edge is not defined in the schema.
+func (m *UserMutation) ResetEdge(name string) error {
+	switch name {
+	case user.EdgeSubscriptions:
+		m.ResetSubscriptions()
+		return nil
+	case user.EdgeConnections:
+		m.ResetConnections()
+		return nil
+	case user.EdgeContent:
+		m.ResetContent()
+		return nil
+	}
+	return fmt.Errorf("unknown User edge %s", name)
+}
+
+// UserConnectionMutation represents an operation that mutates the UserConnection nodes in the graph.
+type UserConnectionMutation struct {
+	config
+	op            Op
+	typ           string
+	id            *string
+	created_at    *int
+	addcreated_at *int
+	updated_at    *int
+	addupdated_at *int
+	_type         *models.ConnectionType
+	reference_id  *string
+	permissions   *string
+	metadata      *map[string]interface{}
+	clearedFields map[string]struct{}
+	user          *string
+	cleareduser   bool
+	done          bool
+	oldValue      func(context.Context) (*UserConnection, error)
+	predicates    []predicate.UserConnection
+}
+
+var _ ent.Mutation = (*UserConnectionMutation)(nil)
+
+// userconnectionOption allows management of the mutation configuration using functional options.
+type userconnectionOption func(*UserConnectionMutation)
+
+// newUserConnectionMutation creates new mutation for the UserConnection entity.
+func newUserConnectionMutation(c config, op Op, opts ...userconnectionOption) *UserConnectionMutation {
+	m := &UserConnectionMutation{
+		config:        c,
+		op:            op,
+		typ:           TypeUserConnection,
+		clearedFields: make(map[string]struct{}),
+	}
+	for _, opt := range opts {
+		opt(m)
+	}
+	return m
+}
+
+// withUserConnectionID sets the ID field of the mutation.
+func withUserConnectionID(id string) userconnectionOption {
+	return func(m *UserConnectionMutation) {
+		var (
+			err   error
+			once  sync.Once
+			value *UserConnection
+		)
+		m.oldValue = func(ctx context.Context) (*UserConnection, error) {
+			once.Do(func() {
+				if m.done {
+					err = errors.New("querying old values post mutation is not allowed")
+				} else {
+					value, err = m.Client().UserConnection.Get(ctx, id)
+				}
+			})
+			return value, err
+		}
+		m.id = &id
+	}
+}
+
+// withUserConnection sets the old UserConnection of the mutation.
+func withUserConnection(node *UserConnection) userconnectionOption {
+	return func(m *UserConnectionMutation) {
+		m.oldValue = func(context.Context) (*UserConnection, error) {
+			return node, nil
+		}
+		m.id = &node.ID
+	}
+}
+
+// Client returns a new `ent.Client` from the mutation. If the mutation was
+// executed in a transaction (ent.Tx), a transactional client is returned.
+func (m UserConnectionMutation) Client() *Client {
+	client := &Client{config: m.config}
+	client.init()
+	return client
+}
+
+// Tx returns an `ent.Tx` for mutations that were executed in transactions;
+// it returns an error otherwise.
+func (m UserConnectionMutation) Tx() (*Tx, error) {
+	if _, ok := m.driver.(*txDriver); !ok {
+		return nil, errors.New("db: mutation is not running in a transaction")
+	}
+	tx := &Tx{config: m.config}
+	tx.init()
+	return tx, nil
+}
+
+// SetID sets the value of the id field. Note that this
+// operation is only accepted on creation of UserConnection entities.
+func (m *UserConnectionMutation) SetID(id string) {
+	m.id = &id
+}
+
+// ID returns the ID value in the mutation. Note that the ID is only available
+// if it was provided to the builder or after it was returned from the database.
+func (m *UserConnectionMutation) ID() (id string, exists bool) {
+	if m.id == nil {
+		return
+	}
+	return *m.id, true
+}
+
+// IDs queries the database and returns the entity ids that match the mutation's predicate.
+// That means, if the mutation is applied within a transaction with an isolation level such
+// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
+// or updated by the mutation.
+func (m *UserConnectionMutation) IDs(ctx context.Context) ([]string, error) {
+	switch {
+	case m.op.Is(OpUpdateOne | OpDeleteOne):
+		id, exists := m.ID()
+		if exists {
+			return []string{id}, nil
+		}
+		fallthrough
+	case m.op.Is(OpUpdate | OpDelete):
+		return m.Client().UserConnection.Query().Where(m.predicates...).IDs(ctx)
+	default:
+		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
+	}
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (m *UserConnectionMutation) SetCreatedAt(i int) {
+	m.created_at = &i
+	m.addcreated_at = nil
+}
+
+// CreatedAt returns the value of the "created_at" field in the mutation.
+func (m *UserConnectionMutation) CreatedAt() (r int, exists bool) {
+	v := m.created_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldCreatedAt returns the old "created_at" field's value of the UserConnection entity.
+// If the UserConnection object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserConnectionMutation) OldCreatedAt(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldCreatedAt requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
+	}
+	return oldValue.CreatedAt, nil
+}
+
+// AddCreatedAt adds i to the "created_at" field.
+func (m *UserConnectionMutation) AddCreatedAt(i int) {
+	if m.addcreated_at != nil {
+		*m.addcreated_at += i
+	} else {
+		m.addcreated_at = &i
+	}
+}
+
+// AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
+func (m *UserConnectionMutation) AddedCreatedAt() (r int, exists bool) {
+	v := m.addcreated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetCreatedAt resets all changes to the "created_at" field.
+func (m *UserConnectionMutation) ResetCreatedAt() {
+	m.created_at = nil
+	m.addcreated_at = nil
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (m *UserConnectionMutation) SetUpdatedAt(i int) {
+	m.updated_at = &i
+	m.addupdated_at = nil
+}
+
+// UpdatedAt returns the value of the "updated_at" field in the mutation.
+func (m *UserConnectionMutation) UpdatedAt() (r int, exists bool) {
+	v := m.updated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldUpdatedAt returns the old "updated_at" field's value of the UserConnection entity.
+// If the UserConnection object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserConnectionMutation) OldUpdatedAt(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
+	}
+	return oldValue.UpdatedAt, nil
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (m *UserConnectionMutation) AddUpdatedAt(i int) {
+	if m.addupdated_at != nil {
+		*m.addupdated_at += i
+	} else {
+		m.addupdated_at = &i
+	}
+}
+
+// AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
+func (m *UserConnectionMutation) AddedUpdatedAt() (r int, exists bool) {
+	v := m.addupdated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetUpdatedAt resets all changes to the "updated_at" field.
+func (m *UserConnectionMutation) ResetUpdatedAt() {
+	m.updated_at = nil
+	m.addupdated_at = nil
+}
+
+// SetType sets the "type" field.
+func (m *UserConnectionMutation) SetType(mt models.ConnectionType) {
+	m._type = &mt
+}
+
+// GetType returns the value of the "type" field in the mutation.
+func (m *UserConnectionMutation) GetType() (r models.ConnectionType, exists bool) {
+	v := m._type
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldType returns the old "type" field's value of the UserConnection entity.
+// If the UserConnection object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserConnectionMutation) OldType(ctx context.Context) (v models.ConnectionType, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldType is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldType requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldType: %w", err)
+	}
+	return oldValue.Type, nil
+}
+
+// ResetType resets all changes to the "type" field.
+func (m *UserConnectionMutation) ResetType() {
+	m._type = nil
+}
+
+// SetUserID sets the "user_id" field.
+func (m *UserConnectionMutation) SetUserID(s string) {
+	m.user = &s
+}
+
+// UserID returns the value of the "user_id" field in the mutation.
+func (m *UserConnectionMutation) UserID() (r string, exists bool) {
+	v := m.user
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldUserID returns the old "user_id" field's value of the UserConnection entity.
+// If the UserConnection object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserConnectionMutation) OldUserID(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldUserID is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldUserID requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldUserID: %w", err)
+	}
+	return oldValue.UserID, nil
+}
+
+// ResetUserID resets all changes to the "user_id" field.
+func (m *UserConnectionMutation) ResetUserID() {
+	m.user = nil
+}
+
+// SetReferenceID sets the "reference_id" field.
+func (m *UserConnectionMutation) SetReferenceID(s string) {
+	m.reference_id = &s
+}
+
+// ReferenceID returns the value of the "reference_id" field in the mutation.
+func (m *UserConnectionMutation) ReferenceID() (r string, exists bool) {
+	v := m.reference_id
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldReferenceID returns the old "reference_id" field's value of the UserConnection entity.
+// If the UserConnection object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserConnectionMutation) OldReferenceID(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldReferenceID is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldReferenceID requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldReferenceID: %w", err)
+	}
+	return oldValue.ReferenceID, nil
+}
+
+// ResetReferenceID resets all changes to the "reference_id" field.
+func (m *UserConnectionMutation) ResetReferenceID() {
+	m.reference_id = nil
+}
+
+// SetPermissions sets the "permissions" field.
+func (m *UserConnectionMutation) SetPermissions(s string) {
+	m.permissions = &s
+}
+
+// Permissions returns the value of the "permissions" field in the mutation.
+func (m *UserConnectionMutation) Permissions() (r string, exists bool) {
+	v := m.permissions
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldPermissions returns the old "permissions" field's value of the UserConnection entity.
+// If the UserConnection object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserConnectionMutation) OldPermissions(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldPermissions is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldPermissions requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldPermissions: %w", err)
+	}
+	return oldValue.Permissions, nil
+}
+
+// ClearPermissions clears the value of the "permissions" field.
+func (m *UserConnectionMutation) ClearPermissions() {
+	m.permissions = nil
+	m.clearedFields[userconnection.FieldPermissions] = struct{}{}
+}
+
+// PermissionsCleared returns if the "permissions" field was cleared in this mutation.
+func (m *UserConnectionMutation) PermissionsCleared() bool {
+	_, ok := m.clearedFields[userconnection.FieldPermissions]
+	return ok
+}
+
+// ResetPermissions resets all changes to the "permissions" field.
+func (m *UserConnectionMutation) ResetPermissions() {
+	m.permissions = nil
+	delete(m.clearedFields, userconnection.FieldPermissions)
+}
+
+// SetMetadata sets the "metadata" field.
+func (m *UserConnectionMutation) SetMetadata(value map[string]interface{}) {
+	m.metadata = &value
+}
+
+// Metadata returns the value of the "metadata" field in the mutation.
+func (m *UserConnectionMutation) Metadata() (r map[string]interface{}, exists bool) {
+	v := m.metadata
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldMetadata returns the old "metadata" field's value of the UserConnection entity.
+// If the UserConnection object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserConnectionMutation) OldMetadata(ctx context.Context) (v map[string]interface{}, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldMetadata is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldMetadata requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldMetadata: %w", err)
+	}
+	return oldValue.Metadata, nil
+}
+
+// ClearMetadata clears the value of the "metadata" field.
+func (m *UserConnectionMutation) ClearMetadata() {
+	m.metadata = nil
+	m.clearedFields[userconnection.FieldMetadata] = struct{}{}
+}
+
+// MetadataCleared returns if the "metadata" field was cleared in this mutation.
+func (m *UserConnectionMutation) MetadataCleared() bool {
+	_, ok := m.clearedFields[userconnection.FieldMetadata]
+	return ok
+}
+
+// ResetMetadata resets all changes to the "metadata" field.
+func (m *UserConnectionMutation) ResetMetadata() {
+	m.metadata = nil
+	delete(m.clearedFields, userconnection.FieldMetadata)
+}
+
+// ClearUser clears the "user" edge to the User entity.
+func (m *UserConnectionMutation) ClearUser() {
+	m.cleareduser = true
+	m.clearedFields[userconnection.FieldUserID] = struct{}{}
+}
+
+// UserCleared reports if the "user" edge to the User entity was cleared.
+func (m *UserConnectionMutation) UserCleared() bool {
+	return m.cleareduser
+}
+
+// UserIDs returns the "user" edge IDs in the mutation.
+// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
+// UserID instead. It exists only for internal usage by the builders.
+func (m *UserConnectionMutation) UserIDs() (ids []string) {
+	if id := m.user; id != nil {
+		ids = append(ids, *id)
+	}
+	return
+}
+
+// ResetUser resets all changes to the "user" edge.
+func (m *UserConnectionMutation) ResetUser() {
+	m.user = nil
+	m.cleareduser = false
+}
+
+// Where appends a list predicates to the UserConnectionMutation builder.
+func (m *UserConnectionMutation) Where(ps ...predicate.UserConnection) {
+	m.predicates = append(m.predicates, ps...)
+}
+
+// WhereP appends storage-level predicates to the UserConnectionMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *UserConnectionMutation) WhereP(ps ...func(*sql.Selector)) {
+	p := make([]predicate.UserConnection, len(ps))
+	for i := range ps {
+		p[i] = ps[i]
+	}
+	m.Where(p...)
+}
+
+// Op returns the operation name.
+func (m *UserConnectionMutation) Op() Op {
+	return m.op
+}
+
+// SetOp allows setting the mutation operation.
+func (m *UserConnectionMutation) SetOp(op Op) {
+	m.op = op
+}
+
+// Type returns the node type of this mutation (UserConnection).
+func (m *UserConnectionMutation) Type() string {
+	return m.typ
+}
+
+// Fields returns all fields that were changed during this mutation. Note that in
+// order to get all numeric fields that were incremented/decremented, call
+// AddedFields().
+func (m *UserConnectionMutation) Fields() []string {
+	fields := make([]string, 0, 7)
+	if m.created_at != nil {
+		fields = append(fields, userconnection.FieldCreatedAt)
+	}
+	if m.updated_at != nil {
+		fields = append(fields, userconnection.FieldUpdatedAt)
+	}
+	if m._type != nil {
+		fields = append(fields, userconnection.FieldType)
+	}
+	if m.user != nil {
+		fields = append(fields, userconnection.FieldUserID)
+	}
+	if m.reference_id != nil {
+		fields = append(fields, userconnection.FieldReferenceID)
+	}
+	if m.permissions != nil {
+		fields = append(fields, userconnection.FieldPermissions)
+	}
+	if m.metadata != nil {
+		fields = append(fields, userconnection.FieldMetadata)
+	}
+	return fields
+}
+
+// Field returns the value of a field with the given name. The second boolean
+// return value indicates that this field was not set, or was not defined in the
+// schema.
+func (m *UserConnectionMutation) Field(name string) (ent.Value, bool) {
+	switch name {
+	case userconnection.FieldCreatedAt:
+		return m.CreatedAt()
+	case userconnection.FieldUpdatedAt:
+		return m.UpdatedAt()
+	case userconnection.FieldType:
+		return m.GetType()
+	case userconnection.FieldUserID:
+		return m.UserID()
+	case userconnection.FieldReferenceID:
+		return m.ReferenceID()
+	case userconnection.FieldPermissions:
+		return m.Permissions()
+	case userconnection.FieldMetadata:
+		return m.Metadata()
+	}
+	return nil, false
+}
+
+// OldField returns the old value of the field from the database. An error is
+// returned if the mutation operation is not UpdateOne, or the query to the
+// database failed.
+func (m *UserConnectionMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
+	switch name {
+	case userconnection.FieldCreatedAt:
+		return m.OldCreatedAt(ctx)
+	case userconnection.FieldUpdatedAt:
+		return m.OldUpdatedAt(ctx)
+	case userconnection.FieldType:
+		return m.OldType(ctx)
+	case userconnection.FieldUserID:
+		return m.OldUserID(ctx)
+	case userconnection.FieldReferenceID:
+		return m.OldReferenceID(ctx)
+	case userconnection.FieldPermissions:
+		return m.OldPermissions(ctx)
+	case userconnection.FieldMetadata:
+		return m.OldMetadata(ctx)
+	}
+	return nil, fmt.Errorf("unknown UserConnection field %s", name)
+}
+
+// SetField sets the value of a field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *UserConnectionMutation) SetField(name string, value ent.Value) error {
+	switch name {
+	case userconnection.FieldCreatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetCreatedAt(v)
+		return nil
+	case userconnection.FieldUpdatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetUpdatedAt(v)
+		return nil
+	case userconnection.FieldType:
+		v, ok := value.(models.ConnectionType)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetType(v)
+		return nil
+	case userconnection.FieldUserID:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetUserID(v)
+		return nil
+	case userconnection.FieldReferenceID:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetReferenceID(v)
+		return nil
+	case userconnection.FieldPermissions:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetPermissions(v)
+		return nil
+	case userconnection.FieldMetadata:
+		v, ok := value.(map[string]interface{})
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetMetadata(v)
+		return nil
+	}
+	return fmt.Errorf("unknown UserConnection field %s", name)
+}
+
+// AddedFields returns all numeric fields that were incremented/decremented during
+// this mutation.
+func (m *UserConnectionMutation) AddedFields() []string {
+	var fields []string
+	if m.addcreated_at != nil {
+		fields = append(fields, userconnection.FieldCreatedAt)
+	}
+	if m.addupdated_at != nil {
+		fields = append(fields, userconnection.FieldUpdatedAt)
+	}
+	return fields
+}
+
+// AddedField returns the numeric value that was incremented/decremented on a field
+// with the given name. The second boolean return value indicates that this field
+// was not set, or was not defined in the schema.
+func (m *UserConnectionMutation) AddedField(name string) (ent.Value, bool) {
+	switch name {
+	case userconnection.FieldCreatedAt:
+		return m.AddedCreatedAt()
+	case userconnection.FieldUpdatedAt:
+		return m.AddedUpdatedAt()
+	}
+	return nil, false
+}
+
+// AddField adds the value to the field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *UserConnectionMutation) AddField(name string, value ent.Value) error {
+	switch name {
+	case userconnection.FieldCreatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddCreatedAt(v)
+		return nil
+	case userconnection.FieldUpdatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddUpdatedAt(v)
+		return nil
+	}
+	return fmt.Errorf("unknown UserConnection numeric field %s", name)
+}
+
+// ClearedFields returns all nullable fields that were cleared during this
+// mutation.
+func (m *UserConnectionMutation) ClearedFields() []string {
+	var fields []string
+	if m.FieldCleared(userconnection.FieldPermissions) {
+		fields = append(fields, userconnection.FieldPermissions)
+	}
+	if m.FieldCleared(userconnection.FieldMetadata) {
+		fields = append(fields, userconnection.FieldMetadata)
+	}
+	return fields
+}
+
+// FieldCleared returns a boolean indicating if a field with the given name was
+// cleared in this mutation.
+func (m *UserConnectionMutation) FieldCleared(name string) bool {
+	_, ok := m.clearedFields[name]
+	return ok
+}
+
+// ClearField clears the value of the field with the given name. It returns an
+// error if the field is not defined in the schema.
+func (m *UserConnectionMutation) ClearField(name string) error {
+	switch name {
+	case userconnection.FieldPermissions:
+		m.ClearPermissions()
+		return nil
+	case userconnection.FieldMetadata:
+		m.ClearMetadata()
+		return nil
+	}
+	return fmt.Errorf("unknown UserConnection nullable field %s", name)
+}
+
+// ResetField resets all changes in the mutation for the field with the given name.
+// It returns an error if the field is not defined in the schema.
+func (m *UserConnectionMutation) ResetField(name string) error {
+	switch name {
+	case userconnection.FieldCreatedAt:
+		m.ResetCreatedAt()
+		return nil
+	case userconnection.FieldUpdatedAt:
+		m.ResetUpdatedAt()
+		return nil
+	case userconnection.FieldType:
+		m.ResetType()
+		return nil
+	case userconnection.FieldUserID:
+		m.ResetUserID()
+		return nil
+	case userconnection.FieldReferenceID:
+		m.ResetReferenceID()
+		return nil
+	case userconnection.FieldPermissions:
+		m.ResetPermissions()
+		return nil
+	case userconnection.FieldMetadata:
+		m.ResetMetadata()
+		return nil
+	}
+	return fmt.Errorf("unknown UserConnection field %s", name)
+}
+
+// AddedEdges returns all edge names that were set/added in this mutation.
+func (m *UserConnectionMutation) AddedEdges() []string {
+	edges := make([]string, 0, 1)
+	if m.user != nil {
+		edges = append(edges, userconnection.EdgeUser)
+	}
+	return edges
+}
+
+// AddedIDs returns all IDs (to other nodes) that were added for the given edge
+// name in this mutation.
+func (m *UserConnectionMutation) AddedIDs(name string) []ent.Value {
+	switch name {
+	case userconnection.EdgeUser:
+		if id := m.user; id != nil {
+			return []ent.Value{*id}
+		}
+	}
+	return nil
+}
+
+// RemovedEdges returns all edge names that were removed in this mutation.
+func (m *UserConnectionMutation) RemovedEdges() []string {
+	edges := make([]string, 0, 1)
+	return edges
+}
+
+// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
+// the given name in this mutation.
+func (m *UserConnectionMutation) RemovedIDs(name string) []ent.Value {
+	return nil
+}
+
+// ClearedEdges returns all edge names that were cleared in this mutation.
+func (m *UserConnectionMutation) ClearedEdges() []string {
+	edges := make([]string, 0, 1)
+	if m.cleareduser {
+		edges = append(edges, userconnection.EdgeUser)
+	}
+	return edges
+}
+
+// EdgeCleared returns a boolean which indicates if the edge with the given name
+// was cleared in this mutation.
+func (m *UserConnectionMutation) EdgeCleared(name string) bool {
+	switch name {
+	case userconnection.EdgeUser:
+		return m.cleareduser
+	}
+	return false
+}
+
+// ClearEdge clears the value of the edge with the given name. It returns an error
+// if that edge is not defined in the schema.
+func (m *UserConnectionMutation) ClearEdge(name string) error {
+	switch name {
+	case userconnection.EdgeUser:
+		m.ClearUser()
+		return nil
+	}
+	return fmt.Errorf("unknown UserConnection unique edge %s", name)
+}
+
+// ResetEdge resets all changes to the edge with the given name in this mutation.
+// It returns an error if the edge is not defined in the schema.
+func (m *UserConnectionMutation) ResetEdge(name string) error {
+	switch name {
+	case userconnection.EdgeUser:
+		m.ResetUser()
+		return nil
+	}
+	return fmt.Errorf("unknown UserConnection edge %s", name)
+}
+
+// UserContentMutation represents an operation that mutates the UserContent nodes in the graph.
+type UserContentMutation struct {
+	config
+	op            Op
+	typ           string
+	id            *string
+	created_at    *int
+	addcreated_at *int
+	updated_at    *int
+	addupdated_at *int
+	_type         *models.UserContentType
+	reference_id  *string
+	value         *any
+	metadata      *map[string]interface{}
+	clearedFields map[string]struct{}
+	user          *string
+	cleareduser   bool
+	done          bool
+	oldValue      func(context.Context) (*UserContent, error)
+	predicates    []predicate.UserContent
+}
+
+var _ ent.Mutation = (*UserContentMutation)(nil)
+
+// usercontentOption allows management of the mutation configuration using functional options.
+type usercontentOption func(*UserContentMutation)
+
+// newUserContentMutation creates new mutation for the UserContent entity.
+func newUserContentMutation(c config, op Op, opts ...usercontentOption) *UserContentMutation {
+	m := &UserContentMutation{
+		config:        c,
+		op:            op,
+		typ:           TypeUserContent,
+		clearedFields: make(map[string]struct{}),
+	}
+	for _, opt := range opts {
+		opt(m)
+	}
+	return m
+}
+
+// withUserContentID sets the ID field of the mutation.
+func withUserContentID(id string) usercontentOption {
+	return func(m *UserContentMutation) {
+		var (
+			err   error
+			once  sync.Once
+			value *UserContent
+		)
+		m.oldValue = func(ctx context.Context) (*UserContent, error) {
+			once.Do(func() {
+				if m.done {
+					err = errors.New("querying old values post mutation is not allowed")
+				} else {
+					value, err = m.Client().UserContent.Get(ctx, id)
+				}
+			})
+			return value, err
+		}
+		m.id = &id
+	}
+}
+
+// withUserContent sets the old UserContent of the mutation.
+func withUserContent(node *UserContent) usercontentOption {
+	return func(m *UserContentMutation) {
+		m.oldValue = func(context.Context) (*UserContent, error) {
+			return node, nil
+		}
+		m.id = &node.ID
+	}
+}
+
+// Client returns a new `ent.Client` from the mutation. If the mutation was
+// executed in a transaction (ent.Tx), a transactional client is returned.
+func (m UserContentMutation) Client() *Client {
+	client := &Client{config: m.config}
+	client.init()
+	return client
+}
+
+// Tx returns an `ent.Tx` for mutations that were executed in transactions;
+// it returns an error otherwise.
+func (m UserContentMutation) Tx() (*Tx, error) {
+	if _, ok := m.driver.(*txDriver); !ok {
+		return nil, errors.New("db: mutation is not running in a transaction")
+	}
+	tx := &Tx{config: m.config}
+	tx.init()
+	return tx, nil
+}
+
+// SetID sets the value of the id field. Note that this
+// operation is only accepted on creation of UserContent entities.
+func (m *UserContentMutation) SetID(id string) {
+	m.id = &id
+}
+
+// ID returns the ID value in the mutation. Note that the ID is only available
+// if it was provided to the builder or after it was returned from the database.
+func (m *UserContentMutation) ID() (id string, exists bool) {
+	if m.id == nil {
+		return
+	}
+	return *m.id, true
+}
+
+// IDs queries the database and returns the entity ids that match the mutation's predicate.
+// That means, if the mutation is applied within a transaction with an isolation level such
+// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
+// or updated by the mutation.
+func (m *UserContentMutation) IDs(ctx context.Context) ([]string, error) {
+	switch {
+	case m.op.Is(OpUpdateOne | OpDeleteOne):
+		id, exists := m.ID()
+		if exists {
+			return []string{id}, nil
+		}
+		fallthrough
+	case m.op.Is(OpUpdate | OpDelete):
+		return m.Client().UserContent.Query().Where(m.predicates...).IDs(ctx)
+	default:
+		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
+	}
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (m *UserContentMutation) SetCreatedAt(i int) {
+	m.created_at = &i
+	m.addcreated_at = nil
+}
+
+// CreatedAt returns the value of the "created_at" field in the mutation.
+func (m *UserContentMutation) CreatedAt() (r int, exists bool) {
+	v := m.created_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldCreatedAt returns the old "created_at" field's value of the UserContent entity.
+// If the UserContent object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserContentMutation) OldCreatedAt(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldCreatedAt requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
+	}
+	return oldValue.CreatedAt, nil
+}
+
+// AddCreatedAt adds i to the "created_at" field.
+func (m *UserContentMutation) AddCreatedAt(i int) {
+	if m.addcreated_at != nil {
+		*m.addcreated_at += i
+	} else {
+		m.addcreated_at = &i
+	}
+}
+
+// AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
+func (m *UserContentMutation) AddedCreatedAt() (r int, exists bool) {
+	v := m.addcreated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetCreatedAt resets all changes to the "created_at" field.
+func (m *UserContentMutation) ResetCreatedAt() {
+	m.created_at = nil
+	m.addcreated_at = nil
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (m *UserContentMutation) SetUpdatedAt(i int) {
+	m.updated_at = &i
+	m.addupdated_at = nil
+}
+
+// UpdatedAt returns the value of the "updated_at" field in the mutation.
+func (m *UserContentMutation) UpdatedAt() (r int, exists bool) {
+	v := m.updated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldUpdatedAt returns the old "updated_at" field's value of the UserContent entity.
+// If the UserContent object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserContentMutation) OldUpdatedAt(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
+	}
+	return oldValue.UpdatedAt, nil
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (m *UserContentMutation) AddUpdatedAt(i int) {
+	if m.addupdated_at != nil {
+		*m.addupdated_at += i
+	} else {
+		m.addupdated_at = &i
+	}
+}
+
+// AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
+func (m *UserContentMutation) AddedUpdatedAt() (r int, exists bool) {
+	v := m.addupdated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetUpdatedAt resets all changes to the "updated_at" field.
+func (m *UserContentMutation) ResetUpdatedAt() {
+	m.updated_at = nil
+	m.addupdated_at = nil
+}
+
+// SetType sets the "type" field.
+func (m *UserContentMutation) SetType(mct models.UserContentType) {
+	m._type = &mct
+}
+
+// GetType returns the value of the "type" field in the mutation.
+func (m *UserContentMutation) GetType() (r models.UserContentType, exists bool) {
+	v := m._type
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldType returns the old "type" field's value of the UserContent entity.
+// If the UserContent object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserContentMutation) OldType(ctx context.Context) (v models.UserContentType, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldType is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldType requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldType: %w", err)
+	}
+	return oldValue.Type, nil
+}
+
+// ResetType resets all changes to the "type" field.
+func (m *UserContentMutation) ResetType() {
+	m._type = nil
+}
+
+// SetUserID sets the "user_id" field.
+func (m *UserContentMutation) SetUserID(s string) {
+	m.user = &s
+}
+
+// UserID returns the value of the "user_id" field in the mutation.
+func (m *UserContentMutation) UserID() (r string, exists bool) {
+	v := m.user
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldUserID returns the old "user_id" field's value of the UserContent entity.
+// If the UserContent object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserContentMutation) OldUserID(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldUserID is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldUserID requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldUserID: %w", err)
+	}
+	return oldValue.UserID, nil
+}
+
+// ResetUserID resets all changes to the "user_id" field.
+func (m *UserContentMutation) ResetUserID() {
+	m.user = nil
+}
+
+// SetReferenceID sets the "reference_id" field.
+func (m *UserContentMutation) SetReferenceID(s string) {
+	m.reference_id = &s
+}
+
+// ReferenceID returns the value of the "reference_id" field in the mutation.
+func (m *UserContentMutation) ReferenceID() (r string, exists bool) {
+	v := m.reference_id
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldReferenceID returns the old "reference_id" field's value of the UserContent entity.
+// If the UserContent object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserContentMutation) OldReferenceID(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldReferenceID is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldReferenceID requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldReferenceID: %w", err)
+	}
+	return oldValue.ReferenceID, nil
+}
+
+// ResetReferenceID resets all changes to the "reference_id" field.
+func (m *UserContentMutation) ResetReferenceID() {
+	m.reference_id = nil
+}
+
+// SetValue sets the "value" field.
+func (m *UserContentMutation) SetValue(a any) {
+	m.value = &a
+}
+
+// Value returns the value of the "value" field in the mutation.
+func (m *UserContentMutation) Value() (r any, exists bool) {
+	v := m.value
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldValue returns the old "value" field's value of the UserContent entity.
+// If the UserContent object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserContentMutation) OldValue(ctx context.Context) (v any, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldValue is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldValue requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldValue: %w", err)
+	}
+	return oldValue.Value, nil
+}
+
+// ResetValue resets all changes to the "value" field.
+func (m *UserContentMutation) ResetValue() {
+	m.value = nil
+}
+
+// SetMetadata sets the "metadata" field.
+func (m *UserContentMutation) SetMetadata(value map[string]interface{}) {
+	m.metadata = &value
+}
+
+// Metadata returns the value of the "metadata" field in the mutation.
+func (m *UserContentMutation) Metadata() (r map[string]interface{}, exists bool) {
+	v := m.metadata
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldMetadata returns the old "metadata" field's value of the UserContent entity.
+// If the UserContent object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserContentMutation) OldMetadata(ctx context.Context) (v map[string]interface{}, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldMetadata is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldMetadata requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldMetadata: %w", err)
+	}
+	return oldValue.Metadata, nil
+}
+
+// ResetMetadata resets all changes to the "metadata" field.
+func (m *UserContentMutation) ResetMetadata() {
+	m.metadata = nil
+}
+
+// ClearUser clears the "user" edge to the User entity.
+func (m *UserContentMutation) ClearUser() {
+	m.cleareduser = true
+	m.clearedFields[usercontent.FieldUserID] = struct{}{}
+}
+
+// UserCleared reports if the "user" edge to the User entity was cleared.
+func (m *UserContentMutation) UserCleared() bool {
+	return m.cleareduser
+}
+
+// UserIDs returns the "user" edge IDs in the mutation.
+// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
+// UserID instead. It exists only for internal usage by the builders.
+func (m *UserContentMutation) UserIDs() (ids []string) {
+	if id := m.user; id != nil {
+		ids = append(ids, *id)
+	}
+	return
+}
+
+// ResetUser resets all changes to the "user" edge.
+func (m *UserContentMutation) ResetUser() {
+	m.user = nil
+	m.cleareduser = false
+}
+
+// Where appends a list predicates to the UserContentMutation builder.
+func (m *UserContentMutation) Where(ps ...predicate.UserContent) {
+	m.predicates = append(m.predicates, ps...)
+}
+
+// WhereP appends storage-level predicates to the UserContentMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *UserContentMutation) WhereP(ps ...func(*sql.Selector)) {
+	p := make([]predicate.UserContent, len(ps))
+	for i := range ps {
+		p[i] = ps[i]
+	}
+	m.Where(p...)
+}
+
+// Op returns the operation name.
+func (m *UserContentMutation) Op() Op {
+	return m.op
+}
+
+// SetOp allows setting the mutation operation.
+func (m *UserContentMutation) SetOp(op Op) {
+	m.op = op
+}
+
+// Type returns the node type of this mutation (UserContent).
+func (m *UserContentMutation) Type() string {
+	return m.typ
+}
+
+// Fields returns all fields that were changed during this mutation. Note that in
+// order to get all numeric fields that were incremented/decremented, call
+// AddedFields().
+func (m *UserContentMutation) Fields() []string {
+	fields := make([]string, 0, 7)
+	if m.created_at != nil {
+		fields = append(fields, usercontent.FieldCreatedAt)
+	}
+	if m.updated_at != nil {
+		fields = append(fields, usercontent.FieldUpdatedAt)
+	}
+	if m._type != nil {
+		fields = append(fields, usercontent.FieldType)
+	}
+	if m.user != nil {
+		fields = append(fields, usercontent.FieldUserID)
+	}
+	if m.reference_id != nil {
+		fields = append(fields, usercontent.FieldReferenceID)
+	}
+	if m.value != nil {
+		fields = append(fields, usercontent.FieldValue)
+	}
+	if m.metadata != nil {
+		fields = append(fields, usercontent.FieldMetadata)
+	}
+	return fields
+}
+
+// Field returns the value of a field with the given name. The second boolean
+// return value indicates that this field was not set, or was not defined in the
+// schema.
+func (m *UserContentMutation) Field(name string) (ent.Value, bool) {
+	switch name {
+	case usercontent.FieldCreatedAt:
+		return m.CreatedAt()
+	case usercontent.FieldUpdatedAt:
+		return m.UpdatedAt()
+	case usercontent.FieldType:
+		return m.GetType()
+	case usercontent.FieldUserID:
+		return m.UserID()
+	case usercontent.FieldReferenceID:
+		return m.ReferenceID()
+	case usercontent.FieldValue:
+		return m.Value()
+	case usercontent.FieldMetadata:
+		return m.Metadata()
+	}
+	return nil, false
+}
+
+// OldField returns the old value of the field from the database. An error is
+// returned if the mutation operation is not UpdateOne, or the query to the
+// database failed.
+func (m *UserContentMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
+	switch name {
+	case usercontent.FieldCreatedAt:
+		return m.OldCreatedAt(ctx)
+	case usercontent.FieldUpdatedAt:
+		return m.OldUpdatedAt(ctx)
+	case usercontent.FieldType:
+		return m.OldType(ctx)
+	case usercontent.FieldUserID:
+		return m.OldUserID(ctx)
+	case usercontent.FieldReferenceID:
+		return m.OldReferenceID(ctx)
+	case usercontent.FieldValue:
+		return m.OldValue(ctx)
+	case usercontent.FieldMetadata:
+		return m.OldMetadata(ctx)
+	}
+	return nil, fmt.Errorf("unknown UserContent field %s", name)
+}
+
+// SetField sets the value of a field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *UserContentMutation) SetField(name string, value ent.Value) error {
+	switch name {
+	case usercontent.FieldCreatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetCreatedAt(v)
+		return nil
+	case usercontent.FieldUpdatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetUpdatedAt(v)
+		return nil
+	case usercontent.FieldType:
+		v, ok := value.(models.UserContentType)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetType(v)
+		return nil
+	case usercontent.FieldUserID:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetUserID(v)
+		return nil
+	case usercontent.FieldReferenceID:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetReferenceID(v)
+		return nil
+	case usercontent.FieldValue:
+		v, ok := value.(any)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetValue(v)
+		return nil
+	case usercontent.FieldMetadata:
+		v, ok := value.(map[string]interface{})
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetMetadata(v)
+		return nil
+	}
+	return fmt.Errorf("unknown UserContent field %s", name)
+}
+
+// AddedFields returns all numeric fields that were incremented/decremented during
+// this mutation.
+func (m *UserContentMutation) AddedFields() []string {
+	var fields []string
+	if m.addcreated_at != nil {
+		fields = append(fields, usercontent.FieldCreatedAt)
+	}
+	if m.addupdated_at != nil {
+		fields = append(fields, usercontent.FieldUpdatedAt)
+	}
+	return fields
+}
+
+// AddedField returns the numeric value that was incremented/decremented on a field
+// with the given name. The second boolean return value indicates that this field
+// was not set, or was not defined in the schema.
+func (m *UserContentMutation) AddedField(name string) (ent.Value, bool) {
+	switch name {
+	case usercontent.FieldCreatedAt:
+		return m.AddedCreatedAt()
+	case usercontent.FieldUpdatedAt:
+		return m.AddedUpdatedAt()
+	}
+	return nil, false
+}
+
+// AddField adds the value to the field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *UserContentMutation) AddField(name string, value ent.Value) error {
+	switch name {
+	case usercontent.FieldCreatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddCreatedAt(v)
+		return nil
+	case usercontent.FieldUpdatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddUpdatedAt(v)
+		return nil
+	}
+	return fmt.Errorf("unknown UserContent numeric field %s", name)
+}
+
+// ClearedFields returns all nullable fields that were cleared during this
+// mutation.
+func (m *UserContentMutation) ClearedFields() []string {
+	return nil
+}
+
+// FieldCleared returns a boolean indicating if a field with the given name was
+// cleared in this mutation.
+func (m *UserContentMutation) FieldCleared(name string) bool {
+	_, ok := m.clearedFields[name]
+	return ok
+}
+
+// ClearField clears the value of the field with the given name. It returns an
+// error if the field is not defined in the schema.
+func (m *UserContentMutation) ClearField(name string) error {
+	return fmt.Errorf("unknown UserContent nullable field %s", name)
+}
+
+// ResetField resets all changes in the mutation for the field with the given name.
+// It returns an error if the field is not defined in the schema.
+func (m *UserContentMutation) ResetField(name string) error {
+	switch name {
+	case usercontent.FieldCreatedAt:
+		m.ResetCreatedAt()
+		return nil
+	case usercontent.FieldUpdatedAt:
+		m.ResetUpdatedAt()
+		return nil
+	case usercontent.FieldType:
+		m.ResetType()
+		return nil
+	case usercontent.FieldUserID:
+		m.ResetUserID()
+		return nil
+	case usercontent.FieldReferenceID:
+		m.ResetReferenceID()
+		return nil
+	case usercontent.FieldValue:
+		m.ResetValue()
+		return nil
+	case usercontent.FieldMetadata:
+		m.ResetMetadata()
+		return nil
+	}
+	return fmt.Errorf("unknown UserContent field %s", name)
+}
+
+// AddedEdges returns all edge names that were set/added in this mutation.
+func (m *UserContentMutation) AddedEdges() []string {
+	edges := make([]string, 0, 1)
+	if m.user != nil {
+		edges = append(edges, usercontent.EdgeUser)
+	}
+	return edges
+}
+
+// AddedIDs returns all IDs (to other nodes) that were added for the given edge
+// name in this mutation.
+func (m *UserContentMutation) AddedIDs(name string) []ent.Value {
+	switch name {
+	case usercontent.EdgeUser:
+		if id := m.user; id != nil {
+			return []ent.Value{*id}
+		}
+	}
+	return nil
+}
+
+// RemovedEdges returns all edge names that were removed in this mutation.
+func (m *UserContentMutation) RemovedEdges() []string {
+	edges := make([]string, 0, 1)
+	return edges
+}
+
+// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
+// the given name in this mutation.
+func (m *UserContentMutation) RemovedIDs(name string) []ent.Value {
+	return nil
+}
+
+// ClearedEdges returns all edge names that were cleared in this mutation.
+func (m *UserContentMutation) ClearedEdges() []string {
+	edges := make([]string, 0, 1)
+	if m.cleareduser {
+		edges = append(edges, usercontent.EdgeUser)
+	}
+	return edges
+}
+
+// EdgeCleared returns a boolean which indicates if the edge with the given name
+// was cleared in this mutation.
+func (m *UserContentMutation) EdgeCleared(name string) bool {
+	switch name {
+	case usercontent.EdgeUser:
+		return m.cleareduser
+	}
+	return false
+}
+
+// ClearEdge clears the value of the edge with the given name. It returns an error
+// if that edge is not defined in the schema.
+func (m *UserContentMutation) ClearEdge(name string) error {
+	switch name {
+	case usercontent.EdgeUser:
+		m.ClearUser()
+		return nil
+	}
+	return fmt.Errorf("unknown UserContent unique edge %s", name)
+}
+
+// ResetEdge resets all changes to the edge with the given name in this mutation.
+// It returns an error if the edge is not defined in the schema.
+func (m *UserContentMutation) ResetEdge(name string) error {
+	switch name {
+	case usercontent.EdgeUser:
+		m.ResetUser()
+		return nil
+	}
+	return fmt.Errorf("unknown UserContent edge %s", name)
+}
+
+// UserSubscriptionMutation represents an operation that mutates the UserSubscription nodes in the graph.
+type UserSubscriptionMutation struct {
+	config
+	op            Op
+	typ           string
+	id            *string
+	created_at    *int
+	addcreated_at *int
+	updated_at    *int
+	addupdated_at *int
+	_type         *models.SubscriptionType
+	expires_at    *int
+	addexpires_at *int
+	permissions   *string
+	reference_id  *string
+	clearedFields map[string]struct{}
+	user          *string
+	cleareduser   bool
+	done          bool
+	oldValue      func(context.Context) (*UserSubscription, error)
+	predicates    []predicate.UserSubscription
+}
+
+var _ ent.Mutation = (*UserSubscriptionMutation)(nil)
+
+// usersubscriptionOption allows management of the mutation configuration using functional options.
+type usersubscriptionOption func(*UserSubscriptionMutation)
+
+// newUserSubscriptionMutation creates new mutation for the UserSubscription entity.
+func newUserSubscriptionMutation(c config, op Op, opts ...usersubscriptionOption) *UserSubscriptionMutation {
+	m := &UserSubscriptionMutation{
+		config:        c,
+		op:            op,
+		typ:           TypeUserSubscription,
+		clearedFields: make(map[string]struct{}),
+	}
+	for _, opt := range opts {
+		opt(m)
+	}
+	return m
+}
+
+// withUserSubscriptionID sets the ID field of the mutation.
+func withUserSubscriptionID(id string) usersubscriptionOption {
+	return func(m *UserSubscriptionMutation) {
+		var (
+			err   error
+			once  sync.Once
+			value *UserSubscription
+		)
+		m.oldValue = func(ctx context.Context) (*UserSubscription, error) {
+			once.Do(func() {
+				if m.done {
+					err = errors.New("querying old values post mutation is not allowed")
+				} else {
+					value, err = m.Client().UserSubscription.Get(ctx, id)
+				}
+			})
+			return value, err
+		}
+		m.id = &id
+	}
+}
+
+// withUserSubscription sets the old UserSubscription of the mutation.
+func withUserSubscription(node *UserSubscription) usersubscriptionOption {
+	return func(m *UserSubscriptionMutation) {
+		m.oldValue = func(context.Context) (*UserSubscription, error) {
+			return node, nil
+		}
+		m.id = &node.ID
+	}
+}
+
+// Client returns a new `ent.Client` from the mutation. If the mutation was
+// executed in a transaction (ent.Tx), a transactional client is returned.
+func (m UserSubscriptionMutation) Client() *Client {
+	client := &Client{config: m.config}
+	client.init()
+	return client
+}
+
+// Tx returns an `ent.Tx` for mutations that were executed in transactions;
+// it returns an error otherwise.
+func (m UserSubscriptionMutation) Tx() (*Tx, error) {
+	if _, ok := m.driver.(*txDriver); !ok {
+		return nil, errors.New("db: mutation is not running in a transaction")
+	}
+	tx := &Tx{config: m.config}
+	tx.init()
+	return tx, nil
+}
+
+// SetID sets the value of the id field. Note that this
+// operation is only accepted on creation of UserSubscription entities.
+func (m *UserSubscriptionMutation) SetID(id string) {
+	m.id = &id
+}
+
+// ID returns the ID value in the mutation. Note that the ID is only available
+// if it was provided to the builder or after it was returned from the database.
+func (m *UserSubscriptionMutation) ID() (id string, exists bool) {
+	if m.id == nil {
+		return
+	}
+	return *m.id, true
+}
+
+// IDs queries the database and returns the entity ids that match the mutation's predicate.
+// That means, if the mutation is applied within a transaction with an isolation level such
+// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
+// or updated by the mutation.
+func (m *UserSubscriptionMutation) IDs(ctx context.Context) ([]string, error) {
+	switch {
+	case m.op.Is(OpUpdateOne | OpDeleteOne):
+		id, exists := m.ID()
+		if exists {
+			return []string{id}, nil
+		}
+		fallthrough
+	case m.op.Is(OpUpdate | OpDelete):
+		return m.Client().UserSubscription.Query().Where(m.predicates...).IDs(ctx)
+	default:
+		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
+	}
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (m *UserSubscriptionMutation) SetCreatedAt(i int) {
+	m.created_at = &i
+	m.addcreated_at = nil
+}
+
+// CreatedAt returns the value of the "created_at" field in the mutation.
+func (m *UserSubscriptionMutation) CreatedAt() (r int, exists bool) {
+	v := m.created_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldCreatedAt returns the old "created_at" field's value of the UserSubscription entity.
+// If the UserSubscription object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserSubscriptionMutation) OldCreatedAt(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldCreatedAt requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
+	}
+	return oldValue.CreatedAt, nil
+}
+
+// AddCreatedAt adds i to the "created_at" field.
+func (m *UserSubscriptionMutation) AddCreatedAt(i int) {
+	if m.addcreated_at != nil {
+		*m.addcreated_at += i
+	} else {
+		m.addcreated_at = &i
+	}
+}
+
+// AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
+func (m *UserSubscriptionMutation) AddedCreatedAt() (r int, exists bool) {
+	v := m.addcreated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetCreatedAt resets all changes to the "created_at" field.
+func (m *UserSubscriptionMutation) ResetCreatedAt() {
+	m.created_at = nil
+	m.addcreated_at = nil
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (m *UserSubscriptionMutation) SetUpdatedAt(i int) {
+	m.updated_at = &i
+	m.addupdated_at = nil
+}
+
+// UpdatedAt returns the value of the "updated_at" field in the mutation.
+func (m *UserSubscriptionMutation) UpdatedAt() (r int, exists bool) {
+	v := m.updated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldUpdatedAt returns the old "updated_at" field's value of the UserSubscription entity.
+// If the UserSubscription object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserSubscriptionMutation) OldUpdatedAt(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
+	}
+	return oldValue.UpdatedAt, nil
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (m *UserSubscriptionMutation) AddUpdatedAt(i int) {
+	if m.addupdated_at != nil {
+		*m.addupdated_at += i
+	} else {
+		m.addupdated_at = &i
+	}
+}
+
+// AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
+func (m *UserSubscriptionMutation) AddedUpdatedAt() (r int, exists bool) {
+	v := m.addupdated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetUpdatedAt resets all changes to the "updated_at" field.
+func (m *UserSubscriptionMutation) ResetUpdatedAt() {
+	m.updated_at = nil
+	m.addupdated_at = nil
+}
+
+// SetType sets the "type" field.
+func (m *UserSubscriptionMutation) SetType(mt models.SubscriptionType) {
+	m._type = &mt
+}
+
+// GetType returns the value of the "type" field in the mutation.
+func (m *UserSubscriptionMutation) GetType() (r models.SubscriptionType, exists bool) {
+	v := m._type
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldType returns the old "type" field's value of the UserSubscription entity.
+// If the UserSubscription object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserSubscriptionMutation) OldType(ctx context.Context) (v models.SubscriptionType, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldType is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldType requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldType: %w", err)
+	}
+	return oldValue.Type, nil
+}
+
+// ResetType resets all changes to the "type" field.
+func (m *UserSubscriptionMutation) ResetType() {
+	m._type = nil
+}
+
+// SetExpiresAt sets the "expires_at" field.
+func (m *UserSubscriptionMutation) SetExpiresAt(i int) {
+	m.expires_at = &i
+	m.addexpires_at = nil
+}
+
+// ExpiresAt returns the value of the "expires_at" field in the mutation.
+func (m *UserSubscriptionMutation) ExpiresAt() (r int, exists bool) {
+	v := m.expires_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldExpiresAt returns the old "expires_at" field's value of the UserSubscription entity.
+// If the UserSubscription object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserSubscriptionMutation) OldExpiresAt(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldExpiresAt is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldExpiresAt requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldExpiresAt: %w", err)
+	}
+	return oldValue.ExpiresAt, nil
+}
+
+// AddExpiresAt adds i to the "expires_at" field.
+func (m *UserSubscriptionMutation) AddExpiresAt(i int) {
+	if m.addexpires_at != nil {
+		*m.addexpires_at += i
+	} else {
+		m.addexpires_at = &i
+	}
+}
+
+// AddedExpiresAt returns the value that was added to the "expires_at" field in this mutation.
+func (m *UserSubscriptionMutation) AddedExpiresAt() (r int, exists bool) {
+	v := m.addexpires_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetExpiresAt resets all changes to the "expires_at" field.
+func (m *UserSubscriptionMutation) ResetExpiresAt() {
+	m.expires_at = nil
+	m.addexpires_at = nil
+}
+
+// SetUserID sets the "user_id" field.
+func (m *UserSubscriptionMutation) SetUserID(s string) {
+	m.user = &s
+}
+
+// UserID returns the value of the "user_id" field in the mutation.
+func (m *UserSubscriptionMutation) UserID() (r string, exists bool) {
+	v := m.user
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldUserID returns the old "user_id" field's value of the UserSubscription entity.
+// If the UserSubscription object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserSubscriptionMutation) OldUserID(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldUserID is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldUserID requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldUserID: %w", err)
+	}
+	return oldValue.UserID, nil
+}
+
+// ResetUserID resets all changes to the "user_id" field.
+func (m *UserSubscriptionMutation) ResetUserID() {
+	m.user = nil
+}
+
+// SetPermissions sets the "permissions" field.
+func (m *UserSubscriptionMutation) SetPermissions(s string) {
+	m.permissions = &s
+}
+
+// Permissions returns the value of the "permissions" field in the mutation.
+func (m *UserSubscriptionMutation) Permissions() (r string, exists bool) {
+	v := m.permissions
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldPermissions returns the old "permissions" field's value of the UserSubscription entity.
+// If the UserSubscription object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserSubscriptionMutation) OldPermissions(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldPermissions is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldPermissions requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldPermissions: %w", err)
+	}
+	return oldValue.Permissions, nil
+}
+
+// ResetPermissions resets all changes to the "permissions" field.
+func (m *UserSubscriptionMutation) ResetPermissions() {
+	m.permissions = nil
+}
+
+// SetReferenceID sets the "reference_id" field.
+func (m *UserSubscriptionMutation) SetReferenceID(s string) {
+	m.reference_id = &s
+}
+
+// ReferenceID returns the value of the "reference_id" field in the mutation.
+func (m *UserSubscriptionMutation) ReferenceID() (r string, exists bool) {
+	v := m.reference_id
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldReferenceID returns the old "reference_id" field's value of the UserSubscription entity.
+// If the UserSubscription object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserSubscriptionMutation) OldReferenceID(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldReferenceID is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldReferenceID requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldReferenceID: %w", err)
+	}
+	return oldValue.ReferenceID, nil
+}
+
+// ResetReferenceID resets all changes to the "reference_id" field.
+func (m *UserSubscriptionMutation) ResetReferenceID() {
+	m.reference_id = nil
+}
+
+// ClearUser clears the "user" edge to the User entity.
+func (m *UserSubscriptionMutation) ClearUser() {
+	m.cleareduser = true
+	m.clearedFields[usersubscription.FieldUserID] = struct{}{}
+}
+
+// UserCleared reports if the "user" edge to the User entity was cleared.
+func (m *UserSubscriptionMutation) UserCleared() bool {
+	return m.cleareduser
+}
+
+// UserIDs returns the "user" edge IDs in the mutation.
+// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
+// UserID instead. It exists only for internal usage by the builders.
+func (m *UserSubscriptionMutation) UserIDs() (ids []string) {
+	if id := m.user; id != nil {
+		ids = append(ids, *id)
+	}
+	return
+}
+
+// ResetUser resets all changes to the "user" edge.
+func (m *UserSubscriptionMutation) ResetUser() {
+	m.user = nil
+	m.cleareduser = false
+}
+
+// Where appends a list predicates to the UserSubscriptionMutation builder.
+func (m *UserSubscriptionMutation) Where(ps ...predicate.UserSubscription) {
+	m.predicates = append(m.predicates, ps...)
+}
+
+// WhereP appends storage-level predicates to the UserSubscriptionMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *UserSubscriptionMutation) WhereP(ps ...func(*sql.Selector)) {
+	p := make([]predicate.UserSubscription, len(ps))
+	for i := range ps {
+		p[i] = ps[i]
+	}
+	m.Where(p...)
+}
+
+// Op returns the operation name.
+func (m *UserSubscriptionMutation) Op() Op {
+	return m.op
+}
+
+// SetOp allows setting the mutation operation.
+func (m *UserSubscriptionMutation) SetOp(op Op) {
+	m.op = op
+}
+
+// Type returns the node type of this mutation (UserSubscription).
+func (m *UserSubscriptionMutation) Type() string {
+	return m.typ
+}
+
+// Fields returns all fields that were changed during this mutation. Note that in
+// order to get all numeric fields that were incremented/decremented, call
+// AddedFields().
+func (m *UserSubscriptionMutation) Fields() []string {
+	fields := make([]string, 0, 7)
+	if m.created_at != nil {
+		fields = append(fields, usersubscription.FieldCreatedAt)
+	}
+	if m.updated_at != nil {
+		fields = append(fields, usersubscription.FieldUpdatedAt)
+	}
+	if m._type != nil {
+		fields = append(fields, usersubscription.FieldType)
+	}
+	if m.expires_at != nil {
+		fields = append(fields, usersubscription.FieldExpiresAt)
+	}
+	if m.user != nil {
+		fields = append(fields, usersubscription.FieldUserID)
+	}
+	if m.permissions != nil {
+		fields = append(fields, usersubscription.FieldPermissions)
+	}
+	if m.reference_id != nil {
+		fields = append(fields, usersubscription.FieldReferenceID)
+	}
+	return fields
+}
+
+// Field returns the value of a field with the given name. The second boolean
+// return value indicates that this field was not set, or was not defined in the
+// schema.
+func (m *UserSubscriptionMutation) Field(name string) (ent.Value, bool) {
+	switch name {
+	case usersubscription.FieldCreatedAt:
+		return m.CreatedAt()
+	case usersubscription.FieldUpdatedAt:
+		return m.UpdatedAt()
+	case usersubscription.FieldType:
+		return m.GetType()
+	case usersubscription.FieldExpiresAt:
+		return m.ExpiresAt()
+	case usersubscription.FieldUserID:
+		return m.UserID()
+	case usersubscription.FieldPermissions:
+		return m.Permissions()
+	case usersubscription.FieldReferenceID:
+		return m.ReferenceID()
+	}
+	return nil, false
+}
+
+// OldField returns the old value of the field from the database. An error is
+// returned if the mutation operation is not UpdateOne, or the query to the
+// database failed.
+func (m *UserSubscriptionMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
+	switch name {
+	case usersubscription.FieldCreatedAt:
+		return m.OldCreatedAt(ctx)
+	case usersubscription.FieldUpdatedAt:
+		return m.OldUpdatedAt(ctx)
+	case usersubscription.FieldType:
+		return m.OldType(ctx)
+	case usersubscription.FieldExpiresAt:
+		return m.OldExpiresAt(ctx)
+	case usersubscription.FieldUserID:
+		return m.OldUserID(ctx)
+	case usersubscription.FieldPermissions:
+		return m.OldPermissions(ctx)
+	case usersubscription.FieldReferenceID:
+		return m.OldReferenceID(ctx)
+	}
+	return nil, fmt.Errorf("unknown UserSubscription field %s", name)
+}
+
+// SetField sets the value of a field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *UserSubscriptionMutation) SetField(name string, value ent.Value) error {
+	switch name {
+	case usersubscription.FieldCreatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetCreatedAt(v)
+		return nil
+	case usersubscription.FieldUpdatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetUpdatedAt(v)
+		return nil
+	case usersubscription.FieldType:
+		v, ok := value.(models.SubscriptionType)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetType(v)
+		return nil
+	case usersubscription.FieldExpiresAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetExpiresAt(v)
+		return nil
+	case usersubscription.FieldUserID:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetUserID(v)
+		return nil
+	case usersubscription.FieldPermissions:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetPermissions(v)
+		return nil
+	case usersubscription.FieldReferenceID:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetReferenceID(v)
+		return nil
+	}
+	return fmt.Errorf("unknown UserSubscription field %s", name)
+}
+
+// AddedFields returns all numeric fields that were incremented/decremented during
+// this mutation.
+func (m *UserSubscriptionMutation) AddedFields() []string {
+	var fields []string
+	if m.addcreated_at != nil {
+		fields = append(fields, usersubscription.FieldCreatedAt)
+	}
+	if m.addupdated_at != nil {
+		fields = append(fields, usersubscription.FieldUpdatedAt)
+	}
+	if m.addexpires_at != nil {
+		fields = append(fields, usersubscription.FieldExpiresAt)
+	}
+	return fields
+}
+
+// AddedField returns the numeric value that was incremented/decremented on a field
+// with the given name. The second boolean return value indicates that this field
+// was not set, or was not defined in the schema.
+func (m *UserSubscriptionMutation) AddedField(name string) (ent.Value, bool) {
+	switch name {
+	case usersubscription.FieldCreatedAt:
+		return m.AddedCreatedAt()
+	case usersubscription.FieldUpdatedAt:
+		return m.AddedUpdatedAt()
+	case usersubscription.FieldExpiresAt:
+		return m.AddedExpiresAt()
+	}
+	return nil, false
+}
+
+// AddField adds the value to the field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *UserSubscriptionMutation) AddField(name string, value ent.Value) error {
+	switch name {
+	case usersubscription.FieldCreatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddCreatedAt(v)
+		return nil
+	case usersubscription.FieldUpdatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddUpdatedAt(v)
+		return nil
+	case usersubscription.FieldExpiresAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddExpiresAt(v)
+		return nil
+	}
+	return fmt.Errorf("unknown UserSubscription numeric field %s", name)
+}
+
+// ClearedFields returns all nullable fields that were cleared during this
+// mutation.
+func (m *UserSubscriptionMutation) ClearedFields() []string {
+	return nil
+}
+
+// FieldCleared returns a boolean indicating if a field with the given name was
+// cleared in this mutation.
+func (m *UserSubscriptionMutation) FieldCleared(name string) bool {
+	_, ok := m.clearedFields[name]
+	return ok
+}
+
+// ClearField clears the value of the field with the given name. It returns an
+// error if the field is not defined in the schema.
+func (m *UserSubscriptionMutation) ClearField(name string) error {
+	return fmt.Errorf("unknown UserSubscription nullable field %s", name)
+}
+
+// ResetField resets all changes in the mutation for the field with the given name.
+// It returns an error if the field is not defined in the schema.
+func (m *UserSubscriptionMutation) ResetField(name string) error {
+	switch name {
+	case usersubscription.FieldCreatedAt:
+		m.ResetCreatedAt()
+		return nil
+	case usersubscription.FieldUpdatedAt:
+		m.ResetUpdatedAt()
+		return nil
+	case usersubscription.FieldType:
+		m.ResetType()
+		return nil
+	case usersubscription.FieldExpiresAt:
+		m.ResetExpiresAt()
+		return nil
+	case usersubscription.FieldUserID:
+		m.ResetUserID()
+		return nil
+	case usersubscription.FieldPermissions:
+		m.ResetPermissions()
+		return nil
+	case usersubscription.FieldReferenceID:
+		m.ResetReferenceID()
+		return nil
+	}
+	return fmt.Errorf("unknown UserSubscription field %s", name)
+}
+
+// AddedEdges returns all edge names that were set/added in this mutation.
+func (m *UserSubscriptionMutation) AddedEdges() []string {
+	edges := make([]string, 0, 1)
+	if m.user != nil {
+		edges = append(edges, usersubscription.EdgeUser)
+	}
+	return edges
+}
+
+// AddedIDs returns all IDs (to other nodes) that were added for the given edge
+// name in this mutation.
+func (m *UserSubscriptionMutation) AddedIDs(name string) []ent.Value {
+	switch name {
+	case usersubscription.EdgeUser:
+		if id := m.user; id != nil {
+			return []ent.Value{*id}
+		}
+	}
+	return nil
+}
+
+// RemovedEdges returns all edge names that were removed in this mutation.
+func (m *UserSubscriptionMutation) RemovedEdges() []string {
+	edges := make([]string, 0, 1)
+	return edges
+}
+
+// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
+// the given name in this mutation.
+func (m *UserSubscriptionMutation) RemovedIDs(name string) []ent.Value {
+	return nil
+}
+
+// ClearedEdges returns all edge names that were cleared in this mutation.
+func (m *UserSubscriptionMutation) ClearedEdges() []string {
+	edges := make([]string, 0, 1)
+	if m.cleareduser {
+		edges = append(edges, usersubscription.EdgeUser)
+	}
+	return edges
+}
+
+// EdgeCleared returns a boolean which indicates if the edge with the given name
+// was cleared in this mutation.
+func (m *UserSubscriptionMutation) EdgeCleared(name string) bool {
+	switch name {
+	case usersubscription.EdgeUser:
+		return m.cleareduser
+	}
+	return false
+}
+
+// ClearEdge clears the value of the edge with the given name. It returns an error
+// if that edge is not defined in the schema.
+func (m *UserSubscriptionMutation) ClearEdge(name string) error {
+	switch name {
+	case usersubscription.EdgeUser:
+		m.ClearUser()
+		return nil
+	}
+	return fmt.Errorf("unknown UserSubscription unique edge %s", name)
+}
+
+// ResetEdge resets all changes to the edge with the given name in this mutation.
+// It returns an error if the edge is not defined in the schema.
+func (m *UserSubscriptionMutation) ResetEdge(name string) error {
+	switch name {
+	case usersubscription.EdgeUser:
+		m.ResetUser()
+		return nil
+	}
+	return fmt.Errorf("unknown UserSubscription edge %s", name)
+}
+
+// VehicleMutation represents an operation that mutates the Vehicle nodes in the graph.
+type VehicleMutation struct {
+	config
+	op              Op
+	typ             string
+	id              *string
+	created_at      *int
+	addcreated_at   *int
+	updated_at      *int
+	addupdated_at   *int
+	tier            *int
+	addtier         *int
+	localized_names *map[string]string
+	clearedFields   map[string]struct{}
+	done            bool
+	oldValue        func(context.Context) (*Vehicle, error)
+	predicates      []predicate.Vehicle
+}
+
+var _ ent.Mutation = (*VehicleMutation)(nil)
+
+// vehicleOption allows management of the mutation configuration using functional options.
+type vehicleOption func(*VehicleMutation)
+
+// newVehicleMutation creates new mutation for the Vehicle entity.
+func newVehicleMutation(c config, op Op, opts ...vehicleOption) *VehicleMutation {
+	m := &VehicleMutation{
+		config:        c,
+		op:            op,
+		typ:           TypeVehicle,
+		clearedFields: make(map[string]struct{}),
+	}
+	for _, opt := range opts {
+		opt(m)
+	}
+	return m
+}
+
+// withVehicleID sets the ID field of the mutation.
+func withVehicleID(id string) vehicleOption {
+	return func(m *VehicleMutation) {
+		var (
+			err   error
+			once  sync.Once
+			value *Vehicle
+		)
+		m.oldValue = func(ctx context.Context) (*Vehicle, error) {
+			once.Do(func() {
+				if m.done {
+					err = errors.New("querying old values post mutation is not allowed")
+				} else {
+					value, err = m.Client().Vehicle.Get(ctx, id)
+				}
+			})
+			return value, err
+		}
+		m.id = &id
+	}
+}
+
+// withVehicle sets the old Vehicle of the mutation.
+func withVehicle(node *Vehicle) vehicleOption {
+	return func(m *VehicleMutation) {
+		m.oldValue = func(context.Context) (*Vehicle, error) {
+			return node, nil
+		}
+		m.id = &node.ID
+	}
+}
+
+// Client returns a new `ent.Client` from the mutation. If the mutation was
+// executed in a transaction (ent.Tx), a transactional client is returned.
+func (m VehicleMutation) Client() *Client {
+	client := &Client{config: m.config}
+	client.init()
+	return client
+}
+
+// Tx returns an `ent.Tx` for mutations that were executed in transactions;
+// it returns an error otherwise.
+func (m VehicleMutation) Tx() (*Tx, error) {
+	if _, ok := m.driver.(*txDriver); !ok {
+		return nil, errors.New("db: mutation is not running in a transaction")
+	}
+	tx := &Tx{config: m.config}
+	tx.init()
+	return tx, nil
+}
+
+// SetID sets the value of the id field. Note that this
+// operation is only accepted on creation of Vehicle entities.
+func (m *VehicleMutation) SetID(id string) {
+	m.id = &id
+}
+
+// ID returns the ID value in the mutation. Note that the ID is only available
+// if it was provided to the builder or after it was returned from the database.
+func (m *VehicleMutation) ID() (id string, exists bool) {
+	if m.id == nil {
+		return
+	}
+	return *m.id, true
+}
+
+// IDs queries the database and returns the entity ids that match the mutation's predicate.
+// That means, if the mutation is applied within a transaction with an isolation level such
+// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
+// or updated by the mutation.
+func (m *VehicleMutation) IDs(ctx context.Context) ([]string, error) {
+	switch {
+	case m.op.Is(OpUpdateOne | OpDeleteOne):
+		id, exists := m.ID()
+		if exists {
+			return []string{id}, nil
+		}
+		fallthrough
+	case m.op.Is(OpUpdate | OpDelete):
+		return m.Client().Vehicle.Query().Where(m.predicates...).IDs(ctx)
+	default:
+		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
+	}
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (m *VehicleMutation) SetCreatedAt(i int) {
+	m.created_at = &i
+	m.addcreated_at = nil
+}
+
+// CreatedAt returns the value of the "created_at" field in the mutation.
+func (m *VehicleMutation) CreatedAt() (r int, exists bool) {
+	v := m.created_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldCreatedAt returns the old "created_at" field's value of the Vehicle entity.
+// If the Vehicle object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *VehicleMutation) OldCreatedAt(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldCreatedAt requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
+	}
+	return oldValue.CreatedAt, nil
+}
+
+// AddCreatedAt adds i to the "created_at" field.
+func (m *VehicleMutation) AddCreatedAt(i int) {
+	if m.addcreated_at != nil {
+		*m.addcreated_at += i
+	} else {
+		m.addcreated_at = &i
+	}
+}
+
+// AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
+func (m *VehicleMutation) AddedCreatedAt() (r int, exists bool) {
+	v := m.addcreated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetCreatedAt resets all changes to the "created_at" field.
+func (m *VehicleMutation) ResetCreatedAt() {
+	m.created_at = nil
+	m.addcreated_at = nil
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (m *VehicleMutation) SetUpdatedAt(i int) {
+	m.updated_at = &i
+	m.addupdated_at = nil
+}
+
+// UpdatedAt returns the value of the "updated_at" field in the mutation.
+func (m *VehicleMutation) UpdatedAt() (r int, exists bool) {
+	v := m.updated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldUpdatedAt returns the old "updated_at" field's value of the Vehicle entity.
+// If the Vehicle object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *VehicleMutation) OldUpdatedAt(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
+	}
+	return oldValue.UpdatedAt, nil
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (m *VehicleMutation) AddUpdatedAt(i int) {
+	if m.addupdated_at != nil {
+		*m.addupdated_at += i
+	} else {
+		m.addupdated_at = &i
+	}
+}
+
+// AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
+func (m *VehicleMutation) AddedUpdatedAt() (r int, exists bool) {
+	v := m.addupdated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetUpdatedAt resets all changes to the "updated_at" field.
+func (m *VehicleMutation) ResetUpdatedAt() {
+	m.updated_at = nil
+	m.addupdated_at = nil
+}
+
+// SetTier sets the "tier" field.
+func (m *VehicleMutation) SetTier(i int) {
+	m.tier = &i
+	m.addtier = nil
+}
+
+// Tier returns the value of the "tier" field in the mutation.
+func (m *VehicleMutation) Tier() (r int, exists bool) {
+	v := m.tier
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldTier returns the old "tier" field's value of the Vehicle entity.
+// If the Vehicle object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *VehicleMutation) OldTier(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldTier is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldTier requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldTier: %w", err)
+	}
+	return oldValue.Tier, nil
+}
+
+// AddTier adds i to the "tier" field.
+func (m *VehicleMutation) AddTier(i int) {
+	if m.addtier != nil {
+		*m.addtier += i
+	} else {
+		m.addtier = &i
+	}
+}
+
+// AddedTier returns the value that was added to the "tier" field in this mutation.
+func (m *VehicleMutation) AddedTier() (r int, exists bool) {
+	v := m.addtier
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetTier resets all changes to the "tier" field.
+func (m *VehicleMutation) ResetTier() {
+	m.tier = nil
+	m.addtier = nil
+}
+
+// SetLocalizedNames sets the "localized_names" field.
+func (m *VehicleMutation) SetLocalizedNames(value map[string]string) {
+	m.localized_names = &value
+}
+
+// LocalizedNames returns the value of the "localized_names" field in the mutation.
+func (m *VehicleMutation) LocalizedNames() (r map[string]string, exists bool) {
+	v := m.localized_names
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldLocalizedNames returns the old "localized_names" field's value of the Vehicle entity.
+// If the Vehicle object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *VehicleMutation) OldLocalizedNames(ctx context.Context) (v map[string]string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldLocalizedNames is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldLocalizedNames requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldLocalizedNames: %w", err)
+	}
+	return oldValue.LocalizedNames, nil
+}
+
+// ResetLocalizedNames resets all changes to the "localized_names" field.
+func (m *VehicleMutation) ResetLocalizedNames() {
+	m.localized_names = nil
+}
+
+// Where appends a list predicates to the VehicleMutation builder.
+func (m *VehicleMutation) Where(ps ...predicate.Vehicle) {
+	m.predicates = append(m.predicates, ps...)
+}
+
+// WhereP appends storage-level predicates to the VehicleMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *VehicleMutation) WhereP(ps ...func(*sql.Selector)) {
+	p := make([]predicate.Vehicle, len(ps))
+	for i := range ps {
+		p[i] = ps[i]
+	}
+	m.Where(p...)
+}
+
+// Op returns the operation name.
+func (m *VehicleMutation) Op() Op {
+	return m.op
+}
+
+// SetOp allows setting the mutation operation.
+func (m *VehicleMutation) SetOp(op Op) {
+	m.op = op
+}
+
+// Type returns the node type of this mutation (Vehicle).
+func (m *VehicleMutation) Type() string {
+	return m.typ
+}
+
+// Fields returns all fields that were changed during this mutation. Note that in
+// order to get all numeric fields that were incremented/decremented, call
+// AddedFields().
+func (m *VehicleMutation) Fields() []string {
+	fields := make([]string, 0, 4)
+	if m.created_at != nil {
+		fields = append(fields, vehicle.FieldCreatedAt)
+	}
+	if m.updated_at != nil {
+		fields = append(fields, vehicle.FieldUpdatedAt)
+	}
+	if m.tier != nil {
+		fields = append(fields, vehicle.FieldTier)
+	}
+	if m.localized_names != nil {
+		fields = append(fields, vehicle.FieldLocalizedNames)
+	}
+	return fields
+}
+
+// Field returns the value of a field with the given name. The second boolean
+// return value indicates that this field was not set, or was not defined in the
+// schema.
+func (m *VehicleMutation) Field(name string) (ent.Value, bool) {
+	switch name {
+	case vehicle.FieldCreatedAt:
+		return m.CreatedAt()
+	case vehicle.FieldUpdatedAt:
+		return m.UpdatedAt()
+	case vehicle.FieldTier:
+		return m.Tier()
+	case vehicle.FieldLocalizedNames:
+		return m.LocalizedNames()
+	}
+	return nil, false
+}
+
+// OldField returns the old value of the field from the database. An error is
+// returned if the mutation operation is not UpdateOne, or the query to the
+// database failed.
+func (m *VehicleMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
+	switch name {
+	case vehicle.FieldCreatedAt:
+		return m.OldCreatedAt(ctx)
+	case vehicle.FieldUpdatedAt:
+		return m.OldUpdatedAt(ctx)
+	case vehicle.FieldTier:
+		return m.OldTier(ctx)
+	case vehicle.FieldLocalizedNames:
+		return m.OldLocalizedNames(ctx)
+	}
+	return nil, fmt.Errorf("unknown Vehicle field %s", name)
+}
+
+// SetField sets the value of a field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *VehicleMutation) SetField(name string, value ent.Value) error {
+	switch name {
+	case vehicle.FieldCreatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetCreatedAt(v)
+		return nil
+	case vehicle.FieldUpdatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetUpdatedAt(v)
+		return nil
+	case vehicle.FieldTier:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetTier(v)
+		return nil
+	case vehicle.FieldLocalizedNames:
+		v, ok := value.(map[string]string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetLocalizedNames(v)
+		return nil
+	}
+	return fmt.Errorf("unknown Vehicle field %s", name)
+}
+
+// AddedFields returns all numeric fields that were incremented/decremented during
+// this mutation.
+func (m *VehicleMutation) AddedFields() []string {
+	var fields []string
+	if m.addcreated_at != nil {
+		fields = append(fields, vehicle.FieldCreatedAt)
+	}
+	if m.addupdated_at != nil {
+		fields = append(fields, vehicle.FieldUpdatedAt)
+	}
+	if m.addtier != nil {
+		fields = append(fields, vehicle.FieldTier)
+	}
+	return fields
+}
+
+// AddedField returns the numeric value that was incremented/decremented on a field
+// with the given name. The second boolean return value indicates that this field
+// was not set, or was not defined in the schema.
+func (m *VehicleMutation) AddedField(name string) (ent.Value, bool) {
+	switch name {
+	case vehicle.FieldCreatedAt:
+		return m.AddedCreatedAt()
+	case vehicle.FieldUpdatedAt:
+		return m.AddedUpdatedAt()
+	case vehicle.FieldTier:
+		return m.AddedTier()
+	}
+	return nil, false
+}
+
+// AddField adds the value to the field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *VehicleMutation) AddField(name string, value ent.Value) error {
+	switch name {
+	case vehicle.FieldCreatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddCreatedAt(v)
+		return nil
+	case vehicle.FieldUpdatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddUpdatedAt(v)
+		return nil
+	case vehicle.FieldTier:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddTier(v)
+		return nil
+	}
+	return fmt.Errorf("unknown Vehicle numeric field %s", name)
+}
+
+// ClearedFields returns all nullable fields that were cleared during this
+// mutation.
+func (m *VehicleMutation) ClearedFields() []string {
+	return nil
+}
+
+// FieldCleared returns a boolean indicating if a field with the given name was
+// cleared in this mutation.
+func (m *VehicleMutation) FieldCleared(name string) bool {
+	_, ok := m.clearedFields[name]
+	return ok
+}
+
+// ClearField clears the value of the field with the given name. It returns an
+// error if the field is not defined in the schema.
+func (m *VehicleMutation) ClearField(name string) error {
+	return fmt.Errorf("unknown Vehicle nullable field %s", name)
+}
+
+// ResetField resets all changes in the mutation for the field with the given name.
+// It returns an error if the field is not defined in the schema.
+func (m *VehicleMutation) ResetField(name string) error {
+	switch name {
+	case vehicle.FieldCreatedAt:
+		m.ResetCreatedAt()
+		return nil
+	case vehicle.FieldUpdatedAt:
+		m.ResetUpdatedAt()
+		return nil
+	case vehicle.FieldTier:
+		m.ResetTier()
+		return nil
+	case vehicle.FieldLocalizedNames:
+		m.ResetLocalizedNames()
+		return nil
+	}
+	return fmt.Errorf("unknown Vehicle field %s", name)
+}
+
+// AddedEdges returns all edge names that were set/added in this mutation.
+func (m *VehicleMutation) AddedEdges() []string {
+	edges := make([]string, 0, 0)
+	return edges
+}
+
+// AddedIDs returns all IDs (to other nodes) that were added for the given edge
+// name in this mutation.
+func (m *VehicleMutation) AddedIDs(name string) []ent.Value {
+	return nil
+}
+
+// RemovedEdges returns all edge names that were removed in this mutation.
+func (m *VehicleMutation) RemovedEdges() []string {
+	edges := make([]string, 0, 0)
+	return edges
+}
+
+// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
+// the given name in this mutation.
+func (m *VehicleMutation) RemovedIDs(name string) []ent.Value {
+	return nil
+}
+
+// ClearedEdges returns all edge names that were cleared in this mutation.
+func (m *VehicleMutation) ClearedEdges() []string {
+	edges := make([]string, 0, 0)
+	return edges
+}
+
+// EdgeCleared returns a boolean which indicates if the edge with the given name
+// was cleared in this mutation.
+func (m *VehicleMutation) EdgeCleared(name string) bool {
+	return false
+}
+
+// ClearEdge clears the value of the edge with the given name. It returns an error
+// if that edge is not defined in the schema.
+func (m *VehicleMutation) ClearEdge(name string) error {
+	return fmt.Errorf("unknown Vehicle unique edge %s", name)
+}
+
+// ResetEdge resets all changes to the edge with the given name in this mutation.
+// It returns an error if the edge is not defined in the schema.
+func (m *VehicleMutation) ResetEdge(name string) error {
+	return fmt.Errorf("unknown Vehicle edge %s", name)
+}
+
+// VehicleAverageMutation represents an operation that mutates the VehicleAverage nodes in the graph.
+type VehicleAverageMutation struct {
+	config
+	op            Op
+	typ           string
+	id            *string
+	created_at    *int
+	addcreated_at *int
+	updated_at    *int
+	addupdated_at *int
+	data          *map[string]frame.StatsFrame
+	clearedFields map[string]struct{}
+	done          bool
+	oldValue      func(context.Context) (*VehicleAverage, error)
+	predicates    []predicate.VehicleAverage
+}
+
+var _ ent.Mutation = (*VehicleAverageMutation)(nil)
+
+// vehicleaverageOption allows management of the mutation configuration using functional options.
+type vehicleaverageOption func(*VehicleAverageMutation)
+
+// newVehicleAverageMutation creates new mutation for the VehicleAverage entity.
+func newVehicleAverageMutation(c config, op Op, opts ...vehicleaverageOption) *VehicleAverageMutation {
+	m := &VehicleAverageMutation{
+		config:        c,
+		op:            op,
+		typ:           TypeVehicleAverage,
+		clearedFields: make(map[string]struct{}),
+	}
+	for _, opt := range opts {
+		opt(m)
+	}
+	return m
+}
+
+// withVehicleAverageID sets the ID field of the mutation.
+func withVehicleAverageID(id string) vehicleaverageOption {
+	return func(m *VehicleAverageMutation) {
+		var (
+			err   error
+			once  sync.Once
+			value *VehicleAverage
+		)
+		m.oldValue = func(ctx context.Context) (*VehicleAverage, error) {
+			once.Do(func() {
+				if m.done {
+					err = errors.New("querying old values post mutation is not allowed")
+				} else {
+					value, err = m.Client().VehicleAverage.Get(ctx, id)
+				}
+			})
+			return value, err
+		}
+		m.id = &id
+	}
+}
+
+// withVehicleAverage sets the old VehicleAverage of the mutation.
+func withVehicleAverage(node *VehicleAverage) vehicleaverageOption {
+	return func(m *VehicleAverageMutation) {
+		m.oldValue = func(context.Context) (*VehicleAverage, error) {
+			return node, nil
+		}
+		m.id = &node.ID
+	}
+}
+
+// Client returns a new `ent.Client` from the mutation. If the mutation was
+// executed in a transaction (ent.Tx), a transactional client is returned.
+func (m VehicleAverageMutation) Client() *Client {
+	client := &Client{config: m.config}
+	client.init()
+	return client
+}
+
+// Tx returns an `ent.Tx` for mutations that were executed in transactions;
+// it returns an error otherwise.
+func (m VehicleAverageMutation) Tx() (*Tx, error) {
+	if _, ok := m.driver.(*txDriver); !ok {
+		return nil, errors.New("db: mutation is not running in a transaction")
+	}
+	tx := &Tx{config: m.config}
+	tx.init()
+	return tx, nil
+}
+
+// SetID sets the value of the id field. Note that this
+// operation is only accepted on creation of VehicleAverage entities.
+func (m *VehicleAverageMutation) SetID(id string) {
+	m.id = &id
+}
+
+// ID returns the ID value in the mutation. Note that the ID is only available
+// if it was provided to the builder or after it was returned from the database.
+func (m *VehicleAverageMutation) ID() (id string, exists bool) {
+	if m.id == nil {
+		return
+	}
+	return *m.id, true
+}
+
+// IDs queries the database and returns the entity ids that match the mutation's predicate.
+// That means, if the mutation is applied within a transaction with an isolation level such
+// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
+// or updated by the mutation.
+func (m *VehicleAverageMutation) IDs(ctx context.Context) ([]string, error) {
+	switch {
+	case m.op.Is(OpUpdateOne | OpDeleteOne):
+		id, exists := m.ID()
+		if exists {
+			return []string{id}, nil
+		}
+		fallthrough
+	case m.op.Is(OpUpdate | OpDelete):
+		return m.Client().VehicleAverage.Query().Where(m.predicates...).IDs(ctx)
+	default:
+		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
+	}
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (m *VehicleAverageMutation) SetCreatedAt(i int) {
+	m.created_at = &i
+	m.addcreated_at = nil
+}
+
+// CreatedAt returns the value of the "created_at" field in the mutation.
+func (m *VehicleAverageMutation) CreatedAt() (r int, exists bool) {
+	v := m.created_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldCreatedAt returns the old "created_at" field's value of the VehicleAverage entity.
+// If the VehicleAverage object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *VehicleAverageMutation) OldCreatedAt(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldCreatedAt requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
+	}
+	return oldValue.CreatedAt, nil
+}
+
+// AddCreatedAt adds i to the "created_at" field.
+func (m *VehicleAverageMutation) AddCreatedAt(i int) {
+	if m.addcreated_at != nil {
+		*m.addcreated_at += i
+	} else {
+		m.addcreated_at = &i
+	}
+}
+
+// AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
+func (m *VehicleAverageMutation) AddedCreatedAt() (r int, exists bool) {
+	v := m.addcreated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetCreatedAt resets all changes to the "created_at" field.
+func (m *VehicleAverageMutation) ResetCreatedAt() {
+	m.created_at = nil
+	m.addcreated_at = nil
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (m *VehicleAverageMutation) SetUpdatedAt(i int) {
+	m.updated_at = &i
+	m.addupdated_at = nil
+}
+
+// UpdatedAt returns the value of the "updated_at" field in the mutation.
+func (m *VehicleAverageMutation) UpdatedAt() (r int, exists bool) {
+	v := m.updated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldUpdatedAt returns the old "updated_at" field's value of the VehicleAverage entity.
+// If the VehicleAverage object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *VehicleAverageMutation) OldUpdatedAt(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
+	}
+	return oldValue.UpdatedAt, nil
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (m *VehicleAverageMutation) AddUpdatedAt(i int) {
+	if m.addupdated_at != nil {
+		*m.addupdated_at += i
+	} else {
+		m.addupdated_at = &i
+	}
+}
+
+// AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
+func (m *VehicleAverageMutation) AddedUpdatedAt() (r int, exists bool) {
+	v := m.addupdated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetUpdatedAt resets all changes to the "updated_at" field.
+func (m *VehicleAverageMutation) ResetUpdatedAt() {
+	m.updated_at = nil
+	m.addupdated_at = nil
+}
+
+// SetData sets the "data" field.
+func (m *VehicleAverageMutation) SetData(mf map[string]frame.StatsFrame) {
+	m.data = &mf
+}
+
+// Data returns the value of the "data" field in the mutation.
+func (m *VehicleAverageMutation) Data() (r map[string]frame.StatsFrame, exists bool) {
+	v := m.data
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldData returns the old "data" field's value of the VehicleAverage entity.
+// If the VehicleAverage object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *VehicleAverageMutation) OldData(ctx context.Context) (v map[string]frame.StatsFrame, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldData is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldData requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldData: %w", err)
+	}
+	return oldValue.Data, nil
+}
+
+// ResetData resets all changes to the "data" field.
+func (m *VehicleAverageMutation) ResetData() {
+	m.data = nil
+}
+
+// Where appends a list predicates to the VehicleAverageMutation builder.
+func (m *VehicleAverageMutation) Where(ps ...predicate.VehicleAverage) {
+	m.predicates = append(m.predicates, ps...)
+}
+
+// WhereP appends storage-level predicates to the VehicleAverageMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *VehicleAverageMutation) WhereP(ps ...func(*sql.Selector)) {
+	p := make([]predicate.VehicleAverage, len(ps))
+	for i := range ps {
+		p[i] = ps[i]
+	}
+	m.Where(p...)
+}
+
+// Op returns the operation name.
+func (m *VehicleAverageMutation) Op() Op {
+	return m.op
+}
+
+// SetOp allows setting the mutation operation.
+func (m *VehicleAverageMutation) SetOp(op Op) {
+	m.op = op
+}
+
+// Type returns the node type of this mutation (VehicleAverage).
+func (m *VehicleAverageMutation) Type() string {
+	return m.typ
+}
+
+// Fields returns all fields that were changed during this mutation. Note that in
+// order to get all numeric fields that were incremented/decremented, call
+// AddedFields().
+func (m *VehicleAverageMutation) Fields() []string {
+	fields := make([]string, 0, 3)
+	if m.created_at != nil {
+		fields = append(fields, vehicleaverage.FieldCreatedAt)
+	}
+	if m.updated_at != nil {
+		fields = append(fields, vehicleaverage.FieldUpdatedAt)
+	}
+	if m.data != nil {
+		fields = append(fields, vehicleaverage.FieldData)
+	}
+	return fields
+}
+
+// Field returns the value of a field with the given name. The second boolean
+// return value indicates that this field was not set, or was not defined in the
+// schema.
+func (m *VehicleAverageMutation) Field(name string) (ent.Value, bool) {
+	switch name {
+	case vehicleaverage.FieldCreatedAt:
+		return m.CreatedAt()
+	case vehicleaverage.FieldUpdatedAt:
+		return m.UpdatedAt()
+	case vehicleaverage.FieldData:
+		return m.Data()
+	}
+	return nil, false
+}
+
+// OldField returns the old value of the field from the database. An error is
+// returned if the mutation operation is not UpdateOne, or the query to the
+// database failed.
+func (m *VehicleAverageMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
+	switch name {
+	case vehicleaverage.FieldCreatedAt:
+		return m.OldCreatedAt(ctx)
+	case vehicleaverage.FieldUpdatedAt:
+		return m.OldUpdatedAt(ctx)
+	case vehicleaverage.FieldData:
+		return m.OldData(ctx)
+	}
+	return nil, fmt.Errorf("unknown VehicleAverage field %s", name)
+}
+
+// SetField sets the value of a field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *VehicleAverageMutation) SetField(name string, value ent.Value) error {
+	switch name {
+	case vehicleaverage.FieldCreatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetCreatedAt(v)
+		return nil
+	case vehicleaverage.FieldUpdatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetUpdatedAt(v)
+		return nil
+	case vehicleaverage.FieldData:
+		v, ok := value.(map[string]frame.StatsFrame)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetData(v)
+		return nil
+	}
+	return fmt.Errorf("unknown VehicleAverage field %s", name)
+}
+
+// AddedFields returns all numeric fields that were incremented/decremented during
+// this mutation.
+func (m *VehicleAverageMutation) AddedFields() []string {
+	var fields []string
+	if m.addcreated_at != nil {
+		fields = append(fields, vehicleaverage.FieldCreatedAt)
+	}
+	if m.addupdated_at != nil {
+		fields = append(fields, vehicleaverage.FieldUpdatedAt)
+	}
+	return fields
+}
+
+// AddedField returns the numeric value that was incremented/decremented on a field
+// with the given name. The second boolean return value indicates that this field
+// was not set, or was not defined in the schema.
+func (m *VehicleAverageMutation) AddedField(name string) (ent.Value, bool) {
+	switch name {
+	case vehicleaverage.FieldCreatedAt:
+		return m.AddedCreatedAt()
+	case vehicleaverage.FieldUpdatedAt:
+		return m.AddedUpdatedAt()
+	}
+	return nil, false
+}
+
+// AddField adds the value to the field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *VehicleAverageMutation) AddField(name string, value ent.Value) error {
+	switch name {
+	case vehicleaverage.FieldCreatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddCreatedAt(v)
+		return nil
+	case vehicleaverage.FieldUpdatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddUpdatedAt(v)
+		return nil
+	}
+	return fmt.Errorf("unknown VehicleAverage numeric field %s", name)
+}
+
+// ClearedFields returns all nullable fields that were cleared during this
+// mutation.
+func (m *VehicleAverageMutation) ClearedFields() []string {
+	return nil
+}
+
+// FieldCleared returns a boolean indicating if a field with the given name was
+// cleared in this mutation.
+func (m *VehicleAverageMutation) FieldCleared(name string) bool {
+	_, ok := m.clearedFields[name]
+	return ok
+}
+
+// ClearField clears the value of the field with the given name. It returns an
+// error if the field is not defined in the schema.
+func (m *VehicleAverageMutation) ClearField(name string) error {
+	return fmt.Errorf("unknown VehicleAverage nullable field %s", name)
+}
+
+// ResetField resets all changes in the mutation for the field with the given name.
+// It returns an error if the field is not defined in the schema.
+func (m *VehicleAverageMutation) ResetField(name string) error {
+	switch name {
+	case vehicleaverage.FieldCreatedAt:
+		m.ResetCreatedAt()
+		return nil
+	case vehicleaverage.FieldUpdatedAt:
+		m.ResetUpdatedAt()
+		return nil
+	case vehicleaverage.FieldData:
+		m.ResetData()
+		return nil
+	}
+	return fmt.Errorf("unknown VehicleAverage field %s", name)
+}
+
+// AddedEdges returns all edge names that were set/added in this mutation.
+func (m *VehicleAverageMutation) AddedEdges() []string {
+	edges := make([]string, 0, 0)
+	return edges
+}
+
+// AddedIDs returns all IDs (to other nodes) that were added for the given edge
+// name in this mutation.
+func (m *VehicleAverageMutation) AddedIDs(name string) []ent.Value {
+	return nil
+}
+
+// RemovedEdges returns all edge names that were removed in this mutation.
+func (m *VehicleAverageMutation) RemovedEdges() []string {
+	edges := make([]string, 0, 0)
+	return edges
+}
+
+// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
+// the given name in this mutation.
+func (m *VehicleAverageMutation) RemovedIDs(name string) []ent.Value {
+	return nil
+}
+
+// ClearedEdges returns all edge names that were cleared in this mutation.
+func (m *VehicleAverageMutation) ClearedEdges() []string {
+	edges := make([]string, 0, 0)
+	return edges
+}
+
+// EdgeCleared returns a boolean which indicates if the edge with the given name
+// was cleared in this mutation.
+func (m *VehicleAverageMutation) EdgeCleared(name string) bool {
+	return false
+}
+
+// ClearEdge clears the value of the edge with the given name. It returns an error
+// if that edge is not defined in the schema.
+func (m *VehicleAverageMutation) ClearEdge(name string) error {
+	return fmt.Errorf("unknown VehicleAverage unique edge %s", name)
+}
+
+// ResetEdge resets all changes to the edge with the given name in this mutation.
+// It returns an error if the edge is not defined in the schema.
+func (m *VehicleAverageMutation) ResetEdge(name string) error {
+	return fmt.Errorf("unknown VehicleAverage edge %s", name)
+}
+
+// VehicleSnapshotMutation represents an operation that mutates the VehicleSnapshot nodes in the graph.
+type VehicleSnapshotMutation struct {
+	config
+	op                  Op
+	typ                 string
+	id                  *string
+	created_at          *int
+	addcreated_at       *int
+	updated_at          *int
+	addupdated_at       *int
+	_type               *models.SnapshotType
+	vehicle_id          *string
+	reference_id        *string
+	battles             *int
+	addbattles          *int
+	last_battle_time    *int
+	addlast_battle_time *int
+	frame               *frame.StatsFrame
+	clearedFields       map[string]struct{}
+	account             *string
+	clearedaccount      bool
+	done                bool
+	oldValue            func(context.Context) (*VehicleSnapshot, error)
+	predicates          []predicate.VehicleSnapshot
+}
+
+var _ ent.Mutation = (*VehicleSnapshotMutation)(nil)
+
+// vehiclesnapshotOption allows management of the mutation configuration using functional options.
+type vehiclesnapshotOption func(*VehicleSnapshotMutation)
+
+// newVehicleSnapshotMutation creates new mutation for the VehicleSnapshot entity.
+func newVehicleSnapshotMutation(c config, op Op, opts ...vehiclesnapshotOption) *VehicleSnapshotMutation {
+	m := &VehicleSnapshotMutation{
+		config:        c,
+		op:            op,
+		typ:           TypeVehicleSnapshot,
+		clearedFields: make(map[string]struct{}),
+	}
+	for _, opt := range opts {
+		opt(m)
+	}
+	return m
+}
+
+// withVehicleSnapshotID sets the ID field of the mutation.
+func withVehicleSnapshotID(id string) vehiclesnapshotOption {
+	return func(m *VehicleSnapshotMutation) {
+		var (
+			err   error
+			once  sync.Once
+			value *VehicleSnapshot
+		)
+		m.oldValue = func(ctx context.Context) (*VehicleSnapshot, error) {
+			once.Do(func() {
+				if m.done {
+					err = errors.New("querying old values post mutation is not allowed")
+				} else {
+					value, err = m.Client().VehicleSnapshot.Get(ctx, id)
+				}
+			})
+			return value, err
+		}
+		m.id = &id
+	}
+}
+
+// withVehicleSnapshot sets the old VehicleSnapshot of the mutation.
+func withVehicleSnapshot(node *VehicleSnapshot) vehiclesnapshotOption {
+	return func(m *VehicleSnapshotMutation) {
+		m.oldValue = func(context.Context) (*VehicleSnapshot, error) {
+			return node, nil
+		}
+		m.id = &node.ID
+	}
+}
+
+// Client returns a new `ent.Client` from the mutation. If the mutation was
+// executed in a transaction (ent.Tx), a transactional client is returned.
+func (m VehicleSnapshotMutation) Client() *Client {
+	client := &Client{config: m.config}
+	client.init()
+	return client
+}
+
+// Tx returns an `ent.Tx` for mutations that were executed in transactions;
+// it returns an error otherwise.
+func (m VehicleSnapshotMutation) Tx() (*Tx, error) {
+	if _, ok := m.driver.(*txDriver); !ok {
+		return nil, errors.New("db: mutation is not running in a transaction")
+	}
+	tx := &Tx{config: m.config}
+	tx.init()
+	return tx, nil
+}
+
+// SetID sets the value of the id field. Note that this
+// operation is only accepted on creation of VehicleSnapshot entities.
+func (m *VehicleSnapshotMutation) SetID(id string) {
+	m.id = &id
+}
+
+// ID returns the ID value in the mutation. Note that the ID is only available
+// if it was provided to the builder or after it was returned from the database.
+func (m *VehicleSnapshotMutation) ID() (id string, exists bool) {
+	if m.id == nil {
+		return
+	}
+	return *m.id, true
+}
+
+// IDs queries the database and returns the entity ids that match the mutation's predicate.
+// That means, if the mutation is applied within a transaction with an isolation level such
+// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
+// or updated by the mutation.
+func (m *VehicleSnapshotMutation) IDs(ctx context.Context) ([]string, error) {
+	switch {
+	case m.op.Is(OpUpdateOne | OpDeleteOne):
+		id, exists := m.ID()
+		if exists {
+			return []string{id}, nil
+		}
+		fallthrough
+	case m.op.Is(OpUpdate | OpDelete):
+		return m.Client().VehicleSnapshot.Query().Where(m.predicates...).IDs(ctx)
+	default:
+		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
+	}
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (m *VehicleSnapshotMutation) SetCreatedAt(i int) {
+	m.created_at = &i
+	m.addcreated_at = nil
+}
+
+// CreatedAt returns the value of the "created_at" field in the mutation.
+func (m *VehicleSnapshotMutation) CreatedAt() (r int, exists bool) {
+	v := m.created_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldCreatedAt returns the old "created_at" field's value of the VehicleSnapshot entity.
+// If the VehicleSnapshot object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *VehicleSnapshotMutation) OldCreatedAt(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldCreatedAt requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
+	}
+	return oldValue.CreatedAt, nil
+}
+
+// AddCreatedAt adds i to the "created_at" field.
+func (m *VehicleSnapshotMutation) AddCreatedAt(i int) {
+	if m.addcreated_at != nil {
+		*m.addcreated_at += i
+	} else {
+		m.addcreated_at = &i
+	}
+}
+
+// AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
+func (m *VehicleSnapshotMutation) AddedCreatedAt() (r int, exists bool) {
+	v := m.addcreated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetCreatedAt resets all changes to the "created_at" field.
+func (m *VehicleSnapshotMutation) ResetCreatedAt() {
+	m.created_at = nil
+	m.addcreated_at = nil
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (m *VehicleSnapshotMutation) SetUpdatedAt(i int) {
+	m.updated_at = &i
+	m.addupdated_at = nil
+}
+
+// UpdatedAt returns the value of the "updated_at" field in the mutation.
+func (m *VehicleSnapshotMutation) UpdatedAt() (r int, exists bool) {
+	v := m.updated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldUpdatedAt returns the old "updated_at" field's value of the VehicleSnapshot entity.
+// If the VehicleSnapshot object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *VehicleSnapshotMutation) OldUpdatedAt(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
+	}
+	return oldValue.UpdatedAt, nil
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (m *VehicleSnapshotMutation) AddUpdatedAt(i int) {
+	if m.addupdated_at != nil {
+		*m.addupdated_at += i
+	} else {
+		m.addupdated_at = &i
+	}
+}
+
+// AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
+func (m *VehicleSnapshotMutation) AddedUpdatedAt() (r int, exists bool) {
+	v := m.addupdated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetUpdatedAt resets all changes to the "updated_at" field.
+func (m *VehicleSnapshotMutation) ResetUpdatedAt() {
+	m.updated_at = nil
+	m.addupdated_at = nil
+}
+
+// SetType sets the "type" field.
+func (m *VehicleSnapshotMutation) SetType(mt models.SnapshotType) {
+	m._type = &mt
+}
+
+// GetType returns the value of the "type" field in the mutation.
+func (m *VehicleSnapshotMutation) GetType() (r models.SnapshotType, exists bool) {
+	v := m._type
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldType returns the old "type" field's value of the VehicleSnapshot entity.
+// If the VehicleSnapshot object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *VehicleSnapshotMutation) OldType(ctx context.Context) (v models.SnapshotType, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldType is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldType requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldType: %w", err)
+	}
+	return oldValue.Type, nil
+}
+
+// ResetType resets all changes to the "type" field.
+func (m *VehicleSnapshotMutation) ResetType() {
+	m._type = nil
+}
+
+// SetAccountID sets the "account_id" field.
+func (m *VehicleSnapshotMutation) SetAccountID(s string) {
+	m.account = &s
+}
+
+// AccountID returns the value of the "account_id" field in the mutation.
+func (m *VehicleSnapshotMutation) AccountID() (r string, exists bool) {
+	v := m.account
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldAccountID returns the old "account_id" field's value of the VehicleSnapshot entity.
+// If the VehicleSnapshot object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *VehicleSnapshotMutation) OldAccountID(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldAccountID is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldAccountID requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldAccountID: %w", err)
+	}
+	return oldValue.AccountID, nil
+}
+
+// ResetAccountID resets all changes to the "account_id" field.
+func (m *VehicleSnapshotMutation) ResetAccountID() {
+	m.account = nil
+}
+
+// SetVehicleID sets the "vehicle_id" field.
+func (m *VehicleSnapshotMutation) SetVehicleID(s string) {
+	m.vehicle_id = &s
+}
+
+// VehicleID returns the value of the "vehicle_id" field in the mutation.
+func (m *VehicleSnapshotMutation) VehicleID() (r string, exists bool) {
+	v := m.vehicle_id
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldVehicleID returns the old "vehicle_id" field's value of the VehicleSnapshot entity.
+// If the VehicleSnapshot object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *VehicleSnapshotMutation) OldVehicleID(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldVehicleID is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldVehicleID requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldVehicleID: %w", err)
+	}
+	return oldValue.VehicleID, nil
+}
+
+// ResetVehicleID resets all changes to the "vehicle_id" field.
+func (m *VehicleSnapshotMutation) ResetVehicleID() {
+	m.vehicle_id = nil
+}
+
+// SetReferenceID sets the "reference_id" field.
+func (m *VehicleSnapshotMutation) SetReferenceID(s string) {
+	m.reference_id = &s
+}
+
+// ReferenceID returns the value of the "reference_id" field in the mutation.
+func (m *VehicleSnapshotMutation) ReferenceID() (r string, exists bool) {
+	v := m.reference_id
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldReferenceID returns the old "reference_id" field's value of the VehicleSnapshot entity.
+// If the VehicleSnapshot object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *VehicleSnapshotMutation) OldReferenceID(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldReferenceID is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldReferenceID requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldReferenceID: %w", err)
+	}
+	return oldValue.ReferenceID, nil
+}
+
+// ResetReferenceID resets all changes to the "reference_id" field.
+func (m *VehicleSnapshotMutation) ResetReferenceID() {
+	m.reference_id = nil
+}
+
+// SetBattles sets the "battles" field.
+func (m *VehicleSnapshotMutation) SetBattles(i int) {
+	m.battles = &i
+	m.addbattles = nil
+}
+
+// Battles returns the value of the "battles" field in the mutation.
+func (m *VehicleSnapshotMutation) Battles() (r int, exists bool) {
+	v := m.battles
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldBattles returns the old "battles" field's value of the VehicleSnapshot entity.
+// If the VehicleSnapshot object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *VehicleSnapshotMutation) OldBattles(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldBattles is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldBattles requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldBattles: %w", err)
+	}
+	return oldValue.Battles, nil
+}
+
+// AddBattles adds i to the "battles" field.
+func (m *VehicleSnapshotMutation) AddBattles(i int) {
+	if m.addbattles != nil {
+		*m.addbattles += i
+	} else {
+		m.addbattles = &i
+	}
+}
+
+// AddedBattles returns the value that was added to the "battles" field in this mutation.
+func (m *VehicleSnapshotMutation) AddedBattles() (r int, exists bool) {
+	v := m.addbattles
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetBattles resets all changes to the "battles" field.
+func (m *VehicleSnapshotMutation) ResetBattles() {
+	m.battles = nil
+	m.addbattles = nil
+}
+
+// SetLastBattleTime sets the "last_battle_time" field.
+func (m *VehicleSnapshotMutation) SetLastBattleTime(i int) {
+	m.last_battle_time = &i
+	m.addlast_battle_time = nil
+}
+
+// LastBattleTime returns the value of the "last_battle_time" field in the mutation.
+func (m *VehicleSnapshotMutation) LastBattleTime() (r int, exists bool) {
+	v := m.last_battle_time
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldLastBattleTime returns the old "last_battle_time" field's value of the VehicleSnapshot entity.
+// If the VehicleSnapshot object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *VehicleSnapshotMutation) OldLastBattleTime(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldLastBattleTime is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldLastBattleTime requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldLastBattleTime: %w", err)
+	}
+	return oldValue.LastBattleTime, nil
+}
+
+// AddLastBattleTime adds i to the "last_battle_time" field.
+func (m *VehicleSnapshotMutation) AddLastBattleTime(i int) {
+	if m.addlast_battle_time != nil {
+		*m.addlast_battle_time += i
+	} else {
+		m.addlast_battle_time = &i
+	}
+}
+
+// AddedLastBattleTime returns the value that was added to the "last_battle_time" field in this mutation.
+func (m *VehicleSnapshotMutation) AddedLastBattleTime() (r int, exists bool) {
+	v := m.addlast_battle_time
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetLastBattleTime resets all changes to the "last_battle_time" field.
+func (m *VehicleSnapshotMutation) ResetLastBattleTime() {
+	m.last_battle_time = nil
+	m.addlast_battle_time = nil
+}
+
+// SetFrame sets the "frame" field.
+func (m *VehicleSnapshotMutation) SetFrame(ff frame.StatsFrame) {
+	m.frame = &ff
+}
+
+// Frame returns the value of the "frame" field in the mutation.
+func (m *VehicleSnapshotMutation) Frame() (r frame.StatsFrame, exists bool) {
+	v := m.frame
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldFrame returns the old "frame" field's value of the VehicleSnapshot entity.
+// If the VehicleSnapshot object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *VehicleSnapshotMutation) OldFrame(ctx context.Context) (v frame.StatsFrame, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldFrame is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldFrame requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldFrame: %w", err)
+	}
+	return oldValue.Frame, nil
+}
+
+// ResetFrame resets all changes to the "frame" field.
+func (m *VehicleSnapshotMutation) ResetFrame() {
+	m.frame = nil
+}
+
+// ClearAccount clears the "account" edge to the Account entity.
+func (m *VehicleSnapshotMutation) ClearAccount() {
+	m.clearedaccount = true
+	m.clearedFields[vehiclesnapshot.FieldAccountID] = struct{}{}
+}
+
+// AccountCleared reports if the "account" edge to the Account entity was cleared.
+func (m *VehicleSnapshotMutation) AccountCleared() bool {
+	return m.clearedaccount
+}
+
+// AccountIDs returns the "account" edge IDs in the mutation.
+// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
+// AccountID instead. It exists only for internal usage by the builders.
+func (m *VehicleSnapshotMutation) AccountIDs() (ids []string) {
+	if id := m.account; id != nil {
+		ids = append(ids, *id)
+	}
+	return
+}
+
+// ResetAccount resets all changes to the "account" edge.
+func (m *VehicleSnapshotMutation) ResetAccount() {
+	m.account = nil
+	m.clearedaccount = false
+}
+
+// Where appends a list predicates to the VehicleSnapshotMutation builder.
+func (m *VehicleSnapshotMutation) Where(ps ...predicate.VehicleSnapshot) {
+	m.predicates = append(m.predicates, ps...)
+}
+
+// WhereP appends storage-level predicates to the VehicleSnapshotMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *VehicleSnapshotMutation) WhereP(ps ...func(*sql.Selector)) {
+	p := make([]predicate.VehicleSnapshot, len(ps))
+	for i := range ps {
+		p[i] = ps[i]
+	}
+	m.Where(p...)
+}
+
+// Op returns the operation name.
+func (m *VehicleSnapshotMutation) Op() Op {
+	return m.op
+}
+
+// SetOp allows setting the mutation operation.
+func (m *VehicleSnapshotMutation) SetOp(op Op) {
+	m.op = op
+}
+
+// Type returns the node type of this mutation (VehicleSnapshot).
+func (m *VehicleSnapshotMutation) Type() string {
+	return m.typ
+}
+
+// Fields returns all fields that were changed during this mutation. Note that in
+// order to get all numeric fields that were incremented/decremented, call
+// AddedFields().
+func (m *VehicleSnapshotMutation) Fields() []string {
+	fields := make([]string, 0, 9)
+	if m.created_at != nil {
+		fields = append(fields, vehiclesnapshot.FieldCreatedAt)
+	}
+	if m.updated_at != nil {
+		fields = append(fields, vehiclesnapshot.FieldUpdatedAt)
+	}
+	if m._type != nil {
+		fields = append(fields, vehiclesnapshot.FieldType)
+	}
+	if m.account != nil {
+		fields = append(fields, vehiclesnapshot.FieldAccountID)
+	}
+	if m.vehicle_id != nil {
+		fields = append(fields, vehiclesnapshot.FieldVehicleID)
+	}
+	if m.reference_id != nil {
+		fields = append(fields, vehiclesnapshot.FieldReferenceID)
+	}
+	if m.battles != nil {
+		fields = append(fields, vehiclesnapshot.FieldBattles)
+	}
+	if m.last_battle_time != nil {
+		fields = append(fields, vehiclesnapshot.FieldLastBattleTime)
+	}
+	if m.frame != nil {
+		fields = append(fields, vehiclesnapshot.FieldFrame)
+	}
+	return fields
+}
+
+// Field returns the value of a field with the given name. The second boolean
+// return value indicates that this field was not set, or was not defined in the
+// schema.
+func (m *VehicleSnapshotMutation) Field(name string) (ent.Value, bool) {
+	switch name {
+	case vehiclesnapshot.FieldCreatedAt:
+		return m.CreatedAt()
+	case vehiclesnapshot.FieldUpdatedAt:
+		return m.UpdatedAt()
+	case vehiclesnapshot.FieldType:
+		return m.GetType()
+	case vehiclesnapshot.FieldAccountID:
+		return m.AccountID()
+	case vehiclesnapshot.FieldVehicleID:
+		return m.VehicleID()
+	case vehiclesnapshot.FieldReferenceID:
+		return m.ReferenceID()
+	case vehiclesnapshot.FieldBattles:
+		return m.Battles()
+	case vehiclesnapshot.FieldLastBattleTime:
+		return m.LastBattleTime()
+	case vehiclesnapshot.FieldFrame:
+		return m.Frame()
+	}
+	return nil, false
+}
+
+// OldField returns the old value of the field from the database. An error is
+// returned if the mutation operation is not UpdateOne, or the query to the
+// database failed.
+func (m *VehicleSnapshotMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
+	switch name {
+	case vehiclesnapshot.FieldCreatedAt:
+		return m.OldCreatedAt(ctx)
+	case vehiclesnapshot.FieldUpdatedAt:
+		return m.OldUpdatedAt(ctx)
+	case vehiclesnapshot.FieldType:
+		return m.OldType(ctx)
+	case vehiclesnapshot.FieldAccountID:
+		return m.OldAccountID(ctx)
+	case vehiclesnapshot.FieldVehicleID:
+		return m.OldVehicleID(ctx)
+	case vehiclesnapshot.FieldReferenceID:
+		return m.OldReferenceID(ctx)
+	case vehiclesnapshot.FieldBattles:
+		return m.OldBattles(ctx)
+	case vehiclesnapshot.FieldLastBattleTime:
+		return m.OldLastBattleTime(ctx)
+	case vehiclesnapshot.FieldFrame:
+		return m.OldFrame(ctx)
+	}
+	return nil, fmt.Errorf("unknown VehicleSnapshot field %s", name)
+}
+
+// SetField sets the value of a field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *VehicleSnapshotMutation) SetField(name string, value ent.Value) error {
+	switch name {
+	case vehiclesnapshot.FieldCreatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetCreatedAt(v)
+		return nil
+	case vehiclesnapshot.FieldUpdatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetUpdatedAt(v)
+		return nil
+	case vehiclesnapshot.FieldType:
+		v, ok := value.(models.SnapshotType)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetType(v)
+		return nil
+	case vehiclesnapshot.FieldAccountID:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetAccountID(v)
+		return nil
+	case vehiclesnapshot.FieldVehicleID:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetVehicleID(v)
+		return nil
+	case vehiclesnapshot.FieldReferenceID:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetReferenceID(v)
+		return nil
+	case vehiclesnapshot.FieldBattles:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetBattles(v)
+		return nil
+	case vehiclesnapshot.FieldLastBattleTime:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetLastBattleTime(v)
+		return nil
+	case vehiclesnapshot.FieldFrame:
+		v, ok := value.(frame.StatsFrame)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetFrame(v)
+		return nil
+	}
+	return fmt.Errorf("unknown VehicleSnapshot field %s", name)
+}
+
+// AddedFields returns all numeric fields that were incremented/decremented during
+// this mutation.
+func (m *VehicleSnapshotMutation) AddedFields() []string {
+	var fields []string
+	if m.addcreated_at != nil {
+		fields = append(fields, vehiclesnapshot.FieldCreatedAt)
+	}
+	if m.addupdated_at != nil {
+		fields = append(fields, vehiclesnapshot.FieldUpdatedAt)
+	}
+	if m.addbattles != nil {
+		fields = append(fields, vehiclesnapshot.FieldBattles)
+	}
+	if m.addlast_battle_time != nil {
+		fields = append(fields, vehiclesnapshot.FieldLastBattleTime)
+	}
+	return fields
+}
+
+// AddedField returns the numeric value that was incremented/decremented on a field
+// with the given name. The second boolean return value indicates that this field
+// was not set, or was not defined in the schema.
+func (m *VehicleSnapshotMutation) AddedField(name string) (ent.Value, bool) {
+	switch name {
+	case vehiclesnapshot.FieldCreatedAt:
+		return m.AddedCreatedAt()
+	case vehiclesnapshot.FieldUpdatedAt:
+		return m.AddedUpdatedAt()
+	case vehiclesnapshot.FieldBattles:
+		return m.AddedBattles()
+	case vehiclesnapshot.FieldLastBattleTime:
+		return m.AddedLastBattleTime()
+	}
+	return nil, false
+}
+
+// AddField adds the value to the field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *VehicleSnapshotMutation) AddField(name string, value ent.Value) error {
+	switch name {
+	case vehiclesnapshot.FieldCreatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddCreatedAt(v)
+		return nil
+	case vehiclesnapshot.FieldUpdatedAt:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddUpdatedAt(v)
+		return nil
+	case vehiclesnapshot.FieldBattles:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddBattles(v)
+		return nil
+	case vehiclesnapshot.FieldLastBattleTime:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddLastBattleTime(v)
+		return nil
+	}
+	return fmt.Errorf("unknown VehicleSnapshot numeric field %s", name)
+}
+
+// ClearedFields returns all nullable fields that were cleared during this
+// mutation.
+func (m *VehicleSnapshotMutation) ClearedFields() []string {
+	return nil
+}
+
+// FieldCleared returns a boolean indicating if a field with the given name was
+// cleared in this mutation.
+func (m *VehicleSnapshotMutation) FieldCleared(name string) bool {
+	_, ok := m.clearedFields[name]
+	return ok
+}
+
+// ClearField clears the value of the field with the given name. It returns an
+// error if the field is not defined in the schema.
+func (m *VehicleSnapshotMutation) ClearField(name string) error {
+	return fmt.Errorf("unknown VehicleSnapshot nullable field %s", name)
+}
+
+// ResetField resets all changes in the mutation for the field with the given name.
+// It returns an error if the field is not defined in the schema.
+func (m *VehicleSnapshotMutation) ResetField(name string) error {
+	switch name {
+	case vehiclesnapshot.FieldCreatedAt:
+		m.ResetCreatedAt()
+		return nil
+	case vehiclesnapshot.FieldUpdatedAt:
+		m.ResetUpdatedAt()
+		return nil
+	case vehiclesnapshot.FieldType:
+		m.ResetType()
+		return nil
+	case vehiclesnapshot.FieldAccountID:
+		m.ResetAccountID()
+		return nil
+	case vehiclesnapshot.FieldVehicleID:
+		m.ResetVehicleID()
+		return nil
+	case vehiclesnapshot.FieldReferenceID:
+		m.ResetReferenceID()
+		return nil
+	case vehiclesnapshot.FieldBattles:
+		m.ResetBattles()
+		return nil
+	case vehiclesnapshot.FieldLastBattleTime:
+		m.ResetLastBattleTime()
+		return nil
+	case vehiclesnapshot.FieldFrame:
+		m.ResetFrame()
+		return nil
+	}
+	return fmt.Errorf("unknown VehicleSnapshot field %s", name)
+}
+
+// AddedEdges returns all edge names that were set/added in this mutation.
+func (m *VehicleSnapshotMutation) AddedEdges() []string {
+	edges := make([]string, 0, 1)
+	if m.account != nil {
+		edges = append(edges, vehiclesnapshot.EdgeAccount)
+	}
+	return edges
+}
+
+// AddedIDs returns all IDs (to other nodes) that were added for the given edge
+// name in this mutation.
+func (m *VehicleSnapshotMutation) AddedIDs(name string) []ent.Value {
+	switch name {
+	case vehiclesnapshot.EdgeAccount:
+		if id := m.account; id != nil {
+			return []ent.Value{*id}
+		}
+	}
+	return nil
+}
+
+// RemovedEdges returns all edge names that were removed in this mutation.
+func (m *VehicleSnapshotMutation) RemovedEdges() []string {
+	edges := make([]string, 0, 1)
+	return edges
+}
+
+// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
+// the given name in this mutation.
+func (m *VehicleSnapshotMutation) RemovedIDs(name string) []ent.Value {
+	return nil
+}
+
+// ClearedEdges returns all edge names that were cleared in this mutation.
+func (m *VehicleSnapshotMutation) ClearedEdges() []string {
+	edges := make([]string, 0, 1)
+	if m.clearedaccount {
+		edges = append(edges, vehiclesnapshot.EdgeAccount)
+	}
+	return edges
+}
+
+// EdgeCleared returns a boolean which indicates if the edge with the given name
+// was cleared in this mutation.
+func (m *VehicleSnapshotMutation) EdgeCleared(name string) bool {
+	switch name {
+	case vehiclesnapshot.EdgeAccount:
+		return m.clearedaccount
+	}
+	return false
+}
+
+// ClearEdge clears the value of the edge with the given name. It returns an error
+// if that edge is not defined in the schema.
+func (m *VehicleSnapshotMutation) ClearEdge(name string) error {
+	switch name {
+	case vehiclesnapshot.EdgeAccount:
+		m.ClearAccount()
+		return nil
+	}
+	return fmt.Errorf("unknown VehicleSnapshot unique edge %s", name)
+}
+
+// ResetEdge resets all changes to the edge with the given name in this mutation.
+// It returns an error if the edge is not defined in the schema.
+func (m *VehicleSnapshotMutation) ResetEdge(name string) error {
+	switch name {
+	case vehiclesnapshot.EdgeAccount:
+		m.ResetAccount()
+		return nil
+	}
+	return fmt.Errorf("unknown VehicleSnapshot edge %s", name)
+}
diff --git a/internal/database/ent/db/predicate/predicate.go b/internal/database/ent/db/predicate/predicate.go
new file mode 100644
index 00000000..899084f2
--- /dev/null
+++ b/internal/database/ent/db/predicate/predicate.go
@@ -0,0 +1,49 @@
+// Code generated by ent, DO NOT EDIT.
+
+package predicate
+
+import (
+	"entgo.io/ent/dialect/sql"
+)
+
+// Account is the predicate function for account builders.
+type Account func(*sql.Selector)
+
+// AccountSnapshot is the predicate function for accountsnapshot builders.
+type AccountSnapshot func(*sql.Selector)
+
+// AchievementsSnapshot is the predicate function for achievementssnapshot builders.
+type AchievementsSnapshot func(*sql.Selector)
+
+// AppConfiguration is the predicate function for appconfiguration builders.
+type AppConfiguration func(*sql.Selector)
+
+// ApplicationCommand is the predicate function for applicationcommand builders.
+type ApplicationCommand func(*sql.Selector)
+
+// Clan is the predicate function for clan builders.
+type Clan func(*sql.Selector)
+
+// CronTask is the predicate function for crontask builders.
+type CronTask func(*sql.Selector)
+
+// User is the predicate function for user builders.
+type User func(*sql.Selector)
+
+// UserConnection is the predicate function for userconnection builders.
+type UserConnection func(*sql.Selector)
+
+// UserContent is the predicate function for usercontent builders.
+type UserContent func(*sql.Selector)
+
+// UserSubscription is the predicate function for usersubscription builders.
+type UserSubscription func(*sql.Selector)
+
+// Vehicle is the predicate function for vehicle builders.
+type Vehicle func(*sql.Selector)
+
+// VehicleAverage is the predicate function for vehicleaverage builders.
+type VehicleAverage func(*sql.Selector)
+
+// VehicleSnapshot is the predicate function for vehiclesnapshot builders.
+type VehicleSnapshot func(*sql.Selector)
diff --git a/internal/database/ent/db/runtime.go b/internal/database/ent/db/runtime.go
new file mode 100644
index 00000000..15bfe7e8
--- /dev/null
+++ b/internal/database/ent/db/runtime.go
@@ -0,0 +1,363 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"github.com/cufee/aftermath/internal/database/ent/db/account"
+	"github.com/cufee/aftermath/internal/database/ent/db/accountsnapshot"
+	"github.com/cufee/aftermath/internal/database/ent/db/achievementssnapshot"
+	"github.com/cufee/aftermath/internal/database/ent/db/appconfiguration"
+	"github.com/cufee/aftermath/internal/database/ent/db/applicationcommand"
+	"github.com/cufee/aftermath/internal/database/ent/db/clan"
+	"github.com/cufee/aftermath/internal/database/ent/db/crontask"
+	"github.com/cufee/aftermath/internal/database/ent/db/user"
+	"github.com/cufee/aftermath/internal/database/ent/db/userconnection"
+	"github.com/cufee/aftermath/internal/database/ent/db/usercontent"
+	"github.com/cufee/aftermath/internal/database/ent/db/usersubscription"
+	"github.com/cufee/aftermath/internal/database/ent/db/vehicle"
+	"github.com/cufee/aftermath/internal/database/ent/db/vehicleaverage"
+	"github.com/cufee/aftermath/internal/database/ent/db/vehiclesnapshot"
+	"github.com/cufee/aftermath/internal/database/ent/schema"
+)
+
+// The init function reads all schema descriptors with runtime code
+// (default values, validators, hooks and policies) and stitches it
+// to their package variables.
+func init() {
+	accountFields := schema.Account{}.Fields()
+	_ = accountFields
+	// accountDescCreatedAt is the schema descriptor for created_at field.
+	accountDescCreatedAt := accountFields[1].Descriptor()
+	// account.DefaultCreatedAt holds the default value on creation for the created_at field.
+	account.DefaultCreatedAt = accountDescCreatedAt.Default.(func() int)
+	// accountDescUpdatedAt is the schema descriptor for updated_at field.
+	accountDescUpdatedAt := accountFields[2].Descriptor()
+	// account.DefaultUpdatedAt holds the default value on creation for the updated_at field.
+	account.DefaultUpdatedAt = accountDescUpdatedAt.Default.(func() int)
+	// account.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
+	account.UpdateDefaultUpdatedAt = accountDescUpdatedAt.UpdateDefault.(func() int)
+	// accountDescRealm is the schema descriptor for realm field.
+	accountDescRealm := accountFields[5].Descriptor()
+	// account.RealmValidator is a validator for the "realm" field. It is called by the builders before save.
+	account.RealmValidator = func() func(string) error {
+		validators := accountDescRealm.Validators
+		fns := [...]func(string) error{
+			validators[0].(func(string) error),
+			validators[1].(func(string) error),
+		}
+		return func(realm string) error {
+			for _, fn := range fns {
+				if err := fn(realm); err != nil {
+					return err
+				}
+			}
+			return nil
+		}
+	}()
+	// accountDescNickname is the schema descriptor for nickname field.
+	accountDescNickname := accountFields[6].Descriptor()
+	// account.NicknameValidator is a validator for the "nickname" field. It is called by the builders before save.
+	account.NicknameValidator = accountDescNickname.Validators[0].(func(string) error)
+	// accountDescPrivate is the schema descriptor for private field.
+	accountDescPrivate := accountFields[7].Descriptor()
+	// account.DefaultPrivate holds the default value on creation for the private field.
+	account.DefaultPrivate = accountDescPrivate.Default.(bool)
+	accountsnapshotFields := schema.AccountSnapshot{}.Fields()
+	_ = accountsnapshotFields
+	// accountsnapshotDescCreatedAt is the schema descriptor for created_at field.
+	accountsnapshotDescCreatedAt := accountsnapshotFields[1].Descriptor()
+	// accountsnapshot.DefaultCreatedAt holds the default value on creation for the created_at field.
+	accountsnapshot.DefaultCreatedAt = accountsnapshotDescCreatedAt.Default.(func() int)
+	// accountsnapshotDescUpdatedAt is the schema descriptor for updated_at field.
+	accountsnapshotDescUpdatedAt := accountsnapshotFields[2].Descriptor()
+	// accountsnapshot.DefaultUpdatedAt holds the default value on creation for the updated_at field.
+	accountsnapshot.DefaultUpdatedAt = accountsnapshotDescUpdatedAt.Default.(func() int)
+	// accountsnapshot.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
+	accountsnapshot.UpdateDefaultUpdatedAt = accountsnapshotDescUpdatedAt.UpdateDefault.(func() int)
+	// accountsnapshotDescAccountID is the schema descriptor for account_id field.
+	accountsnapshotDescAccountID := accountsnapshotFields[5].Descriptor()
+	// accountsnapshot.AccountIDValidator is a validator for the "account_id" field. It is called by the builders before save.
+	accountsnapshot.AccountIDValidator = accountsnapshotDescAccountID.Validators[0].(func(string) error)
+	// accountsnapshotDescReferenceID is the schema descriptor for reference_id field.
+	accountsnapshotDescReferenceID := accountsnapshotFields[6].Descriptor()
+	// accountsnapshot.ReferenceIDValidator is a validator for the "reference_id" field. It is called by the builders before save.
+	accountsnapshot.ReferenceIDValidator = accountsnapshotDescReferenceID.Validators[0].(func(string) error)
+	// accountsnapshotDescID is the schema descriptor for id field.
+	accountsnapshotDescID := accountsnapshotFields[0].Descriptor()
+	// accountsnapshot.DefaultID holds the default value on creation for the id field.
+	accountsnapshot.DefaultID = accountsnapshotDescID.Default.(func() string)
+	achievementssnapshotFields := schema.AchievementsSnapshot{}.Fields()
+	_ = achievementssnapshotFields
+	// achievementssnapshotDescCreatedAt is the schema descriptor for created_at field.
+	achievementssnapshotDescCreatedAt := achievementssnapshotFields[1].Descriptor()
+	// achievementssnapshot.DefaultCreatedAt holds the default value on creation for the created_at field.
+	achievementssnapshot.DefaultCreatedAt = achievementssnapshotDescCreatedAt.Default.(func() int)
+	// achievementssnapshotDescUpdatedAt is the schema descriptor for updated_at field.
+	achievementssnapshotDescUpdatedAt := achievementssnapshotFields[2].Descriptor()
+	// achievementssnapshot.DefaultUpdatedAt holds the default value on creation for the updated_at field.
+	achievementssnapshot.DefaultUpdatedAt = achievementssnapshotDescUpdatedAt.Default.(func() int)
+	// achievementssnapshot.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
+	achievementssnapshot.UpdateDefaultUpdatedAt = achievementssnapshotDescUpdatedAt.UpdateDefault.(func() int)
+	// achievementssnapshotDescAccountID is the schema descriptor for account_id field.
+	achievementssnapshotDescAccountID := achievementssnapshotFields[4].Descriptor()
+	// achievementssnapshot.AccountIDValidator is a validator for the "account_id" field. It is called by the builders before save.
+	achievementssnapshot.AccountIDValidator = achievementssnapshotDescAccountID.Validators[0].(func(string) error)
+	// achievementssnapshotDescReferenceID is the schema descriptor for reference_id field.
+	achievementssnapshotDescReferenceID := achievementssnapshotFields[5].Descriptor()
+	// achievementssnapshot.ReferenceIDValidator is a validator for the "reference_id" field. It is called by the builders before save.
+	achievementssnapshot.ReferenceIDValidator = achievementssnapshotDescReferenceID.Validators[0].(func(string) error)
+	// achievementssnapshotDescID is the schema descriptor for id field.
+	achievementssnapshotDescID := achievementssnapshotFields[0].Descriptor()
+	// achievementssnapshot.DefaultID holds the default value on creation for the id field.
+	achievementssnapshot.DefaultID = achievementssnapshotDescID.Default.(func() string)
+	appconfigurationFields := schema.AppConfiguration{}.Fields()
+	_ = appconfigurationFields
+	// appconfigurationDescCreatedAt is the schema descriptor for created_at field.
+	appconfigurationDescCreatedAt := appconfigurationFields[1].Descriptor()
+	// appconfiguration.DefaultCreatedAt holds the default value on creation for the created_at field.
+	appconfiguration.DefaultCreatedAt = appconfigurationDescCreatedAt.Default.(func() int)
+	// appconfigurationDescUpdatedAt is the schema descriptor for updated_at field.
+	appconfigurationDescUpdatedAt := appconfigurationFields[2].Descriptor()
+	// appconfiguration.DefaultUpdatedAt holds the default value on creation for the updated_at field.
+	appconfiguration.DefaultUpdatedAt = appconfigurationDescUpdatedAt.Default.(func() int)
+	// appconfiguration.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
+	appconfiguration.UpdateDefaultUpdatedAt = appconfigurationDescUpdatedAt.UpdateDefault.(func() int)
+	// appconfigurationDescKey is the schema descriptor for key field.
+	appconfigurationDescKey := appconfigurationFields[3].Descriptor()
+	// appconfiguration.KeyValidator is a validator for the "key" field. It is called by the builders before save.
+	appconfiguration.KeyValidator = appconfigurationDescKey.Validators[0].(func(string) error)
+	// appconfigurationDescID is the schema descriptor for id field.
+	appconfigurationDescID := appconfigurationFields[0].Descriptor()
+	// appconfiguration.DefaultID holds the default value on creation for the id field.
+	appconfiguration.DefaultID = appconfigurationDescID.Default.(func() string)
+	applicationcommandFields := schema.ApplicationCommand{}.Fields()
+	_ = applicationcommandFields
+	// applicationcommandDescCreatedAt is the schema descriptor for created_at field.
+	applicationcommandDescCreatedAt := applicationcommandFields[1].Descriptor()
+	// applicationcommand.DefaultCreatedAt holds the default value on creation for the created_at field.
+	applicationcommand.DefaultCreatedAt = applicationcommandDescCreatedAt.Default.(func() int)
+	// applicationcommandDescUpdatedAt is the schema descriptor for updated_at field.
+	applicationcommandDescUpdatedAt := applicationcommandFields[2].Descriptor()
+	// applicationcommand.DefaultUpdatedAt holds the default value on creation for the updated_at field.
+	applicationcommand.DefaultUpdatedAt = applicationcommandDescUpdatedAt.Default.(func() int)
+	// applicationcommand.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
+	applicationcommand.UpdateDefaultUpdatedAt = applicationcommandDescUpdatedAt.UpdateDefault.(func() int)
+	// applicationcommandDescName is the schema descriptor for name field.
+	applicationcommandDescName := applicationcommandFields[3].Descriptor()
+	// applicationcommand.NameValidator is a validator for the "name" field. It is called by the builders before save.
+	applicationcommand.NameValidator = applicationcommandDescName.Validators[0].(func(string) error)
+	// applicationcommandDescVersion is the schema descriptor for version field.
+	applicationcommandDescVersion := applicationcommandFields[4].Descriptor()
+	// applicationcommand.VersionValidator is a validator for the "version" field. It is called by the builders before save.
+	applicationcommand.VersionValidator = applicationcommandDescVersion.Validators[0].(func(string) error)
+	// applicationcommandDescOptionsHash is the schema descriptor for options_hash field.
+	applicationcommandDescOptionsHash := applicationcommandFields[5].Descriptor()
+	// applicationcommand.OptionsHashValidator is a validator for the "options_hash" field. It is called by the builders before save.
+	applicationcommand.OptionsHashValidator = applicationcommandDescOptionsHash.Validators[0].(func(string) error)
+	// applicationcommandDescID is the schema descriptor for id field.
+	applicationcommandDescID := applicationcommandFields[0].Descriptor()
+	// applicationcommand.DefaultID holds the default value on creation for the id field.
+	applicationcommand.DefaultID = applicationcommandDescID.Default.(func() string)
+	clanFields := schema.Clan{}.Fields()
+	_ = clanFields
+	// clanDescCreatedAt is the schema descriptor for created_at field.
+	clanDescCreatedAt := clanFields[1].Descriptor()
+	// clan.DefaultCreatedAt holds the default value on creation for the created_at field.
+	clan.DefaultCreatedAt = clanDescCreatedAt.Default.(func() int)
+	// clanDescUpdatedAt is the schema descriptor for updated_at field.
+	clanDescUpdatedAt := clanFields[2].Descriptor()
+	// clan.DefaultUpdatedAt holds the default value on creation for the updated_at field.
+	clan.DefaultUpdatedAt = clanDescUpdatedAt.Default.(func() int)
+	// clan.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
+	clan.UpdateDefaultUpdatedAt = clanDescUpdatedAt.UpdateDefault.(func() int)
+	// clanDescTag is the schema descriptor for tag field.
+	clanDescTag := clanFields[3].Descriptor()
+	// clan.TagValidator is a validator for the "tag" field. It is called by the builders before save.
+	clan.TagValidator = clanDescTag.Validators[0].(func(string) error)
+	// clanDescName is the schema descriptor for name field.
+	clanDescName := clanFields[4].Descriptor()
+	// clan.NameValidator is a validator for the "name" field. It is called by the builders before save.
+	clan.NameValidator = clanDescName.Validators[0].(func(string) error)
+	// clanDescEmblemID is the schema descriptor for emblem_id field.
+	clanDescEmblemID := clanFields[5].Descriptor()
+	// clan.DefaultEmblemID holds the default value on creation for the emblem_id field.
+	clan.DefaultEmblemID = clanDescEmblemID.Default.(string)
+	crontaskFields := schema.CronTask{}.Fields()
+	_ = crontaskFields
+	// crontaskDescCreatedAt is the schema descriptor for created_at field.
+	crontaskDescCreatedAt := crontaskFields[1].Descriptor()
+	// crontask.DefaultCreatedAt holds the default value on creation for the created_at field.
+	crontask.DefaultCreatedAt = crontaskDescCreatedAt.Default.(func() int)
+	// crontaskDescUpdatedAt is the schema descriptor for updated_at field.
+	crontaskDescUpdatedAt := crontaskFields[2].Descriptor()
+	// crontask.DefaultUpdatedAt holds the default value on creation for the updated_at field.
+	crontask.DefaultUpdatedAt = crontaskDescUpdatedAt.Default.(func() int)
+	// crontask.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
+	crontask.UpdateDefaultUpdatedAt = crontaskDescUpdatedAt.UpdateDefault.(func() int)
+	// crontaskDescType is the schema descriptor for type field.
+	crontaskDescType := crontaskFields[3].Descriptor()
+	// crontask.TypeValidator is a validator for the "type" field. It is called by the builders before save.
+	crontask.TypeValidator = crontaskDescType.Validators[0].(func(string) error)
+	// crontaskDescReferenceID is the schema descriptor for reference_id field.
+	crontaskDescReferenceID := crontaskFields[4].Descriptor()
+	// crontask.ReferenceIDValidator is a validator for the "reference_id" field. It is called by the builders before save.
+	crontask.ReferenceIDValidator = crontaskDescReferenceID.Validators[0].(func(string) error)
+	// crontaskDescStatus is the schema descriptor for status field.
+	crontaskDescStatus := crontaskFields[6].Descriptor()
+	// crontask.StatusValidator is a validator for the "status" field. It is called by the builders before save.
+	crontask.StatusValidator = crontaskDescStatus.Validators[0].(func(string) error)
+	// crontaskDescID is the schema descriptor for id field.
+	crontaskDescID := crontaskFields[0].Descriptor()
+	// crontask.DefaultID holds the default value on creation for the id field.
+	crontask.DefaultID = crontaskDescID.Default.(func() string)
+	userFields := schema.User{}.Fields()
+	_ = userFields
+	// userDescCreatedAt is the schema descriptor for created_at field.
+	userDescCreatedAt := userFields[1].Descriptor()
+	// user.DefaultCreatedAt holds the default value on creation for the created_at field.
+	user.DefaultCreatedAt = userDescCreatedAt.Default.(func() int)
+	// userDescUpdatedAt is the schema descriptor for updated_at field.
+	userDescUpdatedAt := userFields[2].Descriptor()
+	// user.DefaultUpdatedAt holds the default value on creation for the updated_at field.
+	user.DefaultUpdatedAt = userDescUpdatedAt.Default.(func() int)
+	// user.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
+	user.UpdateDefaultUpdatedAt = userDescUpdatedAt.UpdateDefault.(func() int)
+	// userDescPermissions is the schema descriptor for permissions field.
+	userDescPermissions := userFields[3].Descriptor()
+	// user.DefaultPermissions holds the default value on creation for the permissions field.
+	user.DefaultPermissions = userDescPermissions.Default.(string)
+	userconnectionFields := schema.UserConnection{}.Fields()
+	_ = userconnectionFields
+	// userconnectionDescCreatedAt is the schema descriptor for created_at field.
+	userconnectionDescCreatedAt := userconnectionFields[1].Descriptor()
+	// userconnection.DefaultCreatedAt holds the default value on creation for the created_at field.
+	userconnection.DefaultCreatedAt = userconnectionDescCreatedAt.Default.(func() int)
+	// userconnectionDescUpdatedAt is the schema descriptor for updated_at field.
+	userconnectionDescUpdatedAt := userconnectionFields[2].Descriptor()
+	// userconnection.DefaultUpdatedAt holds the default value on creation for the updated_at field.
+	userconnection.DefaultUpdatedAt = userconnectionDescUpdatedAt.Default.(func() int)
+	// userconnection.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
+	userconnection.UpdateDefaultUpdatedAt = userconnectionDescUpdatedAt.UpdateDefault.(func() int)
+	// userconnectionDescPermissions is the schema descriptor for permissions field.
+	userconnectionDescPermissions := userconnectionFields[6].Descriptor()
+	// userconnection.DefaultPermissions holds the default value on creation for the permissions field.
+	userconnection.DefaultPermissions = userconnectionDescPermissions.Default.(string)
+	// userconnectionDescID is the schema descriptor for id field.
+	userconnectionDescID := userconnectionFields[0].Descriptor()
+	// userconnection.DefaultID holds the default value on creation for the id field.
+	userconnection.DefaultID = userconnectionDescID.Default.(func() string)
+	usercontentFields := schema.UserContent{}.Fields()
+	_ = usercontentFields
+	// usercontentDescCreatedAt is the schema descriptor for created_at field.
+	usercontentDescCreatedAt := usercontentFields[1].Descriptor()
+	// usercontent.DefaultCreatedAt holds the default value on creation for the created_at field.
+	usercontent.DefaultCreatedAt = usercontentDescCreatedAt.Default.(func() int)
+	// usercontentDescUpdatedAt is the schema descriptor for updated_at field.
+	usercontentDescUpdatedAt := usercontentFields[2].Descriptor()
+	// usercontent.DefaultUpdatedAt holds the default value on creation for the updated_at field.
+	usercontent.DefaultUpdatedAt = usercontentDescUpdatedAt.Default.(func() int)
+	// usercontent.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
+	usercontent.UpdateDefaultUpdatedAt = usercontentDescUpdatedAt.UpdateDefault.(func() int)
+	// usercontentDescID is the schema descriptor for id field.
+	usercontentDescID := usercontentFields[0].Descriptor()
+	// usercontent.DefaultID holds the default value on creation for the id field.
+	usercontent.DefaultID = usercontentDescID.Default.(func() string)
+	usersubscriptionFields := schema.UserSubscription{}.Fields()
+	_ = usersubscriptionFields
+	// usersubscriptionDescCreatedAt is the schema descriptor for created_at field.
+	usersubscriptionDescCreatedAt := usersubscriptionFields[1].Descriptor()
+	// usersubscription.DefaultCreatedAt holds the default value on creation for the created_at field.
+	usersubscription.DefaultCreatedAt = usersubscriptionDescCreatedAt.Default.(func() int)
+	// usersubscriptionDescUpdatedAt is the schema descriptor for updated_at field.
+	usersubscriptionDescUpdatedAt := usersubscriptionFields[2].Descriptor()
+	// usersubscription.DefaultUpdatedAt holds the default value on creation for the updated_at field.
+	usersubscription.DefaultUpdatedAt = usersubscriptionDescUpdatedAt.Default.(func() int)
+	// usersubscription.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
+	usersubscription.UpdateDefaultUpdatedAt = usersubscriptionDescUpdatedAt.UpdateDefault.(func() int)
+	// usersubscriptionDescUserID is the schema descriptor for user_id field.
+	usersubscriptionDescUserID := usersubscriptionFields[5].Descriptor()
+	// usersubscription.UserIDValidator is a validator for the "user_id" field. It is called by the builders before save.
+	usersubscription.UserIDValidator = usersubscriptionDescUserID.Validators[0].(func(string) error)
+	// usersubscriptionDescPermissions is the schema descriptor for permissions field.
+	usersubscriptionDescPermissions := usersubscriptionFields[6].Descriptor()
+	// usersubscription.PermissionsValidator is a validator for the "permissions" field. It is called by the builders before save.
+	usersubscription.PermissionsValidator = usersubscriptionDescPermissions.Validators[0].(func(string) error)
+	// usersubscriptionDescReferenceID is the schema descriptor for reference_id field.
+	usersubscriptionDescReferenceID := usersubscriptionFields[7].Descriptor()
+	// usersubscription.ReferenceIDValidator is a validator for the "reference_id" field. It is called by the builders before save.
+	usersubscription.ReferenceIDValidator = usersubscriptionDescReferenceID.Validators[0].(func(string) error)
+	// usersubscriptionDescID is the schema descriptor for id field.
+	usersubscriptionDescID := usersubscriptionFields[0].Descriptor()
+	// usersubscription.DefaultID holds the default value on creation for the id field.
+	usersubscription.DefaultID = usersubscriptionDescID.Default.(func() string)
+	vehicleFields := schema.Vehicle{}.Fields()
+	_ = vehicleFields
+	// vehicleDescCreatedAt is the schema descriptor for created_at field.
+	vehicleDescCreatedAt := vehicleFields[1].Descriptor()
+	// vehicle.DefaultCreatedAt holds the default value on creation for the created_at field.
+	vehicle.DefaultCreatedAt = vehicleDescCreatedAt.Default.(func() int)
+	// vehicleDescUpdatedAt is the schema descriptor for updated_at field.
+	vehicleDescUpdatedAt := vehicleFields[2].Descriptor()
+	// vehicle.DefaultUpdatedAt holds the default value on creation for the updated_at field.
+	vehicle.DefaultUpdatedAt = vehicleDescUpdatedAt.Default.(func() int)
+	// vehicle.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
+	vehicle.UpdateDefaultUpdatedAt = vehicleDescUpdatedAt.UpdateDefault.(func() int)
+	// vehicleDescTier is the schema descriptor for tier field.
+	vehicleDescTier := vehicleFields[3].Descriptor()
+	// vehicle.TierValidator is a validator for the "tier" field. It is called by the builders before save.
+	vehicle.TierValidator = func() func(int) error {
+		validators := vehicleDescTier.Validators
+		fns := [...]func(int) error{
+			validators[0].(func(int) error),
+			validators[1].(func(int) error),
+		}
+		return func(tier int) error {
+			for _, fn := range fns {
+				if err := fn(tier); err != nil {
+					return err
+				}
+			}
+			return nil
+		}
+	}()
+	vehicleaverageFields := schema.VehicleAverage{}.Fields()
+	_ = vehicleaverageFields
+	// vehicleaverageDescCreatedAt is the schema descriptor for created_at field.
+	vehicleaverageDescCreatedAt := vehicleaverageFields[1].Descriptor()
+	// vehicleaverage.DefaultCreatedAt holds the default value on creation for the created_at field.
+	vehicleaverage.DefaultCreatedAt = vehicleaverageDescCreatedAt.Default.(func() int)
+	// vehicleaverageDescUpdatedAt is the schema descriptor for updated_at field.
+	vehicleaverageDescUpdatedAt := vehicleaverageFields[2].Descriptor()
+	// vehicleaverage.DefaultUpdatedAt holds the default value on creation for the updated_at field.
+	vehicleaverage.DefaultUpdatedAt = vehicleaverageDescUpdatedAt.Default.(func() int)
+	// vehicleaverage.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
+	vehicleaverage.UpdateDefaultUpdatedAt = vehicleaverageDescUpdatedAt.UpdateDefault.(func() int)
+	vehiclesnapshotFields := schema.VehicleSnapshot{}.Fields()
+	_ = vehiclesnapshotFields
+	// vehiclesnapshotDescCreatedAt is the schema descriptor for created_at field.
+	vehiclesnapshotDescCreatedAt := vehiclesnapshotFields[1].Descriptor()
+	// vehiclesnapshot.DefaultCreatedAt holds the default value on creation for the created_at field.
+	vehiclesnapshot.DefaultCreatedAt = vehiclesnapshotDescCreatedAt.Default.(func() int)
+	// vehiclesnapshotDescUpdatedAt is the schema descriptor for updated_at field.
+	vehiclesnapshotDescUpdatedAt := vehiclesnapshotFields[2].Descriptor()
+	// vehiclesnapshot.DefaultUpdatedAt holds the default value on creation for the updated_at field.
+	vehiclesnapshot.DefaultUpdatedAt = vehiclesnapshotDescUpdatedAt.Default.(func() int)
+	// vehiclesnapshot.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
+	vehiclesnapshot.UpdateDefaultUpdatedAt = vehiclesnapshotDescUpdatedAt.UpdateDefault.(func() int)
+	// vehiclesnapshotDescAccountID is the schema descriptor for account_id field.
+	vehiclesnapshotDescAccountID := vehiclesnapshotFields[4].Descriptor()
+	// vehiclesnapshot.AccountIDValidator is a validator for the "account_id" field. It is called by the builders before save.
+	vehiclesnapshot.AccountIDValidator = vehiclesnapshotDescAccountID.Validators[0].(func(string) error)
+	// vehiclesnapshotDescVehicleID is the schema descriptor for vehicle_id field.
+	vehiclesnapshotDescVehicleID := vehiclesnapshotFields[5].Descriptor()
+	// vehiclesnapshot.VehicleIDValidator is a validator for the "vehicle_id" field. It is called by the builders before save.
+	vehiclesnapshot.VehicleIDValidator = vehiclesnapshotDescVehicleID.Validators[0].(func(string) error)
+	// vehiclesnapshotDescReferenceID is the schema descriptor for reference_id field.
+	vehiclesnapshotDescReferenceID := vehiclesnapshotFields[6].Descriptor()
+	// vehiclesnapshot.ReferenceIDValidator is a validator for the "reference_id" field. It is called by the builders before save.
+	vehiclesnapshot.ReferenceIDValidator = vehiclesnapshotDescReferenceID.Validators[0].(func(string) error)
+	// vehiclesnapshotDescID is the schema descriptor for id field.
+	vehiclesnapshotDescID := vehiclesnapshotFields[0].Descriptor()
+	// vehiclesnapshot.DefaultID holds the default value on creation for the id field.
+	vehiclesnapshot.DefaultID = vehiclesnapshotDescID.Default.(func() string)
+}
diff --git a/internal/database/ent/db/runtime/runtime.go b/internal/database/ent/db/runtime/runtime.go
new file mode 100644
index 00000000..167b2ce9
--- /dev/null
+++ b/internal/database/ent/db/runtime/runtime.go
@@ -0,0 +1,10 @@
+// Code generated by ent, DO NOT EDIT.
+
+package runtime
+
+// The schema-stitching logic is generated in github.com/cufee/aftermath/internal/database/ent/db/runtime.go
+
+const (
+	Version = "v0.13.1"                                         // Version of ent codegen.
+	Sum     = "h1:uD8QwN1h6SNphdCCzmkMN3feSUzNnVvV/WIkHKMbzOE=" // Sum of ent codegen.
+)
diff --git a/internal/database/ent/db/tx.go b/internal/database/ent/db/tx.go
new file mode 100644
index 00000000..a9856134
--- /dev/null
+++ b/internal/database/ent/db/tx.go
@@ -0,0 +1,249 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"sync"
+
+	"entgo.io/ent/dialect"
+)
+
+// Tx is a transactional client that is created by calling Client.Tx().
+type Tx struct {
+	config
+	// Account is the client for interacting with the Account builders.
+	Account *AccountClient
+	// AccountSnapshot is the client for interacting with the AccountSnapshot builders.
+	AccountSnapshot *AccountSnapshotClient
+	// AchievementsSnapshot is the client for interacting with the AchievementsSnapshot builders.
+	AchievementsSnapshot *AchievementsSnapshotClient
+	// AppConfiguration is the client for interacting with the AppConfiguration builders.
+	AppConfiguration *AppConfigurationClient
+	// ApplicationCommand is the client for interacting with the ApplicationCommand builders.
+	ApplicationCommand *ApplicationCommandClient
+	// Clan is the client for interacting with the Clan builders.
+	Clan *ClanClient
+	// CronTask is the client for interacting with the CronTask builders.
+	CronTask *CronTaskClient
+	// User is the client for interacting with the User builders.
+	User *UserClient
+	// UserConnection is the client for interacting with the UserConnection builders.
+	UserConnection *UserConnectionClient
+	// UserContent is the client for interacting with the UserContent builders.
+	UserContent *UserContentClient
+	// UserSubscription is the client for interacting with the UserSubscription builders.
+	UserSubscription *UserSubscriptionClient
+	// Vehicle is the client for interacting with the Vehicle builders.
+	Vehicle *VehicleClient
+	// VehicleAverage is the client for interacting with the VehicleAverage builders.
+	VehicleAverage *VehicleAverageClient
+	// VehicleSnapshot is the client for interacting with the VehicleSnapshot builders.
+	VehicleSnapshot *VehicleSnapshotClient
+
+	// lazily loaded.
+	client     *Client
+	clientOnce sync.Once
+	// ctx lives for the life of the transaction. It is
+	// the same context used by the underlying connection.
+	ctx context.Context
+}
+
+type (
+	// Committer is the interface that wraps the Commit method.
+	Committer interface {
+		Commit(context.Context, *Tx) error
+	}
+
+	// The CommitFunc type is an adapter to allow the use of ordinary
+	// function as a Committer. If f is a function with the appropriate
+	// signature, CommitFunc(f) is a Committer that calls f.
+	CommitFunc func(context.Context, *Tx) error
+
+	// CommitHook defines the "commit middleware". A function that gets a Committer
+	// and returns a Committer. For example:
+	//
+	//	hook := func(next ent.Committer) ent.Committer {
+	//		return ent.CommitFunc(func(ctx context.Context, tx *ent.Tx) error {
+	//			// Do some stuff before.
+	//			if err := next.Commit(ctx, tx); err != nil {
+	//				return err
+	//			}
+	//			// Do some stuff after.
+	//			return nil
+	//		})
+	//	}
+	//
+	CommitHook func(Committer) Committer
+)
+
+// Commit calls f(ctx, m).
+func (f CommitFunc) Commit(ctx context.Context, tx *Tx) error {
+	return f(ctx, tx)
+}
+
+// Commit commits the transaction.
+func (tx *Tx) Commit() error {
+	txDriver := tx.config.driver.(*txDriver)
+	var fn Committer = CommitFunc(func(context.Context, *Tx) error {
+		return txDriver.tx.Commit()
+	})
+	txDriver.mu.Lock()
+	hooks := append([]CommitHook(nil), txDriver.onCommit...)
+	txDriver.mu.Unlock()
+	for i := len(hooks) - 1; i >= 0; i-- {
+		fn = hooks[i](fn)
+	}
+	return fn.Commit(tx.ctx, tx)
+}
+
+// OnCommit adds a hook to call on commit.
+func (tx *Tx) OnCommit(f CommitHook) {
+	txDriver := tx.config.driver.(*txDriver)
+	txDriver.mu.Lock()
+	txDriver.onCommit = append(txDriver.onCommit, f)
+	txDriver.mu.Unlock()
+}
+
+type (
+	// Rollbacker is the interface that wraps the Rollback method.
+	Rollbacker interface {
+		Rollback(context.Context, *Tx) error
+	}
+
+	// The RollbackFunc type is an adapter to allow the use of ordinary
+	// function as a Rollbacker. If f is a function with the appropriate
+	// signature, RollbackFunc(f) is a Rollbacker that calls f.
+	RollbackFunc func(context.Context, *Tx) error
+
+	// RollbackHook defines the "rollback middleware". A function that gets a Rollbacker
+	// and returns a Rollbacker. For example:
+	//
+	//	hook := func(next ent.Rollbacker) ent.Rollbacker {
+	//		return ent.RollbackFunc(func(ctx context.Context, tx *ent.Tx) error {
+	//			// Do some stuff before.
+	//			if err := next.Rollback(ctx, tx); err != nil {
+	//				return err
+	//			}
+	//			// Do some stuff after.
+	//			return nil
+	//		})
+	//	}
+	//
+	RollbackHook func(Rollbacker) Rollbacker
+)
+
+// Rollback calls f(ctx, m).
+func (f RollbackFunc) Rollback(ctx context.Context, tx *Tx) error {
+	return f(ctx, tx)
+}
+
+// Rollback rollbacks the transaction.
+func (tx *Tx) Rollback() error {
+	txDriver := tx.config.driver.(*txDriver)
+	var fn Rollbacker = RollbackFunc(func(context.Context, *Tx) error {
+		return txDriver.tx.Rollback()
+	})
+	txDriver.mu.Lock()
+	hooks := append([]RollbackHook(nil), txDriver.onRollback...)
+	txDriver.mu.Unlock()
+	for i := len(hooks) - 1; i >= 0; i-- {
+		fn = hooks[i](fn)
+	}
+	return fn.Rollback(tx.ctx, tx)
+}
+
+// OnRollback adds a hook to call on rollback.
+func (tx *Tx) OnRollback(f RollbackHook) {
+	txDriver := tx.config.driver.(*txDriver)
+	txDriver.mu.Lock()
+	txDriver.onRollback = append(txDriver.onRollback, f)
+	txDriver.mu.Unlock()
+}
+
+// Client returns a Client that binds to current transaction.
+func (tx *Tx) Client() *Client {
+	tx.clientOnce.Do(func() {
+		tx.client = &Client{config: tx.config}
+		tx.client.init()
+	})
+	return tx.client
+}
+
+func (tx *Tx) init() {
+	tx.Account = NewAccountClient(tx.config)
+	tx.AccountSnapshot = NewAccountSnapshotClient(tx.config)
+	tx.AchievementsSnapshot = NewAchievementsSnapshotClient(tx.config)
+	tx.AppConfiguration = NewAppConfigurationClient(tx.config)
+	tx.ApplicationCommand = NewApplicationCommandClient(tx.config)
+	tx.Clan = NewClanClient(tx.config)
+	tx.CronTask = NewCronTaskClient(tx.config)
+	tx.User = NewUserClient(tx.config)
+	tx.UserConnection = NewUserConnectionClient(tx.config)
+	tx.UserContent = NewUserContentClient(tx.config)
+	tx.UserSubscription = NewUserSubscriptionClient(tx.config)
+	tx.Vehicle = NewVehicleClient(tx.config)
+	tx.VehicleAverage = NewVehicleAverageClient(tx.config)
+	tx.VehicleSnapshot = NewVehicleSnapshotClient(tx.config)
+}
+
+// txDriver wraps the given dialect.Tx with a nop dialect.Driver implementation.
+// The idea is to support transactions without adding any extra code to the builders.
+// When a builder calls to driver.Tx(), it gets the same dialect.Tx instance.
+// Commit and Rollback are nop for the internal builders and the user must call one
+// of them in order to commit or rollback the transaction.
+//
+// If a closed transaction is embedded in one of the generated entities, and the entity
+// applies a query, for example: Account.QueryXXX(), the query will be executed
+// through the driver which created this transaction.
+//
+// Note that txDriver is not goroutine safe.
+type txDriver struct {
+	// the driver we started the transaction from.
+	drv dialect.Driver
+	// tx is the underlying transaction.
+	tx dialect.Tx
+	// completion hooks.
+	mu         sync.Mutex
+	onCommit   []CommitHook
+	onRollback []RollbackHook
+}
+
+// newTx creates a new transactional driver.
+func newTx(ctx context.Context, drv dialect.Driver) (*txDriver, error) {
+	tx, err := drv.Tx(ctx)
+	if err != nil {
+		return nil, err
+	}
+	return &txDriver{tx: tx, drv: drv}, nil
+}
+
+// Tx returns the transaction wrapper (txDriver) to avoid Commit or Rollback calls
+// from the internal builders. Should be called only by the internal builders.
+func (tx *txDriver) Tx(context.Context) (dialect.Tx, error) { return tx, nil }
+
+// Dialect returns the dialect of the driver we started the transaction from.
+func (tx *txDriver) Dialect() string { return tx.drv.Dialect() }
+
+// Close is a nop close.
+func (*txDriver) Close() error { return nil }
+
+// Commit is a nop commit for the internal builders.
+// User must call `Tx.Commit` in order to commit the transaction.
+func (*txDriver) Commit() error { return nil }
+
+// Rollback is a nop rollback for the internal builders.
+// User must call `Tx.Rollback` in order to rollback the transaction.
+func (*txDriver) Rollback() error { return nil }
+
+// Exec calls tx.Exec.
+func (tx *txDriver) Exec(ctx context.Context, query string, args, v any) error {
+	return tx.tx.Exec(ctx, query, args, v)
+}
+
+// Query calls tx.Query.
+func (tx *txDriver) Query(ctx context.Context, query string, args, v any) error {
+	return tx.tx.Query(ctx, query, args, v)
+}
+
+var _ dialect.Driver = (*txDriver)(nil)
diff --git a/internal/database/ent/db/user.go b/internal/database/ent/db/user.go
new file mode 100644
index 00000000..f62dd2bb
--- /dev/null
+++ b/internal/database/ent/db/user.go
@@ -0,0 +1,199 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+	"github.com/cufee/aftermath/internal/database/ent/db/user"
+)
+
+// User is the model entity for the User schema.
+type User struct {
+	config `json:"-"`
+	// ID of the ent.
+	ID string `json:"id,omitempty"`
+	// CreatedAt holds the value of the "created_at" field.
+	CreatedAt int `json:"created_at,omitempty"`
+	// UpdatedAt holds the value of the "updated_at" field.
+	UpdatedAt int `json:"updated_at,omitempty"`
+	// Permissions holds the value of the "permissions" field.
+	Permissions string `json:"permissions,omitempty"`
+	// FeatureFlags holds the value of the "feature_flags" field.
+	FeatureFlags []string `json:"feature_flags,omitempty"`
+	// Edges holds the relations/edges for other nodes in the graph.
+	// The values are being populated by the UserQuery when eager-loading is set.
+	Edges        UserEdges `json:"edges"`
+	selectValues sql.SelectValues
+}
+
+// UserEdges holds the relations/edges for other nodes in the graph.
+type UserEdges struct {
+	// Subscriptions holds the value of the subscriptions edge.
+	Subscriptions []*UserSubscription `json:"subscriptions,omitempty"`
+	// Connections holds the value of the connections edge.
+	Connections []*UserConnection `json:"connections,omitempty"`
+	// Content holds the value of the content edge.
+	Content []*UserContent `json:"content,omitempty"`
+	// loadedTypes holds the information for reporting if a
+	// type was loaded (or requested) in eager-loading or not.
+	loadedTypes [3]bool
+}
+
+// SubscriptionsOrErr returns the Subscriptions value or an error if the edge
+// was not loaded in eager-loading.
+func (e UserEdges) SubscriptionsOrErr() ([]*UserSubscription, error) {
+	if e.loadedTypes[0] {
+		return e.Subscriptions, nil
+	}
+	return nil, &NotLoadedError{edge: "subscriptions"}
+}
+
+// ConnectionsOrErr returns the Connections value or an error if the edge
+// was not loaded in eager-loading.
+func (e UserEdges) ConnectionsOrErr() ([]*UserConnection, error) {
+	if e.loadedTypes[1] {
+		return e.Connections, nil
+	}
+	return nil, &NotLoadedError{edge: "connections"}
+}
+
+// ContentOrErr returns the Content value or an error if the edge
+// was not loaded in eager-loading.
+func (e UserEdges) ContentOrErr() ([]*UserContent, error) {
+	if e.loadedTypes[2] {
+		return e.Content, nil
+	}
+	return nil, &NotLoadedError{edge: "content"}
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*User) scanValues(columns []string) ([]any, error) {
+	values := make([]any, len(columns))
+	for i := range columns {
+		switch columns[i] {
+		case user.FieldFeatureFlags:
+			values[i] = new([]byte)
+		case user.FieldCreatedAt, user.FieldUpdatedAt:
+			values[i] = new(sql.NullInt64)
+		case user.FieldID, user.FieldPermissions:
+			values[i] = new(sql.NullString)
+		default:
+			values[i] = new(sql.UnknownType)
+		}
+	}
+	return values, nil
+}
+
+// assignValues assigns the values that were returned from sql.Rows (after scanning)
+// to the User fields.
+func (u *User) assignValues(columns []string, values []any) error {
+	if m, n := len(values), len(columns); m < n {
+		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
+	}
+	for i := range columns {
+		switch columns[i] {
+		case user.FieldID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field id", values[i])
+			} else if value.Valid {
+				u.ID = value.String
+			}
+		case user.FieldCreatedAt:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field created_at", values[i])
+			} else if value.Valid {
+				u.CreatedAt = int(value.Int64)
+			}
+		case user.FieldUpdatedAt:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
+			} else if value.Valid {
+				u.UpdatedAt = int(value.Int64)
+			}
+		case user.FieldPermissions:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field permissions", values[i])
+			} else if value.Valid {
+				u.Permissions = value.String
+			}
+		case user.FieldFeatureFlags:
+			if value, ok := values[i].(*[]byte); !ok {
+				return fmt.Errorf("unexpected type %T for field feature_flags", values[i])
+			} else if value != nil && len(*value) > 0 {
+				if err := json.Unmarshal(*value, &u.FeatureFlags); err != nil {
+					return fmt.Errorf("unmarshal field feature_flags: %w", err)
+				}
+			}
+		default:
+			u.selectValues.Set(columns[i], values[i])
+		}
+	}
+	return nil
+}
+
+// Value returns the ent.Value that was dynamically selected and assigned to the User.
+// This includes values selected through modifiers, order, etc.
+func (u *User) Value(name string) (ent.Value, error) {
+	return u.selectValues.Get(name)
+}
+
+// QuerySubscriptions queries the "subscriptions" edge of the User entity.
+func (u *User) QuerySubscriptions() *UserSubscriptionQuery {
+	return NewUserClient(u.config).QuerySubscriptions(u)
+}
+
+// QueryConnections queries the "connections" edge of the User entity.
+func (u *User) QueryConnections() *UserConnectionQuery {
+	return NewUserClient(u.config).QueryConnections(u)
+}
+
+// QueryContent queries the "content" edge of the User entity.
+func (u *User) QueryContent() *UserContentQuery {
+	return NewUserClient(u.config).QueryContent(u)
+}
+
+// Update returns a builder for updating this User.
+// Note that you need to call User.Unwrap() before calling this method if this User
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (u *User) Update() *UserUpdateOne {
+	return NewUserClient(u.config).UpdateOne(u)
+}
+
+// Unwrap unwraps the User entity that was returned from a transaction after it was closed,
+// so that all future queries will be executed through the driver which created the transaction.
+func (u *User) Unwrap() *User {
+	_tx, ok := u.config.driver.(*txDriver)
+	if !ok {
+		panic("db: User is not a transactional entity")
+	}
+	u.config.driver = _tx.drv
+	return u
+}
+
+// String implements the fmt.Stringer.
+func (u *User) String() string {
+	var builder strings.Builder
+	builder.WriteString("User(")
+	builder.WriteString(fmt.Sprintf("id=%v, ", u.ID))
+	builder.WriteString("created_at=")
+	builder.WriteString(fmt.Sprintf("%v", u.CreatedAt))
+	builder.WriteString(", ")
+	builder.WriteString("updated_at=")
+	builder.WriteString(fmt.Sprintf("%v", u.UpdatedAt))
+	builder.WriteString(", ")
+	builder.WriteString("permissions=")
+	builder.WriteString(u.Permissions)
+	builder.WriteString(", ")
+	builder.WriteString("feature_flags=")
+	builder.WriteString(fmt.Sprintf("%v", u.FeatureFlags))
+	builder.WriteByte(')')
+	return builder.String()
+}
+
+// Users is a parsable slice of User.
+type Users []*User
diff --git a/internal/database/ent/db/user/user.go b/internal/database/ent/db/user/user.go
new file mode 100644
index 00000000..9ee9bd12
--- /dev/null
+++ b/internal/database/ent/db/user/user.go
@@ -0,0 +1,168 @@
+// Code generated by ent, DO NOT EDIT.
+
+package user
+
+import (
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+)
+
+const (
+	// Label holds the string label denoting the user type in the database.
+	Label = "user"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// FieldPermissions holds the string denoting the permissions field in the database.
+	FieldPermissions = "permissions"
+	// FieldFeatureFlags holds the string denoting the feature_flags field in the database.
+	FieldFeatureFlags = "feature_flags"
+	// EdgeSubscriptions holds the string denoting the subscriptions edge name in mutations.
+	EdgeSubscriptions = "subscriptions"
+	// EdgeConnections holds the string denoting the connections edge name in mutations.
+	EdgeConnections = "connections"
+	// EdgeContent holds the string denoting the content edge name in mutations.
+	EdgeContent = "content"
+	// Table holds the table name of the user in the database.
+	Table = "users"
+	// SubscriptionsTable is the table that holds the subscriptions relation/edge.
+	SubscriptionsTable = "user_subscriptions"
+	// SubscriptionsInverseTable is the table name for the UserSubscription entity.
+	// It exists in this package in order to avoid circular dependency with the "usersubscription" package.
+	SubscriptionsInverseTable = "user_subscriptions"
+	// SubscriptionsColumn is the table column denoting the subscriptions relation/edge.
+	SubscriptionsColumn = "user_id"
+	// ConnectionsTable is the table that holds the connections relation/edge.
+	ConnectionsTable = "user_connections"
+	// ConnectionsInverseTable is the table name for the UserConnection entity.
+	// It exists in this package in order to avoid circular dependency with the "userconnection" package.
+	ConnectionsInverseTable = "user_connections"
+	// ConnectionsColumn is the table column denoting the connections relation/edge.
+	ConnectionsColumn = "user_id"
+	// ContentTable is the table that holds the content relation/edge.
+	ContentTable = "user_contents"
+	// ContentInverseTable is the table name for the UserContent entity.
+	// It exists in this package in order to avoid circular dependency with the "usercontent" package.
+	ContentInverseTable = "user_contents"
+	// ContentColumn is the table column denoting the content relation/edge.
+	ContentColumn = "user_id"
+)
+
+// Columns holds all SQL columns for user fields.
+var Columns = []string{
+	FieldID,
+	FieldCreatedAt,
+	FieldUpdatedAt,
+	FieldPermissions,
+	FieldFeatureFlags,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() int
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() int
+	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
+	UpdateDefaultUpdatedAt func() int
+	// DefaultPermissions holds the default value on creation for the "permissions" field.
+	DefaultPermissions string
+)
+
+// OrderOption defines the ordering options for the User queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByPermissions orders the results by the permissions field.
+func ByPermissions(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldPermissions, opts...).ToFunc()
+}
+
+// BySubscriptionsCount orders the results by subscriptions count.
+func BySubscriptionsCount(opts ...sql.OrderTermOption) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborsCount(s, newSubscriptionsStep(), opts...)
+	}
+}
+
+// BySubscriptions orders the results by subscriptions terms.
+func BySubscriptions(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborTerms(s, newSubscriptionsStep(), append([]sql.OrderTerm{term}, terms...)...)
+	}
+}
+
+// ByConnectionsCount orders the results by connections count.
+func ByConnectionsCount(opts ...sql.OrderTermOption) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborsCount(s, newConnectionsStep(), opts...)
+	}
+}
+
+// ByConnections orders the results by connections terms.
+func ByConnections(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborTerms(s, newConnectionsStep(), append([]sql.OrderTerm{term}, terms...)...)
+	}
+}
+
+// ByContentCount orders the results by content count.
+func ByContentCount(opts ...sql.OrderTermOption) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborsCount(s, newContentStep(), opts...)
+	}
+}
+
+// ByContent orders the results by content terms.
+func ByContent(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborTerms(s, newContentStep(), append([]sql.OrderTerm{term}, terms...)...)
+	}
+}
+func newSubscriptionsStep() *sqlgraph.Step {
+	return sqlgraph.NewStep(
+		sqlgraph.From(Table, FieldID),
+		sqlgraph.To(SubscriptionsInverseTable, FieldID),
+		sqlgraph.Edge(sqlgraph.O2M, false, SubscriptionsTable, SubscriptionsColumn),
+	)
+}
+func newConnectionsStep() *sqlgraph.Step {
+	return sqlgraph.NewStep(
+		sqlgraph.From(Table, FieldID),
+		sqlgraph.To(ConnectionsInverseTable, FieldID),
+		sqlgraph.Edge(sqlgraph.O2M, false, ConnectionsTable, ConnectionsColumn),
+	)
+}
+func newContentStep() *sqlgraph.Step {
+	return sqlgraph.NewStep(
+		sqlgraph.From(Table, FieldID),
+		sqlgraph.To(ContentInverseTable, FieldID),
+		sqlgraph.Edge(sqlgraph.O2M, false, ContentTable, ContentColumn),
+	)
+}
diff --git a/internal/database/ent/db/user/where.go b/internal/database/ent/db/user/where.go
new file mode 100644
index 00000000..a0abc0ee
--- /dev/null
+++ b/internal/database/ent/db/user/where.go
@@ -0,0 +1,318 @@
+// Code generated by ent, DO NOT EDIT.
+
+package user
+
+import (
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id string) predicate.User {
+	return predicate.User(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id string) predicate.User {
+	return predicate.User(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id string) predicate.User {
+	return predicate.User(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...string) predicate.User {
+	return predicate.User(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...string) predicate.User {
+	return predicate.User(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id string) predicate.User {
+	return predicate.User(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id string) predicate.User {
+	return predicate.User(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id string) predicate.User {
+	return predicate.User(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id string) predicate.User {
+	return predicate.User(sql.FieldLTE(FieldID, id))
+}
+
+// IDEqualFold applies the EqualFold predicate on the ID field.
+func IDEqualFold(id string) predicate.User {
+	return predicate.User(sql.FieldEqualFold(FieldID, id))
+}
+
+// IDContainsFold applies the ContainsFold predicate on the ID field.
+func IDContainsFold(id string) predicate.User {
+	return predicate.User(sql.FieldContainsFold(FieldID, id))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v int) predicate.User {
+	return predicate.User(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v int) predicate.User {
+	return predicate.User(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// Permissions applies equality check predicate on the "permissions" field. It's identical to PermissionsEQ.
+func Permissions(v string) predicate.User {
+	return predicate.User(sql.FieldEQ(FieldPermissions, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v int) predicate.User {
+	return predicate.User(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v int) predicate.User {
+	return predicate.User(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...int) predicate.User {
+	return predicate.User(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...int) predicate.User {
+	return predicate.User(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v int) predicate.User {
+	return predicate.User(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v int) predicate.User {
+	return predicate.User(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v int) predicate.User {
+	return predicate.User(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v int) predicate.User {
+	return predicate.User(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v int) predicate.User {
+	return predicate.User(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v int) predicate.User {
+	return predicate.User(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...int) predicate.User {
+	return predicate.User(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...int) predicate.User {
+	return predicate.User(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v int) predicate.User {
+	return predicate.User(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v int) predicate.User {
+	return predicate.User(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v int) predicate.User {
+	return predicate.User(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v int) predicate.User {
+	return predicate.User(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// PermissionsEQ applies the EQ predicate on the "permissions" field.
+func PermissionsEQ(v string) predicate.User {
+	return predicate.User(sql.FieldEQ(FieldPermissions, v))
+}
+
+// PermissionsNEQ applies the NEQ predicate on the "permissions" field.
+func PermissionsNEQ(v string) predicate.User {
+	return predicate.User(sql.FieldNEQ(FieldPermissions, v))
+}
+
+// PermissionsIn applies the In predicate on the "permissions" field.
+func PermissionsIn(vs ...string) predicate.User {
+	return predicate.User(sql.FieldIn(FieldPermissions, vs...))
+}
+
+// PermissionsNotIn applies the NotIn predicate on the "permissions" field.
+func PermissionsNotIn(vs ...string) predicate.User {
+	return predicate.User(sql.FieldNotIn(FieldPermissions, vs...))
+}
+
+// PermissionsGT applies the GT predicate on the "permissions" field.
+func PermissionsGT(v string) predicate.User {
+	return predicate.User(sql.FieldGT(FieldPermissions, v))
+}
+
+// PermissionsGTE applies the GTE predicate on the "permissions" field.
+func PermissionsGTE(v string) predicate.User {
+	return predicate.User(sql.FieldGTE(FieldPermissions, v))
+}
+
+// PermissionsLT applies the LT predicate on the "permissions" field.
+func PermissionsLT(v string) predicate.User {
+	return predicate.User(sql.FieldLT(FieldPermissions, v))
+}
+
+// PermissionsLTE applies the LTE predicate on the "permissions" field.
+func PermissionsLTE(v string) predicate.User {
+	return predicate.User(sql.FieldLTE(FieldPermissions, v))
+}
+
+// PermissionsContains applies the Contains predicate on the "permissions" field.
+func PermissionsContains(v string) predicate.User {
+	return predicate.User(sql.FieldContains(FieldPermissions, v))
+}
+
+// PermissionsHasPrefix applies the HasPrefix predicate on the "permissions" field.
+func PermissionsHasPrefix(v string) predicate.User {
+	return predicate.User(sql.FieldHasPrefix(FieldPermissions, v))
+}
+
+// PermissionsHasSuffix applies the HasSuffix predicate on the "permissions" field.
+func PermissionsHasSuffix(v string) predicate.User {
+	return predicate.User(sql.FieldHasSuffix(FieldPermissions, v))
+}
+
+// PermissionsEqualFold applies the EqualFold predicate on the "permissions" field.
+func PermissionsEqualFold(v string) predicate.User {
+	return predicate.User(sql.FieldEqualFold(FieldPermissions, v))
+}
+
+// PermissionsContainsFold applies the ContainsFold predicate on the "permissions" field.
+func PermissionsContainsFold(v string) predicate.User {
+	return predicate.User(sql.FieldContainsFold(FieldPermissions, v))
+}
+
+// FeatureFlagsIsNil applies the IsNil predicate on the "feature_flags" field.
+func FeatureFlagsIsNil() predicate.User {
+	return predicate.User(sql.FieldIsNull(FieldFeatureFlags))
+}
+
+// FeatureFlagsNotNil applies the NotNil predicate on the "feature_flags" field.
+func FeatureFlagsNotNil() predicate.User {
+	return predicate.User(sql.FieldNotNull(FieldFeatureFlags))
+}
+
+// HasSubscriptions applies the HasEdge predicate on the "subscriptions" edge.
+func HasSubscriptions() predicate.User {
+	return predicate.User(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, SubscriptionsTable, SubscriptionsColumn),
+		)
+		sqlgraph.HasNeighbors(s, step)
+	})
+}
+
+// HasSubscriptionsWith applies the HasEdge predicate on the "subscriptions" edge with a given conditions (other predicates).
+func HasSubscriptionsWith(preds ...predicate.UserSubscription) predicate.User {
+	return predicate.User(func(s *sql.Selector) {
+		step := newSubscriptionsStep()
+		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+			for _, p := range preds {
+				p(s)
+			}
+		})
+	})
+}
+
+// HasConnections applies the HasEdge predicate on the "connections" edge.
+func HasConnections() predicate.User {
+	return predicate.User(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, ConnectionsTable, ConnectionsColumn),
+		)
+		sqlgraph.HasNeighbors(s, step)
+	})
+}
+
+// HasConnectionsWith applies the HasEdge predicate on the "connections" edge with a given conditions (other predicates).
+func HasConnectionsWith(preds ...predicate.UserConnection) predicate.User {
+	return predicate.User(func(s *sql.Selector) {
+		step := newConnectionsStep()
+		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+			for _, p := range preds {
+				p(s)
+			}
+		})
+	})
+}
+
+// HasContent applies the HasEdge predicate on the "content" edge.
+func HasContent() predicate.User {
+	return predicate.User(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, ContentTable, ContentColumn),
+		)
+		sqlgraph.HasNeighbors(s, step)
+	})
+}
+
+// HasContentWith applies the HasEdge predicate on the "content" edge with a given conditions (other predicates).
+func HasContentWith(preds ...predicate.UserContent) predicate.User {
+	return predicate.User(func(s *sql.Selector) {
+		step := newContentStep()
+		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+			for _, p := range preds {
+				p(s)
+			}
+		})
+	})
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.User) predicate.User {
+	return predicate.User(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.User) predicate.User {
+	return predicate.User(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.User) predicate.User {
+	return predicate.User(sql.NotPredicates(p))
+}
diff --git a/internal/database/ent/db/user_create.go b/internal/database/ent/db/user_create.go
new file mode 100644
index 00000000..a5916908
--- /dev/null
+++ b/internal/database/ent/db/user_create.go
@@ -0,0 +1,368 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/user"
+	"github.com/cufee/aftermath/internal/database/ent/db/userconnection"
+	"github.com/cufee/aftermath/internal/database/ent/db/usercontent"
+	"github.com/cufee/aftermath/internal/database/ent/db/usersubscription"
+)
+
+// UserCreate is the builder for creating a User entity.
+type UserCreate struct {
+	config
+	mutation *UserMutation
+	hooks    []Hook
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (uc *UserCreate) SetCreatedAt(i int) *UserCreate {
+	uc.mutation.SetCreatedAt(i)
+	return uc
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (uc *UserCreate) SetNillableCreatedAt(i *int) *UserCreate {
+	if i != nil {
+		uc.SetCreatedAt(*i)
+	}
+	return uc
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (uc *UserCreate) SetUpdatedAt(i int) *UserCreate {
+	uc.mutation.SetUpdatedAt(i)
+	return uc
+}
+
+// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
+func (uc *UserCreate) SetNillableUpdatedAt(i *int) *UserCreate {
+	if i != nil {
+		uc.SetUpdatedAt(*i)
+	}
+	return uc
+}
+
+// SetPermissions sets the "permissions" field.
+func (uc *UserCreate) SetPermissions(s string) *UserCreate {
+	uc.mutation.SetPermissions(s)
+	return uc
+}
+
+// SetNillablePermissions sets the "permissions" field if the given value is not nil.
+func (uc *UserCreate) SetNillablePermissions(s *string) *UserCreate {
+	if s != nil {
+		uc.SetPermissions(*s)
+	}
+	return uc
+}
+
+// SetFeatureFlags sets the "feature_flags" field.
+func (uc *UserCreate) SetFeatureFlags(s []string) *UserCreate {
+	uc.mutation.SetFeatureFlags(s)
+	return uc
+}
+
+// SetID sets the "id" field.
+func (uc *UserCreate) SetID(s string) *UserCreate {
+	uc.mutation.SetID(s)
+	return uc
+}
+
+// AddSubscriptionIDs adds the "subscriptions" edge to the UserSubscription entity by IDs.
+func (uc *UserCreate) AddSubscriptionIDs(ids ...string) *UserCreate {
+	uc.mutation.AddSubscriptionIDs(ids...)
+	return uc
+}
+
+// AddSubscriptions adds the "subscriptions" edges to the UserSubscription entity.
+func (uc *UserCreate) AddSubscriptions(u ...*UserSubscription) *UserCreate {
+	ids := make([]string, len(u))
+	for i := range u {
+		ids[i] = u[i].ID
+	}
+	return uc.AddSubscriptionIDs(ids...)
+}
+
+// AddConnectionIDs adds the "connections" edge to the UserConnection entity by IDs.
+func (uc *UserCreate) AddConnectionIDs(ids ...string) *UserCreate {
+	uc.mutation.AddConnectionIDs(ids...)
+	return uc
+}
+
+// AddConnections adds the "connections" edges to the UserConnection entity.
+func (uc *UserCreate) AddConnections(u ...*UserConnection) *UserCreate {
+	ids := make([]string, len(u))
+	for i := range u {
+		ids[i] = u[i].ID
+	}
+	return uc.AddConnectionIDs(ids...)
+}
+
+// AddContentIDs adds the "content" edge to the UserContent entity by IDs.
+func (uc *UserCreate) AddContentIDs(ids ...string) *UserCreate {
+	uc.mutation.AddContentIDs(ids...)
+	return uc
+}
+
+// AddContent adds the "content" edges to the UserContent entity.
+func (uc *UserCreate) AddContent(u ...*UserContent) *UserCreate {
+	ids := make([]string, len(u))
+	for i := range u {
+		ids[i] = u[i].ID
+	}
+	return uc.AddContentIDs(ids...)
+}
+
+// Mutation returns the UserMutation object of the builder.
+func (uc *UserCreate) Mutation() *UserMutation {
+	return uc.mutation
+}
+
+// Save creates the User in the database.
+func (uc *UserCreate) Save(ctx context.Context) (*User, error) {
+	uc.defaults()
+	return withHooks(ctx, uc.sqlSave, uc.mutation, uc.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (uc *UserCreate) SaveX(ctx context.Context) *User {
+	v, err := uc.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (uc *UserCreate) Exec(ctx context.Context) error {
+	_, err := uc.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (uc *UserCreate) ExecX(ctx context.Context) {
+	if err := uc.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (uc *UserCreate) defaults() {
+	if _, ok := uc.mutation.CreatedAt(); !ok {
+		v := user.DefaultCreatedAt()
+		uc.mutation.SetCreatedAt(v)
+	}
+	if _, ok := uc.mutation.UpdatedAt(); !ok {
+		v := user.DefaultUpdatedAt()
+		uc.mutation.SetUpdatedAt(v)
+	}
+	if _, ok := uc.mutation.Permissions(); !ok {
+		v := user.DefaultPermissions
+		uc.mutation.SetPermissions(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (uc *UserCreate) check() error {
+	if _, ok := uc.mutation.CreatedAt(); !ok {
+		return &ValidationError{Name: "created_at", err: errors.New(`db: missing required field "User.created_at"`)}
+	}
+	if _, ok := uc.mutation.UpdatedAt(); !ok {
+		return &ValidationError{Name: "updated_at", err: errors.New(`db: missing required field "User.updated_at"`)}
+	}
+	if _, ok := uc.mutation.Permissions(); !ok {
+		return &ValidationError{Name: "permissions", err: errors.New(`db: missing required field "User.permissions"`)}
+	}
+	return nil
+}
+
+func (uc *UserCreate) sqlSave(ctx context.Context) (*User, error) {
+	if err := uc.check(); err != nil {
+		return nil, err
+	}
+	_node, _spec := uc.createSpec()
+	if err := sqlgraph.CreateNode(ctx, uc.driver, _spec); err != nil {
+		if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	if _spec.ID.Value != nil {
+		if id, ok := _spec.ID.Value.(string); ok {
+			_node.ID = id
+		} else {
+			return nil, fmt.Errorf("unexpected User.ID type: %T", _spec.ID.Value)
+		}
+	}
+	uc.mutation.id = &_node.ID
+	uc.mutation.done = true
+	return _node, nil
+}
+
+func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) {
+	var (
+		_node = &User{config: uc.config}
+		_spec = sqlgraph.NewCreateSpec(user.Table, sqlgraph.NewFieldSpec(user.FieldID, field.TypeString))
+	)
+	if id, ok := uc.mutation.ID(); ok {
+		_node.ID = id
+		_spec.ID.Value = id
+	}
+	if value, ok := uc.mutation.CreatedAt(); ok {
+		_spec.SetField(user.FieldCreatedAt, field.TypeInt, value)
+		_node.CreatedAt = value
+	}
+	if value, ok := uc.mutation.UpdatedAt(); ok {
+		_spec.SetField(user.FieldUpdatedAt, field.TypeInt, value)
+		_node.UpdatedAt = value
+	}
+	if value, ok := uc.mutation.Permissions(); ok {
+		_spec.SetField(user.FieldPermissions, field.TypeString, value)
+		_node.Permissions = value
+	}
+	if value, ok := uc.mutation.FeatureFlags(); ok {
+		_spec.SetField(user.FieldFeatureFlags, field.TypeJSON, value)
+		_node.FeatureFlags = value
+	}
+	if nodes := uc.mutation.SubscriptionsIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.SubscriptionsTable,
+			Columns: []string{user.SubscriptionsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(usersubscription.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges = append(_spec.Edges, edge)
+	}
+	if nodes := uc.mutation.ConnectionsIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.ConnectionsTable,
+			Columns: []string{user.ConnectionsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(userconnection.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges = append(_spec.Edges, edge)
+	}
+	if nodes := uc.mutation.ContentIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.ContentTable,
+			Columns: []string{user.ContentColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(usercontent.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges = append(_spec.Edges, edge)
+	}
+	return _node, _spec
+}
+
+// UserCreateBulk is the builder for creating many User entities in bulk.
+type UserCreateBulk struct {
+	config
+	err      error
+	builders []*UserCreate
+}
+
+// Save creates the User entities in the database.
+func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) {
+	if ucb.err != nil {
+		return nil, ucb.err
+	}
+	specs := make([]*sqlgraph.CreateSpec, len(ucb.builders))
+	nodes := make([]*User, len(ucb.builders))
+	mutators := make([]Mutator, len(ucb.builders))
+	for i := range ucb.builders {
+		func(i int, root context.Context) {
+			builder := ucb.builders[i]
+			builder.defaults()
+			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+				mutation, ok := m.(*UserMutation)
+				if !ok {
+					return nil, fmt.Errorf("unexpected mutation type %T", m)
+				}
+				if err := builder.check(); err != nil {
+					return nil, err
+				}
+				builder.mutation = mutation
+				var err error
+				nodes[i], specs[i] = builder.createSpec()
+				if i < len(mutators)-1 {
+					_, err = mutators[i+1].Mutate(root, ucb.builders[i+1].mutation)
+				} else {
+					spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
+					// Invoke the actual operation on the latest mutation in the chain.
+					if err = sqlgraph.BatchCreate(ctx, ucb.driver, spec); err != nil {
+						if sqlgraph.IsConstraintError(err) {
+							err = &ConstraintError{msg: err.Error(), wrap: err}
+						}
+					}
+				}
+				if err != nil {
+					return nil, err
+				}
+				mutation.id = &nodes[i].ID
+				mutation.done = true
+				return nodes[i], nil
+			})
+			for i := len(builder.hooks) - 1; i >= 0; i-- {
+				mut = builder.hooks[i](mut)
+			}
+			mutators[i] = mut
+		}(i, ctx)
+	}
+	if len(mutators) > 0 {
+		if _, err := mutators[0].Mutate(ctx, ucb.builders[0].mutation); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (ucb *UserCreateBulk) SaveX(ctx context.Context) []*User {
+	v, err := ucb.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (ucb *UserCreateBulk) Exec(ctx context.Context) error {
+	_, err := ucb.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (ucb *UserCreateBulk) ExecX(ctx context.Context) {
+	if err := ucb.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/database/ent/db/user_delete.go b/internal/database/ent/db/user_delete.go
new file mode 100644
index 00000000..4b01013f
--- /dev/null
+++ b/internal/database/ent/db/user_delete.go
@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/ent/db/user"
+)
+
+// UserDelete is the builder for deleting a User entity.
+type UserDelete struct {
+	config
+	hooks    []Hook
+	mutation *UserMutation
+}
+
+// Where appends a list predicates to the UserDelete builder.
+func (ud *UserDelete) Where(ps ...predicate.User) *UserDelete {
+	ud.mutation.Where(ps...)
+	return ud
+}
+
+// Exec executes the deletion query and returns how many vertices were deleted.
+func (ud *UserDelete) Exec(ctx context.Context) (int, error) {
+	return withHooks(ctx, ud.sqlExec, ud.mutation, ud.hooks)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (ud *UserDelete) ExecX(ctx context.Context) int {
+	n, err := ud.Exec(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return n
+}
+
+func (ud *UserDelete) sqlExec(ctx context.Context) (int, error) {
+	_spec := sqlgraph.NewDeleteSpec(user.Table, sqlgraph.NewFieldSpec(user.FieldID, field.TypeString))
+	if ps := ud.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	affected, err := sqlgraph.DeleteNodes(ctx, ud.driver, _spec)
+	if err != nil && sqlgraph.IsConstraintError(err) {
+		err = &ConstraintError{msg: err.Error(), wrap: err}
+	}
+	ud.mutation.done = true
+	return affected, err
+}
+
+// UserDeleteOne is the builder for deleting a single User entity.
+type UserDeleteOne struct {
+	ud *UserDelete
+}
+
+// Where appends a list predicates to the UserDelete builder.
+func (udo *UserDeleteOne) Where(ps ...predicate.User) *UserDeleteOne {
+	udo.ud.mutation.Where(ps...)
+	return udo
+}
+
+// Exec executes the deletion query.
+func (udo *UserDeleteOne) Exec(ctx context.Context) error {
+	n, err := udo.ud.Exec(ctx)
+	switch {
+	case err != nil:
+		return err
+	case n == 0:
+		return &NotFoundError{user.Label}
+	default:
+		return nil
+	}
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (udo *UserDeleteOne) ExecX(ctx context.Context) {
+	if err := udo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/database/ent/db/user_query.go b/internal/database/ent/db/user_query.go
new file mode 100644
index 00000000..5fef02bf
--- /dev/null
+++ b/internal/database/ent/db/user_query.go
@@ -0,0 +1,753 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"database/sql/driver"
+	"fmt"
+	"math"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/ent/db/user"
+	"github.com/cufee/aftermath/internal/database/ent/db/userconnection"
+	"github.com/cufee/aftermath/internal/database/ent/db/usercontent"
+	"github.com/cufee/aftermath/internal/database/ent/db/usersubscription"
+)
+
+// UserQuery is the builder for querying User entities.
+type UserQuery struct {
+	config
+	ctx               *QueryContext
+	order             []user.OrderOption
+	inters            []Interceptor
+	predicates        []predicate.User
+	withSubscriptions *UserSubscriptionQuery
+	withConnections   *UserConnectionQuery
+	withContent       *UserContentQuery
+	// intermediate query (i.e. traversal path).
+	sql  *sql.Selector
+	path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the UserQuery builder.
+func (uq *UserQuery) Where(ps ...predicate.User) *UserQuery {
+	uq.predicates = append(uq.predicates, ps...)
+	return uq
+}
+
+// Limit the number of records to be returned by this query.
+func (uq *UserQuery) Limit(limit int) *UserQuery {
+	uq.ctx.Limit = &limit
+	return uq
+}
+
+// Offset to start from.
+func (uq *UserQuery) Offset(offset int) *UserQuery {
+	uq.ctx.Offset = &offset
+	return uq
+}
+
+// Unique configures the query builder to filter duplicate records on query.
+// By default, unique is set to true, and can be disabled using this method.
+func (uq *UserQuery) Unique(unique bool) *UserQuery {
+	uq.ctx.Unique = &unique
+	return uq
+}
+
+// Order specifies how the records should be ordered.
+func (uq *UserQuery) Order(o ...user.OrderOption) *UserQuery {
+	uq.order = append(uq.order, o...)
+	return uq
+}
+
+// QuerySubscriptions chains the current query on the "subscriptions" edge.
+func (uq *UserQuery) QuerySubscriptions() *UserSubscriptionQuery {
+	query := (&UserSubscriptionClient{config: uq.config}).Query()
+	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+		if err := uq.prepareQuery(ctx); err != nil {
+			return nil, err
+		}
+		selector := uq.sqlQuery(ctx)
+		if err := selector.Err(); err != nil {
+			return nil, err
+		}
+		step := sqlgraph.NewStep(
+			sqlgraph.From(user.Table, user.FieldID, selector),
+			sqlgraph.To(usersubscription.Table, usersubscription.FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, user.SubscriptionsTable, user.SubscriptionsColumn),
+		)
+		fromU = sqlgraph.SetNeighbors(uq.driver.Dialect(), step)
+		return fromU, nil
+	}
+	return query
+}
+
+// QueryConnections chains the current query on the "connections" edge.
+func (uq *UserQuery) QueryConnections() *UserConnectionQuery {
+	query := (&UserConnectionClient{config: uq.config}).Query()
+	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+		if err := uq.prepareQuery(ctx); err != nil {
+			return nil, err
+		}
+		selector := uq.sqlQuery(ctx)
+		if err := selector.Err(); err != nil {
+			return nil, err
+		}
+		step := sqlgraph.NewStep(
+			sqlgraph.From(user.Table, user.FieldID, selector),
+			sqlgraph.To(userconnection.Table, userconnection.FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, user.ConnectionsTable, user.ConnectionsColumn),
+		)
+		fromU = sqlgraph.SetNeighbors(uq.driver.Dialect(), step)
+		return fromU, nil
+	}
+	return query
+}
+
+// QueryContent chains the current query on the "content" edge.
+func (uq *UserQuery) QueryContent() *UserContentQuery {
+	query := (&UserContentClient{config: uq.config}).Query()
+	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+		if err := uq.prepareQuery(ctx); err != nil {
+			return nil, err
+		}
+		selector := uq.sqlQuery(ctx)
+		if err := selector.Err(); err != nil {
+			return nil, err
+		}
+		step := sqlgraph.NewStep(
+			sqlgraph.From(user.Table, user.FieldID, selector),
+			sqlgraph.To(usercontent.Table, usercontent.FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, user.ContentTable, user.ContentColumn),
+		)
+		fromU = sqlgraph.SetNeighbors(uq.driver.Dialect(), step)
+		return fromU, nil
+	}
+	return query
+}
+
+// First returns the first User entity from the query.
+// Returns a *NotFoundError when no User was found.
+func (uq *UserQuery) First(ctx context.Context) (*User, error) {
+	nodes, err := uq.Limit(1).All(setContextOp(ctx, uq.ctx, "First"))
+	if err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nil, &NotFoundError{user.Label}
+	}
+	return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (uq *UserQuery) FirstX(ctx context.Context) *User {
+	node, err := uq.First(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return node
+}
+
+// FirstID returns the first User ID from the query.
+// Returns a *NotFoundError when no User ID was found.
+func (uq *UserQuery) FirstID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = uq.Limit(1).IDs(setContextOp(ctx, uq.ctx, "FirstID")); err != nil {
+		return
+	}
+	if len(ids) == 0 {
+		err = &NotFoundError{user.Label}
+		return
+	}
+	return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (uq *UserQuery) FirstIDX(ctx context.Context) string {
+	id, err := uq.FirstID(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return id
+}
+
+// Only returns a single User entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one User entity is found.
+// Returns a *NotFoundError when no User entities are found.
+func (uq *UserQuery) Only(ctx context.Context) (*User, error) {
+	nodes, err := uq.Limit(2).All(setContextOp(ctx, uq.ctx, "Only"))
+	if err != nil {
+		return nil, err
+	}
+	switch len(nodes) {
+	case 1:
+		return nodes[0], nil
+	case 0:
+		return nil, &NotFoundError{user.Label}
+	default:
+		return nil, &NotSingularError{user.Label}
+	}
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (uq *UserQuery) OnlyX(ctx context.Context) *User {
+	node, err := uq.Only(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// OnlyID is like Only, but returns the only User ID in the query.
+// Returns a *NotSingularError when more than one User ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (uq *UserQuery) OnlyID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = uq.Limit(2).IDs(setContextOp(ctx, uq.ctx, "OnlyID")); err != nil {
+		return
+	}
+	switch len(ids) {
+	case 1:
+		id = ids[0]
+	case 0:
+		err = &NotFoundError{user.Label}
+	default:
+		err = &NotSingularError{user.Label}
+	}
+	return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (uq *UserQuery) OnlyIDX(ctx context.Context) string {
+	id, err := uq.OnlyID(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return id
+}
+
+// All executes the query and returns a list of Users.
+func (uq *UserQuery) All(ctx context.Context) ([]*User, error) {
+	ctx = setContextOp(ctx, uq.ctx, "All")
+	if err := uq.prepareQuery(ctx); err != nil {
+		return nil, err
+	}
+	qr := querierAll[[]*User, *UserQuery]()
+	return withInterceptors[[]*User](ctx, uq, qr, uq.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (uq *UserQuery) AllX(ctx context.Context) []*User {
+	nodes, err := uq.All(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return nodes
+}
+
+// IDs executes the query and returns a list of User IDs.
+func (uq *UserQuery) IDs(ctx context.Context) (ids []string, err error) {
+	if uq.ctx.Unique == nil && uq.path != nil {
+		uq.Unique(true)
+	}
+	ctx = setContextOp(ctx, uq.ctx, "IDs")
+	if err = uq.Select(user.FieldID).Scan(ctx, &ids); err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (uq *UserQuery) IDsX(ctx context.Context) []string {
+	ids, err := uq.IDs(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return ids
+}
+
+// Count returns the count of the given query.
+func (uq *UserQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, uq.ctx, "Count")
+	if err := uq.prepareQuery(ctx); err != nil {
+		return 0, err
+	}
+	return withInterceptors[int](ctx, uq, querierCount[*UserQuery](), uq.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (uq *UserQuery) CountX(ctx context.Context) int {
+	count, err := uq.Count(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (uq *UserQuery) Exist(ctx context.Context) (bool, error) {
+	ctx = setContextOp(ctx, uq.ctx, "Exist")
+	switch _, err := uq.FirstID(ctx); {
+	case IsNotFound(err):
+		return false, nil
+	case err != nil:
+		return false, fmt.Errorf("db: check existence: %w", err)
+	default:
+		return true, nil
+	}
+}
+
+// ExistX is like Exist, but panics if an error occurs.
+func (uq *UserQuery) ExistX(ctx context.Context) bool {
+	exist, err := uq.Exist(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return exist
+}
+
+// Clone returns a duplicate of the UserQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (uq *UserQuery) Clone() *UserQuery {
+	if uq == nil {
+		return nil
+	}
+	return &UserQuery{
+		config:            uq.config,
+		ctx:               uq.ctx.Clone(),
+		order:             append([]user.OrderOption{}, uq.order...),
+		inters:            append([]Interceptor{}, uq.inters...),
+		predicates:        append([]predicate.User{}, uq.predicates...),
+		withSubscriptions: uq.withSubscriptions.Clone(),
+		withConnections:   uq.withConnections.Clone(),
+		withContent:       uq.withContent.Clone(),
+		// clone intermediate query.
+		sql:  uq.sql.Clone(),
+		path: uq.path,
+	}
+}
+
+// WithSubscriptions tells the query-builder to eager-load the nodes that are connected to
+// the "subscriptions" edge. The optional arguments are used to configure the query builder of the edge.
+func (uq *UserQuery) WithSubscriptions(opts ...func(*UserSubscriptionQuery)) *UserQuery {
+	query := (&UserSubscriptionClient{config: uq.config}).Query()
+	for _, opt := range opts {
+		opt(query)
+	}
+	uq.withSubscriptions = query
+	return uq
+}
+
+// WithConnections tells the query-builder to eager-load the nodes that are connected to
+// the "connections" edge. The optional arguments are used to configure the query builder of the edge.
+func (uq *UserQuery) WithConnections(opts ...func(*UserConnectionQuery)) *UserQuery {
+	query := (&UserConnectionClient{config: uq.config}).Query()
+	for _, opt := range opts {
+		opt(query)
+	}
+	uq.withConnections = query
+	return uq
+}
+
+// WithContent tells the query-builder to eager-load the nodes that are connected to
+// the "content" edge. The optional arguments are used to configure the query builder of the edge.
+func (uq *UserQuery) WithContent(opts ...func(*UserContentQuery)) *UserQuery {
+	query := (&UserContentClient{config: uq.config}).Query()
+	for _, opt := range opts {
+		opt(query)
+	}
+	uq.withContent = query
+	return uq
+}
+
+// GroupBy is used to group vertices by one or more fields/columns.
+// It is often used with aggregate functions, like: count, max, mean, min, sum.
+//
+// Example:
+//
+//	var v []struct {
+//		CreatedAt int `json:"created_at,omitempty"`
+//		Count int `json:"count,omitempty"`
+//	}
+//
+//	client.User.Query().
+//		GroupBy(user.FieldCreatedAt).
+//		Aggregate(db.Count()).
+//		Scan(ctx, &v)
+func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy {
+	uq.ctx.Fields = append([]string{field}, fields...)
+	grbuild := &UserGroupBy{build: uq}
+	grbuild.flds = &uq.ctx.Fields
+	grbuild.label = user.Label
+	grbuild.scan = grbuild.Scan
+	return grbuild
+}
+
+// Select allows the selection one or more fields/columns for the given query,
+// instead of selecting all fields in the entity.
+//
+// Example:
+//
+//	var v []struct {
+//		CreatedAt int `json:"created_at,omitempty"`
+//	}
+//
+//	client.User.Query().
+//		Select(user.FieldCreatedAt).
+//		Scan(ctx, &v)
+func (uq *UserQuery) Select(fields ...string) *UserSelect {
+	uq.ctx.Fields = append(uq.ctx.Fields, fields...)
+	sbuild := &UserSelect{UserQuery: uq}
+	sbuild.label = user.Label
+	sbuild.flds, sbuild.scan = &uq.ctx.Fields, sbuild.Scan
+	return sbuild
+}
+
+// Aggregate returns a UserSelect configured with the given aggregations.
+func (uq *UserQuery) Aggregate(fns ...AggregateFunc) *UserSelect {
+	return uq.Select().Aggregate(fns...)
+}
+
+func (uq *UserQuery) prepareQuery(ctx context.Context) error {
+	for _, inter := range uq.inters {
+		if inter == nil {
+			return fmt.Errorf("db: uninitialized interceptor (forgotten import db/runtime?)")
+		}
+		if trv, ok := inter.(Traverser); ok {
+			if err := trv.Traverse(ctx, uq); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range uq.ctx.Fields {
+		if !user.ValidColumn(f) {
+			return &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+		}
+	}
+	if uq.path != nil {
+		prev, err := uq.path(ctx)
+		if err != nil {
+			return err
+		}
+		uq.sql = prev
+	}
+	return nil
+}
+
+func (uq *UserQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*User, error) {
+	var (
+		nodes       = []*User{}
+		_spec       = uq.querySpec()
+		loadedTypes = [3]bool{
+			uq.withSubscriptions != nil,
+			uq.withConnections != nil,
+			uq.withContent != nil,
+		}
+	)
+	_spec.ScanValues = func(columns []string) ([]any, error) {
+		return (*User).scanValues(nil, columns)
+	}
+	_spec.Assign = func(columns []string, values []any) error {
+		node := &User{config: uq.config}
+		nodes = append(nodes, node)
+		node.Edges.loadedTypes = loadedTypes
+		return node.assignValues(columns, values)
+	}
+	for i := range hooks {
+		hooks[i](ctx, _spec)
+	}
+	if err := sqlgraph.QueryNodes(ctx, uq.driver, _spec); err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nodes, nil
+	}
+	if query := uq.withSubscriptions; query != nil {
+		if err := uq.loadSubscriptions(ctx, query, nodes,
+			func(n *User) { n.Edges.Subscriptions = []*UserSubscription{} },
+			func(n *User, e *UserSubscription) { n.Edges.Subscriptions = append(n.Edges.Subscriptions, e) }); err != nil {
+			return nil, err
+		}
+	}
+	if query := uq.withConnections; query != nil {
+		if err := uq.loadConnections(ctx, query, nodes,
+			func(n *User) { n.Edges.Connections = []*UserConnection{} },
+			func(n *User, e *UserConnection) { n.Edges.Connections = append(n.Edges.Connections, e) }); err != nil {
+			return nil, err
+		}
+	}
+	if query := uq.withContent; query != nil {
+		if err := uq.loadContent(ctx, query, nodes,
+			func(n *User) { n.Edges.Content = []*UserContent{} },
+			func(n *User, e *UserContent) { n.Edges.Content = append(n.Edges.Content, e) }); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+func (uq *UserQuery) loadSubscriptions(ctx context.Context, query *UserSubscriptionQuery, nodes []*User, init func(*User), assign func(*User, *UserSubscription)) error {
+	fks := make([]driver.Value, 0, len(nodes))
+	nodeids := make(map[string]*User)
+	for i := range nodes {
+		fks = append(fks, nodes[i].ID)
+		nodeids[nodes[i].ID] = nodes[i]
+		if init != nil {
+			init(nodes[i])
+		}
+	}
+	if len(query.ctx.Fields) > 0 {
+		query.ctx.AppendFieldOnce(usersubscription.FieldUserID)
+	}
+	query.Where(predicate.UserSubscription(func(s *sql.Selector) {
+		s.Where(sql.InValues(s.C(user.SubscriptionsColumn), fks...))
+	}))
+	neighbors, err := query.All(ctx)
+	if err != nil {
+		return err
+	}
+	for _, n := range neighbors {
+		fk := n.UserID
+		node, ok := nodeids[fk]
+		if !ok {
+			return fmt.Errorf(`unexpected referenced foreign-key "user_id" returned %v for node %v`, fk, n.ID)
+		}
+		assign(node, n)
+	}
+	return nil
+}
+func (uq *UserQuery) loadConnections(ctx context.Context, query *UserConnectionQuery, nodes []*User, init func(*User), assign func(*User, *UserConnection)) error {
+	fks := make([]driver.Value, 0, len(nodes))
+	nodeids := make(map[string]*User)
+	for i := range nodes {
+		fks = append(fks, nodes[i].ID)
+		nodeids[nodes[i].ID] = nodes[i]
+		if init != nil {
+			init(nodes[i])
+		}
+	}
+	if len(query.ctx.Fields) > 0 {
+		query.ctx.AppendFieldOnce(userconnection.FieldUserID)
+	}
+	query.Where(predicate.UserConnection(func(s *sql.Selector) {
+		s.Where(sql.InValues(s.C(user.ConnectionsColumn), fks...))
+	}))
+	neighbors, err := query.All(ctx)
+	if err != nil {
+		return err
+	}
+	for _, n := range neighbors {
+		fk := n.UserID
+		node, ok := nodeids[fk]
+		if !ok {
+			return fmt.Errorf(`unexpected referenced foreign-key "user_id" returned %v for node %v`, fk, n.ID)
+		}
+		assign(node, n)
+	}
+	return nil
+}
+func (uq *UserQuery) loadContent(ctx context.Context, query *UserContentQuery, nodes []*User, init func(*User), assign func(*User, *UserContent)) error {
+	fks := make([]driver.Value, 0, len(nodes))
+	nodeids := make(map[string]*User)
+	for i := range nodes {
+		fks = append(fks, nodes[i].ID)
+		nodeids[nodes[i].ID] = nodes[i]
+		if init != nil {
+			init(nodes[i])
+		}
+	}
+	if len(query.ctx.Fields) > 0 {
+		query.ctx.AppendFieldOnce(usercontent.FieldUserID)
+	}
+	query.Where(predicate.UserContent(func(s *sql.Selector) {
+		s.Where(sql.InValues(s.C(user.ContentColumn), fks...))
+	}))
+	neighbors, err := query.All(ctx)
+	if err != nil {
+		return err
+	}
+	for _, n := range neighbors {
+		fk := n.UserID
+		node, ok := nodeids[fk]
+		if !ok {
+			return fmt.Errorf(`unexpected referenced foreign-key "user_id" returned %v for node %v`, fk, n.ID)
+		}
+		assign(node, n)
+	}
+	return nil
+}
+
+func (uq *UserQuery) sqlCount(ctx context.Context) (int, error) {
+	_spec := uq.querySpec()
+	_spec.Node.Columns = uq.ctx.Fields
+	if len(uq.ctx.Fields) > 0 {
+		_spec.Unique = uq.ctx.Unique != nil && *uq.ctx.Unique
+	}
+	return sqlgraph.CountNodes(ctx, uq.driver, _spec)
+}
+
+func (uq *UserQuery) querySpec() *sqlgraph.QuerySpec {
+	_spec := sqlgraph.NewQuerySpec(user.Table, user.Columns, sqlgraph.NewFieldSpec(user.FieldID, field.TypeString))
+	_spec.From = uq.sql
+	if unique := uq.ctx.Unique; unique != nil {
+		_spec.Unique = *unique
+	} else if uq.path != nil {
+		_spec.Unique = true
+	}
+	if fields := uq.ctx.Fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, user.FieldID)
+		for i := range fields {
+			if fields[i] != user.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+			}
+		}
+	}
+	if ps := uq.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if limit := uq.ctx.Limit; limit != nil {
+		_spec.Limit = *limit
+	}
+	if offset := uq.ctx.Offset; offset != nil {
+		_spec.Offset = *offset
+	}
+	if ps := uq.order; len(ps) > 0 {
+		_spec.Order = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	return _spec
+}
+
+func (uq *UserQuery) sqlQuery(ctx context.Context) *sql.Selector {
+	builder := sql.Dialect(uq.driver.Dialect())
+	t1 := builder.Table(user.Table)
+	columns := uq.ctx.Fields
+	if len(columns) == 0 {
+		columns = user.Columns
+	}
+	selector := builder.Select(t1.Columns(columns...)...).From(t1)
+	if uq.sql != nil {
+		selector = uq.sql
+		selector.Select(selector.Columns(columns...)...)
+	}
+	if uq.ctx.Unique != nil && *uq.ctx.Unique {
+		selector.Distinct()
+	}
+	for _, p := range uq.predicates {
+		p(selector)
+	}
+	for _, p := range uq.order {
+		p(selector)
+	}
+	if offset := uq.ctx.Offset; offset != nil {
+		// limit is mandatory for offset clause. We start
+		// with default value, and override it below if needed.
+		selector.Offset(*offset).Limit(math.MaxInt32)
+	}
+	if limit := uq.ctx.Limit; limit != nil {
+		selector.Limit(*limit)
+	}
+	return selector
+}
+
+// UserGroupBy is the group-by builder for User entities.
+type UserGroupBy struct {
+	selector
+	build *UserQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (ugb *UserGroupBy) Aggregate(fns ...AggregateFunc) *UserGroupBy {
+	ugb.fns = append(ugb.fns, fns...)
+	return ugb
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (ugb *UserGroupBy) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, ugb.build.ctx, "GroupBy")
+	if err := ugb.build.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*UserQuery, *UserGroupBy](ctx, ugb.build, ugb, ugb.build.inters, v)
+}
+
+func (ugb *UserGroupBy) sqlScan(ctx context.Context, root *UserQuery, v any) error {
+	selector := root.sqlQuery(ctx).Select()
+	aggregation := make([]string, 0, len(ugb.fns))
+	for _, fn := range ugb.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*ugb.flds)+len(ugb.fns))
+		for _, f := range *ugb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*ugb.flds...)...)
+	if err := selector.Err(); err != nil {
+		return err
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := ugb.build.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
+
+// UserSelect is the builder for selecting fields of User entities.
+type UserSelect struct {
+	*UserQuery
+	selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (us *UserSelect) Aggregate(fns ...AggregateFunc) *UserSelect {
+	us.fns = append(us.fns, fns...)
+	return us
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (us *UserSelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, us.ctx, "Select")
+	if err := us.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*UserQuery, *UserSelect](ctx, us.UserQuery, us, us.inters, v)
+}
+
+func (us *UserSelect) sqlScan(ctx context.Context, root *UserQuery, v any) error {
+	selector := root.sqlQuery(ctx)
+	aggregation := make([]string, 0, len(us.fns))
+	for _, fn := range us.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	switch n := len(*us.selector.flds); {
+	case n == 0 && len(aggregation) > 0:
+		selector.Select(aggregation...)
+	case n != 0 && len(aggregation) > 0:
+		selector.AppendSelect(aggregation...)
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := us.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
diff --git a/internal/database/ent/db/user_update.go b/internal/database/ent/db/user_update.go
new file mode 100644
index 00000000..4d7932c2
--- /dev/null
+++ b/internal/database/ent/db/user_update.go
@@ -0,0 +1,813 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/dialect/sql/sqljson"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/ent/db/user"
+	"github.com/cufee/aftermath/internal/database/ent/db/userconnection"
+	"github.com/cufee/aftermath/internal/database/ent/db/usercontent"
+	"github.com/cufee/aftermath/internal/database/ent/db/usersubscription"
+)
+
+// UserUpdate is the builder for updating User entities.
+type UserUpdate struct {
+	config
+	hooks    []Hook
+	mutation *UserMutation
+}
+
+// Where appends a list predicates to the UserUpdate builder.
+func (uu *UserUpdate) Where(ps ...predicate.User) *UserUpdate {
+	uu.mutation.Where(ps...)
+	return uu
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (uu *UserUpdate) SetUpdatedAt(i int) *UserUpdate {
+	uu.mutation.ResetUpdatedAt()
+	uu.mutation.SetUpdatedAt(i)
+	return uu
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (uu *UserUpdate) AddUpdatedAt(i int) *UserUpdate {
+	uu.mutation.AddUpdatedAt(i)
+	return uu
+}
+
+// SetPermissions sets the "permissions" field.
+func (uu *UserUpdate) SetPermissions(s string) *UserUpdate {
+	uu.mutation.SetPermissions(s)
+	return uu
+}
+
+// SetNillablePermissions sets the "permissions" field if the given value is not nil.
+func (uu *UserUpdate) SetNillablePermissions(s *string) *UserUpdate {
+	if s != nil {
+		uu.SetPermissions(*s)
+	}
+	return uu
+}
+
+// SetFeatureFlags sets the "feature_flags" field.
+func (uu *UserUpdate) SetFeatureFlags(s []string) *UserUpdate {
+	uu.mutation.SetFeatureFlags(s)
+	return uu
+}
+
+// AppendFeatureFlags appends s to the "feature_flags" field.
+func (uu *UserUpdate) AppendFeatureFlags(s []string) *UserUpdate {
+	uu.mutation.AppendFeatureFlags(s)
+	return uu
+}
+
+// ClearFeatureFlags clears the value of the "feature_flags" field.
+func (uu *UserUpdate) ClearFeatureFlags() *UserUpdate {
+	uu.mutation.ClearFeatureFlags()
+	return uu
+}
+
+// AddSubscriptionIDs adds the "subscriptions" edge to the UserSubscription entity by IDs.
+func (uu *UserUpdate) AddSubscriptionIDs(ids ...string) *UserUpdate {
+	uu.mutation.AddSubscriptionIDs(ids...)
+	return uu
+}
+
+// AddSubscriptions adds the "subscriptions" edges to the UserSubscription entity.
+func (uu *UserUpdate) AddSubscriptions(u ...*UserSubscription) *UserUpdate {
+	ids := make([]string, len(u))
+	for i := range u {
+		ids[i] = u[i].ID
+	}
+	return uu.AddSubscriptionIDs(ids...)
+}
+
+// AddConnectionIDs adds the "connections" edge to the UserConnection entity by IDs.
+func (uu *UserUpdate) AddConnectionIDs(ids ...string) *UserUpdate {
+	uu.mutation.AddConnectionIDs(ids...)
+	return uu
+}
+
+// AddConnections adds the "connections" edges to the UserConnection entity.
+func (uu *UserUpdate) AddConnections(u ...*UserConnection) *UserUpdate {
+	ids := make([]string, len(u))
+	for i := range u {
+		ids[i] = u[i].ID
+	}
+	return uu.AddConnectionIDs(ids...)
+}
+
+// AddContentIDs adds the "content" edge to the UserContent entity by IDs.
+func (uu *UserUpdate) AddContentIDs(ids ...string) *UserUpdate {
+	uu.mutation.AddContentIDs(ids...)
+	return uu
+}
+
+// AddContent adds the "content" edges to the UserContent entity.
+func (uu *UserUpdate) AddContent(u ...*UserContent) *UserUpdate {
+	ids := make([]string, len(u))
+	for i := range u {
+		ids[i] = u[i].ID
+	}
+	return uu.AddContentIDs(ids...)
+}
+
+// Mutation returns the UserMutation object of the builder.
+func (uu *UserUpdate) Mutation() *UserMutation {
+	return uu.mutation
+}
+
+// ClearSubscriptions clears all "subscriptions" edges to the UserSubscription entity.
+func (uu *UserUpdate) ClearSubscriptions() *UserUpdate {
+	uu.mutation.ClearSubscriptions()
+	return uu
+}
+
+// RemoveSubscriptionIDs removes the "subscriptions" edge to UserSubscription entities by IDs.
+func (uu *UserUpdate) RemoveSubscriptionIDs(ids ...string) *UserUpdate {
+	uu.mutation.RemoveSubscriptionIDs(ids...)
+	return uu
+}
+
+// RemoveSubscriptions removes "subscriptions" edges to UserSubscription entities.
+func (uu *UserUpdate) RemoveSubscriptions(u ...*UserSubscription) *UserUpdate {
+	ids := make([]string, len(u))
+	for i := range u {
+		ids[i] = u[i].ID
+	}
+	return uu.RemoveSubscriptionIDs(ids...)
+}
+
+// ClearConnections clears all "connections" edges to the UserConnection entity.
+func (uu *UserUpdate) ClearConnections() *UserUpdate {
+	uu.mutation.ClearConnections()
+	return uu
+}
+
+// RemoveConnectionIDs removes the "connections" edge to UserConnection entities by IDs.
+func (uu *UserUpdate) RemoveConnectionIDs(ids ...string) *UserUpdate {
+	uu.mutation.RemoveConnectionIDs(ids...)
+	return uu
+}
+
+// RemoveConnections removes "connections" edges to UserConnection entities.
+func (uu *UserUpdate) RemoveConnections(u ...*UserConnection) *UserUpdate {
+	ids := make([]string, len(u))
+	for i := range u {
+		ids[i] = u[i].ID
+	}
+	return uu.RemoveConnectionIDs(ids...)
+}
+
+// ClearContent clears all "content" edges to the UserContent entity.
+func (uu *UserUpdate) ClearContent() *UserUpdate {
+	uu.mutation.ClearContent()
+	return uu
+}
+
+// RemoveContentIDs removes the "content" edge to UserContent entities by IDs.
+func (uu *UserUpdate) RemoveContentIDs(ids ...string) *UserUpdate {
+	uu.mutation.RemoveContentIDs(ids...)
+	return uu
+}
+
+// RemoveContent removes "content" edges to UserContent entities.
+func (uu *UserUpdate) RemoveContent(u ...*UserContent) *UserUpdate {
+	ids := make([]string, len(u))
+	for i := range u {
+		ids[i] = u[i].ID
+	}
+	return uu.RemoveContentIDs(ids...)
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (uu *UserUpdate) Save(ctx context.Context) (int, error) {
+	uu.defaults()
+	return withHooks(ctx, uu.sqlSave, uu.mutation, uu.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (uu *UserUpdate) SaveX(ctx context.Context) int {
+	affected, err := uu.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return affected
+}
+
+// Exec executes the query.
+func (uu *UserUpdate) Exec(ctx context.Context) error {
+	_, err := uu.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (uu *UserUpdate) ExecX(ctx context.Context) {
+	if err := uu.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (uu *UserUpdate) defaults() {
+	if _, ok := uu.mutation.UpdatedAt(); !ok {
+		v := user.UpdateDefaultUpdatedAt()
+		uu.mutation.SetUpdatedAt(v)
+	}
+}
+
+func (uu *UserUpdate) sqlSave(ctx context.Context) (n int, err error) {
+	_spec := sqlgraph.NewUpdateSpec(user.Table, user.Columns, sqlgraph.NewFieldSpec(user.FieldID, field.TypeString))
+	if ps := uu.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := uu.mutation.UpdatedAt(); ok {
+		_spec.SetField(user.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := uu.mutation.AddedUpdatedAt(); ok {
+		_spec.AddField(user.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := uu.mutation.Permissions(); ok {
+		_spec.SetField(user.FieldPermissions, field.TypeString, value)
+	}
+	if value, ok := uu.mutation.FeatureFlags(); ok {
+		_spec.SetField(user.FieldFeatureFlags, field.TypeJSON, value)
+	}
+	if value, ok := uu.mutation.AppendedFeatureFlags(); ok {
+		_spec.AddModifier(func(u *sql.UpdateBuilder) {
+			sqljson.Append(u, user.FieldFeatureFlags, value)
+		})
+	}
+	if uu.mutation.FeatureFlagsCleared() {
+		_spec.ClearField(user.FieldFeatureFlags, field.TypeJSON)
+	}
+	if uu.mutation.SubscriptionsCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.SubscriptionsTable,
+			Columns: []string{user.SubscriptionsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(usersubscription.FieldID, field.TypeString),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := uu.mutation.RemovedSubscriptionsIDs(); len(nodes) > 0 && !uu.mutation.SubscriptionsCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.SubscriptionsTable,
+			Columns: []string{user.SubscriptionsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(usersubscription.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := uu.mutation.SubscriptionsIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.SubscriptionsTable,
+			Columns: []string{user.SubscriptionsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(usersubscription.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
+	if uu.mutation.ConnectionsCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.ConnectionsTable,
+			Columns: []string{user.ConnectionsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(userconnection.FieldID, field.TypeString),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := uu.mutation.RemovedConnectionsIDs(); len(nodes) > 0 && !uu.mutation.ConnectionsCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.ConnectionsTable,
+			Columns: []string{user.ConnectionsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(userconnection.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := uu.mutation.ConnectionsIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.ConnectionsTable,
+			Columns: []string{user.ConnectionsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(userconnection.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
+	if uu.mutation.ContentCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.ContentTable,
+			Columns: []string{user.ContentColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(usercontent.FieldID, field.TypeString),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := uu.mutation.RemovedContentIDs(); len(nodes) > 0 && !uu.mutation.ContentCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.ContentTable,
+			Columns: []string{user.ContentColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(usercontent.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := uu.mutation.ContentIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.ContentTable,
+			Columns: []string{user.ContentColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(usercontent.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
+	if n, err = sqlgraph.UpdateNodes(ctx, uu.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{user.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return 0, err
+	}
+	uu.mutation.done = true
+	return n, nil
+}
+
+// UserUpdateOne is the builder for updating a single User entity.
+type UserUpdateOne struct {
+	config
+	fields   []string
+	hooks    []Hook
+	mutation *UserMutation
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (uuo *UserUpdateOne) SetUpdatedAt(i int) *UserUpdateOne {
+	uuo.mutation.ResetUpdatedAt()
+	uuo.mutation.SetUpdatedAt(i)
+	return uuo
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (uuo *UserUpdateOne) AddUpdatedAt(i int) *UserUpdateOne {
+	uuo.mutation.AddUpdatedAt(i)
+	return uuo
+}
+
+// SetPermissions sets the "permissions" field.
+func (uuo *UserUpdateOne) SetPermissions(s string) *UserUpdateOne {
+	uuo.mutation.SetPermissions(s)
+	return uuo
+}
+
+// SetNillablePermissions sets the "permissions" field if the given value is not nil.
+func (uuo *UserUpdateOne) SetNillablePermissions(s *string) *UserUpdateOne {
+	if s != nil {
+		uuo.SetPermissions(*s)
+	}
+	return uuo
+}
+
+// SetFeatureFlags sets the "feature_flags" field.
+func (uuo *UserUpdateOne) SetFeatureFlags(s []string) *UserUpdateOne {
+	uuo.mutation.SetFeatureFlags(s)
+	return uuo
+}
+
+// AppendFeatureFlags appends s to the "feature_flags" field.
+func (uuo *UserUpdateOne) AppendFeatureFlags(s []string) *UserUpdateOne {
+	uuo.mutation.AppendFeatureFlags(s)
+	return uuo
+}
+
+// ClearFeatureFlags clears the value of the "feature_flags" field.
+func (uuo *UserUpdateOne) ClearFeatureFlags() *UserUpdateOne {
+	uuo.mutation.ClearFeatureFlags()
+	return uuo
+}
+
+// AddSubscriptionIDs adds the "subscriptions" edge to the UserSubscription entity by IDs.
+func (uuo *UserUpdateOne) AddSubscriptionIDs(ids ...string) *UserUpdateOne {
+	uuo.mutation.AddSubscriptionIDs(ids...)
+	return uuo
+}
+
+// AddSubscriptions adds the "subscriptions" edges to the UserSubscription entity.
+func (uuo *UserUpdateOne) AddSubscriptions(u ...*UserSubscription) *UserUpdateOne {
+	ids := make([]string, len(u))
+	for i := range u {
+		ids[i] = u[i].ID
+	}
+	return uuo.AddSubscriptionIDs(ids...)
+}
+
+// AddConnectionIDs adds the "connections" edge to the UserConnection entity by IDs.
+func (uuo *UserUpdateOne) AddConnectionIDs(ids ...string) *UserUpdateOne {
+	uuo.mutation.AddConnectionIDs(ids...)
+	return uuo
+}
+
+// AddConnections adds the "connections" edges to the UserConnection entity.
+func (uuo *UserUpdateOne) AddConnections(u ...*UserConnection) *UserUpdateOne {
+	ids := make([]string, len(u))
+	for i := range u {
+		ids[i] = u[i].ID
+	}
+	return uuo.AddConnectionIDs(ids...)
+}
+
+// AddContentIDs adds the "content" edge to the UserContent entity by IDs.
+func (uuo *UserUpdateOne) AddContentIDs(ids ...string) *UserUpdateOne {
+	uuo.mutation.AddContentIDs(ids...)
+	return uuo
+}
+
+// AddContent adds the "content" edges to the UserContent entity.
+func (uuo *UserUpdateOne) AddContent(u ...*UserContent) *UserUpdateOne {
+	ids := make([]string, len(u))
+	for i := range u {
+		ids[i] = u[i].ID
+	}
+	return uuo.AddContentIDs(ids...)
+}
+
+// Mutation returns the UserMutation object of the builder.
+func (uuo *UserUpdateOne) Mutation() *UserMutation {
+	return uuo.mutation
+}
+
+// ClearSubscriptions clears all "subscriptions" edges to the UserSubscription entity.
+func (uuo *UserUpdateOne) ClearSubscriptions() *UserUpdateOne {
+	uuo.mutation.ClearSubscriptions()
+	return uuo
+}
+
+// RemoveSubscriptionIDs removes the "subscriptions" edge to UserSubscription entities by IDs.
+func (uuo *UserUpdateOne) RemoveSubscriptionIDs(ids ...string) *UserUpdateOne {
+	uuo.mutation.RemoveSubscriptionIDs(ids...)
+	return uuo
+}
+
+// RemoveSubscriptions removes "subscriptions" edges to UserSubscription entities.
+func (uuo *UserUpdateOne) RemoveSubscriptions(u ...*UserSubscription) *UserUpdateOne {
+	ids := make([]string, len(u))
+	for i := range u {
+		ids[i] = u[i].ID
+	}
+	return uuo.RemoveSubscriptionIDs(ids...)
+}
+
+// ClearConnections clears all "connections" edges to the UserConnection entity.
+func (uuo *UserUpdateOne) ClearConnections() *UserUpdateOne {
+	uuo.mutation.ClearConnections()
+	return uuo
+}
+
+// RemoveConnectionIDs removes the "connections" edge to UserConnection entities by IDs.
+func (uuo *UserUpdateOne) RemoveConnectionIDs(ids ...string) *UserUpdateOne {
+	uuo.mutation.RemoveConnectionIDs(ids...)
+	return uuo
+}
+
+// RemoveConnections removes "connections" edges to UserConnection entities.
+func (uuo *UserUpdateOne) RemoveConnections(u ...*UserConnection) *UserUpdateOne {
+	ids := make([]string, len(u))
+	for i := range u {
+		ids[i] = u[i].ID
+	}
+	return uuo.RemoveConnectionIDs(ids...)
+}
+
+// ClearContent clears all "content" edges to the UserContent entity.
+func (uuo *UserUpdateOne) ClearContent() *UserUpdateOne {
+	uuo.mutation.ClearContent()
+	return uuo
+}
+
+// RemoveContentIDs removes the "content" edge to UserContent entities by IDs.
+func (uuo *UserUpdateOne) RemoveContentIDs(ids ...string) *UserUpdateOne {
+	uuo.mutation.RemoveContentIDs(ids...)
+	return uuo
+}
+
+// RemoveContent removes "content" edges to UserContent entities.
+func (uuo *UserUpdateOne) RemoveContent(u ...*UserContent) *UserUpdateOne {
+	ids := make([]string, len(u))
+	for i := range u {
+		ids[i] = u[i].ID
+	}
+	return uuo.RemoveContentIDs(ids...)
+}
+
+// Where appends a list predicates to the UserUpdate builder.
+func (uuo *UserUpdateOne) Where(ps ...predicate.User) *UserUpdateOne {
+	uuo.mutation.Where(ps...)
+	return uuo
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (uuo *UserUpdateOne) Select(field string, fields ...string) *UserUpdateOne {
+	uuo.fields = append([]string{field}, fields...)
+	return uuo
+}
+
+// Save executes the query and returns the updated User entity.
+func (uuo *UserUpdateOne) Save(ctx context.Context) (*User, error) {
+	uuo.defaults()
+	return withHooks(ctx, uuo.sqlSave, uuo.mutation, uuo.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (uuo *UserUpdateOne) SaveX(ctx context.Context) *User {
+	node, err := uuo.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// Exec executes the query on the entity.
+func (uuo *UserUpdateOne) Exec(ctx context.Context) error {
+	_, err := uuo.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (uuo *UserUpdateOne) ExecX(ctx context.Context) {
+	if err := uuo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (uuo *UserUpdateOne) defaults() {
+	if _, ok := uuo.mutation.UpdatedAt(); !ok {
+		v := user.UpdateDefaultUpdatedAt()
+		uuo.mutation.SetUpdatedAt(v)
+	}
+}
+
+func (uuo *UserUpdateOne) sqlSave(ctx context.Context) (_node *User, err error) {
+	_spec := sqlgraph.NewUpdateSpec(user.Table, user.Columns, sqlgraph.NewFieldSpec(user.FieldID, field.TypeString))
+	id, ok := uuo.mutation.ID()
+	if !ok {
+		return nil, &ValidationError{Name: "id", err: errors.New(`db: missing "User.id" for update`)}
+	}
+	_spec.Node.ID.Value = id
+	if fields := uuo.fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, user.FieldID)
+		for _, f := range fields {
+			if !user.ValidColumn(f) {
+				return nil, &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+			}
+			if f != user.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, f)
+			}
+		}
+	}
+	if ps := uuo.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := uuo.mutation.UpdatedAt(); ok {
+		_spec.SetField(user.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := uuo.mutation.AddedUpdatedAt(); ok {
+		_spec.AddField(user.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := uuo.mutation.Permissions(); ok {
+		_spec.SetField(user.FieldPermissions, field.TypeString, value)
+	}
+	if value, ok := uuo.mutation.FeatureFlags(); ok {
+		_spec.SetField(user.FieldFeatureFlags, field.TypeJSON, value)
+	}
+	if value, ok := uuo.mutation.AppendedFeatureFlags(); ok {
+		_spec.AddModifier(func(u *sql.UpdateBuilder) {
+			sqljson.Append(u, user.FieldFeatureFlags, value)
+		})
+	}
+	if uuo.mutation.FeatureFlagsCleared() {
+		_spec.ClearField(user.FieldFeatureFlags, field.TypeJSON)
+	}
+	if uuo.mutation.SubscriptionsCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.SubscriptionsTable,
+			Columns: []string{user.SubscriptionsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(usersubscription.FieldID, field.TypeString),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := uuo.mutation.RemovedSubscriptionsIDs(); len(nodes) > 0 && !uuo.mutation.SubscriptionsCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.SubscriptionsTable,
+			Columns: []string{user.SubscriptionsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(usersubscription.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := uuo.mutation.SubscriptionsIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.SubscriptionsTable,
+			Columns: []string{user.SubscriptionsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(usersubscription.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
+	if uuo.mutation.ConnectionsCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.ConnectionsTable,
+			Columns: []string{user.ConnectionsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(userconnection.FieldID, field.TypeString),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := uuo.mutation.RemovedConnectionsIDs(); len(nodes) > 0 && !uuo.mutation.ConnectionsCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.ConnectionsTable,
+			Columns: []string{user.ConnectionsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(userconnection.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := uuo.mutation.ConnectionsIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.ConnectionsTable,
+			Columns: []string{user.ConnectionsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(userconnection.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
+	if uuo.mutation.ContentCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.ContentTable,
+			Columns: []string{user.ContentColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(usercontent.FieldID, field.TypeString),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := uuo.mutation.RemovedContentIDs(); len(nodes) > 0 && !uuo.mutation.ContentCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.ContentTable,
+			Columns: []string{user.ContentColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(usercontent.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := uuo.mutation.ContentIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.ContentTable,
+			Columns: []string{user.ContentColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(usercontent.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
+	_node = &User{config: uuo.config}
+	_spec.Assign = _node.assignValues
+	_spec.ScanValues = _node.scanValues
+	if err = sqlgraph.UpdateNode(ctx, uuo.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{user.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	uuo.mutation.done = true
+	return _node, nil
+}
diff --git a/internal/database/ent/db/userconnection.go b/internal/database/ent/db/userconnection.go
new file mode 100644
index 00000000..c5b03752
--- /dev/null
+++ b/internal/database/ent/db/userconnection.go
@@ -0,0 +1,204 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+	"github.com/cufee/aftermath/internal/database/ent/db/user"
+	"github.com/cufee/aftermath/internal/database/ent/db/userconnection"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+// UserConnection is the model entity for the UserConnection schema.
+type UserConnection struct {
+	config `json:"-"`
+	// ID of the ent.
+	ID string `json:"id,omitempty"`
+	// CreatedAt holds the value of the "created_at" field.
+	CreatedAt int `json:"created_at,omitempty"`
+	// UpdatedAt holds the value of the "updated_at" field.
+	UpdatedAt int `json:"updated_at,omitempty"`
+	// Type holds the value of the "type" field.
+	Type models.ConnectionType `json:"type,omitempty"`
+	// UserID holds the value of the "user_id" field.
+	UserID string `json:"user_id,omitempty"`
+	// ReferenceID holds the value of the "reference_id" field.
+	ReferenceID string `json:"reference_id,omitempty"`
+	// Permissions holds the value of the "permissions" field.
+	Permissions string `json:"permissions,omitempty"`
+	// Metadata holds the value of the "metadata" field.
+	Metadata map[string]interface{} `json:"metadata,omitempty"`
+	// Edges holds the relations/edges for other nodes in the graph.
+	// The values are being populated by the UserConnectionQuery when eager-loading is set.
+	Edges        UserConnectionEdges `json:"edges"`
+	selectValues sql.SelectValues
+}
+
+// UserConnectionEdges holds the relations/edges for other nodes in the graph.
+type UserConnectionEdges struct {
+	// User holds the value of the user edge.
+	User *User `json:"user,omitempty"`
+	// loadedTypes holds the information for reporting if a
+	// type was loaded (or requested) in eager-loading or not.
+	loadedTypes [1]bool
+}
+
+// UserOrErr returns the User value or an error if the edge
+// was not loaded in eager-loading, or loaded but was not found.
+func (e UserConnectionEdges) UserOrErr() (*User, error) {
+	if e.User != nil {
+		return e.User, nil
+	} else if e.loadedTypes[0] {
+		return nil, &NotFoundError{label: user.Label}
+	}
+	return nil, &NotLoadedError{edge: "user"}
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*UserConnection) scanValues(columns []string) ([]any, error) {
+	values := make([]any, len(columns))
+	for i := range columns {
+		switch columns[i] {
+		case userconnection.FieldMetadata:
+			values[i] = new([]byte)
+		case userconnection.FieldCreatedAt, userconnection.FieldUpdatedAt:
+			values[i] = new(sql.NullInt64)
+		case userconnection.FieldID, userconnection.FieldType, userconnection.FieldUserID, userconnection.FieldReferenceID, userconnection.FieldPermissions:
+			values[i] = new(sql.NullString)
+		default:
+			values[i] = new(sql.UnknownType)
+		}
+	}
+	return values, nil
+}
+
+// assignValues assigns the values that were returned from sql.Rows (after scanning)
+// to the UserConnection fields.
+func (uc *UserConnection) assignValues(columns []string, values []any) error {
+	if m, n := len(values), len(columns); m < n {
+		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
+	}
+	for i := range columns {
+		switch columns[i] {
+		case userconnection.FieldID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field id", values[i])
+			} else if value.Valid {
+				uc.ID = value.String
+			}
+		case userconnection.FieldCreatedAt:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field created_at", values[i])
+			} else if value.Valid {
+				uc.CreatedAt = int(value.Int64)
+			}
+		case userconnection.FieldUpdatedAt:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
+			} else if value.Valid {
+				uc.UpdatedAt = int(value.Int64)
+			}
+		case userconnection.FieldType:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field type", values[i])
+			} else if value.Valid {
+				uc.Type = models.ConnectionType(value.String)
+			}
+		case userconnection.FieldUserID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field user_id", values[i])
+			} else if value.Valid {
+				uc.UserID = value.String
+			}
+		case userconnection.FieldReferenceID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field reference_id", values[i])
+			} else if value.Valid {
+				uc.ReferenceID = value.String
+			}
+		case userconnection.FieldPermissions:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field permissions", values[i])
+			} else if value.Valid {
+				uc.Permissions = value.String
+			}
+		case userconnection.FieldMetadata:
+			if value, ok := values[i].(*[]byte); !ok {
+				return fmt.Errorf("unexpected type %T for field metadata", values[i])
+			} else if value != nil && len(*value) > 0 {
+				if err := json.Unmarshal(*value, &uc.Metadata); err != nil {
+					return fmt.Errorf("unmarshal field metadata: %w", err)
+				}
+			}
+		default:
+			uc.selectValues.Set(columns[i], values[i])
+		}
+	}
+	return nil
+}
+
+// Value returns the ent.Value that was dynamically selected and assigned to the UserConnection.
+// This includes values selected through modifiers, order, etc.
+func (uc *UserConnection) Value(name string) (ent.Value, error) {
+	return uc.selectValues.Get(name)
+}
+
+// QueryUser queries the "user" edge of the UserConnection entity.
+func (uc *UserConnection) QueryUser() *UserQuery {
+	return NewUserConnectionClient(uc.config).QueryUser(uc)
+}
+
+// Update returns a builder for updating this UserConnection.
+// Note that you need to call UserConnection.Unwrap() before calling this method if this UserConnection
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (uc *UserConnection) Update() *UserConnectionUpdateOne {
+	return NewUserConnectionClient(uc.config).UpdateOne(uc)
+}
+
+// Unwrap unwraps the UserConnection entity that was returned from a transaction after it was closed,
+// so that all future queries will be executed through the driver which created the transaction.
+func (uc *UserConnection) Unwrap() *UserConnection {
+	_tx, ok := uc.config.driver.(*txDriver)
+	if !ok {
+		panic("db: UserConnection is not a transactional entity")
+	}
+	uc.config.driver = _tx.drv
+	return uc
+}
+
+// String implements the fmt.Stringer.
+func (uc *UserConnection) String() string {
+	var builder strings.Builder
+	builder.WriteString("UserConnection(")
+	builder.WriteString(fmt.Sprintf("id=%v, ", uc.ID))
+	builder.WriteString("created_at=")
+	builder.WriteString(fmt.Sprintf("%v", uc.CreatedAt))
+	builder.WriteString(", ")
+	builder.WriteString("updated_at=")
+	builder.WriteString(fmt.Sprintf("%v", uc.UpdatedAt))
+	builder.WriteString(", ")
+	builder.WriteString("type=")
+	builder.WriteString(fmt.Sprintf("%v", uc.Type))
+	builder.WriteString(", ")
+	builder.WriteString("user_id=")
+	builder.WriteString(uc.UserID)
+	builder.WriteString(", ")
+	builder.WriteString("reference_id=")
+	builder.WriteString(uc.ReferenceID)
+	builder.WriteString(", ")
+	builder.WriteString("permissions=")
+	builder.WriteString(uc.Permissions)
+	builder.WriteString(", ")
+	builder.WriteString("metadata=")
+	builder.WriteString(fmt.Sprintf("%v", uc.Metadata))
+	builder.WriteByte(')')
+	return builder.String()
+}
+
+// UserConnections is a parsable slice of UserConnection.
+type UserConnections []*UserConnection
diff --git a/internal/database/ent/db/userconnection/userconnection.go b/internal/database/ent/db/userconnection/userconnection.go
new file mode 100644
index 00000000..1cb8085b
--- /dev/null
+++ b/internal/database/ent/db/userconnection/userconnection.go
@@ -0,0 +1,140 @@
+// Code generated by ent, DO NOT EDIT.
+
+package userconnection
+
+import (
+	"fmt"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+const (
+	// Label holds the string label denoting the userconnection type in the database.
+	Label = "user_connection"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// FieldType holds the string denoting the type field in the database.
+	FieldType = "type"
+	// FieldUserID holds the string denoting the user_id field in the database.
+	FieldUserID = "user_id"
+	// FieldReferenceID holds the string denoting the reference_id field in the database.
+	FieldReferenceID = "reference_id"
+	// FieldPermissions holds the string denoting the permissions field in the database.
+	FieldPermissions = "permissions"
+	// FieldMetadata holds the string denoting the metadata field in the database.
+	FieldMetadata = "metadata"
+	// EdgeUser holds the string denoting the user edge name in mutations.
+	EdgeUser = "user"
+	// Table holds the table name of the userconnection in the database.
+	Table = "user_connections"
+	// UserTable is the table that holds the user relation/edge.
+	UserTable = "user_connections"
+	// UserInverseTable is the table name for the User entity.
+	// It exists in this package in order to avoid circular dependency with the "user" package.
+	UserInverseTable = "users"
+	// UserColumn is the table column denoting the user relation/edge.
+	UserColumn = "user_id"
+)
+
+// Columns holds all SQL columns for userconnection fields.
+var Columns = []string{
+	FieldID,
+	FieldCreatedAt,
+	FieldUpdatedAt,
+	FieldType,
+	FieldUserID,
+	FieldReferenceID,
+	FieldPermissions,
+	FieldMetadata,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() int
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() int
+	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
+	UpdateDefaultUpdatedAt func() int
+	// DefaultPermissions holds the default value on creation for the "permissions" field.
+	DefaultPermissions string
+	// DefaultID holds the default value on creation for the "id" field.
+	DefaultID func() string
+)
+
+// TypeValidator is a validator for the "type" field enum values. It is called by the builders before save.
+func TypeValidator(_type models.ConnectionType) error {
+	switch _type {
+	case "wargaming":
+		return nil
+	default:
+		return fmt.Errorf("userconnection: invalid enum value for type field: %q", _type)
+	}
+}
+
+// OrderOption defines the ordering options for the UserConnection queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByType orders the results by the type field.
+func ByType(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldType, opts...).ToFunc()
+}
+
+// ByUserID orders the results by the user_id field.
+func ByUserID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUserID, opts...).ToFunc()
+}
+
+// ByReferenceID orders the results by the reference_id field.
+func ByReferenceID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldReferenceID, opts...).ToFunc()
+}
+
+// ByPermissions orders the results by the permissions field.
+func ByPermissions(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldPermissions, opts...).ToFunc()
+}
+
+// ByUserField orders the results by user field.
+func ByUserField(field string, opts ...sql.OrderTermOption) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborTerms(s, newUserStep(), sql.OrderByField(field, opts...))
+	}
+}
+func newUserStep() *sqlgraph.Step {
+	return sqlgraph.NewStep(
+		sqlgraph.From(Table, FieldID),
+		sqlgraph.To(UserInverseTable, FieldID),
+		sqlgraph.Edge(sqlgraph.M2O, true, UserTable, UserColumn),
+	)
+}
diff --git a/internal/database/ent/db/userconnection/where.go b/internal/database/ent/db/userconnection/where.go
new file mode 100644
index 00000000..6d1f373a
--- /dev/null
+++ b/internal/database/ent/db/userconnection/where.go
@@ -0,0 +1,453 @@
+// Code generated by ent, DO NOT EDIT.
+
+package userconnection
+
+import (
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldLTE(FieldID, id))
+}
+
+// IDEqualFold applies the EqualFold predicate on the ID field.
+func IDEqualFold(id string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldEqualFold(FieldID, id))
+}
+
+// IDContainsFold applies the ContainsFold predicate on the ID field.
+func IDContainsFold(id string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldContainsFold(FieldID, id))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v int) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v int) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UserID applies equality check predicate on the "user_id" field. It's identical to UserIDEQ.
+func UserID(v string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldEQ(FieldUserID, v))
+}
+
+// ReferenceID applies equality check predicate on the "reference_id" field. It's identical to ReferenceIDEQ.
+func ReferenceID(v string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldEQ(FieldReferenceID, v))
+}
+
+// Permissions applies equality check predicate on the "permissions" field. It's identical to PermissionsEQ.
+func Permissions(v string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldEQ(FieldPermissions, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v int) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v int) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...int) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...int) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v int) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v int) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v int) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v int) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v int) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v int) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...int) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...int) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v int) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v int) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v int) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v int) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// TypeEQ applies the EQ predicate on the "type" field.
+func TypeEQ(v models.ConnectionType) predicate.UserConnection {
+	vc := v
+	return predicate.UserConnection(sql.FieldEQ(FieldType, vc))
+}
+
+// TypeNEQ applies the NEQ predicate on the "type" field.
+func TypeNEQ(v models.ConnectionType) predicate.UserConnection {
+	vc := v
+	return predicate.UserConnection(sql.FieldNEQ(FieldType, vc))
+}
+
+// TypeIn applies the In predicate on the "type" field.
+func TypeIn(vs ...models.ConnectionType) predicate.UserConnection {
+	v := make([]any, len(vs))
+	for i := range v {
+		v[i] = vs[i]
+	}
+	return predicate.UserConnection(sql.FieldIn(FieldType, v...))
+}
+
+// TypeNotIn applies the NotIn predicate on the "type" field.
+func TypeNotIn(vs ...models.ConnectionType) predicate.UserConnection {
+	v := make([]any, len(vs))
+	for i := range v {
+		v[i] = vs[i]
+	}
+	return predicate.UserConnection(sql.FieldNotIn(FieldType, v...))
+}
+
+// UserIDEQ applies the EQ predicate on the "user_id" field.
+func UserIDEQ(v string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldEQ(FieldUserID, v))
+}
+
+// UserIDNEQ applies the NEQ predicate on the "user_id" field.
+func UserIDNEQ(v string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldNEQ(FieldUserID, v))
+}
+
+// UserIDIn applies the In predicate on the "user_id" field.
+func UserIDIn(vs ...string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldIn(FieldUserID, vs...))
+}
+
+// UserIDNotIn applies the NotIn predicate on the "user_id" field.
+func UserIDNotIn(vs ...string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldNotIn(FieldUserID, vs...))
+}
+
+// UserIDGT applies the GT predicate on the "user_id" field.
+func UserIDGT(v string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldGT(FieldUserID, v))
+}
+
+// UserIDGTE applies the GTE predicate on the "user_id" field.
+func UserIDGTE(v string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldGTE(FieldUserID, v))
+}
+
+// UserIDLT applies the LT predicate on the "user_id" field.
+func UserIDLT(v string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldLT(FieldUserID, v))
+}
+
+// UserIDLTE applies the LTE predicate on the "user_id" field.
+func UserIDLTE(v string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldLTE(FieldUserID, v))
+}
+
+// UserIDContains applies the Contains predicate on the "user_id" field.
+func UserIDContains(v string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldContains(FieldUserID, v))
+}
+
+// UserIDHasPrefix applies the HasPrefix predicate on the "user_id" field.
+func UserIDHasPrefix(v string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldHasPrefix(FieldUserID, v))
+}
+
+// UserIDHasSuffix applies the HasSuffix predicate on the "user_id" field.
+func UserIDHasSuffix(v string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldHasSuffix(FieldUserID, v))
+}
+
+// UserIDEqualFold applies the EqualFold predicate on the "user_id" field.
+func UserIDEqualFold(v string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldEqualFold(FieldUserID, v))
+}
+
+// UserIDContainsFold applies the ContainsFold predicate on the "user_id" field.
+func UserIDContainsFold(v string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldContainsFold(FieldUserID, v))
+}
+
+// ReferenceIDEQ applies the EQ predicate on the "reference_id" field.
+func ReferenceIDEQ(v string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldEQ(FieldReferenceID, v))
+}
+
+// ReferenceIDNEQ applies the NEQ predicate on the "reference_id" field.
+func ReferenceIDNEQ(v string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldNEQ(FieldReferenceID, v))
+}
+
+// ReferenceIDIn applies the In predicate on the "reference_id" field.
+func ReferenceIDIn(vs ...string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldIn(FieldReferenceID, vs...))
+}
+
+// ReferenceIDNotIn applies the NotIn predicate on the "reference_id" field.
+func ReferenceIDNotIn(vs ...string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldNotIn(FieldReferenceID, vs...))
+}
+
+// ReferenceIDGT applies the GT predicate on the "reference_id" field.
+func ReferenceIDGT(v string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldGT(FieldReferenceID, v))
+}
+
+// ReferenceIDGTE applies the GTE predicate on the "reference_id" field.
+func ReferenceIDGTE(v string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldGTE(FieldReferenceID, v))
+}
+
+// ReferenceIDLT applies the LT predicate on the "reference_id" field.
+func ReferenceIDLT(v string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldLT(FieldReferenceID, v))
+}
+
+// ReferenceIDLTE applies the LTE predicate on the "reference_id" field.
+func ReferenceIDLTE(v string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldLTE(FieldReferenceID, v))
+}
+
+// ReferenceIDContains applies the Contains predicate on the "reference_id" field.
+func ReferenceIDContains(v string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldContains(FieldReferenceID, v))
+}
+
+// ReferenceIDHasPrefix applies the HasPrefix predicate on the "reference_id" field.
+func ReferenceIDHasPrefix(v string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldHasPrefix(FieldReferenceID, v))
+}
+
+// ReferenceIDHasSuffix applies the HasSuffix predicate on the "reference_id" field.
+func ReferenceIDHasSuffix(v string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldHasSuffix(FieldReferenceID, v))
+}
+
+// ReferenceIDEqualFold applies the EqualFold predicate on the "reference_id" field.
+func ReferenceIDEqualFold(v string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldEqualFold(FieldReferenceID, v))
+}
+
+// ReferenceIDContainsFold applies the ContainsFold predicate on the "reference_id" field.
+func ReferenceIDContainsFold(v string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldContainsFold(FieldReferenceID, v))
+}
+
+// PermissionsEQ applies the EQ predicate on the "permissions" field.
+func PermissionsEQ(v string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldEQ(FieldPermissions, v))
+}
+
+// PermissionsNEQ applies the NEQ predicate on the "permissions" field.
+func PermissionsNEQ(v string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldNEQ(FieldPermissions, v))
+}
+
+// PermissionsIn applies the In predicate on the "permissions" field.
+func PermissionsIn(vs ...string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldIn(FieldPermissions, vs...))
+}
+
+// PermissionsNotIn applies the NotIn predicate on the "permissions" field.
+func PermissionsNotIn(vs ...string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldNotIn(FieldPermissions, vs...))
+}
+
+// PermissionsGT applies the GT predicate on the "permissions" field.
+func PermissionsGT(v string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldGT(FieldPermissions, v))
+}
+
+// PermissionsGTE applies the GTE predicate on the "permissions" field.
+func PermissionsGTE(v string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldGTE(FieldPermissions, v))
+}
+
+// PermissionsLT applies the LT predicate on the "permissions" field.
+func PermissionsLT(v string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldLT(FieldPermissions, v))
+}
+
+// PermissionsLTE applies the LTE predicate on the "permissions" field.
+func PermissionsLTE(v string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldLTE(FieldPermissions, v))
+}
+
+// PermissionsContains applies the Contains predicate on the "permissions" field.
+func PermissionsContains(v string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldContains(FieldPermissions, v))
+}
+
+// PermissionsHasPrefix applies the HasPrefix predicate on the "permissions" field.
+func PermissionsHasPrefix(v string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldHasPrefix(FieldPermissions, v))
+}
+
+// PermissionsHasSuffix applies the HasSuffix predicate on the "permissions" field.
+func PermissionsHasSuffix(v string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldHasSuffix(FieldPermissions, v))
+}
+
+// PermissionsIsNil applies the IsNil predicate on the "permissions" field.
+func PermissionsIsNil() predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldIsNull(FieldPermissions))
+}
+
+// PermissionsNotNil applies the NotNil predicate on the "permissions" field.
+func PermissionsNotNil() predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldNotNull(FieldPermissions))
+}
+
+// PermissionsEqualFold applies the EqualFold predicate on the "permissions" field.
+func PermissionsEqualFold(v string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldEqualFold(FieldPermissions, v))
+}
+
+// PermissionsContainsFold applies the ContainsFold predicate on the "permissions" field.
+func PermissionsContainsFold(v string) predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldContainsFold(FieldPermissions, v))
+}
+
+// MetadataIsNil applies the IsNil predicate on the "metadata" field.
+func MetadataIsNil() predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldIsNull(FieldMetadata))
+}
+
+// MetadataNotNil applies the NotNil predicate on the "metadata" field.
+func MetadataNotNil() predicate.UserConnection {
+	return predicate.UserConnection(sql.FieldNotNull(FieldMetadata))
+}
+
+// HasUser applies the HasEdge predicate on the "user" edge.
+func HasUser() predicate.UserConnection {
+	return predicate.UserConnection(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, UserTable, UserColumn),
+		)
+		sqlgraph.HasNeighbors(s, step)
+	})
+}
+
+// HasUserWith applies the HasEdge predicate on the "user" edge with a given conditions (other predicates).
+func HasUserWith(preds ...predicate.User) predicate.UserConnection {
+	return predicate.UserConnection(func(s *sql.Selector) {
+		step := newUserStep()
+		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+			for _, p := range preds {
+				p(s)
+			}
+		})
+	})
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.UserConnection) predicate.UserConnection {
+	return predicate.UserConnection(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.UserConnection) predicate.UserConnection {
+	return predicate.UserConnection(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.UserConnection) predicate.UserConnection {
+	return predicate.UserConnection(sql.NotPredicates(p))
+}
diff --git a/internal/database/ent/db/userconnection_create.go b/internal/database/ent/db/userconnection_create.go
new file mode 100644
index 00000000..ee25aacf
--- /dev/null
+++ b/internal/database/ent/db/userconnection_create.go
@@ -0,0 +1,348 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/user"
+	"github.com/cufee/aftermath/internal/database/ent/db/userconnection"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+// UserConnectionCreate is the builder for creating a UserConnection entity.
+type UserConnectionCreate struct {
+	config
+	mutation *UserConnectionMutation
+	hooks    []Hook
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (ucc *UserConnectionCreate) SetCreatedAt(i int) *UserConnectionCreate {
+	ucc.mutation.SetCreatedAt(i)
+	return ucc
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (ucc *UserConnectionCreate) SetNillableCreatedAt(i *int) *UserConnectionCreate {
+	if i != nil {
+		ucc.SetCreatedAt(*i)
+	}
+	return ucc
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (ucc *UserConnectionCreate) SetUpdatedAt(i int) *UserConnectionCreate {
+	ucc.mutation.SetUpdatedAt(i)
+	return ucc
+}
+
+// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
+func (ucc *UserConnectionCreate) SetNillableUpdatedAt(i *int) *UserConnectionCreate {
+	if i != nil {
+		ucc.SetUpdatedAt(*i)
+	}
+	return ucc
+}
+
+// SetType sets the "type" field.
+func (ucc *UserConnectionCreate) SetType(mt models.ConnectionType) *UserConnectionCreate {
+	ucc.mutation.SetType(mt)
+	return ucc
+}
+
+// SetUserID sets the "user_id" field.
+func (ucc *UserConnectionCreate) SetUserID(s string) *UserConnectionCreate {
+	ucc.mutation.SetUserID(s)
+	return ucc
+}
+
+// SetReferenceID sets the "reference_id" field.
+func (ucc *UserConnectionCreate) SetReferenceID(s string) *UserConnectionCreate {
+	ucc.mutation.SetReferenceID(s)
+	return ucc
+}
+
+// SetPermissions sets the "permissions" field.
+func (ucc *UserConnectionCreate) SetPermissions(s string) *UserConnectionCreate {
+	ucc.mutation.SetPermissions(s)
+	return ucc
+}
+
+// SetNillablePermissions sets the "permissions" field if the given value is not nil.
+func (ucc *UserConnectionCreate) SetNillablePermissions(s *string) *UserConnectionCreate {
+	if s != nil {
+		ucc.SetPermissions(*s)
+	}
+	return ucc
+}
+
+// SetMetadata sets the "metadata" field.
+func (ucc *UserConnectionCreate) SetMetadata(m map[string]interface{}) *UserConnectionCreate {
+	ucc.mutation.SetMetadata(m)
+	return ucc
+}
+
+// SetID sets the "id" field.
+func (ucc *UserConnectionCreate) SetID(s string) *UserConnectionCreate {
+	ucc.mutation.SetID(s)
+	return ucc
+}
+
+// SetNillableID sets the "id" field if the given value is not nil.
+func (ucc *UserConnectionCreate) SetNillableID(s *string) *UserConnectionCreate {
+	if s != nil {
+		ucc.SetID(*s)
+	}
+	return ucc
+}
+
+// SetUser sets the "user" edge to the User entity.
+func (ucc *UserConnectionCreate) SetUser(u *User) *UserConnectionCreate {
+	return ucc.SetUserID(u.ID)
+}
+
+// Mutation returns the UserConnectionMutation object of the builder.
+func (ucc *UserConnectionCreate) Mutation() *UserConnectionMutation {
+	return ucc.mutation
+}
+
+// Save creates the UserConnection in the database.
+func (ucc *UserConnectionCreate) Save(ctx context.Context) (*UserConnection, error) {
+	ucc.defaults()
+	return withHooks(ctx, ucc.sqlSave, ucc.mutation, ucc.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (ucc *UserConnectionCreate) SaveX(ctx context.Context) *UserConnection {
+	v, err := ucc.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (ucc *UserConnectionCreate) Exec(ctx context.Context) error {
+	_, err := ucc.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (ucc *UserConnectionCreate) ExecX(ctx context.Context) {
+	if err := ucc.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (ucc *UserConnectionCreate) defaults() {
+	if _, ok := ucc.mutation.CreatedAt(); !ok {
+		v := userconnection.DefaultCreatedAt()
+		ucc.mutation.SetCreatedAt(v)
+	}
+	if _, ok := ucc.mutation.UpdatedAt(); !ok {
+		v := userconnection.DefaultUpdatedAt()
+		ucc.mutation.SetUpdatedAt(v)
+	}
+	if _, ok := ucc.mutation.Permissions(); !ok {
+		v := userconnection.DefaultPermissions
+		ucc.mutation.SetPermissions(v)
+	}
+	if _, ok := ucc.mutation.ID(); !ok {
+		v := userconnection.DefaultID()
+		ucc.mutation.SetID(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (ucc *UserConnectionCreate) check() error {
+	if _, ok := ucc.mutation.CreatedAt(); !ok {
+		return &ValidationError{Name: "created_at", err: errors.New(`db: missing required field "UserConnection.created_at"`)}
+	}
+	if _, ok := ucc.mutation.UpdatedAt(); !ok {
+		return &ValidationError{Name: "updated_at", err: errors.New(`db: missing required field "UserConnection.updated_at"`)}
+	}
+	if _, ok := ucc.mutation.GetType(); !ok {
+		return &ValidationError{Name: "type", err: errors.New(`db: missing required field "UserConnection.type"`)}
+	}
+	if v, ok := ucc.mutation.GetType(); ok {
+		if err := userconnection.TypeValidator(v); err != nil {
+			return &ValidationError{Name: "type", err: fmt.Errorf(`db: validator failed for field "UserConnection.type": %w`, err)}
+		}
+	}
+	if _, ok := ucc.mutation.UserID(); !ok {
+		return &ValidationError{Name: "user_id", err: errors.New(`db: missing required field "UserConnection.user_id"`)}
+	}
+	if _, ok := ucc.mutation.ReferenceID(); !ok {
+		return &ValidationError{Name: "reference_id", err: errors.New(`db: missing required field "UserConnection.reference_id"`)}
+	}
+	if _, ok := ucc.mutation.UserID(); !ok {
+		return &ValidationError{Name: "user", err: errors.New(`db: missing required edge "UserConnection.user"`)}
+	}
+	return nil
+}
+
+func (ucc *UserConnectionCreate) sqlSave(ctx context.Context) (*UserConnection, error) {
+	if err := ucc.check(); err != nil {
+		return nil, err
+	}
+	_node, _spec := ucc.createSpec()
+	if err := sqlgraph.CreateNode(ctx, ucc.driver, _spec); err != nil {
+		if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	if _spec.ID.Value != nil {
+		if id, ok := _spec.ID.Value.(string); ok {
+			_node.ID = id
+		} else {
+			return nil, fmt.Errorf("unexpected UserConnection.ID type: %T", _spec.ID.Value)
+		}
+	}
+	ucc.mutation.id = &_node.ID
+	ucc.mutation.done = true
+	return _node, nil
+}
+
+func (ucc *UserConnectionCreate) createSpec() (*UserConnection, *sqlgraph.CreateSpec) {
+	var (
+		_node = &UserConnection{config: ucc.config}
+		_spec = sqlgraph.NewCreateSpec(userconnection.Table, sqlgraph.NewFieldSpec(userconnection.FieldID, field.TypeString))
+	)
+	if id, ok := ucc.mutation.ID(); ok {
+		_node.ID = id
+		_spec.ID.Value = id
+	}
+	if value, ok := ucc.mutation.CreatedAt(); ok {
+		_spec.SetField(userconnection.FieldCreatedAt, field.TypeInt, value)
+		_node.CreatedAt = value
+	}
+	if value, ok := ucc.mutation.UpdatedAt(); ok {
+		_spec.SetField(userconnection.FieldUpdatedAt, field.TypeInt, value)
+		_node.UpdatedAt = value
+	}
+	if value, ok := ucc.mutation.GetType(); ok {
+		_spec.SetField(userconnection.FieldType, field.TypeEnum, value)
+		_node.Type = value
+	}
+	if value, ok := ucc.mutation.ReferenceID(); ok {
+		_spec.SetField(userconnection.FieldReferenceID, field.TypeString, value)
+		_node.ReferenceID = value
+	}
+	if value, ok := ucc.mutation.Permissions(); ok {
+		_spec.SetField(userconnection.FieldPermissions, field.TypeString, value)
+		_node.Permissions = value
+	}
+	if value, ok := ucc.mutation.Metadata(); ok {
+		_spec.SetField(userconnection.FieldMetadata, field.TypeJSON, value)
+		_node.Metadata = value
+	}
+	if nodes := ucc.mutation.UserIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   userconnection.UserTable,
+			Columns: []string{userconnection.UserColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_node.UserID = nodes[0]
+		_spec.Edges = append(_spec.Edges, edge)
+	}
+	return _node, _spec
+}
+
+// UserConnectionCreateBulk is the builder for creating many UserConnection entities in bulk.
+type UserConnectionCreateBulk struct {
+	config
+	err      error
+	builders []*UserConnectionCreate
+}
+
+// Save creates the UserConnection entities in the database.
+func (uccb *UserConnectionCreateBulk) Save(ctx context.Context) ([]*UserConnection, error) {
+	if uccb.err != nil {
+		return nil, uccb.err
+	}
+	specs := make([]*sqlgraph.CreateSpec, len(uccb.builders))
+	nodes := make([]*UserConnection, len(uccb.builders))
+	mutators := make([]Mutator, len(uccb.builders))
+	for i := range uccb.builders {
+		func(i int, root context.Context) {
+			builder := uccb.builders[i]
+			builder.defaults()
+			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+				mutation, ok := m.(*UserConnectionMutation)
+				if !ok {
+					return nil, fmt.Errorf("unexpected mutation type %T", m)
+				}
+				if err := builder.check(); err != nil {
+					return nil, err
+				}
+				builder.mutation = mutation
+				var err error
+				nodes[i], specs[i] = builder.createSpec()
+				if i < len(mutators)-1 {
+					_, err = mutators[i+1].Mutate(root, uccb.builders[i+1].mutation)
+				} else {
+					spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
+					// Invoke the actual operation on the latest mutation in the chain.
+					if err = sqlgraph.BatchCreate(ctx, uccb.driver, spec); err != nil {
+						if sqlgraph.IsConstraintError(err) {
+							err = &ConstraintError{msg: err.Error(), wrap: err}
+						}
+					}
+				}
+				if err != nil {
+					return nil, err
+				}
+				mutation.id = &nodes[i].ID
+				mutation.done = true
+				return nodes[i], nil
+			})
+			for i := len(builder.hooks) - 1; i >= 0; i-- {
+				mut = builder.hooks[i](mut)
+			}
+			mutators[i] = mut
+		}(i, ctx)
+	}
+	if len(mutators) > 0 {
+		if _, err := mutators[0].Mutate(ctx, uccb.builders[0].mutation); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (uccb *UserConnectionCreateBulk) SaveX(ctx context.Context) []*UserConnection {
+	v, err := uccb.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (uccb *UserConnectionCreateBulk) Exec(ctx context.Context) error {
+	_, err := uccb.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (uccb *UserConnectionCreateBulk) ExecX(ctx context.Context) {
+	if err := uccb.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/database/ent/db/userconnection_delete.go b/internal/database/ent/db/userconnection_delete.go
new file mode 100644
index 00000000..48b985f9
--- /dev/null
+++ b/internal/database/ent/db/userconnection_delete.go
@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/ent/db/userconnection"
+)
+
+// UserConnectionDelete is the builder for deleting a UserConnection entity.
+type UserConnectionDelete struct {
+	config
+	hooks    []Hook
+	mutation *UserConnectionMutation
+}
+
+// Where appends a list predicates to the UserConnectionDelete builder.
+func (ucd *UserConnectionDelete) Where(ps ...predicate.UserConnection) *UserConnectionDelete {
+	ucd.mutation.Where(ps...)
+	return ucd
+}
+
+// Exec executes the deletion query and returns how many vertices were deleted.
+func (ucd *UserConnectionDelete) Exec(ctx context.Context) (int, error) {
+	return withHooks(ctx, ucd.sqlExec, ucd.mutation, ucd.hooks)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (ucd *UserConnectionDelete) ExecX(ctx context.Context) int {
+	n, err := ucd.Exec(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return n
+}
+
+func (ucd *UserConnectionDelete) sqlExec(ctx context.Context) (int, error) {
+	_spec := sqlgraph.NewDeleteSpec(userconnection.Table, sqlgraph.NewFieldSpec(userconnection.FieldID, field.TypeString))
+	if ps := ucd.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	affected, err := sqlgraph.DeleteNodes(ctx, ucd.driver, _spec)
+	if err != nil && sqlgraph.IsConstraintError(err) {
+		err = &ConstraintError{msg: err.Error(), wrap: err}
+	}
+	ucd.mutation.done = true
+	return affected, err
+}
+
+// UserConnectionDeleteOne is the builder for deleting a single UserConnection entity.
+type UserConnectionDeleteOne struct {
+	ucd *UserConnectionDelete
+}
+
+// Where appends a list predicates to the UserConnectionDelete builder.
+func (ucdo *UserConnectionDeleteOne) Where(ps ...predicate.UserConnection) *UserConnectionDeleteOne {
+	ucdo.ucd.mutation.Where(ps...)
+	return ucdo
+}
+
+// Exec executes the deletion query.
+func (ucdo *UserConnectionDeleteOne) Exec(ctx context.Context) error {
+	n, err := ucdo.ucd.Exec(ctx)
+	switch {
+	case err != nil:
+		return err
+	case n == 0:
+		return &NotFoundError{userconnection.Label}
+	default:
+		return nil
+	}
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (ucdo *UserConnectionDeleteOne) ExecX(ctx context.Context) {
+	if err := ucdo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/database/ent/db/userconnection_query.go b/internal/database/ent/db/userconnection_query.go
new file mode 100644
index 00000000..020530b6
--- /dev/null
+++ b/internal/database/ent/db/userconnection_query.go
@@ -0,0 +1,605 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"fmt"
+	"math"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/ent/db/user"
+	"github.com/cufee/aftermath/internal/database/ent/db/userconnection"
+)
+
+// UserConnectionQuery is the builder for querying UserConnection entities.
+type UserConnectionQuery struct {
+	config
+	ctx        *QueryContext
+	order      []userconnection.OrderOption
+	inters     []Interceptor
+	predicates []predicate.UserConnection
+	withUser   *UserQuery
+	// intermediate query (i.e. traversal path).
+	sql  *sql.Selector
+	path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the UserConnectionQuery builder.
+func (ucq *UserConnectionQuery) Where(ps ...predicate.UserConnection) *UserConnectionQuery {
+	ucq.predicates = append(ucq.predicates, ps...)
+	return ucq
+}
+
+// Limit the number of records to be returned by this query.
+func (ucq *UserConnectionQuery) Limit(limit int) *UserConnectionQuery {
+	ucq.ctx.Limit = &limit
+	return ucq
+}
+
+// Offset to start from.
+func (ucq *UserConnectionQuery) Offset(offset int) *UserConnectionQuery {
+	ucq.ctx.Offset = &offset
+	return ucq
+}
+
+// Unique configures the query builder to filter duplicate records on query.
+// By default, unique is set to true, and can be disabled using this method.
+func (ucq *UserConnectionQuery) Unique(unique bool) *UserConnectionQuery {
+	ucq.ctx.Unique = &unique
+	return ucq
+}
+
+// Order specifies how the records should be ordered.
+func (ucq *UserConnectionQuery) Order(o ...userconnection.OrderOption) *UserConnectionQuery {
+	ucq.order = append(ucq.order, o...)
+	return ucq
+}
+
+// QueryUser chains the current query on the "user" edge.
+func (ucq *UserConnectionQuery) QueryUser() *UserQuery {
+	query := (&UserClient{config: ucq.config}).Query()
+	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+		if err := ucq.prepareQuery(ctx); err != nil {
+			return nil, err
+		}
+		selector := ucq.sqlQuery(ctx)
+		if err := selector.Err(); err != nil {
+			return nil, err
+		}
+		step := sqlgraph.NewStep(
+			sqlgraph.From(userconnection.Table, userconnection.FieldID, selector),
+			sqlgraph.To(user.Table, user.FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, userconnection.UserTable, userconnection.UserColumn),
+		)
+		fromU = sqlgraph.SetNeighbors(ucq.driver.Dialect(), step)
+		return fromU, nil
+	}
+	return query
+}
+
+// First returns the first UserConnection entity from the query.
+// Returns a *NotFoundError when no UserConnection was found.
+func (ucq *UserConnectionQuery) First(ctx context.Context) (*UserConnection, error) {
+	nodes, err := ucq.Limit(1).All(setContextOp(ctx, ucq.ctx, "First"))
+	if err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nil, &NotFoundError{userconnection.Label}
+	}
+	return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (ucq *UserConnectionQuery) FirstX(ctx context.Context) *UserConnection {
+	node, err := ucq.First(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return node
+}
+
+// FirstID returns the first UserConnection ID from the query.
+// Returns a *NotFoundError when no UserConnection ID was found.
+func (ucq *UserConnectionQuery) FirstID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = ucq.Limit(1).IDs(setContextOp(ctx, ucq.ctx, "FirstID")); err != nil {
+		return
+	}
+	if len(ids) == 0 {
+		err = &NotFoundError{userconnection.Label}
+		return
+	}
+	return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (ucq *UserConnectionQuery) FirstIDX(ctx context.Context) string {
+	id, err := ucq.FirstID(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return id
+}
+
+// Only returns a single UserConnection entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one UserConnection entity is found.
+// Returns a *NotFoundError when no UserConnection entities are found.
+func (ucq *UserConnectionQuery) Only(ctx context.Context) (*UserConnection, error) {
+	nodes, err := ucq.Limit(2).All(setContextOp(ctx, ucq.ctx, "Only"))
+	if err != nil {
+		return nil, err
+	}
+	switch len(nodes) {
+	case 1:
+		return nodes[0], nil
+	case 0:
+		return nil, &NotFoundError{userconnection.Label}
+	default:
+		return nil, &NotSingularError{userconnection.Label}
+	}
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (ucq *UserConnectionQuery) OnlyX(ctx context.Context) *UserConnection {
+	node, err := ucq.Only(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// OnlyID is like Only, but returns the only UserConnection ID in the query.
+// Returns a *NotSingularError when more than one UserConnection ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (ucq *UserConnectionQuery) OnlyID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = ucq.Limit(2).IDs(setContextOp(ctx, ucq.ctx, "OnlyID")); err != nil {
+		return
+	}
+	switch len(ids) {
+	case 1:
+		id = ids[0]
+	case 0:
+		err = &NotFoundError{userconnection.Label}
+	default:
+		err = &NotSingularError{userconnection.Label}
+	}
+	return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (ucq *UserConnectionQuery) OnlyIDX(ctx context.Context) string {
+	id, err := ucq.OnlyID(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return id
+}
+
+// All executes the query and returns a list of UserConnections.
+func (ucq *UserConnectionQuery) All(ctx context.Context) ([]*UserConnection, error) {
+	ctx = setContextOp(ctx, ucq.ctx, "All")
+	if err := ucq.prepareQuery(ctx); err != nil {
+		return nil, err
+	}
+	qr := querierAll[[]*UserConnection, *UserConnectionQuery]()
+	return withInterceptors[[]*UserConnection](ctx, ucq, qr, ucq.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (ucq *UserConnectionQuery) AllX(ctx context.Context) []*UserConnection {
+	nodes, err := ucq.All(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return nodes
+}
+
+// IDs executes the query and returns a list of UserConnection IDs.
+func (ucq *UserConnectionQuery) IDs(ctx context.Context) (ids []string, err error) {
+	if ucq.ctx.Unique == nil && ucq.path != nil {
+		ucq.Unique(true)
+	}
+	ctx = setContextOp(ctx, ucq.ctx, "IDs")
+	if err = ucq.Select(userconnection.FieldID).Scan(ctx, &ids); err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (ucq *UserConnectionQuery) IDsX(ctx context.Context) []string {
+	ids, err := ucq.IDs(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return ids
+}
+
+// Count returns the count of the given query.
+func (ucq *UserConnectionQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, ucq.ctx, "Count")
+	if err := ucq.prepareQuery(ctx); err != nil {
+		return 0, err
+	}
+	return withInterceptors[int](ctx, ucq, querierCount[*UserConnectionQuery](), ucq.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (ucq *UserConnectionQuery) CountX(ctx context.Context) int {
+	count, err := ucq.Count(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (ucq *UserConnectionQuery) Exist(ctx context.Context) (bool, error) {
+	ctx = setContextOp(ctx, ucq.ctx, "Exist")
+	switch _, err := ucq.FirstID(ctx); {
+	case IsNotFound(err):
+		return false, nil
+	case err != nil:
+		return false, fmt.Errorf("db: check existence: %w", err)
+	default:
+		return true, nil
+	}
+}
+
+// ExistX is like Exist, but panics if an error occurs.
+func (ucq *UserConnectionQuery) ExistX(ctx context.Context) bool {
+	exist, err := ucq.Exist(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return exist
+}
+
+// Clone returns a duplicate of the UserConnectionQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (ucq *UserConnectionQuery) Clone() *UserConnectionQuery {
+	if ucq == nil {
+		return nil
+	}
+	return &UserConnectionQuery{
+		config:     ucq.config,
+		ctx:        ucq.ctx.Clone(),
+		order:      append([]userconnection.OrderOption{}, ucq.order...),
+		inters:     append([]Interceptor{}, ucq.inters...),
+		predicates: append([]predicate.UserConnection{}, ucq.predicates...),
+		withUser:   ucq.withUser.Clone(),
+		// clone intermediate query.
+		sql:  ucq.sql.Clone(),
+		path: ucq.path,
+	}
+}
+
+// WithUser tells the query-builder to eager-load the nodes that are connected to
+// the "user" edge. The optional arguments are used to configure the query builder of the edge.
+func (ucq *UserConnectionQuery) WithUser(opts ...func(*UserQuery)) *UserConnectionQuery {
+	query := (&UserClient{config: ucq.config}).Query()
+	for _, opt := range opts {
+		opt(query)
+	}
+	ucq.withUser = query
+	return ucq
+}
+
+// GroupBy is used to group vertices by one or more fields/columns.
+// It is often used with aggregate functions, like: count, max, mean, min, sum.
+//
+// Example:
+//
+//	var v []struct {
+//		CreatedAt int `json:"created_at,omitempty"`
+//		Count int `json:"count,omitempty"`
+//	}
+//
+//	client.UserConnection.Query().
+//		GroupBy(userconnection.FieldCreatedAt).
+//		Aggregate(db.Count()).
+//		Scan(ctx, &v)
+func (ucq *UserConnectionQuery) GroupBy(field string, fields ...string) *UserConnectionGroupBy {
+	ucq.ctx.Fields = append([]string{field}, fields...)
+	grbuild := &UserConnectionGroupBy{build: ucq}
+	grbuild.flds = &ucq.ctx.Fields
+	grbuild.label = userconnection.Label
+	grbuild.scan = grbuild.Scan
+	return grbuild
+}
+
+// Select allows the selection one or more fields/columns for the given query,
+// instead of selecting all fields in the entity.
+//
+// Example:
+//
+//	var v []struct {
+//		CreatedAt int `json:"created_at,omitempty"`
+//	}
+//
+//	client.UserConnection.Query().
+//		Select(userconnection.FieldCreatedAt).
+//		Scan(ctx, &v)
+func (ucq *UserConnectionQuery) Select(fields ...string) *UserConnectionSelect {
+	ucq.ctx.Fields = append(ucq.ctx.Fields, fields...)
+	sbuild := &UserConnectionSelect{UserConnectionQuery: ucq}
+	sbuild.label = userconnection.Label
+	sbuild.flds, sbuild.scan = &ucq.ctx.Fields, sbuild.Scan
+	return sbuild
+}
+
+// Aggregate returns a UserConnectionSelect configured with the given aggregations.
+func (ucq *UserConnectionQuery) Aggregate(fns ...AggregateFunc) *UserConnectionSelect {
+	return ucq.Select().Aggregate(fns...)
+}
+
+func (ucq *UserConnectionQuery) prepareQuery(ctx context.Context) error {
+	for _, inter := range ucq.inters {
+		if inter == nil {
+			return fmt.Errorf("db: uninitialized interceptor (forgotten import db/runtime?)")
+		}
+		if trv, ok := inter.(Traverser); ok {
+			if err := trv.Traverse(ctx, ucq); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range ucq.ctx.Fields {
+		if !userconnection.ValidColumn(f) {
+			return &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+		}
+	}
+	if ucq.path != nil {
+		prev, err := ucq.path(ctx)
+		if err != nil {
+			return err
+		}
+		ucq.sql = prev
+	}
+	return nil
+}
+
+func (ucq *UserConnectionQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*UserConnection, error) {
+	var (
+		nodes       = []*UserConnection{}
+		_spec       = ucq.querySpec()
+		loadedTypes = [1]bool{
+			ucq.withUser != nil,
+		}
+	)
+	_spec.ScanValues = func(columns []string) ([]any, error) {
+		return (*UserConnection).scanValues(nil, columns)
+	}
+	_spec.Assign = func(columns []string, values []any) error {
+		node := &UserConnection{config: ucq.config}
+		nodes = append(nodes, node)
+		node.Edges.loadedTypes = loadedTypes
+		return node.assignValues(columns, values)
+	}
+	for i := range hooks {
+		hooks[i](ctx, _spec)
+	}
+	if err := sqlgraph.QueryNodes(ctx, ucq.driver, _spec); err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nodes, nil
+	}
+	if query := ucq.withUser; query != nil {
+		if err := ucq.loadUser(ctx, query, nodes, nil,
+			func(n *UserConnection, e *User) { n.Edges.User = e }); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+func (ucq *UserConnectionQuery) loadUser(ctx context.Context, query *UserQuery, nodes []*UserConnection, init func(*UserConnection), assign func(*UserConnection, *User)) error {
+	ids := make([]string, 0, len(nodes))
+	nodeids := make(map[string][]*UserConnection)
+	for i := range nodes {
+		fk := nodes[i].UserID
+		if _, ok := nodeids[fk]; !ok {
+			ids = append(ids, fk)
+		}
+		nodeids[fk] = append(nodeids[fk], nodes[i])
+	}
+	if len(ids) == 0 {
+		return nil
+	}
+	query.Where(user.IDIn(ids...))
+	neighbors, err := query.All(ctx)
+	if err != nil {
+		return err
+	}
+	for _, n := range neighbors {
+		nodes, ok := nodeids[n.ID]
+		if !ok {
+			return fmt.Errorf(`unexpected foreign-key "user_id" returned %v`, n.ID)
+		}
+		for i := range nodes {
+			assign(nodes[i], n)
+		}
+	}
+	return nil
+}
+
+func (ucq *UserConnectionQuery) sqlCount(ctx context.Context) (int, error) {
+	_spec := ucq.querySpec()
+	_spec.Node.Columns = ucq.ctx.Fields
+	if len(ucq.ctx.Fields) > 0 {
+		_spec.Unique = ucq.ctx.Unique != nil && *ucq.ctx.Unique
+	}
+	return sqlgraph.CountNodes(ctx, ucq.driver, _spec)
+}
+
+func (ucq *UserConnectionQuery) querySpec() *sqlgraph.QuerySpec {
+	_spec := sqlgraph.NewQuerySpec(userconnection.Table, userconnection.Columns, sqlgraph.NewFieldSpec(userconnection.FieldID, field.TypeString))
+	_spec.From = ucq.sql
+	if unique := ucq.ctx.Unique; unique != nil {
+		_spec.Unique = *unique
+	} else if ucq.path != nil {
+		_spec.Unique = true
+	}
+	if fields := ucq.ctx.Fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, userconnection.FieldID)
+		for i := range fields {
+			if fields[i] != userconnection.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+			}
+		}
+		if ucq.withUser != nil {
+			_spec.Node.AddColumnOnce(userconnection.FieldUserID)
+		}
+	}
+	if ps := ucq.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if limit := ucq.ctx.Limit; limit != nil {
+		_spec.Limit = *limit
+	}
+	if offset := ucq.ctx.Offset; offset != nil {
+		_spec.Offset = *offset
+	}
+	if ps := ucq.order; len(ps) > 0 {
+		_spec.Order = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	return _spec
+}
+
+func (ucq *UserConnectionQuery) sqlQuery(ctx context.Context) *sql.Selector {
+	builder := sql.Dialect(ucq.driver.Dialect())
+	t1 := builder.Table(userconnection.Table)
+	columns := ucq.ctx.Fields
+	if len(columns) == 0 {
+		columns = userconnection.Columns
+	}
+	selector := builder.Select(t1.Columns(columns...)...).From(t1)
+	if ucq.sql != nil {
+		selector = ucq.sql
+		selector.Select(selector.Columns(columns...)...)
+	}
+	if ucq.ctx.Unique != nil && *ucq.ctx.Unique {
+		selector.Distinct()
+	}
+	for _, p := range ucq.predicates {
+		p(selector)
+	}
+	for _, p := range ucq.order {
+		p(selector)
+	}
+	if offset := ucq.ctx.Offset; offset != nil {
+		// limit is mandatory for offset clause. We start
+		// with default value, and override it below if needed.
+		selector.Offset(*offset).Limit(math.MaxInt32)
+	}
+	if limit := ucq.ctx.Limit; limit != nil {
+		selector.Limit(*limit)
+	}
+	return selector
+}
+
+// UserConnectionGroupBy is the group-by builder for UserConnection entities.
+type UserConnectionGroupBy struct {
+	selector
+	build *UserConnectionQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (ucgb *UserConnectionGroupBy) Aggregate(fns ...AggregateFunc) *UserConnectionGroupBy {
+	ucgb.fns = append(ucgb.fns, fns...)
+	return ucgb
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (ucgb *UserConnectionGroupBy) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, ucgb.build.ctx, "GroupBy")
+	if err := ucgb.build.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*UserConnectionQuery, *UserConnectionGroupBy](ctx, ucgb.build, ucgb, ucgb.build.inters, v)
+}
+
+func (ucgb *UserConnectionGroupBy) sqlScan(ctx context.Context, root *UserConnectionQuery, v any) error {
+	selector := root.sqlQuery(ctx).Select()
+	aggregation := make([]string, 0, len(ucgb.fns))
+	for _, fn := range ucgb.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*ucgb.flds)+len(ucgb.fns))
+		for _, f := range *ucgb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*ucgb.flds...)...)
+	if err := selector.Err(); err != nil {
+		return err
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := ucgb.build.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
+
+// UserConnectionSelect is the builder for selecting fields of UserConnection entities.
+type UserConnectionSelect struct {
+	*UserConnectionQuery
+	selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (ucs *UserConnectionSelect) Aggregate(fns ...AggregateFunc) *UserConnectionSelect {
+	ucs.fns = append(ucs.fns, fns...)
+	return ucs
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (ucs *UserConnectionSelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, ucs.ctx, "Select")
+	if err := ucs.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*UserConnectionQuery, *UserConnectionSelect](ctx, ucs.UserConnectionQuery, ucs, ucs.inters, v)
+}
+
+func (ucs *UserConnectionSelect) sqlScan(ctx context.Context, root *UserConnectionQuery, v any) error {
+	selector := root.sqlQuery(ctx)
+	aggregation := make([]string, 0, len(ucs.fns))
+	for _, fn := range ucs.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	switch n := len(*ucs.selector.flds); {
+	case n == 0 && len(aggregation) > 0:
+		selector.Select(aggregation...)
+	case n != 0 && len(aggregation) > 0:
+		selector.AppendSelect(aggregation...)
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := ucs.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
diff --git a/internal/database/ent/db/userconnection_update.go b/internal/database/ent/db/userconnection_update.go
new file mode 100644
index 00000000..d7985deb
--- /dev/null
+++ b/internal/database/ent/db/userconnection_update.go
@@ -0,0 +1,420 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/ent/db/userconnection"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+// UserConnectionUpdate is the builder for updating UserConnection entities.
+type UserConnectionUpdate struct {
+	config
+	hooks    []Hook
+	mutation *UserConnectionMutation
+}
+
+// Where appends a list predicates to the UserConnectionUpdate builder.
+func (ucu *UserConnectionUpdate) Where(ps ...predicate.UserConnection) *UserConnectionUpdate {
+	ucu.mutation.Where(ps...)
+	return ucu
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (ucu *UserConnectionUpdate) SetUpdatedAt(i int) *UserConnectionUpdate {
+	ucu.mutation.ResetUpdatedAt()
+	ucu.mutation.SetUpdatedAt(i)
+	return ucu
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (ucu *UserConnectionUpdate) AddUpdatedAt(i int) *UserConnectionUpdate {
+	ucu.mutation.AddUpdatedAt(i)
+	return ucu
+}
+
+// SetType sets the "type" field.
+func (ucu *UserConnectionUpdate) SetType(mt models.ConnectionType) *UserConnectionUpdate {
+	ucu.mutation.SetType(mt)
+	return ucu
+}
+
+// SetNillableType sets the "type" field if the given value is not nil.
+func (ucu *UserConnectionUpdate) SetNillableType(mt *models.ConnectionType) *UserConnectionUpdate {
+	if mt != nil {
+		ucu.SetType(*mt)
+	}
+	return ucu
+}
+
+// SetReferenceID sets the "reference_id" field.
+func (ucu *UserConnectionUpdate) SetReferenceID(s string) *UserConnectionUpdate {
+	ucu.mutation.SetReferenceID(s)
+	return ucu
+}
+
+// SetNillableReferenceID sets the "reference_id" field if the given value is not nil.
+func (ucu *UserConnectionUpdate) SetNillableReferenceID(s *string) *UserConnectionUpdate {
+	if s != nil {
+		ucu.SetReferenceID(*s)
+	}
+	return ucu
+}
+
+// SetPermissions sets the "permissions" field.
+func (ucu *UserConnectionUpdate) SetPermissions(s string) *UserConnectionUpdate {
+	ucu.mutation.SetPermissions(s)
+	return ucu
+}
+
+// SetNillablePermissions sets the "permissions" field if the given value is not nil.
+func (ucu *UserConnectionUpdate) SetNillablePermissions(s *string) *UserConnectionUpdate {
+	if s != nil {
+		ucu.SetPermissions(*s)
+	}
+	return ucu
+}
+
+// ClearPermissions clears the value of the "permissions" field.
+func (ucu *UserConnectionUpdate) ClearPermissions() *UserConnectionUpdate {
+	ucu.mutation.ClearPermissions()
+	return ucu
+}
+
+// SetMetadata sets the "metadata" field.
+func (ucu *UserConnectionUpdate) SetMetadata(m map[string]interface{}) *UserConnectionUpdate {
+	ucu.mutation.SetMetadata(m)
+	return ucu
+}
+
+// ClearMetadata clears the value of the "metadata" field.
+func (ucu *UserConnectionUpdate) ClearMetadata() *UserConnectionUpdate {
+	ucu.mutation.ClearMetadata()
+	return ucu
+}
+
+// Mutation returns the UserConnectionMutation object of the builder.
+func (ucu *UserConnectionUpdate) Mutation() *UserConnectionMutation {
+	return ucu.mutation
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (ucu *UserConnectionUpdate) Save(ctx context.Context) (int, error) {
+	ucu.defaults()
+	return withHooks(ctx, ucu.sqlSave, ucu.mutation, ucu.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (ucu *UserConnectionUpdate) SaveX(ctx context.Context) int {
+	affected, err := ucu.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return affected
+}
+
+// Exec executes the query.
+func (ucu *UserConnectionUpdate) Exec(ctx context.Context) error {
+	_, err := ucu.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (ucu *UserConnectionUpdate) ExecX(ctx context.Context) {
+	if err := ucu.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (ucu *UserConnectionUpdate) defaults() {
+	if _, ok := ucu.mutation.UpdatedAt(); !ok {
+		v := userconnection.UpdateDefaultUpdatedAt()
+		ucu.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (ucu *UserConnectionUpdate) check() error {
+	if v, ok := ucu.mutation.GetType(); ok {
+		if err := userconnection.TypeValidator(v); err != nil {
+			return &ValidationError{Name: "type", err: fmt.Errorf(`db: validator failed for field "UserConnection.type": %w`, err)}
+		}
+	}
+	if _, ok := ucu.mutation.UserID(); ucu.mutation.UserCleared() && !ok {
+		return errors.New(`db: clearing a required unique edge "UserConnection.user"`)
+	}
+	return nil
+}
+
+func (ucu *UserConnectionUpdate) sqlSave(ctx context.Context) (n int, err error) {
+	if err := ucu.check(); err != nil {
+		return n, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(userconnection.Table, userconnection.Columns, sqlgraph.NewFieldSpec(userconnection.FieldID, field.TypeString))
+	if ps := ucu.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := ucu.mutation.UpdatedAt(); ok {
+		_spec.SetField(userconnection.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := ucu.mutation.AddedUpdatedAt(); ok {
+		_spec.AddField(userconnection.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := ucu.mutation.GetType(); ok {
+		_spec.SetField(userconnection.FieldType, field.TypeEnum, value)
+	}
+	if value, ok := ucu.mutation.ReferenceID(); ok {
+		_spec.SetField(userconnection.FieldReferenceID, field.TypeString, value)
+	}
+	if value, ok := ucu.mutation.Permissions(); ok {
+		_spec.SetField(userconnection.FieldPermissions, field.TypeString, value)
+	}
+	if ucu.mutation.PermissionsCleared() {
+		_spec.ClearField(userconnection.FieldPermissions, field.TypeString)
+	}
+	if value, ok := ucu.mutation.Metadata(); ok {
+		_spec.SetField(userconnection.FieldMetadata, field.TypeJSON, value)
+	}
+	if ucu.mutation.MetadataCleared() {
+		_spec.ClearField(userconnection.FieldMetadata, field.TypeJSON)
+	}
+	if n, err = sqlgraph.UpdateNodes(ctx, ucu.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{userconnection.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return 0, err
+	}
+	ucu.mutation.done = true
+	return n, nil
+}
+
+// UserConnectionUpdateOne is the builder for updating a single UserConnection entity.
+type UserConnectionUpdateOne struct {
+	config
+	fields   []string
+	hooks    []Hook
+	mutation *UserConnectionMutation
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (ucuo *UserConnectionUpdateOne) SetUpdatedAt(i int) *UserConnectionUpdateOne {
+	ucuo.mutation.ResetUpdatedAt()
+	ucuo.mutation.SetUpdatedAt(i)
+	return ucuo
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (ucuo *UserConnectionUpdateOne) AddUpdatedAt(i int) *UserConnectionUpdateOne {
+	ucuo.mutation.AddUpdatedAt(i)
+	return ucuo
+}
+
+// SetType sets the "type" field.
+func (ucuo *UserConnectionUpdateOne) SetType(mt models.ConnectionType) *UserConnectionUpdateOne {
+	ucuo.mutation.SetType(mt)
+	return ucuo
+}
+
+// SetNillableType sets the "type" field if the given value is not nil.
+func (ucuo *UserConnectionUpdateOne) SetNillableType(mt *models.ConnectionType) *UserConnectionUpdateOne {
+	if mt != nil {
+		ucuo.SetType(*mt)
+	}
+	return ucuo
+}
+
+// SetReferenceID sets the "reference_id" field.
+func (ucuo *UserConnectionUpdateOne) SetReferenceID(s string) *UserConnectionUpdateOne {
+	ucuo.mutation.SetReferenceID(s)
+	return ucuo
+}
+
+// SetNillableReferenceID sets the "reference_id" field if the given value is not nil.
+func (ucuo *UserConnectionUpdateOne) SetNillableReferenceID(s *string) *UserConnectionUpdateOne {
+	if s != nil {
+		ucuo.SetReferenceID(*s)
+	}
+	return ucuo
+}
+
+// SetPermissions sets the "permissions" field.
+func (ucuo *UserConnectionUpdateOne) SetPermissions(s string) *UserConnectionUpdateOne {
+	ucuo.mutation.SetPermissions(s)
+	return ucuo
+}
+
+// SetNillablePermissions sets the "permissions" field if the given value is not nil.
+func (ucuo *UserConnectionUpdateOne) SetNillablePermissions(s *string) *UserConnectionUpdateOne {
+	if s != nil {
+		ucuo.SetPermissions(*s)
+	}
+	return ucuo
+}
+
+// ClearPermissions clears the value of the "permissions" field.
+func (ucuo *UserConnectionUpdateOne) ClearPermissions() *UserConnectionUpdateOne {
+	ucuo.mutation.ClearPermissions()
+	return ucuo
+}
+
+// SetMetadata sets the "metadata" field.
+func (ucuo *UserConnectionUpdateOne) SetMetadata(m map[string]interface{}) *UserConnectionUpdateOne {
+	ucuo.mutation.SetMetadata(m)
+	return ucuo
+}
+
+// ClearMetadata clears the value of the "metadata" field.
+func (ucuo *UserConnectionUpdateOne) ClearMetadata() *UserConnectionUpdateOne {
+	ucuo.mutation.ClearMetadata()
+	return ucuo
+}
+
+// Mutation returns the UserConnectionMutation object of the builder.
+func (ucuo *UserConnectionUpdateOne) Mutation() *UserConnectionMutation {
+	return ucuo.mutation
+}
+
+// Where appends a list predicates to the UserConnectionUpdate builder.
+func (ucuo *UserConnectionUpdateOne) Where(ps ...predicate.UserConnection) *UserConnectionUpdateOne {
+	ucuo.mutation.Where(ps...)
+	return ucuo
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (ucuo *UserConnectionUpdateOne) Select(field string, fields ...string) *UserConnectionUpdateOne {
+	ucuo.fields = append([]string{field}, fields...)
+	return ucuo
+}
+
+// Save executes the query and returns the updated UserConnection entity.
+func (ucuo *UserConnectionUpdateOne) Save(ctx context.Context) (*UserConnection, error) {
+	ucuo.defaults()
+	return withHooks(ctx, ucuo.sqlSave, ucuo.mutation, ucuo.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (ucuo *UserConnectionUpdateOne) SaveX(ctx context.Context) *UserConnection {
+	node, err := ucuo.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// Exec executes the query on the entity.
+func (ucuo *UserConnectionUpdateOne) Exec(ctx context.Context) error {
+	_, err := ucuo.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (ucuo *UserConnectionUpdateOne) ExecX(ctx context.Context) {
+	if err := ucuo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (ucuo *UserConnectionUpdateOne) defaults() {
+	if _, ok := ucuo.mutation.UpdatedAt(); !ok {
+		v := userconnection.UpdateDefaultUpdatedAt()
+		ucuo.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (ucuo *UserConnectionUpdateOne) check() error {
+	if v, ok := ucuo.mutation.GetType(); ok {
+		if err := userconnection.TypeValidator(v); err != nil {
+			return &ValidationError{Name: "type", err: fmt.Errorf(`db: validator failed for field "UserConnection.type": %w`, err)}
+		}
+	}
+	if _, ok := ucuo.mutation.UserID(); ucuo.mutation.UserCleared() && !ok {
+		return errors.New(`db: clearing a required unique edge "UserConnection.user"`)
+	}
+	return nil
+}
+
+func (ucuo *UserConnectionUpdateOne) sqlSave(ctx context.Context) (_node *UserConnection, err error) {
+	if err := ucuo.check(); err != nil {
+		return _node, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(userconnection.Table, userconnection.Columns, sqlgraph.NewFieldSpec(userconnection.FieldID, field.TypeString))
+	id, ok := ucuo.mutation.ID()
+	if !ok {
+		return nil, &ValidationError{Name: "id", err: errors.New(`db: missing "UserConnection.id" for update`)}
+	}
+	_spec.Node.ID.Value = id
+	if fields := ucuo.fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, userconnection.FieldID)
+		for _, f := range fields {
+			if !userconnection.ValidColumn(f) {
+				return nil, &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+			}
+			if f != userconnection.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, f)
+			}
+		}
+	}
+	if ps := ucuo.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := ucuo.mutation.UpdatedAt(); ok {
+		_spec.SetField(userconnection.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := ucuo.mutation.AddedUpdatedAt(); ok {
+		_spec.AddField(userconnection.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := ucuo.mutation.GetType(); ok {
+		_spec.SetField(userconnection.FieldType, field.TypeEnum, value)
+	}
+	if value, ok := ucuo.mutation.ReferenceID(); ok {
+		_spec.SetField(userconnection.FieldReferenceID, field.TypeString, value)
+	}
+	if value, ok := ucuo.mutation.Permissions(); ok {
+		_spec.SetField(userconnection.FieldPermissions, field.TypeString, value)
+	}
+	if ucuo.mutation.PermissionsCleared() {
+		_spec.ClearField(userconnection.FieldPermissions, field.TypeString)
+	}
+	if value, ok := ucuo.mutation.Metadata(); ok {
+		_spec.SetField(userconnection.FieldMetadata, field.TypeJSON, value)
+	}
+	if ucuo.mutation.MetadataCleared() {
+		_spec.ClearField(userconnection.FieldMetadata, field.TypeJSON)
+	}
+	_node = &UserConnection{config: ucuo.config}
+	_spec.Assign = _node.assignValues
+	_spec.ScanValues = _node.scanValues
+	if err = sqlgraph.UpdateNode(ctx, ucuo.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{userconnection.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	ucuo.mutation.done = true
+	return _node, nil
+}
diff --git a/internal/database/ent/db/usercontent.go b/internal/database/ent/db/usercontent.go
new file mode 100644
index 00000000..f9c1b079
--- /dev/null
+++ b/internal/database/ent/db/usercontent.go
@@ -0,0 +1,206 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+	"github.com/cufee/aftermath/internal/database/ent/db/user"
+	"github.com/cufee/aftermath/internal/database/ent/db/usercontent"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+// UserContent is the model entity for the UserContent schema.
+type UserContent struct {
+	config `json:"-"`
+	// ID of the ent.
+	ID string `json:"id,omitempty"`
+	// CreatedAt holds the value of the "created_at" field.
+	CreatedAt int `json:"created_at,omitempty"`
+	// UpdatedAt holds the value of the "updated_at" field.
+	UpdatedAt int `json:"updated_at,omitempty"`
+	// Type holds the value of the "type" field.
+	Type models.UserContentType `json:"type,omitempty"`
+	// UserID holds the value of the "user_id" field.
+	UserID string `json:"user_id,omitempty"`
+	// ReferenceID holds the value of the "reference_id" field.
+	ReferenceID string `json:"reference_id,omitempty"`
+	// Value holds the value of the "value" field.
+	Value any `json:"value,omitempty"`
+	// Metadata holds the value of the "metadata" field.
+	Metadata map[string]interface{} `json:"metadata,omitempty"`
+	// Edges holds the relations/edges for other nodes in the graph.
+	// The values are being populated by the UserContentQuery when eager-loading is set.
+	Edges        UserContentEdges `json:"edges"`
+	selectValues sql.SelectValues
+}
+
+// UserContentEdges holds the relations/edges for other nodes in the graph.
+type UserContentEdges struct {
+	// User holds the value of the user edge.
+	User *User `json:"user,omitempty"`
+	// loadedTypes holds the information for reporting if a
+	// type was loaded (or requested) in eager-loading or not.
+	loadedTypes [1]bool
+}
+
+// UserOrErr returns the User value or an error if the edge
+// was not loaded in eager-loading, or loaded but was not found.
+func (e UserContentEdges) UserOrErr() (*User, error) {
+	if e.User != nil {
+		return e.User, nil
+	} else if e.loadedTypes[0] {
+		return nil, &NotFoundError{label: user.Label}
+	}
+	return nil, &NotLoadedError{edge: "user"}
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*UserContent) scanValues(columns []string) ([]any, error) {
+	values := make([]any, len(columns))
+	for i := range columns {
+		switch columns[i] {
+		case usercontent.FieldValue, usercontent.FieldMetadata:
+			values[i] = new([]byte)
+		case usercontent.FieldCreatedAt, usercontent.FieldUpdatedAt:
+			values[i] = new(sql.NullInt64)
+		case usercontent.FieldID, usercontent.FieldType, usercontent.FieldUserID, usercontent.FieldReferenceID:
+			values[i] = new(sql.NullString)
+		default:
+			values[i] = new(sql.UnknownType)
+		}
+	}
+	return values, nil
+}
+
+// assignValues assigns the values that were returned from sql.Rows (after scanning)
+// to the UserContent fields.
+func (uc *UserContent) assignValues(columns []string, values []any) error {
+	if m, n := len(values), len(columns); m < n {
+		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
+	}
+	for i := range columns {
+		switch columns[i] {
+		case usercontent.FieldID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field id", values[i])
+			} else if value.Valid {
+				uc.ID = value.String
+			}
+		case usercontent.FieldCreatedAt:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field created_at", values[i])
+			} else if value.Valid {
+				uc.CreatedAt = int(value.Int64)
+			}
+		case usercontent.FieldUpdatedAt:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
+			} else if value.Valid {
+				uc.UpdatedAt = int(value.Int64)
+			}
+		case usercontent.FieldType:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field type", values[i])
+			} else if value.Valid {
+				uc.Type = models.UserContentType(value.String)
+			}
+		case usercontent.FieldUserID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field user_id", values[i])
+			} else if value.Valid {
+				uc.UserID = value.String
+			}
+		case usercontent.FieldReferenceID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field reference_id", values[i])
+			} else if value.Valid {
+				uc.ReferenceID = value.String
+			}
+		case usercontent.FieldValue:
+			if value, ok := values[i].(*[]byte); !ok {
+				return fmt.Errorf("unexpected type %T for field value", values[i])
+			} else if value != nil && len(*value) > 0 {
+				if err := json.Unmarshal(*value, &uc.Value); err != nil {
+					return fmt.Errorf("unmarshal field value: %w", err)
+				}
+			}
+		case usercontent.FieldMetadata:
+			if value, ok := values[i].(*[]byte); !ok {
+				return fmt.Errorf("unexpected type %T for field metadata", values[i])
+			} else if value != nil && len(*value) > 0 {
+				if err := json.Unmarshal(*value, &uc.Metadata); err != nil {
+					return fmt.Errorf("unmarshal field metadata: %w", err)
+				}
+			}
+		default:
+			uc.selectValues.Set(columns[i], values[i])
+		}
+	}
+	return nil
+}
+
+// GetValue returns the ent.Value that was dynamically selected and assigned to the UserContent.
+// This includes values selected through modifiers, order, etc.
+func (uc *UserContent) GetValue(name string) (ent.Value, error) {
+	return uc.selectValues.Get(name)
+}
+
+// QueryUser queries the "user" edge of the UserContent entity.
+func (uc *UserContent) QueryUser() *UserQuery {
+	return NewUserContentClient(uc.config).QueryUser(uc)
+}
+
+// Update returns a builder for updating this UserContent.
+// Note that you need to call UserContent.Unwrap() before calling this method if this UserContent
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (uc *UserContent) Update() *UserContentUpdateOne {
+	return NewUserContentClient(uc.config).UpdateOne(uc)
+}
+
+// Unwrap unwraps the UserContent entity that was returned from a transaction after it was closed,
+// so that all future queries will be executed through the driver which created the transaction.
+func (uc *UserContent) Unwrap() *UserContent {
+	_tx, ok := uc.config.driver.(*txDriver)
+	if !ok {
+		panic("db: UserContent is not a transactional entity")
+	}
+	uc.config.driver = _tx.drv
+	return uc
+}
+
+// String implements the fmt.Stringer.
+func (uc *UserContent) String() string {
+	var builder strings.Builder
+	builder.WriteString("UserContent(")
+	builder.WriteString(fmt.Sprintf("id=%v, ", uc.ID))
+	builder.WriteString("created_at=")
+	builder.WriteString(fmt.Sprintf("%v", uc.CreatedAt))
+	builder.WriteString(", ")
+	builder.WriteString("updated_at=")
+	builder.WriteString(fmt.Sprintf("%v", uc.UpdatedAt))
+	builder.WriteString(", ")
+	builder.WriteString("type=")
+	builder.WriteString(fmt.Sprintf("%v", uc.Type))
+	builder.WriteString(", ")
+	builder.WriteString("user_id=")
+	builder.WriteString(uc.UserID)
+	builder.WriteString(", ")
+	builder.WriteString("reference_id=")
+	builder.WriteString(uc.ReferenceID)
+	builder.WriteString(", ")
+	builder.WriteString("value=")
+	builder.WriteString(fmt.Sprintf("%v", uc.Value))
+	builder.WriteString(", ")
+	builder.WriteString("metadata=")
+	builder.WriteString(fmt.Sprintf("%v", uc.Metadata))
+	builder.WriteByte(')')
+	return builder.String()
+}
+
+// UserContents is a parsable slice of UserContent.
+type UserContents []*UserContent
diff --git a/internal/database/ent/db/usercontent/usercontent.go b/internal/database/ent/db/usercontent/usercontent.go
new file mode 100644
index 00000000..c3ea1314
--- /dev/null
+++ b/internal/database/ent/db/usercontent/usercontent.go
@@ -0,0 +1,133 @@
+// Code generated by ent, DO NOT EDIT.
+
+package usercontent
+
+import (
+	"fmt"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+const (
+	// Label holds the string label denoting the usercontent type in the database.
+	Label = "user_content"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// FieldType holds the string denoting the type field in the database.
+	FieldType = "type"
+	// FieldUserID holds the string denoting the user_id field in the database.
+	FieldUserID = "user_id"
+	// FieldReferenceID holds the string denoting the reference_id field in the database.
+	FieldReferenceID = "reference_id"
+	// FieldValue holds the string denoting the value field in the database.
+	FieldValue = "value"
+	// FieldMetadata holds the string denoting the metadata field in the database.
+	FieldMetadata = "metadata"
+	// EdgeUser holds the string denoting the user edge name in mutations.
+	EdgeUser = "user"
+	// Table holds the table name of the usercontent in the database.
+	Table = "user_contents"
+	// UserTable is the table that holds the user relation/edge.
+	UserTable = "user_contents"
+	// UserInverseTable is the table name for the User entity.
+	// It exists in this package in order to avoid circular dependency with the "user" package.
+	UserInverseTable = "users"
+	// UserColumn is the table column denoting the user relation/edge.
+	UserColumn = "user_id"
+)
+
+// Columns holds all SQL columns for usercontent fields.
+var Columns = []string{
+	FieldID,
+	FieldCreatedAt,
+	FieldUpdatedAt,
+	FieldType,
+	FieldUserID,
+	FieldReferenceID,
+	FieldValue,
+	FieldMetadata,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() int
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() int
+	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
+	UpdateDefaultUpdatedAt func() int
+	// DefaultID holds the default value on creation for the "id" field.
+	DefaultID func() string
+)
+
+// TypeValidator is a validator for the "type" field enum values. It is called by the builders before save.
+func TypeValidator(_type models.UserContentType) error {
+	switch _type {
+	case "clan-background-image", "personal-background-image":
+		return nil
+	default:
+		return fmt.Errorf("usercontent: invalid enum value for type field: %q", _type)
+	}
+}
+
+// OrderOption defines the ordering options for the UserContent queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByType orders the results by the type field.
+func ByType(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldType, opts...).ToFunc()
+}
+
+// ByUserID orders the results by the user_id field.
+func ByUserID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUserID, opts...).ToFunc()
+}
+
+// ByReferenceID orders the results by the reference_id field.
+func ByReferenceID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldReferenceID, opts...).ToFunc()
+}
+
+// ByUserField orders the results by user field.
+func ByUserField(field string, opts ...sql.OrderTermOption) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborTerms(s, newUserStep(), sql.OrderByField(field, opts...))
+	}
+}
+func newUserStep() *sqlgraph.Step {
+	return sqlgraph.NewStep(
+		sqlgraph.From(Table, FieldID),
+		sqlgraph.To(UserInverseTable, FieldID),
+		sqlgraph.Edge(sqlgraph.M2O, true, UserTable, UserColumn),
+	)
+}
diff --git a/internal/database/ent/db/usercontent/where.go b/internal/database/ent/db/usercontent/where.go
new file mode 100644
index 00000000..41358635
--- /dev/null
+++ b/internal/database/ent/db/usercontent/where.go
@@ -0,0 +1,363 @@
+// Code generated by ent, DO NOT EDIT.
+
+package usercontent
+
+import (
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldLTE(FieldID, id))
+}
+
+// IDEqualFold applies the EqualFold predicate on the ID field.
+func IDEqualFold(id string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldEqualFold(FieldID, id))
+}
+
+// IDContainsFold applies the ContainsFold predicate on the ID field.
+func IDContainsFold(id string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldContainsFold(FieldID, id))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v int) predicate.UserContent {
+	return predicate.UserContent(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v int) predicate.UserContent {
+	return predicate.UserContent(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UserID applies equality check predicate on the "user_id" field. It's identical to UserIDEQ.
+func UserID(v string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldEQ(FieldUserID, v))
+}
+
+// ReferenceID applies equality check predicate on the "reference_id" field. It's identical to ReferenceIDEQ.
+func ReferenceID(v string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldEQ(FieldReferenceID, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v int) predicate.UserContent {
+	return predicate.UserContent(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v int) predicate.UserContent {
+	return predicate.UserContent(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...int) predicate.UserContent {
+	return predicate.UserContent(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...int) predicate.UserContent {
+	return predicate.UserContent(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v int) predicate.UserContent {
+	return predicate.UserContent(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v int) predicate.UserContent {
+	return predicate.UserContent(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v int) predicate.UserContent {
+	return predicate.UserContent(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v int) predicate.UserContent {
+	return predicate.UserContent(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v int) predicate.UserContent {
+	return predicate.UserContent(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v int) predicate.UserContent {
+	return predicate.UserContent(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...int) predicate.UserContent {
+	return predicate.UserContent(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...int) predicate.UserContent {
+	return predicate.UserContent(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v int) predicate.UserContent {
+	return predicate.UserContent(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v int) predicate.UserContent {
+	return predicate.UserContent(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v int) predicate.UserContent {
+	return predicate.UserContent(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v int) predicate.UserContent {
+	return predicate.UserContent(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// TypeEQ applies the EQ predicate on the "type" field.
+func TypeEQ(v models.UserContentType) predicate.UserContent {
+	vc := v
+	return predicate.UserContent(sql.FieldEQ(FieldType, vc))
+}
+
+// TypeNEQ applies the NEQ predicate on the "type" field.
+func TypeNEQ(v models.UserContentType) predicate.UserContent {
+	vc := v
+	return predicate.UserContent(sql.FieldNEQ(FieldType, vc))
+}
+
+// TypeIn applies the In predicate on the "type" field.
+func TypeIn(vs ...models.UserContentType) predicate.UserContent {
+	v := make([]any, len(vs))
+	for i := range v {
+		v[i] = vs[i]
+	}
+	return predicate.UserContent(sql.FieldIn(FieldType, v...))
+}
+
+// TypeNotIn applies the NotIn predicate on the "type" field.
+func TypeNotIn(vs ...models.UserContentType) predicate.UserContent {
+	v := make([]any, len(vs))
+	for i := range v {
+		v[i] = vs[i]
+	}
+	return predicate.UserContent(sql.FieldNotIn(FieldType, v...))
+}
+
+// UserIDEQ applies the EQ predicate on the "user_id" field.
+func UserIDEQ(v string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldEQ(FieldUserID, v))
+}
+
+// UserIDNEQ applies the NEQ predicate on the "user_id" field.
+func UserIDNEQ(v string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldNEQ(FieldUserID, v))
+}
+
+// UserIDIn applies the In predicate on the "user_id" field.
+func UserIDIn(vs ...string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldIn(FieldUserID, vs...))
+}
+
+// UserIDNotIn applies the NotIn predicate on the "user_id" field.
+func UserIDNotIn(vs ...string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldNotIn(FieldUserID, vs...))
+}
+
+// UserIDGT applies the GT predicate on the "user_id" field.
+func UserIDGT(v string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldGT(FieldUserID, v))
+}
+
+// UserIDGTE applies the GTE predicate on the "user_id" field.
+func UserIDGTE(v string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldGTE(FieldUserID, v))
+}
+
+// UserIDLT applies the LT predicate on the "user_id" field.
+func UserIDLT(v string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldLT(FieldUserID, v))
+}
+
+// UserIDLTE applies the LTE predicate on the "user_id" field.
+func UserIDLTE(v string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldLTE(FieldUserID, v))
+}
+
+// UserIDContains applies the Contains predicate on the "user_id" field.
+func UserIDContains(v string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldContains(FieldUserID, v))
+}
+
+// UserIDHasPrefix applies the HasPrefix predicate on the "user_id" field.
+func UserIDHasPrefix(v string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldHasPrefix(FieldUserID, v))
+}
+
+// UserIDHasSuffix applies the HasSuffix predicate on the "user_id" field.
+func UserIDHasSuffix(v string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldHasSuffix(FieldUserID, v))
+}
+
+// UserIDEqualFold applies the EqualFold predicate on the "user_id" field.
+func UserIDEqualFold(v string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldEqualFold(FieldUserID, v))
+}
+
+// UserIDContainsFold applies the ContainsFold predicate on the "user_id" field.
+func UserIDContainsFold(v string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldContainsFold(FieldUserID, v))
+}
+
+// ReferenceIDEQ applies the EQ predicate on the "reference_id" field.
+func ReferenceIDEQ(v string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldEQ(FieldReferenceID, v))
+}
+
+// ReferenceIDNEQ applies the NEQ predicate on the "reference_id" field.
+func ReferenceIDNEQ(v string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldNEQ(FieldReferenceID, v))
+}
+
+// ReferenceIDIn applies the In predicate on the "reference_id" field.
+func ReferenceIDIn(vs ...string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldIn(FieldReferenceID, vs...))
+}
+
+// ReferenceIDNotIn applies the NotIn predicate on the "reference_id" field.
+func ReferenceIDNotIn(vs ...string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldNotIn(FieldReferenceID, vs...))
+}
+
+// ReferenceIDGT applies the GT predicate on the "reference_id" field.
+func ReferenceIDGT(v string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldGT(FieldReferenceID, v))
+}
+
+// ReferenceIDGTE applies the GTE predicate on the "reference_id" field.
+func ReferenceIDGTE(v string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldGTE(FieldReferenceID, v))
+}
+
+// ReferenceIDLT applies the LT predicate on the "reference_id" field.
+func ReferenceIDLT(v string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldLT(FieldReferenceID, v))
+}
+
+// ReferenceIDLTE applies the LTE predicate on the "reference_id" field.
+func ReferenceIDLTE(v string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldLTE(FieldReferenceID, v))
+}
+
+// ReferenceIDContains applies the Contains predicate on the "reference_id" field.
+func ReferenceIDContains(v string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldContains(FieldReferenceID, v))
+}
+
+// ReferenceIDHasPrefix applies the HasPrefix predicate on the "reference_id" field.
+func ReferenceIDHasPrefix(v string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldHasPrefix(FieldReferenceID, v))
+}
+
+// ReferenceIDHasSuffix applies the HasSuffix predicate on the "reference_id" field.
+func ReferenceIDHasSuffix(v string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldHasSuffix(FieldReferenceID, v))
+}
+
+// ReferenceIDEqualFold applies the EqualFold predicate on the "reference_id" field.
+func ReferenceIDEqualFold(v string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldEqualFold(FieldReferenceID, v))
+}
+
+// ReferenceIDContainsFold applies the ContainsFold predicate on the "reference_id" field.
+func ReferenceIDContainsFold(v string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldContainsFold(FieldReferenceID, v))
+}
+
+// HasUser applies the HasEdge predicate on the "user" edge.
+func HasUser() predicate.UserContent {
+	return predicate.UserContent(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, UserTable, UserColumn),
+		)
+		sqlgraph.HasNeighbors(s, step)
+	})
+}
+
+// HasUserWith applies the HasEdge predicate on the "user" edge with a given conditions (other predicates).
+func HasUserWith(preds ...predicate.User) predicate.UserContent {
+	return predicate.UserContent(func(s *sql.Selector) {
+		step := newUserStep()
+		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+			for _, p := range preds {
+				p(s)
+			}
+		})
+	})
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.UserContent) predicate.UserContent {
+	return predicate.UserContent(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.UserContent) predicate.UserContent {
+	return predicate.UserContent(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.UserContent) predicate.UserContent {
+	return predicate.UserContent(sql.NotPredicates(p))
+}
diff --git a/internal/database/ent/db/usercontent_create.go b/internal/database/ent/db/usercontent_create.go
new file mode 100644
index 00000000..50abe9e4
--- /dev/null
+++ b/internal/database/ent/db/usercontent_create.go
@@ -0,0 +1,342 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/user"
+	"github.com/cufee/aftermath/internal/database/ent/db/usercontent"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+// UserContentCreate is the builder for creating a UserContent entity.
+type UserContentCreate struct {
+	config
+	mutation *UserContentMutation
+	hooks    []Hook
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (ucc *UserContentCreate) SetCreatedAt(i int) *UserContentCreate {
+	ucc.mutation.SetCreatedAt(i)
+	return ucc
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (ucc *UserContentCreate) SetNillableCreatedAt(i *int) *UserContentCreate {
+	if i != nil {
+		ucc.SetCreatedAt(*i)
+	}
+	return ucc
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (ucc *UserContentCreate) SetUpdatedAt(i int) *UserContentCreate {
+	ucc.mutation.SetUpdatedAt(i)
+	return ucc
+}
+
+// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
+func (ucc *UserContentCreate) SetNillableUpdatedAt(i *int) *UserContentCreate {
+	if i != nil {
+		ucc.SetUpdatedAt(*i)
+	}
+	return ucc
+}
+
+// SetType sets the "type" field.
+func (ucc *UserContentCreate) SetType(mct models.UserContentType) *UserContentCreate {
+	ucc.mutation.SetType(mct)
+	return ucc
+}
+
+// SetUserID sets the "user_id" field.
+func (ucc *UserContentCreate) SetUserID(s string) *UserContentCreate {
+	ucc.mutation.SetUserID(s)
+	return ucc
+}
+
+// SetReferenceID sets the "reference_id" field.
+func (ucc *UserContentCreate) SetReferenceID(s string) *UserContentCreate {
+	ucc.mutation.SetReferenceID(s)
+	return ucc
+}
+
+// SetValue sets the "value" field.
+func (ucc *UserContentCreate) SetValue(a any) *UserContentCreate {
+	ucc.mutation.SetValue(a)
+	return ucc
+}
+
+// SetMetadata sets the "metadata" field.
+func (ucc *UserContentCreate) SetMetadata(m map[string]interface{}) *UserContentCreate {
+	ucc.mutation.SetMetadata(m)
+	return ucc
+}
+
+// SetID sets the "id" field.
+func (ucc *UserContentCreate) SetID(s string) *UserContentCreate {
+	ucc.mutation.SetID(s)
+	return ucc
+}
+
+// SetNillableID sets the "id" field if the given value is not nil.
+func (ucc *UserContentCreate) SetNillableID(s *string) *UserContentCreate {
+	if s != nil {
+		ucc.SetID(*s)
+	}
+	return ucc
+}
+
+// SetUser sets the "user" edge to the User entity.
+func (ucc *UserContentCreate) SetUser(u *User) *UserContentCreate {
+	return ucc.SetUserID(u.ID)
+}
+
+// Mutation returns the UserContentMutation object of the builder.
+func (ucc *UserContentCreate) Mutation() *UserContentMutation {
+	return ucc.mutation
+}
+
+// Save creates the UserContent in the database.
+func (ucc *UserContentCreate) Save(ctx context.Context) (*UserContent, error) {
+	ucc.defaults()
+	return withHooks(ctx, ucc.sqlSave, ucc.mutation, ucc.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (ucc *UserContentCreate) SaveX(ctx context.Context) *UserContent {
+	v, err := ucc.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (ucc *UserContentCreate) Exec(ctx context.Context) error {
+	_, err := ucc.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (ucc *UserContentCreate) ExecX(ctx context.Context) {
+	if err := ucc.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (ucc *UserContentCreate) defaults() {
+	if _, ok := ucc.mutation.CreatedAt(); !ok {
+		v := usercontent.DefaultCreatedAt()
+		ucc.mutation.SetCreatedAt(v)
+	}
+	if _, ok := ucc.mutation.UpdatedAt(); !ok {
+		v := usercontent.DefaultUpdatedAt()
+		ucc.mutation.SetUpdatedAt(v)
+	}
+	if _, ok := ucc.mutation.ID(); !ok {
+		v := usercontent.DefaultID()
+		ucc.mutation.SetID(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (ucc *UserContentCreate) check() error {
+	if _, ok := ucc.mutation.CreatedAt(); !ok {
+		return &ValidationError{Name: "created_at", err: errors.New(`db: missing required field "UserContent.created_at"`)}
+	}
+	if _, ok := ucc.mutation.UpdatedAt(); !ok {
+		return &ValidationError{Name: "updated_at", err: errors.New(`db: missing required field "UserContent.updated_at"`)}
+	}
+	if _, ok := ucc.mutation.GetType(); !ok {
+		return &ValidationError{Name: "type", err: errors.New(`db: missing required field "UserContent.type"`)}
+	}
+	if v, ok := ucc.mutation.GetType(); ok {
+		if err := usercontent.TypeValidator(v); err != nil {
+			return &ValidationError{Name: "type", err: fmt.Errorf(`db: validator failed for field "UserContent.type": %w`, err)}
+		}
+	}
+	if _, ok := ucc.mutation.UserID(); !ok {
+		return &ValidationError{Name: "user_id", err: errors.New(`db: missing required field "UserContent.user_id"`)}
+	}
+	if _, ok := ucc.mutation.ReferenceID(); !ok {
+		return &ValidationError{Name: "reference_id", err: errors.New(`db: missing required field "UserContent.reference_id"`)}
+	}
+	if _, ok := ucc.mutation.Value(); !ok {
+		return &ValidationError{Name: "value", err: errors.New(`db: missing required field "UserContent.value"`)}
+	}
+	if _, ok := ucc.mutation.Metadata(); !ok {
+		return &ValidationError{Name: "metadata", err: errors.New(`db: missing required field "UserContent.metadata"`)}
+	}
+	if _, ok := ucc.mutation.UserID(); !ok {
+		return &ValidationError{Name: "user", err: errors.New(`db: missing required edge "UserContent.user"`)}
+	}
+	return nil
+}
+
+func (ucc *UserContentCreate) sqlSave(ctx context.Context) (*UserContent, error) {
+	if err := ucc.check(); err != nil {
+		return nil, err
+	}
+	_node, _spec := ucc.createSpec()
+	if err := sqlgraph.CreateNode(ctx, ucc.driver, _spec); err != nil {
+		if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	if _spec.ID.Value != nil {
+		if id, ok := _spec.ID.Value.(string); ok {
+			_node.ID = id
+		} else {
+			return nil, fmt.Errorf("unexpected UserContent.ID type: %T", _spec.ID.Value)
+		}
+	}
+	ucc.mutation.id = &_node.ID
+	ucc.mutation.done = true
+	return _node, nil
+}
+
+func (ucc *UserContentCreate) createSpec() (*UserContent, *sqlgraph.CreateSpec) {
+	var (
+		_node = &UserContent{config: ucc.config}
+		_spec = sqlgraph.NewCreateSpec(usercontent.Table, sqlgraph.NewFieldSpec(usercontent.FieldID, field.TypeString))
+	)
+	if id, ok := ucc.mutation.ID(); ok {
+		_node.ID = id
+		_spec.ID.Value = id
+	}
+	if value, ok := ucc.mutation.CreatedAt(); ok {
+		_spec.SetField(usercontent.FieldCreatedAt, field.TypeInt, value)
+		_node.CreatedAt = value
+	}
+	if value, ok := ucc.mutation.UpdatedAt(); ok {
+		_spec.SetField(usercontent.FieldUpdatedAt, field.TypeInt, value)
+		_node.UpdatedAt = value
+	}
+	if value, ok := ucc.mutation.GetType(); ok {
+		_spec.SetField(usercontent.FieldType, field.TypeEnum, value)
+		_node.Type = value
+	}
+	if value, ok := ucc.mutation.ReferenceID(); ok {
+		_spec.SetField(usercontent.FieldReferenceID, field.TypeString, value)
+		_node.ReferenceID = value
+	}
+	if value, ok := ucc.mutation.Value(); ok {
+		_spec.SetField(usercontent.FieldValue, field.TypeJSON, value)
+		_node.Value = value
+	}
+	if value, ok := ucc.mutation.Metadata(); ok {
+		_spec.SetField(usercontent.FieldMetadata, field.TypeJSON, value)
+		_node.Metadata = value
+	}
+	if nodes := ucc.mutation.UserIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   usercontent.UserTable,
+			Columns: []string{usercontent.UserColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_node.UserID = nodes[0]
+		_spec.Edges = append(_spec.Edges, edge)
+	}
+	return _node, _spec
+}
+
+// UserContentCreateBulk is the builder for creating many UserContent entities in bulk.
+type UserContentCreateBulk struct {
+	config
+	err      error
+	builders []*UserContentCreate
+}
+
+// Save creates the UserContent entities in the database.
+func (uccb *UserContentCreateBulk) Save(ctx context.Context) ([]*UserContent, error) {
+	if uccb.err != nil {
+		return nil, uccb.err
+	}
+	specs := make([]*sqlgraph.CreateSpec, len(uccb.builders))
+	nodes := make([]*UserContent, len(uccb.builders))
+	mutators := make([]Mutator, len(uccb.builders))
+	for i := range uccb.builders {
+		func(i int, root context.Context) {
+			builder := uccb.builders[i]
+			builder.defaults()
+			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+				mutation, ok := m.(*UserContentMutation)
+				if !ok {
+					return nil, fmt.Errorf("unexpected mutation type %T", m)
+				}
+				if err := builder.check(); err != nil {
+					return nil, err
+				}
+				builder.mutation = mutation
+				var err error
+				nodes[i], specs[i] = builder.createSpec()
+				if i < len(mutators)-1 {
+					_, err = mutators[i+1].Mutate(root, uccb.builders[i+1].mutation)
+				} else {
+					spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
+					// Invoke the actual operation on the latest mutation in the chain.
+					if err = sqlgraph.BatchCreate(ctx, uccb.driver, spec); err != nil {
+						if sqlgraph.IsConstraintError(err) {
+							err = &ConstraintError{msg: err.Error(), wrap: err}
+						}
+					}
+				}
+				if err != nil {
+					return nil, err
+				}
+				mutation.id = &nodes[i].ID
+				mutation.done = true
+				return nodes[i], nil
+			})
+			for i := len(builder.hooks) - 1; i >= 0; i-- {
+				mut = builder.hooks[i](mut)
+			}
+			mutators[i] = mut
+		}(i, ctx)
+	}
+	if len(mutators) > 0 {
+		if _, err := mutators[0].Mutate(ctx, uccb.builders[0].mutation); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (uccb *UserContentCreateBulk) SaveX(ctx context.Context) []*UserContent {
+	v, err := uccb.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (uccb *UserContentCreateBulk) Exec(ctx context.Context) error {
+	_, err := uccb.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (uccb *UserContentCreateBulk) ExecX(ctx context.Context) {
+	if err := uccb.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/database/ent/db/usercontent_delete.go b/internal/database/ent/db/usercontent_delete.go
new file mode 100644
index 00000000..a2674f8a
--- /dev/null
+++ b/internal/database/ent/db/usercontent_delete.go
@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/ent/db/usercontent"
+)
+
+// UserContentDelete is the builder for deleting a UserContent entity.
+type UserContentDelete struct {
+	config
+	hooks    []Hook
+	mutation *UserContentMutation
+}
+
+// Where appends a list predicates to the UserContentDelete builder.
+func (ucd *UserContentDelete) Where(ps ...predicate.UserContent) *UserContentDelete {
+	ucd.mutation.Where(ps...)
+	return ucd
+}
+
+// Exec executes the deletion query and returns how many vertices were deleted.
+func (ucd *UserContentDelete) Exec(ctx context.Context) (int, error) {
+	return withHooks(ctx, ucd.sqlExec, ucd.mutation, ucd.hooks)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (ucd *UserContentDelete) ExecX(ctx context.Context) int {
+	n, err := ucd.Exec(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return n
+}
+
+func (ucd *UserContentDelete) sqlExec(ctx context.Context) (int, error) {
+	_spec := sqlgraph.NewDeleteSpec(usercontent.Table, sqlgraph.NewFieldSpec(usercontent.FieldID, field.TypeString))
+	if ps := ucd.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	affected, err := sqlgraph.DeleteNodes(ctx, ucd.driver, _spec)
+	if err != nil && sqlgraph.IsConstraintError(err) {
+		err = &ConstraintError{msg: err.Error(), wrap: err}
+	}
+	ucd.mutation.done = true
+	return affected, err
+}
+
+// UserContentDeleteOne is the builder for deleting a single UserContent entity.
+type UserContentDeleteOne struct {
+	ucd *UserContentDelete
+}
+
+// Where appends a list predicates to the UserContentDelete builder.
+func (ucdo *UserContentDeleteOne) Where(ps ...predicate.UserContent) *UserContentDeleteOne {
+	ucdo.ucd.mutation.Where(ps...)
+	return ucdo
+}
+
+// Exec executes the deletion query.
+func (ucdo *UserContentDeleteOne) Exec(ctx context.Context) error {
+	n, err := ucdo.ucd.Exec(ctx)
+	switch {
+	case err != nil:
+		return err
+	case n == 0:
+		return &NotFoundError{usercontent.Label}
+	default:
+		return nil
+	}
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (ucdo *UserContentDeleteOne) ExecX(ctx context.Context) {
+	if err := ucdo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/database/ent/db/usercontent_query.go b/internal/database/ent/db/usercontent_query.go
new file mode 100644
index 00000000..21683730
--- /dev/null
+++ b/internal/database/ent/db/usercontent_query.go
@@ -0,0 +1,605 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"fmt"
+	"math"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/ent/db/user"
+	"github.com/cufee/aftermath/internal/database/ent/db/usercontent"
+)
+
+// UserContentQuery is the builder for querying UserContent entities.
+type UserContentQuery struct {
+	config
+	ctx        *QueryContext
+	order      []usercontent.OrderOption
+	inters     []Interceptor
+	predicates []predicate.UserContent
+	withUser   *UserQuery
+	// intermediate query (i.e. traversal path).
+	sql  *sql.Selector
+	path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the UserContentQuery builder.
+func (ucq *UserContentQuery) Where(ps ...predicate.UserContent) *UserContentQuery {
+	ucq.predicates = append(ucq.predicates, ps...)
+	return ucq
+}
+
+// Limit the number of records to be returned by this query.
+func (ucq *UserContentQuery) Limit(limit int) *UserContentQuery {
+	ucq.ctx.Limit = &limit
+	return ucq
+}
+
+// Offset to start from.
+func (ucq *UserContentQuery) Offset(offset int) *UserContentQuery {
+	ucq.ctx.Offset = &offset
+	return ucq
+}
+
+// Unique configures the query builder to filter duplicate records on query.
+// By default, unique is set to true, and can be disabled using this method.
+func (ucq *UserContentQuery) Unique(unique bool) *UserContentQuery {
+	ucq.ctx.Unique = &unique
+	return ucq
+}
+
+// Order specifies how the records should be ordered.
+func (ucq *UserContentQuery) Order(o ...usercontent.OrderOption) *UserContentQuery {
+	ucq.order = append(ucq.order, o...)
+	return ucq
+}
+
+// QueryUser chains the current query on the "user" edge.
+func (ucq *UserContentQuery) QueryUser() *UserQuery {
+	query := (&UserClient{config: ucq.config}).Query()
+	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+		if err := ucq.prepareQuery(ctx); err != nil {
+			return nil, err
+		}
+		selector := ucq.sqlQuery(ctx)
+		if err := selector.Err(); err != nil {
+			return nil, err
+		}
+		step := sqlgraph.NewStep(
+			sqlgraph.From(usercontent.Table, usercontent.FieldID, selector),
+			sqlgraph.To(user.Table, user.FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, usercontent.UserTable, usercontent.UserColumn),
+		)
+		fromU = sqlgraph.SetNeighbors(ucq.driver.Dialect(), step)
+		return fromU, nil
+	}
+	return query
+}
+
+// First returns the first UserContent entity from the query.
+// Returns a *NotFoundError when no UserContent was found.
+func (ucq *UserContentQuery) First(ctx context.Context) (*UserContent, error) {
+	nodes, err := ucq.Limit(1).All(setContextOp(ctx, ucq.ctx, "First"))
+	if err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nil, &NotFoundError{usercontent.Label}
+	}
+	return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (ucq *UserContentQuery) FirstX(ctx context.Context) *UserContent {
+	node, err := ucq.First(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return node
+}
+
+// FirstID returns the first UserContent ID from the query.
+// Returns a *NotFoundError when no UserContent ID was found.
+func (ucq *UserContentQuery) FirstID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = ucq.Limit(1).IDs(setContextOp(ctx, ucq.ctx, "FirstID")); err != nil {
+		return
+	}
+	if len(ids) == 0 {
+		err = &NotFoundError{usercontent.Label}
+		return
+	}
+	return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (ucq *UserContentQuery) FirstIDX(ctx context.Context) string {
+	id, err := ucq.FirstID(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return id
+}
+
+// Only returns a single UserContent entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one UserContent entity is found.
+// Returns a *NotFoundError when no UserContent entities are found.
+func (ucq *UserContentQuery) Only(ctx context.Context) (*UserContent, error) {
+	nodes, err := ucq.Limit(2).All(setContextOp(ctx, ucq.ctx, "Only"))
+	if err != nil {
+		return nil, err
+	}
+	switch len(nodes) {
+	case 1:
+		return nodes[0], nil
+	case 0:
+		return nil, &NotFoundError{usercontent.Label}
+	default:
+		return nil, &NotSingularError{usercontent.Label}
+	}
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (ucq *UserContentQuery) OnlyX(ctx context.Context) *UserContent {
+	node, err := ucq.Only(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// OnlyID is like Only, but returns the only UserContent ID in the query.
+// Returns a *NotSingularError when more than one UserContent ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (ucq *UserContentQuery) OnlyID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = ucq.Limit(2).IDs(setContextOp(ctx, ucq.ctx, "OnlyID")); err != nil {
+		return
+	}
+	switch len(ids) {
+	case 1:
+		id = ids[0]
+	case 0:
+		err = &NotFoundError{usercontent.Label}
+	default:
+		err = &NotSingularError{usercontent.Label}
+	}
+	return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (ucq *UserContentQuery) OnlyIDX(ctx context.Context) string {
+	id, err := ucq.OnlyID(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return id
+}
+
+// All executes the query and returns a list of UserContents.
+func (ucq *UserContentQuery) All(ctx context.Context) ([]*UserContent, error) {
+	ctx = setContextOp(ctx, ucq.ctx, "All")
+	if err := ucq.prepareQuery(ctx); err != nil {
+		return nil, err
+	}
+	qr := querierAll[[]*UserContent, *UserContentQuery]()
+	return withInterceptors[[]*UserContent](ctx, ucq, qr, ucq.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (ucq *UserContentQuery) AllX(ctx context.Context) []*UserContent {
+	nodes, err := ucq.All(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return nodes
+}
+
+// IDs executes the query and returns a list of UserContent IDs.
+func (ucq *UserContentQuery) IDs(ctx context.Context) (ids []string, err error) {
+	if ucq.ctx.Unique == nil && ucq.path != nil {
+		ucq.Unique(true)
+	}
+	ctx = setContextOp(ctx, ucq.ctx, "IDs")
+	if err = ucq.Select(usercontent.FieldID).Scan(ctx, &ids); err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (ucq *UserContentQuery) IDsX(ctx context.Context) []string {
+	ids, err := ucq.IDs(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return ids
+}
+
+// Count returns the count of the given query.
+func (ucq *UserContentQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, ucq.ctx, "Count")
+	if err := ucq.prepareQuery(ctx); err != nil {
+		return 0, err
+	}
+	return withInterceptors[int](ctx, ucq, querierCount[*UserContentQuery](), ucq.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (ucq *UserContentQuery) CountX(ctx context.Context) int {
+	count, err := ucq.Count(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (ucq *UserContentQuery) Exist(ctx context.Context) (bool, error) {
+	ctx = setContextOp(ctx, ucq.ctx, "Exist")
+	switch _, err := ucq.FirstID(ctx); {
+	case IsNotFound(err):
+		return false, nil
+	case err != nil:
+		return false, fmt.Errorf("db: check existence: %w", err)
+	default:
+		return true, nil
+	}
+}
+
+// ExistX is like Exist, but panics if an error occurs.
+func (ucq *UserContentQuery) ExistX(ctx context.Context) bool {
+	exist, err := ucq.Exist(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return exist
+}
+
+// Clone returns a duplicate of the UserContentQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (ucq *UserContentQuery) Clone() *UserContentQuery {
+	if ucq == nil {
+		return nil
+	}
+	return &UserContentQuery{
+		config:     ucq.config,
+		ctx:        ucq.ctx.Clone(),
+		order:      append([]usercontent.OrderOption{}, ucq.order...),
+		inters:     append([]Interceptor{}, ucq.inters...),
+		predicates: append([]predicate.UserContent{}, ucq.predicates...),
+		withUser:   ucq.withUser.Clone(),
+		// clone intermediate query.
+		sql:  ucq.sql.Clone(),
+		path: ucq.path,
+	}
+}
+
+// WithUser tells the query-builder to eager-load the nodes that are connected to
+// the "user" edge. The optional arguments are used to configure the query builder of the edge.
+func (ucq *UserContentQuery) WithUser(opts ...func(*UserQuery)) *UserContentQuery {
+	query := (&UserClient{config: ucq.config}).Query()
+	for _, opt := range opts {
+		opt(query)
+	}
+	ucq.withUser = query
+	return ucq
+}
+
+// GroupBy is used to group vertices by one or more fields/columns.
+// It is often used with aggregate functions, like: count, max, mean, min, sum.
+//
+// Example:
+//
+//	var v []struct {
+//		CreatedAt int `json:"created_at,omitempty"`
+//		Count int `json:"count,omitempty"`
+//	}
+//
+//	client.UserContent.Query().
+//		GroupBy(usercontent.FieldCreatedAt).
+//		Aggregate(db.Count()).
+//		Scan(ctx, &v)
+func (ucq *UserContentQuery) GroupBy(field string, fields ...string) *UserContentGroupBy {
+	ucq.ctx.Fields = append([]string{field}, fields...)
+	grbuild := &UserContentGroupBy{build: ucq}
+	grbuild.flds = &ucq.ctx.Fields
+	grbuild.label = usercontent.Label
+	grbuild.scan = grbuild.Scan
+	return grbuild
+}
+
+// Select allows the selection one or more fields/columns for the given query,
+// instead of selecting all fields in the entity.
+//
+// Example:
+//
+//	var v []struct {
+//		CreatedAt int `json:"created_at,omitempty"`
+//	}
+//
+//	client.UserContent.Query().
+//		Select(usercontent.FieldCreatedAt).
+//		Scan(ctx, &v)
+func (ucq *UserContentQuery) Select(fields ...string) *UserContentSelect {
+	ucq.ctx.Fields = append(ucq.ctx.Fields, fields...)
+	sbuild := &UserContentSelect{UserContentQuery: ucq}
+	sbuild.label = usercontent.Label
+	sbuild.flds, sbuild.scan = &ucq.ctx.Fields, sbuild.Scan
+	return sbuild
+}
+
+// Aggregate returns a UserContentSelect configured with the given aggregations.
+func (ucq *UserContentQuery) Aggregate(fns ...AggregateFunc) *UserContentSelect {
+	return ucq.Select().Aggregate(fns...)
+}
+
+func (ucq *UserContentQuery) prepareQuery(ctx context.Context) error {
+	for _, inter := range ucq.inters {
+		if inter == nil {
+			return fmt.Errorf("db: uninitialized interceptor (forgotten import db/runtime?)")
+		}
+		if trv, ok := inter.(Traverser); ok {
+			if err := trv.Traverse(ctx, ucq); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range ucq.ctx.Fields {
+		if !usercontent.ValidColumn(f) {
+			return &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+		}
+	}
+	if ucq.path != nil {
+		prev, err := ucq.path(ctx)
+		if err != nil {
+			return err
+		}
+		ucq.sql = prev
+	}
+	return nil
+}
+
+func (ucq *UserContentQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*UserContent, error) {
+	var (
+		nodes       = []*UserContent{}
+		_spec       = ucq.querySpec()
+		loadedTypes = [1]bool{
+			ucq.withUser != nil,
+		}
+	)
+	_spec.ScanValues = func(columns []string) ([]any, error) {
+		return (*UserContent).scanValues(nil, columns)
+	}
+	_spec.Assign = func(columns []string, values []any) error {
+		node := &UserContent{config: ucq.config}
+		nodes = append(nodes, node)
+		node.Edges.loadedTypes = loadedTypes
+		return node.assignValues(columns, values)
+	}
+	for i := range hooks {
+		hooks[i](ctx, _spec)
+	}
+	if err := sqlgraph.QueryNodes(ctx, ucq.driver, _spec); err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nodes, nil
+	}
+	if query := ucq.withUser; query != nil {
+		if err := ucq.loadUser(ctx, query, nodes, nil,
+			func(n *UserContent, e *User) { n.Edges.User = e }); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+func (ucq *UserContentQuery) loadUser(ctx context.Context, query *UserQuery, nodes []*UserContent, init func(*UserContent), assign func(*UserContent, *User)) error {
+	ids := make([]string, 0, len(nodes))
+	nodeids := make(map[string][]*UserContent)
+	for i := range nodes {
+		fk := nodes[i].UserID
+		if _, ok := nodeids[fk]; !ok {
+			ids = append(ids, fk)
+		}
+		nodeids[fk] = append(nodeids[fk], nodes[i])
+	}
+	if len(ids) == 0 {
+		return nil
+	}
+	query.Where(user.IDIn(ids...))
+	neighbors, err := query.All(ctx)
+	if err != nil {
+		return err
+	}
+	for _, n := range neighbors {
+		nodes, ok := nodeids[n.ID]
+		if !ok {
+			return fmt.Errorf(`unexpected foreign-key "user_id" returned %v`, n.ID)
+		}
+		for i := range nodes {
+			assign(nodes[i], n)
+		}
+	}
+	return nil
+}
+
+func (ucq *UserContentQuery) sqlCount(ctx context.Context) (int, error) {
+	_spec := ucq.querySpec()
+	_spec.Node.Columns = ucq.ctx.Fields
+	if len(ucq.ctx.Fields) > 0 {
+		_spec.Unique = ucq.ctx.Unique != nil && *ucq.ctx.Unique
+	}
+	return sqlgraph.CountNodes(ctx, ucq.driver, _spec)
+}
+
+func (ucq *UserContentQuery) querySpec() *sqlgraph.QuerySpec {
+	_spec := sqlgraph.NewQuerySpec(usercontent.Table, usercontent.Columns, sqlgraph.NewFieldSpec(usercontent.FieldID, field.TypeString))
+	_spec.From = ucq.sql
+	if unique := ucq.ctx.Unique; unique != nil {
+		_spec.Unique = *unique
+	} else if ucq.path != nil {
+		_spec.Unique = true
+	}
+	if fields := ucq.ctx.Fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, usercontent.FieldID)
+		for i := range fields {
+			if fields[i] != usercontent.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+			}
+		}
+		if ucq.withUser != nil {
+			_spec.Node.AddColumnOnce(usercontent.FieldUserID)
+		}
+	}
+	if ps := ucq.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if limit := ucq.ctx.Limit; limit != nil {
+		_spec.Limit = *limit
+	}
+	if offset := ucq.ctx.Offset; offset != nil {
+		_spec.Offset = *offset
+	}
+	if ps := ucq.order; len(ps) > 0 {
+		_spec.Order = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	return _spec
+}
+
+func (ucq *UserContentQuery) sqlQuery(ctx context.Context) *sql.Selector {
+	builder := sql.Dialect(ucq.driver.Dialect())
+	t1 := builder.Table(usercontent.Table)
+	columns := ucq.ctx.Fields
+	if len(columns) == 0 {
+		columns = usercontent.Columns
+	}
+	selector := builder.Select(t1.Columns(columns...)...).From(t1)
+	if ucq.sql != nil {
+		selector = ucq.sql
+		selector.Select(selector.Columns(columns...)...)
+	}
+	if ucq.ctx.Unique != nil && *ucq.ctx.Unique {
+		selector.Distinct()
+	}
+	for _, p := range ucq.predicates {
+		p(selector)
+	}
+	for _, p := range ucq.order {
+		p(selector)
+	}
+	if offset := ucq.ctx.Offset; offset != nil {
+		// limit is mandatory for offset clause. We start
+		// with default value, and override it below if needed.
+		selector.Offset(*offset).Limit(math.MaxInt32)
+	}
+	if limit := ucq.ctx.Limit; limit != nil {
+		selector.Limit(*limit)
+	}
+	return selector
+}
+
+// UserContentGroupBy is the group-by builder for UserContent entities.
+type UserContentGroupBy struct {
+	selector
+	build *UserContentQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (ucgb *UserContentGroupBy) Aggregate(fns ...AggregateFunc) *UserContentGroupBy {
+	ucgb.fns = append(ucgb.fns, fns...)
+	return ucgb
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (ucgb *UserContentGroupBy) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, ucgb.build.ctx, "GroupBy")
+	if err := ucgb.build.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*UserContentQuery, *UserContentGroupBy](ctx, ucgb.build, ucgb, ucgb.build.inters, v)
+}
+
+func (ucgb *UserContentGroupBy) sqlScan(ctx context.Context, root *UserContentQuery, v any) error {
+	selector := root.sqlQuery(ctx).Select()
+	aggregation := make([]string, 0, len(ucgb.fns))
+	for _, fn := range ucgb.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*ucgb.flds)+len(ucgb.fns))
+		for _, f := range *ucgb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*ucgb.flds...)...)
+	if err := selector.Err(); err != nil {
+		return err
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := ucgb.build.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
+
+// UserContentSelect is the builder for selecting fields of UserContent entities.
+type UserContentSelect struct {
+	*UserContentQuery
+	selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (ucs *UserContentSelect) Aggregate(fns ...AggregateFunc) *UserContentSelect {
+	ucs.fns = append(ucs.fns, fns...)
+	return ucs
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (ucs *UserContentSelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, ucs.ctx, "Select")
+	if err := ucs.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*UserContentQuery, *UserContentSelect](ctx, ucs.UserContentQuery, ucs, ucs.inters, v)
+}
+
+func (ucs *UserContentSelect) sqlScan(ctx context.Context, root *UserContentQuery, v any) error {
+	selector := root.sqlQuery(ctx)
+	aggregation := make([]string, 0, len(ucs.fns))
+	for _, fn := range ucs.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	switch n := len(*ucs.selector.flds); {
+	case n == 0 && len(aggregation) > 0:
+		selector.Select(aggregation...)
+	case n != 0 && len(aggregation) > 0:
+		selector.AppendSelect(aggregation...)
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := ucs.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
diff --git a/internal/database/ent/db/usercontent_update.go b/internal/database/ent/db/usercontent_update.go
new file mode 100644
index 00000000..a6d031e0
--- /dev/null
+++ b/internal/database/ent/db/usercontent_update.go
@@ -0,0 +1,368 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/ent/db/usercontent"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+// UserContentUpdate is the builder for updating UserContent entities.
+type UserContentUpdate struct {
+	config
+	hooks    []Hook
+	mutation *UserContentMutation
+}
+
+// Where appends a list predicates to the UserContentUpdate builder.
+func (ucu *UserContentUpdate) Where(ps ...predicate.UserContent) *UserContentUpdate {
+	ucu.mutation.Where(ps...)
+	return ucu
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (ucu *UserContentUpdate) SetUpdatedAt(i int) *UserContentUpdate {
+	ucu.mutation.ResetUpdatedAt()
+	ucu.mutation.SetUpdatedAt(i)
+	return ucu
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (ucu *UserContentUpdate) AddUpdatedAt(i int) *UserContentUpdate {
+	ucu.mutation.AddUpdatedAt(i)
+	return ucu
+}
+
+// SetType sets the "type" field.
+func (ucu *UserContentUpdate) SetType(mct models.UserContentType) *UserContentUpdate {
+	ucu.mutation.SetType(mct)
+	return ucu
+}
+
+// SetNillableType sets the "type" field if the given value is not nil.
+func (ucu *UserContentUpdate) SetNillableType(mct *models.UserContentType) *UserContentUpdate {
+	if mct != nil {
+		ucu.SetType(*mct)
+	}
+	return ucu
+}
+
+// SetReferenceID sets the "reference_id" field.
+func (ucu *UserContentUpdate) SetReferenceID(s string) *UserContentUpdate {
+	ucu.mutation.SetReferenceID(s)
+	return ucu
+}
+
+// SetNillableReferenceID sets the "reference_id" field if the given value is not nil.
+func (ucu *UserContentUpdate) SetNillableReferenceID(s *string) *UserContentUpdate {
+	if s != nil {
+		ucu.SetReferenceID(*s)
+	}
+	return ucu
+}
+
+// SetValue sets the "value" field.
+func (ucu *UserContentUpdate) SetValue(a any) *UserContentUpdate {
+	ucu.mutation.SetValue(a)
+	return ucu
+}
+
+// SetMetadata sets the "metadata" field.
+func (ucu *UserContentUpdate) SetMetadata(m map[string]interface{}) *UserContentUpdate {
+	ucu.mutation.SetMetadata(m)
+	return ucu
+}
+
+// Mutation returns the UserContentMutation object of the builder.
+func (ucu *UserContentUpdate) Mutation() *UserContentMutation {
+	return ucu.mutation
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (ucu *UserContentUpdate) Save(ctx context.Context) (int, error) {
+	ucu.defaults()
+	return withHooks(ctx, ucu.sqlSave, ucu.mutation, ucu.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (ucu *UserContentUpdate) SaveX(ctx context.Context) int {
+	affected, err := ucu.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return affected
+}
+
+// Exec executes the query.
+func (ucu *UserContentUpdate) Exec(ctx context.Context) error {
+	_, err := ucu.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (ucu *UserContentUpdate) ExecX(ctx context.Context) {
+	if err := ucu.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (ucu *UserContentUpdate) defaults() {
+	if _, ok := ucu.mutation.UpdatedAt(); !ok {
+		v := usercontent.UpdateDefaultUpdatedAt()
+		ucu.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (ucu *UserContentUpdate) check() error {
+	if v, ok := ucu.mutation.GetType(); ok {
+		if err := usercontent.TypeValidator(v); err != nil {
+			return &ValidationError{Name: "type", err: fmt.Errorf(`db: validator failed for field "UserContent.type": %w`, err)}
+		}
+	}
+	if _, ok := ucu.mutation.UserID(); ucu.mutation.UserCleared() && !ok {
+		return errors.New(`db: clearing a required unique edge "UserContent.user"`)
+	}
+	return nil
+}
+
+func (ucu *UserContentUpdate) sqlSave(ctx context.Context) (n int, err error) {
+	if err := ucu.check(); err != nil {
+		return n, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(usercontent.Table, usercontent.Columns, sqlgraph.NewFieldSpec(usercontent.FieldID, field.TypeString))
+	if ps := ucu.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := ucu.mutation.UpdatedAt(); ok {
+		_spec.SetField(usercontent.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := ucu.mutation.AddedUpdatedAt(); ok {
+		_spec.AddField(usercontent.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := ucu.mutation.GetType(); ok {
+		_spec.SetField(usercontent.FieldType, field.TypeEnum, value)
+	}
+	if value, ok := ucu.mutation.ReferenceID(); ok {
+		_spec.SetField(usercontent.FieldReferenceID, field.TypeString, value)
+	}
+	if value, ok := ucu.mutation.Value(); ok {
+		_spec.SetField(usercontent.FieldValue, field.TypeJSON, value)
+	}
+	if value, ok := ucu.mutation.Metadata(); ok {
+		_spec.SetField(usercontent.FieldMetadata, field.TypeJSON, value)
+	}
+	if n, err = sqlgraph.UpdateNodes(ctx, ucu.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{usercontent.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return 0, err
+	}
+	ucu.mutation.done = true
+	return n, nil
+}
+
+// UserContentUpdateOne is the builder for updating a single UserContent entity.
+type UserContentUpdateOne struct {
+	config
+	fields   []string
+	hooks    []Hook
+	mutation *UserContentMutation
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (ucuo *UserContentUpdateOne) SetUpdatedAt(i int) *UserContentUpdateOne {
+	ucuo.mutation.ResetUpdatedAt()
+	ucuo.mutation.SetUpdatedAt(i)
+	return ucuo
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (ucuo *UserContentUpdateOne) AddUpdatedAt(i int) *UserContentUpdateOne {
+	ucuo.mutation.AddUpdatedAt(i)
+	return ucuo
+}
+
+// SetType sets the "type" field.
+func (ucuo *UserContentUpdateOne) SetType(mct models.UserContentType) *UserContentUpdateOne {
+	ucuo.mutation.SetType(mct)
+	return ucuo
+}
+
+// SetNillableType sets the "type" field if the given value is not nil.
+func (ucuo *UserContentUpdateOne) SetNillableType(mct *models.UserContentType) *UserContentUpdateOne {
+	if mct != nil {
+		ucuo.SetType(*mct)
+	}
+	return ucuo
+}
+
+// SetReferenceID sets the "reference_id" field.
+func (ucuo *UserContentUpdateOne) SetReferenceID(s string) *UserContentUpdateOne {
+	ucuo.mutation.SetReferenceID(s)
+	return ucuo
+}
+
+// SetNillableReferenceID sets the "reference_id" field if the given value is not nil.
+func (ucuo *UserContentUpdateOne) SetNillableReferenceID(s *string) *UserContentUpdateOne {
+	if s != nil {
+		ucuo.SetReferenceID(*s)
+	}
+	return ucuo
+}
+
+// SetValue sets the "value" field.
+func (ucuo *UserContentUpdateOne) SetValue(a any) *UserContentUpdateOne {
+	ucuo.mutation.SetValue(a)
+	return ucuo
+}
+
+// SetMetadata sets the "metadata" field.
+func (ucuo *UserContentUpdateOne) SetMetadata(m map[string]interface{}) *UserContentUpdateOne {
+	ucuo.mutation.SetMetadata(m)
+	return ucuo
+}
+
+// Mutation returns the UserContentMutation object of the builder.
+func (ucuo *UserContentUpdateOne) Mutation() *UserContentMutation {
+	return ucuo.mutation
+}
+
+// Where appends a list predicates to the UserContentUpdate builder.
+func (ucuo *UserContentUpdateOne) Where(ps ...predicate.UserContent) *UserContentUpdateOne {
+	ucuo.mutation.Where(ps...)
+	return ucuo
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (ucuo *UserContentUpdateOne) Select(field string, fields ...string) *UserContentUpdateOne {
+	ucuo.fields = append([]string{field}, fields...)
+	return ucuo
+}
+
+// Save executes the query and returns the updated UserContent entity.
+func (ucuo *UserContentUpdateOne) Save(ctx context.Context) (*UserContent, error) {
+	ucuo.defaults()
+	return withHooks(ctx, ucuo.sqlSave, ucuo.mutation, ucuo.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (ucuo *UserContentUpdateOne) SaveX(ctx context.Context) *UserContent {
+	node, err := ucuo.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// Exec executes the query on the entity.
+func (ucuo *UserContentUpdateOne) Exec(ctx context.Context) error {
+	_, err := ucuo.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (ucuo *UserContentUpdateOne) ExecX(ctx context.Context) {
+	if err := ucuo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (ucuo *UserContentUpdateOne) defaults() {
+	if _, ok := ucuo.mutation.UpdatedAt(); !ok {
+		v := usercontent.UpdateDefaultUpdatedAt()
+		ucuo.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (ucuo *UserContentUpdateOne) check() error {
+	if v, ok := ucuo.mutation.GetType(); ok {
+		if err := usercontent.TypeValidator(v); err != nil {
+			return &ValidationError{Name: "type", err: fmt.Errorf(`db: validator failed for field "UserContent.type": %w`, err)}
+		}
+	}
+	if _, ok := ucuo.mutation.UserID(); ucuo.mutation.UserCleared() && !ok {
+		return errors.New(`db: clearing a required unique edge "UserContent.user"`)
+	}
+	return nil
+}
+
+func (ucuo *UserContentUpdateOne) sqlSave(ctx context.Context) (_node *UserContent, err error) {
+	if err := ucuo.check(); err != nil {
+		return _node, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(usercontent.Table, usercontent.Columns, sqlgraph.NewFieldSpec(usercontent.FieldID, field.TypeString))
+	id, ok := ucuo.mutation.ID()
+	if !ok {
+		return nil, &ValidationError{Name: "id", err: errors.New(`db: missing "UserContent.id" for update`)}
+	}
+	_spec.Node.ID.Value = id
+	if fields := ucuo.fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, usercontent.FieldID)
+		for _, f := range fields {
+			if !usercontent.ValidColumn(f) {
+				return nil, &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+			}
+			if f != usercontent.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, f)
+			}
+		}
+	}
+	if ps := ucuo.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := ucuo.mutation.UpdatedAt(); ok {
+		_spec.SetField(usercontent.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := ucuo.mutation.AddedUpdatedAt(); ok {
+		_spec.AddField(usercontent.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := ucuo.mutation.GetType(); ok {
+		_spec.SetField(usercontent.FieldType, field.TypeEnum, value)
+	}
+	if value, ok := ucuo.mutation.ReferenceID(); ok {
+		_spec.SetField(usercontent.FieldReferenceID, field.TypeString, value)
+	}
+	if value, ok := ucuo.mutation.Value(); ok {
+		_spec.SetField(usercontent.FieldValue, field.TypeJSON, value)
+	}
+	if value, ok := ucuo.mutation.Metadata(); ok {
+		_spec.SetField(usercontent.FieldMetadata, field.TypeJSON, value)
+	}
+	_node = &UserContent{config: ucuo.config}
+	_spec.Assign = _node.assignValues
+	_spec.ScanValues = _node.scanValues
+	if err = sqlgraph.UpdateNode(ctx, ucuo.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{usercontent.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	ucuo.mutation.done = true
+	return _node, nil
+}
diff --git a/internal/database/ent/db/usersubscription.go b/internal/database/ent/db/usersubscription.go
new file mode 100644
index 00000000..573a557e
--- /dev/null
+++ b/internal/database/ent/db/usersubscription.go
@@ -0,0 +1,199 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"fmt"
+	"strings"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+	"github.com/cufee/aftermath/internal/database/ent/db/user"
+	"github.com/cufee/aftermath/internal/database/ent/db/usersubscription"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+// UserSubscription is the model entity for the UserSubscription schema.
+type UserSubscription struct {
+	config `json:"-"`
+	// ID of the ent.
+	ID string `json:"id,omitempty"`
+	// CreatedAt holds the value of the "created_at" field.
+	CreatedAt int `json:"created_at,omitempty"`
+	// UpdatedAt holds the value of the "updated_at" field.
+	UpdatedAt int `json:"updated_at,omitempty"`
+	// Type holds the value of the "type" field.
+	Type models.SubscriptionType `json:"type,omitempty"`
+	// ExpiresAt holds the value of the "expires_at" field.
+	ExpiresAt int `json:"expires_at,omitempty"`
+	// UserID holds the value of the "user_id" field.
+	UserID string `json:"user_id,omitempty"`
+	// Permissions holds the value of the "permissions" field.
+	Permissions string `json:"permissions,omitempty"`
+	// ReferenceID holds the value of the "reference_id" field.
+	ReferenceID string `json:"reference_id,omitempty"`
+	// Edges holds the relations/edges for other nodes in the graph.
+	// The values are being populated by the UserSubscriptionQuery when eager-loading is set.
+	Edges        UserSubscriptionEdges `json:"edges"`
+	selectValues sql.SelectValues
+}
+
+// UserSubscriptionEdges holds the relations/edges for other nodes in the graph.
+type UserSubscriptionEdges struct {
+	// User holds the value of the user edge.
+	User *User `json:"user,omitempty"`
+	// loadedTypes holds the information for reporting if a
+	// type was loaded (or requested) in eager-loading or not.
+	loadedTypes [1]bool
+}
+
+// UserOrErr returns the User value or an error if the edge
+// was not loaded in eager-loading, or loaded but was not found.
+func (e UserSubscriptionEdges) UserOrErr() (*User, error) {
+	if e.User != nil {
+		return e.User, nil
+	} else if e.loadedTypes[0] {
+		return nil, &NotFoundError{label: user.Label}
+	}
+	return nil, &NotLoadedError{edge: "user"}
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*UserSubscription) scanValues(columns []string) ([]any, error) {
+	values := make([]any, len(columns))
+	for i := range columns {
+		switch columns[i] {
+		case usersubscription.FieldCreatedAt, usersubscription.FieldUpdatedAt, usersubscription.FieldExpiresAt:
+			values[i] = new(sql.NullInt64)
+		case usersubscription.FieldID, usersubscription.FieldType, usersubscription.FieldUserID, usersubscription.FieldPermissions, usersubscription.FieldReferenceID:
+			values[i] = new(sql.NullString)
+		default:
+			values[i] = new(sql.UnknownType)
+		}
+	}
+	return values, nil
+}
+
+// assignValues assigns the values that were returned from sql.Rows (after scanning)
+// to the UserSubscription fields.
+func (us *UserSubscription) assignValues(columns []string, values []any) error {
+	if m, n := len(values), len(columns); m < n {
+		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
+	}
+	for i := range columns {
+		switch columns[i] {
+		case usersubscription.FieldID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field id", values[i])
+			} else if value.Valid {
+				us.ID = value.String
+			}
+		case usersubscription.FieldCreatedAt:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field created_at", values[i])
+			} else if value.Valid {
+				us.CreatedAt = int(value.Int64)
+			}
+		case usersubscription.FieldUpdatedAt:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
+			} else if value.Valid {
+				us.UpdatedAt = int(value.Int64)
+			}
+		case usersubscription.FieldType:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field type", values[i])
+			} else if value.Valid {
+				us.Type = models.SubscriptionType(value.String)
+			}
+		case usersubscription.FieldExpiresAt:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field expires_at", values[i])
+			} else if value.Valid {
+				us.ExpiresAt = int(value.Int64)
+			}
+		case usersubscription.FieldUserID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field user_id", values[i])
+			} else if value.Valid {
+				us.UserID = value.String
+			}
+		case usersubscription.FieldPermissions:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field permissions", values[i])
+			} else if value.Valid {
+				us.Permissions = value.String
+			}
+		case usersubscription.FieldReferenceID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field reference_id", values[i])
+			} else if value.Valid {
+				us.ReferenceID = value.String
+			}
+		default:
+			us.selectValues.Set(columns[i], values[i])
+		}
+	}
+	return nil
+}
+
+// Value returns the ent.Value that was dynamically selected and assigned to the UserSubscription.
+// This includes values selected through modifiers, order, etc.
+func (us *UserSubscription) Value(name string) (ent.Value, error) {
+	return us.selectValues.Get(name)
+}
+
+// QueryUser queries the "user" edge of the UserSubscription entity.
+func (us *UserSubscription) QueryUser() *UserQuery {
+	return NewUserSubscriptionClient(us.config).QueryUser(us)
+}
+
+// Update returns a builder for updating this UserSubscription.
+// Note that you need to call UserSubscription.Unwrap() before calling this method if this UserSubscription
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (us *UserSubscription) Update() *UserSubscriptionUpdateOne {
+	return NewUserSubscriptionClient(us.config).UpdateOne(us)
+}
+
+// Unwrap unwraps the UserSubscription entity that was returned from a transaction after it was closed,
+// so that all future queries will be executed through the driver which created the transaction.
+func (us *UserSubscription) Unwrap() *UserSubscription {
+	_tx, ok := us.config.driver.(*txDriver)
+	if !ok {
+		panic("db: UserSubscription is not a transactional entity")
+	}
+	us.config.driver = _tx.drv
+	return us
+}
+
+// String implements the fmt.Stringer.
+func (us *UserSubscription) String() string {
+	var builder strings.Builder
+	builder.WriteString("UserSubscription(")
+	builder.WriteString(fmt.Sprintf("id=%v, ", us.ID))
+	builder.WriteString("created_at=")
+	builder.WriteString(fmt.Sprintf("%v", us.CreatedAt))
+	builder.WriteString(", ")
+	builder.WriteString("updated_at=")
+	builder.WriteString(fmt.Sprintf("%v", us.UpdatedAt))
+	builder.WriteString(", ")
+	builder.WriteString("type=")
+	builder.WriteString(fmt.Sprintf("%v", us.Type))
+	builder.WriteString(", ")
+	builder.WriteString("expires_at=")
+	builder.WriteString(fmt.Sprintf("%v", us.ExpiresAt))
+	builder.WriteString(", ")
+	builder.WriteString("user_id=")
+	builder.WriteString(us.UserID)
+	builder.WriteString(", ")
+	builder.WriteString("permissions=")
+	builder.WriteString(us.Permissions)
+	builder.WriteString(", ")
+	builder.WriteString("reference_id=")
+	builder.WriteString(us.ReferenceID)
+	builder.WriteByte(')')
+	return builder.String()
+}
+
+// UserSubscriptions is a parsable slice of UserSubscription.
+type UserSubscriptions []*UserSubscription
diff --git a/internal/database/ent/db/usersubscription/usersubscription.go b/internal/database/ent/db/usersubscription/usersubscription.go
new file mode 100644
index 00000000..e8a6c86f
--- /dev/null
+++ b/internal/database/ent/db/usersubscription/usersubscription.go
@@ -0,0 +1,149 @@
+// Code generated by ent, DO NOT EDIT.
+
+package usersubscription
+
+import (
+	"fmt"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+const (
+	// Label holds the string label denoting the usersubscription type in the database.
+	Label = "user_subscription"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// FieldType holds the string denoting the type field in the database.
+	FieldType = "type"
+	// FieldExpiresAt holds the string denoting the expires_at field in the database.
+	FieldExpiresAt = "expires_at"
+	// FieldUserID holds the string denoting the user_id field in the database.
+	FieldUserID = "user_id"
+	// FieldPermissions holds the string denoting the permissions field in the database.
+	FieldPermissions = "permissions"
+	// FieldReferenceID holds the string denoting the reference_id field in the database.
+	FieldReferenceID = "reference_id"
+	// EdgeUser holds the string denoting the user edge name in mutations.
+	EdgeUser = "user"
+	// Table holds the table name of the usersubscription in the database.
+	Table = "user_subscriptions"
+	// UserTable is the table that holds the user relation/edge.
+	UserTable = "user_subscriptions"
+	// UserInverseTable is the table name for the User entity.
+	// It exists in this package in order to avoid circular dependency with the "user" package.
+	UserInverseTable = "users"
+	// UserColumn is the table column denoting the user relation/edge.
+	UserColumn = "user_id"
+)
+
+// Columns holds all SQL columns for usersubscription fields.
+var Columns = []string{
+	FieldID,
+	FieldCreatedAt,
+	FieldUpdatedAt,
+	FieldType,
+	FieldExpiresAt,
+	FieldUserID,
+	FieldPermissions,
+	FieldReferenceID,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() int
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() int
+	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
+	UpdateDefaultUpdatedAt func() int
+	// UserIDValidator is a validator for the "user_id" field. It is called by the builders before save.
+	UserIDValidator func(string) error
+	// PermissionsValidator is a validator for the "permissions" field. It is called by the builders before save.
+	PermissionsValidator func(string) error
+	// ReferenceIDValidator is a validator for the "reference_id" field. It is called by the builders before save.
+	ReferenceIDValidator func(string) error
+	// DefaultID holds the default value on creation for the "id" field.
+	DefaultID func() string
+)
+
+// TypeValidator is a validator for the "type" field enum values. It is called by the builders before save.
+func TypeValidator(_type models.SubscriptionType) error {
+	switch _type {
+	case "aftermath-pro", "aftermath-pro-clan", "aftermath-plus", "supporter", "verified-clan", "server-moderator", "content-moderator", "developer", "server-booster", "content-translator":
+		return nil
+	default:
+		return fmt.Errorf("usersubscription: invalid enum value for type field: %q", _type)
+	}
+}
+
+// OrderOption defines the ordering options for the UserSubscription queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByType orders the results by the type field.
+func ByType(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldType, opts...).ToFunc()
+}
+
+// ByExpiresAt orders the results by the expires_at field.
+func ByExpiresAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldExpiresAt, opts...).ToFunc()
+}
+
+// ByUserID orders the results by the user_id field.
+func ByUserID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUserID, opts...).ToFunc()
+}
+
+// ByPermissions orders the results by the permissions field.
+func ByPermissions(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldPermissions, opts...).ToFunc()
+}
+
+// ByReferenceID orders the results by the reference_id field.
+func ByReferenceID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldReferenceID, opts...).ToFunc()
+}
+
+// ByUserField orders the results by user field.
+func ByUserField(field string, opts ...sql.OrderTermOption) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborTerms(s, newUserStep(), sql.OrderByField(field, opts...))
+	}
+}
+func newUserStep() *sqlgraph.Step {
+	return sqlgraph.NewStep(
+		sqlgraph.From(Table, FieldID),
+		sqlgraph.To(UserInverseTable, FieldID),
+		sqlgraph.Edge(sqlgraph.M2O, true, UserTable, UserColumn),
+	)
+}
diff --git a/internal/database/ent/db/usersubscription/where.go b/internal/database/ent/db/usersubscription/where.go
new file mode 100644
index 00000000..71f3025c
--- /dev/null
+++ b/internal/database/ent/db/usersubscription/where.go
@@ -0,0 +1,478 @@
+// Code generated by ent, DO NOT EDIT.
+
+package usersubscription
+
+import (
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldLTE(FieldID, id))
+}
+
+// IDEqualFold applies the EqualFold predicate on the ID field.
+func IDEqualFold(id string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldEqualFold(FieldID, id))
+}
+
+// IDContainsFold applies the ContainsFold predicate on the ID field.
+func IDContainsFold(id string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldContainsFold(FieldID, id))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v int) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v int) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// ExpiresAt applies equality check predicate on the "expires_at" field. It's identical to ExpiresAtEQ.
+func ExpiresAt(v int) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldEQ(FieldExpiresAt, v))
+}
+
+// UserID applies equality check predicate on the "user_id" field. It's identical to UserIDEQ.
+func UserID(v string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldEQ(FieldUserID, v))
+}
+
+// Permissions applies equality check predicate on the "permissions" field. It's identical to PermissionsEQ.
+func Permissions(v string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldEQ(FieldPermissions, v))
+}
+
+// ReferenceID applies equality check predicate on the "reference_id" field. It's identical to ReferenceIDEQ.
+func ReferenceID(v string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldEQ(FieldReferenceID, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v int) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v int) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...int) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...int) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v int) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v int) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v int) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v int) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v int) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v int) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...int) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...int) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v int) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v int) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v int) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v int) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// TypeEQ applies the EQ predicate on the "type" field.
+func TypeEQ(v models.SubscriptionType) predicate.UserSubscription {
+	vc := v
+	return predicate.UserSubscription(sql.FieldEQ(FieldType, vc))
+}
+
+// TypeNEQ applies the NEQ predicate on the "type" field.
+func TypeNEQ(v models.SubscriptionType) predicate.UserSubscription {
+	vc := v
+	return predicate.UserSubscription(sql.FieldNEQ(FieldType, vc))
+}
+
+// TypeIn applies the In predicate on the "type" field.
+func TypeIn(vs ...models.SubscriptionType) predicate.UserSubscription {
+	v := make([]any, len(vs))
+	for i := range v {
+		v[i] = vs[i]
+	}
+	return predicate.UserSubscription(sql.FieldIn(FieldType, v...))
+}
+
+// TypeNotIn applies the NotIn predicate on the "type" field.
+func TypeNotIn(vs ...models.SubscriptionType) predicate.UserSubscription {
+	v := make([]any, len(vs))
+	for i := range v {
+		v[i] = vs[i]
+	}
+	return predicate.UserSubscription(sql.FieldNotIn(FieldType, v...))
+}
+
+// ExpiresAtEQ applies the EQ predicate on the "expires_at" field.
+func ExpiresAtEQ(v int) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldEQ(FieldExpiresAt, v))
+}
+
+// ExpiresAtNEQ applies the NEQ predicate on the "expires_at" field.
+func ExpiresAtNEQ(v int) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldNEQ(FieldExpiresAt, v))
+}
+
+// ExpiresAtIn applies the In predicate on the "expires_at" field.
+func ExpiresAtIn(vs ...int) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldIn(FieldExpiresAt, vs...))
+}
+
+// ExpiresAtNotIn applies the NotIn predicate on the "expires_at" field.
+func ExpiresAtNotIn(vs ...int) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldNotIn(FieldExpiresAt, vs...))
+}
+
+// ExpiresAtGT applies the GT predicate on the "expires_at" field.
+func ExpiresAtGT(v int) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldGT(FieldExpiresAt, v))
+}
+
+// ExpiresAtGTE applies the GTE predicate on the "expires_at" field.
+func ExpiresAtGTE(v int) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldGTE(FieldExpiresAt, v))
+}
+
+// ExpiresAtLT applies the LT predicate on the "expires_at" field.
+func ExpiresAtLT(v int) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldLT(FieldExpiresAt, v))
+}
+
+// ExpiresAtLTE applies the LTE predicate on the "expires_at" field.
+func ExpiresAtLTE(v int) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldLTE(FieldExpiresAt, v))
+}
+
+// UserIDEQ applies the EQ predicate on the "user_id" field.
+func UserIDEQ(v string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldEQ(FieldUserID, v))
+}
+
+// UserIDNEQ applies the NEQ predicate on the "user_id" field.
+func UserIDNEQ(v string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldNEQ(FieldUserID, v))
+}
+
+// UserIDIn applies the In predicate on the "user_id" field.
+func UserIDIn(vs ...string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldIn(FieldUserID, vs...))
+}
+
+// UserIDNotIn applies the NotIn predicate on the "user_id" field.
+func UserIDNotIn(vs ...string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldNotIn(FieldUserID, vs...))
+}
+
+// UserIDGT applies the GT predicate on the "user_id" field.
+func UserIDGT(v string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldGT(FieldUserID, v))
+}
+
+// UserIDGTE applies the GTE predicate on the "user_id" field.
+func UserIDGTE(v string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldGTE(FieldUserID, v))
+}
+
+// UserIDLT applies the LT predicate on the "user_id" field.
+func UserIDLT(v string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldLT(FieldUserID, v))
+}
+
+// UserIDLTE applies the LTE predicate on the "user_id" field.
+func UserIDLTE(v string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldLTE(FieldUserID, v))
+}
+
+// UserIDContains applies the Contains predicate on the "user_id" field.
+func UserIDContains(v string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldContains(FieldUserID, v))
+}
+
+// UserIDHasPrefix applies the HasPrefix predicate on the "user_id" field.
+func UserIDHasPrefix(v string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldHasPrefix(FieldUserID, v))
+}
+
+// UserIDHasSuffix applies the HasSuffix predicate on the "user_id" field.
+func UserIDHasSuffix(v string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldHasSuffix(FieldUserID, v))
+}
+
+// UserIDEqualFold applies the EqualFold predicate on the "user_id" field.
+func UserIDEqualFold(v string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldEqualFold(FieldUserID, v))
+}
+
+// UserIDContainsFold applies the ContainsFold predicate on the "user_id" field.
+func UserIDContainsFold(v string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldContainsFold(FieldUserID, v))
+}
+
+// PermissionsEQ applies the EQ predicate on the "permissions" field.
+func PermissionsEQ(v string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldEQ(FieldPermissions, v))
+}
+
+// PermissionsNEQ applies the NEQ predicate on the "permissions" field.
+func PermissionsNEQ(v string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldNEQ(FieldPermissions, v))
+}
+
+// PermissionsIn applies the In predicate on the "permissions" field.
+func PermissionsIn(vs ...string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldIn(FieldPermissions, vs...))
+}
+
+// PermissionsNotIn applies the NotIn predicate on the "permissions" field.
+func PermissionsNotIn(vs ...string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldNotIn(FieldPermissions, vs...))
+}
+
+// PermissionsGT applies the GT predicate on the "permissions" field.
+func PermissionsGT(v string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldGT(FieldPermissions, v))
+}
+
+// PermissionsGTE applies the GTE predicate on the "permissions" field.
+func PermissionsGTE(v string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldGTE(FieldPermissions, v))
+}
+
+// PermissionsLT applies the LT predicate on the "permissions" field.
+func PermissionsLT(v string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldLT(FieldPermissions, v))
+}
+
+// PermissionsLTE applies the LTE predicate on the "permissions" field.
+func PermissionsLTE(v string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldLTE(FieldPermissions, v))
+}
+
+// PermissionsContains applies the Contains predicate on the "permissions" field.
+func PermissionsContains(v string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldContains(FieldPermissions, v))
+}
+
+// PermissionsHasPrefix applies the HasPrefix predicate on the "permissions" field.
+func PermissionsHasPrefix(v string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldHasPrefix(FieldPermissions, v))
+}
+
+// PermissionsHasSuffix applies the HasSuffix predicate on the "permissions" field.
+func PermissionsHasSuffix(v string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldHasSuffix(FieldPermissions, v))
+}
+
+// PermissionsEqualFold applies the EqualFold predicate on the "permissions" field.
+func PermissionsEqualFold(v string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldEqualFold(FieldPermissions, v))
+}
+
+// PermissionsContainsFold applies the ContainsFold predicate on the "permissions" field.
+func PermissionsContainsFold(v string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldContainsFold(FieldPermissions, v))
+}
+
+// ReferenceIDEQ applies the EQ predicate on the "reference_id" field.
+func ReferenceIDEQ(v string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldEQ(FieldReferenceID, v))
+}
+
+// ReferenceIDNEQ applies the NEQ predicate on the "reference_id" field.
+func ReferenceIDNEQ(v string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldNEQ(FieldReferenceID, v))
+}
+
+// ReferenceIDIn applies the In predicate on the "reference_id" field.
+func ReferenceIDIn(vs ...string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldIn(FieldReferenceID, vs...))
+}
+
+// ReferenceIDNotIn applies the NotIn predicate on the "reference_id" field.
+func ReferenceIDNotIn(vs ...string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldNotIn(FieldReferenceID, vs...))
+}
+
+// ReferenceIDGT applies the GT predicate on the "reference_id" field.
+func ReferenceIDGT(v string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldGT(FieldReferenceID, v))
+}
+
+// ReferenceIDGTE applies the GTE predicate on the "reference_id" field.
+func ReferenceIDGTE(v string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldGTE(FieldReferenceID, v))
+}
+
+// ReferenceIDLT applies the LT predicate on the "reference_id" field.
+func ReferenceIDLT(v string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldLT(FieldReferenceID, v))
+}
+
+// ReferenceIDLTE applies the LTE predicate on the "reference_id" field.
+func ReferenceIDLTE(v string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldLTE(FieldReferenceID, v))
+}
+
+// ReferenceIDContains applies the Contains predicate on the "reference_id" field.
+func ReferenceIDContains(v string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldContains(FieldReferenceID, v))
+}
+
+// ReferenceIDHasPrefix applies the HasPrefix predicate on the "reference_id" field.
+func ReferenceIDHasPrefix(v string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldHasPrefix(FieldReferenceID, v))
+}
+
+// ReferenceIDHasSuffix applies the HasSuffix predicate on the "reference_id" field.
+func ReferenceIDHasSuffix(v string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldHasSuffix(FieldReferenceID, v))
+}
+
+// ReferenceIDEqualFold applies the EqualFold predicate on the "reference_id" field.
+func ReferenceIDEqualFold(v string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldEqualFold(FieldReferenceID, v))
+}
+
+// ReferenceIDContainsFold applies the ContainsFold predicate on the "reference_id" field.
+func ReferenceIDContainsFold(v string) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.FieldContainsFold(FieldReferenceID, v))
+}
+
+// HasUser applies the HasEdge predicate on the "user" edge.
+func HasUser() predicate.UserSubscription {
+	return predicate.UserSubscription(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, UserTable, UserColumn),
+		)
+		sqlgraph.HasNeighbors(s, step)
+	})
+}
+
+// HasUserWith applies the HasEdge predicate on the "user" edge with a given conditions (other predicates).
+func HasUserWith(preds ...predicate.User) predicate.UserSubscription {
+	return predicate.UserSubscription(func(s *sql.Selector) {
+		step := newUserStep()
+		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+			for _, p := range preds {
+				p(s)
+			}
+		})
+	})
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.UserSubscription) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.UserSubscription) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.UserSubscription) predicate.UserSubscription {
+	return predicate.UserSubscription(sql.NotPredicates(p))
+}
diff --git a/internal/database/ent/db/usersubscription_create.go b/internal/database/ent/db/usersubscription_create.go
new file mode 100644
index 00000000..fe9f5eee
--- /dev/null
+++ b/internal/database/ent/db/usersubscription_create.go
@@ -0,0 +1,357 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/user"
+	"github.com/cufee/aftermath/internal/database/ent/db/usersubscription"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+// UserSubscriptionCreate is the builder for creating a UserSubscription entity.
+type UserSubscriptionCreate struct {
+	config
+	mutation *UserSubscriptionMutation
+	hooks    []Hook
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (usc *UserSubscriptionCreate) SetCreatedAt(i int) *UserSubscriptionCreate {
+	usc.mutation.SetCreatedAt(i)
+	return usc
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (usc *UserSubscriptionCreate) SetNillableCreatedAt(i *int) *UserSubscriptionCreate {
+	if i != nil {
+		usc.SetCreatedAt(*i)
+	}
+	return usc
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (usc *UserSubscriptionCreate) SetUpdatedAt(i int) *UserSubscriptionCreate {
+	usc.mutation.SetUpdatedAt(i)
+	return usc
+}
+
+// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
+func (usc *UserSubscriptionCreate) SetNillableUpdatedAt(i *int) *UserSubscriptionCreate {
+	if i != nil {
+		usc.SetUpdatedAt(*i)
+	}
+	return usc
+}
+
+// SetType sets the "type" field.
+func (usc *UserSubscriptionCreate) SetType(mt models.SubscriptionType) *UserSubscriptionCreate {
+	usc.mutation.SetType(mt)
+	return usc
+}
+
+// SetExpiresAt sets the "expires_at" field.
+func (usc *UserSubscriptionCreate) SetExpiresAt(i int) *UserSubscriptionCreate {
+	usc.mutation.SetExpiresAt(i)
+	return usc
+}
+
+// SetUserID sets the "user_id" field.
+func (usc *UserSubscriptionCreate) SetUserID(s string) *UserSubscriptionCreate {
+	usc.mutation.SetUserID(s)
+	return usc
+}
+
+// SetPermissions sets the "permissions" field.
+func (usc *UserSubscriptionCreate) SetPermissions(s string) *UserSubscriptionCreate {
+	usc.mutation.SetPermissions(s)
+	return usc
+}
+
+// SetReferenceID sets the "reference_id" field.
+func (usc *UserSubscriptionCreate) SetReferenceID(s string) *UserSubscriptionCreate {
+	usc.mutation.SetReferenceID(s)
+	return usc
+}
+
+// SetID sets the "id" field.
+func (usc *UserSubscriptionCreate) SetID(s string) *UserSubscriptionCreate {
+	usc.mutation.SetID(s)
+	return usc
+}
+
+// SetNillableID sets the "id" field if the given value is not nil.
+func (usc *UserSubscriptionCreate) SetNillableID(s *string) *UserSubscriptionCreate {
+	if s != nil {
+		usc.SetID(*s)
+	}
+	return usc
+}
+
+// SetUser sets the "user" edge to the User entity.
+func (usc *UserSubscriptionCreate) SetUser(u *User) *UserSubscriptionCreate {
+	return usc.SetUserID(u.ID)
+}
+
+// Mutation returns the UserSubscriptionMutation object of the builder.
+func (usc *UserSubscriptionCreate) Mutation() *UserSubscriptionMutation {
+	return usc.mutation
+}
+
+// Save creates the UserSubscription in the database.
+func (usc *UserSubscriptionCreate) Save(ctx context.Context) (*UserSubscription, error) {
+	usc.defaults()
+	return withHooks(ctx, usc.sqlSave, usc.mutation, usc.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (usc *UserSubscriptionCreate) SaveX(ctx context.Context) *UserSubscription {
+	v, err := usc.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (usc *UserSubscriptionCreate) Exec(ctx context.Context) error {
+	_, err := usc.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (usc *UserSubscriptionCreate) ExecX(ctx context.Context) {
+	if err := usc.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (usc *UserSubscriptionCreate) defaults() {
+	if _, ok := usc.mutation.CreatedAt(); !ok {
+		v := usersubscription.DefaultCreatedAt()
+		usc.mutation.SetCreatedAt(v)
+	}
+	if _, ok := usc.mutation.UpdatedAt(); !ok {
+		v := usersubscription.DefaultUpdatedAt()
+		usc.mutation.SetUpdatedAt(v)
+	}
+	if _, ok := usc.mutation.ID(); !ok {
+		v := usersubscription.DefaultID()
+		usc.mutation.SetID(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (usc *UserSubscriptionCreate) check() error {
+	if _, ok := usc.mutation.CreatedAt(); !ok {
+		return &ValidationError{Name: "created_at", err: errors.New(`db: missing required field "UserSubscription.created_at"`)}
+	}
+	if _, ok := usc.mutation.UpdatedAt(); !ok {
+		return &ValidationError{Name: "updated_at", err: errors.New(`db: missing required field "UserSubscription.updated_at"`)}
+	}
+	if _, ok := usc.mutation.GetType(); !ok {
+		return &ValidationError{Name: "type", err: errors.New(`db: missing required field "UserSubscription.type"`)}
+	}
+	if v, ok := usc.mutation.GetType(); ok {
+		if err := usersubscription.TypeValidator(v); err != nil {
+			return &ValidationError{Name: "type", err: fmt.Errorf(`db: validator failed for field "UserSubscription.type": %w`, err)}
+		}
+	}
+	if _, ok := usc.mutation.ExpiresAt(); !ok {
+		return &ValidationError{Name: "expires_at", err: errors.New(`db: missing required field "UserSubscription.expires_at"`)}
+	}
+	if _, ok := usc.mutation.UserID(); !ok {
+		return &ValidationError{Name: "user_id", err: errors.New(`db: missing required field "UserSubscription.user_id"`)}
+	}
+	if v, ok := usc.mutation.UserID(); ok {
+		if err := usersubscription.UserIDValidator(v); err != nil {
+			return &ValidationError{Name: "user_id", err: fmt.Errorf(`db: validator failed for field "UserSubscription.user_id": %w`, err)}
+		}
+	}
+	if _, ok := usc.mutation.Permissions(); !ok {
+		return &ValidationError{Name: "permissions", err: errors.New(`db: missing required field "UserSubscription.permissions"`)}
+	}
+	if v, ok := usc.mutation.Permissions(); ok {
+		if err := usersubscription.PermissionsValidator(v); err != nil {
+			return &ValidationError{Name: "permissions", err: fmt.Errorf(`db: validator failed for field "UserSubscription.permissions": %w`, err)}
+		}
+	}
+	if _, ok := usc.mutation.ReferenceID(); !ok {
+		return &ValidationError{Name: "reference_id", err: errors.New(`db: missing required field "UserSubscription.reference_id"`)}
+	}
+	if v, ok := usc.mutation.ReferenceID(); ok {
+		if err := usersubscription.ReferenceIDValidator(v); err != nil {
+			return &ValidationError{Name: "reference_id", err: fmt.Errorf(`db: validator failed for field "UserSubscription.reference_id": %w`, err)}
+		}
+	}
+	if _, ok := usc.mutation.UserID(); !ok {
+		return &ValidationError{Name: "user", err: errors.New(`db: missing required edge "UserSubscription.user"`)}
+	}
+	return nil
+}
+
+func (usc *UserSubscriptionCreate) sqlSave(ctx context.Context) (*UserSubscription, error) {
+	if err := usc.check(); err != nil {
+		return nil, err
+	}
+	_node, _spec := usc.createSpec()
+	if err := sqlgraph.CreateNode(ctx, usc.driver, _spec); err != nil {
+		if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	if _spec.ID.Value != nil {
+		if id, ok := _spec.ID.Value.(string); ok {
+			_node.ID = id
+		} else {
+			return nil, fmt.Errorf("unexpected UserSubscription.ID type: %T", _spec.ID.Value)
+		}
+	}
+	usc.mutation.id = &_node.ID
+	usc.mutation.done = true
+	return _node, nil
+}
+
+func (usc *UserSubscriptionCreate) createSpec() (*UserSubscription, *sqlgraph.CreateSpec) {
+	var (
+		_node = &UserSubscription{config: usc.config}
+		_spec = sqlgraph.NewCreateSpec(usersubscription.Table, sqlgraph.NewFieldSpec(usersubscription.FieldID, field.TypeString))
+	)
+	if id, ok := usc.mutation.ID(); ok {
+		_node.ID = id
+		_spec.ID.Value = id
+	}
+	if value, ok := usc.mutation.CreatedAt(); ok {
+		_spec.SetField(usersubscription.FieldCreatedAt, field.TypeInt, value)
+		_node.CreatedAt = value
+	}
+	if value, ok := usc.mutation.UpdatedAt(); ok {
+		_spec.SetField(usersubscription.FieldUpdatedAt, field.TypeInt, value)
+		_node.UpdatedAt = value
+	}
+	if value, ok := usc.mutation.GetType(); ok {
+		_spec.SetField(usersubscription.FieldType, field.TypeEnum, value)
+		_node.Type = value
+	}
+	if value, ok := usc.mutation.ExpiresAt(); ok {
+		_spec.SetField(usersubscription.FieldExpiresAt, field.TypeInt, value)
+		_node.ExpiresAt = value
+	}
+	if value, ok := usc.mutation.Permissions(); ok {
+		_spec.SetField(usersubscription.FieldPermissions, field.TypeString, value)
+		_node.Permissions = value
+	}
+	if value, ok := usc.mutation.ReferenceID(); ok {
+		_spec.SetField(usersubscription.FieldReferenceID, field.TypeString, value)
+		_node.ReferenceID = value
+	}
+	if nodes := usc.mutation.UserIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   usersubscription.UserTable,
+			Columns: []string{usersubscription.UserColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_node.UserID = nodes[0]
+		_spec.Edges = append(_spec.Edges, edge)
+	}
+	return _node, _spec
+}
+
+// UserSubscriptionCreateBulk is the builder for creating many UserSubscription entities in bulk.
+type UserSubscriptionCreateBulk struct {
+	config
+	err      error
+	builders []*UserSubscriptionCreate
+}
+
+// Save creates the UserSubscription entities in the database.
+func (uscb *UserSubscriptionCreateBulk) Save(ctx context.Context) ([]*UserSubscription, error) {
+	if uscb.err != nil {
+		return nil, uscb.err
+	}
+	specs := make([]*sqlgraph.CreateSpec, len(uscb.builders))
+	nodes := make([]*UserSubscription, len(uscb.builders))
+	mutators := make([]Mutator, len(uscb.builders))
+	for i := range uscb.builders {
+		func(i int, root context.Context) {
+			builder := uscb.builders[i]
+			builder.defaults()
+			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+				mutation, ok := m.(*UserSubscriptionMutation)
+				if !ok {
+					return nil, fmt.Errorf("unexpected mutation type %T", m)
+				}
+				if err := builder.check(); err != nil {
+					return nil, err
+				}
+				builder.mutation = mutation
+				var err error
+				nodes[i], specs[i] = builder.createSpec()
+				if i < len(mutators)-1 {
+					_, err = mutators[i+1].Mutate(root, uscb.builders[i+1].mutation)
+				} else {
+					spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
+					// Invoke the actual operation on the latest mutation in the chain.
+					if err = sqlgraph.BatchCreate(ctx, uscb.driver, spec); err != nil {
+						if sqlgraph.IsConstraintError(err) {
+							err = &ConstraintError{msg: err.Error(), wrap: err}
+						}
+					}
+				}
+				if err != nil {
+					return nil, err
+				}
+				mutation.id = &nodes[i].ID
+				mutation.done = true
+				return nodes[i], nil
+			})
+			for i := len(builder.hooks) - 1; i >= 0; i-- {
+				mut = builder.hooks[i](mut)
+			}
+			mutators[i] = mut
+		}(i, ctx)
+	}
+	if len(mutators) > 0 {
+		if _, err := mutators[0].Mutate(ctx, uscb.builders[0].mutation); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (uscb *UserSubscriptionCreateBulk) SaveX(ctx context.Context) []*UserSubscription {
+	v, err := uscb.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (uscb *UserSubscriptionCreateBulk) Exec(ctx context.Context) error {
+	_, err := uscb.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (uscb *UserSubscriptionCreateBulk) ExecX(ctx context.Context) {
+	if err := uscb.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/database/ent/db/usersubscription_delete.go b/internal/database/ent/db/usersubscription_delete.go
new file mode 100644
index 00000000..48e06d20
--- /dev/null
+++ b/internal/database/ent/db/usersubscription_delete.go
@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/ent/db/usersubscription"
+)
+
+// UserSubscriptionDelete is the builder for deleting a UserSubscription entity.
+type UserSubscriptionDelete struct {
+	config
+	hooks    []Hook
+	mutation *UserSubscriptionMutation
+}
+
+// Where appends a list predicates to the UserSubscriptionDelete builder.
+func (usd *UserSubscriptionDelete) Where(ps ...predicate.UserSubscription) *UserSubscriptionDelete {
+	usd.mutation.Where(ps...)
+	return usd
+}
+
+// Exec executes the deletion query and returns how many vertices were deleted.
+func (usd *UserSubscriptionDelete) Exec(ctx context.Context) (int, error) {
+	return withHooks(ctx, usd.sqlExec, usd.mutation, usd.hooks)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (usd *UserSubscriptionDelete) ExecX(ctx context.Context) int {
+	n, err := usd.Exec(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return n
+}
+
+func (usd *UserSubscriptionDelete) sqlExec(ctx context.Context) (int, error) {
+	_spec := sqlgraph.NewDeleteSpec(usersubscription.Table, sqlgraph.NewFieldSpec(usersubscription.FieldID, field.TypeString))
+	if ps := usd.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	affected, err := sqlgraph.DeleteNodes(ctx, usd.driver, _spec)
+	if err != nil && sqlgraph.IsConstraintError(err) {
+		err = &ConstraintError{msg: err.Error(), wrap: err}
+	}
+	usd.mutation.done = true
+	return affected, err
+}
+
+// UserSubscriptionDeleteOne is the builder for deleting a single UserSubscription entity.
+type UserSubscriptionDeleteOne struct {
+	usd *UserSubscriptionDelete
+}
+
+// Where appends a list predicates to the UserSubscriptionDelete builder.
+func (usdo *UserSubscriptionDeleteOne) Where(ps ...predicate.UserSubscription) *UserSubscriptionDeleteOne {
+	usdo.usd.mutation.Where(ps...)
+	return usdo
+}
+
+// Exec executes the deletion query.
+func (usdo *UserSubscriptionDeleteOne) Exec(ctx context.Context) error {
+	n, err := usdo.usd.Exec(ctx)
+	switch {
+	case err != nil:
+		return err
+	case n == 0:
+		return &NotFoundError{usersubscription.Label}
+	default:
+		return nil
+	}
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (usdo *UserSubscriptionDeleteOne) ExecX(ctx context.Context) {
+	if err := usdo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/database/ent/db/usersubscription_query.go b/internal/database/ent/db/usersubscription_query.go
new file mode 100644
index 00000000..dc392666
--- /dev/null
+++ b/internal/database/ent/db/usersubscription_query.go
@@ -0,0 +1,605 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"fmt"
+	"math"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/ent/db/user"
+	"github.com/cufee/aftermath/internal/database/ent/db/usersubscription"
+)
+
+// UserSubscriptionQuery is the builder for querying UserSubscription entities.
+type UserSubscriptionQuery struct {
+	config
+	ctx        *QueryContext
+	order      []usersubscription.OrderOption
+	inters     []Interceptor
+	predicates []predicate.UserSubscription
+	withUser   *UserQuery
+	// intermediate query (i.e. traversal path).
+	sql  *sql.Selector
+	path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the UserSubscriptionQuery builder.
+func (usq *UserSubscriptionQuery) Where(ps ...predicate.UserSubscription) *UserSubscriptionQuery {
+	usq.predicates = append(usq.predicates, ps...)
+	return usq
+}
+
+// Limit the number of records to be returned by this query.
+func (usq *UserSubscriptionQuery) Limit(limit int) *UserSubscriptionQuery {
+	usq.ctx.Limit = &limit
+	return usq
+}
+
+// Offset to start from.
+func (usq *UserSubscriptionQuery) Offset(offset int) *UserSubscriptionQuery {
+	usq.ctx.Offset = &offset
+	return usq
+}
+
+// Unique configures the query builder to filter duplicate records on query.
+// By default, unique is set to true, and can be disabled using this method.
+func (usq *UserSubscriptionQuery) Unique(unique bool) *UserSubscriptionQuery {
+	usq.ctx.Unique = &unique
+	return usq
+}
+
+// Order specifies how the records should be ordered.
+func (usq *UserSubscriptionQuery) Order(o ...usersubscription.OrderOption) *UserSubscriptionQuery {
+	usq.order = append(usq.order, o...)
+	return usq
+}
+
+// QueryUser chains the current query on the "user" edge.
+func (usq *UserSubscriptionQuery) QueryUser() *UserQuery {
+	query := (&UserClient{config: usq.config}).Query()
+	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+		if err := usq.prepareQuery(ctx); err != nil {
+			return nil, err
+		}
+		selector := usq.sqlQuery(ctx)
+		if err := selector.Err(); err != nil {
+			return nil, err
+		}
+		step := sqlgraph.NewStep(
+			sqlgraph.From(usersubscription.Table, usersubscription.FieldID, selector),
+			sqlgraph.To(user.Table, user.FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, usersubscription.UserTable, usersubscription.UserColumn),
+		)
+		fromU = sqlgraph.SetNeighbors(usq.driver.Dialect(), step)
+		return fromU, nil
+	}
+	return query
+}
+
+// First returns the first UserSubscription entity from the query.
+// Returns a *NotFoundError when no UserSubscription was found.
+func (usq *UserSubscriptionQuery) First(ctx context.Context) (*UserSubscription, error) {
+	nodes, err := usq.Limit(1).All(setContextOp(ctx, usq.ctx, "First"))
+	if err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nil, &NotFoundError{usersubscription.Label}
+	}
+	return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (usq *UserSubscriptionQuery) FirstX(ctx context.Context) *UserSubscription {
+	node, err := usq.First(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return node
+}
+
+// FirstID returns the first UserSubscription ID from the query.
+// Returns a *NotFoundError when no UserSubscription ID was found.
+func (usq *UserSubscriptionQuery) FirstID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = usq.Limit(1).IDs(setContextOp(ctx, usq.ctx, "FirstID")); err != nil {
+		return
+	}
+	if len(ids) == 0 {
+		err = &NotFoundError{usersubscription.Label}
+		return
+	}
+	return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (usq *UserSubscriptionQuery) FirstIDX(ctx context.Context) string {
+	id, err := usq.FirstID(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return id
+}
+
+// Only returns a single UserSubscription entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one UserSubscription entity is found.
+// Returns a *NotFoundError when no UserSubscription entities are found.
+func (usq *UserSubscriptionQuery) Only(ctx context.Context) (*UserSubscription, error) {
+	nodes, err := usq.Limit(2).All(setContextOp(ctx, usq.ctx, "Only"))
+	if err != nil {
+		return nil, err
+	}
+	switch len(nodes) {
+	case 1:
+		return nodes[0], nil
+	case 0:
+		return nil, &NotFoundError{usersubscription.Label}
+	default:
+		return nil, &NotSingularError{usersubscription.Label}
+	}
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (usq *UserSubscriptionQuery) OnlyX(ctx context.Context) *UserSubscription {
+	node, err := usq.Only(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// OnlyID is like Only, but returns the only UserSubscription ID in the query.
+// Returns a *NotSingularError when more than one UserSubscription ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (usq *UserSubscriptionQuery) OnlyID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = usq.Limit(2).IDs(setContextOp(ctx, usq.ctx, "OnlyID")); err != nil {
+		return
+	}
+	switch len(ids) {
+	case 1:
+		id = ids[0]
+	case 0:
+		err = &NotFoundError{usersubscription.Label}
+	default:
+		err = &NotSingularError{usersubscription.Label}
+	}
+	return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (usq *UserSubscriptionQuery) OnlyIDX(ctx context.Context) string {
+	id, err := usq.OnlyID(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return id
+}
+
+// All executes the query and returns a list of UserSubscriptions.
+func (usq *UserSubscriptionQuery) All(ctx context.Context) ([]*UserSubscription, error) {
+	ctx = setContextOp(ctx, usq.ctx, "All")
+	if err := usq.prepareQuery(ctx); err != nil {
+		return nil, err
+	}
+	qr := querierAll[[]*UserSubscription, *UserSubscriptionQuery]()
+	return withInterceptors[[]*UserSubscription](ctx, usq, qr, usq.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (usq *UserSubscriptionQuery) AllX(ctx context.Context) []*UserSubscription {
+	nodes, err := usq.All(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return nodes
+}
+
+// IDs executes the query and returns a list of UserSubscription IDs.
+func (usq *UserSubscriptionQuery) IDs(ctx context.Context) (ids []string, err error) {
+	if usq.ctx.Unique == nil && usq.path != nil {
+		usq.Unique(true)
+	}
+	ctx = setContextOp(ctx, usq.ctx, "IDs")
+	if err = usq.Select(usersubscription.FieldID).Scan(ctx, &ids); err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (usq *UserSubscriptionQuery) IDsX(ctx context.Context) []string {
+	ids, err := usq.IDs(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return ids
+}
+
+// Count returns the count of the given query.
+func (usq *UserSubscriptionQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, usq.ctx, "Count")
+	if err := usq.prepareQuery(ctx); err != nil {
+		return 0, err
+	}
+	return withInterceptors[int](ctx, usq, querierCount[*UserSubscriptionQuery](), usq.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (usq *UserSubscriptionQuery) CountX(ctx context.Context) int {
+	count, err := usq.Count(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (usq *UserSubscriptionQuery) Exist(ctx context.Context) (bool, error) {
+	ctx = setContextOp(ctx, usq.ctx, "Exist")
+	switch _, err := usq.FirstID(ctx); {
+	case IsNotFound(err):
+		return false, nil
+	case err != nil:
+		return false, fmt.Errorf("db: check existence: %w", err)
+	default:
+		return true, nil
+	}
+}
+
+// ExistX is like Exist, but panics if an error occurs.
+func (usq *UserSubscriptionQuery) ExistX(ctx context.Context) bool {
+	exist, err := usq.Exist(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return exist
+}
+
+// Clone returns a duplicate of the UserSubscriptionQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (usq *UserSubscriptionQuery) Clone() *UserSubscriptionQuery {
+	if usq == nil {
+		return nil
+	}
+	return &UserSubscriptionQuery{
+		config:     usq.config,
+		ctx:        usq.ctx.Clone(),
+		order:      append([]usersubscription.OrderOption{}, usq.order...),
+		inters:     append([]Interceptor{}, usq.inters...),
+		predicates: append([]predicate.UserSubscription{}, usq.predicates...),
+		withUser:   usq.withUser.Clone(),
+		// clone intermediate query.
+		sql:  usq.sql.Clone(),
+		path: usq.path,
+	}
+}
+
+// WithUser tells the query-builder to eager-load the nodes that are connected to
+// the "user" edge. The optional arguments are used to configure the query builder of the edge.
+func (usq *UserSubscriptionQuery) WithUser(opts ...func(*UserQuery)) *UserSubscriptionQuery {
+	query := (&UserClient{config: usq.config}).Query()
+	for _, opt := range opts {
+		opt(query)
+	}
+	usq.withUser = query
+	return usq
+}
+
+// GroupBy is used to group vertices by one or more fields/columns.
+// It is often used with aggregate functions, like: count, max, mean, min, sum.
+//
+// Example:
+//
+//	var v []struct {
+//		CreatedAt int `json:"created_at,omitempty"`
+//		Count int `json:"count,omitempty"`
+//	}
+//
+//	client.UserSubscription.Query().
+//		GroupBy(usersubscription.FieldCreatedAt).
+//		Aggregate(db.Count()).
+//		Scan(ctx, &v)
+func (usq *UserSubscriptionQuery) GroupBy(field string, fields ...string) *UserSubscriptionGroupBy {
+	usq.ctx.Fields = append([]string{field}, fields...)
+	grbuild := &UserSubscriptionGroupBy{build: usq}
+	grbuild.flds = &usq.ctx.Fields
+	grbuild.label = usersubscription.Label
+	grbuild.scan = grbuild.Scan
+	return grbuild
+}
+
+// Select allows the selection one or more fields/columns for the given query,
+// instead of selecting all fields in the entity.
+//
+// Example:
+//
+//	var v []struct {
+//		CreatedAt int `json:"created_at,omitempty"`
+//	}
+//
+//	client.UserSubscription.Query().
+//		Select(usersubscription.FieldCreatedAt).
+//		Scan(ctx, &v)
+func (usq *UserSubscriptionQuery) Select(fields ...string) *UserSubscriptionSelect {
+	usq.ctx.Fields = append(usq.ctx.Fields, fields...)
+	sbuild := &UserSubscriptionSelect{UserSubscriptionQuery: usq}
+	sbuild.label = usersubscription.Label
+	sbuild.flds, sbuild.scan = &usq.ctx.Fields, sbuild.Scan
+	return sbuild
+}
+
+// Aggregate returns a UserSubscriptionSelect configured with the given aggregations.
+func (usq *UserSubscriptionQuery) Aggregate(fns ...AggregateFunc) *UserSubscriptionSelect {
+	return usq.Select().Aggregate(fns...)
+}
+
+func (usq *UserSubscriptionQuery) prepareQuery(ctx context.Context) error {
+	for _, inter := range usq.inters {
+		if inter == nil {
+			return fmt.Errorf("db: uninitialized interceptor (forgotten import db/runtime?)")
+		}
+		if trv, ok := inter.(Traverser); ok {
+			if err := trv.Traverse(ctx, usq); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range usq.ctx.Fields {
+		if !usersubscription.ValidColumn(f) {
+			return &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+		}
+	}
+	if usq.path != nil {
+		prev, err := usq.path(ctx)
+		if err != nil {
+			return err
+		}
+		usq.sql = prev
+	}
+	return nil
+}
+
+func (usq *UserSubscriptionQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*UserSubscription, error) {
+	var (
+		nodes       = []*UserSubscription{}
+		_spec       = usq.querySpec()
+		loadedTypes = [1]bool{
+			usq.withUser != nil,
+		}
+	)
+	_spec.ScanValues = func(columns []string) ([]any, error) {
+		return (*UserSubscription).scanValues(nil, columns)
+	}
+	_spec.Assign = func(columns []string, values []any) error {
+		node := &UserSubscription{config: usq.config}
+		nodes = append(nodes, node)
+		node.Edges.loadedTypes = loadedTypes
+		return node.assignValues(columns, values)
+	}
+	for i := range hooks {
+		hooks[i](ctx, _spec)
+	}
+	if err := sqlgraph.QueryNodes(ctx, usq.driver, _spec); err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nodes, nil
+	}
+	if query := usq.withUser; query != nil {
+		if err := usq.loadUser(ctx, query, nodes, nil,
+			func(n *UserSubscription, e *User) { n.Edges.User = e }); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+func (usq *UserSubscriptionQuery) loadUser(ctx context.Context, query *UserQuery, nodes []*UserSubscription, init func(*UserSubscription), assign func(*UserSubscription, *User)) error {
+	ids := make([]string, 0, len(nodes))
+	nodeids := make(map[string][]*UserSubscription)
+	for i := range nodes {
+		fk := nodes[i].UserID
+		if _, ok := nodeids[fk]; !ok {
+			ids = append(ids, fk)
+		}
+		nodeids[fk] = append(nodeids[fk], nodes[i])
+	}
+	if len(ids) == 0 {
+		return nil
+	}
+	query.Where(user.IDIn(ids...))
+	neighbors, err := query.All(ctx)
+	if err != nil {
+		return err
+	}
+	for _, n := range neighbors {
+		nodes, ok := nodeids[n.ID]
+		if !ok {
+			return fmt.Errorf(`unexpected foreign-key "user_id" returned %v`, n.ID)
+		}
+		for i := range nodes {
+			assign(nodes[i], n)
+		}
+	}
+	return nil
+}
+
+func (usq *UserSubscriptionQuery) sqlCount(ctx context.Context) (int, error) {
+	_spec := usq.querySpec()
+	_spec.Node.Columns = usq.ctx.Fields
+	if len(usq.ctx.Fields) > 0 {
+		_spec.Unique = usq.ctx.Unique != nil && *usq.ctx.Unique
+	}
+	return sqlgraph.CountNodes(ctx, usq.driver, _spec)
+}
+
+func (usq *UserSubscriptionQuery) querySpec() *sqlgraph.QuerySpec {
+	_spec := sqlgraph.NewQuerySpec(usersubscription.Table, usersubscription.Columns, sqlgraph.NewFieldSpec(usersubscription.FieldID, field.TypeString))
+	_spec.From = usq.sql
+	if unique := usq.ctx.Unique; unique != nil {
+		_spec.Unique = *unique
+	} else if usq.path != nil {
+		_spec.Unique = true
+	}
+	if fields := usq.ctx.Fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, usersubscription.FieldID)
+		for i := range fields {
+			if fields[i] != usersubscription.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+			}
+		}
+		if usq.withUser != nil {
+			_spec.Node.AddColumnOnce(usersubscription.FieldUserID)
+		}
+	}
+	if ps := usq.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if limit := usq.ctx.Limit; limit != nil {
+		_spec.Limit = *limit
+	}
+	if offset := usq.ctx.Offset; offset != nil {
+		_spec.Offset = *offset
+	}
+	if ps := usq.order; len(ps) > 0 {
+		_spec.Order = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	return _spec
+}
+
+func (usq *UserSubscriptionQuery) sqlQuery(ctx context.Context) *sql.Selector {
+	builder := sql.Dialect(usq.driver.Dialect())
+	t1 := builder.Table(usersubscription.Table)
+	columns := usq.ctx.Fields
+	if len(columns) == 0 {
+		columns = usersubscription.Columns
+	}
+	selector := builder.Select(t1.Columns(columns...)...).From(t1)
+	if usq.sql != nil {
+		selector = usq.sql
+		selector.Select(selector.Columns(columns...)...)
+	}
+	if usq.ctx.Unique != nil && *usq.ctx.Unique {
+		selector.Distinct()
+	}
+	for _, p := range usq.predicates {
+		p(selector)
+	}
+	for _, p := range usq.order {
+		p(selector)
+	}
+	if offset := usq.ctx.Offset; offset != nil {
+		// limit is mandatory for offset clause. We start
+		// with default value, and override it below if needed.
+		selector.Offset(*offset).Limit(math.MaxInt32)
+	}
+	if limit := usq.ctx.Limit; limit != nil {
+		selector.Limit(*limit)
+	}
+	return selector
+}
+
+// UserSubscriptionGroupBy is the group-by builder for UserSubscription entities.
+type UserSubscriptionGroupBy struct {
+	selector
+	build *UserSubscriptionQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (usgb *UserSubscriptionGroupBy) Aggregate(fns ...AggregateFunc) *UserSubscriptionGroupBy {
+	usgb.fns = append(usgb.fns, fns...)
+	return usgb
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (usgb *UserSubscriptionGroupBy) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, usgb.build.ctx, "GroupBy")
+	if err := usgb.build.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*UserSubscriptionQuery, *UserSubscriptionGroupBy](ctx, usgb.build, usgb, usgb.build.inters, v)
+}
+
+func (usgb *UserSubscriptionGroupBy) sqlScan(ctx context.Context, root *UserSubscriptionQuery, v any) error {
+	selector := root.sqlQuery(ctx).Select()
+	aggregation := make([]string, 0, len(usgb.fns))
+	for _, fn := range usgb.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*usgb.flds)+len(usgb.fns))
+		for _, f := range *usgb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*usgb.flds...)...)
+	if err := selector.Err(); err != nil {
+		return err
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := usgb.build.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
+
+// UserSubscriptionSelect is the builder for selecting fields of UserSubscription entities.
+type UserSubscriptionSelect struct {
+	*UserSubscriptionQuery
+	selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (uss *UserSubscriptionSelect) Aggregate(fns ...AggregateFunc) *UserSubscriptionSelect {
+	uss.fns = append(uss.fns, fns...)
+	return uss
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (uss *UserSubscriptionSelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, uss.ctx, "Select")
+	if err := uss.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*UserSubscriptionQuery, *UserSubscriptionSelect](ctx, uss.UserSubscriptionQuery, uss, uss.inters, v)
+}
+
+func (uss *UserSubscriptionSelect) sqlScan(ctx context.Context, root *UserSubscriptionQuery, v any) error {
+	selector := root.sqlQuery(ctx)
+	aggregation := make([]string, 0, len(uss.fns))
+	for _, fn := range uss.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	switch n := len(*uss.selector.flds); {
+	case n == 0 && len(aggregation) > 0:
+		selector.Select(aggregation...)
+	case n != 0 && len(aggregation) > 0:
+		selector.AppendSelect(aggregation...)
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := uss.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
diff --git a/internal/database/ent/db/usersubscription_update.go b/internal/database/ent/db/usersubscription_update.go
new file mode 100644
index 00000000..ccb7e131
--- /dev/null
+++ b/internal/database/ent/db/usersubscription_update.go
@@ -0,0 +1,440 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/ent/db/usersubscription"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+// UserSubscriptionUpdate is the builder for updating UserSubscription entities.
+type UserSubscriptionUpdate struct {
+	config
+	hooks    []Hook
+	mutation *UserSubscriptionMutation
+}
+
+// Where appends a list predicates to the UserSubscriptionUpdate builder.
+func (usu *UserSubscriptionUpdate) Where(ps ...predicate.UserSubscription) *UserSubscriptionUpdate {
+	usu.mutation.Where(ps...)
+	return usu
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (usu *UserSubscriptionUpdate) SetUpdatedAt(i int) *UserSubscriptionUpdate {
+	usu.mutation.ResetUpdatedAt()
+	usu.mutation.SetUpdatedAt(i)
+	return usu
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (usu *UserSubscriptionUpdate) AddUpdatedAt(i int) *UserSubscriptionUpdate {
+	usu.mutation.AddUpdatedAt(i)
+	return usu
+}
+
+// SetType sets the "type" field.
+func (usu *UserSubscriptionUpdate) SetType(mt models.SubscriptionType) *UserSubscriptionUpdate {
+	usu.mutation.SetType(mt)
+	return usu
+}
+
+// SetNillableType sets the "type" field if the given value is not nil.
+func (usu *UserSubscriptionUpdate) SetNillableType(mt *models.SubscriptionType) *UserSubscriptionUpdate {
+	if mt != nil {
+		usu.SetType(*mt)
+	}
+	return usu
+}
+
+// SetExpiresAt sets the "expires_at" field.
+func (usu *UserSubscriptionUpdate) SetExpiresAt(i int) *UserSubscriptionUpdate {
+	usu.mutation.ResetExpiresAt()
+	usu.mutation.SetExpiresAt(i)
+	return usu
+}
+
+// SetNillableExpiresAt sets the "expires_at" field if the given value is not nil.
+func (usu *UserSubscriptionUpdate) SetNillableExpiresAt(i *int) *UserSubscriptionUpdate {
+	if i != nil {
+		usu.SetExpiresAt(*i)
+	}
+	return usu
+}
+
+// AddExpiresAt adds i to the "expires_at" field.
+func (usu *UserSubscriptionUpdate) AddExpiresAt(i int) *UserSubscriptionUpdate {
+	usu.mutation.AddExpiresAt(i)
+	return usu
+}
+
+// SetPermissions sets the "permissions" field.
+func (usu *UserSubscriptionUpdate) SetPermissions(s string) *UserSubscriptionUpdate {
+	usu.mutation.SetPermissions(s)
+	return usu
+}
+
+// SetNillablePermissions sets the "permissions" field if the given value is not nil.
+func (usu *UserSubscriptionUpdate) SetNillablePermissions(s *string) *UserSubscriptionUpdate {
+	if s != nil {
+		usu.SetPermissions(*s)
+	}
+	return usu
+}
+
+// SetReferenceID sets the "reference_id" field.
+func (usu *UserSubscriptionUpdate) SetReferenceID(s string) *UserSubscriptionUpdate {
+	usu.mutation.SetReferenceID(s)
+	return usu
+}
+
+// SetNillableReferenceID sets the "reference_id" field if the given value is not nil.
+func (usu *UserSubscriptionUpdate) SetNillableReferenceID(s *string) *UserSubscriptionUpdate {
+	if s != nil {
+		usu.SetReferenceID(*s)
+	}
+	return usu
+}
+
+// Mutation returns the UserSubscriptionMutation object of the builder.
+func (usu *UserSubscriptionUpdate) Mutation() *UserSubscriptionMutation {
+	return usu.mutation
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (usu *UserSubscriptionUpdate) Save(ctx context.Context) (int, error) {
+	usu.defaults()
+	return withHooks(ctx, usu.sqlSave, usu.mutation, usu.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (usu *UserSubscriptionUpdate) SaveX(ctx context.Context) int {
+	affected, err := usu.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return affected
+}
+
+// Exec executes the query.
+func (usu *UserSubscriptionUpdate) Exec(ctx context.Context) error {
+	_, err := usu.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (usu *UserSubscriptionUpdate) ExecX(ctx context.Context) {
+	if err := usu.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (usu *UserSubscriptionUpdate) defaults() {
+	if _, ok := usu.mutation.UpdatedAt(); !ok {
+		v := usersubscription.UpdateDefaultUpdatedAt()
+		usu.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (usu *UserSubscriptionUpdate) check() error {
+	if v, ok := usu.mutation.GetType(); ok {
+		if err := usersubscription.TypeValidator(v); err != nil {
+			return &ValidationError{Name: "type", err: fmt.Errorf(`db: validator failed for field "UserSubscription.type": %w`, err)}
+		}
+	}
+	if v, ok := usu.mutation.Permissions(); ok {
+		if err := usersubscription.PermissionsValidator(v); err != nil {
+			return &ValidationError{Name: "permissions", err: fmt.Errorf(`db: validator failed for field "UserSubscription.permissions": %w`, err)}
+		}
+	}
+	if v, ok := usu.mutation.ReferenceID(); ok {
+		if err := usersubscription.ReferenceIDValidator(v); err != nil {
+			return &ValidationError{Name: "reference_id", err: fmt.Errorf(`db: validator failed for field "UserSubscription.reference_id": %w`, err)}
+		}
+	}
+	if _, ok := usu.mutation.UserID(); usu.mutation.UserCleared() && !ok {
+		return errors.New(`db: clearing a required unique edge "UserSubscription.user"`)
+	}
+	return nil
+}
+
+func (usu *UserSubscriptionUpdate) sqlSave(ctx context.Context) (n int, err error) {
+	if err := usu.check(); err != nil {
+		return n, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(usersubscription.Table, usersubscription.Columns, sqlgraph.NewFieldSpec(usersubscription.FieldID, field.TypeString))
+	if ps := usu.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := usu.mutation.UpdatedAt(); ok {
+		_spec.SetField(usersubscription.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := usu.mutation.AddedUpdatedAt(); ok {
+		_spec.AddField(usersubscription.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := usu.mutation.GetType(); ok {
+		_spec.SetField(usersubscription.FieldType, field.TypeEnum, value)
+	}
+	if value, ok := usu.mutation.ExpiresAt(); ok {
+		_spec.SetField(usersubscription.FieldExpiresAt, field.TypeInt, value)
+	}
+	if value, ok := usu.mutation.AddedExpiresAt(); ok {
+		_spec.AddField(usersubscription.FieldExpiresAt, field.TypeInt, value)
+	}
+	if value, ok := usu.mutation.Permissions(); ok {
+		_spec.SetField(usersubscription.FieldPermissions, field.TypeString, value)
+	}
+	if value, ok := usu.mutation.ReferenceID(); ok {
+		_spec.SetField(usersubscription.FieldReferenceID, field.TypeString, value)
+	}
+	if n, err = sqlgraph.UpdateNodes(ctx, usu.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{usersubscription.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return 0, err
+	}
+	usu.mutation.done = true
+	return n, nil
+}
+
+// UserSubscriptionUpdateOne is the builder for updating a single UserSubscription entity.
+type UserSubscriptionUpdateOne struct {
+	config
+	fields   []string
+	hooks    []Hook
+	mutation *UserSubscriptionMutation
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (usuo *UserSubscriptionUpdateOne) SetUpdatedAt(i int) *UserSubscriptionUpdateOne {
+	usuo.mutation.ResetUpdatedAt()
+	usuo.mutation.SetUpdatedAt(i)
+	return usuo
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (usuo *UserSubscriptionUpdateOne) AddUpdatedAt(i int) *UserSubscriptionUpdateOne {
+	usuo.mutation.AddUpdatedAt(i)
+	return usuo
+}
+
+// SetType sets the "type" field.
+func (usuo *UserSubscriptionUpdateOne) SetType(mt models.SubscriptionType) *UserSubscriptionUpdateOne {
+	usuo.mutation.SetType(mt)
+	return usuo
+}
+
+// SetNillableType sets the "type" field if the given value is not nil.
+func (usuo *UserSubscriptionUpdateOne) SetNillableType(mt *models.SubscriptionType) *UserSubscriptionUpdateOne {
+	if mt != nil {
+		usuo.SetType(*mt)
+	}
+	return usuo
+}
+
+// SetExpiresAt sets the "expires_at" field.
+func (usuo *UserSubscriptionUpdateOne) SetExpiresAt(i int) *UserSubscriptionUpdateOne {
+	usuo.mutation.ResetExpiresAt()
+	usuo.mutation.SetExpiresAt(i)
+	return usuo
+}
+
+// SetNillableExpiresAt sets the "expires_at" field if the given value is not nil.
+func (usuo *UserSubscriptionUpdateOne) SetNillableExpiresAt(i *int) *UserSubscriptionUpdateOne {
+	if i != nil {
+		usuo.SetExpiresAt(*i)
+	}
+	return usuo
+}
+
+// AddExpiresAt adds i to the "expires_at" field.
+func (usuo *UserSubscriptionUpdateOne) AddExpiresAt(i int) *UserSubscriptionUpdateOne {
+	usuo.mutation.AddExpiresAt(i)
+	return usuo
+}
+
+// SetPermissions sets the "permissions" field.
+func (usuo *UserSubscriptionUpdateOne) SetPermissions(s string) *UserSubscriptionUpdateOne {
+	usuo.mutation.SetPermissions(s)
+	return usuo
+}
+
+// SetNillablePermissions sets the "permissions" field if the given value is not nil.
+func (usuo *UserSubscriptionUpdateOne) SetNillablePermissions(s *string) *UserSubscriptionUpdateOne {
+	if s != nil {
+		usuo.SetPermissions(*s)
+	}
+	return usuo
+}
+
+// SetReferenceID sets the "reference_id" field.
+func (usuo *UserSubscriptionUpdateOne) SetReferenceID(s string) *UserSubscriptionUpdateOne {
+	usuo.mutation.SetReferenceID(s)
+	return usuo
+}
+
+// SetNillableReferenceID sets the "reference_id" field if the given value is not nil.
+func (usuo *UserSubscriptionUpdateOne) SetNillableReferenceID(s *string) *UserSubscriptionUpdateOne {
+	if s != nil {
+		usuo.SetReferenceID(*s)
+	}
+	return usuo
+}
+
+// Mutation returns the UserSubscriptionMutation object of the builder.
+func (usuo *UserSubscriptionUpdateOne) Mutation() *UserSubscriptionMutation {
+	return usuo.mutation
+}
+
+// Where appends a list predicates to the UserSubscriptionUpdate builder.
+func (usuo *UserSubscriptionUpdateOne) Where(ps ...predicate.UserSubscription) *UserSubscriptionUpdateOne {
+	usuo.mutation.Where(ps...)
+	return usuo
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (usuo *UserSubscriptionUpdateOne) Select(field string, fields ...string) *UserSubscriptionUpdateOne {
+	usuo.fields = append([]string{field}, fields...)
+	return usuo
+}
+
+// Save executes the query and returns the updated UserSubscription entity.
+func (usuo *UserSubscriptionUpdateOne) Save(ctx context.Context) (*UserSubscription, error) {
+	usuo.defaults()
+	return withHooks(ctx, usuo.sqlSave, usuo.mutation, usuo.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (usuo *UserSubscriptionUpdateOne) SaveX(ctx context.Context) *UserSubscription {
+	node, err := usuo.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// Exec executes the query on the entity.
+func (usuo *UserSubscriptionUpdateOne) Exec(ctx context.Context) error {
+	_, err := usuo.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (usuo *UserSubscriptionUpdateOne) ExecX(ctx context.Context) {
+	if err := usuo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (usuo *UserSubscriptionUpdateOne) defaults() {
+	if _, ok := usuo.mutation.UpdatedAt(); !ok {
+		v := usersubscription.UpdateDefaultUpdatedAt()
+		usuo.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (usuo *UserSubscriptionUpdateOne) check() error {
+	if v, ok := usuo.mutation.GetType(); ok {
+		if err := usersubscription.TypeValidator(v); err != nil {
+			return &ValidationError{Name: "type", err: fmt.Errorf(`db: validator failed for field "UserSubscription.type": %w`, err)}
+		}
+	}
+	if v, ok := usuo.mutation.Permissions(); ok {
+		if err := usersubscription.PermissionsValidator(v); err != nil {
+			return &ValidationError{Name: "permissions", err: fmt.Errorf(`db: validator failed for field "UserSubscription.permissions": %w`, err)}
+		}
+	}
+	if v, ok := usuo.mutation.ReferenceID(); ok {
+		if err := usersubscription.ReferenceIDValidator(v); err != nil {
+			return &ValidationError{Name: "reference_id", err: fmt.Errorf(`db: validator failed for field "UserSubscription.reference_id": %w`, err)}
+		}
+	}
+	if _, ok := usuo.mutation.UserID(); usuo.mutation.UserCleared() && !ok {
+		return errors.New(`db: clearing a required unique edge "UserSubscription.user"`)
+	}
+	return nil
+}
+
+func (usuo *UserSubscriptionUpdateOne) sqlSave(ctx context.Context) (_node *UserSubscription, err error) {
+	if err := usuo.check(); err != nil {
+		return _node, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(usersubscription.Table, usersubscription.Columns, sqlgraph.NewFieldSpec(usersubscription.FieldID, field.TypeString))
+	id, ok := usuo.mutation.ID()
+	if !ok {
+		return nil, &ValidationError{Name: "id", err: errors.New(`db: missing "UserSubscription.id" for update`)}
+	}
+	_spec.Node.ID.Value = id
+	if fields := usuo.fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, usersubscription.FieldID)
+		for _, f := range fields {
+			if !usersubscription.ValidColumn(f) {
+				return nil, &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+			}
+			if f != usersubscription.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, f)
+			}
+		}
+	}
+	if ps := usuo.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := usuo.mutation.UpdatedAt(); ok {
+		_spec.SetField(usersubscription.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := usuo.mutation.AddedUpdatedAt(); ok {
+		_spec.AddField(usersubscription.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := usuo.mutation.GetType(); ok {
+		_spec.SetField(usersubscription.FieldType, field.TypeEnum, value)
+	}
+	if value, ok := usuo.mutation.ExpiresAt(); ok {
+		_spec.SetField(usersubscription.FieldExpiresAt, field.TypeInt, value)
+	}
+	if value, ok := usuo.mutation.AddedExpiresAt(); ok {
+		_spec.AddField(usersubscription.FieldExpiresAt, field.TypeInt, value)
+	}
+	if value, ok := usuo.mutation.Permissions(); ok {
+		_spec.SetField(usersubscription.FieldPermissions, field.TypeString, value)
+	}
+	if value, ok := usuo.mutation.ReferenceID(); ok {
+		_spec.SetField(usersubscription.FieldReferenceID, field.TypeString, value)
+	}
+	_node = &UserSubscription{config: usuo.config}
+	_spec.Assign = _node.assignValues
+	_spec.ScanValues = _node.scanValues
+	if err = sqlgraph.UpdateNode(ctx, usuo.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{usersubscription.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	usuo.mutation.done = true
+	return _node, nil
+}
diff --git a/internal/database/ent/db/vehicle.go b/internal/database/ent/db/vehicle.go
new file mode 100644
index 00000000..14f5ecf1
--- /dev/null
+++ b/internal/database/ent/db/vehicle.go
@@ -0,0 +1,141 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+	"github.com/cufee/aftermath/internal/database/ent/db/vehicle"
+)
+
+// Vehicle is the model entity for the Vehicle schema.
+type Vehicle struct {
+	config `json:"-"`
+	// ID of the ent.
+	ID string `json:"id,omitempty"`
+	// CreatedAt holds the value of the "created_at" field.
+	CreatedAt int `json:"created_at,omitempty"`
+	// UpdatedAt holds the value of the "updated_at" field.
+	UpdatedAt int `json:"updated_at,omitempty"`
+	// Tier holds the value of the "tier" field.
+	Tier int `json:"tier,omitempty"`
+	// LocalizedNames holds the value of the "localized_names" field.
+	LocalizedNames map[string]string `json:"localized_names,omitempty"`
+	selectValues   sql.SelectValues
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*Vehicle) scanValues(columns []string) ([]any, error) {
+	values := make([]any, len(columns))
+	for i := range columns {
+		switch columns[i] {
+		case vehicle.FieldLocalizedNames:
+			values[i] = new([]byte)
+		case vehicle.FieldCreatedAt, vehicle.FieldUpdatedAt, vehicle.FieldTier:
+			values[i] = new(sql.NullInt64)
+		case vehicle.FieldID:
+			values[i] = new(sql.NullString)
+		default:
+			values[i] = new(sql.UnknownType)
+		}
+	}
+	return values, nil
+}
+
+// assignValues assigns the values that were returned from sql.Rows (after scanning)
+// to the Vehicle fields.
+func (v *Vehicle) assignValues(columns []string, values []any) error {
+	if m, n := len(values), len(columns); m < n {
+		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
+	}
+	for i := range columns {
+		switch columns[i] {
+		case vehicle.FieldID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field id", values[i])
+			} else if value.Valid {
+				v.ID = value.String
+			}
+		case vehicle.FieldCreatedAt:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field created_at", values[i])
+			} else if value.Valid {
+				v.CreatedAt = int(value.Int64)
+			}
+		case vehicle.FieldUpdatedAt:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
+			} else if value.Valid {
+				v.UpdatedAt = int(value.Int64)
+			}
+		case vehicle.FieldTier:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field tier", values[i])
+			} else if value.Valid {
+				v.Tier = int(value.Int64)
+			}
+		case vehicle.FieldLocalizedNames:
+			if value, ok := values[i].(*[]byte); !ok {
+				return fmt.Errorf("unexpected type %T for field localized_names", values[i])
+			} else if value != nil && len(*value) > 0 {
+				if err := json.Unmarshal(*value, &v.LocalizedNames); err != nil {
+					return fmt.Errorf("unmarshal field localized_names: %w", err)
+				}
+			}
+		default:
+			v.selectValues.Set(columns[i], values[i])
+		}
+	}
+	return nil
+}
+
+// Value returns the ent.Value that was dynamically selected and assigned to the Vehicle.
+// This includes values selected through modifiers, order, etc.
+func (v *Vehicle) Value(name string) (ent.Value, error) {
+	return v.selectValues.Get(name)
+}
+
+// Update returns a builder for updating this Vehicle.
+// Note that you need to call Vehicle.Unwrap() before calling this method if this Vehicle
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (v *Vehicle) Update() *VehicleUpdateOne {
+	return NewVehicleClient(v.config).UpdateOne(v)
+}
+
+// Unwrap unwraps the Vehicle entity that was returned from a transaction after it was closed,
+// so that all future queries will be executed through the driver which created the transaction.
+func (v *Vehicle) Unwrap() *Vehicle {
+	_tx, ok := v.config.driver.(*txDriver)
+	if !ok {
+		panic("db: Vehicle is not a transactional entity")
+	}
+	v.config.driver = _tx.drv
+	return v
+}
+
+// String implements the fmt.Stringer.
+func (v *Vehicle) String() string {
+	var builder strings.Builder
+	builder.WriteString("Vehicle(")
+	builder.WriteString(fmt.Sprintf("id=%v, ", v.ID))
+	builder.WriteString("created_at=")
+	builder.WriteString(fmt.Sprintf("%v", v.CreatedAt))
+	builder.WriteString(", ")
+	builder.WriteString("updated_at=")
+	builder.WriteString(fmt.Sprintf("%v", v.UpdatedAt))
+	builder.WriteString(", ")
+	builder.WriteString("tier=")
+	builder.WriteString(fmt.Sprintf("%v", v.Tier))
+	builder.WriteString(", ")
+	builder.WriteString("localized_names=")
+	builder.WriteString(fmt.Sprintf("%v", v.LocalizedNames))
+	builder.WriteByte(')')
+	return builder.String()
+}
+
+// Vehicles is a parsable slice of Vehicle.
+type Vehicles []*Vehicle
diff --git a/internal/database/ent/db/vehicle/vehicle.go b/internal/database/ent/db/vehicle/vehicle.go
new file mode 100644
index 00000000..236f55e0
--- /dev/null
+++ b/internal/database/ent/db/vehicle/vehicle.go
@@ -0,0 +1,77 @@
+// Code generated by ent, DO NOT EDIT.
+
+package vehicle
+
+import (
+	"entgo.io/ent/dialect/sql"
+)
+
+const (
+	// Label holds the string label denoting the vehicle type in the database.
+	Label = "vehicle"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// FieldTier holds the string denoting the tier field in the database.
+	FieldTier = "tier"
+	// FieldLocalizedNames holds the string denoting the localized_names field in the database.
+	FieldLocalizedNames = "localized_names"
+	// Table holds the table name of the vehicle in the database.
+	Table = "vehicles"
+)
+
+// Columns holds all SQL columns for vehicle fields.
+var Columns = []string{
+	FieldID,
+	FieldCreatedAt,
+	FieldUpdatedAt,
+	FieldTier,
+	FieldLocalizedNames,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() int
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() int
+	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
+	UpdateDefaultUpdatedAt func() int
+	// TierValidator is a validator for the "tier" field. It is called by the builders before save.
+	TierValidator func(int) error
+)
+
+// OrderOption defines the ordering options for the Vehicle queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByTier orders the results by the tier field.
+func ByTier(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldTier, opts...).ToFunc()
+}
diff --git a/internal/database/ent/db/vehicle/where.go b/internal/database/ent/db/vehicle/where.go
new file mode 100644
index 00000000..c09e0846
--- /dev/null
+++ b/internal/database/ent/db/vehicle/where.go
@@ -0,0 +1,213 @@
+// Code generated by ent, DO NOT EDIT.
+
+package vehicle
+
+import (
+	"entgo.io/ent/dialect/sql"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id string) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id string) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id string) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...string) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...string) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id string) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id string) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id string) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id string) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldLTE(FieldID, id))
+}
+
+// IDEqualFold applies the EqualFold predicate on the ID field.
+func IDEqualFold(id string) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldEqualFold(FieldID, id))
+}
+
+// IDContainsFold applies the ContainsFold predicate on the ID field.
+func IDContainsFold(id string) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldContainsFold(FieldID, id))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v int) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v int) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// Tier applies equality check predicate on the "tier" field. It's identical to TierEQ.
+func Tier(v int) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldEQ(FieldTier, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v int) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v int) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...int) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...int) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v int) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v int) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v int) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v int) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v int) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v int) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...int) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...int) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v int) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v int) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v int) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v int) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// TierEQ applies the EQ predicate on the "tier" field.
+func TierEQ(v int) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldEQ(FieldTier, v))
+}
+
+// TierNEQ applies the NEQ predicate on the "tier" field.
+func TierNEQ(v int) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldNEQ(FieldTier, v))
+}
+
+// TierIn applies the In predicate on the "tier" field.
+func TierIn(vs ...int) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldIn(FieldTier, vs...))
+}
+
+// TierNotIn applies the NotIn predicate on the "tier" field.
+func TierNotIn(vs ...int) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldNotIn(FieldTier, vs...))
+}
+
+// TierGT applies the GT predicate on the "tier" field.
+func TierGT(v int) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldGT(FieldTier, v))
+}
+
+// TierGTE applies the GTE predicate on the "tier" field.
+func TierGTE(v int) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldGTE(FieldTier, v))
+}
+
+// TierLT applies the LT predicate on the "tier" field.
+func TierLT(v int) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldLT(FieldTier, v))
+}
+
+// TierLTE applies the LTE predicate on the "tier" field.
+func TierLTE(v int) predicate.Vehicle {
+	return predicate.Vehicle(sql.FieldLTE(FieldTier, v))
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.Vehicle) predicate.Vehicle {
+	return predicate.Vehicle(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.Vehicle) predicate.Vehicle {
+	return predicate.Vehicle(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.Vehicle) predicate.Vehicle {
+	return predicate.Vehicle(sql.NotPredicates(p))
+}
diff --git a/internal/database/ent/db/vehicle_create.go b/internal/database/ent/db/vehicle_create.go
new file mode 100644
index 00000000..5487bf7b
--- /dev/null
+++ b/internal/database/ent/db/vehicle_create.go
@@ -0,0 +1,268 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/vehicle"
+)
+
+// VehicleCreate is the builder for creating a Vehicle entity.
+type VehicleCreate struct {
+	config
+	mutation *VehicleMutation
+	hooks    []Hook
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (vc *VehicleCreate) SetCreatedAt(i int) *VehicleCreate {
+	vc.mutation.SetCreatedAt(i)
+	return vc
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (vc *VehicleCreate) SetNillableCreatedAt(i *int) *VehicleCreate {
+	if i != nil {
+		vc.SetCreatedAt(*i)
+	}
+	return vc
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (vc *VehicleCreate) SetUpdatedAt(i int) *VehicleCreate {
+	vc.mutation.SetUpdatedAt(i)
+	return vc
+}
+
+// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
+func (vc *VehicleCreate) SetNillableUpdatedAt(i *int) *VehicleCreate {
+	if i != nil {
+		vc.SetUpdatedAt(*i)
+	}
+	return vc
+}
+
+// SetTier sets the "tier" field.
+func (vc *VehicleCreate) SetTier(i int) *VehicleCreate {
+	vc.mutation.SetTier(i)
+	return vc
+}
+
+// SetLocalizedNames sets the "localized_names" field.
+func (vc *VehicleCreate) SetLocalizedNames(m map[string]string) *VehicleCreate {
+	vc.mutation.SetLocalizedNames(m)
+	return vc
+}
+
+// SetID sets the "id" field.
+func (vc *VehicleCreate) SetID(s string) *VehicleCreate {
+	vc.mutation.SetID(s)
+	return vc
+}
+
+// Mutation returns the VehicleMutation object of the builder.
+func (vc *VehicleCreate) Mutation() *VehicleMutation {
+	return vc.mutation
+}
+
+// Save creates the Vehicle in the database.
+func (vc *VehicleCreate) Save(ctx context.Context) (*Vehicle, error) {
+	vc.defaults()
+	return withHooks(ctx, vc.sqlSave, vc.mutation, vc.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (vc *VehicleCreate) SaveX(ctx context.Context) *Vehicle {
+	v, err := vc.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (vc *VehicleCreate) Exec(ctx context.Context) error {
+	_, err := vc.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (vc *VehicleCreate) ExecX(ctx context.Context) {
+	if err := vc.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (vc *VehicleCreate) defaults() {
+	if _, ok := vc.mutation.CreatedAt(); !ok {
+		v := vehicle.DefaultCreatedAt()
+		vc.mutation.SetCreatedAt(v)
+	}
+	if _, ok := vc.mutation.UpdatedAt(); !ok {
+		v := vehicle.DefaultUpdatedAt()
+		vc.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (vc *VehicleCreate) check() error {
+	if _, ok := vc.mutation.CreatedAt(); !ok {
+		return &ValidationError{Name: "created_at", err: errors.New(`db: missing required field "Vehicle.created_at"`)}
+	}
+	if _, ok := vc.mutation.UpdatedAt(); !ok {
+		return &ValidationError{Name: "updated_at", err: errors.New(`db: missing required field "Vehicle.updated_at"`)}
+	}
+	if _, ok := vc.mutation.Tier(); !ok {
+		return &ValidationError{Name: "tier", err: errors.New(`db: missing required field "Vehicle.tier"`)}
+	}
+	if v, ok := vc.mutation.Tier(); ok {
+		if err := vehicle.TierValidator(v); err != nil {
+			return &ValidationError{Name: "tier", err: fmt.Errorf(`db: validator failed for field "Vehicle.tier": %w`, err)}
+		}
+	}
+	if _, ok := vc.mutation.LocalizedNames(); !ok {
+		return &ValidationError{Name: "localized_names", err: errors.New(`db: missing required field "Vehicle.localized_names"`)}
+	}
+	return nil
+}
+
+func (vc *VehicleCreate) sqlSave(ctx context.Context) (*Vehicle, error) {
+	if err := vc.check(); err != nil {
+		return nil, err
+	}
+	_node, _spec := vc.createSpec()
+	if err := sqlgraph.CreateNode(ctx, vc.driver, _spec); err != nil {
+		if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	if _spec.ID.Value != nil {
+		if id, ok := _spec.ID.Value.(string); ok {
+			_node.ID = id
+		} else {
+			return nil, fmt.Errorf("unexpected Vehicle.ID type: %T", _spec.ID.Value)
+		}
+	}
+	vc.mutation.id = &_node.ID
+	vc.mutation.done = true
+	return _node, nil
+}
+
+func (vc *VehicleCreate) createSpec() (*Vehicle, *sqlgraph.CreateSpec) {
+	var (
+		_node = &Vehicle{config: vc.config}
+		_spec = sqlgraph.NewCreateSpec(vehicle.Table, sqlgraph.NewFieldSpec(vehicle.FieldID, field.TypeString))
+	)
+	if id, ok := vc.mutation.ID(); ok {
+		_node.ID = id
+		_spec.ID.Value = id
+	}
+	if value, ok := vc.mutation.CreatedAt(); ok {
+		_spec.SetField(vehicle.FieldCreatedAt, field.TypeInt, value)
+		_node.CreatedAt = value
+	}
+	if value, ok := vc.mutation.UpdatedAt(); ok {
+		_spec.SetField(vehicle.FieldUpdatedAt, field.TypeInt, value)
+		_node.UpdatedAt = value
+	}
+	if value, ok := vc.mutation.Tier(); ok {
+		_spec.SetField(vehicle.FieldTier, field.TypeInt, value)
+		_node.Tier = value
+	}
+	if value, ok := vc.mutation.LocalizedNames(); ok {
+		_spec.SetField(vehicle.FieldLocalizedNames, field.TypeJSON, value)
+		_node.LocalizedNames = value
+	}
+	return _node, _spec
+}
+
+// VehicleCreateBulk is the builder for creating many Vehicle entities in bulk.
+type VehicleCreateBulk struct {
+	config
+	err      error
+	builders []*VehicleCreate
+}
+
+// Save creates the Vehicle entities in the database.
+func (vcb *VehicleCreateBulk) Save(ctx context.Context) ([]*Vehicle, error) {
+	if vcb.err != nil {
+		return nil, vcb.err
+	}
+	specs := make([]*sqlgraph.CreateSpec, len(vcb.builders))
+	nodes := make([]*Vehicle, len(vcb.builders))
+	mutators := make([]Mutator, len(vcb.builders))
+	for i := range vcb.builders {
+		func(i int, root context.Context) {
+			builder := vcb.builders[i]
+			builder.defaults()
+			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+				mutation, ok := m.(*VehicleMutation)
+				if !ok {
+					return nil, fmt.Errorf("unexpected mutation type %T", m)
+				}
+				if err := builder.check(); err != nil {
+					return nil, err
+				}
+				builder.mutation = mutation
+				var err error
+				nodes[i], specs[i] = builder.createSpec()
+				if i < len(mutators)-1 {
+					_, err = mutators[i+1].Mutate(root, vcb.builders[i+1].mutation)
+				} else {
+					spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
+					// Invoke the actual operation on the latest mutation in the chain.
+					if err = sqlgraph.BatchCreate(ctx, vcb.driver, spec); err != nil {
+						if sqlgraph.IsConstraintError(err) {
+							err = &ConstraintError{msg: err.Error(), wrap: err}
+						}
+					}
+				}
+				if err != nil {
+					return nil, err
+				}
+				mutation.id = &nodes[i].ID
+				mutation.done = true
+				return nodes[i], nil
+			})
+			for i := len(builder.hooks) - 1; i >= 0; i-- {
+				mut = builder.hooks[i](mut)
+			}
+			mutators[i] = mut
+		}(i, ctx)
+	}
+	if len(mutators) > 0 {
+		if _, err := mutators[0].Mutate(ctx, vcb.builders[0].mutation); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (vcb *VehicleCreateBulk) SaveX(ctx context.Context) []*Vehicle {
+	v, err := vcb.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (vcb *VehicleCreateBulk) Exec(ctx context.Context) error {
+	_, err := vcb.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (vcb *VehicleCreateBulk) ExecX(ctx context.Context) {
+	if err := vcb.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/database/ent/db/vehicle_delete.go b/internal/database/ent/db/vehicle_delete.go
new file mode 100644
index 00000000..bb495b37
--- /dev/null
+++ b/internal/database/ent/db/vehicle_delete.go
@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/ent/db/vehicle"
+)
+
+// VehicleDelete is the builder for deleting a Vehicle entity.
+type VehicleDelete struct {
+	config
+	hooks    []Hook
+	mutation *VehicleMutation
+}
+
+// Where appends a list predicates to the VehicleDelete builder.
+func (vd *VehicleDelete) Where(ps ...predicate.Vehicle) *VehicleDelete {
+	vd.mutation.Where(ps...)
+	return vd
+}
+
+// Exec executes the deletion query and returns how many vertices were deleted.
+func (vd *VehicleDelete) Exec(ctx context.Context) (int, error) {
+	return withHooks(ctx, vd.sqlExec, vd.mutation, vd.hooks)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (vd *VehicleDelete) ExecX(ctx context.Context) int {
+	n, err := vd.Exec(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return n
+}
+
+func (vd *VehicleDelete) sqlExec(ctx context.Context) (int, error) {
+	_spec := sqlgraph.NewDeleteSpec(vehicle.Table, sqlgraph.NewFieldSpec(vehicle.FieldID, field.TypeString))
+	if ps := vd.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	affected, err := sqlgraph.DeleteNodes(ctx, vd.driver, _spec)
+	if err != nil && sqlgraph.IsConstraintError(err) {
+		err = &ConstraintError{msg: err.Error(), wrap: err}
+	}
+	vd.mutation.done = true
+	return affected, err
+}
+
+// VehicleDeleteOne is the builder for deleting a single Vehicle entity.
+type VehicleDeleteOne struct {
+	vd *VehicleDelete
+}
+
+// Where appends a list predicates to the VehicleDelete builder.
+func (vdo *VehicleDeleteOne) Where(ps ...predicate.Vehicle) *VehicleDeleteOne {
+	vdo.vd.mutation.Where(ps...)
+	return vdo
+}
+
+// Exec executes the deletion query.
+func (vdo *VehicleDeleteOne) Exec(ctx context.Context) error {
+	n, err := vdo.vd.Exec(ctx)
+	switch {
+	case err != nil:
+		return err
+	case n == 0:
+		return &NotFoundError{vehicle.Label}
+	default:
+		return nil
+	}
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (vdo *VehicleDeleteOne) ExecX(ctx context.Context) {
+	if err := vdo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/database/ent/db/vehicle_query.go b/internal/database/ent/db/vehicle_query.go
new file mode 100644
index 00000000..2eef76b0
--- /dev/null
+++ b/internal/database/ent/db/vehicle_query.go
@@ -0,0 +1,526 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"fmt"
+	"math"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/ent/db/vehicle"
+)
+
+// VehicleQuery is the builder for querying Vehicle entities.
+type VehicleQuery struct {
+	config
+	ctx        *QueryContext
+	order      []vehicle.OrderOption
+	inters     []Interceptor
+	predicates []predicate.Vehicle
+	// intermediate query (i.e. traversal path).
+	sql  *sql.Selector
+	path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the VehicleQuery builder.
+func (vq *VehicleQuery) Where(ps ...predicate.Vehicle) *VehicleQuery {
+	vq.predicates = append(vq.predicates, ps...)
+	return vq
+}
+
+// Limit the number of records to be returned by this query.
+func (vq *VehicleQuery) Limit(limit int) *VehicleQuery {
+	vq.ctx.Limit = &limit
+	return vq
+}
+
+// Offset to start from.
+func (vq *VehicleQuery) Offset(offset int) *VehicleQuery {
+	vq.ctx.Offset = &offset
+	return vq
+}
+
+// Unique configures the query builder to filter duplicate records on query.
+// By default, unique is set to true, and can be disabled using this method.
+func (vq *VehicleQuery) Unique(unique bool) *VehicleQuery {
+	vq.ctx.Unique = &unique
+	return vq
+}
+
+// Order specifies how the records should be ordered.
+func (vq *VehicleQuery) Order(o ...vehicle.OrderOption) *VehicleQuery {
+	vq.order = append(vq.order, o...)
+	return vq
+}
+
+// First returns the first Vehicle entity from the query.
+// Returns a *NotFoundError when no Vehicle was found.
+func (vq *VehicleQuery) First(ctx context.Context) (*Vehicle, error) {
+	nodes, err := vq.Limit(1).All(setContextOp(ctx, vq.ctx, "First"))
+	if err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nil, &NotFoundError{vehicle.Label}
+	}
+	return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (vq *VehicleQuery) FirstX(ctx context.Context) *Vehicle {
+	node, err := vq.First(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return node
+}
+
+// FirstID returns the first Vehicle ID from the query.
+// Returns a *NotFoundError when no Vehicle ID was found.
+func (vq *VehicleQuery) FirstID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = vq.Limit(1).IDs(setContextOp(ctx, vq.ctx, "FirstID")); err != nil {
+		return
+	}
+	if len(ids) == 0 {
+		err = &NotFoundError{vehicle.Label}
+		return
+	}
+	return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (vq *VehicleQuery) FirstIDX(ctx context.Context) string {
+	id, err := vq.FirstID(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return id
+}
+
+// Only returns a single Vehicle entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one Vehicle entity is found.
+// Returns a *NotFoundError when no Vehicle entities are found.
+func (vq *VehicleQuery) Only(ctx context.Context) (*Vehicle, error) {
+	nodes, err := vq.Limit(2).All(setContextOp(ctx, vq.ctx, "Only"))
+	if err != nil {
+		return nil, err
+	}
+	switch len(nodes) {
+	case 1:
+		return nodes[0], nil
+	case 0:
+		return nil, &NotFoundError{vehicle.Label}
+	default:
+		return nil, &NotSingularError{vehicle.Label}
+	}
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (vq *VehicleQuery) OnlyX(ctx context.Context) *Vehicle {
+	node, err := vq.Only(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// OnlyID is like Only, but returns the only Vehicle ID in the query.
+// Returns a *NotSingularError when more than one Vehicle ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (vq *VehicleQuery) OnlyID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = vq.Limit(2).IDs(setContextOp(ctx, vq.ctx, "OnlyID")); err != nil {
+		return
+	}
+	switch len(ids) {
+	case 1:
+		id = ids[0]
+	case 0:
+		err = &NotFoundError{vehicle.Label}
+	default:
+		err = &NotSingularError{vehicle.Label}
+	}
+	return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (vq *VehicleQuery) OnlyIDX(ctx context.Context) string {
+	id, err := vq.OnlyID(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return id
+}
+
+// All executes the query and returns a list of Vehicles.
+func (vq *VehicleQuery) All(ctx context.Context) ([]*Vehicle, error) {
+	ctx = setContextOp(ctx, vq.ctx, "All")
+	if err := vq.prepareQuery(ctx); err != nil {
+		return nil, err
+	}
+	qr := querierAll[[]*Vehicle, *VehicleQuery]()
+	return withInterceptors[[]*Vehicle](ctx, vq, qr, vq.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (vq *VehicleQuery) AllX(ctx context.Context) []*Vehicle {
+	nodes, err := vq.All(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return nodes
+}
+
+// IDs executes the query and returns a list of Vehicle IDs.
+func (vq *VehicleQuery) IDs(ctx context.Context) (ids []string, err error) {
+	if vq.ctx.Unique == nil && vq.path != nil {
+		vq.Unique(true)
+	}
+	ctx = setContextOp(ctx, vq.ctx, "IDs")
+	if err = vq.Select(vehicle.FieldID).Scan(ctx, &ids); err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (vq *VehicleQuery) IDsX(ctx context.Context) []string {
+	ids, err := vq.IDs(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return ids
+}
+
+// Count returns the count of the given query.
+func (vq *VehicleQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, vq.ctx, "Count")
+	if err := vq.prepareQuery(ctx); err != nil {
+		return 0, err
+	}
+	return withInterceptors[int](ctx, vq, querierCount[*VehicleQuery](), vq.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (vq *VehicleQuery) CountX(ctx context.Context) int {
+	count, err := vq.Count(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (vq *VehicleQuery) Exist(ctx context.Context) (bool, error) {
+	ctx = setContextOp(ctx, vq.ctx, "Exist")
+	switch _, err := vq.FirstID(ctx); {
+	case IsNotFound(err):
+		return false, nil
+	case err != nil:
+		return false, fmt.Errorf("db: check existence: %w", err)
+	default:
+		return true, nil
+	}
+}
+
+// ExistX is like Exist, but panics if an error occurs.
+func (vq *VehicleQuery) ExistX(ctx context.Context) bool {
+	exist, err := vq.Exist(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return exist
+}
+
+// Clone returns a duplicate of the VehicleQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (vq *VehicleQuery) Clone() *VehicleQuery {
+	if vq == nil {
+		return nil
+	}
+	return &VehicleQuery{
+		config:     vq.config,
+		ctx:        vq.ctx.Clone(),
+		order:      append([]vehicle.OrderOption{}, vq.order...),
+		inters:     append([]Interceptor{}, vq.inters...),
+		predicates: append([]predicate.Vehicle{}, vq.predicates...),
+		// clone intermediate query.
+		sql:  vq.sql.Clone(),
+		path: vq.path,
+	}
+}
+
+// GroupBy is used to group vertices by one or more fields/columns.
+// It is often used with aggregate functions, like: count, max, mean, min, sum.
+//
+// Example:
+//
+//	var v []struct {
+//		CreatedAt int `json:"created_at,omitempty"`
+//		Count int `json:"count,omitempty"`
+//	}
+//
+//	client.Vehicle.Query().
+//		GroupBy(vehicle.FieldCreatedAt).
+//		Aggregate(db.Count()).
+//		Scan(ctx, &v)
+func (vq *VehicleQuery) GroupBy(field string, fields ...string) *VehicleGroupBy {
+	vq.ctx.Fields = append([]string{field}, fields...)
+	grbuild := &VehicleGroupBy{build: vq}
+	grbuild.flds = &vq.ctx.Fields
+	grbuild.label = vehicle.Label
+	grbuild.scan = grbuild.Scan
+	return grbuild
+}
+
+// Select allows the selection one or more fields/columns for the given query,
+// instead of selecting all fields in the entity.
+//
+// Example:
+//
+//	var v []struct {
+//		CreatedAt int `json:"created_at,omitempty"`
+//	}
+//
+//	client.Vehicle.Query().
+//		Select(vehicle.FieldCreatedAt).
+//		Scan(ctx, &v)
+func (vq *VehicleQuery) Select(fields ...string) *VehicleSelect {
+	vq.ctx.Fields = append(vq.ctx.Fields, fields...)
+	sbuild := &VehicleSelect{VehicleQuery: vq}
+	sbuild.label = vehicle.Label
+	sbuild.flds, sbuild.scan = &vq.ctx.Fields, sbuild.Scan
+	return sbuild
+}
+
+// Aggregate returns a VehicleSelect configured with the given aggregations.
+func (vq *VehicleQuery) Aggregate(fns ...AggregateFunc) *VehicleSelect {
+	return vq.Select().Aggregate(fns...)
+}
+
+func (vq *VehicleQuery) prepareQuery(ctx context.Context) error {
+	for _, inter := range vq.inters {
+		if inter == nil {
+			return fmt.Errorf("db: uninitialized interceptor (forgotten import db/runtime?)")
+		}
+		if trv, ok := inter.(Traverser); ok {
+			if err := trv.Traverse(ctx, vq); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range vq.ctx.Fields {
+		if !vehicle.ValidColumn(f) {
+			return &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+		}
+	}
+	if vq.path != nil {
+		prev, err := vq.path(ctx)
+		if err != nil {
+			return err
+		}
+		vq.sql = prev
+	}
+	return nil
+}
+
+func (vq *VehicleQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Vehicle, error) {
+	var (
+		nodes = []*Vehicle{}
+		_spec = vq.querySpec()
+	)
+	_spec.ScanValues = func(columns []string) ([]any, error) {
+		return (*Vehicle).scanValues(nil, columns)
+	}
+	_spec.Assign = func(columns []string, values []any) error {
+		node := &Vehicle{config: vq.config}
+		nodes = append(nodes, node)
+		return node.assignValues(columns, values)
+	}
+	for i := range hooks {
+		hooks[i](ctx, _spec)
+	}
+	if err := sqlgraph.QueryNodes(ctx, vq.driver, _spec); err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nodes, nil
+	}
+	return nodes, nil
+}
+
+func (vq *VehicleQuery) sqlCount(ctx context.Context) (int, error) {
+	_spec := vq.querySpec()
+	_spec.Node.Columns = vq.ctx.Fields
+	if len(vq.ctx.Fields) > 0 {
+		_spec.Unique = vq.ctx.Unique != nil && *vq.ctx.Unique
+	}
+	return sqlgraph.CountNodes(ctx, vq.driver, _spec)
+}
+
+func (vq *VehicleQuery) querySpec() *sqlgraph.QuerySpec {
+	_spec := sqlgraph.NewQuerySpec(vehicle.Table, vehicle.Columns, sqlgraph.NewFieldSpec(vehicle.FieldID, field.TypeString))
+	_spec.From = vq.sql
+	if unique := vq.ctx.Unique; unique != nil {
+		_spec.Unique = *unique
+	} else if vq.path != nil {
+		_spec.Unique = true
+	}
+	if fields := vq.ctx.Fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, vehicle.FieldID)
+		for i := range fields {
+			if fields[i] != vehicle.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+			}
+		}
+	}
+	if ps := vq.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if limit := vq.ctx.Limit; limit != nil {
+		_spec.Limit = *limit
+	}
+	if offset := vq.ctx.Offset; offset != nil {
+		_spec.Offset = *offset
+	}
+	if ps := vq.order; len(ps) > 0 {
+		_spec.Order = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	return _spec
+}
+
+func (vq *VehicleQuery) sqlQuery(ctx context.Context) *sql.Selector {
+	builder := sql.Dialect(vq.driver.Dialect())
+	t1 := builder.Table(vehicle.Table)
+	columns := vq.ctx.Fields
+	if len(columns) == 0 {
+		columns = vehicle.Columns
+	}
+	selector := builder.Select(t1.Columns(columns...)...).From(t1)
+	if vq.sql != nil {
+		selector = vq.sql
+		selector.Select(selector.Columns(columns...)...)
+	}
+	if vq.ctx.Unique != nil && *vq.ctx.Unique {
+		selector.Distinct()
+	}
+	for _, p := range vq.predicates {
+		p(selector)
+	}
+	for _, p := range vq.order {
+		p(selector)
+	}
+	if offset := vq.ctx.Offset; offset != nil {
+		// limit is mandatory for offset clause. We start
+		// with default value, and override it below if needed.
+		selector.Offset(*offset).Limit(math.MaxInt32)
+	}
+	if limit := vq.ctx.Limit; limit != nil {
+		selector.Limit(*limit)
+	}
+	return selector
+}
+
+// VehicleGroupBy is the group-by builder for Vehicle entities.
+type VehicleGroupBy struct {
+	selector
+	build *VehicleQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (vgb *VehicleGroupBy) Aggregate(fns ...AggregateFunc) *VehicleGroupBy {
+	vgb.fns = append(vgb.fns, fns...)
+	return vgb
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (vgb *VehicleGroupBy) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, vgb.build.ctx, "GroupBy")
+	if err := vgb.build.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*VehicleQuery, *VehicleGroupBy](ctx, vgb.build, vgb, vgb.build.inters, v)
+}
+
+func (vgb *VehicleGroupBy) sqlScan(ctx context.Context, root *VehicleQuery, v any) error {
+	selector := root.sqlQuery(ctx).Select()
+	aggregation := make([]string, 0, len(vgb.fns))
+	for _, fn := range vgb.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*vgb.flds)+len(vgb.fns))
+		for _, f := range *vgb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*vgb.flds...)...)
+	if err := selector.Err(); err != nil {
+		return err
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := vgb.build.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
+
+// VehicleSelect is the builder for selecting fields of Vehicle entities.
+type VehicleSelect struct {
+	*VehicleQuery
+	selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (vs *VehicleSelect) Aggregate(fns ...AggregateFunc) *VehicleSelect {
+	vs.fns = append(vs.fns, fns...)
+	return vs
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (vs *VehicleSelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, vs.ctx, "Select")
+	if err := vs.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*VehicleQuery, *VehicleSelect](ctx, vs.VehicleQuery, vs, vs.inters, v)
+}
+
+func (vs *VehicleSelect) sqlScan(ctx context.Context, root *VehicleQuery, v any) error {
+	selector := root.sqlQuery(ctx)
+	aggregation := make([]string, 0, len(vs.fns))
+	for _, fn := range vs.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	switch n := len(*vs.selector.flds); {
+	case n == 0 && len(aggregation) > 0:
+		selector.Select(aggregation...)
+	case n != 0 && len(aggregation) > 0:
+		selector.AppendSelect(aggregation...)
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := vs.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
diff --git a/internal/database/ent/db/vehicle_update.go b/internal/database/ent/db/vehicle_update.go
new file mode 100644
index 00000000..0459f716
--- /dev/null
+++ b/internal/database/ent/db/vehicle_update.go
@@ -0,0 +1,329 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/ent/db/vehicle"
+)
+
+// VehicleUpdate is the builder for updating Vehicle entities.
+type VehicleUpdate struct {
+	config
+	hooks    []Hook
+	mutation *VehicleMutation
+}
+
+// Where appends a list predicates to the VehicleUpdate builder.
+func (vu *VehicleUpdate) Where(ps ...predicate.Vehicle) *VehicleUpdate {
+	vu.mutation.Where(ps...)
+	return vu
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (vu *VehicleUpdate) SetUpdatedAt(i int) *VehicleUpdate {
+	vu.mutation.ResetUpdatedAt()
+	vu.mutation.SetUpdatedAt(i)
+	return vu
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (vu *VehicleUpdate) AddUpdatedAt(i int) *VehicleUpdate {
+	vu.mutation.AddUpdatedAt(i)
+	return vu
+}
+
+// SetTier sets the "tier" field.
+func (vu *VehicleUpdate) SetTier(i int) *VehicleUpdate {
+	vu.mutation.ResetTier()
+	vu.mutation.SetTier(i)
+	return vu
+}
+
+// SetNillableTier sets the "tier" field if the given value is not nil.
+func (vu *VehicleUpdate) SetNillableTier(i *int) *VehicleUpdate {
+	if i != nil {
+		vu.SetTier(*i)
+	}
+	return vu
+}
+
+// AddTier adds i to the "tier" field.
+func (vu *VehicleUpdate) AddTier(i int) *VehicleUpdate {
+	vu.mutation.AddTier(i)
+	return vu
+}
+
+// SetLocalizedNames sets the "localized_names" field.
+func (vu *VehicleUpdate) SetLocalizedNames(m map[string]string) *VehicleUpdate {
+	vu.mutation.SetLocalizedNames(m)
+	return vu
+}
+
+// Mutation returns the VehicleMutation object of the builder.
+func (vu *VehicleUpdate) Mutation() *VehicleMutation {
+	return vu.mutation
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (vu *VehicleUpdate) Save(ctx context.Context) (int, error) {
+	vu.defaults()
+	return withHooks(ctx, vu.sqlSave, vu.mutation, vu.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (vu *VehicleUpdate) SaveX(ctx context.Context) int {
+	affected, err := vu.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return affected
+}
+
+// Exec executes the query.
+func (vu *VehicleUpdate) Exec(ctx context.Context) error {
+	_, err := vu.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (vu *VehicleUpdate) ExecX(ctx context.Context) {
+	if err := vu.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (vu *VehicleUpdate) defaults() {
+	if _, ok := vu.mutation.UpdatedAt(); !ok {
+		v := vehicle.UpdateDefaultUpdatedAt()
+		vu.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (vu *VehicleUpdate) check() error {
+	if v, ok := vu.mutation.Tier(); ok {
+		if err := vehicle.TierValidator(v); err != nil {
+			return &ValidationError{Name: "tier", err: fmt.Errorf(`db: validator failed for field "Vehicle.tier": %w`, err)}
+		}
+	}
+	return nil
+}
+
+func (vu *VehicleUpdate) sqlSave(ctx context.Context) (n int, err error) {
+	if err := vu.check(); err != nil {
+		return n, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(vehicle.Table, vehicle.Columns, sqlgraph.NewFieldSpec(vehicle.FieldID, field.TypeString))
+	if ps := vu.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := vu.mutation.UpdatedAt(); ok {
+		_spec.SetField(vehicle.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := vu.mutation.AddedUpdatedAt(); ok {
+		_spec.AddField(vehicle.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := vu.mutation.Tier(); ok {
+		_spec.SetField(vehicle.FieldTier, field.TypeInt, value)
+	}
+	if value, ok := vu.mutation.AddedTier(); ok {
+		_spec.AddField(vehicle.FieldTier, field.TypeInt, value)
+	}
+	if value, ok := vu.mutation.LocalizedNames(); ok {
+		_spec.SetField(vehicle.FieldLocalizedNames, field.TypeJSON, value)
+	}
+	if n, err = sqlgraph.UpdateNodes(ctx, vu.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{vehicle.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return 0, err
+	}
+	vu.mutation.done = true
+	return n, nil
+}
+
+// VehicleUpdateOne is the builder for updating a single Vehicle entity.
+type VehicleUpdateOne struct {
+	config
+	fields   []string
+	hooks    []Hook
+	mutation *VehicleMutation
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (vuo *VehicleUpdateOne) SetUpdatedAt(i int) *VehicleUpdateOne {
+	vuo.mutation.ResetUpdatedAt()
+	vuo.mutation.SetUpdatedAt(i)
+	return vuo
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (vuo *VehicleUpdateOne) AddUpdatedAt(i int) *VehicleUpdateOne {
+	vuo.mutation.AddUpdatedAt(i)
+	return vuo
+}
+
+// SetTier sets the "tier" field.
+func (vuo *VehicleUpdateOne) SetTier(i int) *VehicleUpdateOne {
+	vuo.mutation.ResetTier()
+	vuo.mutation.SetTier(i)
+	return vuo
+}
+
+// SetNillableTier sets the "tier" field if the given value is not nil.
+func (vuo *VehicleUpdateOne) SetNillableTier(i *int) *VehicleUpdateOne {
+	if i != nil {
+		vuo.SetTier(*i)
+	}
+	return vuo
+}
+
+// AddTier adds i to the "tier" field.
+func (vuo *VehicleUpdateOne) AddTier(i int) *VehicleUpdateOne {
+	vuo.mutation.AddTier(i)
+	return vuo
+}
+
+// SetLocalizedNames sets the "localized_names" field.
+func (vuo *VehicleUpdateOne) SetLocalizedNames(m map[string]string) *VehicleUpdateOne {
+	vuo.mutation.SetLocalizedNames(m)
+	return vuo
+}
+
+// Mutation returns the VehicleMutation object of the builder.
+func (vuo *VehicleUpdateOne) Mutation() *VehicleMutation {
+	return vuo.mutation
+}
+
+// Where appends a list predicates to the VehicleUpdate builder.
+func (vuo *VehicleUpdateOne) Where(ps ...predicate.Vehicle) *VehicleUpdateOne {
+	vuo.mutation.Where(ps...)
+	return vuo
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (vuo *VehicleUpdateOne) Select(field string, fields ...string) *VehicleUpdateOne {
+	vuo.fields = append([]string{field}, fields...)
+	return vuo
+}
+
+// Save executes the query and returns the updated Vehicle entity.
+func (vuo *VehicleUpdateOne) Save(ctx context.Context) (*Vehicle, error) {
+	vuo.defaults()
+	return withHooks(ctx, vuo.sqlSave, vuo.mutation, vuo.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (vuo *VehicleUpdateOne) SaveX(ctx context.Context) *Vehicle {
+	node, err := vuo.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// Exec executes the query on the entity.
+func (vuo *VehicleUpdateOne) Exec(ctx context.Context) error {
+	_, err := vuo.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (vuo *VehicleUpdateOne) ExecX(ctx context.Context) {
+	if err := vuo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (vuo *VehicleUpdateOne) defaults() {
+	if _, ok := vuo.mutation.UpdatedAt(); !ok {
+		v := vehicle.UpdateDefaultUpdatedAt()
+		vuo.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (vuo *VehicleUpdateOne) check() error {
+	if v, ok := vuo.mutation.Tier(); ok {
+		if err := vehicle.TierValidator(v); err != nil {
+			return &ValidationError{Name: "tier", err: fmt.Errorf(`db: validator failed for field "Vehicle.tier": %w`, err)}
+		}
+	}
+	return nil
+}
+
+func (vuo *VehicleUpdateOne) sqlSave(ctx context.Context) (_node *Vehicle, err error) {
+	if err := vuo.check(); err != nil {
+		return _node, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(vehicle.Table, vehicle.Columns, sqlgraph.NewFieldSpec(vehicle.FieldID, field.TypeString))
+	id, ok := vuo.mutation.ID()
+	if !ok {
+		return nil, &ValidationError{Name: "id", err: errors.New(`db: missing "Vehicle.id" for update`)}
+	}
+	_spec.Node.ID.Value = id
+	if fields := vuo.fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, vehicle.FieldID)
+		for _, f := range fields {
+			if !vehicle.ValidColumn(f) {
+				return nil, &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+			}
+			if f != vehicle.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, f)
+			}
+		}
+	}
+	if ps := vuo.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := vuo.mutation.UpdatedAt(); ok {
+		_spec.SetField(vehicle.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := vuo.mutation.AddedUpdatedAt(); ok {
+		_spec.AddField(vehicle.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := vuo.mutation.Tier(); ok {
+		_spec.SetField(vehicle.FieldTier, field.TypeInt, value)
+	}
+	if value, ok := vuo.mutation.AddedTier(); ok {
+		_spec.AddField(vehicle.FieldTier, field.TypeInt, value)
+	}
+	if value, ok := vuo.mutation.LocalizedNames(); ok {
+		_spec.SetField(vehicle.FieldLocalizedNames, field.TypeJSON, value)
+	}
+	_node = &Vehicle{config: vuo.config}
+	_spec.Assign = _node.assignValues
+	_spec.ScanValues = _node.scanValues
+	if err = sqlgraph.UpdateNode(ctx, vuo.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{vehicle.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	vuo.mutation.done = true
+	return _node, nil
+}
diff --git a/internal/database/ent/db/vehicleaverage.go b/internal/database/ent/db/vehicleaverage.go
new file mode 100644
index 00000000..8b300a7e
--- /dev/null
+++ b/internal/database/ent/db/vehicleaverage.go
@@ -0,0 +1,131 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+	"github.com/cufee/aftermath/internal/database/ent/db/vehicleaverage"
+	"github.com/cufee/aftermath/internal/stats/frame"
+)
+
+// VehicleAverage is the model entity for the VehicleAverage schema.
+type VehicleAverage struct {
+	config `json:"-"`
+	// ID of the ent.
+	ID string `json:"id,omitempty"`
+	// CreatedAt holds the value of the "created_at" field.
+	CreatedAt int `json:"created_at,omitempty"`
+	// UpdatedAt holds the value of the "updated_at" field.
+	UpdatedAt int `json:"updated_at,omitempty"`
+	// Data holds the value of the "data" field.
+	Data         map[string]frame.StatsFrame `json:"data,omitempty"`
+	selectValues sql.SelectValues
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*VehicleAverage) scanValues(columns []string) ([]any, error) {
+	values := make([]any, len(columns))
+	for i := range columns {
+		switch columns[i] {
+		case vehicleaverage.FieldData:
+			values[i] = new([]byte)
+		case vehicleaverage.FieldCreatedAt, vehicleaverage.FieldUpdatedAt:
+			values[i] = new(sql.NullInt64)
+		case vehicleaverage.FieldID:
+			values[i] = new(sql.NullString)
+		default:
+			values[i] = new(sql.UnknownType)
+		}
+	}
+	return values, nil
+}
+
+// assignValues assigns the values that were returned from sql.Rows (after scanning)
+// to the VehicleAverage fields.
+func (va *VehicleAverage) assignValues(columns []string, values []any) error {
+	if m, n := len(values), len(columns); m < n {
+		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
+	}
+	for i := range columns {
+		switch columns[i] {
+		case vehicleaverage.FieldID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field id", values[i])
+			} else if value.Valid {
+				va.ID = value.String
+			}
+		case vehicleaverage.FieldCreatedAt:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field created_at", values[i])
+			} else if value.Valid {
+				va.CreatedAt = int(value.Int64)
+			}
+		case vehicleaverage.FieldUpdatedAt:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
+			} else if value.Valid {
+				va.UpdatedAt = int(value.Int64)
+			}
+		case vehicleaverage.FieldData:
+			if value, ok := values[i].(*[]byte); !ok {
+				return fmt.Errorf("unexpected type %T for field data", values[i])
+			} else if value != nil && len(*value) > 0 {
+				if err := json.Unmarshal(*value, &va.Data); err != nil {
+					return fmt.Errorf("unmarshal field data: %w", err)
+				}
+			}
+		default:
+			va.selectValues.Set(columns[i], values[i])
+		}
+	}
+	return nil
+}
+
+// Value returns the ent.Value that was dynamically selected and assigned to the VehicleAverage.
+// This includes values selected through modifiers, order, etc.
+func (va *VehicleAverage) Value(name string) (ent.Value, error) {
+	return va.selectValues.Get(name)
+}
+
+// Update returns a builder for updating this VehicleAverage.
+// Note that you need to call VehicleAverage.Unwrap() before calling this method if this VehicleAverage
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (va *VehicleAverage) Update() *VehicleAverageUpdateOne {
+	return NewVehicleAverageClient(va.config).UpdateOne(va)
+}
+
+// Unwrap unwraps the VehicleAverage entity that was returned from a transaction after it was closed,
+// so that all future queries will be executed through the driver which created the transaction.
+func (va *VehicleAverage) Unwrap() *VehicleAverage {
+	_tx, ok := va.config.driver.(*txDriver)
+	if !ok {
+		panic("db: VehicleAverage is not a transactional entity")
+	}
+	va.config.driver = _tx.drv
+	return va
+}
+
+// String implements the fmt.Stringer.
+func (va *VehicleAverage) String() string {
+	var builder strings.Builder
+	builder.WriteString("VehicleAverage(")
+	builder.WriteString(fmt.Sprintf("id=%v, ", va.ID))
+	builder.WriteString("created_at=")
+	builder.WriteString(fmt.Sprintf("%v", va.CreatedAt))
+	builder.WriteString(", ")
+	builder.WriteString("updated_at=")
+	builder.WriteString(fmt.Sprintf("%v", va.UpdatedAt))
+	builder.WriteString(", ")
+	builder.WriteString("data=")
+	builder.WriteString(fmt.Sprintf("%v", va.Data))
+	builder.WriteByte(')')
+	return builder.String()
+}
+
+// VehicleAverages is a parsable slice of VehicleAverage.
+type VehicleAverages []*VehicleAverage
diff --git a/internal/database/ent/db/vehicleaverage/vehicleaverage.go b/internal/database/ent/db/vehicleaverage/vehicleaverage.go
new file mode 100644
index 00000000..4b90c1bc
--- /dev/null
+++ b/internal/database/ent/db/vehicleaverage/vehicleaverage.go
@@ -0,0 +1,67 @@
+// Code generated by ent, DO NOT EDIT.
+
+package vehicleaverage
+
+import (
+	"entgo.io/ent/dialect/sql"
+)
+
+const (
+	// Label holds the string label denoting the vehicleaverage type in the database.
+	Label = "vehicle_average"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// FieldData holds the string denoting the data field in the database.
+	FieldData = "data"
+	// Table holds the table name of the vehicleaverage in the database.
+	Table = "vehicle_averages"
+)
+
+// Columns holds all SQL columns for vehicleaverage fields.
+var Columns = []string{
+	FieldID,
+	FieldCreatedAt,
+	FieldUpdatedAt,
+	FieldData,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() int
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() int
+	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
+	UpdateDefaultUpdatedAt func() int
+)
+
+// OrderOption defines the ordering options for the VehicleAverage queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
diff --git a/internal/database/ent/db/vehicleaverage/where.go b/internal/database/ent/db/vehicleaverage/where.go
new file mode 100644
index 00000000..08934c78
--- /dev/null
+++ b/internal/database/ent/db/vehicleaverage/where.go
@@ -0,0 +1,168 @@
+// Code generated by ent, DO NOT EDIT.
+
+package vehicleaverage
+
+import (
+	"entgo.io/ent/dialect/sql"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id string) predicate.VehicleAverage {
+	return predicate.VehicleAverage(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id string) predicate.VehicleAverage {
+	return predicate.VehicleAverage(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id string) predicate.VehicleAverage {
+	return predicate.VehicleAverage(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...string) predicate.VehicleAverage {
+	return predicate.VehicleAverage(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...string) predicate.VehicleAverage {
+	return predicate.VehicleAverage(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id string) predicate.VehicleAverage {
+	return predicate.VehicleAverage(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id string) predicate.VehicleAverage {
+	return predicate.VehicleAverage(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id string) predicate.VehicleAverage {
+	return predicate.VehicleAverage(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id string) predicate.VehicleAverage {
+	return predicate.VehicleAverage(sql.FieldLTE(FieldID, id))
+}
+
+// IDEqualFold applies the EqualFold predicate on the ID field.
+func IDEqualFold(id string) predicate.VehicleAverage {
+	return predicate.VehicleAverage(sql.FieldEqualFold(FieldID, id))
+}
+
+// IDContainsFold applies the ContainsFold predicate on the ID field.
+func IDContainsFold(id string) predicate.VehicleAverage {
+	return predicate.VehicleAverage(sql.FieldContainsFold(FieldID, id))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v int) predicate.VehicleAverage {
+	return predicate.VehicleAverage(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v int) predicate.VehicleAverage {
+	return predicate.VehicleAverage(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v int) predicate.VehicleAverage {
+	return predicate.VehicleAverage(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v int) predicate.VehicleAverage {
+	return predicate.VehicleAverage(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...int) predicate.VehicleAverage {
+	return predicate.VehicleAverage(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...int) predicate.VehicleAverage {
+	return predicate.VehicleAverage(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v int) predicate.VehicleAverage {
+	return predicate.VehicleAverage(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v int) predicate.VehicleAverage {
+	return predicate.VehicleAverage(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v int) predicate.VehicleAverage {
+	return predicate.VehicleAverage(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v int) predicate.VehicleAverage {
+	return predicate.VehicleAverage(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v int) predicate.VehicleAverage {
+	return predicate.VehicleAverage(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v int) predicate.VehicleAverage {
+	return predicate.VehicleAverage(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...int) predicate.VehicleAverage {
+	return predicate.VehicleAverage(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...int) predicate.VehicleAverage {
+	return predicate.VehicleAverage(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v int) predicate.VehicleAverage {
+	return predicate.VehicleAverage(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v int) predicate.VehicleAverage {
+	return predicate.VehicleAverage(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v int) predicate.VehicleAverage {
+	return predicate.VehicleAverage(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v int) predicate.VehicleAverage {
+	return predicate.VehicleAverage(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.VehicleAverage) predicate.VehicleAverage {
+	return predicate.VehicleAverage(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.VehicleAverage) predicate.VehicleAverage {
+	return predicate.VehicleAverage(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.VehicleAverage) predicate.VehicleAverage {
+	return predicate.VehicleAverage(sql.NotPredicates(p))
+}
diff --git a/internal/database/ent/db/vehicleaverage_create.go b/internal/database/ent/db/vehicleaverage_create.go
new file mode 100644
index 00000000..01704d15
--- /dev/null
+++ b/internal/database/ent/db/vehicleaverage_create.go
@@ -0,0 +1,251 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/vehicleaverage"
+	"github.com/cufee/aftermath/internal/stats/frame"
+)
+
+// VehicleAverageCreate is the builder for creating a VehicleAverage entity.
+type VehicleAverageCreate struct {
+	config
+	mutation *VehicleAverageMutation
+	hooks    []Hook
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (vac *VehicleAverageCreate) SetCreatedAt(i int) *VehicleAverageCreate {
+	vac.mutation.SetCreatedAt(i)
+	return vac
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (vac *VehicleAverageCreate) SetNillableCreatedAt(i *int) *VehicleAverageCreate {
+	if i != nil {
+		vac.SetCreatedAt(*i)
+	}
+	return vac
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (vac *VehicleAverageCreate) SetUpdatedAt(i int) *VehicleAverageCreate {
+	vac.mutation.SetUpdatedAt(i)
+	return vac
+}
+
+// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
+func (vac *VehicleAverageCreate) SetNillableUpdatedAt(i *int) *VehicleAverageCreate {
+	if i != nil {
+		vac.SetUpdatedAt(*i)
+	}
+	return vac
+}
+
+// SetData sets the "data" field.
+func (vac *VehicleAverageCreate) SetData(mf map[string]frame.StatsFrame) *VehicleAverageCreate {
+	vac.mutation.SetData(mf)
+	return vac
+}
+
+// SetID sets the "id" field.
+func (vac *VehicleAverageCreate) SetID(s string) *VehicleAverageCreate {
+	vac.mutation.SetID(s)
+	return vac
+}
+
+// Mutation returns the VehicleAverageMutation object of the builder.
+func (vac *VehicleAverageCreate) Mutation() *VehicleAverageMutation {
+	return vac.mutation
+}
+
+// Save creates the VehicleAverage in the database.
+func (vac *VehicleAverageCreate) Save(ctx context.Context) (*VehicleAverage, error) {
+	vac.defaults()
+	return withHooks(ctx, vac.sqlSave, vac.mutation, vac.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (vac *VehicleAverageCreate) SaveX(ctx context.Context) *VehicleAverage {
+	v, err := vac.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (vac *VehicleAverageCreate) Exec(ctx context.Context) error {
+	_, err := vac.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (vac *VehicleAverageCreate) ExecX(ctx context.Context) {
+	if err := vac.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (vac *VehicleAverageCreate) defaults() {
+	if _, ok := vac.mutation.CreatedAt(); !ok {
+		v := vehicleaverage.DefaultCreatedAt()
+		vac.mutation.SetCreatedAt(v)
+	}
+	if _, ok := vac.mutation.UpdatedAt(); !ok {
+		v := vehicleaverage.DefaultUpdatedAt()
+		vac.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (vac *VehicleAverageCreate) check() error {
+	if _, ok := vac.mutation.CreatedAt(); !ok {
+		return &ValidationError{Name: "created_at", err: errors.New(`db: missing required field "VehicleAverage.created_at"`)}
+	}
+	if _, ok := vac.mutation.UpdatedAt(); !ok {
+		return &ValidationError{Name: "updated_at", err: errors.New(`db: missing required field "VehicleAverage.updated_at"`)}
+	}
+	if _, ok := vac.mutation.Data(); !ok {
+		return &ValidationError{Name: "data", err: errors.New(`db: missing required field "VehicleAverage.data"`)}
+	}
+	return nil
+}
+
+func (vac *VehicleAverageCreate) sqlSave(ctx context.Context) (*VehicleAverage, error) {
+	if err := vac.check(); err != nil {
+		return nil, err
+	}
+	_node, _spec := vac.createSpec()
+	if err := sqlgraph.CreateNode(ctx, vac.driver, _spec); err != nil {
+		if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	if _spec.ID.Value != nil {
+		if id, ok := _spec.ID.Value.(string); ok {
+			_node.ID = id
+		} else {
+			return nil, fmt.Errorf("unexpected VehicleAverage.ID type: %T", _spec.ID.Value)
+		}
+	}
+	vac.mutation.id = &_node.ID
+	vac.mutation.done = true
+	return _node, nil
+}
+
+func (vac *VehicleAverageCreate) createSpec() (*VehicleAverage, *sqlgraph.CreateSpec) {
+	var (
+		_node = &VehicleAverage{config: vac.config}
+		_spec = sqlgraph.NewCreateSpec(vehicleaverage.Table, sqlgraph.NewFieldSpec(vehicleaverage.FieldID, field.TypeString))
+	)
+	if id, ok := vac.mutation.ID(); ok {
+		_node.ID = id
+		_spec.ID.Value = id
+	}
+	if value, ok := vac.mutation.CreatedAt(); ok {
+		_spec.SetField(vehicleaverage.FieldCreatedAt, field.TypeInt, value)
+		_node.CreatedAt = value
+	}
+	if value, ok := vac.mutation.UpdatedAt(); ok {
+		_spec.SetField(vehicleaverage.FieldUpdatedAt, field.TypeInt, value)
+		_node.UpdatedAt = value
+	}
+	if value, ok := vac.mutation.Data(); ok {
+		_spec.SetField(vehicleaverage.FieldData, field.TypeJSON, value)
+		_node.Data = value
+	}
+	return _node, _spec
+}
+
+// VehicleAverageCreateBulk is the builder for creating many VehicleAverage entities in bulk.
+type VehicleAverageCreateBulk struct {
+	config
+	err      error
+	builders []*VehicleAverageCreate
+}
+
+// Save creates the VehicleAverage entities in the database.
+func (vacb *VehicleAverageCreateBulk) Save(ctx context.Context) ([]*VehicleAverage, error) {
+	if vacb.err != nil {
+		return nil, vacb.err
+	}
+	specs := make([]*sqlgraph.CreateSpec, len(vacb.builders))
+	nodes := make([]*VehicleAverage, len(vacb.builders))
+	mutators := make([]Mutator, len(vacb.builders))
+	for i := range vacb.builders {
+		func(i int, root context.Context) {
+			builder := vacb.builders[i]
+			builder.defaults()
+			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+				mutation, ok := m.(*VehicleAverageMutation)
+				if !ok {
+					return nil, fmt.Errorf("unexpected mutation type %T", m)
+				}
+				if err := builder.check(); err != nil {
+					return nil, err
+				}
+				builder.mutation = mutation
+				var err error
+				nodes[i], specs[i] = builder.createSpec()
+				if i < len(mutators)-1 {
+					_, err = mutators[i+1].Mutate(root, vacb.builders[i+1].mutation)
+				} else {
+					spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
+					// Invoke the actual operation on the latest mutation in the chain.
+					if err = sqlgraph.BatchCreate(ctx, vacb.driver, spec); err != nil {
+						if sqlgraph.IsConstraintError(err) {
+							err = &ConstraintError{msg: err.Error(), wrap: err}
+						}
+					}
+				}
+				if err != nil {
+					return nil, err
+				}
+				mutation.id = &nodes[i].ID
+				mutation.done = true
+				return nodes[i], nil
+			})
+			for i := len(builder.hooks) - 1; i >= 0; i-- {
+				mut = builder.hooks[i](mut)
+			}
+			mutators[i] = mut
+		}(i, ctx)
+	}
+	if len(mutators) > 0 {
+		if _, err := mutators[0].Mutate(ctx, vacb.builders[0].mutation); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (vacb *VehicleAverageCreateBulk) SaveX(ctx context.Context) []*VehicleAverage {
+	v, err := vacb.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (vacb *VehicleAverageCreateBulk) Exec(ctx context.Context) error {
+	_, err := vacb.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (vacb *VehicleAverageCreateBulk) ExecX(ctx context.Context) {
+	if err := vacb.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/database/ent/db/vehicleaverage_delete.go b/internal/database/ent/db/vehicleaverage_delete.go
new file mode 100644
index 00000000..59f4953c
--- /dev/null
+++ b/internal/database/ent/db/vehicleaverage_delete.go
@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/ent/db/vehicleaverage"
+)
+
+// VehicleAverageDelete is the builder for deleting a VehicleAverage entity.
+type VehicleAverageDelete struct {
+	config
+	hooks    []Hook
+	mutation *VehicleAverageMutation
+}
+
+// Where appends a list predicates to the VehicleAverageDelete builder.
+func (vad *VehicleAverageDelete) Where(ps ...predicate.VehicleAverage) *VehicleAverageDelete {
+	vad.mutation.Where(ps...)
+	return vad
+}
+
+// Exec executes the deletion query and returns how many vertices were deleted.
+func (vad *VehicleAverageDelete) Exec(ctx context.Context) (int, error) {
+	return withHooks(ctx, vad.sqlExec, vad.mutation, vad.hooks)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (vad *VehicleAverageDelete) ExecX(ctx context.Context) int {
+	n, err := vad.Exec(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return n
+}
+
+func (vad *VehicleAverageDelete) sqlExec(ctx context.Context) (int, error) {
+	_spec := sqlgraph.NewDeleteSpec(vehicleaverage.Table, sqlgraph.NewFieldSpec(vehicleaverage.FieldID, field.TypeString))
+	if ps := vad.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	affected, err := sqlgraph.DeleteNodes(ctx, vad.driver, _spec)
+	if err != nil && sqlgraph.IsConstraintError(err) {
+		err = &ConstraintError{msg: err.Error(), wrap: err}
+	}
+	vad.mutation.done = true
+	return affected, err
+}
+
+// VehicleAverageDeleteOne is the builder for deleting a single VehicleAverage entity.
+type VehicleAverageDeleteOne struct {
+	vad *VehicleAverageDelete
+}
+
+// Where appends a list predicates to the VehicleAverageDelete builder.
+func (vado *VehicleAverageDeleteOne) Where(ps ...predicate.VehicleAverage) *VehicleAverageDeleteOne {
+	vado.vad.mutation.Where(ps...)
+	return vado
+}
+
+// Exec executes the deletion query.
+func (vado *VehicleAverageDeleteOne) Exec(ctx context.Context) error {
+	n, err := vado.vad.Exec(ctx)
+	switch {
+	case err != nil:
+		return err
+	case n == 0:
+		return &NotFoundError{vehicleaverage.Label}
+	default:
+		return nil
+	}
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (vado *VehicleAverageDeleteOne) ExecX(ctx context.Context) {
+	if err := vado.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/database/ent/db/vehicleaverage_query.go b/internal/database/ent/db/vehicleaverage_query.go
new file mode 100644
index 00000000..67b533b4
--- /dev/null
+++ b/internal/database/ent/db/vehicleaverage_query.go
@@ -0,0 +1,526 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"fmt"
+	"math"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/ent/db/vehicleaverage"
+)
+
+// VehicleAverageQuery is the builder for querying VehicleAverage entities.
+type VehicleAverageQuery struct {
+	config
+	ctx        *QueryContext
+	order      []vehicleaverage.OrderOption
+	inters     []Interceptor
+	predicates []predicate.VehicleAverage
+	// intermediate query (i.e. traversal path).
+	sql  *sql.Selector
+	path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the VehicleAverageQuery builder.
+func (vaq *VehicleAverageQuery) Where(ps ...predicate.VehicleAverage) *VehicleAverageQuery {
+	vaq.predicates = append(vaq.predicates, ps...)
+	return vaq
+}
+
+// Limit the number of records to be returned by this query.
+func (vaq *VehicleAverageQuery) Limit(limit int) *VehicleAverageQuery {
+	vaq.ctx.Limit = &limit
+	return vaq
+}
+
+// Offset to start from.
+func (vaq *VehicleAverageQuery) Offset(offset int) *VehicleAverageQuery {
+	vaq.ctx.Offset = &offset
+	return vaq
+}
+
+// Unique configures the query builder to filter duplicate records on query.
+// By default, unique is set to true, and can be disabled using this method.
+func (vaq *VehicleAverageQuery) Unique(unique bool) *VehicleAverageQuery {
+	vaq.ctx.Unique = &unique
+	return vaq
+}
+
+// Order specifies how the records should be ordered.
+func (vaq *VehicleAverageQuery) Order(o ...vehicleaverage.OrderOption) *VehicleAverageQuery {
+	vaq.order = append(vaq.order, o...)
+	return vaq
+}
+
+// First returns the first VehicleAverage entity from the query.
+// Returns a *NotFoundError when no VehicleAverage was found.
+func (vaq *VehicleAverageQuery) First(ctx context.Context) (*VehicleAverage, error) {
+	nodes, err := vaq.Limit(1).All(setContextOp(ctx, vaq.ctx, "First"))
+	if err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nil, &NotFoundError{vehicleaverage.Label}
+	}
+	return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (vaq *VehicleAverageQuery) FirstX(ctx context.Context) *VehicleAverage {
+	node, err := vaq.First(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return node
+}
+
+// FirstID returns the first VehicleAverage ID from the query.
+// Returns a *NotFoundError when no VehicleAverage ID was found.
+func (vaq *VehicleAverageQuery) FirstID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = vaq.Limit(1).IDs(setContextOp(ctx, vaq.ctx, "FirstID")); err != nil {
+		return
+	}
+	if len(ids) == 0 {
+		err = &NotFoundError{vehicleaverage.Label}
+		return
+	}
+	return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (vaq *VehicleAverageQuery) FirstIDX(ctx context.Context) string {
+	id, err := vaq.FirstID(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return id
+}
+
+// Only returns a single VehicleAverage entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one VehicleAverage entity is found.
+// Returns a *NotFoundError when no VehicleAverage entities are found.
+func (vaq *VehicleAverageQuery) Only(ctx context.Context) (*VehicleAverage, error) {
+	nodes, err := vaq.Limit(2).All(setContextOp(ctx, vaq.ctx, "Only"))
+	if err != nil {
+		return nil, err
+	}
+	switch len(nodes) {
+	case 1:
+		return nodes[0], nil
+	case 0:
+		return nil, &NotFoundError{vehicleaverage.Label}
+	default:
+		return nil, &NotSingularError{vehicleaverage.Label}
+	}
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (vaq *VehicleAverageQuery) OnlyX(ctx context.Context) *VehicleAverage {
+	node, err := vaq.Only(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// OnlyID is like Only, but returns the only VehicleAverage ID in the query.
+// Returns a *NotSingularError when more than one VehicleAverage ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (vaq *VehicleAverageQuery) OnlyID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = vaq.Limit(2).IDs(setContextOp(ctx, vaq.ctx, "OnlyID")); err != nil {
+		return
+	}
+	switch len(ids) {
+	case 1:
+		id = ids[0]
+	case 0:
+		err = &NotFoundError{vehicleaverage.Label}
+	default:
+		err = &NotSingularError{vehicleaverage.Label}
+	}
+	return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (vaq *VehicleAverageQuery) OnlyIDX(ctx context.Context) string {
+	id, err := vaq.OnlyID(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return id
+}
+
+// All executes the query and returns a list of VehicleAverages.
+func (vaq *VehicleAverageQuery) All(ctx context.Context) ([]*VehicleAverage, error) {
+	ctx = setContextOp(ctx, vaq.ctx, "All")
+	if err := vaq.prepareQuery(ctx); err != nil {
+		return nil, err
+	}
+	qr := querierAll[[]*VehicleAverage, *VehicleAverageQuery]()
+	return withInterceptors[[]*VehicleAverage](ctx, vaq, qr, vaq.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (vaq *VehicleAverageQuery) AllX(ctx context.Context) []*VehicleAverage {
+	nodes, err := vaq.All(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return nodes
+}
+
+// IDs executes the query and returns a list of VehicleAverage IDs.
+func (vaq *VehicleAverageQuery) IDs(ctx context.Context) (ids []string, err error) {
+	if vaq.ctx.Unique == nil && vaq.path != nil {
+		vaq.Unique(true)
+	}
+	ctx = setContextOp(ctx, vaq.ctx, "IDs")
+	if err = vaq.Select(vehicleaverage.FieldID).Scan(ctx, &ids); err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (vaq *VehicleAverageQuery) IDsX(ctx context.Context) []string {
+	ids, err := vaq.IDs(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return ids
+}
+
+// Count returns the count of the given query.
+func (vaq *VehicleAverageQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, vaq.ctx, "Count")
+	if err := vaq.prepareQuery(ctx); err != nil {
+		return 0, err
+	}
+	return withInterceptors[int](ctx, vaq, querierCount[*VehicleAverageQuery](), vaq.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (vaq *VehicleAverageQuery) CountX(ctx context.Context) int {
+	count, err := vaq.Count(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (vaq *VehicleAverageQuery) Exist(ctx context.Context) (bool, error) {
+	ctx = setContextOp(ctx, vaq.ctx, "Exist")
+	switch _, err := vaq.FirstID(ctx); {
+	case IsNotFound(err):
+		return false, nil
+	case err != nil:
+		return false, fmt.Errorf("db: check existence: %w", err)
+	default:
+		return true, nil
+	}
+}
+
+// ExistX is like Exist, but panics if an error occurs.
+func (vaq *VehicleAverageQuery) ExistX(ctx context.Context) bool {
+	exist, err := vaq.Exist(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return exist
+}
+
+// Clone returns a duplicate of the VehicleAverageQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (vaq *VehicleAverageQuery) Clone() *VehicleAverageQuery {
+	if vaq == nil {
+		return nil
+	}
+	return &VehicleAverageQuery{
+		config:     vaq.config,
+		ctx:        vaq.ctx.Clone(),
+		order:      append([]vehicleaverage.OrderOption{}, vaq.order...),
+		inters:     append([]Interceptor{}, vaq.inters...),
+		predicates: append([]predicate.VehicleAverage{}, vaq.predicates...),
+		// clone intermediate query.
+		sql:  vaq.sql.Clone(),
+		path: vaq.path,
+	}
+}
+
+// GroupBy is used to group vertices by one or more fields/columns.
+// It is often used with aggregate functions, like: count, max, mean, min, sum.
+//
+// Example:
+//
+//	var v []struct {
+//		CreatedAt int `json:"created_at,omitempty"`
+//		Count int `json:"count,omitempty"`
+//	}
+//
+//	client.VehicleAverage.Query().
+//		GroupBy(vehicleaverage.FieldCreatedAt).
+//		Aggregate(db.Count()).
+//		Scan(ctx, &v)
+func (vaq *VehicleAverageQuery) GroupBy(field string, fields ...string) *VehicleAverageGroupBy {
+	vaq.ctx.Fields = append([]string{field}, fields...)
+	grbuild := &VehicleAverageGroupBy{build: vaq}
+	grbuild.flds = &vaq.ctx.Fields
+	grbuild.label = vehicleaverage.Label
+	grbuild.scan = grbuild.Scan
+	return grbuild
+}
+
+// Select allows the selection one or more fields/columns for the given query,
+// instead of selecting all fields in the entity.
+//
+// Example:
+//
+//	var v []struct {
+//		CreatedAt int `json:"created_at,omitempty"`
+//	}
+//
+//	client.VehicleAverage.Query().
+//		Select(vehicleaverage.FieldCreatedAt).
+//		Scan(ctx, &v)
+func (vaq *VehicleAverageQuery) Select(fields ...string) *VehicleAverageSelect {
+	vaq.ctx.Fields = append(vaq.ctx.Fields, fields...)
+	sbuild := &VehicleAverageSelect{VehicleAverageQuery: vaq}
+	sbuild.label = vehicleaverage.Label
+	sbuild.flds, sbuild.scan = &vaq.ctx.Fields, sbuild.Scan
+	return sbuild
+}
+
+// Aggregate returns a VehicleAverageSelect configured with the given aggregations.
+func (vaq *VehicleAverageQuery) Aggregate(fns ...AggregateFunc) *VehicleAverageSelect {
+	return vaq.Select().Aggregate(fns...)
+}
+
+func (vaq *VehicleAverageQuery) prepareQuery(ctx context.Context) error {
+	for _, inter := range vaq.inters {
+		if inter == nil {
+			return fmt.Errorf("db: uninitialized interceptor (forgotten import db/runtime?)")
+		}
+		if trv, ok := inter.(Traverser); ok {
+			if err := trv.Traverse(ctx, vaq); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range vaq.ctx.Fields {
+		if !vehicleaverage.ValidColumn(f) {
+			return &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+		}
+	}
+	if vaq.path != nil {
+		prev, err := vaq.path(ctx)
+		if err != nil {
+			return err
+		}
+		vaq.sql = prev
+	}
+	return nil
+}
+
+func (vaq *VehicleAverageQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*VehicleAverage, error) {
+	var (
+		nodes = []*VehicleAverage{}
+		_spec = vaq.querySpec()
+	)
+	_spec.ScanValues = func(columns []string) ([]any, error) {
+		return (*VehicleAverage).scanValues(nil, columns)
+	}
+	_spec.Assign = func(columns []string, values []any) error {
+		node := &VehicleAverage{config: vaq.config}
+		nodes = append(nodes, node)
+		return node.assignValues(columns, values)
+	}
+	for i := range hooks {
+		hooks[i](ctx, _spec)
+	}
+	if err := sqlgraph.QueryNodes(ctx, vaq.driver, _spec); err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nodes, nil
+	}
+	return nodes, nil
+}
+
+func (vaq *VehicleAverageQuery) sqlCount(ctx context.Context) (int, error) {
+	_spec := vaq.querySpec()
+	_spec.Node.Columns = vaq.ctx.Fields
+	if len(vaq.ctx.Fields) > 0 {
+		_spec.Unique = vaq.ctx.Unique != nil && *vaq.ctx.Unique
+	}
+	return sqlgraph.CountNodes(ctx, vaq.driver, _spec)
+}
+
+func (vaq *VehicleAverageQuery) querySpec() *sqlgraph.QuerySpec {
+	_spec := sqlgraph.NewQuerySpec(vehicleaverage.Table, vehicleaverage.Columns, sqlgraph.NewFieldSpec(vehicleaverage.FieldID, field.TypeString))
+	_spec.From = vaq.sql
+	if unique := vaq.ctx.Unique; unique != nil {
+		_spec.Unique = *unique
+	} else if vaq.path != nil {
+		_spec.Unique = true
+	}
+	if fields := vaq.ctx.Fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, vehicleaverage.FieldID)
+		for i := range fields {
+			if fields[i] != vehicleaverage.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+			}
+		}
+	}
+	if ps := vaq.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if limit := vaq.ctx.Limit; limit != nil {
+		_spec.Limit = *limit
+	}
+	if offset := vaq.ctx.Offset; offset != nil {
+		_spec.Offset = *offset
+	}
+	if ps := vaq.order; len(ps) > 0 {
+		_spec.Order = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	return _spec
+}
+
+func (vaq *VehicleAverageQuery) sqlQuery(ctx context.Context) *sql.Selector {
+	builder := sql.Dialect(vaq.driver.Dialect())
+	t1 := builder.Table(vehicleaverage.Table)
+	columns := vaq.ctx.Fields
+	if len(columns) == 0 {
+		columns = vehicleaverage.Columns
+	}
+	selector := builder.Select(t1.Columns(columns...)...).From(t1)
+	if vaq.sql != nil {
+		selector = vaq.sql
+		selector.Select(selector.Columns(columns...)...)
+	}
+	if vaq.ctx.Unique != nil && *vaq.ctx.Unique {
+		selector.Distinct()
+	}
+	for _, p := range vaq.predicates {
+		p(selector)
+	}
+	for _, p := range vaq.order {
+		p(selector)
+	}
+	if offset := vaq.ctx.Offset; offset != nil {
+		// limit is mandatory for offset clause. We start
+		// with default value, and override it below if needed.
+		selector.Offset(*offset).Limit(math.MaxInt32)
+	}
+	if limit := vaq.ctx.Limit; limit != nil {
+		selector.Limit(*limit)
+	}
+	return selector
+}
+
+// VehicleAverageGroupBy is the group-by builder for VehicleAverage entities.
+type VehicleAverageGroupBy struct {
+	selector
+	build *VehicleAverageQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (vagb *VehicleAverageGroupBy) Aggregate(fns ...AggregateFunc) *VehicleAverageGroupBy {
+	vagb.fns = append(vagb.fns, fns...)
+	return vagb
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (vagb *VehicleAverageGroupBy) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, vagb.build.ctx, "GroupBy")
+	if err := vagb.build.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*VehicleAverageQuery, *VehicleAverageGroupBy](ctx, vagb.build, vagb, vagb.build.inters, v)
+}
+
+func (vagb *VehicleAverageGroupBy) sqlScan(ctx context.Context, root *VehicleAverageQuery, v any) error {
+	selector := root.sqlQuery(ctx).Select()
+	aggregation := make([]string, 0, len(vagb.fns))
+	for _, fn := range vagb.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*vagb.flds)+len(vagb.fns))
+		for _, f := range *vagb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*vagb.flds...)...)
+	if err := selector.Err(); err != nil {
+		return err
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := vagb.build.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
+
+// VehicleAverageSelect is the builder for selecting fields of VehicleAverage entities.
+type VehicleAverageSelect struct {
+	*VehicleAverageQuery
+	selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (vas *VehicleAverageSelect) Aggregate(fns ...AggregateFunc) *VehicleAverageSelect {
+	vas.fns = append(vas.fns, fns...)
+	return vas
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (vas *VehicleAverageSelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, vas.ctx, "Select")
+	if err := vas.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*VehicleAverageQuery, *VehicleAverageSelect](ctx, vas.VehicleAverageQuery, vas, vas.inters, v)
+}
+
+func (vas *VehicleAverageSelect) sqlScan(ctx context.Context, root *VehicleAverageQuery, v any) error {
+	selector := root.sqlQuery(ctx)
+	aggregation := make([]string, 0, len(vas.fns))
+	for _, fn := range vas.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	switch n := len(*vas.selector.flds); {
+	case n == 0 && len(aggregation) > 0:
+		selector.Select(aggregation...)
+	case n != 0 && len(aggregation) > 0:
+		selector.AppendSelect(aggregation...)
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := vas.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
diff --git a/internal/database/ent/db/vehicleaverage_update.go b/internal/database/ent/db/vehicleaverage_update.go
new file mode 100644
index 00000000..787df205
--- /dev/null
+++ b/internal/database/ent/db/vehicleaverage_update.go
@@ -0,0 +1,250 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/ent/db/vehicleaverage"
+	"github.com/cufee/aftermath/internal/stats/frame"
+)
+
+// VehicleAverageUpdate is the builder for updating VehicleAverage entities.
+type VehicleAverageUpdate struct {
+	config
+	hooks    []Hook
+	mutation *VehicleAverageMutation
+}
+
+// Where appends a list predicates to the VehicleAverageUpdate builder.
+func (vau *VehicleAverageUpdate) Where(ps ...predicate.VehicleAverage) *VehicleAverageUpdate {
+	vau.mutation.Where(ps...)
+	return vau
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (vau *VehicleAverageUpdate) SetUpdatedAt(i int) *VehicleAverageUpdate {
+	vau.mutation.ResetUpdatedAt()
+	vau.mutation.SetUpdatedAt(i)
+	return vau
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (vau *VehicleAverageUpdate) AddUpdatedAt(i int) *VehicleAverageUpdate {
+	vau.mutation.AddUpdatedAt(i)
+	return vau
+}
+
+// SetData sets the "data" field.
+func (vau *VehicleAverageUpdate) SetData(mf map[string]frame.StatsFrame) *VehicleAverageUpdate {
+	vau.mutation.SetData(mf)
+	return vau
+}
+
+// Mutation returns the VehicleAverageMutation object of the builder.
+func (vau *VehicleAverageUpdate) Mutation() *VehicleAverageMutation {
+	return vau.mutation
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (vau *VehicleAverageUpdate) Save(ctx context.Context) (int, error) {
+	vau.defaults()
+	return withHooks(ctx, vau.sqlSave, vau.mutation, vau.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (vau *VehicleAverageUpdate) SaveX(ctx context.Context) int {
+	affected, err := vau.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return affected
+}
+
+// Exec executes the query.
+func (vau *VehicleAverageUpdate) Exec(ctx context.Context) error {
+	_, err := vau.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (vau *VehicleAverageUpdate) ExecX(ctx context.Context) {
+	if err := vau.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (vau *VehicleAverageUpdate) defaults() {
+	if _, ok := vau.mutation.UpdatedAt(); !ok {
+		v := vehicleaverage.UpdateDefaultUpdatedAt()
+		vau.mutation.SetUpdatedAt(v)
+	}
+}
+
+func (vau *VehicleAverageUpdate) sqlSave(ctx context.Context) (n int, err error) {
+	_spec := sqlgraph.NewUpdateSpec(vehicleaverage.Table, vehicleaverage.Columns, sqlgraph.NewFieldSpec(vehicleaverage.FieldID, field.TypeString))
+	if ps := vau.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := vau.mutation.UpdatedAt(); ok {
+		_spec.SetField(vehicleaverage.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := vau.mutation.AddedUpdatedAt(); ok {
+		_spec.AddField(vehicleaverage.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := vau.mutation.Data(); ok {
+		_spec.SetField(vehicleaverage.FieldData, field.TypeJSON, value)
+	}
+	if n, err = sqlgraph.UpdateNodes(ctx, vau.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{vehicleaverage.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return 0, err
+	}
+	vau.mutation.done = true
+	return n, nil
+}
+
+// VehicleAverageUpdateOne is the builder for updating a single VehicleAverage entity.
+type VehicleAverageUpdateOne struct {
+	config
+	fields   []string
+	hooks    []Hook
+	mutation *VehicleAverageMutation
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (vauo *VehicleAverageUpdateOne) SetUpdatedAt(i int) *VehicleAverageUpdateOne {
+	vauo.mutation.ResetUpdatedAt()
+	vauo.mutation.SetUpdatedAt(i)
+	return vauo
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (vauo *VehicleAverageUpdateOne) AddUpdatedAt(i int) *VehicleAverageUpdateOne {
+	vauo.mutation.AddUpdatedAt(i)
+	return vauo
+}
+
+// SetData sets the "data" field.
+func (vauo *VehicleAverageUpdateOne) SetData(mf map[string]frame.StatsFrame) *VehicleAverageUpdateOne {
+	vauo.mutation.SetData(mf)
+	return vauo
+}
+
+// Mutation returns the VehicleAverageMutation object of the builder.
+func (vauo *VehicleAverageUpdateOne) Mutation() *VehicleAverageMutation {
+	return vauo.mutation
+}
+
+// Where appends a list predicates to the VehicleAverageUpdate builder.
+func (vauo *VehicleAverageUpdateOne) Where(ps ...predicate.VehicleAverage) *VehicleAverageUpdateOne {
+	vauo.mutation.Where(ps...)
+	return vauo
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (vauo *VehicleAverageUpdateOne) Select(field string, fields ...string) *VehicleAverageUpdateOne {
+	vauo.fields = append([]string{field}, fields...)
+	return vauo
+}
+
+// Save executes the query and returns the updated VehicleAverage entity.
+func (vauo *VehicleAverageUpdateOne) Save(ctx context.Context) (*VehicleAverage, error) {
+	vauo.defaults()
+	return withHooks(ctx, vauo.sqlSave, vauo.mutation, vauo.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (vauo *VehicleAverageUpdateOne) SaveX(ctx context.Context) *VehicleAverage {
+	node, err := vauo.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// Exec executes the query on the entity.
+func (vauo *VehicleAverageUpdateOne) Exec(ctx context.Context) error {
+	_, err := vauo.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (vauo *VehicleAverageUpdateOne) ExecX(ctx context.Context) {
+	if err := vauo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (vauo *VehicleAverageUpdateOne) defaults() {
+	if _, ok := vauo.mutation.UpdatedAt(); !ok {
+		v := vehicleaverage.UpdateDefaultUpdatedAt()
+		vauo.mutation.SetUpdatedAt(v)
+	}
+}
+
+func (vauo *VehicleAverageUpdateOne) sqlSave(ctx context.Context) (_node *VehicleAverage, err error) {
+	_spec := sqlgraph.NewUpdateSpec(vehicleaverage.Table, vehicleaverage.Columns, sqlgraph.NewFieldSpec(vehicleaverage.FieldID, field.TypeString))
+	id, ok := vauo.mutation.ID()
+	if !ok {
+		return nil, &ValidationError{Name: "id", err: errors.New(`db: missing "VehicleAverage.id" for update`)}
+	}
+	_spec.Node.ID.Value = id
+	if fields := vauo.fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, vehicleaverage.FieldID)
+		for _, f := range fields {
+			if !vehicleaverage.ValidColumn(f) {
+				return nil, &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+			}
+			if f != vehicleaverage.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, f)
+			}
+		}
+	}
+	if ps := vauo.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := vauo.mutation.UpdatedAt(); ok {
+		_spec.SetField(vehicleaverage.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := vauo.mutation.AddedUpdatedAt(); ok {
+		_spec.AddField(vehicleaverage.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := vauo.mutation.Data(); ok {
+		_spec.SetField(vehicleaverage.FieldData, field.TypeJSON, value)
+	}
+	_node = &VehicleAverage{config: vauo.config}
+	_spec.Assign = _node.assignValues
+	_spec.ScanValues = _node.scanValues
+	if err = sqlgraph.UpdateNode(ctx, vauo.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{vehicleaverage.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	vauo.mutation.done = true
+	return _node, nil
+}
diff --git a/internal/database/ent/db/vehiclesnapshot.go b/internal/database/ent/db/vehiclesnapshot.go
new file mode 100644
index 00000000..ae0d2d10
--- /dev/null
+++ b/internal/database/ent/db/vehiclesnapshot.go
@@ -0,0 +1,227 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+	"github.com/cufee/aftermath/internal/database/ent/db/account"
+	"github.com/cufee/aftermath/internal/database/ent/db/vehiclesnapshot"
+	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/stats/frame"
+)
+
+// VehicleSnapshot is the model entity for the VehicleSnapshot schema.
+type VehicleSnapshot struct {
+	config `json:"-"`
+	// ID of the ent.
+	ID string `json:"id,omitempty"`
+	// CreatedAt holds the value of the "created_at" field.
+	CreatedAt int `json:"created_at,omitempty"`
+	// UpdatedAt holds the value of the "updated_at" field.
+	UpdatedAt int `json:"updated_at,omitempty"`
+	// Type holds the value of the "type" field.
+	Type models.SnapshotType `json:"type,omitempty"`
+	// AccountID holds the value of the "account_id" field.
+	AccountID string `json:"account_id,omitempty"`
+	// VehicleID holds the value of the "vehicle_id" field.
+	VehicleID string `json:"vehicle_id,omitempty"`
+	// ReferenceID holds the value of the "reference_id" field.
+	ReferenceID string `json:"reference_id,omitempty"`
+	// Battles holds the value of the "battles" field.
+	Battles int `json:"battles,omitempty"`
+	// LastBattleTime holds the value of the "last_battle_time" field.
+	LastBattleTime int `json:"last_battle_time,omitempty"`
+	// Frame holds the value of the "frame" field.
+	Frame frame.StatsFrame `json:"frame,omitempty"`
+	// Edges holds the relations/edges for other nodes in the graph.
+	// The values are being populated by the VehicleSnapshotQuery when eager-loading is set.
+	Edges        VehicleSnapshotEdges `json:"edges"`
+	selectValues sql.SelectValues
+}
+
+// VehicleSnapshotEdges holds the relations/edges for other nodes in the graph.
+type VehicleSnapshotEdges struct {
+	// Account holds the value of the account edge.
+	Account *Account `json:"account,omitempty"`
+	// loadedTypes holds the information for reporting if a
+	// type was loaded (or requested) in eager-loading or not.
+	loadedTypes [1]bool
+}
+
+// AccountOrErr returns the Account value or an error if the edge
+// was not loaded in eager-loading, or loaded but was not found.
+func (e VehicleSnapshotEdges) AccountOrErr() (*Account, error) {
+	if e.Account != nil {
+		return e.Account, nil
+	} else if e.loadedTypes[0] {
+		return nil, &NotFoundError{label: account.Label}
+	}
+	return nil, &NotLoadedError{edge: "account"}
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*VehicleSnapshot) scanValues(columns []string) ([]any, error) {
+	values := make([]any, len(columns))
+	for i := range columns {
+		switch columns[i] {
+		case vehiclesnapshot.FieldFrame:
+			values[i] = new([]byte)
+		case vehiclesnapshot.FieldCreatedAt, vehiclesnapshot.FieldUpdatedAt, vehiclesnapshot.FieldBattles, vehiclesnapshot.FieldLastBattleTime:
+			values[i] = new(sql.NullInt64)
+		case vehiclesnapshot.FieldID, vehiclesnapshot.FieldType, vehiclesnapshot.FieldAccountID, vehiclesnapshot.FieldVehicleID, vehiclesnapshot.FieldReferenceID:
+			values[i] = new(sql.NullString)
+		default:
+			values[i] = new(sql.UnknownType)
+		}
+	}
+	return values, nil
+}
+
+// assignValues assigns the values that were returned from sql.Rows (after scanning)
+// to the VehicleSnapshot fields.
+func (vs *VehicleSnapshot) assignValues(columns []string, values []any) error {
+	if m, n := len(values), len(columns); m < n {
+		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
+	}
+	for i := range columns {
+		switch columns[i] {
+		case vehiclesnapshot.FieldID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field id", values[i])
+			} else if value.Valid {
+				vs.ID = value.String
+			}
+		case vehiclesnapshot.FieldCreatedAt:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field created_at", values[i])
+			} else if value.Valid {
+				vs.CreatedAt = int(value.Int64)
+			}
+		case vehiclesnapshot.FieldUpdatedAt:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
+			} else if value.Valid {
+				vs.UpdatedAt = int(value.Int64)
+			}
+		case vehiclesnapshot.FieldType:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field type", values[i])
+			} else if value.Valid {
+				vs.Type = models.SnapshotType(value.String)
+			}
+		case vehiclesnapshot.FieldAccountID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field account_id", values[i])
+			} else if value.Valid {
+				vs.AccountID = value.String
+			}
+		case vehiclesnapshot.FieldVehicleID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field vehicle_id", values[i])
+			} else if value.Valid {
+				vs.VehicleID = value.String
+			}
+		case vehiclesnapshot.FieldReferenceID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field reference_id", values[i])
+			} else if value.Valid {
+				vs.ReferenceID = value.String
+			}
+		case vehiclesnapshot.FieldBattles:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field battles", values[i])
+			} else if value.Valid {
+				vs.Battles = int(value.Int64)
+			}
+		case vehiclesnapshot.FieldLastBattleTime:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field last_battle_time", values[i])
+			} else if value.Valid {
+				vs.LastBattleTime = int(value.Int64)
+			}
+		case vehiclesnapshot.FieldFrame:
+			if value, ok := values[i].(*[]byte); !ok {
+				return fmt.Errorf("unexpected type %T for field frame", values[i])
+			} else if value != nil && len(*value) > 0 {
+				if err := json.Unmarshal(*value, &vs.Frame); err != nil {
+					return fmt.Errorf("unmarshal field frame: %w", err)
+				}
+			}
+		default:
+			vs.selectValues.Set(columns[i], values[i])
+		}
+	}
+	return nil
+}
+
+// Value returns the ent.Value that was dynamically selected and assigned to the VehicleSnapshot.
+// This includes values selected through modifiers, order, etc.
+func (vs *VehicleSnapshot) Value(name string) (ent.Value, error) {
+	return vs.selectValues.Get(name)
+}
+
+// QueryAccount queries the "account" edge of the VehicleSnapshot entity.
+func (vs *VehicleSnapshot) QueryAccount() *AccountQuery {
+	return NewVehicleSnapshotClient(vs.config).QueryAccount(vs)
+}
+
+// Update returns a builder for updating this VehicleSnapshot.
+// Note that you need to call VehicleSnapshot.Unwrap() before calling this method if this VehicleSnapshot
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (vs *VehicleSnapshot) Update() *VehicleSnapshotUpdateOne {
+	return NewVehicleSnapshotClient(vs.config).UpdateOne(vs)
+}
+
+// Unwrap unwraps the VehicleSnapshot entity that was returned from a transaction after it was closed,
+// so that all future queries will be executed through the driver which created the transaction.
+func (vs *VehicleSnapshot) Unwrap() *VehicleSnapshot {
+	_tx, ok := vs.config.driver.(*txDriver)
+	if !ok {
+		panic("db: VehicleSnapshot is not a transactional entity")
+	}
+	vs.config.driver = _tx.drv
+	return vs
+}
+
+// String implements the fmt.Stringer.
+func (vs *VehicleSnapshot) String() string {
+	var builder strings.Builder
+	builder.WriteString("VehicleSnapshot(")
+	builder.WriteString(fmt.Sprintf("id=%v, ", vs.ID))
+	builder.WriteString("created_at=")
+	builder.WriteString(fmt.Sprintf("%v", vs.CreatedAt))
+	builder.WriteString(", ")
+	builder.WriteString("updated_at=")
+	builder.WriteString(fmt.Sprintf("%v", vs.UpdatedAt))
+	builder.WriteString(", ")
+	builder.WriteString("type=")
+	builder.WriteString(fmt.Sprintf("%v", vs.Type))
+	builder.WriteString(", ")
+	builder.WriteString("account_id=")
+	builder.WriteString(vs.AccountID)
+	builder.WriteString(", ")
+	builder.WriteString("vehicle_id=")
+	builder.WriteString(vs.VehicleID)
+	builder.WriteString(", ")
+	builder.WriteString("reference_id=")
+	builder.WriteString(vs.ReferenceID)
+	builder.WriteString(", ")
+	builder.WriteString("battles=")
+	builder.WriteString(fmt.Sprintf("%v", vs.Battles))
+	builder.WriteString(", ")
+	builder.WriteString("last_battle_time=")
+	builder.WriteString(fmt.Sprintf("%v", vs.LastBattleTime))
+	builder.WriteString(", ")
+	builder.WriteString("frame=")
+	builder.WriteString(fmt.Sprintf("%v", vs.Frame))
+	builder.WriteByte(')')
+	return builder.String()
+}
+
+// VehicleSnapshots is a parsable slice of VehicleSnapshot.
+type VehicleSnapshots []*VehicleSnapshot
diff --git a/internal/database/ent/db/vehiclesnapshot/vehiclesnapshot.go b/internal/database/ent/db/vehiclesnapshot/vehiclesnapshot.go
new file mode 100644
index 00000000..aa8d81ed
--- /dev/null
+++ b/internal/database/ent/db/vehiclesnapshot/vehiclesnapshot.go
@@ -0,0 +1,160 @@
+// Code generated by ent, DO NOT EDIT.
+
+package vehiclesnapshot
+
+import (
+	"fmt"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+const (
+	// Label holds the string label denoting the vehiclesnapshot type in the database.
+	Label = "vehicle_snapshot"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// FieldType holds the string denoting the type field in the database.
+	FieldType = "type"
+	// FieldAccountID holds the string denoting the account_id field in the database.
+	FieldAccountID = "account_id"
+	// FieldVehicleID holds the string denoting the vehicle_id field in the database.
+	FieldVehicleID = "vehicle_id"
+	// FieldReferenceID holds the string denoting the reference_id field in the database.
+	FieldReferenceID = "reference_id"
+	// FieldBattles holds the string denoting the battles field in the database.
+	FieldBattles = "battles"
+	// FieldLastBattleTime holds the string denoting the last_battle_time field in the database.
+	FieldLastBattleTime = "last_battle_time"
+	// FieldFrame holds the string denoting the frame field in the database.
+	FieldFrame = "frame"
+	// EdgeAccount holds the string denoting the account edge name in mutations.
+	EdgeAccount = "account"
+	// Table holds the table name of the vehiclesnapshot in the database.
+	Table = "vehicle_snapshots"
+	// AccountTable is the table that holds the account relation/edge.
+	AccountTable = "vehicle_snapshots"
+	// AccountInverseTable is the table name for the Account entity.
+	// It exists in this package in order to avoid circular dependency with the "account" package.
+	AccountInverseTable = "accounts"
+	// AccountColumn is the table column denoting the account relation/edge.
+	AccountColumn = "account_id"
+)
+
+// Columns holds all SQL columns for vehiclesnapshot fields.
+var Columns = []string{
+	FieldID,
+	FieldCreatedAt,
+	FieldUpdatedAt,
+	FieldType,
+	FieldAccountID,
+	FieldVehicleID,
+	FieldReferenceID,
+	FieldBattles,
+	FieldLastBattleTime,
+	FieldFrame,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() int
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() int
+	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
+	UpdateDefaultUpdatedAt func() int
+	// AccountIDValidator is a validator for the "account_id" field. It is called by the builders before save.
+	AccountIDValidator func(string) error
+	// VehicleIDValidator is a validator for the "vehicle_id" field. It is called by the builders before save.
+	VehicleIDValidator func(string) error
+	// ReferenceIDValidator is a validator for the "reference_id" field. It is called by the builders before save.
+	ReferenceIDValidator func(string) error
+	// DefaultID holds the default value on creation for the "id" field.
+	DefaultID func() string
+)
+
+// TypeValidator is a validator for the "type" field enum values. It is called by the builders before save.
+func TypeValidator(_type models.SnapshotType) error {
+	switch _type {
+	case "live", "daily":
+		return nil
+	default:
+		return fmt.Errorf("vehiclesnapshot: invalid enum value for type field: %q", _type)
+	}
+}
+
+// OrderOption defines the ordering options for the VehicleSnapshot queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByType orders the results by the type field.
+func ByType(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldType, opts...).ToFunc()
+}
+
+// ByAccountID orders the results by the account_id field.
+func ByAccountID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldAccountID, opts...).ToFunc()
+}
+
+// ByVehicleID orders the results by the vehicle_id field.
+func ByVehicleID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldVehicleID, opts...).ToFunc()
+}
+
+// ByReferenceID orders the results by the reference_id field.
+func ByReferenceID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldReferenceID, opts...).ToFunc()
+}
+
+// ByBattles orders the results by the battles field.
+func ByBattles(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldBattles, opts...).ToFunc()
+}
+
+// ByLastBattleTime orders the results by the last_battle_time field.
+func ByLastBattleTime(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldLastBattleTime, opts...).ToFunc()
+}
+
+// ByAccountField orders the results by account field.
+func ByAccountField(field string, opts ...sql.OrderTermOption) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborTerms(s, newAccountStep(), sql.OrderByField(field, opts...))
+	}
+}
+func newAccountStep() *sqlgraph.Step {
+	return sqlgraph.NewStep(
+		sqlgraph.From(Table, FieldID),
+		sqlgraph.To(AccountInverseTable, FieldID),
+		sqlgraph.Edge(sqlgraph.M2O, true, AccountTable, AccountColumn),
+	)
+}
diff --git a/internal/database/ent/db/vehiclesnapshot/where.go b/internal/database/ent/db/vehiclesnapshot/where.go
new file mode 100644
index 00000000..758156fe
--- /dev/null
+++ b/internal/database/ent/db/vehiclesnapshot/where.go
@@ -0,0 +1,523 @@
+// Code generated by ent, DO NOT EDIT.
+
+package vehiclesnapshot
+
+import (
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldLTE(FieldID, id))
+}
+
+// IDEqualFold applies the EqualFold predicate on the ID field.
+func IDEqualFold(id string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldEqualFold(FieldID, id))
+}
+
+// IDContainsFold applies the ContainsFold predicate on the ID field.
+func IDContainsFold(id string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldContainsFold(FieldID, id))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v int) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v int) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// AccountID applies equality check predicate on the "account_id" field. It's identical to AccountIDEQ.
+func AccountID(v string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldEQ(FieldAccountID, v))
+}
+
+// VehicleID applies equality check predicate on the "vehicle_id" field. It's identical to VehicleIDEQ.
+func VehicleID(v string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldEQ(FieldVehicleID, v))
+}
+
+// ReferenceID applies equality check predicate on the "reference_id" field. It's identical to ReferenceIDEQ.
+func ReferenceID(v string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldEQ(FieldReferenceID, v))
+}
+
+// Battles applies equality check predicate on the "battles" field. It's identical to BattlesEQ.
+func Battles(v int) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldEQ(FieldBattles, v))
+}
+
+// LastBattleTime applies equality check predicate on the "last_battle_time" field. It's identical to LastBattleTimeEQ.
+func LastBattleTime(v int) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldEQ(FieldLastBattleTime, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v int) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v int) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...int) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...int) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v int) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v int) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v int) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v int) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v int) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v int) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...int) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...int) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v int) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v int) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v int) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v int) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// TypeEQ applies the EQ predicate on the "type" field.
+func TypeEQ(v models.SnapshotType) predicate.VehicleSnapshot {
+	vc := v
+	return predicate.VehicleSnapshot(sql.FieldEQ(FieldType, vc))
+}
+
+// TypeNEQ applies the NEQ predicate on the "type" field.
+func TypeNEQ(v models.SnapshotType) predicate.VehicleSnapshot {
+	vc := v
+	return predicate.VehicleSnapshot(sql.FieldNEQ(FieldType, vc))
+}
+
+// TypeIn applies the In predicate on the "type" field.
+func TypeIn(vs ...models.SnapshotType) predicate.VehicleSnapshot {
+	v := make([]any, len(vs))
+	for i := range v {
+		v[i] = vs[i]
+	}
+	return predicate.VehicleSnapshot(sql.FieldIn(FieldType, v...))
+}
+
+// TypeNotIn applies the NotIn predicate on the "type" field.
+func TypeNotIn(vs ...models.SnapshotType) predicate.VehicleSnapshot {
+	v := make([]any, len(vs))
+	for i := range v {
+		v[i] = vs[i]
+	}
+	return predicate.VehicleSnapshot(sql.FieldNotIn(FieldType, v...))
+}
+
+// AccountIDEQ applies the EQ predicate on the "account_id" field.
+func AccountIDEQ(v string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldEQ(FieldAccountID, v))
+}
+
+// AccountIDNEQ applies the NEQ predicate on the "account_id" field.
+func AccountIDNEQ(v string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldNEQ(FieldAccountID, v))
+}
+
+// AccountIDIn applies the In predicate on the "account_id" field.
+func AccountIDIn(vs ...string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldIn(FieldAccountID, vs...))
+}
+
+// AccountIDNotIn applies the NotIn predicate on the "account_id" field.
+func AccountIDNotIn(vs ...string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldNotIn(FieldAccountID, vs...))
+}
+
+// AccountIDGT applies the GT predicate on the "account_id" field.
+func AccountIDGT(v string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldGT(FieldAccountID, v))
+}
+
+// AccountIDGTE applies the GTE predicate on the "account_id" field.
+func AccountIDGTE(v string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldGTE(FieldAccountID, v))
+}
+
+// AccountIDLT applies the LT predicate on the "account_id" field.
+func AccountIDLT(v string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldLT(FieldAccountID, v))
+}
+
+// AccountIDLTE applies the LTE predicate on the "account_id" field.
+func AccountIDLTE(v string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldLTE(FieldAccountID, v))
+}
+
+// AccountIDContains applies the Contains predicate on the "account_id" field.
+func AccountIDContains(v string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldContains(FieldAccountID, v))
+}
+
+// AccountIDHasPrefix applies the HasPrefix predicate on the "account_id" field.
+func AccountIDHasPrefix(v string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldHasPrefix(FieldAccountID, v))
+}
+
+// AccountIDHasSuffix applies the HasSuffix predicate on the "account_id" field.
+func AccountIDHasSuffix(v string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldHasSuffix(FieldAccountID, v))
+}
+
+// AccountIDEqualFold applies the EqualFold predicate on the "account_id" field.
+func AccountIDEqualFold(v string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldEqualFold(FieldAccountID, v))
+}
+
+// AccountIDContainsFold applies the ContainsFold predicate on the "account_id" field.
+func AccountIDContainsFold(v string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldContainsFold(FieldAccountID, v))
+}
+
+// VehicleIDEQ applies the EQ predicate on the "vehicle_id" field.
+func VehicleIDEQ(v string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldEQ(FieldVehicleID, v))
+}
+
+// VehicleIDNEQ applies the NEQ predicate on the "vehicle_id" field.
+func VehicleIDNEQ(v string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldNEQ(FieldVehicleID, v))
+}
+
+// VehicleIDIn applies the In predicate on the "vehicle_id" field.
+func VehicleIDIn(vs ...string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldIn(FieldVehicleID, vs...))
+}
+
+// VehicleIDNotIn applies the NotIn predicate on the "vehicle_id" field.
+func VehicleIDNotIn(vs ...string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldNotIn(FieldVehicleID, vs...))
+}
+
+// VehicleIDGT applies the GT predicate on the "vehicle_id" field.
+func VehicleIDGT(v string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldGT(FieldVehicleID, v))
+}
+
+// VehicleIDGTE applies the GTE predicate on the "vehicle_id" field.
+func VehicleIDGTE(v string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldGTE(FieldVehicleID, v))
+}
+
+// VehicleIDLT applies the LT predicate on the "vehicle_id" field.
+func VehicleIDLT(v string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldLT(FieldVehicleID, v))
+}
+
+// VehicleIDLTE applies the LTE predicate on the "vehicle_id" field.
+func VehicleIDLTE(v string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldLTE(FieldVehicleID, v))
+}
+
+// VehicleIDContains applies the Contains predicate on the "vehicle_id" field.
+func VehicleIDContains(v string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldContains(FieldVehicleID, v))
+}
+
+// VehicleIDHasPrefix applies the HasPrefix predicate on the "vehicle_id" field.
+func VehicleIDHasPrefix(v string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldHasPrefix(FieldVehicleID, v))
+}
+
+// VehicleIDHasSuffix applies the HasSuffix predicate on the "vehicle_id" field.
+func VehicleIDHasSuffix(v string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldHasSuffix(FieldVehicleID, v))
+}
+
+// VehicleIDEqualFold applies the EqualFold predicate on the "vehicle_id" field.
+func VehicleIDEqualFold(v string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldEqualFold(FieldVehicleID, v))
+}
+
+// VehicleIDContainsFold applies the ContainsFold predicate on the "vehicle_id" field.
+func VehicleIDContainsFold(v string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldContainsFold(FieldVehicleID, v))
+}
+
+// ReferenceIDEQ applies the EQ predicate on the "reference_id" field.
+func ReferenceIDEQ(v string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldEQ(FieldReferenceID, v))
+}
+
+// ReferenceIDNEQ applies the NEQ predicate on the "reference_id" field.
+func ReferenceIDNEQ(v string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldNEQ(FieldReferenceID, v))
+}
+
+// ReferenceIDIn applies the In predicate on the "reference_id" field.
+func ReferenceIDIn(vs ...string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldIn(FieldReferenceID, vs...))
+}
+
+// ReferenceIDNotIn applies the NotIn predicate on the "reference_id" field.
+func ReferenceIDNotIn(vs ...string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldNotIn(FieldReferenceID, vs...))
+}
+
+// ReferenceIDGT applies the GT predicate on the "reference_id" field.
+func ReferenceIDGT(v string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldGT(FieldReferenceID, v))
+}
+
+// ReferenceIDGTE applies the GTE predicate on the "reference_id" field.
+func ReferenceIDGTE(v string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldGTE(FieldReferenceID, v))
+}
+
+// ReferenceIDLT applies the LT predicate on the "reference_id" field.
+func ReferenceIDLT(v string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldLT(FieldReferenceID, v))
+}
+
+// ReferenceIDLTE applies the LTE predicate on the "reference_id" field.
+func ReferenceIDLTE(v string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldLTE(FieldReferenceID, v))
+}
+
+// ReferenceIDContains applies the Contains predicate on the "reference_id" field.
+func ReferenceIDContains(v string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldContains(FieldReferenceID, v))
+}
+
+// ReferenceIDHasPrefix applies the HasPrefix predicate on the "reference_id" field.
+func ReferenceIDHasPrefix(v string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldHasPrefix(FieldReferenceID, v))
+}
+
+// ReferenceIDHasSuffix applies the HasSuffix predicate on the "reference_id" field.
+func ReferenceIDHasSuffix(v string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldHasSuffix(FieldReferenceID, v))
+}
+
+// ReferenceIDEqualFold applies the EqualFold predicate on the "reference_id" field.
+func ReferenceIDEqualFold(v string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldEqualFold(FieldReferenceID, v))
+}
+
+// ReferenceIDContainsFold applies the ContainsFold predicate on the "reference_id" field.
+func ReferenceIDContainsFold(v string) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldContainsFold(FieldReferenceID, v))
+}
+
+// BattlesEQ applies the EQ predicate on the "battles" field.
+func BattlesEQ(v int) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldEQ(FieldBattles, v))
+}
+
+// BattlesNEQ applies the NEQ predicate on the "battles" field.
+func BattlesNEQ(v int) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldNEQ(FieldBattles, v))
+}
+
+// BattlesIn applies the In predicate on the "battles" field.
+func BattlesIn(vs ...int) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldIn(FieldBattles, vs...))
+}
+
+// BattlesNotIn applies the NotIn predicate on the "battles" field.
+func BattlesNotIn(vs ...int) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldNotIn(FieldBattles, vs...))
+}
+
+// BattlesGT applies the GT predicate on the "battles" field.
+func BattlesGT(v int) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldGT(FieldBattles, v))
+}
+
+// BattlesGTE applies the GTE predicate on the "battles" field.
+func BattlesGTE(v int) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldGTE(FieldBattles, v))
+}
+
+// BattlesLT applies the LT predicate on the "battles" field.
+func BattlesLT(v int) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldLT(FieldBattles, v))
+}
+
+// BattlesLTE applies the LTE predicate on the "battles" field.
+func BattlesLTE(v int) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldLTE(FieldBattles, v))
+}
+
+// LastBattleTimeEQ applies the EQ predicate on the "last_battle_time" field.
+func LastBattleTimeEQ(v int) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldEQ(FieldLastBattleTime, v))
+}
+
+// LastBattleTimeNEQ applies the NEQ predicate on the "last_battle_time" field.
+func LastBattleTimeNEQ(v int) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldNEQ(FieldLastBattleTime, v))
+}
+
+// LastBattleTimeIn applies the In predicate on the "last_battle_time" field.
+func LastBattleTimeIn(vs ...int) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldIn(FieldLastBattleTime, vs...))
+}
+
+// LastBattleTimeNotIn applies the NotIn predicate on the "last_battle_time" field.
+func LastBattleTimeNotIn(vs ...int) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldNotIn(FieldLastBattleTime, vs...))
+}
+
+// LastBattleTimeGT applies the GT predicate on the "last_battle_time" field.
+func LastBattleTimeGT(v int) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldGT(FieldLastBattleTime, v))
+}
+
+// LastBattleTimeGTE applies the GTE predicate on the "last_battle_time" field.
+func LastBattleTimeGTE(v int) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldGTE(FieldLastBattleTime, v))
+}
+
+// LastBattleTimeLT applies the LT predicate on the "last_battle_time" field.
+func LastBattleTimeLT(v int) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldLT(FieldLastBattleTime, v))
+}
+
+// LastBattleTimeLTE applies the LTE predicate on the "last_battle_time" field.
+func LastBattleTimeLTE(v int) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.FieldLTE(FieldLastBattleTime, v))
+}
+
+// HasAccount applies the HasEdge predicate on the "account" edge.
+func HasAccount() predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, AccountTable, AccountColumn),
+		)
+		sqlgraph.HasNeighbors(s, step)
+	})
+}
+
+// HasAccountWith applies the HasEdge predicate on the "account" edge with a given conditions (other predicates).
+func HasAccountWith(preds ...predicate.Account) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(func(s *sql.Selector) {
+		step := newAccountStep()
+		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+			for _, p := range preds {
+				p(s)
+			}
+		})
+	})
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.VehicleSnapshot) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.VehicleSnapshot) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.VehicleSnapshot) predicate.VehicleSnapshot {
+	return predicate.VehicleSnapshot(sql.NotPredicates(p))
+}
diff --git a/internal/database/ent/db/vehiclesnapshot_create.go b/internal/database/ent/db/vehiclesnapshot_create.go
new file mode 100644
index 00000000..6120d27b
--- /dev/null
+++ b/internal/database/ent/db/vehiclesnapshot_create.go
@@ -0,0 +1,384 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/account"
+	"github.com/cufee/aftermath/internal/database/ent/db/vehiclesnapshot"
+	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/stats/frame"
+)
+
+// VehicleSnapshotCreate is the builder for creating a VehicleSnapshot entity.
+type VehicleSnapshotCreate struct {
+	config
+	mutation *VehicleSnapshotMutation
+	hooks    []Hook
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (vsc *VehicleSnapshotCreate) SetCreatedAt(i int) *VehicleSnapshotCreate {
+	vsc.mutation.SetCreatedAt(i)
+	return vsc
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (vsc *VehicleSnapshotCreate) SetNillableCreatedAt(i *int) *VehicleSnapshotCreate {
+	if i != nil {
+		vsc.SetCreatedAt(*i)
+	}
+	return vsc
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (vsc *VehicleSnapshotCreate) SetUpdatedAt(i int) *VehicleSnapshotCreate {
+	vsc.mutation.SetUpdatedAt(i)
+	return vsc
+}
+
+// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
+func (vsc *VehicleSnapshotCreate) SetNillableUpdatedAt(i *int) *VehicleSnapshotCreate {
+	if i != nil {
+		vsc.SetUpdatedAt(*i)
+	}
+	return vsc
+}
+
+// SetType sets the "type" field.
+func (vsc *VehicleSnapshotCreate) SetType(mt models.SnapshotType) *VehicleSnapshotCreate {
+	vsc.mutation.SetType(mt)
+	return vsc
+}
+
+// SetAccountID sets the "account_id" field.
+func (vsc *VehicleSnapshotCreate) SetAccountID(s string) *VehicleSnapshotCreate {
+	vsc.mutation.SetAccountID(s)
+	return vsc
+}
+
+// SetVehicleID sets the "vehicle_id" field.
+func (vsc *VehicleSnapshotCreate) SetVehicleID(s string) *VehicleSnapshotCreate {
+	vsc.mutation.SetVehicleID(s)
+	return vsc
+}
+
+// SetReferenceID sets the "reference_id" field.
+func (vsc *VehicleSnapshotCreate) SetReferenceID(s string) *VehicleSnapshotCreate {
+	vsc.mutation.SetReferenceID(s)
+	return vsc
+}
+
+// SetBattles sets the "battles" field.
+func (vsc *VehicleSnapshotCreate) SetBattles(i int) *VehicleSnapshotCreate {
+	vsc.mutation.SetBattles(i)
+	return vsc
+}
+
+// SetLastBattleTime sets the "last_battle_time" field.
+func (vsc *VehicleSnapshotCreate) SetLastBattleTime(i int) *VehicleSnapshotCreate {
+	vsc.mutation.SetLastBattleTime(i)
+	return vsc
+}
+
+// SetFrame sets the "frame" field.
+func (vsc *VehicleSnapshotCreate) SetFrame(ff frame.StatsFrame) *VehicleSnapshotCreate {
+	vsc.mutation.SetFrame(ff)
+	return vsc
+}
+
+// SetID sets the "id" field.
+func (vsc *VehicleSnapshotCreate) SetID(s string) *VehicleSnapshotCreate {
+	vsc.mutation.SetID(s)
+	return vsc
+}
+
+// SetNillableID sets the "id" field if the given value is not nil.
+func (vsc *VehicleSnapshotCreate) SetNillableID(s *string) *VehicleSnapshotCreate {
+	if s != nil {
+		vsc.SetID(*s)
+	}
+	return vsc
+}
+
+// SetAccount sets the "account" edge to the Account entity.
+func (vsc *VehicleSnapshotCreate) SetAccount(a *Account) *VehicleSnapshotCreate {
+	return vsc.SetAccountID(a.ID)
+}
+
+// Mutation returns the VehicleSnapshotMutation object of the builder.
+func (vsc *VehicleSnapshotCreate) Mutation() *VehicleSnapshotMutation {
+	return vsc.mutation
+}
+
+// Save creates the VehicleSnapshot in the database.
+func (vsc *VehicleSnapshotCreate) Save(ctx context.Context) (*VehicleSnapshot, error) {
+	vsc.defaults()
+	return withHooks(ctx, vsc.sqlSave, vsc.mutation, vsc.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (vsc *VehicleSnapshotCreate) SaveX(ctx context.Context) *VehicleSnapshot {
+	v, err := vsc.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (vsc *VehicleSnapshotCreate) Exec(ctx context.Context) error {
+	_, err := vsc.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (vsc *VehicleSnapshotCreate) ExecX(ctx context.Context) {
+	if err := vsc.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (vsc *VehicleSnapshotCreate) defaults() {
+	if _, ok := vsc.mutation.CreatedAt(); !ok {
+		v := vehiclesnapshot.DefaultCreatedAt()
+		vsc.mutation.SetCreatedAt(v)
+	}
+	if _, ok := vsc.mutation.UpdatedAt(); !ok {
+		v := vehiclesnapshot.DefaultUpdatedAt()
+		vsc.mutation.SetUpdatedAt(v)
+	}
+	if _, ok := vsc.mutation.ID(); !ok {
+		v := vehiclesnapshot.DefaultID()
+		vsc.mutation.SetID(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (vsc *VehicleSnapshotCreate) check() error {
+	if _, ok := vsc.mutation.CreatedAt(); !ok {
+		return &ValidationError{Name: "created_at", err: errors.New(`db: missing required field "VehicleSnapshot.created_at"`)}
+	}
+	if _, ok := vsc.mutation.UpdatedAt(); !ok {
+		return &ValidationError{Name: "updated_at", err: errors.New(`db: missing required field "VehicleSnapshot.updated_at"`)}
+	}
+	if _, ok := vsc.mutation.GetType(); !ok {
+		return &ValidationError{Name: "type", err: errors.New(`db: missing required field "VehicleSnapshot.type"`)}
+	}
+	if v, ok := vsc.mutation.GetType(); ok {
+		if err := vehiclesnapshot.TypeValidator(v); err != nil {
+			return &ValidationError{Name: "type", err: fmt.Errorf(`db: validator failed for field "VehicleSnapshot.type": %w`, err)}
+		}
+	}
+	if _, ok := vsc.mutation.AccountID(); !ok {
+		return &ValidationError{Name: "account_id", err: errors.New(`db: missing required field "VehicleSnapshot.account_id"`)}
+	}
+	if v, ok := vsc.mutation.AccountID(); ok {
+		if err := vehiclesnapshot.AccountIDValidator(v); err != nil {
+			return &ValidationError{Name: "account_id", err: fmt.Errorf(`db: validator failed for field "VehicleSnapshot.account_id": %w`, err)}
+		}
+	}
+	if _, ok := vsc.mutation.VehicleID(); !ok {
+		return &ValidationError{Name: "vehicle_id", err: errors.New(`db: missing required field "VehicleSnapshot.vehicle_id"`)}
+	}
+	if v, ok := vsc.mutation.VehicleID(); ok {
+		if err := vehiclesnapshot.VehicleIDValidator(v); err != nil {
+			return &ValidationError{Name: "vehicle_id", err: fmt.Errorf(`db: validator failed for field "VehicleSnapshot.vehicle_id": %w`, err)}
+		}
+	}
+	if _, ok := vsc.mutation.ReferenceID(); !ok {
+		return &ValidationError{Name: "reference_id", err: errors.New(`db: missing required field "VehicleSnapshot.reference_id"`)}
+	}
+	if v, ok := vsc.mutation.ReferenceID(); ok {
+		if err := vehiclesnapshot.ReferenceIDValidator(v); err != nil {
+			return &ValidationError{Name: "reference_id", err: fmt.Errorf(`db: validator failed for field "VehicleSnapshot.reference_id": %w`, err)}
+		}
+	}
+	if _, ok := vsc.mutation.Battles(); !ok {
+		return &ValidationError{Name: "battles", err: errors.New(`db: missing required field "VehicleSnapshot.battles"`)}
+	}
+	if _, ok := vsc.mutation.LastBattleTime(); !ok {
+		return &ValidationError{Name: "last_battle_time", err: errors.New(`db: missing required field "VehicleSnapshot.last_battle_time"`)}
+	}
+	if _, ok := vsc.mutation.Frame(); !ok {
+		return &ValidationError{Name: "frame", err: errors.New(`db: missing required field "VehicleSnapshot.frame"`)}
+	}
+	if _, ok := vsc.mutation.AccountID(); !ok {
+		return &ValidationError{Name: "account", err: errors.New(`db: missing required edge "VehicleSnapshot.account"`)}
+	}
+	return nil
+}
+
+func (vsc *VehicleSnapshotCreate) sqlSave(ctx context.Context) (*VehicleSnapshot, error) {
+	if err := vsc.check(); err != nil {
+		return nil, err
+	}
+	_node, _spec := vsc.createSpec()
+	if err := sqlgraph.CreateNode(ctx, vsc.driver, _spec); err != nil {
+		if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	if _spec.ID.Value != nil {
+		if id, ok := _spec.ID.Value.(string); ok {
+			_node.ID = id
+		} else {
+			return nil, fmt.Errorf("unexpected VehicleSnapshot.ID type: %T", _spec.ID.Value)
+		}
+	}
+	vsc.mutation.id = &_node.ID
+	vsc.mutation.done = true
+	return _node, nil
+}
+
+func (vsc *VehicleSnapshotCreate) createSpec() (*VehicleSnapshot, *sqlgraph.CreateSpec) {
+	var (
+		_node = &VehicleSnapshot{config: vsc.config}
+		_spec = sqlgraph.NewCreateSpec(vehiclesnapshot.Table, sqlgraph.NewFieldSpec(vehiclesnapshot.FieldID, field.TypeString))
+	)
+	if id, ok := vsc.mutation.ID(); ok {
+		_node.ID = id
+		_spec.ID.Value = id
+	}
+	if value, ok := vsc.mutation.CreatedAt(); ok {
+		_spec.SetField(vehiclesnapshot.FieldCreatedAt, field.TypeInt, value)
+		_node.CreatedAt = value
+	}
+	if value, ok := vsc.mutation.UpdatedAt(); ok {
+		_spec.SetField(vehiclesnapshot.FieldUpdatedAt, field.TypeInt, value)
+		_node.UpdatedAt = value
+	}
+	if value, ok := vsc.mutation.GetType(); ok {
+		_spec.SetField(vehiclesnapshot.FieldType, field.TypeEnum, value)
+		_node.Type = value
+	}
+	if value, ok := vsc.mutation.VehicleID(); ok {
+		_spec.SetField(vehiclesnapshot.FieldVehicleID, field.TypeString, value)
+		_node.VehicleID = value
+	}
+	if value, ok := vsc.mutation.ReferenceID(); ok {
+		_spec.SetField(vehiclesnapshot.FieldReferenceID, field.TypeString, value)
+		_node.ReferenceID = value
+	}
+	if value, ok := vsc.mutation.Battles(); ok {
+		_spec.SetField(vehiclesnapshot.FieldBattles, field.TypeInt, value)
+		_node.Battles = value
+	}
+	if value, ok := vsc.mutation.LastBattleTime(); ok {
+		_spec.SetField(vehiclesnapshot.FieldLastBattleTime, field.TypeInt, value)
+		_node.LastBattleTime = value
+	}
+	if value, ok := vsc.mutation.Frame(); ok {
+		_spec.SetField(vehiclesnapshot.FieldFrame, field.TypeJSON, value)
+		_node.Frame = value
+	}
+	if nodes := vsc.mutation.AccountIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   vehiclesnapshot.AccountTable,
+			Columns: []string{vehiclesnapshot.AccountColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(account.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_node.AccountID = nodes[0]
+		_spec.Edges = append(_spec.Edges, edge)
+	}
+	return _node, _spec
+}
+
+// VehicleSnapshotCreateBulk is the builder for creating many VehicleSnapshot entities in bulk.
+type VehicleSnapshotCreateBulk struct {
+	config
+	err      error
+	builders []*VehicleSnapshotCreate
+}
+
+// Save creates the VehicleSnapshot entities in the database.
+func (vscb *VehicleSnapshotCreateBulk) Save(ctx context.Context) ([]*VehicleSnapshot, error) {
+	if vscb.err != nil {
+		return nil, vscb.err
+	}
+	specs := make([]*sqlgraph.CreateSpec, len(vscb.builders))
+	nodes := make([]*VehicleSnapshot, len(vscb.builders))
+	mutators := make([]Mutator, len(vscb.builders))
+	for i := range vscb.builders {
+		func(i int, root context.Context) {
+			builder := vscb.builders[i]
+			builder.defaults()
+			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+				mutation, ok := m.(*VehicleSnapshotMutation)
+				if !ok {
+					return nil, fmt.Errorf("unexpected mutation type %T", m)
+				}
+				if err := builder.check(); err != nil {
+					return nil, err
+				}
+				builder.mutation = mutation
+				var err error
+				nodes[i], specs[i] = builder.createSpec()
+				if i < len(mutators)-1 {
+					_, err = mutators[i+1].Mutate(root, vscb.builders[i+1].mutation)
+				} else {
+					spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
+					// Invoke the actual operation on the latest mutation in the chain.
+					if err = sqlgraph.BatchCreate(ctx, vscb.driver, spec); err != nil {
+						if sqlgraph.IsConstraintError(err) {
+							err = &ConstraintError{msg: err.Error(), wrap: err}
+						}
+					}
+				}
+				if err != nil {
+					return nil, err
+				}
+				mutation.id = &nodes[i].ID
+				mutation.done = true
+				return nodes[i], nil
+			})
+			for i := len(builder.hooks) - 1; i >= 0; i-- {
+				mut = builder.hooks[i](mut)
+			}
+			mutators[i] = mut
+		}(i, ctx)
+	}
+	if len(mutators) > 0 {
+		if _, err := mutators[0].Mutate(ctx, vscb.builders[0].mutation); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (vscb *VehicleSnapshotCreateBulk) SaveX(ctx context.Context) []*VehicleSnapshot {
+	v, err := vscb.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (vscb *VehicleSnapshotCreateBulk) Exec(ctx context.Context) error {
+	_, err := vscb.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (vscb *VehicleSnapshotCreateBulk) ExecX(ctx context.Context) {
+	if err := vscb.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/database/ent/db/vehiclesnapshot_delete.go b/internal/database/ent/db/vehiclesnapshot_delete.go
new file mode 100644
index 00000000..2fc70b41
--- /dev/null
+++ b/internal/database/ent/db/vehiclesnapshot_delete.go
@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/ent/db/vehiclesnapshot"
+)
+
+// VehicleSnapshotDelete is the builder for deleting a VehicleSnapshot entity.
+type VehicleSnapshotDelete struct {
+	config
+	hooks    []Hook
+	mutation *VehicleSnapshotMutation
+}
+
+// Where appends a list predicates to the VehicleSnapshotDelete builder.
+func (vsd *VehicleSnapshotDelete) Where(ps ...predicate.VehicleSnapshot) *VehicleSnapshotDelete {
+	vsd.mutation.Where(ps...)
+	return vsd
+}
+
+// Exec executes the deletion query and returns how many vertices were deleted.
+func (vsd *VehicleSnapshotDelete) Exec(ctx context.Context) (int, error) {
+	return withHooks(ctx, vsd.sqlExec, vsd.mutation, vsd.hooks)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (vsd *VehicleSnapshotDelete) ExecX(ctx context.Context) int {
+	n, err := vsd.Exec(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return n
+}
+
+func (vsd *VehicleSnapshotDelete) sqlExec(ctx context.Context) (int, error) {
+	_spec := sqlgraph.NewDeleteSpec(vehiclesnapshot.Table, sqlgraph.NewFieldSpec(vehiclesnapshot.FieldID, field.TypeString))
+	if ps := vsd.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	affected, err := sqlgraph.DeleteNodes(ctx, vsd.driver, _spec)
+	if err != nil && sqlgraph.IsConstraintError(err) {
+		err = &ConstraintError{msg: err.Error(), wrap: err}
+	}
+	vsd.mutation.done = true
+	return affected, err
+}
+
+// VehicleSnapshotDeleteOne is the builder for deleting a single VehicleSnapshot entity.
+type VehicleSnapshotDeleteOne struct {
+	vsd *VehicleSnapshotDelete
+}
+
+// Where appends a list predicates to the VehicleSnapshotDelete builder.
+func (vsdo *VehicleSnapshotDeleteOne) Where(ps ...predicate.VehicleSnapshot) *VehicleSnapshotDeleteOne {
+	vsdo.vsd.mutation.Where(ps...)
+	return vsdo
+}
+
+// Exec executes the deletion query.
+func (vsdo *VehicleSnapshotDeleteOne) Exec(ctx context.Context) error {
+	n, err := vsdo.vsd.Exec(ctx)
+	switch {
+	case err != nil:
+		return err
+	case n == 0:
+		return &NotFoundError{vehiclesnapshot.Label}
+	default:
+		return nil
+	}
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (vsdo *VehicleSnapshotDeleteOne) ExecX(ctx context.Context) {
+	if err := vsdo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/database/ent/db/vehiclesnapshot_query.go b/internal/database/ent/db/vehiclesnapshot_query.go
new file mode 100644
index 00000000..89f20225
--- /dev/null
+++ b/internal/database/ent/db/vehiclesnapshot_query.go
@@ -0,0 +1,605 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"fmt"
+	"math"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/account"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/ent/db/vehiclesnapshot"
+)
+
+// VehicleSnapshotQuery is the builder for querying VehicleSnapshot entities.
+type VehicleSnapshotQuery struct {
+	config
+	ctx         *QueryContext
+	order       []vehiclesnapshot.OrderOption
+	inters      []Interceptor
+	predicates  []predicate.VehicleSnapshot
+	withAccount *AccountQuery
+	// intermediate query (i.e. traversal path).
+	sql  *sql.Selector
+	path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the VehicleSnapshotQuery builder.
+func (vsq *VehicleSnapshotQuery) Where(ps ...predicate.VehicleSnapshot) *VehicleSnapshotQuery {
+	vsq.predicates = append(vsq.predicates, ps...)
+	return vsq
+}
+
+// Limit the number of records to be returned by this query.
+func (vsq *VehicleSnapshotQuery) Limit(limit int) *VehicleSnapshotQuery {
+	vsq.ctx.Limit = &limit
+	return vsq
+}
+
+// Offset to start from.
+func (vsq *VehicleSnapshotQuery) Offset(offset int) *VehicleSnapshotQuery {
+	vsq.ctx.Offset = &offset
+	return vsq
+}
+
+// Unique configures the query builder to filter duplicate records on query.
+// By default, unique is set to true, and can be disabled using this method.
+func (vsq *VehicleSnapshotQuery) Unique(unique bool) *VehicleSnapshotQuery {
+	vsq.ctx.Unique = &unique
+	return vsq
+}
+
+// Order specifies how the records should be ordered.
+func (vsq *VehicleSnapshotQuery) Order(o ...vehiclesnapshot.OrderOption) *VehicleSnapshotQuery {
+	vsq.order = append(vsq.order, o...)
+	return vsq
+}
+
+// QueryAccount chains the current query on the "account" edge.
+func (vsq *VehicleSnapshotQuery) QueryAccount() *AccountQuery {
+	query := (&AccountClient{config: vsq.config}).Query()
+	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+		if err := vsq.prepareQuery(ctx); err != nil {
+			return nil, err
+		}
+		selector := vsq.sqlQuery(ctx)
+		if err := selector.Err(); err != nil {
+			return nil, err
+		}
+		step := sqlgraph.NewStep(
+			sqlgraph.From(vehiclesnapshot.Table, vehiclesnapshot.FieldID, selector),
+			sqlgraph.To(account.Table, account.FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, vehiclesnapshot.AccountTable, vehiclesnapshot.AccountColumn),
+		)
+		fromU = sqlgraph.SetNeighbors(vsq.driver.Dialect(), step)
+		return fromU, nil
+	}
+	return query
+}
+
+// First returns the first VehicleSnapshot entity from the query.
+// Returns a *NotFoundError when no VehicleSnapshot was found.
+func (vsq *VehicleSnapshotQuery) First(ctx context.Context) (*VehicleSnapshot, error) {
+	nodes, err := vsq.Limit(1).All(setContextOp(ctx, vsq.ctx, "First"))
+	if err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nil, &NotFoundError{vehiclesnapshot.Label}
+	}
+	return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (vsq *VehicleSnapshotQuery) FirstX(ctx context.Context) *VehicleSnapshot {
+	node, err := vsq.First(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return node
+}
+
+// FirstID returns the first VehicleSnapshot ID from the query.
+// Returns a *NotFoundError when no VehicleSnapshot ID was found.
+func (vsq *VehicleSnapshotQuery) FirstID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = vsq.Limit(1).IDs(setContextOp(ctx, vsq.ctx, "FirstID")); err != nil {
+		return
+	}
+	if len(ids) == 0 {
+		err = &NotFoundError{vehiclesnapshot.Label}
+		return
+	}
+	return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (vsq *VehicleSnapshotQuery) FirstIDX(ctx context.Context) string {
+	id, err := vsq.FirstID(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return id
+}
+
+// Only returns a single VehicleSnapshot entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one VehicleSnapshot entity is found.
+// Returns a *NotFoundError when no VehicleSnapshot entities are found.
+func (vsq *VehicleSnapshotQuery) Only(ctx context.Context) (*VehicleSnapshot, error) {
+	nodes, err := vsq.Limit(2).All(setContextOp(ctx, vsq.ctx, "Only"))
+	if err != nil {
+		return nil, err
+	}
+	switch len(nodes) {
+	case 1:
+		return nodes[0], nil
+	case 0:
+		return nil, &NotFoundError{vehiclesnapshot.Label}
+	default:
+		return nil, &NotSingularError{vehiclesnapshot.Label}
+	}
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (vsq *VehicleSnapshotQuery) OnlyX(ctx context.Context) *VehicleSnapshot {
+	node, err := vsq.Only(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// OnlyID is like Only, but returns the only VehicleSnapshot ID in the query.
+// Returns a *NotSingularError when more than one VehicleSnapshot ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (vsq *VehicleSnapshotQuery) OnlyID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = vsq.Limit(2).IDs(setContextOp(ctx, vsq.ctx, "OnlyID")); err != nil {
+		return
+	}
+	switch len(ids) {
+	case 1:
+		id = ids[0]
+	case 0:
+		err = &NotFoundError{vehiclesnapshot.Label}
+	default:
+		err = &NotSingularError{vehiclesnapshot.Label}
+	}
+	return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (vsq *VehicleSnapshotQuery) OnlyIDX(ctx context.Context) string {
+	id, err := vsq.OnlyID(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return id
+}
+
+// All executes the query and returns a list of VehicleSnapshots.
+func (vsq *VehicleSnapshotQuery) All(ctx context.Context) ([]*VehicleSnapshot, error) {
+	ctx = setContextOp(ctx, vsq.ctx, "All")
+	if err := vsq.prepareQuery(ctx); err != nil {
+		return nil, err
+	}
+	qr := querierAll[[]*VehicleSnapshot, *VehicleSnapshotQuery]()
+	return withInterceptors[[]*VehicleSnapshot](ctx, vsq, qr, vsq.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (vsq *VehicleSnapshotQuery) AllX(ctx context.Context) []*VehicleSnapshot {
+	nodes, err := vsq.All(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return nodes
+}
+
+// IDs executes the query and returns a list of VehicleSnapshot IDs.
+func (vsq *VehicleSnapshotQuery) IDs(ctx context.Context) (ids []string, err error) {
+	if vsq.ctx.Unique == nil && vsq.path != nil {
+		vsq.Unique(true)
+	}
+	ctx = setContextOp(ctx, vsq.ctx, "IDs")
+	if err = vsq.Select(vehiclesnapshot.FieldID).Scan(ctx, &ids); err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (vsq *VehicleSnapshotQuery) IDsX(ctx context.Context) []string {
+	ids, err := vsq.IDs(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return ids
+}
+
+// Count returns the count of the given query.
+func (vsq *VehicleSnapshotQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, vsq.ctx, "Count")
+	if err := vsq.prepareQuery(ctx); err != nil {
+		return 0, err
+	}
+	return withInterceptors[int](ctx, vsq, querierCount[*VehicleSnapshotQuery](), vsq.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (vsq *VehicleSnapshotQuery) CountX(ctx context.Context) int {
+	count, err := vsq.Count(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (vsq *VehicleSnapshotQuery) Exist(ctx context.Context) (bool, error) {
+	ctx = setContextOp(ctx, vsq.ctx, "Exist")
+	switch _, err := vsq.FirstID(ctx); {
+	case IsNotFound(err):
+		return false, nil
+	case err != nil:
+		return false, fmt.Errorf("db: check existence: %w", err)
+	default:
+		return true, nil
+	}
+}
+
+// ExistX is like Exist, but panics if an error occurs.
+func (vsq *VehicleSnapshotQuery) ExistX(ctx context.Context) bool {
+	exist, err := vsq.Exist(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return exist
+}
+
+// Clone returns a duplicate of the VehicleSnapshotQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (vsq *VehicleSnapshotQuery) Clone() *VehicleSnapshotQuery {
+	if vsq == nil {
+		return nil
+	}
+	return &VehicleSnapshotQuery{
+		config:      vsq.config,
+		ctx:         vsq.ctx.Clone(),
+		order:       append([]vehiclesnapshot.OrderOption{}, vsq.order...),
+		inters:      append([]Interceptor{}, vsq.inters...),
+		predicates:  append([]predicate.VehicleSnapshot{}, vsq.predicates...),
+		withAccount: vsq.withAccount.Clone(),
+		// clone intermediate query.
+		sql:  vsq.sql.Clone(),
+		path: vsq.path,
+	}
+}
+
+// WithAccount tells the query-builder to eager-load the nodes that are connected to
+// the "account" edge. The optional arguments are used to configure the query builder of the edge.
+func (vsq *VehicleSnapshotQuery) WithAccount(opts ...func(*AccountQuery)) *VehicleSnapshotQuery {
+	query := (&AccountClient{config: vsq.config}).Query()
+	for _, opt := range opts {
+		opt(query)
+	}
+	vsq.withAccount = query
+	return vsq
+}
+
+// GroupBy is used to group vertices by one or more fields/columns.
+// It is often used with aggregate functions, like: count, max, mean, min, sum.
+//
+// Example:
+//
+//	var v []struct {
+//		CreatedAt int `json:"created_at,omitempty"`
+//		Count int `json:"count,omitempty"`
+//	}
+//
+//	client.VehicleSnapshot.Query().
+//		GroupBy(vehiclesnapshot.FieldCreatedAt).
+//		Aggregate(db.Count()).
+//		Scan(ctx, &v)
+func (vsq *VehicleSnapshotQuery) GroupBy(field string, fields ...string) *VehicleSnapshotGroupBy {
+	vsq.ctx.Fields = append([]string{field}, fields...)
+	grbuild := &VehicleSnapshotGroupBy{build: vsq}
+	grbuild.flds = &vsq.ctx.Fields
+	grbuild.label = vehiclesnapshot.Label
+	grbuild.scan = grbuild.Scan
+	return grbuild
+}
+
+// Select allows the selection one or more fields/columns for the given query,
+// instead of selecting all fields in the entity.
+//
+// Example:
+//
+//	var v []struct {
+//		CreatedAt int `json:"created_at,omitempty"`
+//	}
+//
+//	client.VehicleSnapshot.Query().
+//		Select(vehiclesnapshot.FieldCreatedAt).
+//		Scan(ctx, &v)
+func (vsq *VehicleSnapshotQuery) Select(fields ...string) *VehicleSnapshotSelect {
+	vsq.ctx.Fields = append(vsq.ctx.Fields, fields...)
+	sbuild := &VehicleSnapshotSelect{VehicleSnapshotQuery: vsq}
+	sbuild.label = vehiclesnapshot.Label
+	sbuild.flds, sbuild.scan = &vsq.ctx.Fields, sbuild.Scan
+	return sbuild
+}
+
+// Aggregate returns a VehicleSnapshotSelect configured with the given aggregations.
+func (vsq *VehicleSnapshotQuery) Aggregate(fns ...AggregateFunc) *VehicleSnapshotSelect {
+	return vsq.Select().Aggregate(fns...)
+}
+
+func (vsq *VehicleSnapshotQuery) prepareQuery(ctx context.Context) error {
+	for _, inter := range vsq.inters {
+		if inter == nil {
+			return fmt.Errorf("db: uninitialized interceptor (forgotten import db/runtime?)")
+		}
+		if trv, ok := inter.(Traverser); ok {
+			if err := trv.Traverse(ctx, vsq); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range vsq.ctx.Fields {
+		if !vehiclesnapshot.ValidColumn(f) {
+			return &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+		}
+	}
+	if vsq.path != nil {
+		prev, err := vsq.path(ctx)
+		if err != nil {
+			return err
+		}
+		vsq.sql = prev
+	}
+	return nil
+}
+
+func (vsq *VehicleSnapshotQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*VehicleSnapshot, error) {
+	var (
+		nodes       = []*VehicleSnapshot{}
+		_spec       = vsq.querySpec()
+		loadedTypes = [1]bool{
+			vsq.withAccount != nil,
+		}
+	)
+	_spec.ScanValues = func(columns []string) ([]any, error) {
+		return (*VehicleSnapshot).scanValues(nil, columns)
+	}
+	_spec.Assign = func(columns []string, values []any) error {
+		node := &VehicleSnapshot{config: vsq.config}
+		nodes = append(nodes, node)
+		node.Edges.loadedTypes = loadedTypes
+		return node.assignValues(columns, values)
+	}
+	for i := range hooks {
+		hooks[i](ctx, _spec)
+	}
+	if err := sqlgraph.QueryNodes(ctx, vsq.driver, _spec); err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nodes, nil
+	}
+	if query := vsq.withAccount; query != nil {
+		if err := vsq.loadAccount(ctx, query, nodes, nil,
+			func(n *VehicleSnapshot, e *Account) { n.Edges.Account = e }); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+func (vsq *VehicleSnapshotQuery) loadAccount(ctx context.Context, query *AccountQuery, nodes []*VehicleSnapshot, init func(*VehicleSnapshot), assign func(*VehicleSnapshot, *Account)) error {
+	ids := make([]string, 0, len(nodes))
+	nodeids := make(map[string][]*VehicleSnapshot)
+	for i := range nodes {
+		fk := nodes[i].AccountID
+		if _, ok := nodeids[fk]; !ok {
+			ids = append(ids, fk)
+		}
+		nodeids[fk] = append(nodeids[fk], nodes[i])
+	}
+	if len(ids) == 0 {
+		return nil
+	}
+	query.Where(account.IDIn(ids...))
+	neighbors, err := query.All(ctx)
+	if err != nil {
+		return err
+	}
+	for _, n := range neighbors {
+		nodes, ok := nodeids[n.ID]
+		if !ok {
+			return fmt.Errorf(`unexpected foreign-key "account_id" returned %v`, n.ID)
+		}
+		for i := range nodes {
+			assign(nodes[i], n)
+		}
+	}
+	return nil
+}
+
+func (vsq *VehicleSnapshotQuery) sqlCount(ctx context.Context) (int, error) {
+	_spec := vsq.querySpec()
+	_spec.Node.Columns = vsq.ctx.Fields
+	if len(vsq.ctx.Fields) > 0 {
+		_spec.Unique = vsq.ctx.Unique != nil && *vsq.ctx.Unique
+	}
+	return sqlgraph.CountNodes(ctx, vsq.driver, _spec)
+}
+
+func (vsq *VehicleSnapshotQuery) querySpec() *sqlgraph.QuerySpec {
+	_spec := sqlgraph.NewQuerySpec(vehiclesnapshot.Table, vehiclesnapshot.Columns, sqlgraph.NewFieldSpec(vehiclesnapshot.FieldID, field.TypeString))
+	_spec.From = vsq.sql
+	if unique := vsq.ctx.Unique; unique != nil {
+		_spec.Unique = *unique
+	} else if vsq.path != nil {
+		_spec.Unique = true
+	}
+	if fields := vsq.ctx.Fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, vehiclesnapshot.FieldID)
+		for i := range fields {
+			if fields[i] != vehiclesnapshot.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+			}
+		}
+		if vsq.withAccount != nil {
+			_spec.Node.AddColumnOnce(vehiclesnapshot.FieldAccountID)
+		}
+	}
+	if ps := vsq.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if limit := vsq.ctx.Limit; limit != nil {
+		_spec.Limit = *limit
+	}
+	if offset := vsq.ctx.Offset; offset != nil {
+		_spec.Offset = *offset
+	}
+	if ps := vsq.order; len(ps) > 0 {
+		_spec.Order = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	return _spec
+}
+
+func (vsq *VehicleSnapshotQuery) sqlQuery(ctx context.Context) *sql.Selector {
+	builder := sql.Dialect(vsq.driver.Dialect())
+	t1 := builder.Table(vehiclesnapshot.Table)
+	columns := vsq.ctx.Fields
+	if len(columns) == 0 {
+		columns = vehiclesnapshot.Columns
+	}
+	selector := builder.Select(t1.Columns(columns...)...).From(t1)
+	if vsq.sql != nil {
+		selector = vsq.sql
+		selector.Select(selector.Columns(columns...)...)
+	}
+	if vsq.ctx.Unique != nil && *vsq.ctx.Unique {
+		selector.Distinct()
+	}
+	for _, p := range vsq.predicates {
+		p(selector)
+	}
+	for _, p := range vsq.order {
+		p(selector)
+	}
+	if offset := vsq.ctx.Offset; offset != nil {
+		// limit is mandatory for offset clause. We start
+		// with default value, and override it below if needed.
+		selector.Offset(*offset).Limit(math.MaxInt32)
+	}
+	if limit := vsq.ctx.Limit; limit != nil {
+		selector.Limit(*limit)
+	}
+	return selector
+}
+
+// VehicleSnapshotGroupBy is the group-by builder for VehicleSnapshot entities.
+type VehicleSnapshotGroupBy struct {
+	selector
+	build *VehicleSnapshotQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (vsgb *VehicleSnapshotGroupBy) Aggregate(fns ...AggregateFunc) *VehicleSnapshotGroupBy {
+	vsgb.fns = append(vsgb.fns, fns...)
+	return vsgb
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (vsgb *VehicleSnapshotGroupBy) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, vsgb.build.ctx, "GroupBy")
+	if err := vsgb.build.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*VehicleSnapshotQuery, *VehicleSnapshotGroupBy](ctx, vsgb.build, vsgb, vsgb.build.inters, v)
+}
+
+func (vsgb *VehicleSnapshotGroupBy) sqlScan(ctx context.Context, root *VehicleSnapshotQuery, v any) error {
+	selector := root.sqlQuery(ctx).Select()
+	aggregation := make([]string, 0, len(vsgb.fns))
+	for _, fn := range vsgb.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*vsgb.flds)+len(vsgb.fns))
+		for _, f := range *vsgb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*vsgb.flds...)...)
+	if err := selector.Err(); err != nil {
+		return err
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := vsgb.build.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
+
+// VehicleSnapshotSelect is the builder for selecting fields of VehicleSnapshot entities.
+type VehicleSnapshotSelect struct {
+	*VehicleSnapshotQuery
+	selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (vss *VehicleSnapshotSelect) Aggregate(fns ...AggregateFunc) *VehicleSnapshotSelect {
+	vss.fns = append(vss.fns, fns...)
+	return vss
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (vss *VehicleSnapshotSelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, vss.ctx, "Select")
+	if err := vss.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*VehicleSnapshotQuery, *VehicleSnapshotSelect](ctx, vss.VehicleSnapshotQuery, vss, vss.inters, v)
+}
+
+func (vss *VehicleSnapshotSelect) sqlScan(ctx context.Context, root *VehicleSnapshotQuery, v any) error {
+	selector := root.sqlQuery(ctx)
+	aggregation := make([]string, 0, len(vss.fns))
+	for _, fn := range vss.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	switch n := len(*vss.selector.flds); {
+	case n == 0 && len(aggregation) > 0:
+		selector.Select(aggregation...)
+	case n != 0 && len(aggregation) > 0:
+		selector.AppendSelect(aggregation...)
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := vss.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
diff --git a/internal/database/ent/db/vehiclesnapshot_update.go b/internal/database/ent/db/vehiclesnapshot_update.go
new file mode 100644
index 00000000..a80ac271
--- /dev/null
+++ b/internal/database/ent/db/vehiclesnapshot_update.go
@@ -0,0 +1,485 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/ent/db/vehiclesnapshot"
+	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/stats/frame"
+)
+
+// VehicleSnapshotUpdate is the builder for updating VehicleSnapshot entities.
+type VehicleSnapshotUpdate struct {
+	config
+	hooks    []Hook
+	mutation *VehicleSnapshotMutation
+}
+
+// Where appends a list predicates to the VehicleSnapshotUpdate builder.
+func (vsu *VehicleSnapshotUpdate) Where(ps ...predicate.VehicleSnapshot) *VehicleSnapshotUpdate {
+	vsu.mutation.Where(ps...)
+	return vsu
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (vsu *VehicleSnapshotUpdate) SetUpdatedAt(i int) *VehicleSnapshotUpdate {
+	vsu.mutation.ResetUpdatedAt()
+	vsu.mutation.SetUpdatedAt(i)
+	return vsu
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (vsu *VehicleSnapshotUpdate) AddUpdatedAt(i int) *VehicleSnapshotUpdate {
+	vsu.mutation.AddUpdatedAt(i)
+	return vsu
+}
+
+// SetType sets the "type" field.
+func (vsu *VehicleSnapshotUpdate) SetType(mt models.SnapshotType) *VehicleSnapshotUpdate {
+	vsu.mutation.SetType(mt)
+	return vsu
+}
+
+// SetNillableType sets the "type" field if the given value is not nil.
+func (vsu *VehicleSnapshotUpdate) SetNillableType(mt *models.SnapshotType) *VehicleSnapshotUpdate {
+	if mt != nil {
+		vsu.SetType(*mt)
+	}
+	return vsu
+}
+
+// SetReferenceID sets the "reference_id" field.
+func (vsu *VehicleSnapshotUpdate) SetReferenceID(s string) *VehicleSnapshotUpdate {
+	vsu.mutation.SetReferenceID(s)
+	return vsu
+}
+
+// SetNillableReferenceID sets the "reference_id" field if the given value is not nil.
+func (vsu *VehicleSnapshotUpdate) SetNillableReferenceID(s *string) *VehicleSnapshotUpdate {
+	if s != nil {
+		vsu.SetReferenceID(*s)
+	}
+	return vsu
+}
+
+// SetBattles sets the "battles" field.
+func (vsu *VehicleSnapshotUpdate) SetBattles(i int) *VehicleSnapshotUpdate {
+	vsu.mutation.ResetBattles()
+	vsu.mutation.SetBattles(i)
+	return vsu
+}
+
+// SetNillableBattles sets the "battles" field if the given value is not nil.
+func (vsu *VehicleSnapshotUpdate) SetNillableBattles(i *int) *VehicleSnapshotUpdate {
+	if i != nil {
+		vsu.SetBattles(*i)
+	}
+	return vsu
+}
+
+// AddBattles adds i to the "battles" field.
+func (vsu *VehicleSnapshotUpdate) AddBattles(i int) *VehicleSnapshotUpdate {
+	vsu.mutation.AddBattles(i)
+	return vsu
+}
+
+// SetLastBattleTime sets the "last_battle_time" field.
+func (vsu *VehicleSnapshotUpdate) SetLastBattleTime(i int) *VehicleSnapshotUpdate {
+	vsu.mutation.ResetLastBattleTime()
+	vsu.mutation.SetLastBattleTime(i)
+	return vsu
+}
+
+// SetNillableLastBattleTime sets the "last_battle_time" field if the given value is not nil.
+func (vsu *VehicleSnapshotUpdate) SetNillableLastBattleTime(i *int) *VehicleSnapshotUpdate {
+	if i != nil {
+		vsu.SetLastBattleTime(*i)
+	}
+	return vsu
+}
+
+// AddLastBattleTime adds i to the "last_battle_time" field.
+func (vsu *VehicleSnapshotUpdate) AddLastBattleTime(i int) *VehicleSnapshotUpdate {
+	vsu.mutation.AddLastBattleTime(i)
+	return vsu
+}
+
+// SetFrame sets the "frame" field.
+func (vsu *VehicleSnapshotUpdate) SetFrame(ff frame.StatsFrame) *VehicleSnapshotUpdate {
+	vsu.mutation.SetFrame(ff)
+	return vsu
+}
+
+// SetNillableFrame sets the "frame" field if the given value is not nil.
+func (vsu *VehicleSnapshotUpdate) SetNillableFrame(ff *frame.StatsFrame) *VehicleSnapshotUpdate {
+	if ff != nil {
+		vsu.SetFrame(*ff)
+	}
+	return vsu
+}
+
+// Mutation returns the VehicleSnapshotMutation object of the builder.
+func (vsu *VehicleSnapshotUpdate) Mutation() *VehicleSnapshotMutation {
+	return vsu.mutation
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (vsu *VehicleSnapshotUpdate) Save(ctx context.Context) (int, error) {
+	vsu.defaults()
+	return withHooks(ctx, vsu.sqlSave, vsu.mutation, vsu.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (vsu *VehicleSnapshotUpdate) SaveX(ctx context.Context) int {
+	affected, err := vsu.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return affected
+}
+
+// Exec executes the query.
+func (vsu *VehicleSnapshotUpdate) Exec(ctx context.Context) error {
+	_, err := vsu.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (vsu *VehicleSnapshotUpdate) ExecX(ctx context.Context) {
+	if err := vsu.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (vsu *VehicleSnapshotUpdate) defaults() {
+	if _, ok := vsu.mutation.UpdatedAt(); !ok {
+		v := vehiclesnapshot.UpdateDefaultUpdatedAt()
+		vsu.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (vsu *VehicleSnapshotUpdate) check() error {
+	if v, ok := vsu.mutation.GetType(); ok {
+		if err := vehiclesnapshot.TypeValidator(v); err != nil {
+			return &ValidationError{Name: "type", err: fmt.Errorf(`db: validator failed for field "VehicleSnapshot.type": %w`, err)}
+		}
+	}
+	if v, ok := vsu.mutation.ReferenceID(); ok {
+		if err := vehiclesnapshot.ReferenceIDValidator(v); err != nil {
+			return &ValidationError{Name: "reference_id", err: fmt.Errorf(`db: validator failed for field "VehicleSnapshot.reference_id": %w`, err)}
+		}
+	}
+	if _, ok := vsu.mutation.AccountID(); vsu.mutation.AccountCleared() && !ok {
+		return errors.New(`db: clearing a required unique edge "VehicleSnapshot.account"`)
+	}
+	return nil
+}
+
+func (vsu *VehicleSnapshotUpdate) sqlSave(ctx context.Context) (n int, err error) {
+	if err := vsu.check(); err != nil {
+		return n, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(vehiclesnapshot.Table, vehiclesnapshot.Columns, sqlgraph.NewFieldSpec(vehiclesnapshot.FieldID, field.TypeString))
+	if ps := vsu.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := vsu.mutation.UpdatedAt(); ok {
+		_spec.SetField(vehiclesnapshot.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := vsu.mutation.AddedUpdatedAt(); ok {
+		_spec.AddField(vehiclesnapshot.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := vsu.mutation.GetType(); ok {
+		_spec.SetField(vehiclesnapshot.FieldType, field.TypeEnum, value)
+	}
+	if value, ok := vsu.mutation.ReferenceID(); ok {
+		_spec.SetField(vehiclesnapshot.FieldReferenceID, field.TypeString, value)
+	}
+	if value, ok := vsu.mutation.Battles(); ok {
+		_spec.SetField(vehiclesnapshot.FieldBattles, field.TypeInt, value)
+	}
+	if value, ok := vsu.mutation.AddedBattles(); ok {
+		_spec.AddField(vehiclesnapshot.FieldBattles, field.TypeInt, value)
+	}
+	if value, ok := vsu.mutation.LastBattleTime(); ok {
+		_spec.SetField(vehiclesnapshot.FieldLastBattleTime, field.TypeInt, value)
+	}
+	if value, ok := vsu.mutation.AddedLastBattleTime(); ok {
+		_spec.AddField(vehiclesnapshot.FieldLastBattleTime, field.TypeInt, value)
+	}
+	if value, ok := vsu.mutation.Frame(); ok {
+		_spec.SetField(vehiclesnapshot.FieldFrame, field.TypeJSON, value)
+	}
+	if n, err = sqlgraph.UpdateNodes(ctx, vsu.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{vehiclesnapshot.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return 0, err
+	}
+	vsu.mutation.done = true
+	return n, nil
+}
+
+// VehicleSnapshotUpdateOne is the builder for updating a single VehicleSnapshot entity.
+type VehicleSnapshotUpdateOne struct {
+	config
+	fields   []string
+	hooks    []Hook
+	mutation *VehicleSnapshotMutation
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (vsuo *VehicleSnapshotUpdateOne) SetUpdatedAt(i int) *VehicleSnapshotUpdateOne {
+	vsuo.mutation.ResetUpdatedAt()
+	vsuo.mutation.SetUpdatedAt(i)
+	return vsuo
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (vsuo *VehicleSnapshotUpdateOne) AddUpdatedAt(i int) *VehicleSnapshotUpdateOne {
+	vsuo.mutation.AddUpdatedAt(i)
+	return vsuo
+}
+
+// SetType sets the "type" field.
+func (vsuo *VehicleSnapshotUpdateOne) SetType(mt models.SnapshotType) *VehicleSnapshotUpdateOne {
+	vsuo.mutation.SetType(mt)
+	return vsuo
+}
+
+// SetNillableType sets the "type" field if the given value is not nil.
+func (vsuo *VehicleSnapshotUpdateOne) SetNillableType(mt *models.SnapshotType) *VehicleSnapshotUpdateOne {
+	if mt != nil {
+		vsuo.SetType(*mt)
+	}
+	return vsuo
+}
+
+// SetReferenceID sets the "reference_id" field.
+func (vsuo *VehicleSnapshotUpdateOne) SetReferenceID(s string) *VehicleSnapshotUpdateOne {
+	vsuo.mutation.SetReferenceID(s)
+	return vsuo
+}
+
+// SetNillableReferenceID sets the "reference_id" field if the given value is not nil.
+func (vsuo *VehicleSnapshotUpdateOne) SetNillableReferenceID(s *string) *VehicleSnapshotUpdateOne {
+	if s != nil {
+		vsuo.SetReferenceID(*s)
+	}
+	return vsuo
+}
+
+// SetBattles sets the "battles" field.
+func (vsuo *VehicleSnapshotUpdateOne) SetBattles(i int) *VehicleSnapshotUpdateOne {
+	vsuo.mutation.ResetBattles()
+	vsuo.mutation.SetBattles(i)
+	return vsuo
+}
+
+// SetNillableBattles sets the "battles" field if the given value is not nil.
+func (vsuo *VehicleSnapshotUpdateOne) SetNillableBattles(i *int) *VehicleSnapshotUpdateOne {
+	if i != nil {
+		vsuo.SetBattles(*i)
+	}
+	return vsuo
+}
+
+// AddBattles adds i to the "battles" field.
+func (vsuo *VehicleSnapshotUpdateOne) AddBattles(i int) *VehicleSnapshotUpdateOne {
+	vsuo.mutation.AddBattles(i)
+	return vsuo
+}
+
+// SetLastBattleTime sets the "last_battle_time" field.
+func (vsuo *VehicleSnapshotUpdateOne) SetLastBattleTime(i int) *VehicleSnapshotUpdateOne {
+	vsuo.mutation.ResetLastBattleTime()
+	vsuo.mutation.SetLastBattleTime(i)
+	return vsuo
+}
+
+// SetNillableLastBattleTime sets the "last_battle_time" field if the given value is not nil.
+func (vsuo *VehicleSnapshotUpdateOne) SetNillableLastBattleTime(i *int) *VehicleSnapshotUpdateOne {
+	if i != nil {
+		vsuo.SetLastBattleTime(*i)
+	}
+	return vsuo
+}
+
+// AddLastBattleTime adds i to the "last_battle_time" field.
+func (vsuo *VehicleSnapshotUpdateOne) AddLastBattleTime(i int) *VehicleSnapshotUpdateOne {
+	vsuo.mutation.AddLastBattleTime(i)
+	return vsuo
+}
+
+// SetFrame sets the "frame" field.
+func (vsuo *VehicleSnapshotUpdateOne) SetFrame(ff frame.StatsFrame) *VehicleSnapshotUpdateOne {
+	vsuo.mutation.SetFrame(ff)
+	return vsuo
+}
+
+// SetNillableFrame sets the "frame" field if the given value is not nil.
+func (vsuo *VehicleSnapshotUpdateOne) SetNillableFrame(ff *frame.StatsFrame) *VehicleSnapshotUpdateOne {
+	if ff != nil {
+		vsuo.SetFrame(*ff)
+	}
+	return vsuo
+}
+
+// Mutation returns the VehicleSnapshotMutation object of the builder.
+func (vsuo *VehicleSnapshotUpdateOne) Mutation() *VehicleSnapshotMutation {
+	return vsuo.mutation
+}
+
+// Where appends a list predicates to the VehicleSnapshotUpdate builder.
+func (vsuo *VehicleSnapshotUpdateOne) Where(ps ...predicate.VehicleSnapshot) *VehicleSnapshotUpdateOne {
+	vsuo.mutation.Where(ps...)
+	return vsuo
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (vsuo *VehicleSnapshotUpdateOne) Select(field string, fields ...string) *VehicleSnapshotUpdateOne {
+	vsuo.fields = append([]string{field}, fields...)
+	return vsuo
+}
+
+// Save executes the query and returns the updated VehicleSnapshot entity.
+func (vsuo *VehicleSnapshotUpdateOne) Save(ctx context.Context) (*VehicleSnapshot, error) {
+	vsuo.defaults()
+	return withHooks(ctx, vsuo.sqlSave, vsuo.mutation, vsuo.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (vsuo *VehicleSnapshotUpdateOne) SaveX(ctx context.Context) *VehicleSnapshot {
+	node, err := vsuo.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// Exec executes the query on the entity.
+func (vsuo *VehicleSnapshotUpdateOne) Exec(ctx context.Context) error {
+	_, err := vsuo.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (vsuo *VehicleSnapshotUpdateOne) ExecX(ctx context.Context) {
+	if err := vsuo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (vsuo *VehicleSnapshotUpdateOne) defaults() {
+	if _, ok := vsuo.mutation.UpdatedAt(); !ok {
+		v := vehiclesnapshot.UpdateDefaultUpdatedAt()
+		vsuo.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (vsuo *VehicleSnapshotUpdateOne) check() error {
+	if v, ok := vsuo.mutation.GetType(); ok {
+		if err := vehiclesnapshot.TypeValidator(v); err != nil {
+			return &ValidationError{Name: "type", err: fmt.Errorf(`db: validator failed for field "VehicleSnapshot.type": %w`, err)}
+		}
+	}
+	if v, ok := vsuo.mutation.ReferenceID(); ok {
+		if err := vehiclesnapshot.ReferenceIDValidator(v); err != nil {
+			return &ValidationError{Name: "reference_id", err: fmt.Errorf(`db: validator failed for field "VehicleSnapshot.reference_id": %w`, err)}
+		}
+	}
+	if _, ok := vsuo.mutation.AccountID(); vsuo.mutation.AccountCleared() && !ok {
+		return errors.New(`db: clearing a required unique edge "VehicleSnapshot.account"`)
+	}
+	return nil
+}
+
+func (vsuo *VehicleSnapshotUpdateOne) sqlSave(ctx context.Context) (_node *VehicleSnapshot, err error) {
+	if err := vsuo.check(); err != nil {
+		return _node, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(vehiclesnapshot.Table, vehiclesnapshot.Columns, sqlgraph.NewFieldSpec(vehiclesnapshot.FieldID, field.TypeString))
+	id, ok := vsuo.mutation.ID()
+	if !ok {
+		return nil, &ValidationError{Name: "id", err: errors.New(`db: missing "VehicleSnapshot.id" for update`)}
+	}
+	_spec.Node.ID.Value = id
+	if fields := vsuo.fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, vehiclesnapshot.FieldID)
+		for _, f := range fields {
+			if !vehiclesnapshot.ValidColumn(f) {
+				return nil, &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+			}
+			if f != vehiclesnapshot.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, f)
+			}
+		}
+	}
+	if ps := vsuo.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := vsuo.mutation.UpdatedAt(); ok {
+		_spec.SetField(vehiclesnapshot.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := vsuo.mutation.AddedUpdatedAt(); ok {
+		_spec.AddField(vehiclesnapshot.FieldUpdatedAt, field.TypeInt, value)
+	}
+	if value, ok := vsuo.mutation.GetType(); ok {
+		_spec.SetField(vehiclesnapshot.FieldType, field.TypeEnum, value)
+	}
+	if value, ok := vsuo.mutation.ReferenceID(); ok {
+		_spec.SetField(vehiclesnapshot.FieldReferenceID, field.TypeString, value)
+	}
+	if value, ok := vsuo.mutation.Battles(); ok {
+		_spec.SetField(vehiclesnapshot.FieldBattles, field.TypeInt, value)
+	}
+	if value, ok := vsuo.mutation.AddedBattles(); ok {
+		_spec.AddField(vehiclesnapshot.FieldBattles, field.TypeInt, value)
+	}
+	if value, ok := vsuo.mutation.LastBattleTime(); ok {
+		_spec.SetField(vehiclesnapshot.FieldLastBattleTime, field.TypeInt, value)
+	}
+	if value, ok := vsuo.mutation.AddedLastBattleTime(); ok {
+		_spec.AddField(vehiclesnapshot.FieldLastBattleTime, field.TypeInt, value)
+	}
+	if value, ok := vsuo.mutation.Frame(); ok {
+		_spec.SetField(vehiclesnapshot.FieldFrame, field.TypeJSON, value)
+	}
+	_node = &VehicleSnapshot{config: vsuo.config}
+	_spec.Assign = _node.assignValues
+	_spec.ScanValues = _node.scanValues
+	if err = sqlgraph.UpdateNode(ctx, vsuo.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{vehiclesnapshot.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	vsuo.mutation.done = true
+	return _node, nil
+}
diff --git a/internal/database/ent/generate.go b/internal/database/ent/generate.go
new file mode 100644
index 00000000..ce73767e
--- /dev/null
+++ b/internal/database/ent/generate.go
@@ -0,0 +1,3 @@
+package ent
+
+//go:generate go run -mod=mod entgo.io/ent/cmd/ent generate --feature sql/versioned-migration --target ./db ./schema
diff --git a/internal/database/ent/migrate.go b/internal/database/ent/migrate.go
new file mode 100644
index 00000000..39d7f1aa
--- /dev/null
+++ b/internal/database/ent/migrate.go
@@ -0,0 +1,63 @@
+package ent
+
+import (
+	"database/sql"
+)
+
+const migration = `
+CREATE TABLE 'accounts' ('id' text NOT NULL, 'created_at' integer NOT NULL, 'updated_at' integer NOT NULL, 'last_battle_time' integer NOT NULL, 'account_created_at' integer NOT NULL, 'realm' text NOT NULL, 'nickname' text NOT NULL, 'private' bool NOT NULL DEFAULT (false), 'clan_id' text NULL, PRIMARY KEY ('id'), CONSTRAINT 'accounts_clans_accounts' FOREIGN KEY ('clan_id') REFERENCES 'clans' ('id') ON DELETE SET NULL);
+CREATE INDEX 'account_id_last_battle_time' ON 'accounts' ('id', 'last_battle_time');
+CREATE INDEX 'account_realm' ON 'accounts' ('realm');
+CREATE INDEX 'account_realm_last_battle_time' ON 'accounts' ('realm', 'last_battle_time');
+CREATE INDEX 'account_clan_id' ON 'accounts' ('clan_id');
+CREATE TABLE 'account_snapshots' ('id' text NOT NULL, 'created_at' integer NOT NULL, 'updated_at' integer NOT NULL, 'type' text NOT NULL, 'last_battle_time' integer NOT NULL, 'reference_id' text NOT NULL, 'rating_battles' integer NOT NULL, 'rating_frame' json NOT NULL, 'regular_battles' integer NOT NULL, 'regular_frame' json NOT NULL, 'account_id' text NOT NULL, PRIMARY KEY ('id'), CONSTRAINT 'account_snapshots_accounts_snapshots' FOREIGN KEY ('account_id') REFERENCES 'accounts' ('id') ON DELETE NO ACTION);
+CREATE INDEX 'accountsnapshot_created_at' ON 'account_snapshots' ('created_at');
+CREATE INDEX 'accountsnapshot_type_account_id_created_at' ON 'account_snapshots' ('type', 'account_id', 'created_at');
+CREATE INDEX 'accountsnapshot_type_account_id_reference_id' ON 'account_snapshots' ('type', 'account_id', 'reference_id');
+CREATE INDEX 'accountsnapshot_type_account_id_reference_id_created_at' ON 'account_snapshots' ('type', 'account_id', 'reference_id', 'created_at');
+CREATE TABLE 'achievements_snapshots' ('id' text NOT NULL, 'created_at' integer NOT NULL, 'updated_at' integer NOT NULL, 'type' text NOT NULL, 'reference_id' text NOT NULL, 'battles' integer NOT NULL, 'last_battle_time' integer NOT NULL, 'data' json NOT NULL, 'account_id' text NOT NULL, PRIMARY KEY ('id'), CONSTRAINT 'achievements_snapshots_accounts_achievement_snapshots' FOREIGN KEY ('account_id') REFERENCES 'accounts' ('id') ON DELETE NO ACTION);
+CREATE INDEX 'achievementssnapshot_created_at' ON 'achievements_snapshots' ('created_at');
+CREATE INDEX 'achievementssnapshot_account_id_reference_id' ON 'achievements_snapshots' ('account_id', 'reference_id');
+CREATE INDEX 'achievementssnapshot_account_id_reference_id_created_at' ON 'achievements_snapshots' ('account_id', 'reference_id', 'created_at');
+CREATE TABLE 'app_configurations' ('id' text NOT NULL, 'created_at' integer NOT NULL, 'updated_at' integer NOT NULL, 'key' text NOT NULL, 'value' json NOT NULL, 'metadata' json NULL, PRIMARY KEY ('id'));
+CREATE UNIQUE INDEX 'app_configurations_key_key' ON 'app_configurations' ('key');
+CREATE INDEX 'appconfiguration_key' ON 'app_configurations' ('key');
+CREATE TABLE 'application_commands' ('id' text NOT NULL, 'created_at' integer NOT NULL, 'updated_at' integer NOT NULL, 'name' text NOT NULL, 'version' text NOT NULL, 'options_hash' text NOT NULL, PRIMARY KEY ('id'));
+CREATE UNIQUE INDEX 'application_commands_name_key' ON 'application_commands' ('name');
+CREATE INDEX 'applicationcommand_options_hash' ON 'application_commands' ('options_hash');
+CREATE TABLE 'clans' ('id' text NOT NULL, 'created_at' integer NOT NULL, 'updated_at' integer NOT NULL, 'tag' text NOT NULL, 'name' text NOT NULL, 'emblem_id' text NULL DEFAULT (''), 'members' json NOT NULL, PRIMARY KEY ('id'));
+CREATE INDEX 'clan_tag' ON 'clans' ('tag');
+CREATE INDEX 'clan_name' ON 'clans' ('name');
+CREATE TABLE 'cron_tasks' ('id' text NOT NULL, 'created_at' integer NOT NULL, 'updated_at' integer NOT NULL, 'type' text NOT NULL, 'reference_id' text NOT NULL, 'targets' json NOT NULL, 'status' text NOT NULL, 'scheduled_after' integer NOT NULL, 'last_run' integer NOT NULL, 'logs' json NOT NULL, 'data' json NOT NULL, PRIMARY KEY ('id'));
+CREATE INDEX 'crontask_reference_id' ON 'cron_tasks' ('reference_id');
+CREATE INDEX 'crontask_status_last_run' ON 'cron_tasks' ('status', 'last_run');
+CREATE INDEX 'crontask_status_created_at' ON 'cron_tasks' ('status', 'created_at');
+CREATE INDEX 'crontask_status_scheduled_after' ON 'cron_tasks' ('status', 'scheduled_after');
+CREATE TABLE 'users' ('id' text NOT NULL, 'created_at' integer NOT NULL, 'updated_at' integer NOT NULL, 'permissions' text NOT NULL DEFAULT (''), 'feature_flags' json NULL, PRIMARY KEY ('id'));
+CREATE TABLE 'user_connections' ('id' text NOT NULL, 'created_at' integer NOT NULL, 'updated_at' integer NOT NULL, 'type' text NOT NULL, 'reference_id' text NOT NULL, 'permissions' text NULL DEFAULT (''), 'metadata' json NULL, 'user_id' text NOT NULL, PRIMARY KEY ('id'), CONSTRAINT 'user_connections_users_connections' FOREIGN KEY ('user_id') REFERENCES 'users' ('id') ON DELETE NO ACTION);
+CREATE INDEX 'userconnection_user_id' ON 'user_connections' ('user_id');
+CREATE INDEX 'userconnection_type_user_id' ON 'user_connections' ('type', 'user_id');
+CREATE INDEX 'userconnection_reference_id' ON 'user_connections' ('reference_id');
+CREATE INDEX 'userconnection_type_reference_id' ON 'user_connections' ('type', 'reference_id');
+CREATE TABLE 'user_contents' ('id' text NOT NULL, 'created_at' integer NOT NULL, 'updated_at' integer NOT NULL, 'type' text NOT NULL, 'reference_id' text NOT NULL, 'value' json NOT NULL, 'metadata' json NOT NULL, 'user_id' text NOT NULL, PRIMARY KEY ('id'), CONSTRAINT 'user_contents_users_content' FOREIGN KEY ('user_id') REFERENCES 'users' ('id') ON DELETE NO ACTION);
+CREATE INDEX 'usercontent_user_id' ON 'user_contents' ('user_id');
+CREATE INDEX 'usercontent_type_user_id' ON 'user_contents' ('type', 'user_id');
+CREATE INDEX 'usercontent_reference_id' ON 'user_contents' ('reference_id');
+CREATE INDEX 'usercontent_type_reference_id' ON 'user_contents' ('type', 'reference_id');
+CREATE TABLE 'user_subscriptions' ('id' text NOT NULL, 'created_at' integer NOT NULL, 'updated_at' integer NOT NULL, 'type' text NOT NULL, 'expires_at' integer NOT NULL, 'permissions' text NOT NULL, 'reference_id' text NOT NULL, 'user_id' text NOT NULL, PRIMARY KEY ('id'), CONSTRAINT 'user_subscriptions_users_subscriptions' FOREIGN KEY ('user_id') REFERENCES 'users' ('id') ON DELETE NO ACTION);
+CREATE INDEX 'usersubscription_user_id' ON 'user_subscriptions' ('user_id');
+CREATE INDEX 'usersubscription_type_user_id' ON 'user_subscriptions' ('type', 'user_id');
+CREATE INDEX 'usersubscription_expires_at' ON 'user_subscriptions' ('expires_at');
+CREATE INDEX 'usersubscription_expires_at_user_id' ON 'user_subscriptions' ('expires_at', 'user_id');
+CREATE TABLE 'vehicles' ('id' text NOT NULL, 'created_at' integer NOT NULL, 'updated_at' integer NOT NULL, 'tier' integer NOT NULL, 'localized_names' json NOT NULL, PRIMARY KEY ('id'));
+CREATE TABLE 'vehicle_averages' ('id' text NOT NULL, 'created_at' integer NOT NULL, 'updated_at' integer NOT NULL, 'data' json NOT NULL, PRIMARY KEY ('id'));
+CREATE TABLE 'vehicle_snapshots' ('id' text NOT NULL, 'created_at' integer NOT NULL, 'updated_at' integer NOT NULL, 'type' text NOT NULL, 'vehicle_id' text NOT NULL, 'reference_id' text NOT NULL, 'battles' integer NOT NULL, 'last_battle_time' integer NOT NULL, 'frame' json NOT NULL, 'account_id' text NOT NULL, PRIMARY KEY ('id'), CONSTRAINT 'vehicle_snapshots_accounts_vehicle_snapshots' FOREIGN KEY ('account_id') REFERENCES 'accounts' ('id') ON DELETE NO ACTION);
+CREATE INDEX 'vehiclesnapshot_created_at' ON 'vehicle_snapshots' ('created_at');
+CREATE INDEX 'vehiclesnapshot_vehicle_id_created_at' ON 'vehicle_snapshots' ('vehicle_id', 'created_at');
+CREATE INDEX 'vehiclesnapshot_account_id_created_at' ON 'vehicle_snapshots' ('account_id', 'created_at');
+CREATE INDEX 'vehiclesnapshot_account_id_type_created_at' ON 'vehicle_snapshots' ('account_id', 'type', 'created_at');`
+
+func RunMigrations(client *sql.DB) error {
+	_, err := client.Exec(migration)
+	return err
+}
diff --git a/internal/database/ent/migrate/main.go b/internal/database/ent/migrate/main.go
new file mode 100644
index 00000000..d0ab8587
--- /dev/null
+++ b/internal/database/ent/migrate/main.go
@@ -0,0 +1,40 @@
+// go:build ignore
+
+package main
+
+import (
+	"context"
+	"log"
+	"os"
+
+	atlas "ariga.io/atlas/sql/migrate"
+	"entgo.io/ent/dialect"
+	"entgo.io/ent/dialect/sql/schema"
+	"github.com/cufee/aftermath/internal/database/ent/db/migrate"
+	_ "github.com/tursodatabase/libsql-client-go/libsql"
+)
+
+func main() {
+	ctx := context.Background()
+	// Create a local migration directory able to understand Atlas migration file format for replay.
+	dir, err := atlas.NewLocalDir("internal/database/ent/migrate/migrations")
+	if err != nil {
+		log.Fatalf("failed creating atlas migration directory: %v", err)
+	}
+	// Migrate diff options.
+	opts := []schema.MigrateOption{
+		schema.WithForeignKeys(false),
+		schema.WithDir(dir),                         // provide migration directory
+		schema.WithMigrationMode(schema.ModeReplay), // provide migration mode
+		schema.WithDialect(dialect.SQLite),          // Ent dialect to use
+		schema.WithFormatter(atlas.DefaultFormatter),
+	}
+	if len(os.Args) != 2 {
+		log.Fatalln("migration name is required. Use: 'go run -mod=mod ent/migrate/main.go <name>'")
+	}
+	// Generate migrations using Atlas support for MySQL (note the Ent dialect option passed above).
+	err = migrate.NamedDiff(ctx, "libsql+ws://0.0.0.0:8080", os.Args[1], opts...)
+	if err != nil {
+		log.Fatalf("failed generating migration file: %v", err)
+	}
+}
diff --git a/internal/database/ent/migrate/migrations/20240622203812_init.sql b/internal/database/ent/migrate/migrations/20240622203812_init.sql
new file mode 100644
index 00000000..55d46318
--- /dev/null
+++ b/internal/database/ent/migrate/migrations/20240622203812_init.sql
@@ -0,0 +1,102 @@
+-- Create "accounts" table
+CREATE TABLE `accounts` (`id` text NOT NULL, `created_at` integer NOT NULL, `updated_at` integer NOT NULL, `last_battle_time` integer NOT NULL, `account_created_at` integer NOT NULL, `realm` text NOT NULL, `nickname` text NOT NULL, `private` bool NOT NULL DEFAULT (false), `clan_id` text NULL, PRIMARY KEY (`id`), CONSTRAINT `accounts_clans_accounts` FOREIGN KEY (`clan_id`) REFERENCES `clans` (`id`) ON DELETE SET NULL);
+-- Create index "account_id_last_battle_time" to table: "accounts"
+CREATE INDEX `account_id_last_battle_time` ON `accounts` (`id`, `last_battle_time`);
+-- Create index "account_realm" to table: "accounts"
+CREATE INDEX `account_realm` ON `accounts` (`realm`);
+-- Create index "account_realm_last_battle_time" to table: "accounts"
+CREATE INDEX `account_realm_last_battle_time` ON `accounts` (`realm`, `last_battle_time`);
+-- Create index "account_clan_id" to table: "accounts"
+CREATE INDEX `account_clan_id` ON `accounts` (`clan_id`);
+-- Create "account_snapshots" table
+CREATE TABLE `account_snapshots` (`id` text NOT NULL, `created_at` integer NOT NULL, `updated_at` integer NOT NULL, `type` text NOT NULL, `last_battle_time` integer NOT NULL, `reference_id` text NOT NULL, `rating_battles` integer NOT NULL, `rating_frame` json NOT NULL, `regular_battles` integer NOT NULL, `regular_frame` json NOT NULL, `account_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `account_snapshots_accounts_snapshots` FOREIGN KEY (`account_id`) REFERENCES `accounts` (`id`) ON DELETE NO ACTION);
+-- Create index "accountsnapshot_created_at" to table: "account_snapshots"
+CREATE INDEX `accountsnapshot_created_at` ON `account_snapshots` (`created_at`);
+-- Create index "accountsnapshot_type_account_id_created_at" to table: "account_snapshots"
+CREATE INDEX `accountsnapshot_type_account_id_created_at` ON `account_snapshots` (`type`, `account_id`, `created_at`);
+-- Create index "accountsnapshot_type_account_id_reference_id" to table: "account_snapshots"
+CREATE INDEX `accountsnapshot_type_account_id_reference_id` ON `account_snapshots` (`type`, `account_id`, `reference_id`);
+-- Create index "accountsnapshot_type_account_id_reference_id_created_at" to table: "account_snapshots"
+CREATE INDEX `accountsnapshot_type_account_id_reference_id_created_at` ON `account_snapshots` (`type`, `account_id`, `reference_id`, `created_at`);
+-- Create "achievements_snapshots" table
+CREATE TABLE `achievements_snapshots` (`id` text NOT NULL, `created_at` integer NOT NULL, `updated_at` integer NOT NULL, `type` text NOT NULL, `reference_id` text NOT NULL, `battles` integer NOT NULL, `last_battle_time` integer NOT NULL, `data` json NOT NULL, `account_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `achievements_snapshots_accounts_achievement_snapshots` FOREIGN KEY (`account_id`) REFERENCES `accounts` (`id`) ON DELETE NO ACTION);
+-- Create index "achievementssnapshot_created_at" to table: "achievements_snapshots"
+CREATE INDEX `achievementssnapshot_created_at` ON `achievements_snapshots` (`created_at`);
+-- Create index "achievementssnapshot_account_id_reference_id" to table: "achievements_snapshots"
+CREATE INDEX `achievementssnapshot_account_id_reference_id` ON `achievements_snapshots` (`account_id`, `reference_id`);
+-- Create index "achievementssnapshot_account_id_reference_id_created_at" to table: "achievements_snapshots"
+CREATE INDEX `achievementssnapshot_account_id_reference_id_created_at` ON `achievements_snapshots` (`account_id`, `reference_id`, `created_at`);
+-- Create "app_configurations" table
+CREATE TABLE `app_configurations` (`id` text NOT NULL, `created_at` integer NOT NULL, `updated_at` integer NOT NULL, `key` text NOT NULL, `value` json NOT NULL, `metadata` json NULL, PRIMARY KEY (`id`));
+-- Create index "app_configurations_key_key" to table: "app_configurations"
+CREATE UNIQUE INDEX `app_configurations_key_key` ON `app_configurations` (`key`);
+-- Create index "appconfiguration_key" to table: "app_configurations"
+CREATE INDEX `appconfiguration_key` ON `app_configurations` (`key`);
+-- Create "application_commands" table
+CREATE TABLE `application_commands` (`id` text NOT NULL, `created_at` integer NOT NULL, `updated_at` integer NOT NULL, `name` text NOT NULL, `version` text NOT NULL, `options_hash` text NOT NULL, PRIMARY KEY (`id`));
+-- Create index "application_commands_name_key" to table: "application_commands"
+CREATE UNIQUE INDEX `application_commands_name_key` ON `application_commands` (`name`);
+-- Create index "applicationcommand_options_hash" to table: "application_commands"
+CREATE INDEX `applicationcommand_options_hash` ON `application_commands` (`options_hash`);
+-- Create "clans" table
+CREATE TABLE `clans` (`id` text NOT NULL, `created_at` integer NOT NULL, `updated_at` integer NOT NULL, `tag` text NOT NULL, `name` text NOT NULL, `emblem_id` text NULL DEFAULT (''), `members` json NOT NULL, PRIMARY KEY (`id`));
+-- Create index "clan_tag" to table: "clans"
+CREATE INDEX `clan_tag` ON `clans` (`tag`);
+-- Create index "clan_name" to table: "clans"
+CREATE INDEX `clan_name` ON `clans` (`name`);
+-- Create "cron_tasks" table
+CREATE TABLE `cron_tasks` (`id` text NOT NULL, `created_at` integer NOT NULL, `updated_at` integer NOT NULL, `type` text NOT NULL, `reference_id` text NOT NULL, `targets` json NOT NULL, `status` text NOT NULL, `scheduled_after` integer NOT NULL, `last_run` integer NOT NULL, `logs` json NOT NULL, `data` json NOT NULL, PRIMARY KEY (`id`));
+-- Create index "crontask_reference_id" to table: "cron_tasks"
+CREATE INDEX `crontask_reference_id` ON `cron_tasks` (`reference_id`);
+-- Create index "crontask_status_last_run" to table: "cron_tasks"
+CREATE INDEX `crontask_status_last_run` ON `cron_tasks` (`status`, `last_run`);
+-- Create index "crontask_status_created_at" to table: "cron_tasks"
+CREATE INDEX `crontask_status_created_at` ON `cron_tasks` (`status`, `created_at`);
+-- Create index "crontask_status_scheduled_after" to table: "cron_tasks"
+CREATE INDEX `crontask_status_scheduled_after` ON `cron_tasks` (`status`, `scheduled_after`);
+-- Create "users" table
+CREATE TABLE `users` (`id` text NOT NULL, `created_at` integer NOT NULL, `updated_at` integer NOT NULL, `permissions` text NOT NULL DEFAULT (''), `feature_flags` json NULL, PRIMARY KEY (`id`));
+-- Create "user_connections" table
+CREATE TABLE `user_connections` (`id` text NOT NULL, `created_at` integer NOT NULL, `updated_at` integer NOT NULL, `type` text NOT NULL, `reference_id` text NOT NULL, `permissions` text NULL DEFAULT (''), `metadata` json NULL, `user_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `user_connections_users_connections` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE NO ACTION);
+-- Create index "userconnection_user_id" to table: "user_connections"
+CREATE INDEX `userconnection_user_id` ON `user_connections` (`user_id`);
+-- Create index "userconnection_type_user_id" to table: "user_connections"
+CREATE INDEX `userconnection_type_user_id` ON `user_connections` (`type`, `user_id`);
+-- Create index "userconnection_reference_id" to table: "user_connections"
+CREATE INDEX `userconnection_reference_id` ON `user_connections` (`reference_id`);
+-- Create index "userconnection_type_reference_id" to table: "user_connections"
+CREATE INDEX `userconnection_type_reference_id` ON `user_connections` (`type`, `reference_id`);
+-- Create "user_contents" table
+CREATE TABLE `user_contents` (`id` text NOT NULL, `created_at` integer NOT NULL, `updated_at` integer NOT NULL, `type` text NOT NULL, `reference_id` text NOT NULL, `value` json NOT NULL, `metadata` json NOT NULL, `user_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `user_contents_users_content` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE NO ACTION);
+-- Create index "usercontent_user_id" to table: "user_contents"
+CREATE INDEX `usercontent_user_id` ON `user_contents` (`user_id`);
+-- Create index "usercontent_type_user_id" to table: "user_contents"
+CREATE INDEX `usercontent_type_user_id` ON `user_contents` (`type`, `user_id`);
+-- Create index "usercontent_reference_id" to table: "user_contents"
+CREATE INDEX `usercontent_reference_id` ON `user_contents` (`reference_id`);
+-- Create index "usercontent_type_reference_id" to table: "user_contents"
+CREATE INDEX `usercontent_type_reference_id` ON `user_contents` (`type`, `reference_id`);
+-- Create "user_subscriptions" table
+CREATE TABLE `user_subscriptions` (`id` text NOT NULL, `created_at` integer NOT NULL, `updated_at` integer NOT NULL, `type` text NOT NULL, `expires_at` integer NOT NULL, `permissions` text NOT NULL, `reference_id` text NOT NULL, `user_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `user_subscriptions_users_subscriptions` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE NO ACTION);
+-- Create index "usersubscription_user_id" to table: "user_subscriptions"
+CREATE INDEX `usersubscription_user_id` ON `user_subscriptions` (`user_id`);
+-- Create index "usersubscription_type_user_id" to table: "user_subscriptions"
+CREATE INDEX `usersubscription_type_user_id` ON `user_subscriptions` (`type`, `user_id`);
+-- Create index "usersubscription_expires_at" to table: "user_subscriptions"
+CREATE INDEX `usersubscription_expires_at` ON `user_subscriptions` (`expires_at`);
+-- Create index "usersubscription_expires_at_user_id" to table: "user_subscriptions"
+CREATE INDEX `usersubscription_expires_at_user_id` ON `user_subscriptions` (`expires_at`, `user_id`);
+-- Create "vehicles" table
+CREATE TABLE `vehicles` (`id` text NOT NULL, `created_at` integer NOT NULL, `updated_at` integer NOT NULL, `tier` integer NOT NULL, `localized_names` json NOT NULL, PRIMARY KEY (`id`));
+-- Create "vehicle_averages" table
+CREATE TABLE `vehicle_averages` (`id` text NOT NULL, `created_at` integer NOT NULL, `updated_at` integer NOT NULL, `data` json NOT NULL, PRIMARY KEY (`id`));
+-- Create "vehicle_snapshots" table
+CREATE TABLE `vehicle_snapshots` (`id` text NOT NULL, `created_at` integer NOT NULL, `updated_at` integer NOT NULL, `type` text NOT NULL, `vehicle_id` text NOT NULL, `reference_id` text NOT NULL, `battles` integer NOT NULL, `last_battle_time` integer NOT NULL, `frame` json NOT NULL, `account_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `vehicle_snapshots_accounts_vehicle_snapshots` FOREIGN KEY (`account_id`) REFERENCES `accounts` (`id`) ON DELETE NO ACTION);
+-- Create index "vehiclesnapshot_created_at" to table: "vehicle_snapshots"
+CREATE INDEX `vehiclesnapshot_created_at` ON `vehicle_snapshots` (`created_at`);
+-- Create index "vehiclesnapshot_vehicle_id_created_at" to table: "vehicle_snapshots"
+CREATE INDEX `vehiclesnapshot_vehicle_id_created_at` ON `vehicle_snapshots` (`vehicle_id`, `created_at`);
+-- Create index "vehiclesnapshot_account_id_created_at" to table: "vehicle_snapshots"
+CREATE INDEX `vehiclesnapshot_account_id_created_at` ON `vehicle_snapshots` (`account_id`, `created_at`);
+-- Create index "vehiclesnapshot_account_id_type_created_at" to table: "vehicle_snapshots"
+CREATE INDEX `vehiclesnapshot_account_id_type_created_at` ON `vehicle_snapshots` (`account_id`, `type`, `created_at`);
diff --git a/internal/database/ent/migrate/migrations/atlas.sum b/internal/database/ent/migrate/migrations/atlas.sum
new file mode 100644
index 00000000..4c057533
--- /dev/null
+++ b/internal/database/ent/migrate/migrations/atlas.sum
@@ -0,0 +1,2 @@
+h1:lIjXgF0PT71x+0IXOVk9uiIK/23v6AlTegTXIaTyyZI=
+20240622203812_init.sql h1:Rt6NGvXbPBEpjg1pUFqn97FV8X3X2d1x7J2zOAAxolc=
diff --git a/internal/database/ent/schema/account.go b/internal/database/ent/schema/account.go
new file mode 100644
index 00000000..4df6d398
--- /dev/null
+++ b/internal/database/ent/schema/account.go
@@ -0,0 +1,57 @@
+package schema
+
+import (
+	"entgo.io/ent"
+	"entgo.io/ent/schema/edge"
+	"entgo.io/ent/schema/field"
+	"entgo.io/ent/schema/index"
+)
+
+// Account holds the schema definition for the Account entity.
+type Account struct {
+	ent.Schema
+}
+
+// Fields of the Account.
+func (Account) Fields() []ent.Field {
+	return []ent.Field{field.String("id").
+		Unique().
+		Immutable(),
+		field.Int("created_at").
+			Immutable().
+			DefaultFunc(timeNow),
+		field.Int("updated_at").
+			DefaultFunc(timeNow).
+			UpdateDefault(timeNow),
+		field.Int("last_battle_time"),
+		field.Int("account_created_at"),
+		//
+		field.String("realm").
+			MinLen(2).
+			MaxLen(5),
+		field.String("nickname").NotEmpty(),
+		field.Bool("private").
+			Default(false),
+		//
+		field.String("clan_id").Optional(),
+	}
+}
+
+// Edges of the Account.
+func (Account) Edges() []ent.Edge {
+	return []ent.Edge{
+		edge.From("clan", Clan.Type).Ref("accounts").Field("clan_id").Unique(),
+		edge.To("snapshots", AccountSnapshot.Type),
+		edge.To("vehicle_snapshots", VehicleSnapshot.Type),
+		edge.To("achievement_snapshots", AchievementsSnapshot.Type),
+	}
+}
+
+func (Account) Indexes() []ent.Index {
+	return []ent.Index{
+		index.Fields("id", "last_battle_time"),
+		index.Fields("realm"),
+		index.Fields("realm", "last_battle_time"),
+		index.Fields("clan_id"),
+	}
+}
diff --git a/internal/database/ent/schema/accountsnapshot.go b/internal/database/ent/schema/accountsnapshot.go
new file mode 100644
index 00000000..6a33c4c4
--- /dev/null
+++ b/internal/database/ent/schema/accountsnapshot.go
@@ -0,0 +1,49 @@
+package schema
+
+import (
+	"entgo.io/ent"
+	"entgo.io/ent/schema/edge"
+	"entgo.io/ent/schema/field"
+	"entgo.io/ent/schema/index"
+	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/stats/frame"
+)
+
+// AccountSnapshot holds the schema definition for the AccountSnapshot entity.
+type AccountSnapshot struct {
+	ent.Schema
+}
+
+// Fields of the AccountSnapshot.
+func (AccountSnapshot) Fields() []ent.Field {
+	return append(defaultFields,
+		field.Enum("type").
+			GoType(models.SnapshotType("")),
+		field.Int("last_battle_time"),
+		//
+		field.String("account_id").NotEmpty().Immutable(),
+		field.String("reference_id").NotEmpty(),
+		//
+		field.Int("rating_battles"),
+		field.JSON("rating_frame", frame.StatsFrame{}),
+		//
+		field.Int("regular_battles"),
+		field.JSON("regular_frame", frame.StatsFrame{}),
+	)
+}
+
+// Edges of the AccountSnapshot.
+func (AccountSnapshot) Edges() []ent.Edge {
+	return []ent.Edge{
+		edge.From("account", Account.Type).Ref("snapshots").Field("account_id").Required().Immutable().Unique(),
+	}
+}
+
+func (AccountSnapshot) Indexes() []ent.Index {
+	return []ent.Index{
+		index.Fields("created_at"),
+		index.Fields("type", "account_id", "created_at"),
+		index.Fields("type", "account_id", "reference_id"),
+		index.Fields("type", "account_id", "reference_id", "created_at"),
+	}
+}
diff --git a/internal/database/ent/schema/achievementssnapshot.go b/internal/database/ent/schema/achievementssnapshot.go
new file mode 100644
index 00000000..bfd87368
--- /dev/null
+++ b/internal/database/ent/schema/achievementssnapshot.go
@@ -0,0 +1,44 @@
+package schema
+
+import (
+	"entgo.io/ent"
+	"entgo.io/ent/schema/edge"
+	"entgo.io/ent/schema/field"
+	"entgo.io/ent/schema/index"
+	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/am-wg-proxy-next/v2/types"
+)
+
+// AchievementsSnapshot holds the schema definition for the AchievementsSnapshot entity.
+type AchievementsSnapshot struct {
+	ent.Schema
+}
+
+// Fields of the AchievementsSnapshot.
+func (AchievementsSnapshot) Fields() []ent.Field {
+	return append(defaultFields,
+		field.Enum("type").
+			GoType(models.SnapshotType("")),
+		field.String("account_id").NotEmpty().Immutable(),
+		field.String("reference_id").NotEmpty(),
+		//
+		field.Int("battles"),
+		field.Int("last_battle_time"),
+		field.JSON("data", types.AchievementsFrame{}),
+	)
+}
+
+// Edges of the AchievementsSnapshot.
+func (AchievementsSnapshot) Edges() []ent.Edge {
+	return []ent.Edge{
+		edge.From("account", Account.Type).Ref("achievement_snapshots").Field("account_id").Required().Immutable().Unique(),
+	}
+}
+
+func (AchievementsSnapshot) Indexes() []ent.Index {
+	return []ent.Index{
+		index.Fields("created_at"),
+		index.Fields("account_id", "reference_id"),
+		index.Fields("account_id", "reference_id", "created_at"),
+	}
+}
diff --git a/internal/database/ent/schema/appconfiguration.go b/internal/database/ent/schema/appconfiguration.go
new file mode 100644
index 00000000..96ce0b6e
--- /dev/null
+++ b/internal/database/ent/schema/appconfiguration.go
@@ -0,0 +1,33 @@
+package schema
+
+import (
+	"entgo.io/ent"
+	"entgo.io/ent/schema/field"
+	"entgo.io/ent/schema/index"
+)
+
+// AppConfiguration holds the schema definition for the AppConfiguration entity.
+type AppConfiguration struct {
+	ent.Schema
+}
+
+// Fields of the AppConfiguration.
+func (AppConfiguration) Fields() []ent.Field {
+	return append(defaultFields,
+		field.String("key").Unique().NotEmpty(),
+		//
+		field.Any("value"),
+		field.JSON("metadata", map[string]any{}).Optional(),
+	)
+}
+
+// Edges of the AppConfiguration.
+func (AppConfiguration) Edges() []ent.Edge {
+	return nil
+}
+
+func (AppConfiguration) Indexes() []ent.Index {
+	return []ent.Index{
+		index.Fields("key"),
+	}
+}
diff --git a/internal/database/ent/schema/applicationcommand.go b/internal/database/ent/schema/applicationcommand.go
new file mode 100644
index 00000000..71f68cf3
--- /dev/null
+++ b/internal/database/ent/schema/applicationcommand.go
@@ -0,0 +1,45 @@
+package schema
+
+import (
+	"entgo.io/ent"
+	"entgo.io/ent/schema/field"
+	"entgo.io/ent/schema/index"
+)
+
+// model ApplicationCommand {
+//   id        String   @id
+//   createdAt DateTime @default(now())
+//   updatedAt DateTime @updatedAt
+
+//   name        String
+//   version     String
+//   optionsHash String
+
+//   @@index([optionsHash])
+//   @@map("application_commands")
+// }
+
+// ApplicationCommand holds the schema definition for the ApplicationCommand entity.
+type ApplicationCommand struct {
+	ent.Schema
+}
+
+// Fields of the ApplicationCommand.
+func (ApplicationCommand) Fields() []ent.Field {
+	return append(defaultFields,
+		field.String("name").Unique().NotEmpty(),
+		field.String("version").NotEmpty(),
+		field.String("options_hash").NotEmpty(),
+	)
+}
+
+// Edges of the ApplicationCommand.
+func (ApplicationCommand) Edges() []ent.Edge {
+	return nil
+}
+
+func (ApplicationCommand) Indexes() []ent.Index {
+	return []ent.Index{
+		index.Fields("options_hash"),
+	}
+}
diff --git a/internal/database/ent/schema/clan.go b/internal/database/ent/schema/clan.go
new file mode 100644
index 00000000..9b953820
--- /dev/null
+++ b/internal/database/ent/schema/clan.go
@@ -0,0 +1,65 @@
+package schema
+
+import (
+	"entgo.io/ent"
+	"entgo.io/ent/schema/edge"
+	"entgo.io/ent/schema/field"
+	"entgo.io/ent/schema/index"
+)
+
+// model Clan {
+//   id        String   @id
+//   createdAt DateTime
+//   updatedAt DateTime @updatedAt
+
+//   tag      String
+//   name     String
+//   emblemId String @default("")
+
+//   accounts      Account[]
+//   membersString String
+
+//   recordUpdatedAt DateTime @updatedAt
+
+//   @@index([tag])
+//   @@map("account_clans")
+// }
+
+// Clan holds the schema definition for the Clan entity.
+type Clan struct {
+	ent.Schema
+}
+
+// Fields of the Clan.
+func (Clan) Fields() []ent.Field {
+	return []ent.Field{
+		field.String("id").
+			Unique().
+			Immutable(),
+		field.Int("created_at").
+			Immutable().
+			DefaultFunc(timeNow),
+		field.Int("updated_at").
+			DefaultFunc(timeNow).
+			UpdateDefault(timeNow),
+		//
+		field.String("tag").NotEmpty(),
+		field.String("name").NotEmpty(),
+		field.String("emblem_id").Default("").Optional(),
+		field.Strings("members"),
+	}
+}
+
+// Edges of the Clan.
+func (Clan) Edges() []ent.Edge {
+	return []ent.Edge{
+		edge.To("accounts", Account.Type),
+	}
+}
+
+func (Clan) Indexes() []ent.Index {
+	return []ent.Index{
+		index.Fields("tag"),
+		index.Fields("name"),
+	}
+}
diff --git a/internal/database/ent/schema/crontask.go b/internal/database/ent/schema/crontask.go
new file mode 100644
index 00000000..f214f55d
--- /dev/null
+++ b/internal/database/ent/schema/crontask.go
@@ -0,0 +1,43 @@
+package schema
+
+import (
+	"entgo.io/ent"
+	"entgo.io/ent/schema/field"
+	"entgo.io/ent/schema/index"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+// CronTask holds the schema definition for the CronTask entity.
+type CronTask struct {
+	ent.Schema
+}
+
+// Fields of the CronTask.
+func (CronTask) Fields() []ent.Field {
+	return append(defaultFields,
+		field.String("type").NotEmpty(),
+		field.String("reference_id").NotEmpty(),
+		field.Strings("targets"),
+		//
+		field.String("status").NotEmpty(),
+		field.Int("scheduled_after"),
+		field.Int("last_run"),
+		//
+		field.JSON("logs", []models.TaskLog{}),
+		field.JSON("data", map[string]any{}),
+	)
+}
+
+// Edges of the CronTask.
+func (CronTask) Edges() []ent.Edge {
+	return nil
+}
+
+func (CronTask) Indexes() []ent.Index {
+	return []ent.Index{
+		index.Fields("reference_id"),
+		index.Fields("status", "last_run"),
+		index.Fields("status", "created_at"),
+		index.Fields("status", "scheduled_after"),
+	}
+}
diff --git a/internal/database/ent/schema/defaults.go b/internal/database/ent/schema/defaults.go
new file mode 100644
index 00000000..ddf92c1c
--- /dev/null
+++ b/internal/database/ent/schema/defaults.go
@@ -0,0 +1,24 @@
+package schema
+
+import (
+	"time"
+
+	"entgo.io/ent"
+	"entgo.io/ent/schema/field"
+	"github.com/lucsky/cuid"
+)
+
+var defaultFields = []ent.Field{
+	field.String("id").
+		Unique().
+		Immutable().
+		DefaultFunc(cuid.New),
+	field.Int("created_at").
+		Immutable().
+		DefaultFunc(timeNow),
+	field.Int("updated_at").
+		DefaultFunc(timeNow).
+		UpdateDefault(timeNow),
+}
+
+func timeNow() int { return int(time.Now().Unix()) }
diff --git a/internal/database/ent/schema/user.go b/internal/database/ent/schema/user.go
new file mode 100644
index 00000000..188f638f
--- /dev/null
+++ b/internal/database/ent/schema/user.go
@@ -0,0 +1,43 @@
+package schema
+
+import (
+	"entgo.io/ent"
+	"entgo.io/ent/schema/edge"
+	"entgo.io/ent/schema/field"
+)
+
+// User holds the schema definition for the User entity.
+type User struct {
+	ent.Schema
+}
+
+// Fields of the User.
+func (User) Fields() []ent.Field {
+	return []ent.Field{
+		field.String("id").
+			Unique().
+			Immutable(),
+		field.Int("created_at").
+			Immutable().
+			DefaultFunc(timeNow),
+		field.Int("updated_at").
+			DefaultFunc(timeNow).
+			UpdateDefault(timeNow),
+		//
+		field.String("permissions").Default(""),
+		field.Strings("feature_flags").Optional(),
+	}
+}
+
+// Edges of the User.
+func (User) Edges() []ent.Edge {
+	return []ent.Edge{
+		edge.To("subscriptions", UserSubscription.Type),
+		edge.To("connections", UserConnection.Type),
+		edge.To("content", UserContent.Type),
+	}
+}
+
+func (User) Indexes() []ent.Index {
+	return []ent.Index{}
+}
diff --git a/internal/database/ent/schema/userconnection.go b/internal/database/ent/schema/userconnection.go
new file mode 100644
index 00000000..bc04fe6b
--- /dev/null
+++ b/internal/database/ent/schema/userconnection.go
@@ -0,0 +1,64 @@
+package schema
+
+import (
+	"entgo.io/ent"
+	"entgo.io/ent/schema/edge"
+	"entgo.io/ent/schema/field"
+	"entgo.io/ent/schema/index"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+// model UserConnection {
+//   id        String   @id @default(cuid())
+//   createdAt DateTime @default(now())
+//   updatedAt DateTime @updatedAt
+
+//   user   User   @relation(fields: [userId], references: [id])
+//   userId String
+
+//   type        String
+//   permissions String
+//   referenceId String
+
+//   metadataEncoded Bytes
+
+//   @@index([userId])
+//   @@index([type, userId])
+//   @@index([referenceId])
+//   @@index([type, referenceId])
+//   @@map("user_connections")
+// }
+
+// UserConnection holds the schema definition for the UserConnection entity.
+type UserConnection struct {
+	ent.Schema
+}
+
+// Fields of the UserConnection.
+func (UserConnection) Fields() []ent.Field {
+	return append(defaultFields,
+		field.Enum("type").
+			GoType(models.ConnectionType("")),
+		field.String("user_id").Immutable(),
+		field.String("reference_id"),
+		field.String("permissions").Default("").Optional(),
+		field.JSON("metadata", map[string]any{}).Optional(),
+	)
+}
+
+// Edges of the UserConnection.
+func (UserConnection) Edges() []ent.Edge {
+	return []ent.Edge{
+		edge.From("user", User.Type).Ref("connections").Field("user_id").Required().Immutable().Unique(),
+	}
+}
+
+func (UserConnection) Indexes() []ent.Index {
+	return []ent.Index{
+		index.Fields("user_id"),
+		index.Fields("type", "user_id"),
+		index.Fields("reference_id"),
+		index.Fields("type", "reference_id"),
+		// index.Fields("reference_id").Edges("user").Unique(),
+	}
+}
diff --git a/internal/database/ent/schema/usercontent.go b/internal/database/ent/schema/usercontent.go
new file mode 100644
index 00000000..9895f2b6
--- /dev/null
+++ b/internal/database/ent/schema/usercontent.go
@@ -0,0 +1,43 @@
+package schema
+
+import (
+	"entgo.io/ent"
+	"entgo.io/ent/schema/edge"
+	"entgo.io/ent/schema/field"
+	"entgo.io/ent/schema/index"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+// UserContent holds the schema definition for the UserContent entity.
+type UserContent struct {
+	ent.Schema
+}
+
+// Fields of the UserContent.
+func (UserContent) Fields() []ent.Field {
+	return append(defaultFields,
+		field.Enum("type").
+			GoType(models.UserContentType("")),
+		field.String("user_id").Immutable(),
+		field.String("reference_id"),
+		//
+		field.Any("value"),
+		field.JSON("metadata", map[string]any{}),
+	)
+}
+
+// Edges of the UserContent.
+func (UserContent) Edges() []ent.Edge {
+	return []ent.Edge{
+		edge.From("user", User.Type).Ref("content").Field("user_id").Required().Immutable().Unique(),
+	}
+}
+
+func (UserContent) Indexes() []ent.Index {
+	return []ent.Index{
+		index.Fields("user_id"),
+		index.Fields("type", "user_id"),
+		index.Fields("reference_id"),
+		index.Fields("type", "reference_id"),
+	}
+}
diff --git a/internal/database/ent/schema/usersubscription.go b/internal/database/ent/schema/usersubscription.go
new file mode 100644
index 00000000..2394efdb
--- /dev/null
+++ b/internal/database/ent/schema/usersubscription.go
@@ -0,0 +1,43 @@
+package schema
+
+import (
+	"entgo.io/ent"
+	"entgo.io/ent/schema/edge"
+	"entgo.io/ent/schema/field"
+	"entgo.io/ent/schema/index"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+// UserSubscription holds the schema definition for the UserSubscription entity.
+type UserSubscription struct {
+	ent.Schema
+}
+
+// Fields of the UserSubscription.
+func (UserSubscription) Fields() []ent.Field {
+	return append(defaultFields,
+		field.Enum("type").
+			GoType(models.SubscriptionType("")),
+		field.Int("expires_at"),
+		//
+		field.String("user_id").NotEmpty().Immutable(),
+		field.String("permissions").NotEmpty(),
+		field.String("reference_id").NotEmpty(),
+	)
+}
+
+// Edges of the UserSubscription.
+func (UserSubscription) Edges() []ent.Edge {
+	return []ent.Edge{
+		edge.From("user", User.Type).Ref("subscriptions").Field("user_id").Required().Immutable().Unique(),
+	}
+}
+
+func (UserSubscription) Indexes() []ent.Index {
+	return []ent.Index{
+		index.Fields("user_id"),
+		index.Fields("type", "user_id"),
+		index.Fields("expires_at"),
+		index.Fields("expires_at", "user_id"),
+	}
+}
diff --git a/internal/database/ent/schema/vehicle.go b/internal/database/ent/schema/vehicle.go
new file mode 100644
index 00000000..525287a0
--- /dev/null
+++ b/internal/database/ent/schema/vehicle.go
@@ -0,0 +1,41 @@
+package schema
+
+import (
+	"entgo.io/ent"
+	"entgo.io/ent/schema/field"
+)
+
+// Vehicle holds the schema definition for the Vehicle entity.
+type Vehicle struct {
+	ent.Schema
+}
+
+// Fields of the Vehicle.
+func (Vehicle) Fields() []ent.Field {
+	return []ent.Field{
+		field.String("id").
+			Unique().
+			Immutable(),
+		field.Int("created_at").
+			Immutable().
+			DefaultFunc(timeNow),
+		field.Int("updated_at").
+			DefaultFunc(timeNow).
+			UpdateDefault(timeNow),
+		//
+		field.Int("tier").
+			Min(0). // vehicle that does not exist in official glossary has tier set to 0
+			Max(10),
+		field.JSON("localized_names", map[string]string{}),
+	}
+
+}
+
+// Edges of the Vehicle.
+func (Vehicle) Edges() []ent.Edge {
+	return nil
+}
+
+func (Vehicle) Indexes() []ent.Index {
+	return nil
+}
diff --git a/internal/database/ent/schema/vehicleaverage.go b/internal/database/ent/schema/vehicleaverage.go
new file mode 100644
index 00000000..edb1798a
--- /dev/null
+++ b/internal/database/ent/schema/vehicleaverage.go
@@ -0,0 +1,38 @@
+package schema
+
+import (
+	"entgo.io/ent"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/stats/frame"
+)
+
+// VehicleAverage holds the schema definition for the VehicleAverage entity.
+type VehicleAverage struct {
+	ent.Schema
+}
+
+// Fields of the VehicleAverage.
+func (VehicleAverage) Fields() []ent.Field {
+	return []ent.Field{
+		field.String("id").
+			Unique().
+			Immutable(),
+		field.Int("created_at").
+			Immutable().
+			DefaultFunc(timeNow),
+		field.Int("updated_at").
+			DefaultFunc(timeNow).
+			UpdateDefault(timeNow),
+		//
+		field.JSON("data", map[string]frame.StatsFrame{}),
+	}
+}
+
+// Edges of the VehicleAverage.
+func (VehicleAverage) Edges() []ent.Edge {
+	return nil
+}
+
+func (VehicleAverage) Indexes() []ent.Index {
+	return nil
+}
diff --git a/internal/database/ent/schema/vehiclesnapshot.go b/internal/database/ent/schema/vehiclesnapshot.go
new file mode 100644
index 00000000..88dc1fa1
--- /dev/null
+++ b/internal/database/ent/schema/vehiclesnapshot.go
@@ -0,0 +1,47 @@
+package schema
+
+import (
+	"entgo.io/ent"
+	"entgo.io/ent/schema/edge"
+	"entgo.io/ent/schema/field"
+	"entgo.io/ent/schema/index"
+	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/stats/frame"
+)
+
+// VehicleSnapshot holds the schema definition for the VehicleSnapshot entity.
+type VehicleSnapshot struct {
+	ent.Schema
+}
+
+// Fields of the VehicleSnapshot.
+func (VehicleSnapshot) Fields() []ent.Field {
+	return append(defaultFields,
+		field.Enum("type").
+			GoType(models.SnapshotType("")),
+		//
+		field.String("account_id").NotEmpty().Immutable(),
+		field.String("vehicle_id").NotEmpty().Immutable(),
+		field.String("reference_id").NotEmpty(),
+		//
+		field.Int("battles"),
+		field.Int("last_battle_time"),
+		field.JSON("frame", frame.StatsFrame{}),
+	)
+}
+
+// Edges of the VehicleSnapshot.
+func (VehicleSnapshot) Edges() []ent.Edge {
+	return []ent.Edge{
+		edge.From("account", Account.Type).Ref("vehicle_snapshots").Field("account_id").Required().Immutable().Unique(),
+	}
+}
+
+func (VehicleSnapshot) Indexes() []ent.Index {
+	return []ent.Index{
+		index.Fields("created_at"),
+		index.Fields("vehicle_id", "created_at"),
+		index.Fields("account_id", "created_at"),
+		index.Fields("account_id", "type", "created_at"),
+	}
+}
diff --git a/internal/database/errors.go b/internal/database/errors.go
new file mode 100644
index 00000000..3bf7ea53
--- /dev/null
+++ b/internal/database/errors.go
@@ -0,0 +1,7 @@
+package database
+
+import "github.com/cufee/aftermath/internal/database/ent/db"
+
+func IsNotFound(err error) bool {
+	return db.IsNotFound(err)
+}
diff --git a/internal/database/models/account.go b/internal/database/models/account.go
new file mode 100644
index 00000000..773bfdca
--- /dev/null
+++ b/internal/database/models/account.go
@@ -0,0 +1,16 @@
+package models
+
+import "time"
+
+type Account struct {
+	ID       string
+	Realm    string
+	Nickname string
+
+	Private        bool
+	CreatedAt      time.Time
+	LastBattleTime time.Time
+
+	ClanID  string
+	ClanTag string
+}
diff --git a/internal/database/models/account_snapshot.go b/internal/database/models/account_snapshot.go
new file mode 100644
index 00000000..21912618
--- /dev/null
+++ b/internal/database/models/account_snapshot.go
@@ -0,0 +1,18 @@
+package models
+
+import (
+	"time"
+
+	"github.com/cufee/aftermath/internal/stats/frame"
+)
+
+type AccountSnapshot struct {
+	ID             string
+	Type           SnapshotType
+	CreatedAt      time.Time
+	AccountID      string
+	ReferenceID    string
+	LastBattleTime time.Time
+	RatingBattles  frame.StatsFrame
+	RegularBattles frame.StatsFrame
+}
diff --git a/internal/database/models/application_command.go b/internal/database/models/application_command.go
new file mode 100644
index 00000000..b3df3693
--- /dev/null
+++ b/internal/database/models/application_command.go
@@ -0,0 +1,8 @@
+package models
+
+type ApplicationCommand struct {
+	ID      string
+	Hash    string
+	Name    string
+	Version string
+}
diff --git a/internal/database/models/task.go b/internal/database/models/task.go
new file mode 100644
index 00000000..bb1ad319
--- /dev/null
+++ b/internal/database/models/task.go
@@ -0,0 +1,139 @@
+package models
+
+import (
+	"encoding/json"
+	"strings"
+	"time"
+
+	"github.com/cufee/aftermath/internal/encoding"
+)
+
+type TaskType string
+
+const (
+	TaskTypeUpdateClans              TaskType = "UPDATE_CLANS"
+	TaskTypeRecordSessions           TaskType = "RECORD_ACCOUNT_SESSIONS"
+	TaskTypeUpdateAccountWN8         TaskType = "UPDATE_ACCOUNT_WN8"
+	TaskTypeRecordPlayerAchievements TaskType = "UPDATE_ACCOUNT_ACHIEVEMENTS"
+
+	TaskTypeDatabaseCleanup TaskType = "CLEANUP_DATABASE"
+)
+
+// Values provides list valid values for Enum.
+func (TaskType) Values() []string {
+	var kinds []string
+	for _, s := range []TaskType{
+		TaskTypeUpdateClans,
+		TaskTypeRecordSessions,
+		TaskTypeUpdateAccountWN8,
+		TaskTypeRecordPlayerAchievements,
+		//
+		TaskTypeDatabaseCleanup,
+	} {
+		kinds = append(kinds, string(s))
+	}
+	return kinds
+}
+
+// Task statuses
+type TaskStatus string
+
+const (
+	TaskStatusScheduled  TaskStatus = "TASK_SCHEDULED"
+	TaskStatusInProgress TaskStatus = "TASK_IN_PROGRESS"
+	TaskStatusComplete   TaskStatus = "TASK_COMPLETE"
+	TaskStatusFailed     TaskStatus = "TASK_FAILED"
+)
+
+// Values provides list valid values for Enum.
+func (TaskStatus) Values() []string {
+	var kinds []string
+	for _, s := range []TaskStatus{
+		TaskStatusScheduled,
+		TaskStatusInProgress,
+		TaskStatusComplete,
+		TaskStatusFailed,
+	} {
+		kinds = append(kinds, string(s))
+	}
+	return kinds
+}
+
+type Task struct {
+	ID        string    `json:"id"`
+	Type      TaskType  `json:"kind"`
+	CreatedAt time.Time `json:"createdAt"`
+	UpdatedAt time.Time `json:"updatedAt"`
+
+	ReferenceID string   `json:"referenceId"`
+	Targets     []string `json:"targets"`
+
+	Logs []TaskLog `json:"logs"`
+
+	Status         TaskStatus `json:"status"`
+	ScheduledAfter time.Time  `json:"scheduledAfter"`
+	LastRun        time.Time  `json:"lastRun"`
+
+	Data map[string]any `json:"data"`
+}
+
+func (t *Task) LogAttempt(log TaskLog) {
+	t.Logs = append(t.Logs, log)
+}
+
+func (t *Task) OnCreated() {
+	t.LastRun = time.Now()
+	t.CreatedAt = time.Now()
+	t.UpdatedAt = time.Now()
+}
+func (t *Task) OnUpdated() {
+	t.UpdatedAt = time.Now()
+}
+
+func (t *Task) encodeTargets() []byte {
+	return []byte(strings.Join(t.Targets, ";"))
+}
+func (t *Task) decodeTargets(targets []byte) {
+	if string(targets) != "" {
+		t.Targets = strings.Split(string(targets), ";")
+	}
+}
+
+func (t *Task) encodeLogs() []byte {
+	if t.Logs == nil {
+		return []byte{}
+	}
+	data, _ := json.Marshal(t.Logs)
+	return data
+}
+func (t *Task) decodeLogs(logs []byte) {
+	_ = json.Unmarshal(logs, &t.Logs)
+}
+
+func (t *Task) encodeData() []byte {
+	if t.Data == nil {
+		return []byte{}
+	}
+	data, _ := encoding.EncodeGob(t.Data)
+	return data
+}
+func (t *Task) decodeData(data []byte) {
+	t.Data = make(map[string]any)
+	_ = encoding.DecodeGob(data, &t.Data)
+}
+
+type TaskLog struct {
+	Targets   []string  `json:"targets" bson:"targets"`
+	Timestamp time.Time `json:"timestamp" bson:"timestamp"`
+	Comment   string    `json:"result" bson:"result"`
+	Error     string    `json:"error" bson:"error"`
+}
+
+func NewAttemptLog(task Task, comment, err string) TaskLog {
+	return TaskLog{
+		Targets:   task.Targets,
+		Timestamp: time.Now(),
+		Comment:   comment,
+		Error:     err,
+	}
+}
diff --git a/internal/database/models/user.go b/internal/database/models/user.go
new file mode 100644
index 00000000..ae6172c4
--- /dev/null
+++ b/internal/database/models/user.go
@@ -0,0 +1,30 @@
+package models
+
+import "github.com/cufee/aftermath/internal/permissions"
+
+type User struct {
+	ID string
+
+	Permissions permissions.Permissions
+
+	Connections   []UserConnection
+	Subscriptions []UserSubscription
+}
+
+func (u User) Connection(kind ConnectionType) (UserConnection, bool) {
+	for _, connection := range u.Connections {
+		if connection.Type == kind {
+			return connection, true
+		}
+	}
+	return UserConnection{}, false
+}
+
+func (u User) Subscription(kind SubscriptionType) (UserSubscription, bool) {
+	for _, subscription := range u.Subscriptions {
+		if subscription.Type == kind {
+			return subscription, true
+		}
+	}
+	return UserSubscription{}, false
+}
diff --git a/internal/database/models/user_connection.go b/internal/database/models/user_connection.go
new file mode 100644
index 00000000..6dbb2590
--- /dev/null
+++ b/internal/database/models/user_connection.go
@@ -0,0 +1,32 @@
+package models
+
+import "github.com/cufee/aftermath/internal/permissions"
+
+type ConnectionType string
+
+const (
+	ConnectionTypeWargaming = ConnectionType("wargaming")
+)
+
+// Values provides list valid values for Enum.
+func (ConnectionType) Values() []string {
+	var kinds []string
+	for _, s := range []ConnectionType{
+		ConnectionTypeWargaming,
+	} {
+		kinds = append(kinds, string(s))
+	}
+	return kinds
+}
+
+type UserConnection struct {
+	ID string `json:"id"`
+
+	Type ConnectionType `json:"type"`
+
+	UserID      string                  `json:"userId"`
+	ReferenceID string                  `json:"referenceId"`
+	Permissions permissions.Permissions `json:"permissions"`
+
+	Metadata map[string]any `json:"metadata"`
+}
diff --git a/internal/database/models/user_subscription.go b/internal/database/models/user_subscription.go
new file mode 100644
index 00000000..07926bf3
--- /dev/null
+++ b/internal/database/models/user_subscription.go
@@ -0,0 +1,106 @@
+package models
+
+import (
+	"slices"
+	"time"
+
+	"github.com/cufee/aftermath/internal/permissions"
+)
+
+type SubscriptionType string
+
+func (s SubscriptionType) GetPermissions() permissions.Permissions {
+	switch s {
+	case SubscriptionTypePlus:
+		return permissions.SubscriptionAftermathPlus
+	case SubscriptionTypePro:
+		return permissions.SubscriptionAftermathPro
+	case SubscriptionTypeProClan:
+		return permissions.SubscriptionAftermathPro
+	default:
+		return permissions.User
+	}
+}
+
+// Paid
+const SubscriptionTypePro = SubscriptionType("aftermath-pro")
+const SubscriptionTypeProClan = SubscriptionType("aftermath-pro-clan")
+const SubscriptionTypePlus = SubscriptionType("aftermath-plus")
+
+// Misc
+const SubscriptionTypeSupporter = SubscriptionType("supporter")
+const SubscriptionTypeVerifiedClan = SubscriptionType("verified-clan")
+
+// Moderators
+const SubscriptionTypeServerModerator = SubscriptionType("server-moderator")
+const SubscriptionTypeContentModerator = SubscriptionType("content-moderator")
+
+// Special
+const SubscriptionTypeDeveloper = SubscriptionType("developer")
+const SubscriptionTypeServerBooster = SubscriptionType("server-booster")
+const SubscriptionTypeContentTranslator = SubscriptionType("content-translator")
+
+var AllSubscriptionTypes = []SubscriptionType{
+	SubscriptionTypePro,
+	SubscriptionTypeProClan,
+	SubscriptionTypePlus,
+	SubscriptionTypeSupporter,
+	SubscriptionTypeVerifiedClan,
+	SubscriptionTypeServerModerator,
+	SubscriptionTypeContentModerator,
+	SubscriptionTypeDeveloper,
+	SubscriptionTypeServerBooster,
+	SubscriptionTypeContentTranslator,
+}
+
+// Values provides list valid values for Enum.
+func (SubscriptionType) Values() []string {
+	var kinds []string
+	for _, s := range AllSubscriptionTypes {
+		kinds = append(kinds, string(s))
+	}
+	return kinds
+}
+
+func (s SubscriptionType) Valid() bool {
+	return slices.Contains(AllSubscriptionTypes, s)
+}
+
+type UserContentType string
+
+const (
+	UserContentTypeClanBackground     = UserContentType("clan-background-image")
+	UserContentTypePersonalBackground = UserContentType("personal-background-image")
+)
+
+func (t UserContentType) Valid() bool {
+	switch t {
+	case UserContentTypeClanBackground:
+		return true
+	case UserContentTypePersonalBackground:
+		return true
+	default:
+		return false
+	}
+}
+
+// Values provides list valid values for Enum.
+func (UserContentType) Values() []string {
+	var kinds []string
+	for _, s := range []UserContentType{
+		UserContentTypeClanBackground,
+		UserContentTypePersonalBackground,
+	} {
+		kinds = append(kinds, string(s))
+	}
+	return kinds
+}
+
+type UserSubscription struct {
+	ID          string
+	Type        SubscriptionType
+	UserID      string
+	ExpiresAt   time.Time
+	ReferenceID string
+	Permissions permissions.Permissions
+}
diff --git a/internal/database/models/vehicle.go b/internal/database/models/vehicle.go
new file mode 100644
index 00000000..b9f04a4e
--- /dev/null
+++ b/internal/database/models/vehicle.go
@@ -0,0 +1,23 @@
+package models
+
+import "golang.org/x/text/language"
+
+type Vehicle struct {
+	ID     string
+	Tier   int
+	Type   string
+	Class  string
+	Nation string
+
+	LocalizedNames map[string]string
+}
+
+func (v Vehicle) Name(locale language.Tag) string {
+	if n := v.LocalizedNames[locale.String()]; n != "" {
+		return n
+	}
+	if n := v.LocalizedNames[language.English.String()]; n != "" {
+		return n
+	}
+	return "Secret Tank"
+}
diff --git a/internal/database/models/vehicle_snapshot.go b/internal/database/models/vehicle_snapshot.go
new file mode 100644
index 00000000..c3152ce5
--- /dev/null
+++ b/internal/database/models/vehicle_snapshot.go
@@ -0,0 +1,40 @@
+package models
+
+import (
+	"time"
+
+	"github.com/cufee/aftermath/internal/stats/frame"
+)
+
+type SnapshotType string
+
+const (
+	SnapshotTypeLive  SnapshotType = "live"
+	SnapshotTypeDaily SnapshotType = "daily"
+)
+
+// Values provides list valid values for Enum.
+func (SnapshotType) Values() []string {
+	var kinds []string
+	for _, s := range []SnapshotType{
+		SnapshotTypeLive,
+		SnapshotTypeDaily,
+	} {
+		kinds = append(kinds, string(s))
+	}
+	return kinds
+}
+
+type VehicleSnapshot struct {
+	ID        string
+	CreatedAt time.Time
+
+	Type           SnapshotType
+	LastBattleTime time.Time
+
+	AccountID   string
+	VehicleID   string
+	ReferenceID string
+
+	Stats frame.StatsFrame
+}
diff --git a/internal/database/prisma/db/.gitignore b/internal/database/prisma/db/.gitignore
deleted file mode 100644
index a0c7514a..00000000
--- a/internal/database/prisma/db/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-# gitignore generated by Prisma Client Go. DO NOT EDIT.
-*_gen.go
diff --git a/internal/database/prisma/migrations/20240608224040_init/migration.sql b/internal/database/prisma/migrations/20240608224040_init/migration.sql
deleted file mode 100644
index 9b2a667d..00000000
--- a/internal/database/prisma/migrations/20240608224040_init/migration.sql
+++ /dev/null
@@ -1,210 +0,0 @@
--- CreateTable
-CREATE TABLE "app_configurations" (
-    "id" TEXT NOT NULL PRIMARY KEY,
-    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "updatedAt" DATETIME NOT NULL,
-    "valueEncoded" BLOB NOT NULL,
-    "metadataEncoded" BLOB NOT NULL
-);
-
--- CreateTable
-CREATE TABLE "cron_tasks" (
-    "id" TEXT NOT NULL PRIMARY KEY,
-    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "updatedAt" DATETIME NOT NULL,
-    "type" TEXT NOT NULL,
-    "referenceId" TEXT NOT NULL,
-    "targetsEncoded" BLOB NOT NULL,
-    "status" TEXT NOT NULL,
-    "lastRun" DATETIME NOT NULL,
-    "scheduledAfter" DATETIME NOT NULL,
-    "logsEncoded" BLOB NOT NULL,
-    "dataEncoded" BLOB NOT NULL
-);
-
--- CreateTable
-CREATE TABLE "users" (
-    "id" TEXT NOT NULL PRIMARY KEY,
-    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "updatedAt" DATETIME NOT NULL,
-    "permissions" TEXT NOT NULL,
-    "featureFlags" INTEGER NOT NULL DEFAULT 0
-);
-
--- CreateTable
-CREATE TABLE "user_subscriptions" (
-    "id" TEXT NOT NULL PRIMARY KEY,
-    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "updatedAt" DATETIME NOT NULL,
-    "userId" TEXT NOT NULL,
-    "type" TEXT NOT NULL,
-    "expiresAt" DATETIME NOT NULL,
-    "referenceId" TEXT NOT NULL,
-    "permissions" TEXT NOT NULL,
-    CONSTRAINT "user_subscriptions_userId_fkey" FOREIGN KEY ("userId") REFERENCES "users" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
-);
-
--- CreateTable
-CREATE TABLE "user_connections" (
-    "id" TEXT NOT NULL PRIMARY KEY,
-    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "updatedAt" DATETIME NOT NULL,
-    "userId" TEXT NOT NULL,
-    "type" TEXT NOT NULL,
-    "permissions" TEXT NOT NULL,
-    "referenceId" TEXT NOT NULL,
-    "metadataEncoded" BLOB NOT NULL,
-    CONSTRAINT "user_connections_userId_fkey" FOREIGN KEY ("userId") REFERENCES "users" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
-);
-
--- CreateTable
-CREATE TABLE "user_content" (
-    "id" TEXT NOT NULL PRIMARY KEY,
-    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "updatedAt" DATETIME NOT NULL,
-    "userId" TEXT NOT NULL,
-    "type" TEXT NOT NULL,
-    "referenceId" TEXT NOT NULL,
-    "valueEncoded" BLOB NOT NULL,
-    "metadataEncoded" BLOB NOT NULL,
-    CONSTRAINT "user_content_userId_fkey" FOREIGN KEY ("userId") REFERENCES "users" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
-);
-
--- CreateTable
-CREATE TABLE "accounts" (
-    "id" TEXT NOT NULL PRIMARY KEY,
-    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "updatedAt" DATETIME NOT NULL,
-    "lastBattleTime" DATETIME NOT NULL,
-    "accountCreatedAt" DATETIME NOT NULL,
-    "realm" TEXT NOT NULL,
-    "nickname" TEXT NOT NULL,
-    "private" BOOLEAN NOT NULL DEFAULT false,
-    "clanId" TEXT,
-    CONSTRAINT "accounts_clanId_fkey" FOREIGN KEY ("clanId") REFERENCES "account_clans" ("id") ON DELETE SET NULL ON UPDATE CASCADE
-);
-
--- CreateTable
-CREATE TABLE "account_clans" (
-    "id" TEXT NOT NULL PRIMARY KEY,
-    "createdAt" DATETIME NOT NULL,
-    "updatedAt" DATETIME NOT NULL,
-    "tag" TEXT NOT NULL,
-    "name" TEXT NOT NULL,
-    "emblemId" TEXT NOT NULL DEFAULT '',
-    "membersString" TEXT NOT NULL,
-    "recordUpdatedAt" DATETIME NOT NULL
-);
-
--- CreateTable
-CREATE TABLE "account_snapshots" (
-    "id" TEXT NOT NULL PRIMARY KEY,
-    "createdAt" DATETIME NOT NULL,
-    "type" TEXT NOT NULL,
-    "lastBattleTime" DATETIME NOT NULL,
-    "accountId" TEXT NOT NULL,
-    "referenceId" TEXT NOT NULL,
-    "frameEncoded" BLOB NOT NULL
-);
-
--- CreateTable
-CREATE TABLE "vehicle_snapshots" (
-    "id" TEXT NOT NULL PRIMARY KEY,
-    "createdAt" DATETIME NOT NULL,
-    "type" TEXT NOT NULL,
-    "lastBattleTime" DATETIME NOT NULL,
-    "accountId" TEXT NOT NULL,
-    "vehicleId" TEXT NOT NULL,
-    "referenceId" TEXT NOT NULL,
-    "frameEncoded" BLOB NOT NULL
-);
-
--- CreateTable
-CREATE TABLE "achievements_snapshots" (
-    "id" TEXT NOT NULL PRIMARY KEY,
-    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "updatedAt" DATETIME NOT NULL,
-    "accountId" TEXT NOT NULL,
-    "referenceId" TEXT NOT NULL,
-    "dataEncoded" BLOB NOT NULL
-);
-
--- CreateTable
-CREATE TABLE "glossary_averages" (
-    "id" TEXT NOT NULL PRIMARY KEY,
-    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "updatedAt" DATETIME NOT NULL,
-    "dataEncoded" BLOB NOT NULL
-);
-
--- CreateTable
-CREATE TABLE "glossary_vehicles" (
-    "id" TEXT NOT NULL PRIMARY KEY,
-    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "updatedAt" DATETIME NOT NULL,
-    "tier" INTEGER NOT NULL,
-    "type" TEXT NOT NULL,
-    "class" TEXT NOT NULL,
-    "nation" TEXT NOT NULL,
-    "localizedNamesEncoded" BLOB NOT NULL
-);
-
--- CreateIndex
-CREATE INDEX "cron_tasks_referenceId_idx" ON "cron_tasks"("referenceId");
-
--- CreateIndex
-CREATE INDEX "cron_tasks_status_referenceId_scheduledAfter_idx" ON "cron_tasks"("status", "referenceId", "scheduledAfter");
-
--- CreateIndex
-CREATE INDEX "cron_tasks_lastRun_status_idx" ON "cron_tasks"("lastRun", "status");
-
--- CreateIndex
-CREATE INDEX "user_connections_userId_idx" ON "user_connections"("userId");
-
--- CreateIndex
-CREATE INDEX "user_connections_type_userId_idx" ON "user_connections"("type", "userId");
-
--- CreateIndex
-CREATE INDEX "user_connections_referenceId_idx" ON "user_connections"("referenceId");
-
--- CreateIndex
-CREATE INDEX "user_connections_type_referenceId_idx" ON "user_connections"("type", "referenceId");
-
--- CreateIndex
-CREATE INDEX "user_content_userId_idx" ON "user_content"("userId");
-
--- CreateIndex
-CREATE INDEX "user_content_type_userId_idx" ON "user_content"("type", "userId");
-
--- CreateIndex
-CREATE INDEX "user_content_referenceId_idx" ON "user_content"("referenceId");
-
--- CreateIndex
-CREATE INDEX "user_content_type_referenceId_idx" ON "user_content"("type", "referenceId");
-
--- CreateIndex
-CREATE INDEX "accounts_realm_idx" ON "accounts"("realm");
-
--- CreateIndex
-CREATE INDEX "accounts_realm_lastBattleTime_idx" ON "accounts"("realm", "lastBattleTime");
-
--- CreateIndex
-CREATE INDEX "accounts_id_lastBattleTime_idx" ON "accounts"("id", "lastBattleTime");
-
--- CreateIndex
-CREATE INDEX "accounts_clanId_idx" ON "accounts"("clanId");
-
--- CreateIndex
-CREATE INDEX "account_clans_tag_idx" ON "account_clans"("tag");
-
--- CreateIndex
-CREATE INDEX "account_snapshots_createdAt_idx" ON "account_snapshots"("createdAt");
-
--- CreateIndex
-CREATE INDEX "account_snapshots_accountId_lastBattleTime_idx" ON "account_snapshots"("accountId", "lastBattleTime");
-
--- CreateIndex
-CREATE INDEX "vehicle_snapshots_createdAt_idx" ON "vehicle_snapshots"("createdAt");
-
--- CreateIndex
-CREATE INDEX "vehicle_snapshots_accountId_vehicleId_lastBattleTime_idx" ON "vehicle_snapshots"("accountId", "vehicleId", "lastBattleTime");
diff --git a/internal/database/prisma/migrations/20240611180703_added_snapshots/migration.sql b/internal/database/prisma/migrations/20240611180703_added_snapshots/migration.sql
deleted file mode 100644
index 6a503643..00000000
--- a/internal/database/prisma/migrations/20240611180703_added_snapshots/migration.sql
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
-  Warnings:
-
-  - You are about to drop the column `frameEncoded` on the `account_snapshots` table. All the data in the column will be lost.
-  - Added the required column `battles` to the `vehicle_snapshots` table without a default value. This is not possible if the table is not empty.
-  - Added the required column `ratingBattles` to the `account_snapshots` table without a default value. This is not possible if the table is not empty.
-  - Added the required column `ratingFrameEncoded` to the `account_snapshots` table without a default value. This is not possible if the table is not empty.
-  - Added the required column `regularBattles` to the `account_snapshots` table without a default value. This is not possible if the table is not empty.
-  - Added the required column `regularFrameEncoded` to the `account_snapshots` table without a default value. This is not possible if the table is not empty.
-
-*/
--- RedefineTables
-PRAGMA foreign_keys=OFF;
-CREATE TABLE "new_vehicle_snapshots" (
-    "id" TEXT NOT NULL PRIMARY KEY,
-    "createdAt" DATETIME NOT NULL,
-    "type" TEXT NOT NULL,
-    "lastBattleTime" DATETIME NOT NULL,
-    "accountId" TEXT NOT NULL,
-    "vehicleId" TEXT NOT NULL,
-    "referenceId" TEXT NOT NULL,
-    "battles" INTEGER NOT NULL,
-    "frameEncoded" BLOB NOT NULL
-);
-INSERT INTO "new_vehicle_snapshots" ("accountId", "createdAt", "frameEncoded", "id", "lastBattleTime", "referenceId", "type", "vehicleId") SELECT "accountId", "createdAt", "frameEncoded", "id", "lastBattleTime", "referenceId", "type", "vehicleId" FROM "vehicle_snapshots";
-DROP TABLE "vehicle_snapshots";
-ALTER TABLE "new_vehicle_snapshots" RENAME TO "vehicle_snapshots";
-CREATE INDEX "vehicle_snapshots_createdAt_idx" ON "vehicle_snapshots"("createdAt");
-CREATE INDEX "vehicle_snapshots_accountId_vehicleId_lastBattleTime_idx" ON "vehicle_snapshots"("accountId", "vehicleId", "lastBattleTime");
-CREATE TABLE "new_account_snapshots" (
-    "id" TEXT NOT NULL PRIMARY KEY,
-    "createdAt" DATETIME NOT NULL,
-    "type" TEXT NOT NULL,
-    "lastBattleTime" DATETIME NOT NULL,
-    "accountId" TEXT NOT NULL,
-    "referenceId" TEXT NOT NULL,
-    "ratingBattles" INTEGER NOT NULL,
-    "ratingFrameEncoded" BLOB NOT NULL,
-    "regularBattles" INTEGER NOT NULL,
-    "regularFrameEncoded" BLOB NOT NULL
-);
-INSERT INTO "new_account_snapshots" ("accountId", "createdAt", "id", "lastBattleTime", "referenceId", "type") SELECT "accountId", "createdAt", "id", "lastBattleTime", "referenceId", "type" FROM "account_snapshots";
-DROP TABLE "account_snapshots";
-ALTER TABLE "new_account_snapshots" RENAME TO "account_snapshots";
-CREATE INDEX "account_snapshots_createdAt_idx" ON "account_snapshots"("createdAt");
-CREATE INDEX "account_snapshots_accountId_lastBattleTime_idx" ON "account_snapshots"("accountId", "lastBattleTime");
-PRAGMA foreign_key_check;
-PRAGMA foreign_keys=ON;
diff --git a/internal/database/prisma/migrations/20240612202803_sessions/migration.sql b/internal/database/prisma/migrations/20240612202803_sessions/migration.sql
deleted file mode 100644
index 0d46d0ba..00000000
--- a/internal/database/prisma/migrations/20240612202803_sessions/migration.sql
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
-  Warnings:
-
-  - You are about to drop the column `updatedAt` on the `achievements_snapshots` table. All the data in the column will be lost.
-
-*/
--- DropIndex
-DROP INDEX "account_snapshots_accountId_lastBattleTime_idx";
-
--- DropIndex
-DROP INDEX "vehicle_snapshots_accountId_vehicleId_lastBattleTime_idx";
-
--- RedefineTables
-PRAGMA foreign_keys=OFF;
-CREATE TABLE "new_achievements_snapshots" (
-    "id" TEXT NOT NULL PRIMARY KEY,
-    "createdAt" DATETIME NOT NULL,
-    "accountId" TEXT NOT NULL,
-    "referenceId" TEXT NOT NULL,
-    "dataEncoded" BLOB NOT NULL
-);
-INSERT INTO "new_achievements_snapshots" ("accountId", "createdAt", "dataEncoded", "id", "referenceId") SELECT "accountId", "createdAt", "dataEncoded", "id", "referenceId" FROM "achievements_snapshots";
-DROP TABLE "achievements_snapshots";
-ALTER TABLE "new_achievements_snapshots" RENAME TO "achievements_snapshots";
-CREATE INDEX "achievements_snapshots_createdAt_idx" ON "achievements_snapshots"("createdAt");
-CREATE INDEX "achievements_snapshots_accountId_referenceId_idx" ON "achievements_snapshots"("accountId", "referenceId");
-CREATE INDEX "achievements_snapshots_accountId_referenceId_createdAt_idx" ON "achievements_snapshots"("accountId", "referenceId", "createdAt");
-PRAGMA foreign_key_check;
-PRAGMA foreign_keys=ON;
-
--- CreateIndex
-CREATE INDEX "account_snapshots_type_accountId_referenceId_idx" ON "account_snapshots"("type", "accountId", "referenceId");
-
--- CreateIndex
-CREATE INDEX "account_snapshots_type_accountId_referenceId_createdAt_idx" ON "account_snapshots"("type", "accountId", "referenceId", "createdAt");
-
--- CreateIndex
-CREATE INDEX "vehicle_snapshots_vehicleId_createdAt_idx" ON "vehicle_snapshots"("vehicleId", "createdAt");
-
--- CreateIndex
-CREATE INDEX "vehicle_snapshots_accountId_referenceId_idx" ON "vehicle_snapshots"("accountId", "referenceId");
-
--- CreateIndex
-CREATE INDEX "vehicle_snapshots_accountId_referenceId_vehicleId_idx" ON "vehicle_snapshots"("accountId", "referenceId", "vehicleId");
-
--- CreateIndex
-CREATE INDEX "vehicle_snapshots_accountId_referenceId_type_idx" ON "vehicle_snapshots"("accountId", "referenceId", "type");
-
--- CreateIndex
-CREATE INDEX "vehicle_snapshots_accountId_referenceId_createdAt_idx" ON "vehicle_snapshots"("accountId", "referenceId", "createdAt");
diff --git a/internal/database/prisma/migrations/20240614000132_added_app_commands/migration.sql b/internal/database/prisma/migrations/20240614000132_added_app_commands/migration.sql
deleted file mode 100644
index b8a4abf1..00000000
--- a/internal/database/prisma/migrations/20240614000132_added_app_commands/migration.sql
+++ /dev/null
@@ -1,11 +0,0 @@
--- CreateTable
-CREATE TABLE "application_commands" (
-    "id" TEXT NOT NULL PRIMARY KEY,
-    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "updatedAt" DATETIME NOT NULL,
-    "version" TEXT NOT NULL,
-    "optionsHash" TEXT NOT NULL
-);
-
--- CreateIndex
-CREATE INDEX "account_snapshots_type_accountId_createdAt_idx" ON "account_snapshots"("type", "accountId", "createdAt");
diff --git a/internal/database/prisma/migrations/20240614000247_added_index/migration.sql b/internal/database/prisma/migrations/20240614000247_added_index/migration.sql
deleted file mode 100644
index 428604b0..00000000
--- a/internal/database/prisma/migrations/20240614000247_added_index/migration.sql
+++ /dev/null
@@ -1,2 +0,0 @@
--- CreateIndex
-CREATE INDEX "application_commands_optionsHash_idx" ON "application_commands"("optionsHash");
diff --git a/internal/database/prisma/migrations/20240614002652_added_name/migration.sql b/internal/database/prisma/migrations/20240614002652_added_name/migration.sql
deleted file mode 100644
index c7c9687b..00000000
--- a/internal/database/prisma/migrations/20240614002652_added_name/migration.sql
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
-  Warnings:
-
-  - Added the required column `name` to the `application_commands` table without a default value. This is not possible if the table is not empty.
-
-*/
--- RedefineTables
-PRAGMA foreign_keys=OFF;
-CREATE TABLE "new_application_commands" (
-    "id" TEXT NOT NULL PRIMARY KEY,
-    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "updatedAt" DATETIME NOT NULL,
-    "name" TEXT NOT NULL,
-    "version" TEXT NOT NULL,
-    "optionsHash" TEXT NOT NULL
-);
-INSERT INTO "new_application_commands" ("createdAt", "id", "optionsHash", "updatedAt", "version") SELECT "createdAt", "id", "optionsHash", "updatedAt", "version" FROM "application_commands";
-DROP TABLE "application_commands";
-ALTER TABLE "new_application_commands" RENAME TO "application_commands";
-CREATE INDEX "application_commands_optionsHash_idx" ON "application_commands"("optionsHash");
-PRAGMA foreign_key_check;
-PRAGMA foreign_keys=ON;
diff --git a/internal/database/prisma/migrations/migration_lock.toml b/internal/database/prisma/migrations/migration_lock.toml
deleted file mode 100644
index e5e5c470..00000000
--- a/internal/database/prisma/migrations/migration_lock.toml
+++ /dev/null
@@ -1,3 +0,0 @@
-# Please do not edit this file manually
-# It should be added in your version-control system (i.e. Git)
-provider = "sqlite"
\ No newline at end of file
diff --git a/internal/database/prisma/schema.prisma b/internal/database/prisma/schema.prisma
deleted file mode 100644
index 04274134..00000000
--- a/internal/database/prisma/schema.prisma
+++ /dev/null
@@ -1,398 +0,0 @@
-datasource db {
-  provider = "sqlite"
-  url      = env("DATABASE_URL")
-}
-
-generator db {
-  provider = "go run github.com/steebchen/prisma-client-go"
-}
-
-//
-// === App Data ===
-//
-
-// Stores some long-lived app condiguration values
-// the values here would typically be set programmatically
-model AppConfiguration {
-  id        String   @id @default(cuid())
-  createdAt DateTime @default(now())
-  updatedAt DateTime @updatedAt
-
-  valueEncoded    Bytes
-  metadataEncoded Bytes
-
-  @@map("app_configurations")
-}
-
-// A record of a cron task
-model CronTask {
-  id        String   @id @default(cuid())
-  createdAt DateTime @default(now())
-  updatedAt DateTime @updatedAt
-
-  type           String
-  referenceId    String
-  targetsEncoded Bytes
-
-  status         String
-  lastRun        DateTime
-  scheduledAfter DateTime
-
-  logsEncoded Bytes
-  dataEncoded Bytes
-
-  @@index([referenceId])
-  @@index([status, referenceId, scheduledAfter])
-  @@index([lastRun, status])
-  @@map("cron_tasks")
-}
-
-//
-// === Authentification ===
-//
-
-// // A single-use nonce value generated during the auth flow
-// model AuthNonce {
-//   id        String   @id @default(cuid())
-//   createdAt DateTime @default(now())
-//   updatedAt DateTime @updatedAt
-
-//   expiresAt DateTime
-
-//   referenceId     String
-//   metadataEncoded Bytes
-
-//   @@index([createdAt])
-//   @@index([referenceId])
-//   @@index([referenceId, expiresAt])
-//   @@map("auth_nonces")
-//   @@ignore
-// }
-
-//
-// === Users ===
-//
-
-// User record withing the app, primary id is a Discord user ID
-model User {
-  id        String   @id
-  createdAt DateTime @default(now())
-  updatedAt DateTime @updatedAt
-
-  permissions  String
-  featureFlags Int    @default(0)
-
-  subscriptions UserSubscription[]
-  connections   UserConnection[]
-  content       UserContent[]
-
-  @@map("users")
-}
-
-// A subscription record for a user
-model UserSubscription {
-  id        String   @id @default(cuid())
-  createdAt DateTime @default(now())
-  updatedAt DateTime @updatedAt
-
-  user   User   @relation(fields: [userId], references: [id])
-  userId String
-
-  type        String
-  expiresAt   DateTime
-  referenceId String
-  permissions String
-
-  @@map("user_subscriptions")
-}
-
-// A connection to some external service for a user, like Google or Wargaming
-//   - ReferenceID here would be a user id received from the external service
-model UserConnection {
-  id        String   @id @default(cuid())
-  createdAt DateTime @default(now())
-  updatedAt DateTime @updatedAt
-
-  user   User   @relation(fields: [userId], references: [id])
-  userId String
-
-  type        String
-  permissions String
-  referenceId String
-
-  metadataEncoded Bytes
-
-  @@index([userId])
-  @@index([type, userId])
-  @@index([referenceId])
-  @@index([type, referenceId])
-  @@map("user_connections")
-}
-
-// Content uploaded by a user, such as an image
-model UserContent {
-  id        String   @id @default(cuid())
-  createdAt DateTime @default(now())
-  updatedAt DateTime @updatedAt
-
-  user   User   @relation(fields: [userId], references: [id])
-  userId String
-
-  type        String
-  referenceId String
-
-  valueEncoded    Bytes
-  metadataEncoded Bytes
-
-  @@index([userId])
-  @@index([type, userId])
-  @@index([referenceId])
-  @@index([type, referenceId])
-  @@map("user_content")
-}
-
-//
-// === Wargaming Data ===
-//
-
-// Wargaming Account record
-model Account {
-  id        String   @id
-  createdAt DateTime @default(now())
-  updatedAt DateTime @updatedAt
-
-  lastBattleTime   DateTime
-  accountCreatedAt DateTime
-
-  realm    String
-  nickname String
-  private  Boolean @default(false)
-
-  clan   Clan?   @relation(fields: [clanId], references: [id])
-  clanId String?
-
-  @@index([realm])
-  @@index([realm, lastBattleTime])
-  @@index([id, lastBattleTime])
-  @@index([clanId])
-  @@map("accounts")
-}
-
-// Wargaming Clan record
-model Clan {
-  id        String   @id
-  createdAt DateTime
-  updatedAt DateTime @updatedAt
-
-  tag      String
-  name     String
-  emblemId String @default("")
-
-  accounts      Account[]
-  membersString String
-
-  recordUpdatedAt DateTime @updatedAt
-
-  @@index([tag])
-  @@map("account_clans")
-}
-
-// A snapshot of account statistics
-model AccountSnapshot {
-  id        String   @id @default(cuid())
-  createdAt DateTime
-
-  type           String
-  lastBattleTime DateTime
-
-  accountId   String
-  referenceId String
-
-  ratingBattles      Int
-  ratingFrameEncoded Bytes
-
-  regularBattles      Int
-  regularFrameEncoded Bytes
-
-  @@index([createdAt])
-  @@index([type, accountId, createdAt])
-  @@index([type, accountId, referenceId])
-  @@index([type, accountId, referenceId, createdAt])
-  @@map("account_snapshots")
-}
-
-// A snapshot of vehicle statistics on a specific account
-model VehicleSnapshot {
-  id        String   @id @default(cuid())
-  createdAt DateTime
-
-  type           String
-  lastBattleTime DateTime
-
-  accountId   String
-  vehicleId   String
-  referenceId String
-
-  battles      Int
-  frameEncoded Bytes
-
-  @@index([createdAt])
-  @@index([vehicleId, createdAt])
-  @@index([accountId, referenceId])
-  @@index([accountId, referenceId, vehicleId])
-  @@index([accountId, referenceId, type])
-  @@index([accountId, referenceId, createdAt])
-  @@map("vehicle_snapshots")
-}
-
-// A snapshot of all account achievements
-model AchievementsSnapshot {
-  id        String   @id @default(uuid())
-  createdAt DateTime
-
-  accountId   String
-  referenceId String
-
-  dataEncoded Bytes
-
-  @@index([createdAt])
-  @@index([accountId, referenceId])
-  @@index([accountId, referenceId, createdAt])
-  @@map("achievements_snapshots")
-}
-
-// // A snapshot of account rating season stats
-// model AccountRatingSeasonSnapshot {
-//   id        String   @id @default(cuid())
-//   createdAt DateTime
-
-//   seasonId       String
-//   accountId      String
-//   referenceId    String
-//   lastBattleTime DateTime
-
-//   dataEncoded Bytes
-
-//   @@index([createdAt])
-//   @@index([seasonId, accountId])
-//   @@index([seasonId, referenceId])
-//   @@map("account_rating_season_snapshots")
-//   @@ignore // unused atm and may require significant changes
-// }
-
-// A stats frame representing an average player performance on a vehicle
-model VehicleAverage {
-  id        String   @id
-  createdAt DateTime @default(now())
-  updatedAt DateTime @updatedAt
-
-  dataEncoded Bytes
-
-  @@map("glossary_averages")
-}
-
-// Wargaming Vehicle glossary information
-model Vehicle {
-  id        String   @id
-  createdAt DateTime @default(now())
-  updatedAt DateTime @updatedAt
-
-  tier   Int
-  type   String
-  class  String
-  nation String
-
-  localizedNamesEncoded Bytes
-
-  @@map("glossary_vehicles")
-}
-
-// // Wargaming Achievement glossary information
-// model Achievement {
-//   id        String   @id @default(uuid())
-//   createdAt DateTime @default(now())
-//   updatedAt DateTime @updatedAt
-
-//   section String
-
-//   dataEncoded Bytes
-
-//   @@map("glossary_achievements")
-//   @@ignore
-// }
-
-//
-// === Discord Data ===
-//
-
-model ApplicationCommand {
-  id        String   @id
-  createdAt DateTime @default(now())
-  updatedAt DateTime @updatedAt
-
-  name        String
-  version     String
-  optionsHash String
-
-  @@index([optionsHash])
-  @@map("application_commands")
-}
-
-// // A log of a user interaction with the bot
-// model DiscordInteraction {
-//   id        String   @id @default(cuid())
-//   createdAt DateTime @default(now())
-//   updatedAt DateTime @updatedAt
-
-//   type        String
-//   userId      String
-//   referenceId String
-
-//   dataEncoded     Bytes
-//   metadataEncoded Bytes
-
-//   @@map("user_interactions")
-//   @@ignore
-// }
-
-// // An active live session record of a user, requested through the bot
-// model LiveSession {
-//   id        String   @id @default(cuid())
-//   createdAt DateTime @default(now())
-//   updatedAt DateTime @updatedAt
-
-//   locale String
-
-//   userId      String
-//   referenceId String
-
-//   lastUpdate     DateTime @default(now())
-//   lastBattleTime DateTime @default(now())
-
-//   options   StatsRequestsOptions @relation(fields: [optionsId], references: [id])
-//   optionsId String
-
-//   metadataEncoded Bytes
-
-//   @@index([referenceId])
-//   @@map("live_sessions")
-//   @@ignore
-// }
-
-// model StatsRequestsOptions {
-//   id        String   @id @default(cuid())
-//   createdAt DateTime @default(now())
-//   updatedAt DateTime @updatedAt
-
-//   type        String
-//   userId      String
-//   accountId   String
-//   referenceId String
-
-//   dataEncoded  Bytes
-//   liveSessions LiveSession[] @ignore
-
-//   @@index([referenceId])
-//   @@map("stats_request_options")
-//   @@ignore
-// }
diff --git a/internal/database/snapshots.go b/internal/database/snapshots.go
index 671e3ba6..b6f390e4 100644
--- a/internal/database/snapshots.go
+++ b/internal/database/snapshots.go
@@ -2,16 +2,23 @@ package database
 
 import (
 	"context"
-	"fmt"
-	"strings"
 	"time"
 
-	"github.com/cufee/aftermath/internal/database/prisma/db"
-	"github.com/cufee/aftermath/internal/stats/frame"
-	"github.com/rs/zerolog/log"
-	"github.com/steebchen/prisma-client-go/runtime/transaction"
+	"github.com/cufee/aftermath/internal/database/models"
 )
 
+// import (
+// 	"context"
+// 	"fmt"
+// 	"strings"
+// 	"time"
+
+// 	"github.com/cufee/aftermath/internal/database/prisma/db"
+// 	"github.com/cufee/aftermath/internal/stats/frame"
+// 	"github.com/rs/zerolog/log"
+// 	"github.com/steebchen/prisma-client-go/runtime/transaction"
+// )
+
 type getSnapshotQuery struct {
 	vehicleIDs []string
 
@@ -19,157 +26,157 @@ type getSnapshotQuery struct {
 	createdBefore *time.Time
 }
 
-func (s getSnapshotQuery) accountParams(accountID, referenceID string, kind snapshotType) []db.AccountSnapshotWhereParam {
-	var params []db.AccountSnapshotWhereParam
-	params = append(params, db.AccountSnapshot.Type.Equals(string(kind)))
-	params = append(params, db.AccountSnapshot.AccountID.Equals(accountID))
-	params = append(params, db.AccountSnapshot.ReferenceID.Equals(referenceID))
-
-	if s.createdAfter != nil {
-		params = append(params, db.AccountSnapshot.CreatedAt.After(*s.createdAfter))
-	}
-	if s.createdBefore != nil {
-		params = append(params, db.AccountSnapshot.CreatedAt.Before(*s.createdBefore))
-	}
-
-	return params
-}
-
-func (s getSnapshotQuery) vehiclesQuery(accountID, referenceID string, kind snapshotType) (query string, params []interface{}) {
-	var conditions []string
-	var args []interface{}
-
-	// Mandatory conditions
-	conditions = append(conditions, "type = ?")
-	args = append(args, kind)
-
-	conditions = append(conditions, "accountId = ?")
-	args = append(args, accountID)
-
-	conditions = append(conditions, "referenceId = ?")
-	args = append(args, referenceID)
-
-	// Optional conditions
-	if s.createdAfter != nil {
-		conditions = append(conditions, "createdAt > ?")
-		args = append(args, *s.createdAfter)
-	}
-	if s.createdBefore != nil {
-		conditions = append(conditions, "createdAt < ?")
-		args = append(args, *s.createdBefore)
-	}
-
-	// Filter by vehicle IDs if provided
-	if len(s.vehicleIDs) > 0 {
-		placeholders := make([]string, len(s.vehicleIDs))
-		for i, id := range s.vehicleIDs {
-			placeholders[i] = "?"
-			args = append(args, id)
-		}
-		conditions = append(conditions, fmt.Sprintf("vehicleId IN (%s)", strings.Join(placeholders, ",")))
-	}
-
-	// Determine the order by clause
-	var orderBy string = "createdAt DESC"
-	if s.createdAfter != nil {
-		orderBy = "createdAt ASC"
-	}
-
-	// Base query
-	query = `
-		SELECT
-			id, createdAt, type, lastBattleTime, accountId, vehicleId, referenceId, battles, frameEncoded
-		FROM
-			vehicle_snapshots
-		WHERE
-			%s
-		ORDER BY
-			%s
-	`
-
-	// Combine conditions into a single string
-	conditionsStr := strings.Join(conditions, " AND ")
-	query = fmt.Sprintf(query, conditionsStr, orderBy)
-
-	// Wrap the query to select the latest or earliest snapshot per vehicleId
-	wrappedQuery := `
-		SELECT * FROM (
-			%s
-		) AS ordered_snapshots
-		GROUP BY vehicleId
-	`
-
-	query = fmt.Sprintf(wrappedQuery, query)
-	return query, args
-}
-
-func (s getSnapshotQuery) manyAccountsQuery(accountIDs []string, kind snapshotType) (query string, params []interface{}) {
-	var conditions []string
-	var args []interface{}
-
-	// Mandatory conditions
-	conditions = append(conditions, "type = ?")
-	args = append(args, kind)
-
-	// Optional conditions
-	if s.createdAfter != nil {
-		conditions = append(conditions, "createdAt > ?")
-		args = append(args, *s.createdAfter)
-	}
-	if s.createdBefore != nil {
-		conditions = append(conditions, "createdAt < ?")
-		args = append(args, *s.createdBefore)
-	}
-
-	// Filter by account IDs
-	placeholders := make([]string, len(accountIDs))
-	for i := range accountIDs {
-		placeholders[i] = "?"
-	}
-	conditions = append(conditions, fmt.Sprintf("accountId IN (%s)", strings.Join(placeholders, ",")))
-	for _, id := range accountIDs {
-		args = append(args, id)
-	}
-
-	// Determine the order by clause
-	var orderBy string = "createdAt DESC"
-	if s.createdAfter != nil {
-		orderBy = "createdAt ASC"
-	}
-
-	// Combine conditions into a single string
-	conditionsStr := strings.Join(conditions, " AND ")
-
-	// Base query
-	query = fmt.Sprintf(`
-			SELECT
-				id, createdAt, type, lastBattleTime, accountId, referenceId, ratingBattles, ratingFrameEncoded, regularBattles, regularFrameEncoded
-			FROM
-				account_snapshots
-			WHERE
-				%s
-			ORDER BY
-				%s
-		`, conditionsStr, orderBy)
-
-	// Wrap the query to select the latest snapshot per accountId
-	wrappedQuery := fmt.Sprintf(`
-			SELECT * FROM (
-				%s
-			) AS ordered_snapshots
-			GROUP BY accountId
-		`, query)
-
-	return wrappedQuery, args
-}
-
-func (s getSnapshotQuery) accountOrder() []db.AccountSnapshotOrderByParam {
-	order := db.DESC
-	if s.createdAfter != nil {
-		order = db.ASC
-	}
-	return []db.AccountSnapshotOrderByParam{db.AccountSnapshot.CreatedAt.Order(order)}
-}
+// func (s getSnapshotQuery) accountParams(accountID, referenceID string, kind models.SnapshotType) []db.AccountSnapshotWhereParam {
+// 	var params []db.AccountSnapshotWhereParam
+// 	params = append(params, db.AccountSnapshot.Type.Equals(string(kind)))
+// 	params = append(params, db.AccountSnapshot.AccountID.Equals(accountID))
+// 	params = append(params, db.AccountSnapshot.ReferenceID.Equals(referenceID))
+
+// 	if s.createdAfter != nil {
+// 		params = append(params, db.AccountSnapshot.CreatedAt.After(*s.createdAfter))
+// 	}
+// 	if s.createdBefore != nil {
+// 		params = append(params, db.AccountSnapshot.CreatedAt.Before(*s.createdBefore))
+// 	}
+
+// 	return params
+// }
+
+// func (s getSnapshotQuery) vehiclesQuery(accountID, referenceID string, kind models.SnapshotType) (query string, params []interface{}) {
+// 	var conditions []string
+// 	var args []interface{}
+
+// 	// Mandatory conditions
+// 	conditions = append(conditions, "type = ?")
+// 	args = append(args, kind)
+
+// 	conditions = append(conditions, "accountId = ?")
+// 	args = append(args, accountID)
+
+// 	conditions = append(conditions, "referenceId = ?")
+// 	args = append(args, referenceID)
+
+// 	// Optional conditions
+// 	if s.createdAfter != nil {
+// 		conditions = append(conditions, "createdAt > ?")
+// 		args = append(args, *s.createdAfter)
+// 	}
+// 	if s.createdBefore != nil {
+// 		conditions = append(conditions, "createdAt < ?")
+// 		args = append(args, *s.createdBefore)
+// 	}
+
+// 	// Filter by vehicle IDs if provided
+// 	if len(s.vehicleIDs) > 0 {
+// 		placeholders := make([]string, len(s.vehicleIDs))
+// 		for i, id := range s.vehicleIDs {
+// 			placeholders[i] = "?"
+// 			args = append(args, id)
+// 		}
+// 		conditions = append(conditions, fmt.Sprintf("vehicleId IN (%s)", strings.Join(placeholders, ",")))
+// 	}
+
+// 	// Determine the order by clause
+// 	var orderBy string = "createdAt DESC"
+// 	if s.createdAfter != nil {
+// 		orderBy = "createdAt ASC"
+// 	}
+
+// 	// Base query
+// 	query = `
+// 		SELECT
+// 			id, createdAt, type, lastBattleTime, accountId, vehicleId, referenceId, battles, frameEncoded
+// 		FROM
+// 			vehicle_snapshots
+// 		WHERE
+// 			%s
+// 		ORDER BY
+// 			%s
+// 	`
+
+// 	// Combine conditions into a single string
+// 	conditionsStr := strings.Join(conditions, " AND ")
+// 	query = fmt.Sprintf(query, conditionsStr, orderBy)
+
+// 	// Wrap the query to select the latest or earliest snapshot per vehicleId
+// 	wrappedQuery := `
+// 		SELECT * FROM (
+// 			%s
+// 		) AS ordered_snapshots
+// 		GROUP BY vehicleId
+// 	`
+
+// 	query = fmt.Sprintf(wrappedQuery, query)
+// 	return query, args
+// }
+
+// func (s getSnapshotQuery) manyAccountsQuery(accountIDs []string, kind models.SnapshotType) (query string, params []interface{}) {
+// 	var conditions []string
+// 	var args []interface{}
+
+// 	// Mandatory conditions
+// 	conditions = append(conditions, "type = ?")
+// 	args = append(args, kind)
+
+// 	// Optional conditions
+// 	if s.createdAfter != nil {
+// 		conditions = append(conditions, "createdAt > ?")
+// 		args = append(args, *s.createdAfter)
+// 	}
+// 	if s.createdBefore != nil {
+// 		conditions = append(conditions, "createdAt < ?")
+// 		args = append(args, *s.createdBefore)
+// 	}
+
+// 	// Filter by account IDs
+// 	placeholders := make([]string, len(accountIDs))
+// 	for i := range accountIDs {
+// 		placeholders[i] = "?"
+// 	}
+// 	conditions = append(conditions, fmt.Sprintf("accountId IN (%s)", strings.Join(placeholders, ",")))
+// 	for _, id := range accountIDs {
+// 		args = append(args, id)
+// 	}
+
+// 	// Determine the order by clause
+// 	var orderBy string = "createdAt DESC"
+// 	if s.createdAfter != nil {
+// 		orderBy = "createdAt ASC"
+// 	}
+
+// 	// Combine conditions into a single string
+// 	conditionsStr := strings.Join(conditions, " AND ")
+
+// 	// Base query
+// 	query = fmt.Sprintf(`
+// 			SELECT
+// 				id, createdAt, type, lastBattleTime, accountId, referenceId, ratingBattles, ratingFrameEncoded, regularBattles, regularFrameEncoded
+// 			FROM
+// 				account_snapshots
+// 			WHERE
+// 				%s
+// 			ORDER BY
+// 				%s
+// 		`, conditionsStr, orderBy)
+
+// 	// Wrap the query to select the latest snapshot per accountId
+// 	wrappedQuery := fmt.Sprintf(`
+// 			SELECT * FROM (
+// 				%s
+// 			) AS ordered_snapshots
+// 			GROUP BY accountId
+// 		`, query)
+
+// 	return wrappedQuery, args
+// }
+
+// func (s getSnapshotQuery) accountOrder() []db.AccountSnapshotOrderByParam {
+// 	order := db.DESC
+// 	if s.createdAfter != nil {
+// 		order = db.ASC
+// 	}
+// 	return []db.AccountSnapshotOrderByParam{db.AccountSnapshot.CreatedAt.Order(order)}
+// }
 
 type SnapshotQuery func(*getSnapshotQuery)
 
@@ -189,222 +196,192 @@ func WithCreatedBefore(before time.Time) SnapshotQuery {
 	}
 }
 
-type snapshotType string
-
-const (
-	SnapshotTypeLive  snapshotType = "live"
-	SnapshotTypeDaily snapshotType = "daily"
-)
-
-type VehicleSnapshot struct {
-	ID        string
-	CreatedAt time.Time
-
-	Type           snapshotType
-	LastBattleTime time.Time
-
-	AccountID   string
-	VehicleID   string
-	ReferenceID string
-
-	Stats frame.StatsFrame
-}
-
-func (s VehicleSnapshot) FromModel(model db.VehicleSnapshotModel) (VehicleSnapshot, error) {
-	s.ID = model.ID
-	s.Type = snapshotType(model.Type)
-	s.CreatedAt = model.CreatedAt
-	s.LastBattleTime = model.LastBattleTime
-
-	s.AccountID = model.AccountID
-	s.VehicleID = model.VehicleID
-	s.ReferenceID = model.ReferenceID
-
-	stats, err := frame.DecodeStatsFrame(model.FrameEncoded)
-	if err != nil {
-		return VehicleSnapshot{}, err
-	}
-	s.Stats = stats
-	return s, nil
-}
-
-func (c *client) CreateVehicleSnapshots(ctx context.Context, snapshots ...VehicleSnapshot) error {
-	if len(snapshots) < 1 {
-		return nil
-	}
-
-	var transactions []transaction.Transaction
-	for _, data := range snapshots {
-		encoded, err := data.Stats.Encode()
-		if err != nil {
-			log.Err(err).Str("accountId", data.AccountID).Str("vehicleId", data.VehicleID).Msg("failed to encode a stats frame for vehicle snapthsot")
-			continue
-		}
-
-		transactions = append(transactions, c.prisma.VehicleSnapshot.
-			CreateOne(
-				db.VehicleSnapshot.CreatedAt.Set(data.CreatedAt),
-				db.VehicleSnapshot.Type.Set(string(data.Type)),
-				db.VehicleSnapshot.LastBattleTime.Set(data.LastBattleTime),
-				db.VehicleSnapshot.AccountID.Set(data.AccountID),
-				db.VehicleSnapshot.VehicleID.Set(data.VehicleID),
-				db.VehicleSnapshot.ReferenceID.Set(data.ReferenceID),
-				db.VehicleSnapshot.Battles.Set(int(data.Stats.Battles)),
-				db.VehicleSnapshot.FrameEncoded.Set(encoded),
-			).Tx(),
-		)
-	}
-
-	return c.prisma.Prisma.Transaction(transactions...).Exec(ctx)
+// func (s models.VehicleSnapshot) FromModel(model db.models.VehicleSnapshotModel) (models.VehicleSnapshot, error) {
+// 	s.ID = model.ID
+// 	s.Type = models.SnapshotType(model.Type)
+// 	s.CreatedAt = model.CreatedAt
+// 	s.LastBattleTime = model.LastBattleTime
+
+// 	s.AccountID = model.AccountID
+// 	s.VehicleID = model.VehicleID
+// 	s.ReferenceID = model.ReferenceID
+
+// 	stats, err := frame.DecodeStatsFrame(model.FrameEncoded)
+// 	if err != nil {
+// 		return models.VehicleSnapshot{}, err
+// 	}
+// 	s.Stats = stats
+// 	return s, nil
+// }
+
+func (c *libsqlClient) CreateVehicleSnapshots(ctx context.Context, snapshots ...models.VehicleSnapshot) error {
+	// if len(snapshots) < 1 {
+	// 	return nil
+	// }
+
+	// var transactions []transaction.Transaction
+	// for _, data := range snapshots {
+	// 	encoded, err := data.Stats.Encode()
+	// 	if err != nil {
+	// 		log.Err(err).Str("accountId", data.AccountID).Str("vehicleId", data.VehicleID).Msg("failed to encode a stats frame for vehicle snapthsot")
+	// 		continue
+	// 	}
+
+	// 	transactions = append(transactions, c.prisma.models.VehicleSnapshot.
+	// 		CreateOne(
+	// 			db.models.VehicleSnapshot.CreatedAt.Set(data.CreatedAt),
+	// 			db.models.VehicleSnapshot.Type.Set(string(data.Type)),
+	// 			db.models.VehicleSnapshot.LastBattleTime.Set(data.LastBattleTime),
+	// 			db.models.VehicleSnapshot.AccountID.Set(data.AccountID),
+	// 			db.models.VehicleSnapshot.VehicleID.Set(data.VehicleID),
+	// 			db.models.VehicleSnapshot.ReferenceID.Set(data.ReferenceID),
+	// 			db.models.VehicleSnapshot.Battles.Set(int(data.Stats.Battles)),
+	// 			db.models.VehicleSnapshot.FrameEncoded.Set(encoded),
+	// 		).Tx(),
+	// 	)
+	// }
+
+	// return c.prisma.Prisma.Transaction(transactions...).Exec(ctx)
+	return nil
 }
 
-func (c *client) GetVehicleSnapshots(ctx context.Context, accountID, referenceID string, kind snapshotType, options ...SnapshotQuery) ([]VehicleSnapshot, error) {
-	var query getSnapshotQuery
-	for _, apply := range options {
-		apply(&query)
-	}
-
-	var models []db.VehicleSnapshotModel
-	raw, args := query.vehiclesQuery(accountID, referenceID, kind)
-	err := c.prisma.Prisma.Raw.QueryRaw(raw, args...).Exec(ctx, &models)
-	if err != nil {
-		return nil, err
-	}
-
-	var snapshots []VehicleSnapshot
-	for _, model := range models {
-		vehicle, err := VehicleSnapshot{}.FromModel(model)
-		if err != nil {
-			return nil, err
-		}
-		snapshots = append(snapshots, vehicle)
-	}
+func (c *libsqlClient) GetVehicleSnapshots(ctx context.Context, accountID, referenceID string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.VehicleSnapshot, error) {
+	// var query getSnapshotQuery
+	// for _, apply := range options {
+	// 	apply(&query)
+	// }
+
+	// var models []db.models.VehicleSnapshotModel
+	// raw, args := query.vehiclesQuery(accountID, referenceID, kind)
+	// err := c.prisma.Prisma.Raw.QueryRaw(raw, args...).Exec(ctx, &models)
+	// if err != nil {
+	// 	return nil, err
+	// }
+
+	var snapshots []models.VehicleSnapshot
+	// for _, model := range models {
+	// 	vehicle, err := models.VehicleSnapshot{}.FromModel(model)
+	// 	if err != nil {
+	// 		return nil, err
+	// 	}
+	// 	snapshots = append(snapshots, vehicle)
+	// }
 
 	return snapshots, nil
 }
 
-type AccountSnapshot struct {
-	ID             string
-	Type           snapshotType
-	CreatedAt      time.Time
-	AccountID      string
-	ReferenceID    string
-	LastBattleTime time.Time
-	RatingBattles  frame.StatsFrame
-	RegularBattles frame.StatsFrame
+// func (s AccountSnapshot) FromModel(model *db.AccountSnapshotModel) (AccountSnapshot, error) {
+// 	s.ID = model.ID
+// 	s.Type = models.SnapshotType(model.Type)
+// 	s.CreatedAt = model.CreatedAt
+// 	s.AccountID = model.AccountID
+// 	s.ReferenceID = model.ReferenceID
+// 	s.LastBattleTime = model.LastBattleTime
+
+// 	rating, err := frame.DecodeStatsFrame(model.RatingFrameEncoded)
+// 	if err != nil {
+// 		return AccountSnapshot{}, err
+// 	}
+// 	s.RatingBattles = rating
+
+// 	regular, err := frame.DecodeStatsFrame(model.RegularFrameEncoded)
+// 	if err != nil {
+// 		return AccountSnapshot{}, err
+// 	}
+// 	s.RegularBattles = regular
+
+// 	return s, nil
+// }
+
+func (c *libsqlClient) CreateAccountSnapshots(ctx context.Context, snapshots ...models.AccountSnapshot) error {
+	// if len(snapshots) < 1 {
+	// 	return nil
+	// }
+
+	// var transactions []transaction.Transaction
+	// for _, data := range snapshots {
+	// 	ratingEncoded, err := data.RatingBattles.Encode()
+	// 	if err != nil {
+	// 		log.Err(err).Str("accountId", data.AccountID).Msg("failed to encode rating stats frame for account snapthsot")
+	// 		continue
+	// 	}
+	// 	regularEncoded, err := data.RegularBattles.Encode()
+	// 	if err != nil {
+	// 		log.Err(err).Str("accountId", data.AccountID).Msg("failed to encode regular stats frame for account snapthsot")
+	// 		continue
+	// 	}
+
+	// 	transactions = append(transactions, c.prisma.AccountSnapshot.
+	// 		CreateOne(
+	// 			db.AccountSnapshot.CreatedAt.Set(data.CreatedAt),
+	// 			db.AccountSnapshot.Type.Set(string(data.Type)),
+	// 			db.AccountSnapshot.LastBattleTime.Set(data.LastBattleTime),
+	// 			db.AccountSnapshot.AccountID.Set(data.AccountID),
+	// 			db.AccountSnapshot.ReferenceID.Set(data.ReferenceID),
+	// 			db.AccountSnapshot.RatingBattles.Set(int(data.RatingBattles.Battles)),
+	// 			db.AccountSnapshot.RatingFrameEncoded.Set(ratingEncoded),
+	// 			db.AccountSnapshot.RegularBattles.Set(int(data.RegularBattles.Battles)),
+	// 			db.AccountSnapshot.RegularFrameEncoded.Set(regularEncoded),
+	// 		).Tx(),
+	// 	)
+	// }
+
+	// return c.prisma.Prisma.Transaction(transactions...).Exec(ctx)
+	return nil
 }
 
-func (s AccountSnapshot) FromModel(model *db.AccountSnapshotModel) (AccountSnapshot, error) {
-	s.ID = model.ID
-	s.Type = snapshotType(model.Type)
-	s.CreatedAt = model.CreatedAt
-	s.AccountID = model.AccountID
-	s.ReferenceID = model.ReferenceID
-	s.LastBattleTime = model.LastBattleTime
-
-	rating, err := frame.DecodeStatsFrame(model.RatingFrameEncoded)
-	if err != nil {
-		return AccountSnapshot{}, err
-	}
-	s.RatingBattles = rating
-
-	regular, err := frame.DecodeStatsFrame(model.RegularFrameEncoded)
-	if err != nil {
-		return AccountSnapshot{}, err
-	}
-	s.RegularBattles = regular
-
-	return s, nil
-}
-
-func (c *client) CreateAccountSnapshots(ctx context.Context, snapshots ...AccountSnapshot) error {
-	if len(snapshots) < 1 {
-		return nil
-	}
-
-	var transactions []transaction.Transaction
-	for _, data := range snapshots {
-		ratingEncoded, err := data.RatingBattles.Encode()
-		if err != nil {
-			log.Err(err).Str("accountId", data.AccountID).Msg("failed to encode rating stats frame for account snapthsot")
-			continue
-		}
-		regularEncoded, err := data.RegularBattles.Encode()
-		if err != nil {
-			log.Err(err).Str("accountId", data.AccountID).Msg("failed to encode regular stats frame for account snapthsot")
-			continue
-		}
-
-		transactions = append(transactions, c.prisma.AccountSnapshot.
-			CreateOne(
-				db.AccountSnapshot.CreatedAt.Set(data.CreatedAt),
-				db.AccountSnapshot.Type.Set(string(data.Type)),
-				db.AccountSnapshot.LastBattleTime.Set(data.LastBattleTime),
-				db.AccountSnapshot.AccountID.Set(data.AccountID),
-				db.AccountSnapshot.ReferenceID.Set(data.ReferenceID),
-				db.AccountSnapshot.RatingBattles.Set(int(data.RatingBattles.Battles)),
-				db.AccountSnapshot.RatingFrameEncoded.Set(ratingEncoded),
-				db.AccountSnapshot.RegularBattles.Set(int(data.RegularBattles.Battles)),
-				db.AccountSnapshot.RegularFrameEncoded.Set(regularEncoded),
-			).Tx(),
-		)
-	}
-
-	return c.prisma.Prisma.Transaction(transactions...).Exec(ctx)
-}
-
-func (c *client) GetLastAccountSnapshots(ctx context.Context, accountID string, limit int) ([]AccountSnapshot, error) {
-	models, err := c.prisma.AccountSnapshot.FindMany(db.AccountSnapshot.AccountID.Equals(accountID)).OrderBy(db.AccountSnapshot.CreatedAt.Order(db.DESC)).Take(limit).Exec(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	var snapshots []AccountSnapshot
-	for _, model := range models {
-		s, err := AccountSnapshot{}.FromModel(&model)
-		if err != nil {
-			return nil, err
-		}
-		snapshots = append(snapshots, s)
-	}
+func (c *libsqlClient) GetLastAccountSnapshots(ctx context.Context, accountID string, limit int) ([]models.AccountSnapshot, error) {
+	// models, err := c.prisma.AccountSnapshot.FindMany(db.AccountSnapshot.AccountID.Equals(accountID)).OrderBy(db.AccountSnapshot.CreatedAt.Order(db.DESC)).Take(limit).Exec(ctx)
+	// if err != nil {
+	// 	return nil, err
+	// }
+
+	var snapshots []models.AccountSnapshot
+	// for _, model := range models {
+	// 	s, err := AccountSnapshot{}.FromModel(&model)
+	// 	if err != nil {
+	// 		return nil, err
+	// 	}
+	// 	snapshots = append(snapshots, s)
+	// }
 	return snapshots, nil
 }
 
-func (c *client) GetAccountSnapshot(ctx context.Context, accountID, referenceID string, kind snapshotType, options ...SnapshotQuery) (AccountSnapshot, error) {
-	var query getSnapshotQuery
-	for _, apply := range options {
-		apply(&query)
-	}
+func (c *libsqlClient) GetAccountSnapshot(ctx context.Context, accountID, referenceID string, kind models.SnapshotType, options ...SnapshotQuery) (models.AccountSnapshot, error) {
+	// var query getSnapshotQuery
+	// for _, apply := range options {
+	// 	apply(&query)
+	// }
 
-	model, err := c.prisma.AccountSnapshot.FindFirst(query.accountParams(accountID, referenceID, kind)...).OrderBy(query.accountOrder()...).Exec(ctx)
-	if err != nil {
-		return AccountSnapshot{}, err
-	}
+	// model, err := c.prisma.AccountSnapshot.FindFirst(query.accountParams(accountID, referenceID, kind)...).OrderBy(query.accountOrder()...).Exec(ctx)
+	// if err != nil {
+	// 	return AccountSnapshot{}, err
+	// }
 
-	return AccountSnapshot{}.FromModel(model)
+	return models.AccountSnapshot{}, nil
 }
 
-func (c *client) GetManyAccountSnapshots(ctx context.Context, accountIDs []string, kind snapshotType, options ...SnapshotQuery) ([]AccountSnapshot, error) {
-	var query getSnapshotQuery
-	for _, apply := range options {
-		apply(&query)
-	}
-
-	var models []db.AccountSnapshotModel
-	raw, args := query.manyAccountsQuery(accountIDs, kind)
-	err := c.prisma.Prisma.Raw.QueryRaw(raw, args...).Exec(ctx, &models)
-	if err != nil {
-		return nil, err
-	}
-
-	var snapshots []AccountSnapshot
-	for _, model := range models {
-		snapshot, err := AccountSnapshot{}.FromModel(&model)
-		if err != nil {
-			return nil, err
-		}
-		snapshots = append(snapshots, snapshot)
-	}
+func (c *libsqlClient) GetManyAccountSnapshots(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.AccountSnapshot, error) {
+	// var query getSnapshotQuery
+	// for _, apply := range options {
+	// 	apply(&query)
+	// }
+
+	// var models []db.AccountSnapshotModel
+	// raw, args := query.manyAccountsQuery(accountIDs, kind)
+	// err := c.prisma.Prisma.Raw.QueryRaw(raw, args...).Exec(ctx, &models)
+	// if err != nil {
+	// 	return nil, err
+	// }
+
+	var snapshots []models.AccountSnapshot
+	// for _, model := range models {
+	// 	snapshot, err := AccountSnapshot{}.FromModel(&model)
+	// 	if err != nil {
+	// 		return nil, err
+	// 	}
+	// 	snapshots = append(snapshots, snapshot)
+	// }
 
 	return snapshots, nil
 
diff --git a/internal/database/snapshots_test.go b/internal/database/snapshots_test.go
index c4f7553d..06653cf5 100644
--- a/internal/database/snapshots_test.go
+++ b/internal/database/snapshots_test.go
@@ -1,121 +1,113 @@
 package database
 
-import (
-	"context"
-	"testing"
-	"time"
+// /*
+// DATABASE_URL needs to be set and migrations need to be applied
+// */
+// func TestGetVehicleSnapshots(t *testing.T) {
+// 	client, err := NewClient()
+// 	assert.NoError(t, err, "new client should not error")
+// 	defer client.prisma.Disconnect()
 
-	"github.com/stretchr/testify/assert"
-)
+// 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*15)
+// 	defer cancel()
 
-/*
-DATABASE_URL needs to be set and migrations need to be applied
-*/
-func TestGetVehicleSnapshots(t *testing.T) {
-	client, err := NewClient()
-	assert.NoError(t, err, "new client should not error")
-	defer client.prisma.Disconnect()
+// 	client.prisma.VehicleSnapshot.FindMany().Delete().Exec(ctx)
+// 	defer client.prisma.VehicleSnapshot.FindMany().Delete().Exec(ctx)
 
-	ctx, cancel := context.WithTimeout(context.Background(), time.Second*15)
-	defer cancel()
+// 	createdAtVehicle1 := time.Date(2023, 6, 1, 0, 0, 0, 0, time.UTC)
+// 	createdAtVehicle2 := time.Date(2023, 8, 1, 0, 0, 0, 0, time.UTC)
+// 	createdAtVehicle3 := time.Date(2023, 10, 1, 0, 0, 0, 0, time.UTC)
 
-	client.prisma.VehicleSnapshot.FindMany().Delete().Exec(ctx)
-	defer client.prisma.VehicleSnapshot.FindMany().Delete().Exec(ctx)
+// 	createdAtVehicle4 := time.Date(2023, 9, 1, 0, 0, 0, 0, time.UTC)
+// 	createdAtVehicle5 := time.Date(2023, 9, 2, 0, 0, 0, 0, time.UTC)
 
-	createdAtVehicle1 := time.Date(2023, 6, 1, 0, 0, 0, 0, time.UTC)
-	createdAtVehicle2 := time.Date(2023, 8, 1, 0, 0, 0, 0, time.UTC)
-	createdAtVehicle3 := time.Date(2023, 10, 1, 0, 0, 0, 0, time.UTC)
+// 	vehicle1 := VehicleSnapshot{
+// 		VehicleID:   "v1",
+// 		AccountID:   "a1",
+// 		ReferenceID: "r1",
 
-	createdAtVehicle4 := time.Date(2023, 9, 1, 0, 0, 0, 0, time.UTC)
-	createdAtVehicle5 := time.Date(2023, 9, 2, 0, 0, 0, 0, time.UTC)
+// 		Type:           SnapshotTypeDaily,
+// 		CreatedAt:      createdAtVehicle1,
+// 		LastBattleTime: createdAtVehicle1,
+// 	}
+// 	vehicle2 := VehicleSnapshot{
+// 		VehicleID:   "v1",
+// 		AccountID:   "a1",
+// 		ReferenceID: "r1",
 
-	vehicle1 := VehicleSnapshot{
-		VehicleID:   "v1",
-		AccountID:   "a1",
-		ReferenceID: "r1",
+// 		Type:           SnapshotTypeDaily,
+// 		CreatedAt:      createdAtVehicle2,
+// 		LastBattleTime: createdAtVehicle2,
+// 	}
+// 	vehicle3 := VehicleSnapshot{
+// 		VehicleID:   "v1",
+// 		AccountID:   "a1",
+// 		ReferenceID: "r1",
 
-		Type:           SnapshotTypeDaily,
-		CreatedAt:      createdAtVehicle1,
-		LastBattleTime: createdAtVehicle1,
-	}
-	vehicle2 := VehicleSnapshot{
-		VehicleID:   "v1",
-		AccountID:   "a1",
-		ReferenceID: "r1",
+// 		Type:           SnapshotTypeDaily,
+// 		CreatedAt:      createdAtVehicle3,
+// 		LastBattleTime: createdAtVehicle3,
+// 	}
+// 	vehicle4 := VehicleSnapshot{
+// 		VehicleID:   "v4",
+// 		AccountID:   "a1",
+// 		ReferenceID: "r2",
 
-		Type:           SnapshotTypeDaily,
-		CreatedAt:      createdAtVehicle2,
-		LastBattleTime: createdAtVehicle2,
-	}
-	vehicle3 := VehicleSnapshot{
-		VehicleID:   "v1",
-		AccountID:   "a1",
-		ReferenceID: "r1",
+// 		Type:           SnapshotTypeDaily,
+// 		CreatedAt:      createdAtVehicle4,
+// 		LastBattleTime: createdAtVehicle4,
+// 	}
+// 	vehicle5 := VehicleSnapshot{
+// 		VehicleID:   "v5",
+// 		AccountID:   "a1",
+// 		ReferenceID: "r2",
 
-		Type:           SnapshotTypeDaily,
-		CreatedAt:      createdAtVehicle3,
-		LastBattleTime: createdAtVehicle3,
-	}
-	vehicle4 := VehicleSnapshot{
-		VehicleID:   "v4",
-		AccountID:   "a1",
-		ReferenceID: "r2",
+// 		Type:           SnapshotTypeDaily,
+// 		CreatedAt:      createdAtVehicle5,
+// 		LastBattleTime: createdAtVehicle5,
+// 	}
+// 	vehicle6 := VehicleSnapshot{
+// 		VehicleID:   "v5",
+// 		AccountID:   "a1",
+// 		ReferenceID: "r2",
 
-		Type:           SnapshotTypeDaily,
-		CreatedAt:      createdAtVehicle4,
-		LastBattleTime: createdAtVehicle4,
-	}
-	vehicle5 := VehicleSnapshot{
-		VehicleID:   "v5",
-		AccountID:   "a1",
-		ReferenceID: "r2",
+// 		Type:           SnapshotTypeDaily,
+// 		CreatedAt:      createdAtVehicle5,
+// 		LastBattleTime: createdAtVehicle5,
+// 	}
 
-		Type:           SnapshotTypeDaily,
-		CreatedAt:      createdAtVehicle5,
-		LastBattleTime: createdAtVehicle5,
-	}
-	vehicle6 := VehicleSnapshot{
-		VehicleID:   "v5",
-		AccountID:   "a1",
-		ReferenceID: "r2",
-
-		Type:           SnapshotTypeDaily,
-		CreatedAt:      createdAtVehicle5,
-		LastBattleTime: createdAtVehicle5,
-	}
-
-	{ // create snapshots
-		snaphots := []VehicleSnapshot{vehicle1, vehicle2, vehicle3, vehicle4, vehicle5, vehicle6}
-		err = client.CreateVehicleSnapshots(ctx, snaphots...)
-		assert.NoError(t, err, "create vehicle snapshot should not error")
-	}
-	{ // when we check created after, vehicles need to be ordered by createdAt ASC, so we expect to get vehicle2 back
-		vehicles, err := client.GetVehicleSnapshots(ctx, "a1", "r1", SnapshotTypeDaily, WithCreatedAfter(createdAtVehicle1))
-		assert.NoError(t, err, "get vehicle snapshot error")
-		assert.Len(t, vehicles, 1, "should return exactly 1 snapshots")
-		assert.True(t, vehicles[0].CreatedAt.Equal(createdAtVehicle2), "wrong vehicle snapshot returned", vehicles)
-	}
-	{ // when we check created before, vehicles need to be ordered by createdAt DESC, so we expect to get vehicle2 back
-		vehicles, err := client.GetVehicleSnapshots(ctx, "a1", "r1", SnapshotTypeDaily, WithCreatedBefore(createdAtVehicle3))
-		assert.NoError(t, err, "get vehicle snapshot error")
-		assert.Len(t, vehicles, 1, "should return exactly 1 snapshots")
-		assert.True(t, vehicles[0].CreatedAt.Equal(createdAtVehicle2), "wrong vehicle snapshot returned", vehicles)
-	}
-	{ // make sure only 1 vehicle is returned per ID
-		vehicles, err := client.GetVehicleSnapshots(ctx, "a1", "r2", SnapshotTypeDaily, WithCreatedBefore(createdAtVehicle5.Add(time.Hour)))
-		assert.NoError(t, err, "get vehicle snapshot error")
-		assert.Len(t, vehicles, 2, "should return exactly 2 snapshots")
-		assert.NotEqual(t, vehicles[0].ID, vehicles[1].ID, "each vehicle id should only be returned once", vehicles)
-	}
-	{ // get a cehicle with a specific id
-		vehicles, err := client.GetVehicleSnapshots(ctx, "a1", "r2", SnapshotTypeDaily, WithVehicleIDs([]string{"v5"}))
-		assert.NoError(t, err, "get vehicle snapshot error")
-		assert.Len(t, vehicles, 1, "should return exactly 1 snapshots")
-		assert.NotEqual(t, vehicles[0].ID, "v5", "incorrect vehicle returned", vehicles)
-	}
-	{ // this should return no result
-		vehicles, err := client.GetVehicleSnapshots(ctx, "a1", "r1", SnapshotTypeDaily, WithCreatedBefore(createdAtVehicle1))
-		assert.NoError(t, err, "no results from a raw query does not trigger an error")
-		assert.Len(t, vehicles, 0, "return should have no results", vehicles)
-	}
-}
+// 	{ // create snapshots
+// 		snaphots := []VehicleSnapshot{vehicle1, vehicle2, vehicle3, vehicle4, vehicle5, vehicle6}
+// 		err = client.CreateVehicleSnapshots(ctx, snaphots...)
+// 		assert.NoError(t, err, "create vehicle snapshot should not error")
+// 	}
+// 	{ // when we check created after, vehicles need to be ordered by createdAt ASC, so we expect to get vehicle2 back
+// 		vehicles, err := client.GetVehicleSnapshots(ctx, "a1", "r1", SnapshotTypeDaily, WithCreatedAfter(createdAtVehicle1))
+// 		assert.NoError(t, err, "get vehicle snapshot error")
+// 		assert.Len(t, vehicles, 1, "should return exactly 1 snapshots")
+// 		assert.True(t, vehicles[0].CreatedAt.Equal(createdAtVehicle2), "wrong vehicle snapshot returned", vehicles)
+// 	}
+// 	{ // when we check created before, vehicles need to be ordered by createdAt DESC, so we expect to get vehicle2 back
+// 		vehicles, err := client.GetVehicleSnapshots(ctx, "a1", "r1", SnapshotTypeDaily, WithCreatedBefore(createdAtVehicle3))
+// 		assert.NoError(t, err, "get vehicle snapshot error")
+// 		assert.Len(t, vehicles, 1, "should return exactly 1 snapshots")
+// 		assert.True(t, vehicles[0].CreatedAt.Equal(createdAtVehicle2), "wrong vehicle snapshot returned", vehicles)
+// 	}
+// 	{ // make sure only 1 vehicle is returned per ID
+// 		vehicles, err := client.GetVehicleSnapshots(ctx, "a1", "r2", SnapshotTypeDaily, WithCreatedBefore(createdAtVehicle5.Add(time.Hour)))
+// 		assert.NoError(t, err, "get vehicle snapshot error")
+// 		assert.Len(t, vehicles, 2, "should return exactly 2 snapshots")
+// 		assert.NotEqual(t, vehicles[0].ID, vehicles[1].ID, "each vehicle id should only be returned once", vehicles)
+// 	}
+// 	{ // get a cehicle with a specific id
+// 		vehicles, err := client.GetVehicleSnapshots(ctx, "a1", "r2", SnapshotTypeDaily, WithVehicleIDs([]string{"v5"}))
+// 		assert.NoError(t, err, "get vehicle snapshot error")
+// 		assert.Len(t, vehicles, 1, "should return exactly 1 snapshots")
+// 		assert.NotEqual(t, vehicles[0].ID, "v5", "incorrect vehicle returned", vehicles)
+// 	}
+// 	{ // this should return no result
+// 		vehicles, err := client.GetVehicleSnapshots(ctx, "a1", "r1", SnapshotTypeDaily, WithCreatedBefore(createdAtVehicle1))
+// 		assert.NoError(t, err, "no results from a raw query does not trigger an error")
+// 		assert.Len(t, vehicles, 0, "return should have no results", vehicles)
+// 	}
+// }
diff --git a/internal/database/tasks.go b/internal/database/tasks.go
index a2d64be9..73f95eb3 100644
--- a/internal/database/tasks.go
+++ b/internal/database/tasks.go
@@ -2,148 +2,45 @@ package database
 
 import (
 	"context"
-	"encoding/json"
-	"strings"
 	"time"
 
-	"github.com/cufee/aftermath/internal/database/prisma/db"
-	"github.com/cufee/aftermath/internal/encoding"
+	"github.com/cufee/aftermath/internal/database/models"
 )
 
-type TaskType string
+// func (t Task) FromModel(model db.CronTaskModel) Task {
+// 	t.ID = model.ID
+// 	t.Type = TaskType(model.Type)
 
-const (
-	TaskTypeUpdateClans              TaskType = "UPDATE_CLANS"
-	TaskTypeRecordSessions           TaskType = "RECORD_ACCOUNT_SESSIONS"
-	TaskTypeUpdateAccountWN8         TaskType = "UPDATE_ACCOUNT_WN8"
-	TaskTypeRecordPlayerAchievements TaskType = "UPDATE_ACCOUNT_ACHIEVEMENTS"
+// 	t.Status = TaskStatus(model.Status)
+// 	t.ReferenceID = model.ReferenceID
 
-	TaskTypeDatabaseCleanup TaskType = "CLEANUP_DATABASE"
-)
-
-// Task statuses
-type TaskStatus string
-
-const (
-	TaskStatusScheduled  TaskStatus = "TASK_SCHEDULED"
-	TaskStatusInProgress TaskStatus = "TASK_IN_PROGRESS"
-	TaskStatusComplete   TaskStatus = "TASK_COMPLETE"
-	TaskStatusFailed     TaskStatus = "TASK_FAILED"
-)
-
-type Task struct {
-	ID        string    `json:"id"`
-	Type      TaskType  `json:"kind"`
-	CreatedAt time.Time `json:"createdAt"`
-	UpdatedAt time.Time `json:"updatedAt"`
-
-	ReferenceID string   `json:"referenceId"`
-	Targets     []string `json:"targets"`
-
-	Logs []TaskLog `json:"logs"`
-
-	Status         TaskStatus `json:"status"`
-	ScheduledAfter time.Time  `json:"scheduledAfter"`
-	LastRun        time.Time  `json:"lastRun"`
-
-	Data map[string]any `json:"data"`
-}
-
-func (t Task) FromModel(model db.CronTaskModel) Task {
-	t.ID = model.ID
-	t.Type = TaskType(model.Type)
-
-	t.Status = TaskStatus(model.Status)
-	t.ReferenceID = model.ReferenceID
-
-	t.LastRun = model.LastRun
-	t.CreatedAt = model.CreatedAt
-	t.UpdatedAt = model.UpdatedAt
-	t.ScheduledAfter = model.ScheduledAfter
-
-	t.decodeData(model.DataEncoded)
-	t.decodeLogs(model.LogsEncoded)
-	t.decodeTargets(model.TargetsEncoded)
-	return t
-}
-
-func (t *Task) LogAttempt(log TaskLog) {
-	t.Logs = append(t.Logs, log)
-}
-
-func (t *Task) OnCreated() {
-	t.LastRun = time.Now()
-	t.CreatedAt = time.Now()
-	t.UpdatedAt = time.Now()
-}
-func (t *Task) OnUpdated() {
-	t.UpdatedAt = time.Now()
-}
-
-func (t *Task) encodeTargets() []byte {
-	return []byte(strings.Join(t.Targets, ";"))
-}
-func (t *Task) decodeTargets(targets []byte) {
-	if string(targets) != "" {
-		t.Targets = strings.Split(string(targets), ";")
-	}
-}
+// 	t.LastRun = model.LastRun
+// 	t.CreatedAt = model.CreatedAt
+// 	t.UpdatedAt = model.UpdatedAt
+// 	t.ScheduledAfter = model.ScheduledAfter
 
-func (t *Task) encodeLogs() []byte {
-	if t.Logs == nil {
-		return []byte{}
-	}
-	data, _ := json.Marshal(t.Logs)
-	return data
-}
-func (t *Task) decodeLogs(logs []byte) {
-	_ = json.Unmarshal(logs, &t.Logs)
-}
-
-func (t *Task) encodeData() []byte {
-	if t.Data == nil {
-		return []byte{}
-	}
-	data, _ := encoding.EncodeGob(t.Data)
-	return data
-}
-func (t *Task) decodeData(data []byte) {
-	t.Data = make(map[string]any)
-	_ = encoding.DecodeGob(data, &t.Data)
-}
-
-type TaskLog struct {
-	Targets   []string  `json:"targets" bson:"targets"`
-	Timestamp time.Time `json:"timestamp" bson:"timestamp"`
-	Comment   string    `json:"result" bson:"result"`
-	Error     string    `json:"error" bson:"error"`
-}
-
-func NewAttemptLog(task Task, comment, err string) TaskLog {
-	return TaskLog{
-		Targets:   task.Targets,
-		Timestamp: time.Now(),
-		Comment:   comment,
-		Error:     err,
-	}
-}
+// 	t.decodeData(model.DataEncoded)
+// 	t.decodeLogs(model.LogsEncoded)
+// 	t.decodeTargets(model.TargetsEncoded)
+// 	return t
+// }
 
 /*
 Returns up limit tasks that have TaskStatusInProgress and were last updates 1+ hours ago
 */
-func (c *client) GetStaleTasks(ctx context.Context, limit int) ([]Task, error) {
-	models, err := c.prisma.CronTask.FindMany(
-		db.CronTask.Status.Equals(string(TaskStatusInProgress)),
-		db.CronTask.LastRun.Before(time.Now().Add(time.Hour*-1)),
-	).OrderBy(db.CronTask.ScheduledAfter.Order(db.ASC)).Take(limit).Exec(ctx)
-	if err != nil && !db.IsErrNotFound(err) {
-		return nil, err
-	}
-
-	var tasks []Task
-	for _, model := range models {
-		tasks = append(tasks, Task{}.FromModel(model))
-	}
+func (c *libsqlClient) GetStaleTasks(ctx context.Context, limit int) ([]models.Task, error) {
+	// models, err := c.prisma.CronTask.FindMany(
+	// 	db.CronTask.Status.Equals(string(TaskStatusInProgress)),
+	// 	db.CronTask.LastRun.Before(time.Now().Add(time.Hour*-1)),
+	// ).OrderBy(db.CronTask.ScheduledAfter.Order(db.ASC)).Take(limit).Exec(ctx)
+	// if err != nil && !database.IsNotFound(err) {
+	// 	return nil, err
+	// }
+
+	var tasks []models.Task
+	// for _, model := range models {
+	// 	tasks = append(tasks, Task{}.FromModel(model))
+	// }
 
 	return tasks, nil
 }
@@ -151,26 +48,26 @@ func (c *client) GetStaleTasks(ctx context.Context, limit int) ([]Task, error) {
 /*
 Returns all tasks that were created after createdAfter, sorted by ScheduledAfter (DESC)
 */
-func (c *client) GetRecentTasks(ctx context.Context, createdAfter time.Time, status ...TaskStatus) ([]Task, error) {
-	var statusStr []string
-	for _, s := range status {
-		statusStr = append(statusStr, string(s))
-	}
-
-	params := []db.CronTaskWhereParam{db.CronTask.CreatedAt.After(createdAfter)}
-	if len(statusStr) > 0 {
-		params = append(params, db.CronTask.Status.In(statusStr))
-	}
-
-	models, err := c.prisma.CronTask.FindMany(params...).OrderBy(db.CronTask.ScheduledAfter.Order(db.DESC)).Exec(ctx)
-	if err != nil && !db.IsErrNotFound(err) {
-		return nil, err
-	}
-
-	var tasks []Task
-	for _, model := range models {
-		tasks = append(tasks, Task{}.FromModel(model))
-	}
+func (c *libsqlClient) GetRecentTasks(ctx context.Context, createdAfter time.Time, status ...models.TaskStatus) ([]models.Task, error) {
+	// var statusStr []string
+	// for _, s := range status {
+	// 	statusStr = append(statusStr, string(s))
+	// }
+
+	// params := []db.CronTaskWhereParam{db.CronTask.CreatedAt.After(createdAfter)}
+	// if len(statusStr) > 0 {
+	// 	params = append(params, db.CronTask.Status.In(statusStr))
+	// }
+
+	// models, err := c.prisma.CronTask.FindMany(params...).OrderBy(db.CronTask.ScheduledAfter.Order(db.DESC)).Exec(ctx)
+	// if err != nil && !database.IsNotFound(err) {
+	// 	return nil, err
+	// }
+
+	var tasks []models.Task
+	// for _, model := range models {
+	// 	tasks = append(tasks, Task{}.FromModel(model))
+	// }
 
 	return tasks, nil
 }
@@ -179,76 +76,76 @@ func (c *client) GetRecentTasks(ctx context.Context, createdAfter time.Time, sta
 GetAndStartTasks retrieves up to limit number of tasks matching the referenceId and updates their status to in progress
   - this func will block until all other calls to task update funcs are done
 */
-func (c *client) GetAndStartTasks(ctx context.Context, limit int) ([]Task, error) {
-	if limit < 1 {
-		return nil, nil
-	}
-	if err := c.tasksUpdateSem.Acquire(ctx, 1); err != nil {
-		return nil, err
-	}
-	defer c.tasksUpdateSem.Release(1)
-
-	models, err := c.prisma.CronTask.
-		FindMany(
-			db.CronTask.Status.Equals(string(TaskStatusScheduled)),
-			db.CronTask.ScheduledAfter.Lt(time.Now()),
-		).
-		OrderBy(db.CronTask.ScheduledAfter.Order(db.ASC)).
-		Take(limit).
-		Exec(ctx)
-	if err != nil {
-		if db.IsErrNotFound(err) {
-			return nil, nil
-		}
-		return nil, err
-	}
-	if len(models) < 1 {
-		return nil, nil
-	}
-
-	var ids []string
-	var tasks []Task
-	for _, model := range models {
-		tasks = append(tasks, Task{}.FromModel(model))
-		ids = append(ids, model.ID)
-	}
-
-	_, err = c.prisma.CronTask.
-		FindMany(db.CronTask.ID.In(ids)).
-		Update(db.CronTask.Status.Set(string(TaskStatusInProgress)), db.CronTask.LastRun.Set(time.Now())).
-		Exec(ctx)
-	if err != nil {
-		return nil, err
-	}
+func (c *libsqlClient) GetAndStartTasks(ctx context.Context, limit int) ([]models.Task, error) {
+	// if limit < 1 {
+	// 	return nil, nil
+	// }
+	// if err := c.tasksUpdateSem.Acquire(ctx, 1); err != nil {
+	// 	return nil, err
+	// }
+	// defer c.tasksUpdateSem.Release(1)
+
+	// models, err := c.prisma.CronTask.
+	// 	FindMany(
+	// 		db.CronTask.Status.Equals(string(TaskStatusScheduled)),
+	// 		db.CronTask.ScheduledAfter.Lt(time.Now()),
+	// 	).
+	// 	OrderBy(db.CronTask.ScheduledAfter.Order(db.ASC)).
+	// 	Take(limit).
+	// 	Exec(ctx)
+	// if err != nil {
+	// 	if database.IsNotFound(err) {
+	// 		return nil, nil
+	// 	}
+	// 	return nil, err
+	// }
+	// if len(models) < 1 {
+	// 	return nil, nil
+	// }
+
+	// var ids []string
+	var tasks []models.Task
+	// for _, model := range models {
+	// 	tasks = append(tasks, Task{}.FromModel(model))
+	// 	ids = append(ids, model.ID)
+	// }
+
+	// _, err = c.prisma.CronTask.
+	// 	FindMany(db.CronTask.ID.In(ids)).
+	// 	Update(db.CronTask.Status.Set(string(TaskStatusInProgress)), db.CronTask.LastRun.Set(time.Now())).
+	// 	Exec(ctx)
+	// if err != nil {
+	// 	return nil, err
+	// }
 
 	return tasks, nil
 }
 
-func (c *client) CreateTasks(ctx context.Context, tasks ...Task) error {
-	if len(tasks) < 1 {
-		return nil
-	}
-	// we do not block using c.tasksUpdateSem here because the order of ops in GetAndStartTasks makes this safe
-
-	var txns []db.PrismaTransaction
-	for _, task := range tasks {
-		task.OnCreated()
-		txns = append(txns, c.prisma.CronTask.CreateOne(
-			db.CronTask.Type.Set(string(task.Type)),
-			db.CronTask.ReferenceID.Set(task.ReferenceID),
-			db.CronTask.TargetsEncoded.Set(task.encodeTargets()),
-			db.CronTask.Status.Set(string(TaskStatusScheduled)),
-			db.CronTask.LastRun.Set(time.Now()),
-			db.CronTask.ScheduledAfter.Set(task.ScheduledAfter),
-			db.CronTask.LogsEncoded.Set(task.encodeLogs()),
-			db.CronTask.DataEncoded.Set(task.encodeData()),
-		).Tx())
-	}
-
-	err := c.prisma.Prisma.Transaction(txns...).Exec(ctx)
-	if err != nil {
-		return err
-	}
+func (c *libsqlClient) CreateTasks(ctx context.Context, tasks ...models.Task) error {
+	// if len(tasks) < 1 {
+	// 	return nil
+	// }
+	// // we do not block using c.tasksUpdateSem here because the order of ops in GetAndStartTasks makes this safe
+
+	// var txns []db.PrismaTransaction
+	// for _, task := range tasks {
+	// 	task.OnCreated()
+	// 	txns = append(txns, c.prisma.CronTask.CreateOne(
+	// 		db.CronTask.Type.Set(string(task.Type)),
+	// 		db.CronTask.ReferenceID.Set(task.ReferenceID),
+	// 		db.CronTask.TargetsEncoded.Set(task.encodeTargets()),
+	// 		db.CronTask.Status.Set(string(TaskStatusScheduled)),
+	// 		db.CronTask.LastRun.Set(time.Now()),
+	// 		db.CronTask.ScheduledAfter.Set(task.ScheduledAfter),
+	// 		db.CronTask.LogsEncoded.Set(task.encodeLogs()),
+	// 		db.CronTask.DataEncoded.Set(task.encodeData()),
+	// 	).Tx())
+	// }
+
+	// err := c.prisma.Prisma.Transaction(txns...).Exec(ctx)
+	// if err != nil {
+	// 	return err
+	// }
 	return nil
 }
 
@@ -257,35 +154,35 @@ UpdateTasks will update all tasks passed in
   - the following fields will be replaced: targets, status, leastRun, scheduleAfterm logs, data
   - this func will block until all other calls to task update funcs are done
 */
-func (c *client) UpdateTasks(ctx context.Context, tasks ...Task) error {
-	if len(tasks) < 1 {
-		return nil
-	}
-
-	if err := c.tasksUpdateSem.Acquire(ctx, 1); err != nil {
-		return err
-	}
-	defer c.tasksUpdateSem.Release(1)
-
-	var txns []db.PrismaTransaction
-	for _, task := range tasks {
-		task.OnUpdated()
-		txns = append(txns, c.prisma.CronTask.
-			FindUnique(db.CronTask.ID.Equals(task.ID)).
-			Update(
-				db.CronTask.TargetsEncoded.Set(task.encodeTargets()),
-				db.CronTask.Status.Set(string(task.Status)),
-				db.CronTask.LastRun.Set(task.LastRun),
-				db.CronTask.ScheduledAfter.Set(task.ScheduledAfter),
-				db.CronTask.LogsEncoded.Set(task.encodeLogs()),
-				db.CronTask.DataEncoded.Set(task.encodeData()),
-			).Tx())
-	}
-
-	err := c.prisma.Prisma.Transaction(txns...).Exec(ctx)
-	if err != nil {
-		return err
-	}
+func (c *libsqlClient) UpdateTasks(ctx context.Context, tasks ...models.Task) error {
+	// if len(tasks) < 1 {
+	// 	return nil
+	// }
+
+	// if err := c.tasksUpdateSem.Acquire(ctx, 1); err != nil {
+	// 	return err
+	// }
+	// defer c.tasksUpdateSem.Release(1)
+
+	// var txns []db.PrismaTransaction
+	// for _, task := range tasks {
+	// 	task.OnUpdated()
+	// 	txns = append(txns, c.prisma.CronTask.
+	// 		FindUnique(db.CronTask.ID.Equals(task.ID)).
+	// 		Update(
+	// 			db.CronTask.TargetsEncoded.Set(task.encodeTargets()),
+	// 			db.CronTask.Status.Set(string(task.Status)),
+	// 			db.CronTask.LastRun.Set(task.LastRun),
+	// 			db.CronTask.ScheduledAfter.Set(task.ScheduledAfter),
+	// 			db.CronTask.LogsEncoded.Set(task.encodeLogs()),
+	// 			db.CronTask.DataEncoded.Set(task.encodeData()),
+	// 		).Tx())
+	// }
+
+	// err := c.prisma.Prisma.Transaction(txns...).Exec(ctx)
+	// if err != nil {
+	// 	return err
+	// }
 	return nil
 }
 
@@ -293,19 +190,19 @@ func (c *client) UpdateTasks(ctx context.Context, tasks ...Task) error {
 DeleteTasks will delete all tasks matching by ids
   - this func will block until all other calls to task update funcs are done
 */
-func (c *client) DeleteTasks(ctx context.Context, ids ...string) error {
-	if len(ids) < 1 {
-		return nil
-	}
-
-	if err := c.tasksUpdateSem.Acquire(ctx, 1); err != nil {
-		return nil
-	}
-	defer c.tasksUpdateSem.Release(1)
-
-	_, err := c.prisma.CronTask.FindMany(db.CronTask.ID.In(ids)).Delete().Exec(ctx)
-	if err != nil {
-		return err
-	}
+func (c *libsqlClient) DeleteTasks(ctx context.Context, ids ...string) error {
+	// if len(ids) < 1 {
+	// 	return nil
+	// }
+
+	// if err := c.tasksUpdateSem.Acquire(ctx, 1); err != nil {
+	// 	return nil
+	// }
+	// defer c.tasksUpdateSem.Release(1)
+
+	// _, err := c.prisma.CronTask.FindMany(db.CronTask.ID.In(ids)).Delete().Exec(ctx)
+	// if err != nil {
+	// 	return err
+	// }
 	return nil
 }
diff --git a/internal/database/users.go b/internal/database/users.go
index ed953375..83772c6b 100644
--- a/internal/database/users.go
+++ b/internal/database/users.go
@@ -2,134 +2,24 @@ package database
 
 import (
 	"context"
-	"fmt"
-	"slices"
-	"time"
 
-	"github.com/pkg/errors"
-
-	"github.com/cufee/aftermath/internal/database/prisma/db"
-	"github.com/cufee/aftermath/internal/encoding"
+	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/permissions"
 )
 
-type User struct {
-	ID string
-
-	Permissions permissions.Permissions
-
-	Connections   []UserConnection
-	Subscriptions []UserSubscription
-}
-
-func (u User) Connection(kind ConnectionType) (UserConnection, bool) {
-	for _, connection := range u.Connections {
-		if connection.Type == kind {
-			return connection, true
-		}
-	}
-	return UserConnection{}, false
-}
-
-func (u User) Subscription(kind SubscriptionType) (UserSubscription, bool) {
-	for _, subscription := range u.Subscriptions {
-		if subscription.Type == kind {
-			return subscription, true
-		}
-	}
-	return UserSubscription{}, false
-}
-
-type ConnectionType string
-
-const (
-	ConnectionTypeWargaming = ConnectionType("wargaming")
-)
-
-type UserConnection struct {
-	ID string `json:"id"`
-
-	Type ConnectionType `json:"type"`
-
-	UserID      string                  `json:"userId"`
-	ReferenceID string                  `json:"referenceId"`
-	Permissions permissions.Permissions `json:"permissions"`
-
-	Metadata map[string]any `json:"metadata"`
-}
-
-func (c UserConnection) FromModel(model *db.UserConnectionModel) UserConnection {
-	c.ID = model.ID
-	c.UserID = model.UserID
-	c.Metadata = make(map[string]any)
-	c.ReferenceID = model.ReferenceID
-	c.Permissions = permissions.Parse(model.Permissions, permissions.Blank)
-
-	c.Type = ConnectionType(model.Type)
-	if model.MetadataEncoded != nil {
-		_ = encoding.DecodeGob(model.MetadataEncoded, &c.Metadata)
-	}
-	return c
-}
-
-type SubscriptionType string
-
-func (s SubscriptionType) GetPermissions() permissions.Permissions {
-	switch s {
-	case SubscriptionTypePlus:
-		return permissions.SubscriptionAftermathPlus
-	case SubscriptionTypePro:
-		return permissions.SubscriptionAftermathPro
-	case SubscriptionTypeProClan:
-		return permissions.SubscriptionAftermathPro
-	default:
-		return permissions.User
-	}
-}
-
-// Paid
-const SubscriptionTypePro = SubscriptionType("aftermath-pro")
-const SubscriptionTypeProClan = SubscriptionType("aftermath-pro-clan")
-const SubscriptionTypePlus = SubscriptionType("aftermath-plus")
-
-// Misc
-const SubscriptionTypeSupporter = SubscriptionType("supporter")
-const SubscriptionTypeVerifiedClan = SubscriptionType("verified-clan")
-
-// Moderators
-const SubscriptionTypeServerModerator = SubscriptionType("server-moderator")
-const SubscriptionTypeContentModerator = SubscriptionType("content-moderator")
-
-// Special
-const SubscriptionTypeDeveloper = SubscriptionType("developer")
-const SubscriptionTypeServerBooster = SubscriptionType("server-booster")
-const SubscriptionTypeContentTranslator = SubscriptionType("content-translator")
-
-var AllSubscriptionTypes = []SubscriptionType{
-	SubscriptionTypePro,
-	SubscriptionTypeProClan,
-	SubscriptionTypePlus,
-	SubscriptionTypeSupporter,
-	SubscriptionTypeVerifiedClan,
-	SubscriptionTypeServerModerator,
-	SubscriptionTypeContentModerator,
-	SubscriptionTypeDeveloper,
-	SubscriptionTypeServerBooster,
-	SubscriptionTypeContentTranslator,
-}
-
-func (s SubscriptionType) Valid() bool {
-	return slices.Contains(AllSubscriptionTypes, s)
-}
+// func (c UserConnection) FromModel(model *db.UserConnectionModel) UserConnection {
+// 	c.ID = model.ID
+// 	c.UserID = model.UserID
+// 	c.Metadata = make(map[string]any)
+// 	c.ReferenceID = model.ReferenceID
+// 	c.Permissions = permissions.Parse(model.Permissions, permissions.Blank)
 
-type UserSubscription struct {
-	ID          string
-	Type        SubscriptionType
-	UserID      string
-	ExpiresAt   time.Time
-	ReferenceID string
-	Permissions permissions.Permissions
-}
+// 	c.Type = ConnectionType(model.Type)
+// 	if model.MetadataEncoded != nil {
+// 		_ = encoding.DecodeGob(model.MetadataEncoded, &c.Metadata)
+// 	}
+// 	return c
+// }
 
 type userGetOpts struct {
 	content       bool
@@ -159,127 +49,129 @@ func WithContent() userGetOption {
 Gets or creates a user with specified ID
   - assumes the ID is valid
 */
-func (c *client) GetOrCreateUserByID(ctx context.Context, id string, opts ...userGetOption) (User, error) {
-	user, err := c.GetUserByID(ctx, id, opts...)
-	if err != nil {
-		if db.IsErrNotFound(err) {
-			model, err := c.prisma.User.CreateOne(db.User.ID.Set(id), db.User.Permissions.Set(permissions.User.Encode())).Exec(ctx)
-			if err != nil {
-				return User{}, err
-			}
-			user.ID = model.ID
-			user.Permissions = permissions.Parse(model.Permissions, permissions.User)
-		}
-		return user, nil
-	}
-
-	return user, nil
+func (c *libsqlClient) GetOrCreateUserByID(ctx context.Context, id string, opts ...userGetOption) (models.User, error) {
+	// user, err := c.GetUserByID(ctx, id, opts...)
+	// if err != nil {
+	// 	if database.IsNotFound(err) {
+	// 		model, err := c.prisma.User.CreateOne(db.User.ID.Set(id), db.User.Permissions.Set(permissions.User.Encode())).Exec(ctx)
+	// 		if err != nil {
+	// 			return User{}, err
+	// 		}
+	// 		user.ID = model.ID
+	// 		user.Permissions = permissions.Parse(model.Permissions, permissions.User)
+	// 	}
+	// 	return user, nil
+	// }
+
+	return models.User{}, nil
 }
 
 /*
 Gets a user with specified ID
   - assumes the ID is valid
 */
-func (c *client) GetUserByID(ctx context.Context, id string, opts ...userGetOption) (User, error) {
-	var options userGetOpts
-	for _, apply := range opts {
-		apply(&options)
-	}
-
-	var fields []db.UserRelationWith
-	if options.subscriptions {
-		fields = append(fields, db.User.Subscriptions.Fetch())
-	}
-	if options.connections {
-		fields = append(fields, db.User.Connections.Fetch())
-	}
-	if options.content {
-		fields = append(fields, db.User.Content.Fetch())
-	}
-
-	model, err := c.prisma.User.FindUnique(db.User.ID.Equals(id)).With(fields...).Exec(ctx)
-	if err != nil {
-		return User{}, err
-	}
-
-	var user User
-	user.ID = model.ID
-	user.Permissions = permissions.Parse(model.Permissions, permissions.User)
-
-	if options.connections {
-		for _, cModel := range model.Connections() {
-			user.Connections = append(user.Connections, UserConnection{}.FromModel(&cModel))
-		}
-	}
+func (c *libsqlClient) GetUserByID(ctx context.Context, id string, opts ...userGetOption) (models.User, error) {
+	// var options userGetOpts
+	// for _, apply := range opts {
+	// 	apply(&options)
+	// }
+
+	// var fields []db.UserRelationWith
+	// if options.subscriptions {
+	// 	fields = append(fields, db.User.Subscriptions.Fetch())
+	// }
+	// if options.connections {
+	// 	fields = append(fields, db.User.Connections.Fetch())
+	// }
+	// if options.content {
+	// 	fields = append(fields, db.User.Content.Fetch())
+	// }
+
+	// model, err := c.prisma.User.FindUnique(db.User.ID.Equals(id)).With(fields...).Exec(ctx)
+	// if err != nil {
+	// 	return User{}, err
+	// }
+
+	var user models.User
+	// user.ID = model.ID
+	// user.Permissions = permissions.Parse(model.Permissions, permissions.User)
+
+	// if options.connections {
+	// 	for _, cModel := range model.Connections() {
+	// 		user.Connections = append(user.Connections, UserConnection{}.FromModel(&cModel))
+	// 	}
+	// }
 
 	return user, nil
 }
 
-func (c *client) UpsertUserWithPermissions(ctx context.Context, userID string, perms permissions.Permissions) (User, error) {
-	model, err := c.prisma.User.UpsertOne(db.User.ID.Equals(userID)).
-		Create(db.User.ID.Set(userID), db.User.Permissions.Set(perms.String())).
-		Update(db.User.Permissions.Set(perms.String())).Exec(ctx)
-	if err != nil {
-		return User{}, err
-	}
+func (c *libsqlClient) UpsertUserWithPermissions(ctx context.Context, userID string, perms permissions.Permissions) (models.User, error) {
+	// model, err := c.prisma.User.UpsertOne(db.User.ID.Equals(userID)).
+	// 	Create(db.User.ID.Set(userID), db.User.Permissions.Set(perms.String())).
+	// 	Update(db.User.Permissions.Set(perms.String())).Exec(ctx)
+	// if err != nil {
+	// 	return User{}, err
+	// }
 
-	var user User
-	user.ID = model.ID
-	user.Permissions = permissions.Parse(model.Permissions, permissions.User)
+	var user models.User
+	// user.ID = model.ID
+	// user.Permissions = permissions.Parse(model.Permissions, permissions.User)
 	return user, nil
 }
 
-func (c *client) UpdateConnection(ctx context.Context, connection UserConnection) (UserConnection, error) {
-	if connection.ReferenceID == "" {
-		return UserConnection{}, errors.New("connection referenceID cannot be left blank")
-	}
-
-	encoded, err := encoding.EncodeGob(connection.Metadata)
-	if err != nil {
-		return UserConnection{}, fmt.Errorf("failed to encode metadata: %w", err)
-	}
-
-	model, err := c.prisma.UserConnection.FindUnique(db.UserConnection.ID.Equals(connection.ID)).Update(
-		db.UserConnection.ReferenceID.Set(connection.ReferenceID),
-		db.UserConnection.Permissions.Set(connection.Permissions.Encode()),
-		db.UserConnection.MetadataEncoded.Set(encoded),
-	).Exec(ctx)
-	if err != nil {
-		return UserConnection{}, err
-	}
-
-	return connection.FromModel(model), nil
-}
-
-func (c *client) UpsertConnection(ctx context.Context, connection UserConnection) (UserConnection, error) {
-	if connection.ID != "" {
-		return c.UpdateConnection(ctx, connection)
-	}
-	if connection.UserID == "" {
-		return UserConnection{}, errors.New("connection userID cannot be left blank")
-	}
-	if connection.ReferenceID == "" {
-		return UserConnection{}, errors.New("connection referenceID cannot be left blank")
-	}
-	if connection.Type == "" {
-		return UserConnection{}, errors.New("connection Type cannot be left blank")
-	}
-
-	encoded, err := encoding.EncodeGob(connection.Metadata)
-	if err != nil {
-		return UserConnection{}, fmt.Errorf("failed to encode metadata: %w", err)
-	}
-
-	model, err := c.prisma.UserConnection.CreateOne(
-		db.UserConnection.User.Link(db.User.ID.Equals(connection.UserID)),
-		db.UserConnection.Type.Set(string(connection.Type)),
-		db.UserConnection.Permissions.Set(connection.Permissions.Encode()),
-		db.UserConnection.ReferenceID.Set(connection.ReferenceID),
-		db.UserConnection.MetadataEncoded.Set(encoded),
-	).Exec(ctx)
-	if err != nil {
-		return UserConnection{}, err
-	}
-
-	return connection.FromModel(model), nil
+func (c *libsqlClient) UpdateConnection(ctx context.Context, connection models.UserConnection) (models.UserConnection, error) {
+	// if connection.ReferenceID == "" {
+	// 	return UserConnection{}, errors.New("connection referenceID cannot be left blank")
+	// }
+
+	// encoded, err := encoding.EncodeGob(connection.Metadata)
+	// if err != nil {
+	// 	return UserConnection{}, fmt.Errorf("failed to encode metadata: %w", err)
+	// }
+
+	// model, err := c.prisma.UserConnection.FindUnique(db.UserConnection.ID.Equals(connection.ID)).Update(
+	// 	db.UserConnection.ReferenceID.Set(connection.ReferenceID),
+	// 	db.UserConnection.Permissions.Set(connection.Permissions.Encode()),
+	// 	db.UserConnection.MetadataEncoded.Set(encoded),
+	// ).Exec(ctx)
+	// if err != nil {
+	// 	return UserConnection{}, err
+	// }
+
+	// return connection.FromModel(model), nil
+	return models.UserConnection{}, nil
+}
+
+func (c *libsqlClient) UpsertConnection(ctx context.Context, connection models.UserConnection) (models.UserConnection, error) {
+	// if connection.ID != "" {
+	// 	return c.UpdateConnection(ctx, connection)
+	// }
+	// if connection.UserID == "" {
+	// 	return UserConnection{}, errors.New("connection userID cannot be left blank")
+	// }
+	// if connection.ReferenceID == "" {
+	// 	return UserConnection{}, errors.New("connection referenceID cannot be left blank")
+	// }
+	// if connection.Type == "" {
+	// 	return UserConnection{}, errors.New("connection Type cannot be left blank")
+	// }
+
+	// encoded, err := encoding.EncodeGob(connection.Metadata)
+	// if err != nil {
+	// 	return UserConnection{}, fmt.Errorf("failed to encode metadata: %w", err)
+	// }
+
+	// model, err := c.prisma.UserConnection.CreateOne(
+	// 	db.UserConnection.User.Link(db.User.ID.Equals(connection.UserID)),
+	// 	db.UserConnection.Type.Set(string(connection.Type)),
+	// 	db.UserConnection.Permissions.Set(connection.Permissions.Encode()),
+	// 	db.UserConnection.ReferenceID.Set(connection.ReferenceID),
+	// 	db.UserConnection.MetadataEncoded.Set(encoded),
+	// ).Exec(ctx)
+	// if err != nil {
+	// 	return UserConnection{}, err
+	// }
+
+	// return connection.FromModel(model), nil
+	return models.UserConnection{}, nil
 }
diff --git a/internal/database/vehicles.go b/internal/database/vehicles.go
index 2e11eb6e..e5cc80df 100644
--- a/internal/database/vehicles.go
+++ b/internal/database/vehicles.go
@@ -3,97 +3,74 @@ package database
 import (
 	"context"
 
-	"github.com/cufee/aftermath/internal/database/prisma/db"
-	"github.com/cufee/aftermath/internal/encoding"
-	"github.com/rs/zerolog/log"
-	"github.com/steebchen/prisma-client-go/runtime/transaction"
-	"golang.org/x/text/language"
+	"github.com/cufee/aftermath/internal/database/models"
 )
 
-type Vehicle struct {
-	ID     string
-	Tier   int
-	Type   string
-	Class  string
-	Nation string
+// func (v Vehicle) FromModel(model db.VehicleModel) Vehicle {
+// 	v.ID = model.ID
+// 	v.Tier = model.Tier
+// 	v.Type = model.Type
+// 	v.Nation = model.Nation
+// 	v.LocalizedNames = make(map[string]string)
+// 	if model.LocalizedNamesEncoded != nil {
+// 		err := encoding.DecodeGob(model.LocalizedNamesEncoded, &v.LocalizedNames)
+// 		if err != nil {
+// 			log.Err(err).Str("id", v.ID).Msg("failed to decode vehicle localized names")
+// 		}
+// 	}
+// 	return v
+// }
 
-	LocalizedNames map[string]string
-}
-
-func (v Vehicle) FromModel(model db.VehicleModel) Vehicle {
-	v.ID = model.ID
-	v.Tier = model.Tier
-	v.Type = model.Type
-	v.Nation = model.Nation
-	v.LocalizedNames = make(map[string]string)
-	if model.LocalizedNamesEncoded != nil {
-		err := encoding.DecodeGob(model.LocalizedNamesEncoded, &v.LocalizedNames)
-		if err != nil {
-			log.Err(err).Str("id", v.ID).Msg("failed to decode vehicle localized names")
-		}
-	}
-	return v
-}
-
-func (v Vehicle) EncodeNames() []byte {
-	encoded, _ := encoding.EncodeGob(v.LocalizedNames)
-	return encoded
-}
-
-func (v Vehicle) Name(locale language.Tag) string {
-	if n := v.LocalizedNames[locale.String()]; n != "" {
-		return n
-	}
-	if n := v.LocalizedNames[language.English.String()]; n != "" {
-		return n
-	}
-	return "Secret Tank"
-}
+// func (v Vehicle) EncodeNames() []byte {
+// 	encoded, _ := encoding.EncodeGob(v.LocalizedNames)
+// 	return encoded
+// }
 
-func (c *client) UpsertVehicles(ctx context.Context, vehicles map[string]Vehicle) error {
-	if len(vehicles) < 1 {
-		return nil
-	}
+func (c *libsqlClient) UpsertVehicles(ctx context.Context, vehicles map[string]models.Vehicle) error {
+	// if len(vehicles) < 1 {
+	// 	return nil
+	// }
 
-	var transactions []transaction.Transaction
-	for id, data := range vehicles {
-		transactions = append(transactions, c.prisma.Vehicle.
-			UpsertOne(db.Vehicle.ID.Equals(id)).
-			Create(
-				db.Vehicle.ID.Set(id),
-				db.Vehicle.Tier.Set(data.Tier),
-				db.Vehicle.Type.Set(data.Type),
-				db.Vehicle.Class.Set(data.Class),
-				db.Vehicle.Nation.Set(data.Nation),
-				db.Vehicle.LocalizedNamesEncoded.Set(data.EncodeNames()),
-			).
-			Update(
-				db.Vehicle.Tier.Set(data.Tier),
-				db.Vehicle.Type.Set(data.Type),
-				db.Vehicle.Class.Set(data.Class),
-				db.Vehicle.Nation.Set(data.Nation),
-				db.Vehicle.LocalizedNamesEncoded.Set(data.EncodeNames()),
-			).Tx(),
-		)
-	}
+	// var transactions []transaction.Transaction
+	// for id, data := range vehicles {
+	// 	transactions = append(transactions, c.prisma.Vehicle.
+	// 		UpsertOne(db.Vehicle.ID.Equals(id)).
+	// 		Create(
+	// 			db.Vehicle.ID.Set(id),
+	// 			db.Vehicle.Tier.Set(data.Tier),
+	// 			db.Vehicle.Type.Set(data.Type),
+	// 			db.Vehicle.Class.Set(data.Class),
+	// 			db.Vehicle.Nation.Set(data.Nation),
+	// 			db.Vehicle.LocalizedNamesEncoded.Set(data.EncodeNames()),
+	// 		).
+	// 		Update(
+	// 			db.Vehicle.Tier.Set(data.Tier),
+	// 			db.Vehicle.Type.Set(data.Type),
+	// 			db.Vehicle.Class.Set(data.Class),
+	// 			db.Vehicle.Nation.Set(data.Nation),
+	// 			db.Vehicle.LocalizedNamesEncoded.Set(data.EncodeNames()),
+	// 		).Tx(),
+	// 	)
+	// }
 
-	return c.prisma.Prisma.Transaction(transactions...).Exec(ctx)
+	// return c.prisma.Prisma.Transaction(transactions...).Exec(ctx)
+	return nil
 }
 
-func (c *client) GetVehicles(ctx context.Context, ids []string) (map[string]Vehicle, error) {
-	if len(ids) < 1 {
-		return nil, nil
-	}
+func (c *libsqlClient) GetVehicles(ctx context.Context, ids []string) (map[string]models.Vehicle, error) {
+	// 	if len(ids) < 1 {
+	// 		return nil, nil
+	// 	}
 
-	models, err := c.prisma.Vehicle.FindMany(db.Vehicle.ID.In(ids)).Exec(ctx)
-	if err != nil {
-		return nil, err
-	}
+	// 	models, err := c.prisma.Vehicle.FindMany(db.Vehicle.ID.In(ids)).Exec(ctx)
+	// 	if err != nil {
+	// 		return nil, err
+	// 	}
 
-	vehicles := make(map[string]Vehicle)
-	for _, model := range models {
-		vehicles[model.ID] = vehicles[model.ID].FromModel(model)
-	}
+	vehicles := make(map[string]models.Vehicle)
+	// 	for _, model := range models {
+	// 		vehicles[model.ID] = vehicles[model.ID].FromModel(model)
+	// 	}
 
 	return vehicles, nil
 }
diff --git a/internal/logic/sessions.go b/internal/logic/sessions.go
index d5e75343..36f17b94 100644
--- a/internal/logic/sessions.go
+++ b/internal/logic/sessions.go
@@ -6,7 +6,8 @@ import (
 	"time"
 
 	"github.com/cufee/aftermath/internal/database"
-	"github.com/cufee/aftermath/internal/database/prisma/db"
+	"github.com/cufee/aftermath/internal/database/models"
+
 	"github.com/cufee/aftermath/internal/external/wargaming"
 	"github.com/cufee/aftermath/internal/retry"
 	"github.com/cufee/aftermath/internal/stats/fetch"
@@ -29,11 +30,11 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 	}
 
 	// existing snaphsots for accounts
-	existingSnapshots, err := dbClient.GetManyAccountSnapshots(ctx, accountIDs, database.SnapshotTypeDaily)
-	if err != nil && !db.IsErrNotFound(err) {
+	existingSnapshots, err := dbClient.GetManyAccountSnapshots(ctx, accountIDs, models.SnapshotTypeDaily)
+	if err != nil && !database.IsNotFound(err) {
 		return nil, errors.Wrap(err, "failed to get existing snapshots")
 	}
-	existingSnapshotsMap := make(map[string]*database.AccountSnapshot)
+	existingSnapshotsMap := make(map[string]*models.AccountSnapshot)
 	for _, snapshot := range existingSnapshots {
 		existingSnapshotsMap[snapshot.AccountID] = &snapshot
 	}
@@ -90,9 +91,9 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 	close(vehicleCh)
 
 	var accountErrors = make(map[string]error)
-	var accountUpdates []database.Account
-	var snapshots []database.AccountSnapshot
-	var vehicleSnapshots []database.VehicleSnapshot
+	var accountUpdates []models.Account
+	var snapshots []models.AccountSnapshot
+	var vehicleSnapshots []models.VehicleSnapshot
 	for result := range vehicleCh {
 		// there is only 1 key in this map
 		for id, vehicles := range result.Data {
@@ -100,18 +101,18 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 				accountErrors[id] = result.Err
 				continue
 			}
-			existingSnapshots, err := dbClient.GetVehicleSnapshots(ctx, id, id, database.SnapshotTypeDaily)
-			if err != nil && !db.IsErrNotFound(err) {
+			existingSnapshots, err := dbClient.GetVehicleSnapshots(ctx, id, id, models.SnapshotTypeDaily)
+			if err != nil && !database.IsNotFound(err) {
 				accountErrors[id] = err
 				continue
 			}
-			existingSnapshotsMap := make(map[string]*database.VehicleSnapshot)
+			existingSnapshotsMap := make(map[string]*models.VehicleSnapshot)
 			for _, snapshot := range existingSnapshots {
 				existingSnapshotsMap[snapshot.VehicleID] = &snapshot
 			}
 
 			stats := fetch.WargamingToStats(realm, accounts[id], clans[id], vehicles)
-			accountUpdates = append(accountUpdates, database.Account{
+			accountUpdates = append(accountUpdates, models.Account{
 				Realm:    stats.Realm,
 				ID:       stats.Account.ID,
 				Nickname: stats.Account.Nickname,
@@ -123,8 +124,8 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 				ClanID:  stats.Account.ClanID,
 				ClanTag: stats.Account.ClanTag,
 			})
-			snapshots = append(snapshots, database.AccountSnapshot{
-				Type:           database.SnapshotTypeDaily,
+			snapshots = append(snapshots, models.AccountSnapshot{
+				Type:           models.SnapshotTypeDaily,
 				CreatedAt:      createdAt,
 				AccountID:      stats.Account.ID,
 				ReferenceID:    stats.Account.ID,
@@ -147,9 +148,9 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 					continue
 				}
 
-				vehicleSnapshots = append(vehicleSnapshots, database.VehicleSnapshot{
+				vehicleSnapshots = append(vehicleSnapshots, models.VehicleSnapshot{
 					CreatedAt:      createdAt,
-					Type:           database.SnapshotTypeDaily,
+					Type:           models.SnapshotTypeDaily,
 					LastBattleTime: vehicle.LastBattleTime,
 					AccountID:      stats.Account.ID,
 					VehicleID:      vehicle.VehicleID,
diff --git a/internal/stats/fetch/client.go b/internal/stats/fetch/client.go
index 7844d93f..f15e157b 100644
--- a/internal/stats/fetch/client.go
+++ b/internal/stats/fetch/client.go
@@ -4,7 +4,7 @@ import (
 	"context"
 	"time"
 
-	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/stats/frame"
 	"github.com/cufee/am-wg-proxy-next/v2/types"
 )
@@ -12,7 +12,7 @@ import (
 type AccountStatsOverPeriod struct {
 	Realm string `json:"realm"`
 
-	Account database.Account `json:"account"`
+	Account models.Account `json:"account"`
 
 	PeriodStart time.Time `json:"start"`
 	PeriodEnd   time.Time `json:"end"`
@@ -47,7 +47,7 @@ type StatsWithVehicles struct {
 }
 
 type Client interface {
-	Account(ctx context.Context, id string) (database.Account, error)
+	Account(ctx context.Context, id string) (models.Account, error)
 	Search(ctx context.Context, nickname, realm string) (types.Account, error)
 	CurrentStats(ctx context.Context, id string, opts ...statsOption) (AccountStatsOverPeriod, error)
 
diff --git a/internal/stats/fetch/convert.go b/internal/stats/fetch/convert.go
index 39fa8c39..7a9b27fb 100644
--- a/internal/stats/fetch/convert.go
+++ b/internal/stats/fetch/convert.go
@@ -5,7 +5,7 @@ import (
 	"strconv"
 	"time"
 
-	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/external/blitzstars"
 	"github.com/cufee/aftermath/internal/stats/frame"
 	"github.com/cufee/am-wg-proxy-next/v2/types"
@@ -15,8 +15,8 @@ func timestampToTime(timestamp int) time.Time {
 	return time.Unix(int64(timestamp), 0)
 }
 
-func WargamingToAccount(realm string, account types.ExtendedAccount, clan types.ClanMember, private bool) database.Account {
-	a := database.Account{
+func WargamingToAccount(realm string, account types.ExtendedAccount, clan types.ClanMember, private bool) models.Account {
+	a := models.Account{
 		ID:       strconv.Itoa(account.ID),
 		Realm:    realm,
 		Nickname: account.Nickname,
diff --git a/internal/stats/fetch/multisource.go b/internal/stats/fetch/multisource.go
index b893916f..752715e3 100644
--- a/internal/stats/fetch/multisource.go
+++ b/internal/stats/fetch/multisource.go
@@ -9,7 +9,8 @@ import (
 	"github.com/pkg/errors"
 
 	"github.com/cufee/aftermath/internal/database"
-	"github.com/cufee/aftermath/internal/database/prisma/db"
+	"github.com/cufee/aftermath/internal/database/models"
+
 	"github.com/cufee/aftermath/internal/external/blitzstars"
 	"github.com/cufee/aftermath/internal/external/wargaming"
 	"github.com/cufee/aftermath/internal/retry"
@@ -55,7 +56,7 @@ func (c *multiSourceClient) Search(ctx context.Context, nickname, realm string)
 /*
 Gets account info from wg and updates cache
 */
-func (c *multiSourceClient) Account(ctx context.Context, id string) (database.Account, error) {
+func (c *multiSourceClient) Account(ctx context.Context, id string) (models.Account, error) {
 	realm := c.wargaming.RealmFromAccountID(id)
 
 	var group sync.WaitGroup
@@ -80,7 +81,7 @@ func (c *multiSourceClient) Account(ctx context.Context, id string) (database.Ac
 	group.Wait()
 
 	if wgAccount.Err != nil {
-		return database.Account{}, wgAccount.Err
+		return models.Account{}, wgAccount.Err
 	}
 
 	account := WargamingToAccount(realm, wgAccount.Data, clan, false)
@@ -88,7 +89,7 @@ func (c *multiSourceClient) Account(ctx context.Context, id string) (database.Ac
 		ctx, cancel := context.WithTimeout(context.Background(), time.Second)
 		defer cancel()
 
-		errMap := c.database.UpsertAccounts(ctx, []database.Account{account})
+		errMap := c.database.UpsertAccounts(ctx, []models.Account{account})
 		if err := errMap[id]; err != nil {
 			log.Err(err).Msg("failed to update account cache")
 		}
@@ -171,7 +172,7 @@ func (c *multiSourceClient) CurrentStats(ctx context.Context, id string, opts ..
 		ctx, cancel := context.WithTimeout(context.Background(), time.Second)
 		defer cancel()
 
-		errMap := c.database.UpsertAccounts(ctx, []database.Account{stats.Account})
+		errMap := c.database.UpsertAccounts(ctx, []models.Account{stats.Account})
 		if err := errMap[id]; err != nil {
 			log.Err(err).Msg("failed to update account cache")
 		}
@@ -276,8 +277,8 @@ func (c *multiSourceClient) SessionStats(ctx context.Context, id string, session
 
 	sessionBefore := sessionStart
 
-	var accountSnapshot retry.DataWithErr[database.AccountSnapshot]
-	var vehiclesSnapshots retry.DataWithErr[[]database.VehicleSnapshot]
+	var accountSnapshot retry.DataWithErr[models.AccountSnapshot]
+	var vehiclesSnapshots retry.DataWithErr[[]models.VehicleSnapshot]
 	var averages retry.DataWithErr[map[string]frame.StatsFrame]
 	var current retry.DataWithErr[AccountStatsOverPeriod]
 
@@ -304,10 +305,10 @@ func (c *multiSourceClient) SessionStats(ctx context.Context, id string, session
 	group.Add(1)
 	go func() {
 		defer group.Done()
-		s, err := c.database.GetAccountSnapshot(ctx, id, id, database.SnapshotTypeDaily, database.WithCreatedBefore(sessionBefore))
-		accountSnapshot = retry.DataWithErr[database.AccountSnapshot]{Data: s, Err: err}
-		v, err := c.database.GetVehicleSnapshots(ctx, id, id, database.SnapshotTypeDaily, database.WithCreatedBefore(sessionBefore))
-		vehiclesSnapshots = retry.DataWithErr[[]database.VehicleSnapshot]{Data: v, Err: err}
+		s, err := c.database.GetAccountSnapshot(ctx, id, id, models.SnapshotTypeDaily, database.WithCreatedBefore(sessionBefore))
+		accountSnapshot = retry.DataWithErr[models.AccountSnapshot]{Data: s, Err: err}
+		v, err := c.database.GetVehicleSnapshots(ctx, id, id, models.SnapshotTypeDaily, database.WithCreatedBefore(sessionBefore))
+		vehiclesSnapshots = retry.DataWithErr[[]models.VehicleSnapshot]{Data: v, Err: err}
 	}()
 
 	// wait for all requests to finish and check errors
@@ -316,7 +317,7 @@ func (c *multiSourceClient) SessionStats(ctx context.Context, id string, session
 		return AccountStatsOverPeriod{}, AccountStatsOverPeriod{}, current.Err
 	}
 	if accountSnapshot.Err != nil {
-		if db.IsErrNotFound(accountSnapshot.Err) {
+		if database.IsNotFound(accountSnapshot.Err) {
 			return AccountStatsOverPeriod{}, AccountStatsOverPeriod{}, ErrSessionNotFound
 		}
 		return AccountStatsOverPeriod{}, AccountStatsOverPeriod{}, accountSnapshot.Err
diff --git a/internal/stats/prepare/common/card.go b/internal/stats/prepare/common/card.go
index 38eb4b89..fbbfe206 100644
--- a/internal/stats/prepare/common/card.go
+++ b/internal/stats/prepare/common/card.go
@@ -3,7 +3,7 @@ package common
 import (
 	"github.com/pkg/errors"
 
-	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/stats/frame"
 )
 
@@ -82,7 +82,7 @@ func PresetValue(preset Tag, stats frame.StatsFrame, args ...any) (frame.Value,
 		if !ok {
 			return frame.InvalidValue, errors.New("invalid args for avg_tier, first arg should be vehicles")
 		}
-		glossary, ok := args[1].(map[string]database.Vehicle)
+		glossary, ok := args[1].(map[string]models.Vehicle)
 		if !ok {
 			return frame.InvalidValue, errors.New("invalid args for avg_tier, second arg should be glossary")
 		}
@@ -97,7 +97,7 @@ func PresetValue(preset Tag, stats frame.StatsFrame, args ...any) (frame.Value,
 	}
 }
 
-func avgTierValue(vehicles map[string]frame.VehicleStatsFrame, glossary map[string]database.Vehicle) frame.Value {
+func avgTierValue(vehicles map[string]frame.VehicleStatsFrame, glossary map[string]models.Vehicle) frame.Value {
 	var weightedTotal, battlesTotal float32
 	for _, vehicle := range vehicles {
 		if data, ok := glossary[vehicle.VehicleID]; ok && data.Tier > 0 {
diff --git a/internal/stats/prepare/period/card.go b/internal/stats/prepare/period/card.go
index d8511cb1..7fcffe72 100644
--- a/internal/stats/prepare/period/card.go
+++ b/internal/stats/prepare/period/card.go
@@ -4,18 +4,18 @@ import (
 	"fmt"
 	"math"
 
-	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/stats/fetch"
 	"github.com/cufee/aftermath/internal/stats/prepare/common"
 )
 
-func NewCards(stats fetch.AccountStatsOverPeriod, glossary map[string]database.Vehicle, opts ...common.Option) (Cards, error) {
+func NewCards(stats fetch.AccountStatsOverPeriod, glossary map[string]models.Vehicle, opts ...common.Option) (Cards, error) {
 	options := common.DefaultOptions
 	for _, apply := range opts {
 		apply(&options)
 	}
 	if glossary == nil {
-		glossary = make(map[string]database.Vehicle)
+		glossary = make(map[string]models.Vehicle)
 	}
 
 	var cards Cards
diff --git a/internal/stats/prepare/period/preset.go b/internal/stats/prepare/period/preset.go
index 3a64bbc6..dfe9b336 100644
--- a/internal/stats/prepare/period/preset.go
+++ b/internal/stats/prepare/period/preset.go
@@ -1,12 +1,12 @@
 package period
 
 import (
-	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/stats/frame"
 	"github.com/cufee/aftermath/internal/stats/prepare/common"
 )
 
-func presetToBlock(preset common.Tag, stats frame.StatsFrame, vehicles map[string]frame.VehicleStatsFrame, glossary map[string]database.Vehicle) (common.StatsBlock[BlockData], error) {
+func presetToBlock(preset common.Tag, stats frame.StatsFrame, vehicles map[string]frame.VehicleStatsFrame, glossary map[string]models.Vehicle) (common.StatsBlock[BlockData], error) {
 	block := common.StatsBlock[BlockData](common.NewBlock(preset, BlockData{}))
 
 	switch preset {
diff --git a/internal/stats/prepare/session/card.go b/internal/stats/prepare/session/card.go
index fc3f947d..ea7ede65 100644
--- a/internal/stats/prepare/session/card.go
+++ b/internal/stats/prepare/session/card.go
@@ -4,20 +4,20 @@ import (
 	"math"
 	"slices"
 
-	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/stats/fetch"
 	"github.com/cufee/aftermath/internal/stats/frame"
 	"github.com/cufee/aftermath/internal/stats/prepare/common"
 	"golang.org/x/text/language"
 )
 
-func NewCards(session, career fetch.AccountStatsOverPeriod, glossary map[string]database.Vehicle, opts ...common.Option) (Cards, error) {
+func NewCards(session, career fetch.AccountStatsOverPeriod, glossary map[string]models.Vehicle, opts ...common.Option) (Cards, error) {
 	options := common.DefaultOptions
 	for _, apply := range opts {
 		apply(&options)
 	}
 	if glossary == nil {
-		glossary = make(map[string]database.Vehicle)
+		glossary = make(map[string]models.Vehicle)
 	}
 
 	var cards Cards
@@ -167,7 +167,7 @@ func NewCards(session, career fetch.AccountStatsOverPeriod, glossary map[string]
 	return cards, nil
 }
 
-func makeVehicleCard(presets []common.Tag, cardType common.CardType, session, career frame.VehicleStatsFrame, printer func(string) string, locale language.Tag, glossary database.Vehicle) (VehicleCard, error) {
+func makeVehicleCard(presets []common.Tag, cardType common.CardType, session, career frame.VehicleStatsFrame, printer func(string) string, locale language.Tag, glossary models.Vehicle) (VehicleCard, error) {
 	var sFrame, cFrame frame.StatsFrame
 	if session.StatsFrame != nil {
 		sFrame = *session.StatsFrame
@@ -194,7 +194,7 @@ func makeVehicleCard(presets []common.Tag, cardType common.CardType, session, ca
 	}, nil
 }
 
-func makeHighlightCard(highlight common.Highlight, session, career frame.VehicleStatsFrame, printer func(string) string, locale language.Tag, glossary database.Vehicle) (VehicleCard, error) {
+func makeHighlightCard(highlight common.Highlight, session, career frame.VehicleStatsFrame, printer func(string) string, locale language.Tag, glossary models.Vehicle) (VehicleCard, error) {
 	var sFrame, cFrame frame.StatsFrame
 	if session.StatsFrame != nil {
 		sFrame = *session.StatsFrame
diff --git a/internal/stats/render/common/badges.go b/internal/stats/render/common/badges.go
index 3d8e24c0..7b2fa492 100644
--- a/internal/stats/render/common/badges.go
+++ b/internal/stats/render/common/badges.go
@@ -6,7 +6,7 @@ import (
 
 	"github.com/pkg/errors"
 
-	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/stats/render/assets"
 )
 
@@ -34,20 +34,20 @@ func (sub subscriptionHeader) Block() (Block, error) {
 }
 
 var (
-	subscriptionWeight = map[database.SubscriptionType]int{
-		database.SubscriptionTypeDeveloper: 999,
+	subscriptionWeight = map[models.SubscriptionType]int{
+		models.SubscriptionTypeDeveloper: 999,
 		// Moderators
-		database.SubscriptionTypeServerModerator:  99,
-		database.SubscriptionTypeContentModerator: 98,
+		models.SubscriptionTypeServerModerator:  99,
+		models.SubscriptionTypeContentModerator: 98,
 		// Paid
-		database.SubscriptionTypePro:     89,
-		database.SubscriptionTypeProClan: 88,
-		database.SubscriptionTypePlus:    79,
+		models.SubscriptionTypePro:     89,
+		models.SubscriptionTypeProClan: 88,
+		models.SubscriptionTypePlus:    79,
 		//
-		database.SubscriptionTypeSupporter:     29,
-		database.SubscriptionTypeServerBooster: 28,
+		models.SubscriptionTypeSupporter:     29,
+		models.SubscriptionTypeServerBooster: 28,
 		//
-		database.SubscriptionTypeVerifiedClan: 19,
+		models.SubscriptionTypeVerifiedClan: 19,
 	}
 
 	// Personal
@@ -142,8 +142,8 @@ var (
 	}
 )
 
-func SubscriptionsBadges(subscriptions []database.UserSubscription) ([]Block, error) {
-	slices.SortFunc(subscriptions, func(i, j database.UserSubscription) int {
+func SubscriptionsBadges(subscriptions []models.UserSubscription) ([]Block, error) {
+	slices.SortFunc(subscriptions, func(i, j models.UserSubscription) int {
 		return subscriptionWeight[j.Type] - subscriptionWeight[i.Type]
 	})
 
@@ -151,11 +151,11 @@ func SubscriptionsBadges(subscriptions []database.UserSubscription) ([]Block, er
 	for _, subscription := range subscriptions {
 		var header *subscriptionHeader
 		switch subscription.Type {
-		case database.SubscriptionTypeDeveloper:
+		case models.SubscriptionTypeDeveloper:
 			header = subscriptionDeveloper
-		case database.SubscriptionTypeServerModerator:
+		case models.SubscriptionTypeServerModerator:
 			header = subscriptionServerModerator
-		case database.SubscriptionTypeContentModerator:
+		case models.SubscriptionTypeContentModerator:
 			header = subscriptionContentModerator
 		}
 
@@ -171,7 +171,7 @@ func SubscriptionsBadges(subscriptions []database.UserSubscription) ([]Block, er
 	for _, subscription := range subscriptions {
 		var header *subscriptionHeader
 		switch subscription.Type {
-		case database.SubscriptionTypeContentTranslator:
+		case models.SubscriptionTypeContentTranslator:
 			header = subscriptionTranslator
 		}
 
@@ -187,13 +187,13 @@ func SubscriptionsBadges(subscriptions []database.UserSubscription) ([]Block, er
 	for _, subscription := range subscriptions {
 		var header *subscriptionHeader
 		switch subscription.Type {
-		case database.SubscriptionTypePro:
+		case models.SubscriptionTypePro:
 			header = userSubscriptionPro
-		case database.SubscriptionTypePlus:
+		case models.SubscriptionTypePlus:
 			header = userSubscriptionPlus
-		case database.SubscriptionTypeServerBooster:
+		case models.SubscriptionTypeServerBooster:
 			header = subscriptionServerBooster
-		case database.SubscriptionTypeSupporter:
+		case models.SubscriptionTypeSupporter:
 			header = userSubscriptionSupporter
 		}
 
@@ -210,14 +210,14 @@ func SubscriptionsBadges(subscriptions []database.UserSubscription) ([]Block, er
 	return badges, nil
 }
 
-func ClanSubscriptionsBadges(subscriptions []database.UserSubscription) *subscriptionHeader {
+func ClanSubscriptionsBadges(subscriptions []models.UserSubscription) *subscriptionHeader {
 	var headers []*subscriptionHeader
 
 	for _, subscription := range subscriptions {
 		switch subscription.Type {
-		case database.SubscriptionTypeProClan:
+		case models.SubscriptionTypeProClan:
 			headers = append(headers, clanSubscriptionPro)
-		case database.SubscriptionTypeVerifiedClan:
+		case models.SubscriptionTypeVerifiedClan:
 			headers = append(headers, clanSubscriptionVerified)
 		}
 	}
diff --git a/internal/stats/render/common/header.go b/internal/stats/render/common/header.go
index e28f925b..24c8945c 100644
--- a/internal/stats/render/common/header.go
+++ b/internal/stats/render/common/header.go
@@ -1,16 +1,16 @@
 package common
 
 import (
-	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/models"
 )
 
-func NewHeaderCard(width float64, subscriptions []database.UserSubscription, promoText []string) (Block, bool) {
+func NewHeaderCard(width float64, subscriptions []models.UserSubscription, promoText []string) (Block, bool) {
 	var cards []Block
 
 	var addPromoText = len(promoText) > 0
 	for _, sub := range subscriptions {
 		switch sub.Type {
-		case database.SubscriptionTypePro, database.SubscriptionTypePlus, database.SubscriptionTypeDeveloper:
+		case models.SubscriptionTypePro, models.SubscriptionTypePlus, models.SubscriptionTypeDeveloper:
 			addPromoText = false
 		}
 		if !addPromoText {
diff --git a/internal/stats/render/common/player_title.go b/internal/stats/render/common/player_title.go
index d77c6a07..7636f5a9 100644
--- a/internal/stats/render/common/player_title.go
+++ b/internal/stats/render/common/player_title.go
@@ -3,7 +3,7 @@ package common
 import (
 	"image/color"
 
-	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/rs/zerolog/log"
 )
 
@@ -34,7 +34,7 @@ func DefaultPlayerTitleStyle(containerStyle Style) TitleCardStyle {
 	}
 }
 
-func NewPlayerTitleCard(style TitleCardStyle, nickname, clanTag string, subscriptions []database.UserSubscription) Block {
+func NewPlayerTitleCard(style TitleCardStyle, nickname, clanTag string, subscriptions []models.UserSubscription) Block {
 	clanTagBlock, hasClanTagBlock := newClanTagBlock(style.ClanTag, clanTag, subscriptions)
 	if !hasClanTagBlock {
 		return NewBlocksContent(style.Container, NewTextContent(style.Nickname, nickname))
@@ -65,7 +65,7 @@ func NewPlayerTitleCard(style TitleCardStyle, nickname, clanTag string, subscrip
 
 }
 
-func newClanTagBlock(style Style, clanTag string, subs []database.UserSubscription) (Block, bool) {
+func newClanTagBlock(style Style, clanTag string, subs []models.UserSubscription) (Block, bool) {
 	if clanTag == "" {
 		return Block{}, false
 	}
diff --git a/internal/stats/render/common/tier_percentage.go b/internal/stats/render/common/tier_percentage.go
index dd96c2d4..d6238cc8 100644
--- a/internal/stats/render/common/tier_percentage.go
+++ b/internal/stats/render/common/tier_percentage.go
@@ -4,11 +4,11 @@ import (
 	"fmt"
 	"image/color"
 
-	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/stats/frame"
 )
 
-func NewTierPercentageCard(style Style, vehicles map[string]frame.VehicleStatsFrame, glossary map[int]database.Vehicle) Block {
+func NewTierPercentageCard(style Style, vehicles map[string]frame.VehicleStatsFrame, glossary map[int]models.Vehicle) Block {
 	var blocks []Block
 	var elements int = 10
 
diff --git a/internal/stats/render/period/cards.go b/internal/stats/render/period/cards.go
index 57918453..0074d6fc 100644
--- a/internal/stats/render/period/cards.go
+++ b/internal/stats/render/period/cards.go
@@ -5,7 +5,7 @@ import (
 
 	"github.com/pkg/errors"
 
-	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/stats/fetch"
 	prepare "github.com/cufee/aftermath/internal/stats/prepare/common"
 	"github.com/cufee/aftermath/internal/stats/prepare/period"
@@ -15,7 +15,7 @@ import (
 	"github.com/rs/zerolog/log"
 )
 
-func generateCards(stats fetch.AccountStatsOverPeriod, cards period.Cards, subs []database.UserSubscription, opts render.Options) (render.Segments, error) {
+func generateCards(stats fetch.AccountStatsOverPeriod, cards period.Cards, subs []models.UserSubscription, opts render.Options) (render.Segments, error) {
 	if len(cards.Overview.Blocks) == 0 && len(cards.Highlights) == 0 {
 		log.Error().Msg("player cards slice is 0 length, this should not happen")
 		return render.Segments{}, errors.New("no cards provided")
diff --git a/internal/stats/render/period/image.go b/internal/stats/render/period/image.go
index 95cbfcb3..47f9f5aa 100644
--- a/internal/stats/render/period/image.go
+++ b/internal/stats/render/period/image.go
@@ -3,13 +3,13 @@ package period
 import (
 	"image"
 
-	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/stats/fetch"
 	"github.com/cufee/aftermath/internal/stats/prepare/period"
 	"github.com/cufee/aftermath/internal/stats/render"
 )
 
-func CardsToImage(stats fetch.AccountStatsOverPeriod, cards period.Cards, subs []database.UserSubscription, opts ...render.Option) (image.Image, error) {
+func CardsToImage(stats fetch.AccountStatsOverPeriod, cards period.Cards, subs []models.UserSubscription, opts ...render.Option) (image.Image, error) {
 	o := render.DefaultOptions()
 	for _, apply := range opts {
 		apply(&o)
diff --git a/internal/stats/render/session/cards.go b/internal/stats/render/session/cards.go
index c09ec22e..28dd1dca 100644
--- a/internal/stats/render/session/cards.go
+++ b/internal/stats/render/session/cards.go
@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/stats/fetch"
 	"github.com/cufee/aftermath/internal/stats/frame"
 	prepare "github.com/cufee/aftermath/internal/stats/prepare/common"
@@ -14,7 +14,7 @@ import (
 	"github.com/cufee/aftermath/internal/stats/render"
 )
 
-func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Cards, subs []database.UserSubscription, opts render.Options) (render.Segments, error) {
+func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Cards, subs []models.UserSubscription, opts render.Options) (render.Segments, error) {
 	var (
 		// primary cards
 		// when there are some unrated battles or no battles at all
diff --git a/internal/stats/render/session/image.go b/internal/stats/render/session/image.go
index dd19c6c7..65ea4196 100644
--- a/internal/stats/render/session/image.go
+++ b/internal/stats/render/session/image.go
@@ -3,13 +3,13 @@ package session
 import (
 	"image"
 
-	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/stats/fetch"
 	"github.com/cufee/aftermath/internal/stats/prepare/session"
 	"github.com/cufee/aftermath/internal/stats/render"
 )
 
-func CardsToImage(session, career fetch.AccountStatsOverPeriod, cards session.Cards, subs []database.UserSubscription, opts ...render.Option) (image.Image, error) {
+func CardsToImage(session, career fetch.AccountStatsOverPeriod, cards session.Cards, subs []models.UserSubscription, opts ...render.Option) (image.Image, error) {
 	o := render.DefaultOptions()
 	for _, apply := range opts {
 		apply(&o)
diff --git a/internal/stats/session.go b/internal/stats/session.go
index aa079f46..22ac652a 100644
--- a/internal/stats/session.go
+++ b/internal/stats/session.go
@@ -5,7 +5,7 @@ import (
 	"slices"
 	"time"
 
-	"github.com/cufee/aftermath/internal/database/prisma/db"
+	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/localization"
 	"github.com/cufee/aftermath/internal/logic"
 	"github.com/cufee/aftermath/internal/stats/fetch"
@@ -23,7 +23,7 @@ func (r *renderer) Session(ctx context.Context, accountId string, from time.Time
 	_, err := r.database.GetAccountByID(ctx, accountId)
 	stop()
 	if err != nil {
-		if db.IsErrNotFound(err) {
+		if database.IsNotFound(err) {
 			_, err := r.fetchClient.Account(ctx, accountId) // this will cache the account
 			if err != nil {
 				return nil, meta, err
diff --git a/main.go b/main.go
index cd67cab4..a83c4d65 100644
--- a/main.go
+++ b/main.go
@@ -29,7 +29,7 @@ import (
 	_ "github.com/joho/godotenv/autoload"
 )
 
-//go:generate go run github.com/steebchen/prisma-client-go generate --schema ./internal/database/prisma/schema.prisma
+//go:generate go generate ./internal/database/ent
 
 //go:embed static/*
 var static embed.FS
@@ -42,7 +42,7 @@ func main() {
 	loadStaticAssets(static)
 
 	liveCoreClient, cacheCoreClient := coreClientsFromEnv()
-	startSchedulerFromEnvAsync(cacheCoreClient.Wargaming())
+	startSchedulerFromEnvAsync(cacheCoreClient.Database(), cacheCoreClient.Wargaming())
 
 	// Load some init options to registered admin accounts and etc
 	logic.ApplyInitOptions(liveCoreClient.Database())
@@ -71,15 +71,11 @@ func main() {
 	servePublic()
 }
 
-func startSchedulerFromEnvAsync(wgClient wargaming.Client) {
+func startSchedulerFromEnvAsync(dbClient database.Client, wgClient wargaming.Client) {
 	if os.Getenv("SCHEDULER_ENABLED") != "true" {
 		return
 	}
 
-	dbClient, err := database.NewClient()
-	if err != nil {
-		log.Fatal().Msgf("database#NewClient failed %s", err)
-	}
 	bsClient, err := blitzstars.NewClient(os.Getenv("BLITZ_STARS_API_URL"), time.Second*10)
 	if err != nil {
 		log.Fatal().Msgf("failed to init a blitzstars client %s", err)
@@ -114,7 +110,7 @@ func startSchedulerFromEnvAsync(wgClient wargaming.Client) {
 
 func coreClientsFromEnv() (core.Client, core.Client) {
 	// Dependencies
-	dbClient, err := database.NewClient()
+	dbClient, err := database.NewLibSQLClient(os.Getenv("DATABASE_URL"))
 	if err != nil {
 		log.Fatal().Msgf("database#NewClient failed %s", err)
 	}

From d905c24f01940f72f14551c29c276937a534a618 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sat, 22 Jun 2024 21:02:27 -0400
Subject: [PATCH 091/341] database client logic

---
 Taskfile.yaml                                 |   2 +-
 cmds/core/scheduler/glossary.go               |   7 +-
 cmds/core/server/handlers/private/accounts.go |   6 +-
 go.sum                                        |  12 +
 internal/database/accounts.go                 | 167 +++--
 internal/database/averages.go                 | 115 ++-
 internal/database/cleanup.go                  |  43 +-
 internal/database/client.go                   |  20 +-
 internal/database/discord.go                  | 131 ++--
 internal/database/ent/db/account.go           |  16 +-
 internal/database/ent/db/account/account.go   |   6 +-
 internal/database/ent/db/account/where.go     |  72 +-
 internal/database/ent/db/account_create.go    |  20 +-
 internal/database/ent/db/account_query.go     |   4 +-
 internal/database/ent/db/account_update.go    |  56 +-
 internal/database/ent/db/accountsnapshot.go   |  12 +-
 .../ent/db/accountsnapshot/accountsnapshot.go |   6 +-
 .../database/ent/db/accountsnapshot/where.go  |  54 +-
 .../database/ent/db/accountsnapshot_create.go |  16 +-
 .../database/ent/db/accountsnapshot_query.go  |   4 +-
 .../database/ent/db/accountsnapshot_update.go |  36 +-
 .../database/ent/db/achievementssnapshot.go   |  12 +-
 .../achievementssnapshot.go                   |   6 +-
 .../ent/db/achievementssnapshot/where.go      |  54 +-
 .../ent/db/achievementssnapshot_create.go     |  16 +-
 .../ent/db/achievementssnapshot_query.go      |   4 +-
 .../ent/db/achievementssnapshot_update.go     |  36 +-
 internal/database/ent/db/appconfiguration.go  |   8 +-
 .../db/appconfiguration/appconfiguration.go   |   6 +-
 .../database/ent/db/appconfiguration/where.go |  36 +-
 .../ent/db/appconfiguration_create.go         |  12 +-
 .../database/ent/db/appconfiguration_query.go |   4 +-
 .../ent/db/appconfiguration_update.go         |  16 +-
 .../database/ent/db/applicationcommand.go     |   8 +-
 .../applicationcommand/applicationcommand.go  |   6 +-
 .../ent/db/applicationcommand/where.go        |  36 +-
 .../ent/db/applicationcommand_create.go       |  12 +-
 .../ent/db/applicationcommand_query.go        |   4 +-
 .../ent/db/applicationcommand_update.go       |  16 +-
 internal/database/ent/db/clan.go              |   8 +-
 internal/database/ent/db/clan/clan.go         |   6 +-
 internal/database/ent/db/clan/where.go        |  36 +-
 internal/database/ent/db/clan_create.go       |  12 +-
 internal/database/ent/db/clan_query.go        |   4 +-
 internal/database/ent/db/clan_update.go       |  16 +-
 internal/database/ent/db/crontask.go          |  28 +-
 internal/database/ent/db/crontask/crontask.go |  33 +-
 internal/database/ent/db/crontask/where.go    | 225 ++----
 internal/database/ent/db/crontask_create.go   |  32 +-
 internal/database/ent/db/crontask_query.go    |   4 +-
 internal/database/ent/db/crontask_update.go   | 104 +--
 internal/database/ent/db/migrate/schema.go    |  76 +-
 internal/database/ent/db/mutation.go          | 684 +++++++++---------
 internal/database/ent/db/runtime.go           |  92 ++-
 internal/database/ent/db/user.go              |   8 +-
 internal/database/ent/db/user/user.go         |   6 +-
 internal/database/ent/db/user/where.go        |  36 +-
 internal/database/ent/db/user_create.go       |  12 +-
 internal/database/ent/db/user_query.go        |   4 +-
 internal/database/ent/db/user_update.go       |  16 +-
 internal/database/ent/db/userconnection.go    |   8 +-
 .../ent/db/userconnection/userconnection.go   |   6 +-
 .../database/ent/db/userconnection/where.go   |  36 +-
 .../database/ent/db/userconnection_create.go  |  12 +-
 .../database/ent/db/userconnection_query.go   |   4 +-
 .../database/ent/db/userconnection_update.go  |  16 +-
 internal/database/ent/db/usercontent.go       |   8 +-
 .../ent/db/usercontent/usercontent.go         |   6 +-
 internal/database/ent/db/usercontent/where.go |  36 +-
 .../database/ent/db/usercontent_create.go     |  12 +-
 internal/database/ent/db/usercontent_query.go |   4 +-
 .../database/ent/db/usercontent_update.go     |  16 +-
 internal/database/ent/db/usersubscription.go  |  12 +-
 .../db/usersubscription/usersubscription.go   |   6 +-
 .../database/ent/db/usersubscription/where.go |  54 +-
 .../ent/db/usersubscription_create.go         |  16 +-
 .../database/ent/db/usersubscription_query.go |   4 +-
 .../ent/db/usersubscription_update.go         |  36 +-
 internal/database/ent/db/vehicle.go           |   8 +-
 internal/database/ent/db/vehicle/vehicle.go   |   6 +-
 internal/database/ent/db/vehicle/where.go     |  36 +-
 internal/database/ent/db/vehicle_create.go    |  12 +-
 internal/database/ent/db/vehicle_query.go     |   4 +-
 internal/database/ent/db/vehicle_update.go    |  16 +-
 internal/database/ent/db/vehicleaverage.go    |  10 +-
 .../ent/db/vehicleaverage/vehicleaverage.go   |   6 +-
 .../database/ent/db/vehicleaverage/where.go   |  36 +-
 .../database/ent/db/vehicleaverage_create.go  |  16 +-
 .../database/ent/db/vehicleaverage_query.go   |   4 +-
 .../database/ent/db/vehicleaverage_update.go  |  40 +-
 internal/database/ent/db/vehiclesnapshot.go   |  12 +-
 .../ent/db/vehiclesnapshot/vehiclesnapshot.go |   6 +-
 .../database/ent/db/vehiclesnapshot/where.go  |  54 +-
 .../database/ent/db/vehiclesnapshot_create.go |  16 +-
 .../database/ent/db/vehiclesnapshot_query.go  |   4 +-
 .../database/ent/db/vehiclesnapshot_update.go |  36 +-
 internal/database/ent/migrate.go              |  63 --
 internal/database/ent/migrate/main.go         |   2 +-
 internal/database/ent/schema/account.go       |   8 +-
 ...accountsnapshot.go => account_snapshot.go} |   2 +-
 ...tssnapshot.go => achievements_snapshot.go} |   2 +-
 ...pconfiguration.go => app_configuration.go} |   0
 ...ationcommand.go => application_command.go} |   0
 internal/database/ent/schema/clan.go          |   4 +-
 .../ent/schema/{crontask.go => cron_task.go}  |  10 +-
 internal/database/ent/schema/defaults.go      |   6 +-
 internal/database/ent/schema/user.go          |   4 +-
 .../{userconnection.go => user_connection.go} |   0
 .../{usercontent.go => user_content.go}       |   0
 ...ersubscription.go => user_subscription.go} |   2 +-
 internal/database/ent/schema/vehicle.go       |   4 +-
 .../{vehicleaverage.go => vehicle_average.go} |   6 +-
 ...vehiclesnapshot.go => vehicle_snapshot.go} |   2 +-
 internal/database/models/vehicle.go           |   8 +-
 internal/database/snapshots.go                | 461 ++++--------
 internal/database/tasks.go                    | 294 ++++----
 internal/database/users.go                    | 239 +++---
 internal/database/vehicles.go                 | 128 ++--
 internal/stats/fetch/multisource.go           |   8 +-
 119 files changed, 2106 insertions(+), 2300 deletions(-)
 delete mode 100644 internal/database/ent/migrate.go
 rename internal/database/ent/schema/{accountsnapshot.go => account_snapshot.go} (97%)
 rename internal/database/ent/schema/{achievementssnapshot.go => achievements_snapshot.go} (97%)
 rename internal/database/ent/schema/{appconfiguration.go => app_configuration.go} (100%)
 rename internal/database/ent/schema/{applicationcommand.go => application_command.go} (100%)
 rename internal/database/ent/schema/{crontask.go => cron_task.go} (82%)
 rename internal/database/ent/schema/{userconnection.go => user_connection.go} (100%)
 rename internal/database/ent/schema/{usercontent.go => user_content.go} (100%)
 rename internal/database/ent/schema/{usersubscription.go => user_subscription.go} (97%)
 rename internal/database/ent/schema/{vehicleaverage.go => vehicle_average.go} (85%)
 rename internal/database/ent/schema/{vehiclesnapshot.go => vehicle_snapshot.go} (97%)

diff --git a/Taskfile.yaml b/Taskfile.yaml
index 8cbe17a8..cd2e67c1 100644
--- a/Taskfile.yaml
+++ b/Taskfile.yaml
@@ -29,7 +29,7 @@ tasks:
 
   db-migrate:
     desc: generate migrations
-    cmd: atlas migrate diff init --dir "file://internal/database/ent/migrate/migrations" --to "ent://internal/database/ent/schema" --dev-url "sqlite://tmp/file?mode=memory&_fk=1"
+    cmd: atlas migrate diff {{.CLI_ARGS}} --dir "file://internal/database/ent/migrate/migrations" --to "ent://internal/database/ent/schema" --dev-url "sqlite://file?mode=memory&_fk=1"
   db-migrate-apply:
     desc: apply migrations using atlas
     cmd: ${ATLAS_TEMP_DIR} migrate apply --allow-dirty --dir "file://internal/database/ent/migrate/migrations" --tx-mode all --url "libsql+ws://0.0.0.0:8080"
diff --git a/cmds/core/scheduler/glossary.go b/cmds/core/scheduler/glossary.go
index 89f5d23e..14327f15 100644
--- a/cmds/core/scheduler/glossary.go
+++ b/cmds/core/scheduler/glossary.go
@@ -51,11 +51,8 @@ func UpdateGlossaryWorker(client core.Client) func() {
 		vehicles := make(map[string]models.Vehicle)
 		for id, data := range glossary {
 			vehicles[id] = models.Vehicle{
-				ID:   id,
-				Tier: data.Tier,
-				Type: data.Type,
-				// Class: ,
-				Nation:         data.Nation,
+				ID:             id,
+				Tier:           data.Tier,
 				LocalizedNames: map[string]string{language.English.String(): data.Name},
 			}
 		}
diff --git a/cmds/core/server/handlers/private/accounts.go b/cmds/core/server/handlers/private/accounts.go
index 2afb639b..e1128c0d 100644
--- a/cmds/core/server/handlers/private/accounts.go
+++ b/cmds/core/server/handlers/private/accounts.go
@@ -96,9 +96,9 @@ func LoadAccountsHandler(client core.Client) http.HandlerFunc {
 							inserts = append(inserts, fetch.WargamingToAccount(realm, account, types.ClanMember{}, false))
 						}
 
-						errors := client.Database().UpsertAccounts(ctx, inserts)
-						if len(errors) > 0 {
-							log.Error().Any("errors", errors).Msg("failed to upsert some accounts")
+						err = client.Database().UpsertAccounts(ctx, inserts)
+						if err != nil {
+							log.Err(err).Msg("failed to upsert accounts")
 							return
 						}
 
diff --git a/go.sum b/go.sum
index 24ee26f5..844c602f 100644
--- a/go.sum
+++ b/go.sum
@@ -67,17 +67,23 @@ github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/
 github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
+github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/mattn/go-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o4kU=
 github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
 github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7 h1:DpOJ2HYzCv8LZP15IdmG+YdwD2luVPHITV96TkirNBM=
 github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7/go.mod h1:ZXFpozHsX6DPmq2I0TCekCxypsnAUbP2oI0UX1GXzOo=
 github.com/nlpodyssey/gopickle v0.3.0 h1:BLUE5gxFLyyNOPzlXxt6GoHEMMxD0qhsE4p0CIQyoLw=
 github.com/nlpodyssey/gopickle v0.3.0/go.mod h1:f070HJ/yR+eLi5WmM1OXJEGaTpuJEUiib19olXgYha0=
+github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
+github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
+github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
 github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=
 github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
@@ -88,6 +94,10 @@ github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8=
 github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
 github.com/sergi/go-diff v1.0.0 h1:Kpca3qRNrduNnOQeazBd0ysaKrUJiIuISHxogkT9RPQ=
 github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
+github.com/spf13/cobra v1.7.0 h1:hyqWnYt1ZQShIddO5kBpj3vu05/++x6tJ6dg8EC572I=
+github.com/spf13/cobra v1.7.0/go.mod h1:uLxZILRyS/50WlhOIKD7W6V5bgeIt+4sICxh6uRMrb0=
+github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
@@ -148,6 +158,8 @@ golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
 golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.22.0 h1:gqSGLZqv+AI9lIQzniJ0nZDRG5GBPsSi+DRNHWNz6yA=
+golang.org/x/tools v0.22.0/go.mod h1:aCwcsjqvq7Yqt6TNyX7QMU2enbQ/Gt0bo6krSeEri+c=
 google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
diff --git a/internal/database/accounts.go b/internal/database/accounts.go
index 79f5a55e..ef7be030 100644
--- a/internal/database/accounts.go
+++ b/internal/database/accounts.go
@@ -10,8 +10,8 @@ import (
 	"github.com/cufee/aftermath/internal/database/models"
 )
 
-func toAccount(model db.Account) models.Account {
-	return models.Account{
+func toAccount(model *db.Account) models.Account {
+	account := models.Account{
 		ID:             model.ID,
 		Realm:          model.Realm,
 		Nickname:       model.Nickname,
@@ -19,6 +19,11 @@ func toAccount(model db.Account) models.Account {
 		CreatedAt:      time.Unix(int64(model.AccountCreatedAt), 0),
 		LastBattleTime: time.Unix(int64(model.LastBattleTime), 0),
 	}
+	if model.Edges.Clan != nil {
+		account.ClanID = model.Edges.Clan.ID
+		account.ClanTag = model.Edges.Clan.Tag
+	}
+	return account
 }
 
 func (c *libsqlClient) GetRealmAccountIDs(ctx context.Context, realm string) ([]string, error) {
@@ -36,96 +41,98 @@ func (c *libsqlClient) GetRealmAccountIDs(ctx context.Context, realm string) ([]
 }
 
 func (c *libsqlClient) GetAccountByID(ctx context.Context, id string) (models.Account, error) {
-	// model, err := c.prisma.Account.FindUnique(db.Account.ID.Equals(id)).With(db.Account.Clan.Fetch()).Exec(ctx)
-	// if err != nil {
-	// 	return Account{}, err
-	// }
-
-	// account := Account{}.FromModel(*model)
-	// if clan, ok := model.Clan(); ok {
-	// 	account.AddClan(clan)
-	// }
-
-	return models.Account{}, nil
+	result, err := c.db.Account.Query().Where(account.ID(id)).WithClan().Only(ctx)
+	if err != nil {
+		return models.Account{}, err
+	}
+	return toAccount(result), nil
 }
 
 func (c *libsqlClient) GetAccounts(ctx context.Context, ids []string) ([]models.Account, error) {
-	// if len(ids) < 1 {
-	// 	return nil, nil
-	// }
+	if len(ids) < 1 {
+		return nil, nil
+	}
 
-	// models, err := c.prisma.Account.FindMany(db.Account.ID.In(ids)).With(db.Account.Clan.Fetch()).Exec(ctx)
-	// if err != nil {
-	// 	return nil, err
-	// }
+	result, err := c.db.Account.Query().Where(account.IDIn(ids...)).WithClan().All(ctx)
+	if err != nil {
+		return nil, err
+	}
 
 	var accounts []models.Account
-	// for _, model := range models {
-	// 	account := Account{}.FromModel(model)
-	// 	if clan, ok := model.Clan(); ok {
-	// 		account.AddClan(clan)
-	// 	}
-	// 	accounts = append(accounts, account)
-	// }
+	for _, a := range result {
+		accounts = append(accounts, toAccount(a))
+	}
 
 	return accounts, nil
 }
 
-func (c *libsqlClient) UpsertAccounts(ctx context.Context, accounts []models.Account) map[string]error {
-	// if len(accounts) < 1 {
-	// 	return nil
-	// }
-
-	// var mx sync.Mutex
-	// var wg sync.WaitGroup
-	errors := make(map[string]error, len(accounts))
-
-	// // we don't really want to exit if one fails
-	// for _, account := range accounts {
-	// 	wg.Add(1)
-	// 	go func(account Account) {
-	// 		defer wg.Done()
-	// 		optional := []db.AccountSetParam{db.Account.Private.Set(account.Private)}
-	// 		if account.ClanID != "" {
-	// 			clan, err := c.prisma.Clan.FindUnique(db.Clan.ID.Equals(account.ClanID)).Exec(ctx)
-	// 			if err == nil {
-	// 				optional = append(optional, db.Account.Clan.Link(db.Clan.ID.Equals(clan.ID)))
-	// 			}
-	// 		}
-
-	// 		_, err := c.prisma.Account.
-	// 			UpsertOne(db.Account.ID.Equals(account.ID)).
-	// 			Create(db.Account.ID.Set(account.ID),
-	// 				db.Account.LastBattleTime.Set(account.LastBattleTime),
-	// 				db.Account.AccountCreatedAt.Set(account.CreatedAt),
-	// 				db.Account.Realm.Set(account.Realm),
-	// 				db.Account.Nickname.Set(account.Nickname),
-	// 				optional...,
-	// 			).
-	// 			Update(
-	// 				append(optional,
-	// 					db.Account.Nickname.Set(account.Nickname),
-	// 					db.Account.LastBattleTime.Set(account.LastBattleTime),
-	// 				)...,
-	// 			).
-	// 			Exec(ctx)
-	// 		if err != nil {
-	// 			mx.Lock()
-	// 			errors[account.ID] = err
-	// 			mx.Unlock()
-	// 			return
-	// 		}
-	// 	}(account)
-	// }
-	// wg.Wait()
-
-	return errors
+func (c *libsqlClient) UpsertAccounts(ctx context.Context, accounts []models.Account) error {
+	if len(accounts) < 1 {
+		return nil
+	}
+
+	var ids []string
+	accountsMap := make(map[string]*models.Account)
+	for _, a := range accounts {
+		ids = append(ids, a.ID)
+		accountsMap[a.ID] = &a
+	}
+
+	tx, err := c.db.Tx(ctx)
+	if err != nil {
+		return err
+	}
+
+	records, err := tx.Account.Query().Where(account.IDIn(ids...)).All(ctx)
+	if err != nil && !IsNotFound(err) {
+		return rollback(tx, err)
+	}
+
+	for _, r := range records {
+		update, ok := accountsMap[r.ID]
+		if !ok {
+			continue // this should never happen tho
+		}
+
+		err = tx.Account.UpdateOneID(r.ID).
+			SetRealm(update.Realm).
+			SetNickname(update.Nickname).
+			SetPrivate(update.Private).
+			SetLastBattleTime(update.LastBattleTime.Unix()).
+			SetClanID(update.ClanID).
+			Exec(ctx)
+		if err != nil {
+			return rollback(tx, err)
+		}
+
+		delete(accountsMap, r.ID)
+	}
+
+	var inserts []*db.AccountCreate
+	for _, a := range accountsMap {
+		inserts = append(inserts,
+			c.db.Account.Create().
+				SetID(a.ID).
+				SetRealm(a.Realm).
+				SetNickname(a.Nickname).
+				SetPrivate(a.Private).
+				SetAccountCreatedAt(a.CreatedAt.Unix()).
+				SetLastBattleTime(a.LastBattleTime.Unix()).
+				SetClanID(a.ClanID),
+		)
+	}
+
+	err = c.db.Account.CreateBulk(inserts...).Exec(ctx)
+	if err != nil {
+		return rollback(tx, err)
+	}
+	return tx.Commit()
 }
 
 func (c *libsqlClient) AccountSetPrivate(ctx context.Context, id string, value bool) error {
-	// _, err := c.prisma.Account.FindUnique(db.Account.ID.Equals(id)).Update(db.Account.Private.Set(value)).Exec(ctx)
-	// if err != nil && !database.IsNotFound(err) {
-	// 	return err
-	// }
+	err := c.db.Account.UpdateOneID(id).SetPrivate(value).Exec(ctx)
+	if err != nil && !IsNotFound(err) {
+		return err
+	}
 	return nil
 }
diff --git a/internal/database/averages.go b/internal/database/averages.go
index b798fe9b..881307b3 100644
--- a/internal/database/averages.go
+++ b/internal/database/averages.go
@@ -3,78 +3,75 @@ package database
 import (
 	"context"
 
+	"github.com/cufee/aftermath/internal/database/ent/db"
+	"github.com/cufee/aftermath/internal/database/ent/db/vehicleaverage"
 	"github.com/cufee/aftermath/internal/stats/frame"
 )
 
 func (c *libsqlClient) UpsertVehicleAverages(ctx context.Context, averages map[string]frame.StatsFrame) error {
-	// if len(averages) < 1 {
-	// 	return nil
-	// }
+	if len(averages) < 1 {
+		return nil
+	}
 
-	// var transactions []transaction.Transaction
-	// for id, data := range averages {
-	// 	encoded, err := data.Encode()
-	// 	if err != nil {
-	// 		log.Err(err).Str("id", id).Msg("failed to encode a stats frame for vehicle averages")
-	// 		continue
-	// 	}
+	var ids []string
+	for id := range averages {
+		ids = append(ids, id)
+	}
 
-	// 	transactions = append(transactions, c.prisma.VehicleAverage.
-	// 		UpsertOne(db.VehicleAverage.ID.Equals(id)).
-	// 		Create(
-	// 			db.VehicleAverage.ID.Set(id),
-	// 			db.VehicleAverage.DataEncoded.Set(encoded),
-	// 		).
-	// 		Update(
-	// 			db.VehicleAverage.DataEncoded.Set(encoded),
-	// 		).Tx(),
-	// 	)
-	// }
+	tx, err := c.db.Tx(ctx)
+	if err != nil {
+		return err
+	}
 
-	// return c.prisma.Prisma.Transaction(transactions...).Exec(ctx)
-	return nil
-}
+	existing, err := tx.VehicleAverage.Query().Where(vehicleaverage.IDIn(ids...)).All(ctx)
+	if err != nil {
+		return rollback(tx, err)
+	}
 
-func (c *libsqlClient) GetVehicleAverages(ctx context.Context, ids []string) (map[string]frame.StatsFrame, error) {
-	// if len(ids) < 1 {
-	// 	return nil, nil
-	// }
+	for _, r := range existing {
+		update, ok := averages[r.ID]
+		if !ok {
+			continue // should never happen tho
+		}
 
-	// qCtx, cancel := context.WithTimeout(ctx, time.Second)
-	// defer cancel()
-	// records, err := c.prisma.VehicleAverage.FindMany(db.VehicleAverage.ID.In(ids)).Exec(qCtx)
-	// if err != nil {
-	// 	return nil, err
-	// }
+		err := tx.VehicleAverage.UpdateOneID(r.ID).SetData(update).Exec(ctx)
+		if err != nil {
+			return rollback(tx, err)
+		}
 
-	averages := make(map[string]frame.StatsFrame)
-	// var badRecords []string
-	// var lastErr error
+		delete(averages, r.ID)
+	}
+
+	var inserts []*db.VehicleAverageCreate
+	for id, frame := range averages {
+		inserts = append(inserts,
+			c.db.VehicleAverage.Create().
+				SetID(id).
+				SetData(frame),
+		)
+	}
 
-	// for _, record := range records {
-	// 	parsed, err := frame.DecodeStatsFrame(record.DataEncoded)
-	// 	lastErr = err
-	// 	if err != nil {
-	// 		badRecords = append(badRecords, record.ID)
-	// 		continue
-	// 	}
-	// 	averages[record.ID] = parsed
-	// }
+	err = tx.VehicleAverage.CreateBulk(inserts...).Exec(ctx)
+	if err != nil {
+		return rollback(tx, err)
+	}
 
-	// if len(badRecords) == len(ids) || len(badRecords) == 0 {
-	// 	return averages, lastErr
-	// }
+	return tx.Commit()
+}
+
+func (c *libsqlClient) GetVehicleAverages(ctx context.Context, ids []string) (map[string]frame.StatsFrame, error) {
+	if len(ids) < 1 {
+		return nil, nil
+	}
 
-	// go func() {
-	// 	// one bad record should not break the whole query since this data is optional
-	// 	// we can just delete the record and move on
-	// 	ctx, cancel := context.WithCancel(context.Background())
-	// 	defer cancel()
-	// 	_, err := c.prisma.VehicleAverage.FindMany(db.VehicleAverage.ID.In(badRecords)).Delete().Exec(ctx)
-	// 	if err != nil {
-	// 		log.Err(err).Strs("ids", badRecords).Msg("failed to delete a bad vehicle average records")
-	// 	}
-	// }()
+	records, err := c.db.VehicleAverage.Query().Where(vehicleaverage.IDIn(ids...)).All(ctx)
+	if err != nil {
+		return nil, err
+	}
 
+	averages := make(map[string]frame.StatsFrame)
+	for _, a := range records {
+		averages[a.ID] = a.Data
+	}
 	return averages, nil
 }
diff --git a/internal/database/cleanup.go b/internal/database/cleanup.go
index 22eae805..89216aa7 100644
--- a/internal/database/cleanup.go
+++ b/internal/database/cleanup.go
@@ -3,24 +3,41 @@ package database
 import (
 	"context"
 	"time"
+
+	"github.com/cufee/aftermath/internal/database/ent/db/accountsnapshot"
+	"github.com/cufee/aftermath/internal/database/ent/db/achievementssnapshot"
+	"github.com/cufee/aftermath/internal/database/ent/db/crontask"
+	"github.com/cufee/aftermath/internal/database/ent/db/vehiclesnapshot"
 )
 
 func (c *libsqlClient) DeleteExpiredTasks(ctx context.Context, expiration time.Time) error {
-	// _, err := c.prisma.CronTask.FindMany(db.CronTask.CreatedAt.Before(expiration)).Delete().Exec(ctx)
-	// if err != nil && !database.IsNotFound(err) {
-	// 	return err
-	// }
-	return nil
+	tx, err := c.db.Tx(ctx)
+	if err != nil {
+		return err
+	}
+
+	_, err = tx.CronTask.Delete().Where(crontask.CreatedAtLT(expiration.Unix())).Exec(ctx)
+	if err != nil && !IsNotFound(err) {
+		return rollback(tx, err)
+	}
+	return tx.Commit()
 }
 
 func (c *libsqlClient) DeleteExpiredSnapshots(ctx context.Context, expiration time.Time) error {
-	// _, err := c.prisma.AccountSnapshot.FindMany(db.AccountSnapshot.CreatedAt.Before(expiration)).Delete().Exec(ctx)
-	// if err != nil && !database.IsNotFound(err) {
-	// 	return err
-	// }
-	// _, err = c.prisma.VehicleSnapshot.FindMany(db.VehicleSnapshot.CreatedAt.Before(expiration)).Delete().Exec(ctx)
-	// if err != nil && !database.IsNotFound(err) {
-	// 	return err
-	// }
+	_, err := c.db.AccountSnapshot.Delete().Where(accountsnapshot.CreatedAtLT(expiration.Unix())).Exec(ctx)
+	if err != nil && !IsNotFound(err) {
+		return err
+	}
+
+	_, err = c.db.VehicleSnapshot.Delete().Where(vehiclesnapshot.CreatedAtLT(expiration.Unix())).Exec(ctx)
+	if err != nil && !IsNotFound(err) {
+		return err
+	}
+
+	_, err = c.db.AchievementsSnapshot.Delete().Where(achievementssnapshot.CreatedAtLT(expiration.Unix())).Exec(ctx)
+	if err != nil && !IsNotFound(err) {
+		return err
+	}
+
 	return nil
 }
diff --git a/internal/database/client.go b/internal/database/client.go
index 3166f44b..e1b4024d 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -3,13 +3,13 @@ package database
 import (
 	"context"
 	"database/sql"
+	"fmt"
 	"time"
 
 	"github.com/cufee/aftermath/internal/database/ent/db"
 	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/permissions"
 	"github.com/cufee/aftermath/internal/stats/frame"
-	"golang.org/x/sync/semaphore"
 
 	"entgo.io/ent/dialect"
 	entsql "entgo.io/ent/dialect/sql"
@@ -22,7 +22,7 @@ type AccountsClient interface {
 	GetAccountByID(ctx context.Context, id string) (models.Account, error)
 	GetRealmAccountIDs(ctx context.Context, realm string) ([]string, error)
 	GetAccounts(ctx context.Context, ids []string) ([]models.Account, error)
-	UpsertAccounts(ctx context.Context, accounts []models.Account) map[string]error
+	UpsertAccounts(ctx context.Context, accounts []models.Account) error
 	AccountSetPrivate(ctx context.Context, id string, value bool) error
 }
 
@@ -81,8 +81,7 @@ type Client interface {
 }
 
 type libsqlClient struct {
-	db             *db.Client
-	tasksUpdateSem *semaphore.Weighted
+	db *db.Client
 }
 
 func (c *libsqlClient) Disconnect() error {
@@ -96,9 +95,16 @@ func NewLibSQLClient(primaryUrl string) (*libsqlClient, error) {
 	}
 
 	dbClient := db.NewClient(db.Driver(entsql.OpenDB(dialect.SQLite, driver)))
-
 	return &libsqlClient{
-		db:             dbClient,
-		tasksUpdateSem: semaphore.NewWeighted(1),
+		db: dbClient,
 	}, nil
 }
+
+// rollback calls to tx.Rollback and wraps the given error
+// with the rollback error if occurred.
+func rollback(tx *db.Tx, err error) error {
+	if rerr := tx.Rollback(); rerr != nil {
+		err = fmt.Errorf("%w: %v", err, rerr)
+	}
+	return err
+}
diff --git a/internal/database/discord.go b/internal/database/discord.go
index c9d368ba..91f084b3 100644
--- a/internal/database/discord.go
+++ b/internal/database/discord.go
@@ -3,64 +3,109 @@ package database
 import (
 	"context"
 
+	"github.com/cufee/aftermath/internal/database/ent/db"
+	"github.com/cufee/aftermath/internal/database/ent/db/applicationcommand"
 	"github.com/cufee/aftermath/internal/database/models"
 )
 
+func toApplicationCommand(record *db.ApplicationCommand) models.ApplicationCommand {
+	return models.ApplicationCommand{
+		ID:      record.ID,
+		Name:    record.Name,
+		Hash:    record.OptionsHash,
+		Version: record.Version,
+	}
+
+}
+
 func (c *libsqlClient) GetCommandsByID(ctx context.Context, commandIDs ...string) ([]models.ApplicationCommand, error) {
-	// if len(commandIDs) < 1 {
-	// 	return nil, nil
-	// }
+	if len(commandIDs) < 1 {
+		return nil, nil
+	}
 
-	// models, err := c.prisma.models.ApplicationCommand.FindMany(db.models.ApplicationCommand.ID.In(commandIDs)).Exec(ctx)
-	// if err != nil {
-	// 	return nil, err
-	// }
+	records, err := c.db.ApplicationCommand.Query().Where(applicationcommand.IDIn(commandIDs...)).All(ctx)
+	if err != nil {
+		return nil, err
+	}
 
 	var commands []models.ApplicationCommand
-	// for _, model := range models {
-	// 	commands = append(commands, models.ApplicationCommand{}.fromModel(model))
-	// }
+	for _, c := range records {
+		commands = append(commands, toApplicationCommand(c))
+	}
 	return commands, nil
 }
 
 func (c *libsqlClient) GetCommandsByHash(ctx context.Context, commandHashes ...string) ([]models.ApplicationCommand, error) {
-	// if len(commandHashes) < 1 {
-	// 	return nil, nil
-	// }
-
-	// models, err := c.prisma.models.ApplicationCommand.FindMany(db.models.ApplicationCommand.OptionsHash.In(commandHashes)).Exec(ctx)
-	// if err != nil {
-	// 	return nil, err
-	// }
+	if len(commandHashes) < 1 {
+		return nil, nil
+	}
 
+	records, err := c.db.ApplicationCommand.Query().Where(applicationcommand.OptionsHashIn(commandHashes...)).All(ctx)
+	if err != nil {
+		return nil, err
+	}
 	var commands []models.ApplicationCommand
-	// for _, model := range models {
-	// 	commands = append(commands, models.ApplicationCommand{}.fromModel(model))
-	// }
+	for _, c := range records {
+		commands = append(commands, toApplicationCommand(c))
+	}
 	return commands, nil
 }
 
 func (c *libsqlClient) UpsertCommands(ctx context.Context, commands ...models.ApplicationCommand) error {
-	// if len(commands) < 1 {
-	// 	return nil
-	// }
-
-	// var tx []db.PrismaTransaction
-	// for _, cmd := range commands {
-	// 	tx = append(tx, c.prisma.models.ApplicationCommand.UpsertOne(db.models.ApplicationCommand.ID.Equals(cmd.ID)).
-	// 		Create(
-	// 			db.models.ApplicationCommand.ID.Set(cmd.ID),
-	// 			db.models.ApplicationCommand.Name.Set(cmd.Name),
-	// 			db.models.ApplicationCommand.Version.Set(cmd.Version),
-	// 			db.models.ApplicationCommand.OptionsHash.Set(cmd.Hash),
-	// 		).
-	// 		Update(
-	// 			db.models.ApplicationCommand.Name.Set(cmd.Name),
-	// 			db.models.ApplicationCommand.Version.Set(cmd.Version),
-	// 			db.models.ApplicationCommand.OptionsHash.Set(cmd.Hash),
-	// 		).Tx(),
-	// 	)
-	// }
-	// return c.prisma.Prisma.Transaction(tx...).Exec(ctx)
-	return nil
+	if len(commands) < 1 {
+		return nil
+	}
+
+	var ids []string
+	commandsMap := make(map[string]*models.ApplicationCommand)
+	for _, c := range commands {
+		ids = append(ids, c.ID)
+		commandsMap[c.ID] = &c
+	}
+
+	tx, err := c.db.Tx(ctx)
+	if err != nil {
+		return err
+	}
+
+	existing, err := tx.ApplicationCommand.Query().Where(applicationcommand.IDIn(ids...)).All(ctx)
+	if err != nil {
+		return rollback(tx, err)
+	}
+
+	for _, c := range existing {
+		update, ok := commandsMap[c.ID]
+		if !ok {
+			continue
+		}
+
+		err := tx.ApplicationCommand.UpdateOneID(c.ID).
+			SetName(update.Name).
+			SetVersion(update.Version).
+			SetOptionsHash(update.Hash).
+			Exec(ctx)
+		if err != nil {
+			return rollback(tx, err)
+		}
+
+		delete(commandsMap, c.ID)
+	}
+
+	var inserts []*db.ApplicationCommandCreate
+	for _, cmd := range commandsMap {
+		inserts = append(inserts,
+			c.db.ApplicationCommand.Create().
+				SetID(cmd.ID).
+				SetName(cmd.Name).
+				SetVersion(cmd.Version).
+				SetOptionsHash(cmd.Hash),
+		)
+	}
+
+	err = tx.ApplicationCommand.CreateBulk(inserts...).Exec(ctx)
+	if err != nil {
+		return rollback(tx, err)
+	}
+
+	return tx.Commit()
 }
diff --git a/internal/database/ent/db/account.go b/internal/database/ent/db/account.go
index 7cdf8b15..40cc0fa5 100644
--- a/internal/database/ent/db/account.go
+++ b/internal/database/ent/db/account.go
@@ -18,13 +18,13 @@ type Account struct {
 	// ID of the ent.
 	ID string `json:"id,omitempty"`
 	// CreatedAt holds the value of the "created_at" field.
-	CreatedAt int `json:"created_at,omitempty"`
+	CreatedAt int64 `json:"created_at,omitempty"`
 	// UpdatedAt holds the value of the "updated_at" field.
-	UpdatedAt int `json:"updated_at,omitempty"`
+	UpdatedAt int64 `json:"updated_at,omitempty"`
 	// LastBattleTime holds the value of the "last_battle_time" field.
-	LastBattleTime int `json:"last_battle_time,omitempty"`
+	LastBattleTime int64 `json:"last_battle_time,omitempty"`
 	// AccountCreatedAt holds the value of the "account_created_at" field.
-	AccountCreatedAt int `json:"account_created_at,omitempty"`
+	AccountCreatedAt int64 `json:"account_created_at,omitempty"`
 	// Realm holds the value of the "realm" field.
 	Realm string `json:"realm,omitempty"`
 	// Nickname holds the value of the "nickname" field.
@@ -128,25 +128,25 @@ func (a *Account) assignValues(columns []string, values []any) error {
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field created_at", values[i])
 			} else if value.Valid {
-				a.CreatedAt = int(value.Int64)
+				a.CreatedAt = value.Int64
 			}
 		case account.FieldUpdatedAt:
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
 			} else if value.Valid {
-				a.UpdatedAt = int(value.Int64)
+				a.UpdatedAt = value.Int64
 			}
 		case account.FieldLastBattleTime:
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field last_battle_time", values[i])
 			} else if value.Valid {
-				a.LastBattleTime = int(value.Int64)
+				a.LastBattleTime = value.Int64
 			}
 		case account.FieldAccountCreatedAt:
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field account_created_at", values[i])
 			} else if value.Valid {
-				a.AccountCreatedAt = int(value.Int64)
+				a.AccountCreatedAt = value.Int64
 			}
 		case account.FieldRealm:
 			if value, ok := values[i].(*sql.NullString); !ok {
diff --git a/internal/database/ent/db/account/account.go b/internal/database/ent/db/account/account.go
index d2979c1d..3434e510 100644
--- a/internal/database/ent/db/account/account.go
+++ b/internal/database/ent/db/account/account.go
@@ -93,11 +93,11 @@ func ValidColumn(column string) bool {
 
 var (
 	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
-	DefaultCreatedAt func() int
+	DefaultCreatedAt func() int64
 	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
-	DefaultUpdatedAt func() int
+	DefaultUpdatedAt func() int64
 	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
-	UpdateDefaultUpdatedAt func() int
+	UpdateDefaultUpdatedAt func() int64
 	// RealmValidator is a validator for the "realm" field. It is called by the builders before save.
 	RealmValidator func(string) error
 	// NicknameValidator is a validator for the "nickname" field. It is called by the builders before save.
diff --git a/internal/database/ent/db/account/where.go b/internal/database/ent/db/account/where.go
index a6b0cd6d..8f872414 100644
--- a/internal/database/ent/db/account/where.go
+++ b/internal/database/ent/db/account/where.go
@@ -64,22 +64,22 @@ func IDContainsFold(id string) predicate.Account {
 }
 
 // CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
-func CreatedAt(v int) predicate.Account {
+func CreatedAt(v int64) predicate.Account {
 	return predicate.Account(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
-func UpdatedAt(v int) predicate.Account {
+func UpdatedAt(v int64) predicate.Account {
 	return predicate.Account(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // LastBattleTime applies equality check predicate on the "last_battle_time" field. It's identical to LastBattleTimeEQ.
-func LastBattleTime(v int) predicate.Account {
+func LastBattleTime(v int64) predicate.Account {
 	return predicate.Account(sql.FieldEQ(FieldLastBattleTime, v))
 }
 
 // AccountCreatedAt applies equality check predicate on the "account_created_at" field. It's identical to AccountCreatedAtEQ.
-func AccountCreatedAt(v int) predicate.Account {
+func AccountCreatedAt(v int64) predicate.Account {
 	return predicate.Account(sql.FieldEQ(FieldAccountCreatedAt, v))
 }
 
@@ -104,162 +104,162 @@ func ClanID(v string) predicate.Account {
 }
 
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v int) predicate.Account {
+func CreatedAtEQ(v int64) predicate.Account {
 	return predicate.Account(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v int) predicate.Account {
+func CreatedAtNEQ(v int64) predicate.Account {
 	return predicate.Account(sql.FieldNEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...int) predicate.Account {
+func CreatedAtIn(vs ...int64) predicate.Account {
 	return predicate.Account(sql.FieldIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...int) predicate.Account {
+func CreatedAtNotIn(vs ...int64) predicate.Account {
 	return predicate.Account(sql.FieldNotIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v int) predicate.Account {
+func CreatedAtGT(v int64) predicate.Account {
 	return predicate.Account(sql.FieldGT(FieldCreatedAt, v))
 }
 
 // CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v int) predicate.Account {
+func CreatedAtGTE(v int64) predicate.Account {
 	return predicate.Account(sql.FieldGTE(FieldCreatedAt, v))
 }
 
 // CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v int) predicate.Account {
+func CreatedAtLT(v int64) predicate.Account {
 	return predicate.Account(sql.FieldLT(FieldCreatedAt, v))
 }
 
 // CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v int) predicate.Account {
+func CreatedAtLTE(v int64) predicate.Account {
 	return predicate.Account(sql.FieldLTE(FieldCreatedAt, v))
 }
 
 // UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
-func UpdatedAtEQ(v int) predicate.Account {
+func UpdatedAtEQ(v int64) predicate.Account {
 	return predicate.Account(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
-func UpdatedAtNEQ(v int) predicate.Account {
+func UpdatedAtNEQ(v int64) predicate.Account {
 	return predicate.Account(sql.FieldNEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtIn applies the In predicate on the "updated_at" field.
-func UpdatedAtIn(vs ...int) predicate.Account {
+func UpdatedAtIn(vs ...int64) predicate.Account {
 	return predicate.Account(sql.FieldIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
-func UpdatedAtNotIn(vs ...int) predicate.Account {
+func UpdatedAtNotIn(vs ...int64) predicate.Account {
 	return predicate.Account(sql.FieldNotIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtGT applies the GT predicate on the "updated_at" field.
-func UpdatedAtGT(v int) predicate.Account {
+func UpdatedAtGT(v int64) predicate.Account {
 	return predicate.Account(sql.FieldGT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
-func UpdatedAtGTE(v int) predicate.Account {
+func UpdatedAtGTE(v int64) predicate.Account {
 	return predicate.Account(sql.FieldGTE(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLT applies the LT predicate on the "updated_at" field.
-func UpdatedAtLT(v int) predicate.Account {
+func UpdatedAtLT(v int64) predicate.Account {
 	return predicate.Account(sql.FieldLT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
-func UpdatedAtLTE(v int) predicate.Account {
+func UpdatedAtLTE(v int64) predicate.Account {
 	return predicate.Account(sql.FieldLTE(FieldUpdatedAt, v))
 }
 
 // LastBattleTimeEQ applies the EQ predicate on the "last_battle_time" field.
-func LastBattleTimeEQ(v int) predicate.Account {
+func LastBattleTimeEQ(v int64) predicate.Account {
 	return predicate.Account(sql.FieldEQ(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeNEQ applies the NEQ predicate on the "last_battle_time" field.
-func LastBattleTimeNEQ(v int) predicate.Account {
+func LastBattleTimeNEQ(v int64) predicate.Account {
 	return predicate.Account(sql.FieldNEQ(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeIn applies the In predicate on the "last_battle_time" field.
-func LastBattleTimeIn(vs ...int) predicate.Account {
+func LastBattleTimeIn(vs ...int64) predicate.Account {
 	return predicate.Account(sql.FieldIn(FieldLastBattleTime, vs...))
 }
 
 // LastBattleTimeNotIn applies the NotIn predicate on the "last_battle_time" field.
-func LastBattleTimeNotIn(vs ...int) predicate.Account {
+func LastBattleTimeNotIn(vs ...int64) predicate.Account {
 	return predicate.Account(sql.FieldNotIn(FieldLastBattleTime, vs...))
 }
 
 // LastBattleTimeGT applies the GT predicate on the "last_battle_time" field.
-func LastBattleTimeGT(v int) predicate.Account {
+func LastBattleTimeGT(v int64) predicate.Account {
 	return predicate.Account(sql.FieldGT(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeGTE applies the GTE predicate on the "last_battle_time" field.
-func LastBattleTimeGTE(v int) predicate.Account {
+func LastBattleTimeGTE(v int64) predicate.Account {
 	return predicate.Account(sql.FieldGTE(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeLT applies the LT predicate on the "last_battle_time" field.
-func LastBattleTimeLT(v int) predicate.Account {
+func LastBattleTimeLT(v int64) predicate.Account {
 	return predicate.Account(sql.FieldLT(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeLTE applies the LTE predicate on the "last_battle_time" field.
-func LastBattleTimeLTE(v int) predicate.Account {
+func LastBattleTimeLTE(v int64) predicate.Account {
 	return predicate.Account(sql.FieldLTE(FieldLastBattleTime, v))
 }
 
 // AccountCreatedAtEQ applies the EQ predicate on the "account_created_at" field.
-func AccountCreatedAtEQ(v int) predicate.Account {
+func AccountCreatedAtEQ(v int64) predicate.Account {
 	return predicate.Account(sql.FieldEQ(FieldAccountCreatedAt, v))
 }
 
 // AccountCreatedAtNEQ applies the NEQ predicate on the "account_created_at" field.
-func AccountCreatedAtNEQ(v int) predicate.Account {
+func AccountCreatedAtNEQ(v int64) predicate.Account {
 	return predicate.Account(sql.FieldNEQ(FieldAccountCreatedAt, v))
 }
 
 // AccountCreatedAtIn applies the In predicate on the "account_created_at" field.
-func AccountCreatedAtIn(vs ...int) predicate.Account {
+func AccountCreatedAtIn(vs ...int64) predicate.Account {
 	return predicate.Account(sql.FieldIn(FieldAccountCreatedAt, vs...))
 }
 
 // AccountCreatedAtNotIn applies the NotIn predicate on the "account_created_at" field.
-func AccountCreatedAtNotIn(vs ...int) predicate.Account {
+func AccountCreatedAtNotIn(vs ...int64) predicate.Account {
 	return predicate.Account(sql.FieldNotIn(FieldAccountCreatedAt, vs...))
 }
 
 // AccountCreatedAtGT applies the GT predicate on the "account_created_at" field.
-func AccountCreatedAtGT(v int) predicate.Account {
+func AccountCreatedAtGT(v int64) predicate.Account {
 	return predicate.Account(sql.FieldGT(FieldAccountCreatedAt, v))
 }
 
 // AccountCreatedAtGTE applies the GTE predicate on the "account_created_at" field.
-func AccountCreatedAtGTE(v int) predicate.Account {
+func AccountCreatedAtGTE(v int64) predicate.Account {
 	return predicate.Account(sql.FieldGTE(FieldAccountCreatedAt, v))
 }
 
 // AccountCreatedAtLT applies the LT predicate on the "account_created_at" field.
-func AccountCreatedAtLT(v int) predicate.Account {
+func AccountCreatedAtLT(v int64) predicate.Account {
 	return predicate.Account(sql.FieldLT(FieldAccountCreatedAt, v))
 }
 
 // AccountCreatedAtLTE applies the LTE predicate on the "account_created_at" field.
-func AccountCreatedAtLTE(v int) predicate.Account {
+func AccountCreatedAtLTE(v int64) predicate.Account {
 	return predicate.Account(sql.FieldLTE(FieldAccountCreatedAt, v))
 }
 
diff --git a/internal/database/ent/db/account_create.go b/internal/database/ent/db/account_create.go
index 4afd1e09..7afba00e 100644
--- a/internal/database/ent/db/account_create.go
+++ b/internal/database/ent/db/account_create.go
@@ -24,13 +24,13 @@ type AccountCreate struct {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (ac *AccountCreate) SetCreatedAt(i int) *AccountCreate {
+func (ac *AccountCreate) SetCreatedAt(i int64) *AccountCreate {
 	ac.mutation.SetCreatedAt(i)
 	return ac
 }
 
 // SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
-func (ac *AccountCreate) SetNillableCreatedAt(i *int) *AccountCreate {
+func (ac *AccountCreate) SetNillableCreatedAt(i *int64) *AccountCreate {
 	if i != nil {
 		ac.SetCreatedAt(*i)
 	}
@@ -38,13 +38,13 @@ func (ac *AccountCreate) SetNillableCreatedAt(i *int) *AccountCreate {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (ac *AccountCreate) SetUpdatedAt(i int) *AccountCreate {
+func (ac *AccountCreate) SetUpdatedAt(i int64) *AccountCreate {
 	ac.mutation.SetUpdatedAt(i)
 	return ac
 }
 
 // SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
-func (ac *AccountCreate) SetNillableUpdatedAt(i *int) *AccountCreate {
+func (ac *AccountCreate) SetNillableUpdatedAt(i *int64) *AccountCreate {
 	if i != nil {
 		ac.SetUpdatedAt(*i)
 	}
@@ -52,13 +52,13 @@ func (ac *AccountCreate) SetNillableUpdatedAt(i *int) *AccountCreate {
 }
 
 // SetLastBattleTime sets the "last_battle_time" field.
-func (ac *AccountCreate) SetLastBattleTime(i int) *AccountCreate {
+func (ac *AccountCreate) SetLastBattleTime(i int64) *AccountCreate {
 	ac.mutation.SetLastBattleTime(i)
 	return ac
 }
 
 // SetAccountCreatedAt sets the "account_created_at" field.
-func (ac *AccountCreate) SetAccountCreatedAt(i int) *AccountCreate {
+func (ac *AccountCreate) SetAccountCreatedAt(i int64) *AccountCreate {
 	ac.mutation.SetAccountCreatedAt(i)
 	return ac
 }
@@ -277,19 +277,19 @@ func (ac *AccountCreate) createSpec() (*Account, *sqlgraph.CreateSpec) {
 		_spec.ID.Value = id
 	}
 	if value, ok := ac.mutation.CreatedAt(); ok {
-		_spec.SetField(account.FieldCreatedAt, field.TypeInt, value)
+		_spec.SetField(account.FieldCreatedAt, field.TypeInt64, value)
 		_node.CreatedAt = value
 	}
 	if value, ok := ac.mutation.UpdatedAt(); ok {
-		_spec.SetField(account.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(account.FieldUpdatedAt, field.TypeInt64, value)
 		_node.UpdatedAt = value
 	}
 	if value, ok := ac.mutation.LastBattleTime(); ok {
-		_spec.SetField(account.FieldLastBattleTime, field.TypeInt, value)
+		_spec.SetField(account.FieldLastBattleTime, field.TypeInt64, value)
 		_node.LastBattleTime = value
 	}
 	if value, ok := ac.mutation.AccountCreatedAt(); ok {
-		_spec.SetField(account.FieldAccountCreatedAt, field.TypeInt, value)
+		_spec.SetField(account.FieldAccountCreatedAt, field.TypeInt64, value)
 		_node.AccountCreatedAt = value
 	}
 	if value, ok := ac.mutation.Realm(); ok {
diff --git a/internal/database/ent/db/account_query.go b/internal/database/ent/db/account_query.go
index 9dce0052..bd81a273 100644
--- a/internal/database/ent/db/account_query.go
+++ b/internal/database/ent/db/account_query.go
@@ -406,7 +406,7 @@ func (aq *AccountQuery) WithAchievementSnapshots(opts ...func(*AchievementsSnaps
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int `json:"created_at,omitempty"`
+//		CreatedAt int64 `json:"created_at,omitempty"`
 //		Count int `json:"count,omitempty"`
 //	}
 //
@@ -429,7 +429,7 @@ func (aq *AccountQuery) GroupBy(field string, fields ...string) *AccountGroupBy
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int `json:"created_at,omitempty"`
+//		CreatedAt int64 `json:"created_at,omitempty"`
 //	}
 //
 //	client.Account.Query().
diff --git a/internal/database/ent/db/account_update.go b/internal/database/ent/db/account_update.go
index c58f930b..7a80ee46 100644
--- a/internal/database/ent/db/account_update.go
+++ b/internal/database/ent/db/account_update.go
@@ -32,27 +32,27 @@ func (au *AccountUpdate) Where(ps ...predicate.Account) *AccountUpdate {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (au *AccountUpdate) SetUpdatedAt(i int) *AccountUpdate {
+func (au *AccountUpdate) SetUpdatedAt(i int64) *AccountUpdate {
 	au.mutation.ResetUpdatedAt()
 	au.mutation.SetUpdatedAt(i)
 	return au
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (au *AccountUpdate) AddUpdatedAt(i int) *AccountUpdate {
+func (au *AccountUpdate) AddUpdatedAt(i int64) *AccountUpdate {
 	au.mutation.AddUpdatedAt(i)
 	return au
 }
 
 // SetLastBattleTime sets the "last_battle_time" field.
-func (au *AccountUpdate) SetLastBattleTime(i int) *AccountUpdate {
+func (au *AccountUpdate) SetLastBattleTime(i int64) *AccountUpdate {
 	au.mutation.ResetLastBattleTime()
 	au.mutation.SetLastBattleTime(i)
 	return au
 }
 
 // SetNillableLastBattleTime sets the "last_battle_time" field if the given value is not nil.
-func (au *AccountUpdate) SetNillableLastBattleTime(i *int) *AccountUpdate {
+func (au *AccountUpdate) SetNillableLastBattleTime(i *int64) *AccountUpdate {
 	if i != nil {
 		au.SetLastBattleTime(*i)
 	}
@@ -60,20 +60,20 @@ func (au *AccountUpdate) SetNillableLastBattleTime(i *int) *AccountUpdate {
 }
 
 // AddLastBattleTime adds i to the "last_battle_time" field.
-func (au *AccountUpdate) AddLastBattleTime(i int) *AccountUpdate {
+func (au *AccountUpdate) AddLastBattleTime(i int64) *AccountUpdate {
 	au.mutation.AddLastBattleTime(i)
 	return au
 }
 
 // SetAccountCreatedAt sets the "account_created_at" field.
-func (au *AccountUpdate) SetAccountCreatedAt(i int) *AccountUpdate {
+func (au *AccountUpdate) SetAccountCreatedAt(i int64) *AccountUpdate {
 	au.mutation.ResetAccountCreatedAt()
 	au.mutation.SetAccountCreatedAt(i)
 	return au
 }
 
 // SetNillableAccountCreatedAt sets the "account_created_at" field if the given value is not nil.
-func (au *AccountUpdate) SetNillableAccountCreatedAt(i *int) *AccountUpdate {
+func (au *AccountUpdate) SetNillableAccountCreatedAt(i *int64) *AccountUpdate {
 	if i != nil {
 		au.SetAccountCreatedAt(*i)
 	}
@@ -81,7 +81,7 @@ func (au *AccountUpdate) SetNillableAccountCreatedAt(i *int) *AccountUpdate {
 }
 
 // AddAccountCreatedAt adds i to the "account_created_at" field.
-func (au *AccountUpdate) AddAccountCreatedAt(i int) *AccountUpdate {
+func (au *AccountUpdate) AddAccountCreatedAt(i int64) *AccountUpdate {
 	au.mutation.AddAccountCreatedAt(i)
 	return au
 }
@@ -336,22 +336,22 @@ func (au *AccountUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 	}
 	if value, ok := au.mutation.UpdatedAt(); ok {
-		_spec.SetField(account.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(account.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := au.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(account.FieldUpdatedAt, field.TypeInt, value)
+		_spec.AddField(account.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := au.mutation.LastBattleTime(); ok {
-		_spec.SetField(account.FieldLastBattleTime, field.TypeInt, value)
+		_spec.SetField(account.FieldLastBattleTime, field.TypeInt64, value)
 	}
 	if value, ok := au.mutation.AddedLastBattleTime(); ok {
-		_spec.AddField(account.FieldLastBattleTime, field.TypeInt, value)
+		_spec.AddField(account.FieldLastBattleTime, field.TypeInt64, value)
 	}
 	if value, ok := au.mutation.AccountCreatedAt(); ok {
-		_spec.SetField(account.FieldAccountCreatedAt, field.TypeInt, value)
+		_spec.SetField(account.FieldAccountCreatedAt, field.TypeInt64, value)
 	}
 	if value, ok := au.mutation.AddedAccountCreatedAt(); ok {
-		_spec.AddField(account.FieldAccountCreatedAt, field.TypeInt, value)
+		_spec.AddField(account.FieldAccountCreatedAt, field.TypeInt64, value)
 	}
 	if value, ok := au.mutation.Realm(); ok {
 		_spec.SetField(account.FieldRealm, field.TypeString, value)
@@ -547,27 +547,27 @@ type AccountUpdateOne struct {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (auo *AccountUpdateOne) SetUpdatedAt(i int) *AccountUpdateOne {
+func (auo *AccountUpdateOne) SetUpdatedAt(i int64) *AccountUpdateOne {
 	auo.mutation.ResetUpdatedAt()
 	auo.mutation.SetUpdatedAt(i)
 	return auo
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (auo *AccountUpdateOne) AddUpdatedAt(i int) *AccountUpdateOne {
+func (auo *AccountUpdateOne) AddUpdatedAt(i int64) *AccountUpdateOne {
 	auo.mutation.AddUpdatedAt(i)
 	return auo
 }
 
 // SetLastBattleTime sets the "last_battle_time" field.
-func (auo *AccountUpdateOne) SetLastBattleTime(i int) *AccountUpdateOne {
+func (auo *AccountUpdateOne) SetLastBattleTime(i int64) *AccountUpdateOne {
 	auo.mutation.ResetLastBattleTime()
 	auo.mutation.SetLastBattleTime(i)
 	return auo
 }
 
 // SetNillableLastBattleTime sets the "last_battle_time" field if the given value is not nil.
-func (auo *AccountUpdateOne) SetNillableLastBattleTime(i *int) *AccountUpdateOne {
+func (auo *AccountUpdateOne) SetNillableLastBattleTime(i *int64) *AccountUpdateOne {
 	if i != nil {
 		auo.SetLastBattleTime(*i)
 	}
@@ -575,20 +575,20 @@ func (auo *AccountUpdateOne) SetNillableLastBattleTime(i *int) *AccountUpdateOne
 }
 
 // AddLastBattleTime adds i to the "last_battle_time" field.
-func (auo *AccountUpdateOne) AddLastBattleTime(i int) *AccountUpdateOne {
+func (auo *AccountUpdateOne) AddLastBattleTime(i int64) *AccountUpdateOne {
 	auo.mutation.AddLastBattleTime(i)
 	return auo
 }
 
 // SetAccountCreatedAt sets the "account_created_at" field.
-func (auo *AccountUpdateOne) SetAccountCreatedAt(i int) *AccountUpdateOne {
+func (auo *AccountUpdateOne) SetAccountCreatedAt(i int64) *AccountUpdateOne {
 	auo.mutation.ResetAccountCreatedAt()
 	auo.mutation.SetAccountCreatedAt(i)
 	return auo
 }
 
 // SetNillableAccountCreatedAt sets the "account_created_at" field if the given value is not nil.
-func (auo *AccountUpdateOne) SetNillableAccountCreatedAt(i *int) *AccountUpdateOne {
+func (auo *AccountUpdateOne) SetNillableAccountCreatedAt(i *int64) *AccountUpdateOne {
 	if i != nil {
 		auo.SetAccountCreatedAt(*i)
 	}
@@ -596,7 +596,7 @@ func (auo *AccountUpdateOne) SetNillableAccountCreatedAt(i *int) *AccountUpdateO
 }
 
 // AddAccountCreatedAt adds i to the "account_created_at" field.
-func (auo *AccountUpdateOne) AddAccountCreatedAt(i int) *AccountUpdateOne {
+func (auo *AccountUpdateOne) AddAccountCreatedAt(i int64) *AccountUpdateOne {
 	auo.mutation.AddAccountCreatedAt(i)
 	return auo
 }
@@ -881,22 +881,22 @@ func (auo *AccountUpdateOne) sqlSave(ctx context.Context) (_node *Account, err e
 		}
 	}
 	if value, ok := auo.mutation.UpdatedAt(); ok {
-		_spec.SetField(account.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(account.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := auo.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(account.FieldUpdatedAt, field.TypeInt, value)
+		_spec.AddField(account.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := auo.mutation.LastBattleTime(); ok {
-		_spec.SetField(account.FieldLastBattleTime, field.TypeInt, value)
+		_spec.SetField(account.FieldLastBattleTime, field.TypeInt64, value)
 	}
 	if value, ok := auo.mutation.AddedLastBattleTime(); ok {
-		_spec.AddField(account.FieldLastBattleTime, field.TypeInt, value)
+		_spec.AddField(account.FieldLastBattleTime, field.TypeInt64, value)
 	}
 	if value, ok := auo.mutation.AccountCreatedAt(); ok {
-		_spec.SetField(account.FieldAccountCreatedAt, field.TypeInt, value)
+		_spec.SetField(account.FieldAccountCreatedAt, field.TypeInt64, value)
 	}
 	if value, ok := auo.mutation.AddedAccountCreatedAt(); ok {
-		_spec.AddField(account.FieldAccountCreatedAt, field.TypeInt, value)
+		_spec.AddField(account.FieldAccountCreatedAt, field.TypeInt64, value)
 	}
 	if value, ok := auo.mutation.Realm(); ok {
 		_spec.SetField(account.FieldRealm, field.TypeString, value)
diff --git a/internal/database/ent/db/accountsnapshot.go b/internal/database/ent/db/accountsnapshot.go
index d0dd7952..18d8c5f7 100644
--- a/internal/database/ent/db/accountsnapshot.go
+++ b/internal/database/ent/db/accountsnapshot.go
@@ -21,13 +21,13 @@ type AccountSnapshot struct {
 	// ID of the ent.
 	ID string `json:"id,omitempty"`
 	// CreatedAt holds the value of the "created_at" field.
-	CreatedAt int `json:"created_at,omitempty"`
+	CreatedAt int64 `json:"created_at,omitempty"`
 	// UpdatedAt holds the value of the "updated_at" field.
-	UpdatedAt int `json:"updated_at,omitempty"`
+	UpdatedAt int64 `json:"updated_at,omitempty"`
 	// Type holds the value of the "type" field.
 	Type models.SnapshotType `json:"type,omitempty"`
 	// LastBattleTime holds the value of the "last_battle_time" field.
-	LastBattleTime int `json:"last_battle_time,omitempty"`
+	LastBattleTime int64 `json:"last_battle_time,omitempty"`
 	// AccountID holds the value of the "account_id" field.
 	AccountID string `json:"account_id,omitempty"`
 	// ReferenceID holds the value of the "reference_id" field.
@@ -102,13 +102,13 @@ func (as *AccountSnapshot) assignValues(columns []string, values []any) error {
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field created_at", values[i])
 			} else if value.Valid {
-				as.CreatedAt = int(value.Int64)
+				as.CreatedAt = value.Int64
 			}
 		case accountsnapshot.FieldUpdatedAt:
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
 			} else if value.Valid {
-				as.UpdatedAt = int(value.Int64)
+				as.UpdatedAt = value.Int64
 			}
 		case accountsnapshot.FieldType:
 			if value, ok := values[i].(*sql.NullString); !ok {
@@ -120,7 +120,7 @@ func (as *AccountSnapshot) assignValues(columns []string, values []any) error {
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field last_battle_time", values[i])
 			} else if value.Valid {
-				as.LastBattleTime = int(value.Int64)
+				as.LastBattleTime = value.Int64
 			}
 		case accountsnapshot.FieldAccountID:
 			if value, ok := values[i].(*sql.NullString); !ok {
diff --git a/internal/database/ent/db/accountsnapshot/accountsnapshot.go b/internal/database/ent/db/accountsnapshot/accountsnapshot.go
index d99d867d..1a60c4b6 100644
--- a/internal/database/ent/db/accountsnapshot/accountsnapshot.go
+++ b/internal/database/ent/db/accountsnapshot/accountsnapshot.go
@@ -75,11 +75,11 @@ func ValidColumn(column string) bool {
 
 var (
 	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
-	DefaultCreatedAt func() int
+	DefaultCreatedAt func() int64
 	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
-	DefaultUpdatedAt func() int
+	DefaultUpdatedAt func() int64
 	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
-	UpdateDefaultUpdatedAt func() int
+	UpdateDefaultUpdatedAt func() int64
 	// AccountIDValidator is a validator for the "account_id" field. It is called by the builders before save.
 	AccountIDValidator func(string) error
 	// ReferenceIDValidator is a validator for the "reference_id" field. It is called by the builders before save.
diff --git a/internal/database/ent/db/accountsnapshot/where.go b/internal/database/ent/db/accountsnapshot/where.go
index 16101ea9..6f49d0e8 100644
--- a/internal/database/ent/db/accountsnapshot/where.go
+++ b/internal/database/ent/db/accountsnapshot/where.go
@@ -65,17 +65,17 @@ func IDContainsFold(id string) predicate.AccountSnapshot {
 }
 
 // CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
-func CreatedAt(v int) predicate.AccountSnapshot {
+func CreatedAt(v int64) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
-func UpdatedAt(v int) predicate.AccountSnapshot {
+func UpdatedAt(v int64) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // LastBattleTime applies equality check predicate on the "last_battle_time" field. It's identical to LastBattleTimeEQ.
-func LastBattleTime(v int) predicate.AccountSnapshot {
+func LastBattleTime(v int64) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldEQ(FieldLastBattleTime, v))
 }
 
@@ -100,82 +100,82 @@ func RegularBattles(v int) predicate.AccountSnapshot {
 }
 
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v int) predicate.AccountSnapshot {
+func CreatedAtEQ(v int64) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v int) predicate.AccountSnapshot {
+func CreatedAtNEQ(v int64) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldNEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...int) predicate.AccountSnapshot {
+func CreatedAtIn(vs ...int64) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...int) predicate.AccountSnapshot {
+func CreatedAtNotIn(vs ...int64) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldNotIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v int) predicate.AccountSnapshot {
+func CreatedAtGT(v int64) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldGT(FieldCreatedAt, v))
 }
 
 // CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v int) predicate.AccountSnapshot {
+func CreatedAtGTE(v int64) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldGTE(FieldCreatedAt, v))
 }
 
 // CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v int) predicate.AccountSnapshot {
+func CreatedAtLT(v int64) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldLT(FieldCreatedAt, v))
 }
 
 // CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v int) predicate.AccountSnapshot {
+func CreatedAtLTE(v int64) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldLTE(FieldCreatedAt, v))
 }
 
 // UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
-func UpdatedAtEQ(v int) predicate.AccountSnapshot {
+func UpdatedAtEQ(v int64) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
-func UpdatedAtNEQ(v int) predicate.AccountSnapshot {
+func UpdatedAtNEQ(v int64) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldNEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtIn applies the In predicate on the "updated_at" field.
-func UpdatedAtIn(vs ...int) predicate.AccountSnapshot {
+func UpdatedAtIn(vs ...int64) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
-func UpdatedAtNotIn(vs ...int) predicate.AccountSnapshot {
+func UpdatedAtNotIn(vs ...int64) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldNotIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtGT applies the GT predicate on the "updated_at" field.
-func UpdatedAtGT(v int) predicate.AccountSnapshot {
+func UpdatedAtGT(v int64) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldGT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
-func UpdatedAtGTE(v int) predicate.AccountSnapshot {
+func UpdatedAtGTE(v int64) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldGTE(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLT applies the LT predicate on the "updated_at" field.
-func UpdatedAtLT(v int) predicate.AccountSnapshot {
+func UpdatedAtLT(v int64) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldLT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
-func UpdatedAtLTE(v int) predicate.AccountSnapshot {
+func UpdatedAtLTE(v int64) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldLTE(FieldUpdatedAt, v))
 }
 
@@ -210,42 +210,42 @@ func TypeNotIn(vs ...models.SnapshotType) predicate.AccountSnapshot {
 }
 
 // LastBattleTimeEQ applies the EQ predicate on the "last_battle_time" field.
-func LastBattleTimeEQ(v int) predicate.AccountSnapshot {
+func LastBattleTimeEQ(v int64) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldEQ(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeNEQ applies the NEQ predicate on the "last_battle_time" field.
-func LastBattleTimeNEQ(v int) predicate.AccountSnapshot {
+func LastBattleTimeNEQ(v int64) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldNEQ(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeIn applies the In predicate on the "last_battle_time" field.
-func LastBattleTimeIn(vs ...int) predicate.AccountSnapshot {
+func LastBattleTimeIn(vs ...int64) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldIn(FieldLastBattleTime, vs...))
 }
 
 // LastBattleTimeNotIn applies the NotIn predicate on the "last_battle_time" field.
-func LastBattleTimeNotIn(vs ...int) predicate.AccountSnapshot {
+func LastBattleTimeNotIn(vs ...int64) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldNotIn(FieldLastBattleTime, vs...))
 }
 
 // LastBattleTimeGT applies the GT predicate on the "last_battle_time" field.
-func LastBattleTimeGT(v int) predicate.AccountSnapshot {
+func LastBattleTimeGT(v int64) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldGT(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeGTE applies the GTE predicate on the "last_battle_time" field.
-func LastBattleTimeGTE(v int) predicate.AccountSnapshot {
+func LastBattleTimeGTE(v int64) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldGTE(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeLT applies the LT predicate on the "last_battle_time" field.
-func LastBattleTimeLT(v int) predicate.AccountSnapshot {
+func LastBattleTimeLT(v int64) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldLT(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeLTE applies the LTE predicate on the "last_battle_time" field.
-func LastBattleTimeLTE(v int) predicate.AccountSnapshot {
+func LastBattleTimeLTE(v int64) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldLTE(FieldLastBattleTime, v))
 }
 
diff --git a/internal/database/ent/db/accountsnapshot_create.go b/internal/database/ent/db/accountsnapshot_create.go
index c4059901..9cc5742c 100644
--- a/internal/database/ent/db/accountsnapshot_create.go
+++ b/internal/database/ent/db/accountsnapshot_create.go
@@ -23,13 +23,13 @@ type AccountSnapshotCreate struct {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (asc *AccountSnapshotCreate) SetCreatedAt(i int) *AccountSnapshotCreate {
+func (asc *AccountSnapshotCreate) SetCreatedAt(i int64) *AccountSnapshotCreate {
 	asc.mutation.SetCreatedAt(i)
 	return asc
 }
 
 // SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
-func (asc *AccountSnapshotCreate) SetNillableCreatedAt(i *int) *AccountSnapshotCreate {
+func (asc *AccountSnapshotCreate) SetNillableCreatedAt(i *int64) *AccountSnapshotCreate {
 	if i != nil {
 		asc.SetCreatedAt(*i)
 	}
@@ -37,13 +37,13 @@ func (asc *AccountSnapshotCreate) SetNillableCreatedAt(i *int) *AccountSnapshotC
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (asc *AccountSnapshotCreate) SetUpdatedAt(i int) *AccountSnapshotCreate {
+func (asc *AccountSnapshotCreate) SetUpdatedAt(i int64) *AccountSnapshotCreate {
 	asc.mutation.SetUpdatedAt(i)
 	return asc
 }
 
 // SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
-func (asc *AccountSnapshotCreate) SetNillableUpdatedAt(i *int) *AccountSnapshotCreate {
+func (asc *AccountSnapshotCreate) SetNillableUpdatedAt(i *int64) *AccountSnapshotCreate {
 	if i != nil {
 		asc.SetUpdatedAt(*i)
 	}
@@ -57,7 +57,7 @@ func (asc *AccountSnapshotCreate) SetType(mt models.SnapshotType) *AccountSnapsh
 }
 
 // SetLastBattleTime sets the "last_battle_time" field.
-func (asc *AccountSnapshotCreate) SetLastBattleTime(i int) *AccountSnapshotCreate {
+func (asc *AccountSnapshotCreate) SetLastBattleTime(i int64) *AccountSnapshotCreate {
 	asc.mutation.SetLastBattleTime(i)
 	return asc
 }
@@ -252,11 +252,11 @@ func (asc *AccountSnapshotCreate) createSpec() (*AccountSnapshot, *sqlgraph.Crea
 		_spec.ID.Value = id
 	}
 	if value, ok := asc.mutation.CreatedAt(); ok {
-		_spec.SetField(accountsnapshot.FieldCreatedAt, field.TypeInt, value)
+		_spec.SetField(accountsnapshot.FieldCreatedAt, field.TypeInt64, value)
 		_node.CreatedAt = value
 	}
 	if value, ok := asc.mutation.UpdatedAt(); ok {
-		_spec.SetField(accountsnapshot.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(accountsnapshot.FieldUpdatedAt, field.TypeInt64, value)
 		_node.UpdatedAt = value
 	}
 	if value, ok := asc.mutation.GetType(); ok {
@@ -264,7 +264,7 @@ func (asc *AccountSnapshotCreate) createSpec() (*AccountSnapshot, *sqlgraph.Crea
 		_node.Type = value
 	}
 	if value, ok := asc.mutation.LastBattleTime(); ok {
-		_spec.SetField(accountsnapshot.FieldLastBattleTime, field.TypeInt, value)
+		_spec.SetField(accountsnapshot.FieldLastBattleTime, field.TypeInt64, value)
 		_node.LastBattleTime = value
 	}
 	if value, ok := asc.mutation.ReferenceID(); ok {
diff --git a/internal/database/ent/db/accountsnapshot_query.go b/internal/database/ent/db/accountsnapshot_query.go
index af3bf5f9..33acaaf3 100644
--- a/internal/database/ent/db/accountsnapshot_query.go
+++ b/internal/database/ent/db/accountsnapshot_query.go
@@ -297,7 +297,7 @@ func (asq *AccountSnapshotQuery) WithAccount(opts ...func(*AccountQuery)) *Accou
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int `json:"created_at,omitempty"`
+//		CreatedAt int64 `json:"created_at,omitempty"`
 //		Count int `json:"count,omitempty"`
 //	}
 //
@@ -320,7 +320,7 @@ func (asq *AccountSnapshotQuery) GroupBy(field string, fields ...string) *Accoun
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int `json:"created_at,omitempty"`
+//		CreatedAt int64 `json:"created_at,omitempty"`
 //	}
 //
 //	client.AccountSnapshot.Query().
diff --git a/internal/database/ent/db/accountsnapshot_update.go b/internal/database/ent/db/accountsnapshot_update.go
index 0d1dcb15..407e16bf 100644
--- a/internal/database/ent/db/accountsnapshot_update.go
+++ b/internal/database/ent/db/accountsnapshot_update.go
@@ -30,14 +30,14 @@ func (asu *AccountSnapshotUpdate) Where(ps ...predicate.AccountSnapshot) *Accoun
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (asu *AccountSnapshotUpdate) SetUpdatedAt(i int) *AccountSnapshotUpdate {
+func (asu *AccountSnapshotUpdate) SetUpdatedAt(i int64) *AccountSnapshotUpdate {
 	asu.mutation.ResetUpdatedAt()
 	asu.mutation.SetUpdatedAt(i)
 	return asu
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (asu *AccountSnapshotUpdate) AddUpdatedAt(i int) *AccountSnapshotUpdate {
+func (asu *AccountSnapshotUpdate) AddUpdatedAt(i int64) *AccountSnapshotUpdate {
 	asu.mutation.AddUpdatedAt(i)
 	return asu
 }
@@ -57,14 +57,14 @@ func (asu *AccountSnapshotUpdate) SetNillableType(mt *models.SnapshotType) *Acco
 }
 
 // SetLastBattleTime sets the "last_battle_time" field.
-func (asu *AccountSnapshotUpdate) SetLastBattleTime(i int) *AccountSnapshotUpdate {
+func (asu *AccountSnapshotUpdate) SetLastBattleTime(i int64) *AccountSnapshotUpdate {
 	asu.mutation.ResetLastBattleTime()
 	asu.mutation.SetLastBattleTime(i)
 	return asu
 }
 
 // SetNillableLastBattleTime sets the "last_battle_time" field if the given value is not nil.
-func (asu *AccountSnapshotUpdate) SetNillableLastBattleTime(i *int) *AccountSnapshotUpdate {
+func (asu *AccountSnapshotUpdate) SetNillableLastBattleTime(i *int64) *AccountSnapshotUpdate {
 	if i != nil {
 		asu.SetLastBattleTime(*i)
 	}
@@ -72,7 +72,7 @@ func (asu *AccountSnapshotUpdate) SetNillableLastBattleTime(i *int) *AccountSnap
 }
 
 // AddLastBattleTime adds i to the "last_battle_time" field.
-func (asu *AccountSnapshotUpdate) AddLastBattleTime(i int) *AccountSnapshotUpdate {
+func (asu *AccountSnapshotUpdate) AddLastBattleTime(i int64) *AccountSnapshotUpdate {
 	asu.mutation.AddLastBattleTime(i)
 	return asu
 }
@@ -233,19 +233,19 @@ func (asu *AccountSnapshotUpdate) sqlSave(ctx context.Context) (n int, err error
 		}
 	}
 	if value, ok := asu.mutation.UpdatedAt(); ok {
-		_spec.SetField(accountsnapshot.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(accountsnapshot.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := asu.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(accountsnapshot.FieldUpdatedAt, field.TypeInt, value)
+		_spec.AddField(accountsnapshot.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := asu.mutation.GetType(); ok {
 		_spec.SetField(accountsnapshot.FieldType, field.TypeEnum, value)
 	}
 	if value, ok := asu.mutation.LastBattleTime(); ok {
-		_spec.SetField(accountsnapshot.FieldLastBattleTime, field.TypeInt, value)
+		_spec.SetField(accountsnapshot.FieldLastBattleTime, field.TypeInt64, value)
 	}
 	if value, ok := asu.mutation.AddedLastBattleTime(); ok {
-		_spec.AddField(accountsnapshot.FieldLastBattleTime, field.TypeInt, value)
+		_spec.AddField(accountsnapshot.FieldLastBattleTime, field.TypeInt64, value)
 	}
 	if value, ok := asu.mutation.ReferenceID(); ok {
 		_spec.SetField(accountsnapshot.FieldReferenceID, field.TypeString, value)
@@ -289,14 +289,14 @@ type AccountSnapshotUpdateOne struct {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (asuo *AccountSnapshotUpdateOne) SetUpdatedAt(i int) *AccountSnapshotUpdateOne {
+func (asuo *AccountSnapshotUpdateOne) SetUpdatedAt(i int64) *AccountSnapshotUpdateOne {
 	asuo.mutation.ResetUpdatedAt()
 	asuo.mutation.SetUpdatedAt(i)
 	return asuo
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (asuo *AccountSnapshotUpdateOne) AddUpdatedAt(i int) *AccountSnapshotUpdateOne {
+func (asuo *AccountSnapshotUpdateOne) AddUpdatedAt(i int64) *AccountSnapshotUpdateOne {
 	asuo.mutation.AddUpdatedAt(i)
 	return asuo
 }
@@ -316,14 +316,14 @@ func (asuo *AccountSnapshotUpdateOne) SetNillableType(mt *models.SnapshotType) *
 }
 
 // SetLastBattleTime sets the "last_battle_time" field.
-func (asuo *AccountSnapshotUpdateOne) SetLastBattleTime(i int) *AccountSnapshotUpdateOne {
+func (asuo *AccountSnapshotUpdateOne) SetLastBattleTime(i int64) *AccountSnapshotUpdateOne {
 	asuo.mutation.ResetLastBattleTime()
 	asuo.mutation.SetLastBattleTime(i)
 	return asuo
 }
 
 // SetNillableLastBattleTime sets the "last_battle_time" field if the given value is not nil.
-func (asuo *AccountSnapshotUpdateOne) SetNillableLastBattleTime(i *int) *AccountSnapshotUpdateOne {
+func (asuo *AccountSnapshotUpdateOne) SetNillableLastBattleTime(i *int64) *AccountSnapshotUpdateOne {
 	if i != nil {
 		asuo.SetLastBattleTime(*i)
 	}
@@ -331,7 +331,7 @@ func (asuo *AccountSnapshotUpdateOne) SetNillableLastBattleTime(i *int) *Account
 }
 
 // AddLastBattleTime adds i to the "last_battle_time" field.
-func (asuo *AccountSnapshotUpdateOne) AddLastBattleTime(i int) *AccountSnapshotUpdateOne {
+func (asuo *AccountSnapshotUpdateOne) AddLastBattleTime(i int64) *AccountSnapshotUpdateOne {
 	asuo.mutation.AddLastBattleTime(i)
 	return asuo
 }
@@ -522,19 +522,19 @@ func (asuo *AccountSnapshotUpdateOne) sqlSave(ctx context.Context) (_node *Accou
 		}
 	}
 	if value, ok := asuo.mutation.UpdatedAt(); ok {
-		_spec.SetField(accountsnapshot.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(accountsnapshot.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := asuo.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(accountsnapshot.FieldUpdatedAt, field.TypeInt, value)
+		_spec.AddField(accountsnapshot.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := asuo.mutation.GetType(); ok {
 		_spec.SetField(accountsnapshot.FieldType, field.TypeEnum, value)
 	}
 	if value, ok := asuo.mutation.LastBattleTime(); ok {
-		_spec.SetField(accountsnapshot.FieldLastBattleTime, field.TypeInt, value)
+		_spec.SetField(accountsnapshot.FieldLastBattleTime, field.TypeInt64, value)
 	}
 	if value, ok := asuo.mutation.AddedLastBattleTime(); ok {
-		_spec.AddField(accountsnapshot.FieldLastBattleTime, field.TypeInt, value)
+		_spec.AddField(accountsnapshot.FieldLastBattleTime, field.TypeInt64, value)
 	}
 	if value, ok := asuo.mutation.ReferenceID(); ok {
 		_spec.SetField(accountsnapshot.FieldReferenceID, field.TypeString, value)
diff --git a/internal/database/ent/db/achievementssnapshot.go b/internal/database/ent/db/achievementssnapshot.go
index b26ece54..6a16a84d 100644
--- a/internal/database/ent/db/achievementssnapshot.go
+++ b/internal/database/ent/db/achievementssnapshot.go
@@ -21,9 +21,9 @@ type AchievementsSnapshot struct {
 	// ID of the ent.
 	ID string `json:"id,omitempty"`
 	// CreatedAt holds the value of the "created_at" field.
-	CreatedAt int `json:"created_at,omitempty"`
+	CreatedAt int64 `json:"created_at,omitempty"`
 	// UpdatedAt holds the value of the "updated_at" field.
-	UpdatedAt int `json:"updated_at,omitempty"`
+	UpdatedAt int64 `json:"updated_at,omitempty"`
 	// Type holds the value of the "type" field.
 	Type models.SnapshotType `json:"type,omitempty"`
 	// AccountID holds the value of the "account_id" field.
@@ -33,7 +33,7 @@ type AchievementsSnapshot struct {
 	// Battles holds the value of the "battles" field.
 	Battles int `json:"battles,omitempty"`
 	// LastBattleTime holds the value of the "last_battle_time" field.
-	LastBattleTime int `json:"last_battle_time,omitempty"`
+	LastBattleTime int64 `json:"last_battle_time,omitempty"`
 	// Data holds the value of the "data" field.
 	Data types.AchievementsFrame `json:"data,omitempty"`
 	// Edges holds the relations/edges for other nodes in the graph.
@@ -98,13 +98,13 @@ func (as *AchievementsSnapshot) assignValues(columns []string, values []any) err
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field created_at", values[i])
 			} else if value.Valid {
-				as.CreatedAt = int(value.Int64)
+				as.CreatedAt = value.Int64
 			}
 		case achievementssnapshot.FieldUpdatedAt:
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
 			} else if value.Valid {
-				as.UpdatedAt = int(value.Int64)
+				as.UpdatedAt = value.Int64
 			}
 		case achievementssnapshot.FieldType:
 			if value, ok := values[i].(*sql.NullString); !ok {
@@ -134,7 +134,7 @@ func (as *AchievementsSnapshot) assignValues(columns []string, values []any) err
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field last_battle_time", values[i])
 			} else if value.Valid {
-				as.LastBattleTime = int(value.Int64)
+				as.LastBattleTime = value.Int64
 			}
 		case achievementssnapshot.FieldData:
 			if value, ok := values[i].(*[]byte); !ok {
diff --git a/internal/database/ent/db/achievementssnapshot/achievementssnapshot.go b/internal/database/ent/db/achievementssnapshot/achievementssnapshot.go
index e6c64d4f..959b9e38 100644
--- a/internal/database/ent/db/achievementssnapshot/achievementssnapshot.go
+++ b/internal/database/ent/db/achievementssnapshot/achievementssnapshot.go
@@ -69,11 +69,11 @@ func ValidColumn(column string) bool {
 
 var (
 	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
-	DefaultCreatedAt func() int
+	DefaultCreatedAt func() int64
 	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
-	DefaultUpdatedAt func() int
+	DefaultUpdatedAt func() int64
 	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
-	UpdateDefaultUpdatedAt func() int
+	UpdateDefaultUpdatedAt func() int64
 	// AccountIDValidator is a validator for the "account_id" field. It is called by the builders before save.
 	AccountIDValidator func(string) error
 	// ReferenceIDValidator is a validator for the "reference_id" field. It is called by the builders before save.
diff --git a/internal/database/ent/db/achievementssnapshot/where.go b/internal/database/ent/db/achievementssnapshot/where.go
index d7b2035f..5d0bea81 100644
--- a/internal/database/ent/db/achievementssnapshot/where.go
+++ b/internal/database/ent/db/achievementssnapshot/where.go
@@ -65,12 +65,12 @@ func IDContainsFold(id string) predicate.AchievementsSnapshot {
 }
 
 // CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
-func CreatedAt(v int) predicate.AchievementsSnapshot {
+func CreatedAt(v int64) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
-func UpdatedAt(v int) predicate.AchievementsSnapshot {
+func UpdatedAt(v int64) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
@@ -90,87 +90,87 @@ func Battles(v int) predicate.AchievementsSnapshot {
 }
 
 // LastBattleTime applies equality check predicate on the "last_battle_time" field. It's identical to LastBattleTimeEQ.
-func LastBattleTime(v int) predicate.AchievementsSnapshot {
+func LastBattleTime(v int64) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldLastBattleTime, v))
 }
 
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v int) predicate.AchievementsSnapshot {
+func CreatedAtEQ(v int64) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v int) predicate.AchievementsSnapshot {
+func CreatedAtNEQ(v int64) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldNEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...int) predicate.AchievementsSnapshot {
+func CreatedAtIn(vs ...int64) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...int) predicate.AchievementsSnapshot {
+func CreatedAtNotIn(vs ...int64) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldNotIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v int) predicate.AchievementsSnapshot {
+func CreatedAtGT(v int64) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldGT(FieldCreatedAt, v))
 }
 
 // CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v int) predicate.AchievementsSnapshot {
+func CreatedAtGTE(v int64) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldGTE(FieldCreatedAt, v))
 }
 
 // CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v int) predicate.AchievementsSnapshot {
+func CreatedAtLT(v int64) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldLT(FieldCreatedAt, v))
 }
 
 // CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v int) predicate.AchievementsSnapshot {
+func CreatedAtLTE(v int64) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldLTE(FieldCreatedAt, v))
 }
 
 // UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
-func UpdatedAtEQ(v int) predicate.AchievementsSnapshot {
+func UpdatedAtEQ(v int64) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
-func UpdatedAtNEQ(v int) predicate.AchievementsSnapshot {
+func UpdatedAtNEQ(v int64) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldNEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtIn applies the In predicate on the "updated_at" field.
-func UpdatedAtIn(vs ...int) predicate.AchievementsSnapshot {
+func UpdatedAtIn(vs ...int64) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
-func UpdatedAtNotIn(vs ...int) predicate.AchievementsSnapshot {
+func UpdatedAtNotIn(vs ...int64) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldNotIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtGT applies the GT predicate on the "updated_at" field.
-func UpdatedAtGT(v int) predicate.AchievementsSnapshot {
+func UpdatedAtGT(v int64) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldGT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
-func UpdatedAtGTE(v int) predicate.AchievementsSnapshot {
+func UpdatedAtGTE(v int64) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldGTE(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLT applies the LT predicate on the "updated_at" field.
-func UpdatedAtLT(v int) predicate.AchievementsSnapshot {
+func UpdatedAtLT(v int64) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldLT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
-func UpdatedAtLTE(v int) predicate.AchievementsSnapshot {
+func UpdatedAtLTE(v int64) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldLTE(FieldUpdatedAt, v))
 }
 
@@ -375,42 +375,42 @@ func BattlesLTE(v int) predicate.AchievementsSnapshot {
 }
 
 // LastBattleTimeEQ applies the EQ predicate on the "last_battle_time" field.
-func LastBattleTimeEQ(v int) predicate.AchievementsSnapshot {
+func LastBattleTimeEQ(v int64) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeNEQ applies the NEQ predicate on the "last_battle_time" field.
-func LastBattleTimeNEQ(v int) predicate.AchievementsSnapshot {
+func LastBattleTimeNEQ(v int64) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldNEQ(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeIn applies the In predicate on the "last_battle_time" field.
-func LastBattleTimeIn(vs ...int) predicate.AchievementsSnapshot {
+func LastBattleTimeIn(vs ...int64) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldIn(FieldLastBattleTime, vs...))
 }
 
 // LastBattleTimeNotIn applies the NotIn predicate on the "last_battle_time" field.
-func LastBattleTimeNotIn(vs ...int) predicate.AchievementsSnapshot {
+func LastBattleTimeNotIn(vs ...int64) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldNotIn(FieldLastBattleTime, vs...))
 }
 
 // LastBattleTimeGT applies the GT predicate on the "last_battle_time" field.
-func LastBattleTimeGT(v int) predicate.AchievementsSnapshot {
+func LastBattleTimeGT(v int64) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldGT(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeGTE applies the GTE predicate on the "last_battle_time" field.
-func LastBattleTimeGTE(v int) predicate.AchievementsSnapshot {
+func LastBattleTimeGTE(v int64) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldGTE(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeLT applies the LT predicate on the "last_battle_time" field.
-func LastBattleTimeLT(v int) predicate.AchievementsSnapshot {
+func LastBattleTimeLT(v int64) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldLT(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeLTE applies the LTE predicate on the "last_battle_time" field.
-func LastBattleTimeLTE(v int) predicate.AchievementsSnapshot {
+func LastBattleTimeLTE(v int64) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldLTE(FieldLastBattleTime, v))
 }
 
diff --git a/internal/database/ent/db/achievementssnapshot_create.go b/internal/database/ent/db/achievementssnapshot_create.go
index 26b95982..7e18e271 100644
--- a/internal/database/ent/db/achievementssnapshot_create.go
+++ b/internal/database/ent/db/achievementssnapshot_create.go
@@ -23,13 +23,13 @@ type AchievementsSnapshotCreate struct {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (asc *AchievementsSnapshotCreate) SetCreatedAt(i int) *AchievementsSnapshotCreate {
+func (asc *AchievementsSnapshotCreate) SetCreatedAt(i int64) *AchievementsSnapshotCreate {
 	asc.mutation.SetCreatedAt(i)
 	return asc
 }
 
 // SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
-func (asc *AchievementsSnapshotCreate) SetNillableCreatedAt(i *int) *AchievementsSnapshotCreate {
+func (asc *AchievementsSnapshotCreate) SetNillableCreatedAt(i *int64) *AchievementsSnapshotCreate {
 	if i != nil {
 		asc.SetCreatedAt(*i)
 	}
@@ -37,13 +37,13 @@ func (asc *AchievementsSnapshotCreate) SetNillableCreatedAt(i *int) *Achievement
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (asc *AchievementsSnapshotCreate) SetUpdatedAt(i int) *AchievementsSnapshotCreate {
+func (asc *AchievementsSnapshotCreate) SetUpdatedAt(i int64) *AchievementsSnapshotCreate {
 	asc.mutation.SetUpdatedAt(i)
 	return asc
 }
 
 // SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
-func (asc *AchievementsSnapshotCreate) SetNillableUpdatedAt(i *int) *AchievementsSnapshotCreate {
+func (asc *AchievementsSnapshotCreate) SetNillableUpdatedAt(i *int64) *AchievementsSnapshotCreate {
 	if i != nil {
 		asc.SetUpdatedAt(*i)
 	}
@@ -75,7 +75,7 @@ func (asc *AchievementsSnapshotCreate) SetBattles(i int) *AchievementsSnapshotCr
 }
 
 // SetLastBattleTime sets the "last_battle_time" field.
-func (asc *AchievementsSnapshotCreate) SetLastBattleTime(i int) *AchievementsSnapshotCreate {
+func (asc *AchievementsSnapshotCreate) SetLastBattleTime(i int64) *AchievementsSnapshotCreate {
 	asc.mutation.SetLastBattleTime(i)
 	return asc
 }
@@ -234,11 +234,11 @@ func (asc *AchievementsSnapshotCreate) createSpec() (*AchievementsSnapshot, *sql
 		_spec.ID.Value = id
 	}
 	if value, ok := asc.mutation.CreatedAt(); ok {
-		_spec.SetField(achievementssnapshot.FieldCreatedAt, field.TypeInt, value)
+		_spec.SetField(achievementssnapshot.FieldCreatedAt, field.TypeInt64, value)
 		_node.CreatedAt = value
 	}
 	if value, ok := asc.mutation.UpdatedAt(); ok {
-		_spec.SetField(achievementssnapshot.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(achievementssnapshot.FieldUpdatedAt, field.TypeInt64, value)
 		_node.UpdatedAt = value
 	}
 	if value, ok := asc.mutation.GetType(); ok {
@@ -254,7 +254,7 @@ func (asc *AchievementsSnapshotCreate) createSpec() (*AchievementsSnapshot, *sql
 		_node.Battles = value
 	}
 	if value, ok := asc.mutation.LastBattleTime(); ok {
-		_spec.SetField(achievementssnapshot.FieldLastBattleTime, field.TypeInt, value)
+		_spec.SetField(achievementssnapshot.FieldLastBattleTime, field.TypeInt64, value)
 		_node.LastBattleTime = value
 	}
 	if value, ok := asc.mutation.Data(); ok {
diff --git a/internal/database/ent/db/achievementssnapshot_query.go b/internal/database/ent/db/achievementssnapshot_query.go
index fed3275c..fa60ab7f 100644
--- a/internal/database/ent/db/achievementssnapshot_query.go
+++ b/internal/database/ent/db/achievementssnapshot_query.go
@@ -297,7 +297,7 @@ func (asq *AchievementsSnapshotQuery) WithAccount(opts ...func(*AccountQuery)) *
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int `json:"created_at,omitempty"`
+//		CreatedAt int64 `json:"created_at,omitempty"`
 //		Count int `json:"count,omitempty"`
 //	}
 //
@@ -320,7 +320,7 @@ func (asq *AchievementsSnapshotQuery) GroupBy(field string, fields ...string) *A
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int `json:"created_at,omitempty"`
+//		CreatedAt int64 `json:"created_at,omitempty"`
 //	}
 //
 //	client.AchievementsSnapshot.Query().
diff --git a/internal/database/ent/db/achievementssnapshot_update.go b/internal/database/ent/db/achievementssnapshot_update.go
index 10f05608..834089c4 100644
--- a/internal/database/ent/db/achievementssnapshot_update.go
+++ b/internal/database/ent/db/achievementssnapshot_update.go
@@ -30,14 +30,14 @@ func (asu *AchievementsSnapshotUpdate) Where(ps ...predicate.AchievementsSnapsho
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (asu *AchievementsSnapshotUpdate) SetUpdatedAt(i int) *AchievementsSnapshotUpdate {
+func (asu *AchievementsSnapshotUpdate) SetUpdatedAt(i int64) *AchievementsSnapshotUpdate {
 	asu.mutation.ResetUpdatedAt()
 	asu.mutation.SetUpdatedAt(i)
 	return asu
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (asu *AchievementsSnapshotUpdate) AddUpdatedAt(i int) *AchievementsSnapshotUpdate {
+func (asu *AchievementsSnapshotUpdate) AddUpdatedAt(i int64) *AchievementsSnapshotUpdate {
 	asu.mutation.AddUpdatedAt(i)
 	return asu
 }
@@ -92,14 +92,14 @@ func (asu *AchievementsSnapshotUpdate) AddBattles(i int) *AchievementsSnapshotUp
 }
 
 // SetLastBattleTime sets the "last_battle_time" field.
-func (asu *AchievementsSnapshotUpdate) SetLastBattleTime(i int) *AchievementsSnapshotUpdate {
+func (asu *AchievementsSnapshotUpdate) SetLastBattleTime(i int64) *AchievementsSnapshotUpdate {
 	asu.mutation.ResetLastBattleTime()
 	asu.mutation.SetLastBattleTime(i)
 	return asu
 }
 
 // SetNillableLastBattleTime sets the "last_battle_time" field if the given value is not nil.
-func (asu *AchievementsSnapshotUpdate) SetNillableLastBattleTime(i *int) *AchievementsSnapshotUpdate {
+func (asu *AchievementsSnapshotUpdate) SetNillableLastBattleTime(i *int64) *AchievementsSnapshotUpdate {
 	if i != nil {
 		asu.SetLastBattleTime(*i)
 	}
@@ -107,7 +107,7 @@ func (asu *AchievementsSnapshotUpdate) SetNillableLastBattleTime(i *int) *Achiev
 }
 
 // AddLastBattleTime adds i to the "last_battle_time" field.
-func (asu *AchievementsSnapshotUpdate) AddLastBattleTime(i int) *AchievementsSnapshotUpdate {
+func (asu *AchievementsSnapshotUpdate) AddLastBattleTime(i int64) *AchievementsSnapshotUpdate {
 	asu.mutation.AddLastBattleTime(i)
 	return asu
 }
@@ -198,10 +198,10 @@ func (asu *AchievementsSnapshotUpdate) sqlSave(ctx context.Context) (n int, err
 		}
 	}
 	if value, ok := asu.mutation.UpdatedAt(); ok {
-		_spec.SetField(achievementssnapshot.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(achievementssnapshot.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := asu.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(achievementssnapshot.FieldUpdatedAt, field.TypeInt, value)
+		_spec.AddField(achievementssnapshot.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := asu.mutation.GetType(); ok {
 		_spec.SetField(achievementssnapshot.FieldType, field.TypeEnum, value)
@@ -216,10 +216,10 @@ func (asu *AchievementsSnapshotUpdate) sqlSave(ctx context.Context) (n int, err
 		_spec.AddField(achievementssnapshot.FieldBattles, field.TypeInt, value)
 	}
 	if value, ok := asu.mutation.LastBattleTime(); ok {
-		_spec.SetField(achievementssnapshot.FieldLastBattleTime, field.TypeInt, value)
+		_spec.SetField(achievementssnapshot.FieldLastBattleTime, field.TypeInt64, value)
 	}
 	if value, ok := asu.mutation.AddedLastBattleTime(); ok {
-		_spec.AddField(achievementssnapshot.FieldLastBattleTime, field.TypeInt, value)
+		_spec.AddField(achievementssnapshot.FieldLastBattleTime, field.TypeInt64, value)
 	}
 	if value, ok := asu.mutation.Data(); ok {
 		_spec.SetField(achievementssnapshot.FieldData, field.TypeJSON, value)
@@ -245,14 +245,14 @@ type AchievementsSnapshotUpdateOne struct {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (asuo *AchievementsSnapshotUpdateOne) SetUpdatedAt(i int) *AchievementsSnapshotUpdateOne {
+func (asuo *AchievementsSnapshotUpdateOne) SetUpdatedAt(i int64) *AchievementsSnapshotUpdateOne {
 	asuo.mutation.ResetUpdatedAt()
 	asuo.mutation.SetUpdatedAt(i)
 	return asuo
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (asuo *AchievementsSnapshotUpdateOne) AddUpdatedAt(i int) *AchievementsSnapshotUpdateOne {
+func (asuo *AchievementsSnapshotUpdateOne) AddUpdatedAt(i int64) *AchievementsSnapshotUpdateOne {
 	asuo.mutation.AddUpdatedAt(i)
 	return asuo
 }
@@ -307,14 +307,14 @@ func (asuo *AchievementsSnapshotUpdateOne) AddBattles(i int) *AchievementsSnapsh
 }
 
 // SetLastBattleTime sets the "last_battle_time" field.
-func (asuo *AchievementsSnapshotUpdateOne) SetLastBattleTime(i int) *AchievementsSnapshotUpdateOne {
+func (asuo *AchievementsSnapshotUpdateOne) SetLastBattleTime(i int64) *AchievementsSnapshotUpdateOne {
 	asuo.mutation.ResetLastBattleTime()
 	asuo.mutation.SetLastBattleTime(i)
 	return asuo
 }
 
 // SetNillableLastBattleTime sets the "last_battle_time" field if the given value is not nil.
-func (asuo *AchievementsSnapshotUpdateOne) SetNillableLastBattleTime(i *int) *AchievementsSnapshotUpdateOne {
+func (asuo *AchievementsSnapshotUpdateOne) SetNillableLastBattleTime(i *int64) *AchievementsSnapshotUpdateOne {
 	if i != nil {
 		asuo.SetLastBattleTime(*i)
 	}
@@ -322,7 +322,7 @@ func (asuo *AchievementsSnapshotUpdateOne) SetNillableLastBattleTime(i *int) *Ac
 }
 
 // AddLastBattleTime adds i to the "last_battle_time" field.
-func (asuo *AchievementsSnapshotUpdateOne) AddLastBattleTime(i int) *AchievementsSnapshotUpdateOne {
+func (asuo *AchievementsSnapshotUpdateOne) AddLastBattleTime(i int64) *AchievementsSnapshotUpdateOne {
 	asuo.mutation.AddLastBattleTime(i)
 	return asuo
 }
@@ -443,10 +443,10 @@ func (asuo *AchievementsSnapshotUpdateOne) sqlSave(ctx context.Context) (_node *
 		}
 	}
 	if value, ok := asuo.mutation.UpdatedAt(); ok {
-		_spec.SetField(achievementssnapshot.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(achievementssnapshot.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := asuo.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(achievementssnapshot.FieldUpdatedAt, field.TypeInt, value)
+		_spec.AddField(achievementssnapshot.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := asuo.mutation.GetType(); ok {
 		_spec.SetField(achievementssnapshot.FieldType, field.TypeEnum, value)
@@ -461,10 +461,10 @@ func (asuo *AchievementsSnapshotUpdateOne) sqlSave(ctx context.Context) (_node *
 		_spec.AddField(achievementssnapshot.FieldBattles, field.TypeInt, value)
 	}
 	if value, ok := asuo.mutation.LastBattleTime(); ok {
-		_spec.SetField(achievementssnapshot.FieldLastBattleTime, field.TypeInt, value)
+		_spec.SetField(achievementssnapshot.FieldLastBattleTime, field.TypeInt64, value)
 	}
 	if value, ok := asuo.mutation.AddedLastBattleTime(); ok {
-		_spec.AddField(achievementssnapshot.FieldLastBattleTime, field.TypeInt, value)
+		_spec.AddField(achievementssnapshot.FieldLastBattleTime, field.TypeInt64, value)
 	}
 	if value, ok := asuo.mutation.Data(); ok {
 		_spec.SetField(achievementssnapshot.FieldData, field.TypeJSON, value)
diff --git a/internal/database/ent/db/appconfiguration.go b/internal/database/ent/db/appconfiguration.go
index 8dbdef16..5aaf0eb8 100644
--- a/internal/database/ent/db/appconfiguration.go
+++ b/internal/database/ent/db/appconfiguration.go
@@ -18,9 +18,9 @@ type AppConfiguration struct {
 	// ID of the ent.
 	ID string `json:"id,omitempty"`
 	// CreatedAt holds the value of the "created_at" field.
-	CreatedAt int `json:"created_at,omitempty"`
+	CreatedAt int64 `json:"created_at,omitempty"`
 	// UpdatedAt holds the value of the "updated_at" field.
-	UpdatedAt int `json:"updated_at,omitempty"`
+	UpdatedAt int64 `json:"updated_at,omitempty"`
 	// Key holds the value of the "key" field.
 	Key string `json:"key,omitempty"`
 	// Value holds the value of the "value" field.
@@ -66,13 +66,13 @@ func (ac *AppConfiguration) assignValues(columns []string, values []any) error {
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field created_at", values[i])
 			} else if value.Valid {
-				ac.CreatedAt = int(value.Int64)
+				ac.CreatedAt = value.Int64
 			}
 		case appconfiguration.FieldUpdatedAt:
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
 			} else if value.Valid {
-				ac.UpdatedAt = int(value.Int64)
+				ac.UpdatedAt = value.Int64
 			}
 		case appconfiguration.FieldKey:
 			if value, ok := values[i].(*sql.NullString); !ok {
diff --git a/internal/database/ent/db/appconfiguration/appconfiguration.go b/internal/database/ent/db/appconfiguration/appconfiguration.go
index 02f8ba48..facffdce 100644
--- a/internal/database/ent/db/appconfiguration/appconfiguration.go
+++ b/internal/database/ent/db/appconfiguration/appconfiguration.go
@@ -47,11 +47,11 @@ func ValidColumn(column string) bool {
 
 var (
 	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
-	DefaultCreatedAt func() int
+	DefaultCreatedAt func() int64
 	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
-	DefaultUpdatedAt func() int
+	DefaultUpdatedAt func() int64
 	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
-	UpdateDefaultUpdatedAt func() int
+	UpdateDefaultUpdatedAt func() int64
 	// KeyValidator is a validator for the "key" field. It is called by the builders before save.
 	KeyValidator func(string) error
 	// DefaultID holds the default value on creation for the "id" field.
diff --git a/internal/database/ent/db/appconfiguration/where.go b/internal/database/ent/db/appconfiguration/where.go
index ffb17f2d..6d63474c 100644
--- a/internal/database/ent/db/appconfiguration/where.go
+++ b/internal/database/ent/db/appconfiguration/where.go
@@ -63,12 +63,12 @@ func IDContainsFold(id string) predicate.AppConfiguration {
 }
 
 // CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
-func CreatedAt(v int) predicate.AppConfiguration {
+func CreatedAt(v int64) predicate.AppConfiguration {
 	return predicate.AppConfiguration(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
-func UpdatedAt(v int) predicate.AppConfiguration {
+func UpdatedAt(v int64) predicate.AppConfiguration {
 	return predicate.AppConfiguration(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
@@ -78,82 +78,82 @@ func Key(v string) predicate.AppConfiguration {
 }
 
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v int) predicate.AppConfiguration {
+func CreatedAtEQ(v int64) predicate.AppConfiguration {
 	return predicate.AppConfiguration(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v int) predicate.AppConfiguration {
+func CreatedAtNEQ(v int64) predicate.AppConfiguration {
 	return predicate.AppConfiguration(sql.FieldNEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...int) predicate.AppConfiguration {
+func CreatedAtIn(vs ...int64) predicate.AppConfiguration {
 	return predicate.AppConfiguration(sql.FieldIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...int) predicate.AppConfiguration {
+func CreatedAtNotIn(vs ...int64) predicate.AppConfiguration {
 	return predicate.AppConfiguration(sql.FieldNotIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v int) predicate.AppConfiguration {
+func CreatedAtGT(v int64) predicate.AppConfiguration {
 	return predicate.AppConfiguration(sql.FieldGT(FieldCreatedAt, v))
 }
 
 // CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v int) predicate.AppConfiguration {
+func CreatedAtGTE(v int64) predicate.AppConfiguration {
 	return predicate.AppConfiguration(sql.FieldGTE(FieldCreatedAt, v))
 }
 
 // CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v int) predicate.AppConfiguration {
+func CreatedAtLT(v int64) predicate.AppConfiguration {
 	return predicate.AppConfiguration(sql.FieldLT(FieldCreatedAt, v))
 }
 
 // CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v int) predicate.AppConfiguration {
+func CreatedAtLTE(v int64) predicate.AppConfiguration {
 	return predicate.AppConfiguration(sql.FieldLTE(FieldCreatedAt, v))
 }
 
 // UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
-func UpdatedAtEQ(v int) predicate.AppConfiguration {
+func UpdatedAtEQ(v int64) predicate.AppConfiguration {
 	return predicate.AppConfiguration(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
-func UpdatedAtNEQ(v int) predicate.AppConfiguration {
+func UpdatedAtNEQ(v int64) predicate.AppConfiguration {
 	return predicate.AppConfiguration(sql.FieldNEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtIn applies the In predicate on the "updated_at" field.
-func UpdatedAtIn(vs ...int) predicate.AppConfiguration {
+func UpdatedAtIn(vs ...int64) predicate.AppConfiguration {
 	return predicate.AppConfiguration(sql.FieldIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
-func UpdatedAtNotIn(vs ...int) predicate.AppConfiguration {
+func UpdatedAtNotIn(vs ...int64) predicate.AppConfiguration {
 	return predicate.AppConfiguration(sql.FieldNotIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtGT applies the GT predicate on the "updated_at" field.
-func UpdatedAtGT(v int) predicate.AppConfiguration {
+func UpdatedAtGT(v int64) predicate.AppConfiguration {
 	return predicate.AppConfiguration(sql.FieldGT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
-func UpdatedAtGTE(v int) predicate.AppConfiguration {
+func UpdatedAtGTE(v int64) predicate.AppConfiguration {
 	return predicate.AppConfiguration(sql.FieldGTE(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLT applies the LT predicate on the "updated_at" field.
-func UpdatedAtLT(v int) predicate.AppConfiguration {
+func UpdatedAtLT(v int64) predicate.AppConfiguration {
 	return predicate.AppConfiguration(sql.FieldLT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
-func UpdatedAtLTE(v int) predicate.AppConfiguration {
+func UpdatedAtLTE(v int64) predicate.AppConfiguration {
 	return predicate.AppConfiguration(sql.FieldLTE(FieldUpdatedAt, v))
 }
 
diff --git a/internal/database/ent/db/appconfiguration_create.go b/internal/database/ent/db/appconfiguration_create.go
index 2cf22a7b..c6a9c349 100644
--- a/internal/database/ent/db/appconfiguration_create.go
+++ b/internal/database/ent/db/appconfiguration_create.go
@@ -20,13 +20,13 @@ type AppConfigurationCreate struct {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (acc *AppConfigurationCreate) SetCreatedAt(i int) *AppConfigurationCreate {
+func (acc *AppConfigurationCreate) SetCreatedAt(i int64) *AppConfigurationCreate {
 	acc.mutation.SetCreatedAt(i)
 	return acc
 }
 
 // SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
-func (acc *AppConfigurationCreate) SetNillableCreatedAt(i *int) *AppConfigurationCreate {
+func (acc *AppConfigurationCreate) SetNillableCreatedAt(i *int64) *AppConfigurationCreate {
 	if i != nil {
 		acc.SetCreatedAt(*i)
 	}
@@ -34,13 +34,13 @@ func (acc *AppConfigurationCreate) SetNillableCreatedAt(i *int) *AppConfiguratio
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (acc *AppConfigurationCreate) SetUpdatedAt(i int) *AppConfigurationCreate {
+func (acc *AppConfigurationCreate) SetUpdatedAt(i int64) *AppConfigurationCreate {
 	acc.mutation.SetUpdatedAt(i)
 	return acc
 }
 
 // SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
-func (acc *AppConfigurationCreate) SetNillableUpdatedAt(i *int) *AppConfigurationCreate {
+func (acc *AppConfigurationCreate) SetNillableUpdatedAt(i *int64) *AppConfigurationCreate {
 	if i != nil {
 		acc.SetUpdatedAt(*i)
 	}
@@ -183,11 +183,11 @@ func (acc *AppConfigurationCreate) createSpec() (*AppConfiguration, *sqlgraph.Cr
 		_spec.ID.Value = id
 	}
 	if value, ok := acc.mutation.CreatedAt(); ok {
-		_spec.SetField(appconfiguration.FieldCreatedAt, field.TypeInt, value)
+		_spec.SetField(appconfiguration.FieldCreatedAt, field.TypeInt64, value)
 		_node.CreatedAt = value
 	}
 	if value, ok := acc.mutation.UpdatedAt(); ok {
-		_spec.SetField(appconfiguration.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(appconfiguration.FieldUpdatedAt, field.TypeInt64, value)
 		_node.UpdatedAt = value
 	}
 	if value, ok := acc.mutation.Key(); ok {
diff --git a/internal/database/ent/db/appconfiguration_query.go b/internal/database/ent/db/appconfiguration_query.go
index 549a21e4..759954bb 100644
--- a/internal/database/ent/db/appconfiguration_query.go
+++ b/internal/database/ent/db/appconfiguration_query.go
@@ -261,7 +261,7 @@ func (acq *AppConfigurationQuery) Clone() *AppConfigurationQuery {
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int `json:"created_at,omitempty"`
+//		CreatedAt int64 `json:"created_at,omitempty"`
 //		Count int `json:"count,omitempty"`
 //	}
 //
@@ -284,7 +284,7 @@ func (acq *AppConfigurationQuery) GroupBy(field string, fields ...string) *AppCo
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int `json:"created_at,omitempty"`
+//		CreatedAt int64 `json:"created_at,omitempty"`
 //	}
 //
 //	client.AppConfiguration.Query().
diff --git a/internal/database/ent/db/appconfiguration_update.go b/internal/database/ent/db/appconfiguration_update.go
index 168e52c4..12994e32 100644
--- a/internal/database/ent/db/appconfiguration_update.go
+++ b/internal/database/ent/db/appconfiguration_update.go
@@ -28,14 +28,14 @@ func (acu *AppConfigurationUpdate) Where(ps ...predicate.AppConfiguration) *AppC
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (acu *AppConfigurationUpdate) SetUpdatedAt(i int) *AppConfigurationUpdate {
+func (acu *AppConfigurationUpdate) SetUpdatedAt(i int64) *AppConfigurationUpdate {
 	acu.mutation.ResetUpdatedAt()
 	acu.mutation.SetUpdatedAt(i)
 	return acu
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (acu *AppConfigurationUpdate) AddUpdatedAt(i int) *AppConfigurationUpdate {
+func (acu *AppConfigurationUpdate) AddUpdatedAt(i int64) *AppConfigurationUpdate {
 	acu.mutation.AddUpdatedAt(i)
 	return acu
 }
@@ -136,10 +136,10 @@ func (acu *AppConfigurationUpdate) sqlSave(ctx context.Context) (n int, err erro
 		}
 	}
 	if value, ok := acu.mutation.UpdatedAt(); ok {
-		_spec.SetField(appconfiguration.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(appconfiguration.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := acu.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(appconfiguration.FieldUpdatedAt, field.TypeInt, value)
+		_spec.AddField(appconfiguration.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := acu.mutation.Key(); ok {
 		_spec.SetField(appconfiguration.FieldKey, field.TypeString, value)
@@ -174,14 +174,14 @@ type AppConfigurationUpdateOne struct {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (acuo *AppConfigurationUpdateOne) SetUpdatedAt(i int) *AppConfigurationUpdateOne {
+func (acuo *AppConfigurationUpdateOne) SetUpdatedAt(i int64) *AppConfigurationUpdateOne {
 	acuo.mutation.ResetUpdatedAt()
 	acuo.mutation.SetUpdatedAt(i)
 	return acuo
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (acuo *AppConfigurationUpdateOne) AddUpdatedAt(i int) *AppConfigurationUpdateOne {
+func (acuo *AppConfigurationUpdateOne) AddUpdatedAt(i int64) *AppConfigurationUpdateOne {
 	acuo.mutation.AddUpdatedAt(i)
 	return acuo
 }
@@ -312,10 +312,10 @@ func (acuo *AppConfigurationUpdateOne) sqlSave(ctx context.Context) (_node *AppC
 		}
 	}
 	if value, ok := acuo.mutation.UpdatedAt(); ok {
-		_spec.SetField(appconfiguration.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(appconfiguration.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := acuo.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(appconfiguration.FieldUpdatedAt, field.TypeInt, value)
+		_spec.AddField(appconfiguration.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := acuo.mutation.Key(); ok {
 		_spec.SetField(appconfiguration.FieldKey, field.TypeString, value)
diff --git a/internal/database/ent/db/applicationcommand.go b/internal/database/ent/db/applicationcommand.go
index ea3626b9..0ba69869 100644
--- a/internal/database/ent/db/applicationcommand.go
+++ b/internal/database/ent/db/applicationcommand.go
@@ -17,9 +17,9 @@ type ApplicationCommand struct {
 	// ID of the ent.
 	ID string `json:"id,omitempty"`
 	// CreatedAt holds the value of the "created_at" field.
-	CreatedAt int `json:"created_at,omitempty"`
+	CreatedAt int64 `json:"created_at,omitempty"`
 	// UpdatedAt holds the value of the "updated_at" field.
-	UpdatedAt int `json:"updated_at,omitempty"`
+	UpdatedAt int64 `json:"updated_at,omitempty"`
 	// Name holds the value of the "name" field.
 	Name string `json:"name,omitempty"`
 	// Version holds the value of the "version" field.
@@ -63,13 +63,13 @@ func (ac *ApplicationCommand) assignValues(columns []string, values []any) error
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field created_at", values[i])
 			} else if value.Valid {
-				ac.CreatedAt = int(value.Int64)
+				ac.CreatedAt = value.Int64
 			}
 		case applicationcommand.FieldUpdatedAt:
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
 			} else if value.Valid {
-				ac.UpdatedAt = int(value.Int64)
+				ac.UpdatedAt = value.Int64
 			}
 		case applicationcommand.FieldName:
 			if value, ok := values[i].(*sql.NullString); !ok {
diff --git a/internal/database/ent/db/applicationcommand/applicationcommand.go b/internal/database/ent/db/applicationcommand/applicationcommand.go
index 6860891e..4e67599d 100644
--- a/internal/database/ent/db/applicationcommand/applicationcommand.go
+++ b/internal/database/ent/db/applicationcommand/applicationcommand.go
@@ -47,11 +47,11 @@ func ValidColumn(column string) bool {
 
 var (
 	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
-	DefaultCreatedAt func() int
+	DefaultCreatedAt func() int64
 	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
-	DefaultUpdatedAt func() int
+	DefaultUpdatedAt func() int64
 	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
-	UpdateDefaultUpdatedAt func() int
+	UpdateDefaultUpdatedAt func() int64
 	// NameValidator is a validator for the "name" field. It is called by the builders before save.
 	NameValidator func(string) error
 	// VersionValidator is a validator for the "version" field. It is called by the builders before save.
diff --git a/internal/database/ent/db/applicationcommand/where.go b/internal/database/ent/db/applicationcommand/where.go
index d281b98f..81486987 100644
--- a/internal/database/ent/db/applicationcommand/where.go
+++ b/internal/database/ent/db/applicationcommand/where.go
@@ -63,12 +63,12 @@ func IDContainsFold(id string) predicate.ApplicationCommand {
 }
 
 // CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
-func CreatedAt(v int) predicate.ApplicationCommand {
+func CreatedAt(v int64) predicate.ApplicationCommand {
 	return predicate.ApplicationCommand(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
-func UpdatedAt(v int) predicate.ApplicationCommand {
+func UpdatedAt(v int64) predicate.ApplicationCommand {
 	return predicate.ApplicationCommand(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
@@ -88,82 +88,82 @@ func OptionsHash(v string) predicate.ApplicationCommand {
 }
 
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v int) predicate.ApplicationCommand {
+func CreatedAtEQ(v int64) predicate.ApplicationCommand {
 	return predicate.ApplicationCommand(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v int) predicate.ApplicationCommand {
+func CreatedAtNEQ(v int64) predicate.ApplicationCommand {
 	return predicate.ApplicationCommand(sql.FieldNEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...int) predicate.ApplicationCommand {
+func CreatedAtIn(vs ...int64) predicate.ApplicationCommand {
 	return predicate.ApplicationCommand(sql.FieldIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...int) predicate.ApplicationCommand {
+func CreatedAtNotIn(vs ...int64) predicate.ApplicationCommand {
 	return predicate.ApplicationCommand(sql.FieldNotIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v int) predicate.ApplicationCommand {
+func CreatedAtGT(v int64) predicate.ApplicationCommand {
 	return predicate.ApplicationCommand(sql.FieldGT(FieldCreatedAt, v))
 }
 
 // CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v int) predicate.ApplicationCommand {
+func CreatedAtGTE(v int64) predicate.ApplicationCommand {
 	return predicate.ApplicationCommand(sql.FieldGTE(FieldCreatedAt, v))
 }
 
 // CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v int) predicate.ApplicationCommand {
+func CreatedAtLT(v int64) predicate.ApplicationCommand {
 	return predicate.ApplicationCommand(sql.FieldLT(FieldCreatedAt, v))
 }
 
 // CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v int) predicate.ApplicationCommand {
+func CreatedAtLTE(v int64) predicate.ApplicationCommand {
 	return predicate.ApplicationCommand(sql.FieldLTE(FieldCreatedAt, v))
 }
 
 // UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
-func UpdatedAtEQ(v int) predicate.ApplicationCommand {
+func UpdatedAtEQ(v int64) predicate.ApplicationCommand {
 	return predicate.ApplicationCommand(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
-func UpdatedAtNEQ(v int) predicate.ApplicationCommand {
+func UpdatedAtNEQ(v int64) predicate.ApplicationCommand {
 	return predicate.ApplicationCommand(sql.FieldNEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtIn applies the In predicate on the "updated_at" field.
-func UpdatedAtIn(vs ...int) predicate.ApplicationCommand {
+func UpdatedAtIn(vs ...int64) predicate.ApplicationCommand {
 	return predicate.ApplicationCommand(sql.FieldIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
-func UpdatedAtNotIn(vs ...int) predicate.ApplicationCommand {
+func UpdatedAtNotIn(vs ...int64) predicate.ApplicationCommand {
 	return predicate.ApplicationCommand(sql.FieldNotIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtGT applies the GT predicate on the "updated_at" field.
-func UpdatedAtGT(v int) predicate.ApplicationCommand {
+func UpdatedAtGT(v int64) predicate.ApplicationCommand {
 	return predicate.ApplicationCommand(sql.FieldGT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
-func UpdatedAtGTE(v int) predicate.ApplicationCommand {
+func UpdatedAtGTE(v int64) predicate.ApplicationCommand {
 	return predicate.ApplicationCommand(sql.FieldGTE(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLT applies the LT predicate on the "updated_at" field.
-func UpdatedAtLT(v int) predicate.ApplicationCommand {
+func UpdatedAtLT(v int64) predicate.ApplicationCommand {
 	return predicate.ApplicationCommand(sql.FieldLT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
-func UpdatedAtLTE(v int) predicate.ApplicationCommand {
+func UpdatedAtLTE(v int64) predicate.ApplicationCommand {
 	return predicate.ApplicationCommand(sql.FieldLTE(FieldUpdatedAt, v))
 }
 
diff --git a/internal/database/ent/db/applicationcommand_create.go b/internal/database/ent/db/applicationcommand_create.go
index 14f3abb9..830a457d 100644
--- a/internal/database/ent/db/applicationcommand_create.go
+++ b/internal/database/ent/db/applicationcommand_create.go
@@ -20,13 +20,13 @@ type ApplicationCommandCreate struct {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (acc *ApplicationCommandCreate) SetCreatedAt(i int) *ApplicationCommandCreate {
+func (acc *ApplicationCommandCreate) SetCreatedAt(i int64) *ApplicationCommandCreate {
 	acc.mutation.SetCreatedAt(i)
 	return acc
 }
 
 // SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
-func (acc *ApplicationCommandCreate) SetNillableCreatedAt(i *int) *ApplicationCommandCreate {
+func (acc *ApplicationCommandCreate) SetNillableCreatedAt(i *int64) *ApplicationCommandCreate {
 	if i != nil {
 		acc.SetCreatedAt(*i)
 	}
@@ -34,13 +34,13 @@ func (acc *ApplicationCommandCreate) SetNillableCreatedAt(i *int) *ApplicationCo
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (acc *ApplicationCommandCreate) SetUpdatedAt(i int) *ApplicationCommandCreate {
+func (acc *ApplicationCommandCreate) SetUpdatedAt(i int64) *ApplicationCommandCreate {
 	acc.mutation.SetUpdatedAt(i)
 	return acc
 }
 
 // SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
-func (acc *ApplicationCommandCreate) SetNillableUpdatedAt(i *int) *ApplicationCommandCreate {
+func (acc *ApplicationCommandCreate) SetNillableUpdatedAt(i *int64) *ApplicationCommandCreate {
 	if i != nil {
 		acc.SetUpdatedAt(*i)
 	}
@@ -196,11 +196,11 @@ func (acc *ApplicationCommandCreate) createSpec() (*ApplicationCommand, *sqlgrap
 		_spec.ID.Value = id
 	}
 	if value, ok := acc.mutation.CreatedAt(); ok {
-		_spec.SetField(applicationcommand.FieldCreatedAt, field.TypeInt, value)
+		_spec.SetField(applicationcommand.FieldCreatedAt, field.TypeInt64, value)
 		_node.CreatedAt = value
 	}
 	if value, ok := acc.mutation.UpdatedAt(); ok {
-		_spec.SetField(applicationcommand.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(applicationcommand.FieldUpdatedAt, field.TypeInt64, value)
 		_node.UpdatedAt = value
 	}
 	if value, ok := acc.mutation.Name(); ok {
diff --git a/internal/database/ent/db/applicationcommand_query.go b/internal/database/ent/db/applicationcommand_query.go
index 5c45967e..5bd7757c 100644
--- a/internal/database/ent/db/applicationcommand_query.go
+++ b/internal/database/ent/db/applicationcommand_query.go
@@ -261,7 +261,7 @@ func (acq *ApplicationCommandQuery) Clone() *ApplicationCommandQuery {
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int `json:"created_at,omitempty"`
+//		CreatedAt int64 `json:"created_at,omitempty"`
 //		Count int `json:"count,omitempty"`
 //	}
 //
@@ -284,7 +284,7 @@ func (acq *ApplicationCommandQuery) GroupBy(field string, fields ...string) *App
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int `json:"created_at,omitempty"`
+//		CreatedAt int64 `json:"created_at,omitempty"`
 //	}
 //
 //	client.ApplicationCommand.Query().
diff --git a/internal/database/ent/db/applicationcommand_update.go b/internal/database/ent/db/applicationcommand_update.go
index ebdf0db2..f681b841 100644
--- a/internal/database/ent/db/applicationcommand_update.go
+++ b/internal/database/ent/db/applicationcommand_update.go
@@ -28,14 +28,14 @@ func (acu *ApplicationCommandUpdate) Where(ps ...predicate.ApplicationCommand) *
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (acu *ApplicationCommandUpdate) SetUpdatedAt(i int) *ApplicationCommandUpdate {
+func (acu *ApplicationCommandUpdate) SetUpdatedAt(i int64) *ApplicationCommandUpdate {
 	acu.mutation.ResetUpdatedAt()
 	acu.mutation.SetUpdatedAt(i)
 	return acu
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (acu *ApplicationCommandUpdate) AddUpdatedAt(i int) *ApplicationCommandUpdate {
+func (acu *ApplicationCommandUpdate) AddUpdatedAt(i int64) *ApplicationCommandUpdate {
 	acu.mutation.AddUpdatedAt(i)
 	return acu
 }
@@ -156,10 +156,10 @@ func (acu *ApplicationCommandUpdate) sqlSave(ctx context.Context) (n int, err er
 		}
 	}
 	if value, ok := acu.mutation.UpdatedAt(); ok {
-		_spec.SetField(applicationcommand.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(applicationcommand.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := acu.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(applicationcommand.FieldUpdatedAt, field.TypeInt, value)
+		_spec.AddField(applicationcommand.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := acu.mutation.Name(); ok {
 		_spec.SetField(applicationcommand.FieldName, field.TypeString, value)
@@ -191,14 +191,14 @@ type ApplicationCommandUpdateOne struct {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (acuo *ApplicationCommandUpdateOne) SetUpdatedAt(i int) *ApplicationCommandUpdateOne {
+func (acuo *ApplicationCommandUpdateOne) SetUpdatedAt(i int64) *ApplicationCommandUpdateOne {
 	acuo.mutation.ResetUpdatedAt()
 	acuo.mutation.SetUpdatedAt(i)
 	return acuo
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (acuo *ApplicationCommandUpdateOne) AddUpdatedAt(i int) *ApplicationCommandUpdateOne {
+func (acuo *ApplicationCommandUpdateOne) AddUpdatedAt(i int64) *ApplicationCommandUpdateOne {
 	acuo.mutation.AddUpdatedAt(i)
 	return acuo
 }
@@ -349,10 +349,10 @@ func (acuo *ApplicationCommandUpdateOne) sqlSave(ctx context.Context) (_node *Ap
 		}
 	}
 	if value, ok := acuo.mutation.UpdatedAt(); ok {
-		_spec.SetField(applicationcommand.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(applicationcommand.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := acuo.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(applicationcommand.FieldUpdatedAt, field.TypeInt, value)
+		_spec.AddField(applicationcommand.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := acuo.mutation.Name(); ok {
 		_spec.SetField(applicationcommand.FieldName, field.TypeString, value)
diff --git a/internal/database/ent/db/clan.go b/internal/database/ent/db/clan.go
index 98645aef..1f883f27 100644
--- a/internal/database/ent/db/clan.go
+++ b/internal/database/ent/db/clan.go
@@ -18,9 +18,9 @@ type Clan struct {
 	// ID of the ent.
 	ID string `json:"id,omitempty"`
 	// CreatedAt holds the value of the "created_at" field.
-	CreatedAt int `json:"created_at,omitempty"`
+	CreatedAt int64 `json:"created_at,omitempty"`
 	// UpdatedAt holds the value of the "updated_at" field.
-	UpdatedAt int `json:"updated_at,omitempty"`
+	UpdatedAt int64 `json:"updated_at,omitempty"`
 	// Tag holds the value of the "tag" field.
 	Tag string `json:"tag,omitempty"`
 	// Name holds the value of the "name" field.
@@ -89,13 +89,13 @@ func (c *Clan) assignValues(columns []string, values []any) error {
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field created_at", values[i])
 			} else if value.Valid {
-				c.CreatedAt = int(value.Int64)
+				c.CreatedAt = value.Int64
 			}
 		case clan.FieldUpdatedAt:
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
 			} else if value.Valid {
-				c.UpdatedAt = int(value.Int64)
+				c.UpdatedAt = value.Int64
 			}
 		case clan.FieldTag:
 			if value, ok := values[i].(*sql.NullString); !ok {
diff --git a/internal/database/ent/db/clan/clan.go b/internal/database/ent/db/clan/clan.go
index df17d622..59a2f6e0 100644
--- a/internal/database/ent/db/clan/clan.go
+++ b/internal/database/ent/db/clan/clan.go
@@ -60,11 +60,11 @@ func ValidColumn(column string) bool {
 
 var (
 	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
-	DefaultCreatedAt func() int
+	DefaultCreatedAt func() int64
 	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
-	DefaultUpdatedAt func() int
+	DefaultUpdatedAt func() int64
 	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
-	UpdateDefaultUpdatedAt func() int
+	UpdateDefaultUpdatedAt func() int64
 	// TagValidator is a validator for the "tag" field. It is called by the builders before save.
 	TagValidator func(string) error
 	// NameValidator is a validator for the "name" field. It is called by the builders before save.
diff --git a/internal/database/ent/db/clan/where.go b/internal/database/ent/db/clan/where.go
index c860dc4d..6ab4d8fe 100644
--- a/internal/database/ent/db/clan/where.go
+++ b/internal/database/ent/db/clan/where.go
@@ -64,12 +64,12 @@ func IDContainsFold(id string) predicate.Clan {
 }
 
 // CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
-func CreatedAt(v int) predicate.Clan {
+func CreatedAt(v int64) predicate.Clan {
 	return predicate.Clan(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
-func UpdatedAt(v int) predicate.Clan {
+func UpdatedAt(v int64) predicate.Clan {
 	return predicate.Clan(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
@@ -89,82 +89,82 @@ func EmblemID(v string) predicate.Clan {
 }
 
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v int) predicate.Clan {
+func CreatedAtEQ(v int64) predicate.Clan {
 	return predicate.Clan(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v int) predicate.Clan {
+func CreatedAtNEQ(v int64) predicate.Clan {
 	return predicate.Clan(sql.FieldNEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...int) predicate.Clan {
+func CreatedAtIn(vs ...int64) predicate.Clan {
 	return predicate.Clan(sql.FieldIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...int) predicate.Clan {
+func CreatedAtNotIn(vs ...int64) predicate.Clan {
 	return predicate.Clan(sql.FieldNotIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v int) predicate.Clan {
+func CreatedAtGT(v int64) predicate.Clan {
 	return predicate.Clan(sql.FieldGT(FieldCreatedAt, v))
 }
 
 // CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v int) predicate.Clan {
+func CreatedAtGTE(v int64) predicate.Clan {
 	return predicate.Clan(sql.FieldGTE(FieldCreatedAt, v))
 }
 
 // CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v int) predicate.Clan {
+func CreatedAtLT(v int64) predicate.Clan {
 	return predicate.Clan(sql.FieldLT(FieldCreatedAt, v))
 }
 
 // CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v int) predicate.Clan {
+func CreatedAtLTE(v int64) predicate.Clan {
 	return predicate.Clan(sql.FieldLTE(FieldCreatedAt, v))
 }
 
 // UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
-func UpdatedAtEQ(v int) predicate.Clan {
+func UpdatedAtEQ(v int64) predicate.Clan {
 	return predicate.Clan(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
-func UpdatedAtNEQ(v int) predicate.Clan {
+func UpdatedAtNEQ(v int64) predicate.Clan {
 	return predicate.Clan(sql.FieldNEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtIn applies the In predicate on the "updated_at" field.
-func UpdatedAtIn(vs ...int) predicate.Clan {
+func UpdatedAtIn(vs ...int64) predicate.Clan {
 	return predicate.Clan(sql.FieldIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
-func UpdatedAtNotIn(vs ...int) predicate.Clan {
+func UpdatedAtNotIn(vs ...int64) predicate.Clan {
 	return predicate.Clan(sql.FieldNotIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtGT applies the GT predicate on the "updated_at" field.
-func UpdatedAtGT(v int) predicate.Clan {
+func UpdatedAtGT(v int64) predicate.Clan {
 	return predicate.Clan(sql.FieldGT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
-func UpdatedAtGTE(v int) predicate.Clan {
+func UpdatedAtGTE(v int64) predicate.Clan {
 	return predicate.Clan(sql.FieldGTE(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLT applies the LT predicate on the "updated_at" field.
-func UpdatedAtLT(v int) predicate.Clan {
+func UpdatedAtLT(v int64) predicate.Clan {
 	return predicate.Clan(sql.FieldLT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
-func UpdatedAtLTE(v int) predicate.Clan {
+func UpdatedAtLTE(v int64) predicate.Clan {
 	return predicate.Clan(sql.FieldLTE(FieldUpdatedAt, v))
 }
 
diff --git a/internal/database/ent/db/clan_create.go b/internal/database/ent/db/clan_create.go
index fb96c54d..438f1f4d 100644
--- a/internal/database/ent/db/clan_create.go
+++ b/internal/database/ent/db/clan_create.go
@@ -21,13 +21,13 @@ type ClanCreate struct {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (cc *ClanCreate) SetCreatedAt(i int) *ClanCreate {
+func (cc *ClanCreate) SetCreatedAt(i int64) *ClanCreate {
 	cc.mutation.SetCreatedAt(i)
 	return cc
 }
 
 // SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
-func (cc *ClanCreate) SetNillableCreatedAt(i *int) *ClanCreate {
+func (cc *ClanCreate) SetNillableCreatedAt(i *int64) *ClanCreate {
 	if i != nil {
 		cc.SetCreatedAt(*i)
 	}
@@ -35,13 +35,13 @@ func (cc *ClanCreate) SetNillableCreatedAt(i *int) *ClanCreate {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (cc *ClanCreate) SetUpdatedAt(i int) *ClanCreate {
+func (cc *ClanCreate) SetUpdatedAt(i int64) *ClanCreate {
 	cc.mutation.SetUpdatedAt(i)
 	return cc
 }
 
 // SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
-func (cc *ClanCreate) SetNillableUpdatedAt(i *int) *ClanCreate {
+func (cc *ClanCreate) SetNillableUpdatedAt(i *int64) *ClanCreate {
 	if i != nil {
 		cc.SetUpdatedAt(*i)
 	}
@@ -213,11 +213,11 @@ func (cc *ClanCreate) createSpec() (*Clan, *sqlgraph.CreateSpec) {
 		_spec.ID.Value = id
 	}
 	if value, ok := cc.mutation.CreatedAt(); ok {
-		_spec.SetField(clan.FieldCreatedAt, field.TypeInt, value)
+		_spec.SetField(clan.FieldCreatedAt, field.TypeInt64, value)
 		_node.CreatedAt = value
 	}
 	if value, ok := cc.mutation.UpdatedAt(); ok {
-		_spec.SetField(clan.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(clan.FieldUpdatedAt, field.TypeInt64, value)
 		_node.UpdatedAt = value
 	}
 	if value, ok := cc.mutation.Tag(); ok {
diff --git a/internal/database/ent/db/clan_query.go b/internal/database/ent/db/clan_query.go
index 274928c5..76649a32 100644
--- a/internal/database/ent/db/clan_query.go
+++ b/internal/database/ent/db/clan_query.go
@@ -298,7 +298,7 @@ func (cq *ClanQuery) WithAccounts(opts ...func(*AccountQuery)) *ClanQuery {
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int `json:"created_at,omitempty"`
+//		CreatedAt int64 `json:"created_at,omitempty"`
 //		Count int `json:"count,omitempty"`
 //	}
 //
@@ -321,7 +321,7 @@ func (cq *ClanQuery) GroupBy(field string, fields ...string) *ClanGroupBy {
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int `json:"created_at,omitempty"`
+//		CreatedAt int64 `json:"created_at,omitempty"`
 //	}
 //
 //	client.Clan.Query().
diff --git a/internal/database/ent/db/clan_update.go b/internal/database/ent/db/clan_update.go
index 85b62c7a..8a5ae595 100644
--- a/internal/database/ent/db/clan_update.go
+++ b/internal/database/ent/db/clan_update.go
@@ -30,14 +30,14 @@ func (cu *ClanUpdate) Where(ps ...predicate.Clan) *ClanUpdate {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (cu *ClanUpdate) SetUpdatedAt(i int) *ClanUpdate {
+func (cu *ClanUpdate) SetUpdatedAt(i int64) *ClanUpdate {
 	cu.mutation.ResetUpdatedAt()
 	cu.mutation.SetUpdatedAt(i)
 	return cu
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (cu *ClanUpdate) AddUpdatedAt(i int) *ClanUpdate {
+func (cu *ClanUpdate) AddUpdatedAt(i int64) *ClanUpdate {
 	cu.mutation.AddUpdatedAt(i)
 	return cu
 }
@@ -207,10 +207,10 @@ func (cu *ClanUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 	}
 	if value, ok := cu.mutation.UpdatedAt(); ok {
-		_spec.SetField(clan.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(clan.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := cu.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(clan.FieldUpdatedAt, field.TypeInt, value)
+		_spec.AddField(clan.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := cu.mutation.Tag(); ok {
 		_spec.SetField(clan.FieldTag, field.TypeString, value)
@@ -298,14 +298,14 @@ type ClanUpdateOne struct {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (cuo *ClanUpdateOne) SetUpdatedAt(i int) *ClanUpdateOne {
+func (cuo *ClanUpdateOne) SetUpdatedAt(i int64) *ClanUpdateOne {
 	cuo.mutation.ResetUpdatedAt()
 	cuo.mutation.SetUpdatedAt(i)
 	return cuo
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (cuo *ClanUpdateOne) AddUpdatedAt(i int) *ClanUpdateOne {
+func (cuo *ClanUpdateOne) AddUpdatedAt(i int64) *ClanUpdateOne {
 	cuo.mutation.AddUpdatedAt(i)
 	return cuo
 }
@@ -505,10 +505,10 @@ func (cuo *ClanUpdateOne) sqlSave(ctx context.Context) (_node *Clan, err error)
 		}
 	}
 	if value, ok := cuo.mutation.UpdatedAt(); ok {
-		_spec.SetField(clan.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(clan.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := cuo.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(clan.FieldUpdatedAt, field.TypeInt, value)
+		_spec.AddField(clan.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := cuo.mutation.Tag(); ok {
 		_spec.SetField(clan.FieldTag, field.TypeString, value)
diff --git a/internal/database/ent/db/crontask.go b/internal/database/ent/db/crontask.go
index c7580c3c..c4ba99dd 100644
--- a/internal/database/ent/db/crontask.go
+++ b/internal/database/ent/db/crontask.go
@@ -19,21 +19,21 @@ type CronTask struct {
 	// ID of the ent.
 	ID string `json:"id,omitempty"`
 	// CreatedAt holds the value of the "created_at" field.
-	CreatedAt int `json:"created_at,omitempty"`
+	CreatedAt int64 `json:"created_at,omitempty"`
 	// UpdatedAt holds the value of the "updated_at" field.
-	UpdatedAt int `json:"updated_at,omitempty"`
+	UpdatedAt int64 `json:"updated_at,omitempty"`
 	// Type holds the value of the "type" field.
-	Type string `json:"type,omitempty"`
+	Type models.TaskType `json:"type,omitempty"`
 	// ReferenceID holds the value of the "reference_id" field.
 	ReferenceID string `json:"reference_id,omitempty"`
 	// Targets holds the value of the "targets" field.
 	Targets []string `json:"targets,omitempty"`
 	// Status holds the value of the "status" field.
-	Status string `json:"status,omitempty"`
+	Status models.TaskStatus `json:"status,omitempty"`
 	// ScheduledAfter holds the value of the "scheduled_after" field.
-	ScheduledAfter int `json:"scheduled_after,omitempty"`
+	ScheduledAfter int64 `json:"scheduled_after,omitempty"`
 	// LastRun holds the value of the "last_run" field.
-	LastRun int `json:"last_run,omitempty"`
+	LastRun int64 `json:"last_run,omitempty"`
 	// Logs holds the value of the "logs" field.
 	Logs []models.TaskLog `json:"logs,omitempty"`
 	// Data holds the value of the "data" field.
@@ -77,19 +77,19 @@ func (ct *CronTask) assignValues(columns []string, values []any) error {
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field created_at", values[i])
 			} else if value.Valid {
-				ct.CreatedAt = int(value.Int64)
+				ct.CreatedAt = value.Int64
 			}
 		case crontask.FieldUpdatedAt:
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
 			} else if value.Valid {
-				ct.UpdatedAt = int(value.Int64)
+				ct.UpdatedAt = value.Int64
 			}
 		case crontask.FieldType:
 			if value, ok := values[i].(*sql.NullString); !ok {
 				return fmt.Errorf("unexpected type %T for field type", values[i])
 			} else if value.Valid {
-				ct.Type = value.String
+				ct.Type = models.TaskType(value.String)
 			}
 		case crontask.FieldReferenceID:
 			if value, ok := values[i].(*sql.NullString); !ok {
@@ -109,19 +109,19 @@ func (ct *CronTask) assignValues(columns []string, values []any) error {
 			if value, ok := values[i].(*sql.NullString); !ok {
 				return fmt.Errorf("unexpected type %T for field status", values[i])
 			} else if value.Valid {
-				ct.Status = value.String
+				ct.Status = models.TaskStatus(value.String)
 			}
 		case crontask.FieldScheduledAfter:
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field scheduled_after", values[i])
 			} else if value.Valid {
-				ct.ScheduledAfter = int(value.Int64)
+				ct.ScheduledAfter = value.Int64
 			}
 		case crontask.FieldLastRun:
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field last_run", values[i])
 			} else if value.Valid {
-				ct.LastRun = int(value.Int64)
+				ct.LastRun = value.Int64
 			}
 		case crontask.FieldLogs:
 			if value, ok := values[i].(*[]byte); !ok {
@@ -182,7 +182,7 @@ func (ct *CronTask) String() string {
 	builder.WriteString(fmt.Sprintf("%v", ct.UpdatedAt))
 	builder.WriteString(", ")
 	builder.WriteString("type=")
-	builder.WriteString(ct.Type)
+	builder.WriteString(fmt.Sprintf("%v", ct.Type))
 	builder.WriteString(", ")
 	builder.WriteString("reference_id=")
 	builder.WriteString(ct.ReferenceID)
@@ -191,7 +191,7 @@ func (ct *CronTask) String() string {
 	builder.WriteString(fmt.Sprintf("%v", ct.Targets))
 	builder.WriteString(", ")
 	builder.WriteString("status=")
-	builder.WriteString(ct.Status)
+	builder.WriteString(fmt.Sprintf("%v", ct.Status))
 	builder.WriteString(", ")
 	builder.WriteString("scheduled_after=")
 	builder.WriteString(fmt.Sprintf("%v", ct.ScheduledAfter))
diff --git a/internal/database/ent/db/crontask/crontask.go b/internal/database/ent/db/crontask/crontask.go
index eec007e1..f3ba2093 100644
--- a/internal/database/ent/db/crontask/crontask.go
+++ b/internal/database/ent/db/crontask/crontask.go
@@ -3,7 +3,10 @@
 package crontask
 
 import (
+	"fmt"
+
 	"entgo.io/ent/dialect/sql"
+	"github.com/cufee/aftermath/internal/database/models"
 )
 
 const (
@@ -62,21 +65,37 @@ func ValidColumn(column string) bool {
 
 var (
 	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
-	DefaultCreatedAt func() int
+	DefaultCreatedAt func() int64
 	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
-	DefaultUpdatedAt func() int
+	DefaultUpdatedAt func() int64
 	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
-	UpdateDefaultUpdatedAt func() int
-	// TypeValidator is a validator for the "type" field. It is called by the builders before save.
-	TypeValidator func(string) error
+	UpdateDefaultUpdatedAt func() int64
 	// ReferenceIDValidator is a validator for the "reference_id" field. It is called by the builders before save.
 	ReferenceIDValidator func(string) error
-	// StatusValidator is a validator for the "status" field. It is called by the builders before save.
-	StatusValidator func(string) error
 	// DefaultID holds the default value on creation for the "id" field.
 	DefaultID func() string
 )
 
+// TypeValidator is a validator for the "type" field enum values. It is called by the builders before save.
+func TypeValidator(_type models.TaskType) error {
+	switch _type {
+	case "UPDATE_CLANS", "RECORD_ACCOUNT_SESSIONS", "UPDATE_ACCOUNT_WN8", "UPDATE_ACCOUNT_ACHIEVEMENTS", "CLEANUP_DATABASE":
+		return nil
+	default:
+		return fmt.Errorf("crontask: invalid enum value for type field: %q", _type)
+	}
+}
+
+// StatusValidator is a validator for the "status" field enum values. It is called by the builders before save.
+func StatusValidator(s models.TaskStatus) error {
+	switch s {
+	case "TASK_SCHEDULED", "TASK_IN_PROGRESS", "TASK_COMPLETE", "TASK_FAILED":
+		return nil
+	default:
+		return fmt.Errorf("crontask: invalid enum value for status field: %q", s)
+	}
+}
+
 // OrderOption defines the ordering options for the CronTask queries.
 type OrderOption func(*sql.Selector)
 
diff --git a/internal/database/ent/db/crontask/where.go b/internal/database/ent/db/crontask/where.go
index a3da3987..3eb15146 100644
--- a/internal/database/ent/db/crontask/where.go
+++ b/internal/database/ent/db/crontask/where.go
@@ -5,6 +5,7 @@ package crontask
 import (
 	"entgo.io/ent/dialect/sql"
 	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/models"
 )
 
 // ID filters vertices based on their ID field.
@@ -63,183 +64,138 @@ func IDContainsFold(id string) predicate.CronTask {
 }
 
 // CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
-func CreatedAt(v int) predicate.CronTask {
+func CreatedAt(v int64) predicate.CronTask {
 	return predicate.CronTask(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
-func UpdatedAt(v int) predicate.CronTask {
+func UpdatedAt(v int64) predicate.CronTask {
 	return predicate.CronTask(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
-// Type applies equality check predicate on the "type" field. It's identical to TypeEQ.
-func Type(v string) predicate.CronTask {
-	return predicate.CronTask(sql.FieldEQ(FieldType, v))
-}
-
 // ReferenceID applies equality check predicate on the "reference_id" field. It's identical to ReferenceIDEQ.
 func ReferenceID(v string) predicate.CronTask {
 	return predicate.CronTask(sql.FieldEQ(FieldReferenceID, v))
 }
 
-// Status applies equality check predicate on the "status" field. It's identical to StatusEQ.
-func Status(v string) predicate.CronTask {
-	return predicate.CronTask(sql.FieldEQ(FieldStatus, v))
-}
-
 // ScheduledAfter applies equality check predicate on the "scheduled_after" field. It's identical to ScheduledAfterEQ.
-func ScheduledAfter(v int) predicate.CronTask {
+func ScheduledAfter(v int64) predicate.CronTask {
 	return predicate.CronTask(sql.FieldEQ(FieldScheduledAfter, v))
 }
 
 // LastRun applies equality check predicate on the "last_run" field. It's identical to LastRunEQ.
-func LastRun(v int) predicate.CronTask {
+func LastRun(v int64) predicate.CronTask {
 	return predicate.CronTask(sql.FieldEQ(FieldLastRun, v))
 }
 
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v int) predicate.CronTask {
+func CreatedAtEQ(v int64) predicate.CronTask {
 	return predicate.CronTask(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v int) predicate.CronTask {
+func CreatedAtNEQ(v int64) predicate.CronTask {
 	return predicate.CronTask(sql.FieldNEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...int) predicate.CronTask {
+func CreatedAtIn(vs ...int64) predicate.CronTask {
 	return predicate.CronTask(sql.FieldIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...int) predicate.CronTask {
+func CreatedAtNotIn(vs ...int64) predicate.CronTask {
 	return predicate.CronTask(sql.FieldNotIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v int) predicate.CronTask {
+func CreatedAtGT(v int64) predicate.CronTask {
 	return predicate.CronTask(sql.FieldGT(FieldCreatedAt, v))
 }
 
 // CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v int) predicate.CronTask {
+func CreatedAtGTE(v int64) predicate.CronTask {
 	return predicate.CronTask(sql.FieldGTE(FieldCreatedAt, v))
 }
 
 // CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v int) predicate.CronTask {
+func CreatedAtLT(v int64) predicate.CronTask {
 	return predicate.CronTask(sql.FieldLT(FieldCreatedAt, v))
 }
 
 // CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v int) predicate.CronTask {
+func CreatedAtLTE(v int64) predicate.CronTask {
 	return predicate.CronTask(sql.FieldLTE(FieldCreatedAt, v))
 }
 
 // UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
-func UpdatedAtEQ(v int) predicate.CronTask {
+func UpdatedAtEQ(v int64) predicate.CronTask {
 	return predicate.CronTask(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
-func UpdatedAtNEQ(v int) predicate.CronTask {
+func UpdatedAtNEQ(v int64) predicate.CronTask {
 	return predicate.CronTask(sql.FieldNEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtIn applies the In predicate on the "updated_at" field.
-func UpdatedAtIn(vs ...int) predicate.CronTask {
+func UpdatedAtIn(vs ...int64) predicate.CronTask {
 	return predicate.CronTask(sql.FieldIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
-func UpdatedAtNotIn(vs ...int) predicate.CronTask {
+func UpdatedAtNotIn(vs ...int64) predicate.CronTask {
 	return predicate.CronTask(sql.FieldNotIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtGT applies the GT predicate on the "updated_at" field.
-func UpdatedAtGT(v int) predicate.CronTask {
+func UpdatedAtGT(v int64) predicate.CronTask {
 	return predicate.CronTask(sql.FieldGT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
-func UpdatedAtGTE(v int) predicate.CronTask {
+func UpdatedAtGTE(v int64) predicate.CronTask {
 	return predicate.CronTask(sql.FieldGTE(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLT applies the LT predicate on the "updated_at" field.
-func UpdatedAtLT(v int) predicate.CronTask {
+func UpdatedAtLT(v int64) predicate.CronTask {
 	return predicate.CronTask(sql.FieldLT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
-func UpdatedAtLTE(v int) predicate.CronTask {
+func UpdatedAtLTE(v int64) predicate.CronTask {
 	return predicate.CronTask(sql.FieldLTE(FieldUpdatedAt, v))
 }
 
 // TypeEQ applies the EQ predicate on the "type" field.
-func TypeEQ(v string) predicate.CronTask {
-	return predicate.CronTask(sql.FieldEQ(FieldType, v))
+func TypeEQ(v models.TaskType) predicate.CronTask {
+	vc := v
+	return predicate.CronTask(sql.FieldEQ(FieldType, vc))
 }
 
 // TypeNEQ applies the NEQ predicate on the "type" field.
-func TypeNEQ(v string) predicate.CronTask {
-	return predicate.CronTask(sql.FieldNEQ(FieldType, v))
+func TypeNEQ(v models.TaskType) predicate.CronTask {
+	vc := v
+	return predicate.CronTask(sql.FieldNEQ(FieldType, vc))
 }
 
 // TypeIn applies the In predicate on the "type" field.
-func TypeIn(vs ...string) predicate.CronTask {
-	return predicate.CronTask(sql.FieldIn(FieldType, vs...))
+func TypeIn(vs ...models.TaskType) predicate.CronTask {
+	v := make([]any, len(vs))
+	for i := range v {
+		v[i] = vs[i]
+	}
+	return predicate.CronTask(sql.FieldIn(FieldType, v...))
 }
 
 // TypeNotIn applies the NotIn predicate on the "type" field.
-func TypeNotIn(vs ...string) predicate.CronTask {
-	return predicate.CronTask(sql.FieldNotIn(FieldType, vs...))
-}
-
-// TypeGT applies the GT predicate on the "type" field.
-func TypeGT(v string) predicate.CronTask {
-	return predicate.CronTask(sql.FieldGT(FieldType, v))
-}
-
-// TypeGTE applies the GTE predicate on the "type" field.
-func TypeGTE(v string) predicate.CronTask {
-	return predicate.CronTask(sql.FieldGTE(FieldType, v))
-}
-
-// TypeLT applies the LT predicate on the "type" field.
-func TypeLT(v string) predicate.CronTask {
-	return predicate.CronTask(sql.FieldLT(FieldType, v))
-}
-
-// TypeLTE applies the LTE predicate on the "type" field.
-func TypeLTE(v string) predicate.CronTask {
-	return predicate.CronTask(sql.FieldLTE(FieldType, v))
-}
-
-// TypeContains applies the Contains predicate on the "type" field.
-func TypeContains(v string) predicate.CronTask {
-	return predicate.CronTask(sql.FieldContains(FieldType, v))
-}
-
-// TypeHasPrefix applies the HasPrefix predicate on the "type" field.
-func TypeHasPrefix(v string) predicate.CronTask {
-	return predicate.CronTask(sql.FieldHasPrefix(FieldType, v))
-}
-
-// TypeHasSuffix applies the HasSuffix predicate on the "type" field.
-func TypeHasSuffix(v string) predicate.CronTask {
-	return predicate.CronTask(sql.FieldHasSuffix(FieldType, v))
-}
-
-// TypeEqualFold applies the EqualFold predicate on the "type" field.
-func TypeEqualFold(v string) predicate.CronTask {
-	return predicate.CronTask(sql.FieldEqualFold(FieldType, v))
-}
-
-// TypeContainsFold applies the ContainsFold predicate on the "type" field.
-func TypeContainsFold(v string) predicate.CronTask {
-	return predicate.CronTask(sql.FieldContainsFold(FieldType, v))
+func TypeNotIn(vs ...models.TaskType) predicate.CronTask {
+	v := make([]any, len(vs))
+	for i := range v {
+		v[i] = vs[i]
+	}
+	return predicate.CronTask(sql.FieldNotIn(FieldType, v...))
 }
 
 // ReferenceIDEQ applies the EQ predicate on the "reference_id" field.
@@ -308,147 +264,112 @@ func ReferenceIDContainsFold(v string) predicate.CronTask {
 }
 
 // StatusEQ applies the EQ predicate on the "status" field.
-func StatusEQ(v string) predicate.CronTask {
-	return predicate.CronTask(sql.FieldEQ(FieldStatus, v))
+func StatusEQ(v models.TaskStatus) predicate.CronTask {
+	vc := v
+	return predicate.CronTask(sql.FieldEQ(FieldStatus, vc))
 }
 
 // StatusNEQ applies the NEQ predicate on the "status" field.
-func StatusNEQ(v string) predicate.CronTask {
-	return predicate.CronTask(sql.FieldNEQ(FieldStatus, v))
+func StatusNEQ(v models.TaskStatus) predicate.CronTask {
+	vc := v
+	return predicate.CronTask(sql.FieldNEQ(FieldStatus, vc))
 }
 
 // StatusIn applies the In predicate on the "status" field.
-func StatusIn(vs ...string) predicate.CronTask {
-	return predicate.CronTask(sql.FieldIn(FieldStatus, vs...))
+func StatusIn(vs ...models.TaskStatus) predicate.CronTask {
+	v := make([]any, len(vs))
+	for i := range v {
+		v[i] = vs[i]
+	}
+	return predicate.CronTask(sql.FieldIn(FieldStatus, v...))
 }
 
 // StatusNotIn applies the NotIn predicate on the "status" field.
-func StatusNotIn(vs ...string) predicate.CronTask {
-	return predicate.CronTask(sql.FieldNotIn(FieldStatus, vs...))
-}
-
-// StatusGT applies the GT predicate on the "status" field.
-func StatusGT(v string) predicate.CronTask {
-	return predicate.CronTask(sql.FieldGT(FieldStatus, v))
-}
-
-// StatusGTE applies the GTE predicate on the "status" field.
-func StatusGTE(v string) predicate.CronTask {
-	return predicate.CronTask(sql.FieldGTE(FieldStatus, v))
-}
-
-// StatusLT applies the LT predicate on the "status" field.
-func StatusLT(v string) predicate.CronTask {
-	return predicate.CronTask(sql.FieldLT(FieldStatus, v))
-}
-
-// StatusLTE applies the LTE predicate on the "status" field.
-func StatusLTE(v string) predicate.CronTask {
-	return predicate.CronTask(sql.FieldLTE(FieldStatus, v))
-}
-
-// StatusContains applies the Contains predicate on the "status" field.
-func StatusContains(v string) predicate.CronTask {
-	return predicate.CronTask(sql.FieldContains(FieldStatus, v))
-}
-
-// StatusHasPrefix applies the HasPrefix predicate on the "status" field.
-func StatusHasPrefix(v string) predicate.CronTask {
-	return predicate.CronTask(sql.FieldHasPrefix(FieldStatus, v))
-}
-
-// StatusHasSuffix applies the HasSuffix predicate on the "status" field.
-func StatusHasSuffix(v string) predicate.CronTask {
-	return predicate.CronTask(sql.FieldHasSuffix(FieldStatus, v))
-}
-
-// StatusEqualFold applies the EqualFold predicate on the "status" field.
-func StatusEqualFold(v string) predicate.CronTask {
-	return predicate.CronTask(sql.FieldEqualFold(FieldStatus, v))
-}
-
-// StatusContainsFold applies the ContainsFold predicate on the "status" field.
-func StatusContainsFold(v string) predicate.CronTask {
-	return predicate.CronTask(sql.FieldContainsFold(FieldStatus, v))
+func StatusNotIn(vs ...models.TaskStatus) predicate.CronTask {
+	v := make([]any, len(vs))
+	for i := range v {
+		v[i] = vs[i]
+	}
+	return predicate.CronTask(sql.FieldNotIn(FieldStatus, v...))
 }
 
 // ScheduledAfterEQ applies the EQ predicate on the "scheduled_after" field.
-func ScheduledAfterEQ(v int) predicate.CronTask {
+func ScheduledAfterEQ(v int64) predicate.CronTask {
 	return predicate.CronTask(sql.FieldEQ(FieldScheduledAfter, v))
 }
 
 // ScheduledAfterNEQ applies the NEQ predicate on the "scheduled_after" field.
-func ScheduledAfterNEQ(v int) predicate.CronTask {
+func ScheduledAfterNEQ(v int64) predicate.CronTask {
 	return predicate.CronTask(sql.FieldNEQ(FieldScheduledAfter, v))
 }
 
 // ScheduledAfterIn applies the In predicate on the "scheduled_after" field.
-func ScheduledAfterIn(vs ...int) predicate.CronTask {
+func ScheduledAfterIn(vs ...int64) predicate.CronTask {
 	return predicate.CronTask(sql.FieldIn(FieldScheduledAfter, vs...))
 }
 
 // ScheduledAfterNotIn applies the NotIn predicate on the "scheduled_after" field.
-func ScheduledAfterNotIn(vs ...int) predicate.CronTask {
+func ScheduledAfterNotIn(vs ...int64) predicate.CronTask {
 	return predicate.CronTask(sql.FieldNotIn(FieldScheduledAfter, vs...))
 }
 
 // ScheduledAfterGT applies the GT predicate on the "scheduled_after" field.
-func ScheduledAfterGT(v int) predicate.CronTask {
+func ScheduledAfterGT(v int64) predicate.CronTask {
 	return predicate.CronTask(sql.FieldGT(FieldScheduledAfter, v))
 }
 
 // ScheduledAfterGTE applies the GTE predicate on the "scheduled_after" field.
-func ScheduledAfterGTE(v int) predicate.CronTask {
+func ScheduledAfterGTE(v int64) predicate.CronTask {
 	return predicate.CronTask(sql.FieldGTE(FieldScheduledAfter, v))
 }
 
 // ScheduledAfterLT applies the LT predicate on the "scheduled_after" field.
-func ScheduledAfterLT(v int) predicate.CronTask {
+func ScheduledAfterLT(v int64) predicate.CronTask {
 	return predicate.CronTask(sql.FieldLT(FieldScheduledAfter, v))
 }
 
 // ScheduledAfterLTE applies the LTE predicate on the "scheduled_after" field.
-func ScheduledAfterLTE(v int) predicate.CronTask {
+func ScheduledAfterLTE(v int64) predicate.CronTask {
 	return predicate.CronTask(sql.FieldLTE(FieldScheduledAfter, v))
 }
 
 // LastRunEQ applies the EQ predicate on the "last_run" field.
-func LastRunEQ(v int) predicate.CronTask {
+func LastRunEQ(v int64) predicate.CronTask {
 	return predicate.CronTask(sql.FieldEQ(FieldLastRun, v))
 }
 
 // LastRunNEQ applies the NEQ predicate on the "last_run" field.
-func LastRunNEQ(v int) predicate.CronTask {
+func LastRunNEQ(v int64) predicate.CronTask {
 	return predicate.CronTask(sql.FieldNEQ(FieldLastRun, v))
 }
 
 // LastRunIn applies the In predicate on the "last_run" field.
-func LastRunIn(vs ...int) predicate.CronTask {
+func LastRunIn(vs ...int64) predicate.CronTask {
 	return predicate.CronTask(sql.FieldIn(FieldLastRun, vs...))
 }
 
 // LastRunNotIn applies the NotIn predicate on the "last_run" field.
-func LastRunNotIn(vs ...int) predicate.CronTask {
+func LastRunNotIn(vs ...int64) predicate.CronTask {
 	return predicate.CronTask(sql.FieldNotIn(FieldLastRun, vs...))
 }
 
 // LastRunGT applies the GT predicate on the "last_run" field.
-func LastRunGT(v int) predicate.CronTask {
+func LastRunGT(v int64) predicate.CronTask {
 	return predicate.CronTask(sql.FieldGT(FieldLastRun, v))
 }
 
 // LastRunGTE applies the GTE predicate on the "last_run" field.
-func LastRunGTE(v int) predicate.CronTask {
+func LastRunGTE(v int64) predicate.CronTask {
 	return predicate.CronTask(sql.FieldGTE(FieldLastRun, v))
 }
 
 // LastRunLT applies the LT predicate on the "last_run" field.
-func LastRunLT(v int) predicate.CronTask {
+func LastRunLT(v int64) predicate.CronTask {
 	return predicate.CronTask(sql.FieldLT(FieldLastRun, v))
 }
 
 // LastRunLTE applies the LTE predicate on the "last_run" field.
-func LastRunLTE(v int) predicate.CronTask {
+func LastRunLTE(v int64) predicate.CronTask {
 	return predicate.CronTask(sql.FieldLTE(FieldLastRun, v))
 }
 
diff --git a/internal/database/ent/db/crontask_create.go b/internal/database/ent/db/crontask_create.go
index 40345b5d..78feb06e 100644
--- a/internal/database/ent/db/crontask_create.go
+++ b/internal/database/ent/db/crontask_create.go
@@ -21,13 +21,13 @@ type CronTaskCreate struct {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (ctc *CronTaskCreate) SetCreatedAt(i int) *CronTaskCreate {
+func (ctc *CronTaskCreate) SetCreatedAt(i int64) *CronTaskCreate {
 	ctc.mutation.SetCreatedAt(i)
 	return ctc
 }
 
 // SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
-func (ctc *CronTaskCreate) SetNillableCreatedAt(i *int) *CronTaskCreate {
+func (ctc *CronTaskCreate) SetNillableCreatedAt(i *int64) *CronTaskCreate {
 	if i != nil {
 		ctc.SetCreatedAt(*i)
 	}
@@ -35,13 +35,13 @@ func (ctc *CronTaskCreate) SetNillableCreatedAt(i *int) *CronTaskCreate {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (ctc *CronTaskCreate) SetUpdatedAt(i int) *CronTaskCreate {
+func (ctc *CronTaskCreate) SetUpdatedAt(i int64) *CronTaskCreate {
 	ctc.mutation.SetUpdatedAt(i)
 	return ctc
 }
 
 // SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
-func (ctc *CronTaskCreate) SetNillableUpdatedAt(i *int) *CronTaskCreate {
+func (ctc *CronTaskCreate) SetNillableUpdatedAt(i *int64) *CronTaskCreate {
 	if i != nil {
 		ctc.SetUpdatedAt(*i)
 	}
@@ -49,8 +49,8 @@ func (ctc *CronTaskCreate) SetNillableUpdatedAt(i *int) *CronTaskCreate {
 }
 
 // SetType sets the "type" field.
-func (ctc *CronTaskCreate) SetType(s string) *CronTaskCreate {
-	ctc.mutation.SetType(s)
+func (ctc *CronTaskCreate) SetType(mt models.TaskType) *CronTaskCreate {
+	ctc.mutation.SetType(mt)
 	return ctc
 }
 
@@ -67,19 +67,19 @@ func (ctc *CronTaskCreate) SetTargets(s []string) *CronTaskCreate {
 }
 
 // SetStatus sets the "status" field.
-func (ctc *CronTaskCreate) SetStatus(s string) *CronTaskCreate {
-	ctc.mutation.SetStatus(s)
+func (ctc *CronTaskCreate) SetStatus(ms models.TaskStatus) *CronTaskCreate {
+	ctc.mutation.SetStatus(ms)
 	return ctc
 }
 
 // SetScheduledAfter sets the "scheduled_after" field.
-func (ctc *CronTaskCreate) SetScheduledAfter(i int) *CronTaskCreate {
+func (ctc *CronTaskCreate) SetScheduledAfter(i int64) *CronTaskCreate {
 	ctc.mutation.SetScheduledAfter(i)
 	return ctc
 }
 
 // SetLastRun sets the "last_run" field.
-func (ctc *CronTaskCreate) SetLastRun(i int) *CronTaskCreate {
+func (ctc *CronTaskCreate) SetLastRun(i int64) *CronTaskCreate {
 	ctc.mutation.SetLastRun(i)
 	return ctc
 }
@@ -242,15 +242,15 @@ func (ctc *CronTaskCreate) createSpec() (*CronTask, *sqlgraph.CreateSpec) {
 		_spec.ID.Value = id
 	}
 	if value, ok := ctc.mutation.CreatedAt(); ok {
-		_spec.SetField(crontask.FieldCreatedAt, field.TypeInt, value)
+		_spec.SetField(crontask.FieldCreatedAt, field.TypeInt64, value)
 		_node.CreatedAt = value
 	}
 	if value, ok := ctc.mutation.UpdatedAt(); ok {
-		_spec.SetField(crontask.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(crontask.FieldUpdatedAt, field.TypeInt64, value)
 		_node.UpdatedAt = value
 	}
 	if value, ok := ctc.mutation.GetType(); ok {
-		_spec.SetField(crontask.FieldType, field.TypeString, value)
+		_spec.SetField(crontask.FieldType, field.TypeEnum, value)
 		_node.Type = value
 	}
 	if value, ok := ctc.mutation.ReferenceID(); ok {
@@ -262,15 +262,15 @@ func (ctc *CronTaskCreate) createSpec() (*CronTask, *sqlgraph.CreateSpec) {
 		_node.Targets = value
 	}
 	if value, ok := ctc.mutation.Status(); ok {
-		_spec.SetField(crontask.FieldStatus, field.TypeString, value)
+		_spec.SetField(crontask.FieldStatus, field.TypeEnum, value)
 		_node.Status = value
 	}
 	if value, ok := ctc.mutation.ScheduledAfter(); ok {
-		_spec.SetField(crontask.FieldScheduledAfter, field.TypeInt, value)
+		_spec.SetField(crontask.FieldScheduledAfter, field.TypeInt64, value)
 		_node.ScheduledAfter = value
 	}
 	if value, ok := ctc.mutation.LastRun(); ok {
-		_spec.SetField(crontask.FieldLastRun, field.TypeInt, value)
+		_spec.SetField(crontask.FieldLastRun, field.TypeInt64, value)
 		_node.LastRun = value
 	}
 	if value, ok := ctc.mutation.Logs(); ok {
diff --git a/internal/database/ent/db/crontask_query.go b/internal/database/ent/db/crontask_query.go
index 2ff7de14..27b8ca39 100644
--- a/internal/database/ent/db/crontask_query.go
+++ b/internal/database/ent/db/crontask_query.go
@@ -261,7 +261,7 @@ func (ctq *CronTaskQuery) Clone() *CronTaskQuery {
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int `json:"created_at,omitempty"`
+//		CreatedAt int64 `json:"created_at,omitempty"`
 //		Count int `json:"count,omitempty"`
 //	}
 //
@@ -284,7 +284,7 @@ func (ctq *CronTaskQuery) GroupBy(field string, fields ...string) *CronTaskGroup
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int `json:"created_at,omitempty"`
+//		CreatedAt int64 `json:"created_at,omitempty"`
 //	}
 //
 //	client.CronTask.Query().
diff --git a/internal/database/ent/db/crontask_update.go b/internal/database/ent/db/crontask_update.go
index 1d3bd10f..ddbf9627 100644
--- a/internal/database/ent/db/crontask_update.go
+++ b/internal/database/ent/db/crontask_update.go
@@ -30,28 +30,28 @@ func (ctu *CronTaskUpdate) Where(ps ...predicate.CronTask) *CronTaskUpdate {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (ctu *CronTaskUpdate) SetUpdatedAt(i int) *CronTaskUpdate {
+func (ctu *CronTaskUpdate) SetUpdatedAt(i int64) *CronTaskUpdate {
 	ctu.mutation.ResetUpdatedAt()
 	ctu.mutation.SetUpdatedAt(i)
 	return ctu
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (ctu *CronTaskUpdate) AddUpdatedAt(i int) *CronTaskUpdate {
+func (ctu *CronTaskUpdate) AddUpdatedAt(i int64) *CronTaskUpdate {
 	ctu.mutation.AddUpdatedAt(i)
 	return ctu
 }
 
 // SetType sets the "type" field.
-func (ctu *CronTaskUpdate) SetType(s string) *CronTaskUpdate {
-	ctu.mutation.SetType(s)
+func (ctu *CronTaskUpdate) SetType(mt models.TaskType) *CronTaskUpdate {
+	ctu.mutation.SetType(mt)
 	return ctu
 }
 
 // SetNillableType sets the "type" field if the given value is not nil.
-func (ctu *CronTaskUpdate) SetNillableType(s *string) *CronTaskUpdate {
-	if s != nil {
-		ctu.SetType(*s)
+func (ctu *CronTaskUpdate) SetNillableType(mt *models.TaskType) *CronTaskUpdate {
+	if mt != nil {
+		ctu.SetType(*mt)
 	}
 	return ctu
 }
@@ -83,28 +83,28 @@ func (ctu *CronTaskUpdate) AppendTargets(s []string) *CronTaskUpdate {
 }
 
 // SetStatus sets the "status" field.
-func (ctu *CronTaskUpdate) SetStatus(s string) *CronTaskUpdate {
-	ctu.mutation.SetStatus(s)
+func (ctu *CronTaskUpdate) SetStatus(ms models.TaskStatus) *CronTaskUpdate {
+	ctu.mutation.SetStatus(ms)
 	return ctu
 }
 
 // SetNillableStatus sets the "status" field if the given value is not nil.
-func (ctu *CronTaskUpdate) SetNillableStatus(s *string) *CronTaskUpdate {
-	if s != nil {
-		ctu.SetStatus(*s)
+func (ctu *CronTaskUpdate) SetNillableStatus(ms *models.TaskStatus) *CronTaskUpdate {
+	if ms != nil {
+		ctu.SetStatus(*ms)
 	}
 	return ctu
 }
 
 // SetScheduledAfter sets the "scheduled_after" field.
-func (ctu *CronTaskUpdate) SetScheduledAfter(i int) *CronTaskUpdate {
+func (ctu *CronTaskUpdate) SetScheduledAfter(i int64) *CronTaskUpdate {
 	ctu.mutation.ResetScheduledAfter()
 	ctu.mutation.SetScheduledAfter(i)
 	return ctu
 }
 
 // SetNillableScheduledAfter sets the "scheduled_after" field if the given value is not nil.
-func (ctu *CronTaskUpdate) SetNillableScheduledAfter(i *int) *CronTaskUpdate {
+func (ctu *CronTaskUpdate) SetNillableScheduledAfter(i *int64) *CronTaskUpdate {
 	if i != nil {
 		ctu.SetScheduledAfter(*i)
 	}
@@ -112,20 +112,20 @@ func (ctu *CronTaskUpdate) SetNillableScheduledAfter(i *int) *CronTaskUpdate {
 }
 
 // AddScheduledAfter adds i to the "scheduled_after" field.
-func (ctu *CronTaskUpdate) AddScheduledAfter(i int) *CronTaskUpdate {
+func (ctu *CronTaskUpdate) AddScheduledAfter(i int64) *CronTaskUpdate {
 	ctu.mutation.AddScheduledAfter(i)
 	return ctu
 }
 
 // SetLastRun sets the "last_run" field.
-func (ctu *CronTaskUpdate) SetLastRun(i int) *CronTaskUpdate {
+func (ctu *CronTaskUpdate) SetLastRun(i int64) *CronTaskUpdate {
 	ctu.mutation.ResetLastRun()
 	ctu.mutation.SetLastRun(i)
 	return ctu
 }
 
 // SetNillableLastRun sets the "last_run" field if the given value is not nil.
-func (ctu *CronTaskUpdate) SetNillableLastRun(i *int) *CronTaskUpdate {
+func (ctu *CronTaskUpdate) SetNillableLastRun(i *int64) *CronTaskUpdate {
 	if i != nil {
 		ctu.SetLastRun(*i)
 	}
@@ -133,7 +133,7 @@ func (ctu *CronTaskUpdate) SetNillableLastRun(i *int) *CronTaskUpdate {
 }
 
 // AddLastRun adds i to the "last_run" field.
-func (ctu *CronTaskUpdate) AddLastRun(i int) *CronTaskUpdate {
+func (ctu *CronTaskUpdate) AddLastRun(i int64) *CronTaskUpdate {
 	ctu.mutation.AddLastRun(i)
 	return ctu
 }
@@ -230,13 +230,13 @@ func (ctu *CronTaskUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 	}
 	if value, ok := ctu.mutation.UpdatedAt(); ok {
-		_spec.SetField(crontask.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(crontask.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := ctu.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(crontask.FieldUpdatedAt, field.TypeInt, value)
+		_spec.AddField(crontask.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := ctu.mutation.GetType(); ok {
-		_spec.SetField(crontask.FieldType, field.TypeString, value)
+		_spec.SetField(crontask.FieldType, field.TypeEnum, value)
 	}
 	if value, ok := ctu.mutation.ReferenceID(); ok {
 		_spec.SetField(crontask.FieldReferenceID, field.TypeString, value)
@@ -250,19 +250,19 @@ func (ctu *CronTaskUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		})
 	}
 	if value, ok := ctu.mutation.Status(); ok {
-		_spec.SetField(crontask.FieldStatus, field.TypeString, value)
+		_spec.SetField(crontask.FieldStatus, field.TypeEnum, value)
 	}
 	if value, ok := ctu.mutation.ScheduledAfter(); ok {
-		_spec.SetField(crontask.FieldScheduledAfter, field.TypeInt, value)
+		_spec.SetField(crontask.FieldScheduledAfter, field.TypeInt64, value)
 	}
 	if value, ok := ctu.mutation.AddedScheduledAfter(); ok {
-		_spec.AddField(crontask.FieldScheduledAfter, field.TypeInt, value)
+		_spec.AddField(crontask.FieldScheduledAfter, field.TypeInt64, value)
 	}
 	if value, ok := ctu.mutation.LastRun(); ok {
-		_spec.SetField(crontask.FieldLastRun, field.TypeInt, value)
+		_spec.SetField(crontask.FieldLastRun, field.TypeInt64, value)
 	}
 	if value, ok := ctu.mutation.AddedLastRun(); ok {
-		_spec.AddField(crontask.FieldLastRun, field.TypeInt, value)
+		_spec.AddField(crontask.FieldLastRun, field.TypeInt64, value)
 	}
 	if value, ok := ctu.mutation.Logs(); ok {
 		_spec.SetField(crontask.FieldLogs, field.TypeJSON, value)
@@ -296,28 +296,28 @@ type CronTaskUpdateOne struct {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (ctuo *CronTaskUpdateOne) SetUpdatedAt(i int) *CronTaskUpdateOne {
+func (ctuo *CronTaskUpdateOne) SetUpdatedAt(i int64) *CronTaskUpdateOne {
 	ctuo.mutation.ResetUpdatedAt()
 	ctuo.mutation.SetUpdatedAt(i)
 	return ctuo
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (ctuo *CronTaskUpdateOne) AddUpdatedAt(i int) *CronTaskUpdateOne {
+func (ctuo *CronTaskUpdateOne) AddUpdatedAt(i int64) *CronTaskUpdateOne {
 	ctuo.mutation.AddUpdatedAt(i)
 	return ctuo
 }
 
 // SetType sets the "type" field.
-func (ctuo *CronTaskUpdateOne) SetType(s string) *CronTaskUpdateOne {
-	ctuo.mutation.SetType(s)
+func (ctuo *CronTaskUpdateOne) SetType(mt models.TaskType) *CronTaskUpdateOne {
+	ctuo.mutation.SetType(mt)
 	return ctuo
 }
 
 // SetNillableType sets the "type" field if the given value is not nil.
-func (ctuo *CronTaskUpdateOne) SetNillableType(s *string) *CronTaskUpdateOne {
-	if s != nil {
-		ctuo.SetType(*s)
+func (ctuo *CronTaskUpdateOne) SetNillableType(mt *models.TaskType) *CronTaskUpdateOne {
+	if mt != nil {
+		ctuo.SetType(*mt)
 	}
 	return ctuo
 }
@@ -349,28 +349,28 @@ func (ctuo *CronTaskUpdateOne) AppendTargets(s []string) *CronTaskUpdateOne {
 }
 
 // SetStatus sets the "status" field.
-func (ctuo *CronTaskUpdateOne) SetStatus(s string) *CronTaskUpdateOne {
-	ctuo.mutation.SetStatus(s)
+func (ctuo *CronTaskUpdateOne) SetStatus(ms models.TaskStatus) *CronTaskUpdateOne {
+	ctuo.mutation.SetStatus(ms)
 	return ctuo
 }
 
 // SetNillableStatus sets the "status" field if the given value is not nil.
-func (ctuo *CronTaskUpdateOne) SetNillableStatus(s *string) *CronTaskUpdateOne {
-	if s != nil {
-		ctuo.SetStatus(*s)
+func (ctuo *CronTaskUpdateOne) SetNillableStatus(ms *models.TaskStatus) *CronTaskUpdateOne {
+	if ms != nil {
+		ctuo.SetStatus(*ms)
 	}
 	return ctuo
 }
 
 // SetScheduledAfter sets the "scheduled_after" field.
-func (ctuo *CronTaskUpdateOne) SetScheduledAfter(i int) *CronTaskUpdateOne {
+func (ctuo *CronTaskUpdateOne) SetScheduledAfter(i int64) *CronTaskUpdateOne {
 	ctuo.mutation.ResetScheduledAfter()
 	ctuo.mutation.SetScheduledAfter(i)
 	return ctuo
 }
 
 // SetNillableScheduledAfter sets the "scheduled_after" field if the given value is not nil.
-func (ctuo *CronTaskUpdateOne) SetNillableScheduledAfter(i *int) *CronTaskUpdateOne {
+func (ctuo *CronTaskUpdateOne) SetNillableScheduledAfter(i *int64) *CronTaskUpdateOne {
 	if i != nil {
 		ctuo.SetScheduledAfter(*i)
 	}
@@ -378,20 +378,20 @@ func (ctuo *CronTaskUpdateOne) SetNillableScheduledAfter(i *int) *CronTaskUpdate
 }
 
 // AddScheduledAfter adds i to the "scheduled_after" field.
-func (ctuo *CronTaskUpdateOne) AddScheduledAfter(i int) *CronTaskUpdateOne {
+func (ctuo *CronTaskUpdateOne) AddScheduledAfter(i int64) *CronTaskUpdateOne {
 	ctuo.mutation.AddScheduledAfter(i)
 	return ctuo
 }
 
 // SetLastRun sets the "last_run" field.
-func (ctuo *CronTaskUpdateOne) SetLastRun(i int) *CronTaskUpdateOne {
+func (ctuo *CronTaskUpdateOne) SetLastRun(i int64) *CronTaskUpdateOne {
 	ctuo.mutation.ResetLastRun()
 	ctuo.mutation.SetLastRun(i)
 	return ctuo
 }
 
 // SetNillableLastRun sets the "last_run" field if the given value is not nil.
-func (ctuo *CronTaskUpdateOne) SetNillableLastRun(i *int) *CronTaskUpdateOne {
+func (ctuo *CronTaskUpdateOne) SetNillableLastRun(i *int64) *CronTaskUpdateOne {
 	if i != nil {
 		ctuo.SetLastRun(*i)
 	}
@@ -399,7 +399,7 @@ func (ctuo *CronTaskUpdateOne) SetNillableLastRun(i *int) *CronTaskUpdateOne {
 }
 
 // AddLastRun adds i to the "last_run" field.
-func (ctuo *CronTaskUpdateOne) AddLastRun(i int) *CronTaskUpdateOne {
+func (ctuo *CronTaskUpdateOne) AddLastRun(i int64) *CronTaskUpdateOne {
 	ctuo.mutation.AddLastRun(i)
 	return ctuo
 }
@@ -526,13 +526,13 @@ func (ctuo *CronTaskUpdateOne) sqlSave(ctx context.Context) (_node *CronTask, er
 		}
 	}
 	if value, ok := ctuo.mutation.UpdatedAt(); ok {
-		_spec.SetField(crontask.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(crontask.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := ctuo.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(crontask.FieldUpdatedAt, field.TypeInt, value)
+		_spec.AddField(crontask.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := ctuo.mutation.GetType(); ok {
-		_spec.SetField(crontask.FieldType, field.TypeString, value)
+		_spec.SetField(crontask.FieldType, field.TypeEnum, value)
 	}
 	if value, ok := ctuo.mutation.ReferenceID(); ok {
 		_spec.SetField(crontask.FieldReferenceID, field.TypeString, value)
@@ -546,19 +546,19 @@ func (ctuo *CronTaskUpdateOne) sqlSave(ctx context.Context) (_node *CronTask, er
 		})
 	}
 	if value, ok := ctuo.mutation.Status(); ok {
-		_spec.SetField(crontask.FieldStatus, field.TypeString, value)
+		_spec.SetField(crontask.FieldStatus, field.TypeEnum, value)
 	}
 	if value, ok := ctuo.mutation.ScheduledAfter(); ok {
-		_spec.SetField(crontask.FieldScheduledAfter, field.TypeInt, value)
+		_spec.SetField(crontask.FieldScheduledAfter, field.TypeInt64, value)
 	}
 	if value, ok := ctuo.mutation.AddedScheduledAfter(); ok {
-		_spec.AddField(crontask.FieldScheduledAfter, field.TypeInt, value)
+		_spec.AddField(crontask.FieldScheduledAfter, field.TypeInt64, value)
 	}
 	if value, ok := ctuo.mutation.LastRun(); ok {
-		_spec.SetField(crontask.FieldLastRun, field.TypeInt, value)
+		_spec.SetField(crontask.FieldLastRun, field.TypeInt64, value)
 	}
 	if value, ok := ctuo.mutation.AddedLastRun(); ok {
-		_spec.AddField(crontask.FieldLastRun, field.TypeInt, value)
+		_spec.AddField(crontask.FieldLastRun, field.TypeInt64, value)
 	}
 	if value, ok := ctuo.mutation.Logs(); ok {
 		_spec.SetField(crontask.FieldLogs, field.TypeJSON, value)
diff --git a/internal/database/ent/db/migrate/schema.go b/internal/database/ent/db/migrate/schema.go
index 6496f121..f5c10f59 100644
--- a/internal/database/ent/db/migrate/schema.go
+++ b/internal/database/ent/db/migrate/schema.go
@@ -11,10 +11,10 @@ var (
 	// AccountsColumns holds the columns for the "accounts" table.
 	AccountsColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeString, Unique: true},
-		{Name: "created_at", Type: field.TypeInt},
-		{Name: "updated_at", Type: field.TypeInt},
-		{Name: "last_battle_time", Type: field.TypeInt},
-		{Name: "account_created_at", Type: field.TypeInt},
+		{Name: "created_at", Type: field.TypeInt64},
+		{Name: "updated_at", Type: field.TypeInt64},
+		{Name: "last_battle_time", Type: field.TypeInt64},
+		{Name: "account_created_at", Type: field.TypeInt64},
 		{Name: "realm", Type: field.TypeString, Size: 5},
 		{Name: "nickname", Type: field.TypeString},
 		{Name: "private", Type: field.TypeBool, Default: false},
@@ -59,10 +59,10 @@ var (
 	// AccountSnapshotsColumns holds the columns for the "account_snapshots" table.
 	AccountSnapshotsColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeString, Unique: true},
-		{Name: "created_at", Type: field.TypeInt},
-		{Name: "updated_at", Type: field.TypeInt},
+		{Name: "created_at", Type: field.TypeInt64},
+		{Name: "updated_at", Type: field.TypeInt64},
 		{Name: "type", Type: field.TypeEnum, Enums: []string{"live", "daily"}},
-		{Name: "last_battle_time", Type: field.TypeInt},
+		{Name: "last_battle_time", Type: field.TypeInt64},
 		{Name: "reference_id", Type: field.TypeString},
 		{Name: "rating_battles", Type: field.TypeInt},
 		{Name: "rating_frame", Type: field.TypeJSON},
@@ -109,12 +109,12 @@ var (
 	// AchievementsSnapshotsColumns holds the columns for the "achievements_snapshots" table.
 	AchievementsSnapshotsColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeString, Unique: true},
-		{Name: "created_at", Type: field.TypeInt},
-		{Name: "updated_at", Type: field.TypeInt},
+		{Name: "created_at", Type: field.TypeInt64},
+		{Name: "updated_at", Type: field.TypeInt64},
 		{Name: "type", Type: field.TypeEnum, Enums: []string{"live", "daily"}},
 		{Name: "reference_id", Type: field.TypeString},
 		{Name: "battles", Type: field.TypeInt},
-		{Name: "last_battle_time", Type: field.TypeInt},
+		{Name: "last_battle_time", Type: field.TypeInt64},
 		{Name: "data", Type: field.TypeJSON},
 		{Name: "account_id", Type: field.TypeString},
 	}
@@ -152,8 +152,8 @@ var (
 	// AppConfigurationsColumns holds the columns for the "app_configurations" table.
 	AppConfigurationsColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeString, Unique: true},
-		{Name: "created_at", Type: field.TypeInt},
-		{Name: "updated_at", Type: field.TypeInt},
+		{Name: "created_at", Type: field.TypeInt64},
+		{Name: "updated_at", Type: field.TypeInt64},
 		{Name: "key", Type: field.TypeString, Unique: true},
 		{Name: "value", Type: field.TypeJSON},
 		{Name: "metadata", Type: field.TypeJSON, Nullable: true},
@@ -174,8 +174,8 @@ var (
 	// ApplicationCommandsColumns holds the columns for the "application_commands" table.
 	ApplicationCommandsColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeString, Unique: true},
-		{Name: "created_at", Type: field.TypeInt},
-		{Name: "updated_at", Type: field.TypeInt},
+		{Name: "created_at", Type: field.TypeInt64},
+		{Name: "updated_at", Type: field.TypeInt64},
 		{Name: "name", Type: field.TypeString, Unique: true},
 		{Name: "version", Type: field.TypeString},
 		{Name: "options_hash", Type: field.TypeString},
@@ -196,8 +196,8 @@ var (
 	// ClansColumns holds the columns for the "clans" table.
 	ClansColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeString, Unique: true},
-		{Name: "created_at", Type: field.TypeInt},
-		{Name: "updated_at", Type: field.TypeInt},
+		{Name: "created_at", Type: field.TypeInt64},
+		{Name: "updated_at", Type: field.TypeInt64},
 		{Name: "tag", Type: field.TypeString},
 		{Name: "name", Type: field.TypeString},
 		{Name: "emblem_id", Type: field.TypeString, Nullable: true, Default: ""},
@@ -224,14 +224,14 @@ var (
 	// CronTasksColumns holds the columns for the "cron_tasks" table.
 	CronTasksColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeString, Unique: true},
-		{Name: "created_at", Type: field.TypeInt},
-		{Name: "updated_at", Type: field.TypeInt},
-		{Name: "type", Type: field.TypeString},
+		{Name: "created_at", Type: field.TypeInt64},
+		{Name: "updated_at", Type: field.TypeInt64},
+		{Name: "type", Type: field.TypeEnum, Enums: []string{"UPDATE_CLANS", "RECORD_ACCOUNT_SESSIONS", "UPDATE_ACCOUNT_WN8", "UPDATE_ACCOUNT_ACHIEVEMENTS", "CLEANUP_DATABASE"}},
 		{Name: "reference_id", Type: field.TypeString},
 		{Name: "targets", Type: field.TypeJSON},
-		{Name: "status", Type: field.TypeString},
-		{Name: "scheduled_after", Type: field.TypeInt},
-		{Name: "last_run", Type: field.TypeInt},
+		{Name: "status", Type: field.TypeEnum, Enums: []string{"TASK_SCHEDULED", "TASK_IN_PROGRESS", "TASK_COMPLETE", "TASK_FAILED"}},
+		{Name: "scheduled_after", Type: field.TypeInt64},
+		{Name: "last_run", Type: field.TypeInt64},
 		{Name: "logs", Type: field.TypeJSON},
 		{Name: "data", Type: field.TypeJSON},
 	}
@@ -266,8 +266,8 @@ var (
 	// UsersColumns holds the columns for the "users" table.
 	UsersColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeString, Unique: true},
-		{Name: "created_at", Type: field.TypeInt},
-		{Name: "updated_at", Type: field.TypeInt},
+		{Name: "created_at", Type: field.TypeInt64},
+		{Name: "updated_at", Type: field.TypeInt64},
 		{Name: "permissions", Type: field.TypeString, Default: ""},
 		{Name: "feature_flags", Type: field.TypeJSON, Nullable: true},
 	}
@@ -280,8 +280,8 @@ var (
 	// UserConnectionsColumns holds the columns for the "user_connections" table.
 	UserConnectionsColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeString, Unique: true},
-		{Name: "created_at", Type: field.TypeInt},
-		{Name: "updated_at", Type: field.TypeInt},
+		{Name: "created_at", Type: field.TypeInt64},
+		{Name: "updated_at", Type: field.TypeInt64},
 		{Name: "type", Type: field.TypeEnum, Enums: []string{"wargaming"}},
 		{Name: "reference_id", Type: field.TypeString},
 		{Name: "permissions", Type: field.TypeString, Nullable: true, Default: ""},
@@ -327,8 +327,8 @@ var (
 	// UserContentsColumns holds the columns for the "user_contents" table.
 	UserContentsColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeString, Unique: true},
-		{Name: "created_at", Type: field.TypeInt},
-		{Name: "updated_at", Type: field.TypeInt},
+		{Name: "created_at", Type: field.TypeInt64},
+		{Name: "updated_at", Type: field.TypeInt64},
 		{Name: "type", Type: field.TypeEnum, Enums: []string{"clan-background-image", "personal-background-image"}},
 		{Name: "reference_id", Type: field.TypeString},
 		{Name: "value", Type: field.TypeJSON},
@@ -374,10 +374,10 @@ var (
 	// UserSubscriptionsColumns holds the columns for the "user_subscriptions" table.
 	UserSubscriptionsColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeString, Unique: true},
-		{Name: "created_at", Type: field.TypeInt},
-		{Name: "updated_at", Type: field.TypeInt},
+		{Name: "created_at", Type: field.TypeInt64},
+		{Name: "updated_at", Type: field.TypeInt64},
 		{Name: "type", Type: field.TypeEnum, Enums: []string{"aftermath-pro", "aftermath-pro-clan", "aftermath-plus", "supporter", "verified-clan", "server-moderator", "content-moderator", "developer", "server-booster", "content-translator"}},
-		{Name: "expires_at", Type: field.TypeInt},
+		{Name: "expires_at", Type: field.TypeInt64},
 		{Name: "permissions", Type: field.TypeString},
 		{Name: "reference_id", Type: field.TypeString},
 		{Name: "user_id", Type: field.TypeString},
@@ -421,8 +421,8 @@ var (
 	// VehiclesColumns holds the columns for the "vehicles" table.
 	VehiclesColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeString, Unique: true},
-		{Name: "created_at", Type: field.TypeInt},
-		{Name: "updated_at", Type: field.TypeInt},
+		{Name: "created_at", Type: field.TypeInt64},
+		{Name: "updated_at", Type: field.TypeInt64},
 		{Name: "tier", Type: field.TypeInt},
 		{Name: "localized_names", Type: field.TypeJSON},
 	}
@@ -435,8 +435,8 @@ var (
 	// VehicleAveragesColumns holds the columns for the "vehicle_averages" table.
 	VehicleAveragesColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeString, Unique: true},
-		{Name: "created_at", Type: field.TypeInt},
-		{Name: "updated_at", Type: field.TypeInt},
+		{Name: "created_at", Type: field.TypeInt64},
+		{Name: "updated_at", Type: field.TypeInt64},
 		{Name: "data", Type: field.TypeJSON},
 	}
 	// VehicleAveragesTable holds the schema information for the "vehicle_averages" table.
@@ -448,13 +448,13 @@ var (
 	// VehicleSnapshotsColumns holds the columns for the "vehicle_snapshots" table.
 	VehicleSnapshotsColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeString, Unique: true},
-		{Name: "created_at", Type: field.TypeInt},
-		{Name: "updated_at", Type: field.TypeInt},
+		{Name: "created_at", Type: field.TypeInt64},
+		{Name: "updated_at", Type: field.TypeInt64},
 		{Name: "type", Type: field.TypeEnum, Enums: []string{"live", "daily"}},
 		{Name: "vehicle_id", Type: field.TypeString},
 		{Name: "reference_id", Type: field.TypeString},
 		{Name: "battles", Type: field.TypeInt},
-		{Name: "last_battle_time", Type: field.TypeInt},
+		{Name: "last_battle_time", Type: field.TypeInt64},
 		{Name: "frame", Type: field.TypeJSON},
 		{Name: "account_id", Type: field.TypeString},
 	}
diff --git a/internal/database/ent/db/mutation.go b/internal/database/ent/db/mutation.go
index dbf6c4bc..49983f2e 100644
--- a/internal/database/ent/db/mutation.go
+++ b/internal/database/ent/db/mutation.go
@@ -61,14 +61,14 @@ type AccountMutation struct {
 	op                           Op
 	typ                          string
 	id                           *string
-	created_at                   *int
-	addcreated_at                *int
-	updated_at                   *int
-	addupdated_at                *int
-	last_battle_time             *int
-	addlast_battle_time          *int
-	account_created_at           *int
-	addaccount_created_at        *int
+	created_at                   *int64
+	addcreated_at                *int64
+	updated_at                   *int64
+	addupdated_at                *int64
+	last_battle_time             *int64
+	addlast_battle_time          *int64
+	account_created_at           *int64
+	addaccount_created_at        *int64
 	realm                        *string
 	nickname                     *string
 	private                      *bool
@@ -194,13 +194,13 @@ func (m *AccountMutation) IDs(ctx context.Context) ([]string, error) {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (m *AccountMutation) SetCreatedAt(i int) {
+func (m *AccountMutation) SetCreatedAt(i int64) {
 	m.created_at = &i
 	m.addcreated_at = nil
 }
 
 // CreatedAt returns the value of the "created_at" field in the mutation.
-func (m *AccountMutation) CreatedAt() (r int, exists bool) {
+func (m *AccountMutation) CreatedAt() (r int64, exists bool) {
 	v := m.created_at
 	if v == nil {
 		return
@@ -211,7 +211,7 @@ func (m *AccountMutation) CreatedAt() (r int, exists bool) {
 // OldCreatedAt returns the old "created_at" field's value of the Account entity.
 // If the Account object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *AccountMutation) OldCreatedAt(ctx context.Context) (v int, err error) {
+func (m *AccountMutation) OldCreatedAt(ctx context.Context) (v int64, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
 	}
@@ -226,7 +226,7 @@ func (m *AccountMutation) OldCreatedAt(ctx context.Context) (v int, err error) {
 }
 
 // AddCreatedAt adds i to the "created_at" field.
-func (m *AccountMutation) AddCreatedAt(i int) {
+func (m *AccountMutation) AddCreatedAt(i int64) {
 	if m.addcreated_at != nil {
 		*m.addcreated_at += i
 	} else {
@@ -235,7 +235,7 @@ func (m *AccountMutation) AddCreatedAt(i int) {
 }
 
 // AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
-func (m *AccountMutation) AddedCreatedAt() (r int, exists bool) {
+func (m *AccountMutation) AddedCreatedAt() (r int64, exists bool) {
 	v := m.addcreated_at
 	if v == nil {
 		return
@@ -250,13 +250,13 @@ func (m *AccountMutation) ResetCreatedAt() {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (m *AccountMutation) SetUpdatedAt(i int) {
+func (m *AccountMutation) SetUpdatedAt(i int64) {
 	m.updated_at = &i
 	m.addupdated_at = nil
 }
 
 // UpdatedAt returns the value of the "updated_at" field in the mutation.
-func (m *AccountMutation) UpdatedAt() (r int, exists bool) {
+func (m *AccountMutation) UpdatedAt() (r int64, exists bool) {
 	v := m.updated_at
 	if v == nil {
 		return
@@ -267,7 +267,7 @@ func (m *AccountMutation) UpdatedAt() (r int, exists bool) {
 // OldUpdatedAt returns the old "updated_at" field's value of the Account entity.
 // If the Account object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *AccountMutation) OldUpdatedAt(ctx context.Context) (v int, err error) {
+func (m *AccountMutation) OldUpdatedAt(ctx context.Context) (v int64, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
 	}
@@ -282,7 +282,7 @@ func (m *AccountMutation) OldUpdatedAt(ctx context.Context) (v int, err error) {
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (m *AccountMutation) AddUpdatedAt(i int) {
+func (m *AccountMutation) AddUpdatedAt(i int64) {
 	if m.addupdated_at != nil {
 		*m.addupdated_at += i
 	} else {
@@ -291,7 +291,7 @@ func (m *AccountMutation) AddUpdatedAt(i int) {
 }
 
 // AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
-func (m *AccountMutation) AddedUpdatedAt() (r int, exists bool) {
+func (m *AccountMutation) AddedUpdatedAt() (r int64, exists bool) {
 	v := m.addupdated_at
 	if v == nil {
 		return
@@ -306,13 +306,13 @@ func (m *AccountMutation) ResetUpdatedAt() {
 }
 
 // SetLastBattleTime sets the "last_battle_time" field.
-func (m *AccountMutation) SetLastBattleTime(i int) {
+func (m *AccountMutation) SetLastBattleTime(i int64) {
 	m.last_battle_time = &i
 	m.addlast_battle_time = nil
 }
 
 // LastBattleTime returns the value of the "last_battle_time" field in the mutation.
-func (m *AccountMutation) LastBattleTime() (r int, exists bool) {
+func (m *AccountMutation) LastBattleTime() (r int64, exists bool) {
 	v := m.last_battle_time
 	if v == nil {
 		return
@@ -323,7 +323,7 @@ func (m *AccountMutation) LastBattleTime() (r int, exists bool) {
 // OldLastBattleTime returns the old "last_battle_time" field's value of the Account entity.
 // If the Account object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *AccountMutation) OldLastBattleTime(ctx context.Context) (v int, err error) {
+func (m *AccountMutation) OldLastBattleTime(ctx context.Context) (v int64, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldLastBattleTime is only allowed on UpdateOne operations")
 	}
@@ -338,7 +338,7 @@ func (m *AccountMutation) OldLastBattleTime(ctx context.Context) (v int, err err
 }
 
 // AddLastBattleTime adds i to the "last_battle_time" field.
-func (m *AccountMutation) AddLastBattleTime(i int) {
+func (m *AccountMutation) AddLastBattleTime(i int64) {
 	if m.addlast_battle_time != nil {
 		*m.addlast_battle_time += i
 	} else {
@@ -347,7 +347,7 @@ func (m *AccountMutation) AddLastBattleTime(i int) {
 }
 
 // AddedLastBattleTime returns the value that was added to the "last_battle_time" field in this mutation.
-func (m *AccountMutation) AddedLastBattleTime() (r int, exists bool) {
+func (m *AccountMutation) AddedLastBattleTime() (r int64, exists bool) {
 	v := m.addlast_battle_time
 	if v == nil {
 		return
@@ -362,13 +362,13 @@ func (m *AccountMutation) ResetLastBattleTime() {
 }
 
 // SetAccountCreatedAt sets the "account_created_at" field.
-func (m *AccountMutation) SetAccountCreatedAt(i int) {
+func (m *AccountMutation) SetAccountCreatedAt(i int64) {
 	m.account_created_at = &i
 	m.addaccount_created_at = nil
 }
 
 // AccountCreatedAt returns the value of the "account_created_at" field in the mutation.
-func (m *AccountMutation) AccountCreatedAt() (r int, exists bool) {
+func (m *AccountMutation) AccountCreatedAt() (r int64, exists bool) {
 	v := m.account_created_at
 	if v == nil {
 		return
@@ -379,7 +379,7 @@ func (m *AccountMutation) AccountCreatedAt() (r int, exists bool) {
 // OldAccountCreatedAt returns the old "account_created_at" field's value of the Account entity.
 // If the Account object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *AccountMutation) OldAccountCreatedAt(ctx context.Context) (v int, err error) {
+func (m *AccountMutation) OldAccountCreatedAt(ctx context.Context) (v int64, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldAccountCreatedAt is only allowed on UpdateOne operations")
 	}
@@ -394,7 +394,7 @@ func (m *AccountMutation) OldAccountCreatedAt(ctx context.Context) (v int, err e
 }
 
 // AddAccountCreatedAt adds i to the "account_created_at" field.
-func (m *AccountMutation) AddAccountCreatedAt(i int) {
+func (m *AccountMutation) AddAccountCreatedAt(i int64) {
 	if m.addaccount_created_at != nil {
 		*m.addaccount_created_at += i
 	} else {
@@ -403,7 +403,7 @@ func (m *AccountMutation) AddAccountCreatedAt(i int) {
 }
 
 // AddedAccountCreatedAt returns the value that was added to the "account_created_at" field in this mutation.
-func (m *AccountMutation) AddedAccountCreatedAt() (r int, exists bool) {
+func (m *AccountMutation) AddedAccountCreatedAt() (r int64, exists bool) {
 	v := m.addaccount_created_at
 	if v == nil {
 		return
@@ -881,28 +881,28 @@ func (m *AccountMutation) OldField(ctx context.Context, name string) (ent.Value,
 func (m *AccountMutation) SetField(name string, value ent.Value) error {
 	switch name {
 	case account.FieldCreatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetCreatedAt(v)
 		return nil
 	case account.FieldUpdatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetUpdatedAt(v)
 		return nil
 	case account.FieldLastBattleTime:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetLastBattleTime(v)
 		return nil
 	case account.FieldAccountCreatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -982,28 +982,28 @@ func (m *AccountMutation) AddedField(name string) (ent.Value, bool) {
 func (m *AccountMutation) AddField(name string, value ent.Value) error {
 	switch name {
 	case account.FieldCreatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.AddCreatedAt(v)
 		return nil
 	case account.FieldUpdatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.AddUpdatedAt(v)
 		return nil
 	case account.FieldLastBattleTime:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.AddLastBattleTime(v)
 		return nil
 	case account.FieldAccountCreatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -1233,13 +1233,13 @@ type AccountSnapshotMutation struct {
 	op                  Op
 	typ                 string
 	id                  *string
-	created_at          *int
-	addcreated_at       *int
-	updated_at          *int
-	addupdated_at       *int
+	created_at          *int64
+	addcreated_at       *int64
+	updated_at          *int64
+	addupdated_at       *int64
 	_type               *models.SnapshotType
-	last_battle_time    *int
-	addlast_battle_time *int
+	last_battle_time    *int64
+	addlast_battle_time *int64
 	reference_id        *string
 	rating_battles      *int
 	addrating_battles   *int
@@ -1360,13 +1360,13 @@ func (m *AccountSnapshotMutation) IDs(ctx context.Context) ([]string, error) {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (m *AccountSnapshotMutation) SetCreatedAt(i int) {
+func (m *AccountSnapshotMutation) SetCreatedAt(i int64) {
 	m.created_at = &i
 	m.addcreated_at = nil
 }
 
 // CreatedAt returns the value of the "created_at" field in the mutation.
-func (m *AccountSnapshotMutation) CreatedAt() (r int, exists bool) {
+func (m *AccountSnapshotMutation) CreatedAt() (r int64, exists bool) {
 	v := m.created_at
 	if v == nil {
 		return
@@ -1377,7 +1377,7 @@ func (m *AccountSnapshotMutation) CreatedAt() (r int, exists bool) {
 // OldCreatedAt returns the old "created_at" field's value of the AccountSnapshot entity.
 // If the AccountSnapshot object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *AccountSnapshotMutation) OldCreatedAt(ctx context.Context) (v int, err error) {
+func (m *AccountSnapshotMutation) OldCreatedAt(ctx context.Context) (v int64, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
 	}
@@ -1392,7 +1392,7 @@ func (m *AccountSnapshotMutation) OldCreatedAt(ctx context.Context) (v int, err
 }
 
 // AddCreatedAt adds i to the "created_at" field.
-func (m *AccountSnapshotMutation) AddCreatedAt(i int) {
+func (m *AccountSnapshotMutation) AddCreatedAt(i int64) {
 	if m.addcreated_at != nil {
 		*m.addcreated_at += i
 	} else {
@@ -1401,7 +1401,7 @@ func (m *AccountSnapshotMutation) AddCreatedAt(i int) {
 }
 
 // AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
-func (m *AccountSnapshotMutation) AddedCreatedAt() (r int, exists bool) {
+func (m *AccountSnapshotMutation) AddedCreatedAt() (r int64, exists bool) {
 	v := m.addcreated_at
 	if v == nil {
 		return
@@ -1416,13 +1416,13 @@ func (m *AccountSnapshotMutation) ResetCreatedAt() {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (m *AccountSnapshotMutation) SetUpdatedAt(i int) {
+func (m *AccountSnapshotMutation) SetUpdatedAt(i int64) {
 	m.updated_at = &i
 	m.addupdated_at = nil
 }
 
 // UpdatedAt returns the value of the "updated_at" field in the mutation.
-func (m *AccountSnapshotMutation) UpdatedAt() (r int, exists bool) {
+func (m *AccountSnapshotMutation) UpdatedAt() (r int64, exists bool) {
 	v := m.updated_at
 	if v == nil {
 		return
@@ -1433,7 +1433,7 @@ func (m *AccountSnapshotMutation) UpdatedAt() (r int, exists bool) {
 // OldUpdatedAt returns the old "updated_at" field's value of the AccountSnapshot entity.
 // If the AccountSnapshot object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *AccountSnapshotMutation) OldUpdatedAt(ctx context.Context) (v int, err error) {
+func (m *AccountSnapshotMutation) OldUpdatedAt(ctx context.Context) (v int64, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
 	}
@@ -1448,7 +1448,7 @@ func (m *AccountSnapshotMutation) OldUpdatedAt(ctx context.Context) (v int, err
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (m *AccountSnapshotMutation) AddUpdatedAt(i int) {
+func (m *AccountSnapshotMutation) AddUpdatedAt(i int64) {
 	if m.addupdated_at != nil {
 		*m.addupdated_at += i
 	} else {
@@ -1457,7 +1457,7 @@ func (m *AccountSnapshotMutation) AddUpdatedAt(i int) {
 }
 
 // AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
-func (m *AccountSnapshotMutation) AddedUpdatedAt() (r int, exists bool) {
+func (m *AccountSnapshotMutation) AddedUpdatedAt() (r int64, exists bool) {
 	v := m.addupdated_at
 	if v == nil {
 		return
@@ -1508,13 +1508,13 @@ func (m *AccountSnapshotMutation) ResetType() {
 }
 
 // SetLastBattleTime sets the "last_battle_time" field.
-func (m *AccountSnapshotMutation) SetLastBattleTime(i int) {
+func (m *AccountSnapshotMutation) SetLastBattleTime(i int64) {
 	m.last_battle_time = &i
 	m.addlast_battle_time = nil
 }
 
 // LastBattleTime returns the value of the "last_battle_time" field in the mutation.
-func (m *AccountSnapshotMutation) LastBattleTime() (r int, exists bool) {
+func (m *AccountSnapshotMutation) LastBattleTime() (r int64, exists bool) {
 	v := m.last_battle_time
 	if v == nil {
 		return
@@ -1525,7 +1525,7 @@ func (m *AccountSnapshotMutation) LastBattleTime() (r int, exists bool) {
 // OldLastBattleTime returns the old "last_battle_time" field's value of the AccountSnapshot entity.
 // If the AccountSnapshot object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *AccountSnapshotMutation) OldLastBattleTime(ctx context.Context) (v int, err error) {
+func (m *AccountSnapshotMutation) OldLastBattleTime(ctx context.Context) (v int64, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldLastBattleTime is only allowed on UpdateOne operations")
 	}
@@ -1540,7 +1540,7 @@ func (m *AccountSnapshotMutation) OldLastBattleTime(ctx context.Context) (v int,
 }
 
 // AddLastBattleTime adds i to the "last_battle_time" field.
-func (m *AccountSnapshotMutation) AddLastBattleTime(i int) {
+func (m *AccountSnapshotMutation) AddLastBattleTime(i int64) {
 	if m.addlast_battle_time != nil {
 		*m.addlast_battle_time += i
 	} else {
@@ -1549,7 +1549,7 @@ func (m *AccountSnapshotMutation) AddLastBattleTime(i int) {
 }
 
 // AddedLastBattleTime returns the value that was added to the "last_battle_time" field in this mutation.
-func (m *AccountSnapshotMutation) AddedLastBattleTime() (r int, exists bool) {
+func (m *AccountSnapshotMutation) AddedLastBattleTime() (r int64, exists bool) {
 	v := m.addlast_battle_time
 	if v == nil {
 		return
@@ -1978,14 +1978,14 @@ func (m *AccountSnapshotMutation) OldField(ctx context.Context, name string) (en
 func (m *AccountSnapshotMutation) SetField(name string, value ent.Value) error {
 	switch name {
 	case accountsnapshot.FieldCreatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetCreatedAt(v)
 		return nil
 	case accountsnapshot.FieldUpdatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -1999,7 +1999,7 @@ func (m *AccountSnapshotMutation) SetField(name string, value ent.Value) error {
 		m.SetType(v)
 		return nil
 	case accountsnapshot.FieldLastBattleTime:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -2098,21 +2098,21 @@ func (m *AccountSnapshotMutation) AddedField(name string) (ent.Value, bool) {
 func (m *AccountSnapshotMutation) AddField(name string, value ent.Value) error {
 	switch name {
 	case accountsnapshot.FieldCreatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.AddCreatedAt(v)
 		return nil
 	case accountsnapshot.FieldUpdatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.AddUpdatedAt(v)
 		return nil
 	case accountsnapshot.FieldLastBattleTime:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -2273,16 +2273,16 @@ type AchievementsSnapshotMutation struct {
 	op                  Op
 	typ                 string
 	id                  *string
-	created_at          *int
-	addcreated_at       *int
-	updated_at          *int
-	addupdated_at       *int
+	created_at          *int64
+	addcreated_at       *int64
+	updated_at          *int64
+	addupdated_at       *int64
 	_type               *models.SnapshotType
 	reference_id        *string
 	battles             *int
 	addbattles          *int
-	last_battle_time    *int
-	addlast_battle_time *int
+	last_battle_time    *int64
+	addlast_battle_time *int64
 	data                *types.AchievementsFrame
 	clearedFields       map[string]struct{}
 	account             *string
@@ -2397,13 +2397,13 @@ func (m *AchievementsSnapshotMutation) IDs(ctx context.Context) ([]string, error
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (m *AchievementsSnapshotMutation) SetCreatedAt(i int) {
+func (m *AchievementsSnapshotMutation) SetCreatedAt(i int64) {
 	m.created_at = &i
 	m.addcreated_at = nil
 }
 
 // CreatedAt returns the value of the "created_at" field in the mutation.
-func (m *AchievementsSnapshotMutation) CreatedAt() (r int, exists bool) {
+func (m *AchievementsSnapshotMutation) CreatedAt() (r int64, exists bool) {
 	v := m.created_at
 	if v == nil {
 		return
@@ -2414,7 +2414,7 @@ func (m *AchievementsSnapshotMutation) CreatedAt() (r int, exists bool) {
 // OldCreatedAt returns the old "created_at" field's value of the AchievementsSnapshot entity.
 // If the AchievementsSnapshot object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *AchievementsSnapshotMutation) OldCreatedAt(ctx context.Context) (v int, err error) {
+func (m *AchievementsSnapshotMutation) OldCreatedAt(ctx context.Context) (v int64, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
 	}
@@ -2429,7 +2429,7 @@ func (m *AchievementsSnapshotMutation) OldCreatedAt(ctx context.Context) (v int,
 }
 
 // AddCreatedAt adds i to the "created_at" field.
-func (m *AchievementsSnapshotMutation) AddCreatedAt(i int) {
+func (m *AchievementsSnapshotMutation) AddCreatedAt(i int64) {
 	if m.addcreated_at != nil {
 		*m.addcreated_at += i
 	} else {
@@ -2438,7 +2438,7 @@ func (m *AchievementsSnapshotMutation) AddCreatedAt(i int) {
 }
 
 // AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
-func (m *AchievementsSnapshotMutation) AddedCreatedAt() (r int, exists bool) {
+func (m *AchievementsSnapshotMutation) AddedCreatedAt() (r int64, exists bool) {
 	v := m.addcreated_at
 	if v == nil {
 		return
@@ -2453,13 +2453,13 @@ func (m *AchievementsSnapshotMutation) ResetCreatedAt() {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (m *AchievementsSnapshotMutation) SetUpdatedAt(i int) {
+func (m *AchievementsSnapshotMutation) SetUpdatedAt(i int64) {
 	m.updated_at = &i
 	m.addupdated_at = nil
 }
 
 // UpdatedAt returns the value of the "updated_at" field in the mutation.
-func (m *AchievementsSnapshotMutation) UpdatedAt() (r int, exists bool) {
+func (m *AchievementsSnapshotMutation) UpdatedAt() (r int64, exists bool) {
 	v := m.updated_at
 	if v == nil {
 		return
@@ -2470,7 +2470,7 @@ func (m *AchievementsSnapshotMutation) UpdatedAt() (r int, exists bool) {
 // OldUpdatedAt returns the old "updated_at" field's value of the AchievementsSnapshot entity.
 // If the AchievementsSnapshot object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *AchievementsSnapshotMutation) OldUpdatedAt(ctx context.Context) (v int, err error) {
+func (m *AchievementsSnapshotMutation) OldUpdatedAt(ctx context.Context) (v int64, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
 	}
@@ -2485,7 +2485,7 @@ func (m *AchievementsSnapshotMutation) OldUpdatedAt(ctx context.Context) (v int,
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (m *AchievementsSnapshotMutation) AddUpdatedAt(i int) {
+func (m *AchievementsSnapshotMutation) AddUpdatedAt(i int64) {
 	if m.addupdated_at != nil {
 		*m.addupdated_at += i
 	} else {
@@ -2494,7 +2494,7 @@ func (m *AchievementsSnapshotMutation) AddUpdatedAt(i int) {
 }
 
 // AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
-func (m *AchievementsSnapshotMutation) AddedUpdatedAt() (r int, exists bool) {
+func (m *AchievementsSnapshotMutation) AddedUpdatedAt() (r int64, exists bool) {
 	v := m.addupdated_at
 	if v == nil {
 		return
@@ -2673,13 +2673,13 @@ func (m *AchievementsSnapshotMutation) ResetBattles() {
 }
 
 // SetLastBattleTime sets the "last_battle_time" field.
-func (m *AchievementsSnapshotMutation) SetLastBattleTime(i int) {
+func (m *AchievementsSnapshotMutation) SetLastBattleTime(i int64) {
 	m.last_battle_time = &i
 	m.addlast_battle_time = nil
 }
 
 // LastBattleTime returns the value of the "last_battle_time" field in the mutation.
-func (m *AchievementsSnapshotMutation) LastBattleTime() (r int, exists bool) {
+func (m *AchievementsSnapshotMutation) LastBattleTime() (r int64, exists bool) {
 	v := m.last_battle_time
 	if v == nil {
 		return
@@ -2690,7 +2690,7 @@ func (m *AchievementsSnapshotMutation) LastBattleTime() (r int, exists bool) {
 // OldLastBattleTime returns the old "last_battle_time" field's value of the AchievementsSnapshot entity.
 // If the AchievementsSnapshot object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *AchievementsSnapshotMutation) OldLastBattleTime(ctx context.Context) (v int, err error) {
+func (m *AchievementsSnapshotMutation) OldLastBattleTime(ctx context.Context) (v int64, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldLastBattleTime is only allowed on UpdateOne operations")
 	}
@@ -2705,7 +2705,7 @@ func (m *AchievementsSnapshotMutation) OldLastBattleTime(ctx context.Context) (v
 }
 
 // AddLastBattleTime adds i to the "last_battle_time" field.
-func (m *AchievementsSnapshotMutation) AddLastBattleTime(i int) {
+func (m *AchievementsSnapshotMutation) AddLastBattleTime(i int64) {
 	if m.addlast_battle_time != nil {
 		*m.addlast_battle_time += i
 	} else {
@@ -2714,7 +2714,7 @@ func (m *AchievementsSnapshotMutation) AddLastBattleTime(i int) {
 }
 
 // AddedLastBattleTime returns the value that was added to the "last_battle_time" field in this mutation.
-func (m *AchievementsSnapshotMutation) AddedLastBattleTime() (r int, exists bool) {
+func (m *AchievementsSnapshotMutation) AddedLastBattleTime() (r int64, exists bool) {
 	v := m.addlast_battle_time
 	if v == nil {
 		return
@@ -2909,14 +2909,14 @@ func (m *AchievementsSnapshotMutation) OldField(ctx context.Context, name string
 func (m *AchievementsSnapshotMutation) SetField(name string, value ent.Value) error {
 	switch name {
 	case achievementssnapshot.FieldCreatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetCreatedAt(v)
 		return nil
 	case achievementssnapshot.FieldUpdatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -2951,7 +2951,7 @@ func (m *AchievementsSnapshotMutation) SetField(name string, value ent.Value) er
 		m.SetBattles(v)
 		return nil
 	case achievementssnapshot.FieldLastBattleTime:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -3010,14 +3010,14 @@ func (m *AchievementsSnapshotMutation) AddedField(name string) (ent.Value, bool)
 func (m *AchievementsSnapshotMutation) AddField(name string, value ent.Value) error {
 	switch name {
 	case achievementssnapshot.FieldCreatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.AddCreatedAt(v)
 		return nil
 	case achievementssnapshot.FieldUpdatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -3031,7 +3031,7 @@ func (m *AchievementsSnapshotMutation) AddField(name string, value ent.Value) er
 		m.AddBattles(v)
 		return nil
 	case achievementssnapshot.FieldLastBattleTime:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -3172,10 +3172,10 @@ type AppConfigurationMutation struct {
 	op            Op
 	typ           string
 	id            *string
-	created_at    *int
-	addcreated_at *int
-	updated_at    *int
-	addupdated_at *int
+	created_at    *int64
+	addcreated_at *int64
+	updated_at    *int64
+	addupdated_at *int64
 	key           *string
 	value         *any
 	metadata      *map[string]interface{}
@@ -3290,13 +3290,13 @@ func (m *AppConfigurationMutation) IDs(ctx context.Context) ([]string, error) {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (m *AppConfigurationMutation) SetCreatedAt(i int) {
+func (m *AppConfigurationMutation) SetCreatedAt(i int64) {
 	m.created_at = &i
 	m.addcreated_at = nil
 }
 
 // CreatedAt returns the value of the "created_at" field in the mutation.
-func (m *AppConfigurationMutation) CreatedAt() (r int, exists bool) {
+func (m *AppConfigurationMutation) CreatedAt() (r int64, exists bool) {
 	v := m.created_at
 	if v == nil {
 		return
@@ -3307,7 +3307,7 @@ func (m *AppConfigurationMutation) CreatedAt() (r int, exists bool) {
 // OldCreatedAt returns the old "created_at" field's value of the AppConfiguration entity.
 // If the AppConfiguration object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *AppConfigurationMutation) OldCreatedAt(ctx context.Context) (v int, err error) {
+func (m *AppConfigurationMutation) OldCreatedAt(ctx context.Context) (v int64, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
 	}
@@ -3322,7 +3322,7 @@ func (m *AppConfigurationMutation) OldCreatedAt(ctx context.Context) (v int, err
 }
 
 // AddCreatedAt adds i to the "created_at" field.
-func (m *AppConfigurationMutation) AddCreatedAt(i int) {
+func (m *AppConfigurationMutation) AddCreatedAt(i int64) {
 	if m.addcreated_at != nil {
 		*m.addcreated_at += i
 	} else {
@@ -3331,7 +3331,7 @@ func (m *AppConfigurationMutation) AddCreatedAt(i int) {
 }
 
 // AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
-func (m *AppConfigurationMutation) AddedCreatedAt() (r int, exists bool) {
+func (m *AppConfigurationMutation) AddedCreatedAt() (r int64, exists bool) {
 	v := m.addcreated_at
 	if v == nil {
 		return
@@ -3346,13 +3346,13 @@ func (m *AppConfigurationMutation) ResetCreatedAt() {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (m *AppConfigurationMutation) SetUpdatedAt(i int) {
+func (m *AppConfigurationMutation) SetUpdatedAt(i int64) {
 	m.updated_at = &i
 	m.addupdated_at = nil
 }
 
 // UpdatedAt returns the value of the "updated_at" field in the mutation.
-func (m *AppConfigurationMutation) UpdatedAt() (r int, exists bool) {
+func (m *AppConfigurationMutation) UpdatedAt() (r int64, exists bool) {
 	v := m.updated_at
 	if v == nil {
 		return
@@ -3363,7 +3363,7 @@ func (m *AppConfigurationMutation) UpdatedAt() (r int, exists bool) {
 // OldUpdatedAt returns the old "updated_at" field's value of the AppConfiguration entity.
 // If the AppConfiguration object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *AppConfigurationMutation) OldUpdatedAt(ctx context.Context) (v int, err error) {
+func (m *AppConfigurationMutation) OldUpdatedAt(ctx context.Context) (v int64, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
 	}
@@ -3378,7 +3378,7 @@ func (m *AppConfigurationMutation) OldUpdatedAt(ctx context.Context) (v int, err
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (m *AppConfigurationMutation) AddUpdatedAt(i int) {
+func (m *AppConfigurationMutation) AddUpdatedAt(i int64) {
 	if m.addupdated_at != nil {
 		*m.addupdated_at += i
 	} else {
@@ -3387,7 +3387,7 @@ func (m *AppConfigurationMutation) AddUpdatedAt(i int) {
 }
 
 // AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
-func (m *AppConfigurationMutation) AddedUpdatedAt() (r int, exists bool) {
+func (m *AppConfigurationMutation) AddedUpdatedAt() (r int64, exists bool) {
 	v := m.addupdated_at
 	if v == nil {
 		return
@@ -3619,14 +3619,14 @@ func (m *AppConfigurationMutation) OldField(ctx context.Context, name string) (e
 func (m *AppConfigurationMutation) SetField(name string, value ent.Value) error {
 	switch name {
 	case appconfiguration.FieldCreatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetCreatedAt(v)
 		return nil
 	case appconfiguration.FieldUpdatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -3689,14 +3689,14 @@ func (m *AppConfigurationMutation) AddedField(name string) (ent.Value, bool) {
 func (m *AppConfigurationMutation) AddField(name string, value ent.Value) error {
 	switch name {
 	case appconfiguration.FieldCreatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.AddCreatedAt(v)
 		return nil
 	case appconfiguration.FieldUpdatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -3811,10 +3811,10 @@ type ApplicationCommandMutation struct {
 	op            Op
 	typ           string
 	id            *string
-	created_at    *int
-	addcreated_at *int
-	updated_at    *int
-	addupdated_at *int
+	created_at    *int64
+	addcreated_at *int64
+	updated_at    *int64
+	addupdated_at *int64
 	name          *string
 	version       *string
 	options_hash  *string
@@ -3929,13 +3929,13 @@ func (m *ApplicationCommandMutation) IDs(ctx context.Context) ([]string, error)
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (m *ApplicationCommandMutation) SetCreatedAt(i int) {
+func (m *ApplicationCommandMutation) SetCreatedAt(i int64) {
 	m.created_at = &i
 	m.addcreated_at = nil
 }
 
 // CreatedAt returns the value of the "created_at" field in the mutation.
-func (m *ApplicationCommandMutation) CreatedAt() (r int, exists bool) {
+func (m *ApplicationCommandMutation) CreatedAt() (r int64, exists bool) {
 	v := m.created_at
 	if v == nil {
 		return
@@ -3946,7 +3946,7 @@ func (m *ApplicationCommandMutation) CreatedAt() (r int, exists bool) {
 // OldCreatedAt returns the old "created_at" field's value of the ApplicationCommand entity.
 // If the ApplicationCommand object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *ApplicationCommandMutation) OldCreatedAt(ctx context.Context) (v int, err error) {
+func (m *ApplicationCommandMutation) OldCreatedAt(ctx context.Context) (v int64, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
 	}
@@ -3961,7 +3961,7 @@ func (m *ApplicationCommandMutation) OldCreatedAt(ctx context.Context) (v int, e
 }
 
 // AddCreatedAt adds i to the "created_at" field.
-func (m *ApplicationCommandMutation) AddCreatedAt(i int) {
+func (m *ApplicationCommandMutation) AddCreatedAt(i int64) {
 	if m.addcreated_at != nil {
 		*m.addcreated_at += i
 	} else {
@@ -3970,7 +3970,7 @@ func (m *ApplicationCommandMutation) AddCreatedAt(i int) {
 }
 
 // AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
-func (m *ApplicationCommandMutation) AddedCreatedAt() (r int, exists bool) {
+func (m *ApplicationCommandMutation) AddedCreatedAt() (r int64, exists bool) {
 	v := m.addcreated_at
 	if v == nil {
 		return
@@ -3985,13 +3985,13 @@ func (m *ApplicationCommandMutation) ResetCreatedAt() {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (m *ApplicationCommandMutation) SetUpdatedAt(i int) {
+func (m *ApplicationCommandMutation) SetUpdatedAt(i int64) {
 	m.updated_at = &i
 	m.addupdated_at = nil
 }
 
 // UpdatedAt returns the value of the "updated_at" field in the mutation.
-func (m *ApplicationCommandMutation) UpdatedAt() (r int, exists bool) {
+func (m *ApplicationCommandMutation) UpdatedAt() (r int64, exists bool) {
 	v := m.updated_at
 	if v == nil {
 		return
@@ -4002,7 +4002,7 @@ func (m *ApplicationCommandMutation) UpdatedAt() (r int, exists bool) {
 // OldUpdatedAt returns the old "updated_at" field's value of the ApplicationCommand entity.
 // If the ApplicationCommand object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *ApplicationCommandMutation) OldUpdatedAt(ctx context.Context) (v int, err error) {
+func (m *ApplicationCommandMutation) OldUpdatedAt(ctx context.Context) (v int64, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
 	}
@@ -4017,7 +4017,7 @@ func (m *ApplicationCommandMutation) OldUpdatedAt(ctx context.Context) (v int, e
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (m *ApplicationCommandMutation) AddUpdatedAt(i int) {
+func (m *ApplicationCommandMutation) AddUpdatedAt(i int64) {
 	if m.addupdated_at != nil {
 		*m.addupdated_at += i
 	} else {
@@ -4026,7 +4026,7 @@ func (m *ApplicationCommandMutation) AddUpdatedAt(i int) {
 }
 
 // AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
-func (m *ApplicationCommandMutation) AddedUpdatedAt() (r int, exists bool) {
+func (m *ApplicationCommandMutation) AddedUpdatedAt() (r int64, exists bool) {
 	v := m.addupdated_at
 	if v == nil {
 		return
@@ -4245,14 +4245,14 @@ func (m *ApplicationCommandMutation) OldField(ctx context.Context, name string)
 func (m *ApplicationCommandMutation) SetField(name string, value ent.Value) error {
 	switch name {
 	case applicationcommand.FieldCreatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetCreatedAt(v)
 		return nil
 	case applicationcommand.FieldUpdatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -4315,14 +4315,14 @@ func (m *ApplicationCommandMutation) AddedField(name string) (ent.Value, bool) {
 func (m *ApplicationCommandMutation) AddField(name string, value ent.Value) error {
 	switch name {
 	case applicationcommand.FieldCreatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.AddCreatedAt(v)
 		return nil
 	case applicationcommand.FieldUpdatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -4428,10 +4428,10 @@ type ClanMutation struct {
 	op              Op
 	typ             string
 	id              *string
-	created_at      *int
-	addcreated_at   *int
-	updated_at      *int
-	addupdated_at   *int
+	created_at      *int64
+	addcreated_at   *int64
+	updated_at      *int64
+	addupdated_at   *int64
 	tag             *string
 	name            *string
 	emblem_id       *string
@@ -4551,13 +4551,13 @@ func (m *ClanMutation) IDs(ctx context.Context) ([]string, error) {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (m *ClanMutation) SetCreatedAt(i int) {
+func (m *ClanMutation) SetCreatedAt(i int64) {
 	m.created_at = &i
 	m.addcreated_at = nil
 }
 
 // CreatedAt returns the value of the "created_at" field in the mutation.
-func (m *ClanMutation) CreatedAt() (r int, exists bool) {
+func (m *ClanMutation) CreatedAt() (r int64, exists bool) {
 	v := m.created_at
 	if v == nil {
 		return
@@ -4568,7 +4568,7 @@ func (m *ClanMutation) CreatedAt() (r int, exists bool) {
 // OldCreatedAt returns the old "created_at" field's value of the Clan entity.
 // If the Clan object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *ClanMutation) OldCreatedAt(ctx context.Context) (v int, err error) {
+func (m *ClanMutation) OldCreatedAt(ctx context.Context) (v int64, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
 	}
@@ -4583,7 +4583,7 @@ func (m *ClanMutation) OldCreatedAt(ctx context.Context) (v int, err error) {
 }
 
 // AddCreatedAt adds i to the "created_at" field.
-func (m *ClanMutation) AddCreatedAt(i int) {
+func (m *ClanMutation) AddCreatedAt(i int64) {
 	if m.addcreated_at != nil {
 		*m.addcreated_at += i
 	} else {
@@ -4592,7 +4592,7 @@ func (m *ClanMutation) AddCreatedAt(i int) {
 }
 
 // AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
-func (m *ClanMutation) AddedCreatedAt() (r int, exists bool) {
+func (m *ClanMutation) AddedCreatedAt() (r int64, exists bool) {
 	v := m.addcreated_at
 	if v == nil {
 		return
@@ -4607,13 +4607,13 @@ func (m *ClanMutation) ResetCreatedAt() {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (m *ClanMutation) SetUpdatedAt(i int) {
+func (m *ClanMutation) SetUpdatedAt(i int64) {
 	m.updated_at = &i
 	m.addupdated_at = nil
 }
 
 // UpdatedAt returns the value of the "updated_at" field in the mutation.
-func (m *ClanMutation) UpdatedAt() (r int, exists bool) {
+func (m *ClanMutation) UpdatedAt() (r int64, exists bool) {
 	v := m.updated_at
 	if v == nil {
 		return
@@ -4624,7 +4624,7 @@ func (m *ClanMutation) UpdatedAt() (r int, exists bool) {
 // OldUpdatedAt returns the old "updated_at" field's value of the Clan entity.
 // If the Clan object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *ClanMutation) OldUpdatedAt(ctx context.Context) (v int, err error) {
+func (m *ClanMutation) OldUpdatedAt(ctx context.Context) (v int64, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
 	}
@@ -4639,7 +4639,7 @@ func (m *ClanMutation) OldUpdatedAt(ctx context.Context) (v int, err error) {
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (m *ClanMutation) AddUpdatedAt(i int) {
+func (m *ClanMutation) AddUpdatedAt(i int64) {
 	if m.addupdated_at != nil {
 		*m.addupdated_at += i
 	} else {
@@ -4648,7 +4648,7 @@ func (m *ClanMutation) AddUpdatedAt(i int) {
 }
 
 // AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
-func (m *ClanMutation) AddedUpdatedAt() (r int, exists bool) {
+func (m *ClanMutation) AddedUpdatedAt() (r int64, exists bool) {
 	v := m.addupdated_at
 	if v == nil {
 		return
@@ -4992,14 +4992,14 @@ func (m *ClanMutation) OldField(ctx context.Context, name string) (ent.Value, er
 func (m *ClanMutation) SetField(name string, value ent.Value) error {
 	switch name {
 	case clan.FieldCreatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetCreatedAt(v)
 		return nil
 	case clan.FieldUpdatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -5069,14 +5069,14 @@ func (m *ClanMutation) AddedField(name string) (ent.Value, bool) {
 func (m *ClanMutation) AddField(name string, value ent.Value) error {
 	switch name {
 	case clan.FieldCreatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.AddCreatedAt(v)
 		return nil
 	case clan.FieldUpdatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -5230,19 +5230,19 @@ type CronTaskMutation struct {
 	op                 Op
 	typ                string
 	id                 *string
-	created_at         *int
-	addcreated_at      *int
-	updated_at         *int
-	addupdated_at      *int
-	_type              *string
+	created_at         *int64
+	addcreated_at      *int64
+	updated_at         *int64
+	addupdated_at      *int64
+	_type              *models.TaskType
 	reference_id       *string
 	targets            *[]string
 	appendtargets      []string
-	status             *string
-	scheduled_after    *int
-	addscheduled_after *int
-	last_run           *int
-	addlast_run        *int
+	status             *models.TaskStatus
+	scheduled_after    *int64
+	addscheduled_after *int64
+	last_run           *int64
+	addlast_run        *int64
 	logs               *[]models.TaskLog
 	appendlogs         []models.TaskLog
 	data               *map[string]interface{}
@@ -5357,13 +5357,13 @@ func (m *CronTaskMutation) IDs(ctx context.Context) ([]string, error) {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (m *CronTaskMutation) SetCreatedAt(i int) {
+func (m *CronTaskMutation) SetCreatedAt(i int64) {
 	m.created_at = &i
 	m.addcreated_at = nil
 }
 
 // CreatedAt returns the value of the "created_at" field in the mutation.
-func (m *CronTaskMutation) CreatedAt() (r int, exists bool) {
+func (m *CronTaskMutation) CreatedAt() (r int64, exists bool) {
 	v := m.created_at
 	if v == nil {
 		return
@@ -5374,7 +5374,7 @@ func (m *CronTaskMutation) CreatedAt() (r int, exists bool) {
 // OldCreatedAt returns the old "created_at" field's value of the CronTask entity.
 // If the CronTask object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *CronTaskMutation) OldCreatedAt(ctx context.Context) (v int, err error) {
+func (m *CronTaskMutation) OldCreatedAt(ctx context.Context) (v int64, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
 	}
@@ -5389,7 +5389,7 @@ func (m *CronTaskMutation) OldCreatedAt(ctx context.Context) (v int, err error)
 }
 
 // AddCreatedAt adds i to the "created_at" field.
-func (m *CronTaskMutation) AddCreatedAt(i int) {
+func (m *CronTaskMutation) AddCreatedAt(i int64) {
 	if m.addcreated_at != nil {
 		*m.addcreated_at += i
 	} else {
@@ -5398,7 +5398,7 @@ func (m *CronTaskMutation) AddCreatedAt(i int) {
 }
 
 // AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
-func (m *CronTaskMutation) AddedCreatedAt() (r int, exists bool) {
+func (m *CronTaskMutation) AddedCreatedAt() (r int64, exists bool) {
 	v := m.addcreated_at
 	if v == nil {
 		return
@@ -5413,13 +5413,13 @@ func (m *CronTaskMutation) ResetCreatedAt() {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (m *CronTaskMutation) SetUpdatedAt(i int) {
+func (m *CronTaskMutation) SetUpdatedAt(i int64) {
 	m.updated_at = &i
 	m.addupdated_at = nil
 }
 
 // UpdatedAt returns the value of the "updated_at" field in the mutation.
-func (m *CronTaskMutation) UpdatedAt() (r int, exists bool) {
+func (m *CronTaskMutation) UpdatedAt() (r int64, exists bool) {
 	v := m.updated_at
 	if v == nil {
 		return
@@ -5430,7 +5430,7 @@ func (m *CronTaskMutation) UpdatedAt() (r int, exists bool) {
 // OldUpdatedAt returns the old "updated_at" field's value of the CronTask entity.
 // If the CronTask object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *CronTaskMutation) OldUpdatedAt(ctx context.Context) (v int, err error) {
+func (m *CronTaskMutation) OldUpdatedAt(ctx context.Context) (v int64, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
 	}
@@ -5445,7 +5445,7 @@ func (m *CronTaskMutation) OldUpdatedAt(ctx context.Context) (v int, err error)
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (m *CronTaskMutation) AddUpdatedAt(i int) {
+func (m *CronTaskMutation) AddUpdatedAt(i int64) {
 	if m.addupdated_at != nil {
 		*m.addupdated_at += i
 	} else {
@@ -5454,7 +5454,7 @@ func (m *CronTaskMutation) AddUpdatedAt(i int) {
 }
 
 // AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
-func (m *CronTaskMutation) AddedUpdatedAt() (r int, exists bool) {
+func (m *CronTaskMutation) AddedUpdatedAt() (r int64, exists bool) {
 	v := m.addupdated_at
 	if v == nil {
 		return
@@ -5469,12 +5469,12 @@ func (m *CronTaskMutation) ResetUpdatedAt() {
 }
 
 // SetType sets the "type" field.
-func (m *CronTaskMutation) SetType(s string) {
-	m._type = &s
+func (m *CronTaskMutation) SetType(mt models.TaskType) {
+	m._type = &mt
 }
 
 // GetType returns the value of the "type" field in the mutation.
-func (m *CronTaskMutation) GetType() (r string, exists bool) {
+func (m *CronTaskMutation) GetType() (r models.TaskType, exists bool) {
 	v := m._type
 	if v == nil {
 		return
@@ -5485,7 +5485,7 @@ func (m *CronTaskMutation) GetType() (r string, exists bool) {
 // OldType returns the old "type" field's value of the CronTask entity.
 // If the CronTask object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *CronTaskMutation) OldType(ctx context.Context) (v string, err error) {
+func (m *CronTaskMutation) OldType(ctx context.Context) (v models.TaskType, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldType is only allowed on UpdateOne operations")
 	}
@@ -5592,12 +5592,12 @@ func (m *CronTaskMutation) ResetTargets() {
 }
 
 // SetStatus sets the "status" field.
-func (m *CronTaskMutation) SetStatus(s string) {
-	m.status = &s
+func (m *CronTaskMutation) SetStatus(ms models.TaskStatus) {
+	m.status = &ms
 }
 
 // Status returns the value of the "status" field in the mutation.
-func (m *CronTaskMutation) Status() (r string, exists bool) {
+func (m *CronTaskMutation) Status() (r models.TaskStatus, exists bool) {
 	v := m.status
 	if v == nil {
 		return
@@ -5608,7 +5608,7 @@ func (m *CronTaskMutation) Status() (r string, exists bool) {
 // OldStatus returns the old "status" field's value of the CronTask entity.
 // If the CronTask object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *CronTaskMutation) OldStatus(ctx context.Context) (v string, err error) {
+func (m *CronTaskMutation) OldStatus(ctx context.Context) (v models.TaskStatus, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldStatus is only allowed on UpdateOne operations")
 	}
@@ -5628,13 +5628,13 @@ func (m *CronTaskMutation) ResetStatus() {
 }
 
 // SetScheduledAfter sets the "scheduled_after" field.
-func (m *CronTaskMutation) SetScheduledAfter(i int) {
+func (m *CronTaskMutation) SetScheduledAfter(i int64) {
 	m.scheduled_after = &i
 	m.addscheduled_after = nil
 }
 
 // ScheduledAfter returns the value of the "scheduled_after" field in the mutation.
-func (m *CronTaskMutation) ScheduledAfter() (r int, exists bool) {
+func (m *CronTaskMutation) ScheduledAfter() (r int64, exists bool) {
 	v := m.scheduled_after
 	if v == nil {
 		return
@@ -5645,7 +5645,7 @@ func (m *CronTaskMutation) ScheduledAfter() (r int, exists bool) {
 // OldScheduledAfter returns the old "scheduled_after" field's value of the CronTask entity.
 // If the CronTask object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *CronTaskMutation) OldScheduledAfter(ctx context.Context) (v int, err error) {
+func (m *CronTaskMutation) OldScheduledAfter(ctx context.Context) (v int64, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldScheduledAfter is only allowed on UpdateOne operations")
 	}
@@ -5660,7 +5660,7 @@ func (m *CronTaskMutation) OldScheduledAfter(ctx context.Context) (v int, err er
 }
 
 // AddScheduledAfter adds i to the "scheduled_after" field.
-func (m *CronTaskMutation) AddScheduledAfter(i int) {
+func (m *CronTaskMutation) AddScheduledAfter(i int64) {
 	if m.addscheduled_after != nil {
 		*m.addscheduled_after += i
 	} else {
@@ -5669,7 +5669,7 @@ func (m *CronTaskMutation) AddScheduledAfter(i int) {
 }
 
 // AddedScheduledAfter returns the value that was added to the "scheduled_after" field in this mutation.
-func (m *CronTaskMutation) AddedScheduledAfter() (r int, exists bool) {
+func (m *CronTaskMutation) AddedScheduledAfter() (r int64, exists bool) {
 	v := m.addscheduled_after
 	if v == nil {
 		return
@@ -5684,13 +5684,13 @@ func (m *CronTaskMutation) ResetScheduledAfter() {
 }
 
 // SetLastRun sets the "last_run" field.
-func (m *CronTaskMutation) SetLastRun(i int) {
+func (m *CronTaskMutation) SetLastRun(i int64) {
 	m.last_run = &i
 	m.addlast_run = nil
 }
 
 // LastRun returns the value of the "last_run" field in the mutation.
-func (m *CronTaskMutation) LastRun() (r int, exists bool) {
+func (m *CronTaskMutation) LastRun() (r int64, exists bool) {
 	v := m.last_run
 	if v == nil {
 		return
@@ -5701,7 +5701,7 @@ func (m *CronTaskMutation) LastRun() (r int, exists bool) {
 // OldLastRun returns the old "last_run" field's value of the CronTask entity.
 // If the CronTask object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *CronTaskMutation) OldLastRun(ctx context.Context) (v int, err error) {
+func (m *CronTaskMutation) OldLastRun(ctx context.Context) (v int64, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldLastRun is only allowed on UpdateOne operations")
 	}
@@ -5716,7 +5716,7 @@ func (m *CronTaskMutation) OldLastRun(ctx context.Context) (v int, err error) {
 }
 
 // AddLastRun adds i to the "last_run" field.
-func (m *CronTaskMutation) AddLastRun(i int) {
+func (m *CronTaskMutation) AddLastRun(i int64) {
 	if m.addlast_run != nil {
 		*m.addlast_run += i
 	} else {
@@ -5725,7 +5725,7 @@ func (m *CronTaskMutation) AddLastRun(i int) {
 }
 
 // AddedLastRun returns the value that was added to the "last_run" field in this mutation.
-func (m *CronTaskMutation) AddedLastRun() (r int, exists bool) {
+func (m *CronTaskMutation) AddedLastRun() (r int64, exists bool) {
 	v := m.addlast_run
 	if v == nil {
 		return
@@ -5958,21 +5958,21 @@ func (m *CronTaskMutation) OldField(ctx context.Context, name string) (ent.Value
 func (m *CronTaskMutation) SetField(name string, value ent.Value) error {
 	switch name {
 	case crontask.FieldCreatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetCreatedAt(v)
 		return nil
 	case crontask.FieldUpdatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetUpdatedAt(v)
 		return nil
 	case crontask.FieldType:
-		v, ok := value.(string)
+		v, ok := value.(models.TaskType)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -5993,21 +5993,21 @@ func (m *CronTaskMutation) SetField(name string, value ent.Value) error {
 		m.SetTargets(v)
 		return nil
 	case crontask.FieldStatus:
-		v, ok := value.(string)
+		v, ok := value.(models.TaskStatus)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetStatus(v)
 		return nil
 	case crontask.FieldScheduledAfter:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetScheduledAfter(v)
 		return nil
 	case crontask.FieldLastRun:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -6073,28 +6073,28 @@ func (m *CronTaskMutation) AddedField(name string) (ent.Value, bool) {
 func (m *CronTaskMutation) AddField(name string, value ent.Value) error {
 	switch name {
 	case crontask.FieldCreatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.AddCreatedAt(v)
 		return nil
 	case crontask.FieldUpdatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.AddUpdatedAt(v)
 		return nil
 	case crontask.FieldScheduledAfter:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.AddScheduledAfter(v)
 		return nil
 	case crontask.FieldLastRun:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -6215,10 +6215,10 @@ type UserMutation struct {
 	op                   Op
 	typ                  string
 	id                   *string
-	created_at           *int
-	addcreated_at        *int
-	updated_at           *int
-	addupdated_at        *int
+	created_at           *int64
+	addcreated_at        *int64
+	updated_at           *int64
+	addupdated_at        *int64
 	permissions          *string
 	feature_flags        *[]string
 	appendfeature_flags  []string
@@ -6342,13 +6342,13 @@ func (m *UserMutation) IDs(ctx context.Context) ([]string, error) {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (m *UserMutation) SetCreatedAt(i int) {
+func (m *UserMutation) SetCreatedAt(i int64) {
 	m.created_at = &i
 	m.addcreated_at = nil
 }
 
 // CreatedAt returns the value of the "created_at" field in the mutation.
-func (m *UserMutation) CreatedAt() (r int, exists bool) {
+func (m *UserMutation) CreatedAt() (r int64, exists bool) {
 	v := m.created_at
 	if v == nil {
 		return
@@ -6359,7 +6359,7 @@ func (m *UserMutation) CreatedAt() (r int, exists bool) {
 // OldCreatedAt returns the old "created_at" field's value of the User entity.
 // If the User object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *UserMutation) OldCreatedAt(ctx context.Context) (v int, err error) {
+func (m *UserMutation) OldCreatedAt(ctx context.Context) (v int64, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
 	}
@@ -6374,7 +6374,7 @@ func (m *UserMutation) OldCreatedAt(ctx context.Context) (v int, err error) {
 }
 
 // AddCreatedAt adds i to the "created_at" field.
-func (m *UserMutation) AddCreatedAt(i int) {
+func (m *UserMutation) AddCreatedAt(i int64) {
 	if m.addcreated_at != nil {
 		*m.addcreated_at += i
 	} else {
@@ -6383,7 +6383,7 @@ func (m *UserMutation) AddCreatedAt(i int) {
 }
 
 // AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
-func (m *UserMutation) AddedCreatedAt() (r int, exists bool) {
+func (m *UserMutation) AddedCreatedAt() (r int64, exists bool) {
 	v := m.addcreated_at
 	if v == nil {
 		return
@@ -6398,13 +6398,13 @@ func (m *UserMutation) ResetCreatedAt() {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (m *UserMutation) SetUpdatedAt(i int) {
+func (m *UserMutation) SetUpdatedAt(i int64) {
 	m.updated_at = &i
 	m.addupdated_at = nil
 }
 
 // UpdatedAt returns the value of the "updated_at" field in the mutation.
-func (m *UserMutation) UpdatedAt() (r int, exists bool) {
+func (m *UserMutation) UpdatedAt() (r int64, exists bool) {
 	v := m.updated_at
 	if v == nil {
 		return
@@ -6415,7 +6415,7 @@ func (m *UserMutation) UpdatedAt() (r int, exists bool) {
 // OldUpdatedAt returns the old "updated_at" field's value of the User entity.
 // If the User object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *UserMutation) OldUpdatedAt(ctx context.Context) (v int, err error) {
+func (m *UserMutation) OldUpdatedAt(ctx context.Context) (v int64, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
 	}
@@ -6430,7 +6430,7 @@ func (m *UserMutation) OldUpdatedAt(ctx context.Context) (v int, err error) {
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (m *UserMutation) AddUpdatedAt(i int) {
+func (m *UserMutation) AddUpdatedAt(i int64) {
 	if m.addupdated_at != nil {
 		*m.addupdated_at += i
 	} else {
@@ -6439,7 +6439,7 @@ func (m *UserMutation) AddUpdatedAt(i int) {
 }
 
 // AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
-func (m *UserMutation) AddedUpdatedAt() (r int, exists bool) {
+func (m *UserMutation) AddedUpdatedAt() (r int64, exists bool) {
 	v := m.addupdated_at
 	if v == nil {
 		return
@@ -6806,14 +6806,14 @@ func (m *UserMutation) OldField(ctx context.Context, name string) (ent.Value, er
 func (m *UserMutation) SetField(name string, value ent.Value) error {
 	switch name {
 	case user.FieldCreatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetCreatedAt(v)
 		return nil
 	case user.FieldUpdatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -6869,14 +6869,14 @@ func (m *UserMutation) AddedField(name string) (ent.Value, bool) {
 func (m *UserMutation) AddField(name string, value ent.Value) error {
 	switch name {
 	case user.FieldCreatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.AddCreatedAt(v)
 		return nil
 	case user.FieldUpdatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -7076,10 +7076,10 @@ type UserConnectionMutation struct {
 	op            Op
 	typ           string
 	id            *string
-	created_at    *int
-	addcreated_at *int
-	updated_at    *int
-	addupdated_at *int
+	created_at    *int64
+	addcreated_at *int64
+	updated_at    *int64
+	addupdated_at *int64
 	_type         *models.ConnectionType
 	reference_id  *string
 	permissions   *string
@@ -7197,13 +7197,13 @@ func (m *UserConnectionMutation) IDs(ctx context.Context) ([]string, error) {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (m *UserConnectionMutation) SetCreatedAt(i int) {
+func (m *UserConnectionMutation) SetCreatedAt(i int64) {
 	m.created_at = &i
 	m.addcreated_at = nil
 }
 
 // CreatedAt returns the value of the "created_at" field in the mutation.
-func (m *UserConnectionMutation) CreatedAt() (r int, exists bool) {
+func (m *UserConnectionMutation) CreatedAt() (r int64, exists bool) {
 	v := m.created_at
 	if v == nil {
 		return
@@ -7214,7 +7214,7 @@ func (m *UserConnectionMutation) CreatedAt() (r int, exists bool) {
 // OldCreatedAt returns the old "created_at" field's value of the UserConnection entity.
 // If the UserConnection object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *UserConnectionMutation) OldCreatedAt(ctx context.Context) (v int, err error) {
+func (m *UserConnectionMutation) OldCreatedAt(ctx context.Context) (v int64, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
 	}
@@ -7229,7 +7229,7 @@ func (m *UserConnectionMutation) OldCreatedAt(ctx context.Context) (v int, err e
 }
 
 // AddCreatedAt adds i to the "created_at" field.
-func (m *UserConnectionMutation) AddCreatedAt(i int) {
+func (m *UserConnectionMutation) AddCreatedAt(i int64) {
 	if m.addcreated_at != nil {
 		*m.addcreated_at += i
 	} else {
@@ -7238,7 +7238,7 @@ func (m *UserConnectionMutation) AddCreatedAt(i int) {
 }
 
 // AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
-func (m *UserConnectionMutation) AddedCreatedAt() (r int, exists bool) {
+func (m *UserConnectionMutation) AddedCreatedAt() (r int64, exists bool) {
 	v := m.addcreated_at
 	if v == nil {
 		return
@@ -7253,13 +7253,13 @@ func (m *UserConnectionMutation) ResetCreatedAt() {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (m *UserConnectionMutation) SetUpdatedAt(i int) {
+func (m *UserConnectionMutation) SetUpdatedAt(i int64) {
 	m.updated_at = &i
 	m.addupdated_at = nil
 }
 
 // UpdatedAt returns the value of the "updated_at" field in the mutation.
-func (m *UserConnectionMutation) UpdatedAt() (r int, exists bool) {
+func (m *UserConnectionMutation) UpdatedAt() (r int64, exists bool) {
 	v := m.updated_at
 	if v == nil {
 		return
@@ -7270,7 +7270,7 @@ func (m *UserConnectionMutation) UpdatedAt() (r int, exists bool) {
 // OldUpdatedAt returns the old "updated_at" field's value of the UserConnection entity.
 // If the UserConnection object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *UserConnectionMutation) OldUpdatedAt(ctx context.Context) (v int, err error) {
+func (m *UserConnectionMutation) OldUpdatedAt(ctx context.Context) (v int64, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
 	}
@@ -7285,7 +7285,7 @@ func (m *UserConnectionMutation) OldUpdatedAt(ctx context.Context) (v int, err e
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (m *UserConnectionMutation) AddUpdatedAt(i int) {
+func (m *UserConnectionMutation) AddUpdatedAt(i int64) {
 	if m.addupdated_at != nil {
 		*m.addupdated_at += i
 	} else {
@@ -7294,7 +7294,7 @@ func (m *UserConnectionMutation) AddUpdatedAt(i int) {
 }
 
 // AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
-func (m *UserConnectionMutation) AddedUpdatedAt() (r int, exists bool) {
+func (m *UserConnectionMutation) AddedUpdatedAt() (r int64, exists bool) {
 	v := m.addupdated_at
 	if v == nil {
 		return
@@ -7652,14 +7652,14 @@ func (m *UserConnectionMutation) OldField(ctx context.Context, name string) (ent
 func (m *UserConnectionMutation) SetField(name string, value ent.Value) error {
 	switch name {
 	case userconnection.FieldCreatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetCreatedAt(v)
 		return nil
 	case userconnection.FieldUpdatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -7736,14 +7736,14 @@ func (m *UserConnectionMutation) AddedField(name string) (ent.Value, bool) {
 func (m *UserConnectionMutation) AddField(name string, value ent.Value) error {
 	switch name {
 	case userconnection.FieldCreatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.AddCreatedAt(v)
 		return nil
 	case userconnection.FieldUpdatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -7896,10 +7896,10 @@ type UserContentMutation struct {
 	op            Op
 	typ           string
 	id            *string
-	created_at    *int
-	addcreated_at *int
-	updated_at    *int
-	addupdated_at *int
+	created_at    *int64
+	addcreated_at *int64
+	updated_at    *int64
+	addupdated_at *int64
 	_type         *models.UserContentType
 	reference_id  *string
 	value         *any
@@ -8017,13 +8017,13 @@ func (m *UserContentMutation) IDs(ctx context.Context) ([]string, error) {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (m *UserContentMutation) SetCreatedAt(i int) {
+func (m *UserContentMutation) SetCreatedAt(i int64) {
 	m.created_at = &i
 	m.addcreated_at = nil
 }
 
 // CreatedAt returns the value of the "created_at" field in the mutation.
-func (m *UserContentMutation) CreatedAt() (r int, exists bool) {
+func (m *UserContentMutation) CreatedAt() (r int64, exists bool) {
 	v := m.created_at
 	if v == nil {
 		return
@@ -8034,7 +8034,7 @@ func (m *UserContentMutation) CreatedAt() (r int, exists bool) {
 // OldCreatedAt returns the old "created_at" field's value of the UserContent entity.
 // If the UserContent object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *UserContentMutation) OldCreatedAt(ctx context.Context) (v int, err error) {
+func (m *UserContentMutation) OldCreatedAt(ctx context.Context) (v int64, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
 	}
@@ -8049,7 +8049,7 @@ func (m *UserContentMutation) OldCreatedAt(ctx context.Context) (v int, err erro
 }
 
 // AddCreatedAt adds i to the "created_at" field.
-func (m *UserContentMutation) AddCreatedAt(i int) {
+func (m *UserContentMutation) AddCreatedAt(i int64) {
 	if m.addcreated_at != nil {
 		*m.addcreated_at += i
 	} else {
@@ -8058,7 +8058,7 @@ func (m *UserContentMutation) AddCreatedAt(i int) {
 }
 
 // AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
-func (m *UserContentMutation) AddedCreatedAt() (r int, exists bool) {
+func (m *UserContentMutation) AddedCreatedAt() (r int64, exists bool) {
 	v := m.addcreated_at
 	if v == nil {
 		return
@@ -8073,13 +8073,13 @@ func (m *UserContentMutation) ResetCreatedAt() {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (m *UserContentMutation) SetUpdatedAt(i int) {
+func (m *UserContentMutation) SetUpdatedAt(i int64) {
 	m.updated_at = &i
 	m.addupdated_at = nil
 }
 
 // UpdatedAt returns the value of the "updated_at" field in the mutation.
-func (m *UserContentMutation) UpdatedAt() (r int, exists bool) {
+func (m *UserContentMutation) UpdatedAt() (r int64, exists bool) {
 	v := m.updated_at
 	if v == nil {
 		return
@@ -8090,7 +8090,7 @@ func (m *UserContentMutation) UpdatedAt() (r int, exists bool) {
 // OldUpdatedAt returns the old "updated_at" field's value of the UserContent entity.
 // If the UserContent object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *UserContentMutation) OldUpdatedAt(ctx context.Context) (v int, err error) {
+func (m *UserContentMutation) OldUpdatedAt(ctx context.Context) (v int64, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
 	}
@@ -8105,7 +8105,7 @@ func (m *UserContentMutation) OldUpdatedAt(ctx context.Context) (v int, err erro
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (m *UserContentMutation) AddUpdatedAt(i int) {
+func (m *UserContentMutation) AddUpdatedAt(i int64) {
 	if m.addupdated_at != nil {
 		*m.addupdated_at += i
 	} else {
@@ -8114,7 +8114,7 @@ func (m *UserContentMutation) AddUpdatedAt(i int) {
 }
 
 // AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
-func (m *UserContentMutation) AddedUpdatedAt() (r int, exists bool) {
+func (m *UserContentMutation) AddedUpdatedAt() (r int64, exists bool) {
 	v := m.addupdated_at
 	if v == nil {
 		return
@@ -8446,14 +8446,14 @@ func (m *UserContentMutation) OldField(ctx context.Context, name string) (ent.Va
 func (m *UserContentMutation) SetField(name string, value ent.Value) error {
 	switch name {
 	case usercontent.FieldCreatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetCreatedAt(v)
 		return nil
 	case usercontent.FieldUpdatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -8530,14 +8530,14 @@ func (m *UserContentMutation) AddedField(name string) (ent.Value, bool) {
 func (m *UserContentMutation) AddField(name string, value ent.Value) error {
 	switch name {
 	case usercontent.FieldCreatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.AddCreatedAt(v)
 		return nil
 	case usercontent.FieldUpdatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -8675,13 +8675,13 @@ type UserSubscriptionMutation struct {
 	op            Op
 	typ           string
 	id            *string
-	created_at    *int
-	addcreated_at *int
-	updated_at    *int
-	addupdated_at *int
+	created_at    *int64
+	addcreated_at *int64
+	updated_at    *int64
+	addupdated_at *int64
 	_type         *models.SubscriptionType
-	expires_at    *int
-	addexpires_at *int
+	expires_at    *int64
+	addexpires_at *int64
 	permissions   *string
 	reference_id  *string
 	clearedFields map[string]struct{}
@@ -8797,13 +8797,13 @@ func (m *UserSubscriptionMutation) IDs(ctx context.Context) ([]string, error) {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (m *UserSubscriptionMutation) SetCreatedAt(i int) {
+func (m *UserSubscriptionMutation) SetCreatedAt(i int64) {
 	m.created_at = &i
 	m.addcreated_at = nil
 }
 
 // CreatedAt returns the value of the "created_at" field in the mutation.
-func (m *UserSubscriptionMutation) CreatedAt() (r int, exists bool) {
+func (m *UserSubscriptionMutation) CreatedAt() (r int64, exists bool) {
 	v := m.created_at
 	if v == nil {
 		return
@@ -8814,7 +8814,7 @@ func (m *UserSubscriptionMutation) CreatedAt() (r int, exists bool) {
 // OldCreatedAt returns the old "created_at" field's value of the UserSubscription entity.
 // If the UserSubscription object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *UserSubscriptionMutation) OldCreatedAt(ctx context.Context) (v int, err error) {
+func (m *UserSubscriptionMutation) OldCreatedAt(ctx context.Context) (v int64, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
 	}
@@ -8829,7 +8829,7 @@ func (m *UserSubscriptionMutation) OldCreatedAt(ctx context.Context) (v int, err
 }
 
 // AddCreatedAt adds i to the "created_at" field.
-func (m *UserSubscriptionMutation) AddCreatedAt(i int) {
+func (m *UserSubscriptionMutation) AddCreatedAt(i int64) {
 	if m.addcreated_at != nil {
 		*m.addcreated_at += i
 	} else {
@@ -8838,7 +8838,7 @@ func (m *UserSubscriptionMutation) AddCreatedAt(i int) {
 }
 
 // AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
-func (m *UserSubscriptionMutation) AddedCreatedAt() (r int, exists bool) {
+func (m *UserSubscriptionMutation) AddedCreatedAt() (r int64, exists bool) {
 	v := m.addcreated_at
 	if v == nil {
 		return
@@ -8853,13 +8853,13 @@ func (m *UserSubscriptionMutation) ResetCreatedAt() {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (m *UserSubscriptionMutation) SetUpdatedAt(i int) {
+func (m *UserSubscriptionMutation) SetUpdatedAt(i int64) {
 	m.updated_at = &i
 	m.addupdated_at = nil
 }
 
 // UpdatedAt returns the value of the "updated_at" field in the mutation.
-func (m *UserSubscriptionMutation) UpdatedAt() (r int, exists bool) {
+func (m *UserSubscriptionMutation) UpdatedAt() (r int64, exists bool) {
 	v := m.updated_at
 	if v == nil {
 		return
@@ -8870,7 +8870,7 @@ func (m *UserSubscriptionMutation) UpdatedAt() (r int, exists bool) {
 // OldUpdatedAt returns the old "updated_at" field's value of the UserSubscription entity.
 // If the UserSubscription object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *UserSubscriptionMutation) OldUpdatedAt(ctx context.Context) (v int, err error) {
+func (m *UserSubscriptionMutation) OldUpdatedAt(ctx context.Context) (v int64, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
 	}
@@ -8885,7 +8885,7 @@ func (m *UserSubscriptionMutation) OldUpdatedAt(ctx context.Context) (v int, err
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (m *UserSubscriptionMutation) AddUpdatedAt(i int) {
+func (m *UserSubscriptionMutation) AddUpdatedAt(i int64) {
 	if m.addupdated_at != nil {
 		*m.addupdated_at += i
 	} else {
@@ -8894,7 +8894,7 @@ func (m *UserSubscriptionMutation) AddUpdatedAt(i int) {
 }
 
 // AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
-func (m *UserSubscriptionMutation) AddedUpdatedAt() (r int, exists bool) {
+func (m *UserSubscriptionMutation) AddedUpdatedAt() (r int64, exists bool) {
 	v := m.addupdated_at
 	if v == nil {
 		return
@@ -8945,13 +8945,13 @@ func (m *UserSubscriptionMutation) ResetType() {
 }
 
 // SetExpiresAt sets the "expires_at" field.
-func (m *UserSubscriptionMutation) SetExpiresAt(i int) {
+func (m *UserSubscriptionMutation) SetExpiresAt(i int64) {
 	m.expires_at = &i
 	m.addexpires_at = nil
 }
 
 // ExpiresAt returns the value of the "expires_at" field in the mutation.
-func (m *UserSubscriptionMutation) ExpiresAt() (r int, exists bool) {
+func (m *UserSubscriptionMutation) ExpiresAt() (r int64, exists bool) {
 	v := m.expires_at
 	if v == nil {
 		return
@@ -8962,7 +8962,7 @@ func (m *UserSubscriptionMutation) ExpiresAt() (r int, exists bool) {
 // OldExpiresAt returns the old "expires_at" field's value of the UserSubscription entity.
 // If the UserSubscription object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *UserSubscriptionMutation) OldExpiresAt(ctx context.Context) (v int, err error) {
+func (m *UserSubscriptionMutation) OldExpiresAt(ctx context.Context) (v int64, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldExpiresAt is only allowed on UpdateOne operations")
 	}
@@ -8977,7 +8977,7 @@ func (m *UserSubscriptionMutation) OldExpiresAt(ctx context.Context) (v int, err
 }
 
 // AddExpiresAt adds i to the "expires_at" field.
-func (m *UserSubscriptionMutation) AddExpiresAt(i int) {
+func (m *UserSubscriptionMutation) AddExpiresAt(i int64) {
 	if m.addexpires_at != nil {
 		*m.addexpires_at += i
 	} else {
@@ -8986,7 +8986,7 @@ func (m *UserSubscriptionMutation) AddExpiresAt(i int) {
 }
 
 // AddedExpiresAt returns the value that was added to the "expires_at" field in this mutation.
-func (m *UserSubscriptionMutation) AddedExpiresAt() (r int, exists bool) {
+func (m *UserSubscriptionMutation) AddedExpiresAt() (r int64, exists bool) {
 	v := m.addexpires_at
 	if v == nil {
 		return
@@ -9246,14 +9246,14 @@ func (m *UserSubscriptionMutation) OldField(ctx context.Context, name string) (e
 func (m *UserSubscriptionMutation) SetField(name string, value ent.Value) error {
 	switch name {
 	case usersubscription.FieldCreatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetCreatedAt(v)
 		return nil
 	case usersubscription.FieldUpdatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -9267,7 +9267,7 @@ func (m *UserSubscriptionMutation) SetField(name string, value ent.Value) error
 		m.SetType(v)
 		return nil
 	case usersubscription.FieldExpiresAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -9335,21 +9335,21 @@ func (m *UserSubscriptionMutation) AddedField(name string) (ent.Value, bool) {
 func (m *UserSubscriptionMutation) AddField(name string, value ent.Value) error {
 	switch name {
 	case usersubscription.FieldCreatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.AddCreatedAt(v)
 		return nil
 	case usersubscription.FieldUpdatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.AddUpdatedAt(v)
 		return nil
 	case usersubscription.FieldExpiresAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -9487,10 +9487,10 @@ type VehicleMutation struct {
 	op              Op
 	typ             string
 	id              *string
-	created_at      *int
-	addcreated_at   *int
-	updated_at      *int
-	addupdated_at   *int
+	created_at      *int64
+	addcreated_at   *int64
+	updated_at      *int64
+	addupdated_at   *int64
 	tier            *int
 	addtier         *int
 	localized_names *map[string]string
@@ -9605,13 +9605,13 @@ func (m *VehicleMutation) IDs(ctx context.Context) ([]string, error) {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (m *VehicleMutation) SetCreatedAt(i int) {
+func (m *VehicleMutation) SetCreatedAt(i int64) {
 	m.created_at = &i
 	m.addcreated_at = nil
 }
 
 // CreatedAt returns the value of the "created_at" field in the mutation.
-func (m *VehicleMutation) CreatedAt() (r int, exists bool) {
+func (m *VehicleMutation) CreatedAt() (r int64, exists bool) {
 	v := m.created_at
 	if v == nil {
 		return
@@ -9622,7 +9622,7 @@ func (m *VehicleMutation) CreatedAt() (r int, exists bool) {
 // OldCreatedAt returns the old "created_at" field's value of the Vehicle entity.
 // If the Vehicle object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *VehicleMutation) OldCreatedAt(ctx context.Context) (v int, err error) {
+func (m *VehicleMutation) OldCreatedAt(ctx context.Context) (v int64, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
 	}
@@ -9637,7 +9637,7 @@ func (m *VehicleMutation) OldCreatedAt(ctx context.Context) (v int, err error) {
 }
 
 // AddCreatedAt adds i to the "created_at" field.
-func (m *VehicleMutation) AddCreatedAt(i int) {
+func (m *VehicleMutation) AddCreatedAt(i int64) {
 	if m.addcreated_at != nil {
 		*m.addcreated_at += i
 	} else {
@@ -9646,7 +9646,7 @@ func (m *VehicleMutation) AddCreatedAt(i int) {
 }
 
 // AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
-func (m *VehicleMutation) AddedCreatedAt() (r int, exists bool) {
+func (m *VehicleMutation) AddedCreatedAt() (r int64, exists bool) {
 	v := m.addcreated_at
 	if v == nil {
 		return
@@ -9661,13 +9661,13 @@ func (m *VehicleMutation) ResetCreatedAt() {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (m *VehicleMutation) SetUpdatedAt(i int) {
+func (m *VehicleMutation) SetUpdatedAt(i int64) {
 	m.updated_at = &i
 	m.addupdated_at = nil
 }
 
 // UpdatedAt returns the value of the "updated_at" field in the mutation.
-func (m *VehicleMutation) UpdatedAt() (r int, exists bool) {
+func (m *VehicleMutation) UpdatedAt() (r int64, exists bool) {
 	v := m.updated_at
 	if v == nil {
 		return
@@ -9678,7 +9678,7 @@ func (m *VehicleMutation) UpdatedAt() (r int, exists bool) {
 // OldUpdatedAt returns the old "updated_at" field's value of the Vehicle entity.
 // If the Vehicle object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *VehicleMutation) OldUpdatedAt(ctx context.Context) (v int, err error) {
+func (m *VehicleMutation) OldUpdatedAt(ctx context.Context) (v int64, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
 	}
@@ -9693,7 +9693,7 @@ func (m *VehicleMutation) OldUpdatedAt(ctx context.Context) (v int, err error) {
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (m *VehicleMutation) AddUpdatedAt(i int) {
+func (m *VehicleMutation) AddUpdatedAt(i int64) {
 	if m.addupdated_at != nil {
 		*m.addupdated_at += i
 	} else {
@@ -9702,7 +9702,7 @@ func (m *VehicleMutation) AddUpdatedAt(i int) {
 }
 
 // AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
-func (m *VehicleMutation) AddedUpdatedAt() (r int, exists bool) {
+func (m *VehicleMutation) AddedUpdatedAt() (r int64, exists bool) {
 	v := m.addupdated_at
 	if v == nil {
 		return
@@ -9898,14 +9898,14 @@ func (m *VehicleMutation) OldField(ctx context.Context, name string) (ent.Value,
 func (m *VehicleMutation) SetField(name string, value ent.Value) error {
 	switch name {
 	case vehicle.FieldCreatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetCreatedAt(v)
 		return nil
 	case vehicle.FieldUpdatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -9966,14 +9966,14 @@ func (m *VehicleMutation) AddedField(name string) (ent.Value, bool) {
 func (m *VehicleMutation) AddField(name string, value ent.Value) error {
 	switch name {
 	case vehicle.FieldCreatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.AddCreatedAt(v)
 		return nil
 	case vehicle.FieldUpdatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -10083,11 +10083,11 @@ type VehicleAverageMutation struct {
 	op            Op
 	typ           string
 	id            *string
-	created_at    *int
-	addcreated_at *int
-	updated_at    *int
-	addupdated_at *int
-	data          *map[string]frame.StatsFrame
+	created_at    *int64
+	addcreated_at *int64
+	updated_at    *int64
+	addupdated_at *int64
+	data          *frame.StatsFrame
 	clearedFields map[string]struct{}
 	done          bool
 	oldValue      func(context.Context) (*VehicleAverage, error)
@@ -10199,13 +10199,13 @@ func (m *VehicleAverageMutation) IDs(ctx context.Context) ([]string, error) {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (m *VehicleAverageMutation) SetCreatedAt(i int) {
+func (m *VehicleAverageMutation) SetCreatedAt(i int64) {
 	m.created_at = &i
 	m.addcreated_at = nil
 }
 
 // CreatedAt returns the value of the "created_at" field in the mutation.
-func (m *VehicleAverageMutation) CreatedAt() (r int, exists bool) {
+func (m *VehicleAverageMutation) CreatedAt() (r int64, exists bool) {
 	v := m.created_at
 	if v == nil {
 		return
@@ -10216,7 +10216,7 @@ func (m *VehicleAverageMutation) CreatedAt() (r int, exists bool) {
 // OldCreatedAt returns the old "created_at" field's value of the VehicleAverage entity.
 // If the VehicleAverage object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *VehicleAverageMutation) OldCreatedAt(ctx context.Context) (v int, err error) {
+func (m *VehicleAverageMutation) OldCreatedAt(ctx context.Context) (v int64, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
 	}
@@ -10231,7 +10231,7 @@ func (m *VehicleAverageMutation) OldCreatedAt(ctx context.Context) (v int, err e
 }
 
 // AddCreatedAt adds i to the "created_at" field.
-func (m *VehicleAverageMutation) AddCreatedAt(i int) {
+func (m *VehicleAverageMutation) AddCreatedAt(i int64) {
 	if m.addcreated_at != nil {
 		*m.addcreated_at += i
 	} else {
@@ -10240,7 +10240,7 @@ func (m *VehicleAverageMutation) AddCreatedAt(i int) {
 }
 
 // AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
-func (m *VehicleAverageMutation) AddedCreatedAt() (r int, exists bool) {
+func (m *VehicleAverageMutation) AddedCreatedAt() (r int64, exists bool) {
 	v := m.addcreated_at
 	if v == nil {
 		return
@@ -10255,13 +10255,13 @@ func (m *VehicleAverageMutation) ResetCreatedAt() {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (m *VehicleAverageMutation) SetUpdatedAt(i int) {
+func (m *VehicleAverageMutation) SetUpdatedAt(i int64) {
 	m.updated_at = &i
 	m.addupdated_at = nil
 }
 
 // UpdatedAt returns the value of the "updated_at" field in the mutation.
-func (m *VehicleAverageMutation) UpdatedAt() (r int, exists bool) {
+func (m *VehicleAverageMutation) UpdatedAt() (r int64, exists bool) {
 	v := m.updated_at
 	if v == nil {
 		return
@@ -10272,7 +10272,7 @@ func (m *VehicleAverageMutation) UpdatedAt() (r int, exists bool) {
 // OldUpdatedAt returns the old "updated_at" field's value of the VehicleAverage entity.
 // If the VehicleAverage object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *VehicleAverageMutation) OldUpdatedAt(ctx context.Context) (v int, err error) {
+func (m *VehicleAverageMutation) OldUpdatedAt(ctx context.Context) (v int64, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
 	}
@@ -10287,7 +10287,7 @@ func (m *VehicleAverageMutation) OldUpdatedAt(ctx context.Context) (v int, err e
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (m *VehicleAverageMutation) AddUpdatedAt(i int) {
+func (m *VehicleAverageMutation) AddUpdatedAt(i int64) {
 	if m.addupdated_at != nil {
 		*m.addupdated_at += i
 	} else {
@@ -10296,7 +10296,7 @@ func (m *VehicleAverageMutation) AddUpdatedAt(i int) {
 }
 
 // AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
-func (m *VehicleAverageMutation) AddedUpdatedAt() (r int, exists bool) {
+func (m *VehicleAverageMutation) AddedUpdatedAt() (r int64, exists bool) {
 	v := m.addupdated_at
 	if v == nil {
 		return
@@ -10311,12 +10311,12 @@ func (m *VehicleAverageMutation) ResetUpdatedAt() {
 }
 
 // SetData sets the "data" field.
-func (m *VehicleAverageMutation) SetData(mf map[string]frame.StatsFrame) {
-	m.data = &mf
+func (m *VehicleAverageMutation) SetData(ff frame.StatsFrame) {
+	m.data = &ff
 }
 
 // Data returns the value of the "data" field in the mutation.
-func (m *VehicleAverageMutation) Data() (r map[string]frame.StatsFrame, exists bool) {
+func (m *VehicleAverageMutation) Data() (r frame.StatsFrame, exists bool) {
 	v := m.data
 	if v == nil {
 		return
@@ -10327,7 +10327,7 @@ func (m *VehicleAverageMutation) Data() (r map[string]frame.StatsFrame, exists b
 // OldData returns the old "data" field's value of the VehicleAverage entity.
 // If the VehicleAverage object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *VehicleAverageMutation) OldData(ctx context.Context) (v map[string]frame.StatsFrame, err error) {
+func (m *VehicleAverageMutation) OldData(ctx context.Context) (v frame.StatsFrame, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldData is only allowed on UpdateOne operations")
 	}
@@ -10429,21 +10429,21 @@ func (m *VehicleAverageMutation) OldField(ctx context.Context, name string) (ent
 func (m *VehicleAverageMutation) SetField(name string, value ent.Value) error {
 	switch name {
 	case vehicleaverage.FieldCreatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetCreatedAt(v)
 		return nil
 	case vehicleaverage.FieldUpdatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetUpdatedAt(v)
 		return nil
 	case vehicleaverage.FieldData:
-		v, ok := value.(map[string]frame.StatsFrame)
+		v, ok := value.(frame.StatsFrame)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -10485,14 +10485,14 @@ func (m *VehicleAverageMutation) AddedField(name string) (ent.Value, bool) {
 func (m *VehicleAverageMutation) AddField(name string, value ent.Value) error {
 	switch name {
 	case vehicleaverage.FieldCreatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.AddCreatedAt(v)
 		return nil
 	case vehicleaverage.FieldUpdatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -10592,17 +10592,17 @@ type VehicleSnapshotMutation struct {
 	op                  Op
 	typ                 string
 	id                  *string
-	created_at          *int
-	addcreated_at       *int
-	updated_at          *int
-	addupdated_at       *int
+	created_at          *int64
+	addcreated_at       *int64
+	updated_at          *int64
+	addupdated_at       *int64
 	_type               *models.SnapshotType
 	vehicle_id          *string
 	reference_id        *string
 	battles             *int
 	addbattles          *int
-	last_battle_time    *int
-	addlast_battle_time *int
+	last_battle_time    *int64
+	addlast_battle_time *int64
 	frame               *frame.StatsFrame
 	clearedFields       map[string]struct{}
 	account             *string
@@ -10717,13 +10717,13 @@ func (m *VehicleSnapshotMutation) IDs(ctx context.Context) ([]string, error) {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (m *VehicleSnapshotMutation) SetCreatedAt(i int) {
+func (m *VehicleSnapshotMutation) SetCreatedAt(i int64) {
 	m.created_at = &i
 	m.addcreated_at = nil
 }
 
 // CreatedAt returns the value of the "created_at" field in the mutation.
-func (m *VehicleSnapshotMutation) CreatedAt() (r int, exists bool) {
+func (m *VehicleSnapshotMutation) CreatedAt() (r int64, exists bool) {
 	v := m.created_at
 	if v == nil {
 		return
@@ -10734,7 +10734,7 @@ func (m *VehicleSnapshotMutation) CreatedAt() (r int, exists bool) {
 // OldCreatedAt returns the old "created_at" field's value of the VehicleSnapshot entity.
 // If the VehicleSnapshot object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *VehicleSnapshotMutation) OldCreatedAt(ctx context.Context) (v int, err error) {
+func (m *VehicleSnapshotMutation) OldCreatedAt(ctx context.Context) (v int64, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
 	}
@@ -10749,7 +10749,7 @@ func (m *VehicleSnapshotMutation) OldCreatedAt(ctx context.Context) (v int, err
 }
 
 // AddCreatedAt adds i to the "created_at" field.
-func (m *VehicleSnapshotMutation) AddCreatedAt(i int) {
+func (m *VehicleSnapshotMutation) AddCreatedAt(i int64) {
 	if m.addcreated_at != nil {
 		*m.addcreated_at += i
 	} else {
@@ -10758,7 +10758,7 @@ func (m *VehicleSnapshotMutation) AddCreatedAt(i int) {
 }
 
 // AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
-func (m *VehicleSnapshotMutation) AddedCreatedAt() (r int, exists bool) {
+func (m *VehicleSnapshotMutation) AddedCreatedAt() (r int64, exists bool) {
 	v := m.addcreated_at
 	if v == nil {
 		return
@@ -10773,13 +10773,13 @@ func (m *VehicleSnapshotMutation) ResetCreatedAt() {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (m *VehicleSnapshotMutation) SetUpdatedAt(i int) {
+func (m *VehicleSnapshotMutation) SetUpdatedAt(i int64) {
 	m.updated_at = &i
 	m.addupdated_at = nil
 }
 
 // UpdatedAt returns the value of the "updated_at" field in the mutation.
-func (m *VehicleSnapshotMutation) UpdatedAt() (r int, exists bool) {
+func (m *VehicleSnapshotMutation) UpdatedAt() (r int64, exists bool) {
 	v := m.updated_at
 	if v == nil {
 		return
@@ -10790,7 +10790,7 @@ func (m *VehicleSnapshotMutation) UpdatedAt() (r int, exists bool) {
 // OldUpdatedAt returns the old "updated_at" field's value of the VehicleSnapshot entity.
 // If the VehicleSnapshot object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *VehicleSnapshotMutation) OldUpdatedAt(ctx context.Context) (v int, err error) {
+func (m *VehicleSnapshotMutation) OldUpdatedAt(ctx context.Context) (v int64, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
 	}
@@ -10805,7 +10805,7 @@ func (m *VehicleSnapshotMutation) OldUpdatedAt(ctx context.Context) (v int, err
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (m *VehicleSnapshotMutation) AddUpdatedAt(i int) {
+func (m *VehicleSnapshotMutation) AddUpdatedAt(i int64) {
 	if m.addupdated_at != nil {
 		*m.addupdated_at += i
 	} else {
@@ -10814,7 +10814,7 @@ func (m *VehicleSnapshotMutation) AddUpdatedAt(i int) {
 }
 
 // AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
-func (m *VehicleSnapshotMutation) AddedUpdatedAt() (r int, exists bool) {
+func (m *VehicleSnapshotMutation) AddedUpdatedAt() (r int64, exists bool) {
 	v := m.addupdated_at
 	if v == nil {
 		return
@@ -11029,13 +11029,13 @@ func (m *VehicleSnapshotMutation) ResetBattles() {
 }
 
 // SetLastBattleTime sets the "last_battle_time" field.
-func (m *VehicleSnapshotMutation) SetLastBattleTime(i int) {
+func (m *VehicleSnapshotMutation) SetLastBattleTime(i int64) {
 	m.last_battle_time = &i
 	m.addlast_battle_time = nil
 }
 
 // LastBattleTime returns the value of the "last_battle_time" field in the mutation.
-func (m *VehicleSnapshotMutation) LastBattleTime() (r int, exists bool) {
+func (m *VehicleSnapshotMutation) LastBattleTime() (r int64, exists bool) {
 	v := m.last_battle_time
 	if v == nil {
 		return
@@ -11046,7 +11046,7 @@ func (m *VehicleSnapshotMutation) LastBattleTime() (r int, exists bool) {
 // OldLastBattleTime returns the old "last_battle_time" field's value of the VehicleSnapshot entity.
 // If the VehicleSnapshot object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *VehicleSnapshotMutation) OldLastBattleTime(ctx context.Context) (v int, err error) {
+func (m *VehicleSnapshotMutation) OldLastBattleTime(ctx context.Context) (v int64, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldLastBattleTime is only allowed on UpdateOne operations")
 	}
@@ -11061,7 +11061,7 @@ func (m *VehicleSnapshotMutation) OldLastBattleTime(ctx context.Context) (v int,
 }
 
 // AddLastBattleTime adds i to the "last_battle_time" field.
-func (m *VehicleSnapshotMutation) AddLastBattleTime(i int) {
+func (m *VehicleSnapshotMutation) AddLastBattleTime(i int64) {
 	if m.addlast_battle_time != nil {
 		*m.addlast_battle_time += i
 	} else {
@@ -11070,7 +11070,7 @@ func (m *VehicleSnapshotMutation) AddLastBattleTime(i int) {
 }
 
 // AddedLastBattleTime returns the value that was added to the "last_battle_time" field in this mutation.
-func (m *VehicleSnapshotMutation) AddedLastBattleTime() (r int, exists bool) {
+func (m *VehicleSnapshotMutation) AddedLastBattleTime() (r int64, exists bool) {
 	v := m.addlast_battle_time
 	if v == nil {
 		return
@@ -11272,14 +11272,14 @@ func (m *VehicleSnapshotMutation) OldField(ctx context.Context, name string) (en
 func (m *VehicleSnapshotMutation) SetField(name string, value ent.Value) error {
 	switch name {
 	case vehiclesnapshot.FieldCreatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetCreatedAt(v)
 		return nil
 	case vehiclesnapshot.FieldUpdatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -11321,7 +11321,7 @@ func (m *VehicleSnapshotMutation) SetField(name string, value ent.Value) error {
 		m.SetBattles(v)
 		return nil
 	case vehiclesnapshot.FieldLastBattleTime:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -11380,14 +11380,14 @@ func (m *VehicleSnapshotMutation) AddedField(name string) (ent.Value, bool) {
 func (m *VehicleSnapshotMutation) AddField(name string, value ent.Value) error {
 	switch name {
 	case vehiclesnapshot.FieldCreatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.AddCreatedAt(v)
 		return nil
 	case vehiclesnapshot.FieldUpdatedAt:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -11401,7 +11401,7 @@ func (m *VehicleSnapshotMutation) AddField(name string, value ent.Value) error {
 		m.AddBattles(v)
 		return nil
 	case vehiclesnapshot.FieldLastBattleTime:
-		v, ok := value.(int)
+		v, ok := value.(int64)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
diff --git a/internal/database/ent/db/runtime.go b/internal/database/ent/db/runtime.go
index 15bfe7e8..2b639c03 100644
--- a/internal/database/ent/db/runtime.go
+++ b/internal/database/ent/db/runtime.go
@@ -29,13 +29,13 @@ func init() {
 	// accountDescCreatedAt is the schema descriptor for created_at field.
 	accountDescCreatedAt := accountFields[1].Descriptor()
 	// account.DefaultCreatedAt holds the default value on creation for the created_at field.
-	account.DefaultCreatedAt = accountDescCreatedAt.Default.(func() int)
+	account.DefaultCreatedAt = accountDescCreatedAt.Default.(func() int64)
 	// accountDescUpdatedAt is the schema descriptor for updated_at field.
 	accountDescUpdatedAt := accountFields[2].Descriptor()
 	// account.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	account.DefaultUpdatedAt = accountDescUpdatedAt.Default.(func() int)
+	account.DefaultUpdatedAt = accountDescUpdatedAt.Default.(func() int64)
 	// account.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	account.UpdateDefaultUpdatedAt = accountDescUpdatedAt.UpdateDefault.(func() int)
+	account.UpdateDefaultUpdatedAt = accountDescUpdatedAt.UpdateDefault.(func() int64)
 	// accountDescRealm is the schema descriptor for realm field.
 	accountDescRealm := accountFields[5].Descriptor()
 	// account.RealmValidator is a validator for the "realm" field. It is called by the builders before save.
@@ -67,13 +67,13 @@ func init() {
 	// accountsnapshotDescCreatedAt is the schema descriptor for created_at field.
 	accountsnapshotDescCreatedAt := accountsnapshotFields[1].Descriptor()
 	// accountsnapshot.DefaultCreatedAt holds the default value on creation for the created_at field.
-	accountsnapshot.DefaultCreatedAt = accountsnapshotDescCreatedAt.Default.(func() int)
+	accountsnapshot.DefaultCreatedAt = accountsnapshotDescCreatedAt.Default.(func() int64)
 	// accountsnapshotDescUpdatedAt is the schema descriptor for updated_at field.
 	accountsnapshotDescUpdatedAt := accountsnapshotFields[2].Descriptor()
 	// accountsnapshot.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	accountsnapshot.DefaultUpdatedAt = accountsnapshotDescUpdatedAt.Default.(func() int)
+	accountsnapshot.DefaultUpdatedAt = accountsnapshotDescUpdatedAt.Default.(func() int64)
 	// accountsnapshot.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	accountsnapshot.UpdateDefaultUpdatedAt = accountsnapshotDescUpdatedAt.UpdateDefault.(func() int)
+	accountsnapshot.UpdateDefaultUpdatedAt = accountsnapshotDescUpdatedAt.UpdateDefault.(func() int64)
 	// accountsnapshotDescAccountID is the schema descriptor for account_id field.
 	accountsnapshotDescAccountID := accountsnapshotFields[5].Descriptor()
 	// accountsnapshot.AccountIDValidator is a validator for the "account_id" field. It is called by the builders before save.
@@ -91,13 +91,13 @@ func init() {
 	// achievementssnapshotDescCreatedAt is the schema descriptor for created_at field.
 	achievementssnapshotDescCreatedAt := achievementssnapshotFields[1].Descriptor()
 	// achievementssnapshot.DefaultCreatedAt holds the default value on creation for the created_at field.
-	achievementssnapshot.DefaultCreatedAt = achievementssnapshotDescCreatedAt.Default.(func() int)
+	achievementssnapshot.DefaultCreatedAt = achievementssnapshotDescCreatedAt.Default.(func() int64)
 	// achievementssnapshotDescUpdatedAt is the schema descriptor for updated_at field.
 	achievementssnapshotDescUpdatedAt := achievementssnapshotFields[2].Descriptor()
 	// achievementssnapshot.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	achievementssnapshot.DefaultUpdatedAt = achievementssnapshotDescUpdatedAt.Default.(func() int)
+	achievementssnapshot.DefaultUpdatedAt = achievementssnapshotDescUpdatedAt.Default.(func() int64)
 	// achievementssnapshot.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	achievementssnapshot.UpdateDefaultUpdatedAt = achievementssnapshotDescUpdatedAt.UpdateDefault.(func() int)
+	achievementssnapshot.UpdateDefaultUpdatedAt = achievementssnapshotDescUpdatedAt.UpdateDefault.(func() int64)
 	// achievementssnapshotDescAccountID is the schema descriptor for account_id field.
 	achievementssnapshotDescAccountID := achievementssnapshotFields[4].Descriptor()
 	// achievementssnapshot.AccountIDValidator is a validator for the "account_id" field. It is called by the builders before save.
@@ -115,13 +115,13 @@ func init() {
 	// appconfigurationDescCreatedAt is the schema descriptor for created_at field.
 	appconfigurationDescCreatedAt := appconfigurationFields[1].Descriptor()
 	// appconfiguration.DefaultCreatedAt holds the default value on creation for the created_at field.
-	appconfiguration.DefaultCreatedAt = appconfigurationDescCreatedAt.Default.(func() int)
+	appconfiguration.DefaultCreatedAt = appconfigurationDescCreatedAt.Default.(func() int64)
 	// appconfigurationDescUpdatedAt is the schema descriptor for updated_at field.
 	appconfigurationDescUpdatedAt := appconfigurationFields[2].Descriptor()
 	// appconfiguration.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	appconfiguration.DefaultUpdatedAt = appconfigurationDescUpdatedAt.Default.(func() int)
+	appconfiguration.DefaultUpdatedAt = appconfigurationDescUpdatedAt.Default.(func() int64)
 	// appconfiguration.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	appconfiguration.UpdateDefaultUpdatedAt = appconfigurationDescUpdatedAt.UpdateDefault.(func() int)
+	appconfiguration.UpdateDefaultUpdatedAt = appconfigurationDescUpdatedAt.UpdateDefault.(func() int64)
 	// appconfigurationDescKey is the schema descriptor for key field.
 	appconfigurationDescKey := appconfigurationFields[3].Descriptor()
 	// appconfiguration.KeyValidator is a validator for the "key" field. It is called by the builders before save.
@@ -135,13 +135,13 @@ func init() {
 	// applicationcommandDescCreatedAt is the schema descriptor for created_at field.
 	applicationcommandDescCreatedAt := applicationcommandFields[1].Descriptor()
 	// applicationcommand.DefaultCreatedAt holds the default value on creation for the created_at field.
-	applicationcommand.DefaultCreatedAt = applicationcommandDescCreatedAt.Default.(func() int)
+	applicationcommand.DefaultCreatedAt = applicationcommandDescCreatedAt.Default.(func() int64)
 	// applicationcommandDescUpdatedAt is the schema descriptor for updated_at field.
 	applicationcommandDescUpdatedAt := applicationcommandFields[2].Descriptor()
 	// applicationcommand.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	applicationcommand.DefaultUpdatedAt = applicationcommandDescUpdatedAt.Default.(func() int)
+	applicationcommand.DefaultUpdatedAt = applicationcommandDescUpdatedAt.Default.(func() int64)
 	// applicationcommand.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	applicationcommand.UpdateDefaultUpdatedAt = applicationcommandDescUpdatedAt.UpdateDefault.(func() int)
+	applicationcommand.UpdateDefaultUpdatedAt = applicationcommandDescUpdatedAt.UpdateDefault.(func() int64)
 	// applicationcommandDescName is the schema descriptor for name field.
 	applicationcommandDescName := applicationcommandFields[3].Descriptor()
 	// applicationcommand.NameValidator is a validator for the "name" field. It is called by the builders before save.
@@ -163,13 +163,13 @@ func init() {
 	// clanDescCreatedAt is the schema descriptor for created_at field.
 	clanDescCreatedAt := clanFields[1].Descriptor()
 	// clan.DefaultCreatedAt holds the default value on creation for the created_at field.
-	clan.DefaultCreatedAt = clanDescCreatedAt.Default.(func() int)
+	clan.DefaultCreatedAt = clanDescCreatedAt.Default.(func() int64)
 	// clanDescUpdatedAt is the schema descriptor for updated_at field.
 	clanDescUpdatedAt := clanFields[2].Descriptor()
 	// clan.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	clan.DefaultUpdatedAt = clanDescUpdatedAt.Default.(func() int)
+	clan.DefaultUpdatedAt = clanDescUpdatedAt.Default.(func() int64)
 	// clan.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	clan.UpdateDefaultUpdatedAt = clanDescUpdatedAt.UpdateDefault.(func() int)
+	clan.UpdateDefaultUpdatedAt = clanDescUpdatedAt.UpdateDefault.(func() int64)
 	// clanDescTag is the schema descriptor for tag field.
 	clanDescTag := clanFields[3].Descriptor()
 	// clan.TagValidator is a validator for the "tag" field. It is called by the builders before save.
@@ -187,25 +187,17 @@ func init() {
 	// crontaskDescCreatedAt is the schema descriptor for created_at field.
 	crontaskDescCreatedAt := crontaskFields[1].Descriptor()
 	// crontask.DefaultCreatedAt holds the default value on creation for the created_at field.
-	crontask.DefaultCreatedAt = crontaskDescCreatedAt.Default.(func() int)
+	crontask.DefaultCreatedAt = crontaskDescCreatedAt.Default.(func() int64)
 	// crontaskDescUpdatedAt is the schema descriptor for updated_at field.
 	crontaskDescUpdatedAt := crontaskFields[2].Descriptor()
 	// crontask.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	crontask.DefaultUpdatedAt = crontaskDescUpdatedAt.Default.(func() int)
+	crontask.DefaultUpdatedAt = crontaskDescUpdatedAt.Default.(func() int64)
 	// crontask.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	crontask.UpdateDefaultUpdatedAt = crontaskDescUpdatedAt.UpdateDefault.(func() int)
-	// crontaskDescType is the schema descriptor for type field.
-	crontaskDescType := crontaskFields[3].Descriptor()
-	// crontask.TypeValidator is a validator for the "type" field. It is called by the builders before save.
-	crontask.TypeValidator = crontaskDescType.Validators[0].(func(string) error)
+	crontask.UpdateDefaultUpdatedAt = crontaskDescUpdatedAt.UpdateDefault.(func() int64)
 	// crontaskDescReferenceID is the schema descriptor for reference_id field.
 	crontaskDescReferenceID := crontaskFields[4].Descriptor()
 	// crontask.ReferenceIDValidator is a validator for the "reference_id" field. It is called by the builders before save.
 	crontask.ReferenceIDValidator = crontaskDescReferenceID.Validators[0].(func(string) error)
-	// crontaskDescStatus is the schema descriptor for status field.
-	crontaskDescStatus := crontaskFields[6].Descriptor()
-	// crontask.StatusValidator is a validator for the "status" field. It is called by the builders before save.
-	crontask.StatusValidator = crontaskDescStatus.Validators[0].(func(string) error)
 	// crontaskDescID is the schema descriptor for id field.
 	crontaskDescID := crontaskFields[0].Descriptor()
 	// crontask.DefaultID holds the default value on creation for the id field.
@@ -215,13 +207,13 @@ func init() {
 	// userDescCreatedAt is the schema descriptor for created_at field.
 	userDescCreatedAt := userFields[1].Descriptor()
 	// user.DefaultCreatedAt holds the default value on creation for the created_at field.
-	user.DefaultCreatedAt = userDescCreatedAt.Default.(func() int)
+	user.DefaultCreatedAt = userDescCreatedAt.Default.(func() int64)
 	// userDescUpdatedAt is the schema descriptor for updated_at field.
 	userDescUpdatedAt := userFields[2].Descriptor()
 	// user.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	user.DefaultUpdatedAt = userDescUpdatedAt.Default.(func() int)
+	user.DefaultUpdatedAt = userDescUpdatedAt.Default.(func() int64)
 	// user.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	user.UpdateDefaultUpdatedAt = userDescUpdatedAt.UpdateDefault.(func() int)
+	user.UpdateDefaultUpdatedAt = userDescUpdatedAt.UpdateDefault.(func() int64)
 	// userDescPermissions is the schema descriptor for permissions field.
 	userDescPermissions := userFields[3].Descriptor()
 	// user.DefaultPermissions holds the default value on creation for the permissions field.
@@ -231,13 +223,13 @@ func init() {
 	// userconnectionDescCreatedAt is the schema descriptor for created_at field.
 	userconnectionDescCreatedAt := userconnectionFields[1].Descriptor()
 	// userconnection.DefaultCreatedAt holds the default value on creation for the created_at field.
-	userconnection.DefaultCreatedAt = userconnectionDescCreatedAt.Default.(func() int)
+	userconnection.DefaultCreatedAt = userconnectionDescCreatedAt.Default.(func() int64)
 	// userconnectionDescUpdatedAt is the schema descriptor for updated_at field.
 	userconnectionDescUpdatedAt := userconnectionFields[2].Descriptor()
 	// userconnection.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	userconnection.DefaultUpdatedAt = userconnectionDescUpdatedAt.Default.(func() int)
+	userconnection.DefaultUpdatedAt = userconnectionDescUpdatedAt.Default.(func() int64)
 	// userconnection.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	userconnection.UpdateDefaultUpdatedAt = userconnectionDescUpdatedAt.UpdateDefault.(func() int)
+	userconnection.UpdateDefaultUpdatedAt = userconnectionDescUpdatedAt.UpdateDefault.(func() int64)
 	// userconnectionDescPermissions is the schema descriptor for permissions field.
 	userconnectionDescPermissions := userconnectionFields[6].Descriptor()
 	// userconnection.DefaultPermissions holds the default value on creation for the permissions field.
@@ -251,13 +243,13 @@ func init() {
 	// usercontentDescCreatedAt is the schema descriptor for created_at field.
 	usercontentDescCreatedAt := usercontentFields[1].Descriptor()
 	// usercontent.DefaultCreatedAt holds the default value on creation for the created_at field.
-	usercontent.DefaultCreatedAt = usercontentDescCreatedAt.Default.(func() int)
+	usercontent.DefaultCreatedAt = usercontentDescCreatedAt.Default.(func() int64)
 	// usercontentDescUpdatedAt is the schema descriptor for updated_at field.
 	usercontentDescUpdatedAt := usercontentFields[2].Descriptor()
 	// usercontent.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	usercontent.DefaultUpdatedAt = usercontentDescUpdatedAt.Default.(func() int)
+	usercontent.DefaultUpdatedAt = usercontentDescUpdatedAt.Default.(func() int64)
 	// usercontent.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	usercontent.UpdateDefaultUpdatedAt = usercontentDescUpdatedAt.UpdateDefault.(func() int)
+	usercontent.UpdateDefaultUpdatedAt = usercontentDescUpdatedAt.UpdateDefault.(func() int64)
 	// usercontentDescID is the schema descriptor for id field.
 	usercontentDescID := usercontentFields[0].Descriptor()
 	// usercontent.DefaultID holds the default value on creation for the id field.
@@ -267,13 +259,13 @@ func init() {
 	// usersubscriptionDescCreatedAt is the schema descriptor for created_at field.
 	usersubscriptionDescCreatedAt := usersubscriptionFields[1].Descriptor()
 	// usersubscription.DefaultCreatedAt holds the default value on creation for the created_at field.
-	usersubscription.DefaultCreatedAt = usersubscriptionDescCreatedAt.Default.(func() int)
+	usersubscription.DefaultCreatedAt = usersubscriptionDescCreatedAt.Default.(func() int64)
 	// usersubscriptionDescUpdatedAt is the schema descriptor for updated_at field.
 	usersubscriptionDescUpdatedAt := usersubscriptionFields[2].Descriptor()
 	// usersubscription.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	usersubscription.DefaultUpdatedAt = usersubscriptionDescUpdatedAt.Default.(func() int)
+	usersubscription.DefaultUpdatedAt = usersubscriptionDescUpdatedAt.Default.(func() int64)
 	// usersubscription.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	usersubscription.UpdateDefaultUpdatedAt = usersubscriptionDescUpdatedAt.UpdateDefault.(func() int)
+	usersubscription.UpdateDefaultUpdatedAt = usersubscriptionDescUpdatedAt.UpdateDefault.(func() int64)
 	// usersubscriptionDescUserID is the schema descriptor for user_id field.
 	usersubscriptionDescUserID := usersubscriptionFields[5].Descriptor()
 	// usersubscription.UserIDValidator is a validator for the "user_id" field. It is called by the builders before save.
@@ -295,13 +287,13 @@ func init() {
 	// vehicleDescCreatedAt is the schema descriptor for created_at field.
 	vehicleDescCreatedAt := vehicleFields[1].Descriptor()
 	// vehicle.DefaultCreatedAt holds the default value on creation for the created_at field.
-	vehicle.DefaultCreatedAt = vehicleDescCreatedAt.Default.(func() int)
+	vehicle.DefaultCreatedAt = vehicleDescCreatedAt.Default.(func() int64)
 	// vehicleDescUpdatedAt is the schema descriptor for updated_at field.
 	vehicleDescUpdatedAt := vehicleFields[2].Descriptor()
 	// vehicle.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	vehicle.DefaultUpdatedAt = vehicleDescUpdatedAt.Default.(func() int)
+	vehicle.DefaultUpdatedAt = vehicleDescUpdatedAt.Default.(func() int64)
 	// vehicle.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	vehicle.UpdateDefaultUpdatedAt = vehicleDescUpdatedAt.UpdateDefault.(func() int)
+	vehicle.UpdateDefaultUpdatedAt = vehicleDescUpdatedAt.UpdateDefault.(func() int64)
 	// vehicleDescTier is the schema descriptor for tier field.
 	vehicleDescTier := vehicleFields[3].Descriptor()
 	// vehicle.TierValidator is a validator for the "tier" field. It is called by the builders before save.
@@ -325,25 +317,25 @@ func init() {
 	// vehicleaverageDescCreatedAt is the schema descriptor for created_at field.
 	vehicleaverageDescCreatedAt := vehicleaverageFields[1].Descriptor()
 	// vehicleaverage.DefaultCreatedAt holds the default value on creation for the created_at field.
-	vehicleaverage.DefaultCreatedAt = vehicleaverageDescCreatedAt.Default.(func() int)
+	vehicleaverage.DefaultCreatedAt = vehicleaverageDescCreatedAt.Default.(func() int64)
 	// vehicleaverageDescUpdatedAt is the schema descriptor for updated_at field.
 	vehicleaverageDescUpdatedAt := vehicleaverageFields[2].Descriptor()
 	// vehicleaverage.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	vehicleaverage.DefaultUpdatedAt = vehicleaverageDescUpdatedAt.Default.(func() int)
+	vehicleaverage.DefaultUpdatedAt = vehicleaverageDescUpdatedAt.Default.(func() int64)
 	// vehicleaverage.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	vehicleaverage.UpdateDefaultUpdatedAt = vehicleaverageDescUpdatedAt.UpdateDefault.(func() int)
+	vehicleaverage.UpdateDefaultUpdatedAt = vehicleaverageDescUpdatedAt.UpdateDefault.(func() int64)
 	vehiclesnapshotFields := schema.VehicleSnapshot{}.Fields()
 	_ = vehiclesnapshotFields
 	// vehiclesnapshotDescCreatedAt is the schema descriptor for created_at field.
 	vehiclesnapshotDescCreatedAt := vehiclesnapshotFields[1].Descriptor()
 	// vehiclesnapshot.DefaultCreatedAt holds the default value on creation for the created_at field.
-	vehiclesnapshot.DefaultCreatedAt = vehiclesnapshotDescCreatedAt.Default.(func() int)
+	vehiclesnapshot.DefaultCreatedAt = vehiclesnapshotDescCreatedAt.Default.(func() int64)
 	// vehiclesnapshotDescUpdatedAt is the schema descriptor for updated_at field.
 	vehiclesnapshotDescUpdatedAt := vehiclesnapshotFields[2].Descriptor()
 	// vehiclesnapshot.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	vehiclesnapshot.DefaultUpdatedAt = vehiclesnapshotDescUpdatedAt.Default.(func() int)
+	vehiclesnapshot.DefaultUpdatedAt = vehiclesnapshotDescUpdatedAt.Default.(func() int64)
 	// vehiclesnapshot.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	vehiclesnapshot.UpdateDefaultUpdatedAt = vehiclesnapshotDescUpdatedAt.UpdateDefault.(func() int)
+	vehiclesnapshot.UpdateDefaultUpdatedAt = vehiclesnapshotDescUpdatedAt.UpdateDefault.(func() int64)
 	// vehiclesnapshotDescAccountID is the schema descriptor for account_id field.
 	vehiclesnapshotDescAccountID := vehiclesnapshotFields[4].Descriptor()
 	// vehiclesnapshot.AccountIDValidator is a validator for the "account_id" field. It is called by the builders before save.
diff --git a/internal/database/ent/db/user.go b/internal/database/ent/db/user.go
index f62dd2bb..e8a51556 100644
--- a/internal/database/ent/db/user.go
+++ b/internal/database/ent/db/user.go
@@ -18,9 +18,9 @@ type User struct {
 	// ID of the ent.
 	ID string `json:"id,omitempty"`
 	// CreatedAt holds the value of the "created_at" field.
-	CreatedAt int `json:"created_at,omitempty"`
+	CreatedAt int64 `json:"created_at,omitempty"`
 	// UpdatedAt holds the value of the "updated_at" field.
-	UpdatedAt int `json:"updated_at,omitempty"`
+	UpdatedAt int64 `json:"updated_at,omitempty"`
 	// Permissions holds the value of the "permissions" field.
 	Permissions string `json:"permissions,omitempty"`
 	// FeatureFlags holds the value of the "feature_flags" field.
@@ -107,13 +107,13 @@ func (u *User) assignValues(columns []string, values []any) error {
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field created_at", values[i])
 			} else if value.Valid {
-				u.CreatedAt = int(value.Int64)
+				u.CreatedAt = value.Int64
 			}
 		case user.FieldUpdatedAt:
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
 			} else if value.Valid {
-				u.UpdatedAt = int(value.Int64)
+				u.UpdatedAt = value.Int64
 			}
 		case user.FieldPermissions:
 			if value, ok := values[i].(*sql.NullString); !ok {
diff --git a/internal/database/ent/db/user/user.go b/internal/database/ent/db/user/user.go
index 9ee9bd12..b16e3e67 100644
--- a/internal/database/ent/db/user/user.go
+++ b/internal/database/ent/db/user/user.go
@@ -72,11 +72,11 @@ func ValidColumn(column string) bool {
 
 var (
 	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
-	DefaultCreatedAt func() int
+	DefaultCreatedAt func() int64
 	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
-	DefaultUpdatedAt func() int
+	DefaultUpdatedAt func() int64
 	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
-	UpdateDefaultUpdatedAt func() int
+	UpdateDefaultUpdatedAt func() int64
 	// DefaultPermissions holds the default value on creation for the "permissions" field.
 	DefaultPermissions string
 )
diff --git a/internal/database/ent/db/user/where.go b/internal/database/ent/db/user/where.go
index a0abc0ee..cf752542 100644
--- a/internal/database/ent/db/user/where.go
+++ b/internal/database/ent/db/user/where.go
@@ -64,12 +64,12 @@ func IDContainsFold(id string) predicate.User {
 }
 
 // CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
-func CreatedAt(v int) predicate.User {
+func CreatedAt(v int64) predicate.User {
 	return predicate.User(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
-func UpdatedAt(v int) predicate.User {
+func UpdatedAt(v int64) predicate.User {
 	return predicate.User(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
@@ -79,82 +79,82 @@ func Permissions(v string) predicate.User {
 }
 
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v int) predicate.User {
+func CreatedAtEQ(v int64) predicate.User {
 	return predicate.User(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v int) predicate.User {
+func CreatedAtNEQ(v int64) predicate.User {
 	return predicate.User(sql.FieldNEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...int) predicate.User {
+func CreatedAtIn(vs ...int64) predicate.User {
 	return predicate.User(sql.FieldIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...int) predicate.User {
+func CreatedAtNotIn(vs ...int64) predicate.User {
 	return predicate.User(sql.FieldNotIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v int) predicate.User {
+func CreatedAtGT(v int64) predicate.User {
 	return predicate.User(sql.FieldGT(FieldCreatedAt, v))
 }
 
 // CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v int) predicate.User {
+func CreatedAtGTE(v int64) predicate.User {
 	return predicate.User(sql.FieldGTE(FieldCreatedAt, v))
 }
 
 // CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v int) predicate.User {
+func CreatedAtLT(v int64) predicate.User {
 	return predicate.User(sql.FieldLT(FieldCreatedAt, v))
 }
 
 // CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v int) predicate.User {
+func CreatedAtLTE(v int64) predicate.User {
 	return predicate.User(sql.FieldLTE(FieldCreatedAt, v))
 }
 
 // UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
-func UpdatedAtEQ(v int) predicate.User {
+func UpdatedAtEQ(v int64) predicate.User {
 	return predicate.User(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
-func UpdatedAtNEQ(v int) predicate.User {
+func UpdatedAtNEQ(v int64) predicate.User {
 	return predicate.User(sql.FieldNEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtIn applies the In predicate on the "updated_at" field.
-func UpdatedAtIn(vs ...int) predicate.User {
+func UpdatedAtIn(vs ...int64) predicate.User {
 	return predicate.User(sql.FieldIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
-func UpdatedAtNotIn(vs ...int) predicate.User {
+func UpdatedAtNotIn(vs ...int64) predicate.User {
 	return predicate.User(sql.FieldNotIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtGT applies the GT predicate on the "updated_at" field.
-func UpdatedAtGT(v int) predicate.User {
+func UpdatedAtGT(v int64) predicate.User {
 	return predicate.User(sql.FieldGT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
-func UpdatedAtGTE(v int) predicate.User {
+func UpdatedAtGTE(v int64) predicate.User {
 	return predicate.User(sql.FieldGTE(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLT applies the LT predicate on the "updated_at" field.
-func UpdatedAtLT(v int) predicate.User {
+func UpdatedAtLT(v int64) predicate.User {
 	return predicate.User(sql.FieldLT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
-func UpdatedAtLTE(v int) predicate.User {
+func UpdatedAtLTE(v int64) predicate.User {
 	return predicate.User(sql.FieldLTE(FieldUpdatedAt, v))
 }
 
diff --git a/internal/database/ent/db/user_create.go b/internal/database/ent/db/user_create.go
index a5916908..1db7f19a 100644
--- a/internal/database/ent/db/user_create.go
+++ b/internal/database/ent/db/user_create.go
@@ -23,13 +23,13 @@ type UserCreate struct {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (uc *UserCreate) SetCreatedAt(i int) *UserCreate {
+func (uc *UserCreate) SetCreatedAt(i int64) *UserCreate {
 	uc.mutation.SetCreatedAt(i)
 	return uc
 }
 
 // SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
-func (uc *UserCreate) SetNillableCreatedAt(i *int) *UserCreate {
+func (uc *UserCreate) SetNillableCreatedAt(i *int64) *UserCreate {
 	if i != nil {
 		uc.SetCreatedAt(*i)
 	}
@@ -37,13 +37,13 @@ func (uc *UserCreate) SetNillableCreatedAt(i *int) *UserCreate {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (uc *UserCreate) SetUpdatedAt(i int) *UserCreate {
+func (uc *UserCreate) SetUpdatedAt(i int64) *UserCreate {
 	uc.mutation.SetUpdatedAt(i)
 	return uc
 }
 
 // SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
-func (uc *UserCreate) SetNillableUpdatedAt(i *int) *UserCreate {
+func (uc *UserCreate) SetNillableUpdatedAt(i *int64) *UserCreate {
 	if i != nil {
 		uc.SetUpdatedAt(*i)
 	}
@@ -217,11 +217,11 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) {
 		_spec.ID.Value = id
 	}
 	if value, ok := uc.mutation.CreatedAt(); ok {
-		_spec.SetField(user.FieldCreatedAt, field.TypeInt, value)
+		_spec.SetField(user.FieldCreatedAt, field.TypeInt64, value)
 		_node.CreatedAt = value
 	}
 	if value, ok := uc.mutation.UpdatedAt(); ok {
-		_spec.SetField(user.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(user.FieldUpdatedAt, field.TypeInt64, value)
 		_node.UpdatedAt = value
 	}
 	if value, ok := uc.mutation.Permissions(); ok {
diff --git a/internal/database/ent/db/user_query.go b/internal/database/ent/db/user_query.go
index 5fef02bf..83ee3ea8 100644
--- a/internal/database/ent/db/user_query.go
+++ b/internal/database/ent/db/user_query.go
@@ -370,7 +370,7 @@ func (uq *UserQuery) WithContent(opts ...func(*UserContentQuery)) *UserQuery {
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int `json:"created_at,omitempty"`
+//		CreatedAt int64 `json:"created_at,omitempty"`
 //		Count int `json:"count,omitempty"`
 //	}
 //
@@ -393,7 +393,7 @@ func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy {
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int `json:"created_at,omitempty"`
+//		CreatedAt int64 `json:"created_at,omitempty"`
 //	}
 //
 //	client.User.Query().
diff --git a/internal/database/ent/db/user_update.go b/internal/database/ent/db/user_update.go
index 4d7932c2..d4ac1622 100644
--- a/internal/database/ent/db/user_update.go
+++ b/internal/database/ent/db/user_update.go
@@ -32,14 +32,14 @@ func (uu *UserUpdate) Where(ps ...predicate.User) *UserUpdate {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (uu *UserUpdate) SetUpdatedAt(i int) *UserUpdate {
+func (uu *UserUpdate) SetUpdatedAt(i int64) *UserUpdate {
 	uu.mutation.ResetUpdatedAt()
 	uu.mutation.SetUpdatedAt(i)
 	return uu
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (uu *UserUpdate) AddUpdatedAt(i int) *UserUpdate {
+func (uu *UserUpdate) AddUpdatedAt(i int64) *UserUpdate {
 	uu.mutation.AddUpdatedAt(i)
 	return uu
 }
@@ -235,10 +235,10 @@ func (uu *UserUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 	}
 	if value, ok := uu.mutation.UpdatedAt(); ok {
-		_spec.SetField(user.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(user.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := uu.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(user.FieldUpdatedAt, field.TypeInt, value)
+		_spec.AddField(user.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := uu.mutation.Permissions(); ok {
 		_spec.SetField(user.FieldPermissions, field.TypeString, value)
@@ -410,14 +410,14 @@ type UserUpdateOne struct {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (uuo *UserUpdateOne) SetUpdatedAt(i int) *UserUpdateOne {
+func (uuo *UserUpdateOne) SetUpdatedAt(i int64) *UserUpdateOne {
 	uuo.mutation.ResetUpdatedAt()
 	uuo.mutation.SetUpdatedAt(i)
 	return uuo
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (uuo *UserUpdateOne) AddUpdatedAt(i int) *UserUpdateOne {
+func (uuo *UserUpdateOne) AddUpdatedAt(i int64) *UserUpdateOne {
 	uuo.mutation.AddUpdatedAt(i)
 	return uuo
 }
@@ -643,10 +643,10 @@ func (uuo *UserUpdateOne) sqlSave(ctx context.Context) (_node *User, err error)
 		}
 	}
 	if value, ok := uuo.mutation.UpdatedAt(); ok {
-		_spec.SetField(user.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(user.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := uuo.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(user.FieldUpdatedAt, field.TypeInt, value)
+		_spec.AddField(user.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := uuo.mutation.Permissions(); ok {
 		_spec.SetField(user.FieldPermissions, field.TypeString, value)
diff --git a/internal/database/ent/db/userconnection.go b/internal/database/ent/db/userconnection.go
index c5b03752..100553b6 100644
--- a/internal/database/ent/db/userconnection.go
+++ b/internal/database/ent/db/userconnection.go
@@ -20,9 +20,9 @@ type UserConnection struct {
 	// ID of the ent.
 	ID string `json:"id,omitempty"`
 	// CreatedAt holds the value of the "created_at" field.
-	CreatedAt int `json:"created_at,omitempty"`
+	CreatedAt int64 `json:"created_at,omitempty"`
 	// UpdatedAt holds the value of the "updated_at" field.
-	UpdatedAt int `json:"updated_at,omitempty"`
+	UpdatedAt int64 `json:"updated_at,omitempty"`
 	// Type holds the value of the "type" field.
 	Type models.ConnectionType `json:"type,omitempty"`
 	// UserID holds the value of the "user_id" field.
@@ -95,13 +95,13 @@ func (uc *UserConnection) assignValues(columns []string, values []any) error {
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field created_at", values[i])
 			} else if value.Valid {
-				uc.CreatedAt = int(value.Int64)
+				uc.CreatedAt = value.Int64
 			}
 		case userconnection.FieldUpdatedAt:
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
 			} else if value.Valid {
-				uc.UpdatedAt = int(value.Int64)
+				uc.UpdatedAt = value.Int64
 			}
 		case userconnection.FieldType:
 			if value, ok := values[i].(*sql.NullString); !ok {
diff --git a/internal/database/ent/db/userconnection/userconnection.go b/internal/database/ent/db/userconnection/userconnection.go
index 1cb8085b..0b1c4114 100644
--- a/internal/database/ent/db/userconnection/userconnection.go
+++ b/internal/database/ent/db/userconnection/userconnection.go
@@ -66,11 +66,11 @@ func ValidColumn(column string) bool {
 
 var (
 	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
-	DefaultCreatedAt func() int
+	DefaultCreatedAt func() int64
 	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
-	DefaultUpdatedAt func() int
+	DefaultUpdatedAt func() int64
 	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
-	UpdateDefaultUpdatedAt func() int
+	UpdateDefaultUpdatedAt func() int64
 	// DefaultPermissions holds the default value on creation for the "permissions" field.
 	DefaultPermissions string
 	// DefaultID holds the default value on creation for the "id" field.
diff --git a/internal/database/ent/db/userconnection/where.go b/internal/database/ent/db/userconnection/where.go
index 6d1f373a..9726b22e 100644
--- a/internal/database/ent/db/userconnection/where.go
+++ b/internal/database/ent/db/userconnection/where.go
@@ -65,12 +65,12 @@ func IDContainsFold(id string) predicate.UserConnection {
 }
 
 // CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
-func CreatedAt(v int) predicate.UserConnection {
+func CreatedAt(v int64) predicate.UserConnection {
 	return predicate.UserConnection(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
-func UpdatedAt(v int) predicate.UserConnection {
+func UpdatedAt(v int64) predicate.UserConnection {
 	return predicate.UserConnection(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
@@ -90,82 +90,82 @@ func Permissions(v string) predicate.UserConnection {
 }
 
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v int) predicate.UserConnection {
+func CreatedAtEQ(v int64) predicate.UserConnection {
 	return predicate.UserConnection(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v int) predicate.UserConnection {
+func CreatedAtNEQ(v int64) predicate.UserConnection {
 	return predicate.UserConnection(sql.FieldNEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...int) predicate.UserConnection {
+func CreatedAtIn(vs ...int64) predicate.UserConnection {
 	return predicate.UserConnection(sql.FieldIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...int) predicate.UserConnection {
+func CreatedAtNotIn(vs ...int64) predicate.UserConnection {
 	return predicate.UserConnection(sql.FieldNotIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v int) predicate.UserConnection {
+func CreatedAtGT(v int64) predicate.UserConnection {
 	return predicate.UserConnection(sql.FieldGT(FieldCreatedAt, v))
 }
 
 // CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v int) predicate.UserConnection {
+func CreatedAtGTE(v int64) predicate.UserConnection {
 	return predicate.UserConnection(sql.FieldGTE(FieldCreatedAt, v))
 }
 
 // CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v int) predicate.UserConnection {
+func CreatedAtLT(v int64) predicate.UserConnection {
 	return predicate.UserConnection(sql.FieldLT(FieldCreatedAt, v))
 }
 
 // CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v int) predicate.UserConnection {
+func CreatedAtLTE(v int64) predicate.UserConnection {
 	return predicate.UserConnection(sql.FieldLTE(FieldCreatedAt, v))
 }
 
 // UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
-func UpdatedAtEQ(v int) predicate.UserConnection {
+func UpdatedAtEQ(v int64) predicate.UserConnection {
 	return predicate.UserConnection(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
-func UpdatedAtNEQ(v int) predicate.UserConnection {
+func UpdatedAtNEQ(v int64) predicate.UserConnection {
 	return predicate.UserConnection(sql.FieldNEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtIn applies the In predicate on the "updated_at" field.
-func UpdatedAtIn(vs ...int) predicate.UserConnection {
+func UpdatedAtIn(vs ...int64) predicate.UserConnection {
 	return predicate.UserConnection(sql.FieldIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
-func UpdatedAtNotIn(vs ...int) predicate.UserConnection {
+func UpdatedAtNotIn(vs ...int64) predicate.UserConnection {
 	return predicate.UserConnection(sql.FieldNotIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtGT applies the GT predicate on the "updated_at" field.
-func UpdatedAtGT(v int) predicate.UserConnection {
+func UpdatedAtGT(v int64) predicate.UserConnection {
 	return predicate.UserConnection(sql.FieldGT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
-func UpdatedAtGTE(v int) predicate.UserConnection {
+func UpdatedAtGTE(v int64) predicate.UserConnection {
 	return predicate.UserConnection(sql.FieldGTE(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLT applies the LT predicate on the "updated_at" field.
-func UpdatedAtLT(v int) predicate.UserConnection {
+func UpdatedAtLT(v int64) predicate.UserConnection {
 	return predicate.UserConnection(sql.FieldLT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
-func UpdatedAtLTE(v int) predicate.UserConnection {
+func UpdatedAtLTE(v int64) predicate.UserConnection {
 	return predicate.UserConnection(sql.FieldLTE(FieldUpdatedAt, v))
 }
 
diff --git a/internal/database/ent/db/userconnection_create.go b/internal/database/ent/db/userconnection_create.go
index ee25aacf..8478c906 100644
--- a/internal/database/ent/db/userconnection_create.go
+++ b/internal/database/ent/db/userconnection_create.go
@@ -22,13 +22,13 @@ type UserConnectionCreate struct {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (ucc *UserConnectionCreate) SetCreatedAt(i int) *UserConnectionCreate {
+func (ucc *UserConnectionCreate) SetCreatedAt(i int64) *UserConnectionCreate {
 	ucc.mutation.SetCreatedAt(i)
 	return ucc
 }
 
 // SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
-func (ucc *UserConnectionCreate) SetNillableCreatedAt(i *int) *UserConnectionCreate {
+func (ucc *UserConnectionCreate) SetNillableCreatedAt(i *int64) *UserConnectionCreate {
 	if i != nil {
 		ucc.SetCreatedAt(*i)
 	}
@@ -36,13 +36,13 @@ func (ucc *UserConnectionCreate) SetNillableCreatedAt(i *int) *UserConnectionCre
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (ucc *UserConnectionCreate) SetUpdatedAt(i int) *UserConnectionCreate {
+func (ucc *UserConnectionCreate) SetUpdatedAt(i int64) *UserConnectionCreate {
 	ucc.mutation.SetUpdatedAt(i)
 	return ucc
 }
 
 // SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
-func (ucc *UserConnectionCreate) SetNillableUpdatedAt(i *int) *UserConnectionCreate {
+func (ucc *UserConnectionCreate) SetNillableUpdatedAt(i *int64) *UserConnectionCreate {
 	if i != nil {
 		ucc.SetUpdatedAt(*i)
 	}
@@ -220,11 +220,11 @@ func (ucc *UserConnectionCreate) createSpec() (*UserConnection, *sqlgraph.Create
 		_spec.ID.Value = id
 	}
 	if value, ok := ucc.mutation.CreatedAt(); ok {
-		_spec.SetField(userconnection.FieldCreatedAt, field.TypeInt, value)
+		_spec.SetField(userconnection.FieldCreatedAt, field.TypeInt64, value)
 		_node.CreatedAt = value
 	}
 	if value, ok := ucc.mutation.UpdatedAt(); ok {
-		_spec.SetField(userconnection.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(userconnection.FieldUpdatedAt, field.TypeInt64, value)
 		_node.UpdatedAt = value
 	}
 	if value, ok := ucc.mutation.GetType(); ok {
diff --git a/internal/database/ent/db/userconnection_query.go b/internal/database/ent/db/userconnection_query.go
index 020530b6..164e8e87 100644
--- a/internal/database/ent/db/userconnection_query.go
+++ b/internal/database/ent/db/userconnection_query.go
@@ -297,7 +297,7 @@ func (ucq *UserConnectionQuery) WithUser(opts ...func(*UserQuery)) *UserConnecti
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int `json:"created_at,omitempty"`
+//		CreatedAt int64 `json:"created_at,omitempty"`
 //		Count int `json:"count,omitempty"`
 //	}
 //
@@ -320,7 +320,7 @@ func (ucq *UserConnectionQuery) GroupBy(field string, fields ...string) *UserCon
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int `json:"created_at,omitempty"`
+//		CreatedAt int64 `json:"created_at,omitempty"`
 //	}
 //
 //	client.UserConnection.Query().
diff --git a/internal/database/ent/db/userconnection_update.go b/internal/database/ent/db/userconnection_update.go
index d7985deb..8744515f 100644
--- a/internal/database/ent/db/userconnection_update.go
+++ b/internal/database/ent/db/userconnection_update.go
@@ -29,14 +29,14 @@ func (ucu *UserConnectionUpdate) Where(ps ...predicate.UserConnection) *UserConn
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (ucu *UserConnectionUpdate) SetUpdatedAt(i int) *UserConnectionUpdate {
+func (ucu *UserConnectionUpdate) SetUpdatedAt(i int64) *UserConnectionUpdate {
 	ucu.mutation.ResetUpdatedAt()
 	ucu.mutation.SetUpdatedAt(i)
 	return ucu
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (ucu *UserConnectionUpdate) AddUpdatedAt(i int) *UserConnectionUpdate {
+func (ucu *UserConnectionUpdate) AddUpdatedAt(i int64) *UserConnectionUpdate {
 	ucu.mutation.AddUpdatedAt(i)
 	return ucu
 }
@@ -168,10 +168,10 @@ func (ucu *UserConnectionUpdate) sqlSave(ctx context.Context) (n int, err error)
 		}
 	}
 	if value, ok := ucu.mutation.UpdatedAt(); ok {
-		_spec.SetField(userconnection.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(userconnection.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := ucu.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(userconnection.FieldUpdatedAt, field.TypeInt, value)
+		_spec.AddField(userconnection.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := ucu.mutation.GetType(); ok {
 		_spec.SetField(userconnection.FieldType, field.TypeEnum, value)
@@ -212,14 +212,14 @@ type UserConnectionUpdateOne struct {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (ucuo *UserConnectionUpdateOne) SetUpdatedAt(i int) *UserConnectionUpdateOne {
+func (ucuo *UserConnectionUpdateOne) SetUpdatedAt(i int64) *UserConnectionUpdateOne {
 	ucuo.mutation.ResetUpdatedAt()
 	ucuo.mutation.SetUpdatedAt(i)
 	return ucuo
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (ucuo *UserConnectionUpdateOne) AddUpdatedAt(i int) *UserConnectionUpdateOne {
+func (ucuo *UserConnectionUpdateOne) AddUpdatedAt(i int64) *UserConnectionUpdateOne {
 	ucuo.mutation.AddUpdatedAt(i)
 	return ucuo
 }
@@ -381,10 +381,10 @@ func (ucuo *UserConnectionUpdateOne) sqlSave(ctx context.Context) (_node *UserCo
 		}
 	}
 	if value, ok := ucuo.mutation.UpdatedAt(); ok {
-		_spec.SetField(userconnection.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(userconnection.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := ucuo.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(userconnection.FieldUpdatedAt, field.TypeInt, value)
+		_spec.AddField(userconnection.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := ucuo.mutation.GetType(); ok {
 		_spec.SetField(userconnection.FieldType, field.TypeEnum, value)
diff --git a/internal/database/ent/db/usercontent.go b/internal/database/ent/db/usercontent.go
index f9c1b079..dfa12961 100644
--- a/internal/database/ent/db/usercontent.go
+++ b/internal/database/ent/db/usercontent.go
@@ -20,9 +20,9 @@ type UserContent struct {
 	// ID of the ent.
 	ID string `json:"id,omitempty"`
 	// CreatedAt holds the value of the "created_at" field.
-	CreatedAt int `json:"created_at,omitempty"`
+	CreatedAt int64 `json:"created_at,omitempty"`
 	// UpdatedAt holds the value of the "updated_at" field.
-	UpdatedAt int `json:"updated_at,omitempty"`
+	UpdatedAt int64 `json:"updated_at,omitempty"`
 	// Type holds the value of the "type" field.
 	Type models.UserContentType `json:"type,omitempty"`
 	// UserID holds the value of the "user_id" field.
@@ -95,13 +95,13 @@ func (uc *UserContent) assignValues(columns []string, values []any) error {
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field created_at", values[i])
 			} else if value.Valid {
-				uc.CreatedAt = int(value.Int64)
+				uc.CreatedAt = value.Int64
 			}
 		case usercontent.FieldUpdatedAt:
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
 			} else if value.Valid {
-				uc.UpdatedAt = int(value.Int64)
+				uc.UpdatedAt = value.Int64
 			}
 		case usercontent.FieldType:
 			if value, ok := values[i].(*sql.NullString); !ok {
diff --git a/internal/database/ent/db/usercontent/usercontent.go b/internal/database/ent/db/usercontent/usercontent.go
index c3ea1314..89a1d190 100644
--- a/internal/database/ent/db/usercontent/usercontent.go
+++ b/internal/database/ent/db/usercontent/usercontent.go
@@ -66,11 +66,11 @@ func ValidColumn(column string) bool {
 
 var (
 	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
-	DefaultCreatedAt func() int
+	DefaultCreatedAt func() int64
 	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
-	DefaultUpdatedAt func() int
+	DefaultUpdatedAt func() int64
 	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
-	UpdateDefaultUpdatedAt func() int
+	UpdateDefaultUpdatedAt func() int64
 	// DefaultID holds the default value on creation for the "id" field.
 	DefaultID func() string
 )
diff --git a/internal/database/ent/db/usercontent/where.go b/internal/database/ent/db/usercontent/where.go
index 41358635..b8133da2 100644
--- a/internal/database/ent/db/usercontent/where.go
+++ b/internal/database/ent/db/usercontent/where.go
@@ -65,12 +65,12 @@ func IDContainsFold(id string) predicate.UserContent {
 }
 
 // CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
-func CreatedAt(v int) predicate.UserContent {
+func CreatedAt(v int64) predicate.UserContent {
 	return predicate.UserContent(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
-func UpdatedAt(v int) predicate.UserContent {
+func UpdatedAt(v int64) predicate.UserContent {
 	return predicate.UserContent(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
@@ -85,82 +85,82 @@ func ReferenceID(v string) predicate.UserContent {
 }
 
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v int) predicate.UserContent {
+func CreatedAtEQ(v int64) predicate.UserContent {
 	return predicate.UserContent(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v int) predicate.UserContent {
+func CreatedAtNEQ(v int64) predicate.UserContent {
 	return predicate.UserContent(sql.FieldNEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...int) predicate.UserContent {
+func CreatedAtIn(vs ...int64) predicate.UserContent {
 	return predicate.UserContent(sql.FieldIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...int) predicate.UserContent {
+func CreatedAtNotIn(vs ...int64) predicate.UserContent {
 	return predicate.UserContent(sql.FieldNotIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v int) predicate.UserContent {
+func CreatedAtGT(v int64) predicate.UserContent {
 	return predicate.UserContent(sql.FieldGT(FieldCreatedAt, v))
 }
 
 // CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v int) predicate.UserContent {
+func CreatedAtGTE(v int64) predicate.UserContent {
 	return predicate.UserContent(sql.FieldGTE(FieldCreatedAt, v))
 }
 
 // CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v int) predicate.UserContent {
+func CreatedAtLT(v int64) predicate.UserContent {
 	return predicate.UserContent(sql.FieldLT(FieldCreatedAt, v))
 }
 
 // CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v int) predicate.UserContent {
+func CreatedAtLTE(v int64) predicate.UserContent {
 	return predicate.UserContent(sql.FieldLTE(FieldCreatedAt, v))
 }
 
 // UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
-func UpdatedAtEQ(v int) predicate.UserContent {
+func UpdatedAtEQ(v int64) predicate.UserContent {
 	return predicate.UserContent(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
-func UpdatedAtNEQ(v int) predicate.UserContent {
+func UpdatedAtNEQ(v int64) predicate.UserContent {
 	return predicate.UserContent(sql.FieldNEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtIn applies the In predicate on the "updated_at" field.
-func UpdatedAtIn(vs ...int) predicate.UserContent {
+func UpdatedAtIn(vs ...int64) predicate.UserContent {
 	return predicate.UserContent(sql.FieldIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
-func UpdatedAtNotIn(vs ...int) predicate.UserContent {
+func UpdatedAtNotIn(vs ...int64) predicate.UserContent {
 	return predicate.UserContent(sql.FieldNotIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtGT applies the GT predicate on the "updated_at" field.
-func UpdatedAtGT(v int) predicate.UserContent {
+func UpdatedAtGT(v int64) predicate.UserContent {
 	return predicate.UserContent(sql.FieldGT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
-func UpdatedAtGTE(v int) predicate.UserContent {
+func UpdatedAtGTE(v int64) predicate.UserContent {
 	return predicate.UserContent(sql.FieldGTE(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLT applies the LT predicate on the "updated_at" field.
-func UpdatedAtLT(v int) predicate.UserContent {
+func UpdatedAtLT(v int64) predicate.UserContent {
 	return predicate.UserContent(sql.FieldLT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
-func UpdatedAtLTE(v int) predicate.UserContent {
+func UpdatedAtLTE(v int64) predicate.UserContent {
 	return predicate.UserContent(sql.FieldLTE(FieldUpdatedAt, v))
 }
 
diff --git a/internal/database/ent/db/usercontent_create.go b/internal/database/ent/db/usercontent_create.go
index 50abe9e4..ac65c16b 100644
--- a/internal/database/ent/db/usercontent_create.go
+++ b/internal/database/ent/db/usercontent_create.go
@@ -22,13 +22,13 @@ type UserContentCreate struct {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (ucc *UserContentCreate) SetCreatedAt(i int) *UserContentCreate {
+func (ucc *UserContentCreate) SetCreatedAt(i int64) *UserContentCreate {
 	ucc.mutation.SetCreatedAt(i)
 	return ucc
 }
 
 // SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
-func (ucc *UserContentCreate) SetNillableCreatedAt(i *int) *UserContentCreate {
+func (ucc *UserContentCreate) SetNillableCreatedAt(i *int64) *UserContentCreate {
 	if i != nil {
 		ucc.SetCreatedAt(*i)
 	}
@@ -36,13 +36,13 @@ func (ucc *UserContentCreate) SetNillableCreatedAt(i *int) *UserContentCreate {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (ucc *UserContentCreate) SetUpdatedAt(i int) *UserContentCreate {
+func (ucc *UserContentCreate) SetUpdatedAt(i int64) *UserContentCreate {
 	ucc.mutation.SetUpdatedAt(i)
 	return ucc
 }
 
 // SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
-func (ucc *UserContentCreate) SetNillableUpdatedAt(i *int) *UserContentCreate {
+func (ucc *UserContentCreate) SetNillableUpdatedAt(i *int64) *UserContentCreate {
 	if i != nil {
 		ucc.SetUpdatedAt(*i)
 	}
@@ -214,11 +214,11 @@ func (ucc *UserContentCreate) createSpec() (*UserContent, *sqlgraph.CreateSpec)
 		_spec.ID.Value = id
 	}
 	if value, ok := ucc.mutation.CreatedAt(); ok {
-		_spec.SetField(usercontent.FieldCreatedAt, field.TypeInt, value)
+		_spec.SetField(usercontent.FieldCreatedAt, field.TypeInt64, value)
 		_node.CreatedAt = value
 	}
 	if value, ok := ucc.mutation.UpdatedAt(); ok {
-		_spec.SetField(usercontent.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(usercontent.FieldUpdatedAt, field.TypeInt64, value)
 		_node.UpdatedAt = value
 	}
 	if value, ok := ucc.mutation.GetType(); ok {
diff --git a/internal/database/ent/db/usercontent_query.go b/internal/database/ent/db/usercontent_query.go
index 21683730..8c189429 100644
--- a/internal/database/ent/db/usercontent_query.go
+++ b/internal/database/ent/db/usercontent_query.go
@@ -297,7 +297,7 @@ func (ucq *UserContentQuery) WithUser(opts ...func(*UserQuery)) *UserContentQuer
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int `json:"created_at,omitempty"`
+//		CreatedAt int64 `json:"created_at,omitempty"`
 //		Count int `json:"count,omitempty"`
 //	}
 //
@@ -320,7 +320,7 @@ func (ucq *UserContentQuery) GroupBy(field string, fields ...string) *UserConten
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int `json:"created_at,omitempty"`
+//		CreatedAt int64 `json:"created_at,omitempty"`
 //	}
 //
 //	client.UserContent.Query().
diff --git a/internal/database/ent/db/usercontent_update.go b/internal/database/ent/db/usercontent_update.go
index a6d031e0..25bb317e 100644
--- a/internal/database/ent/db/usercontent_update.go
+++ b/internal/database/ent/db/usercontent_update.go
@@ -29,14 +29,14 @@ func (ucu *UserContentUpdate) Where(ps ...predicate.UserContent) *UserContentUpd
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (ucu *UserContentUpdate) SetUpdatedAt(i int) *UserContentUpdate {
+func (ucu *UserContentUpdate) SetUpdatedAt(i int64) *UserContentUpdate {
 	ucu.mutation.ResetUpdatedAt()
 	ucu.mutation.SetUpdatedAt(i)
 	return ucu
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (ucu *UserContentUpdate) AddUpdatedAt(i int) *UserContentUpdate {
+func (ucu *UserContentUpdate) AddUpdatedAt(i int64) *UserContentUpdate {
 	ucu.mutation.AddUpdatedAt(i)
 	return ucu
 }
@@ -148,10 +148,10 @@ func (ucu *UserContentUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 	}
 	if value, ok := ucu.mutation.UpdatedAt(); ok {
-		_spec.SetField(usercontent.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(usercontent.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := ucu.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(usercontent.FieldUpdatedAt, field.TypeInt, value)
+		_spec.AddField(usercontent.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := ucu.mutation.GetType(); ok {
 		_spec.SetField(usercontent.FieldType, field.TypeEnum, value)
@@ -186,14 +186,14 @@ type UserContentUpdateOne struct {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (ucuo *UserContentUpdateOne) SetUpdatedAt(i int) *UserContentUpdateOne {
+func (ucuo *UserContentUpdateOne) SetUpdatedAt(i int64) *UserContentUpdateOne {
 	ucuo.mutation.ResetUpdatedAt()
 	ucuo.mutation.SetUpdatedAt(i)
 	return ucuo
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (ucuo *UserContentUpdateOne) AddUpdatedAt(i int) *UserContentUpdateOne {
+func (ucuo *UserContentUpdateOne) AddUpdatedAt(i int64) *UserContentUpdateOne {
 	ucuo.mutation.AddUpdatedAt(i)
 	return ucuo
 }
@@ -335,10 +335,10 @@ func (ucuo *UserContentUpdateOne) sqlSave(ctx context.Context) (_node *UserConte
 		}
 	}
 	if value, ok := ucuo.mutation.UpdatedAt(); ok {
-		_spec.SetField(usercontent.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(usercontent.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := ucuo.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(usercontent.FieldUpdatedAt, field.TypeInt, value)
+		_spec.AddField(usercontent.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := ucuo.mutation.GetType(); ok {
 		_spec.SetField(usercontent.FieldType, field.TypeEnum, value)
diff --git a/internal/database/ent/db/usersubscription.go b/internal/database/ent/db/usersubscription.go
index 573a557e..11cdb283 100644
--- a/internal/database/ent/db/usersubscription.go
+++ b/internal/database/ent/db/usersubscription.go
@@ -19,13 +19,13 @@ type UserSubscription struct {
 	// ID of the ent.
 	ID string `json:"id,omitempty"`
 	// CreatedAt holds the value of the "created_at" field.
-	CreatedAt int `json:"created_at,omitempty"`
+	CreatedAt int64 `json:"created_at,omitempty"`
 	// UpdatedAt holds the value of the "updated_at" field.
-	UpdatedAt int `json:"updated_at,omitempty"`
+	UpdatedAt int64 `json:"updated_at,omitempty"`
 	// Type holds the value of the "type" field.
 	Type models.SubscriptionType `json:"type,omitempty"`
 	// ExpiresAt holds the value of the "expires_at" field.
-	ExpiresAt int `json:"expires_at,omitempty"`
+	ExpiresAt int64 `json:"expires_at,omitempty"`
 	// UserID holds the value of the "user_id" field.
 	UserID string `json:"user_id,omitempty"`
 	// Permissions holds the value of the "permissions" field.
@@ -92,13 +92,13 @@ func (us *UserSubscription) assignValues(columns []string, values []any) error {
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field created_at", values[i])
 			} else if value.Valid {
-				us.CreatedAt = int(value.Int64)
+				us.CreatedAt = value.Int64
 			}
 		case usersubscription.FieldUpdatedAt:
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
 			} else if value.Valid {
-				us.UpdatedAt = int(value.Int64)
+				us.UpdatedAt = value.Int64
 			}
 		case usersubscription.FieldType:
 			if value, ok := values[i].(*sql.NullString); !ok {
@@ -110,7 +110,7 @@ func (us *UserSubscription) assignValues(columns []string, values []any) error {
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field expires_at", values[i])
 			} else if value.Valid {
-				us.ExpiresAt = int(value.Int64)
+				us.ExpiresAt = value.Int64
 			}
 		case usersubscription.FieldUserID:
 			if value, ok := values[i].(*sql.NullString); !ok {
diff --git a/internal/database/ent/db/usersubscription/usersubscription.go b/internal/database/ent/db/usersubscription/usersubscription.go
index e8a6c86f..5a34f32b 100644
--- a/internal/database/ent/db/usersubscription/usersubscription.go
+++ b/internal/database/ent/db/usersubscription/usersubscription.go
@@ -66,11 +66,11 @@ func ValidColumn(column string) bool {
 
 var (
 	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
-	DefaultCreatedAt func() int
+	DefaultCreatedAt func() int64
 	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
-	DefaultUpdatedAt func() int
+	DefaultUpdatedAt func() int64
 	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
-	UpdateDefaultUpdatedAt func() int
+	UpdateDefaultUpdatedAt func() int64
 	// UserIDValidator is a validator for the "user_id" field. It is called by the builders before save.
 	UserIDValidator func(string) error
 	// PermissionsValidator is a validator for the "permissions" field. It is called by the builders before save.
diff --git a/internal/database/ent/db/usersubscription/where.go b/internal/database/ent/db/usersubscription/where.go
index 71f3025c..9111e4f8 100644
--- a/internal/database/ent/db/usersubscription/where.go
+++ b/internal/database/ent/db/usersubscription/where.go
@@ -65,17 +65,17 @@ func IDContainsFold(id string) predicate.UserSubscription {
 }
 
 // CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
-func CreatedAt(v int) predicate.UserSubscription {
+func CreatedAt(v int64) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
-func UpdatedAt(v int) predicate.UserSubscription {
+func UpdatedAt(v int64) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // ExpiresAt applies equality check predicate on the "expires_at" field. It's identical to ExpiresAtEQ.
-func ExpiresAt(v int) predicate.UserSubscription {
+func ExpiresAt(v int64) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldEQ(FieldExpiresAt, v))
 }
 
@@ -95,82 +95,82 @@ func ReferenceID(v string) predicate.UserSubscription {
 }
 
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v int) predicate.UserSubscription {
+func CreatedAtEQ(v int64) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v int) predicate.UserSubscription {
+func CreatedAtNEQ(v int64) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldNEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...int) predicate.UserSubscription {
+func CreatedAtIn(vs ...int64) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...int) predicate.UserSubscription {
+func CreatedAtNotIn(vs ...int64) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldNotIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v int) predicate.UserSubscription {
+func CreatedAtGT(v int64) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldGT(FieldCreatedAt, v))
 }
 
 // CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v int) predicate.UserSubscription {
+func CreatedAtGTE(v int64) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldGTE(FieldCreatedAt, v))
 }
 
 // CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v int) predicate.UserSubscription {
+func CreatedAtLT(v int64) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldLT(FieldCreatedAt, v))
 }
 
 // CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v int) predicate.UserSubscription {
+func CreatedAtLTE(v int64) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldLTE(FieldCreatedAt, v))
 }
 
 // UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
-func UpdatedAtEQ(v int) predicate.UserSubscription {
+func UpdatedAtEQ(v int64) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
-func UpdatedAtNEQ(v int) predicate.UserSubscription {
+func UpdatedAtNEQ(v int64) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldNEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtIn applies the In predicate on the "updated_at" field.
-func UpdatedAtIn(vs ...int) predicate.UserSubscription {
+func UpdatedAtIn(vs ...int64) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
-func UpdatedAtNotIn(vs ...int) predicate.UserSubscription {
+func UpdatedAtNotIn(vs ...int64) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldNotIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtGT applies the GT predicate on the "updated_at" field.
-func UpdatedAtGT(v int) predicate.UserSubscription {
+func UpdatedAtGT(v int64) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldGT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
-func UpdatedAtGTE(v int) predicate.UserSubscription {
+func UpdatedAtGTE(v int64) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldGTE(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLT applies the LT predicate on the "updated_at" field.
-func UpdatedAtLT(v int) predicate.UserSubscription {
+func UpdatedAtLT(v int64) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldLT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
-func UpdatedAtLTE(v int) predicate.UserSubscription {
+func UpdatedAtLTE(v int64) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldLTE(FieldUpdatedAt, v))
 }
 
@@ -205,42 +205,42 @@ func TypeNotIn(vs ...models.SubscriptionType) predicate.UserSubscription {
 }
 
 // ExpiresAtEQ applies the EQ predicate on the "expires_at" field.
-func ExpiresAtEQ(v int) predicate.UserSubscription {
+func ExpiresAtEQ(v int64) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldEQ(FieldExpiresAt, v))
 }
 
 // ExpiresAtNEQ applies the NEQ predicate on the "expires_at" field.
-func ExpiresAtNEQ(v int) predicate.UserSubscription {
+func ExpiresAtNEQ(v int64) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldNEQ(FieldExpiresAt, v))
 }
 
 // ExpiresAtIn applies the In predicate on the "expires_at" field.
-func ExpiresAtIn(vs ...int) predicate.UserSubscription {
+func ExpiresAtIn(vs ...int64) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldIn(FieldExpiresAt, vs...))
 }
 
 // ExpiresAtNotIn applies the NotIn predicate on the "expires_at" field.
-func ExpiresAtNotIn(vs ...int) predicate.UserSubscription {
+func ExpiresAtNotIn(vs ...int64) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldNotIn(FieldExpiresAt, vs...))
 }
 
 // ExpiresAtGT applies the GT predicate on the "expires_at" field.
-func ExpiresAtGT(v int) predicate.UserSubscription {
+func ExpiresAtGT(v int64) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldGT(FieldExpiresAt, v))
 }
 
 // ExpiresAtGTE applies the GTE predicate on the "expires_at" field.
-func ExpiresAtGTE(v int) predicate.UserSubscription {
+func ExpiresAtGTE(v int64) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldGTE(FieldExpiresAt, v))
 }
 
 // ExpiresAtLT applies the LT predicate on the "expires_at" field.
-func ExpiresAtLT(v int) predicate.UserSubscription {
+func ExpiresAtLT(v int64) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldLT(FieldExpiresAt, v))
 }
 
 // ExpiresAtLTE applies the LTE predicate on the "expires_at" field.
-func ExpiresAtLTE(v int) predicate.UserSubscription {
+func ExpiresAtLTE(v int64) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldLTE(FieldExpiresAt, v))
 }
 
diff --git a/internal/database/ent/db/usersubscription_create.go b/internal/database/ent/db/usersubscription_create.go
index fe9f5eee..64971258 100644
--- a/internal/database/ent/db/usersubscription_create.go
+++ b/internal/database/ent/db/usersubscription_create.go
@@ -22,13 +22,13 @@ type UserSubscriptionCreate struct {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (usc *UserSubscriptionCreate) SetCreatedAt(i int) *UserSubscriptionCreate {
+func (usc *UserSubscriptionCreate) SetCreatedAt(i int64) *UserSubscriptionCreate {
 	usc.mutation.SetCreatedAt(i)
 	return usc
 }
 
 // SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
-func (usc *UserSubscriptionCreate) SetNillableCreatedAt(i *int) *UserSubscriptionCreate {
+func (usc *UserSubscriptionCreate) SetNillableCreatedAt(i *int64) *UserSubscriptionCreate {
 	if i != nil {
 		usc.SetCreatedAt(*i)
 	}
@@ -36,13 +36,13 @@ func (usc *UserSubscriptionCreate) SetNillableCreatedAt(i *int) *UserSubscriptio
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (usc *UserSubscriptionCreate) SetUpdatedAt(i int) *UserSubscriptionCreate {
+func (usc *UserSubscriptionCreate) SetUpdatedAt(i int64) *UserSubscriptionCreate {
 	usc.mutation.SetUpdatedAt(i)
 	return usc
 }
 
 // SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
-func (usc *UserSubscriptionCreate) SetNillableUpdatedAt(i *int) *UserSubscriptionCreate {
+func (usc *UserSubscriptionCreate) SetNillableUpdatedAt(i *int64) *UserSubscriptionCreate {
 	if i != nil {
 		usc.SetUpdatedAt(*i)
 	}
@@ -56,7 +56,7 @@ func (usc *UserSubscriptionCreate) SetType(mt models.SubscriptionType) *UserSubs
 }
 
 // SetExpiresAt sets the "expires_at" field.
-func (usc *UserSubscriptionCreate) SetExpiresAt(i int) *UserSubscriptionCreate {
+func (usc *UserSubscriptionCreate) SetExpiresAt(i int64) *UserSubscriptionCreate {
 	usc.mutation.SetExpiresAt(i)
 	return usc
 }
@@ -229,11 +229,11 @@ func (usc *UserSubscriptionCreate) createSpec() (*UserSubscription, *sqlgraph.Cr
 		_spec.ID.Value = id
 	}
 	if value, ok := usc.mutation.CreatedAt(); ok {
-		_spec.SetField(usersubscription.FieldCreatedAt, field.TypeInt, value)
+		_spec.SetField(usersubscription.FieldCreatedAt, field.TypeInt64, value)
 		_node.CreatedAt = value
 	}
 	if value, ok := usc.mutation.UpdatedAt(); ok {
-		_spec.SetField(usersubscription.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(usersubscription.FieldUpdatedAt, field.TypeInt64, value)
 		_node.UpdatedAt = value
 	}
 	if value, ok := usc.mutation.GetType(); ok {
@@ -241,7 +241,7 @@ func (usc *UserSubscriptionCreate) createSpec() (*UserSubscription, *sqlgraph.Cr
 		_node.Type = value
 	}
 	if value, ok := usc.mutation.ExpiresAt(); ok {
-		_spec.SetField(usersubscription.FieldExpiresAt, field.TypeInt, value)
+		_spec.SetField(usersubscription.FieldExpiresAt, field.TypeInt64, value)
 		_node.ExpiresAt = value
 	}
 	if value, ok := usc.mutation.Permissions(); ok {
diff --git a/internal/database/ent/db/usersubscription_query.go b/internal/database/ent/db/usersubscription_query.go
index dc392666..25027d45 100644
--- a/internal/database/ent/db/usersubscription_query.go
+++ b/internal/database/ent/db/usersubscription_query.go
@@ -297,7 +297,7 @@ func (usq *UserSubscriptionQuery) WithUser(opts ...func(*UserQuery)) *UserSubscr
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int `json:"created_at,omitempty"`
+//		CreatedAt int64 `json:"created_at,omitempty"`
 //		Count int `json:"count,omitempty"`
 //	}
 //
@@ -320,7 +320,7 @@ func (usq *UserSubscriptionQuery) GroupBy(field string, fields ...string) *UserS
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int `json:"created_at,omitempty"`
+//		CreatedAt int64 `json:"created_at,omitempty"`
 //	}
 //
 //	client.UserSubscription.Query().
diff --git a/internal/database/ent/db/usersubscription_update.go b/internal/database/ent/db/usersubscription_update.go
index ccb7e131..b2806f54 100644
--- a/internal/database/ent/db/usersubscription_update.go
+++ b/internal/database/ent/db/usersubscription_update.go
@@ -29,14 +29,14 @@ func (usu *UserSubscriptionUpdate) Where(ps ...predicate.UserSubscription) *User
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (usu *UserSubscriptionUpdate) SetUpdatedAt(i int) *UserSubscriptionUpdate {
+func (usu *UserSubscriptionUpdate) SetUpdatedAt(i int64) *UserSubscriptionUpdate {
 	usu.mutation.ResetUpdatedAt()
 	usu.mutation.SetUpdatedAt(i)
 	return usu
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (usu *UserSubscriptionUpdate) AddUpdatedAt(i int) *UserSubscriptionUpdate {
+func (usu *UserSubscriptionUpdate) AddUpdatedAt(i int64) *UserSubscriptionUpdate {
 	usu.mutation.AddUpdatedAt(i)
 	return usu
 }
@@ -56,14 +56,14 @@ func (usu *UserSubscriptionUpdate) SetNillableType(mt *models.SubscriptionType)
 }
 
 // SetExpiresAt sets the "expires_at" field.
-func (usu *UserSubscriptionUpdate) SetExpiresAt(i int) *UserSubscriptionUpdate {
+func (usu *UserSubscriptionUpdate) SetExpiresAt(i int64) *UserSubscriptionUpdate {
 	usu.mutation.ResetExpiresAt()
 	usu.mutation.SetExpiresAt(i)
 	return usu
 }
 
 // SetNillableExpiresAt sets the "expires_at" field if the given value is not nil.
-func (usu *UserSubscriptionUpdate) SetNillableExpiresAt(i *int) *UserSubscriptionUpdate {
+func (usu *UserSubscriptionUpdate) SetNillableExpiresAt(i *int64) *UserSubscriptionUpdate {
 	if i != nil {
 		usu.SetExpiresAt(*i)
 	}
@@ -71,7 +71,7 @@ func (usu *UserSubscriptionUpdate) SetNillableExpiresAt(i *int) *UserSubscriptio
 }
 
 // AddExpiresAt adds i to the "expires_at" field.
-func (usu *UserSubscriptionUpdate) AddExpiresAt(i int) *UserSubscriptionUpdate {
+func (usu *UserSubscriptionUpdate) AddExpiresAt(i int64) *UserSubscriptionUpdate {
 	usu.mutation.AddExpiresAt(i)
 	return usu
 }
@@ -181,19 +181,19 @@ func (usu *UserSubscriptionUpdate) sqlSave(ctx context.Context) (n int, err erro
 		}
 	}
 	if value, ok := usu.mutation.UpdatedAt(); ok {
-		_spec.SetField(usersubscription.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(usersubscription.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := usu.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(usersubscription.FieldUpdatedAt, field.TypeInt, value)
+		_spec.AddField(usersubscription.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := usu.mutation.GetType(); ok {
 		_spec.SetField(usersubscription.FieldType, field.TypeEnum, value)
 	}
 	if value, ok := usu.mutation.ExpiresAt(); ok {
-		_spec.SetField(usersubscription.FieldExpiresAt, field.TypeInt, value)
+		_spec.SetField(usersubscription.FieldExpiresAt, field.TypeInt64, value)
 	}
 	if value, ok := usu.mutation.AddedExpiresAt(); ok {
-		_spec.AddField(usersubscription.FieldExpiresAt, field.TypeInt, value)
+		_spec.AddField(usersubscription.FieldExpiresAt, field.TypeInt64, value)
 	}
 	if value, ok := usu.mutation.Permissions(); ok {
 		_spec.SetField(usersubscription.FieldPermissions, field.TypeString, value)
@@ -222,14 +222,14 @@ type UserSubscriptionUpdateOne struct {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (usuo *UserSubscriptionUpdateOne) SetUpdatedAt(i int) *UserSubscriptionUpdateOne {
+func (usuo *UserSubscriptionUpdateOne) SetUpdatedAt(i int64) *UserSubscriptionUpdateOne {
 	usuo.mutation.ResetUpdatedAt()
 	usuo.mutation.SetUpdatedAt(i)
 	return usuo
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (usuo *UserSubscriptionUpdateOne) AddUpdatedAt(i int) *UserSubscriptionUpdateOne {
+func (usuo *UserSubscriptionUpdateOne) AddUpdatedAt(i int64) *UserSubscriptionUpdateOne {
 	usuo.mutation.AddUpdatedAt(i)
 	return usuo
 }
@@ -249,14 +249,14 @@ func (usuo *UserSubscriptionUpdateOne) SetNillableType(mt *models.SubscriptionTy
 }
 
 // SetExpiresAt sets the "expires_at" field.
-func (usuo *UserSubscriptionUpdateOne) SetExpiresAt(i int) *UserSubscriptionUpdateOne {
+func (usuo *UserSubscriptionUpdateOne) SetExpiresAt(i int64) *UserSubscriptionUpdateOne {
 	usuo.mutation.ResetExpiresAt()
 	usuo.mutation.SetExpiresAt(i)
 	return usuo
 }
 
 // SetNillableExpiresAt sets the "expires_at" field if the given value is not nil.
-func (usuo *UserSubscriptionUpdateOne) SetNillableExpiresAt(i *int) *UserSubscriptionUpdateOne {
+func (usuo *UserSubscriptionUpdateOne) SetNillableExpiresAt(i *int64) *UserSubscriptionUpdateOne {
 	if i != nil {
 		usuo.SetExpiresAt(*i)
 	}
@@ -264,7 +264,7 @@ func (usuo *UserSubscriptionUpdateOne) SetNillableExpiresAt(i *int) *UserSubscri
 }
 
 // AddExpiresAt adds i to the "expires_at" field.
-func (usuo *UserSubscriptionUpdateOne) AddExpiresAt(i int) *UserSubscriptionUpdateOne {
+func (usuo *UserSubscriptionUpdateOne) AddExpiresAt(i int64) *UserSubscriptionUpdateOne {
 	usuo.mutation.AddExpiresAt(i)
 	return usuo
 }
@@ -404,19 +404,19 @@ func (usuo *UserSubscriptionUpdateOne) sqlSave(ctx context.Context) (_node *User
 		}
 	}
 	if value, ok := usuo.mutation.UpdatedAt(); ok {
-		_spec.SetField(usersubscription.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(usersubscription.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := usuo.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(usersubscription.FieldUpdatedAt, field.TypeInt, value)
+		_spec.AddField(usersubscription.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := usuo.mutation.GetType(); ok {
 		_spec.SetField(usersubscription.FieldType, field.TypeEnum, value)
 	}
 	if value, ok := usuo.mutation.ExpiresAt(); ok {
-		_spec.SetField(usersubscription.FieldExpiresAt, field.TypeInt, value)
+		_spec.SetField(usersubscription.FieldExpiresAt, field.TypeInt64, value)
 	}
 	if value, ok := usuo.mutation.AddedExpiresAt(); ok {
-		_spec.AddField(usersubscription.FieldExpiresAt, field.TypeInt, value)
+		_spec.AddField(usersubscription.FieldExpiresAt, field.TypeInt64, value)
 	}
 	if value, ok := usuo.mutation.Permissions(); ok {
 		_spec.SetField(usersubscription.FieldPermissions, field.TypeString, value)
diff --git a/internal/database/ent/db/vehicle.go b/internal/database/ent/db/vehicle.go
index 14f5ecf1..639c60e9 100644
--- a/internal/database/ent/db/vehicle.go
+++ b/internal/database/ent/db/vehicle.go
@@ -18,9 +18,9 @@ type Vehicle struct {
 	// ID of the ent.
 	ID string `json:"id,omitempty"`
 	// CreatedAt holds the value of the "created_at" field.
-	CreatedAt int `json:"created_at,omitempty"`
+	CreatedAt int64 `json:"created_at,omitempty"`
 	// UpdatedAt holds the value of the "updated_at" field.
-	UpdatedAt int `json:"updated_at,omitempty"`
+	UpdatedAt int64 `json:"updated_at,omitempty"`
 	// Tier holds the value of the "tier" field.
 	Tier int `json:"tier,omitempty"`
 	// LocalizedNames holds the value of the "localized_names" field.
@@ -64,13 +64,13 @@ func (v *Vehicle) assignValues(columns []string, values []any) error {
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field created_at", values[i])
 			} else if value.Valid {
-				v.CreatedAt = int(value.Int64)
+				v.CreatedAt = value.Int64
 			}
 		case vehicle.FieldUpdatedAt:
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
 			} else if value.Valid {
-				v.UpdatedAt = int(value.Int64)
+				v.UpdatedAt = value.Int64
 			}
 		case vehicle.FieldTier:
 			if value, ok := values[i].(*sql.NullInt64); !ok {
diff --git a/internal/database/ent/db/vehicle/vehicle.go b/internal/database/ent/db/vehicle/vehicle.go
index 236f55e0..5e417ea2 100644
--- a/internal/database/ent/db/vehicle/vehicle.go
+++ b/internal/database/ent/db/vehicle/vehicle.go
@@ -44,11 +44,11 @@ func ValidColumn(column string) bool {
 
 var (
 	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
-	DefaultCreatedAt func() int
+	DefaultCreatedAt func() int64
 	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
-	DefaultUpdatedAt func() int
+	DefaultUpdatedAt func() int64
 	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
-	UpdateDefaultUpdatedAt func() int
+	UpdateDefaultUpdatedAt func() int64
 	// TierValidator is a validator for the "tier" field. It is called by the builders before save.
 	TierValidator func(int) error
 )
diff --git a/internal/database/ent/db/vehicle/where.go b/internal/database/ent/db/vehicle/where.go
index c09e0846..5bf6a6dc 100644
--- a/internal/database/ent/db/vehicle/where.go
+++ b/internal/database/ent/db/vehicle/where.go
@@ -63,12 +63,12 @@ func IDContainsFold(id string) predicate.Vehicle {
 }
 
 // CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
-func CreatedAt(v int) predicate.Vehicle {
+func CreatedAt(v int64) predicate.Vehicle {
 	return predicate.Vehicle(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
-func UpdatedAt(v int) predicate.Vehicle {
+func UpdatedAt(v int64) predicate.Vehicle {
 	return predicate.Vehicle(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
@@ -78,82 +78,82 @@ func Tier(v int) predicate.Vehicle {
 }
 
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v int) predicate.Vehicle {
+func CreatedAtEQ(v int64) predicate.Vehicle {
 	return predicate.Vehicle(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v int) predicate.Vehicle {
+func CreatedAtNEQ(v int64) predicate.Vehicle {
 	return predicate.Vehicle(sql.FieldNEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...int) predicate.Vehicle {
+func CreatedAtIn(vs ...int64) predicate.Vehicle {
 	return predicate.Vehicle(sql.FieldIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...int) predicate.Vehicle {
+func CreatedAtNotIn(vs ...int64) predicate.Vehicle {
 	return predicate.Vehicle(sql.FieldNotIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v int) predicate.Vehicle {
+func CreatedAtGT(v int64) predicate.Vehicle {
 	return predicate.Vehicle(sql.FieldGT(FieldCreatedAt, v))
 }
 
 // CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v int) predicate.Vehicle {
+func CreatedAtGTE(v int64) predicate.Vehicle {
 	return predicate.Vehicle(sql.FieldGTE(FieldCreatedAt, v))
 }
 
 // CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v int) predicate.Vehicle {
+func CreatedAtLT(v int64) predicate.Vehicle {
 	return predicate.Vehicle(sql.FieldLT(FieldCreatedAt, v))
 }
 
 // CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v int) predicate.Vehicle {
+func CreatedAtLTE(v int64) predicate.Vehicle {
 	return predicate.Vehicle(sql.FieldLTE(FieldCreatedAt, v))
 }
 
 // UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
-func UpdatedAtEQ(v int) predicate.Vehicle {
+func UpdatedAtEQ(v int64) predicate.Vehicle {
 	return predicate.Vehicle(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
-func UpdatedAtNEQ(v int) predicate.Vehicle {
+func UpdatedAtNEQ(v int64) predicate.Vehicle {
 	return predicate.Vehicle(sql.FieldNEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtIn applies the In predicate on the "updated_at" field.
-func UpdatedAtIn(vs ...int) predicate.Vehicle {
+func UpdatedAtIn(vs ...int64) predicate.Vehicle {
 	return predicate.Vehicle(sql.FieldIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
-func UpdatedAtNotIn(vs ...int) predicate.Vehicle {
+func UpdatedAtNotIn(vs ...int64) predicate.Vehicle {
 	return predicate.Vehicle(sql.FieldNotIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtGT applies the GT predicate on the "updated_at" field.
-func UpdatedAtGT(v int) predicate.Vehicle {
+func UpdatedAtGT(v int64) predicate.Vehicle {
 	return predicate.Vehicle(sql.FieldGT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
-func UpdatedAtGTE(v int) predicate.Vehicle {
+func UpdatedAtGTE(v int64) predicate.Vehicle {
 	return predicate.Vehicle(sql.FieldGTE(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLT applies the LT predicate on the "updated_at" field.
-func UpdatedAtLT(v int) predicate.Vehicle {
+func UpdatedAtLT(v int64) predicate.Vehicle {
 	return predicate.Vehicle(sql.FieldLT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
-func UpdatedAtLTE(v int) predicate.Vehicle {
+func UpdatedAtLTE(v int64) predicate.Vehicle {
 	return predicate.Vehicle(sql.FieldLTE(FieldUpdatedAt, v))
 }
 
diff --git a/internal/database/ent/db/vehicle_create.go b/internal/database/ent/db/vehicle_create.go
index 5487bf7b..b94dc90c 100644
--- a/internal/database/ent/db/vehicle_create.go
+++ b/internal/database/ent/db/vehicle_create.go
@@ -20,13 +20,13 @@ type VehicleCreate struct {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (vc *VehicleCreate) SetCreatedAt(i int) *VehicleCreate {
+func (vc *VehicleCreate) SetCreatedAt(i int64) *VehicleCreate {
 	vc.mutation.SetCreatedAt(i)
 	return vc
 }
 
 // SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
-func (vc *VehicleCreate) SetNillableCreatedAt(i *int) *VehicleCreate {
+func (vc *VehicleCreate) SetNillableCreatedAt(i *int64) *VehicleCreate {
 	if i != nil {
 		vc.SetCreatedAt(*i)
 	}
@@ -34,13 +34,13 @@ func (vc *VehicleCreate) SetNillableCreatedAt(i *int) *VehicleCreate {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (vc *VehicleCreate) SetUpdatedAt(i int) *VehicleCreate {
+func (vc *VehicleCreate) SetUpdatedAt(i int64) *VehicleCreate {
 	vc.mutation.SetUpdatedAt(i)
 	return vc
 }
 
 // SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
-func (vc *VehicleCreate) SetNillableUpdatedAt(i *int) *VehicleCreate {
+func (vc *VehicleCreate) SetNillableUpdatedAt(i *int64) *VehicleCreate {
 	if i != nil {
 		vc.SetUpdatedAt(*i)
 	}
@@ -165,11 +165,11 @@ func (vc *VehicleCreate) createSpec() (*Vehicle, *sqlgraph.CreateSpec) {
 		_spec.ID.Value = id
 	}
 	if value, ok := vc.mutation.CreatedAt(); ok {
-		_spec.SetField(vehicle.FieldCreatedAt, field.TypeInt, value)
+		_spec.SetField(vehicle.FieldCreatedAt, field.TypeInt64, value)
 		_node.CreatedAt = value
 	}
 	if value, ok := vc.mutation.UpdatedAt(); ok {
-		_spec.SetField(vehicle.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(vehicle.FieldUpdatedAt, field.TypeInt64, value)
 		_node.UpdatedAt = value
 	}
 	if value, ok := vc.mutation.Tier(); ok {
diff --git a/internal/database/ent/db/vehicle_query.go b/internal/database/ent/db/vehicle_query.go
index 2eef76b0..6b09ce3b 100644
--- a/internal/database/ent/db/vehicle_query.go
+++ b/internal/database/ent/db/vehicle_query.go
@@ -261,7 +261,7 @@ func (vq *VehicleQuery) Clone() *VehicleQuery {
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int `json:"created_at,omitempty"`
+//		CreatedAt int64 `json:"created_at,omitempty"`
 //		Count int `json:"count,omitempty"`
 //	}
 //
@@ -284,7 +284,7 @@ func (vq *VehicleQuery) GroupBy(field string, fields ...string) *VehicleGroupBy
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int `json:"created_at,omitempty"`
+//		CreatedAt int64 `json:"created_at,omitempty"`
 //	}
 //
 //	client.Vehicle.Query().
diff --git a/internal/database/ent/db/vehicle_update.go b/internal/database/ent/db/vehicle_update.go
index 0459f716..f5cec932 100644
--- a/internal/database/ent/db/vehicle_update.go
+++ b/internal/database/ent/db/vehicle_update.go
@@ -28,14 +28,14 @@ func (vu *VehicleUpdate) Where(ps ...predicate.Vehicle) *VehicleUpdate {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (vu *VehicleUpdate) SetUpdatedAt(i int) *VehicleUpdate {
+func (vu *VehicleUpdate) SetUpdatedAt(i int64) *VehicleUpdate {
 	vu.mutation.ResetUpdatedAt()
 	vu.mutation.SetUpdatedAt(i)
 	return vu
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (vu *VehicleUpdate) AddUpdatedAt(i int) *VehicleUpdate {
+func (vu *VehicleUpdate) AddUpdatedAt(i int64) *VehicleUpdate {
 	vu.mutation.AddUpdatedAt(i)
 	return vu
 }
@@ -131,10 +131,10 @@ func (vu *VehicleUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 	}
 	if value, ok := vu.mutation.UpdatedAt(); ok {
-		_spec.SetField(vehicle.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(vehicle.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := vu.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(vehicle.FieldUpdatedAt, field.TypeInt, value)
+		_spec.AddField(vehicle.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := vu.mutation.Tier(); ok {
 		_spec.SetField(vehicle.FieldTier, field.TypeInt, value)
@@ -166,14 +166,14 @@ type VehicleUpdateOne struct {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (vuo *VehicleUpdateOne) SetUpdatedAt(i int) *VehicleUpdateOne {
+func (vuo *VehicleUpdateOne) SetUpdatedAt(i int64) *VehicleUpdateOne {
 	vuo.mutation.ResetUpdatedAt()
 	vuo.mutation.SetUpdatedAt(i)
 	return vuo
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (vuo *VehicleUpdateOne) AddUpdatedAt(i int) *VehicleUpdateOne {
+func (vuo *VehicleUpdateOne) AddUpdatedAt(i int64) *VehicleUpdateOne {
 	vuo.mutation.AddUpdatedAt(i)
 	return vuo
 }
@@ -299,10 +299,10 @@ func (vuo *VehicleUpdateOne) sqlSave(ctx context.Context) (_node *Vehicle, err e
 		}
 	}
 	if value, ok := vuo.mutation.UpdatedAt(); ok {
-		_spec.SetField(vehicle.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(vehicle.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := vuo.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(vehicle.FieldUpdatedAt, field.TypeInt, value)
+		_spec.AddField(vehicle.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := vuo.mutation.Tier(); ok {
 		_spec.SetField(vehicle.FieldTier, field.TypeInt, value)
diff --git a/internal/database/ent/db/vehicleaverage.go b/internal/database/ent/db/vehicleaverage.go
index 8b300a7e..f24062ab 100644
--- a/internal/database/ent/db/vehicleaverage.go
+++ b/internal/database/ent/db/vehicleaverage.go
@@ -19,11 +19,11 @@ type VehicleAverage struct {
 	// ID of the ent.
 	ID string `json:"id,omitempty"`
 	// CreatedAt holds the value of the "created_at" field.
-	CreatedAt int `json:"created_at,omitempty"`
+	CreatedAt int64 `json:"created_at,omitempty"`
 	// UpdatedAt holds the value of the "updated_at" field.
-	UpdatedAt int `json:"updated_at,omitempty"`
+	UpdatedAt int64 `json:"updated_at,omitempty"`
 	// Data holds the value of the "data" field.
-	Data         map[string]frame.StatsFrame `json:"data,omitempty"`
+	Data         frame.StatsFrame `json:"data,omitempty"`
 	selectValues sql.SelectValues
 }
 
@@ -63,13 +63,13 @@ func (va *VehicleAverage) assignValues(columns []string, values []any) error {
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field created_at", values[i])
 			} else if value.Valid {
-				va.CreatedAt = int(value.Int64)
+				va.CreatedAt = value.Int64
 			}
 		case vehicleaverage.FieldUpdatedAt:
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
 			} else if value.Valid {
-				va.UpdatedAt = int(value.Int64)
+				va.UpdatedAt = value.Int64
 			}
 		case vehicleaverage.FieldData:
 			if value, ok := values[i].(*[]byte); !ok {
diff --git a/internal/database/ent/db/vehicleaverage/vehicleaverage.go b/internal/database/ent/db/vehicleaverage/vehicleaverage.go
index 4b90c1bc..ab45c826 100644
--- a/internal/database/ent/db/vehicleaverage/vehicleaverage.go
+++ b/internal/database/ent/db/vehicleaverage/vehicleaverage.go
@@ -41,11 +41,11 @@ func ValidColumn(column string) bool {
 
 var (
 	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
-	DefaultCreatedAt func() int
+	DefaultCreatedAt func() int64
 	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
-	DefaultUpdatedAt func() int
+	DefaultUpdatedAt func() int64
 	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
-	UpdateDefaultUpdatedAt func() int
+	UpdateDefaultUpdatedAt func() int64
 )
 
 // OrderOption defines the ordering options for the VehicleAverage queries.
diff --git a/internal/database/ent/db/vehicleaverage/where.go b/internal/database/ent/db/vehicleaverage/where.go
index 08934c78..e9f20546 100644
--- a/internal/database/ent/db/vehicleaverage/where.go
+++ b/internal/database/ent/db/vehicleaverage/where.go
@@ -63,92 +63,92 @@ func IDContainsFold(id string) predicate.VehicleAverage {
 }
 
 // CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
-func CreatedAt(v int) predicate.VehicleAverage {
+func CreatedAt(v int64) predicate.VehicleAverage {
 	return predicate.VehicleAverage(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
-func UpdatedAt(v int) predicate.VehicleAverage {
+func UpdatedAt(v int64) predicate.VehicleAverage {
 	return predicate.VehicleAverage(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v int) predicate.VehicleAverage {
+func CreatedAtEQ(v int64) predicate.VehicleAverage {
 	return predicate.VehicleAverage(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v int) predicate.VehicleAverage {
+func CreatedAtNEQ(v int64) predicate.VehicleAverage {
 	return predicate.VehicleAverage(sql.FieldNEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...int) predicate.VehicleAverage {
+func CreatedAtIn(vs ...int64) predicate.VehicleAverage {
 	return predicate.VehicleAverage(sql.FieldIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...int) predicate.VehicleAverage {
+func CreatedAtNotIn(vs ...int64) predicate.VehicleAverage {
 	return predicate.VehicleAverage(sql.FieldNotIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v int) predicate.VehicleAverage {
+func CreatedAtGT(v int64) predicate.VehicleAverage {
 	return predicate.VehicleAverage(sql.FieldGT(FieldCreatedAt, v))
 }
 
 // CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v int) predicate.VehicleAverage {
+func CreatedAtGTE(v int64) predicate.VehicleAverage {
 	return predicate.VehicleAverage(sql.FieldGTE(FieldCreatedAt, v))
 }
 
 // CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v int) predicate.VehicleAverage {
+func CreatedAtLT(v int64) predicate.VehicleAverage {
 	return predicate.VehicleAverage(sql.FieldLT(FieldCreatedAt, v))
 }
 
 // CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v int) predicate.VehicleAverage {
+func CreatedAtLTE(v int64) predicate.VehicleAverage {
 	return predicate.VehicleAverage(sql.FieldLTE(FieldCreatedAt, v))
 }
 
 // UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
-func UpdatedAtEQ(v int) predicate.VehicleAverage {
+func UpdatedAtEQ(v int64) predicate.VehicleAverage {
 	return predicate.VehicleAverage(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
-func UpdatedAtNEQ(v int) predicate.VehicleAverage {
+func UpdatedAtNEQ(v int64) predicate.VehicleAverage {
 	return predicate.VehicleAverage(sql.FieldNEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtIn applies the In predicate on the "updated_at" field.
-func UpdatedAtIn(vs ...int) predicate.VehicleAverage {
+func UpdatedAtIn(vs ...int64) predicate.VehicleAverage {
 	return predicate.VehicleAverage(sql.FieldIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
-func UpdatedAtNotIn(vs ...int) predicate.VehicleAverage {
+func UpdatedAtNotIn(vs ...int64) predicate.VehicleAverage {
 	return predicate.VehicleAverage(sql.FieldNotIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtGT applies the GT predicate on the "updated_at" field.
-func UpdatedAtGT(v int) predicate.VehicleAverage {
+func UpdatedAtGT(v int64) predicate.VehicleAverage {
 	return predicate.VehicleAverage(sql.FieldGT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
-func UpdatedAtGTE(v int) predicate.VehicleAverage {
+func UpdatedAtGTE(v int64) predicate.VehicleAverage {
 	return predicate.VehicleAverage(sql.FieldGTE(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLT applies the LT predicate on the "updated_at" field.
-func UpdatedAtLT(v int) predicate.VehicleAverage {
+func UpdatedAtLT(v int64) predicate.VehicleAverage {
 	return predicate.VehicleAverage(sql.FieldLT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
-func UpdatedAtLTE(v int) predicate.VehicleAverage {
+func UpdatedAtLTE(v int64) predicate.VehicleAverage {
 	return predicate.VehicleAverage(sql.FieldLTE(FieldUpdatedAt, v))
 }
 
diff --git a/internal/database/ent/db/vehicleaverage_create.go b/internal/database/ent/db/vehicleaverage_create.go
index 01704d15..1ed5f96c 100644
--- a/internal/database/ent/db/vehicleaverage_create.go
+++ b/internal/database/ent/db/vehicleaverage_create.go
@@ -21,13 +21,13 @@ type VehicleAverageCreate struct {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (vac *VehicleAverageCreate) SetCreatedAt(i int) *VehicleAverageCreate {
+func (vac *VehicleAverageCreate) SetCreatedAt(i int64) *VehicleAverageCreate {
 	vac.mutation.SetCreatedAt(i)
 	return vac
 }
 
 // SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
-func (vac *VehicleAverageCreate) SetNillableCreatedAt(i *int) *VehicleAverageCreate {
+func (vac *VehicleAverageCreate) SetNillableCreatedAt(i *int64) *VehicleAverageCreate {
 	if i != nil {
 		vac.SetCreatedAt(*i)
 	}
@@ -35,13 +35,13 @@ func (vac *VehicleAverageCreate) SetNillableCreatedAt(i *int) *VehicleAverageCre
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (vac *VehicleAverageCreate) SetUpdatedAt(i int) *VehicleAverageCreate {
+func (vac *VehicleAverageCreate) SetUpdatedAt(i int64) *VehicleAverageCreate {
 	vac.mutation.SetUpdatedAt(i)
 	return vac
 }
 
 // SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
-func (vac *VehicleAverageCreate) SetNillableUpdatedAt(i *int) *VehicleAverageCreate {
+func (vac *VehicleAverageCreate) SetNillableUpdatedAt(i *int64) *VehicleAverageCreate {
 	if i != nil {
 		vac.SetUpdatedAt(*i)
 	}
@@ -49,8 +49,8 @@ func (vac *VehicleAverageCreate) SetNillableUpdatedAt(i *int) *VehicleAverageCre
 }
 
 // SetData sets the "data" field.
-func (vac *VehicleAverageCreate) SetData(mf map[string]frame.StatsFrame) *VehicleAverageCreate {
-	vac.mutation.SetData(mf)
+func (vac *VehicleAverageCreate) SetData(ff frame.StatsFrame) *VehicleAverageCreate {
+	vac.mutation.SetData(ff)
 	return vac
 }
 
@@ -152,11 +152,11 @@ func (vac *VehicleAverageCreate) createSpec() (*VehicleAverage, *sqlgraph.Create
 		_spec.ID.Value = id
 	}
 	if value, ok := vac.mutation.CreatedAt(); ok {
-		_spec.SetField(vehicleaverage.FieldCreatedAt, field.TypeInt, value)
+		_spec.SetField(vehicleaverage.FieldCreatedAt, field.TypeInt64, value)
 		_node.CreatedAt = value
 	}
 	if value, ok := vac.mutation.UpdatedAt(); ok {
-		_spec.SetField(vehicleaverage.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(vehicleaverage.FieldUpdatedAt, field.TypeInt64, value)
 		_node.UpdatedAt = value
 	}
 	if value, ok := vac.mutation.Data(); ok {
diff --git a/internal/database/ent/db/vehicleaverage_query.go b/internal/database/ent/db/vehicleaverage_query.go
index 67b533b4..b5c7891d 100644
--- a/internal/database/ent/db/vehicleaverage_query.go
+++ b/internal/database/ent/db/vehicleaverage_query.go
@@ -261,7 +261,7 @@ func (vaq *VehicleAverageQuery) Clone() *VehicleAverageQuery {
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int `json:"created_at,omitempty"`
+//		CreatedAt int64 `json:"created_at,omitempty"`
 //		Count int `json:"count,omitempty"`
 //	}
 //
@@ -284,7 +284,7 @@ func (vaq *VehicleAverageQuery) GroupBy(field string, fields ...string) *Vehicle
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int `json:"created_at,omitempty"`
+//		CreatedAt int64 `json:"created_at,omitempty"`
 //	}
 //
 //	client.VehicleAverage.Query().
diff --git a/internal/database/ent/db/vehicleaverage_update.go b/internal/database/ent/db/vehicleaverage_update.go
index 787df205..199f96c2 100644
--- a/internal/database/ent/db/vehicleaverage_update.go
+++ b/internal/database/ent/db/vehicleaverage_update.go
@@ -29,21 +29,29 @@ func (vau *VehicleAverageUpdate) Where(ps ...predicate.VehicleAverage) *VehicleA
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (vau *VehicleAverageUpdate) SetUpdatedAt(i int) *VehicleAverageUpdate {
+func (vau *VehicleAverageUpdate) SetUpdatedAt(i int64) *VehicleAverageUpdate {
 	vau.mutation.ResetUpdatedAt()
 	vau.mutation.SetUpdatedAt(i)
 	return vau
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (vau *VehicleAverageUpdate) AddUpdatedAt(i int) *VehicleAverageUpdate {
+func (vau *VehicleAverageUpdate) AddUpdatedAt(i int64) *VehicleAverageUpdate {
 	vau.mutation.AddUpdatedAt(i)
 	return vau
 }
 
 // SetData sets the "data" field.
-func (vau *VehicleAverageUpdate) SetData(mf map[string]frame.StatsFrame) *VehicleAverageUpdate {
-	vau.mutation.SetData(mf)
+func (vau *VehicleAverageUpdate) SetData(ff frame.StatsFrame) *VehicleAverageUpdate {
+	vau.mutation.SetData(ff)
+	return vau
+}
+
+// SetNillableData sets the "data" field if the given value is not nil.
+func (vau *VehicleAverageUpdate) SetNillableData(ff *frame.StatsFrame) *VehicleAverageUpdate {
+	if ff != nil {
+		vau.SetData(*ff)
+	}
 	return vau
 }
 
@@ -98,10 +106,10 @@ func (vau *VehicleAverageUpdate) sqlSave(ctx context.Context) (n int, err error)
 		}
 	}
 	if value, ok := vau.mutation.UpdatedAt(); ok {
-		_spec.SetField(vehicleaverage.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(vehicleaverage.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := vau.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(vehicleaverage.FieldUpdatedAt, field.TypeInt, value)
+		_spec.AddField(vehicleaverage.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := vau.mutation.Data(); ok {
 		_spec.SetField(vehicleaverage.FieldData, field.TypeJSON, value)
@@ -127,21 +135,29 @@ type VehicleAverageUpdateOne struct {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (vauo *VehicleAverageUpdateOne) SetUpdatedAt(i int) *VehicleAverageUpdateOne {
+func (vauo *VehicleAverageUpdateOne) SetUpdatedAt(i int64) *VehicleAverageUpdateOne {
 	vauo.mutation.ResetUpdatedAt()
 	vauo.mutation.SetUpdatedAt(i)
 	return vauo
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (vauo *VehicleAverageUpdateOne) AddUpdatedAt(i int) *VehicleAverageUpdateOne {
+func (vauo *VehicleAverageUpdateOne) AddUpdatedAt(i int64) *VehicleAverageUpdateOne {
 	vauo.mutation.AddUpdatedAt(i)
 	return vauo
 }
 
 // SetData sets the "data" field.
-func (vauo *VehicleAverageUpdateOne) SetData(mf map[string]frame.StatsFrame) *VehicleAverageUpdateOne {
-	vauo.mutation.SetData(mf)
+func (vauo *VehicleAverageUpdateOne) SetData(ff frame.StatsFrame) *VehicleAverageUpdateOne {
+	vauo.mutation.SetData(ff)
+	return vauo
+}
+
+// SetNillableData sets the "data" field if the given value is not nil.
+func (vauo *VehicleAverageUpdateOne) SetNillableData(ff *frame.StatsFrame) *VehicleAverageUpdateOne {
+	if ff != nil {
+		vauo.SetData(*ff)
+	}
 	return vauo
 }
 
@@ -226,10 +242,10 @@ func (vauo *VehicleAverageUpdateOne) sqlSave(ctx context.Context) (_node *Vehicl
 		}
 	}
 	if value, ok := vauo.mutation.UpdatedAt(); ok {
-		_spec.SetField(vehicleaverage.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(vehicleaverage.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := vauo.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(vehicleaverage.FieldUpdatedAt, field.TypeInt, value)
+		_spec.AddField(vehicleaverage.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := vauo.mutation.Data(); ok {
 		_spec.SetField(vehicleaverage.FieldData, field.TypeJSON, value)
diff --git a/internal/database/ent/db/vehiclesnapshot.go b/internal/database/ent/db/vehiclesnapshot.go
index ae0d2d10..03565cf0 100644
--- a/internal/database/ent/db/vehiclesnapshot.go
+++ b/internal/database/ent/db/vehiclesnapshot.go
@@ -21,9 +21,9 @@ type VehicleSnapshot struct {
 	// ID of the ent.
 	ID string `json:"id,omitempty"`
 	// CreatedAt holds the value of the "created_at" field.
-	CreatedAt int `json:"created_at,omitempty"`
+	CreatedAt int64 `json:"created_at,omitempty"`
 	// UpdatedAt holds the value of the "updated_at" field.
-	UpdatedAt int `json:"updated_at,omitempty"`
+	UpdatedAt int64 `json:"updated_at,omitempty"`
 	// Type holds the value of the "type" field.
 	Type models.SnapshotType `json:"type,omitempty"`
 	// AccountID holds the value of the "account_id" field.
@@ -35,7 +35,7 @@ type VehicleSnapshot struct {
 	// Battles holds the value of the "battles" field.
 	Battles int `json:"battles,omitempty"`
 	// LastBattleTime holds the value of the "last_battle_time" field.
-	LastBattleTime int `json:"last_battle_time,omitempty"`
+	LastBattleTime int64 `json:"last_battle_time,omitempty"`
 	// Frame holds the value of the "frame" field.
 	Frame frame.StatsFrame `json:"frame,omitempty"`
 	// Edges holds the relations/edges for other nodes in the graph.
@@ -100,13 +100,13 @@ func (vs *VehicleSnapshot) assignValues(columns []string, values []any) error {
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field created_at", values[i])
 			} else if value.Valid {
-				vs.CreatedAt = int(value.Int64)
+				vs.CreatedAt = value.Int64
 			}
 		case vehiclesnapshot.FieldUpdatedAt:
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
 			} else if value.Valid {
-				vs.UpdatedAt = int(value.Int64)
+				vs.UpdatedAt = value.Int64
 			}
 		case vehiclesnapshot.FieldType:
 			if value, ok := values[i].(*sql.NullString); !ok {
@@ -142,7 +142,7 @@ func (vs *VehicleSnapshot) assignValues(columns []string, values []any) error {
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field last_battle_time", values[i])
 			} else if value.Valid {
-				vs.LastBattleTime = int(value.Int64)
+				vs.LastBattleTime = value.Int64
 			}
 		case vehiclesnapshot.FieldFrame:
 			if value, ok := values[i].(*[]byte); !ok {
diff --git a/internal/database/ent/db/vehiclesnapshot/vehiclesnapshot.go b/internal/database/ent/db/vehiclesnapshot/vehiclesnapshot.go
index aa8d81ed..0d13bf1a 100644
--- a/internal/database/ent/db/vehiclesnapshot/vehiclesnapshot.go
+++ b/internal/database/ent/db/vehiclesnapshot/vehiclesnapshot.go
@@ -72,11 +72,11 @@ func ValidColumn(column string) bool {
 
 var (
 	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
-	DefaultCreatedAt func() int
+	DefaultCreatedAt func() int64
 	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
-	DefaultUpdatedAt func() int
+	DefaultUpdatedAt func() int64
 	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
-	UpdateDefaultUpdatedAt func() int
+	UpdateDefaultUpdatedAt func() int64
 	// AccountIDValidator is a validator for the "account_id" field. It is called by the builders before save.
 	AccountIDValidator func(string) error
 	// VehicleIDValidator is a validator for the "vehicle_id" field. It is called by the builders before save.
diff --git a/internal/database/ent/db/vehiclesnapshot/where.go b/internal/database/ent/db/vehiclesnapshot/where.go
index 758156fe..d0489259 100644
--- a/internal/database/ent/db/vehiclesnapshot/where.go
+++ b/internal/database/ent/db/vehiclesnapshot/where.go
@@ -65,12 +65,12 @@ func IDContainsFold(id string) predicate.VehicleSnapshot {
 }
 
 // CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
-func CreatedAt(v int) predicate.VehicleSnapshot {
+func CreatedAt(v int64) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
-func UpdatedAt(v int) predicate.VehicleSnapshot {
+func UpdatedAt(v int64) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
@@ -95,87 +95,87 @@ func Battles(v int) predicate.VehicleSnapshot {
 }
 
 // LastBattleTime applies equality check predicate on the "last_battle_time" field. It's identical to LastBattleTimeEQ.
-func LastBattleTime(v int) predicate.VehicleSnapshot {
+func LastBattleTime(v int64) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldEQ(FieldLastBattleTime, v))
 }
 
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v int) predicate.VehicleSnapshot {
+func CreatedAtEQ(v int64) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v int) predicate.VehicleSnapshot {
+func CreatedAtNEQ(v int64) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldNEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...int) predicate.VehicleSnapshot {
+func CreatedAtIn(vs ...int64) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...int) predicate.VehicleSnapshot {
+func CreatedAtNotIn(vs ...int64) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldNotIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v int) predicate.VehicleSnapshot {
+func CreatedAtGT(v int64) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldGT(FieldCreatedAt, v))
 }
 
 // CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v int) predicate.VehicleSnapshot {
+func CreatedAtGTE(v int64) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldGTE(FieldCreatedAt, v))
 }
 
 // CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v int) predicate.VehicleSnapshot {
+func CreatedAtLT(v int64) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldLT(FieldCreatedAt, v))
 }
 
 // CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v int) predicate.VehicleSnapshot {
+func CreatedAtLTE(v int64) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldLTE(FieldCreatedAt, v))
 }
 
 // UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
-func UpdatedAtEQ(v int) predicate.VehicleSnapshot {
+func UpdatedAtEQ(v int64) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
-func UpdatedAtNEQ(v int) predicate.VehicleSnapshot {
+func UpdatedAtNEQ(v int64) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldNEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtIn applies the In predicate on the "updated_at" field.
-func UpdatedAtIn(vs ...int) predicate.VehicleSnapshot {
+func UpdatedAtIn(vs ...int64) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
-func UpdatedAtNotIn(vs ...int) predicate.VehicleSnapshot {
+func UpdatedAtNotIn(vs ...int64) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldNotIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtGT applies the GT predicate on the "updated_at" field.
-func UpdatedAtGT(v int) predicate.VehicleSnapshot {
+func UpdatedAtGT(v int64) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldGT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
-func UpdatedAtGTE(v int) predicate.VehicleSnapshot {
+func UpdatedAtGTE(v int64) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldGTE(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLT applies the LT predicate on the "updated_at" field.
-func UpdatedAtLT(v int) predicate.VehicleSnapshot {
+func UpdatedAtLT(v int64) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldLT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
-func UpdatedAtLTE(v int) predicate.VehicleSnapshot {
+func UpdatedAtLTE(v int64) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldLTE(FieldUpdatedAt, v))
 }
 
@@ -445,42 +445,42 @@ func BattlesLTE(v int) predicate.VehicleSnapshot {
 }
 
 // LastBattleTimeEQ applies the EQ predicate on the "last_battle_time" field.
-func LastBattleTimeEQ(v int) predicate.VehicleSnapshot {
+func LastBattleTimeEQ(v int64) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldEQ(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeNEQ applies the NEQ predicate on the "last_battle_time" field.
-func LastBattleTimeNEQ(v int) predicate.VehicleSnapshot {
+func LastBattleTimeNEQ(v int64) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldNEQ(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeIn applies the In predicate on the "last_battle_time" field.
-func LastBattleTimeIn(vs ...int) predicate.VehicleSnapshot {
+func LastBattleTimeIn(vs ...int64) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldIn(FieldLastBattleTime, vs...))
 }
 
 // LastBattleTimeNotIn applies the NotIn predicate on the "last_battle_time" field.
-func LastBattleTimeNotIn(vs ...int) predicate.VehicleSnapshot {
+func LastBattleTimeNotIn(vs ...int64) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldNotIn(FieldLastBattleTime, vs...))
 }
 
 // LastBattleTimeGT applies the GT predicate on the "last_battle_time" field.
-func LastBattleTimeGT(v int) predicate.VehicleSnapshot {
+func LastBattleTimeGT(v int64) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldGT(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeGTE applies the GTE predicate on the "last_battle_time" field.
-func LastBattleTimeGTE(v int) predicate.VehicleSnapshot {
+func LastBattleTimeGTE(v int64) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldGTE(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeLT applies the LT predicate on the "last_battle_time" field.
-func LastBattleTimeLT(v int) predicate.VehicleSnapshot {
+func LastBattleTimeLT(v int64) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldLT(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeLTE applies the LTE predicate on the "last_battle_time" field.
-func LastBattleTimeLTE(v int) predicate.VehicleSnapshot {
+func LastBattleTimeLTE(v int64) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldLTE(FieldLastBattleTime, v))
 }
 
diff --git a/internal/database/ent/db/vehiclesnapshot_create.go b/internal/database/ent/db/vehiclesnapshot_create.go
index 6120d27b..32c64243 100644
--- a/internal/database/ent/db/vehiclesnapshot_create.go
+++ b/internal/database/ent/db/vehiclesnapshot_create.go
@@ -23,13 +23,13 @@ type VehicleSnapshotCreate struct {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (vsc *VehicleSnapshotCreate) SetCreatedAt(i int) *VehicleSnapshotCreate {
+func (vsc *VehicleSnapshotCreate) SetCreatedAt(i int64) *VehicleSnapshotCreate {
 	vsc.mutation.SetCreatedAt(i)
 	return vsc
 }
 
 // SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
-func (vsc *VehicleSnapshotCreate) SetNillableCreatedAt(i *int) *VehicleSnapshotCreate {
+func (vsc *VehicleSnapshotCreate) SetNillableCreatedAt(i *int64) *VehicleSnapshotCreate {
 	if i != nil {
 		vsc.SetCreatedAt(*i)
 	}
@@ -37,13 +37,13 @@ func (vsc *VehicleSnapshotCreate) SetNillableCreatedAt(i *int) *VehicleSnapshotC
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (vsc *VehicleSnapshotCreate) SetUpdatedAt(i int) *VehicleSnapshotCreate {
+func (vsc *VehicleSnapshotCreate) SetUpdatedAt(i int64) *VehicleSnapshotCreate {
 	vsc.mutation.SetUpdatedAt(i)
 	return vsc
 }
 
 // SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
-func (vsc *VehicleSnapshotCreate) SetNillableUpdatedAt(i *int) *VehicleSnapshotCreate {
+func (vsc *VehicleSnapshotCreate) SetNillableUpdatedAt(i *int64) *VehicleSnapshotCreate {
 	if i != nil {
 		vsc.SetUpdatedAt(*i)
 	}
@@ -81,7 +81,7 @@ func (vsc *VehicleSnapshotCreate) SetBattles(i int) *VehicleSnapshotCreate {
 }
 
 // SetLastBattleTime sets the "last_battle_time" field.
-func (vsc *VehicleSnapshotCreate) SetLastBattleTime(i int) *VehicleSnapshotCreate {
+func (vsc *VehicleSnapshotCreate) SetLastBattleTime(i int64) *VehicleSnapshotCreate {
 	vsc.mutation.SetLastBattleTime(i)
 	return vsc
 }
@@ -248,11 +248,11 @@ func (vsc *VehicleSnapshotCreate) createSpec() (*VehicleSnapshot, *sqlgraph.Crea
 		_spec.ID.Value = id
 	}
 	if value, ok := vsc.mutation.CreatedAt(); ok {
-		_spec.SetField(vehiclesnapshot.FieldCreatedAt, field.TypeInt, value)
+		_spec.SetField(vehiclesnapshot.FieldCreatedAt, field.TypeInt64, value)
 		_node.CreatedAt = value
 	}
 	if value, ok := vsc.mutation.UpdatedAt(); ok {
-		_spec.SetField(vehiclesnapshot.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(vehiclesnapshot.FieldUpdatedAt, field.TypeInt64, value)
 		_node.UpdatedAt = value
 	}
 	if value, ok := vsc.mutation.GetType(); ok {
@@ -272,7 +272,7 @@ func (vsc *VehicleSnapshotCreate) createSpec() (*VehicleSnapshot, *sqlgraph.Crea
 		_node.Battles = value
 	}
 	if value, ok := vsc.mutation.LastBattleTime(); ok {
-		_spec.SetField(vehiclesnapshot.FieldLastBattleTime, field.TypeInt, value)
+		_spec.SetField(vehiclesnapshot.FieldLastBattleTime, field.TypeInt64, value)
 		_node.LastBattleTime = value
 	}
 	if value, ok := vsc.mutation.Frame(); ok {
diff --git a/internal/database/ent/db/vehiclesnapshot_query.go b/internal/database/ent/db/vehiclesnapshot_query.go
index 89f20225..c6c9730e 100644
--- a/internal/database/ent/db/vehiclesnapshot_query.go
+++ b/internal/database/ent/db/vehiclesnapshot_query.go
@@ -297,7 +297,7 @@ func (vsq *VehicleSnapshotQuery) WithAccount(opts ...func(*AccountQuery)) *Vehic
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int `json:"created_at,omitempty"`
+//		CreatedAt int64 `json:"created_at,omitempty"`
 //		Count int `json:"count,omitempty"`
 //	}
 //
@@ -320,7 +320,7 @@ func (vsq *VehicleSnapshotQuery) GroupBy(field string, fields ...string) *Vehicl
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int `json:"created_at,omitempty"`
+//		CreatedAt int64 `json:"created_at,omitempty"`
 //	}
 //
 //	client.VehicleSnapshot.Query().
diff --git a/internal/database/ent/db/vehiclesnapshot_update.go b/internal/database/ent/db/vehiclesnapshot_update.go
index a80ac271..ec24d4d9 100644
--- a/internal/database/ent/db/vehiclesnapshot_update.go
+++ b/internal/database/ent/db/vehiclesnapshot_update.go
@@ -30,14 +30,14 @@ func (vsu *VehicleSnapshotUpdate) Where(ps ...predicate.VehicleSnapshot) *Vehicl
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (vsu *VehicleSnapshotUpdate) SetUpdatedAt(i int) *VehicleSnapshotUpdate {
+func (vsu *VehicleSnapshotUpdate) SetUpdatedAt(i int64) *VehicleSnapshotUpdate {
 	vsu.mutation.ResetUpdatedAt()
 	vsu.mutation.SetUpdatedAt(i)
 	return vsu
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (vsu *VehicleSnapshotUpdate) AddUpdatedAt(i int) *VehicleSnapshotUpdate {
+func (vsu *VehicleSnapshotUpdate) AddUpdatedAt(i int64) *VehicleSnapshotUpdate {
 	vsu.mutation.AddUpdatedAt(i)
 	return vsu
 }
@@ -92,14 +92,14 @@ func (vsu *VehicleSnapshotUpdate) AddBattles(i int) *VehicleSnapshotUpdate {
 }
 
 // SetLastBattleTime sets the "last_battle_time" field.
-func (vsu *VehicleSnapshotUpdate) SetLastBattleTime(i int) *VehicleSnapshotUpdate {
+func (vsu *VehicleSnapshotUpdate) SetLastBattleTime(i int64) *VehicleSnapshotUpdate {
 	vsu.mutation.ResetLastBattleTime()
 	vsu.mutation.SetLastBattleTime(i)
 	return vsu
 }
 
 // SetNillableLastBattleTime sets the "last_battle_time" field if the given value is not nil.
-func (vsu *VehicleSnapshotUpdate) SetNillableLastBattleTime(i *int) *VehicleSnapshotUpdate {
+func (vsu *VehicleSnapshotUpdate) SetNillableLastBattleTime(i *int64) *VehicleSnapshotUpdate {
 	if i != nil {
 		vsu.SetLastBattleTime(*i)
 	}
@@ -107,7 +107,7 @@ func (vsu *VehicleSnapshotUpdate) SetNillableLastBattleTime(i *int) *VehicleSnap
 }
 
 // AddLastBattleTime adds i to the "last_battle_time" field.
-func (vsu *VehicleSnapshotUpdate) AddLastBattleTime(i int) *VehicleSnapshotUpdate {
+func (vsu *VehicleSnapshotUpdate) AddLastBattleTime(i int64) *VehicleSnapshotUpdate {
 	vsu.mutation.AddLastBattleTime(i)
 	return vsu
 }
@@ -198,10 +198,10 @@ func (vsu *VehicleSnapshotUpdate) sqlSave(ctx context.Context) (n int, err error
 		}
 	}
 	if value, ok := vsu.mutation.UpdatedAt(); ok {
-		_spec.SetField(vehiclesnapshot.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(vehiclesnapshot.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := vsu.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(vehiclesnapshot.FieldUpdatedAt, field.TypeInt, value)
+		_spec.AddField(vehiclesnapshot.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := vsu.mutation.GetType(); ok {
 		_spec.SetField(vehiclesnapshot.FieldType, field.TypeEnum, value)
@@ -216,10 +216,10 @@ func (vsu *VehicleSnapshotUpdate) sqlSave(ctx context.Context) (n int, err error
 		_spec.AddField(vehiclesnapshot.FieldBattles, field.TypeInt, value)
 	}
 	if value, ok := vsu.mutation.LastBattleTime(); ok {
-		_spec.SetField(vehiclesnapshot.FieldLastBattleTime, field.TypeInt, value)
+		_spec.SetField(vehiclesnapshot.FieldLastBattleTime, field.TypeInt64, value)
 	}
 	if value, ok := vsu.mutation.AddedLastBattleTime(); ok {
-		_spec.AddField(vehiclesnapshot.FieldLastBattleTime, field.TypeInt, value)
+		_spec.AddField(vehiclesnapshot.FieldLastBattleTime, field.TypeInt64, value)
 	}
 	if value, ok := vsu.mutation.Frame(); ok {
 		_spec.SetField(vehiclesnapshot.FieldFrame, field.TypeJSON, value)
@@ -245,14 +245,14 @@ type VehicleSnapshotUpdateOne struct {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (vsuo *VehicleSnapshotUpdateOne) SetUpdatedAt(i int) *VehicleSnapshotUpdateOne {
+func (vsuo *VehicleSnapshotUpdateOne) SetUpdatedAt(i int64) *VehicleSnapshotUpdateOne {
 	vsuo.mutation.ResetUpdatedAt()
 	vsuo.mutation.SetUpdatedAt(i)
 	return vsuo
 }
 
 // AddUpdatedAt adds i to the "updated_at" field.
-func (vsuo *VehicleSnapshotUpdateOne) AddUpdatedAt(i int) *VehicleSnapshotUpdateOne {
+func (vsuo *VehicleSnapshotUpdateOne) AddUpdatedAt(i int64) *VehicleSnapshotUpdateOne {
 	vsuo.mutation.AddUpdatedAt(i)
 	return vsuo
 }
@@ -307,14 +307,14 @@ func (vsuo *VehicleSnapshotUpdateOne) AddBattles(i int) *VehicleSnapshotUpdateOn
 }
 
 // SetLastBattleTime sets the "last_battle_time" field.
-func (vsuo *VehicleSnapshotUpdateOne) SetLastBattleTime(i int) *VehicleSnapshotUpdateOne {
+func (vsuo *VehicleSnapshotUpdateOne) SetLastBattleTime(i int64) *VehicleSnapshotUpdateOne {
 	vsuo.mutation.ResetLastBattleTime()
 	vsuo.mutation.SetLastBattleTime(i)
 	return vsuo
 }
 
 // SetNillableLastBattleTime sets the "last_battle_time" field if the given value is not nil.
-func (vsuo *VehicleSnapshotUpdateOne) SetNillableLastBattleTime(i *int) *VehicleSnapshotUpdateOne {
+func (vsuo *VehicleSnapshotUpdateOne) SetNillableLastBattleTime(i *int64) *VehicleSnapshotUpdateOne {
 	if i != nil {
 		vsuo.SetLastBattleTime(*i)
 	}
@@ -322,7 +322,7 @@ func (vsuo *VehicleSnapshotUpdateOne) SetNillableLastBattleTime(i *int) *Vehicle
 }
 
 // AddLastBattleTime adds i to the "last_battle_time" field.
-func (vsuo *VehicleSnapshotUpdateOne) AddLastBattleTime(i int) *VehicleSnapshotUpdateOne {
+func (vsuo *VehicleSnapshotUpdateOne) AddLastBattleTime(i int64) *VehicleSnapshotUpdateOne {
 	vsuo.mutation.AddLastBattleTime(i)
 	return vsuo
 }
@@ -443,10 +443,10 @@ func (vsuo *VehicleSnapshotUpdateOne) sqlSave(ctx context.Context) (_node *Vehic
 		}
 	}
 	if value, ok := vsuo.mutation.UpdatedAt(); ok {
-		_spec.SetField(vehiclesnapshot.FieldUpdatedAt, field.TypeInt, value)
+		_spec.SetField(vehiclesnapshot.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := vsuo.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(vehiclesnapshot.FieldUpdatedAt, field.TypeInt, value)
+		_spec.AddField(vehiclesnapshot.FieldUpdatedAt, field.TypeInt64, value)
 	}
 	if value, ok := vsuo.mutation.GetType(); ok {
 		_spec.SetField(vehiclesnapshot.FieldType, field.TypeEnum, value)
@@ -461,10 +461,10 @@ func (vsuo *VehicleSnapshotUpdateOne) sqlSave(ctx context.Context) (_node *Vehic
 		_spec.AddField(vehiclesnapshot.FieldBattles, field.TypeInt, value)
 	}
 	if value, ok := vsuo.mutation.LastBattleTime(); ok {
-		_spec.SetField(vehiclesnapshot.FieldLastBattleTime, field.TypeInt, value)
+		_spec.SetField(vehiclesnapshot.FieldLastBattleTime, field.TypeInt64, value)
 	}
 	if value, ok := vsuo.mutation.AddedLastBattleTime(); ok {
-		_spec.AddField(vehiclesnapshot.FieldLastBattleTime, field.TypeInt, value)
+		_spec.AddField(vehiclesnapshot.FieldLastBattleTime, field.TypeInt64, value)
 	}
 	if value, ok := vsuo.mutation.Frame(); ok {
 		_spec.SetField(vehiclesnapshot.FieldFrame, field.TypeJSON, value)
diff --git a/internal/database/ent/migrate.go b/internal/database/ent/migrate.go
deleted file mode 100644
index 39d7f1aa..00000000
--- a/internal/database/ent/migrate.go
+++ /dev/null
@@ -1,63 +0,0 @@
-package ent
-
-import (
-	"database/sql"
-)
-
-const migration = `
-CREATE TABLE 'accounts' ('id' text NOT NULL, 'created_at' integer NOT NULL, 'updated_at' integer NOT NULL, 'last_battle_time' integer NOT NULL, 'account_created_at' integer NOT NULL, 'realm' text NOT NULL, 'nickname' text NOT NULL, 'private' bool NOT NULL DEFAULT (false), 'clan_id' text NULL, PRIMARY KEY ('id'), CONSTRAINT 'accounts_clans_accounts' FOREIGN KEY ('clan_id') REFERENCES 'clans' ('id') ON DELETE SET NULL);
-CREATE INDEX 'account_id_last_battle_time' ON 'accounts' ('id', 'last_battle_time');
-CREATE INDEX 'account_realm' ON 'accounts' ('realm');
-CREATE INDEX 'account_realm_last_battle_time' ON 'accounts' ('realm', 'last_battle_time');
-CREATE INDEX 'account_clan_id' ON 'accounts' ('clan_id');
-CREATE TABLE 'account_snapshots' ('id' text NOT NULL, 'created_at' integer NOT NULL, 'updated_at' integer NOT NULL, 'type' text NOT NULL, 'last_battle_time' integer NOT NULL, 'reference_id' text NOT NULL, 'rating_battles' integer NOT NULL, 'rating_frame' json NOT NULL, 'regular_battles' integer NOT NULL, 'regular_frame' json NOT NULL, 'account_id' text NOT NULL, PRIMARY KEY ('id'), CONSTRAINT 'account_snapshots_accounts_snapshots' FOREIGN KEY ('account_id') REFERENCES 'accounts' ('id') ON DELETE NO ACTION);
-CREATE INDEX 'accountsnapshot_created_at' ON 'account_snapshots' ('created_at');
-CREATE INDEX 'accountsnapshot_type_account_id_created_at' ON 'account_snapshots' ('type', 'account_id', 'created_at');
-CREATE INDEX 'accountsnapshot_type_account_id_reference_id' ON 'account_snapshots' ('type', 'account_id', 'reference_id');
-CREATE INDEX 'accountsnapshot_type_account_id_reference_id_created_at' ON 'account_snapshots' ('type', 'account_id', 'reference_id', 'created_at');
-CREATE TABLE 'achievements_snapshots' ('id' text NOT NULL, 'created_at' integer NOT NULL, 'updated_at' integer NOT NULL, 'type' text NOT NULL, 'reference_id' text NOT NULL, 'battles' integer NOT NULL, 'last_battle_time' integer NOT NULL, 'data' json NOT NULL, 'account_id' text NOT NULL, PRIMARY KEY ('id'), CONSTRAINT 'achievements_snapshots_accounts_achievement_snapshots' FOREIGN KEY ('account_id') REFERENCES 'accounts' ('id') ON DELETE NO ACTION);
-CREATE INDEX 'achievementssnapshot_created_at' ON 'achievements_snapshots' ('created_at');
-CREATE INDEX 'achievementssnapshot_account_id_reference_id' ON 'achievements_snapshots' ('account_id', 'reference_id');
-CREATE INDEX 'achievementssnapshot_account_id_reference_id_created_at' ON 'achievements_snapshots' ('account_id', 'reference_id', 'created_at');
-CREATE TABLE 'app_configurations' ('id' text NOT NULL, 'created_at' integer NOT NULL, 'updated_at' integer NOT NULL, 'key' text NOT NULL, 'value' json NOT NULL, 'metadata' json NULL, PRIMARY KEY ('id'));
-CREATE UNIQUE INDEX 'app_configurations_key_key' ON 'app_configurations' ('key');
-CREATE INDEX 'appconfiguration_key' ON 'app_configurations' ('key');
-CREATE TABLE 'application_commands' ('id' text NOT NULL, 'created_at' integer NOT NULL, 'updated_at' integer NOT NULL, 'name' text NOT NULL, 'version' text NOT NULL, 'options_hash' text NOT NULL, PRIMARY KEY ('id'));
-CREATE UNIQUE INDEX 'application_commands_name_key' ON 'application_commands' ('name');
-CREATE INDEX 'applicationcommand_options_hash' ON 'application_commands' ('options_hash');
-CREATE TABLE 'clans' ('id' text NOT NULL, 'created_at' integer NOT NULL, 'updated_at' integer NOT NULL, 'tag' text NOT NULL, 'name' text NOT NULL, 'emblem_id' text NULL DEFAULT (''), 'members' json NOT NULL, PRIMARY KEY ('id'));
-CREATE INDEX 'clan_tag' ON 'clans' ('tag');
-CREATE INDEX 'clan_name' ON 'clans' ('name');
-CREATE TABLE 'cron_tasks' ('id' text NOT NULL, 'created_at' integer NOT NULL, 'updated_at' integer NOT NULL, 'type' text NOT NULL, 'reference_id' text NOT NULL, 'targets' json NOT NULL, 'status' text NOT NULL, 'scheduled_after' integer NOT NULL, 'last_run' integer NOT NULL, 'logs' json NOT NULL, 'data' json NOT NULL, PRIMARY KEY ('id'));
-CREATE INDEX 'crontask_reference_id' ON 'cron_tasks' ('reference_id');
-CREATE INDEX 'crontask_status_last_run' ON 'cron_tasks' ('status', 'last_run');
-CREATE INDEX 'crontask_status_created_at' ON 'cron_tasks' ('status', 'created_at');
-CREATE INDEX 'crontask_status_scheduled_after' ON 'cron_tasks' ('status', 'scheduled_after');
-CREATE TABLE 'users' ('id' text NOT NULL, 'created_at' integer NOT NULL, 'updated_at' integer NOT NULL, 'permissions' text NOT NULL DEFAULT (''), 'feature_flags' json NULL, PRIMARY KEY ('id'));
-CREATE TABLE 'user_connections' ('id' text NOT NULL, 'created_at' integer NOT NULL, 'updated_at' integer NOT NULL, 'type' text NOT NULL, 'reference_id' text NOT NULL, 'permissions' text NULL DEFAULT (''), 'metadata' json NULL, 'user_id' text NOT NULL, PRIMARY KEY ('id'), CONSTRAINT 'user_connections_users_connections' FOREIGN KEY ('user_id') REFERENCES 'users' ('id') ON DELETE NO ACTION);
-CREATE INDEX 'userconnection_user_id' ON 'user_connections' ('user_id');
-CREATE INDEX 'userconnection_type_user_id' ON 'user_connections' ('type', 'user_id');
-CREATE INDEX 'userconnection_reference_id' ON 'user_connections' ('reference_id');
-CREATE INDEX 'userconnection_type_reference_id' ON 'user_connections' ('type', 'reference_id');
-CREATE TABLE 'user_contents' ('id' text NOT NULL, 'created_at' integer NOT NULL, 'updated_at' integer NOT NULL, 'type' text NOT NULL, 'reference_id' text NOT NULL, 'value' json NOT NULL, 'metadata' json NOT NULL, 'user_id' text NOT NULL, PRIMARY KEY ('id'), CONSTRAINT 'user_contents_users_content' FOREIGN KEY ('user_id') REFERENCES 'users' ('id') ON DELETE NO ACTION);
-CREATE INDEX 'usercontent_user_id' ON 'user_contents' ('user_id');
-CREATE INDEX 'usercontent_type_user_id' ON 'user_contents' ('type', 'user_id');
-CREATE INDEX 'usercontent_reference_id' ON 'user_contents' ('reference_id');
-CREATE INDEX 'usercontent_type_reference_id' ON 'user_contents' ('type', 'reference_id');
-CREATE TABLE 'user_subscriptions' ('id' text NOT NULL, 'created_at' integer NOT NULL, 'updated_at' integer NOT NULL, 'type' text NOT NULL, 'expires_at' integer NOT NULL, 'permissions' text NOT NULL, 'reference_id' text NOT NULL, 'user_id' text NOT NULL, PRIMARY KEY ('id'), CONSTRAINT 'user_subscriptions_users_subscriptions' FOREIGN KEY ('user_id') REFERENCES 'users' ('id') ON DELETE NO ACTION);
-CREATE INDEX 'usersubscription_user_id' ON 'user_subscriptions' ('user_id');
-CREATE INDEX 'usersubscription_type_user_id' ON 'user_subscriptions' ('type', 'user_id');
-CREATE INDEX 'usersubscription_expires_at' ON 'user_subscriptions' ('expires_at');
-CREATE INDEX 'usersubscription_expires_at_user_id' ON 'user_subscriptions' ('expires_at', 'user_id');
-CREATE TABLE 'vehicles' ('id' text NOT NULL, 'created_at' integer NOT NULL, 'updated_at' integer NOT NULL, 'tier' integer NOT NULL, 'localized_names' json NOT NULL, PRIMARY KEY ('id'));
-CREATE TABLE 'vehicle_averages' ('id' text NOT NULL, 'created_at' integer NOT NULL, 'updated_at' integer NOT NULL, 'data' json NOT NULL, PRIMARY KEY ('id'));
-CREATE TABLE 'vehicle_snapshots' ('id' text NOT NULL, 'created_at' integer NOT NULL, 'updated_at' integer NOT NULL, 'type' text NOT NULL, 'vehicle_id' text NOT NULL, 'reference_id' text NOT NULL, 'battles' integer NOT NULL, 'last_battle_time' integer NOT NULL, 'frame' json NOT NULL, 'account_id' text NOT NULL, PRIMARY KEY ('id'), CONSTRAINT 'vehicle_snapshots_accounts_vehicle_snapshots' FOREIGN KEY ('account_id') REFERENCES 'accounts' ('id') ON DELETE NO ACTION);
-CREATE INDEX 'vehiclesnapshot_created_at' ON 'vehicle_snapshots' ('created_at');
-CREATE INDEX 'vehiclesnapshot_vehicle_id_created_at' ON 'vehicle_snapshots' ('vehicle_id', 'created_at');
-CREATE INDEX 'vehiclesnapshot_account_id_created_at' ON 'vehicle_snapshots' ('account_id', 'created_at');
-CREATE INDEX 'vehiclesnapshot_account_id_type_created_at' ON 'vehicle_snapshots' ('account_id', 'type', 'created_at');`
-
-func RunMigrations(client *sql.DB) error {
-	_, err := client.Exec(migration)
-	return err
-}
diff --git a/internal/database/ent/migrate/main.go b/internal/database/ent/migrate/main.go
index d0ab8587..de8b8a3d 100644
--- a/internal/database/ent/migrate/main.go
+++ b/internal/database/ent/migrate/main.go
@@ -33,7 +33,7 @@ func main() {
 		log.Fatalln("migration name is required. Use: 'go run -mod=mod ent/migrate/main.go <name>'")
 	}
 	// Generate migrations using Atlas support for MySQL (note the Ent dialect option passed above).
-	err = migrate.NamedDiff(ctx, "libsql+ws://0.0.0.0:8080", os.Args[1], opts...)
+	err = migrate.NamedDiff(ctx, os.Getenv("DATABASE_URL"), os.Args[1], opts...)
 	if err != nil {
 		log.Fatalf("failed generating migration file: %v", err)
 	}
diff --git a/internal/database/ent/schema/account.go b/internal/database/ent/schema/account.go
index 4df6d398..1477f439 100644
--- a/internal/database/ent/schema/account.go
+++ b/internal/database/ent/schema/account.go
@@ -17,14 +17,14 @@ func (Account) Fields() []ent.Field {
 	return []ent.Field{field.String("id").
 		Unique().
 		Immutable(),
-		field.Int("created_at").
+		field.Int64("created_at").
 			Immutable().
 			DefaultFunc(timeNow),
-		field.Int("updated_at").
+		field.Int64("updated_at").
 			DefaultFunc(timeNow).
 			UpdateDefault(timeNow),
-		field.Int("last_battle_time"),
-		field.Int("account_created_at"),
+		field.Int64("last_battle_time"),
+		field.Int64("account_created_at"),
 		//
 		field.String("realm").
 			MinLen(2).
diff --git a/internal/database/ent/schema/accountsnapshot.go b/internal/database/ent/schema/account_snapshot.go
similarity index 97%
rename from internal/database/ent/schema/accountsnapshot.go
rename to internal/database/ent/schema/account_snapshot.go
index 6a33c4c4..cd9391eb 100644
--- a/internal/database/ent/schema/accountsnapshot.go
+++ b/internal/database/ent/schema/account_snapshot.go
@@ -19,7 +19,7 @@ func (AccountSnapshot) Fields() []ent.Field {
 	return append(defaultFields,
 		field.Enum("type").
 			GoType(models.SnapshotType("")),
-		field.Int("last_battle_time"),
+		field.Int64("last_battle_time"),
 		//
 		field.String("account_id").NotEmpty().Immutable(),
 		field.String("reference_id").NotEmpty(),
diff --git a/internal/database/ent/schema/achievementssnapshot.go b/internal/database/ent/schema/achievements_snapshot.go
similarity index 97%
rename from internal/database/ent/schema/achievementssnapshot.go
rename to internal/database/ent/schema/achievements_snapshot.go
index bfd87368..26258e9f 100644
--- a/internal/database/ent/schema/achievementssnapshot.go
+++ b/internal/database/ent/schema/achievements_snapshot.go
@@ -23,7 +23,7 @@ func (AchievementsSnapshot) Fields() []ent.Field {
 		field.String("reference_id").NotEmpty(),
 		//
 		field.Int("battles"),
-		field.Int("last_battle_time"),
+		field.Int64("last_battle_time"),
 		field.JSON("data", types.AchievementsFrame{}),
 	)
 }
diff --git a/internal/database/ent/schema/appconfiguration.go b/internal/database/ent/schema/app_configuration.go
similarity index 100%
rename from internal/database/ent/schema/appconfiguration.go
rename to internal/database/ent/schema/app_configuration.go
diff --git a/internal/database/ent/schema/applicationcommand.go b/internal/database/ent/schema/application_command.go
similarity index 100%
rename from internal/database/ent/schema/applicationcommand.go
rename to internal/database/ent/schema/application_command.go
diff --git a/internal/database/ent/schema/clan.go b/internal/database/ent/schema/clan.go
index 9b953820..9aa1738c 100644
--- a/internal/database/ent/schema/clan.go
+++ b/internal/database/ent/schema/clan.go
@@ -36,10 +36,10 @@ func (Clan) Fields() []ent.Field {
 		field.String("id").
 			Unique().
 			Immutable(),
-		field.Int("created_at").
+		field.Int64("created_at").
 			Immutable().
 			DefaultFunc(timeNow),
-		field.Int("updated_at").
+		field.Int64("updated_at").
 			DefaultFunc(timeNow).
 			UpdateDefault(timeNow),
 		//
diff --git a/internal/database/ent/schema/crontask.go b/internal/database/ent/schema/cron_task.go
similarity index 82%
rename from internal/database/ent/schema/crontask.go
rename to internal/database/ent/schema/cron_task.go
index f214f55d..d329c600 100644
--- a/internal/database/ent/schema/crontask.go
+++ b/internal/database/ent/schema/cron_task.go
@@ -15,13 +15,15 @@ type CronTask struct {
 // Fields of the CronTask.
 func (CronTask) Fields() []ent.Field {
 	return append(defaultFields,
-		field.String("type").NotEmpty(),
+		field.Enum("type").
+			GoType(models.TaskType("")),
 		field.String("reference_id").NotEmpty(),
 		field.Strings("targets"),
 		//
-		field.String("status").NotEmpty(),
-		field.Int("scheduled_after"),
-		field.Int("last_run"),
+		field.Enum("status").
+			GoType(models.TaskStatus("")),
+		field.Int64("scheduled_after"),
+		field.Int64("last_run"),
 		//
 		field.JSON("logs", []models.TaskLog{}),
 		field.JSON("data", map[string]any{}),
diff --git a/internal/database/ent/schema/defaults.go b/internal/database/ent/schema/defaults.go
index ddf92c1c..97d60c1d 100644
--- a/internal/database/ent/schema/defaults.go
+++ b/internal/database/ent/schema/defaults.go
@@ -13,12 +13,12 @@ var defaultFields = []ent.Field{
 		Unique().
 		Immutable().
 		DefaultFunc(cuid.New),
-	field.Int("created_at").
+	field.Int64("created_at").
 		Immutable().
 		DefaultFunc(timeNow),
-	field.Int("updated_at").
+	field.Int64("updated_at").
 		DefaultFunc(timeNow).
 		UpdateDefault(timeNow),
 }
 
-func timeNow() int { return int(time.Now().Unix()) }
+func timeNow() int64 { return time.Now().Unix() }
diff --git a/internal/database/ent/schema/user.go b/internal/database/ent/schema/user.go
index 188f638f..f821f9b0 100644
--- a/internal/database/ent/schema/user.go
+++ b/internal/database/ent/schema/user.go
@@ -17,10 +17,10 @@ func (User) Fields() []ent.Field {
 		field.String("id").
 			Unique().
 			Immutable(),
-		field.Int("created_at").
+		field.Int64("created_at").
 			Immutable().
 			DefaultFunc(timeNow),
-		field.Int("updated_at").
+		field.Int64("updated_at").
 			DefaultFunc(timeNow).
 			UpdateDefault(timeNow),
 		//
diff --git a/internal/database/ent/schema/userconnection.go b/internal/database/ent/schema/user_connection.go
similarity index 100%
rename from internal/database/ent/schema/userconnection.go
rename to internal/database/ent/schema/user_connection.go
diff --git a/internal/database/ent/schema/usercontent.go b/internal/database/ent/schema/user_content.go
similarity index 100%
rename from internal/database/ent/schema/usercontent.go
rename to internal/database/ent/schema/user_content.go
diff --git a/internal/database/ent/schema/usersubscription.go b/internal/database/ent/schema/user_subscription.go
similarity index 97%
rename from internal/database/ent/schema/usersubscription.go
rename to internal/database/ent/schema/user_subscription.go
index 2394efdb..b156bea2 100644
--- a/internal/database/ent/schema/usersubscription.go
+++ b/internal/database/ent/schema/user_subscription.go
@@ -18,7 +18,7 @@ func (UserSubscription) Fields() []ent.Field {
 	return append(defaultFields,
 		field.Enum("type").
 			GoType(models.SubscriptionType("")),
-		field.Int("expires_at"),
+		field.Int64("expires_at"),
 		//
 		field.String("user_id").NotEmpty().Immutable(),
 		field.String("permissions").NotEmpty(),
diff --git a/internal/database/ent/schema/vehicle.go b/internal/database/ent/schema/vehicle.go
index 525287a0..c66424b1 100644
--- a/internal/database/ent/schema/vehicle.go
+++ b/internal/database/ent/schema/vehicle.go
@@ -16,10 +16,10 @@ func (Vehicle) Fields() []ent.Field {
 		field.String("id").
 			Unique().
 			Immutable(),
-		field.Int("created_at").
+		field.Int64("created_at").
 			Immutable().
 			DefaultFunc(timeNow),
-		field.Int("updated_at").
+		field.Int64("updated_at").
 			DefaultFunc(timeNow).
 			UpdateDefault(timeNow),
 		//
diff --git a/internal/database/ent/schema/vehicleaverage.go b/internal/database/ent/schema/vehicle_average.go
similarity index 85%
rename from internal/database/ent/schema/vehicleaverage.go
rename to internal/database/ent/schema/vehicle_average.go
index edb1798a..eda545dd 100644
--- a/internal/database/ent/schema/vehicleaverage.go
+++ b/internal/database/ent/schema/vehicle_average.go
@@ -17,14 +17,14 @@ func (VehicleAverage) Fields() []ent.Field {
 		field.String("id").
 			Unique().
 			Immutable(),
-		field.Int("created_at").
+		field.Int64("created_at").
 			Immutable().
 			DefaultFunc(timeNow),
-		field.Int("updated_at").
+		field.Int64("updated_at").
 			DefaultFunc(timeNow).
 			UpdateDefault(timeNow),
 		//
-		field.JSON("data", map[string]frame.StatsFrame{}),
+		field.JSON("data", frame.StatsFrame{}),
 	}
 }
 
diff --git a/internal/database/ent/schema/vehiclesnapshot.go b/internal/database/ent/schema/vehicle_snapshot.go
similarity index 97%
rename from internal/database/ent/schema/vehiclesnapshot.go
rename to internal/database/ent/schema/vehicle_snapshot.go
index 88dc1fa1..e8ee67e4 100644
--- a/internal/database/ent/schema/vehiclesnapshot.go
+++ b/internal/database/ent/schema/vehicle_snapshot.go
@@ -25,7 +25,7 @@ func (VehicleSnapshot) Fields() []ent.Field {
 		field.String("reference_id").NotEmpty(),
 		//
 		field.Int("battles"),
-		field.Int("last_battle_time"),
+		field.Int64("last_battle_time"),
 		field.JSON("frame", frame.StatsFrame{}),
 	)
 }
diff --git a/internal/database/models/vehicle.go b/internal/database/models/vehicle.go
index b9f04a4e..53787d30 100644
--- a/internal/database/models/vehicle.go
+++ b/internal/database/models/vehicle.go
@@ -3,12 +3,8 @@ package models
 import "golang.org/x/text/language"
 
 type Vehicle struct {
-	ID     string
-	Tier   int
-	Type   string
-	Class  string
-	Nation string
-
+	ID             string
+	Tier           int
 	LocalizedNames map[string]string
 }
 
diff --git a/internal/database/snapshots.go b/internal/database/snapshots.go
index b6f390e4..10636ec6 100644
--- a/internal/database/snapshots.go
+++ b/internal/database/snapshots.go
@@ -4,21 +4,13 @@ import (
 	"context"
 	"time"
 
+	"github.com/cufee/aftermath/internal/database/ent/db"
+	"github.com/cufee/aftermath/internal/database/ent/db/accountsnapshot"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/ent/db/vehiclesnapshot"
 	"github.com/cufee/aftermath/internal/database/models"
 )
 
-// import (
-// 	"context"
-// 	"fmt"
-// 	"strings"
-// 	"time"
-
-// 	"github.com/cufee/aftermath/internal/database/prisma/db"
-// 	"github.com/cufee/aftermath/internal/stats/frame"
-// 	"github.com/rs/zerolog/log"
-// 	"github.com/steebchen/prisma-client-go/runtime/transaction"
-// )
-
 type getSnapshotQuery struct {
 	vehicleIDs []string
 
@@ -26,158 +18,6 @@ type getSnapshotQuery struct {
 	createdBefore *time.Time
 }
 
-// func (s getSnapshotQuery) accountParams(accountID, referenceID string, kind models.SnapshotType) []db.AccountSnapshotWhereParam {
-// 	var params []db.AccountSnapshotWhereParam
-// 	params = append(params, db.AccountSnapshot.Type.Equals(string(kind)))
-// 	params = append(params, db.AccountSnapshot.AccountID.Equals(accountID))
-// 	params = append(params, db.AccountSnapshot.ReferenceID.Equals(referenceID))
-
-// 	if s.createdAfter != nil {
-// 		params = append(params, db.AccountSnapshot.CreatedAt.After(*s.createdAfter))
-// 	}
-// 	if s.createdBefore != nil {
-// 		params = append(params, db.AccountSnapshot.CreatedAt.Before(*s.createdBefore))
-// 	}
-
-// 	return params
-// }
-
-// func (s getSnapshotQuery) vehiclesQuery(accountID, referenceID string, kind models.SnapshotType) (query string, params []interface{}) {
-// 	var conditions []string
-// 	var args []interface{}
-
-// 	// Mandatory conditions
-// 	conditions = append(conditions, "type = ?")
-// 	args = append(args, kind)
-
-// 	conditions = append(conditions, "accountId = ?")
-// 	args = append(args, accountID)
-
-// 	conditions = append(conditions, "referenceId = ?")
-// 	args = append(args, referenceID)
-
-// 	// Optional conditions
-// 	if s.createdAfter != nil {
-// 		conditions = append(conditions, "createdAt > ?")
-// 		args = append(args, *s.createdAfter)
-// 	}
-// 	if s.createdBefore != nil {
-// 		conditions = append(conditions, "createdAt < ?")
-// 		args = append(args, *s.createdBefore)
-// 	}
-
-// 	// Filter by vehicle IDs if provided
-// 	if len(s.vehicleIDs) > 0 {
-// 		placeholders := make([]string, len(s.vehicleIDs))
-// 		for i, id := range s.vehicleIDs {
-// 			placeholders[i] = "?"
-// 			args = append(args, id)
-// 		}
-// 		conditions = append(conditions, fmt.Sprintf("vehicleId IN (%s)", strings.Join(placeholders, ",")))
-// 	}
-
-// 	// Determine the order by clause
-// 	var orderBy string = "createdAt DESC"
-// 	if s.createdAfter != nil {
-// 		orderBy = "createdAt ASC"
-// 	}
-
-// 	// Base query
-// 	query = `
-// 		SELECT
-// 			id, createdAt, type, lastBattleTime, accountId, vehicleId, referenceId, battles, frameEncoded
-// 		FROM
-// 			vehicle_snapshots
-// 		WHERE
-// 			%s
-// 		ORDER BY
-// 			%s
-// 	`
-
-// 	// Combine conditions into a single string
-// 	conditionsStr := strings.Join(conditions, " AND ")
-// 	query = fmt.Sprintf(query, conditionsStr, orderBy)
-
-// 	// Wrap the query to select the latest or earliest snapshot per vehicleId
-// 	wrappedQuery := `
-// 		SELECT * FROM (
-// 			%s
-// 		) AS ordered_snapshots
-// 		GROUP BY vehicleId
-// 	`
-
-// 	query = fmt.Sprintf(wrappedQuery, query)
-// 	return query, args
-// }
-
-// func (s getSnapshotQuery) manyAccountsQuery(accountIDs []string, kind models.SnapshotType) (query string, params []interface{}) {
-// 	var conditions []string
-// 	var args []interface{}
-
-// 	// Mandatory conditions
-// 	conditions = append(conditions, "type = ?")
-// 	args = append(args, kind)
-
-// 	// Optional conditions
-// 	if s.createdAfter != nil {
-// 		conditions = append(conditions, "createdAt > ?")
-// 		args = append(args, *s.createdAfter)
-// 	}
-// 	if s.createdBefore != nil {
-// 		conditions = append(conditions, "createdAt < ?")
-// 		args = append(args, *s.createdBefore)
-// 	}
-
-// 	// Filter by account IDs
-// 	placeholders := make([]string, len(accountIDs))
-// 	for i := range accountIDs {
-// 		placeholders[i] = "?"
-// 	}
-// 	conditions = append(conditions, fmt.Sprintf("accountId IN (%s)", strings.Join(placeholders, ",")))
-// 	for _, id := range accountIDs {
-// 		args = append(args, id)
-// 	}
-
-// 	// Determine the order by clause
-// 	var orderBy string = "createdAt DESC"
-// 	if s.createdAfter != nil {
-// 		orderBy = "createdAt ASC"
-// 	}
-
-// 	// Combine conditions into a single string
-// 	conditionsStr := strings.Join(conditions, " AND ")
-
-// 	// Base query
-// 	query = fmt.Sprintf(`
-// 			SELECT
-// 				id, createdAt, type, lastBattleTime, accountId, referenceId, ratingBattles, ratingFrameEncoded, regularBattles, regularFrameEncoded
-// 			FROM
-// 				account_snapshots
-// 			WHERE
-// 				%s
-// 			ORDER BY
-// 				%s
-// 		`, conditionsStr, orderBy)
-
-// 	// Wrap the query to select the latest snapshot per accountId
-// 	wrappedQuery := fmt.Sprintf(`
-// 			SELECT * FROM (
-// 				%s
-// 			) AS ordered_snapshots
-// 			GROUP BY accountId
-// 		`, query)
-
-// 	return wrappedQuery, args
-// }
-
-// func (s getSnapshotQuery) accountOrder() []db.AccountSnapshotOrderByParam {
-// 	order := db.DESC
-// 	if s.createdAfter != nil {
-// 		order = db.ASC
-// 	}
-// 	return []db.AccountSnapshotOrderByParam{db.AccountSnapshot.CreatedAt.Order(order)}
-// }
-
 type SnapshotQuery func(*getSnapshotQuery)
 
 func WithVehicleIDs(ids []string) SnapshotQuery {
@@ -196,192 +36,173 @@ func WithCreatedBefore(before time.Time) SnapshotQuery {
 	}
 }
 
-// func (s models.VehicleSnapshot) FromModel(model db.models.VehicleSnapshotModel) (models.VehicleSnapshot, error) {
-// 	s.ID = model.ID
-// 	s.Type = models.SnapshotType(model.Type)
-// 	s.CreatedAt = model.CreatedAt
-// 	s.LastBattleTime = model.LastBattleTime
+func toVehicleSnapshot(record *db.VehicleSnapshot) models.VehicleSnapshot {
+	return models.VehicleSnapshot{
+		ID:             record.ID,
+		Type:           record.Type,
+		CreatedAt:      time.Unix(record.CreatedAt, 0),
+		LastBattleTime: time.Unix(record.LastBattleTime, 0),
+		ReferenceID:    record.ReferenceID,
+		AccountID:      record.AccountID,
+		VehicleID:      record.VehicleID,
+		Stats:          record.Frame,
+	}
+}
 
-// 	s.AccountID = model.AccountID
-// 	s.VehicleID = model.VehicleID
-// 	s.ReferenceID = model.ReferenceID
+func (c *libsqlClient) CreateVehicleSnapshots(ctx context.Context, snapshots ...models.VehicleSnapshot) error {
+	if len(snapshots) < 1 {
+		return nil
+	}
 
-// 	stats, err := frame.DecodeStatsFrame(model.FrameEncoded)
-// 	if err != nil {
-// 		return models.VehicleSnapshot{}, err
-// 	}
-// 	s.Stats = stats
-// 	return s, nil
-// }
+	var inserts []*db.VehicleSnapshotCreate
+	for _, data := range snapshots {
+		inserts = append(inserts,
+			c.db.VehicleSnapshot.Create().
+				SetType(data.Type).
+				SetFrame(data.Stats).
+				SetAccountID(data.AccountID).
+				SetVehicleID(data.VehicleID).
+				SetReferenceID(data.ReferenceID).
+				SetBattles(int(data.Stats.Battles.Float())).
+				SetLastBattleTime(data.LastBattleTime.Unix()),
+		)
+	}
 
-func (c *libsqlClient) CreateVehicleSnapshots(ctx context.Context, snapshots ...models.VehicleSnapshot) error {
-	// if len(snapshots) < 1 {
-	// 	return nil
-	// }
-
-	// var transactions []transaction.Transaction
-	// for _, data := range snapshots {
-	// 	encoded, err := data.Stats.Encode()
-	// 	if err != nil {
-	// 		log.Err(err).Str("accountId", data.AccountID).Str("vehicleId", data.VehicleID).Msg("failed to encode a stats frame for vehicle snapthsot")
-	// 		continue
-	// 	}
-
-	// 	transactions = append(transactions, c.prisma.models.VehicleSnapshot.
-	// 		CreateOne(
-	// 			db.models.VehicleSnapshot.CreatedAt.Set(data.CreatedAt),
-	// 			db.models.VehicleSnapshot.Type.Set(string(data.Type)),
-	// 			db.models.VehicleSnapshot.LastBattleTime.Set(data.LastBattleTime),
-	// 			db.models.VehicleSnapshot.AccountID.Set(data.AccountID),
-	// 			db.models.VehicleSnapshot.VehicleID.Set(data.VehicleID),
-	// 			db.models.VehicleSnapshot.ReferenceID.Set(data.ReferenceID),
-	// 			db.models.VehicleSnapshot.Battles.Set(int(data.Stats.Battles)),
-	// 			db.models.VehicleSnapshot.FrameEncoded.Set(encoded),
-	// 		).Tx(),
-	// 	)
-	// }
-
-	// return c.prisma.Prisma.Transaction(transactions...).Exec(ctx)
-	return nil
+	return c.db.VehicleSnapshot.CreateBulk(inserts...).Exec(ctx)
 }
 
 func (c *libsqlClient) GetVehicleSnapshots(ctx context.Context, accountID, referenceID string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.VehicleSnapshot, error) {
-	// var query getSnapshotQuery
-	// for _, apply := range options {
-	// 	apply(&query)
-	// }
-
-	// var models []db.models.VehicleSnapshotModel
-	// raw, args := query.vehiclesQuery(accountID, referenceID, kind)
-	// err := c.prisma.Prisma.Raw.QueryRaw(raw, args...).Exec(ctx, &models)
-	// if err != nil {
-	// 	return nil, err
-	// }
+	var query getSnapshotQuery
+	for _, apply := range options {
+		apply(&query)
+	}
 
+	var where []predicate.VehicleSnapshot
+	where = append(where, vehiclesnapshot.AccountID(accountID))
+	where = append(where, vehiclesnapshot.ReferenceID(referenceID))
+	where = append(where, vehiclesnapshot.TypeEQ(kind))
+
+	if query.createdAfter != nil {
+		where = append(where, vehiclesnapshot.CreatedAtGT(query.createdAfter.Unix()))
+	}
+	if query.createdAfter != nil {
+		where = append(where, vehiclesnapshot.CreatedAtLT(query.createdBefore.Unix()))
+	}
+	if query.vehicleIDs != nil {
+		where = append(where, vehiclesnapshot.VehicleIDIn(query.vehicleIDs...))
+	}
+
+	var records []*db.VehicleSnapshot
+	err := c.db.VehicleSnapshot.Query().Where(where...).GroupBy(vehiclesnapshot.FieldVehicleID).Scan(ctx, &records)
+	if err != nil && !IsNotFound(err) {
+		return nil, err
+	}
 	var snapshots []models.VehicleSnapshot
-	// for _, model := range models {
-	// 	vehicle, err := models.VehicleSnapshot{}.FromModel(model)
-	// 	if err != nil {
-	// 		return nil, err
-	// 	}
-	// 	snapshots = append(snapshots, vehicle)
-	// }
+	for _, r := range records {
+		snapshots = append(snapshots, toVehicleSnapshot(r))
+	}
 
 	return snapshots, nil
 }
 
-// func (s AccountSnapshot) FromModel(model *db.AccountSnapshotModel) (AccountSnapshot, error) {
-// 	s.ID = model.ID
-// 	s.Type = models.SnapshotType(model.Type)
-// 	s.CreatedAt = model.CreatedAt
-// 	s.AccountID = model.AccountID
-// 	s.ReferenceID = model.ReferenceID
-// 	s.LastBattleTime = model.LastBattleTime
-
-// 	rating, err := frame.DecodeStatsFrame(model.RatingFrameEncoded)
-// 	if err != nil {
-// 		return AccountSnapshot{}, err
-// 	}
-// 	s.RatingBattles = rating
-
-// 	regular, err := frame.DecodeStatsFrame(model.RegularFrameEncoded)
-// 	if err != nil {
-// 		return AccountSnapshot{}, err
-// 	}
-// 	s.RegularBattles = regular
-
-// 	return s, nil
-// }
+func toAccountSnapshot(record *db.AccountSnapshot) models.AccountSnapshot {
+	return models.AccountSnapshot{
+		ID:             record.ID,
+		Type:           record.Type,
+		AccountID:      record.AccountID,
+		ReferenceID:    record.ReferenceID,
+		RatingBattles:  record.RatingFrame,
+		RegularBattles: record.RegularFrame,
+		CreatedAt:      time.Unix(record.CreatedAt, 0),
+		LastBattleTime: time.Unix(record.LastBattleTime, 0),
+	}
+}
 
 func (c *libsqlClient) CreateAccountSnapshots(ctx context.Context, snapshots ...models.AccountSnapshot) error {
-	// if len(snapshots) < 1 {
-	// 	return nil
-	// }
-
-	// var transactions []transaction.Transaction
-	// for _, data := range snapshots {
-	// 	ratingEncoded, err := data.RatingBattles.Encode()
-	// 	if err != nil {
-	// 		log.Err(err).Str("accountId", data.AccountID).Msg("failed to encode rating stats frame for account snapthsot")
-	// 		continue
-	// 	}
-	// 	regularEncoded, err := data.RegularBattles.Encode()
-	// 	if err != nil {
-	// 		log.Err(err).Str("accountId", data.AccountID).Msg("failed to encode regular stats frame for account snapthsot")
-	// 		continue
-	// 	}
-
-	// 	transactions = append(transactions, c.prisma.AccountSnapshot.
-	// 		CreateOne(
-	// 			db.AccountSnapshot.CreatedAt.Set(data.CreatedAt),
-	// 			db.AccountSnapshot.Type.Set(string(data.Type)),
-	// 			db.AccountSnapshot.LastBattleTime.Set(data.LastBattleTime),
-	// 			db.AccountSnapshot.AccountID.Set(data.AccountID),
-	// 			db.AccountSnapshot.ReferenceID.Set(data.ReferenceID),
-	// 			db.AccountSnapshot.RatingBattles.Set(int(data.RatingBattles.Battles)),
-	// 			db.AccountSnapshot.RatingFrameEncoded.Set(ratingEncoded),
-	// 			db.AccountSnapshot.RegularBattles.Set(int(data.RegularBattles.Battles)),
-	// 			db.AccountSnapshot.RegularFrameEncoded.Set(regularEncoded),
-	// 		).Tx(),
-	// 	)
-	// }
-
-	// return c.prisma.Prisma.Transaction(transactions...).Exec(ctx)
-	return nil
+	if len(snapshots) < 1 {
+		return nil
+	}
+
+	var inserts []*db.AccountSnapshotCreate
+	for _, s := range snapshots {
+		inserts = append(inserts,
+			c.db.AccountSnapshot.Create().
+				SetAccountID(s.AccountID).
+				SetCreatedAt(s.CreatedAt.Unix()).
+				SetLastBattleTime(s.LastBattleTime.Unix()).
+				SetRatingBattles(int(s.RatingBattles.Battles.Float())).
+				SetRatingFrame(s.RatingBattles).
+				SetReferenceID(s.ReferenceID).
+				SetRegularBattles(int(s.RegularBattles.Battles)).
+				SetRegularFrame(s.RegularBattles).
+				SetType(s.Type),
+		)
+	}
+
+	return c.db.AccountSnapshot.CreateBulk(inserts...).Exec(ctx)
 }
 
 func (c *libsqlClient) GetLastAccountSnapshots(ctx context.Context, accountID string, limit int) ([]models.AccountSnapshot, error) {
-	// models, err := c.prisma.AccountSnapshot.FindMany(db.AccountSnapshot.AccountID.Equals(accountID)).OrderBy(db.AccountSnapshot.CreatedAt.Order(db.DESC)).Take(limit).Exec(ctx)
-	// if err != nil {
-	// 	return nil, err
-	// }
+	records, err := c.db.AccountSnapshot.Query().Where(accountsnapshot.AccountID(accountID)).Limit(limit).All(ctx)
+	if err != nil {
+		return nil, err
+	}
 
 	var snapshots []models.AccountSnapshot
-	// for _, model := range models {
-	// 	s, err := AccountSnapshot{}.FromModel(&model)
-	// 	if err != nil {
-	// 		return nil, err
-	// 	}
-	// 	snapshots = append(snapshots, s)
-	// }
+	for _, r := range records {
+		snapshots = append(snapshots, toAccountSnapshot(r))
+	}
+
 	return snapshots, nil
 }
 
 func (c *libsqlClient) GetAccountSnapshot(ctx context.Context, accountID, referenceID string, kind models.SnapshotType, options ...SnapshotQuery) (models.AccountSnapshot, error) {
-	// var query getSnapshotQuery
-	// for _, apply := range options {
-	// 	apply(&query)
-	// }
+	var query getSnapshotQuery
+	for _, apply := range options {
+		apply(&query)
+	}
 
-	// model, err := c.prisma.AccountSnapshot.FindFirst(query.accountParams(accountID, referenceID, kind)...).OrderBy(query.accountOrder()...).Exec(ctx)
-	// if err != nil {
-	// 	return AccountSnapshot{}, err
-	// }
+	var where []predicate.AccountSnapshot
+	where = append(where, accountsnapshot.AccountID(accountID), accountsnapshot.ReferenceID(referenceID), accountsnapshot.TypeEQ(kind))
+	if query.createdAfter != nil {
+		where = append(where, accountsnapshot.CreatedAtGT(query.createdAfter.Unix()))
+	}
+	if query.createdBefore != nil {
+		where = append(where, accountsnapshot.CreatedAtLT(query.createdAfter.Unix()))
+	}
 
-	return models.AccountSnapshot{}, nil
+	record, err := c.db.AccountSnapshot.Query().Where(where...).First(ctx)
+	if err != nil {
+		return models.AccountSnapshot{}, err
+	}
+
+	return toAccountSnapshot(record), nil
 }
 
 func (c *libsqlClient) GetManyAccountSnapshots(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.AccountSnapshot, error) {
-	// var query getSnapshotQuery
-	// for _, apply := range options {
-	// 	apply(&query)
-	// }
-
-	// var models []db.AccountSnapshotModel
-	// raw, args := query.manyAccountsQuery(accountIDs, kind)
-	// err := c.prisma.Prisma.Raw.QueryRaw(raw, args...).Exec(ctx, &models)
-	// if err != nil {
-	// 	return nil, err
-	// }
+	var query getSnapshotQuery
+	for _, apply := range options {
+		apply(&query)
+	}
+
+	var where []predicate.AccountSnapshot
+	where = append(where, accountsnapshot.AccountIDIn(accountIDs...), accountsnapshot.TypeEQ(kind))
+	if query.createdAfter != nil {
+		where = append(where, accountsnapshot.CreatedAtGT(query.createdAfter.Unix()))
+	}
+	if query.createdBefore != nil {
+		where = append(where, accountsnapshot.CreatedAtLT(query.createdAfter.Unix()))
+	}
+
+	records, err := c.db.AccountSnapshot.Query().Where(where...).All(ctx)
+	if err != nil {
+		return nil, err
+	}
 
 	var snapshots []models.AccountSnapshot
-	// for _, model := range models {
-	// 	snapshot, err := AccountSnapshot{}.FromModel(&model)
-	// 	if err != nil {
-	// 		return nil, err
-	// 	}
-	// 	snapshots = append(snapshots, snapshot)
-	// }
+	for _, r := range records {
+		snapshots = append(snapshots, toAccountSnapshot(r))
+	}
 
 	return snapshots, nil
 
diff --git a/internal/database/tasks.go b/internal/database/tasks.go
index 73f95eb3..57f3904b 100644
--- a/internal/database/tasks.go
+++ b/internal/database/tasks.go
@@ -4,43 +4,49 @@ import (
 	"context"
 	"time"
 
+	"entgo.io/ent/dialect/sql"
+	"github.com/cufee/aftermath/internal/database/ent/db"
+	"github.com/cufee/aftermath/internal/database/ent/db/crontask"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
 	"github.com/cufee/aftermath/internal/database/models"
 )
 
-// func (t Task) FromModel(model db.CronTaskModel) Task {
-// 	t.ID = model.ID
-// 	t.Type = TaskType(model.Type)
-
-// 	t.Status = TaskStatus(model.Status)
-// 	t.ReferenceID = model.ReferenceID
-
-// 	t.LastRun = model.LastRun
-// 	t.CreatedAt = model.CreatedAt
-// 	t.UpdatedAt = model.UpdatedAt
-// 	t.ScheduledAfter = model.ScheduledAfter
-
-// 	t.decodeData(model.DataEncoded)
-// 	t.decodeLogs(model.LogsEncoded)
-// 	t.decodeTargets(model.TargetsEncoded)
-// 	return t
-// }
+func toCronTask(record *db.CronTask) models.Task {
+	return models.Task{
+		ID:             record.ID,
+		Type:           record.Type,
+		CreatedAt:      time.Unix(record.CreatedAt, 0),
+		UpdatedAt:      time.Unix(record.UpdatedAt, 0),
+		ReferenceID:    record.ReferenceID,
+		Targets:        record.Targets,
+		Logs:           record.Logs,
+		Status:         record.Status,
+		ScheduledAfter: time.Unix(record.ScheduledAfter, 0),
+		LastRun:        time.Unix(record.LastRun, 0),
+		Data:           record.Data,
+	}
+}
 
 /*
 Returns up limit tasks that have TaskStatusInProgress and were last updates 1+ hours ago
 */
 func (c *libsqlClient) GetStaleTasks(ctx context.Context, limit int) ([]models.Task, error) {
-	// models, err := c.prisma.CronTask.FindMany(
-	// 	db.CronTask.Status.Equals(string(TaskStatusInProgress)),
-	// 	db.CronTask.LastRun.Before(time.Now().Add(time.Hour*-1)),
-	// ).OrderBy(db.CronTask.ScheduledAfter.Order(db.ASC)).Take(limit).Exec(ctx)
-	// if err != nil && !database.IsNotFound(err) {
-	// 	return nil, err
-	// }
+	records, err := c.db.CronTask.Query().
+		Where(
+			crontask.StatusEQ(models.TaskStatusInProgress),
+			crontask.LastRunLT(time.Now().Add(time.Hour*-1).Unix()),
+		).
+		Order(crontask.ByScheduledAfter(sql.OrderAsc())).
+		Limit(limit).
+		All(ctx)
+	if err != nil && !IsNotFound(err) {
+		return nil, err
+	}
 
 	var tasks []models.Task
-	// for _, model := range models {
-	// 	tasks = append(tasks, Task{}.FromModel(model))
-	// }
+	for _, r := range records {
+		tasks = append(tasks, toCronTask(r))
+	}
 
 	return tasks, nil
 }
@@ -49,104 +55,89 @@ func (c *libsqlClient) GetStaleTasks(ctx context.Context, limit int) ([]models.T
 Returns all tasks that were created after createdAfter, sorted by ScheduledAfter (DESC)
 */
 func (c *libsqlClient) GetRecentTasks(ctx context.Context, createdAfter time.Time, status ...models.TaskStatus) ([]models.Task, error) {
-	// var statusStr []string
-	// for _, s := range status {
-	// 	statusStr = append(statusStr, string(s))
-	// }
-
-	// params := []db.CronTaskWhereParam{db.CronTask.CreatedAt.After(createdAfter)}
-	// if len(statusStr) > 0 {
-	// 	params = append(params, db.CronTask.Status.In(statusStr))
-	// }
+	var where []predicate.CronTask
+	where = append(where, crontask.CreatedAtGT(createdAfter.Unix()))
+	if len(status) > 0 {
+		where = append(where, crontask.StatusIn(status...))
+	}
 
-	// models, err := c.prisma.CronTask.FindMany(params...).OrderBy(db.CronTask.ScheduledAfter.Order(db.DESC)).Exec(ctx)
-	// if err != nil && !database.IsNotFound(err) {
-	// 	return nil, err
-	// }
+	records, err := c.db.CronTask.Query().Where(where...).All(ctx)
+	if err != nil && !IsNotFound(err) {
+		return nil, err
+	}
 
 	var tasks []models.Task
-	// for _, model := range models {
-	// 	tasks = append(tasks, Task{}.FromModel(model))
-	// }
+	for _, r := range records {
+		tasks = append(tasks, toCronTask(r))
+	}
 
 	return tasks, nil
 }
 
 /*
 GetAndStartTasks retrieves up to limit number of tasks matching the referenceId and updates their status to in progress
-  - this func will block until all other calls to task update funcs are done
 */
 func (c *libsqlClient) GetAndStartTasks(ctx context.Context, limit int) ([]models.Task, error) {
-	// if limit < 1 {
-	// 	return nil, nil
-	// }
-	// if err := c.tasksUpdateSem.Acquire(ctx, 1); err != nil {
-	// 	return nil, err
-	// }
-	// defer c.tasksUpdateSem.Release(1)
-
-	// models, err := c.prisma.CronTask.
-	// 	FindMany(
-	// 		db.CronTask.Status.Equals(string(TaskStatusScheduled)),
-	// 		db.CronTask.ScheduledAfter.Lt(time.Now()),
-	// 	).
-	// 	OrderBy(db.CronTask.ScheduledAfter.Order(db.ASC)).
-	// 	Take(limit).
-	// 	Exec(ctx)
-	// if err != nil {
-	// 	if database.IsNotFound(err) {
-	// 		return nil, nil
-	// 	}
-	// 	return nil, err
-	// }
-	// if len(models) < 1 {
-	// 	return nil, nil
-	// }
-
-	// var ids []string
+	if limit < 1 {
+		return nil, nil
+	}
+
+	tx, err := c.db.Tx(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	records, err := tx.CronTask.Query().Where(crontask.StatusEQ(models.TaskStatusScheduled), crontask.ScheduledAfterLT(time.Now().Unix())).Order(crontask.ByScheduledAfter(sql.OrderAsc())).Limit(limit).All(ctx)
+	if err != nil {
+		if IsNotFound(err) {
+			return nil, nil
+		}
+		return nil, rollback(tx, err)
+	}
+
+	var ids []string
 	var tasks []models.Task
-	// for _, model := range models {
-	// 	tasks = append(tasks, Task{}.FromModel(model))
-	// 	ids = append(ids, model.ID)
-	// }
-
-	// _, err = c.prisma.CronTask.
-	// 	FindMany(db.CronTask.ID.In(ids)).
-	// 	Update(db.CronTask.Status.Set(string(TaskStatusInProgress)), db.CronTask.LastRun.Set(time.Now())).
-	// 	Exec(ctx)
-	// if err != nil {
-	// 	return nil, err
-	// }
+	for _, r := range records {
+		t := toCronTask(r)
+		t.OnUpdated()
 
-	return tasks, nil
+		t.Status = models.TaskStatusInProgress
+		tasks = append(tasks, t)
+		ids = append(ids, r.ID)
+	}
+
+	err = tx.CronTask.Update().Where(crontask.IDIn(ids...)).SetStatus(models.TaskStatusInProgress).Exec(ctx)
+	if err != nil && !IsNotFound(err) {
+		return nil, rollback(tx, err)
+	}
+
+	return tasks, tx.Commit()
 }
 
 func (c *libsqlClient) CreateTasks(ctx context.Context, tasks ...models.Task) error {
-	// if len(tasks) < 1 {
-	// 	return nil
-	// }
-	// // we do not block using c.tasksUpdateSem here because the order of ops in GetAndStartTasks makes this safe
-
-	// var txns []db.PrismaTransaction
-	// for _, task := range tasks {
-	// 	task.OnCreated()
-	// 	txns = append(txns, c.prisma.CronTask.CreateOne(
-	// 		db.CronTask.Type.Set(string(task.Type)),
-	// 		db.CronTask.ReferenceID.Set(task.ReferenceID),
-	// 		db.CronTask.TargetsEncoded.Set(task.encodeTargets()),
-	// 		db.CronTask.Status.Set(string(TaskStatusScheduled)),
-	// 		db.CronTask.LastRun.Set(time.Now()),
-	// 		db.CronTask.ScheduledAfter.Set(task.ScheduledAfter),
-	// 		db.CronTask.LogsEncoded.Set(task.encodeLogs()),
-	// 		db.CronTask.DataEncoded.Set(task.encodeData()),
-	// 	).Tx())
-	// }
-
-	// err := c.prisma.Prisma.Transaction(txns...).Exec(ctx)
-	// if err != nil {
-	// 	return err
-	// }
-	return nil
+	if len(tasks) < 1 {
+		return nil
+	}
+
+	var inserts []*db.CronTaskCreate
+	for _, t := range tasks {
+		t.OnCreated()
+		t.OnUpdated()
+
+		inserts = append(inserts,
+			c.db.CronTask.Create().
+				SetType(t.Type).
+				SetData(t.Data).
+				SetLogs(t.Logs).
+				SetStatus(t.Status).
+				SetTargets(t.Targets).
+				SetLastRun(t.LastRun.Unix()).
+				SetReferenceID(t.ReferenceID).
+				SetScheduledAfter(t.ScheduledAfter.Unix()),
+		)
+	}
+
+	return c.db.CronTask.CreateBulk(inserts...).Exec(ctx)
 }
 
 /*
@@ -155,35 +146,33 @@ UpdateTasks will update all tasks passed in
   - this func will block until all other calls to task update funcs are done
 */
 func (c *libsqlClient) UpdateTasks(ctx context.Context, tasks ...models.Task) error {
-	// if len(tasks) < 1 {
-	// 	return nil
-	// }
-
-	// if err := c.tasksUpdateSem.Acquire(ctx, 1); err != nil {
-	// 	return err
-	// }
-	// defer c.tasksUpdateSem.Release(1)
-
-	// var txns []db.PrismaTransaction
-	// for _, task := range tasks {
-	// 	task.OnUpdated()
-	// 	txns = append(txns, c.prisma.CronTask.
-	// 		FindUnique(db.CronTask.ID.Equals(task.ID)).
-	// 		Update(
-	// 			db.CronTask.TargetsEncoded.Set(task.encodeTargets()),
-	// 			db.CronTask.Status.Set(string(task.Status)),
-	// 			db.CronTask.LastRun.Set(task.LastRun),
-	// 			db.CronTask.ScheduledAfter.Set(task.ScheduledAfter),
-	// 			db.CronTask.LogsEncoded.Set(task.encodeLogs()),
-	// 			db.CronTask.DataEncoded.Set(task.encodeData()),
-	// 		).Tx())
-	// }
-
-	// err := c.prisma.Prisma.Transaction(txns...).Exec(ctx)
-	// if err != nil {
-	// 	return err
-	// }
-	return nil
+	if len(tasks) < 1 {
+		return nil
+	}
+
+	tx, err := c.db.Tx(ctx)
+	if err != nil {
+		return err
+	}
+
+	for _, t := range tasks {
+		t.OnUpdated()
+
+		err := tx.CronTask.UpdateOneID(t.ID).
+			SetData(t.Data).
+			SetLogs(t.Logs).
+			SetStatus(t.Status).
+			SetTargets(t.Targets).
+			SetLastRun(t.LastRun.Unix()).
+			SetScheduledAfter(t.ScheduledAfter.Unix()).
+			Exec(ctx)
+
+		if err != nil {
+			return rollback(tx, err)
+		}
+	}
+
+	return tx.Commit()
 }
 
 /*
@@ -191,18 +180,19 @@ DeleteTasks will delete all tasks matching by ids
   - this func will block until all other calls to task update funcs are done
 */
 func (c *libsqlClient) DeleteTasks(ctx context.Context, ids ...string) error {
-	// if len(ids) < 1 {
-	// 	return nil
-	// }
-
-	// if err := c.tasksUpdateSem.Acquire(ctx, 1); err != nil {
-	// 	return nil
-	// }
-	// defer c.tasksUpdateSem.Release(1)
-
-	// _, err := c.prisma.CronTask.FindMany(db.CronTask.ID.In(ids)).Delete().Exec(ctx)
-	// if err != nil {
-	// 	return err
-	// }
-	return nil
+	if len(ids) < 1 {
+		return nil
+	}
+
+	tx, err := c.db.Tx(ctx)
+	if err != nil {
+		return err
+	}
+
+	_, err = tx.CronTask.Delete().Where(crontask.IDIn(ids...)).Exec(ctx)
+	if err != nil {
+		return rollback(tx, err)
+	}
+
+	return tx.Commit()
 }
diff --git a/internal/database/users.go b/internal/database/users.go
index 83772c6b..7f63688b 100644
--- a/internal/database/users.go
+++ b/internal/database/users.go
@@ -2,23 +2,62 @@ package database
 
 import (
 	"context"
+	"time"
 
+	"github.com/cufee/aftermath/internal/database/ent/db"
+	"github.com/cufee/aftermath/internal/database/ent/db/user"
 	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/permissions"
 )
 
-// func (c UserConnection) FromModel(model *db.UserConnectionModel) UserConnection {
-// 	c.ID = model.ID
-// 	c.UserID = model.UserID
-// 	c.Metadata = make(map[string]any)
-// 	c.ReferenceID = model.ReferenceID
-// 	c.Permissions = permissions.Parse(model.Permissions, permissions.Blank)
+func toUser(record *db.User, connections []*db.UserConnection, subscriptions []*db.UserSubscription, content []*db.UserContent) models.User {
+	user := models.User{
+		ID:          record.ID,
+		Permissions: permissions.Parse(record.Permissions, permissions.Blank),
+	}
+	for _, c := range connections {
+		user.Connections = append(user.Connections, toUserConnection(c))
+	}
+	for _, s := range subscriptions {
+		user.Subscriptions = append(user.Subscriptions, toUserSubscription(s))
+	}
+	// for _, s := range content {
+	// 	user.Subscriptions = append(user.Subscriptions, toUserSubscription(s))
+	// }
+	return user
+}
+
+func toUserConnection(record *db.UserConnection) models.UserConnection {
+	return models.UserConnection{
+		ID:          record.ID,
+		Type:        record.Type,
+		UserID:      record.UserID,
+		ReferenceID: record.ReferenceID,
+		Permissions: permissions.Parse(record.Permissions, permissions.Blank),
+		Metadata:    record.Metadata,
+	}
+}
+
+func toUserSubscription(record *db.UserSubscription) models.UserSubscription {
+	return models.UserSubscription{
+		ID:          record.ID,
+		Type:        record.Type,
+		UserID:      record.UserID,
+		ReferenceID: record.ReferenceID,
+		ExpiresAt:   time.Unix(record.ExpiresAt, 0),
+		Permissions: permissions.Parse(record.Permissions, permissions.Blank),
+	}
+}
 
-// 	c.Type = ConnectionType(model.Type)
-// 	if model.MetadataEncoded != nil {
-// 		_ = encoding.DecodeGob(model.MetadataEncoded, &c.Metadata)
+// func toUserContent(record *db.UserSubscription) models.UserConnection {
+// 	return models.UserSubscription{
+// 		ID:          record.ID,
+// 		Type:        record.Type,
+// 		UserID:      record.UserID,
+// 		ReferenceID: record.ReferenceID,
+// 		ExpiresAt:   time.Unix(record.ExpiresAt, 0),
+// 		Permissions: permissions.Parse(record.Permissions, permissions.Blank),
 // 	}
-// 	return c
 // }
 
 type userGetOpts struct {
@@ -50,20 +89,20 @@ Gets or creates a user with specified ID
   - assumes the ID is valid
 */
 func (c *libsqlClient) GetOrCreateUserByID(ctx context.Context, id string, opts ...userGetOption) (models.User, error) {
-	// user, err := c.GetUserByID(ctx, id, opts...)
-	// if err != nil {
-	// 	if database.IsNotFound(err) {
-	// 		model, err := c.prisma.User.CreateOne(db.User.ID.Set(id), db.User.Permissions.Set(permissions.User.Encode())).Exec(ctx)
-	// 		if err != nil {
-	// 			return User{}, err
-	// 		}
-	// 		user.ID = model.ID
-	// 		user.Permissions = permissions.Parse(model.Permissions, permissions.User)
-	// 	}
-	// 	return user, nil
-	// }
+	user, err := c.GetUserByID(ctx, id, opts...)
+	if err != nil && !IsNotFound(err) {
+		return models.User{}, err
+	}
+
+	if IsNotFound(err) {
+		record, err := c.db.User.Create().SetID(id).SetPermissions(permissions.User.String()).Save(ctx)
+		if err != nil {
+			return models.User{}, err
+		}
+		user = toUser(record, nil, nil, nil)
+	}
 
-	return models.User{}, nil
+	return user, nil
 }
 
 /*
@@ -71,107 +110,85 @@ Gets a user with specified ID
   - assumes the ID is valid
 */
 func (c *libsqlClient) GetUserByID(ctx context.Context, id string, opts ...userGetOption) (models.User, error) {
-	// var options userGetOpts
-	// for _, apply := range opts {
-	// 	apply(&options)
-	// }
-
-	// var fields []db.UserRelationWith
-	// if options.subscriptions {
-	// 	fields = append(fields, db.User.Subscriptions.Fetch())
-	// }
-	// if options.connections {
-	// 	fields = append(fields, db.User.Connections.Fetch())
-	// }
-	// if options.content {
-	// 	fields = append(fields, db.User.Content.Fetch())
-	// }
-
-	// model, err := c.prisma.User.FindUnique(db.User.ID.Equals(id)).With(fields...).Exec(ctx)
-	// if err != nil {
-	// 	return User{}, err
-	// }
+	var options userGetOpts
+	for _, apply := range opts {
+		apply(&options)
+	}
 
-	var user models.User
-	// user.ID = model.ID
-	// user.Permissions = permissions.Parse(model.Permissions, permissions.User)
+	query := c.db.User.Query().Where(user.ID(id))
+	if options.subscriptions {
+		query = query.WithSubscriptions()
+	}
+	if options.connections {
+		query = query.WithConnections()
+	}
+	if options.content {
+		query.WithContent()
+	}
 
-	// if options.connections {
-	// 	for _, cModel := range model.Connections() {
-	// 		user.Connections = append(user.Connections, UserConnection{}.FromModel(&cModel))
-	// 	}
-	// }
+	record, err := query.Only(ctx)
+	if err != nil {
+		return models.User{}, err
+	}
 
-	return user, nil
+	return toUser(record, record.Edges.Connections, record.Edges.Subscriptions, record.Edges.Content), nil
 }
 
 func (c *libsqlClient) UpsertUserWithPermissions(ctx context.Context, userID string, perms permissions.Permissions) (models.User, error) {
-	// model, err := c.prisma.User.UpsertOne(db.User.ID.Equals(userID)).
-	// 	Create(db.User.ID.Set(userID), db.User.Permissions.Set(perms.String())).
-	// 	Update(db.User.Permissions.Set(perms.String())).Exec(ctx)
-	// if err != nil {
-	// 	return User{}, err
-	// }
-
-	var user models.User
-	// user.ID = model.ID
-	// user.Permissions = permissions.Parse(model.Permissions, permissions.User)
-	return user, nil
-}
+	record, err := c.db.User.UpdateOneID(userID).SetPermissions(perms.String()).Save(ctx)
+	if err != nil && !IsNotFound(err) {
+		return models.User{}, err
+	}
 
-func (c *libsqlClient) UpdateConnection(ctx context.Context, connection models.UserConnection) (models.UserConnection, error) {
-	// if connection.ReferenceID == "" {
-	// 	return UserConnection{}, errors.New("connection referenceID cannot be left blank")
-	// }
+	if IsNotFound(err) {
+		record, err = c.db.User.Create().SetID(userID).SetPermissions(perms.String()).Save(ctx)
+		if err != nil {
+			return models.User{}, err
+		}
+	}
 
-	// encoded, err := encoding.EncodeGob(connection.Metadata)
-	// if err != nil {
-	// 	return UserConnection{}, fmt.Errorf("failed to encode metadata: %w", err)
-	// }
+	return toUser(record, nil, nil, nil), nil
+}
 
-	// model, err := c.prisma.UserConnection.FindUnique(db.UserConnection.ID.Equals(connection.ID)).Update(
-	// 	db.UserConnection.ReferenceID.Set(connection.ReferenceID),
-	// 	db.UserConnection.Permissions.Set(connection.Permissions.Encode()),
-	// 	db.UserConnection.MetadataEncoded.Set(encoded),
-	// ).Exec(ctx)
-	// if err != nil {
-	// 	return UserConnection{}, err
-	// }
+func (c *libsqlClient) CreateConnection(ctx context.Context, connection models.UserConnection) (models.UserConnection, error) {
+	record, err := c.db.UserConnection.Create().
+		SetUserID(connection.UserID).
+		SetMetadata(connection.Metadata).
+		SetPermissions(connection.Permissions.String()).
+		SetReferenceID(connection.ReferenceID).
+		SetType(connection.Type).
+		Save(ctx)
+	if err != nil {
+		return models.UserConnection{}, err
+	}
+	return toUserConnection(record), err
+}
 
-	// return connection.FromModel(model), nil
-	return models.UserConnection{}, nil
+func (c *libsqlClient) UpdateConnection(ctx context.Context, connection models.UserConnection) (models.UserConnection, error) {
+	record, err := c.db.UserConnection.UpdateOneID(connection.ID).
+		SetMetadata(connection.Metadata).
+		SetPermissions(connection.Permissions.String()).
+		SetReferenceID(connection.ReferenceID).
+		SetType(connection.Type).
+		Save(ctx)
+	if err != nil {
+		return models.UserConnection{}, err
+	}
+	return toUserConnection(record), err
 }
 
 func (c *libsqlClient) UpsertConnection(ctx context.Context, connection models.UserConnection) (models.UserConnection, error) {
-	// if connection.ID != "" {
-	// 	return c.UpdateConnection(ctx, connection)
-	// }
-	// if connection.UserID == "" {
-	// 	return UserConnection{}, errors.New("connection userID cannot be left blank")
-	// }
-	// if connection.ReferenceID == "" {
-	// 	return UserConnection{}, errors.New("connection referenceID cannot be left blank")
-	// }
-	// if connection.Type == "" {
-	// 	return UserConnection{}, errors.New("connection Type cannot be left blank")
-	// }
-
-	// encoded, err := encoding.EncodeGob(connection.Metadata)
-	// if err != nil {
-	// 	return UserConnection{}, fmt.Errorf("failed to encode metadata: %w", err)
-	// }
+	if connection.ID == "" {
+		return c.CreateConnection(ctx, connection)
+	}
 
-	// model, err := c.prisma.UserConnection.CreateOne(
-	// 	db.UserConnection.User.Link(db.User.ID.Equals(connection.UserID)),
-	// 	db.UserConnection.Type.Set(string(connection.Type)),
-	// 	db.UserConnection.Permissions.Set(connection.Permissions.Encode()),
-	// 	db.UserConnection.ReferenceID.Set(connection.ReferenceID),
-	// 	db.UserConnection.MetadataEncoded.Set(encoded),
-	// ).Exec(ctx)
-	// if err != nil {
-	// 	return UserConnection{}, err
-	// }
+	connection, err := c.UpdateConnection(ctx, connection)
+	if err != nil && !IsNotFound(err) {
+		return models.UserConnection{}, err
+	}
+	if IsNotFound(err) {
+		return c.CreateConnection(ctx, connection)
+	}
 
-	// return connection.FromModel(model), nil
-	return models.UserConnection{}, nil
+	return connection, nil
 }
diff --git a/internal/database/vehicles.go b/internal/database/vehicles.go
index e5cc80df..bdf141dd 100644
--- a/internal/database/vehicles.go
+++ b/internal/database/vehicles.go
@@ -3,74 +3,88 @@ package database
 import (
 	"context"
 
+	"github.com/cufee/aftermath/internal/database/ent/db"
+	"github.com/cufee/aftermath/internal/database/ent/db/vehicle"
 	"github.com/cufee/aftermath/internal/database/models"
 )
 
-// func (v Vehicle) FromModel(model db.VehicleModel) Vehicle {
-// 	v.ID = model.ID
-// 	v.Tier = model.Tier
-// 	v.Type = model.Type
-// 	v.Nation = model.Nation
-// 	v.LocalizedNames = make(map[string]string)
-// 	if model.LocalizedNamesEncoded != nil {
-// 		err := encoding.DecodeGob(model.LocalizedNamesEncoded, &v.LocalizedNames)
-// 		if err != nil {
-// 			log.Err(err).Str("id", v.ID).Msg("failed to decode vehicle localized names")
-// 		}
-// 	}
-// 	return v
-// }
-
-// func (v Vehicle) EncodeNames() []byte {
-// 	encoded, _ := encoding.EncodeGob(v.LocalizedNames)
-// 	return encoded
-// }
+func toVehicle(record *db.Vehicle) models.Vehicle {
+	return models.Vehicle{
+		ID:             record.ID,
+		Tier:           record.Tier,
+		LocalizedNames: record.LocalizedNames,
+	}
+}
 
 func (c *libsqlClient) UpsertVehicles(ctx context.Context, vehicles map[string]models.Vehicle) error {
-	// if len(vehicles) < 1 {
-	// 	return nil
-	// }
-
-	// var transactions []transaction.Transaction
-	// for id, data := range vehicles {
-	// 	transactions = append(transactions, c.prisma.Vehicle.
-	// 		UpsertOne(db.Vehicle.ID.Equals(id)).
-	// 		Create(
-	// 			db.Vehicle.ID.Set(id),
-	// 			db.Vehicle.Tier.Set(data.Tier),
-	// 			db.Vehicle.Type.Set(data.Type),
-	// 			db.Vehicle.Class.Set(data.Class),
-	// 			db.Vehicle.Nation.Set(data.Nation),
-	// 			db.Vehicle.LocalizedNamesEncoded.Set(data.EncodeNames()),
-	// 		).
-	// 		Update(
-	// 			db.Vehicle.Tier.Set(data.Tier),
-	// 			db.Vehicle.Type.Set(data.Type),
-	// 			db.Vehicle.Class.Set(data.Class),
-	// 			db.Vehicle.Nation.Set(data.Nation),
-	// 			db.Vehicle.LocalizedNamesEncoded.Set(data.EncodeNames()),
-	// 		).Tx(),
-	// 	)
-	// }
-
-	// return c.prisma.Prisma.Transaction(transactions...).Exec(ctx)
-	return nil
+	if len(vehicles) < 1 {
+		return nil
+	}
+
+	var ids []string
+	for id := range vehicles {
+		ids = append(ids, id)
+	}
+
+	tx, err := c.db.Tx(ctx)
+	if err != nil {
+		return err
+	}
+
+	records, err := tx.Vehicle.Query().Where(vehicle.IDIn(ids...)).All(ctx)
+	if err != nil {
+		return rollback(tx, err)
+	}
+
+	for _, r := range records {
+		v, ok := vehicles[r.ID]
+		if !ok {
+			continue
+		}
+
+		err := tx.Vehicle.UpdateOneID(v.ID).
+			SetTier(v.Tier).
+			SetLocalizedNames(v.LocalizedNames).
+			Exec(ctx)
+		if err != nil {
+			return rollback(tx, err)
+		}
+
+		delete(vehicles, v.ID)
+	}
+
+	var inserts []*db.VehicleCreate
+	for id, v := range vehicles {
+		inserts = append(inserts,
+			c.db.Vehicle.Create().
+				SetID(id).
+				SetTier(v.Tier).
+				SetLocalizedNames(v.LocalizedNames),
+		)
+	}
+
+	err = tx.Vehicle.CreateBulk(inserts...).Exec(ctx)
+	if err != nil {
+		return rollback(tx, err)
+	}
+
+	return tx.Commit()
 }
 
 func (c *libsqlClient) GetVehicles(ctx context.Context, ids []string) (map[string]models.Vehicle, error) {
-	// 	if len(ids) < 1 {
-	// 		return nil, nil
-	// 	}
+	if len(ids) < 1 {
+		return nil, nil
+	}
 
-	// 	models, err := c.prisma.Vehicle.FindMany(db.Vehicle.ID.In(ids)).Exec(ctx)
-	// 	if err != nil {
-	// 		return nil, err
-	// 	}
+	records, err := c.db.Vehicle.Query().Where(vehicle.IDIn(ids...)).All(ctx)
+	if err != nil && !IsNotFound(err) {
+		return nil, err
+	}
 
 	vehicles := make(map[string]models.Vehicle)
-	// 	for _, model := range models {
-	// 		vehicles[model.ID] = vehicles[model.ID].FromModel(model)
-	// 	}
+	for _, r := range records {
+		vehicles[r.ID] = toVehicle(r)
+	}
 
 	return vehicles, nil
 }
diff --git a/internal/stats/fetch/multisource.go b/internal/stats/fetch/multisource.go
index 752715e3..b836a158 100644
--- a/internal/stats/fetch/multisource.go
+++ b/internal/stats/fetch/multisource.go
@@ -89,8 +89,8 @@ func (c *multiSourceClient) Account(ctx context.Context, id string) (models.Acco
 		ctx, cancel := context.WithTimeout(context.Background(), time.Second)
 		defer cancel()
 
-		errMap := c.database.UpsertAccounts(ctx, []models.Account{account})
-		if err := errMap[id]; err != nil {
+		err := c.database.UpsertAccounts(ctx, []models.Account{account})
+		if err != nil {
 			log.Err(err).Msg("failed to update account cache")
 		}
 	}()
@@ -172,8 +172,8 @@ func (c *multiSourceClient) CurrentStats(ctx context.Context, id string, opts ..
 		ctx, cancel := context.WithTimeout(context.Background(), time.Second)
 		defer cancel()
 
-		errMap := c.database.UpsertAccounts(ctx, []models.Account{stats.Account})
-		if err := errMap[id]; err != nil {
+		err := c.database.UpsertAccounts(ctx, []models.Account{stats.Account})
+		if err != nil {
 			log.Err(err).Msg("failed to update account cache")
 		}
 	}()

From c21b121ccd7fa37b81c3526beb128df5a87eb485 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sat, 22 Jun 2024 21:57:12 -0400
Subject: [PATCH 092/341] fixed incorrect edges

---
 .env.example                   | 2 +-
 docker-compose.yaml            | 5 ++++-
 internal/database/accounts.go  | 4 +---
 internal/database/snapshots.go | 8 ++++----
 internal/database/users.go     | 4 ++--
 5 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/.env.example b/.env.example
index d205038b..cb24daea 100644
--- a/.env.example
+++ b/.env.example
@@ -9,7 +9,7 @@ TRAEFIK_HOST="local.amth.one"
 DATABASE_DIR="tmp/"
 # URL to a libsql instance
 # https://github.com/tursodatabase/libsql/blob/main/docs/DOCKER.md
-DATABASE_URL="libsql://0.0.0.0:8080"
+DATABASE_URL="libsql://0.0.0.0:8080?tls=0"
 
 # Init
 INIT_GLOBAL_ADMIN_USER="" # Discord user ID for a user who will be assigned permissions.GlobalAdmin on startup, can be left blank
diff --git a/docker-compose.yaml b/docker-compose.yaml
index 57f25438..516f579f 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -30,7 +30,7 @@ services:
       - .env
     environment:
       - PORT=3000
-      - DATABASE_URL=libsql://aftermath-database:8080
+      - DATABASE_URL=libsql://aftermath-database:8080?tls=0
     depends_on:
       aftermath-database:
         condition: service_started
@@ -57,3 +57,6 @@ services:
 networks:
   dokploy-network:
     external: true
+
+volumes:
+  step-ca-home:
diff --git a/internal/database/accounts.go b/internal/database/accounts.go
index ef7be030..b6fed2cd 100644
--- a/internal/database/accounts.go
+++ b/internal/database/accounts.go
@@ -99,7 +99,6 @@ func (c *libsqlClient) UpsertAccounts(ctx context.Context, accounts []models.Acc
 			SetNickname(update.Nickname).
 			SetPrivate(update.Private).
 			SetLastBattleTime(update.LastBattleTime.Unix()).
-			SetClanID(update.ClanID).
 			Exec(ctx)
 		if err != nil {
 			return rollback(tx, err)
@@ -117,8 +116,7 @@ func (c *libsqlClient) UpsertAccounts(ctx context.Context, accounts []models.Acc
 				SetNickname(a.Nickname).
 				SetPrivate(a.Private).
 				SetAccountCreatedAt(a.CreatedAt.Unix()).
-				SetLastBattleTime(a.LastBattleTime.Unix()).
-				SetClanID(a.ClanID),
+				SetLastBattleTime(a.LastBattleTime.Unix()),
 		)
 	}
 
diff --git a/internal/database/snapshots.go b/internal/database/snapshots.go
index 10636ec6..6657cd5e 100644
--- a/internal/database/snapshots.go
+++ b/internal/database/snapshots.go
@@ -60,11 +60,11 @@ func (c *libsqlClient) CreateVehicleSnapshots(ctx context.Context, snapshots ...
 			c.db.VehicleSnapshot.Create().
 				SetType(data.Type).
 				SetFrame(data.Stats).
-				SetAccountID(data.AccountID).
 				SetVehicleID(data.VehicleID).
 				SetReferenceID(data.ReferenceID).
 				SetBattles(int(data.Stats.Battles.Float())).
-				SetLastBattleTime(data.LastBattleTime.Unix()),
+				SetLastBattleTime(data.LastBattleTime.Unix()).
+				SetAccount(c.db.Account.GetX(ctx, data.AccountID)),
 		)
 	}
 
@@ -127,7 +127,7 @@ func (c *libsqlClient) CreateAccountSnapshots(ctx context.Context, snapshots ...
 	for _, s := range snapshots {
 		inserts = append(inserts,
 			c.db.AccountSnapshot.Create().
-				SetAccountID(s.AccountID).
+				SetAccount(c.db.Account.GetX(ctx, s.AccountID)). // we assume the account exists here
 				SetCreatedAt(s.CreatedAt.Unix()).
 				SetLastBattleTime(s.LastBattleTime.Unix()).
 				SetRatingBattles(int(s.RatingBattles.Battles.Float())).
@@ -168,7 +168,7 @@ func (c *libsqlClient) GetAccountSnapshot(ctx context.Context, accountID, refere
 		where = append(where, accountsnapshot.CreatedAtGT(query.createdAfter.Unix()))
 	}
 	if query.createdBefore != nil {
-		where = append(where, accountsnapshot.CreatedAtLT(query.createdAfter.Unix()))
+		where = append(where, accountsnapshot.CreatedAtLT(query.createdBefore.Unix()))
 	}
 
 	record, err := c.db.AccountSnapshot.Query().Where(where...).First(ctx)
diff --git a/internal/database/users.go b/internal/database/users.go
index 7f63688b..79563d63 100644
--- a/internal/database/users.go
+++ b/internal/database/users.go
@@ -152,10 +152,10 @@ func (c *libsqlClient) UpsertUserWithPermissions(ctx context.Context, userID str
 
 func (c *libsqlClient) CreateConnection(ctx context.Context, connection models.UserConnection) (models.UserConnection, error) {
 	record, err := c.db.UserConnection.Create().
-		SetUserID(connection.UserID).
-		SetMetadata(connection.Metadata).
+		SetUser(c.db.User.GetX(ctx, connection.UserID)).
 		SetPermissions(connection.Permissions.String()).
 		SetReferenceID(connection.ReferenceID).
+		SetMetadata(connection.Metadata).
 		SetType(connection.Type).
 		Save(ctx)
 	if err != nil {

From caf73ed209bce1bbfedd6fe9aefd78aed0e8a770 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sat, 22 Jun 2024 22:10:19 -0400
Subject: [PATCH 093/341] fixed command and entrypoint

---
 Dockerfile.migrate  | 2 +-
 docker-compose.yaml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Dockerfile.migrate b/Dockerfile.migrate
index 16909e31..35c14771 100644
--- a/Dockerfile.migrate
+++ b/Dockerfile.migrate
@@ -11,4 +11,4 @@ RUN go mod download
 RUN go generate ./...
 RUN CGO_ENABLED=1 GOOS=linux go build -o /bin/atlas
 
-ENTRYPOINT ["sh", "-c", 'atlas migrate apply --allow-dirty --dir "file:///migrations" --tx-mode all --url "libsql+ws://0.0.0.0:8080']
+ENTRYPOINT ["atlas", "migrate", "apply","--allow-dirty" ,"--dir" "file:///migrations", ,"--tx-mode" ,"all", "--url", "libsql+ws://0.0.0.0:8080"]
diff --git a/docker-compose.yaml b/docker-compose.yaml
index 516f579f..d0af6e91 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -18,7 +18,7 @@ services:
     depends_on:
       aftermath-database:
         condition: service_started
-    command: sh -c 'migrate apply --allow-dirty --dir "file:///migrations" --tx-mode all --url "libsql+ws://aftermath-database:8080"'
+    command: atlas migrate apply --allow-dirty --dir "file:///migrations" --tx-mode all --url "libsql+ws://aftermath-database:8080"
     networks:
       - dokploy-network
 

From 59a6b3d27298848291893111c4c287038599086c Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sat, 22 Jun 2024 22:12:46 -0400
Subject: [PATCH 094/341] added absolute path

---
 Dockerfile.migrate  | 2 +-
 docker-compose.yaml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Dockerfile.migrate b/Dockerfile.migrate
index 35c14771..9dd12738 100644
--- a/Dockerfile.migrate
+++ b/Dockerfile.migrate
@@ -11,4 +11,4 @@ RUN go mod download
 RUN go generate ./...
 RUN CGO_ENABLED=1 GOOS=linux go build -o /bin/atlas
 
-ENTRYPOINT ["atlas", "migrate", "apply","--allow-dirty" ,"--dir" "file:///migrations", ,"--tx-mode" ,"all", "--url", "libsql+ws://0.0.0.0:8080"]
+ENTRYPOINT ["/bin/atlas", "migrate", "apply","--allow-dirty" ,"--dir" "file:///migrations", ,"--tx-mode" ,"all", "--url", "libsql+ws://0.0.0.0:8080"]
diff --git a/docker-compose.yaml b/docker-compose.yaml
index d0af6e91..fc89055c 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -18,7 +18,7 @@ services:
     depends_on:
       aftermath-database:
         condition: service_started
-    command: atlas migrate apply --allow-dirty --dir "file:///migrations" --tx-mode all --url "libsql+ws://aftermath-database:8080"
+    command: /bin/atlas migrate apply --allow-dirty --dir "file:///migrations" --tx-mode all --url "libsql+ws://aftermath-database:8080"
     networks:
       - dokploy-network
 

From 9e232c91fd16029ca4807d85b96659102bc43d02 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sat, 22 Jun 2024 22:13:42 -0400
Subject: [PATCH 095/341] downloading mod cache

---
 Dockerfile | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Dockerfile b/Dockerfile
index ddcfd59f..0730ea53 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -7,7 +7,8 @@ COPY go.mod go.sum ./
 RUN go mod download
 
 COPY ./ ./
-# generate the Prisma Client Go client
+
+RUN go mod download
 RUN go generate ./...
 
 # build a fully standalone binary with zero dependencies

From 4a698d061bec4750adde232d493eff79cc934893 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sat, 22 Jun 2024 22:18:19 -0400
Subject: [PATCH 096/341] changed back to entrypoint

---
 Dockerfile.migrate  | 4 +++-
 docker-compose.yaml | 2 +-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/Dockerfile.migrate b/Dockerfile.migrate
index 9dd12738..77fb6709 100644
--- a/Dockerfile.migrate
+++ b/Dockerfile.migrate
@@ -6,9 +6,11 @@ WORKDIR /migrate
 COPY ./internal/database/ent/migrate/migrations /migrations
 
 RUN git clone https://github.com/Cufee/atlas-libsql.git
+
 WORKDIR /migrate/atlas-libsql/cmd/atlas
+
 RUN go mod download
 RUN go generate ./...
 RUN CGO_ENABLED=1 GOOS=linux go build -o /bin/atlas
 
-ENTRYPOINT ["/bin/atlas", "migrate", "apply","--allow-dirty" ,"--dir" "file:///migrations", ,"--tx-mode" ,"all", "--url", "libsql+ws://0.0.0.0:8080"]
+ENTRYPOINT ["atlas", "migrate", "apply","--allow-dirty" ,"--dir" "file:///migrations", ,"--tx-mode" ,"all", "--url", "libsql+ws://0.0.0.0:8080"]
diff --git a/docker-compose.yaml b/docker-compose.yaml
index fc89055c..2b35ff2f 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -18,7 +18,7 @@ services:
     depends_on:
       aftermath-database:
         condition: service_started
-    command: /bin/atlas migrate apply --allow-dirty --dir "file:///migrations" --tx-mode all --url "libsql+ws://aftermath-database:8080"
+    entrypoint: /bin/atlas migrate apply --allow-dirty --dir "file:///migrations" --tx-mode all --url "libsql+ws://aftermath-database:8080"
     networks:
       - dokploy-network
 

From 6c7b065590fd25a15c0eff8d65229df251b2e484 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sat, 22 Jun 2024 22:18:35 -0400
Subject: [PATCH 097/341] removed abs path

---
 docker-compose.yaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docker-compose.yaml b/docker-compose.yaml
index 2b35ff2f..1ecda3df 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -18,7 +18,7 @@ services:
     depends_on:
       aftermath-database:
         condition: service_started
-    entrypoint: /bin/atlas migrate apply --allow-dirty --dir "file:///migrations" --tx-mode all --url "libsql+ws://aftermath-database:8080"
+    entrypoint: atlas migrate apply --allow-dirty --dir "file:///migrations" --tx-mode all --url "libsql+ws://aftermath-database:8080"
     networks:
       - dokploy-network
 

From 3133f12c255b7fedb7ec58734144414ff937c3f1 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sat, 22 Jun 2024 22:52:20 -0400
Subject: [PATCH 098/341] removed unused volume

---
 Dockerfile          | 4 ----
 docker-compose.yaml | 3 ---
 2 files changed, 7 deletions(-)

diff --git a/Dockerfile b/Dockerfile
index 0730ea53..f4d80704 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -2,10 +2,6 @@ FROM golang:1.22.3-alpine as builder
 
 WORKDIR /workspace
 
-# add go modules lockfiles
-COPY go.mod go.sum ./
-RUN go mod download
-
 COPY ./ ./
 
 RUN go mod download
diff --git a/docker-compose.yaml b/docker-compose.yaml
index 1ecda3df..a9c0161b 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -57,6 +57,3 @@ services:
 networks:
   dokploy-network:
     external: true
-
-volumes:
-  step-ca-home:

From 0d82859089d1dfe02424c2232b7a92bf1d4c116c Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sat, 22 Jun 2024 22:54:17 -0400
Subject: [PATCH 099/341] added user to database

---
 docker-compose.yaml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/docker-compose.yaml b/docker-compose.yaml
index a9c0161b..c2fbd072 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -1,5 +1,6 @@
 services:
   aftermath-database:
+    user: root
     image: ghcr.io/tursodatabase/libsql-server:latest
     platform: linux/amd64
     restart: always

From c6603d55c581510ac2cf2b37342d84bcf41a86bc Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 08:54:52 -0400
Subject: [PATCH 100/341] setting task status on create

---
 internal/database/models/task.go | 46 +++++++-------------------------
 1 file changed, 10 insertions(+), 36 deletions(-)

diff --git a/internal/database/models/task.go b/internal/database/models/task.go
index bb1ad319..b81c8f5a 100644
--- a/internal/database/models/task.go
+++ b/internal/database/models/task.go
@@ -1,11 +1,7 @@
 package models
 
 import (
-	"encoding/json"
-	"strings"
 	"time"
-
-	"github.com/cufee/aftermath/internal/encoding"
 )
 
 type TaskType string
@@ -82,44 +78,22 @@ func (t *Task) LogAttempt(log TaskLog) {
 }
 
 func (t *Task) OnCreated() {
+	t.Status = TaskStatusScheduled
 	t.LastRun = time.Now()
 	t.CreatedAt = time.Now()
 	t.UpdatedAt = time.Now()
+	t.Logs = append(t.Logs, TaskLog{
+		Comment:   "task created",
+		Timestamp: time.Now(),
+	})
 }
 func (t *Task) OnUpdated() {
+	t.LastRun = time.Now()
 	t.UpdatedAt = time.Now()
-}
-
-func (t *Task) encodeTargets() []byte {
-	return []byte(strings.Join(t.Targets, ";"))
-}
-func (t *Task) decodeTargets(targets []byte) {
-	if string(targets) != "" {
-		t.Targets = strings.Split(string(targets), ";")
-	}
-}
-
-func (t *Task) encodeLogs() []byte {
-	if t.Logs == nil {
-		return []byte{}
-	}
-	data, _ := json.Marshal(t.Logs)
-	return data
-}
-func (t *Task) decodeLogs(logs []byte) {
-	_ = json.Unmarshal(logs, &t.Logs)
-}
-
-func (t *Task) encodeData() []byte {
-	if t.Data == nil {
-		return []byte{}
-	}
-	data, _ := encoding.EncodeGob(t.Data)
-	return data
-}
-func (t *Task) decodeData(data []byte) {
-	t.Data = make(map[string]any)
-	_ = encoding.DecodeGob(data, &t.Data)
+	t.Logs = append(t.Logs, TaskLog{
+		Comment:   "task updated",
+		Timestamp: time.Now(),
+	})
 }
 
 type TaskLog struct {

From 4348037a5a14a11bac5e4ee33f00c8d82ba8bc3c Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 09:24:06 -0400
Subject: [PATCH 101/341] error handling fixes, minor refactor, snapshots
 endpoint

---
 cmds/core/scheduler/tasks/sessions.go         | 17 +++++++---
 cmds/core/scheduler/workers.go                |  2 +-
 .../core/server/handlers/private/snapshots.go | 34 +++++++++++++++++++
 internal/database/accounts.go                 | 15 +++-----
 internal/database/averages.go                 |  2 +-
 internal/database/cleanup.go                  |  8 ++---
 internal/database/discord.go                  |  2 +-
 internal/database/ent/db/crontask/crontask.go |  2 +-
 internal/database/ent/db/migrate/schema.go    |  2 +-
 internal/database/models/task.go              | 14 ++++----
 internal/database/snapshots.go                |  2 +-
 internal/database/tasks.go                    |  9 ++---
 internal/database/vehicles.go                 |  4 +--
 main.go                                       | 14 +++++---
 14 files changed, 83 insertions(+), 44 deletions(-)
 create mode 100644 cmds/core/server/handlers/private/snapshots.go

diff --git a/cmds/core/scheduler/tasks/sessions.go b/cmds/core/scheduler/tasks/sessions.go
index 93ea0273..b4d6803b 100644
--- a/cmds/core/scheduler/tasks/sessions.go
+++ b/cmds/core/scheduler/tasks/sessions.go
@@ -14,7 +14,7 @@ import (
 )
 
 func init() {
-	defaultHandlers[models.TaskTypeRecordSessions] = TaskHandler{
+	defaultHandlers[models.TaskTypeRecordSnapshots] = TaskHandler{
 		Process: func(client core.Client, task models.Task) (string, error) {
 			if task.Data == nil {
 				return "no data provided", errors.New("no data provided")
@@ -72,10 +72,10 @@ func init() {
 	}
 }
 
-func CreateSessionUpdateTasks(client core.Client, realm string) error {
+func CreateRecordSnapshotsTasks(client core.Client, realm string) error {
 	realm = strings.ToUpper(realm)
 	task := models.Task{
-		Type:           models.TaskTypeRecordSessions,
+		Type:           models.TaskTypeRecordSnapshots,
 		ReferenceID:    "realm_" + realm,
 		ScheduledAfter: time.Now(),
 		Data: map[string]any{
@@ -92,10 +92,17 @@ func CreateSessionUpdateTasks(client core.Client, realm string) error {
 		return err
 	}
 	if len(accounts) < 1 {
-		return nil
+		return errors.New("no accounts on realm " + realm)
 	}
 	task.Targets = append(task.Targets, accounts...)
 
 	// This update requires (2 + n) requests per n players
-	return client.Database().CreateTasks(ctx, splitTaskByTargets(task, 90)...)
+	tasks := splitTaskByTargets(task, 90)
+	err = client.Database().CreateTasks(ctx, tasks...)
+	if err != nil {
+		return err
+	}
+
+	log.Debug().Int("count", len(tasks)).Msg("scheduled realm account snapshots tasks")
+	return nil
 }
diff --git a/cmds/core/scheduler/workers.go b/cmds/core/scheduler/workers.go
index 683027be..fed10db4 100644
--- a/cmds/core/scheduler/workers.go
+++ b/cmds/core/scheduler/workers.go
@@ -37,7 +37,7 @@ func RotateBackgroundPresetsWorker(client core.Client) func() {
 
 func CreateSessionTasksWorker(client core.Client, realm string) func() {
 	return func() {
-		err := tasks.CreateSessionUpdateTasks(client, realm)
+		err := tasks.CreateRecordSnapshotsTasks(client, realm)
 		if err != nil {
 			log.Err(err).Str("realm", realm).Msg("failed to schedule session update tasks")
 		}
diff --git a/cmds/core/server/handlers/private/snapshots.go b/cmds/core/server/handlers/private/snapshots.go
new file mode 100644
index 00000000..a90a1ec8
--- /dev/null
+++ b/cmds/core/server/handlers/private/snapshots.go
@@ -0,0 +1,34 @@
+package private
+
+import (
+	"net/http"
+	"slices"
+	"strings"
+
+	"github.com/cufee/aftermath/cmds/core"
+	"github.com/cufee/aftermath/cmds/core/scheduler/tasks"
+)
+
+var validRealms = []string{"na", "eu", "as"}
+
+func SaveRealmSnapshots(client core.Client) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		realm := r.PathValue("realm")
+		if realm == "" {
+			http.Error(w, "realm is required", http.StatusBadRequest)
+			return
+		}
+		if !slices.Contains(validRealms, strings.ToLower(realm)) {
+			http.Error(w, realm+" is not a valid realm", http.StatusBadRequest)
+			return
+		}
+
+		err := tasks.CreateRecordSnapshotsTasks(client, realm)
+		if err != nil {
+			http.Error(w, "failed to create tasks: "+err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		w.Write([]byte("tasks scheduled"))
+	}
+}
diff --git a/internal/database/accounts.go b/internal/database/accounts.go
index b6fed2cd..344dc12b 100644
--- a/internal/database/accounts.go
+++ b/internal/database/accounts.go
@@ -27,17 +27,12 @@ func toAccount(model *db.Account) models.Account {
 }
 
 func (c *libsqlClient) GetRealmAccountIDs(ctx context.Context, realm string) ([]string, error) {
-	result, err := c.db.Account.Query().Where(account.Realm(strings.ToLower(realm))).Select(account.FieldID).All(ctx)
+	result, err := c.db.Account.Query().Where(account.Realm(strings.ToUpper(realm))).IDs(ctx)
 	if err != nil {
 		return nil, err
 	}
 
-	var accounts []string
-	for _, model := range result {
-		accounts = append(accounts, model.ID)
-	}
-
-	return accounts, nil
+	return result, nil
 }
 
 func (c *libsqlClient) GetAccountByID(ctx context.Context, id string) (models.Account, error) {
@@ -95,7 +90,7 @@ func (c *libsqlClient) UpsertAccounts(ctx context.Context, accounts []models.Acc
 		}
 
 		err = tx.Account.UpdateOneID(r.ID).
-			SetRealm(update.Realm).
+			SetRealm(strings.ToUpper(update.Realm)).
 			SetNickname(update.Nickname).
 			SetPrivate(update.Private).
 			SetLastBattleTime(update.LastBattleTime.Unix()).
@@ -112,7 +107,7 @@ func (c *libsqlClient) UpsertAccounts(ctx context.Context, accounts []models.Acc
 		inserts = append(inserts,
 			c.db.Account.Create().
 				SetID(a.ID).
-				SetRealm(a.Realm).
+				SetRealm(strings.ToUpper(a.Realm)).
 				SetNickname(a.Nickname).
 				SetPrivate(a.Private).
 				SetAccountCreatedAt(a.CreatedAt.Unix()).
@@ -129,7 +124,7 @@ func (c *libsqlClient) UpsertAccounts(ctx context.Context, accounts []models.Acc
 
 func (c *libsqlClient) AccountSetPrivate(ctx context.Context, id string, value bool) error {
 	err := c.db.Account.UpdateOneID(id).SetPrivate(value).Exec(ctx)
-	if err != nil && !IsNotFound(err) {
+	if err != nil {
 		return err
 	}
 	return nil
diff --git a/internal/database/averages.go b/internal/database/averages.go
index 881307b3..0d7a47ed 100644
--- a/internal/database/averages.go
+++ b/internal/database/averages.go
@@ -24,7 +24,7 @@ func (c *libsqlClient) UpsertVehicleAverages(ctx context.Context, averages map[s
 	}
 
 	existing, err := tx.VehicleAverage.Query().Where(vehicleaverage.IDIn(ids...)).All(ctx)
-	if err != nil {
+	if err != nil && !IsNotFound(err) {
 		return rollback(tx, err)
 	}
 
diff --git a/internal/database/cleanup.go b/internal/database/cleanup.go
index 89216aa7..d79a7f7b 100644
--- a/internal/database/cleanup.go
+++ b/internal/database/cleanup.go
@@ -17,7 +17,7 @@ func (c *libsqlClient) DeleteExpiredTasks(ctx context.Context, expiration time.T
 	}
 
 	_, err = tx.CronTask.Delete().Where(crontask.CreatedAtLT(expiration.Unix())).Exec(ctx)
-	if err != nil && !IsNotFound(err) {
+	if err != nil {
 		return rollback(tx, err)
 	}
 	return tx.Commit()
@@ -25,17 +25,17 @@ func (c *libsqlClient) DeleteExpiredTasks(ctx context.Context, expiration time.T
 
 func (c *libsqlClient) DeleteExpiredSnapshots(ctx context.Context, expiration time.Time) error {
 	_, err := c.db.AccountSnapshot.Delete().Where(accountsnapshot.CreatedAtLT(expiration.Unix())).Exec(ctx)
-	if err != nil && !IsNotFound(err) {
+	if err != nil {
 		return err
 	}
 
 	_, err = c.db.VehicleSnapshot.Delete().Where(vehiclesnapshot.CreatedAtLT(expiration.Unix())).Exec(ctx)
-	if err != nil && !IsNotFound(err) {
+	if err != nil {
 		return err
 	}
 
 	_, err = c.db.AchievementsSnapshot.Delete().Where(achievementssnapshot.CreatedAtLT(expiration.Unix())).Exec(ctx)
-	if err != nil && !IsNotFound(err) {
+	if err != nil {
 		return err
 	}
 
diff --git a/internal/database/discord.go b/internal/database/discord.go
index 91f084b3..84ae76e2 100644
--- a/internal/database/discord.go
+++ b/internal/database/discord.go
@@ -69,7 +69,7 @@ func (c *libsqlClient) UpsertCommands(ctx context.Context, commands ...models.Ap
 	}
 
 	existing, err := tx.ApplicationCommand.Query().Where(applicationcommand.IDIn(ids...)).All(ctx)
-	if err != nil {
+	if err != nil && !IsNotFound(err) {
 		return rollback(tx, err)
 	}
 
diff --git a/internal/database/ent/db/crontask/crontask.go b/internal/database/ent/db/crontask/crontask.go
index f3ba2093..c83a8067 100644
--- a/internal/database/ent/db/crontask/crontask.go
+++ b/internal/database/ent/db/crontask/crontask.go
@@ -79,7 +79,7 @@ var (
 // TypeValidator is a validator for the "type" field enum values. It is called by the builders before save.
 func TypeValidator(_type models.TaskType) error {
 	switch _type {
-	case "UPDATE_CLANS", "RECORD_ACCOUNT_SESSIONS", "UPDATE_ACCOUNT_WN8", "UPDATE_ACCOUNT_ACHIEVEMENTS", "CLEANUP_DATABASE":
+	case "UPDATE_CLANS", "RECORD_SNAPSHOTS", "CLEANUP_DATABASE":
 		return nil
 	default:
 		return fmt.Errorf("crontask: invalid enum value for type field: %q", _type)
diff --git a/internal/database/ent/db/migrate/schema.go b/internal/database/ent/db/migrate/schema.go
index f5c10f59..700be463 100644
--- a/internal/database/ent/db/migrate/schema.go
+++ b/internal/database/ent/db/migrate/schema.go
@@ -226,7 +226,7 @@ var (
 		{Name: "id", Type: field.TypeString, Unique: true},
 		{Name: "created_at", Type: field.TypeInt64},
 		{Name: "updated_at", Type: field.TypeInt64},
-		{Name: "type", Type: field.TypeEnum, Enums: []string{"UPDATE_CLANS", "RECORD_ACCOUNT_SESSIONS", "UPDATE_ACCOUNT_WN8", "UPDATE_ACCOUNT_ACHIEVEMENTS", "CLEANUP_DATABASE"}},
+		{Name: "type", Type: field.TypeEnum, Enums: []string{"UPDATE_CLANS", "RECORD_SNAPSHOTS", "CLEANUP_DATABASE"}},
 		{Name: "reference_id", Type: field.TypeString},
 		{Name: "targets", Type: field.TypeJSON},
 		{Name: "status", Type: field.TypeEnum, Enums: []string{"TASK_SCHEDULED", "TASK_IN_PROGRESS", "TASK_COMPLETE", "TASK_FAILED"}},
diff --git a/internal/database/models/task.go b/internal/database/models/task.go
index b81c8f5a..c11caf6a 100644
--- a/internal/database/models/task.go
+++ b/internal/database/models/task.go
@@ -7,10 +7,10 @@ import (
 type TaskType string
 
 const (
-	TaskTypeUpdateClans              TaskType = "UPDATE_CLANS"
-	TaskTypeRecordSessions           TaskType = "RECORD_ACCOUNT_SESSIONS"
-	TaskTypeUpdateAccountWN8         TaskType = "UPDATE_ACCOUNT_WN8"
-	TaskTypeRecordPlayerAchievements TaskType = "UPDATE_ACCOUNT_ACHIEVEMENTS"
+	TaskTypeUpdateClans     TaskType = "UPDATE_CLANS"
+	TaskTypeRecordSnapshots TaskType = "RECORD_SNAPSHOTS"
+	// TaskTypeUpdateAccountWN8         TaskType = "UPDATE_ACCOUNT_WN8"
+	// TaskTypeRecordPlayerAchievements TaskType = "UPDATE_ACCOUNT_ACHIEVEMENTS"
 
 	TaskTypeDatabaseCleanup TaskType = "CLEANUP_DATABASE"
 )
@@ -20,9 +20,9 @@ func (TaskType) Values() []string {
 	var kinds []string
 	for _, s := range []TaskType{
 		TaskTypeUpdateClans,
-		TaskTypeRecordSessions,
-		TaskTypeUpdateAccountWN8,
-		TaskTypeRecordPlayerAchievements,
+		TaskTypeRecordSnapshots,
+		// TaskTypeUpdateAccountWN8,
+		// TaskTypeRecordPlayerAchievements,
 		//
 		TaskTypeDatabaseCleanup,
 	} {
diff --git a/internal/database/snapshots.go b/internal/database/snapshots.go
index 6657cd5e..5539ca43 100644
--- a/internal/database/snapshots.go
+++ b/internal/database/snapshots.go
@@ -94,7 +94,7 @@ func (c *libsqlClient) GetVehicleSnapshots(ctx context.Context, accountID, refer
 
 	var records []*db.VehicleSnapshot
 	err := c.db.VehicleSnapshot.Query().Where(where...).GroupBy(vehiclesnapshot.FieldVehicleID).Scan(ctx, &records)
-	if err != nil && !IsNotFound(err) {
+	if err != nil {
 		return nil, err
 	}
 	var snapshots []models.VehicleSnapshot
diff --git a/internal/database/tasks.go b/internal/database/tasks.go
index 57f3904b..63cb365e 100644
--- a/internal/database/tasks.go
+++ b/internal/database/tasks.go
@@ -39,7 +39,7 @@ func (c *libsqlClient) GetStaleTasks(ctx context.Context, limit int) ([]models.T
 		Order(crontask.ByScheduledAfter(sql.OrderAsc())).
 		Limit(limit).
 		All(ctx)
-	if err != nil && !IsNotFound(err) {
+	if err != nil {
 		return nil, err
 	}
 
@@ -62,7 +62,7 @@ func (c *libsqlClient) GetRecentTasks(ctx context.Context, createdAfter time.Tim
 	}
 
 	records, err := c.db.CronTask.Query().Where(where...).All(ctx)
-	if err != nil && !IsNotFound(err) {
+	if err != nil {
 		return nil, err
 	}
 
@@ -89,9 +89,6 @@ func (c *libsqlClient) GetAndStartTasks(ctx context.Context, limit int) ([]model
 
 	records, err := tx.CronTask.Query().Where(crontask.StatusEQ(models.TaskStatusScheduled), crontask.ScheduledAfterLT(time.Now().Unix())).Order(crontask.ByScheduledAfter(sql.OrderAsc())).Limit(limit).All(ctx)
 	if err != nil {
-		if IsNotFound(err) {
-			return nil, nil
-		}
 		return nil, rollback(tx, err)
 	}
 
@@ -107,7 +104,7 @@ func (c *libsqlClient) GetAndStartTasks(ctx context.Context, limit int) ([]model
 	}
 
 	err = tx.CronTask.Update().Where(crontask.IDIn(ids...)).SetStatus(models.TaskStatusInProgress).Exec(ctx)
-	if err != nil && !IsNotFound(err) {
+	if err != nil {
 		return nil, rollback(tx, err)
 	}
 
diff --git a/internal/database/vehicles.go b/internal/database/vehicles.go
index bdf141dd..2cd036ab 100644
--- a/internal/database/vehicles.go
+++ b/internal/database/vehicles.go
@@ -32,7 +32,7 @@ func (c *libsqlClient) UpsertVehicles(ctx context.Context, vehicles map[string]m
 	}
 
 	records, err := tx.Vehicle.Query().Where(vehicle.IDIn(ids...)).All(ctx)
-	if err != nil {
+	if err != nil && !IsNotFound(err) {
 		return rollback(tx, err)
 	}
 
@@ -77,7 +77,7 @@ func (c *libsqlClient) GetVehicles(ctx context.Context, ids []string) (map[strin
 	}
 
 	records, err := c.db.Vehicle.Query().Where(vehicle.IDIn(ids...)).All(ctx)
-	if err != nil && !IsNotFound(err) {
+	if err != nil {
 		return nil, err
 	}
 
diff --git a/main.go b/main.go
index a83c4d65..ff1bb377 100644
--- a/main.go
+++ b/main.go
@@ -54,10 +54,16 @@ func main() {
 
 	if e := os.Getenv("PRIVATE_SERVER_ENABLED"); e == "true" {
 		port := os.Getenv("PRIVATE_SERVER_PORT")
-		servePrivate := server.NewServer(port, server.Handler{
-			Path: "POST /accounts/load",
-			Func: private.LoadAccountsHandler(cacheCoreClient),
-		})
+		servePrivate := server.NewServer(port, []server.Handler{
+			{
+				Path: "POST /accounts/import",
+				Func: private.LoadAccountsHandler(cacheCoreClient),
+			},
+			{
+				Path: "POST /snapshots/{realm}",
+				Func: private.SaveRealmSnapshots(cacheCoreClient),
+			},
+		}...)
 		log.Info().Str("port", port).Msg("starting a private server")
 		go servePrivate()
 	}

From d702da57169d6189a107d87b8366a7758c2fa1d8 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 09:46:42 -0400
Subject: [PATCH 102/341] better logging

---
 cmds/core/scheduler/glossary.go               | 12 ++++++++--
 cmds/core/scheduler/workers.go                | 10 ++++++++
 cmds/core/server/handlers/private/accounts.go | 16 +++++++++++--
 internal/database/accounts.go                 | 15 ++++++------
 internal/database/averages.go                 | 15 ++++++------
 internal/database/client.go                   | 24 ++++++++++++-------
 internal/database/vehicles.go                 | 15 ++++++------
 internal/stats/fetch/multisource.go           | 10 ++++++--
 8 files changed, 81 insertions(+), 36 deletions(-)

diff --git a/cmds/core/scheduler/glossary.go b/cmds/core/scheduler/glossary.go
index 14327f15..41887f80 100644
--- a/cmds/core/scheduler/glossary.go
+++ b/cmds/core/scheduler/glossary.go
@@ -24,11 +24,15 @@ func UpdateAveragesWorker(client core.Client) func() {
 			return
 		}
 
-		err = client.Database().UpsertVehicleAverages(ctx, averages)
+		aErr, err := client.Database().UpsertVehicleAverages(ctx, averages)
 		if err != nil {
 			log.Err(err).Msg("failed to update averages cache")
 			return
 		}
+		if len(aErr) > 0 {
+			log.Error().Any("errors", aErr).Msg("failed to update some average cache")
+			return
+		}
 
 		log.Info().Msg("averages cache updated")
 	}
@@ -57,11 +61,15 @@ func UpdateGlossaryWorker(client core.Client) func() {
 			}
 		}
 
-		err = client.Database().UpsertVehicles(ctx, vehicles)
+		vErr, err := client.Database().UpsertVehicles(ctx, vehicles)
 		if err != nil {
 			log.Err(err).Msg("failed to save vehicle glossary")
 			return
 		}
+		if len(vErr) > 0 {
+			log.Error().Any("errors", vErr).Msg("failed to save some vehicle glossaries")
+			return
+		}
 
 		log.Info().Msg("glossary cache updated")
 	}
diff --git a/cmds/core/scheduler/workers.go b/cmds/core/scheduler/workers.go
index fed10db4..430fa2aa 100644
--- a/cmds/core/scheduler/workers.go
+++ b/cmds/core/scheduler/workers.go
@@ -6,6 +6,7 @@ import (
 
 	"github.com/cufee/aftermath/cmds/core"
 	"github.com/cufee/aftermath/cmds/core/scheduler/tasks"
+	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/rs/zerolog/log"
 )
@@ -48,6 +49,7 @@ func RunTasksWorker(queue *Queue) func() {
 	return func() {
 		activeWorkers := queue.ActiveWorkers()
 		if activeWorkers >= queue.concurrencyLimit {
+			log.Debug().Int("active", activeWorkers).Int("limit", queue.concurrencyLimit).Msg("no available workers to process tasks")
 			return
 		}
 
@@ -59,6 +61,10 @@ func RunTasksWorker(queue *Queue) func() {
 		batchSize := queue.concurrencyLimit - activeWorkers
 		tasks, err := queue.core.Database().GetAndStartTasks(ctx, batchSize*10)
 		if err != nil {
+			if database.IsNotFound(err) {
+				log.Debug().Msg("no scheduled tasks to process")
+				return
+			}
 			log.Err(err).Msg("failed to start scheduled tasks")
 			return
 		}
@@ -81,6 +87,10 @@ func RestartTasksWorker(queue *Queue) func() {
 
 		staleTasks, err := queue.core.Database().GetStaleTasks(ctx, 100)
 		if err != nil {
+			if database.IsNotFound(err) {
+				log.Debug().Msg("no failed tasks to reschedule found")
+				return
+			}
 			log.Err(err).Msg("failed to reschedule stale tasks")
 			return
 		}
diff --git a/cmds/core/server/handlers/private/accounts.go b/cmds/core/server/handlers/private/accounts.go
index e1128c0d..84bcaf6f 100644
--- a/cmds/core/server/handlers/private/accounts.go
+++ b/cmds/core/server/handlers/private/accounts.go
@@ -63,6 +63,8 @@ func LoadAccountsHandler(client core.Client) http.HandlerFunc {
 			batchSize := 50
 			var wg sync.WaitGroup
 			sem := semaphore.NewWeighted(5)
+			errors := make(map[string]error)
+			var errorsMx sync.Mutex
 
 			for realm, accounts := range accountsByRealm {
 				for i := 0; i < len(accounts); i += batchSize {
@@ -96,16 +98,26 @@ func LoadAccountsHandler(client core.Client) http.HandlerFunc {
 							inserts = append(inserts, fetch.WargamingToAccount(realm, account, types.ClanMember{}, false))
 						}
 
-						err = client.Database().UpsertAccounts(ctx, inserts)
+						accErr, err := client.Database().UpsertAccounts(ctx, inserts)
 						if err != nil {
 							log.Err(err).Msg("failed to upsert accounts")
-							return
+						}
+						if len(accErr) > 0 {
+							errorsMx.Lock()
+							for id, err := range accErr {
+								errors[id] = err
+							}
+							errorsMx.Unlock()
 						}
 
 					}(accounts[i:end], realm)
 				}
 			}
 			wg.Wait()
+
+			if len(errors) > 0 {
+				log.Error().Any("errors", errors).Msg("some account imports failed")
+			}
 			log.Info().Int("count", len(accounts)-len(existing)).Msg("finished importing accounts")
 		}()
 	}
diff --git a/internal/database/accounts.go b/internal/database/accounts.go
index 344dc12b..20dc64f2 100644
--- a/internal/database/accounts.go
+++ b/internal/database/accounts.go
@@ -61,9 +61,9 @@ func (c *libsqlClient) GetAccounts(ctx context.Context, ids []string) ([]models.
 	return accounts, nil
 }
 
-func (c *libsqlClient) UpsertAccounts(ctx context.Context, accounts []models.Account) error {
+func (c *libsqlClient) UpsertAccounts(ctx context.Context, accounts []models.Account) (map[string]error, error) {
 	if len(accounts) < 1 {
-		return nil
+		return nil, nil
 	}
 
 	var ids []string
@@ -75,14 +75,15 @@ func (c *libsqlClient) UpsertAccounts(ctx context.Context, accounts []models.Acc
 
 	tx, err := c.db.Tx(ctx)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	records, err := tx.Account.Query().Where(account.IDIn(ids...)).All(ctx)
 	if err != nil && !IsNotFound(err) {
-		return rollback(tx, err)
+		return nil, rollback(tx, err)
 	}
 
+	errors := make(map[string]error)
 	for _, r := range records {
 		update, ok := accountsMap[r.ID]
 		if !ok {
@@ -96,7 +97,7 @@ func (c *libsqlClient) UpsertAccounts(ctx context.Context, accounts []models.Acc
 			SetLastBattleTime(update.LastBattleTime.Unix()).
 			Exec(ctx)
 		if err != nil {
-			return rollback(tx, err)
+			errors[r.ID] = err
 		}
 
 		delete(accountsMap, r.ID)
@@ -117,9 +118,9 @@ func (c *libsqlClient) UpsertAccounts(ctx context.Context, accounts []models.Acc
 
 	err = c.db.Account.CreateBulk(inserts...).Exec(ctx)
 	if err != nil {
-		return rollback(tx, err)
+		return errors, rollback(tx, err)
 	}
-	return tx.Commit()
+	return errors, tx.Commit()
 }
 
 func (c *libsqlClient) AccountSetPrivate(ctx context.Context, id string, value bool) error {
diff --git a/internal/database/averages.go b/internal/database/averages.go
index 0d7a47ed..326530bd 100644
--- a/internal/database/averages.go
+++ b/internal/database/averages.go
@@ -8,9 +8,9 @@ import (
 	"github.com/cufee/aftermath/internal/stats/frame"
 )
 
-func (c *libsqlClient) UpsertVehicleAverages(ctx context.Context, averages map[string]frame.StatsFrame) error {
+func (c *libsqlClient) UpsertVehicleAverages(ctx context.Context, averages map[string]frame.StatsFrame) (map[string]error, error) {
 	if len(averages) < 1 {
-		return nil
+		return nil, nil
 	}
 
 	var ids []string
@@ -20,14 +20,15 @@ func (c *libsqlClient) UpsertVehicleAverages(ctx context.Context, averages map[s
 
 	tx, err := c.db.Tx(ctx)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	existing, err := tx.VehicleAverage.Query().Where(vehicleaverage.IDIn(ids...)).All(ctx)
 	if err != nil && !IsNotFound(err) {
-		return rollback(tx, err)
+		return nil, rollback(tx, err)
 	}
 
+	errors := make(map[string]error)
 	for _, r := range existing {
 		update, ok := averages[r.ID]
 		if !ok {
@@ -36,7 +37,7 @@ func (c *libsqlClient) UpsertVehicleAverages(ctx context.Context, averages map[s
 
 		err := tx.VehicleAverage.UpdateOneID(r.ID).SetData(update).Exec(ctx)
 		if err != nil {
-			return rollback(tx, err)
+			errors[r.ID] = err
 		}
 
 		delete(averages, r.ID)
@@ -53,10 +54,10 @@ func (c *libsqlClient) UpsertVehicleAverages(ctx context.Context, averages map[s
 
 	err = tx.VehicleAverage.CreateBulk(inserts...).Exec(ctx)
 	if err != nil {
-		return rollback(tx, err)
+		return nil, rollback(tx, err)
 	}
 
-	return tx.Commit()
+	return nil, tx.Commit()
 }
 
 func (c *libsqlClient) GetVehicleAverages(ctx context.Context, ids []string) (map[string]frame.StatsFrame, error) {
diff --git a/internal/database/client.go b/internal/database/client.go
index e1b4024d..e531688e 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -19,35 +19,39 @@ import (
 var _ Client = &libsqlClient{}
 
 type AccountsClient interface {
+	GetAccounts(ctx context.Context, ids []string) ([]models.Account, error)
 	GetAccountByID(ctx context.Context, id string) (models.Account, error)
 	GetRealmAccountIDs(ctx context.Context, realm string) ([]string, error)
-	GetAccounts(ctx context.Context, ids []string) ([]models.Account, error)
-	UpsertAccounts(ctx context.Context, accounts []models.Account) error
 	AccountSetPrivate(ctx context.Context, id string, value bool) error
+	UpsertAccounts(ctx context.Context, accounts []models.Account) (map[string]error, error)
 }
 
 type GlossaryClient interface {
-	GetVehicleAverages(ctx context.Context, ids []string) (map[string]frame.StatsFrame, error)
-	UpsertVehicleAverages(ctx context.Context, averages map[string]frame.StatsFrame) error
 	GetVehicles(ctx context.Context, ids []string) (map[string]models.Vehicle, error)
-	UpsertVehicles(ctx context.Context, vehicles map[string]models.Vehicle) error
+	GetVehicleAverages(ctx context.Context, ids []string) (map[string]frame.StatsFrame, error)
+
+	UpsertVehicles(ctx context.Context, vehicles map[string]models.Vehicle) (map[string]error, error)
+	UpsertVehicleAverages(ctx context.Context, averages map[string]frame.StatsFrame) (map[string]error, error)
 }
 
 type UsersClient interface {
 	GetUserByID(ctx context.Context, id string, opts ...userGetOption) (models.User, error)
 	GetOrCreateUserByID(ctx context.Context, id string, opts ...userGetOption) (models.User, error)
+	UpsertUserWithPermissions(ctx context.Context, userID string, perms permissions.Permissions) (models.User, error)
+
 	UpdateConnection(ctx context.Context, connection models.UserConnection) (models.UserConnection, error)
 	UpsertConnection(ctx context.Context, connection models.UserConnection) (models.UserConnection, error)
-	UpsertUserWithPermissions(ctx context.Context, userID string, perms permissions.Permissions) (models.User, error)
 }
 
 type SnapshotsClient interface {
+	GetAccountSnapshot(ctx context.Context, accountID, referenceID string, kind models.SnapshotType, options ...SnapshotQuery) (models.AccountSnapshot, error)
 	CreateAccountSnapshots(ctx context.Context, snapshots ...models.AccountSnapshot) error
 	GetLastAccountSnapshots(ctx context.Context, accountID string, limit int) ([]models.AccountSnapshot, error)
-	GetAccountSnapshot(ctx context.Context, accountID, referenceID string, kind models.SnapshotType, options ...SnapshotQuery) (models.AccountSnapshot, error)
 	GetManyAccountSnapshots(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.AccountSnapshot, error)
-	CreateVehicleSnapshots(ctx context.Context, snapshots ...models.VehicleSnapshot) error
+
 	GetVehicleSnapshots(ctx context.Context, accountID, referenceID string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.VehicleSnapshot, error)
+	CreateVehicleSnapshots(ctx context.Context, snapshots ...models.VehicleSnapshot) error
+
 	DeleteExpiredSnapshots(ctx context.Context, expiration time.Time) error
 }
 
@@ -55,10 +59,12 @@ type TasksClient interface {
 	CreateTasks(ctx context.Context, tasks ...models.Task) error
 	UpdateTasks(ctx context.Context, tasks ...models.Task) error
 	DeleteTasks(ctx context.Context, ids ...string) error
+
 	GetStaleTasks(ctx context.Context, limit int) ([]models.Task, error)
+	GetRecentTasks(ctx context.Context, createdAfter time.Time, status ...models.TaskStatus) ([]models.Task, error)
 	GetAndStartTasks(ctx context.Context, limit int) ([]models.Task, error)
+
 	DeleteExpiredTasks(ctx context.Context, expiration time.Time) error
-	GetRecentTasks(ctx context.Context, createdAfter time.Time, status ...models.TaskStatus) ([]models.Task, error)
 }
 
 type DiscordDataClient interface {
diff --git a/internal/database/vehicles.go b/internal/database/vehicles.go
index 2cd036ab..b9e4bf75 100644
--- a/internal/database/vehicles.go
+++ b/internal/database/vehicles.go
@@ -16,9 +16,9 @@ func toVehicle(record *db.Vehicle) models.Vehicle {
 	}
 }
 
-func (c *libsqlClient) UpsertVehicles(ctx context.Context, vehicles map[string]models.Vehicle) error {
+func (c *libsqlClient) UpsertVehicles(ctx context.Context, vehicles map[string]models.Vehicle) (map[string]error, error) {
 	if len(vehicles) < 1 {
-		return nil
+		return nil, nil
 	}
 
 	var ids []string
@@ -28,14 +28,15 @@ func (c *libsqlClient) UpsertVehicles(ctx context.Context, vehicles map[string]m
 
 	tx, err := c.db.Tx(ctx)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	records, err := tx.Vehicle.Query().Where(vehicle.IDIn(ids...)).All(ctx)
 	if err != nil && !IsNotFound(err) {
-		return rollback(tx, err)
+		return nil, rollback(tx, err)
 	}
 
+	errors := make(map[string]error)
 	for _, r := range records {
 		v, ok := vehicles[r.ID]
 		if !ok {
@@ -47,7 +48,7 @@ func (c *libsqlClient) UpsertVehicles(ctx context.Context, vehicles map[string]m
 			SetLocalizedNames(v.LocalizedNames).
 			Exec(ctx)
 		if err != nil {
-			return rollback(tx, err)
+			errors[v.ID] = err
 		}
 
 		delete(vehicles, v.ID)
@@ -65,10 +66,10 @@ func (c *libsqlClient) UpsertVehicles(ctx context.Context, vehicles map[string]m
 
 	err = tx.Vehicle.CreateBulk(inserts...).Exec(ctx)
 	if err != nil {
-		return rollback(tx, err)
+		return errors, rollback(tx, err)
 	}
 
-	return tx.Commit()
+	return errors, tx.Commit()
 }
 
 func (c *libsqlClient) GetVehicles(ctx context.Context, ids []string) (map[string]models.Vehicle, error) {
diff --git a/internal/stats/fetch/multisource.go b/internal/stats/fetch/multisource.go
index b836a158..b8e700f3 100644
--- a/internal/stats/fetch/multisource.go
+++ b/internal/stats/fetch/multisource.go
@@ -89,10 +89,13 @@ func (c *multiSourceClient) Account(ctx context.Context, id string) (models.Acco
 		ctx, cancel := context.WithTimeout(context.Background(), time.Second)
 		defer cancel()
 
-		err := c.database.UpsertAccounts(ctx, []models.Account{account})
+		aErr, err := c.database.UpsertAccounts(ctx, []models.Account{account})
 		if err != nil {
 			log.Err(err).Msg("failed to update account cache")
 		}
+		if err := aErr[account.ID]; err != nil {
+			log.Err(err).Msg("failed to update account cache")
+		}
 	}()
 
 	return account, nil
@@ -172,10 +175,13 @@ func (c *multiSourceClient) CurrentStats(ctx context.Context, id string, opts ..
 		ctx, cancel := context.WithTimeout(context.Background(), time.Second)
 		defer cancel()
 
-		err := c.database.UpsertAccounts(ctx, []models.Account{stats.Account})
+		aErr, err := c.database.UpsertAccounts(ctx, []models.Account{stats.Account})
 		if err != nil {
 			log.Err(err).Msg("failed to update account cache")
 		}
+		if err := aErr[stats.Account.ID]; err != nil {
+			log.Err(err).Msg("failed to update account cache")
+		}
 	}()
 
 	return stats, nil

From e265f72d7d413ce515ee2c6b574fd1f9ac5db1f5 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 09:57:26 -0400
Subject: [PATCH 103/341] creating records individually to not loose good data

---
 internal/database/accounts.go | 25 +++++++++++--------------
 internal/database/averages.go | 21 ++++++++-------------
 internal/database/vehicles.go | 20 ++++++++------------
 3 files changed, 27 insertions(+), 39 deletions(-)

diff --git a/internal/database/accounts.go b/internal/database/accounts.go
index 20dc64f2..016e8a7f 100644
--- a/internal/database/accounts.go
+++ b/internal/database/accounts.go
@@ -103,23 +103,20 @@ func (c *libsqlClient) UpsertAccounts(ctx context.Context, accounts []models.Acc
 		delete(accountsMap, r.ID)
 	}
 
-	var inserts []*db.AccountCreate
 	for _, a := range accountsMap {
-		inserts = append(inserts,
-			c.db.Account.Create().
-				SetID(a.ID).
-				SetRealm(strings.ToUpper(a.Realm)).
-				SetNickname(a.Nickname).
-				SetPrivate(a.Private).
-				SetAccountCreatedAt(a.CreatedAt.Unix()).
-				SetLastBattleTime(a.LastBattleTime.Unix()),
-		)
+		err := tx.Account.Create().
+			SetID(a.ID).
+			SetRealm(strings.ToUpper(a.Realm)).
+			SetNickname(a.Nickname).
+			SetPrivate(a.Private).
+			SetAccountCreatedAt(a.CreatedAt.Unix()).
+			SetLastBattleTime(a.LastBattleTime.Unix()).
+			Exec(ctx)
+		if err != nil {
+			errors[a.ID] = err
+		}
 	}
 
-	err = c.db.Account.CreateBulk(inserts...).Exec(ctx)
-	if err != nil {
-		return errors, rollback(tx, err)
-	}
 	return errors, tx.Commit()
 }
 
diff --git a/internal/database/averages.go b/internal/database/averages.go
index 326530bd..4b052755 100644
--- a/internal/database/averages.go
+++ b/internal/database/averages.go
@@ -3,7 +3,6 @@ package database
 import (
 	"context"
 
-	"github.com/cufee/aftermath/internal/database/ent/db"
 	"github.com/cufee/aftermath/internal/database/ent/db/vehicleaverage"
 	"github.com/cufee/aftermath/internal/stats/frame"
 )
@@ -43,21 +42,17 @@ func (c *libsqlClient) UpsertVehicleAverages(ctx context.Context, averages map[s
 		delete(averages, r.ID)
 	}
 
-	var inserts []*db.VehicleAverageCreate
 	for id, frame := range averages {
-		inserts = append(inserts,
-			c.db.VehicleAverage.Create().
-				SetID(id).
-				SetData(frame),
-		)
-	}
-
-	err = tx.VehicleAverage.CreateBulk(inserts...).Exec(ctx)
-	if err != nil {
-		return nil, rollback(tx, err)
+		err := tx.VehicleAverage.Create().
+			SetID(id).
+			SetData(frame).
+			Exec(ctx)
+		if err != nil {
+			errors[id] = err
+		}
 	}
 
-	return nil, tx.Commit()
+	return errors, tx.Commit()
 }
 
 func (c *libsqlClient) GetVehicleAverages(ctx context.Context, ids []string) (map[string]frame.StatsFrame, error) {
diff --git a/internal/database/vehicles.go b/internal/database/vehicles.go
index b9e4bf75..fa77af11 100644
--- a/internal/database/vehicles.go
+++ b/internal/database/vehicles.go
@@ -54,19 +54,15 @@ func (c *libsqlClient) UpsertVehicles(ctx context.Context, vehicles map[string]m
 		delete(vehicles, v.ID)
 	}
 
-	var inserts []*db.VehicleCreate
 	for id, v := range vehicles {
-		inserts = append(inserts,
-			c.db.Vehicle.Create().
-				SetID(id).
-				SetTier(v.Tier).
-				SetLocalizedNames(v.LocalizedNames),
-		)
-	}
-
-	err = tx.Vehicle.CreateBulk(inserts...).Exec(ctx)
-	if err != nil {
-		return errors, rollback(tx, err)
+		err := tx.Vehicle.Create().
+			SetID(id).
+			SetTier(v.Tier).
+			SetLocalizedNames(v.LocalizedNames).
+			Exec(ctx)
+		if err != nil {
+			errors[id] = err
+		}
 	}
 
 	return errors, tx.Commit()

From cf35b43e5eb5c8e95a6157be5ad96892c5170c7c Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 10:03:50 -0400
Subject: [PATCH 104/341] logging errors as strings

---
 cmds/core/scheduler/glossary.go               | 12 ++++++++++--
 cmds/core/server/handlers/private/accounts.go |  6 +++++-
 2 files changed, 15 insertions(+), 3 deletions(-)

diff --git a/cmds/core/scheduler/glossary.go b/cmds/core/scheduler/glossary.go
index 41887f80..a5715a1d 100644
--- a/cmds/core/scheduler/glossary.go
+++ b/cmds/core/scheduler/glossary.go
@@ -30,7 +30,11 @@ func UpdateAveragesWorker(client core.Client) func() {
 			return
 		}
 		if len(aErr) > 0 {
-			log.Error().Any("errors", aErr).Msg("failed to update some average cache")
+			event := log.Error()
+			for id, err := range aErr {
+				event.Str(id, err.Error())
+			}
+			event.Msg("failed to update some average cache")
 			return
 		}
 
@@ -67,7 +71,11 @@ func UpdateGlossaryWorker(client core.Client) func() {
 			return
 		}
 		if len(vErr) > 0 {
-			log.Error().Any("errors", vErr).Msg("failed to save some vehicle glossaries")
+			event := log.Error()
+			for id, err := range vErr {
+				event.Str(id, err.Error())
+			}
+			event.Msg("failed to save some vehicle glossaries")
 			return
 		}
 
diff --git a/cmds/core/server/handlers/private/accounts.go b/cmds/core/server/handlers/private/accounts.go
index 84bcaf6f..7284f238 100644
--- a/cmds/core/server/handlers/private/accounts.go
+++ b/cmds/core/server/handlers/private/accounts.go
@@ -116,7 +116,11 @@ func LoadAccountsHandler(client core.Client) http.HandlerFunc {
 			wg.Wait()
 
 			if len(errors) > 0 {
-				log.Error().Any("errors", errors).Msg("some account imports failed")
+				event := log.Error()
+				for id, err := range errors {
+					event.Str(id, err.Error())
+				}
+				event.Msg("some account imports failed")
 			}
 			log.Info().Int("count", len(accounts)-len(existing)).Msg("finished importing accounts")
 		}()

From 81035cd03313fd919a6b26ed29cea1a75cd88004 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 10:10:41 -0400
Subject: [PATCH 105/341] handling bad and private accounts

---
 cmds/core/server/handlers/private/accounts.go | 19 +++++++++++++++++--
 1 file changed, 17 insertions(+), 2 deletions(-)

diff --git a/cmds/core/server/handlers/private/accounts.go b/cmds/core/server/handlers/private/accounts.go
index 7284f238..f87e96a0 100644
--- a/cmds/core/server/handlers/private/accounts.go
+++ b/cmds/core/server/handlers/private/accounts.go
@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	"strconv"
 	"sync"
 
 	"github.com/cufee/aftermath/cmds/core"
@@ -94,8 +95,22 @@ func LoadAccountsHandler(client core.Client) http.HandlerFunc {
 						}
 
 						var inserts []models.Account
-						for _, account := range data {
-							inserts = append(inserts, fetch.WargamingToAccount(realm, account, types.ClanMember{}, false))
+						for id, account := range data {
+							if id == "" && account.ID == 0 {
+								log.Warn().Str("reason", "id is blank").Msg("wargaming returned a bad account")
+								continue
+							}
+
+							var private bool
+							if account.ID == 0 {
+								account.ID, _ = strconv.Atoi(id)
+								private = true
+							}
+							if account.Nickname == "" {
+								account.Nickname = "@Hidden"
+								private = true
+							}
+							inserts = append(inserts, fetch.WargamingToAccount(realm, account, types.ClanMember{}, private))
 						}
 
 						accErr, err := client.Database().UpsertAccounts(ctx, inserts)

From a89cf7bb6c78507681b7d8ddd6b24d1880bf2d62 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 10:28:41 -0400
Subject: [PATCH 106/341] removed most transactions, required transactions
 depend on a lock

---
 internal/database/accounts.go | 23 ++++++++---------------
 internal/database/averages.go | 24 +++++++++---------------
 internal/database/cleanup.go  |  3 ++-
 internal/database/client.go   | 17 +++++++++++++++--
 internal/database/discord.go  |  3 ++-
 internal/database/tasks.go    |  8 +++++---
 internal/database/vehicles.go | 23 ++++++++---------------
 7 files changed, 49 insertions(+), 52 deletions(-)

diff --git a/internal/database/accounts.go b/internal/database/accounts.go
index 016e8a7f..bd1c0911 100644
--- a/internal/database/accounts.go
+++ b/internal/database/accounts.go
@@ -73,14 +73,9 @@ func (c *libsqlClient) UpsertAccounts(ctx context.Context, accounts []models.Acc
 		accountsMap[a.ID] = &a
 	}
 
-	tx, err := c.db.Tx(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	records, err := tx.Account.Query().Where(account.IDIn(ids...)).All(ctx)
+	records, err := c.db.Account.Query().Where(account.IDIn(ids...)).All(ctx)
 	if err != nil && !IsNotFound(err) {
-		return nil, rollback(tx, err)
+		return nil, err
 	}
 
 	errors := make(map[string]error)
@@ -90,7 +85,7 @@ func (c *libsqlClient) UpsertAccounts(ctx context.Context, accounts []models.Acc
 			continue // this should never happen tho
 		}
 
-		err = tx.Account.UpdateOneID(r.ID).
+		err = c.db.Account.UpdateOneID(r.ID).
 			SetRealm(strings.ToUpper(update.Realm)).
 			SetNickname(update.Nickname).
 			SetPrivate(update.Private).
@@ -103,21 +98,19 @@ func (c *libsqlClient) UpsertAccounts(ctx context.Context, accounts []models.Acc
 		delete(accountsMap, r.ID)
 	}
 
+	var writes []*db.AccountCreate
 	for _, a := range accountsMap {
-		err := tx.Account.Create().
+		writes = append(writes, c.db.Account.Create().
 			SetID(a.ID).
 			SetRealm(strings.ToUpper(a.Realm)).
 			SetNickname(a.Nickname).
 			SetPrivate(a.Private).
 			SetAccountCreatedAt(a.CreatedAt.Unix()).
-			SetLastBattleTime(a.LastBattleTime.Unix()).
-			Exec(ctx)
-		if err != nil {
-			errors[a.ID] = err
-		}
+			SetLastBattleTime(a.LastBattleTime.Unix()),
+		)
 	}
 
-	return errors, tx.Commit()
+	return errors, c.db.Account.CreateBulk(writes...).Exec(ctx)
 }
 
 func (c *libsqlClient) AccountSetPrivate(ctx context.Context, id string, value bool) error {
diff --git a/internal/database/averages.go b/internal/database/averages.go
index 4b052755..fe183062 100644
--- a/internal/database/averages.go
+++ b/internal/database/averages.go
@@ -3,6 +3,7 @@ package database
 import (
 	"context"
 
+	"github.com/cufee/aftermath/internal/database/ent/db"
 	"github.com/cufee/aftermath/internal/database/ent/db/vehicleaverage"
 	"github.com/cufee/aftermath/internal/stats/frame"
 )
@@ -17,14 +18,9 @@ func (c *libsqlClient) UpsertVehicleAverages(ctx context.Context, averages map[s
 		ids = append(ids, id)
 	}
 
-	tx, err := c.db.Tx(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	existing, err := tx.VehicleAverage.Query().Where(vehicleaverage.IDIn(ids...)).All(ctx)
+	existing, err := c.db.VehicleAverage.Query().Where(vehicleaverage.IDIn(ids...)).All(ctx)
 	if err != nil && !IsNotFound(err) {
-		return nil, rollback(tx, err)
+		return nil, err
 	}
 
 	errors := make(map[string]error)
@@ -34,7 +30,7 @@ func (c *libsqlClient) UpsertVehicleAverages(ctx context.Context, averages map[s
 			continue // should never happen tho
 		}
 
-		err := tx.VehicleAverage.UpdateOneID(r.ID).SetData(update).Exec(ctx)
+		err := c.db.VehicleAverage.UpdateOneID(r.ID).SetData(update).Exec(ctx)
 		if err != nil {
 			errors[r.ID] = err
 		}
@@ -42,17 +38,15 @@ func (c *libsqlClient) UpsertVehicleAverages(ctx context.Context, averages map[s
 		delete(averages, r.ID)
 	}
 
+	var writes []*db.VehicleAverageCreate
 	for id, frame := range averages {
-		err := tx.VehicleAverage.Create().
+		writes = append(writes, c.db.VehicleAverage.Create().
 			SetID(id).
-			SetData(frame).
-			Exec(ctx)
-		if err != nil {
-			errors[id] = err
-		}
+			SetData(frame),
+		)
 	}
 
-	return errors, tx.Commit()
+	return errors, c.db.VehicleAverage.CreateBulk(writes...).Exec(ctx)
 }
 
 func (c *libsqlClient) GetVehicleAverages(ctx context.Context, ids []string) (map[string]frame.StatsFrame, error) {
diff --git a/internal/database/cleanup.go b/internal/database/cleanup.go
index d79a7f7b..fc2bf367 100644
--- a/internal/database/cleanup.go
+++ b/internal/database/cleanup.go
@@ -11,10 +11,11 @@ import (
 )
 
 func (c *libsqlClient) DeleteExpiredTasks(ctx context.Context, expiration time.Time) error {
-	tx, err := c.db.Tx(ctx)
+	tx, cancel, err := c.txWithLock(ctx)
 	if err != nil {
 		return err
 	}
+	defer cancel()
 
 	_, err = tx.CronTask.Delete().Where(crontask.CreatedAtLT(expiration.Unix())).Exec(ctx)
 	if err != nil {
diff --git a/internal/database/client.go b/internal/database/client.go
index e531688e..16fe9700 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"database/sql"
 	"fmt"
+	"sync"
 	"time"
 
 	"github.com/cufee/aftermath/internal/database/ent/db"
@@ -87,13 +88,24 @@ type Client interface {
 }
 
 type libsqlClient struct {
-	db *db.Client
+	db              *db.Client
+	transactionLock *sync.Mutex
 }
 
 func (c *libsqlClient) Disconnect() error {
 	return c.db.Close()
 }
 
+func (c *libsqlClient) txWithLock(ctx context.Context) (*db.Tx, func(), error) {
+	c.transactionLock.Lock()
+	tx, err := c.db.Tx(ctx)
+	if err != nil {
+		c.transactionLock.Unlock()
+		return tx, func() {}, nil
+	}
+	return tx, c.transactionLock.Unlock, nil
+}
+
 func NewLibSQLClient(primaryUrl string) (*libsqlClient, error) {
 	driver, err := sql.Open("libsql", primaryUrl)
 	if err != nil {
@@ -102,7 +114,8 @@ func NewLibSQLClient(primaryUrl string) (*libsqlClient, error) {
 
 	dbClient := db.NewClient(db.Driver(entsql.OpenDB(dialect.SQLite, driver)))
 	return &libsqlClient{
-		db: dbClient,
+		transactionLock: &sync.Mutex{},
+		db:              dbClient,
 	}, nil
 }
 
diff --git a/internal/database/discord.go b/internal/database/discord.go
index 84ae76e2..783b2ff0 100644
--- a/internal/database/discord.go
+++ b/internal/database/discord.go
@@ -63,10 +63,11 @@ func (c *libsqlClient) UpsertCommands(ctx context.Context, commands ...models.Ap
 		commandsMap[c.ID] = &c
 	}
 
-	tx, err := c.db.Tx(ctx)
+	tx, cancel, err := c.txWithLock(ctx)
 	if err != nil {
 		return err
 	}
+	defer cancel()
 
 	existing, err := tx.ApplicationCommand.Query().Where(applicationcommand.IDIn(ids...)).All(ctx)
 	if err != nil && !IsNotFound(err) {
diff --git a/internal/database/tasks.go b/internal/database/tasks.go
index 63cb365e..adbbec47 100644
--- a/internal/database/tasks.go
+++ b/internal/database/tasks.go
@@ -82,7 +82,7 @@ func (c *libsqlClient) GetAndStartTasks(ctx context.Context, limit int) ([]model
 		return nil, nil
 	}
 
-	tx, err := c.db.Tx(ctx)
+	tx, err := c.db.BeginTx(ctx, &sql.TxOptions{})
 	if err != nil {
 		return nil, err
 	}
@@ -147,10 +147,11 @@ func (c *libsqlClient) UpdateTasks(ctx context.Context, tasks ...models.Task) er
 		return nil
 	}
 
-	tx, err := c.db.Tx(ctx)
+	tx, cancel, err := c.txWithLock(ctx)
 	if err != nil {
 		return err
 	}
+	defer cancel()
 
 	for _, t := range tasks {
 		t.OnUpdated()
@@ -181,10 +182,11 @@ func (c *libsqlClient) DeleteTasks(ctx context.Context, ids ...string) error {
 		return nil
 	}
 
-	tx, err := c.db.Tx(ctx)
+	tx, cancel, err := c.txWithLock(ctx)
 	if err != nil {
 		return err
 	}
+	defer cancel()
 
 	_, err = tx.CronTask.Delete().Where(crontask.IDIn(ids...)).Exec(ctx)
 	if err != nil {
diff --git a/internal/database/vehicles.go b/internal/database/vehicles.go
index fa77af11..317c4b2a 100644
--- a/internal/database/vehicles.go
+++ b/internal/database/vehicles.go
@@ -26,14 +26,9 @@ func (c *libsqlClient) UpsertVehicles(ctx context.Context, vehicles map[string]m
 		ids = append(ids, id)
 	}
 
-	tx, err := c.db.Tx(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	records, err := tx.Vehicle.Query().Where(vehicle.IDIn(ids...)).All(ctx)
+	records, err := c.db.Vehicle.Query().Where(vehicle.IDIn(ids...)).All(ctx)
 	if err != nil && !IsNotFound(err) {
-		return nil, rollback(tx, err)
+		return nil, err
 	}
 
 	errors := make(map[string]error)
@@ -43,7 +38,7 @@ func (c *libsqlClient) UpsertVehicles(ctx context.Context, vehicles map[string]m
 			continue
 		}
 
-		err := tx.Vehicle.UpdateOneID(v.ID).
+		err := c.db.Vehicle.UpdateOneID(v.ID).
 			SetTier(v.Tier).
 			SetLocalizedNames(v.LocalizedNames).
 			Exec(ctx)
@@ -54,18 +49,16 @@ func (c *libsqlClient) UpsertVehicles(ctx context.Context, vehicles map[string]m
 		delete(vehicles, v.ID)
 	}
 
+	var writes []*db.VehicleCreate
 	for id, v := range vehicles {
-		err := tx.Vehicle.Create().
+		writes = append(writes, c.db.Vehicle.Create().
 			SetID(id).
 			SetTier(v.Tier).
-			SetLocalizedNames(v.LocalizedNames).
-			Exec(ctx)
-		if err != nil {
-			errors[id] = err
-		}
+			SetLocalizedNames(v.LocalizedNames),
+		)
 	}
 
-	return errors, tx.Commit()
+	return errors, c.db.Vehicle.CreateBulk(writes...).Exec(ctx)
 }
 
 func (c *libsqlClient) GetVehicles(ctx context.Context, ids []string) (map[string]models.Vehicle, error) {

From 9760712f23528659fc76bf7363ce5f17e11e9396 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 10:37:38 -0400
Subject: [PATCH 107/341] added id indexes

---
 Taskfile.yaml                                 |  2 +-
 internal/database/ent/db/migrate/schema.go    |  5 ++++
 .../20240623143618_added_indexes_on_id.sql    | 30 +++++++++++++++++++
 .../database/ent/migrate/migrations/atlas.sum |  3 +-
 internal/database/ent/schema/account.go       |  1 +
 .../database/ent/schema/account_snapshot.go   |  1 +
 .../ent/schema/achievements_snapshot.go       |  1 +
 .../database/ent/schema/app_configuration.go  |  1 +
 .../ent/schema/application_command.go         |  1 +
 internal/database/ent/schema/clan.go          |  1 +
 internal/database/ent/schema/cron_task.go     |  1 +
 internal/database/ent/schema/user.go          |  5 +++-
 .../database/ent/schema/user_connection.go    |  3 +-
 internal/database/ent/schema/user_content.go  |  1 +
 .../database/ent/schema/user_subscription.go  |  1 +
 internal/database/ent/schema/vehicle.go       |  5 +++-
 .../database/ent/schema/vehicle_average.go    |  5 +++-
 .../database/ent/schema/vehicle_snapshot.go   |  1 +
 18 files changed, 62 insertions(+), 6 deletions(-)
 create mode 100644 internal/database/ent/migrate/migrations/20240623143618_added_indexes_on_id.sql

diff --git a/Taskfile.yaml b/Taskfile.yaml
index cd2e67c1..b36ae7ec 100644
--- a/Taskfile.yaml
+++ b/Taskfile.yaml
@@ -29,7 +29,7 @@ tasks:
 
   db-migrate:
     desc: generate migrations
-    cmd: atlas migrate diff {{.CLI_ARGS}} --dir "file://internal/database/ent/migrate/migrations" --to "ent://internal/database/ent/schema" --dev-url "sqlite://file?mode=memory&_fk=1"
+    cmd: atlas migrate hash --dir "file://internal/database/ent/migrate/migrations" && atlas migrate diff {{.CLI_ARGS}} --dir "file://internal/database/ent/migrate/migrations" --to "ent://internal/database/ent/schema" --dev-url "sqlite://file?mode=memory&_fk=1"
   db-migrate-apply:
     desc: apply migrations using atlas
     cmd: ${ATLAS_TEMP_DIR} migrate apply --allow-dirty --dir "file://internal/database/ent/migrate/migrations" --tx-mode all --url "libsql+ws://0.0.0.0:8080"
diff --git a/internal/database/ent/db/migrate/schema.go b/internal/database/ent/db/migrate/schema.go
index 700be463..6be5f4e7 100644
--- a/internal/database/ent/db/migrate/schema.go
+++ b/internal/database/ent/db/migrate/schema.go
@@ -34,6 +34,11 @@ var (
 			},
 		},
 		Indexes: []*schema.Index{
+			{
+				Name:    "account_id",
+				Unique:  false,
+				Columns: []*schema.Column{AccountsColumns[0]},
+			},
 			{
 				Name:    "account_id_last_battle_time",
 				Unique:  false,
diff --git a/internal/database/ent/migrate/migrations/20240623143618_added_indexes_on_id.sql b/internal/database/ent/migrate/migrations/20240623143618_added_indexes_on_id.sql
new file mode 100644
index 00000000..7314180c
--- /dev/null
+++ b/internal/database/ent/migrate/migrations/20240623143618_added_indexes_on_id.sql
@@ -0,0 +1,30 @@
+-- Create index "account_id" to table: "accounts"
+CREATE INDEX `account_id` ON `accounts` (`id`);
+-- Create index "accountsnapshot_id" to table: "account_snapshots"
+CREATE INDEX `accountsnapshot_id` ON `account_snapshots` (`id`);
+-- Create index "achievementssnapshot_id" to table: "achievements_snapshots"
+CREATE INDEX `achievementssnapshot_id` ON `achievements_snapshots` (`id`);
+-- Create index "appconfiguration_id" to table: "app_configurations"
+CREATE INDEX `appconfiguration_id` ON `app_configurations` (`id`);
+-- Create index "applicationcommand_id" to table: "application_commands"
+CREATE INDEX `applicationcommand_id` ON `application_commands` (`id`);
+-- Create index "clan_id" to table: "clans"
+CREATE INDEX `clan_id` ON `clans` (`id`);
+-- Create index "crontask_id" to table: "cron_tasks"
+CREATE INDEX `crontask_id` ON `cron_tasks` (`id`);
+-- Create index "user_id" to table: "users"
+CREATE INDEX `user_id` ON `users` (`id`);
+-- Create index "userconnection_id" to table: "user_connections"
+CREATE INDEX `userconnection_id` ON `user_connections` (`id`);
+-- Create index "userconnection_reference_id_user_id_type" to table: "user_connections"
+CREATE UNIQUE INDEX `userconnection_reference_id_user_id_type` ON `user_connections` (`reference_id`, `user_id`, `type`);
+-- Create index "usercontent_id" to table: "user_contents"
+CREATE INDEX `usercontent_id` ON `user_contents` (`id`);
+-- Create index "usersubscription_id" to table: "user_subscriptions"
+CREATE INDEX `usersubscription_id` ON `user_subscriptions` (`id`);
+-- Create index "vehicle_id" to table: "vehicles"
+CREATE INDEX `vehicle_id` ON `vehicles` (`id`);
+-- Create index "vehicleaverage_id" to table: "vehicle_averages"
+CREATE INDEX `vehicleaverage_id` ON `vehicle_averages` (`id`);
+-- Create index "vehiclesnapshot_id" to table: "vehicle_snapshots"
+CREATE INDEX `vehiclesnapshot_id` ON `vehicle_snapshots` (`id`);
diff --git a/internal/database/ent/migrate/migrations/atlas.sum b/internal/database/ent/migrate/migrations/atlas.sum
index 4c057533..7cf2c24b 100644
--- a/internal/database/ent/migrate/migrations/atlas.sum
+++ b/internal/database/ent/migrate/migrations/atlas.sum
@@ -1,2 +1,3 @@
-h1:lIjXgF0PT71x+0IXOVk9uiIK/23v6AlTegTXIaTyyZI=
+h1:hbF7dyumL2NNWMkQkprSMNkXUEeHsM+GMYMBPXWdjW0=
 20240622203812_init.sql h1:Rt6NGvXbPBEpjg1pUFqn97FV8X3X2d1x7J2zOAAxolc=
+20240623143618_added_indexes_on_id.sql h1:o57d1Hc6+wGscJp3VIWnCNrmQkBSeSKTEVKRSWmsc6k=
diff --git a/internal/database/ent/schema/account.go b/internal/database/ent/schema/account.go
index 1477f439..ea686293 100644
--- a/internal/database/ent/schema/account.go
+++ b/internal/database/ent/schema/account.go
@@ -49,6 +49,7 @@ func (Account) Edges() []ent.Edge {
 
 func (Account) Indexes() []ent.Index {
 	return []ent.Index{
+		index.Fields("id"),
 		index.Fields("id", "last_battle_time"),
 		index.Fields("realm"),
 		index.Fields("realm", "last_battle_time"),
diff --git a/internal/database/ent/schema/account_snapshot.go b/internal/database/ent/schema/account_snapshot.go
index cd9391eb..67473711 100644
--- a/internal/database/ent/schema/account_snapshot.go
+++ b/internal/database/ent/schema/account_snapshot.go
@@ -41,6 +41,7 @@ func (AccountSnapshot) Edges() []ent.Edge {
 
 func (AccountSnapshot) Indexes() []ent.Index {
 	return []ent.Index{
+		index.Fields("id"),
 		index.Fields("created_at"),
 		index.Fields("type", "account_id", "created_at"),
 		index.Fields("type", "account_id", "reference_id"),
diff --git a/internal/database/ent/schema/achievements_snapshot.go b/internal/database/ent/schema/achievements_snapshot.go
index 26258e9f..70d56852 100644
--- a/internal/database/ent/schema/achievements_snapshot.go
+++ b/internal/database/ent/schema/achievements_snapshot.go
@@ -37,6 +37,7 @@ func (AchievementsSnapshot) Edges() []ent.Edge {
 
 func (AchievementsSnapshot) Indexes() []ent.Index {
 	return []ent.Index{
+		index.Fields("id"),
 		index.Fields("created_at"),
 		index.Fields("account_id", "reference_id"),
 		index.Fields("account_id", "reference_id", "created_at"),
diff --git a/internal/database/ent/schema/app_configuration.go b/internal/database/ent/schema/app_configuration.go
index 96ce0b6e..4b87a818 100644
--- a/internal/database/ent/schema/app_configuration.go
+++ b/internal/database/ent/schema/app_configuration.go
@@ -28,6 +28,7 @@ func (AppConfiguration) Edges() []ent.Edge {
 
 func (AppConfiguration) Indexes() []ent.Index {
 	return []ent.Index{
+		index.Fields("id"),
 		index.Fields("key"),
 	}
 }
diff --git a/internal/database/ent/schema/application_command.go b/internal/database/ent/schema/application_command.go
index 71f68cf3..d15db084 100644
--- a/internal/database/ent/schema/application_command.go
+++ b/internal/database/ent/schema/application_command.go
@@ -40,6 +40,7 @@ func (ApplicationCommand) Edges() []ent.Edge {
 
 func (ApplicationCommand) Indexes() []ent.Index {
 	return []ent.Index{
+		index.Fields("id"),
 		index.Fields("options_hash"),
 	}
 }
diff --git a/internal/database/ent/schema/clan.go b/internal/database/ent/schema/clan.go
index 9aa1738c..6ff58d0f 100644
--- a/internal/database/ent/schema/clan.go
+++ b/internal/database/ent/schema/clan.go
@@ -59,6 +59,7 @@ func (Clan) Edges() []ent.Edge {
 
 func (Clan) Indexes() []ent.Index {
 	return []ent.Index{
+		index.Fields("id"),
 		index.Fields("tag"),
 		index.Fields("name"),
 	}
diff --git a/internal/database/ent/schema/cron_task.go b/internal/database/ent/schema/cron_task.go
index d329c600..34a6640e 100644
--- a/internal/database/ent/schema/cron_task.go
+++ b/internal/database/ent/schema/cron_task.go
@@ -37,6 +37,7 @@ func (CronTask) Edges() []ent.Edge {
 
 func (CronTask) Indexes() []ent.Index {
 	return []ent.Index{
+		index.Fields("id"),
 		index.Fields("reference_id"),
 		index.Fields("status", "last_run"),
 		index.Fields("status", "created_at"),
diff --git a/internal/database/ent/schema/user.go b/internal/database/ent/schema/user.go
index f821f9b0..be20a1be 100644
--- a/internal/database/ent/schema/user.go
+++ b/internal/database/ent/schema/user.go
@@ -4,6 +4,7 @@ import (
 	"entgo.io/ent"
 	"entgo.io/ent/schema/edge"
 	"entgo.io/ent/schema/field"
+	"entgo.io/ent/schema/index"
 )
 
 // User holds the schema definition for the User entity.
@@ -39,5 +40,7 @@ func (User) Edges() []ent.Edge {
 }
 
 func (User) Indexes() []ent.Index {
-	return []ent.Index{}
+	return []ent.Index{
+		index.Fields("id"),
+	}
 }
diff --git a/internal/database/ent/schema/user_connection.go b/internal/database/ent/schema/user_connection.go
index bc04fe6b..8b4a1a28 100644
--- a/internal/database/ent/schema/user_connection.go
+++ b/internal/database/ent/schema/user_connection.go
@@ -55,10 +55,11 @@ func (UserConnection) Edges() []ent.Edge {
 
 func (UserConnection) Indexes() []ent.Index {
 	return []ent.Index{
+		index.Fields("id"),
 		index.Fields("user_id"),
 		index.Fields("type", "user_id"),
 		index.Fields("reference_id"),
 		index.Fields("type", "reference_id"),
-		// index.Fields("reference_id").Edges("user").Unique(),
+		index.Fields("reference_id", "user_id", "type").Unique(),
 	}
 }
diff --git a/internal/database/ent/schema/user_content.go b/internal/database/ent/schema/user_content.go
index 9895f2b6..6cc371b0 100644
--- a/internal/database/ent/schema/user_content.go
+++ b/internal/database/ent/schema/user_content.go
@@ -35,6 +35,7 @@ func (UserContent) Edges() []ent.Edge {
 
 func (UserContent) Indexes() []ent.Index {
 	return []ent.Index{
+		index.Fields("id"),
 		index.Fields("user_id"),
 		index.Fields("type", "user_id"),
 		index.Fields("reference_id"),
diff --git a/internal/database/ent/schema/user_subscription.go b/internal/database/ent/schema/user_subscription.go
index b156bea2..ad0b5439 100644
--- a/internal/database/ent/schema/user_subscription.go
+++ b/internal/database/ent/schema/user_subscription.go
@@ -35,6 +35,7 @@ func (UserSubscription) Edges() []ent.Edge {
 
 func (UserSubscription) Indexes() []ent.Index {
 	return []ent.Index{
+		index.Fields("id"),
 		index.Fields("user_id"),
 		index.Fields("type", "user_id"),
 		index.Fields("expires_at"),
diff --git a/internal/database/ent/schema/vehicle.go b/internal/database/ent/schema/vehicle.go
index c66424b1..167259db 100644
--- a/internal/database/ent/schema/vehicle.go
+++ b/internal/database/ent/schema/vehicle.go
@@ -3,6 +3,7 @@ package schema
 import (
 	"entgo.io/ent"
 	"entgo.io/ent/schema/field"
+	"entgo.io/ent/schema/index"
 )
 
 // Vehicle holds the schema definition for the Vehicle entity.
@@ -37,5 +38,7 @@ func (Vehicle) Edges() []ent.Edge {
 }
 
 func (Vehicle) Indexes() []ent.Index {
-	return nil
+	return []ent.Index{
+		index.Fields("id"),
+	}
 }
diff --git a/internal/database/ent/schema/vehicle_average.go b/internal/database/ent/schema/vehicle_average.go
index eda545dd..57d1a05a 100644
--- a/internal/database/ent/schema/vehicle_average.go
+++ b/internal/database/ent/schema/vehicle_average.go
@@ -3,6 +3,7 @@ package schema
 import (
 	"entgo.io/ent"
 	"entgo.io/ent/schema/field"
+	"entgo.io/ent/schema/index"
 	"github.com/cufee/aftermath/internal/stats/frame"
 )
 
@@ -34,5 +35,7 @@ func (VehicleAverage) Edges() []ent.Edge {
 }
 
 func (VehicleAverage) Indexes() []ent.Index {
-	return nil
+	return []ent.Index{
+		index.Fields("id"),
+	}
 }
diff --git a/internal/database/ent/schema/vehicle_snapshot.go b/internal/database/ent/schema/vehicle_snapshot.go
index e8ee67e4..13fc124f 100644
--- a/internal/database/ent/schema/vehicle_snapshot.go
+++ b/internal/database/ent/schema/vehicle_snapshot.go
@@ -39,6 +39,7 @@ func (VehicleSnapshot) Edges() []ent.Edge {
 
 func (VehicleSnapshot) Indexes() []ent.Index {
 	return []ent.Index{
+		index.Fields("id"),
 		index.Fields("created_at"),
 		index.Fields("vehicle_id", "created_at"),
 		index.Fields("account_id", "created_at"),

From 41ad490de0ef47bdba4d8e440ff49d8acc95b4cf Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 10:43:32 -0400
Subject: [PATCH 108/341] split up migration image into stages

---
 Dockerfile.migrate | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/Dockerfile.migrate b/Dockerfile.migrate
index 77fb6709..20bf0a7e 100644
--- a/Dockerfile.migrate
+++ b/Dockerfile.migrate
@@ -1,10 +1,7 @@
-FROM golang:1.22.3-bookworm
+FROM golang:1.22.3-bookworm as builder
 
 WORKDIR /migrate
 
-# copy migrations and schema
-COPY ./internal/database/ent/migrate/migrations /migrations
-
 RUN git clone https://github.com/Cufee/atlas-libsql.git
 
 WORKDIR /migrate/atlas-libsql/cmd/atlas
@@ -13,4 +10,12 @@ RUN go mod download
 RUN go generate ./...
 RUN CGO_ENABLED=1 GOOS=linux go build -o /bin/atlas
 
+FROM scratch
+
+WORKDIR /migrations
+
+# copy migrations and binary
+COPY ./internal/database/ent/migrate/migrations /migrations
+COPY --from=builder /bin/atlas /bin/atlas
+
 ENTRYPOINT ["atlas", "migrate", "apply","--allow-dirty" ,"--dir" "file:///migrations", ,"--tx-mode" ,"all", "--url", "libsql+ws://0.0.0.0:8080"]

From 2738b5e2c2738ffe315bce0aaf720807c9543eb8 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 11:00:10 -0400
Subject: [PATCH 109/341] manually adding cache for faster builds

---
 Dockerfile         |  7 ++++---
 Dockerfile.migrate | 10 +++-------
 2 files changed, 7 insertions(+), 10 deletions(-)

diff --git a/Dockerfile b/Dockerfile
index f4d80704..6aadb593 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -2,13 +2,14 @@ FROM golang:1.22.3-alpine as builder
 
 WORKDIR /workspace
 
-COPY ./ ./
+COPY go.mod go.sum ./
+RUN --mount=type=cache,target=$GOPATH/pkg/mod go mod download
 
-RUN go mod download
+COPY ./ ./
 RUN go generate ./...
 
 # build a fully standalone binary with zero dependencies
-RUN CGO_ENABLED=0 GOOS=linux go build -o app .
+RUN --mount=type=cache,target=$GOPATH/pkg/mod CGO_ENABLED=0 GOOS=linux go build -o app .
 
 # Make a scratch container with required files and binary
 FROM scratch
diff --git a/Dockerfile.migrate b/Dockerfile.migrate
index 20bf0a7e..b5a3dc70 100644
--- a/Dockerfile.migrate
+++ b/Dockerfile.migrate
@@ -1,14 +1,10 @@
 FROM golang:1.22.3-bookworm as builder
 
 WORKDIR /migrate
+RUN --mount=type=cache,target=/migrate git clone https://github.com/Cufee/atlas-libsql.git . || git pull
 
-RUN git clone https://github.com/Cufee/atlas-libsql.git
-
-WORKDIR /migrate/atlas-libsql/cmd/atlas
-
-RUN go mod download
-RUN go generate ./...
-RUN CGO_ENABLED=1 GOOS=linux go build -o /bin/atlas
+WORKDIR /migrate/cmd/atlas
+RUN  --mount=type=cache,target=/migrate --mount=type=cache,target=$GOPATH/pkg/mod CGO_ENABLED=1 GOOS=linux go build -o /bin/atlas
 
 FROM scratch
 

From 55ba76b4fe139a8d46c357adca4d0c960bee5882 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 11:01:15 -0400
Subject: [PATCH 110/341] fixed copy path

---
 Dockerfile.migrate | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Dockerfile.migrate b/Dockerfile.migrate
index b5a3dc70..e79c8cb2 100644
--- a/Dockerfile.migrate
+++ b/Dockerfile.migrate
@@ -12,6 +12,6 @@ WORKDIR /migrations
 
 # copy migrations and binary
 COPY ./internal/database/ent/migrate/migrations /migrations
-COPY --from=builder /bin/atlas /bin/atlas
+COPY --from=builder /bin/atlas /bin/
 
 ENTRYPOINT ["atlas", "migrate", "apply","--allow-dirty" ,"--dir" "file:///migrations", ,"--tx-mode" ,"all", "--url", "libsql+ws://0.0.0.0:8080"]

From c984d0c533c9e32273cb70f04334d4b5bf300712 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 11:03:51 -0400
Subject: [PATCH 111/341] added cache for generate

---
 Dockerfile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Dockerfile b/Dockerfile
index 6aadb593..0ae63ee9 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -6,7 +6,7 @@ COPY go.mod go.sum ./
 RUN --mount=type=cache,target=$GOPATH/pkg/mod go mod download
 
 COPY ./ ./
-RUN go generate ./...
+RUN --mount=type=cache,target=$GOPATH/pkg/mod go generate ./...
 
 # build a fully standalone binary with zero dependencies
 RUN --mount=type=cache,target=$GOPATH/pkg/mod CGO_ENABLED=0 GOOS=linux go build -o app .

From b4527c8af43f9b36151f0645bae24718cd398fa7 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 11:10:53 -0400
Subject: [PATCH 112/341] fixed migration image

---
 Dockerfile.migrate | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Dockerfile.migrate b/Dockerfile.migrate
index e79c8cb2..11f076c3 100644
--- a/Dockerfile.migrate
+++ b/Dockerfile.migrate
@@ -6,7 +6,7 @@ RUN --mount=type=cache,target=/migrate git clone https://github.com/Cufee/atlas-
 WORKDIR /migrate/cmd/atlas
 RUN  --mount=type=cache,target=/migrate --mount=type=cache,target=$GOPATH/pkg/mod CGO_ENABLED=1 GOOS=linux go build -o /bin/atlas
 
-FROM scratch
+FROM golang:1.22.3-bookworm
 
 WORKDIR /migrations
 

From 79fab7a575b7349b2237c239718972b6b359ce69 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 11:18:18 -0400
Subject: [PATCH 113/341] added endpoint to restart tasks

---
 cmds/core/scheduler/cron.go                |  2 +-
 cmds/core/scheduler/workers.go             |  9 +++++----
 cmds/core/server/handlers/private/tasks.go | 15 +++++++++++++++
 main.go                                    |  8 ++++----
 4 files changed, 25 insertions(+), 9 deletions(-)
 create mode 100644 cmds/core/server/handlers/private/tasks.go

diff --git a/cmds/core/scheduler/cron.go b/cmds/core/scheduler/cron.go
index 144954f7..f17bccac 100644
--- a/cmds/core/scheduler/cron.go
+++ b/cmds/core/scheduler/cron.go
@@ -14,7 +14,7 @@ func (queue *Queue) StartCronJobsAsync() {
 	// Tasks
 	c.Cron("* * * * *").Do(RunTasksWorker(queue))
 	// some tasks might be stuck due to a panic or restart, restart them
-	c.Cron("0 * * * *").Do(RestartTasksWorker(queue))
+	c.Cron("0 * * * *").Do(RestartTasksWorker(queue.core))
 	c.Cron("0 5 * * *").Do(CreateCleanupTaskWorker(queue.core)) // delete expired documents
 
 	// Glossary - Do it around the same time WG releases game updates
diff --git a/cmds/core/scheduler/workers.go b/cmds/core/scheduler/workers.go
index 430fa2aa..69b76c10 100644
--- a/cmds/core/scheduler/workers.go
+++ b/cmds/core/scheduler/workers.go
@@ -80,15 +80,15 @@ func RunTasksWorker(queue *Queue) func() {
 	}
 }
 
-func RestartTasksWorker(queue *Queue) func() {
+func RestartTasksWorker(core core.Client) func() {
 	return func() {
 		ctx, cancel := context.WithTimeout(context.Background(), time.Second*15)
 		defer cancel()
 
-		staleTasks, err := queue.core.Database().GetStaleTasks(ctx, 100)
+		staleTasks, err := core.Database().GetStaleTasks(ctx, 100)
 		if err != nil {
 			if database.IsNotFound(err) {
-				log.Debug().Msg("no failed tasks to reschedule found")
+				log.Debug().Msg("no stale tasks found")
 				return
 			}
 			log.Err(err).Msg("failed to reschedule stale tasks")
@@ -97,6 +97,7 @@ func RestartTasksWorker(queue *Queue) func() {
 		log.Debug().Int("count", len(staleTasks)).Msg("fetched stale tasks from database")
 
 		if len(staleTasks) < 1 {
+			log.Debug().Msg("no stale tasks found")
 			return
 		}
 
@@ -108,7 +109,7 @@ func RestartTasksWorker(queue *Queue) func() {
 		}
 
 		log.Debug().Int("count", len(staleTasks)).Msg("updating stale tasks")
-		err = queue.core.Database().UpdateTasks(ctx, staleTasks...)
+		err = core.Database().UpdateTasks(ctx, staleTasks...)
 		if err != nil {
 			log.Err(err).Msg("failed to update stale tasks")
 			return
diff --git a/cmds/core/server/handlers/private/tasks.go b/cmds/core/server/handlers/private/tasks.go
new file mode 100644
index 00000000..1a520aa1
--- /dev/null
+++ b/cmds/core/server/handlers/private/tasks.go
@@ -0,0 +1,15 @@
+package private
+
+import (
+	"net/http"
+
+	"github.com/cufee/aftermath/cmds/core"
+	"github.com/cufee/aftermath/cmds/core/scheduler"
+)
+
+func RestartStaleTasks(client core.Client) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		scheduler.RestartTasksWorker(client)()
+		w.Write([]byte("stale tasks restarted"))
+	}
+}
diff --git a/main.go b/main.go
index ff1bb377..74e593d3 100644
--- a/main.go
+++ b/main.go
@@ -55,6 +55,10 @@ func main() {
 	if e := os.Getenv("PRIVATE_SERVER_ENABLED"); e == "true" {
 		port := os.Getenv("PRIVATE_SERVER_PORT")
 		servePrivate := server.NewServer(port, []server.Handler{
+			{
+				Path: "POST /tasks/restart",
+				Func: private.RestartStaleTasks(cacheCoreClient),
+			},
 			{
 				Path: "POST /accounts/import",
 				Func: private.LoadAccountsHandler(cacheCoreClient),
@@ -108,10 +112,6 @@ func startSchedulerFromEnvAsync(dbClient database.Client, wgClient wargaming.Cli
 	}()
 
 	queue.StartCronJobsAsync()
-	// Some tasks should run on startup
-	// scheduler.UpdateGlossaryWorker(coreClient)()
-	// scheduler.UpdateAveragesWorker(coreClient)()
-	// scheduler.CreateSessionTasksWorker(coreClient, "AS")()
 }
 
 func coreClientsFromEnv() (core.Client, core.Client) {

From 54182d90036fb9ee0248c842800e27c10bd83074 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 11:18:52 -0400
Subject: [PATCH 114/341] order of ops

---
 cmds/core/scheduler/workers.go | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/cmds/core/scheduler/workers.go b/cmds/core/scheduler/workers.go
index 69b76c10..50b6cce6 100644
--- a/cmds/core/scheduler/workers.go
+++ b/cmds/core/scheduler/workers.go
@@ -94,12 +94,11 @@ func RestartTasksWorker(core core.Client) func() {
 			log.Err(err).Msg("failed to reschedule stale tasks")
 			return
 		}
-		log.Debug().Int("count", len(staleTasks)).Msg("fetched stale tasks from database")
-
 		if len(staleTasks) < 1 {
 			log.Debug().Msg("no stale tasks found")
 			return
 		}
+		log.Debug().Int("count", len(staleTasks)).Msg("fetched stale tasks from database")
 
 		now := time.Now()
 		for i, task := range staleTasks {

From b8ae6a237af1228c945e7f8504a47badcee99a25 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 11:23:16 -0400
Subject: [PATCH 115/341] removed memory limit, bumped reservation

---
 docker-compose.yaml | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/docker-compose.yaml b/docker-compose.yaml
index c2fbd072..2030bc75 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -42,9 +42,7 @@ services:
     deploy:
       resources:
         reservations:
-          memory: 128m
-        limits:
-          memory: 256m
+          memory: 512m
     networks:
       - dokploy-network
     hostname: aftermath-service

From 99825ed3d52ab17ee9c431f6aff48063b3cb115b Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 12:05:20 -0400
Subject: [PATCH 116/341] properly passing args to goroutines

---
 cmds/core/server/handlers/private/accounts.go |  4 +--
 internal/database/accounts.go                 |  2 +-
 internal/database/snapshots.go                |  2 +-
 internal/logic/sessions.go                    | 21 ++++++++-----
 internal/stats/fetch/multisource.go           | 30 +++++++++++--------
 internal/stats/session.go                     |  6 ++--
 6 files changed, 37 insertions(+), 28 deletions(-)

diff --git a/cmds/core/server/handlers/private/accounts.go b/cmds/core/server/handlers/private/accounts.go
index f87e96a0..90ef4164 100644
--- a/cmds/core/server/handlers/private/accounts.go
+++ b/cmds/core/server/handlers/private/accounts.go
@@ -45,7 +45,7 @@ func LoadAccountsHandler(client core.Client) http.HandlerFunc {
 		w.Write([]byte(fmt.Sprintf("working on %d accounts", len(accounts)-len(existing))))
 		log.Info().Int("count", len(accounts)-len(existing)).Msg("importing accounts")
 
-		go func() {
+		go func(accounts []string, existing []models.Account) {
 			existingMap := make(map[string]struct{})
 			for _, a := range existing {
 				existingMap[a.ID] = struct{}{}
@@ -138,6 +138,6 @@ func LoadAccountsHandler(client core.Client) http.HandlerFunc {
 				event.Msg("some account imports failed")
 			}
 			log.Info().Int("count", len(accounts)-len(existing)).Msg("finished importing accounts")
-		}()
+		}(accounts, existing)
 	}
 }
diff --git a/internal/database/accounts.go b/internal/database/accounts.go
index bd1c0911..1bbc47f7 100644
--- a/internal/database/accounts.go
+++ b/internal/database/accounts.go
@@ -36,7 +36,7 @@ func (c *libsqlClient) GetRealmAccountIDs(ctx context.Context, realm string) ([]
 }
 
 func (c *libsqlClient) GetAccountByID(ctx context.Context, id string) (models.Account, error) {
-	result, err := c.db.Account.Query().Where(account.ID(id)).WithClan().Only(ctx)
+	result, err := c.db.Account.Query().Where(account.ID(id)).WithClan().First(ctx)
 	if err != nil {
 		return models.Account{}, err
 	}
diff --git a/internal/database/snapshots.go b/internal/database/snapshots.go
index 5539ca43..24905a1e 100644
--- a/internal/database/snapshots.go
+++ b/internal/database/snapshots.go
@@ -85,7 +85,7 @@ func (c *libsqlClient) GetVehicleSnapshots(ctx context.Context, accountID, refer
 	if query.createdAfter != nil {
 		where = append(where, vehiclesnapshot.CreatedAtGT(query.createdAfter.Unix()))
 	}
-	if query.createdAfter != nil {
+	if query.createdBefore != nil {
 		where = append(where, vehiclesnapshot.CreatedAtLT(query.createdBefore.Unix()))
 	}
 	if query.vehicleIDs != nil {
diff --git a/internal/logic/sessions.go b/internal/logic/sessions.go
index 36f17b94..c554f184 100644
--- a/internal/logic/sessions.go
+++ b/internal/logic/sessions.go
@@ -29,7 +29,7 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 		return nil, errors.Wrap(err, "failed to fetch accounts")
 	}
 
-	// existing snaphsots for accounts
+	// existing snapshots for accounts
 	existingSnapshots, err := dbClient.GetManyAccountSnapshots(ctx, accountIDs, models.SnapshotTypeDaily)
 	if err != nil && !database.IsNotFound(err) {
 		return nil, errors.Wrap(err, "failed to get existing snapshots")
@@ -40,7 +40,7 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 	}
 
 	// make a new slice just in case some accounts were not returned/are private
-	var validAccouts []string
+	var validAccounts []string
 	for _, id := range accountIDs {
 		data, ok := accounts[id]
 		if !ok {
@@ -63,24 +63,26 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 			// last snapshot is the same, we can skip it
 			continue
 		}
-		validAccouts = append(validAccouts, id)
+		validAccounts = append(validAccounts, id)
 	}
 
-	if len(validAccouts) == 0 {
+	println("validAccounts", len(validAccounts))
+
+	if len(validAccounts) < 1 {
 		return nil, nil
 	}
 
 	// clans are options-ish
-	clans, err := wgClient.BatchAccountClan(ctx, realm, validAccouts)
+	clans, err := wgClient.BatchAccountClan(ctx, realm, validAccounts)
 	if err != nil {
 		log.Err(err).Msg("failed to get batch account clans")
 		clans = make(map[string]types.ClanMember)
 	}
 
-	vehicleCh := make(chan retry.DataWithErr[vehicleResponseData], len(validAccouts))
+	vehicleCh := make(chan retry.DataWithErr[vehicleResponseData], len(validAccounts))
 	var group sync.WaitGroup
-	group.Add(len(validAccouts))
-	for _, id := range validAccouts {
+	group.Add(len(validAccounts))
+	for _, id := range validAccounts {
 		go func(id string) {
 			defer group.Done()
 			data, err := wgClient.AccountVehicles(ctx, realm, id)
@@ -161,11 +163,14 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 		}
 	}
 
+	println("account", len(snapshots))
+
 	err = dbClient.CreateAccountSnapshots(ctx, snapshots...)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to save account snapshots to database")
 	}
 
+	println("vehicles", len(vehicleSnapshots))
 	err = dbClient.CreateVehicleSnapshots(ctx, vehicleSnapshots...)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to save vehicle snapshots to database")
diff --git a/internal/stats/fetch/multisource.go b/internal/stats/fetch/multisource.go
index b8e700f3..92c3b7a9 100644
--- a/internal/stats/fetch/multisource.go
+++ b/internal/stats/fetch/multisource.go
@@ -85,8 +85,8 @@ func (c *multiSourceClient) Account(ctx context.Context, id string) (models.Acco
 	}
 
 	account := WargamingToAccount(realm, wgAccount.Data, clan, false)
-	go func() {
-		ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+	go func(account models.Account) {
+		ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 		defer cancel()
 
 		aErr, err := c.database.UpsertAccounts(ctx, []models.Account{account})
@@ -96,7 +96,7 @@ func (c *multiSourceClient) Account(ctx context.Context, id string) (models.Acco
 		if err := aErr[account.ID]; err != nil {
 			log.Err(err).Msg("failed to update account cache")
 		}
-	}()
+	}(account)
 
 	return account, nil
 }
@@ -171,18 +171,18 @@ func (c *multiSourceClient) CurrentStats(ctx context.Context, id string, opts ..
 		stats.AddWN8(averages.Data)
 	}
 
-	go func() {
+	go func(account models.Account) {
 		ctx, cancel := context.WithTimeout(context.Background(), time.Second)
 		defer cancel()
 
-		aErr, err := c.database.UpsertAccounts(ctx, []models.Account{stats.Account})
+		aErr, err := c.database.UpsertAccounts(ctx, []models.Account{account})
 		if err != nil {
 			log.Err(err).Msg("failed to update account cache")
 		}
-		if err := aErr[stats.Account.ID]; err != nil {
+		if err := aErr[account.ID]; err != nil {
 			log.Err(err).Msg("failed to update account cache")
 		}
-	}()
+	}(stats.Account)
 
 	return stats, nil
 }
@@ -313,6 +313,11 @@ func (c *multiSourceClient) SessionStats(ctx context.Context, id string, session
 		defer group.Done()
 		s, err := c.database.GetAccountSnapshot(ctx, id, id, models.SnapshotTypeDaily, database.WithCreatedBefore(sessionBefore))
 		accountSnapshot = retry.DataWithErr[models.AccountSnapshot]{Data: s, Err: err}
+	}()
+
+	group.Add(1)
+	go func() {
+		defer group.Done()
 		v, err := c.database.GetVehicleSnapshots(ctx, id, id, models.SnapshotTypeDaily, database.WithCreatedBefore(sessionBefore))
 		vehiclesSnapshots = retry.DataWithErr[[]models.VehicleSnapshot]{Data: v, Err: err}
 	}()
@@ -353,9 +358,9 @@ func (c *multiSourceClient) SessionStats(ctx context.Context, id string, session
 	career.RatingBattles.Vehicles = make(map[string]frame.VehicleStatsFrame, 0)
 	career.RegularBattles.Vehicles = make(map[string]frame.VehicleStatsFrame, len(vehiclesSnapshots.Data))
 
-	snapshotsMap := make(map[string]int, len(vehiclesSnapshots.Data))
-	for i, data := range vehiclesSnapshots.Data {
-		snapshotsMap[data.VehicleID] = i
+	snapshotsMap := make(map[string]*models.VehicleSnapshot, len(vehiclesSnapshots.Data))
+	for _, data := range vehiclesSnapshots.Data {
+		snapshotsMap[data.VehicleID] = &data
 
 		career.RegularBattles.Vehicles[data.VehicleID] = frame.VehicleStatsFrame{
 			LastBattleTime: data.LastBattleTime,
@@ -365,16 +370,15 @@ func (c *multiSourceClient) SessionStats(ctx context.Context, id string, session
 	}
 
 	for id, current := range current.Data.RegularBattles.Vehicles {
-		snapshotIndex, exists := snapshotsMap[id]
+		snapshot, exists := snapshotsMap[id]
 		if !exists {
 			session.RegularBattles.Vehicles[id] = current
 			continue
 		}
-
-		snapshot := vehiclesSnapshots.Data[snapshotIndex]
 		if current.Battles == 0 || current.Battles == snapshot.Stats.Battles {
 			continue
 		}
+
 		current.StatsFrame.Subtract(snapshot.Stats)
 		session.RegularBattles.Vehicles[id] = current
 	}
diff --git a/internal/stats/session.go b/internal/stats/session.go
index 22ac652a..f398291c 100644
--- a/internal/stats/session.go
+++ b/internal/stats/session.go
@@ -28,16 +28,16 @@ func (r *renderer) Session(ctx context.Context, accountId string, from time.Time
 			if err != nil {
 				return nil, meta, err
 			}
-			go func() {
+			go func(id string) {
 				// record a session in the background
 				ctx, cancel := context.WithTimeout(context.Background(), time.Second*15)
 				defer cancel()
 
-				_, err := logic.RecordAccountSnapshots(ctx, r.wargaming, r.database, r.wargaming.RealmFromAccountID(accountId), false, accountId)
+				_, err := logic.RecordAccountSnapshots(ctx, r.wargaming, r.database, r.wargaming.RealmFromAccountID(id), false, id)
 				if err != nil {
 					log.Err(err).Str("accountId", accountId).Msg("failed to record account snapshot")
 				}
-			}()
+			}(accountId)
 			return nil, meta, ErrAccountNotTracked
 		}
 		return nil, meta, err

From 221a1dd569683f2b5f4a91664bcf56a86ef6e56d Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 12:26:48 -0400
Subject: [PATCH 117/341] fixed snapshots queries

---
 cmds/discord/rest/client.go    |  1 -
 internal/database/snapshots.go | 13 +++++++++----
 internal/logic/sessions.go     |  5 -----
 internal/stats/session.go      |  2 +-
 4 files changed, 10 insertions(+), 11 deletions(-)

diff --git a/cmds/discord/rest/client.go b/cmds/discord/rest/client.go
index 730af69c..4307d565 100644
--- a/cmds/discord/rest/client.go
+++ b/cmds/discord/rest/client.go
@@ -130,7 +130,6 @@ func (c *Client) do(req *http.Request, target any) error {
 		if message == "" {
 			message = res.Status + ", response was not valid json"
 		}
-		println(string(data))
 
 		return errors.New("discord error: " + message)
 	}
diff --git a/internal/database/snapshots.go b/internal/database/snapshots.go
index 24905a1e..611af829 100644
--- a/internal/database/snapshots.go
+++ b/internal/database/snapshots.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"time"
 
+	"entgo.io/ent/dialect/sql"
 	"github.com/cufee/aftermath/internal/database/ent/db"
 	"github.com/cufee/aftermath/internal/database/ent/db/accountsnapshot"
 	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
@@ -82,7 +83,9 @@ func (c *libsqlClient) GetVehicleSnapshots(ctx context.Context, accountID, refer
 	where = append(where, vehiclesnapshot.ReferenceID(referenceID))
 	where = append(where, vehiclesnapshot.TypeEQ(kind))
 
+	order := vehiclesnapshot.ByCreatedAt(sql.OrderDesc())
 	if query.createdAfter != nil {
+		order = vehiclesnapshot.ByCreatedAt(sql.OrderAsc())
 		where = append(where, vehiclesnapshot.CreatedAtGT(query.createdAfter.Unix()))
 	}
 	if query.createdBefore != nil {
@@ -92,8 +95,8 @@ func (c *libsqlClient) GetVehicleSnapshots(ctx context.Context, accountID, refer
 		where = append(where, vehiclesnapshot.VehicleIDIn(query.vehicleIDs...))
 	}
 
-	var records []*db.VehicleSnapshot
-	err := c.db.VehicleSnapshot.Query().Where(where...).GroupBy(vehiclesnapshot.FieldVehicleID).Scan(ctx, &records)
+	var records db.VehicleSnapshots
+	err := c.db.VehicleSnapshot.Query().Where(where...).Order(order).GroupBy(vehiclesnapshot.FieldVehicleID).Aggregate(func(s *sql.Selector) string { return s.Select("*").String() }).Scan(ctx, &records)
 	if err != nil {
 		return nil, err
 	}
@@ -143,7 +146,7 @@ func (c *libsqlClient) CreateAccountSnapshots(ctx context.Context, snapshots ...
 }
 
 func (c *libsqlClient) GetLastAccountSnapshots(ctx context.Context, accountID string, limit int) ([]models.AccountSnapshot, error) {
-	records, err := c.db.AccountSnapshot.Query().Where(accountsnapshot.AccountID(accountID)).Limit(limit).All(ctx)
+	records, err := c.db.AccountSnapshot.Query().Where(accountsnapshot.AccountID(accountID)).Order(accountsnapshot.ByCreatedAt(sql.OrderDesc())).Limit(limit).All(ctx)
 	if err != nil {
 		return nil, err
 	}
@@ -163,15 +166,17 @@ func (c *libsqlClient) GetAccountSnapshot(ctx context.Context, accountID, refere
 	}
 
 	var where []predicate.AccountSnapshot
+	order := accountsnapshot.ByCreatedAt(sql.OrderDesc())
 	where = append(where, accountsnapshot.AccountID(accountID), accountsnapshot.ReferenceID(referenceID), accountsnapshot.TypeEQ(kind))
 	if query.createdAfter != nil {
+		order = accountsnapshot.ByCreatedAt(sql.OrderAsc())
 		where = append(where, accountsnapshot.CreatedAtGT(query.createdAfter.Unix()))
 	}
 	if query.createdBefore != nil {
 		where = append(where, accountsnapshot.CreatedAtLT(query.createdBefore.Unix()))
 	}
 
-	record, err := c.db.AccountSnapshot.Query().Where(where...).First(ctx)
+	record, err := c.db.AccountSnapshot.Query().Where(where...).Order(order).First(ctx)
 	if err != nil {
 		return models.AccountSnapshot{}, err
 	}
diff --git a/internal/logic/sessions.go b/internal/logic/sessions.go
index c554f184..b816cd8e 100644
--- a/internal/logic/sessions.go
+++ b/internal/logic/sessions.go
@@ -66,8 +66,6 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 		validAccounts = append(validAccounts, id)
 	}
 
-	println("validAccounts", len(validAccounts))
-
 	if len(validAccounts) < 1 {
 		return nil, nil
 	}
@@ -163,14 +161,11 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 		}
 	}
 
-	println("account", len(snapshots))
-
 	err = dbClient.CreateAccountSnapshots(ctx, snapshots...)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to save account snapshots to database")
 	}
 
-	println("vehicles", len(vehicleSnapshots))
 	err = dbClient.CreateVehicleSnapshots(ctx, vehicleSnapshots...)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to save vehicle snapshots to database")
diff --git a/internal/stats/session.go b/internal/stats/session.go
index f398291c..a4bfd6ed 100644
--- a/internal/stats/session.go
+++ b/internal/stats/session.go
@@ -35,7 +35,7 @@ func (r *renderer) Session(ctx context.Context, accountId string, from time.Time
 
 				_, err := logic.RecordAccountSnapshots(ctx, r.wargaming, r.database, r.wargaming.RealmFromAccountID(id), false, id)
 				if err != nil {
-					log.Err(err).Str("accountId", accountId).Msg("failed to record account snapshot")
+					log.Err(err).Str("accountId", id).Msg("failed to record account snapshot")
 				}
 			}(accountId)
 			return nil, meta, ErrAccountNotTracked

From 914d1d7f87bdcdb3ca56c3c04760968616e0c8e1 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 12:37:03 -0400
Subject: [PATCH 118/341] added panic recovery in tasks

---
 .env.example                 |  2 +-
 cmds/core/scheduler/queue.go | 17 ++++++++++++++---
 2 files changed, 15 insertions(+), 4 deletions(-)

diff --git a/.env.example b/.env.example
index cb24daea..247efc77 100644
--- a/.env.example
+++ b/.env.example
@@ -39,7 +39,7 @@ DISCORD_ERROR_REPORT_WEBHOOK_URL="" # A Discord webhook URL for a channel where
 
 # Optional components
 SCHEDULER_ENABLED="true" # Scheduler is responsible for refreshing glossary cache and recording sessions
-SCHEDULER_CONCURRENT_WORKERS="10" 
+SCHEDULER_CONCURRENT_WORKERS="5" 
 PRIVATE_SERVER_ENABLED="true" # A private server can be used to access some managemenet endpoints
 PRIVATE_SERVER_PORT="9093"
 
diff --git a/cmds/core/scheduler/queue.go b/cmds/core/scheduler/queue.go
index d0bd8c8d..669a3c9c 100644
--- a/cmds/core/scheduler/queue.go
+++ b/cmds/core/scheduler/queue.go
@@ -59,13 +59,24 @@ func (q *Queue) Process(callback func(error), tasks ...models.Task) {
 	for _, task := range tasks {
 		wg.Add(1)
 		go func(t models.Task) {
-			q.limiter <- struct{}{}
 			defer func() {
+				if r := recover(); r != nil {
+					log.Error().Any("recover", r).Msg("panic in task handler")
+					t.Status = models.TaskStatusFailed
+					t.LogAttempt(models.TaskLog{
+						Targets:   t.Targets,
+						Timestamp: time.Now(),
+						Error:     "task handler caused a panic",
+					})
+				} else {
+					log.Debug().Msgf("finished processing task %s", t.ID)
+				}
 				processedTasks <- t
-				wg.Done()
 				<-q.limiter
-				log.Debug().Msgf("finished processing task %s", t.ID)
+				wg.Done()
 			}()
+
+			q.limiter <- struct{}{}
 			log.Debug().Msgf("processing task %s", t.ID)
 
 			handler, ok := q.handlers[t.Type]

From e635b72a91fe07edbaefb3fb0fe57f9bb0d3c914 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 13:16:06 -0400
Subject: [PATCH 119/341] swapped to sqlite

---
 .env.example                         | 14 +++---------
 Dockerfile.migrate                   | 16 ++------------
 Taskfile.yaml                        | 10 +--------
 docker-compose.yaml                  | 33 +++++++++-------------------
 internal/database/accounts.go        | 10 ++++-----
 internal/database/averages.go        |  4 ++--
 internal/database/cleanup.go         |  4 ++--
 internal/database/client.go          | 22 ++++++++-----------
 internal/database/discord.go         |  6 ++---
 internal/database/ent/schema/clan.go | 18 ---------------
 internal/database/snapshots.go       | 12 +++++-----
 internal/database/tasks.go           | 12 +++++-----
 internal/database/users.go           | 12 +++++-----
 internal/database/vehicles.go        |  4 ++--
 main.go                              |  2 +-
 15 files changed, 58 insertions(+), 121 deletions(-)

diff --git a/.env.example b/.env.example
index 247efc77..f49d5131 100644
--- a/.env.example
+++ b/.env.example
@@ -1,15 +1,5 @@
-# Atlas is currently broken for libsql
-# You need to clone and build https://github.com/Cufee/atlas-libsql
-ATLAS_TEMP_DIR="path/to/atlas-libsql/cmd/atlas/binary"
-
-# This is not required for local deployment. When deploying with Dokploy, this is the domain aftermath service will be available on.
-TRAEFIK_HOST="local.amth.one"
-
 # Path for a bind volume when running with compose
-DATABASE_DIR="tmp/"
-# URL to a libsql instance
-# https://github.com/tursodatabase/libsql/blob/main/docs/DOCKER.md
-DATABASE_URL="libsql://0.0.0.0:8080?tls=0"
+DATABASE_PATH="tmp/deb_local.db"
 
 # Init
 INIT_GLOBAL_ADMIN_USER="" # Discord user ID for a user who will be assigned permissions.GlobalAdmin on startup, can be left blank
@@ -44,6 +34,8 @@ PRIVATE_SERVER_ENABLED="true" # A private server can be used to access some mana
 PRIVATE_SERVER_PORT="9093"
 
 # Misc configuration
+# This is not required for local deployment using compose. When deploying with Dokploy, this is the domain aftermath service will be available on.
+TRAEFIK_HOST="local.amth.one"
 LOG_LEVEL="debug"
 NETWORK="tcp"
 PORT="9092"
diff --git a/Dockerfile.migrate b/Dockerfile.migrate
index 11f076c3..701982ba 100644
--- a/Dockerfile.migrate
+++ b/Dockerfile.migrate
@@ -1,17 +1,5 @@
-FROM golang:1.22.3-bookworm as builder
+FROM arigaio/atlas:latest
 
-WORKDIR /migrate
-RUN --mount=type=cache,target=/migrate git clone https://github.com/Cufee/atlas-libsql.git . || git pull
-
-WORKDIR /migrate/cmd/atlas
-RUN  --mount=type=cache,target=/migrate --mount=type=cache,target=$GOPATH/pkg/mod CGO_ENABLED=1 GOOS=linux go build -o /bin/atlas
-
-FROM golang:1.22.3-bookworm
-
-WORKDIR /migrations
-
-# copy migrations and binary
 COPY ./internal/database/ent/migrate/migrations /migrations
-COPY --from=builder /bin/atlas /bin/
 
-ENTRYPOINT ["atlas", "migrate", "apply","--allow-dirty" ,"--dir" "file:///migrations", ,"--tx-mode" ,"all", "--url", "libsql+ws://0.0.0.0:8080"]
+ENTRYPOINT ["atlas", "migrate", "apply","--allow-dirty" ,"--dir" "file:///migrations", ,"--tx-mode" ,"all", "--url", "sqlite:///database.db?_fk=1"]
diff --git a/Taskfile.yaml b/Taskfile.yaml
index b36ae7ec..3d6889d7 100644
--- a/Taskfile.yaml
+++ b/Taskfile.yaml
@@ -3,10 +3,6 @@ version: "3"
 dotenv:
   - ".env"
 
-vars:
-  ENT_CMD: go run -mod=mod entgo.io/ent/cmd/ent
-  ENT_DIRECTORY: internal/database/ent/schema
-
 tasks:
   test:
     desc: runs tests
@@ -19,10 +15,6 @@ tasks:
           go test -timeout 30s --count=1 -v -run {{ .CLI_ARGS }}
         fi
 
-  ent-new:
-    desc: init a new schema with a given name
-    cmd: '{{.ENT_CMD}} new --target {{.ENT_DIRECTORY}} {{.CLI_ARGS}}'
-
   ent-generate:
     desc: generate go code for the ent schema directory
     cmd: go generate internal/database/ent
@@ -32,7 +24,7 @@ tasks:
     cmd: atlas migrate hash --dir "file://internal/database/ent/migrate/migrations" && atlas migrate diff {{.CLI_ARGS}} --dir "file://internal/database/ent/migrate/migrations" --to "ent://internal/database/ent/schema" --dev-url "sqlite://file?mode=memory&_fk=1"
   db-migrate-apply:
     desc: apply migrations using atlas
-    cmd: ${ATLAS_TEMP_DIR} migrate apply --allow-dirty --dir "file://internal/database/ent/migrate/migrations" --tx-mode all --url "libsql+ws://0.0.0.0:8080"
+    cmd: atlas migrate apply --allow-dirty --dir "file://internal/database/ent/migrate/migrations" --tx-mode all --url "sqlite://${DATABASE_PATH}?_fk=1"
 
   dev:
     desc: Start a local dev server
diff --git a/docker-compose.yaml b/docker-compose.yaml
index 2030bc75..f9c25702 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -1,43 +1,30 @@
 services:
-  aftermath-database:
-    user: root
-    image: ghcr.io/tursodatabase/libsql-server:latest
-    platform: linux/amd64
-    restart: always
-    environment:
-      - SQLD_NODE=primary
-    volumes:
-      - ${DATABASE_DIR}:/var/lib/sqld
-    networks:
-      - dokploy-network
-    hostname: aftermath-database
-
   aftermath-migrate:
     image: aftermath-migrate
     build:
       dockerfile: Dockerfile.migrate
-    depends_on:
-      aftermath-database:
-        condition: service_started
-    entrypoint: atlas migrate apply --allow-dirty --dir "file:///migrations" --tx-mode all --url "libsql+ws://aftermath-database:8080"
+    entrypoint: atlas migrate apply --allow-dirty --dir "file:///migrations" --tx-mode all --url "sqlite:///data/aftermath.db?_fk=1"
+    volumes:
+      - ${DATABASE_PATH}:/data/aftermath.db
     networks:
       - dokploy-network
 
   aftermath-service:
-    image: aftermath-service
-    build:
-      dockerfile: Dockerfile
     env_file:
       - .env
     environment:
       - PORT=3000
-      - DATABASE_URL=libsql://aftermath-database:8080?tls=0
+      - DATABASE_PATH=sqlite:///data/aftermath.db?_fk=1
     depends_on:
-      aftermath-database:
-        condition: service_started
       aftermath-migrate:
         condition: service_completed_successfully
     entrypoint: ["app"]
+    volumes:
+      - ${DATABASE_PATH}:/data/aftermath.db
+
+    image: aftermath-service
+    build:
+      dockerfile: Dockerfile
     restart: always
     deploy:
       resources:
diff --git a/internal/database/accounts.go b/internal/database/accounts.go
index 1bbc47f7..ee9007d5 100644
--- a/internal/database/accounts.go
+++ b/internal/database/accounts.go
@@ -26,7 +26,7 @@ func toAccount(model *db.Account) models.Account {
 	return account
 }
 
-func (c *libsqlClient) GetRealmAccountIDs(ctx context.Context, realm string) ([]string, error) {
+func (c *client) GetRealmAccountIDs(ctx context.Context, realm string) ([]string, error) {
 	result, err := c.db.Account.Query().Where(account.Realm(strings.ToUpper(realm))).IDs(ctx)
 	if err != nil {
 		return nil, err
@@ -35,7 +35,7 @@ func (c *libsqlClient) GetRealmAccountIDs(ctx context.Context, realm string) ([]
 	return result, nil
 }
 
-func (c *libsqlClient) GetAccountByID(ctx context.Context, id string) (models.Account, error) {
+func (c *client) GetAccountByID(ctx context.Context, id string) (models.Account, error) {
 	result, err := c.db.Account.Query().Where(account.ID(id)).WithClan().First(ctx)
 	if err != nil {
 		return models.Account{}, err
@@ -43,7 +43,7 @@ func (c *libsqlClient) GetAccountByID(ctx context.Context, id string) (models.Ac
 	return toAccount(result), nil
 }
 
-func (c *libsqlClient) GetAccounts(ctx context.Context, ids []string) ([]models.Account, error) {
+func (c *client) GetAccounts(ctx context.Context, ids []string) ([]models.Account, error) {
 	if len(ids) < 1 {
 		return nil, nil
 	}
@@ -61,7 +61,7 @@ func (c *libsqlClient) GetAccounts(ctx context.Context, ids []string) ([]models.
 	return accounts, nil
 }
 
-func (c *libsqlClient) UpsertAccounts(ctx context.Context, accounts []models.Account) (map[string]error, error) {
+func (c *client) UpsertAccounts(ctx context.Context, accounts []models.Account) (map[string]error, error) {
 	if len(accounts) < 1 {
 		return nil, nil
 	}
@@ -113,7 +113,7 @@ func (c *libsqlClient) UpsertAccounts(ctx context.Context, accounts []models.Acc
 	return errors, c.db.Account.CreateBulk(writes...).Exec(ctx)
 }
 
-func (c *libsqlClient) AccountSetPrivate(ctx context.Context, id string, value bool) error {
+func (c *client) AccountSetPrivate(ctx context.Context, id string, value bool) error {
 	err := c.db.Account.UpdateOneID(id).SetPrivate(value).Exec(ctx)
 	if err != nil {
 		return err
diff --git a/internal/database/averages.go b/internal/database/averages.go
index fe183062..e643beb4 100644
--- a/internal/database/averages.go
+++ b/internal/database/averages.go
@@ -8,7 +8,7 @@ import (
 	"github.com/cufee/aftermath/internal/stats/frame"
 )
 
-func (c *libsqlClient) UpsertVehicleAverages(ctx context.Context, averages map[string]frame.StatsFrame) (map[string]error, error) {
+func (c *client) UpsertVehicleAverages(ctx context.Context, averages map[string]frame.StatsFrame) (map[string]error, error) {
 	if len(averages) < 1 {
 		return nil, nil
 	}
@@ -49,7 +49,7 @@ func (c *libsqlClient) UpsertVehicleAverages(ctx context.Context, averages map[s
 	return errors, c.db.VehicleAverage.CreateBulk(writes...).Exec(ctx)
 }
 
-func (c *libsqlClient) GetVehicleAverages(ctx context.Context, ids []string) (map[string]frame.StatsFrame, error) {
+func (c *client) GetVehicleAverages(ctx context.Context, ids []string) (map[string]frame.StatsFrame, error) {
 	if len(ids) < 1 {
 		return nil, nil
 	}
diff --git a/internal/database/cleanup.go b/internal/database/cleanup.go
index fc2bf367..4340f281 100644
--- a/internal/database/cleanup.go
+++ b/internal/database/cleanup.go
@@ -10,7 +10,7 @@ import (
 	"github.com/cufee/aftermath/internal/database/ent/db/vehiclesnapshot"
 )
 
-func (c *libsqlClient) DeleteExpiredTasks(ctx context.Context, expiration time.Time) error {
+func (c *client) DeleteExpiredTasks(ctx context.Context, expiration time.Time) error {
 	tx, cancel, err := c.txWithLock(ctx)
 	if err != nil {
 		return err
@@ -24,7 +24,7 @@ func (c *libsqlClient) DeleteExpiredTasks(ctx context.Context, expiration time.T
 	return tx.Commit()
 }
 
-func (c *libsqlClient) DeleteExpiredSnapshots(ctx context.Context, expiration time.Time) error {
+func (c *client) DeleteExpiredSnapshots(ctx context.Context, expiration time.Time) error {
 	_, err := c.db.AccountSnapshot.Delete().Where(accountsnapshot.CreatedAtLT(expiration.Unix())).Exec(ctx)
 	if err != nil {
 		return err
diff --git a/internal/database/client.go b/internal/database/client.go
index 16fe9700..f2cc1c77 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -2,7 +2,6 @@ package database
 
 import (
 	"context"
-	"database/sql"
 	"fmt"
 	"sync"
 	"time"
@@ -12,12 +11,10 @@ import (
 	"github.com/cufee/aftermath/internal/permissions"
 	"github.com/cufee/aftermath/internal/stats/frame"
 
-	"entgo.io/ent/dialect"
-	entsql "entgo.io/ent/dialect/sql"
-	_ "github.com/tursodatabase/libsql-client-go/libsql"
+	_ "github.com/mattn/go-sqlite3"
 )
 
-var _ Client = &libsqlClient{}
+var _ Client = &client{}
 
 type AccountsClient interface {
 	GetAccounts(ctx context.Context, ids []string) ([]models.Account, error)
@@ -87,16 +84,16 @@ type Client interface {
 	Disconnect() error
 }
 
-type libsqlClient struct {
+type client struct {
 	db              *db.Client
 	transactionLock *sync.Mutex
 }
 
-func (c *libsqlClient) Disconnect() error {
+func (c *client) Disconnect() error {
 	return c.db.Close()
 }
 
-func (c *libsqlClient) txWithLock(ctx context.Context) (*db.Tx, func(), error) {
+func (c *client) txWithLock(ctx context.Context) (*db.Tx, func(), error) {
 	c.transactionLock.Lock()
 	tx, err := c.db.Tx(ctx)
 	if err != nil {
@@ -106,16 +103,15 @@ func (c *libsqlClient) txWithLock(ctx context.Context) (*db.Tx, func(), error) {
 	return tx, c.transactionLock.Unlock, nil
 }
 
-func NewLibSQLClient(primaryUrl string) (*libsqlClient, error) {
-	driver, err := sql.Open("libsql", primaryUrl)
+func NewSQLiteClient(filePath string) (*client, error) {
+	c, err := db.Open("sqlite3", fmt.Sprintf("file:%s?cache=shared&_fk=1", filePath))
 	if err != nil {
 		return nil, err
 	}
 
-	dbClient := db.NewClient(db.Driver(entsql.OpenDB(dialect.SQLite, driver)))
-	return &libsqlClient{
+	return &client{
 		transactionLock: &sync.Mutex{},
-		db:              dbClient,
+		db:              c,
 	}, nil
 }
 
diff --git a/internal/database/discord.go b/internal/database/discord.go
index 783b2ff0..c78498ee 100644
--- a/internal/database/discord.go
+++ b/internal/database/discord.go
@@ -18,7 +18,7 @@ func toApplicationCommand(record *db.ApplicationCommand) models.ApplicationComma
 
 }
 
-func (c *libsqlClient) GetCommandsByID(ctx context.Context, commandIDs ...string) ([]models.ApplicationCommand, error) {
+func (c *client) GetCommandsByID(ctx context.Context, commandIDs ...string) ([]models.ApplicationCommand, error) {
 	if len(commandIDs) < 1 {
 		return nil, nil
 	}
@@ -35,7 +35,7 @@ func (c *libsqlClient) GetCommandsByID(ctx context.Context, commandIDs ...string
 	return commands, nil
 }
 
-func (c *libsqlClient) GetCommandsByHash(ctx context.Context, commandHashes ...string) ([]models.ApplicationCommand, error) {
+func (c *client) GetCommandsByHash(ctx context.Context, commandHashes ...string) ([]models.ApplicationCommand, error) {
 	if len(commandHashes) < 1 {
 		return nil, nil
 	}
@@ -51,7 +51,7 @@ func (c *libsqlClient) GetCommandsByHash(ctx context.Context, commandHashes ...s
 	return commands, nil
 }
 
-func (c *libsqlClient) UpsertCommands(ctx context.Context, commands ...models.ApplicationCommand) error {
+func (c *client) UpsertCommands(ctx context.Context, commands ...models.ApplicationCommand) error {
 	if len(commands) < 1 {
 		return nil
 	}
diff --git a/internal/database/ent/schema/clan.go b/internal/database/ent/schema/clan.go
index 6ff58d0f..0aa605e3 100644
--- a/internal/database/ent/schema/clan.go
+++ b/internal/database/ent/schema/clan.go
@@ -7,24 +7,6 @@ import (
 	"entgo.io/ent/schema/index"
 )
 
-// model Clan {
-//   id        String   @id
-//   createdAt DateTime
-//   updatedAt DateTime @updatedAt
-
-//   tag      String
-//   name     String
-//   emblemId String @default("")
-
-//   accounts      Account[]
-//   membersString String
-
-//   recordUpdatedAt DateTime @updatedAt
-
-//   @@index([tag])
-//   @@map("account_clans")
-// }
-
 // Clan holds the schema definition for the Clan entity.
 type Clan struct {
 	ent.Schema
diff --git a/internal/database/snapshots.go b/internal/database/snapshots.go
index 611af829..88cb5465 100644
--- a/internal/database/snapshots.go
+++ b/internal/database/snapshots.go
@@ -50,7 +50,7 @@ func toVehicleSnapshot(record *db.VehicleSnapshot) models.VehicleSnapshot {
 	}
 }
 
-func (c *libsqlClient) CreateVehicleSnapshots(ctx context.Context, snapshots ...models.VehicleSnapshot) error {
+func (c *client) CreateVehicleSnapshots(ctx context.Context, snapshots ...models.VehicleSnapshot) error {
 	if len(snapshots) < 1 {
 		return nil
 	}
@@ -72,7 +72,7 @@ func (c *libsqlClient) CreateVehicleSnapshots(ctx context.Context, snapshots ...
 	return c.db.VehicleSnapshot.CreateBulk(inserts...).Exec(ctx)
 }
 
-func (c *libsqlClient) GetVehicleSnapshots(ctx context.Context, accountID, referenceID string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.VehicleSnapshot, error) {
+func (c *client) GetVehicleSnapshots(ctx context.Context, accountID, referenceID string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.VehicleSnapshot, error) {
 	var query getSnapshotQuery
 	for _, apply := range options {
 		apply(&query)
@@ -121,7 +121,7 @@ func toAccountSnapshot(record *db.AccountSnapshot) models.AccountSnapshot {
 	}
 }
 
-func (c *libsqlClient) CreateAccountSnapshots(ctx context.Context, snapshots ...models.AccountSnapshot) error {
+func (c *client) CreateAccountSnapshots(ctx context.Context, snapshots ...models.AccountSnapshot) error {
 	if len(snapshots) < 1 {
 		return nil
 	}
@@ -145,7 +145,7 @@ func (c *libsqlClient) CreateAccountSnapshots(ctx context.Context, snapshots ...
 	return c.db.AccountSnapshot.CreateBulk(inserts...).Exec(ctx)
 }
 
-func (c *libsqlClient) GetLastAccountSnapshots(ctx context.Context, accountID string, limit int) ([]models.AccountSnapshot, error) {
+func (c *client) GetLastAccountSnapshots(ctx context.Context, accountID string, limit int) ([]models.AccountSnapshot, error) {
 	records, err := c.db.AccountSnapshot.Query().Where(accountsnapshot.AccountID(accountID)).Order(accountsnapshot.ByCreatedAt(sql.OrderDesc())).Limit(limit).All(ctx)
 	if err != nil {
 		return nil, err
@@ -159,7 +159,7 @@ func (c *libsqlClient) GetLastAccountSnapshots(ctx context.Context, accountID st
 	return snapshots, nil
 }
 
-func (c *libsqlClient) GetAccountSnapshot(ctx context.Context, accountID, referenceID string, kind models.SnapshotType, options ...SnapshotQuery) (models.AccountSnapshot, error) {
+func (c *client) GetAccountSnapshot(ctx context.Context, accountID, referenceID string, kind models.SnapshotType, options ...SnapshotQuery) (models.AccountSnapshot, error) {
 	var query getSnapshotQuery
 	for _, apply := range options {
 		apply(&query)
@@ -184,7 +184,7 @@ func (c *libsqlClient) GetAccountSnapshot(ctx context.Context, accountID, refere
 	return toAccountSnapshot(record), nil
 }
 
-func (c *libsqlClient) GetManyAccountSnapshots(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.AccountSnapshot, error) {
+func (c *client) GetManyAccountSnapshots(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.AccountSnapshot, error) {
 	var query getSnapshotQuery
 	for _, apply := range options {
 		apply(&query)
diff --git a/internal/database/tasks.go b/internal/database/tasks.go
index adbbec47..56de971a 100644
--- a/internal/database/tasks.go
+++ b/internal/database/tasks.go
@@ -30,7 +30,7 @@ func toCronTask(record *db.CronTask) models.Task {
 /*
 Returns up limit tasks that have TaskStatusInProgress and were last updates 1+ hours ago
 */
-func (c *libsqlClient) GetStaleTasks(ctx context.Context, limit int) ([]models.Task, error) {
+func (c *client) GetStaleTasks(ctx context.Context, limit int) ([]models.Task, error) {
 	records, err := c.db.CronTask.Query().
 		Where(
 			crontask.StatusEQ(models.TaskStatusInProgress),
@@ -54,7 +54,7 @@ func (c *libsqlClient) GetStaleTasks(ctx context.Context, limit int) ([]models.T
 /*
 Returns all tasks that were created after createdAfter, sorted by ScheduledAfter (DESC)
 */
-func (c *libsqlClient) GetRecentTasks(ctx context.Context, createdAfter time.Time, status ...models.TaskStatus) ([]models.Task, error) {
+func (c *client) GetRecentTasks(ctx context.Context, createdAfter time.Time, status ...models.TaskStatus) ([]models.Task, error) {
 	var where []predicate.CronTask
 	where = append(where, crontask.CreatedAtGT(createdAfter.Unix()))
 	if len(status) > 0 {
@@ -77,7 +77,7 @@ func (c *libsqlClient) GetRecentTasks(ctx context.Context, createdAfter time.Tim
 /*
 GetAndStartTasks retrieves up to limit number of tasks matching the referenceId and updates their status to in progress
 */
-func (c *libsqlClient) GetAndStartTasks(ctx context.Context, limit int) ([]models.Task, error) {
+func (c *client) GetAndStartTasks(ctx context.Context, limit int) ([]models.Task, error) {
 	if limit < 1 {
 		return nil, nil
 	}
@@ -111,7 +111,7 @@ func (c *libsqlClient) GetAndStartTasks(ctx context.Context, limit int) ([]model
 	return tasks, tx.Commit()
 }
 
-func (c *libsqlClient) CreateTasks(ctx context.Context, tasks ...models.Task) error {
+func (c *client) CreateTasks(ctx context.Context, tasks ...models.Task) error {
 	if len(tasks) < 1 {
 		return nil
 	}
@@ -142,7 +142,7 @@ UpdateTasks will update all tasks passed in
   - the following fields will be replaced: targets, status, leastRun, scheduleAfterm logs, data
   - this func will block until all other calls to task update funcs are done
 */
-func (c *libsqlClient) UpdateTasks(ctx context.Context, tasks ...models.Task) error {
+func (c *client) UpdateTasks(ctx context.Context, tasks ...models.Task) error {
 	if len(tasks) < 1 {
 		return nil
 	}
@@ -177,7 +177,7 @@ func (c *libsqlClient) UpdateTasks(ctx context.Context, tasks ...models.Task) er
 DeleteTasks will delete all tasks matching by ids
   - this func will block until all other calls to task update funcs are done
 */
-func (c *libsqlClient) DeleteTasks(ctx context.Context, ids ...string) error {
+func (c *client) DeleteTasks(ctx context.Context, ids ...string) error {
 	if len(ids) < 1 {
 		return nil
 	}
diff --git a/internal/database/users.go b/internal/database/users.go
index 79563d63..e044b34e 100644
--- a/internal/database/users.go
+++ b/internal/database/users.go
@@ -88,7 +88,7 @@ func WithContent() userGetOption {
 Gets or creates a user with specified ID
   - assumes the ID is valid
 */
-func (c *libsqlClient) GetOrCreateUserByID(ctx context.Context, id string, opts ...userGetOption) (models.User, error) {
+func (c *client) GetOrCreateUserByID(ctx context.Context, id string, opts ...userGetOption) (models.User, error) {
 	user, err := c.GetUserByID(ctx, id, opts...)
 	if err != nil && !IsNotFound(err) {
 		return models.User{}, err
@@ -109,7 +109,7 @@ func (c *libsqlClient) GetOrCreateUserByID(ctx context.Context, id string, opts
 Gets a user with specified ID
   - assumes the ID is valid
 */
-func (c *libsqlClient) GetUserByID(ctx context.Context, id string, opts ...userGetOption) (models.User, error) {
+func (c *client) GetUserByID(ctx context.Context, id string, opts ...userGetOption) (models.User, error) {
 	var options userGetOpts
 	for _, apply := range opts {
 		apply(&options)
@@ -134,7 +134,7 @@ func (c *libsqlClient) GetUserByID(ctx context.Context, id string, opts ...userG
 	return toUser(record, record.Edges.Connections, record.Edges.Subscriptions, record.Edges.Content), nil
 }
 
-func (c *libsqlClient) UpsertUserWithPermissions(ctx context.Context, userID string, perms permissions.Permissions) (models.User, error) {
+func (c *client) UpsertUserWithPermissions(ctx context.Context, userID string, perms permissions.Permissions) (models.User, error) {
 	record, err := c.db.User.UpdateOneID(userID).SetPermissions(perms.String()).Save(ctx)
 	if err != nil && !IsNotFound(err) {
 		return models.User{}, err
@@ -150,7 +150,7 @@ func (c *libsqlClient) UpsertUserWithPermissions(ctx context.Context, userID str
 	return toUser(record, nil, nil, nil), nil
 }
 
-func (c *libsqlClient) CreateConnection(ctx context.Context, connection models.UserConnection) (models.UserConnection, error) {
+func (c *client) CreateConnection(ctx context.Context, connection models.UserConnection) (models.UserConnection, error) {
 	record, err := c.db.UserConnection.Create().
 		SetUser(c.db.User.GetX(ctx, connection.UserID)).
 		SetPermissions(connection.Permissions.String()).
@@ -164,7 +164,7 @@ func (c *libsqlClient) CreateConnection(ctx context.Context, connection models.U
 	return toUserConnection(record), err
 }
 
-func (c *libsqlClient) UpdateConnection(ctx context.Context, connection models.UserConnection) (models.UserConnection, error) {
+func (c *client) UpdateConnection(ctx context.Context, connection models.UserConnection) (models.UserConnection, error) {
 	record, err := c.db.UserConnection.UpdateOneID(connection.ID).
 		SetMetadata(connection.Metadata).
 		SetPermissions(connection.Permissions.String()).
@@ -177,7 +177,7 @@ func (c *libsqlClient) UpdateConnection(ctx context.Context, connection models.U
 	return toUserConnection(record), err
 }
 
-func (c *libsqlClient) UpsertConnection(ctx context.Context, connection models.UserConnection) (models.UserConnection, error) {
+func (c *client) UpsertConnection(ctx context.Context, connection models.UserConnection) (models.UserConnection, error) {
 	if connection.ID == "" {
 		return c.CreateConnection(ctx, connection)
 	}
diff --git a/internal/database/vehicles.go b/internal/database/vehicles.go
index 317c4b2a..dde1c3b3 100644
--- a/internal/database/vehicles.go
+++ b/internal/database/vehicles.go
@@ -16,7 +16,7 @@ func toVehicle(record *db.Vehicle) models.Vehicle {
 	}
 }
 
-func (c *libsqlClient) UpsertVehicles(ctx context.Context, vehicles map[string]models.Vehicle) (map[string]error, error) {
+func (c *client) UpsertVehicles(ctx context.Context, vehicles map[string]models.Vehicle) (map[string]error, error) {
 	if len(vehicles) < 1 {
 		return nil, nil
 	}
@@ -61,7 +61,7 @@ func (c *libsqlClient) UpsertVehicles(ctx context.Context, vehicles map[string]m
 	return errors, c.db.Vehicle.CreateBulk(writes...).Exec(ctx)
 }
 
-func (c *libsqlClient) GetVehicles(ctx context.Context, ids []string) (map[string]models.Vehicle, error) {
+func (c *client) GetVehicles(ctx context.Context, ids []string) (map[string]models.Vehicle, error) {
 	if len(ids) < 1 {
 		return nil, nil
 	}
diff --git a/main.go b/main.go
index 74e593d3..25fbfc3d 100644
--- a/main.go
+++ b/main.go
@@ -116,7 +116,7 @@ func startSchedulerFromEnvAsync(dbClient database.Client, wgClient wargaming.Cli
 
 func coreClientsFromEnv() (core.Client, core.Client) {
 	// Dependencies
-	dbClient, err := database.NewLibSQLClient(os.Getenv("DATABASE_URL"))
+	dbClient, err := database.NewSQLiteClient(os.Getenv("DATABASE_PATH"))
 	if err != nil {
 		log.Fatal().Msgf("database#NewClient failed %s", err)
 	}

From 8248e9471a83f19f84ae95088540b9b4f6f439de Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 13:16:38 -0400
Subject: [PATCH 120/341] tidy

---
 go.mod |  2 +-
 go.sum | 12 ------------
 2 files changed, 1 insertion(+), 13 deletions(-)

diff --git a/go.mod b/go.mod
index 330fc17a..bf5fd037 100644
--- a/go.mod
+++ b/go.mod
@@ -13,6 +13,7 @@ require (
 	github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0
 	github.com/joho/godotenv v1.5.1
 	github.com/lucsky/cuid v1.2.1
+	github.com/mattn/go-sqlite3 v1.14.22
 	github.com/nlpodyssey/gopickle v0.3.0
 	github.com/pkg/errors v0.9.1
 	github.com/rs/zerolog v1.33.0
@@ -39,7 +40,6 @@ require (
 	github.com/libsql/sqlite-antlr4-parser v0.0.0-20240327125255-dbf53b6cbf06 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
-	github.com/mattn/go-sqlite3 v1.14.22 // indirect
 	github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/robfig/cron/v3 v3.0.1 // indirect
diff --git a/go.sum b/go.sum
index 844c602f..24ee26f5 100644
--- a/go.sum
+++ b/go.sum
@@ -67,23 +67,17 @@ github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/
 github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
-github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/mattn/go-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o4kU=
 github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
 github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7 h1:DpOJ2HYzCv8LZP15IdmG+YdwD2luVPHITV96TkirNBM=
 github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7/go.mod h1:ZXFpozHsX6DPmq2I0TCekCxypsnAUbP2oI0UX1GXzOo=
 github.com/nlpodyssey/gopickle v0.3.0 h1:BLUE5gxFLyyNOPzlXxt6GoHEMMxD0qhsE4p0CIQyoLw=
 github.com/nlpodyssey/gopickle v0.3.0/go.mod h1:f070HJ/yR+eLi5WmM1OXJEGaTpuJEUiib19olXgYha0=
-github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
-github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
-github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
 github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=
 github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
@@ -94,10 +88,6 @@ github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8=
 github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
 github.com/sergi/go-diff v1.0.0 h1:Kpca3qRNrduNnOQeazBd0ysaKrUJiIuISHxogkT9RPQ=
 github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
-github.com/spf13/cobra v1.7.0 h1:hyqWnYt1ZQShIddO5kBpj3vu05/++x6tJ6dg8EC572I=
-github.com/spf13/cobra v1.7.0/go.mod h1:uLxZILRyS/50WlhOIKD7W6V5bgeIt+4sICxh6uRMrb0=
-github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
-github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
@@ -158,8 +148,6 @@ golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
 golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.22.0 h1:gqSGLZqv+AI9lIQzniJ0nZDRG5GBPsSi+DRNHWNz6yA=
-golang.org/x/tools v0.22.0/go.mod h1:aCwcsjqvq7Yqt6TNyX7QMU2enbQ/Gt0bo6krSeEri+c=
 google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=

From d85e5f183824befe246fdf72856c931789cb1272 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 13:18:12 -0400
Subject: [PATCH 121/341] fixed command

---
 Dockerfile.migrate  | 2 +-
 docker-compose.yaml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Dockerfile.migrate b/Dockerfile.migrate
index 701982ba..8f065468 100644
--- a/Dockerfile.migrate
+++ b/Dockerfile.migrate
@@ -2,4 +2,4 @@ FROM arigaio/atlas:latest
 
 COPY ./internal/database/ent/migrate/migrations /migrations
 
-ENTRYPOINT ["atlas", "migrate", "apply","--allow-dirty" ,"--dir" "file:///migrations", ,"--tx-mode" ,"all", "--url", "sqlite:///database.db?_fk=1"]
+ENTRYPOINT ["migrate", "apply","--allow-dirty" ,"--dir" "file:///migrations", ,"--tx-mode" ,"all", "--url", "sqlite:///database.db?_fk=1"]
diff --git a/docker-compose.yaml b/docker-compose.yaml
index f9c25702..28597efb 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -3,7 +3,7 @@ services:
     image: aftermath-migrate
     build:
       dockerfile: Dockerfile.migrate
-    entrypoint: atlas migrate apply --allow-dirty --dir "file:///migrations" --tx-mode all --url "sqlite:///data/aftermath.db?_fk=1"
+    entrypoint: migrate apply --allow-dirty --dir "file:///migrations" --tx-mode all --url "sqlite:///data/aftermath.db?_fk=1"
     volumes:
       - ${DATABASE_PATH}:/data/aftermath.db
     networks:

From 8d775a547cd1210cacafb72fdd8eb2bd90fa3a0c Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 13:29:48 -0400
Subject: [PATCH 122/341] fixed migrations, more granular cache

---
 Dockerfile          | 3 ++-
 Dockerfile.migrate  | 2 --
 docker-compose.yaml | 7 +++----
 main.go             | 2 +-
 4 files changed, 6 insertions(+), 8 deletions(-)

diff --git a/Dockerfile b/Dockerfile
index 0ae63ee9..0108ab65 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -6,10 +6,11 @@ COPY go.mod go.sum ./
 RUN --mount=type=cache,target=$GOPATH/pkg/mod go mod download
 
 COPY ./ ./
+RUN --mount=type=cache,target=$GOPATH/pkg/mod --mount=type=cache,target=/workspace/internal/database/ent/db go generate ./internal/database/ent
 RUN --mount=type=cache,target=$GOPATH/pkg/mod go generate ./...
 
 # build a fully standalone binary with zero dependencies
-RUN --mount=type=cache,target=$GOPATH/pkg/mod CGO_ENABLED=0 GOOS=linux go build -o app .
+RUN --mount=type=cache,target=$GOPATH/pkg/mod --mount=type=cache,target=/workspace/internal/database/ent/db CGO_ENABLED=0 GOOS=linux go build -o app .
 
 # Make a scratch container with required files and binary
 FROM scratch
diff --git a/Dockerfile.migrate b/Dockerfile.migrate
index 8f065468..5c67306d 100644
--- a/Dockerfile.migrate
+++ b/Dockerfile.migrate
@@ -1,5 +1,3 @@
 FROM arigaio/atlas:latest
 
 COPY ./internal/database/ent/migrate/migrations /migrations
-
-ENTRYPOINT ["migrate", "apply","--allow-dirty" ,"--dir" "file:///migrations", ,"--tx-mode" ,"all", "--url", "sqlite:///database.db?_fk=1"]
diff --git a/docker-compose.yaml b/docker-compose.yaml
index 28597efb..36f8a3e9 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -3,9 +3,9 @@ services:
     image: aftermath-migrate
     build:
       dockerfile: Dockerfile.migrate
-    entrypoint: migrate apply --allow-dirty --dir "file:///migrations" --tx-mode all --url "sqlite:///data/aftermath.db?_fk=1"
+    command: migrate apply --allow-dirty --dir "file:///migrations" --tx-mode all --url "sqlite:///data/aftermath.db?_fk=1"
     volumes:
-      - ${DATABASE_PATH}:/data/aftermath.db
+      - ${DATABASE_PATH}:/data
     networks:
       - dokploy-network
 
@@ -20,7 +20,7 @@ services:
         condition: service_completed_successfully
     entrypoint: ["app"]
     volumes:
-      - ${DATABASE_PATH}:/data/aftermath.db
+      - ${DATABASE_PATH}:/data
 
     image: aftermath-service
     build:
@@ -32,7 +32,6 @@ services:
           memory: 512m
     networks:
       - dokploy-network
-    hostname: aftermath-service
     labels:
       - "traefik.enable=true"
       - "traefik.http.routers.aftermath-monorepo-compose.rule=Host(`${TRAEFIK_HOST}`)"
diff --git a/main.go b/main.go
index 25fbfc3d..17a72aef 100644
--- a/main.go
+++ b/main.go
@@ -116,7 +116,7 @@ func startSchedulerFromEnvAsync(dbClient database.Client, wgClient wargaming.Cli
 
 func coreClientsFromEnv() (core.Client, core.Client) {
 	// Dependencies
-	dbClient, err := database.NewSQLiteClient(os.Getenv("DATABASE_PATH"))
+	dbClient, err := database.NewSQLiteClient(os.Getenv("DATABASE_PATH") + "/aftermath.db")
 	if err != nil {
 		log.Fatal().Msgf("database#NewClient failed %s", err)
 	}

From 8a2e96bdc939b83a5154ca0579b4677d1e9171c2 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 13:31:33 -0400
Subject: [PATCH 123/341] cleaned up generate

---
 Dockerfile | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/Dockerfile b/Dockerfile
index 0108ab65..43d7832e 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -6,11 +6,10 @@ COPY go.mod go.sum ./
 RUN --mount=type=cache,target=$GOPATH/pkg/mod go mod download
 
 COPY ./ ./
-RUN --mount=type=cache,target=$GOPATH/pkg/mod --mount=type=cache,target=/workspace/internal/database/ent/db go generate ./internal/database/ent
-RUN --mount=type=cache,target=$GOPATH/pkg/mod go generate ./...
+RUN --mount=type=cache,target=$GOPATH/pkg/mod --mount=type=cache,target=/workspace/internal/database/ent go generate ./internal/database/ent
 
 # build a fully standalone binary with zero dependencies
-RUN --mount=type=cache,target=$GOPATH/pkg/mod --mount=type=cache,target=/workspace/internal/database/ent/db CGO_ENABLED=0 GOOS=linux go build -o app .
+RUN --mount=type=cache,target=$GOPATH/pkg/mod --mount=type=cache,target=/workspace/internal/database/ent CGO_ENABLED=0 GOOS=linux go build -o app .
 
 # Make a scratch container with required files and binary
 FROM scratch

From 58410f768240930e2bd6d1d89802c2f0d8199a12 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 13:32:14 -0400
Subject: [PATCH 124/341] enabled cgo

---
 Dockerfile | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Dockerfile b/Dockerfile
index 43d7832e..deb85f2d 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,4 +1,4 @@
-FROM golang:1.22.3-alpine as builder
+FROM golang:1.22.3-bookworm as builder
 
 WORKDIR /workspace
 
@@ -9,7 +9,7 @@ COPY ./ ./
 RUN --mount=type=cache,target=$GOPATH/pkg/mod --mount=type=cache,target=/workspace/internal/database/ent go generate ./internal/database/ent
 
 # build a fully standalone binary with zero dependencies
-RUN --mount=type=cache,target=$GOPATH/pkg/mod --mount=type=cache,target=/workspace/internal/database/ent CGO_ENABLED=0 GOOS=linux go build -o app .
+RUN --mount=type=cache,target=$GOPATH/pkg/mod --mount=type=cache,target=/workspace/internal/database/ent CGO_ENABLED=1 GOOS=linux go build -o app .
 
 # Make a scratch container with required files and binary
 FROM scratch

From b19e2d1b34708b6ba110530cc1972de7cbc24f44 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 13:38:19 -0400
Subject: [PATCH 125/341] pulling db name from env

---
 Dockerfile                                 |  4 +-
 Taskfile.yaml                              |  2 +-
 docker-compose.yaml                        |  1 -
 internal/database/ent/db/migrate/schema.go | 76 ++++++++++++++++++++++
 main.go                                    |  3 +-
 5 files changed, 81 insertions(+), 5 deletions(-)

diff --git a/Dockerfile b/Dockerfile
index deb85f2d..e9a93afe 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -6,10 +6,10 @@ COPY go.mod go.sum ./
 RUN --mount=type=cache,target=$GOPATH/pkg/mod go mod download
 
 COPY ./ ./
-RUN --mount=type=cache,target=$GOPATH/pkg/mod --mount=type=cache,target=/workspace/internal/database/ent go generate ./internal/database/ent
+RUN --mount=type=cache,target=$GOPATH/pkg/mod --mount=type=cache,target=/workspace/internal/database/ent/db go generate /workspaceinternal/database/ent
 
 # build a fully standalone binary with zero dependencies
-RUN --mount=type=cache,target=$GOPATH/pkg/mod --mount=type=cache,target=/workspace/internal/database/ent CGO_ENABLED=1 GOOS=linux go build -o app .
+RUN --mount=type=cache,target=$GOPATH/pkg/mod --mount=type=cache,target=/workspace/internal/database/ent/db CGO_ENABLED=1 GOOS=linux go build -o app .
 
 # Make a scratch container with required files and binary
 FROM scratch
diff --git a/Taskfile.yaml b/Taskfile.yaml
index 3d6889d7..c407bc9e 100644
--- a/Taskfile.yaml
+++ b/Taskfile.yaml
@@ -24,7 +24,7 @@ tasks:
     cmd: atlas migrate hash --dir "file://internal/database/ent/migrate/migrations" && atlas migrate diff {{.CLI_ARGS}} --dir "file://internal/database/ent/migrate/migrations" --to "ent://internal/database/ent/schema" --dev-url "sqlite://file?mode=memory&_fk=1"
   db-migrate-apply:
     desc: apply migrations using atlas
-    cmd: atlas migrate apply --allow-dirty --dir "file://internal/database/ent/migrate/migrations" --tx-mode all --url "sqlite://${DATABASE_PATH}?_fk=1"
+    cmd: atlas migrate apply --allow-dirty --dir "file://internal/database/ent/migrate/migrations" --tx-mode all --url "sqlite://${DATABASE_PATH}/${DATABASE_NAME}?_fk=1"
 
   dev:
     desc: Start a local dev server
diff --git a/docker-compose.yaml b/docker-compose.yaml
index 36f8a3e9..e0fc5d38 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -18,7 +18,6 @@ services:
     depends_on:
       aftermath-migrate:
         condition: service_completed_successfully
-    entrypoint: ["app"]
     volumes:
       - ${DATABASE_PATH}:/data
 
diff --git a/internal/database/ent/db/migrate/schema.go b/internal/database/ent/db/migrate/schema.go
index 6be5f4e7..29a7f768 100644
--- a/internal/database/ent/db/migrate/schema.go
+++ b/internal/database/ent/db/migrate/schema.go
@@ -89,6 +89,11 @@ var (
 			},
 		},
 		Indexes: []*schema.Index{
+			{
+				Name:    "accountsnapshot_id",
+				Unique:  false,
+				Columns: []*schema.Column{AccountSnapshotsColumns[0]},
+			},
 			{
 				Name:    "accountsnapshot_created_at",
 				Unique:  false,
@@ -137,6 +142,11 @@ var (
 			},
 		},
 		Indexes: []*schema.Index{
+			{
+				Name:    "achievementssnapshot_id",
+				Unique:  false,
+				Columns: []*schema.Column{AchievementsSnapshotsColumns[0]},
+			},
 			{
 				Name:    "achievementssnapshot_created_at",
 				Unique:  false,
@@ -169,6 +179,11 @@ var (
 		Columns:    AppConfigurationsColumns,
 		PrimaryKey: []*schema.Column{AppConfigurationsColumns[0]},
 		Indexes: []*schema.Index{
+			{
+				Name:    "appconfiguration_id",
+				Unique:  false,
+				Columns: []*schema.Column{AppConfigurationsColumns[0]},
+			},
 			{
 				Name:    "appconfiguration_key",
 				Unique:  false,
@@ -191,6 +206,11 @@ var (
 		Columns:    ApplicationCommandsColumns,
 		PrimaryKey: []*schema.Column{ApplicationCommandsColumns[0]},
 		Indexes: []*schema.Index{
+			{
+				Name:    "applicationcommand_id",
+				Unique:  false,
+				Columns: []*schema.Column{ApplicationCommandsColumns[0]},
+			},
 			{
 				Name:    "applicationcommand_options_hash",
 				Unique:  false,
@@ -214,6 +234,11 @@ var (
 		Columns:    ClansColumns,
 		PrimaryKey: []*schema.Column{ClansColumns[0]},
 		Indexes: []*schema.Index{
+			{
+				Name:    "clan_id",
+				Unique:  false,
+				Columns: []*schema.Column{ClansColumns[0]},
+			},
 			{
 				Name:    "clan_tag",
 				Unique:  false,
@@ -246,6 +271,11 @@ var (
 		Columns:    CronTasksColumns,
 		PrimaryKey: []*schema.Column{CronTasksColumns[0]},
 		Indexes: []*schema.Index{
+			{
+				Name:    "crontask_id",
+				Unique:  false,
+				Columns: []*schema.Column{CronTasksColumns[0]},
+			},
 			{
 				Name:    "crontask_reference_id",
 				Unique:  false,
@@ -281,6 +311,13 @@ var (
 		Name:       "users",
 		Columns:    UsersColumns,
 		PrimaryKey: []*schema.Column{UsersColumns[0]},
+		Indexes: []*schema.Index{
+			{
+				Name:    "user_id",
+				Unique:  false,
+				Columns: []*schema.Column{UsersColumns[0]},
+			},
+		},
 	}
 	// UserConnectionsColumns holds the columns for the "user_connections" table.
 	UserConnectionsColumns = []*schema.Column{
@@ -307,6 +344,11 @@ var (
 			},
 		},
 		Indexes: []*schema.Index{
+			{
+				Name:    "userconnection_id",
+				Unique:  false,
+				Columns: []*schema.Column{UserConnectionsColumns[0]},
+			},
 			{
 				Name:    "userconnection_user_id",
 				Unique:  false,
@@ -327,6 +369,11 @@ var (
 				Unique:  false,
 				Columns: []*schema.Column{UserConnectionsColumns[3], UserConnectionsColumns[4]},
 			},
+			{
+				Name:    "userconnection_reference_id_user_id_type",
+				Unique:  true,
+				Columns: []*schema.Column{UserConnectionsColumns[4], UserConnectionsColumns[7], UserConnectionsColumns[3]},
+			},
 		},
 	}
 	// UserContentsColumns holds the columns for the "user_contents" table.
@@ -354,6 +401,11 @@ var (
 			},
 		},
 		Indexes: []*schema.Index{
+			{
+				Name:    "usercontent_id",
+				Unique:  false,
+				Columns: []*schema.Column{UserContentsColumns[0]},
+			},
 			{
 				Name:    "usercontent_user_id",
 				Unique:  false,
@@ -401,6 +453,11 @@ var (
 			},
 		},
 		Indexes: []*schema.Index{
+			{
+				Name:    "usersubscription_id",
+				Unique:  false,
+				Columns: []*schema.Column{UserSubscriptionsColumns[0]},
+			},
 			{
 				Name:    "usersubscription_user_id",
 				Unique:  false,
@@ -436,6 +493,13 @@ var (
 		Name:       "vehicles",
 		Columns:    VehiclesColumns,
 		PrimaryKey: []*schema.Column{VehiclesColumns[0]},
+		Indexes: []*schema.Index{
+			{
+				Name:    "vehicle_id",
+				Unique:  false,
+				Columns: []*schema.Column{VehiclesColumns[0]},
+			},
+		},
 	}
 	// VehicleAveragesColumns holds the columns for the "vehicle_averages" table.
 	VehicleAveragesColumns = []*schema.Column{
@@ -449,6 +513,13 @@ var (
 		Name:       "vehicle_averages",
 		Columns:    VehicleAveragesColumns,
 		PrimaryKey: []*schema.Column{VehicleAveragesColumns[0]},
+		Indexes: []*schema.Index{
+			{
+				Name:    "vehicleaverage_id",
+				Unique:  false,
+				Columns: []*schema.Column{VehicleAveragesColumns[0]},
+			},
+		},
 	}
 	// VehicleSnapshotsColumns holds the columns for the "vehicle_snapshots" table.
 	VehicleSnapshotsColumns = []*schema.Column{
@@ -477,6 +548,11 @@ var (
 			},
 		},
 		Indexes: []*schema.Index{
+			{
+				Name:    "vehiclesnapshot_id",
+				Unique:  false,
+				Columns: []*schema.Column{VehicleSnapshotsColumns[0]},
+			},
 			{
 				Name:    "vehiclesnapshot_created_at",
 				Unique:  false,
diff --git a/main.go b/main.go
index 17a72aef..4abd36e7 100644
--- a/main.go
+++ b/main.go
@@ -3,6 +3,7 @@ package main
 import (
 	"embed"
 	"io/fs"
+	"path/filepath"
 
 	"os"
 	"strconv"
@@ -116,7 +117,7 @@ func startSchedulerFromEnvAsync(dbClient database.Client, wgClient wargaming.Cli
 
 func coreClientsFromEnv() (core.Client, core.Client) {
 	// Dependencies
-	dbClient, err := database.NewSQLiteClient(os.Getenv("DATABASE_PATH") + "/aftermath.db")
+	dbClient, err := database.NewSQLiteClient(filepath.Join(os.Getenv("DATABASE_PATH"), os.Getenv("DATABASE_NAME")))
 	if err != nil {
 		log.Fatal().Msgf("database#NewClient failed %s", err)
 	}

From d893690de3a79b3e8a0788717c49d7cfc887692c Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 13:39:32 -0400
Subject: [PATCH 126/341] fixed path and name

---
 docker-compose.yaml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/docker-compose.yaml b/docker-compose.yaml
index e0fc5d38..4f186335 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -14,7 +14,8 @@ services:
       - .env
     environment:
       - PORT=3000
-      - DATABASE_PATH=sqlite:///data/aftermath.db?_fk=1
+      - DATABASE_NAME=aftermath.db
+      - DATABASE_PATH=/data
     depends_on:
       aftermath-migrate:
         condition: service_completed_successfully

From 6db281216715f5e1013b7a3c6ecab5d60850a492 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 13:39:57 -0400
Subject: [PATCH 127/341] typo

---
 Dockerfile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Dockerfile b/Dockerfile
index e9a93afe..3198670a 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -6,7 +6,7 @@ COPY go.mod go.sum ./
 RUN --mount=type=cache,target=$GOPATH/pkg/mod go mod download
 
 COPY ./ ./
-RUN --mount=type=cache,target=$GOPATH/pkg/mod --mount=type=cache,target=/workspace/internal/database/ent/db go generate /workspaceinternal/database/ent
+RUN --mount=type=cache,target=$GOPATH/pkg/mod --mount=type=cache,target=/workspace/internal/database/ent/db go generate internal/database/ent
 
 # build a fully standalone binary with zero dependencies
 RUN --mount=type=cache,target=$GOPATH/pkg/mod --mount=type=cache,target=/workspace/internal/database/ent/db CGO_ENABLED=1 GOOS=linux go build -o app .

From aa9ac9744808625749b3f96fbebda096fad674c6 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 13:41:20 -0400
Subject: [PATCH 128/341] removed all manual cache

---
 Dockerfile | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Dockerfile b/Dockerfile
index 3198670a..071d1b3b 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -3,13 +3,13 @@ FROM golang:1.22.3-bookworm as builder
 WORKDIR /workspace
 
 COPY go.mod go.sum ./
-RUN --mount=type=cache,target=$GOPATH/pkg/mod go mod download
+RUN go mod download
 
 COPY ./ ./
-RUN --mount=type=cache,target=$GOPATH/pkg/mod --mount=type=cache,target=/workspace/internal/database/ent/db go generate internal/database/ent
+RUN go generate internal/database/ent
 
 # build a fully standalone binary with zero dependencies
-RUN --mount=type=cache,target=$GOPATH/pkg/mod --mount=type=cache,target=/workspace/internal/database/ent/db CGO_ENABLED=1 GOOS=linux go build -o app .
+RUN CGO_ENABLED=1 GOOS=linux go build -o app .
 
 # Make a scratch container with required files and binary
 FROM scratch

From f4e7f09a53912ac53358591cdab27bae823a4cd3 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 13:41:57 -0400
Subject: [PATCH 129/341] generate

---
 Dockerfile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Dockerfile b/Dockerfile
index 071d1b3b..db7a5955 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -6,7 +6,7 @@ COPY go.mod go.sum ./
 RUN go mod download
 
 COPY ./ ./
-RUN go generate internal/database/ent
+RUN go generate ./...
 
 # build a fully standalone binary with zero dependencies
 RUN CGO_ENABLED=1 GOOS=linux go build -o app .

From 1e8c8d27524e1ad3a86b48de0c30afca5f4f6b80 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 13:43:19 -0400
Subject: [PATCH 130/341] removed generate as a layer

---
 Dockerfile | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/Dockerfile b/Dockerfile
index db7a5955..a71d533c 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -3,13 +3,12 @@ FROM golang:1.22.3-bookworm as builder
 WORKDIR /workspace
 
 COPY go.mod go.sum ./
-RUN go mod download
+RUN --mount=type=cache,target=$GOPATH/pkg/mod go mod download
 
 COPY ./ ./
-RUN go generate ./...
 
 # build a fully standalone binary with zero dependencies
-RUN CGO_ENABLED=1 GOOS=linux go build -o app .
+RUN --mount=type=cache,target=$GOPATH/pkg/mod CGO_ENABLED=1 GOOS=linux go build -o app .
 
 # Make a scratch container with required files and binary
 FROM scratch

From 04aca895d76f6b66906a5005cec199cceaae0eb7 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 13:46:33 -0400
Subject: [PATCH 131/341] temoved cache

---
 Dockerfile | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Dockerfile b/Dockerfile
index a71d533c..241108a4 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -3,12 +3,12 @@ FROM golang:1.22.3-bookworm as builder
 WORKDIR /workspace
 
 COPY go.mod go.sum ./
-RUN --mount=type=cache,target=$GOPATH/pkg/mod go mod download
+RUN go mod download
 
 COPY ./ ./
 
 # build a fully standalone binary with zero dependencies
-RUN --mount=type=cache,target=$GOPATH/pkg/mod CGO_ENABLED=1 GOOS=linux go build -o app .
+RUN CGO_ENABLED=1 GOOS=linux go build -o app .
 
 # Make a scratch container with required files and binary
 FROM scratch

From 1f1e9c6d1ba674fe677357c83ee2ea4b544c992b Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 13:47:37 -0400
Subject: [PATCH 132/341] added back generate

---
 Dockerfile | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Dockerfile b/Dockerfile
index 241108a4..0c9ffd25 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -7,14 +7,14 @@ RUN go mod download
 
 COPY ./ ./
 
+RUN go generate ./...
+
 # build a fully standalone binary with zero dependencies
 RUN CGO_ENABLED=1 GOOS=linux go build -o app .
 
 # Make a scratch container with required files and binary
 FROM scratch
 
-WORKDIR /app
-
 ENV TZ=Europe/Berlin
 ENV ZONEINFO=/zoneinfo.zip
 COPY --from=builder /workspace/app /usr/bin/

From 880eaff71197b82ef57ff7e47c8a08bd6f78fa9f Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 13:48:57 -0400
Subject: [PATCH 133/341] set entrypoint back?

---
 docker-compose.yaml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/docker-compose.yaml b/docker-compose.yaml
index 4f186335..32fddff9 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -16,6 +16,7 @@ services:
       - PORT=3000
       - DATABASE_NAME=aftermath.db
       - DATABASE_PATH=/data
+    entrypoint: ["app"]
     depends_on:
       aftermath-migrate:
         condition: service_completed_successfully

From 632978a6f22561d814681cf45d4f39afaee980c3 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 13:51:10 -0400
Subject: [PATCH 134/341] ensuring a directory exists

---
 main.go | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/main.go b/main.go
index 4abd36e7..b340021a 100644
--- a/main.go
+++ b/main.go
@@ -116,6 +116,11 @@ func startSchedulerFromEnvAsync(dbClient database.Client, wgClient wargaming.Cli
 }
 
 func coreClientsFromEnv() (core.Client, core.Client) {
+	err := os.MkdirAll(os.Getenv("DATABASE_PATH"), os.ModePerm)
+	if err != nil {
+		log.Fatal().Msgf("os#MkdirAll failed %s", err)
+	}
+
 	// Dependencies
 	dbClient, err := database.NewSQLiteClient(filepath.Join(os.Getenv("DATABASE_PATH"), os.Getenv("DATABASE_NAME")))
 	if err != nil {

From 6b070c54b98f15e52813e46b46fb199e15d94542 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 13:52:20 -0400
Subject: [PATCH 135/341] added mod cache back

---
 Dockerfile | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Dockerfile b/Dockerfile
index 0c9ffd25..03ea8afd 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -3,14 +3,14 @@ FROM golang:1.22.3-bookworm as builder
 WORKDIR /workspace
 
 COPY go.mod go.sum ./
-RUN go mod download
+RUN --mount=type=cache,target=$GOPATH/pkg/mod go mod download
 
 COPY ./ ./
 
-RUN go generate ./...
+RUN --mount=type=cache,target=$GOPATH/pkg/mod go generate ./...
 
 # build a fully standalone binary with zero dependencies
-RUN CGO_ENABLED=1 GOOS=linux go build -o app .
+RUN --mount=type=cache,target=$GOPATH/pkg/mod CGO_ENABLED=1 GOOS=linux go build -o app .
 
 # Make a scratch container with required files and binary
 FROM scratch

From ca95f1f407e39bd39421393e28275151dd9bac83 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 13:58:12 -0400
Subject: [PATCH 136/341] catching panic

---
 internal/database/client.go | 9 ++++++++-
 main.go                     | 2 +-
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/internal/database/client.go b/internal/database/client.go
index f2cc1c77..ac557d0d 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -10,6 +10,7 @@ import (
 	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/permissions"
 	"github.com/cufee/aftermath/internal/stats/frame"
+	"github.com/rs/zerolog/log"
 
 	_ "github.com/mattn/go-sqlite3"
 )
@@ -104,7 +105,13 @@ func (c *client) txWithLock(ctx context.Context) (*db.Tx, func(), error) {
 }
 
 func NewSQLiteClient(filePath string) (*client, error) {
-	c, err := db.Open("sqlite3", fmt.Sprintf("file:%s?cache=shared&_fk=1", filePath))
+	defer func() {
+		if r := recover(); r != nil {
+			log.Fatal().Interface("error", r).Stack().Msg("NewSQLiteClient panic")
+		}
+	}()
+
+	c, err := db.Open("sqlite3", fmt.Sprintf("file: %s?_fk=1", filePath))
 	if err != nil {
 		return nil, err
 	}
diff --git a/main.go b/main.go
index b340021a..3111fe1b 100644
--- a/main.go
+++ b/main.go
@@ -50,7 +50,7 @@ func main() {
 
 	discordHandler, err := discord.NewRouterHandler(liveCoreClient, os.Getenv("DISCORD_TOKEN"), os.Getenv("DISCORD_PUBLIC_KEY"))
 	if err != nil {
-		panic(err)
+		log.Fatal().Msgf("discord#NewRouterHandler failed %s", err)
 	}
 
 	if e := os.Getenv("PRIVATE_SERVER_ENABLED"); e == "true" {

From 282e9ac42b999ba5d2550ee563024457a8b24296 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 13:59:41 -0400
Subject: [PATCH 137/341] typo

---
 internal/database/client.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/internal/database/client.go b/internal/database/client.go
index ac557d0d..eecf20c0 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -111,7 +111,7 @@ func NewSQLiteClient(filePath string) (*client, error) {
 		}
 	}()
 
-	c, err := db.Open("sqlite3", fmt.Sprintf("file: %s?_fk=1", filePath))
+	c, err := db.Open("sqlite3", fmt.Sprintf("file://%s?_fk=1", filePath))
 	if err != nil {
 		return nil, err
 	}

From 6c556e40d87e91a0b2086ade8cf7d75699f29e77 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 14:02:16 -0400
Subject: [PATCH 138/341] split up COPY

---
 Dockerfile | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/Dockerfile b/Dockerfile
index 03ea8afd..14ef3f9a 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -5,9 +5,10 @@ WORKDIR /workspace
 COPY go.mod go.sum ./
 RUN --mount=type=cache,target=$GOPATH/pkg/mod go mod download
 
-COPY ./ ./
+COPY ./internal/database/ent internal/database/ent
+RUN --mount=type=cache,target=$GOPATH/pkg/mod go generate internal/database/ent
 
-RUN --mount=type=cache,target=$GOPATH/pkg/mod go generate ./...
+COPY ./ ./
 
 # build a fully standalone binary with zero dependencies
 RUN --mount=type=cache,target=$GOPATH/pkg/mod CGO_ENABLED=1 GOOS=linux go build -o app .

From db2f8cd3596b575d332e9ce5bf3f14ebf8dfb47e Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 14:03:12 -0400
Subject: [PATCH 139/341] relative path

---
 Dockerfile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Dockerfile b/Dockerfile
index 14ef3f9a..9829accd 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -6,7 +6,7 @@ COPY go.mod go.sum ./
 RUN --mount=type=cache,target=$GOPATH/pkg/mod go mod download
 
 COPY ./internal/database/ent internal/database/ent
-RUN --mount=type=cache,target=$GOPATH/pkg/mod go generate internal/database/ent
+RUN --mount=type=cache,target=$GOPATH/pkg/mod go generate ./internal/database/ent
 
 COPY ./ ./
 

From 11b69e562fb8984f760f31c0897f738558cfbae3 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 14:04:48 -0400
Subject: [PATCH 140/341] trying to add cache

---
 Dockerfile | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/Dockerfile b/Dockerfile
index 9829accd..91f74fdc 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -5,13 +5,12 @@ WORKDIR /workspace
 COPY go.mod go.sum ./
 RUN --mount=type=cache,target=$GOPATH/pkg/mod go mod download
 
-COPY ./internal/database/ent internal/database/ent
-RUN --mount=type=cache,target=$GOPATH/pkg/mod go generate ./internal/database/ent
-
 COPY ./ ./
 
+RUN --mount=type=cache,target=$GOPATH/pkg/mod --mount=type=cache,target=/workspace/internal/database/ent go generate ./internal/database/ent
+
 # build a fully standalone binary with zero dependencies
-RUN --mount=type=cache,target=$GOPATH/pkg/mod CGO_ENABLED=1 GOOS=linux go build -o app .
+RUN --mount=type=cache,target=$GOPATH/pkg/mod --mount=type=cache,target=/workspace/internal/database/ent CGO_ENABLED=1 GOOS=linux go build -o app .
 
 # Make a scratch container with required files and binary
 FROM scratch

From cb2d45bff4e39a83ca155717a1c2e64ce09b8f05 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 14:05:19 -0400
Subject: [PATCH 141/341] removed cache

---
 Dockerfile | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Dockerfile b/Dockerfile
index 91f74fdc..03ea8afd 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -7,10 +7,10 @@ RUN --mount=type=cache,target=$GOPATH/pkg/mod go mod download
 
 COPY ./ ./
 
-RUN --mount=type=cache,target=$GOPATH/pkg/mod --mount=type=cache,target=/workspace/internal/database/ent go generate ./internal/database/ent
+RUN --mount=type=cache,target=$GOPATH/pkg/mod go generate ./...
 
 # build a fully standalone binary with zero dependencies
-RUN --mount=type=cache,target=$GOPATH/pkg/mod --mount=type=cache,target=/workspace/internal/database/ent CGO_ENABLED=1 GOOS=linux go build -o app .
+RUN --mount=type=cache,target=$GOPATH/pkg/mod CGO_ENABLED=1 GOOS=linux go build -o app .
 
 # Make a scratch container with required files and binary
 FROM scratch

From 5b26813987afb652d121a5b686631dcc1fb28892 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 14:08:00 -0400
Subject: [PATCH 142/341] accepting path from env

---
 docker-compose.yaml | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/docker-compose.yaml b/docker-compose.yaml
index 32fddff9..c7c26a1c 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -3,7 +3,7 @@ services:
     image: aftermath-migrate
     build:
       dockerfile: Dockerfile.migrate
-    command: migrate apply --allow-dirty --dir "file:///migrations" --tx-mode all --url "sqlite:///data/aftermath.db?_fk=1"
+    command: migrate apply --allow-dirty --dir "file:///migrations" --tx-mode all --url "sqlite:///data/${DATABASE_NAME}?_fk=1"
     volumes:
       - ${DATABASE_PATH}:/data
     networks:
@@ -14,7 +14,6 @@ services:
       - .env
     environment:
       - PORT=3000
-      - DATABASE_NAME=aftermath.db
       - DATABASE_PATH=/data
     entrypoint: ["app"]
     depends_on:

From f8a9bcbc621c3b4d85e6e33420ad1c1a0a259abc Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 14:12:48 -0400
Subject: [PATCH 143/341] changed entrypoint

---
 Dockerfile          | 6 +++---
 docker-compose.yaml | 1 -
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/Dockerfile b/Dockerfile
index 03ea8afd..0ed1469d 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -10,15 +10,15 @@ COPY ./ ./
 RUN --mount=type=cache,target=$GOPATH/pkg/mod go generate ./...
 
 # build a fully standalone binary with zero dependencies
-RUN --mount=type=cache,target=$GOPATH/pkg/mod CGO_ENABLED=1 GOOS=linux go build -o app .
+RUN --mount=type=cache,target=$GOPATH/pkg/mod CGO_ENABLED=1 GOOS=linux go build -o /bin/aftermath .
 
 # Make a scratch container with required files and binary
 FROM scratch
 
 ENV TZ=Europe/Berlin
 ENV ZONEINFO=/zoneinfo.zip
-COPY --from=builder /workspace/app /usr/bin/
+COPY --from=builder /bin/aftermath /usr/bin/
 COPY --from=builder /usr/local/go/lib/time/zoneinfo.zip /
 COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
 
-ENTRYPOINT ["app"]
+ENTRYPOINT ["aftermath"]
diff --git a/docker-compose.yaml b/docker-compose.yaml
index c7c26a1c..e808c713 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -15,7 +15,6 @@ services:
     environment:
       - PORT=3000
       - DATABASE_PATH=/data
-    entrypoint: ["app"]
     depends_on:
       aftermath-migrate:
         condition: service_completed_successfully

From 8922c1833b826163fefca80cdc97050ffcde9497 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 14:15:16 -0400
Subject: [PATCH 144/341] removed all cache

---
 Dockerfile | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Dockerfile b/Dockerfile
index 0ed1469d..0dab5580 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -3,14 +3,14 @@ FROM golang:1.22.3-bookworm as builder
 WORKDIR /workspace
 
 COPY go.mod go.sum ./
-RUN --mount=type=cache,target=$GOPATH/pkg/mod go mod download
+RUN go mod download
 
 COPY ./ ./
 
-RUN --mount=type=cache,target=$GOPATH/pkg/mod go generate ./...
+RUN go generate ./...
 
 # build a fully standalone binary with zero dependencies
-RUN --mount=type=cache,target=$GOPATH/pkg/mod CGO_ENABLED=1 GOOS=linux go build -o /bin/aftermath .
+RUN CGO_ENABLED=1 GOOS=linux go build -o /bin/aftermath .
 
 # Make a scratch container with required files and binary
 FROM scratch

From 952c4a611d4b463a9eecf27c282b85df1edf83d8 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 14:20:59 -0400
Subject: [PATCH 145/341] added cmd

---
 Dockerfile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Dockerfile b/Dockerfile
index 0dab5580..4614dea7 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -21,4 +21,4 @@ COPY --from=builder /bin/aftermath /usr/bin/
 COPY --from=builder /usr/local/go/lib/time/zoneinfo.zip /
 COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
 
-ENTRYPOINT ["aftermath"]
+CMD [ "aftermath" ]

From 72e3a871d15fc8371fcd59b9aaa29e6559b364ea Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 14:21:18 -0400
Subject: [PATCH 146/341] added back cache

---
 Dockerfile | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Dockerfile b/Dockerfile
index 4614dea7..c182f37b 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -3,14 +3,14 @@ FROM golang:1.22.3-bookworm as builder
 WORKDIR /workspace
 
 COPY go.mod go.sum ./
-RUN go mod download
+RUN --mount=type=cache,target=$GOPATH/pkg/mod go mod download
 
 COPY ./ ./
 
-RUN go generate ./...
+RUN --mount=type=cache,target=$GOPATH/pkg/mod go generate ./...
 
 # build a fully standalone binary with zero dependencies
-RUN CGO_ENABLED=1 GOOS=linux go build -o /bin/aftermath .
+RUN --mount=type=cache,target=$GOPATH/pkg/mod CGO_ENABLED=1 GOOS=linux go build -o /bin/aftermath .
 
 # Make a scratch container with required files and binary
 FROM scratch

From 5cf3a66b8138da2e57d6577350046705506adf3d Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 14:22:41 -0400
Subject: [PATCH 147/341] removed pointless step

---
 Dockerfile | 2 --
 1 file changed, 2 deletions(-)

diff --git a/Dockerfile b/Dockerfile
index c182f37b..7a25b7d5 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -7,8 +7,6 @@ RUN --mount=type=cache,target=$GOPATH/pkg/mod go mod download
 
 COPY ./ ./
 
-RUN --mount=type=cache,target=$GOPATH/pkg/mod go generate ./...
-
 # build a fully standalone binary with zero dependencies
 RUN --mount=type=cache,target=$GOPATH/pkg/mod CGO_ENABLED=1 GOOS=linux go build -o /bin/aftermath .
 

From 231e4a4ec448c10c087c6e94b60d04de64d942bd Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 14:23:42 -0400
Subject: [PATCH 148/341] idk at this point

---
 Dockerfile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Dockerfile b/Dockerfile
index 7a25b7d5..e1446fcb 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -15,7 +15,7 @@ FROM scratch
 
 ENV TZ=Europe/Berlin
 ENV ZONEINFO=/zoneinfo.zip
-COPY --from=builder /bin/aftermath /usr/bin/
+COPY --from=builder /bin/aftermath /usr/bin/aftermath
 COPY --from=builder /usr/local/go/lib/time/zoneinfo.zip /
 COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
 

From ddad6ad6f6d148c42b550b9b4da0122d56b0e1a8 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 14:33:23 -0400
Subject: [PATCH 149/341] switched final image

---
 Dockerfile | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/Dockerfile b/Dockerfile
index e1446fcb..1f1802a4 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -8,15 +8,12 @@ RUN --mount=type=cache,target=$GOPATH/pkg/mod go mod download
 COPY ./ ./
 
 # build a fully standalone binary with zero dependencies
-RUN --mount=type=cache,target=$GOPATH/pkg/mod CGO_ENABLED=1 GOOS=linux go build -o /bin/aftermath .
+RUN --mount=type=cache,target=$GOPATH/pkg/mod GOOS=linux go build -a -installsuffix cgo -o /bin/aftermath .
 
 # Make a scratch container with required files and binary
-FROM scratch
+FROM debian:stable-slim
 
 ENV TZ=Europe/Berlin
-ENV ZONEINFO=/zoneinfo.zip
 COPY --from=builder /bin/aftermath /usr/bin/aftermath
-COPY --from=builder /usr/local/go/lib/time/zoneinfo.zip /
-COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
 
-CMD [ "aftermath" ]
+ENTRYPOINT [ "aftermath" ]

From 09adb5aac04abbb62e895df39e08833456d1edf4 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 14:35:48 -0400
Subject: [PATCH 150/341] added certs and time

---
 Dockerfile | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/Dockerfile b/Dockerfile
index 1f1802a4..2816f085 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -8,12 +8,15 @@ RUN --mount=type=cache,target=$GOPATH/pkg/mod go mod download
 COPY ./ ./
 
 # build a fully standalone binary with zero dependencies
-RUN --mount=type=cache,target=$GOPATH/pkg/mod GOOS=linux go build -a -installsuffix cgo -o /bin/aftermath .
+RUN --mount=type=cache,target=$GOPATH/pkg/mod CGO_ENABLED=1 GOOS=linux go build -o /bin/aftermath .
 
 # Make a scratch container with required files and binary
 FROM debian:stable-slim
 
 ENV TZ=Europe/Berlin
+ENV ZONEINFO=/zoneinfo.zip
 COPY --from=builder /bin/aftermath /usr/bin/aftermath
+COPY --from=builder /usr/local/go/lib/time/zoneinfo.zip /
+COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
 
 ENTRYPOINT [ "aftermath" ]

From c4742f03264e5b11c3db619f11c5ed263d17e7e9 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 14:45:28 -0400
Subject: [PATCH 151/341] updated wg proxy

---
 go.mod | 2 +-
 go.sum | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/go.mod b/go.mod
index bf5fd037..dbc963ed 100644
--- a/go.mod
+++ b/go.mod
@@ -6,7 +6,7 @@ require (
 	ariga.io/atlas v0.19.1-0.20240203083654-5948b60a8e43
 	entgo.io/ent v0.13.1
 	github.com/bwmarrin/discordgo v0.28.1
-	github.com/cufee/am-wg-proxy-next/v2 v2.1.3
+	github.com/cufee/am-wg-proxy-next/v2 v2.1.4
 	github.com/disintegration/imaging v1.6.2
 	github.com/fogleman/gg v1.3.0
 	github.com/go-co-op/gocron v1.37.0
diff --git a/go.sum b/go.sum
index 24ee26f5..4f848a8b 100644
--- a/go.sum
+++ b/go.sum
@@ -14,8 +14,8 @@ github.com/bwmarrin/discordgo v0.28.1 h1:gXsuo2GBO7NbR6uqmrrBDplPUx2T3nzu775q/Rd
 github.com/bwmarrin/discordgo v0.28.1/go.mod h1:NJZpH+1AfhIcyQsPeuBKsUtYrRnjkyu0kIVMCHkZtRY=
 github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
-github.com/cufee/am-wg-proxy-next/v2 v2.1.3 h1:qTzzgEapbI/z81R3nXoiiITfBZeHQ1cnebzSNgaoZlQ=
-github.com/cufee/am-wg-proxy-next/v2 v2.1.3/go.mod h1:+VxiIdbrdhHdRThASbVmZ5Fz4H6XPCzL3S2Ix6TO/84=
+github.com/cufee/am-wg-proxy-next/v2 v2.1.4 h1:2EtRrktt2eXcomZB868J2QYuxI1NmwyFrd9EqORD21Y=
+github.com/cufee/am-wg-proxy-next/v2 v2.1.4/go.mod h1:xrgMXzAMU4p5AW1++nnpofNFZLOiSUP8vnezzzG92Zw=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=

From 13d39dd9fc73b38076086b280493c957e6e2e00b Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 18:21:20 -0400
Subject: [PATCH 152/341] saving a snapshot when account exists, but no
 snapshots

---
 internal/stats/session.go | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/internal/stats/session.go b/internal/stats/session.go
index a4bfd6ed..3d7cd416 100644
--- a/internal/stats/session.go
+++ b/internal/stats/session.go
@@ -2,6 +2,7 @@ package stats
 
 import (
 	"context"
+	"errors"
 	"slices"
 	"time"
 
@@ -55,6 +56,18 @@ func (r *renderer) Session(ctx context.Context, accountId string, from time.Time
 	session, career, err := r.fetchClient.SessionStats(ctx, accountId, from, fetch.WithWN8())
 	stop()
 	if err != nil {
+		if errors.Is(fetch.ErrSessionNotFound, err) {
+			go func(id string) {
+				// record a session in the background
+				ctx, cancel := context.WithTimeout(context.Background(), time.Second*15)
+				defer cancel()
+
+				_, err := logic.RecordAccountSnapshots(ctx, r.wargaming, r.database, r.wargaming.RealmFromAccountID(id), false, id)
+				if err != nil {
+					log.Err(err).Str("accountId", id).Msg("failed to record account snapshot")
+				}
+			}(accountId)
+		}
 		return nil, meta, err
 	}
 	meta.Stats["career"] = career

From f09d7f2223e04b33df8e5a1d67ce4f1b983c74ea Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 18:36:28 -0400
Subject: [PATCH 153/341] changed the logo slightly

---
 internal/stats/render/common/logo.go |  4 ++--
 render_test.go                       | 14 ++------------
 2 files changed, 4 insertions(+), 14 deletions(-)

diff --git a/internal/stats/render/common/logo.go b/internal/stats/render/common/logo.go
index 8de5033e..5f25f173 100644
--- a/internal/stats/render/common/logo.go
+++ b/internal/stats/render/common/logo.go
@@ -26,8 +26,8 @@ func (opts LogoSizingOptions) Width() int {
 func DefaultLogoOptions() LogoSizingOptions {
 	return LogoSizingOptions{
 		Gap:       4,
-		Jump:      6,
-		Lines:     9,
+		Jump:      7,
+		Lines:     7,
 		LineStep:  12,
 		LineWidth: 6,
 	}
diff --git a/render_test.go b/render_test.go
index a6770d64..6dc761be 100644
--- a/render_test.go
+++ b/render_test.go
@@ -2,7 +2,6 @@ package main
 
 import (
 	"context"
-	"image/png"
 	"os"
 	"testing"
 	"time"
@@ -10,11 +9,11 @@ import (
 	"github.com/cufee/aftermath/internal/stats"
 	"github.com/cufee/aftermath/internal/stats/render"
 	"github.com/cufee/aftermath/internal/stats/render/assets"
-	"github.com/disintegration/imaging"
-	"github.com/fogleman/gg"
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/assert"
 	"golang.org/x/text/language"
+
+	_ "github.com/joho/godotenv/autoload"
 )
 
 func TestRenderSession(t *testing.T) {
@@ -26,15 +25,6 @@ func TestRenderSession(t *testing.T) {
 	coreClient, _ := coreClientsFromEnv()
 	defer coreClient.Database().Disconnect()
 
-	rating, _ := assets.GetLoadedImage("rating-calibration")
-	c := imaging.PasteCenter(gg.NewContext(int(float64(rating.Bounds().Dx())*1.5), int(float64(rating.Bounds().Dy())*1.5)).Image(), rating)
-
-	fc, err := os.Create("tmp/rating-calibration.png")
-	assert.NoError(t, err, "failed to create a file")
-	defer fc.Close()
-
-	png.Encode(fc, c)
-
 	bgImage, ok := assets.GetLoadedImage("bg-default")
 	assert.True(t, ok, "failed to load a background image")
 

From c95d6b2d12d445de601a56f1612d683b1a7fb94b Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 19:06:29 -0400
Subject: [PATCH 154/341] moved files around, versioned all stats packages

---
 cmds/core/client.go                                    |  4 ++--
 cmds/core/server/handlers/private/accounts.go          |  2 +-
 cmds/discord/commands/session.go                       |  4 ++--
 internal/logic/sessions.go                             |  2 +-
 internal/stats/fetch/{ => v1}/client.go                |  0
 internal/stats/fetch/{ => v1}/convert.go               |  0
 internal/stats/fetch/{ => v1}/errors.go                |  0
 internal/stats/fetch/{ => v1}/multisource.go           |  0
 internal/stats/fetch/{ => v1}/replay/errors.go         |  0
 internal/stats/fetch/{ => v1}/replay/meta.go           |  0
 internal/stats/fetch/{ => v1}/replay/replay.go         |  0
 internal/stats/fetch/{ => v1}/replay/results.go        |  0
 internal/stats/fetch/{ => v1}/replay/unpack.go         |  0
 internal/stats/prepare/common/{ => v1}/card.go         |  0
 internal/stats/prepare/common/{ => v1}/convert.go      |  0
 internal/stats/prepare/common/{ => v1}/highlights.go   |  0
 internal/stats/prepare/common/{ => v1}/options.go      |  0
 internal/stats/prepare/common/{ => v1}/tags.go         |  0
 internal/stats/prepare/period/{ => v1}/card.go         |  4 ++--
 internal/stats/prepare/period/{ => v1}/constants.go    |  2 +-
 internal/stats/prepare/period/{ => v1}/preset.go       |  2 +-
 internal/stats/prepare/replay/{ => v1}/constants.go    |  2 +-
 internal/stats/prepare/session/{ => v1}/card.go        |  4 ++--
 internal/stats/prepare/session/{ => v1}/constants.go   |  2 +-
 internal/stats/prepare/session/{ => v1}/preset.go      |  2 +-
 internal/stats/render/common/{ => v1}/badges.go        |  0
 internal/stats/render/common/{ => v1}/block.go         |  0
 internal/stats/render/common/{ => v1}/calculations.go  |  0
 internal/stats/render/common/{ => v1}/colors.go        |  0
 internal/stats/render/common/{ => v1}/constants.go     |  0
 internal/stats/render/common/{ => v1}/footer.go        |  0
 internal/stats/render/common/{ => v1}/header.go        |  0
 internal/stats/render/common/{ => v1}/images.go        |  0
 internal/stats/render/common/{ => v1}/logo.go          |  0
 internal/stats/render/common/{ => v1}/player_title.go  |  0
 internal/stats/render/common/{ => v1}/strings.go       |  0
 internal/stats/render/common/{ => v1}/style.go         |  0
 .../stats/render/common/{ => v1}/tier_percentage.go    |  0
 internal/stats/render/common/{ => v1}/wn8.go           |  0
 internal/stats/render/period/{ => v1}/block.go         |  6 +++---
 internal/stats/render/period/{ => v1}/cards.go         |  8 ++++----
 internal/stats/render/period/{ => v1}/constants.go     |  6 +++---
 internal/stats/render/period/{ => v1}/image.go         |  4 ++--
 internal/stats/render/replay/{ => v1}/blocks.go.todo   |  2 +-
 internal/stats/render/replay/{ => v1}/cards.go.todo    |  0
 .../stats/render/replay/{ => v1}/constants.go.todo     |  0
 internal/stats/render/replay/{ => v1}/elements.go.todo |  0
 internal/stats/render/replay/{ => v1}/preset.go.todo   |  0
 internal/stats/render/segments.go                      |  2 +-
 internal/stats/render/session/{ => v1}/blocks.go       |  6 +++---
 internal/stats/render/session/{ => v1}/cards.go        |  8 ++++----
 internal/stats/render/session/{ => v1}/constants.go    |  2 +-
 internal/stats/render/session/{ => v1}/icons.go        |  2 +-
 internal/stats/render/session/{ => v1}/image.go        |  4 ++--
 internal/stats/{ => renderer/v1}/errors.go             |  2 +-
 internal/stats/{ => renderer/v1}/image.go              |  4 ++--
 internal/stats/{ => renderer/v1}/metadata.go           |  4 ++--
 internal/stats/{ => renderer/v1}/period.go             | 10 +++++-----
 internal/stats/{ => renderer/v1}/renderer.go           |  4 ++--
 internal/stats/renderer/v1/replay.go                   |  1 +
 internal/stats/{ => renderer/v1}/session.go            | 10 +++++-----
 internal/stats/replay.go                               |  1 -
 main.go                                                | 10 +++++-----
 render_test.go                                         |  2 +-
 64 files changed, 64 insertions(+), 64 deletions(-)
 rename internal/stats/fetch/{ => v1}/client.go (100%)
 rename internal/stats/fetch/{ => v1}/convert.go (100%)
 rename internal/stats/fetch/{ => v1}/errors.go (100%)
 rename internal/stats/fetch/{ => v1}/multisource.go (100%)
 rename internal/stats/fetch/{ => v1}/replay/errors.go (100%)
 rename internal/stats/fetch/{ => v1}/replay/meta.go (100%)
 rename internal/stats/fetch/{ => v1}/replay/replay.go (100%)
 rename internal/stats/fetch/{ => v1}/replay/results.go (100%)
 rename internal/stats/fetch/{ => v1}/replay/unpack.go (100%)
 rename internal/stats/prepare/common/{ => v1}/card.go (100%)
 rename internal/stats/prepare/common/{ => v1}/convert.go (100%)
 rename internal/stats/prepare/common/{ => v1}/highlights.go (100%)
 rename internal/stats/prepare/common/{ => v1}/options.go (100%)
 rename internal/stats/prepare/common/{ => v1}/tags.go (100%)
 rename internal/stats/prepare/period/{ => v1}/card.go (95%)
 rename internal/stats/prepare/period/{ => v1}/constants.go (93%)
 rename internal/stats/prepare/period/{ => v1}/preset.go (94%)
 rename internal/stats/prepare/replay/{ => v1}/constants.go (98%)
 rename internal/stats/prepare/session/{ => v1}/card.go (98%)
 rename internal/stats/prepare/session/{ => v1}/constants.go (94%)
 rename internal/stats/prepare/session/{ => v1}/preset.go (93%)
 rename internal/stats/render/common/{ => v1}/badges.go (100%)
 rename internal/stats/render/common/{ => v1}/block.go (100%)
 rename internal/stats/render/common/{ => v1}/calculations.go (100%)
 rename internal/stats/render/common/{ => v1}/colors.go (100%)
 rename internal/stats/render/common/{ => v1}/constants.go (100%)
 rename internal/stats/render/common/{ => v1}/footer.go (100%)
 rename internal/stats/render/common/{ => v1}/header.go (100%)
 rename internal/stats/render/common/{ => v1}/images.go (100%)
 rename internal/stats/render/common/{ => v1}/logo.go (100%)
 rename internal/stats/render/common/{ => v1}/player_title.go (100%)
 rename internal/stats/render/common/{ => v1}/strings.go (100%)
 rename internal/stats/render/common/{ => v1}/style.go (100%)
 rename internal/stats/render/common/{ => v1}/tier_percentage.go (100%)
 rename internal/stats/render/common/{ => v1}/wn8.go (100%)
 rename internal/stats/render/period/{ => v1}/block.go (94%)
 rename internal/stats/render/period/{ => v1}/cards.go (97%)
 rename internal/stats/render/period/{ => v1}/constants.go (95%)
 rename internal/stats/render/period/{ => v1}/image.go (81%)
 rename internal/stats/render/replay/{ => v1}/blocks.go.todo (98%)
 rename internal/stats/render/replay/{ => v1}/cards.go.todo (100%)
 rename internal/stats/render/replay/{ => v1}/constants.go.todo (100%)
 rename internal/stats/render/replay/{ => v1}/elements.go.todo (100%)
 rename internal/stats/render/replay/{ => v1}/preset.go.todo (100%)
 rename internal/stats/render/session/{ => v1}/blocks.go (97%)
 rename internal/stats/render/session/{ => v1}/cards.go (98%)
 rename internal/stats/render/session/{ => v1}/constants.go (98%)
 rename internal/stats/render/session/{ => v1}/icons.go (93%)
 rename internal/stats/render/session/{ => v1}/image.go (81%)
 rename internal/stats/{ => renderer/v1}/errors.go (85%)
 rename internal/stats/{ => renderer/v1}/image.go (87%)
 rename internal/stats/{ => renderer/v1}/metadata.go (90%)
 rename internal/stats/{ => renderer/v1}/period.go (91%)
 rename internal/stats/{ => renderer/v1}/renderer.go (92%)
 create mode 100644 internal/stats/renderer/v1/replay.go
 rename internal/stats/{ => renderer/v1}/session.go (95%)
 delete mode 100644 internal/stats/replay.go

diff --git a/cmds/core/client.go b/cmds/core/client.go
index 05d6060a..3653c1d1 100644
--- a/cmds/core/client.go
+++ b/cmds/core/client.go
@@ -3,8 +3,8 @@ package core
 import (
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/external/wargaming"
-	"github.com/cufee/aftermath/internal/stats"
-	"github.com/cufee/aftermath/internal/stats/fetch"
+	"github.com/cufee/aftermath/internal/stats/fetch/v1"
+	stats "github.com/cufee/aftermath/internal/stats/renderer/v1"
 	"golang.org/x/text/language"
 )
 
diff --git a/cmds/core/server/handlers/private/accounts.go b/cmds/core/server/handlers/private/accounts.go
index 90ef4164..0b8e3945 100644
--- a/cmds/core/server/handlers/private/accounts.go
+++ b/cmds/core/server/handlers/private/accounts.go
@@ -11,7 +11,7 @@ import (
 
 	"github.com/cufee/aftermath/cmds/core"
 	"github.com/cufee/aftermath/internal/database/models"
-	"github.com/cufee/aftermath/internal/stats/fetch"
+	"github.com/cufee/aftermath/internal/stats/fetch/v1"
 	"github.com/cufee/am-wg-proxy-next/v2/types"
 	"github.com/rs/zerolog/log"
 	"golang.org/x/sync/semaphore"
diff --git a/cmds/discord/commands/session.go b/cmds/discord/commands/session.go
index 591b7267..0fd10023 100644
--- a/cmds/discord/commands/session.go
+++ b/cmds/discord/commands/session.go
@@ -10,10 +10,10 @@ import (
 	"github.com/cufee/aftermath/cmds/discord/common"
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
-	"github.com/cufee/aftermath/internal/stats"
-	"github.com/cufee/aftermath/internal/stats/fetch"
+	"github.com/cufee/aftermath/internal/stats/fetch/v1"
 	"github.com/cufee/aftermath/internal/stats/render"
 	"github.com/cufee/aftermath/internal/stats/render/assets"
+	stats "github.com/cufee/aftermath/internal/stats/renderer/v1"
 	"github.com/pkg/errors"
 )
 
diff --git a/internal/logic/sessions.go b/internal/logic/sessions.go
index b816cd8e..80795daa 100644
--- a/internal/logic/sessions.go
+++ b/internal/logic/sessions.go
@@ -10,7 +10,7 @@ import (
 
 	"github.com/cufee/aftermath/internal/external/wargaming"
 	"github.com/cufee/aftermath/internal/retry"
-	"github.com/cufee/aftermath/internal/stats/fetch"
+	"github.com/cufee/aftermath/internal/stats/fetch/v1"
 	"github.com/cufee/am-wg-proxy-next/v2/types"
 	"github.com/pkg/errors"
 	"github.com/rs/zerolog/log"
diff --git a/internal/stats/fetch/client.go b/internal/stats/fetch/v1/client.go
similarity index 100%
rename from internal/stats/fetch/client.go
rename to internal/stats/fetch/v1/client.go
diff --git a/internal/stats/fetch/convert.go b/internal/stats/fetch/v1/convert.go
similarity index 100%
rename from internal/stats/fetch/convert.go
rename to internal/stats/fetch/v1/convert.go
diff --git a/internal/stats/fetch/errors.go b/internal/stats/fetch/v1/errors.go
similarity index 100%
rename from internal/stats/fetch/errors.go
rename to internal/stats/fetch/v1/errors.go
diff --git a/internal/stats/fetch/multisource.go b/internal/stats/fetch/v1/multisource.go
similarity index 100%
rename from internal/stats/fetch/multisource.go
rename to internal/stats/fetch/v1/multisource.go
diff --git a/internal/stats/fetch/replay/errors.go b/internal/stats/fetch/v1/replay/errors.go
similarity index 100%
rename from internal/stats/fetch/replay/errors.go
rename to internal/stats/fetch/v1/replay/errors.go
diff --git a/internal/stats/fetch/replay/meta.go b/internal/stats/fetch/v1/replay/meta.go
similarity index 100%
rename from internal/stats/fetch/replay/meta.go
rename to internal/stats/fetch/v1/replay/meta.go
diff --git a/internal/stats/fetch/replay/replay.go b/internal/stats/fetch/v1/replay/replay.go
similarity index 100%
rename from internal/stats/fetch/replay/replay.go
rename to internal/stats/fetch/v1/replay/replay.go
diff --git a/internal/stats/fetch/replay/results.go b/internal/stats/fetch/v1/replay/results.go
similarity index 100%
rename from internal/stats/fetch/replay/results.go
rename to internal/stats/fetch/v1/replay/results.go
diff --git a/internal/stats/fetch/replay/unpack.go b/internal/stats/fetch/v1/replay/unpack.go
similarity index 100%
rename from internal/stats/fetch/replay/unpack.go
rename to internal/stats/fetch/v1/replay/unpack.go
diff --git a/internal/stats/prepare/common/card.go b/internal/stats/prepare/common/v1/card.go
similarity index 100%
rename from internal/stats/prepare/common/card.go
rename to internal/stats/prepare/common/v1/card.go
diff --git a/internal/stats/prepare/common/convert.go b/internal/stats/prepare/common/v1/convert.go
similarity index 100%
rename from internal/stats/prepare/common/convert.go
rename to internal/stats/prepare/common/v1/convert.go
diff --git a/internal/stats/prepare/common/highlights.go b/internal/stats/prepare/common/v1/highlights.go
similarity index 100%
rename from internal/stats/prepare/common/highlights.go
rename to internal/stats/prepare/common/v1/highlights.go
diff --git a/internal/stats/prepare/common/options.go b/internal/stats/prepare/common/v1/options.go
similarity index 100%
rename from internal/stats/prepare/common/options.go
rename to internal/stats/prepare/common/v1/options.go
diff --git a/internal/stats/prepare/common/tags.go b/internal/stats/prepare/common/v1/tags.go
similarity index 100%
rename from internal/stats/prepare/common/tags.go
rename to internal/stats/prepare/common/v1/tags.go
diff --git a/internal/stats/prepare/period/card.go b/internal/stats/prepare/period/v1/card.go
similarity index 95%
rename from internal/stats/prepare/period/card.go
rename to internal/stats/prepare/period/v1/card.go
index 7fcffe72..ce1e0407 100644
--- a/internal/stats/prepare/period/card.go
+++ b/internal/stats/prepare/period/v1/card.go
@@ -5,8 +5,8 @@ import (
 	"math"
 
 	"github.com/cufee/aftermath/internal/database/models"
-	"github.com/cufee/aftermath/internal/stats/fetch"
-	"github.com/cufee/aftermath/internal/stats/prepare/common"
+	"github.com/cufee/aftermath/internal/stats/fetch/v1"
+	"github.com/cufee/aftermath/internal/stats/prepare/common/v1"
 )
 
 func NewCards(stats fetch.AccountStatsOverPeriod, glossary map[string]models.Vehicle, opts ...common.Option) (Cards, error) {
diff --git a/internal/stats/prepare/period/constants.go b/internal/stats/prepare/period/v1/constants.go
similarity index 93%
rename from internal/stats/prepare/period/constants.go
rename to internal/stats/prepare/period/v1/constants.go
index 7b4a70c2..eebf62fc 100644
--- a/internal/stats/prepare/period/constants.go
+++ b/internal/stats/prepare/period/v1/constants.go
@@ -1,7 +1,7 @@
 package period
 
 import (
-	"github.com/cufee/aftermath/internal/stats/prepare/common"
+	"github.com/cufee/aftermath/internal/stats/prepare/common/v1"
 )
 
 const TagAvgTier common.Tag = "avg_tier"
diff --git a/internal/stats/prepare/period/preset.go b/internal/stats/prepare/period/v1/preset.go
similarity index 94%
rename from internal/stats/prepare/period/preset.go
rename to internal/stats/prepare/period/v1/preset.go
index dfe9b336..fe41b8ae 100644
--- a/internal/stats/prepare/period/preset.go
+++ b/internal/stats/prepare/period/v1/preset.go
@@ -3,7 +3,7 @@ package period
 import (
 	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/stats/frame"
-	"github.com/cufee/aftermath/internal/stats/prepare/common"
+	"github.com/cufee/aftermath/internal/stats/prepare/common/v1"
 )
 
 func presetToBlock(preset common.Tag, stats frame.StatsFrame, vehicles map[string]frame.VehicleStatsFrame, glossary map[string]models.Vehicle) (common.StatsBlock[BlockData], error) {
diff --git a/internal/stats/prepare/replay/constants.go b/internal/stats/prepare/replay/v1/constants.go
similarity index 98%
rename from internal/stats/prepare/replay/constants.go
rename to internal/stats/prepare/replay/v1/constants.go
index e30da8e9..365fd831 100644
--- a/internal/stats/prepare/replay/constants.go
+++ b/internal/stats/prepare/replay/v1/constants.go
@@ -1,6 +1,6 @@
 package replay
 
-import "github.com/cufee/aftermath/internal/stats/prepare/common"
+import "github.com/cufee/aftermath/internal/stats/prepare/common/v1"
 
 const (
 	TagDamageBlocked          common.Tag = "blocked"
diff --git a/internal/stats/prepare/session/card.go b/internal/stats/prepare/session/v1/card.go
similarity index 98%
rename from internal/stats/prepare/session/card.go
rename to internal/stats/prepare/session/v1/card.go
index ea7ede65..b74511bc 100644
--- a/internal/stats/prepare/session/card.go
+++ b/internal/stats/prepare/session/v1/card.go
@@ -5,9 +5,9 @@ import (
 	"slices"
 
 	"github.com/cufee/aftermath/internal/database/models"
-	"github.com/cufee/aftermath/internal/stats/fetch"
+	"github.com/cufee/aftermath/internal/stats/fetch/v1"
 	"github.com/cufee/aftermath/internal/stats/frame"
-	"github.com/cufee/aftermath/internal/stats/prepare/common"
+	"github.com/cufee/aftermath/internal/stats/prepare/common/v1"
 	"golang.org/x/text/language"
 )
 
diff --git a/internal/stats/prepare/session/constants.go b/internal/stats/prepare/session/v1/constants.go
similarity index 94%
rename from internal/stats/prepare/session/constants.go
rename to internal/stats/prepare/session/v1/constants.go
index 6e8a4533..b663a651 100644
--- a/internal/stats/prepare/session/constants.go
+++ b/internal/stats/prepare/session/v1/constants.go
@@ -2,7 +2,7 @@ package session
 
 import (
 	"github.com/cufee/aftermath/internal/stats/frame"
-	"github.com/cufee/aftermath/internal/stats/prepare/common"
+	"github.com/cufee/aftermath/internal/stats/prepare/common/v1"
 )
 
 var unratedOverviewBlocks = [][]common.Tag{{common.TagBattles, common.TagWinrate}, {common.TagWN8}, {common.TagAvgDamage, common.TagDamageRatio}}
diff --git a/internal/stats/prepare/session/preset.go b/internal/stats/prepare/session/v1/preset.go
similarity index 93%
rename from internal/stats/prepare/session/preset.go
rename to internal/stats/prepare/session/v1/preset.go
index 5c496b0c..2df59e61 100644
--- a/internal/stats/prepare/session/preset.go
+++ b/internal/stats/prepare/session/v1/preset.go
@@ -2,7 +2,7 @@ package session
 
 import (
 	"github.com/cufee/aftermath/internal/stats/frame"
-	"github.com/cufee/aftermath/internal/stats/prepare/common"
+	"github.com/cufee/aftermath/internal/stats/prepare/common/v1"
 )
 
 func presetToBlock(preset common.Tag, session, career frame.StatsFrame) (common.StatsBlock[BlockData], error) {
diff --git a/internal/stats/render/common/badges.go b/internal/stats/render/common/v1/badges.go
similarity index 100%
rename from internal/stats/render/common/badges.go
rename to internal/stats/render/common/v1/badges.go
diff --git a/internal/stats/render/common/block.go b/internal/stats/render/common/v1/block.go
similarity index 100%
rename from internal/stats/render/common/block.go
rename to internal/stats/render/common/v1/block.go
diff --git a/internal/stats/render/common/calculations.go b/internal/stats/render/common/v1/calculations.go
similarity index 100%
rename from internal/stats/render/common/calculations.go
rename to internal/stats/render/common/v1/calculations.go
diff --git a/internal/stats/render/common/colors.go b/internal/stats/render/common/v1/colors.go
similarity index 100%
rename from internal/stats/render/common/colors.go
rename to internal/stats/render/common/v1/colors.go
diff --git a/internal/stats/render/common/constants.go b/internal/stats/render/common/v1/constants.go
similarity index 100%
rename from internal/stats/render/common/constants.go
rename to internal/stats/render/common/v1/constants.go
diff --git a/internal/stats/render/common/footer.go b/internal/stats/render/common/v1/footer.go
similarity index 100%
rename from internal/stats/render/common/footer.go
rename to internal/stats/render/common/v1/footer.go
diff --git a/internal/stats/render/common/header.go b/internal/stats/render/common/v1/header.go
similarity index 100%
rename from internal/stats/render/common/header.go
rename to internal/stats/render/common/v1/header.go
diff --git a/internal/stats/render/common/images.go b/internal/stats/render/common/v1/images.go
similarity index 100%
rename from internal/stats/render/common/images.go
rename to internal/stats/render/common/v1/images.go
diff --git a/internal/stats/render/common/logo.go b/internal/stats/render/common/v1/logo.go
similarity index 100%
rename from internal/stats/render/common/logo.go
rename to internal/stats/render/common/v1/logo.go
diff --git a/internal/stats/render/common/player_title.go b/internal/stats/render/common/v1/player_title.go
similarity index 100%
rename from internal/stats/render/common/player_title.go
rename to internal/stats/render/common/v1/player_title.go
diff --git a/internal/stats/render/common/strings.go b/internal/stats/render/common/v1/strings.go
similarity index 100%
rename from internal/stats/render/common/strings.go
rename to internal/stats/render/common/v1/strings.go
diff --git a/internal/stats/render/common/style.go b/internal/stats/render/common/v1/style.go
similarity index 100%
rename from internal/stats/render/common/style.go
rename to internal/stats/render/common/v1/style.go
diff --git a/internal/stats/render/common/tier_percentage.go b/internal/stats/render/common/v1/tier_percentage.go
similarity index 100%
rename from internal/stats/render/common/tier_percentage.go
rename to internal/stats/render/common/v1/tier_percentage.go
diff --git a/internal/stats/render/common/wn8.go b/internal/stats/render/common/v1/wn8.go
similarity index 100%
rename from internal/stats/render/common/wn8.go
rename to internal/stats/render/common/v1/wn8.go
diff --git a/internal/stats/render/period/block.go b/internal/stats/render/period/v1/block.go
similarity index 94%
rename from internal/stats/render/period/block.go
rename to internal/stats/render/period/v1/block.go
index 2fd79d80..96057065 100644
--- a/internal/stats/render/period/block.go
+++ b/internal/stats/render/period/v1/block.go
@@ -1,9 +1,9 @@
 package period
 
 import (
-	prepare "github.com/cufee/aftermath/internal/stats/prepare/common"
-	"github.com/cufee/aftermath/internal/stats/prepare/period"
-	"github.com/cufee/aftermath/internal/stats/render/common"
+	prepare "github.com/cufee/aftermath/internal/stats/prepare/common/v1"
+	"github.com/cufee/aftermath/internal/stats/prepare/period/v1"
+	"github.com/cufee/aftermath/internal/stats/render/common/v1"
 )
 
 func statsBlocksToColumnBlock(style overviewStyle, statsBlocks []prepare.StatsBlock[period.BlockData]) (common.Block, error) {
diff --git a/internal/stats/render/period/cards.go b/internal/stats/render/period/v1/cards.go
similarity index 97%
rename from internal/stats/render/period/cards.go
rename to internal/stats/render/period/v1/cards.go
index 0074d6fc..b03cc4b0 100644
--- a/internal/stats/render/period/cards.go
+++ b/internal/stats/render/period/v1/cards.go
@@ -6,11 +6,11 @@ import (
 	"github.com/pkg/errors"
 
 	"github.com/cufee/aftermath/internal/database/models"
-	"github.com/cufee/aftermath/internal/stats/fetch"
-	prepare "github.com/cufee/aftermath/internal/stats/prepare/common"
-	"github.com/cufee/aftermath/internal/stats/prepare/period"
+	"github.com/cufee/aftermath/internal/stats/fetch/v1"
+	prepare "github.com/cufee/aftermath/internal/stats/prepare/common/v1"
+	"github.com/cufee/aftermath/internal/stats/prepare/period/v1"
 	"github.com/cufee/aftermath/internal/stats/render"
-	"github.com/cufee/aftermath/internal/stats/render/common"
+	"github.com/cufee/aftermath/internal/stats/render/common/v1"
 
 	"github.com/rs/zerolog/log"
 )
diff --git a/internal/stats/render/period/constants.go b/internal/stats/render/period/v1/constants.go
similarity index 95%
rename from internal/stats/render/period/constants.go
rename to internal/stats/render/period/v1/constants.go
index 74837a58..ed174590 100644
--- a/internal/stats/render/period/constants.go
+++ b/internal/stats/render/period/v1/constants.go
@@ -1,9 +1,9 @@
 package period
 
 import (
-	prepare "github.com/cufee/aftermath/internal/stats/prepare/common"
-	"github.com/cufee/aftermath/internal/stats/prepare/period"
-	"github.com/cufee/aftermath/internal/stats/render/common"
+	prepare "github.com/cufee/aftermath/internal/stats/prepare/common/v1"
+	"github.com/cufee/aftermath/internal/stats/prepare/period/v1"
+	"github.com/cufee/aftermath/internal/stats/render/common/v1"
 )
 
 type overviewStyle struct {
diff --git a/internal/stats/render/period/image.go b/internal/stats/render/period/v1/image.go
similarity index 81%
rename from internal/stats/render/period/image.go
rename to internal/stats/render/period/v1/image.go
index 47f9f5aa..f7e67e10 100644
--- a/internal/stats/render/period/image.go
+++ b/internal/stats/render/period/v1/image.go
@@ -4,8 +4,8 @@ import (
 	"image"
 
 	"github.com/cufee/aftermath/internal/database/models"
-	"github.com/cufee/aftermath/internal/stats/fetch"
-	"github.com/cufee/aftermath/internal/stats/prepare/period"
+	"github.com/cufee/aftermath/internal/stats/fetch/v1"
+	"github.com/cufee/aftermath/internal/stats/prepare/period/v1"
 	"github.com/cufee/aftermath/internal/stats/render"
 )
 
diff --git a/internal/stats/render/replay/blocks.go.todo b/internal/stats/render/replay/v1/blocks.go.todo
similarity index 98%
rename from internal/stats/render/replay/blocks.go.todo
rename to internal/stats/render/replay/v1/blocks.go.todo
index ab08e47b..1759c735 100644
--- a/internal/stats/render/replay/blocks.go.todo
+++ b/internal/stats/render/replay/v1/blocks.go.todo
@@ -7,7 +7,7 @@ import (
 	"github.com/cufee/aftermath-core/dataprep"
 	"github.com/cufee/aftermath-core/dataprep/replay"
 	prepare "github.com/cufee/aftermath/internal/stats/prepare/replay"
-	"github.com/cufee/aftermath/internal/stats/render/common"
+	"github.com/cufee/aftermath/internal/stats/render/common/v1"
 )
 
 func newTitleBlock(replay *prepare.Replay, width float64, printer func(string) string) common.Block {
diff --git a/internal/stats/render/replay/cards.go.todo b/internal/stats/render/replay/v1/cards.go.todo
similarity index 100%
rename from internal/stats/render/replay/cards.go.todo
rename to internal/stats/render/replay/v1/cards.go.todo
diff --git a/internal/stats/render/replay/constants.go.todo b/internal/stats/render/replay/v1/constants.go.todo
similarity index 100%
rename from internal/stats/render/replay/constants.go.todo
rename to internal/stats/render/replay/v1/constants.go.todo
diff --git a/internal/stats/render/replay/elements.go.todo b/internal/stats/render/replay/v1/elements.go.todo
similarity index 100%
rename from internal/stats/render/replay/elements.go.todo
rename to internal/stats/render/replay/v1/elements.go.todo
diff --git a/internal/stats/render/replay/preset.go.todo b/internal/stats/render/replay/v1/preset.go.todo
similarity index 100%
rename from internal/stats/render/replay/preset.go.todo
rename to internal/stats/render/replay/v1/preset.go.todo
diff --git a/internal/stats/render/segments.go b/internal/stats/render/segments.go
index 222d8eaf..76ad27ec 100644
--- a/internal/stats/render/segments.go
+++ b/internal/stats/render/segments.go
@@ -5,7 +5,7 @@ import (
 
 	"github.com/pkg/errors"
 
-	"github.com/cufee/aftermath/internal/stats/render/common"
+	"github.com/cufee/aftermath/internal/stats/render/common/v1"
 )
 
 type Segments struct {
diff --git a/internal/stats/render/session/blocks.go b/internal/stats/render/session/v1/blocks.go
similarity index 97%
rename from internal/stats/render/session/blocks.go
rename to internal/stats/render/session/v1/blocks.go
index 8f7bc811..6dba350c 100644
--- a/internal/stats/render/session/blocks.go
+++ b/internal/stats/render/session/v1/blocks.go
@@ -4,10 +4,10 @@ import (
 	"image/color"
 
 	"github.com/cufee/aftermath/internal/stats/frame"
-	prepare "github.com/cufee/aftermath/internal/stats/prepare/common"
-	"github.com/cufee/aftermath/internal/stats/prepare/session"
+	prepare "github.com/cufee/aftermath/internal/stats/prepare/common/v1"
+	"github.com/cufee/aftermath/internal/stats/prepare/session/v1"
 	"github.com/cufee/aftermath/internal/stats/render/assets"
-	"github.com/cufee/aftermath/internal/stats/render/common"
+	"github.com/cufee/aftermath/internal/stats/render/common/v1"
 	"github.com/disintegration/imaging"
 	"github.com/fogleman/gg"
 )
diff --git a/internal/stats/render/session/cards.go b/internal/stats/render/session/v1/cards.go
similarity index 98%
rename from internal/stats/render/session/cards.go
rename to internal/stats/render/session/v1/cards.go
index 28dd1dca..6d129ef4 100644
--- a/internal/stats/render/session/cards.go
+++ b/internal/stats/render/session/v1/cards.go
@@ -5,11 +5,11 @@ import (
 	"strings"
 
 	"github.com/cufee/aftermath/internal/database/models"
-	"github.com/cufee/aftermath/internal/stats/fetch"
+	"github.com/cufee/aftermath/internal/stats/fetch/v1"
 	"github.com/cufee/aftermath/internal/stats/frame"
-	prepare "github.com/cufee/aftermath/internal/stats/prepare/common"
-	"github.com/cufee/aftermath/internal/stats/prepare/session"
-	"github.com/cufee/aftermath/internal/stats/render/common"
+	prepare "github.com/cufee/aftermath/internal/stats/prepare/common/v1"
+	"github.com/cufee/aftermath/internal/stats/prepare/session/v1"
+	"github.com/cufee/aftermath/internal/stats/render/common/v1"
 
 	"github.com/cufee/aftermath/internal/stats/render"
 )
diff --git a/internal/stats/render/session/constants.go b/internal/stats/render/session/v1/constants.go
similarity index 98%
rename from internal/stats/render/session/constants.go
rename to internal/stats/render/session/v1/constants.go
index e85ffc62..8ef10208 100644
--- a/internal/stats/render/session/constants.go
+++ b/internal/stats/render/session/v1/constants.go
@@ -3,7 +3,7 @@ package session
 import (
 	"image/color"
 
-	"github.com/cufee/aftermath/internal/stats/render/common"
+	"github.com/cufee/aftermath/internal/stats/render/common/v1"
 )
 
 type blockStyle struct {
diff --git a/internal/stats/render/session/icons.go b/internal/stats/render/session/v1/icons.go
similarity index 93%
rename from internal/stats/render/session/icons.go
rename to internal/stats/render/session/v1/icons.go
index 33a87c4e..1684fbaf 100644
--- a/internal/stats/render/session/icons.go
+++ b/internal/stats/render/session/v1/icons.go
@@ -3,7 +3,7 @@ package session
 import (
 	"github.com/cufee/aftermath/internal/stats/frame"
 	"github.com/cufee/aftermath/internal/stats/render/assets"
-	"github.com/cufee/aftermath/internal/stats/render/common"
+	"github.com/cufee/aftermath/internal/stats/render/common/v1"
 )
 
 var iconsCache = make(map[string]common.Block, 6)
diff --git a/internal/stats/render/session/image.go b/internal/stats/render/session/v1/image.go
similarity index 81%
rename from internal/stats/render/session/image.go
rename to internal/stats/render/session/v1/image.go
index 65ea4196..3ea7aef5 100644
--- a/internal/stats/render/session/image.go
+++ b/internal/stats/render/session/v1/image.go
@@ -4,8 +4,8 @@ import (
 	"image"
 
 	"github.com/cufee/aftermath/internal/database/models"
-	"github.com/cufee/aftermath/internal/stats/fetch"
-	"github.com/cufee/aftermath/internal/stats/prepare/session"
+	"github.com/cufee/aftermath/internal/stats/fetch/v1"
+	"github.com/cufee/aftermath/internal/stats/prepare/session/v1"
 	"github.com/cufee/aftermath/internal/stats/render"
 )
 
diff --git a/internal/stats/errors.go b/internal/stats/renderer/v1/errors.go
similarity index 85%
rename from internal/stats/errors.go
rename to internal/stats/renderer/v1/errors.go
index 4bcd0ddf..a09051b0 100644
--- a/internal/stats/errors.go
+++ b/internal/stats/renderer/v1/errors.go
@@ -1,4 +1,4 @@
-package stats
+package renderer
 
 import (
 	"github.com/pkg/errors"
diff --git a/internal/stats/image.go b/internal/stats/renderer/v1/image.go
similarity index 87%
rename from internal/stats/image.go
rename to internal/stats/renderer/v1/image.go
index 7e46305c..d82f9507 100644
--- a/internal/stats/image.go
+++ b/internal/stats/renderer/v1/image.go
@@ -1,4 +1,4 @@
-package stats
+package renderer
 
 import (
 	"image"
@@ -7,7 +7,7 @@ import (
 
 	"github.com/pkg/errors"
 
-	"github.com/cufee/aftermath/internal/stats/render/common"
+	"github.com/cufee/aftermath/internal/stats/render/common/v1"
 )
 
 type Image interface {
diff --git a/internal/stats/metadata.go b/internal/stats/renderer/v1/metadata.go
similarity index 90%
rename from internal/stats/metadata.go
rename to internal/stats/renderer/v1/metadata.go
index 78c6a2a8..e5ffd158 100644
--- a/internal/stats/metadata.go
+++ b/internal/stats/renderer/v1/metadata.go
@@ -1,9 +1,9 @@
-package stats
+package renderer
 
 import (
 	"time"
 
-	"github.com/cufee/aftermath/internal/stats/fetch"
+	"github.com/cufee/aftermath/internal/stats/fetch/v1"
 )
 
 type Metadata struct {
diff --git a/internal/stats/period.go b/internal/stats/renderer/v1/period.go
similarity index 91%
rename from internal/stats/period.go
rename to internal/stats/renderer/v1/period.go
index 96b518f7..6e499c7d 100644
--- a/internal/stats/period.go
+++ b/internal/stats/renderer/v1/period.go
@@ -1,4 +1,4 @@
-package stats
+package renderer
 
 import (
 	"context"
@@ -6,11 +6,11 @@ import (
 	"time"
 
 	"github.com/cufee/aftermath/internal/localization"
-	"github.com/cufee/aftermath/internal/stats/fetch"
-	"github.com/cufee/aftermath/internal/stats/prepare/common"
-	prepare "github.com/cufee/aftermath/internal/stats/prepare/period"
+	"github.com/cufee/aftermath/internal/stats/fetch/v1"
+	"github.com/cufee/aftermath/internal/stats/prepare/common/v1"
+	prepare "github.com/cufee/aftermath/internal/stats/prepare/period/v1"
 	options "github.com/cufee/aftermath/internal/stats/render"
-	render "github.com/cufee/aftermath/internal/stats/render/period"
+	render "github.com/cufee/aftermath/internal/stats/render/period/v1"
 )
 
 func (r *renderer) Period(ctx context.Context, accountId string, from time.Time, opts ...options.Option) (Image, Metadata, error) {
diff --git a/internal/stats/renderer.go b/internal/stats/renderer/v1/renderer.go
similarity index 92%
rename from internal/stats/renderer.go
rename to internal/stats/renderer/v1/renderer.go
index 9c144826..2b2023da 100644
--- a/internal/stats/renderer.go
+++ b/internal/stats/renderer/v1/renderer.go
@@ -1,4 +1,4 @@
-package stats
+package renderer
 
 import (
 	"context"
@@ -6,7 +6,7 @@ import (
 
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/external/wargaming"
-	"github.com/cufee/aftermath/internal/stats/fetch"
+	"github.com/cufee/aftermath/internal/stats/fetch/v1"
 	"github.com/cufee/aftermath/internal/stats/render"
 	"golang.org/x/text/language"
 )
diff --git a/internal/stats/renderer/v1/replay.go b/internal/stats/renderer/v1/replay.go
new file mode 100644
index 00000000..35803f64
--- /dev/null
+++ b/internal/stats/renderer/v1/replay.go
@@ -0,0 +1 @@
+package renderer
diff --git a/internal/stats/session.go b/internal/stats/renderer/v1/session.go
similarity index 95%
rename from internal/stats/session.go
rename to internal/stats/renderer/v1/session.go
index 3d7cd416..cc6b9b5a 100644
--- a/internal/stats/session.go
+++ b/internal/stats/renderer/v1/session.go
@@ -1,4 +1,4 @@
-package stats
+package renderer
 
 import (
 	"context"
@@ -9,11 +9,11 @@ import (
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/localization"
 	"github.com/cufee/aftermath/internal/logic"
-	"github.com/cufee/aftermath/internal/stats/fetch"
-	"github.com/cufee/aftermath/internal/stats/prepare/common"
-	prepare "github.com/cufee/aftermath/internal/stats/prepare/session"
+	"github.com/cufee/aftermath/internal/stats/fetch/v1"
+	"github.com/cufee/aftermath/internal/stats/prepare/common/v1"
+	prepare "github.com/cufee/aftermath/internal/stats/prepare/session/v1"
 	options "github.com/cufee/aftermath/internal/stats/render"
-	render "github.com/cufee/aftermath/internal/stats/render/session"
+	render "github.com/cufee/aftermath/internal/stats/render/session/v1"
 	"github.com/rs/zerolog/log"
 )
 
diff --git a/internal/stats/replay.go b/internal/stats/replay.go
deleted file mode 100644
index 43b4fd56..00000000
--- a/internal/stats/replay.go
+++ /dev/null
@@ -1 +0,0 @@
-package stats
diff --git a/main.go b/main.go
index 3111fe1b..e51ab75d 100644
--- a/main.go
+++ b/main.go
@@ -20,10 +20,10 @@ import (
 	"github.com/cufee/aftermath/internal/external/wargaming"
 	"github.com/cufee/aftermath/internal/localization"
 	"github.com/cufee/aftermath/internal/logic"
-	"github.com/cufee/aftermath/internal/stats/fetch"
+	"github.com/cufee/aftermath/internal/stats/fetch/v1"
 
 	"github.com/cufee/aftermath/internal/stats/render/assets"
-	render "github.com/cufee/aftermath/internal/stats/render/common"
+	render "github.com/cufee/aftermath/internal/stats/render/common/v1"
 	"github.com/rs/zerolog"
 	"github.com/rs/zerolog/log"
 
@@ -57,15 +57,15 @@ func main() {
 		port := os.Getenv("PRIVATE_SERVER_PORT")
 		servePrivate := server.NewServer(port, []server.Handler{
 			{
-				Path: "POST /tasks/restart",
+				Path: "POST /v1/tasks/restart",
 				Func: private.RestartStaleTasks(cacheCoreClient),
 			},
 			{
-				Path: "POST /accounts/import",
+				Path: "POST /v1/accounts/import",
 				Func: private.LoadAccountsHandler(cacheCoreClient),
 			},
 			{
-				Path: "POST /snapshots/{realm}",
+				Path: "POST /v1/snapshots/{realm}",
 				Func: private.SaveRealmSnapshots(cacheCoreClient),
 			},
 		}...)
diff --git a/render_test.go b/render_test.go
index 6dc761be..810b5f5c 100644
--- a/render_test.go
+++ b/render_test.go
@@ -6,9 +6,9 @@ import (
 	"testing"
 	"time"
 
-	"github.com/cufee/aftermath/internal/stats"
 	"github.com/cufee/aftermath/internal/stats/render"
 	"github.com/cufee/aftermath/internal/stats/render/assets"
+	stats "github.com/cufee/aftermath/internal/stats/renderer/v1"
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/assert"
 	"golang.org/x/text/language"

From f3ab9e83605ee1763d8cb1423bec96bcea7c2b20 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 23 Jun 2024 19:13:17 -0400
Subject: [PATCH 155/341] more versioning

---
 cmds/discord/commands/session.go              |  2 +-
 cmds/discord/commands/stats.go                |  2 +-
 .../stats/render/{ => common/v1}/options.go   |  2 +-
 internal/stats/render/common/v1/segments.go   | 80 ++++++++++++++++++
 internal/stats/render/period/v1/cards.go      |  7 +-
 internal/stats/render/period/v1/image.go      |  6 +-
 internal/stats/render/segments.go             | 82 -------------------
 internal/stats/render/session/v1/cards.go     |  6 +-
 internal/stats/render/session/v1/image.go     |  6 +-
 internal/stats/renderer/v1/period.go          |  8 +-
 internal/stats/renderer/v1/renderer.go        |  6 +-
 internal/stats/renderer/v1/session.go         |  2 +-
 render_test.go                                |  4 +-
 13 files changed, 104 insertions(+), 109 deletions(-)
 rename internal/stats/render/{ => common/v1}/options.go (96%)
 create mode 100644 internal/stats/render/common/v1/segments.go
 delete mode 100644 internal/stats/render/segments.go

diff --git a/cmds/discord/commands/session.go b/cmds/discord/commands/session.go
index 0fd10023..b81e0e78 100644
--- a/cmds/discord/commands/session.go
+++ b/cmds/discord/commands/session.go
@@ -11,8 +11,8 @@ import (
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/stats/fetch/v1"
-	"github.com/cufee/aftermath/internal/stats/render"
 	"github.com/cufee/aftermath/internal/stats/render/assets"
+	render "github.com/cufee/aftermath/internal/stats/render/common/v1"
 	stats "github.com/cufee/aftermath/internal/stats/renderer/v1"
 	"github.com/pkg/errors"
 )
diff --git a/cmds/discord/commands/stats.go b/cmds/discord/commands/stats.go
index 70f57879..505c21ef 100644
--- a/cmds/discord/commands/stats.go
+++ b/cmds/discord/commands/stats.go
@@ -10,8 +10,8 @@ import (
 	"github.com/cufee/aftermath/cmds/discord/common"
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
-	"github.com/cufee/aftermath/internal/stats/render"
 	"github.com/cufee/aftermath/internal/stats/render/assets"
+	render "github.com/cufee/aftermath/internal/stats/render/common/v1"
 )
 
 func init() {
diff --git a/internal/stats/render/options.go b/internal/stats/render/common/v1/options.go
similarity index 96%
rename from internal/stats/render/options.go
rename to internal/stats/render/common/v1/options.go
index 014a43c4..c334d085 100644
--- a/internal/stats/render/options.go
+++ b/internal/stats/render/common/v1/options.go
@@ -1,4 +1,4 @@
-package render
+package common
 
 import (
 	"image"
diff --git a/internal/stats/render/common/v1/segments.go b/internal/stats/render/common/v1/segments.go
new file mode 100644
index 00000000..869548f5
--- /dev/null
+++ b/internal/stats/render/common/v1/segments.go
@@ -0,0 +1,80 @@
+package common
+
+import (
+	"image"
+
+	"github.com/pkg/errors"
+)
+
+type Segments struct {
+	header  []Block
+	content []Block
+	footer  []Block
+}
+
+func (s *Segments) AddHeader(blocks ...Block) {
+	s.header = append(s.header, blocks...)
+}
+
+func (s *Segments) AddContent(blocks ...Block) {
+	s.content = append(s.content, blocks...)
+}
+
+func (s *Segments) AddFooter(blocks ...Block) {
+	s.footer = append(s.footer, blocks...)
+}
+
+func (s *Segments) Render(opts ...Option) (image.Image, error) {
+	if len(s.content) < 1 {
+		return nil, errors.New("segments.content cannot be empty")
+	}
+
+	options := DefaultOptions()
+	for _, apply := range opts {
+		apply(&options)
+	}
+
+	var frameParts []Block
+
+	mainSegment := NewBlocksContent(
+		Style{
+			Direction:  DirectionVertical,
+			AlignItems: AlignItemsCenter,
+			PaddingX:   20,
+			PaddingY:   20,
+			Gap:        10,
+		}, s.content...)
+	mainSegmentImg, err := mainSegment.Render()
+	if err != nil {
+		return nil, err
+	}
+	mainSegmentImg = AddBackground(mainSegmentImg, options.Background, Style{Blur: 10, BorderRadius: 42.5})
+
+	frameParts = append(frameParts, NewImageContent(Style{}, mainSegmentImg))
+	if len(s.header) > 0 {
+		frameParts = append(frameParts, NewBlocksContent(
+			Style{
+				Direction:  DirectionVertical,
+				AlignItems: AlignItemsCenter,
+				Gap:        10,
+			}, s.header...))
+	}
+	if len(s.footer) > 0 {
+		frameParts = append(frameParts, NewBlocksContent(
+			Style{
+				Direction:  DirectionVertical,
+				AlignItems: AlignItemsCenter,
+				Gap:        10,
+			}, s.footer...))
+	}
+
+	frame := NewBlocksContent(
+		Style{
+			Direction:  DirectionVertical,
+			AlignItems: AlignItemsCenter,
+			Gap:        5,
+		},
+		frameParts...,
+	)
+	return frame.Render()
+}
diff --git a/internal/stats/render/period/v1/cards.go b/internal/stats/render/period/v1/cards.go
index b03cc4b0..2fa066d9 100644
--- a/internal/stats/render/period/v1/cards.go
+++ b/internal/stats/render/period/v1/cards.go
@@ -9,19 +9,18 @@ import (
 	"github.com/cufee/aftermath/internal/stats/fetch/v1"
 	prepare "github.com/cufee/aftermath/internal/stats/prepare/common/v1"
 	"github.com/cufee/aftermath/internal/stats/prepare/period/v1"
-	"github.com/cufee/aftermath/internal/stats/render"
 	"github.com/cufee/aftermath/internal/stats/render/common/v1"
 
 	"github.com/rs/zerolog/log"
 )
 
-func generateCards(stats fetch.AccountStatsOverPeriod, cards period.Cards, subs []models.UserSubscription, opts render.Options) (render.Segments, error) {
+func generateCards(stats fetch.AccountStatsOverPeriod, cards period.Cards, subs []models.UserSubscription, opts common.Options) (common.Segments, error) {
 	if len(cards.Overview.Blocks) == 0 && len(cards.Highlights) == 0 {
 		log.Error().Msg("player cards slice is 0 length, this should not happen")
-		return render.Segments{}, errors.New("no cards provided")
+		return common.Segments{}, errors.New("no cards provided")
 	}
 
-	var segments render.Segments
+	var segments common.Segments
 
 	// Calculate minimal card width to fit all the content
 	var cardWidth float64
diff --git a/internal/stats/render/period/v1/image.go b/internal/stats/render/period/v1/image.go
index f7e67e10..e8f0c56e 100644
--- a/internal/stats/render/period/v1/image.go
+++ b/internal/stats/render/period/v1/image.go
@@ -6,11 +6,11 @@ import (
 	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/stats/fetch/v1"
 	"github.com/cufee/aftermath/internal/stats/prepare/period/v1"
-	"github.com/cufee/aftermath/internal/stats/render"
+	"github.com/cufee/aftermath/internal/stats/render/common/v1"
 )
 
-func CardsToImage(stats fetch.AccountStatsOverPeriod, cards period.Cards, subs []models.UserSubscription, opts ...render.Option) (image.Image, error) {
-	o := render.DefaultOptions()
+func CardsToImage(stats fetch.AccountStatsOverPeriod, cards period.Cards, subs []models.UserSubscription, opts ...common.Option) (image.Image, error) {
+	o := common.DefaultOptions()
 	for _, apply := range opts {
 		apply(&o)
 	}
diff --git a/internal/stats/render/segments.go b/internal/stats/render/segments.go
deleted file mode 100644
index 76ad27ec..00000000
--- a/internal/stats/render/segments.go
+++ /dev/null
@@ -1,82 +0,0 @@
-package render
-
-import (
-	"image"
-
-	"github.com/pkg/errors"
-
-	"github.com/cufee/aftermath/internal/stats/render/common/v1"
-)
-
-type Segments struct {
-	header  []common.Block
-	content []common.Block
-	footer  []common.Block
-}
-
-func (s *Segments) AddHeader(blocks ...common.Block) {
-	s.header = append(s.header, blocks...)
-}
-
-func (s *Segments) AddContent(blocks ...common.Block) {
-	s.content = append(s.content, blocks...)
-}
-
-func (s *Segments) AddFooter(blocks ...common.Block) {
-	s.footer = append(s.footer, blocks...)
-}
-
-func (s *Segments) Render(opts ...Option) (image.Image, error) {
-	if len(s.content) < 1 {
-		return nil, errors.New("segments.content cannot be empty")
-	}
-
-	options := DefaultOptions()
-	for _, apply := range opts {
-		apply(&options)
-	}
-
-	var frameParts []common.Block
-
-	mainSegment := common.NewBlocksContent(
-		common.Style{
-			Direction:  common.DirectionVertical,
-			AlignItems: common.AlignItemsCenter,
-			PaddingX:   20,
-			PaddingY:   20,
-			Gap:        10,
-		}, s.content...)
-	mainSegmentImg, err := mainSegment.Render()
-	if err != nil {
-		return nil, err
-	}
-	mainSegmentImg = common.AddBackground(mainSegmentImg, options.Background, common.Style{Blur: 10, BorderRadius: 42.5})
-
-	frameParts = append(frameParts, common.NewImageContent(common.Style{}, mainSegmentImg))
-	if len(s.header) > 0 {
-		frameParts = append(frameParts, common.NewBlocksContent(
-			common.Style{
-				Direction:  common.DirectionVertical,
-				AlignItems: common.AlignItemsCenter,
-				Gap:        10,
-			}, s.header...))
-	}
-	if len(s.footer) > 0 {
-		frameParts = append(frameParts, common.NewBlocksContent(
-			common.Style{
-				Direction:  common.DirectionVertical,
-				AlignItems: common.AlignItemsCenter,
-				Gap:        10,
-			}, s.footer...))
-	}
-
-	frame := common.NewBlocksContent(
-		common.Style{
-			Direction:  common.DirectionVertical,
-			AlignItems: common.AlignItemsCenter,
-			Gap:        5,
-		},
-		frameParts...,
-	)
-	return frame.Render()
-}
diff --git a/internal/stats/render/session/v1/cards.go b/internal/stats/render/session/v1/cards.go
index 6d129ef4..2eed140d 100644
--- a/internal/stats/render/session/v1/cards.go
+++ b/internal/stats/render/session/v1/cards.go
@@ -10,11 +10,9 @@ import (
 	prepare "github.com/cufee/aftermath/internal/stats/prepare/common/v1"
 	"github.com/cufee/aftermath/internal/stats/prepare/session/v1"
 	"github.com/cufee/aftermath/internal/stats/render/common/v1"
-
-	"github.com/cufee/aftermath/internal/stats/render"
 )
 
-func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Cards, subs []models.UserSubscription, opts render.Options) (render.Segments, error) {
+func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Cards, subs []models.UserSubscription, opts common.Options) (common.Segments, error) {
 	var (
 		// primary cards
 		// when there are some unrated battles or no battles at all
@@ -28,7 +26,7 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 		shouldRenderUnratedVehicles = len(cards.Unrated.Vehicles) > 0
 	)
 
-	var segments render.Segments
+	var segments common.Segments
 	var primaryColumn []common.Block
 	var secondaryColumn []common.Block
 
diff --git a/internal/stats/render/session/v1/image.go b/internal/stats/render/session/v1/image.go
index 3ea7aef5..69d5de1b 100644
--- a/internal/stats/render/session/v1/image.go
+++ b/internal/stats/render/session/v1/image.go
@@ -6,11 +6,11 @@ import (
 	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/stats/fetch/v1"
 	"github.com/cufee/aftermath/internal/stats/prepare/session/v1"
-	"github.com/cufee/aftermath/internal/stats/render"
+	"github.com/cufee/aftermath/internal/stats/render/common/v1"
 )
 
-func CardsToImage(session, career fetch.AccountStatsOverPeriod, cards session.Cards, subs []models.UserSubscription, opts ...render.Option) (image.Image, error) {
-	o := render.DefaultOptions()
+func CardsToImage(session, career fetch.AccountStatsOverPeriod, cards session.Cards, subs []models.UserSubscription, opts ...common.Option) (image.Image, error) {
+	o := common.DefaultOptions()
 	for _, apply := range opts {
 		apply(&o)
 	}
diff --git a/internal/stats/renderer/v1/period.go b/internal/stats/renderer/v1/period.go
index 6e499c7d..bea9d49f 100644
--- a/internal/stats/renderer/v1/period.go
+++ b/internal/stats/renderer/v1/period.go
@@ -7,13 +7,13 @@ import (
 
 	"github.com/cufee/aftermath/internal/localization"
 	"github.com/cufee/aftermath/internal/stats/fetch/v1"
-	"github.com/cufee/aftermath/internal/stats/prepare/common/v1"
+	pcommon "github.com/cufee/aftermath/internal/stats/prepare/common/v1"
 	prepare "github.com/cufee/aftermath/internal/stats/prepare/period/v1"
-	options "github.com/cufee/aftermath/internal/stats/render"
+	rcommon "github.com/cufee/aftermath/internal/stats/render/common/v1"
 	render "github.com/cufee/aftermath/internal/stats/render/period/v1"
 )
 
-func (r *renderer) Period(ctx context.Context, accountId string, from time.Time, opts ...options.Option) (Image, Metadata, error) {
+func (r *renderer) Period(ctx context.Context, accountId string, from time.Time, opts ...rcommon.Option) (Image, Metadata, error) {
 	meta := Metadata{Stats: make(map[string]fetch.AccountStatsOverPeriod)}
 
 	printer, err := localization.NewPrinter("stats", r.locale)
@@ -47,7 +47,7 @@ func (r *renderer) Period(ctx context.Context, accountId string, from time.Time,
 	stop()
 
 	stop = meta.Timer("prepare#NewCards")
-	cards, err := prepare.NewCards(stats, glossary, common.WithPrinter(printer, r.locale))
+	cards, err := prepare.NewCards(stats, glossary, pcommon.WithPrinter(printer, r.locale))
 	stop()
 	if err != nil {
 		return nil, meta, err
diff --git a/internal/stats/renderer/v1/renderer.go b/internal/stats/renderer/v1/renderer.go
index 2b2023da..fab17367 100644
--- a/internal/stats/renderer/v1/renderer.go
+++ b/internal/stats/renderer/v1/renderer.go
@@ -7,7 +7,7 @@ import (
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/external/wargaming"
 	"github.com/cufee/aftermath/internal/stats/fetch/v1"
-	"github.com/cufee/aftermath/internal/stats/render"
+	"github.com/cufee/aftermath/internal/stats/render/common/v1"
 	"golang.org/x/text/language"
 )
 
@@ -21,8 +21,8 @@ type renderer struct {
 }
 
 type Renderer interface {
-	Period(ctx context.Context, accountId string, from time.Time, opts ...render.Option) (Image, Metadata, error)
-	Session(ctx context.Context, accountId string, from time.Time, opts ...render.Option) (Image, Metadata, error)
+	Period(ctx context.Context, accountId string, from time.Time, opts ...common.Option) (Image, Metadata, error)
+	Session(ctx context.Context, accountId string, from time.Time, opts ...common.Option) (Image, Metadata, error)
 
 	// Replay(accountId string, from time.Time) (image.Image, error)
 }
diff --git a/internal/stats/renderer/v1/session.go b/internal/stats/renderer/v1/session.go
index cc6b9b5a..f1123e8b 100644
--- a/internal/stats/renderer/v1/session.go
+++ b/internal/stats/renderer/v1/session.go
@@ -12,7 +12,7 @@ import (
 	"github.com/cufee/aftermath/internal/stats/fetch/v1"
 	"github.com/cufee/aftermath/internal/stats/prepare/common/v1"
 	prepare "github.com/cufee/aftermath/internal/stats/prepare/session/v1"
-	options "github.com/cufee/aftermath/internal/stats/render"
+	options "github.com/cufee/aftermath/internal/stats/render/common/v1"
 	render "github.com/cufee/aftermath/internal/stats/render/session/v1"
 	"github.com/rs/zerolog/log"
 )
diff --git a/render_test.go b/render_test.go
index 810b5f5c..016202cf 100644
--- a/render_test.go
+++ b/render_test.go
@@ -6,8 +6,8 @@ import (
 	"testing"
 	"time"
 
-	"github.com/cufee/aftermath/internal/stats/render"
 	"github.com/cufee/aftermath/internal/stats/render/assets"
+	"github.com/cufee/aftermath/internal/stats/render/common/v1"
 	stats "github.com/cufee/aftermath/internal/stats/renderer/v1"
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/assert"
@@ -29,7 +29,7 @@ func TestRenderSession(t *testing.T) {
 	assert.True(t, ok, "failed to load a background image")
 
 	renderer := stats.NewRenderer(coreClient.Fetch(), coreClient.Database(), coreClient.Wargaming(), language.English)
-	image, _, err := renderer.Session(context.Background(), "1013072123", time.Now(), render.WithBackground(bgImage))
+	image, _, err := renderer.Session(context.Background(), "1013072123", time.Now(), common.WithBackground(bgImage))
 	assert.NoError(t, err, "failed to render a session image")
 	assert.NotNil(t, image, "image is nil")
 

From f1fc4415ee8eb0ba691d527c1fa0f164c1ba7f88 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Mon, 24 Jun 2024 07:38:42 -0400
Subject: [PATCH 156/341] added mod command, rolled back wg proxy changes

---
 .env.example                    |  4 ++--
 cmds/discord/commands/manage.go | 36 ++++++++++++++++++++++++++++++---
 cmds/discord/rest/client.go     |  2 +-
 go.mod                          |  2 +-
 go.sum                          |  4 ++--
 internal/database/client.go     |  1 +
 internal/database/tasks.go      | 18 +++++++++++++++++
 7 files changed, 58 insertions(+), 9 deletions(-)

diff --git a/.env.example b/.env.example
index f49d5131..fbe664d0 100644
--- a/.env.example
+++ b/.env.example
@@ -1,5 +1,5 @@
-# Path for a bind volume when running with compose
-DATABASE_PATH="tmp/deb_local.db"
+DATABASE_PATH="/absolute/path/"
+DATABASE_NAME="aftermath.db"
 
 # Init
 INIT_GLOBAL_ADMIN_USER="" # Discord user ID for a user who will be assigned permissions.GlobalAdmin on startup, can be left blank
diff --git a/cmds/discord/commands/manage.go b/cmds/discord/commands/manage.go
index 34f9d6a6..1c0a3bbe 100644
--- a/cmds/discord/commands/manage.go
+++ b/cmds/discord/commands/manage.go
@@ -2,6 +2,7 @@ package commands
 
 import (
 	"encoding/json"
+	"strings"
 	"time"
 
 	"github.com/bwmarrin/discordgo"
@@ -38,6 +39,9 @@ func init() {
 						).Required(),
 						builder.NewOption("hours", discordgo.ApplicationCommandOptionNumber).Required(),
 					),
+					builder.NewOption("details", discordgo.ApplicationCommandOptionSubCommand).Options(
+						builder.NewOption("id", discordgo.ApplicationCommandOptionString).Required(),
+					),
 				),
 				builder.NewOption("snapshots", discordgo.ApplicationCommandOptionSubCommandGroup).Options(
 					builder.NewOption("view", discordgo.ApplicationCommandOptionSubCommand).Options(
@@ -119,14 +123,40 @@ func init() {
 						return ctx.Reply("No recent tasks with status " + status)
 					}
 
+					var ids []string
+					for _, t := range tasks {
+						ids = append(ids, t.ID)
+					}
+
+					content := strings.Join(ids, "\n")
+					if len(content) > 1990 {
+						content = content[:1990]
+					}
+					return ctx.Reply("```" + content + "```")
+
+				case "tasks_details":
+					id, _ := opts.Value("id").(string)
+					if id == "" {
+						return ctx.Reply("id cannot be blank")
+					}
+
+					tasks, err := ctx.Core.Database().GetTasks(ctx.Context, id)
+					if err != nil {
+						return ctx.Reply("Database#GetTasks: " + err.Error())
+					}
+					if len(tasks) < 1 {
+						return ctx.Reply("No recent task found")
+					}
+
 					bytes, err := json.MarshalIndent(tasks, "", "  ")
 					if err != nil {
 						return ctx.Reply("json.Marshal: " + err.Error())
 					}
-					if len(string(bytes)) > 1990 {
-						return ctx.ReplyFmt("Too many tasks to show - %d", len(tasks))
+					content := string(bytes)
+					if len(content) > 1990 {
+						content = content[:1990]
 					}
-					return ctx.Reply("```" + string(bytes) + "```")
+					return ctx.Reply("```" + content + "```")
 
 				default:
 					return ctx.Reply("invalid subcommand, thought this should never happen")
diff --git a/cmds/discord/rest/client.go b/cmds/discord/rest/client.go
index 4307d565..e5b829f8 100644
--- a/cmds/discord/rest/client.go
+++ b/cmds/discord/rest/client.go
@@ -26,7 +26,7 @@ type Client struct {
 func NewClient(token string) (*Client, error) {
 	client := &Client{
 		token: token,
-		http:  http.Client{Timeout: time.Millisecond * 1000},
+		http:  http.Client{Timeout: time.Millisecond * 5000}, // discord is very slow sometimes
 	}
 
 	_, err := client.lookupApplicationID()
diff --git a/go.mod b/go.mod
index dbc963ed..bf5fd037 100644
--- a/go.mod
+++ b/go.mod
@@ -6,7 +6,7 @@ require (
 	ariga.io/atlas v0.19.1-0.20240203083654-5948b60a8e43
 	entgo.io/ent v0.13.1
 	github.com/bwmarrin/discordgo v0.28.1
-	github.com/cufee/am-wg-proxy-next/v2 v2.1.4
+	github.com/cufee/am-wg-proxy-next/v2 v2.1.3
 	github.com/disintegration/imaging v1.6.2
 	github.com/fogleman/gg v1.3.0
 	github.com/go-co-op/gocron v1.37.0
diff --git a/go.sum b/go.sum
index 4f848a8b..24ee26f5 100644
--- a/go.sum
+++ b/go.sum
@@ -14,8 +14,8 @@ github.com/bwmarrin/discordgo v0.28.1 h1:gXsuo2GBO7NbR6uqmrrBDplPUx2T3nzu775q/Rd
 github.com/bwmarrin/discordgo v0.28.1/go.mod h1:NJZpH+1AfhIcyQsPeuBKsUtYrRnjkyu0kIVMCHkZtRY=
 github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
-github.com/cufee/am-wg-proxy-next/v2 v2.1.4 h1:2EtRrktt2eXcomZB868J2QYuxI1NmwyFrd9EqORD21Y=
-github.com/cufee/am-wg-proxy-next/v2 v2.1.4/go.mod h1:xrgMXzAMU4p5AW1++nnpofNFZLOiSUP8vnezzzG92Zw=
+github.com/cufee/am-wg-proxy-next/v2 v2.1.3 h1:qTzzgEapbI/z81R3nXoiiITfBZeHQ1cnebzSNgaoZlQ=
+github.com/cufee/am-wg-proxy-next/v2 v2.1.3/go.mod h1:+VxiIdbrdhHdRThASbVmZ5Fz4H6XPCzL3S2Ix6TO/84=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
diff --git a/internal/database/client.go b/internal/database/client.go
index eecf20c0..e8258b80 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -56,6 +56,7 @@ type SnapshotsClient interface {
 
 type TasksClient interface {
 	CreateTasks(ctx context.Context, tasks ...models.Task) error
+	GetTasks(ctx context.Context, ids ...string) ([]models.Task, error)
 	UpdateTasks(ctx context.Context, tasks ...models.Task) error
 	DeleteTasks(ctx context.Context, ids ...string) error
 
diff --git a/internal/database/tasks.go b/internal/database/tasks.go
index 56de971a..0b63828a 100644
--- a/internal/database/tasks.go
+++ b/internal/database/tasks.go
@@ -137,6 +137,24 @@ func (c *client) CreateTasks(ctx context.Context, tasks ...models.Task) error {
 	return c.db.CronTask.CreateBulk(inserts...).Exec(ctx)
 }
 
+func (c *client) GetTasks(ctx context.Context, ids ...string) ([]models.Task, error) {
+	if len(ids) < 1 {
+		return nil, nil
+	}
+
+	records, err := c.db.CronTask.Query().Where(crontask.IDIn(ids...)).All(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	var tasks []models.Task
+	for _, r := range records {
+		tasks = append(tasks, toCronTask(r))
+	}
+
+	return tasks, nil
+}
+
 /*
 UpdateTasks will update all tasks passed in
   - the following fields will be replaced: targets, status, leastRun, scheduleAfterm logs, data

From 00b958317464b6eadbc4cd63f1da17bb622f5635 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Mon, 24 Jun 2024 07:43:21 -0400
Subject: [PATCH 157/341] removed indents

---
 cmds/discord/commands/manage.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cmds/discord/commands/manage.go b/cmds/discord/commands/manage.go
index 1c0a3bbe..0eba3870 100644
--- a/cmds/discord/commands/manage.go
+++ b/cmds/discord/commands/manage.go
@@ -148,7 +148,7 @@ func init() {
 						return ctx.Reply("No recent task found")
 					}
 
-					bytes, err := json.MarshalIndent(tasks, "", "  ")
+					bytes, err := json.Marshal(tasks)
 					if err != nil {
 						return ctx.Reply("json.Marshal: " + err.Error())
 					}

From a1293f636be5080c15ad79a4a7bd9295a39b2c81 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Mon, 24 Jun 2024 07:50:08 -0400
Subject: [PATCH 158/341] sending result as txt file

---
 cmds/discord/commands/manage.go  | 20 +++++++-------------
 internal/database/models/task.go |  8 --------
 2 files changed, 7 insertions(+), 21 deletions(-)

diff --git a/cmds/discord/commands/manage.go b/cmds/discord/commands/manage.go
index 0eba3870..ce5ee5bc 100644
--- a/cmds/discord/commands/manage.go
+++ b/cmds/discord/commands/manage.go
@@ -1,7 +1,9 @@
 package commands
 
 import (
+	"bytes"
 	"encoding/json"
+	"fmt"
 	"strings"
 	"time"
 
@@ -35,6 +37,7 @@ func init() {
 						builder.NewOption("status", discordgo.ApplicationCommandOptionString).Choices(
 							builder.NewChoice("failed", string(models.TaskStatusFailed)),
 							builder.NewChoice("complete", string(models.TaskStatusComplete)),
+							builder.NewChoice("scheduled", string(models.TaskStatusScheduled)),
 							builder.NewChoice("in-progress", string(models.TaskStatusInProgress)),
 						).Required(),
 						builder.NewOption("hours", discordgo.ApplicationCommandOptionNumber).Required(),
@@ -123,16 +126,11 @@ func init() {
 						return ctx.Reply("No recent tasks with status " + status)
 					}
 
-					var ids []string
+					ids := []string{fmt.Sprintf("total: %d", len(tasks))}
 					for _, t := range tasks {
 						ids = append(ids, t.ID)
 					}
-
-					content := strings.Join(ids, "\n")
-					if len(content) > 1990 {
-						content = content[:1990]
-					}
-					return ctx.Reply("```" + content + "```")
+					return ctx.File(bytes.NewBufferString(strings.Join(ids, "\n")), "tasks.txt")
 
 				case "tasks_details":
 					id, _ := opts.Value("id").(string)
@@ -148,15 +146,11 @@ func init() {
 						return ctx.Reply("No recent task found")
 					}
 
-					bytes, err := json.Marshal(tasks)
+					data, err := json.MarshalIndent(tasks, "", "  ")
 					if err != nil {
 						return ctx.Reply("json.Marshal: " + err.Error())
 					}
-					content := string(bytes)
-					if len(content) > 1990 {
-						content = content[:1990]
-					}
-					return ctx.Reply("```" + content + "```")
+					return ctx.File(bytes.NewReader(data), "tasks.txt")
 
 				default:
 					return ctx.Reply("invalid subcommand, thought this should never happen")
diff --git a/internal/database/models/task.go b/internal/database/models/task.go
index c11caf6a..77adbaab 100644
--- a/internal/database/models/task.go
+++ b/internal/database/models/task.go
@@ -82,18 +82,10 @@ func (t *Task) OnCreated() {
 	t.LastRun = time.Now()
 	t.CreatedAt = time.Now()
 	t.UpdatedAt = time.Now()
-	t.Logs = append(t.Logs, TaskLog{
-		Comment:   "task created",
-		Timestamp: time.Now(),
-	})
 }
 func (t *Task) OnUpdated() {
 	t.LastRun = time.Now()
 	t.UpdatedAt = time.Now()
-	t.Logs = append(t.Logs, TaskLog{
-		Comment:   "task updated",
-		Timestamp: time.Now(),
-	})
 }
 
 type TaskLog struct {

From 13de1de827fe5458cd1f5da8065b3acde4e739a4 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Mon, 24 Jun 2024 08:13:50 -0400
Subject: [PATCH 159/341] inserting snapshot individually to avoid SQL errors

---
 cmds/discord/commands/manage.go | 22 +++++++---
 internal/database/client.go     |  4 +-
 internal/database/snapshots.go  | 71 +++++++++++++++++----------------
 internal/logic/sessions.go      | 22 +++++++---
 4 files changed, 72 insertions(+), 47 deletions(-)

diff --git a/cmds/discord/commands/manage.go b/cmds/discord/commands/manage.go
index ce5ee5bc..ec1d926c 100644
--- a/cmds/discord/commands/manage.go
+++ b/cmds/discord/commands/manage.go
@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
-	"strings"
 	"time"
 
 	"github.com/bwmarrin/discordgo"
@@ -126,11 +125,24 @@ func init() {
 						return ctx.Reply("No recent tasks with status " + status)
 					}
 
-					ids := []string{fmt.Sprintf("total: %d", len(tasks))}
+					content := fmt.Sprintf("total: %d\n", len(tasks))
+					var reduced []map[string]any
 					for _, t := range tasks {
-						ids = append(ids, t.ID)
+						reduced = append(reduced, map[string]any{
+							"id":          t.ID,
+							"type":        t.Type,
+							"targets":     len(t.Targets),
+							"referenceID": t.ReferenceID,
+							"lastRun":     t.LastRun,
+						})
 					}
-					return ctx.File(bytes.NewBufferString(strings.Join(ids, "\n")), "tasks.txt")
+					data, err := json.MarshalIndent(reduced, "", "  ")
+					if err != nil {
+						return ctx.Reply("json.Marshal: " + err.Error())
+					}
+					content += string(data)
+
+					return ctx.File(bytes.NewBufferString(content), "tasks.json")
 
 				case "tasks_details":
 					id, _ := opts.Value("id").(string)
@@ -150,7 +162,7 @@ func init() {
 					if err != nil {
 						return ctx.Reply("json.Marshal: " + err.Error())
 					}
-					return ctx.File(bytes.NewReader(data), "tasks.txt")
+					return ctx.File(bytes.NewReader(data), "tasks.json")
 
 				default:
 					return ctx.Reply("invalid subcommand, thought this should never happen")
diff --git a/internal/database/client.go b/internal/database/client.go
index e8258b80..b3c93c9a 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -44,12 +44,12 @@ type UsersClient interface {
 
 type SnapshotsClient interface {
 	GetAccountSnapshot(ctx context.Context, accountID, referenceID string, kind models.SnapshotType, options ...SnapshotQuery) (models.AccountSnapshot, error)
-	CreateAccountSnapshots(ctx context.Context, snapshots ...models.AccountSnapshot) error
+	CreateAccountSnapshots(ctx context.Context, snapshots ...models.AccountSnapshot) (map[string]error, error)
 	GetLastAccountSnapshots(ctx context.Context, accountID string, limit int) ([]models.AccountSnapshot, error)
 	GetManyAccountSnapshots(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.AccountSnapshot, error)
 
 	GetVehicleSnapshots(ctx context.Context, accountID, referenceID string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.VehicleSnapshot, error)
-	CreateVehicleSnapshots(ctx context.Context, snapshots ...models.VehicleSnapshot) error
+	CreateAccountVehicleSnapshots(ctx context.Context, accountID string, snapshots ...models.VehicleSnapshot) (map[string]error, error)
 
 	DeleteExpiredSnapshots(ctx context.Context, expiration time.Time) error
 }
diff --git a/internal/database/snapshots.go b/internal/database/snapshots.go
index 88cb5465..cd344cf7 100644
--- a/internal/database/snapshots.go
+++ b/internal/database/snapshots.go
@@ -50,26 +50,28 @@ func toVehicleSnapshot(record *db.VehicleSnapshot) models.VehicleSnapshot {
 	}
 }
 
-func (c *client) CreateVehicleSnapshots(ctx context.Context, snapshots ...models.VehicleSnapshot) error {
+func (c *client) CreateAccountVehicleSnapshots(ctx context.Context, accountID string, snapshots ...models.VehicleSnapshot) (map[string]error, error) {
 	if len(snapshots) < 1 {
-		return nil
+		return nil, nil
 	}
 
-	var inserts []*db.VehicleSnapshotCreate
+	var errors = make(map[string]error)
 	for _, data := range snapshots {
-		inserts = append(inserts,
-			c.db.VehicleSnapshot.Create().
-				SetType(data.Type).
-				SetFrame(data.Stats).
-				SetVehicleID(data.VehicleID).
-				SetReferenceID(data.ReferenceID).
-				SetBattles(int(data.Stats.Battles.Float())).
-				SetLastBattleTime(data.LastBattleTime.Unix()).
-				SetAccount(c.db.Account.GetX(ctx, data.AccountID)),
-		)
-	}
-
-	return c.db.VehicleSnapshot.CreateBulk(inserts...).Exec(ctx)
+		err := c.db.VehicleSnapshot.Create().
+			SetType(data.Type).
+			SetFrame(data.Stats).
+			SetVehicleID(data.VehicleID).
+			SetReferenceID(data.ReferenceID).
+			SetBattles(int(data.Stats.Battles.Float())).
+			SetLastBattleTime(data.LastBattleTime.Unix()).
+			SetAccount(c.db.Account.GetX(ctx, accountID)).
+			Exec(ctx)
+		if err != nil {
+			errors[data.VehicleID] = err
+		}
+	}
+
+	return errors, nil
 }
 
 func (c *client) GetVehicleSnapshots(ctx context.Context, accountID, referenceID string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.VehicleSnapshot, error) {
@@ -121,28 +123,29 @@ func toAccountSnapshot(record *db.AccountSnapshot) models.AccountSnapshot {
 	}
 }
 
-func (c *client) CreateAccountSnapshots(ctx context.Context, snapshots ...models.AccountSnapshot) error {
+func (c *client) CreateAccountSnapshots(ctx context.Context, snapshots ...models.AccountSnapshot) (map[string]error, error) {
 	if len(snapshots) < 1 {
-		return nil
+		return nil, nil
 	}
 
-	var inserts []*db.AccountSnapshotCreate
+	var errors = make(map[string]error)
 	for _, s := range snapshots {
-		inserts = append(inserts,
-			c.db.AccountSnapshot.Create().
-				SetAccount(c.db.Account.GetX(ctx, s.AccountID)). // we assume the account exists here
-				SetCreatedAt(s.CreatedAt.Unix()).
-				SetLastBattleTime(s.LastBattleTime.Unix()).
-				SetRatingBattles(int(s.RatingBattles.Battles.Float())).
-				SetRatingFrame(s.RatingBattles).
-				SetReferenceID(s.ReferenceID).
-				SetRegularBattles(int(s.RegularBattles.Battles)).
-				SetRegularFrame(s.RegularBattles).
-				SetType(s.Type),
-		)
-	}
-
-	return c.db.AccountSnapshot.CreateBulk(inserts...).Exec(ctx)
+		err := c.db.AccountSnapshot.Create().
+			SetAccount(c.db.Account.GetX(ctx, s.AccountID)). // we assume the account exists here
+			SetCreatedAt(s.CreatedAt.Unix()).
+			SetLastBattleTime(s.LastBattleTime.Unix()).
+			SetRatingBattles(int(s.RatingBattles.Battles.Float())).
+			SetRatingFrame(s.RatingBattles).
+			SetReferenceID(s.ReferenceID).
+			SetRegularBattles(int(s.RegularBattles.Battles)).
+			SetRegularFrame(s.RegularBattles).
+			SetType(s.Type).Exec(ctx)
+		if err != nil {
+			errors[s.AccountID] = err
+		}
+	}
+
+	return errors, nil
 }
 
 func (c *client) GetLastAccountSnapshots(ctx context.Context, accountID string, limit int) ([]models.AccountSnapshot, error) {
diff --git a/internal/logic/sessions.go b/internal/logic/sessions.go
index 80795daa..ee34a601 100644
--- a/internal/logic/sessions.go
+++ b/internal/logic/sessions.go
@@ -93,7 +93,7 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 	var accountErrors = make(map[string]error)
 	var accountUpdates []models.Account
 	var snapshots []models.AccountSnapshot
-	var vehicleSnapshots []models.VehicleSnapshot
+	var vehicleSnapshots = make(map[string][]models.VehicleSnapshot)
 	for result := range vehicleCh {
 		// there is only 1 key in this map
 		for id, vehicles := range result.Data {
@@ -148,7 +148,7 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 					continue
 				}
 
-				vehicleSnapshots = append(vehicleSnapshots, models.VehicleSnapshot{
+				vehicleSnapshots[stats.Account.ID] = append(vehicleSnapshots[stats.Account.ID], models.VehicleSnapshot{
 					CreatedAt:      createdAt,
 					Type:           models.SnapshotTypeDaily,
 					LastBattleTime: vehicle.LastBattleTime,
@@ -161,14 +161,24 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 		}
 	}
 
-	err = dbClient.CreateAccountSnapshots(ctx, snapshots...)
+	aErr, err := dbClient.CreateAccountSnapshots(ctx, snapshots...)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to save account snapshots to database")
 	}
+	for id, err := range aErr {
+		if err != nil {
+			accountErrors[id] = err
+		}
+	}
 
-	err = dbClient.CreateVehicleSnapshots(ctx, vehicleSnapshots...)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to save vehicle snapshots to database")
+	for accountId, vehicles := range vehicleSnapshots {
+		vErr, err := dbClient.CreateAccountVehicleSnapshots(ctx, accountId, vehicles...)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to save vehicle snapshots to database")
+		}
+		if len(vErr) > 0 {
+			accountErrors[accountId] = errors.Errorf("failed to insert %d vehicle snapshots", len(vErr))
+		}
 	}
 
 	return accountErrors, nil

From 55e1c68d6b763025cd0d344e1eefdc0514d19601 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Mon, 24 Jun 2024 08:18:30 -0400
Subject: [PATCH 160/341] upserting accounts

---
 internal/logic/sessions.go | 26 ++++++++++++++------------
 1 file changed, 14 insertions(+), 12 deletions(-)

diff --git a/internal/logic/sessions.go b/internal/logic/sessions.go
index ee34a601..13c2ec95 100644
--- a/internal/logic/sessions.go
+++ b/internal/logic/sessions.go
@@ -112,18 +112,7 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 			}
 
 			stats := fetch.WargamingToStats(realm, accounts[id], clans[id], vehicles)
-			accountUpdates = append(accountUpdates, models.Account{
-				Realm:    stats.Realm,
-				ID:       stats.Account.ID,
-				Nickname: stats.Account.Nickname,
-
-				Private:        false,
-				CreatedAt:      stats.Account.CreatedAt,
-				LastBattleTime: stats.LastBattleTime,
-
-				ClanID:  stats.Account.ClanID,
-				ClanTag: stats.Account.ClanTag,
-			})
+			accountUpdates = append(accountUpdates, stats.Account)
 			snapshots = append(snapshots, models.AccountSnapshot{
 				Type:           models.SnapshotTypeDaily,
 				CreatedAt:      createdAt,
@@ -181,5 +170,18 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 		}
 	}
 
+	uErr, err := dbClient.UpsertAccounts(ctx, accountUpdates)
+	// these errors are not critical, we log and continue
+	if err != nil {
+		log.Err(err).Msg("failed to upsert accounts")
+	}
+	if len(uErr) > 0 {
+		var errors = make(map[string]string)
+		for id, err := range uErr {
+			errors[id] = err.Error()
+		}
+		log.Error().Any("errors", errors).Msg("failed to upsert some accounts")
+	}
+
 	return accountErrors, nil
 }

From c0db8f9ab28ffdf703fc2e010f197ecb8f2e87ef Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Mon, 24 Jun 2024 08:30:20 -0400
Subject: [PATCH 161/341] added stack traces

---
 cmds/core/scheduler/queue.go   | 3 ++-
 cmds/discord/router/handler.go | 3 ++-
 internal/database/client.go    | 3 ++-
 main.go                        | 3 ++-
 4 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/cmds/core/scheduler/queue.go b/cmds/core/scheduler/queue.go
index 669a3c9c..5eca5e38 100644
--- a/cmds/core/scheduler/queue.go
+++ b/cmds/core/scheduler/queue.go
@@ -2,6 +2,7 @@ package scheduler
 
 import (
 	"context"
+	"runtime/debug"
 	"sync"
 	"time"
 
@@ -61,7 +62,7 @@ func (q *Queue) Process(callback func(error), tasks ...models.Task) {
 		go func(t models.Task) {
 			defer func() {
 				if r := recover(); r != nil {
-					log.Error().Any("recover", r).Msg("panic in task handler")
+					log.Error().Str("stack", string(debug.Stack())).Msg("panic in task handler")
 					t.Status = models.TaskStatusFailed
 					t.LogAttempt(models.TaskLog{
 						Targets:   t.Targets,
diff --git a/cmds/discord/router/handler.go b/cmds/discord/router/handler.go
index 327f1858..53d76f72 100644
--- a/cmds/discord/router/handler.go
+++ b/cmds/discord/router/handler.go
@@ -9,6 +9,7 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	"runtime/debug"
 	"sync"
 	"time"
 
@@ -210,7 +211,7 @@ func (router *Router) startInteractionHandlerAsync(interaction discordgo.Interac
 	go func() {
 		defer func() {
 			if r := recover(); r != nil {
-				log.Error().Stack().Any("recover", r).Msg("panic in interaction handler")
+				log.Error().Str("stack", string(debug.Stack())).Msg("panic in interaction handler")
 				state.mx.Lock()
 				router.sendInteractionReply(interaction, state, discordgo.InteractionResponseData{Content: "Something unexpected happened and your command failed. Please try again in a few seconds."})
 				state.mx.Unlock()
diff --git a/internal/database/client.go b/internal/database/client.go
index b3c93c9a..1fb6be9d 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -3,6 +3,7 @@ package database
 import (
 	"context"
 	"fmt"
+	"runtime/debug"
 	"sync"
 	"time"
 
@@ -108,7 +109,7 @@ func (c *client) txWithLock(ctx context.Context) (*db.Tx, func(), error) {
 func NewSQLiteClient(filePath string) (*client, error) {
 	defer func() {
 		if r := recover(); r != nil {
-			log.Fatal().Interface("error", r).Stack().Msg("NewSQLiteClient panic")
+			log.Fatal().Interface("error", r).Str("stack", string(debug.Stack())).Msg("NewSQLiteClient panic")
 		}
 	}()
 
diff --git a/main.go b/main.go
index e51ab75d..0b37f0bb 100644
--- a/main.go
+++ b/main.go
@@ -4,6 +4,7 @@ import (
 	"embed"
 	"io/fs"
 	"path/filepath"
+	"runtime/debug"
 
 	"os"
 	"strconv"
@@ -108,7 +109,7 @@ func startSchedulerFromEnvAsync(dbClient database.Client, wgClient wargaming.Cli
 
 	defer func() {
 		if r := recover(); r != nil {
-			log.Error().Interface("error", r).Stack().Msg("scheduler panic")
+			log.Error().Str("stack", string(debug.Stack())).Interface("error", r).Stack().Msg("scheduler panic")
 		}
 	}()
 

From b0143b5514b1828e3fad59c43b707090bdba685f Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Mon, 24 Jun 2024 08:34:32 -0400
Subject: [PATCH 162/341] pulling 1 task per worker

---
 cmds/core/scheduler/tasks/sessions.go | 2 +-
 cmds/core/scheduler/workers.go        | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/cmds/core/scheduler/tasks/sessions.go b/cmds/core/scheduler/tasks/sessions.go
index b4d6803b..0aaac75f 100644
--- a/cmds/core/scheduler/tasks/sessions.go
+++ b/cmds/core/scheduler/tasks/sessions.go
@@ -97,7 +97,7 @@ func CreateRecordSnapshotsTasks(client core.Client, realm string) error {
 	task.Targets = append(task.Targets, accounts...)
 
 	// This update requires (2 + n) requests per n players
-	tasks := splitTaskByTargets(task, 90)
+	tasks := splitTaskByTargets(task, 50)
 	err = client.Database().CreateTasks(ctx, tasks...)
 	if err != nil {
 		return err
diff --git a/cmds/core/scheduler/workers.go b/cmds/core/scheduler/workers.go
index 50b6cce6..20328053 100644
--- a/cmds/core/scheduler/workers.go
+++ b/cmds/core/scheduler/workers.go
@@ -59,7 +59,7 @@ func RunTasksWorker(queue *Queue) func() {
 		// each task worked handles 1 task at a time, but tasks might be very fast
 		// for now, we queue up 10 tasks per worker, this can be adjusted later/smarter
 		batchSize := queue.concurrencyLimit - activeWorkers
-		tasks, err := queue.core.Database().GetAndStartTasks(ctx, batchSize*10)
+		tasks, err := queue.core.Database().GetAndStartTasks(ctx, batchSize)
 		if err != nil {
 			if database.IsNotFound(err) {
 				log.Debug().Msg("no scheduled tasks to process")

From 04c6ffc23d9342dcac561237f13704ce6b00d640 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Mon, 24 Jun 2024 08:55:15 -0400
Subject: [PATCH 163/341] more frequent scheduler

---
 cmds/core/scheduler/cron.go    | 2 +-
 cmds/core/scheduler/workers.go | 8 +++++---
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/cmds/core/scheduler/cron.go b/cmds/core/scheduler/cron.go
index f17bccac..36970b68 100644
--- a/cmds/core/scheduler/cron.go
+++ b/cmds/core/scheduler/cron.go
@@ -12,7 +12,7 @@ func (queue *Queue) StartCronJobsAsync() {
 
 	c := gocron.NewScheduler(time.UTC)
 	// Tasks
-	c.Cron("* * * * *").Do(RunTasksWorker(queue))
+	c.CronWithSeconds("*/15 * * * * *").Do(RunTasksWorker(queue))
 	// some tasks might be stuck due to a panic or restart, restart them
 	c.Cron("0 * * * *").Do(RestartTasksWorker(queue.core))
 	c.Cron("0 5 * * *").Do(CreateCleanupTaskWorker(queue.core)) // delete expired documents
diff --git a/cmds/core/scheduler/workers.go b/cmds/core/scheduler/workers.go
index 20328053..078ad939 100644
--- a/cmds/core/scheduler/workers.go
+++ b/cmds/core/scheduler/workers.go
@@ -56,8 +56,6 @@ func RunTasksWorker(queue *Queue) func() {
 		ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 		defer cancel()
 
-		// each task worked handles 1 task at a time, but tasks might be very fast
-		// for now, we queue up 10 tasks per worker, this can be adjusted later/smarter
 		batchSize := queue.concurrencyLimit - activeWorkers
 		tasks, err := queue.core.Database().GetAndStartTasks(ctx, batchSize)
 		if err != nil {
@@ -68,13 +66,17 @@ func RunTasksWorker(queue *Queue) func() {
 			log.Err(err).Msg("failed to start scheduled tasks")
 			return
 		}
+		if len(tasks) < 1 {
+			log.Debug().Msg("no scheduled tasks to process")
+			return
+		}
 
 		queue.Process(func(err error) {
 			if err != nil {
 				log.Err(err).Msg("failed to process tasks")
 				return
 			}
-			// if the queue is now empty, we can run the next batch of tasks right away
+			// try to start the next task batch right away
 			RunTasksWorker(queue)
 		}, tasks...)
 	}

From fc2d1d21beeea3a86afdd46a8ebc26fa761d7a42 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Mon, 24 Jun 2024 12:01:16 -0400
Subject: [PATCH 164/341] refactored database connections and transactions

---
 cmds/core/scheduler/tasks/sessions.go |  10 +-
 internal/database/accounts.go         |  58 ++++++------
 internal/database/averages.go         |  40 ++++----
 internal/database/cleanup.go          |  15 +--
 internal/database/client.go           |  54 ++++++-----
 internal/database/discord.go          |  73 +++++++--------
 internal/database/ent/db/client.go    |  26 ++++++
 internal/database/ent/db/tx.go        |  26 ++++++
 internal/database/ent/generate.go     |   2 +-
 internal/database/snapshots.go        |  64 ++++++-------
 internal/database/tasks.go            | 129 +++++++++++---------------
 internal/database/vehicles.go         |  48 +++++-----
 main.go                               |  36 +++----
 13 files changed, 309 insertions(+), 272 deletions(-)

diff --git a/cmds/core/scheduler/tasks/sessions.go b/cmds/core/scheduler/tasks/sessions.go
index 0aaac75f..0125d1ea 100644
--- a/cmds/core/scheduler/tasks/sessions.go
+++ b/cmds/core/scheduler/tasks/sessions.go
@@ -21,15 +21,15 @@ func init() {
 			}
 			realm, ok := task.Data["realm"].(string)
 			if !ok {
-				task.Data["triesLeft"] = int(0) // do not retry
+				task.Data["triesLeft"] = int64(0) // do not retry
 				return "invalid realm", errors.New("invalid realm")
 			}
 			if len(task.Targets) > 100 {
-				task.Data["triesLeft"] = int(0) // do not retry
+				task.Data["triesLeft"] = int64(0) // do not retry
 				return "cannot process 100+ accounts at a time", errors.New("invalid targets length")
 			}
 			if len(task.Targets) < 1 {
-				task.Data["triesLeft"] = int(0) // do not retry
+				task.Data["triesLeft"] = int64(0) // do not retry
 				return "target ids cannot be left blank", errors.New("invalid targets length")
 			}
 			forceUpdate, _ := task.Data["force"].(bool)
@@ -56,7 +56,7 @@ func init() {
 			return "retrying failed accounts", errors.New("some accounts failed")
 		},
 		ShouldRetry: func(task *models.Task) bool {
-			triesLeft, ok := task.Data["triesLeft"].(int)
+			triesLeft, ok := task.Data["triesLeft"].(int64)
 			if !ok {
 				return false
 			}
@@ -80,7 +80,7 @@ func CreateRecordSnapshotsTasks(client core.Client, realm string) error {
 		ScheduledAfter: time.Now(),
 		Data: map[string]any{
 			"realm":     realm,
-			"triesLeft": int(3),
+			"triesLeft": int64(3),
 		},
 	}
 
diff --git a/internal/database/accounts.go b/internal/database/accounts.go
index ee9007d5..55c9ecf8 100644
--- a/internal/database/accounts.go
+++ b/internal/database/accounts.go
@@ -79,38 +79,40 @@ func (c *client) UpsertAccounts(ctx context.Context, accounts []models.Account)
 	}
 
 	errors := make(map[string]error)
-	for _, r := range records {
-		update, ok := accountsMap[r.ID]
-		if !ok {
-			continue // this should never happen tho
+	return errors, c.withTx(ctx, func(tx *db.Tx) error {
+		for _, r := range records {
+			update, ok := accountsMap[r.ID]
+			if !ok {
+				continue // this should never happen tho
+			}
+
+			err = c.db.Account.UpdateOneID(r.ID).
+				SetRealm(strings.ToUpper(update.Realm)).
+				SetNickname(update.Nickname).
+				SetPrivate(update.Private).
+				SetLastBattleTime(update.LastBattleTime.Unix()).
+				Exec(ctx)
+			if err != nil {
+				errors[r.ID] = err
+			}
+
+			delete(accountsMap, r.ID)
 		}
 
-		err = c.db.Account.UpdateOneID(r.ID).
-			SetRealm(strings.ToUpper(update.Realm)).
-			SetNickname(update.Nickname).
-			SetPrivate(update.Private).
-			SetLastBattleTime(update.LastBattleTime.Unix()).
-			Exec(ctx)
-		if err != nil {
-			errors[r.ID] = err
+		var writes []*db.AccountCreate
+		for _, a := range accountsMap {
+			writes = append(writes, c.db.Account.Create().
+				SetID(a.ID).
+				SetRealm(strings.ToUpper(a.Realm)).
+				SetNickname(a.Nickname).
+				SetPrivate(a.Private).
+				SetAccountCreatedAt(a.CreatedAt.Unix()).
+				SetLastBattleTime(a.LastBattleTime.Unix()),
+			)
 		}
 
-		delete(accountsMap, r.ID)
-	}
-
-	var writes []*db.AccountCreate
-	for _, a := range accountsMap {
-		writes = append(writes, c.db.Account.Create().
-			SetID(a.ID).
-			SetRealm(strings.ToUpper(a.Realm)).
-			SetNickname(a.Nickname).
-			SetPrivate(a.Private).
-			SetAccountCreatedAt(a.CreatedAt.Unix()).
-			SetLastBattleTime(a.LastBattleTime.Unix()),
-		)
-	}
-
-	return errors, c.db.Account.CreateBulk(writes...).Exec(ctx)
+		return c.db.Account.CreateBulk(writes...).Exec(ctx)
+	})
 }
 
 func (c *client) AccountSetPrivate(ctx context.Context, id string, value bool) error {
diff --git a/internal/database/averages.go b/internal/database/averages.go
index e643beb4..6dffe796 100644
--- a/internal/database/averages.go
+++ b/internal/database/averages.go
@@ -24,29 +24,31 @@ func (c *client) UpsertVehicleAverages(ctx context.Context, averages map[string]
 	}
 
 	errors := make(map[string]error)
-	for _, r := range existing {
-		update, ok := averages[r.ID]
-		if !ok {
-			continue // should never happen tho
-		}
+	return errors, c.withTx(ctx, func(tx *db.Tx) error {
+		for _, r := range existing {
+			update, ok := averages[r.ID]
+			if !ok {
+				continue // should never happen tho
+			}
 
-		err := c.db.VehicleAverage.UpdateOneID(r.ID).SetData(update).Exec(ctx)
-		if err != nil {
-			errors[r.ID] = err
-		}
+			err := c.db.VehicleAverage.UpdateOneID(r.ID).SetData(update).Exec(ctx)
+			if err != nil {
+				errors[r.ID] = err
+			}
 
-		delete(averages, r.ID)
-	}
+			delete(averages, r.ID)
+		}
 
-	var writes []*db.VehicleAverageCreate
-	for id, frame := range averages {
-		writes = append(writes, c.db.VehicleAverage.Create().
-			SetID(id).
-			SetData(frame),
-		)
-	}
+		var writes []*db.VehicleAverageCreate
+		for id, frame := range averages {
+			writes = append(writes, c.db.VehicleAverage.Create().
+				SetID(id).
+				SetData(frame),
+			)
+		}
 
-	return errors, c.db.VehicleAverage.CreateBulk(writes...).Exec(ctx)
+		return c.db.VehicleAverage.CreateBulk(writes...).Exec(ctx)
+	})
 }
 
 func (c *client) GetVehicleAverages(ctx context.Context, ids []string) (map[string]frame.StatsFrame, error) {
diff --git a/internal/database/cleanup.go b/internal/database/cleanup.go
index 4340f281..05d130f5 100644
--- a/internal/database/cleanup.go
+++ b/internal/database/cleanup.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"time"
 
+	"github.com/cufee/aftermath/internal/database/ent/db"
 	"github.com/cufee/aftermath/internal/database/ent/db/accountsnapshot"
 	"github.com/cufee/aftermath/internal/database/ent/db/achievementssnapshot"
 	"github.com/cufee/aftermath/internal/database/ent/db/crontask"
@@ -11,17 +12,11 @@ import (
 )
 
 func (c *client) DeleteExpiredTasks(ctx context.Context, expiration time.Time) error {
-	tx, cancel, err := c.txWithLock(ctx)
-	if err != nil {
+	err := c.withTx(ctx, func(tx *db.Tx) error {
+		_, err := tx.CronTask.Delete().Where(crontask.CreatedAtLT(expiration.Unix())).Exec(ctx)
 		return err
-	}
-	defer cancel()
-
-	_, err = tx.CronTask.Delete().Where(crontask.CreatedAtLT(expiration.Unix())).Exec(ctx)
-	if err != nil {
-		return rollback(tx, err)
-	}
-	return tx.Commit()
+	})
+	return err
 }
 
 func (c *client) DeleteExpiredSnapshots(ctx context.Context, expiration time.Time) error {
diff --git a/internal/database/client.go b/internal/database/client.go
index 1fb6be9d..d3884a84 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -4,7 +4,6 @@ import (
 	"context"
 	"fmt"
 	"runtime/debug"
-	"sync"
 	"time"
 
 	"github.com/cufee/aftermath/internal/database/ent/db"
@@ -88,22 +87,34 @@ type Client interface {
 }
 
 type client struct {
-	db              *db.Client
-	transactionLock *sync.Mutex
+	db *db.Client
 }
 
-func (c *client) Disconnect() error {
-	return c.db.Close()
-}
-
-func (c *client) txWithLock(ctx context.Context) (*db.Tx, func(), error) {
-	c.transactionLock.Lock()
+func (c *client) withTx(ctx context.Context, fn func(tx *db.Tx) error) error {
 	tx, err := c.db.Tx(ctx)
 	if err != nil {
-		c.transactionLock.Unlock()
-		return tx, func() {}, nil
+		return err
 	}
-	return tx, c.transactionLock.Unlock, nil
+	defer func() {
+		if v := recover(); v != nil {
+			tx.Rollback()
+			panic(v)
+		}
+	}()
+	if err := fn(tx); err != nil {
+		if rerr := tx.Rollback(); rerr != nil {
+			err = fmt.Errorf("%w: rolling back transaction: %v", err, rerr)
+		}
+		return err
+	}
+	if err := tx.Commit(); err != nil {
+		return fmt.Errorf("committing transaction: %w", err)
+	}
+	return nil
+}
+
+func (c *client) Disconnect() error {
+	return c.db.Close()
 }
 
 func NewSQLiteClient(filePath string) (*client, error) {
@@ -118,17 +129,14 @@ func NewSQLiteClient(filePath string) (*client, error) {
 		return nil, err
 	}
 
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+	defer cancel()
+	_, err = c.ExecContext(ctx, "PRAGMA journal_mode=WAL")
+	if err != nil {
+		return nil, err
+	}
+
 	return &client{
-		transactionLock: &sync.Mutex{},
-		db:              c,
+		db: c,
 	}, nil
 }
-
-// rollback calls to tx.Rollback and wraps the given error
-// with the rollback error if occurred.
-func rollback(tx *db.Tx, err error) error {
-	if rerr := tx.Rollback(); rerr != nil {
-		err = fmt.Errorf("%w: %v", err, rerr)
-	}
-	return err
-}
diff --git a/internal/database/discord.go b/internal/database/discord.go
index c78498ee..d7f1ebd9 100644
--- a/internal/database/discord.go
+++ b/internal/database/discord.go
@@ -63,50 +63,41 @@ func (c *client) UpsertCommands(ctx context.Context, commands ...models.Applicat
 		commandsMap[c.ID] = &c
 	}
 
-	tx, cancel, err := c.txWithLock(ctx)
-	if err != nil {
-		return err
-	}
-	defer cancel()
-
-	existing, err := tx.ApplicationCommand.Query().Where(applicationcommand.IDIn(ids...)).All(ctx)
-	if err != nil && !IsNotFound(err) {
-		return rollback(tx, err)
-	}
-
-	for _, c := range existing {
-		update, ok := commandsMap[c.ID]
-		if !ok {
-			continue
+	return c.withTx(ctx, func(tx *db.Tx) error {
+		existing, err := tx.ApplicationCommand.Query().Where(applicationcommand.IDIn(ids...)).All(ctx)
+		if err != nil && !IsNotFound(err) {
+			return err
 		}
 
-		err := tx.ApplicationCommand.UpdateOneID(c.ID).
-			SetName(update.Name).
-			SetVersion(update.Version).
-			SetOptionsHash(update.Hash).
-			Exec(ctx)
-		if err != nil {
-			return rollback(tx, err)
+		for _, c := range existing {
+			update, ok := commandsMap[c.ID]
+			if !ok {
+				continue
+			}
+
+			err := tx.ApplicationCommand.UpdateOneID(c.ID).
+				SetName(update.Name).
+				SetVersion(update.Version).
+				SetOptionsHash(update.Hash).
+				Exec(ctx)
+			if err != nil {
+				return err
+			}
+
+			delete(commandsMap, c.ID)
 		}
 
-		delete(commandsMap, c.ID)
-	}
-
-	var inserts []*db.ApplicationCommandCreate
-	for _, cmd := range commandsMap {
-		inserts = append(inserts,
-			c.db.ApplicationCommand.Create().
-				SetID(cmd.ID).
-				SetName(cmd.Name).
-				SetVersion(cmd.Version).
-				SetOptionsHash(cmd.Hash),
-		)
-	}
-
-	err = tx.ApplicationCommand.CreateBulk(inserts...).Exec(ctx)
-	if err != nil {
-		return rollback(tx, err)
-	}
+		var inserts []*db.ApplicationCommandCreate
+		for _, cmd := range commandsMap {
+			inserts = append(inserts,
+				c.db.ApplicationCommand.Create().
+					SetID(cmd.ID).
+					SetName(cmd.Name).
+					SetVersion(cmd.Version).
+					SetOptionsHash(cmd.Hash),
+			)
+		}
 
-	return tx.Commit()
+		return tx.ApplicationCommand.CreateBulk(inserts...).Exec(ctx)
+	})
 }
diff --git a/internal/database/ent/db/client.go b/internal/database/ent/db/client.go
index 4b53ddbc..9d443fe2 100644
--- a/internal/database/ent/db/client.go
+++ b/internal/database/ent/db/client.go
@@ -29,6 +29,8 @@ import (
 	"github.com/cufee/aftermath/internal/database/ent/db/vehicle"
 	"github.com/cufee/aftermath/internal/database/ent/db/vehicleaverage"
 	"github.com/cufee/aftermath/internal/database/ent/db/vehiclesnapshot"
+
+	stdsql "database/sql"
 )
 
 // Client is the client that holds all ent builders.
@@ -2414,3 +2416,27 @@ type (
 		UserSubscription, Vehicle, VehicleAverage, VehicleSnapshot []ent.Interceptor
 	}
 )
+
+// ExecContext allows calling the underlying ExecContext method of the driver if it is supported by it.
+// See, database/sql#DB.ExecContext for more information.
+func (c *config) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) {
+	ex, ok := c.driver.(interface {
+		ExecContext(context.Context, string, ...any) (stdsql.Result, error)
+	})
+	if !ok {
+		return nil, fmt.Errorf("Driver.ExecContext is not supported")
+	}
+	return ex.ExecContext(ctx, query, args...)
+}
+
+// QueryContext allows calling the underlying QueryContext method of the driver if it is supported by it.
+// See, database/sql#DB.QueryContext for more information.
+func (c *config) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) {
+	q, ok := c.driver.(interface {
+		QueryContext(context.Context, string, ...any) (*stdsql.Rows, error)
+	})
+	if !ok {
+		return nil, fmt.Errorf("Driver.QueryContext is not supported")
+	}
+	return q.QueryContext(ctx, query, args...)
+}
diff --git a/internal/database/ent/db/tx.go b/internal/database/ent/db/tx.go
index a9856134..f0ab91bb 100644
--- a/internal/database/ent/db/tx.go
+++ b/internal/database/ent/db/tx.go
@@ -4,6 +4,8 @@ package db
 
 import (
 	"context"
+	stdsql "database/sql"
+	"fmt"
 	"sync"
 
 	"entgo.io/ent/dialect"
@@ -247,3 +249,27 @@ func (tx *txDriver) Query(ctx context.Context, query string, args, v any) error
 }
 
 var _ dialect.Driver = (*txDriver)(nil)
+
+// ExecContext allows calling the underlying ExecContext method of the transaction if it is supported by it.
+// See, database/sql#Tx.ExecContext for more information.
+func (tx *txDriver) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) {
+	ex, ok := tx.tx.(interface {
+		ExecContext(context.Context, string, ...any) (stdsql.Result, error)
+	})
+	if !ok {
+		return nil, fmt.Errorf("Tx.ExecContext is not supported")
+	}
+	return ex.ExecContext(ctx, query, args...)
+}
+
+// QueryContext allows calling the underlying QueryContext method of the transaction if it is supported by it.
+// See, database/sql#Tx.QueryContext for more information.
+func (tx *txDriver) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) {
+	q, ok := tx.tx.(interface {
+		QueryContext(context.Context, string, ...any) (*stdsql.Rows, error)
+	})
+	if !ok {
+		return nil, fmt.Errorf("Tx.QueryContext is not supported")
+	}
+	return q.QueryContext(ctx, query, args...)
+}
diff --git a/internal/database/ent/generate.go b/internal/database/ent/generate.go
index ce73767e..f92ce718 100644
--- a/internal/database/ent/generate.go
+++ b/internal/database/ent/generate.go
@@ -1,3 +1,3 @@
 package ent
 
-//go:generate go run -mod=mod entgo.io/ent/cmd/ent generate --feature sql/versioned-migration --target ./db ./schema
+//go:generate go run -mod=mod entgo.io/ent/cmd/ent generate --feature sql/versioned-migration,sql/execquery --target ./db ./schema
diff --git a/internal/database/snapshots.go b/internal/database/snapshots.go
index cd344cf7..34613a5c 100644
--- a/internal/database/snapshots.go
+++ b/internal/database/snapshots.go
@@ -56,22 +56,23 @@ func (c *client) CreateAccountVehicleSnapshots(ctx context.Context, accountID st
 	}
 
 	var errors = make(map[string]error)
-	for _, data := range snapshots {
-		err := c.db.VehicleSnapshot.Create().
-			SetType(data.Type).
-			SetFrame(data.Stats).
-			SetVehicleID(data.VehicleID).
-			SetReferenceID(data.ReferenceID).
-			SetBattles(int(data.Stats.Battles.Float())).
-			SetLastBattleTime(data.LastBattleTime.Unix()).
-			SetAccount(c.db.Account.GetX(ctx, accountID)).
-			Exec(ctx)
-		if err != nil {
-			errors[data.VehicleID] = err
+	return errors, c.withTx(ctx, func(tx *db.Tx) error {
+		for _, data := range snapshots {
+			err := c.db.VehicleSnapshot.Create().
+				SetType(data.Type).
+				SetFrame(data.Stats).
+				SetVehicleID(data.VehicleID).
+				SetReferenceID(data.ReferenceID).
+				SetBattles(int(data.Stats.Battles.Float())).
+				SetLastBattleTime(data.LastBattleTime.Unix()).
+				SetAccount(c.db.Account.GetX(ctx, accountID)).
+				Exec(ctx)
+			if err != nil {
+				errors[data.VehicleID] = err
+			}
 		}
-	}
-
-	return errors, nil
+		return nil
+	})
 }
 
 func (c *client) GetVehicleSnapshots(ctx context.Context, accountID, referenceID string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.VehicleSnapshot, error) {
@@ -129,23 +130,24 @@ func (c *client) CreateAccountSnapshots(ctx context.Context, snapshots ...models
 	}
 
 	var errors = make(map[string]error)
-	for _, s := range snapshots {
-		err := c.db.AccountSnapshot.Create().
-			SetAccount(c.db.Account.GetX(ctx, s.AccountID)). // we assume the account exists here
-			SetCreatedAt(s.CreatedAt.Unix()).
-			SetLastBattleTime(s.LastBattleTime.Unix()).
-			SetRatingBattles(int(s.RatingBattles.Battles.Float())).
-			SetRatingFrame(s.RatingBattles).
-			SetReferenceID(s.ReferenceID).
-			SetRegularBattles(int(s.RegularBattles.Battles)).
-			SetRegularFrame(s.RegularBattles).
-			SetType(s.Type).Exec(ctx)
-		if err != nil {
-			errors[s.AccountID] = err
+	return errors, c.withTx(ctx, func(tx *db.Tx) error {
+		for _, s := range snapshots {
+			err := c.db.AccountSnapshot.Create().
+				SetAccount(c.db.Account.GetX(ctx, s.AccountID)). // we assume the account exists here
+				SetCreatedAt(s.CreatedAt.Unix()).
+				SetLastBattleTime(s.LastBattleTime.Unix()).
+				SetRatingBattles(int(s.RatingBattles.Battles.Float())).
+				SetRatingFrame(s.RatingBattles).
+				SetReferenceID(s.ReferenceID).
+				SetRegularBattles(int(s.RegularBattles.Battles)).
+				SetRegularFrame(s.RegularBattles).
+				SetType(s.Type).Exec(ctx)
+			if err != nil {
+				errors[s.AccountID] = err
+			}
 		}
-	}
-
-	return errors, nil
+		return nil
+	})
 }
 
 func (c *client) GetLastAccountSnapshots(ctx context.Context, accountID string, limit int) ([]models.AccountSnapshot, error) {
diff --git a/internal/database/tasks.go b/internal/database/tasks.go
index 0b63828a..19276620 100644
--- a/internal/database/tasks.go
+++ b/internal/database/tasks.go
@@ -82,59 +82,51 @@ func (c *client) GetAndStartTasks(ctx context.Context, limit int) ([]models.Task
 		return nil, nil
 	}
 
-	tx, err := c.db.BeginTx(ctx, &sql.TxOptions{})
-	if err != nil {
-		return nil, err
-	}
-
-	records, err := tx.CronTask.Query().Where(crontask.StatusEQ(models.TaskStatusScheduled), crontask.ScheduledAfterLT(time.Now().Unix())).Order(crontask.ByScheduledAfter(sql.OrderAsc())).Limit(limit).All(ctx)
-	if err != nil {
-		return nil, rollback(tx, err)
-	}
-
-	var ids []string
 	var tasks []models.Task
-	for _, r := range records {
-		t := toCronTask(r)
-		t.OnUpdated()
+	return tasks, c.withTx(ctx, func(tx *db.Tx) error {
+		records, err := tx.CronTask.Query().Where(crontask.StatusEQ(models.TaskStatusScheduled), crontask.ScheduledAfterLT(time.Now().Unix())).Order(crontask.ByScheduledAfter(sql.OrderAsc())).Limit(limit).All(ctx)
+		if err != nil {
+			return err
+		}
 
-		t.Status = models.TaskStatusInProgress
-		tasks = append(tasks, t)
-		ids = append(ids, r.ID)
-	}
+		var ids []string
+		for _, r := range records {
+			t := toCronTask(r)
+			t.OnUpdated()
 
-	err = tx.CronTask.Update().Where(crontask.IDIn(ids...)).SetStatus(models.TaskStatusInProgress).Exec(ctx)
-	if err != nil {
-		return nil, rollback(tx, err)
-	}
+			t.Status = models.TaskStatusInProgress
+			tasks = append(tasks, t)
+			ids = append(ids, r.ID)
+		}
 
-	return tasks, tx.Commit()
+		return tx.CronTask.Update().Where(crontask.IDIn(ids...)).SetStatus(models.TaskStatusInProgress).Exec(ctx)
+	})
 }
 
 func (c *client) CreateTasks(ctx context.Context, tasks ...models.Task) error {
 	if len(tasks) < 1 {
 		return nil
 	}
-
-	var inserts []*db.CronTaskCreate
-	for _, t := range tasks {
-		t.OnCreated()
-		t.OnUpdated()
-
-		inserts = append(inserts,
-			c.db.CronTask.Create().
-				SetType(t.Type).
-				SetData(t.Data).
-				SetLogs(t.Logs).
-				SetStatus(t.Status).
-				SetTargets(t.Targets).
-				SetLastRun(t.LastRun.Unix()).
-				SetReferenceID(t.ReferenceID).
-				SetScheduledAfter(t.ScheduledAfter.Unix()),
-		)
-	}
-
-	return c.db.CronTask.CreateBulk(inserts...).Exec(ctx)
+	return c.withTx(ctx, func(tx *db.Tx) error {
+		var inserts []*db.CronTaskCreate
+		for _, t := range tasks {
+			t.OnCreated()
+			t.OnUpdated()
+
+			inserts = append(inserts,
+				c.db.CronTask.Create().
+					SetType(t.Type).
+					SetData(t.Data).
+					SetLogs(t.Logs).
+					SetStatus(t.Status).
+					SetTargets(t.Targets).
+					SetLastRun(t.LastRun.Unix()).
+					SetReferenceID(t.ReferenceID).
+					SetScheduledAfter(t.ScheduledAfter.Unix()),
+			)
+		}
+		return c.db.CronTask.CreateBulk(inserts...).Exec(ctx)
+	})
 }
 
 func (c *client) GetTasks(ctx context.Context, ids ...string) ([]models.Task, error) {
@@ -165,30 +157,24 @@ func (c *client) UpdateTasks(ctx context.Context, tasks ...models.Task) error {
 		return nil
 	}
 
-	tx, cancel, err := c.txWithLock(ctx)
-	if err != nil {
-		return err
-	}
-	defer cancel()
-
-	for _, t := range tasks {
-		t.OnUpdated()
+	return c.withTx(ctx, func(tx *db.Tx) error {
+		for _, t := range tasks {
+			t.OnUpdated()
 
-		err := tx.CronTask.UpdateOneID(t.ID).
-			SetData(t.Data).
-			SetLogs(t.Logs).
-			SetStatus(t.Status).
-			SetTargets(t.Targets).
-			SetLastRun(t.LastRun.Unix()).
-			SetScheduledAfter(t.ScheduledAfter.Unix()).
-			Exec(ctx)
-
-		if err != nil {
-			return rollback(tx, err)
+			err := tx.CronTask.UpdateOneID(t.ID).
+				SetData(t.Data).
+				SetLogs(t.Logs).
+				SetStatus(t.Status).
+				SetTargets(t.Targets).
+				SetLastRun(t.LastRun.Unix()).
+				SetScheduledAfter(t.ScheduledAfter.Unix()).
+				Exec(ctx)
+			if err != nil {
+				return err
+			}
 		}
-	}
-
-	return tx.Commit()
+		return nil
+	})
 }
 
 /*
@@ -200,16 +186,9 @@ func (c *client) DeleteTasks(ctx context.Context, ids ...string) error {
 		return nil
 	}
 
-	tx, cancel, err := c.txWithLock(ctx)
-	if err != nil {
+	return c.withTx(ctx, func(tx *db.Tx) error {
+		_, err := tx.CronTask.Delete().Where(crontask.IDIn(ids...)).Exec(ctx)
 		return err
-	}
-	defer cancel()
-
-	_, err = tx.CronTask.Delete().Where(crontask.IDIn(ids...)).Exec(ctx)
-	if err != nil {
-		return rollback(tx, err)
-	}
+	})
 
-	return tx.Commit()
 }
diff --git a/internal/database/vehicles.go b/internal/database/vehicles.go
index dde1c3b3..4abd2648 100644
--- a/internal/database/vehicles.go
+++ b/internal/database/vehicles.go
@@ -32,33 +32,35 @@ func (c *client) UpsertVehicles(ctx context.Context, vehicles map[string]models.
 	}
 
 	errors := make(map[string]error)
-	for _, r := range records {
-		v, ok := vehicles[r.ID]
-		if !ok {
-			continue
-		}
+	return errors, c.withTx(ctx, func(tx *db.Tx) error {
+		for _, r := range records {
+			v, ok := vehicles[r.ID]
+			if !ok {
+				continue
+			}
 
-		err := c.db.Vehicle.UpdateOneID(v.ID).
-			SetTier(v.Tier).
-			SetLocalizedNames(v.LocalizedNames).
-			Exec(ctx)
-		if err != nil {
-			errors[v.ID] = err
-		}
+			err := c.db.Vehicle.UpdateOneID(v.ID).
+				SetTier(v.Tier).
+				SetLocalizedNames(v.LocalizedNames).
+				Exec(ctx)
+			if err != nil {
+				errors[v.ID] = err
+			}
 
-		delete(vehicles, v.ID)
-	}
+			delete(vehicles, v.ID)
+		}
 
-	var writes []*db.VehicleCreate
-	for id, v := range vehicles {
-		writes = append(writes, c.db.Vehicle.Create().
-			SetID(id).
-			SetTier(v.Tier).
-			SetLocalizedNames(v.LocalizedNames),
-		)
-	}
+		var writes []*db.VehicleCreate
+		for id, v := range vehicles {
+			writes = append(writes, c.db.Vehicle.Create().
+				SetID(id).
+				SetTier(v.Tier).
+				SetLocalizedNames(v.LocalizedNames),
+			)
+		}
 
-	return errors, c.db.Vehicle.CreateBulk(writes...).Exec(ctx)
+		return c.db.Vehicle.CreateBulk(writes...).Exec(ctx)
+	})
 }
 
 func (c *client) GetVehicles(ctx context.Context, ids []string) (map[string]models.Vehicle, error) {
diff --git a/main.go b/main.go
index 0b37f0bb..2a28f4dc 100644
--- a/main.go
+++ b/main.go
@@ -44,7 +44,7 @@ func main() {
 	loadStaticAssets(static)
 
 	liveCoreClient, cacheCoreClient := coreClientsFromEnv()
-	startSchedulerFromEnvAsync(cacheCoreClient.Database(), cacheCoreClient.Wargaming())
+	startSchedulerFromEnvAsync(cacheCoreClient.Wargaming())
 
 	// Load some init options to registered admin accounts and etc
 	logic.ApplyInitOptions(liveCoreClient.Database())
@@ -83,7 +83,7 @@ func main() {
 	servePublic()
 }
 
-func startSchedulerFromEnvAsync(dbClient database.Client, wgClient wargaming.Client) {
+func startSchedulerFromEnvAsync(wgClient wargaming.Client) {
 	if os.Getenv("SCHEDULER_ENABLED") != "true" {
 		return
 	}
@@ -94,11 +94,11 @@ func startSchedulerFromEnvAsync(dbClient database.Client, wgClient wargaming.Cli
 	}
 
 	// Fetch client
-	client, err := fetch.NewMultiSourceClient(wgClient, bsClient, dbClient)
+	client, err := fetch.NewMultiSourceClient(wgClient, bsClient, newDatabaseClientFromEnv())
 	if err != nil {
 		log.Fatal().Msgf("fetch#NewMultiSourceClient failed %s", err)
 	}
-	coreClient := core.NewClient(client, wgClient, dbClient)
+	coreClient := core.NewClient(client, wgClient, newDatabaseClientFromEnv())
 
 	// Queue
 	taskQueueConcurrency := 10
@@ -117,16 +117,6 @@ func startSchedulerFromEnvAsync(dbClient database.Client, wgClient wargaming.Cli
 }
 
 func coreClientsFromEnv() (core.Client, core.Client) {
-	err := os.MkdirAll(os.Getenv("DATABASE_PATH"), os.ModePerm)
-	if err != nil {
-		log.Fatal().Msgf("os#MkdirAll failed %s", err)
-	}
-
-	// Dependencies
-	dbClient, err := database.NewSQLiteClient(filepath.Join(os.Getenv("DATABASE_PATH"), os.Getenv("DATABASE_NAME")))
-	if err != nil {
-		log.Fatal().Msgf("database#NewClient failed %s", err)
-	}
 	bsClient, err := blitzstars.NewClient(os.Getenv("BLITZ_STARS_API_URL"), time.Second*10)
 	if err != nil {
 		log.Fatal().Msgf("failed to init a blitzstars client %s", err)
@@ -135,12 +125,12 @@ func coreClientsFromEnv() (core.Client, core.Client) {
 	liveClient, cacheClient := wargamingClientsFromEnv()
 
 	// Fetch client
-	fetchClient, err := fetch.NewMultiSourceClient(cacheClient, bsClient, dbClient)
+	fetchClient, err := fetch.NewMultiSourceClient(cacheClient, bsClient, newDatabaseClientFromEnv())
 	if err != nil {
 		log.Fatal().Msgf("fetch#NewMultiSourceClient failed %s", err)
 	}
 
-	return core.NewClient(fetchClient, liveClient, dbClient), core.NewClient(fetchClient, cacheClient, dbClient)
+	return core.NewClient(fetchClient, liveClient, newDatabaseClientFromEnv()), core.NewClient(fetchClient, cacheClient, newDatabaseClientFromEnv())
 }
 
 func loadStaticAssets(static fs.FS) {
@@ -173,3 +163,17 @@ func wargamingClientsFromEnv() (wargaming.Client, wargaming.Client) {
 
 	return liveClient, cacheClient
 }
+
+func newDatabaseClientFromEnv() database.Client {
+	err := os.MkdirAll(os.Getenv("DATABASE_PATH"), os.ModePerm)
+	if err != nil {
+		log.Fatal().Msgf("os#MkdirAll failed %s", err)
+	}
+
+	client, err := database.NewSQLiteClient(filepath.Join(os.Getenv("DATABASE_PATH"), os.Getenv("DATABASE_NAME")))
+	if err != nil {
+		log.Fatal().Msgf("database#NewClient failed %s", err)
+	}
+
+	return client
+}

From 9f847a4f77d3773d84b2056c0776b52c7338fc4e Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Mon, 24 Jun 2024 14:14:03 -0400
Subject: [PATCH 165/341] rewrite of queue/scheduler

---
 cmds/core/queue/queue.go                      | 220 ++++++++++++++++++
 cmds/core/scheduler/cron.go                   |  43 ----
 cmds/core/scheduler/glossary.go               |  84 -------
 cmds/core/scheduler/queue.go                  | 139 -----------
 cmds/core/scheduler/scheduler.go              |  58 +++++
 cmds/core/scheduler/workers.go                | 114 ++++++---
 .../core/server/handlers/private/snapshots.go |   2 +-
 cmds/core/{scheduler => }/tasks/cleanup.go    |   0
 cmds/core/{scheduler => }/tasks/handler.go    |   0
 cmds/core/{scheduler => }/tasks/sessions.go   |   0
 cmds/core/{scheduler => }/tasks/split.go      |   0
 internal/database/client.go                   |   1 +
 internal/database/models/task.go              |   6 +-
 internal/database/tasks.go                    |  36 +++
 main.go                                       | 101 ++++++--
 15 files changed, 471 insertions(+), 333 deletions(-)
 create mode 100644 cmds/core/queue/queue.go
 delete mode 100644 cmds/core/scheduler/cron.go
 delete mode 100644 cmds/core/scheduler/glossary.go
 delete mode 100644 cmds/core/scheduler/queue.go
 create mode 100644 cmds/core/scheduler/scheduler.go
 rename cmds/core/{scheduler => }/tasks/cleanup.go (100%)
 rename cmds/core/{scheduler => }/tasks/handler.go (100%)
 rename cmds/core/{scheduler => }/tasks/sessions.go (100%)
 rename cmds/core/{scheduler => }/tasks/split.go (100%)

diff --git a/cmds/core/queue/queue.go b/cmds/core/queue/queue.go
new file mode 100644
index 00000000..a07ca7a8
--- /dev/null
+++ b/cmds/core/queue/queue.go
@@ -0,0 +1,220 @@
+package queue
+
+import (
+	"context"
+	"fmt"
+	"runtime/debug"
+	"sync"
+	"time"
+
+	"github.com/cufee/aftermath/cmds/core"
+	"github.com/cufee/aftermath/cmds/core/scheduler"
+	"github.com/cufee/aftermath/cmds/core/tasks"
+	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/pkg/errors"
+	"github.com/rs/zerolog/log"
+)
+
+type queue struct {
+	queueLock *sync.Mutex
+	queued    chan models.Task
+	handlers  map[models.TaskType]tasks.TaskHandler
+
+	workerLimit   int
+	workerLimiter chan struct{}
+	workerTimeout time.Duration
+
+	activeTasks   map[string]struct{}
+	activeTasksMx *sync.Mutex
+	newCoreClient func() (core.Client, error)
+}
+
+func New(workerLimit int, newCoreClient func() (core.Client, error)) *queue {
+	return &queue{
+		newCoreClient: newCoreClient,
+		handlers:      make(map[models.TaskType]tasks.TaskHandler),
+
+		workerLimit:   workerLimit,
+		workerLimiter: make(chan struct{}, workerLimit),
+
+		activeTasksMx: &sync.Mutex{},
+		activeTasks:   make(map[string]struct{}),
+
+		queueLock: &sync.Mutex{},
+		queued:    make(chan models.Task, workerLimit*2),
+	}
+}
+
+func (q *queue) SetHandlers(handlers map[models.TaskType]tasks.TaskHandler) error {
+	for t, h := range handlers {
+		if _, ok := q.handlers[t]; ok {
+			return fmt.Errorf("handler for %s is already registered", t)
+		}
+		q.handlers[t] = h
+	}
+	return nil
+}
+
+func (q *queue) Start(ctx context.Context) (func(), error) {
+	qctx, qCancel := context.WithCancel(ctx)
+
+	coreClint, err := q.newCoreClient()
+	if err != nil {
+		qCancel()
+		return nil, err
+	}
+
+	s := scheduler.New()
+	// on cron, pull and enqueue available tasks
+	s.Add("* * * * *", func() {
+		pctx, cancel := context.WithTimeout(qctx, time.Second*5)
+		defer cancel()
+		err := q.pullAndEnqueueTasks(pctx, coreClint.Database())
+		if err != nil {
+			log.Err(err).Msg("failed to pull tasks")
+		}
+	})
+	stopScheduler, err := s.Start(qctx)
+	if err != nil {
+		qCancel()
+		return nil, err
+	}
+
+	go q.startWorkers(qctx, func(_ string) {
+		if len(q.queued) < q.workerLimit {
+			err := q.pullAndEnqueueTasks(qctx, coreClint.Database())
+			if err != nil {
+				log.Err(err).Msg("failed to pull tasks")
+			}
+		}
+	})
+
+	return func() {
+		qCancel()
+		stopScheduler()
+
+		q.activeTasksMx.Lock()
+		defer q.activeTasksMx.Unlock()
+
+		var abandonedIDs []string
+		for id := range q.activeTasks {
+			abandonedIDs = append(abandonedIDs, id)
+		}
+
+		cctx, cancel := context.WithTimeout(context.Background(), time.Second)
+		defer cancel()
+
+		err = coreClint.Database().AbandonTasks(cctx, abandonedIDs...)
+		if err != nil {
+			log.Err(err).Msg("failed to abandon tasks")
+		}
+	}, nil
+}
+
+func (q *queue) Enqueue(task models.Task) {
+	q.queued <- task
+}
+
+func (q *queue) pullAndEnqueueTasks(ctx context.Context, db database.Client) error {
+	if ok := q.queueLock.TryLock(); !ok {
+		return errors.New("queue is locked")
+	}
+	defer q.queueLock.Unlock()
+
+	tasks, err := db.GetAndStartTasks(ctx, q.workerLimit)
+	if err != nil && !database.IsNotFound(err) {
+		return err
+	}
+
+	go func(tasks []models.Task) {
+		for _, t := range tasks {
+			q.Enqueue(t)
+		}
+	}(tasks)
+
+	return nil
+}
+
+func (q *queue) startWorkers(ctx context.Context, onComplete func(id string)) {
+	for {
+		select {
+		case task := <-q.queued:
+			go func() {
+				q.workerLimiter <- struct{}{}
+				q.activeTasksMx.Lock()
+				q.activeTasks[task.ID] = struct{}{}
+				q.activeTasksMx.Unlock()
+				defer func() {
+					<-q.workerLimiter
+					q.activeTasksMx.Lock()
+					delete(q.activeTasks, task.ID)
+					q.activeTasksMx.Unlock()
+					if onComplete != nil {
+						onComplete(task.ID)
+					}
+				}()
+
+				defer func() {
+					if r := recover(); r != nil {
+						event := log.Error().Str("stack", string(debug.Stack())).Str("taskId", task.ID)
+						defer event.Msg("panic in queue worker")
+
+						coreClient, err := q.newCoreClient()
+						if err != nil {
+							event.AnErr("core", err).Str("additional", "failed to create a core client")
+							return
+						}
+						task.Status = models.TaskStatusFailed
+						task.LogAttempt(models.TaskLog{
+							Timestamp: time.Now(),
+							Comment:   "task caused a panic in worker handler",
+						})
+						err = coreClient.Database().UpdateTasks(context.Background(), task)
+						if err != nil {
+							event.AnErr("updateTasks", err).Str("additional", "failed to update a task")
+						}
+					}
+				}()
+
+				wctx, cancel := context.WithTimeout(ctx, q.workerTimeout)
+				defer cancel()
+
+				handler, ok := q.handlers[task.Type]
+				if !ok {
+					log.Error().Str("type", string(task.Type)).Msg("task missing a handler")
+					return
+				}
+
+				coreClient, err := q.newCoreClient()
+				if err != nil {
+					log.Err(err).Msg("failed to create a new core client for a task worker")
+					return
+				}
+				msg, err := handler.Process(coreClient, task)
+				task.Status = models.TaskStatusComplete
+				task.LogAttempt(models.TaskLog{
+					Timestamp: time.Now(),
+					Comment:   msg,
+					Error:     err,
+				})
+
+				if err != nil {
+					if handler.ShouldRetry(&task) {
+						task.Status = models.TaskStatusScheduled
+					} else {
+						task.Status = models.TaskStatusFailed
+					}
+				}
+
+				err = coreClient.Database().UpdateTasks(wctx, task)
+				if err != nil {
+					log.Err(err).Msg("failed to update a task")
+				}
+			}()
+
+		case <-ctx.Done():
+			return
+		}
+	}
+}
diff --git a/cmds/core/scheduler/cron.go b/cmds/core/scheduler/cron.go
deleted file mode 100644
index 36970b68..00000000
--- a/cmds/core/scheduler/cron.go
+++ /dev/null
@@ -1,43 +0,0 @@
-package scheduler
-
-import (
-	"time"
-
-	"github.com/go-co-op/gocron"
-	"github.com/rs/zerolog/log"
-)
-
-func (queue *Queue) StartCronJobsAsync() {
-	defer log.Info().Msg("started cron scheduler")
-
-	c := gocron.NewScheduler(time.UTC)
-	// Tasks
-	c.CronWithSeconds("*/15 * * * * *").Do(RunTasksWorker(queue))
-	// some tasks might be stuck due to a panic or restart, restart them
-	c.Cron("0 * * * *").Do(RestartTasksWorker(queue.core))
-	c.Cron("0 5 * * *").Do(CreateCleanupTaskWorker(queue.core)) // delete expired documents
-
-	// Glossary - Do it around the same time WG releases game updates
-	c.Cron("0 10 * * *").Do(UpdateGlossaryWorker(queue.core))
-	c.Cron("0 12 * * *").Do(UpdateGlossaryWorker(queue.core))
-	// c.AddFunc("40 9 * * 0", updateAchievementsWorker)
-
-	// Averages - Update averages once daily
-	c.Cron("0 0 * * *").Do(UpdateAveragesWorker(queue.core))
-
-	// Sessions
-	c.Cron("0 9 * * *").Do(CreateSessionTasksWorker(queue.core, "NA"))  // NA
-	c.Cron("0 1 * * *").Do(CreateSessionTasksWorker(queue.core, "EU"))  // EU
-	c.Cron("0 18 * * *").Do(CreateSessionTasksWorker(queue.core, "AS")) // Asia
-
-	// Refresh WN8
-	// "45 9 * * *" 	// NA
-	// "45 1 * * *" 	// EU
-	// "45 18 * * *" 	// Asia
-
-	// Configurations
-	c.Cron("0 0 */7 * *").Do(RotateBackgroundPresetsWorker(queue.core))
-
-	// Start the Cron job scheduler
-	c.StartAsync()
-}
diff --git a/cmds/core/scheduler/glossary.go b/cmds/core/scheduler/glossary.go
deleted file mode 100644
index a5715a1d..00000000
--- a/cmds/core/scheduler/glossary.go
+++ /dev/null
@@ -1,84 +0,0 @@
-package scheduler
-
-import (
-	"context"
-	"time"
-
-	"github.com/cufee/aftermath/cmds/core"
-	"github.com/cufee/aftermath/internal/database/models"
-	"github.com/rs/zerolog/log"
-	"golang.org/x/text/language"
-)
-
-func UpdateAveragesWorker(client core.Client) func() {
-	// we just run the logic directly as it's not a heavy task and it doesn't matter if it fails
-	return func() {
-		log.Info().Msg("updating tank averages cache")
-
-		ctx, cancel := context.WithTimeout(context.Background(), time.Minute*1)
-		defer cancel()
-
-		averages, err := client.Fetch().CurrentTankAverages(ctx)
-		if err != nil {
-			log.Err(err).Msg("failed to update averages cache")
-			return
-		}
-
-		aErr, err := client.Database().UpsertVehicleAverages(ctx, averages)
-		if err != nil {
-			log.Err(err).Msg("failed to update averages cache")
-			return
-		}
-		if len(aErr) > 0 {
-			event := log.Error()
-			for id, err := range aErr {
-				event.Str(id, err.Error())
-			}
-			event.Msg("failed to update some average cache")
-			return
-		}
-
-		log.Info().Msg("averages cache updated")
-	}
-}
-
-func UpdateGlossaryWorker(client core.Client) func() {
-	// we just run the logic directly as it's not a heavy task and it doesn't matter if it fails
-	return func() {
-		log.Info().Msg("updating glossary cache")
-
-		ctx, cancel := context.WithTimeout(context.Background(), time.Second*15)
-		defer cancel()
-
-		glossary, err := client.Wargaming().CompleteVehicleGlossary(ctx, "eu", "en")
-		if err != nil {
-			log.Err(err).Msg("failed to get vehicle glossary")
-			return
-		}
-
-		vehicles := make(map[string]models.Vehicle)
-		for id, data := range glossary {
-			vehicles[id] = models.Vehicle{
-				ID:             id,
-				Tier:           data.Tier,
-				LocalizedNames: map[string]string{language.English.String(): data.Name},
-			}
-		}
-
-		vErr, err := client.Database().UpsertVehicles(ctx, vehicles)
-		if err != nil {
-			log.Err(err).Msg("failed to save vehicle glossary")
-			return
-		}
-		if len(vErr) > 0 {
-			event := log.Error()
-			for id, err := range vErr {
-				event.Str(id, err.Error())
-			}
-			event.Msg("failed to save some vehicle glossaries")
-			return
-		}
-
-		log.Info().Msg("glossary cache updated")
-	}
-}
diff --git a/cmds/core/scheduler/queue.go b/cmds/core/scheduler/queue.go
deleted file mode 100644
index 5eca5e38..00000000
--- a/cmds/core/scheduler/queue.go
+++ /dev/null
@@ -1,139 +0,0 @@
-package scheduler
-
-import (
-	"context"
-	"runtime/debug"
-	"sync"
-	"time"
-
-	"github.com/cufee/aftermath/cmds/core"
-	"github.com/cufee/aftermath/cmds/core/scheduler/tasks"
-	"github.com/cufee/aftermath/internal/database/models"
-	"github.com/rs/zerolog/log"
-)
-
-type Queue struct {
-	limiter          chan struct{}
-	concurrencyLimit int
-	lastTaskRun      time.Time
-
-	handlers map[models.TaskType]tasks.TaskHandler
-	core     core.Client
-}
-
-func (q *Queue) ConcurrencyLimit() int {
-	return q.concurrencyLimit
-}
-
-func (q *Queue) ActiveWorkers() int {
-	return len(q.limiter)
-}
-
-func (q *Queue) LastTaskRun() time.Time {
-	return q.lastTaskRun
-}
-
-func NewQueue(client core.Client, handlers map[models.TaskType]tasks.TaskHandler, concurrencyLimit int) *Queue {
-	return &Queue{
-		core:             client,
-		handlers:         handlers,
-		concurrencyLimit: concurrencyLimit,
-		limiter:          make(chan struct{}, concurrencyLimit),
-	}
-}
-
-func (q *Queue) Process(callback func(error), tasks ...models.Task) {
-	var err error
-	if callback != nil {
-		defer callback(err)
-	}
-	if len(tasks) == 0 {
-		log.Debug().Msg("no tasks to process")
-		return
-	}
-
-	log.Debug().Msgf("processing %d tasks", len(tasks))
-
-	var wg sync.WaitGroup
-	q.lastTaskRun = time.Now()
-	processedTasks := make(chan models.Task, len(tasks))
-	for _, task := range tasks {
-		wg.Add(1)
-		go func(t models.Task) {
-			defer func() {
-				if r := recover(); r != nil {
-					log.Error().Str("stack", string(debug.Stack())).Msg("panic in task handler")
-					t.Status = models.TaskStatusFailed
-					t.LogAttempt(models.TaskLog{
-						Targets:   t.Targets,
-						Timestamp: time.Now(),
-						Error:     "task handler caused a panic",
-					})
-				} else {
-					log.Debug().Msgf("finished processing task %s", t.ID)
-				}
-				processedTasks <- t
-				<-q.limiter
-				wg.Done()
-			}()
-
-			q.limiter <- struct{}{}
-			log.Debug().Msgf("processing task %s", t.ID)
-
-			handler, ok := q.handlers[t.Type]
-			if !ok {
-				t.Status = models.TaskStatusFailed
-				t.LogAttempt(models.TaskLog{
-					Targets:   t.Targets,
-					Timestamp: time.Now(),
-					Error:     "missing task type handler",
-				})
-				return
-			}
-			t.LastRun = time.Now()
-
-			attempt := models.TaskLog{
-				Targets:   t.Targets,
-				Timestamp: time.Now(),
-			}
-
-			message, err := handler.Process(q.core, t)
-			attempt.Comment = message
-			if err != nil {
-				attempt.Error = err.Error()
-				t.Status = models.TaskStatusFailed
-			} else {
-				t.Status = models.TaskStatusComplete
-			}
-			t.LogAttempt(attempt)
-		}(task)
-	}
-
-	wg.Wait()
-	close(processedTasks)
-
-	rescheduledCount := 0
-	processedSlice := make([]models.Task, 0, len(processedTasks))
-	for task := range processedTasks {
-		handler, ok := q.handlers[task.Type]
-		if !ok {
-			continue
-		}
-
-		if task.Status == models.TaskStatusFailed && handler.ShouldRetry(&task) {
-			rescheduledCount++
-			task.Status = models.TaskStatusScheduled
-		}
-		processedSlice = append(processedSlice, task)
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
-	defer cancel()
-
-	err = q.core.Database().UpdateTasks(ctx, processedSlice...)
-	if err != nil {
-		return
-	}
-
-	log.Debug().Msgf("processed %d tasks, %d rescheduled", len(processedSlice), rescheduledCount)
-}
diff --git a/cmds/core/scheduler/scheduler.go b/cmds/core/scheduler/scheduler.go
new file mode 100644
index 00000000..ae1ac46d
--- /dev/null
+++ b/cmds/core/scheduler/scheduler.go
@@ -0,0 +1,58 @@
+package scheduler
+
+import (
+	"context"
+	"time"
+
+	"github.com/cufee/aftermath/cmds/core"
+	"github.com/go-co-op/gocron"
+)
+
+type scheduler struct {
+	cron *gocron.Scheduler
+	jobs []*gocron.Job
+}
+
+func New() *scheduler {
+	return &scheduler{cron: gocron.NewScheduler(time.UTC)}
+}
+
+func (s *scheduler) Add(cron string, fn func()) (*gocron.Job, error) {
+	j, err := s.cron.Cron(cron).Do(fn)
+	if err != nil {
+		return nil, err
+	}
+	s.jobs = append(s.jobs, j)
+	return j, nil
+}
+
+func (s *scheduler) Start(ctx context.Context) (func(), error) {
+	go s.cron.StartBlocking()
+	return s.cron.Stop, nil
+}
+
+func RegisterDefaultTasks(s *scheduler, coreClient core.Client) {
+	s.Add("0 * * * *", RestartTasksWorker(coreClient))
+	s.Add("0 5 * * *", CreateCleanupTaskWorker(coreClient)) // delete expired documents
+
+	// Glossary - Do it around the same time WG releases game updates
+	s.Add("0 10 * * *", UpdateGlossaryWorker(coreClient))
+	s.Add("0 12 * * *", UpdateGlossaryWorker(coreClient))
+	// c.AddFunc("40 9 * * 0", updateAchievementsWorker)
+
+	// Averages - Update averages once daily
+	s.Add("0 0 * * *", UpdateAveragesWorker(coreClient))
+
+	// Sessions
+	s.Add("0 9 * * *", CreateSessionTasksWorker(coreClient, "NA"))  // NA
+	s.Add("0 1 * * *", CreateSessionTasksWorker(coreClient, "EU"))  // EU
+	s.Add("0 18 * * *", CreateSessionTasksWorker(coreClient, "AS")) // Asia
+
+	// Refresh WN8
+	// "45 9 * * *" 	// NA
+	// "45 1 * * *" 	// EU
+	// "45 18 * * *" 	// Asia
+
+	// Configurations
+	s.Add("0 0 */7 * *", RotateBackgroundPresetsWorker(coreClient))
+}
diff --git a/cmds/core/scheduler/workers.go b/cmds/core/scheduler/workers.go
index 078ad939..bbd8b2eb 100644
--- a/cmds/core/scheduler/workers.go
+++ b/cmds/core/scheduler/workers.go
@@ -5,7 +5,9 @@ import (
 	"time"
 
 	"github.com/cufee/aftermath/cmds/core"
-	"github.com/cufee/aftermath/cmds/core/scheduler/tasks"
+	"github.com/cufee/aftermath/cmds/core/tasks"
+	"golang.org/x/text/language"
+
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/rs/zerolog/log"
@@ -45,43 +47,6 @@ func CreateSessionTasksWorker(client core.Client, realm string) func() {
 	}
 }
 
-func RunTasksWorker(queue *Queue) func() {
-	return func() {
-		activeWorkers := queue.ActiveWorkers()
-		if activeWorkers >= queue.concurrencyLimit {
-			log.Debug().Int("active", activeWorkers).Int("limit", queue.concurrencyLimit).Msg("no available workers to process tasks")
-			return
-		}
-
-		ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
-		defer cancel()
-
-		batchSize := queue.concurrencyLimit - activeWorkers
-		tasks, err := queue.core.Database().GetAndStartTasks(ctx, batchSize)
-		if err != nil {
-			if database.IsNotFound(err) {
-				log.Debug().Msg("no scheduled tasks to process")
-				return
-			}
-			log.Err(err).Msg("failed to start scheduled tasks")
-			return
-		}
-		if len(tasks) < 1 {
-			log.Debug().Msg("no scheduled tasks to process")
-			return
-		}
-
-		queue.Process(func(err error) {
-			if err != nil {
-				log.Err(err).Msg("failed to process tasks")
-				return
-			}
-			// try to start the next task batch right away
-			RunTasksWorker(queue)
-		}, tasks...)
-	}
-}
-
 func RestartTasksWorker(core core.Client) func() {
 	return func() {
 		ctx, cancel := context.WithTimeout(context.Background(), time.Second*15)
@@ -118,3 +83,76 @@ func RestartTasksWorker(core core.Client) func() {
 		log.Debug().Int("count", len(staleTasks)).Msg("rescheduled stale tasks")
 	}
 }
+
+func UpdateAveragesWorker(client core.Client) func() {
+	// we just run the logic directly as it's not a heavy task and it doesn't matter if it fails
+	return func() {
+		log.Info().Msg("updating tank averages cache")
+
+		ctx, cancel := context.WithTimeout(context.Background(), time.Minute*1)
+		defer cancel()
+
+		averages, err := client.Fetch().CurrentTankAverages(ctx)
+		if err != nil {
+			log.Err(err).Msg("failed to update averages cache")
+			return
+		}
+
+		aErr, err := client.Database().UpsertVehicleAverages(ctx, averages)
+		if err != nil {
+			log.Err(err).Msg("failed to update averages cache")
+			return
+		}
+		if len(aErr) > 0 {
+			event := log.Error()
+			for id, err := range aErr {
+				event.Str(id, err.Error())
+			}
+			event.Msg("failed to update some average cache")
+			return
+		}
+
+		log.Info().Msg("averages cache updated")
+	}
+}
+
+func UpdateGlossaryWorker(client core.Client) func() {
+	// we just run the logic directly as it's not a heavy task and it doesn't matter if it fails
+	return func() {
+		log.Info().Msg("updating glossary cache")
+
+		ctx, cancel := context.WithTimeout(context.Background(), time.Second*15)
+		defer cancel()
+
+		glossary, err := client.Wargaming().CompleteVehicleGlossary(ctx, "eu", "en")
+		if err != nil {
+			log.Err(err).Msg("failed to get vehicle glossary")
+			return
+		}
+
+		vehicles := make(map[string]models.Vehicle)
+		for id, data := range glossary {
+			vehicles[id] = models.Vehicle{
+				ID:             id,
+				Tier:           data.Tier,
+				LocalizedNames: map[string]string{language.English.String(): data.Name},
+			}
+		}
+
+		vErr, err := client.Database().UpsertVehicles(ctx, vehicles)
+		if err != nil {
+			log.Err(err).Msg("failed to save vehicle glossary")
+			return
+		}
+		if len(vErr) > 0 {
+			event := log.Error()
+			for id, err := range vErr {
+				event.Str(id, err.Error())
+			}
+			event.Msg("failed to save some vehicle glossaries")
+			return
+		}
+
+		log.Info().Msg("glossary cache updated")
+	}
+}
diff --git a/cmds/core/server/handlers/private/snapshots.go b/cmds/core/server/handlers/private/snapshots.go
index a90a1ec8..c56b563d 100644
--- a/cmds/core/server/handlers/private/snapshots.go
+++ b/cmds/core/server/handlers/private/snapshots.go
@@ -6,7 +6,7 @@ import (
 	"strings"
 
 	"github.com/cufee/aftermath/cmds/core"
-	"github.com/cufee/aftermath/cmds/core/scheduler/tasks"
+	"github.com/cufee/aftermath/cmds/core/tasks"
 )
 
 var validRealms = []string{"na", "eu", "as"}
diff --git a/cmds/core/scheduler/tasks/cleanup.go b/cmds/core/tasks/cleanup.go
similarity index 100%
rename from cmds/core/scheduler/tasks/cleanup.go
rename to cmds/core/tasks/cleanup.go
diff --git a/cmds/core/scheduler/tasks/handler.go b/cmds/core/tasks/handler.go
similarity index 100%
rename from cmds/core/scheduler/tasks/handler.go
rename to cmds/core/tasks/handler.go
diff --git a/cmds/core/scheduler/tasks/sessions.go b/cmds/core/tasks/sessions.go
similarity index 100%
rename from cmds/core/scheduler/tasks/sessions.go
rename to cmds/core/tasks/sessions.go
diff --git a/cmds/core/scheduler/tasks/split.go b/cmds/core/tasks/split.go
similarity index 100%
rename from cmds/core/scheduler/tasks/split.go
rename to cmds/core/tasks/split.go
diff --git a/internal/database/client.go b/internal/database/client.go
index d3884a84..ee81bfb2 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -59,6 +59,7 @@ type TasksClient interface {
 	GetTasks(ctx context.Context, ids ...string) ([]models.Task, error)
 	UpdateTasks(ctx context.Context, tasks ...models.Task) error
 	DeleteTasks(ctx context.Context, ids ...string) error
+	AbandonTasks(ctx context.Context, ids ...string) error
 
 	GetStaleTasks(ctx context.Context, limit int) ([]models.Task, error)
 	GetRecentTasks(ctx context.Context, createdAfter time.Time, status ...models.TaskStatus) ([]models.Task, error)
diff --git a/internal/database/models/task.go b/internal/database/models/task.go
index 77adbaab..b19bee9c 100644
--- a/internal/database/models/task.go
+++ b/internal/database/models/task.go
@@ -89,15 +89,13 @@ func (t *Task) OnUpdated() {
 }
 
 type TaskLog struct {
-	Targets   []string  `json:"targets" bson:"targets"`
 	Timestamp time.Time `json:"timestamp" bson:"timestamp"`
 	Comment   string    `json:"result" bson:"result"`
-	Error     string    `json:"error" bson:"error"`
+	Error     error     `json:"error" bson:"error"`
 }
 
-func NewAttemptLog(task Task, comment, err string) TaskLog {
+func NewAttemptLog(task Task, comment string, err error) TaskLog {
 	return TaskLog{
-		Targets:   task.Targets,
 		Timestamp: time.Now(),
 		Comment:   comment,
 		Error:     err,
diff --git a/internal/database/tasks.go b/internal/database/tasks.go
index 19276620..34aca9f9 100644
--- a/internal/database/tasks.go
+++ b/internal/database/tasks.go
@@ -103,6 +103,42 @@ func (c *client) GetAndStartTasks(ctx context.Context, limit int) ([]models.Task
 	})
 }
 
+/*
+AbandonTasks retrieves tasks by ids and marks them as scheduled, adding a log noting it was abandoned
+*/
+func (c *client) AbandonTasks(ctx context.Context, ids ...string) error {
+	if len(ids) < 1 {
+		return nil
+	}
+
+	var tasks []models.Task
+	err := c.withTx(ctx, func(tx *db.Tx) error {
+		records, err := tx.CronTask.Query().Where(crontask.IDIn(ids...)).All(ctx)
+		if err != nil {
+			return err
+		}
+
+		now := time.Now()
+		for _, r := range records {
+			t := toCronTask(r)
+			t.OnUpdated()
+
+			t.Status = models.TaskStatusScheduled
+			t.LogAttempt(models.TaskLog{
+				Comment:   "task was abandoned",
+				Timestamp: now,
+			})
+			tasks = append(tasks, t)
+		}
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+
+	return c.UpdateTasks(ctx, tasks...)
+}
+
 func (c *client) CreateTasks(ctx context.Context, tasks ...models.Task) error {
 	if len(tasks) < 1 {
 		return nil
diff --git a/main.go b/main.go
index 2a28f4dc..eb40181f 100644
--- a/main.go
+++ b/main.go
@@ -1,22 +1,27 @@
 package main
 
 import (
+	"context"
 	"embed"
+	"fmt"
 	"io/fs"
+	"os/signal"
 	"path/filepath"
-	"runtime/debug"
+	"strconv"
+	"syscall"
 
 	"os"
-	"strconv"
 	"time"
 
 	"github.com/cufee/aftermath/cmds/core"
+	"github.com/cufee/aftermath/cmds/core/queue"
 	"github.com/cufee/aftermath/cmds/core/scheduler"
-	"github.com/cufee/aftermath/cmds/core/scheduler/tasks"
+
 	"github.com/cufee/aftermath/cmds/core/server"
 	"github.com/cufee/aftermath/cmds/core/server/handlers/private"
 	"github.com/cufee/aftermath/cmds/discord"
 	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/external/blitzstars"
 	"github.com/cufee/aftermath/internal/external/wargaming"
 	"github.com/cufee/aftermath/internal/localization"
@@ -37,6 +42,9 @@ import (
 var static embed.FS
 
 func main() {
+	globalCtx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
 	// Logger
 	level, _ := zerolog.ParseLevel(os.Getenv("LOG_LEVEL"))
 	zerolog.SetGlobalLevel(level)
@@ -44,7 +52,17 @@ func main() {
 	loadStaticAssets(static)
 
 	liveCoreClient, cacheCoreClient := coreClientsFromEnv()
-	startSchedulerFromEnvAsync(cacheCoreClient.Wargaming())
+	stopQueue, err := startQueueFromEnv(globalCtx, cacheCoreClient.Wargaming())
+	if err != nil {
+		log.Fatal().Err(err).Msg("startQueueFromEnv failed")
+	}
+	defer stopQueue()
+
+	stopScheduler, err := startSchedulerFromEnv(globalCtx, cacheCoreClient)
+	if err != nil {
+		log.Fatal().Err(err).Msg("startSchedulerFromEnv failed")
+	}
+	defer stopScheduler()
 
 	// Load some init options to registered admin accounts and etc
 	logic.ApplyInitOptions(liveCoreClient.Database())
@@ -80,40 +98,61 @@ func main() {
 		Func: discordHandler,
 	})
 	log.Info().Str("port", port).Msg("starting a public server")
-	servePublic()
+	go servePublic()
+
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, os.Interrupt, syscall.SIGTERM)
+
+	sig := <-c
+	cancel()
+	log.Info().Msgf("received %s, exiting", sig.String())
 }
 
-func startSchedulerFromEnvAsync(wgClient wargaming.Client) {
+func startSchedulerFromEnv(ctx context.Context, coreClient core.Client) (func(), error) {
 	if os.Getenv("SCHEDULER_ENABLED") != "true" {
-		return
+		return func() {}, nil
 	}
+	s := scheduler.New()
+	scheduler.RegisterDefaultTasks(s, coreClient)
+	return s.Start(ctx)
+}
 
+func startQueueFromEnv(ctx context.Context, wgClient wargaming.Client) (func(), error) {
 	bsClient, err := blitzstars.NewClient(os.Getenv("BLITZ_STARS_API_URL"), time.Second*10)
 	if err != nil {
 		log.Fatal().Msgf("failed to init a blitzstars client %s", err)
 	}
 
 	// Fetch client
-	client, err := fetch.NewMultiSourceClient(wgClient, bsClient, newDatabaseClientFromEnv())
+	fetchDBClient, err := newDatabaseClientFromEnv()
+	if err != nil {
+		log.Fatal().Err(err).Msg("failed to create a database client")
+	}
+	client, err := fetch.NewMultiSourceClient(wgClient, bsClient, fetchDBClient)
 	if err != nil {
 		log.Fatal().Msgf("fetch#NewMultiSourceClient failed %s", err)
 	}
-	coreClient := core.NewClient(client, wgClient, newDatabaseClientFromEnv())
 
-	// Queue
-	taskQueueConcurrency := 10
+	// Queue - pulls tasks from database and runs the logic
+	queueWorkerLimit := 10
 	if v, err := strconv.Atoi(os.Getenv("SCHEDULER_CONCURRENT_WORKERS")); err == nil {
-		taskQueueConcurrency = v
+		queueWorkerLimit = v
 	}
-	queue := scheduler.NewQueue(coreClient, tasks.DefaultHandlers(), taskQueueConcurrency)
-
-	defer func() {
-		if r := recover(); r != nil {
-			log.Error().Str("stack", string(debug.Stack())).Interface("error", r).Stack().Msg("scheduler panic")
+	q := queue.New(queueWorkerLimit, func() (core.Client, error) {
+		// make a new database client and re-use the core client deps from before
+		dbClient, err := newDatabaseClientFromEnv()
+		if err != nil {
+			return nil, err
 		}
+		return core.NewClient(client, wgClient, dbClient), nil
+	})
+
+	go func() {
+		time.Sleep(time.Second * 5)
+		q.Enqueue(models.Task{})
 	}()
 
-	queue.StartCronJobsAsync()
+	return q.Start(ctx)
 }
 
 func coreClientsFromEnv() (core.Client, core.Client) {
@@ -125,12 +164,25 @@ func coreClientsFromEnv() (core.Client, core.Client) {
 	liveClient, cacheClient := wargamingClientsFromEnv()
 
 	// Fetch client
-	fetchClient, err := fetch.NewMultiSourceClient(cacheClient, bsClient, newDatabaseClientFromEnv())
+	liveDBClient, err := newDatabaseClientFromEnv()
+	if err != nil {
+		log.Fatal().Err(err).Msg("newDatabaseClientFromEnv failed")
+	}
+	liveFetchClient, err := fetch.NewMultiSourceClient(liveClient, bsClient, liveDBClient)
 	if err != nil {
 		log.Fatal().Msgf("fetch#NewMultiSourceClient failed %s", err)
 	}
 
-	return core.NewClient(fetchClient, liveClient, newDatabaseClientFromEnv()), core.NewClient(fetchClient, cacheClient, newDatabaseClientFromEnv())
+	cacheDBClient, err := newDatabaseClientFromEnv()
+	if err != nil {
+		log.Fatal().Err(err).Msg("newDatabaseClientFromEnv failed")
+	}
+	cacheFetchClient, err := fetch.NewMultiSourceClient(cacheClient, bsClient, cacheDBClient)
+	if err != nil {
+		log.Fatal().Msgf("fetch#NewMultiSourceClient failed %s", err)
+	}
+
+	return core.NewClient(liveFetchClient, liveClient, liveDBClient), core.NewClient(cacheFetchClient, cacheClient, cacheDBClient)
 }
 
 func loadStaticAssets(static fs.FS) {
@@ -164,16 +216,17 @@ func wargamingClientsFromEnv() (wargaming.Client, wargaming.Client) {
 	return liveClient, cacheClient
 }
 
-func newDatabaseClientFromEnv() database.Client {
+func newDatabaseClientFromEnv() (database.Client, error) {
 	err := os.MkdirAll(os.Getenv("DATABASE_PATH"), os.ModePerm)
 	if err != nil {
-		log.Fatal().Msgf("os#MkdirAll failed %s", err)
+		return nil, fmt.Errorf("os#MkdirAll failed %w", err)
 	}
 
 	client, err := database.NewSQLiteClient(filepath.Join(os.Getenv("DATABASE_PATH"), os.Getenv("DATABASE_NAME")))
 	if err != nil {
-		log.Fatal().Msgf("database#NewClient failed %s", err)
+
+		return nil, fmt.Errorf("database#NewClient failed %w", err)
 	}
 
-	return client
+	return client, nil
 }

From d2ddd2164100f349ba33ea8d07283305822bcc4b Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Mon, 24 Jun 2024 14:27:46 -0400
Subject: [PATCH 166/341] changes error type, added timeout

---
 cmds/core/queue/queue.go         | 25 ++++++++++++++++++-------
 internal/database/models/task.go |  4 ++--
 main.go                          |  7 +------
 3 files changed, 21 insertions(+), 15 deletions(-)

diff --git a/cmds/core/queue/queue.go b/cmds/core/queue/queue.go
index a07ca7a8..33f5b6ad 100644
--- a/cmds/core/queue/queue.go
+++ b/cmds/core/queue/queue.go
@@ -36,6 +36,7 @@ func New(workerLimit int, newCoreClient func() (core.Client, error)) *queue {
 		handlers:      make(map[models.TaskType]tasks.TaskHandler),
 
 		workerLimit:   workerLimit,
+		workerTimeout: time.Second * 15,
 		workerLimiter: make(chan struct{}, workerLimit),
 
 		activeTasksMx: &sync.Mutex{},
@@ -180,23 +181,33 @@ func (q *queue) startWorkers(ctx context.Context, onComplete func(id string)) {
 				wctx, cancel := context.WithTimeout(ctx, q.workerTimeout)
 				defer cancel()
 
-				handler, ok := q.handlers[task.Type]
-				if !ok {
-					log.Error().Str("type", string(task.Type)).Msg("task missing a handler")
-					return
-				}
-
 				coreClient, err := q.newCoreClient()
 				if err != nil {
 					log.Err(err).Msg("failed to create a new core client for a task worker")
 					return
 				}
+
+				handler, ok := q.handlers[task.Type]
+				if !ok {
+					task.Status = models.TaskStatusFailed
+					task.LogAttempt(models.TaskLog{
+						Error:     "task missing a handler",
+						Comment:   "task missing a handler",
+						Timestamp: time.Now(),
+					})
+					err := coreClient.Database().UpdateTasks(wctx, task)
+					if err != nil {
+						log.Err(err).Msg("failed to update a task")
+					}
+					return
+				}
+
 				msg, err := handler.Process(coreClient, task)
 				task.Status = models.TaskStatusComplete
 				task.LogAttempt(models.TaskLog{
+					Error:     err.Error(),
 					Timestamp: time.Now(),
 					Comment:   msg,
-					Error:     err,
 				})
 
 				if err != nil {
diff --git a/internal/database/models/task.go b/internal/database/models/task.go
index b19bee9c..d2d569bb 100644
--- a/internal/database/models/task.go
+++ b/internal/database/models/task.go
@@ -91,13 +91,13 @@ func (t *Task) OnUpdated() {
 type TaskLog struct {
 	Timestamp time.Time `json:"timestamp" bson:"timestamp"`
 	Comment   string    `json:"result" bson:"result"`
-	Error     error     `json:"error" bson:"error"`
+	Error     string    `json:"error" bson:"error"`
 }
 
 func NewAttemptLog(task Task, comment string, err error) TaskLog {
 	return TaskLog{
 		Timestamp: time.Now(),
 		Comment:   comment,
-		Error:     err,
+		Error:     err.Error(),
 	}
 }
diff --git a/main.go b/main.go
index eb40181f..7f1d65b4 100644
--- a/main.go
+++ b/main.go
@@ -21,7 +21,6 @@ import (
 	"github.com/cufee/aftermath/cmds/core/server/handlers/private"
 	"github.com/cufee/aftermath/cmds/discord"
 	"github.com/cufee/aftermath/internal/database"
-	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/external/blitzstars"
 	"github.com/cufee/aftermath/internal/external/wargaming"
 	"github.com/cufee/aftermath/internal/localization"
@@ -146,11 +145,7 @@ func startQueueFromEnv(ctx context.Context, wgClient wargaming.Client) (func(),
 		}
 		return core.NewClient(client, wgClient, dbClient), nil
 	})
-
-	go func() {
-		time.Sleep(time.Second * 5)
-		q.Enqueue(models.Task{})
-	}()
+	// q.SetHandlers(tasks.DefaultHandlers())
 
 	return q.Start(ctx)
 }

From 830d90900c4238b98d6dbefc1b3609b05d92eb15 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Mon, 24 Jun 2024 14:31:23 -0400
Subject: [PATCH 167/341] added debug logs

---
 cmds/core/queue/queue.go | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/cmds/core/queue/queue.go b/cmds/core/queue/queue.go
index 33f5b6ad..ab697a23 100644
--- a/cmds/core/queue/queue.go
+++ b/cmds/core/queue/queue.go
@@ -123,10 +123,13 @@ func (q *queue) pullAndEnqueueTasks(ctx context.Context, db database.Client) err
 	}
 	defer q.queueLock.Unlock()
 
+	log.Debug().Msg("pulling available tasks into queue")
+
 	tasks, err := db.GetAndStartTasks(ctx, q.workerLimit)
 	if err != nil && !database.IsNotFound(err) {
 		return err
 	}
+	log.Debug().Msgf("pulled %d tasks into queue", len(tasks))
 
 	go func(tasks []models.Task) {
 		for _, t := range tasks {
@@ -156,6 +159,9 @@ func (q *queue) startWorkers(ctx context.Context, onComplete func(id string)) {
 					}
 				}()
 
+				log.Debug().Str("taskId", task.ID).Msg("worker started processing a task")
+				defer log.Debug().Str("taskId", task.ID).Msg("worker finished processing a task")
+
 				defer func() {
 					if r := recover(); r != nil {
 						event := log.Error().Str("stack", string(debug.Stack())).Str("taskId", task.ID)

From f8cf13bb723b29631609a83c9faa12f113647b13 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Mon, 24 Jun 2024 14:32:12 -0400
Subject: [PATCH 168/341] added task handlers

---
 main.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/main.go b/main.go
index 7f1d65b4..073f7caa 100644
--- a/main.go
+++ b/main.go
@@ -16,6 +16,7 @@ import (
 	"github.com/cufee/aftermath/cmds/core"
 	"github.com/cufee/aftermath/cmds/core/queue"
 	"github.com/cufee/aftermath/cmds/core/scheduler"
+	"github.com/cufee/aftermath/cmds/core/tasks"
 
 	"github.com/cufee/aftermath/cmds/core/server"
 	"github.com/cufee/aftermath/cmds/core/server/handlers/private"
@@ -145,7 +146,7 @@ func startQueueFromEnv(ctx context.Context, wgClient wargaming.Client) (func(),
 		}
 		return core.NewClient(client, wgClient, dbClient), nil
 	})
-	// q.SetHandlers(tasks.DefaultHandlers())
+	q.SetHandlers(tasks.DefaultHandlers())
 
 	return q.Start(ctx)
 }

From 0b0fe63a55e92871d1e744e9769e57d8ecd7757a Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Mon, 24 Jun 2024 15:00:42 -0400
Subject: [PATCH 169/341] added application level locks

---
 internal/database/client.go | 21 +++++++++++++++------
 internal/database/users.go  | 12 ++++++++++++
 2 files changed, 27 insertions(+), 6 deletions(-)

diff --git a/internal/database/client.go b/internal/database/client.go
index ee81bfb2..458a86f5 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"runtime/debug"
+	"sync"
 	"time"
 
 	"github.com/cufee/aftermath/internal/database/ent/db"
@@ -88,30 +89,37 @@ type Client interface {
 }
 
 type client struct {
-	db *db.Client
+	db        *db.Client
+	writeLock *sync.Mutex
 }
 
 func (c *client) withTx(ctx context.Context, fn func(tx *db.Tx) error) error {
+	c.writeLock.Lock()
+	defer c.writeLock.Unlock()
+
+	var err error
 	tx, err := c.db.Tx(ctx)
 	if err != nil {
 		return err
 	}
+
 	defer func() {
 		if v := recover(); v != nil {
 			tx.Rollback()
-			panic(v)
+			err = fmt.Errorf("%v", v)
 		}
 	}()
-	if err := fn(tx); err != nil {
+
+	if err = fn(tx); err != nil {
 		if rerr := tx.Rollback(); rerr != nil {
 			err = fmt.Errorf("%w: rolling back transaction: %v", err, rerr)
 		}
 		return err
 	}
-	if err := tx.Commit(); err != nil {
+	if err = tx.Commit(); err != nil {
 		return fmt.Errorf("committing transaction: %w", err)
 	}
-	return nil
+	return err
 }
 
 func (c *client) Disconnect() error {
@@ -138,6 +146,7 @@ func NewSQLiteClient(filePath string) (*client, error) {
 	}
 
 	return &client{
-		db: c,
+		writeLock: &sync.Mutex{},
+		db:        c,
 	}, nil
 }
diff --git a/internal/database/users.go b/internal/database/users.go
index e044b34e..19c25e07 100644
--- a/internal/database/users.go
+++ b/internal/database/users.go
@@ -95,6 +95,9 @@ func (c *client) GetOrCreateUserByID(ctx context.Context, id string, opts ...use
 	}
 
 	if IsNotFound(err) {
+		c.writeLock.Lock()
+		defer c.writeLock.Unlock()
+
 		record, err := c.db.User.Create().SetID(id).SetPermissions(permissions.User.String()).Save(ctx)
 		if err != nil {
 			return models.User{}, err
@@ -135,6 +138,9 @@ func (c *client) GetUserByID(ctx context.Context, id string, opts ...userGetOpti
 }
 
 func (c *client) UpsertUserWithPermissions(ctx context.Context, userID string, perms permissions.Permissions) (models.User, error) {
+	c.writeLock.Lock()
+	defer c.writeLock.Unlock()
+
 	record, err := c.db.User.UpdateOneID(userID).SetPermissions(perms.String()).Save(ctx)
 	if err != nil && !IsNotFound(err) {
 		return models.User{}, err
@@ -151,6 +157,9 @@ func (c *client) UpsertUserWithPermissions(ctx context.Context, userID string, p
 }
 
 func (c *client) CreateConnection(ctx context.Context, connection models.UserConnection) (models.UserConnection, error) {
+	c.writeLock.Lock()
+	defer c.writeLock.Unlock()
+
 	record, err := c.db.UserConnection.Create().
 		SetUser(c.db.User.GetX(ctx, connection.UserID)).
 		SetPermissions(connection.Permissions.String()).
@@ -165,6 +174,9 @@ func (c *client) CreateConnection(ctx context.Context, connection models.UserCon
 }
 
 func (c *client) UpdateConnection(ctx context.Context, connection models.UserConnection) (models.UserConnection, error) {
+	c.writeLock.Lock()
+	defer c.writeLock.Unlock()
+
 	record, err := c.db.UserConnection.UpdateOneID(connection.ID).
 		SetMetadata(connection.Metadata).
 		SetPermissions(connection.Permissions.String()).

From 7580d592a2f6378b168b0108d4d44c99a3e7b811 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Mon, 24 Jun 2024 15:08:18 -0400
Subject: [PATCH 170/341] moved back to a single client

---
 main.go | 43 ++++++++++++++++---------------------------
 1 file changed, 16 insertions(+), 27 deletions(-)

diff --git a/main.go b/main.go
index 073f7caa..9fa06838 100644
--- a/main.go
+++ b/main.go
@@ -50,9 +50,13 @@ func main() {
 	zerolog.SetGlobalLevel(level)
 
 	loadStaticAssets(static)
+	db, err := newDatabaseClientFromEnv()
+	if err != nil {
+		log.Fatal().Err(err).Msg("newDatabaseClientFromEnv failed")
+	}
 
-	liveCoreClient, cacheCoreClient := coreClientsFromEnv()
-	stopQueue, err := startQueueFromEnv(globalCtx, cacheCoreClient.Wargaming())
+	liveCoreClient, cacheCoreClient := coreClientsFromEnv(db)
+	stopQueue, err := startQueueFromEnv(globalCtx, db, cacheCoreClient.Wargaming())
 	if err != nil {
 		log.Fatal().Err(err).Msg("startQueueFromEnv failed")
 	}
@@ -117,18 +121,14 @@ func startSchedulerFromEnv(ctx context.Context, coreClient core.Client) (func(),
 	return s.Start(ctx)
 }
 
-func startQueueFromEnv(ctx context.Context, wgClient wargaming.Client) (func(), error) {
+func startQueueFromEnv(ctx context.Context, db database.Client, wgClient wargaming.Client) (func(), error) {
 	bsClient, err := blitzstars.NewClient(os.Getenv("BLITZ_STARS_API_URL"), time.Second*10)
 	if err != nil {
 		log.Fatal().Msgf("failed to init a blitzstars client %s", err)
 	}
 
 	// Fetch client
-	fetchDBClient, err := newDatabaseClientFromEnv()
-	if err != nil {
-		log.Fatal().Err(err).Msg("failed to create a database client")
-	}
-	client, err := fetch.NewMultiSourceClient(wgClient, bsClient, fetchDBClient)
+	client, err := fetch.NewMultiSourceClient(wgClient, bsClient, db)
 	if err != nil {
 		log.Fatal().Msgf("fetch#NewMultiSourceClient failed %s", err)
 	}
@@ -138,20 +138,17 @@ func startQueueFromEnv(ctx context.Context, wgClient wargaming.Client) (func(),
 	if v, err := strconv.Atoi(os.Getenv("SCHEDULER_CONCURRENT_WORKERS")); err == nil {
 		queueWorkerLimit = v
 	}
+
+	coreClient := core.NewClient(client, wgClient, db)
 	q := queue.New(queueWorkerLimit, func() (core.Client, error) {
-		// make a new database client and re-use the core client deps from before
-		dbClient, err := newDatabaseClientFromEnv()
-		if err != nil {
-			return nil, err
-		}
-		return core.NewClient(client, wgClient, dbClient), nil
+		return coreClient, nil
 	})
-	q.SetHandlers(tasks.DefaultHandlers())
 
+	q.SetHandlers(tasks.DefaultHandlers())
 	return q.Start(ctx)
 }
 
-func coreClientsFromEnv() (core.Client, core.Client) {
+func coreClientsFromEnv(db database.Client) (core.Client, core.Client) {
 	bsClient, err := blitzstars.NewClient(os.Getenv("BLITZ_STARS_API_URL"), time.Second*10)
 	if err != nil {
 		log.Fatal().Msgf("failed to init a blitzstars client %s", err)
@@ -160,25 +157,17 @@ func coreClientsFromEnv() (core.Client, core.Client) {
 	liveClient, cacheClient := wargamingClientsFromEnv()
 
 	// Fetch client
-	liveDBClient, err := newDatabaseClientFromEnv()
-	if err != nil {
-		log.Fatal().Err(err).Msg("newDatabaseClientFromEnv failed")
-	}
-	liveFetchClient, err := fetch.NewMultiSourceClient(liveClient, bsClient, liveDBClient)
+	liveFetchClient, err := fetch.NewMultiSourceClient(liveClient, bsClient, db)
 	if err != nil {
 		log.Fatal().Msgf("fetch#NewMultiSourceClient failed %s", err)
 	}
 
-	cacheDBClient, err := newDatabaseClientFromEnv()
-	if err != nil {
-		log.Fatal().Err(err).Msg("newDatabaseClientFromEnv failed")
-	}
-	cacheFetchClient, err := fetch.NewMultiSourceClient(cacheClient, bsClient, cacheDBClient)
+	cacheFetchClient, err := fetch.NewMultiSourceClient(cacheClient, bsClient, db)
 	if err != nil {
 		log.Fatal().Msgf("fetch#NewMultiSourceClient failed %s", err)
 	}
 
-	return core.NewClient(liveFetchClient, liveClient, liveDBClient), core.NewClient(cacheFetchClient, cacheClient, cacheDBClient)
+	return core.NewClient(liveFetchClient, liveClient, db), core.NewClient(cacheFetchClient, cacheClient, db)
 }
 
 func loadStaticAssets(static fs.FS) {

From 11256bbf1cab299c41354e1ea1db42d2722ea17f Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Mon, 24 Jun 2024 15:28:19 -0400
Subject: [PATCH 171/341] removed recover

---
 cmds/core/queue/queue.go | 43 ++++++++++++++++++++--------------------
 1 file changed, 21 insertions(+), 22 deletions(-)

diff --git a/cmds/core/queue/queue.go b/cmds/core/queue/queue.go
index ab697a23..e5a10523 100644
--- a/cmds/core/queue/queue.go
+++ b/cmds/core/queue/queue.go
@@ -3,7 +3,6 @@ package queue
 import (
 	"context"
 	"fmt"
-	"runtime/debug"
 	"sync"
 	"time"
 
@@ -162,27 +161,27 @@ func (q *queue) startWorkers(ctx context.Context, onComplete func(id string)) {
 				log.Debug().Str("taskId", task.ID).Msg("worker started processing a task")
 				defer log.Debug().Str("taskId", task.ID).Msg("worker finished processing a task")
 
-				defer func() {
-					if r := recover(); r != nil {
-						event := log.Error().Str("stack", string(debug.Stack())).Str("taskId", task.ID)
-						defer event.Msg("panic in queue worker")
-
-						coreClient, err := q.newCoreClient()
-						if err != nil {
-							event.AnErr("core", err).Str("additional", "failed to create a core client")
-							return
-						}
-						task.Status = models.TaskStatusFailed
-						task.LogAttempt(models.TaskLog{
-							Timestamp: time.Now(),
-							Comment:   "task caused a panic in worker handler",
-						})
-						err = coreClient.Database().UpdateTasks(context.Background(), task)
-						if err != nil {
-							event.AnErr("updateTasks", err).Str("additional", "failed to update a task")
-						}
-					}
-				}()
+				// defer func() {
+				// 	if r := recover(); r != nil {
+				// 		event := log.Error().Str("stack", string(debug.Stack())).Str("taskId", task.ID)
+				// 		defer event.Msg("panic in queue worker")
+
+				// 		coreClient, err := q.newCoreClient()
+				// 		if err != nil {
+				// 			event.AnErr("core", err).Str("additional", "failed to create a core client")
+				// 			return
+				// 		}
+				// 		task.Status = models.TaskStatusFailed
+				// 		task.LogAttempt(models.TaskLog{
+				// 			Timestamp: time.Now(),
+				// 			Comment:   "task caused a panic in worker handler",
+				// 		})
+				// 		err = coreClient.Database().UpdateTasks(context.Background(), task)
+				// 		if err != nil {
+				// 			event.AnErr("updateTasks", err).Str("additional", "failed to update a task")
+				// 		}
+				// 	}
+				// }()
 
 				wctx, cancel := context.WithTimeout(ctx, q.workerTimeout)
 				defer cancel()

From 548d50cb657d1e64e162d11ee2bf75b563680989 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Mon, 24 Jun 2024 15:33:34 -0400
Subject: [PATCH 172/341] fixed a panic

---
 cmds/core/queue/queue.go | 51 ++++++++++++++++++++--------------------
 1 file changed, 26 insertions(+), 25 deletions(-)

diff --git a/cmds/core/queue/queue.go b/cmds/core/queue/queue.go
index e5a10523..4982b19f 100644
--- a/cmds/core/queue/queue.go
+++ b/cmds/core/queue/queue.go
@@ -3,6 +3,7 @@ package queue
 import (
 	"context"
 	"fmt"
+	"runtime/debug"
 	"sync"
 	"time"
 
@@ -161,27 +162,27 @@ func (q *queue) startWorkers(ctx context.Context, onComplete func(id string)) {
 				log.Debug().Str("taskId", task.ID).Msg("worker started processing a task")
 				defer log.Debug().Str("taskId", task.ID).Msg("worker finished processing a task")
 
-				// defer func() {
-				// 	if r := recover(); r != nil {
-				// 		event := log.Error().Str("stack", string(debug.Stack())).Str("taskId", task.ID)
-				// 		defer event.Msg("panic in queue worker")
-
-				// 		coreClient, err := q.newCoreClient()
-				// 		if err != nil {
-				// 			event.AnErr("core", err).Str("additional", "failed to create a core client")
-				// 			return
-				// 		}
-				// 		task.Status = models.TaskStatusFailed
-				// 		task.LogAttempt(models.TaskLog{
-				// 			Timestamp: time.Now(),
-				// 			Comment:   "task caused a panic in worker handler",
-				// 		})
-				// 		err = coreClient.Database().UpdateTasks(context.Background(), task)
-				// 		if err != nil {
-				// 			event.AnErr("updateTasks", err).Str("additional", "failed to update a task")
-				// 		}
-				// 	}
-				// }()
+				defer func() {
+					if r := recover(); r != nil {
+						event := log.Error().Str("stack", string(debug.Stack())).Str("taskId", task.ID)
+						defer event.Msg("panic in queue worker")
+
+						coreClient, err := q.newCoreClient()
+						if err != nil {
+							event.AnErr("core", err).Str("additional", "failed to create a core client")
+							return
+						}
+						task.Status = models.TaskStatusFailed
+						task.LogAttempt(models.TaskLog{
+							Timestamp: time.Now(),
+							Comment:   "task caused a panic in worker handler",
+						})
+						err = coreClient.Database().UpdateTasks(context.Background(), task)
+						if err != nil {
+							event.AnErr("updateTasks", err).Str("additional", "failed to update a task")
+						}
+					}
+				}()
 
 				wctx, cancel := context.WithTimeout(ctx, q.workerTimeout)
 				defer cancel()
@@ -209,19 +210,19 @@ func (q *queue) startWorkers(ctx context.Context, onComplete func(id string)) {
 
 				msg, err := handler.Process(coreClient, task)
 				task.Status = models.TaskStatusComplete
-				task.LogAttempt(models.TaskLog{
-					Error:     err.Error(),
+				l := models.TaskLog{
 					Timestamp: time.Now(),
 					Comment:   msg,
-				})
-
+				}
 				if err != nil {
+					l.Error = err.Error()
 					if handler.ShouldRetry(&task) {
 						task.Status = models.TaskStatusScheduled
 					} else {
 						task.Status = models.TaskStatusFailed
 					}
 				}
+				task.LogAttempt(l)
 
 				err = coreClient.Database().UpdateTasks(wctx, task)
 				if err != nil {

From 6c0cefe2dbbcbe995933dcdd10451896a23164a4 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Mon, 24 Jun 2024 15:40:09 -0400
Subject: [PATCH 173/341] minor tweaks, sorting tasks

---
 cmds/core/queue/errors.go  | 5 +++++
 cmds/core/queue/queue.go   | 8 ++++----
 internal/database/tasks.go | 2 +-
 3 files changed, 10 insertions(+), 5 deletions(-)
 create mode 100644 cmds/core/queue/errors.go

diff --git a/cmds/core/queue/errors.go b/cmds/core/queue/errors.go
new file mode 100644
index 00000000..49a1e479
--- /dev/null
+++ b/cmds/core/queue/errors.go
@@ -0,0 +1,5 @@
+package queue
+
+import "github.com/pkg/errors"
+
+var ErrQueueLocked = errors.New("queue is locked")
diff --git a/cmds/core/queue/queue.go b/cmds/core/queue/queue.go
index 4982b19f..f96657a3 100644
--- a/cmds/core/queue/queue.go
+++ b/cmds/core/queue/queue.go
@@ -2,6 +2,7 @@ package queue
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"runtime/debug"
 	"sync"
@@ -12,7 +13,6 @@ import (
 	"github.com/cufee/aftermath/cmds/core/tasks"
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
-	"github.com/pkg/errors"
 	"github.com/rs/zerolog/log"
 )
 
@@ -72,7 +72,7 @@ func (q *queue) Start(ctx context.Context) (func(), error) {
 		pctx, cancel := context.WithTimeout(qctx, time.Second*5)
 		defer cancel()
 		err := q.pullAndEnqueueTasks(pctx, coreClint.Database())
-		if err != nil {
+		if err != nil && !errors.Is(ErrQueueLocked, err) {
 			log.Err(err).Msg("failed to pull tasks")
 		}
 	})
@@ -85,7 +85,7 @@ func (q *queue) Start(ctx context.Context) (func(), error) {
 	go q.startWorkers(qctx, func(_ string) {
 		if len(q.queued) < q.workerLimit {
 			err := q.pullAndEnqueueTasks(qctx, coreClint.Database())
-			if err != nil {
+			if err != nil && !errors.Is(ErrQueueLocked, err) {
 				log.Err(err).Msg("failed to pull tasks")
 			}
 		}
@@ -119,7 +119,7 @@ func (q *queue) Enqueue(task models.Task) {
 
 func (q *queue) pullAndEnqueueTasks(ctx context.Context, db database.Client) error {
 	if ok := q.queueLock.TryLock(); !ok {
-		return errors.New("queue is locked")
+		return ErrQueueLocked
 	}
 	defer q.queueLock.Unlock()
 
diff --git a/internal/database/tasks.go b/internal/database/tasks.go
index 34aca9f9..e6ca2bf2 100644
--- a/internal/database/tasks.go
+++ b/internal/database/tasks.go
@@ -61,7 +61,7 @@ func (c *client) GetRecentTasks(ctx context.Context, createdAfter time.Time, sta
 		where = append(where, crontask.StatusIn(status...))
 	}
 
-	records, err := c.db.CronTask.Query().Where(where...).All(ctx)
+	records, err := c.db.CronTask.Query().Where(where...).Order(crontask.ByLastRun(sql.OrderDesc())).All(ctx)
 	if err != nil {
 		return nil, err
 	}

From de5abeb1513cc051627b25413375011141a6986b Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Mon, 24 Jun 2024 15:46:19 -0400
Subject: [PATCH 174/341] upgrade, fixed a test

---
 go.mod                                | 21 ++++------
 go.sum                                | 60 +++++++++------------------
 internal/database/ent/migrate/main.go |  1 -
 render_test.go                        |  6 ++-
 4 files changed, 34 insertions(+), 54 deletions(-)

diff --git a/go.mod b/go.mod
index bf5fd037..c2c64c4a 100644
--- a/go.mod
+++ b/go.mod
@@ -3,10 +3,10 @@ module github.com/cufee/aftermath
 go 1.22.3
 
 require (
-	ariga.io/atlas v0.19.1-0.20240203083654-5948b60a8e43
+	ariga.io/atlas v0.24.0
 	entgo.io/ent v0.13.1
 	github.com/bwmarrin/discordgo v0.28.1
-	github.com/cufee/am-wg-proxy-next/v2 v2.1.3
+	github.com/cufee/am-wg-proxy-next/v2 v2.1.5
 	github.com/disintegration/imaging v1.6.2
 	github.com/fogleman/gg v1.3.0
 	github.com/go-co-op/gocron v1.37.0
@@ -18,7 +18,6 @@ require (
 	github.com/pkg/errors v0.9.1
 	github.com/rs/zerolog v1.33.0
 	github.com/stretchr/testify v1.9.0
-	github.com/tursodatabase/libsql-client-go v0.0.0-20240416075003-747366ff79c4
 	go.dedis.ch/protobuf v1.0.11
 	golang.org/x/exp v0.0.0-20240613232115-7f521ea00fb8
 	golang.org/x/image v0.17.0
@@ -28,25 +27,23 @@ require (
 )
 
 require (
-	github.com/agext/levenshtein v1.2.1 // indirect
-	github.com/antlr4-go/antlr/v4 v4.13.0 // indirect
-	github.com/apparentlymart/go-textseg/v13 v13.0.0 // indirect
+	github.com/agext/levenshtein v1.2.3 // indirect
+	github.com/apparentlymart/go-textseg/v15 v15.0.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/go-openapi/inflect v0.19.0 // indirect
+	github.com/go-openapi/inflect v0.21.0 // indirect
 	github.com/google/go-cmp v0.6.0 // indirect
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/gorilla/websocket v1.5.3 // indirect
-	github.com/hashicorp/hcl/v2 v2.13.0 // indirect
-	github.com/libsql/sqlite-antlr4-parser v0.0.0-20240327125255-dbf53b6cbf06 // indirect
+	github.com/hashicorp/hcl/v2 v2.21.0 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
-	github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7 // indirect
+	github.com/mitchellh/go-wordwrap v1.0.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/robfig/cron/v3 v3.0.1 // indirect
-	github.com/zclconf/go-cty v1.8.0 // indirect
+	github.com/zclconf/go-cty v1.14.4 // indirect
 	go.uber.org/atomic v1.11.0 // indirect
 	golang.org/x/crypto v0.24.0 // indirect
 	golang.org/x/mod v0.18.0 // indirect
 	golang.org/x/sys v0.21.0 // indirect
-	nhooyr.io/websocket v1.8.10 // indirect
+	golang.org/x/tools v0.22.0 // indirect
 )
diff --git a/go.sum b/go.sum
index 24ee26f5..b4bd05ca 100644
--- a/go.sum
+++ b/go.sum
@@ -1,21 +1,19 @@
-ariga.io/atlas v0.19.1-0.20240203083654-5948b60a8e43 h1:GwdJbXydHCYPedeeLt4x/lrlIISQ4JTH1mRWuE5ZZ14=
-ariga.io/atlas v0.19.1-0.20240203083654-5948b60a8e43/go.mod h1:uj3pm+hUTVN/X5yfdBexHlZv+1Xu5u5ZbZx7+CDavNU=
+ariga.io/atlas v0.24.0 h1:ssK25BIfVbVIYt+STIfqgrlEpfJrLtKtdWU2/U23YP4=
+ariga.io/atlas v0.24.0/go.mod h1:uSfJty48trd+YIWkRp7OENP5Wjgy6KzVW6JHv6tko2o=
 entgo.io/ent v0.13.1 h1:uD8QwN1h6SNphdCCzmkMN3feSUzNnVvV/WIkHKMbzOE=
 entgo.io/ent v0.13.1/go.mod h1:qCEmo+biw3ccBn9OyL4ZK5dfpwg++l1Gxwac5B1206A=
 github.com/DATA-DOG/go-sqlmock v1.5.0 h1:Shsta01QNfFxHCfpW6YH2STWB0MudeXXEWMr20OEh60=
 github.com/DATA-DOG/go-sqlmock v1.5.0/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM=
-github.com/agext/levenshtein v1.2.1 h1:QmvMAjj2aEICytGiWzmxoE0x2KZvE0fvmqMOfy2tjT8=
-github.com/agext/levenshtein v1.2.1/go.mod h1:JEDfjyjHDjOF/1e4FlBE/PkbqA9OfWu2ki2W0IB5558=
-github.com/antlr4-go/antlr/v4 v4.13.0 h1:lxCg3LAv+EUK6t1i0y1V6/SLeUi0eKEKdhQAlS8TVTI=
-github.com/antlr4-go/antlr/v4 v4.13.0/go.mod h1:pfChB/xh/Unjila75QW7+VU4TSnWnnk9UTnmpPaOR2g=
-github.com/apparentlymart/go-textseg/v13 v13.0.0 h1:Y+KvPE1NYz0xl601PVImeQfFyEy6iT90AvPUL1NNfNw=
-github.com/apparentlymart/go-textseg/v13 v13.0.0/go.mod h1:ZK2fH7c4NqDTLtiYLvIkEghdlcqw7yxLeM89kiTRPUo=
+github.com/agext/levenshtein v1.2.3 h1:YB2fHEn0UJagG8T1rrWknE3ZQzWM06O8AMAatNn7lmo=
+github.com/agext/levenshtein v1.2.3/go.mod h1:JEDfjyjHDjOF/1e4FlBE/PkbqA9OfWu2ki2W0IB5558=
+github.com/apparentlymart/go-textseg/v15 v15.0.0 h1:uYvfpb3DyLSCGWnctWKGj857c6ew1u1fNQOlOtuGxQY=
+github.com/apparentlymart/go-textseg/v15 v15.0.0/go.mod h1:K8XmNZdhEBkdlyDdvbmmsvpAG721bKi0joRfFdHIWJ4=
 github.com/bwmarrin/discordgo v0.28.1 h1:gXsuo2GBO7NbR6uqmrrBDplPUx2T3nzu775q/Rd1aG4=
 github.com/bwmarrin/discordgo v0.28.1/go.mod h1:NJZpH+1AfhIcyQsPeuBKsUtYrRnjkyu0kIVMCHkZtRY=
 github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
-github.com/cufee/am-wg-proxy-next/v2 v2.1.3 h1:qTzzgEapbI/z81R3nXoiiITfBZeHQ1cnebzSNgaoZlQ=
-github.com/cufee/am-wg-proxy-next/v2 v2.1.3/go.mod h1:+VxiIdbrdhHdRThASbVmZ5Fz4H6XPCzL3S2Ix6TO/84=
+github.com/cufee/am-wg-proxy-next/v2 v2.1.5 h1:F16XkZ8l+vZcRtgSYfxIphldsGBAc4+kWcIly3F3x+U=
+github.com/cufee/am-wg-proxy-next/v2 v2.1.5/go.mod h1:+VxiIdbrdhHdRThASbVmZ5Fz4H6XPCzL3S2Ix6TO/84=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -25,16 +23,13 @@ github.com/fogleman/gg v1.3.0 h1:/7zJX8F6AaYQc57WQCyN9cAIz+4bCJGO9B+dyW29am8=
 github.com/fogleman/gg v1.3.0/go.mod h1:R/bRT+9gY/C5z7JzPU0zXsXHKM4/ayA+zqcVNZzPa1k=
 github.com/go-co-op/gocron v1.37.0 h1:ZYDJGtQ4OMhTLKOKMIch+/CY70Brbb1dGdooLEhh7b0=
 github.com/go-co-op/gocron v1.37.0/go.mod h1:3L/n6BkO7ABj+TrfSVXLRzsP26zmikL4ISkLQ0O8iNY=
-github.com/go-openapi/inflect v0.19.0 h1:9jCH9scKIbHeV9m12SmPilScz6krDxKRasNNSNPXu/4=
-github.com/go-openapi/inflect v0.19.0/go.mod h1:lHpZVlpIQqLyKwJ4N+YSc9hchQy/i12fJykb83CRBH4=
+github.com/go-openapi/inflect v0.21.0 h1:FoBjBTQEcbg2cJUWX6uwL9OyIW8eqc9k4KhN4lfbeYk=
+github.com/go-openapi/inflect v0.21.0/go.mod h1:INezMuUu7SJQc2AyR3WO0DqqYUJSj8Kb4hBd7WtjlAw=
 github.com/go-test/deep v1.0.3 h1:ZrJSEWsXzPOxaZnFteGEfooLba+ju3FYIbOrS+rQd68=
 github.com/go-test/deep v1.0.3/go.mod h1:wGDj63lr65AM2AQyKZd/NYHGb0R+1RLqB8NKt3aSFNA=
 github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
 github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 h1:DACJavvAHhabrF08vX0COfcOBJRhZ8lUbR+ZWIs0Y5g=
 github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k=
-github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
-github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/google/uuid v1.4.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
@@ -43,8 +38,8 @@ github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+
 github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
 github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
-github.com/hashicorp/hcl/v2 v2.13.0 h1:0Apadu1w6M11dyGFxWnmhhcMjkbAiKCv7G1r/2QgCNc=
-github.com/hashicorp/hcl/v2 v2.13.0/go.mod h1:e4z5nxYlWNPdDSNYX+ph14EvWYMFm3eP0zIUqPc2jr0=
+github.com/hashicorp/hcl/v2 v2.21.0 h1:lve4q/o/2rqwYOgUg3y3V2YPyD1/zkCLGjIV74Jit14=
+github.com/hashicorp/hcl/v2 v2.21.0/go.mod h1:62ZYHrXgPoX8xBnzl8QzbWq4dyDsDtfCRgIq1rbJEvA=
 github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
 github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
@@ -55,10 +50,6 @@ github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
-github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
-github.com/libsql/sqlite-antlr4-parser v0.0.0-20240327125255-dbf53b6cbf06 h1:JLvn7D+wXjH9g4Jsjo+VqmzTUpl/LX7vfr6VOfSWTdM=
-github.com/libsql/sqlite-antlr4-parser v0.0.0-20240327125255-dbf53b6cbf06/go.mod h1:FUkZ5OHjlGPjnM2UyGJz9TypXQFgYqw6AFNO1UiROTM=
 github.com/lucsky/cuid v1.2.1 h1:MtJrL2OFhvYufUIn48d35QGXyeTC8tn0upumW9WwTHg=
 github.com/lucsky/cuid v1.2.1/go.mod h1:QaaJqckboimOmhRSJXSx/+IT+VTfxfPGSo/6mfgUfmE=
 github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
@@ -69,8 +60,8 @@ github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWE
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o4kU=
 github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
-github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7 h1:DpOJ2HYzCv8LZP15IdmG+YdwD2luVPHITV96TkirNBM=
-github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7/go.mod h1:ZXFpozHsX6DPmq2I0TCekCxypsnAUbP2oI0UX1GXzOo=
+github.com/mitchellh/go-wordwrap v1.0.1 h1:TLuKupo69TCn6TQSyGxwI1EblZZEsQ0vMlAFQflz0v0=
+github.com/mitchellh/go-wordwrap v1.0.1/go.mod h1:R62XHJLzvMFRBbcrT7m7WgmE1eOyTSsCt+hzestvNj0=
 github.com/nlpodyssey/gopickle v0.3.0 h1:BLUE5gxFLyyNOPzlXxt6GoHEMMxD0qhsE4p0CIQyoLw=
 github.com/nlpodyssey/gopickle v0.3.0/go.mod h1:f070HJ/yR+eLi5WmM1OXJEGaTpuJEUiib19olXgYha0=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
@@ -86,8 +77,6 @@ github.com/rogpeppe/go-internal v1.8.1/go.mod h1:JeRgkft04UBgHMgCIwADu4Pn6Mtm5d4
 github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
 github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8=
 github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
-github.com/sergi/go-diff v1.0.0 h1:Kpca3qRNrduNnOQeazBd0ysaKrUJiIuISHxogkT9RPQ=
-github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
@@ -97,12 +86,10 @@ github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO
 github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
 github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-github.com/tursodatabase/libsql-client-go v0.0.0-20240416075003-747366ff79c4 h1:wNN8t3qiLLzFiETD4jL086WemAgQLfARClUx2Jfk78w=
-github.com/tursodatabase/libsql-client-go v0.0.0-20240416075003-747366ff79c4/go.mod h1:2Fu26tjM011BLeR5+jwTfs6DX/fNMEWV/3CBZvggrA4=
-github.com/vmihailenco/msgpack/v4 v4.3.12/go.mod h1:gborTTJjAo/GWTqqRjrLCn9pgNN+NXzzngzBKDPIqw4=
-github.com/vmihailenco/tagparser v0.1.1/go.mod h1:OeAg3pn3UbLjkWt+rN9oFYB6u/cQgqMEUPoW2WPyhdI=
-github.com/zclconf/go-cty v1.8.0 h1:s4AvqaeQzJIu3ndv4gVIhplVD0krU+bgrcLSVUnaWuA=
-github.com/zclconf/go-cty v1.8.0/go.mod h1:vVKLxnk3puL4qRAv72AO+W99LUD4da90g3uUAzyuvAk=
+github.com/zclconf/go-cty v1.14.4 h1:uXXczd9QDGsgu0i/QFR/hzI5NYCHLf6NQw/atrbnhq8=
+github.com/zclconf/go-cty v1.14.4/go.mod h1:VvMs5i0vgZdhYawQNq5kePSpLAoz8u1xvZgrPIxfnZE=
+github.com/zclconf/go-cty-debug v0.0.0-20240509010212-0d6042c53940 h1:4r45xpDWB6ZMSMNJFMOjqrGHynW3DIBuR2H9j0ug+Mo=
+github.com/zclconf/go-cty-debug v0.0.0-20240509010212-0d6042c53940/go.mod h1:CmBdvvj3nqzfzJ6nTCIwDTPZ56aVGvDrmztiO5g3qrM=
 go.dedis.ch/fixbuf v1.0.3 h1:hGcV9Cd/znUxlusJ64eAlExS+5cJDIyTyEG+otu5wQs=
 go.dedis.ch/fixbuf v1.0.3/go.mod h1:yzJMt34Wa5xD37V5RTdmp38cz3QhMagdGoem9anUalw=
 go.dedis.ch/kyber/v3 v3.0.4/go.mod h1:OzvaEnPvKlyrWyp3kGXlFdp7ap1VC6RkZDTaPikqhsQ=
@@ -116,7 +103,6 @@ go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
 go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE=
 go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0=
 golang.org/x/crypto v0.0.0-20190123085648-057139ce5d2b/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
 golang.org/x/crypto v0.24.0 h1:mnl8DM0o513X8fdIkmyFE/5hTYxbwYOjDS/+rK6qpRI=
 golang.org/x/crypto v0.24.0/go.mod h1:Z1PMYSOR5nyMcyAVAIQSKCDwalqy85Aqn1x3Ws4L5DM=
@@ -127,13 +113,10 @@ golang.org/x/image v0.17.0 h1:nTRVVdajgB8zCMZVsViyzhnMKPwYeroEERRC64JuLco=
 golang.org/x/image v0.17.0/go.mod h1:4yyo5vMFQjVjUcVk4jEQcU9MGy/rulF5WvUILseCM2E=
 golang.org/x/mod v0.18.0 h1:5+9lSbEzPSdWkH32vYPBwEpX8KwDbM52Ud9xBUvNlb0=
 golang.org/x/mod v0.18.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
-golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
-golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
 golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20190124100055-b90733256f2e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@@ -142,13 +125,12 @@ golang.org/x/sys v0.21.0 h1:rF+pYz3DAGSQAxAu1CbC7catZg4ebC4UIeIhKxBZvws=
 golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
 golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
+golang.org/x/tools v0.22.0 h1:gqSGLZqv+AI9lIQzniJ0nZDRG5GBPsSi+DRNHWNz6yA=
+golang.org/x/tools v0.22.0/go.mod h1:aCwcsjqvq7Yqt6TNyX7QMU2enbQ/Gt0bo6krSeEri+c=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
@@ -157,5 +139,3 @@ gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-nhooyr.io/websocket v1.8.10 h1:mv4p+MnGrLDcPlBoWsvPP7XCzTYMXP9F9eIGoKbgx7Q=
-nhooyr.io/websocket v1.8.10/go.mod h1:rN9OFWIUwuxg4fR5tELlYC04bXYowCP9GX47ivo2l+c=
diff --git a/internal/database/ent/migrate/main.go b/internal/database/ent/migrate/main.go
index de8b8a3d..5932cafc 100644
--- a/internal/database/ent/migrate/main.go
+++ b/internal/database/ent/migrate/main.go
@@ -11,7 +11,6 @@ import (
 	"entgo.io/ent/dialect"
 	"entgo.io/ent/dialect/sql/schema"
 	"github.com/cufee/aftermath/internal/database/ent/db/migrate"
-	_ "github.com/tursodatabase/libsql-client-go/libsql"
 )
 
 func main() {
diff --git a/render_test.go b/render_test.go
index 016202cf..866144a3 100644
--- a/render_test.go
+++ b/render_test.go
@@ -22,7 +22,11 @@ func TestRenderSession(t *testing.T) {
 	zerolog.SetGlobalLevel(level)
 
 	loadStaticAssets(static)
-	coreClient, _ := coreClientsFromEnv()
+
+	db, err := newDatabaseClientFromEnv()
+	assert.NoError(t, err)
+
+	coreClient, _ := coreClientsFromEnv(db)
 	defer coreClient.Database().Disconnect()
 
 	bgImage, ok := assets.GetLoadedImage("bg-default")

From b139c61df3ea82444ba3b40ef58244a063810a3d Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Mon, 24 Jun 2024 15:54:02 -0400
Subject: [PATCH 175/341] removed logs that exposed tokens

---
 cmds/discord/rest/client.go | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/cmds/discord/rest/client.go b/cmds/discord/rest/client.go
index e5b829f8..74cdc95f 100644
--- a/cmds/discord/rest/client.go
+++ b/cmds/discord/rest/client.go
@@ -11,7 +11,6 @@ import (
 	"time"
 
 	"github.com/pkg/errors"
-	"github.com/rs/zerolog/log"
 
 	"github.com/bwmarrin/discordgo"
 )
@@ -110,8 +109,6 @@ func partHeader(contentDisposition string, contentType string) textproto.MIMEHea
 }
 
 func (c *Client) do(req *http.Request, target any) error {
-	log.Debug().Str("url", req.URL.String()).Str("contentType", req.Header.Get("Content-Type")).Msg("sending a request to Discord API")
-
 	res, err := c.http.Do(req)
 	if err != nil {
 		return err
@@ -140,8 +137,6 @@ func (c *Client) do(req *http.Request, target any) error {
 			return fmt.Errorf("failed to decode response body :%w", err)
 		}
 	}
-
-	log.Debug().Str("url", req.URL.String()).Str("contentType", req.Header.Get("Content-Type")).Msg("request finished successfully")
 	return nil
 }
 

From 25bbc0445bb91e9a65578180fdb95aa04c24f2d2 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Mon, 24 Jun 2024 16:02:57 -0400
Subject: [PATCH 176/341] more optimistic timeout

---
 cmds/core/queue/queue.go | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/cmds/core/queue/queue.go b/cmds/core/queue/queue.go
index f96657a3..4eab7c86 100644
--- a/cmds/core/queue/queue.go
+++ b/cmds/core/queue/queue.go
@@ -36,7 +36,7 @@ func New(workerLimit int, newCoreClient func() (core.Client, error)) *queue {
 		handlers:      make(map[models.TaskType]tasks.TaskHandler),
 
 		workerLimit:   workerLimit,
-		workerTimeout: time.Second * 15,
+		workerTimeout: time.Second * 30,
 		workerLimiter: make(chan struct{}, workerLimit),
 
 		activeTasksMx: &sync.Mutex{},
@@ -184,9 +184,6 @@ func (q *queue) startWorkers(ctx context.Context, onComplete func(id string)) {
 					}
 				}()
 
-				wctx, cancel := context.WithTimeout(ctx, q.workerTimeout)
-				defer cancel()
-
 				coreClient, err := q.newCoreClient()
 				if err != nil {
 					log.Err(err).Msg("failed to create a new core client for a task worker")
@@ -201,7 +198,7 @@ func (q *queue) startWorkers(ctx context.Context, onComplete func(id string)) {
 						Comment:   "task missing a handler",
 						Timestamp: time.Now(),
 					})
-					err := coreClient.Database().UpdateTasks(wctx, task)
+					err := coreClient.Database().UpdateTasks(ctx, task)
 					if err != nil {
 						log.Err(err).Msg("failed to update a task")
 					}
@@ -224,6 +221,9 @@ func (q *queue) startWorkers(ctx context.Context, onComplete func(id string)) {
 				}
 				task.LogAttempt(l)
 
+				wctx, cancel := context.WithTimeout(ctx, q.workerTimeout)
+				defer cancel()
+
 				err = coreClient.Database().UpdateTasks(wctx, task)
 				if err != nil {
 					log.Err(err).Msg("failed to update a task")

From a8c9fbe320e724dcaf8bfdd68f2ccbc19a06e1f2 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Mon, 24 Jun 2024 16:04:20 -0400
Subject: [PATCH 177/341] made context specifically before each call

---
 cmds/core/queue/queue.go | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/cmds/core/queue/queue.go b/cmds/core/queue/queue.go
index 4eab7c86..e2f13203 100644
--- a/cmds/core/queue/queue.go
+++ b/cmds/core/queue/queue.go
@@ -177,7 +177,11 @@ func (q *queue) startWorkers(ctx context.Context, onComplete func(id string)) {
 							Timestamp: time.Now(),
 							Comment:   "task caused a panic in worker handler",
 						})
-						err = coreClient.Database().UpdateTasks(context.Background(), task)
+
+						uctx, cancel := context.WithTimeout(ctx, q.workerTimeout)
+						defer cancel()
+
+						err = coreClient.Database().UpdateTasks(uctx, task)
 						if err != nil {
 							event.AnErr("updateTasks", err).Str("additional", "failed to update a task")
 						}
@@ -198,7 +202,11 @@ func (q *queue) startWorkers(ctx context.Context, onComplete func(id string)) {
 						Comment:   "task missing a handler",
 						Timestamp: time.Now(),
 					})
-					err := coreClient.Database().UpdateTasks(ctx, task)
+
+					uctx, cancel := context.WithTimeout(ctx, q.workerTimeout)
+					defer cancel()
+
+					err := coreClient.Database().UpdateTasks(uctx, task)
 					if err != nil {
 						log.Err(err).Msg("failed to update a task")
 					}

From ee7bc4694946f5e2c844fd3d1bf2e9d3c27702d8 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Wed, 26 Jun 2024 11:53:49 -0400
Subject: [PATCH 178/341] added timings

---
 cmds/discord/commands/session.go          | 10 ++++++--
 cmds/discord/commands/stats.go            | 10 ++++++--
 cmds/discord/common/context.go            |  5 ++--
 internal/stats/render/session/v1/cards.go | 30 ++++++++++++++++++++---
 4 files changed, 45 insertions(+), 10 deletions(-)

diff --git a/cmds/discord/commands/session.go b/cmds/discord/commands/session.go
index b81e0e78..86a6c644 100644
--- a/cmds/discord/commands/session.go
+++ b/cmds/discord/commands/session.go
@@ -63,7 +63,7 @@ func init() {
 					// TODO: Get user background
 				}
 
-				image, _, err := ctx.Core.Render(ctx.Locale).Session(context.Background(), accountID, options.PeriodStart, render.WithBackground(background))
+				image, meta, err := ctx.Core.Render(ctx.Locale).Session(context.Background(), accountID, options.PeriodStart, render.WithBackground(background))
 				if err != nil {
 					if errors.Is(err, stats.ErrAccountNotTracked) || (errors.Is(err, fetch.ErrSessionNotFound) && options.Days < 1) {
 						return ctx.Reply("session_error_account_was_not_tracked")
@@ -80,7 +80,13 @@ func init() {
 					return ctx.Err(err)
 				}
 
-				return ctx.File(&buf, "session_command_by_aftermath.png")
+				var timings = []string{"```"}
+				for name, duration := range meta.Timings {
+					timings = append(timings, fmt.Sprintf("%s: %v", name, duration.Milliseconds()))
+				}
+				timings = append(timings, "```")
+
+				return ctx.File(&buf, "session_command_by_aftermath.png", timings...)
 			}),
 	)
 }
diff --git a/cmds/discord/commands/stats.go b/cmds/discord/commands/stats.go
index 505c21ef..b7ee55c6 100644
--- a/cmds/discord/commands/stats.go
+++ b/cmds/discord/commands/stats.go
@@ -60,7 +60,7 @@ func init() {
 					// TODO: Get user background
 				}
 
-				image, _, err := ctx.Core.Render(ctx.Locale).Period(context.Background(), accountID, options.PeriodStart, render.WithBackground(background))
+				image, meta, err := ctx.Core.Render(ctx.Locale).Period(context.Background(), accountID, options.PeriodStart, render.WithBackground(background))
 				if err != nil {
 					return ctx.Err(err)
 				}
@@ -71,7 +71,13 @@ func init() {
 					return ctx.Err(err)
 				}
 
-				return ctx.File(&buf, "stats_command_by_aftermath.png")
+				var timings = []string{"```"}
+				for name, duration := range meta.Timings {
+					timings = append(timings, fmt.Sprintf("%s: %v", name, duration.Milliseconds()))
+				}
+				timings = append(timings, "```")
+
+				return ctx.File(&buf, "stats_command_by_aftermath.png", timings...)
 			}),
 	)
 }
diff --git a/cmds/discord/common/context.go b/cmds/discord/common/context.go
index 4fa0c75d..9a09bd6d 100644
--- a/cmds/discord/common/context.go
+++ b/cmds/discord/common/context.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"io"
+	"strings"
 
 	"github.com/pkg/errors"
 
@@ -112,11 +113,11 @@ func (c *Context) ReplyFmt(key string, args ...any) error {
 	return c.Message(fmt.Sprintf(c.Localize(key), args...))
 }
 
-func (c *Context) File(r io.Reader, name string) error {
+func (c *Context) File(r io.Reader, name string, message ...string) error {
 	if r == nil {
 		return errors.New("bad Context#File call with nil io.Reader")
 	}
-	return c.respond(discordgo.InteractionResponseData{Files: []*discordgo.File{{Reader: r, Name: name}}})
+	return c.respond(discordgo.InteractionResponseData{Files: []*discordgo.File{{Reader: r, Name: name}}, Content: strings.Join(message, "\n")})
 }
 
 func (c *Context) isCommand() bool {
diff --git a/internal/stats/render/session/v1/cards.go b/internal/stats/render/session/v1/cards.go
index 2eed140d..855148c2 100644
--- a/internal/stats/render/session/v1/cards.go
+++ b/internal/stats/render/session/v1/cards.go
@@ -10,6 +10,7 @@ import (
 	prepare "github.com/cufee/aftermath/internal/stats/prepare/common/v1"
 	"github.com/cufee/aftermath/internal/stats/prepare/session/v1"
 	"github.com/cufee/aftermath/internal/stats/render/common/v1"
+	"github.com/pkg/errors"
 )
 
 func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Cards, subs []models.UserSubscription, opts common.Options) (common.Segments, error) {
@@ -199,17 +200,38 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 		//
 	}
 
+	// we are done with the primary column at this point and can render it as an image in order to have access to final height
+	primaryColumnBlock := common.NewBlocksContent(overviewColumnStyle(primaryCardWidth), primaryColumn...)
+	primaryColumnImage, err := primaryColumnBlock.Render()
+	if err != nil {
+		return common.Segments{}, err
+	}
+
 	// unrated vehicles
+	var totalSecondaryCardsHeight float64
+	var primaryCardHeight = float64(primaryColumnImage.Bounds().Dy())
 	if shouldRenderUnratedVehicles {
 		for i, vehicle := range cards.Unrated.Vehicles {
-			secondaryColumn = append(secondaryColumn, makeVehicleCard(vehicle, secondaryCardBlockSizes, secondaryCardWidth))
-			if i == len(cards.Unrated.Vehicles)-1 {
-				secondaryColumn = append(secondaryColumn, makeVehicleLegendCard(cards.Unrated.Vehicles[0], secondaryCardBlockSizes, secondaryCardWidth))
+			vehicleCard := makeVehicleCard(vehicle, secondaryCardBlockSizes, secondaryCardWidth)
+			vehicleCardImage, err := vehicleCard.Render()
+			if err != nil {
+				return common.Segments{}, errors.Wrapf(err, "failed to render a vehicle card for %s", vehicle.Title)
 			}
+
+			height := float64(vehicleCardImage.Bounds().Dy())
+			// stop rendering cards when the total column height is larger than the primary column and there are at least 3 vehicles
+			if totalSecondaryCardsHeight+height > primaryCardHeight && i >= 3 {
+				break
+			}
+			secondaryColumn = append(secondaryColumn, common.NewImageContent(common.Style{}, vehicleCardImage))
+			totalSecondaryCardsHeight += height + overviewCardStyle(0).Gap
+		}
+		if len(cards.Unrated.Vehicles) > 0 {
+			secondaryColumn = append(secondaryColumn, makeVehicleLegendCard(cards.Unrated.Vehicles[0], secondaryCardBlockSizes, secondaryCardWidth))
 		}
 	}
 
-	columns := []common.Block{common.NewBlocksContent(overviewColumnStyle(primaryCardWidth), primaryColumn...)}
+	columns := []common.Block{common.NewImageContent(common.Style{}, primaryColumnImage)}
 	if len(secondaryColumn) > 0 {
 		columns = append(columns, common.NewBlocksContent(overviewColumnStyle(secondaryCardWidth), secondaryColumn...))
 	}

From 1bb71688bc980737ef5a813d82d536dbbff76744 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Wed, 26 Jun 2024 13:06:10 -0400
Subject: [PATCH 179/341] added custom font type

---
 internal/stats/render/assets/load.go          | 36 ++++----
 internal/stats/render/common/v1/badges.go     | 16 ++--
 internal/stats/render/common/v1/block.go      |  6 +-
 internal/stats/render/common/v1/constants.go  | 62 +++++++-------
 internal/stats/render/common/v1/footer.go     |  2 +-
 internal/stats/render/common/v1/header.go     |  2 +-
 .../stats/render/common/v1/player_title.go    |  6 +-
 internal/stats/render/common/v1/segments.go   | 84 +++++++++++++------
 internal/stats/render/common/v1/strings.go    | 10 +--
 internal/stats/render/common/v1/style.go      |  4 +-
 .../stats/render/common/v1/tier_percentage.go |  2 +-
 internal/stats/render/period/v1/cards.go      | 16 ++--
 internal/stats/render/period/v1/constants.go  | 14 ++--
 internal/stats/render/session/v1/cards.go     | 71 +++++++---------
 internal/stats/render/session/v1/constants.go | 30 +++----
 15 files changed, 193 insertions(+), 168 deletions(-)

diff --git a/internal/stats/render/assets/load.go b/internal/stats/render/assets/load.go
index 79a68b71..36940806 100644
--- a/internal/stats/render/assets/load.go
+++ b/internal/stats/render/assets/load.go
@@ -13,10 +13,9 @@ import (
 	"github.com/cufee/aftermath/internal/files"
 	"github.com/golang/freetype/truetype"
 	"github.com/rs/zerolog/log"
-	"golang.org/x/image/font"
 )
 
-var fontsMap = make(map[string]*truetype.Font)
+var fontsMap = make(map[string][]byte)
 var imagesMap = make(map[string]image.Image)
 
 func LoadAssets(assets fs.FS, directory string) error {
@@ -38,19 +37,19 @@ func LoadAssets(assets fs.FS, directory string) error {
 	return nil
 }
 
-func loadFonts(files map[string][]byte) (map[string]*truetype.Font, error) {
-	fonts := make(map[string]*truetype.Font)
+func loadFonts(files map[string][]byte) (map[string][]byte, error) {
+	fonts := make(map[string][]byte)
 	for path, data := range files {
 		if !strings.HasSuffix(path, ".ttf") {
 			continue
 		}
 
-		font, err := truetype.Parse(data)
+		_, err := truetype.Parse(data)
 		if err != nil {
 			return nil, err
 		}
 
-		fonts[strings.Split(filepath.Base(path), ".")[0]] = font
+		fonts[strings.Split(filepath.Base(path), ".")[0]] = data
 		log.Debug().Str("path", path).Msg("loaded font")
 	}
 
@@ -79,18 +78,19 @@ func loadImages(files map[string][]byte) (map[string]image.Image, error) {
 	return imagesMap, nil
 }
 
-func GetLoadedFontFaces(name string, sizes ...float64) (map[float64]font.Face, bool) {
-	loadedFont, ok := fontsMap[name]
-	if !ok {
-		return nil, false
-	}
-	faces := make(map[float64]font.Face)
-	for _, size := range sizes {
-		faces[size] = truetype.NewFace(loadedFont, &truetype.Options{
-			Size: size,
-		})
-	}
-	return faces, true
+func GetLoadedFontFace(name string) ([]byte, bool) {
+	f, ok := fontsMap[name]
+	return f, ok
+	// if !ok {
+	// 	return nil, false
+	// }
+	// faces := make(map[float64]font.Face)
+	// for _, size := range sizes {
+	// 	faces[size] = truetype.NewFace(loadedFont, &truetype.Options{
+	// 		Size: size,
+	// 	})
+	// }
+	// return faces, true
 }
 
 func GetLoadedImage(name string) (image.Image, bool) {
diff --git a/internal/stats/render/common/v1/badges.go b/internal/stats/render/common/v1/badges.go
index 7b2fa492..a674f8e7 100644
--- a/internal/stats/render/common/v1/badges.go
+++ b/internal/stats/render/common/v1/badges.go
@@ -57,7 +57,7 @@ var (
 		Style: subscriptionPillStyle{
 			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: DefaultCardColorNoAlpha, BorderRadius: 15, PaddingX: 7, PaddingY: 5, Height: 32},
 			Icon:      Style{Width: 16, Height: 16, BackgroundColor: TextSubscriptionPlus},
-			Text:      Style{Font: &FontSmall, FontColor: TextSecondary, PaddingX: 5},
+			Text:      Style{Font: FontSmall, FontColor: TextSecondary, PaddingX: 5},
 		},
 	}
 	userSubscriptionPlus = &subscriptionHeader{
@@ -66,7 +66,7 @@ var (
 		Style: subscriptionPillStyle{
 			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: DefaultCardColorNoAlpha, BorderRadius: 15, PaddingX: 5, PaddingY: 5, Height: 32},
 			Icon:      Style{Width: 24, Height: 24, BackgroundColor: TextSubscriptionPlus},
-			Text:      Style{Font: &FontSmall, FontColor: TextSecondary, PaddingX: 5},
+			Text:      Style{Font: FontSmall, FontColor: TextSecondary, PaddingX: 5},
 		},
 	}
 	userSubscriptionPro = &subscriptionHeader{
@@ -75,7 +75,7 @@ var (
 		Style: subscriptionPillStyle{
 			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: DefaultCardColorNoAlpha, BorderRadius: 15, PaddingX: 5, PaddingY: 5, Height: 32},
 			Icon:      Style{Width: 24, Height: 24, BackgroundColor: TextSubscriptionPremium},
-			Text:      Style{Font: &FontSmall, FontColor: TextSecondary, PaddingX: 5},
+			Text:      Style{Font: FontSmall, FontColor: TextSecondary, PaddingX: 5},
 		},
 	}
 	// Clans
@@ -101,7 +101,7 @@ var (
 		Style: subscriptionPillStyle{
 			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: color.RGBA{64, 32, 128, 180}, BorderRadius: 15, PaddingX: 6, PaddingY: 5, Gap: 5, Height: 32},
 			Icon:      Style{Width: 20, Height: 20, BackgroundColor: TextPrimary},
-			Text:      Style{Font: &FontSmall, FontColor: TextPrimary, PaddingX: 5},
+			Text:      Style{Font: FontSmall, FontColor: TextPrimary, PaddingX: 5},
 		},
 	}
 	subscriptionServerModerator = &subscriptionHeader{
@@ -110,7 +110,7 @@ var (
 		Style: subscriptionPillStyle{
 			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: DefaultCardColorNoAlpha, BorderRadius: 15, PaddingX: 7, PaddingY: 5, Gap: 5, Height: 32},
 			Icon:      Style{Width: 20, Height: 20},
-			Text:      Style{Font: &FontSmall, FontColor: TextSecondary, PaddingX: 2},
+			Text:      Style{Font: FontSmall, FontColor: TextSecondary, PaddingX: 2},
 		},
 	}
 	subscriptionContentModerator = &subscriptionHeader{
@@ -119,7 +119,7 @@ var (
 		Style: subscriptionPillStyle{
 			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: DefaultCardColorNoAlpha, BorderRadius: 15, PaddingX: 7, PaddingY: 5, Gap: 5, Height: 32},
 			Icon:      Style{Width: 20, Height: 20},
-			Text:      Style{Font: &FontSmall, FontColor: TextSecondary, PaddingX: 2},
+			Text:      Style{Font: FontSmall, FontColor: TextSecondary, PaddingX: 2},
 		},
 	}
 	subscriptionServerBooster = &subscriptionHeader{
@@ -128,7 +128,7 @@ var (
 		Style: subscriptionPillStyle{
 			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: DefaultCardColorNoAlpha, BorderRadius: 15, PaddingX: 10, PaddingY: 5, Gap: 5, Height: 32},
 			Icon:      Style{Width: 20, Height: 20},
-			Text:      Style{Font: &FontSmall, FontColor: TextSecondary},
+			Text:      Style{Font: FontSmall, FontColor: TextSecondary},
 		},
 	}
 	subscriptionTranslator = &subscriptionHeader{
@@ -137,7 +137,7 @@ var (
 		Style: subscriptionPillStyle{
 			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: DefaultCardColorNoAlpha, BorderRadius: 15, PaddingX: 10, PaddingY: 5, Gap: 5, Height: 32},
 			Icon:      Style{Width: 20, Height: 20, BackgroundColor: TextPrimary},
-			Text:      Style{Font: &FontSmall, FontColor: TextSecondary},
+			Text:      Style{Font: FontSmall, FontColor: TextSecondary},
 		},
 	}
 )
diff --git a/internal/stats/render/common/v1/block.go b/internal/stats/render/common/v1/block.go
index c5b20853..307ef9ba 100644
--- a/internal/stats/render/common/v1/block.go
+++ b/internal/stats/render/common/v1/block.go
@@ -53,15 +53,15 @@ func NewTextContent(style Style, value string) Block {
 }
 
 func (content contentText) Render(style Style) (image.Image, error) {
-	if style.Font == nil {
+	if !style.Font.Valid() {
 		return nil, errors.New("font not set")
 	}
 
-	size := MeasureString(content.value, *style.Font)
+	size := MeasureString(content.value, style.Font)
 	ctx := gg.NewContext(int(size.TotalWidth+(style.PaddingX*2)), int(size.TotalHeight+(style.PaddingY*2)))
 
 	// Render text
-	ctx.SetFontFace(*style.Font)
+	ctx.SetFontFace(style.Font.Face())
 	ctx.SetColor(style.FontColor)
 
 	var lastX, lastY float64 = style.PaddingX, style.PaddingY + 1
diff --git a/internal/stats/render/common/v1/constants.go b/internal/stats/render/common/v1/constants.go
index e637e251..bc1c3a25 100644
--- a/internal/stats/render/common/v1/constants.go
+++ b/internal/stats/render/common/v1/constants.go
@@ -3,20 +3,21 @@ package common
 import (
 	"image/color"
 
+	"github.com/golang/freetype/truetype"
 	"github.com/pkg/errors"
+	"golang.org/x/image/font"
 
 	"github.com/cufee/aftermath/internal/stats/render/assets"
-	"golang.org/x/image/font"
 )
 
 var DiscordBackgroundColor = color.RGBA{49, 51, 56, 255}
 
 var (
-	FontXL     font.Face
-	Font2XL    font.Face
-	FontLarge  font.Face
-	FontMedium font.Face
-	FontSmall  font.Face
+	FontXL     Font
+	Font2XL    Font
+	FontLarge  Font
+	FontMedium Font
+	FontSmall  Font
 
 	TextPrimary   = color.RGBA{255, 255, 255, 255}
 	TextSecondary = color.RGBA{204, 204, 204, 255}
@@ -37,35 +38,38 @@ var (
 	BorderRadiusXS = 10.0
 )
 
-var fontCache map[float64]font.Face
+type Font struct {
+	size float64
+	data []byte
+}
 
-func InitLoadedAssets() error {
-	var ok bool
-	fontCache, ok = assets.GetLoadedFontFaces("default", 36, 32, 24, 18, 14)
-	if !ok {
-		return errors.New("default font not found")
-	}
-	FontXL = fontCache[32]
-	Font2XL = fontCache[36]
-	FontLarge = fontCache[24]
-	FontMedium = fontCache[18]
-	FontSmall = fontCache[14]
+func (f *Font) Valid() bool {
+	return f.data != nil && f.size > 0
+}
 
-	return nil
+func (f *Font) Face() font.Face {
+	ttf, _ := truetype.Parse(f.data)
+	return truetype.NewFace(ttf, &truetype.Options{
+		Size: f.size,
+	})
 }
 
-func GetCustomFont(size float64) (font.Face, bool) {
-	if f, ok := fontCache[size]; ok {
-		return f, true
-	}
+// var fontCache map[float64]font.Face
 
-	newCache, ok := assets.GetLoadedFontFaces("default", size)
+func InitLoadedAssets() error {
+	// var ok bool
+	// fontCache, ok = assets.GetLoadedFontFaces("default", 36, 32, 24, 18, 14)
+	fontData, ok := assets.GetLoadedFontFace("default")
 	if !ok {
-		return nil, false
-	}
-	for size, font := range newCache {
-		fontCache[size] = font
+		return errors.New("default font not found")
 	}
 
-	return newCache[size], true
+	FontXL = Font{32, fontData}
+	Font2XL = Font{36, fontData}
+
+	FontLarge = Font{24, fontData}
+	FontMedium = Font{18, fontData}
+	FontSmall = Font{14, fontData}
+
+	return nil
 }
diff --git a/internal/stats/render/common/v1/footer.go b/internal/stats/render/common/v1/footer.go
index 99051184..16cff210 100644
--- a/internal/stats/render/common/v1/footer.go
+++ b/internal/stats/render/common/v1/footer.go
@@ -12,5 +12,5 @@ func NewFooterCard(text string) Block {
 		BackgroundColor: backgroundColor,
 		BorderRadius:    BorderRadiusSM,
 		// Debug:           true,
-	}, NewTextContent(Style{Font: &FontSmall, FontColor: TextSecondary}, text))
+	}, NewTextContent(Style{Font: FontSmall, FontColor: TextSecondary}, text))
 }
diff --git a/internal/stats/render/common/v1/header.go b/internal/stats/render/common/v1/header.go
index 24c8945c..fc599a61 100644
--- a/internal/stats/render/common/v1/header.go
+++ b/internal/stats/render/common/v1/header.go
@@ -22,7 +22,7 @@ func NewHeaderCard(width float64, subscriptions []models.UserSubscription, promo
 		// Users without a subscription get promo text
 		var textBlocks []Block
 		for _, text := range promoText {
-			textBlocks = append(textBlocks, NewTextContent(Style{Font: &FontMedium, FontColor: TextPrimary}, text))
+			textBlocks = append(textBlocks, NewTextContent(Style{Font: FontMedium, FontColor: TextPrimary}, text))
 		}
 		cards = append(cards, NewBlocksContent(Style{
 			Direction:  DirectionVertical,
diff --git a/internal/stats/render/common/v1/player_title.go b/internal/stats/render/common/v1/player_title.go
index 7636f5a9..eceb3f6f 100644
--- a/internal/stats/render/common/v1/player_title.go
+++ b/internal/stats/render/common/v1/player_title.go
@@ -29,8 +29,8 @@ func DefaultPlayerTitleStyle(containerStyle Style) TitleCardStyle {
 
 	return TitleCardStyle{
 		Container: containerStyle,
-		Nickname:  Style{Font: &FontLarge, FontColor: TextPrimary},
-		ClanTag:   Style{Font: &FontMedium, FontColor: TextSecondary, PaddingX: 10, PaddingY: 5, BackgroundColor: clanTagBackgroundColor, BorderRadius: BorderRadiusSM},
+		Nickname:  Style{Font: FontLarge, FontColor: TextPrimary},
+		ClanTag:   Style{Font: FontMedium, FontColor: TextSecondary, PaddingX: 10, PaddingY: 5, BackgroundColor: clanTagBackgroundColor, BorderRadius: BorderRadiusSM},
 	}
 }
 
@@ -71,7 +71,7 @@ func newClanTagBlock(style Style, clanTag string, subs []models.UserSubscription
 	}
 
 	var blocks []Block
-	blocks = append(blocks, NewTextContent(Style{Font: &FontMedium, FontColor: TextSecondary}, clanTag))
+	blocks = append(blocks, NewTextContent(Style{Font: FontMedium, FontColor: TextSecondary}, clanTag))
 	if sub := ClanSubscriptionsBadges(subs); sub != nil {
 		iconBlock, err := sub.Block()
 		if err == nil {
diff --git a/internal/stats/render/common/v1/segments.go b/internal/stats/render/common/v1/segments.go
index 869548f5..fc6dd829 100644
--- a/internal/stats/render/common/v1/segments.go
+++ b/internal/stats/render/common/v1/segments.go
@@ -2,7 +2,9 @@ package common
 
 import (
 	"image"
+	"sync"
 
+	"github.com/cufee/aftermath/internal/retry"
 	"github.com/pkg/errors"
 )
 
@@ -34,38 +36,66 @@ func (s *Segments) Render(opts ...Option) (image.Image, error) {
 		apply(&options)
 	}
 
-	var frameParts []Block
+	var wg sync.WaitGroup
+	var headerBlock *Block
+	var contentBlock retry.DataWithErr[Block]
+	var footerBlock *Block
 
-	mainSegment := NewBlocksContent(
-		Style{
-			Direction:  DirectionVertical,
-			AlignItems: AlignItemsCenter,
-			PaddingX:   20,
-			PaddingY:   20,
-			Gap:        10,
-		}, s.content...)
-	mainSegmentImg, err := mainSegment.Render()
-	if err != nil {
-		return nil, err
-	}
-	mainSegmentImg = AddBackground(mainSegmentImg, options.Background, Style{Blur: 10, BorderRadius: 42.5})
-
-	frameParts = append(frameParts, NewImageContent(Style{}, mainSegmentImg))
-	if len(s.header) > 0 {
-		frameParts = append(frameParts, NewBlocksContent(
+	wg.Add(3)
+	go func() {
+		defer wg.Done()
+		mainSegment := NewBlocksContent(
 			Style{
 				Direction:  DirectionVertical,
 				AlignItems: AlignItemsCenter,
+				PaddingX:   20,
+				PaddingY:   20,
 				Gap:        10,
-			}, s.header...))
+			}, s.content...)
+		mainSegmentImg, err := mainSegment.Render()
+		if err != nil {
+			contentBlock = retry.DataWithErr[Block]{Err: err}
+			return
+		}
+		mainSegmentBlock := NewImageContent(Style{}, AddBackground(mainSegmentImg, options.Background, Style{Blur: 10, BorderRadius: 42.5}))
+		contentBlock = retry.DataWithErr[Block]{Data: mainSegmentBlock}
+	}()
+	go func() {
+		defer wg.Done()
+		if len(s.header) > 0 {
+			header := NewBlocksContent(
+				Style{
+					Direction:  DirectionVertical,
+					AlignItems: AlignItemsCenter,
+					Gap:        10,
+				}, s.header...)
+			headerBlock = &header
+		}
+	}()
+	go func() {
+		defer wg.Done()
+		if len(s.footer) > 0 {
+			footer := NewBlocksContent(
+				Style{
+					Direction:  DirectionVertical,
+					AlignItems: AlignItemsCenter,
+					Gap:        10,
+				}, s.footer...)
+			footerBlock = &footer
+		}
+	}()
+	wg.Wait()
+
+	var frameBlocks []Block
+	if headerBlock != nil {
+		frameBlocks = append(frameBlocks, *headerBlock)
 	}
-	if len(s.footer) > 0 {
-		frameParts = append(frameParts, NewBlocksContent(
-			Style{
-				Direction:  DirectionVertical,
-				AlignItems: AlignItemsCenter,
-				Gap:        10,
-			}, s.footer...))
+	if contentBlock.Err != nil {
+		return nil, contentBlock.Err
+	}
+	frameBlocks = append(frameBlocks, contentBlock.Data)
+	if footerBlock != nil {
+		frameBlocks = append(frameBlocks, *footerBlock)
 	}
 
 	frame := NewBlocksContent(
@@ -74,7 +104,7 @@ func (s *Segments) Render(opts ...Option) (image.Image, error) {
 			AlignItems: AlignItemsCenter,
 			Gap:        5,
 		},
-		frameParts...,
+		frameBlocks...,
 	)
 	return frame.Render()
 }
diff --git a/internal/stats/render/common/v1/strings.go b/internal/stats/render/common/v1/strings.go
index c6a3ba15..4c4eaa89 100644
--- a/internal/stats/render/common/v1/strings.go
+++ b/internal/stats/render/common/v1/strings.go
@@ -4,7 +4,6 @@ import (
 	"strings"
 
 	"github.com/fogleman/gg"
-	"golang.org/x/image/font"
 )
 
 type stringSize struct {
@@ -14,20 +13,21 @@ type stringSize struct {
 	LineHeight  float64
 }
 
-func MeasureString(text string, font font.Face) stringSize {
-	if font == nil {
+func MeasureString(text string, font Font) stringSize {
+	if !font.Valid() {
 		return stringSize{}
 	}
 	if text == "" {
 		return stringSize{}
 	}
 
+	face := font.Face()
 	measureCtx := gg.NewContext(1, 1)
-	measureCtx.SetFontFace(font)
+	measureCtx.SetFontFace(face)
 
 	var result stringSize
 	// Account for font descender height
-	result.LineOffset = float64(font.Metrics().Descent>>6) * 2
+	result.LineOffset = float64(face.Metrics().Descent>>6) * 2
 
 	for _, line := range strings.Split(text, "\n") {
 		w, h := measureCtx.MeasureString(line)
diff --git a/internal/stats/render/common/v1/style.go b/internal/stats/render/common/v1/style.go
index ad1f69e6..f0ed9eb9 100644
--- a/internal/stats/render/common/v1/style.go
+++ b/internal/stats/render/common/v1/style.go
@@ -2,8 +2,6 @@ package common
 
 import (
 	"image/color"
-
-	"golang.org/x/image/font"
 )
 
 type alignItemsValue int
@@ -29,7 +27,7 @@ const (
 )
 
 type Style struct {
-	Font      *font.Face
+	Font      Font
 	FontColor color.Color
 
 	JustifyContent justifyContentValue
diff --git a/internal/stats/render/common/v1/tier_percentage.go b/internal/stats/render/common/v1/tier_percentage.go
index d6238cc8..2a6eabaf 100644
--- a/internal/stats/render/common/v1/tier_percentage.go
+++ b/internal/stats/render/common/v1/tier_percentage.go
@@ -25,7 +25,7 @@ func NewTierPercentageCard(style Style, vehicles map[string]frame.VehicleStatsFr
 			BackgroundColor: shade,
 			Width:           style.Width / float64(elements),
 			JustifyContent:  JustifyContentCenter,
-		}, NewTextContent(Style{Font: &FontMedium, FontColor: TextPrimary}, fmt.Sprint(i))))
+		}, NewTextContent(Style{Font: FontMedium, FontColor: TextPrimary}, fmt.Sprint(i))))
 	}
 
 	return NewBlocksContent(style, blocks...)
diff --git a/internal/stats/render/period/v1/cards.go b/internal/stats/render/period/v1/cards.go
index 2fa066d9..e3f4a350 100644
--- a/internal/stats/render/period/v1/cards.go
+++ b/internal/stats/render/period/v1/cards.go
@@ -28,8 +28,8 @@ func generateCards(stats fetch.AccountStatsOverPeriod, cards period.Cards, subs
 	{
 		{
 			titleStyle := common.DefaultPlayerTitleStyle(titleCardStyle(cardWidth))
-			clanSize := common.MeasureString(stats.Account.ClanTag, *titleStyle.ClanTag.Font)
-			nameSize := common.MeasureString(stats.Account.Nickname, *titleStyle.Nickname.Font)
+			clanSize := common.MeasureString(stats.Account.ClanTag, titleStyle.ClanTag.Font)
+			nameSize := common.MeasureString(stats.Account.Nickname, titleStyle.Nickname.Font)
 			cardWidth = common.Max(cardWidth, titleStyle.TotalPaddingAndGaps()+nameSize.TotalWidth+clanSize.TotalWidth*2)
 		}
 		{
@@ -42,8 +42,8 @@ func generateCards(stats fetch.AccountStatsOverPeriod, cards period.Cards, subs
 					if block.Tag == prepare.TagWN8 {
 						label = common.GetWN8TierName(block.Value.Float())
 					}
-					labelSize := common.MeasureString(label, *labelStyle.Font)
-					valueSize := common.MeasureString(block.Value.String(), *valueStyle.Font)
+					labelSize := common.MeasureString(label, labelStyle.Font)
+					valueSize := common.MeasureString(block.Value.String(), valueStyle.Font)
 
 					overviewColumnWidth = common.Max(overviewColumnWidth, common.Max(labelSize.TotalWidth, valueSize.TotalWidth)+(rowStyle.container.PaddingX*2))
 				}
@@ -61,15 +61,15 @@ func generateCards(stats fetch.AccountStatsOverPeriod, cards period.Cards, subs
 			var highlightBlocksMaxCount, highlightTitleMaxWidth, highlightBlockMaxSize float64
 			for _, highlight := range cards.Highlights {
 				// Title and tank name
-				metaSize := common.MeasureString(highlight.Meta, *highlightStyle.cardTitle.Font)
-				titleSize := common.MeasureString(highlight.Title, *highlightStyle.tankName.Font)
+				metaSize := common.MeasureString(highlight.Meta, highlightStyle.cardTitle.Font)
+				titleSize := common.MeasureString(highlight.Title, highlightStyle.tankName.Font)
 				highlightTitleMaxWidth = common.Max(highlightTitleMaxWidth, metaSize.TotalWidth, titleSize.TotalWidth)
 
 				// Blocks
 				highlightBlocksMaxCount = common.Max(highlightBlocksMaxCount, float64(len(highlight.Blocks)))
 				for _, block := range highlight.Blocks {
-					labelSize := common.MeasureString(block.Label, *highlightStyle.blockLabel.Font)
-					valueSize := common.MeasureString(block.Value.String(), *highlightStyle.blockValue.Font)
+					labelSize := common.MeasureString(block.Label, highlightStyle.blockLabel.Font)
+					valueSize := common.MeasureString(block.Value.String(), highlightStyle.blockValue.Font)
 					highlightBlockMaxSize = common.Max(highlightBlockMaxSize, valueSize.TotalWidth, labelSize.TotalWidth)
 				}
 			}
diff --git a/internal/stats/render/period/v1/constants.go b/internal/stats/render/period/v1/constants.go
index ed174590..4534c18e 100644
--- a/internal/stats/render/period/v1/constants.go
+++ b/internal/stats/render/period/v1/constants.go
@@ -22,11 +22,11 @@ type highlightStyle struct {
 func (s *overviewStyle) block(block prepare.StatsBlock[period.BlockData]) (common.Style, common.Style) {
 	switch block.Data.Flavor {
 	case period.BlockFlavorSpecial:
-		return common.Style{FontColor: common.TextPrimary, Font: &common.FontXL}, common.Style{FontColor: common.TextAlt, Font: &common.FontSmall}
+		return common.Style{FontColor: common.TextPrimary, Font: common.FontXL}, common.Style{FontColor: common.TextAlt, Font: common.FontSmall}
 	case period.BlockFlavorSecondary:
-		return common.Style{FontColor: common.TextSecondary, Font: &common.FontMedium}, common.Style{FontColor: common.TextAlt, Font: &common.FontSmall}
+		return common.Style{FontColor: common.TextSecondary, Font: common.FontMedium}, common.Style{FontColor: common.TextAlt, Font: common.FontSmall}
 	default:
-		return common.Style{FontColor: common.TextPrimary, Font: &common.FontLarge}, common.Style{FontColor: common.TextAlt, Font: &common.FontSmall}
+		return common.Style{FontColor: common.TextPrimary, Font: common.FontLarge}, common.Style{FontColor: common.TextAlt, Font: common.FontSmall}
 	}
 }
 
@@ -92,9 +92,9 @@ func highlightCardStyle(containerStyle common.Style) highlightStyle {
 
 	return highlightStyle{
 		container:  container,
-		cardTitle:  common.Style{Font: &common.FontSmall, FontColor: common.TextSecondary},
-		tankName:   common.Style{Font: &common.FontMedium, FontColor: common.TextPrimary},
-		blockValue: common.Style{Font: &common.FontMedium, FontColor: common.TextPrimary},
-		blockLabel: common.Style{Font: &common.FontSmall, FontColor: common.TextAlt},
+		cardTitle:  common.Style{Font: common.FontSmall, FontColor: common.TextSecondary},
+		tankName:   common.Style{Font: common.FontMedium, FontColor: common.TextPrimary},
+		blockValue: common.Style{Font: common.FontMedium, FontColor: common.TextPrimary},
+		blockLabel: common.Style{Font: common.FontSmall, FontColor: common.TextAlt},
 	}
 }
diff --git a/internal/stats/render/session/v1/cards.go b/internal/stats/render/session/v1/cards.go
index 855148c2..ff530a8e 100644
--- a/internal/stats/render/session/v1/cards.go
+++ b/internal/stats/render/session/v1/cards.go
@@ -10,16 +10,16 @@ import (
 	prepare "github.com/cufee/aftermath/internal/stats/prepare/common/v1"
 	"github.com/cufee/aftermath/internal/stats/prepare/session/v1"
 	"github.com/cufee/aftermath/internal/stats/render/common/v1"
-	"github.com/pkg/errors"
 )
 
 func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Cards, subs []models.UserSubscription, opts common.Options) (common.Segments, error) {
 	var (
+		renderVehiclesCount = 3 // minimum number of vehicle cards
 		// primary cards
 		// when there are some unrated battles or no battles at all
 		shouldRenderUnratedOverview = session.RegularBattles.Battles > 0 || session.RatingBattles.Battles == 0
 		// when there are 3 vehicle cards and no rating overview cards or there are 6 vehicle cards and some rating battles
-		shouldRenderUnratedHighlights = (session.RegularBattles.Battles > 0 && session.RatingBattles.Battles < 1 && len(cards.Unrated.Vehicles) > 3) ||
+		shouldRenderUnratedHighlights = (session.RegularBattles.Battles > 0 && session.RatingBattles.Battles < 1 && len(cards.Unrated.Vehicles) > renderVehiclesCount) ||
 			(session.RegularBattles.Battles > 0 && len(cards.Unrated.Vehicles) > 6)
 		shouldRenderRatingOverview = session.RatingBattles.Battles > 0
 		shouldRenderRatingVehicles = len(cards.Unrated.Vehicles) == 0
@@ -27,6 +27,17 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 		shouldRenderUnratedVehicles = len(cards.Unrated.Vehicles) > 0
 	)
 
+	// try to make the columns height roughly similar to primary column
+	if shouldRenderUnratedHighlights && len(cards.Unrated.Highlights) > 1 {
+		renderVehiclesCount += len(cards.Unrated.Highlights)
+	}
+	if shouldRenderRatingOverview {
+		renderVehiclesCount += 2
+	}
+	if shouldRenderRatingVehicles {
+		renderVehiclesCount += len(cards.Rating.Vehicles)
+	}
+
 	var segments common.Segments
 	var primaryColumn []common.Block
 	var secondaryColumn []common.Block
@@ -44,13 +55,13 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 
 	{
 		titleStyle := common.DefaultPlayerTitleStyle(playerNameCardStyle(0))
-		clanSize := common.MeasureString(session.Account.ClanTag, *titleStyle.ClanTag.Font)
-		nameSize := common.MeasureString(session.Account.Nickname, *titleStyle.Nickname.Font)
+		clanSize := common.MeasureString(session.Account.ClanTag, titleStyle.ClanTag.Font)
+		nameSize := common.MeasureString(session.Account.Nickname, titleStyle.Nickname.Font)
 		primaryCardWidth = common.Max(primaryCardWidth, titleStyle.TotalPaddingAndGaps()+nameSize.TotalWidth+clanSize.TotalWidth*2)
 	}
 	{
 		for _, text := range opts.PromoText {
-			size := common.MeasureString(text, *promoTextStyle.Font)
+			size := common.MeasureString(text, promoTextStyle.Font)
 			totalFrameWidth = common.Max(size.TotalWidth, totalFrameWidth)
 		}
 	}
@@ -88,7 +99,7 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 	if shouldRenderRatingVehicles {
 		for _, card := range cards.Rating.Vehicles {
 			// [title] [session]
-			titleSize := common.MeasureString(card.Title, *ratingVehicleCardTitleStyle.Font)
+			titleSize := common.MeasureString(card.Title, ratingVehicleCardTitleStyle.Font)
 			presetBlockWidth, contentWidth := vehicleBlocksWidth(card.Blocks, ratingVehicleBlockStyle.session, ratingVehicleBlockStyle.career, ratingVehicleBlockStyle.label, ratingVehicleBlocksRowStyle(0))
 			// add the gap and card padding, the gap here accounts for title being inline with content
 			contentWidth += ratingVehicleBlocksRowStyle(0).Gap*float64(len(card.Blocks)) + ratingVehicleCardStyle(0).PaddingX*2 + titleSize.TotalWidth
@@ -104,8 +115,8 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 		for _, card := range cards.Unrated.Highlights {
 			// [card label] [session]
 			// [title]  	  [label]
-			labelSize := common.MeasureString(card.Meta, *highlightCardTitleTextStyle.Font)
-			titleSize := common.MeasureString(card.Title, *highlightVehicleNameTextStyle.Font)
+			labelSize := common.MeasureString(card.Meta, highlightCardTitleTextStyle.Font)
+			titleSize := common.MeasureString(card.Title, highlightVehicleNameTextStyle.Font)
 
 			presetBlockWidth, contentWidth := highlightedVehicleBlocksWidth(card.Blocks, vehicleBlockStyle.session, vehicleBlockStyle.career, vehicleBlockStyle.label, highlightedVehicleBlockRowStyle(0))
 			// add the gap and card padding, the gap here accounts for title/label being inline with content
@@ -131,7 +142,7 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 			presetBlockWidth, contentWidth := vehicleBlocksWidth(card.Blocks, styleWithIconOffset.session, styleWithIconOffset.career, styleWithIconOffset.label, vehicleBlocksRowStyle(0))
 			contentWidth += vehicleBlocksRowStyle(0).Gap*float64(len(card.Blocks)-1) + vehicleCardStyle(0).PaddingX*2
 
-			titleSize := common.MeasureString(card.Title, *vehicleCardTitleTextStyle.Font)
+			titleSize := common.MeasureString(card.Title, vehicleCardTitleTextStyle.Font)
 			secondaryCardWidth = common.Max(secondaryCardWidth, contentWidth, titleSize.TotalWidth+vehicleCardStyle(0).PaddingX*2)
 
 			for key, width := range presetBlockWidth {
@@ -200,38 +211,20 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 		//
 	}
 
-	// we are done with the primary column at this point and can render it as an image in order to have access to final height
-	primaryColumnBlock := common.NewBlocksContent(overviewColumnStyle(primaryCardWidth), primaryColumn...)
-	primaryColumnImage, err := primaryColumnBlock.Render()
-	if err != nil {
-		return common.Segments{}, err
-	}
-
 	// unrated vehicles
-	var totalSecondaryCardsHeight float64
-	var primaryCardHeight = float64(primaryColumnImage.Bounds().Dy())
 	if shouldRenderUnratedVehicles {
 		for i, vehicle := range cards.Unrated.Vehicles {
-			vehicleCard := makeVehicleCard(vehicle, secondaryCardBlockSizes, secondaryCardWidth)
-			vehicleCardImage, err := vehicleCard.Render()
-			if err != nil {
-				return common.Segments{}, errors.Wrapf(err, "failed to render a vehicle card for %s", vehicle.Title)
-			}
-
-			height := float64(vehicleCardImage.Bounds().Dy())
-			// stop rendering cards when the total column height is larger than the primary column and there are at least 3 vehicles
-			if totalSecondaryCardsHeight+height > primaryCardHeight && i >= 3 {
+			if i >= renderVehiclesCount {
 				break
 			}
-			secondaryColumn = append(secondaryColumn, common.NewImageContent(common.Style{}, vehicleCardImage))
-			totalSecondaryCardsHeight += height + overviewCardStyle(0).Gap
-		}
-		if len(cards.Unrated.Vehicles) > 0 {
-			secondaryColumn = append(secondaryColumn, makeVehicleLegendCard(cards.Unrated.Vehicles[0], secondaryCardBlockSizes, secondaryCardWidth))
+			secondaryColumn = append(secondaryColumn, makeVehicleCard(vehicle, secondaryCardBlockSizes, secondaryCardWidth))
+			if i == len(cards.Unrated.Vehicles)-1 {
+				secondaryColumn = append(secondaryColumn, makeVehicleLegendCard(cards.Unrated.Vehicles[0], secondaryCardBlockSizes, secondaryCardWidth))
+			}
 		}
 	}
 
-	columns := []common.Block{common.NewImageContent(common.Style{}, primaryColumnImage)}
+	columns := []common.Block{common.NewBlocksContent(overviewColumnStyle(primaryCardWidth), primaryColumn...)}
 	if len(secondaryColumn) > 0 {
 		columns = append(columns, common.NewBlocksContent(overviewColumnStyle(secondaryCardWidth), secondaryColumn...))
 	}
@@ -247,15 +240,15 @@ func vehicleBlocksWidth(blocks []prepare.StatsBlock[session.BlockData], sessionS
 	for _, block := range blocks {
 		var width float64
 		{
-			size := common.MeasureString(block.Data.Session.String(), *sessionStyle.Font)
+			size := common.MeasureString(block.Data.Session.String(), sessionStyle.Font)
 			width = common.Max(width, size.TotalWidth+sessionStyle.PaddingX*2)
 		}
 		{
-			size := common.MeasureString(block.Data.Career.String(), *careerStyle.Font)
+			size := common.MeasureString(block.Data.Career.String(), careerStyle.Font)
 			width = common.Max(width, size.TotalWidth+careerStyle.PaddingX*2)
 		}
 		{
-			size := common.MeasureString(block.Label, *labelStyle.Font)
+			size := common.MeasureString(block.Label, labelStyle.Font)
 			width = common.Max(width, size.TotalWidth+labelStyle.PaddingX*2+vehicleLegendLabelContainer.PaddingX*2)
 		}
 		maxBlockWidth = common.Max(maxBlockWidth, width)
@@ -280,11 +273,11 @@ func highlightedVehicleBlocksWidth(blocks []prepare.StatsBlock[session.BlockData
 	for _, block := range blocks {
 		var width float64
 		{
-			size := common.MeasureString(block.Data.Session.String(), *sessionStyle.Font)
+			size := common.MeasureString(block.Data.Session.String(), sessionStyle.Font)
 			width = common.Max(width, size.TotalWidth+sessionStyle.PaddingX*2)
 		}
 		{
-			size := common.MeasureString(block.Label, *labelStyle.Font)
+			size := common.MeasureString(block.Label, labelStyle.Font)
 			width = common.Max(width, size.TotalWidth+labelStyle.PaddingX*2)
 		}
 		maxBlockWidth = common.Max(maxBlockWidth, width)
@@ -307,7 +300,7 @@ func overviewColumnBlocksWidth(blocks []prepare.StatsBlock[session.BlockData], s
 	for _, block := range blocks {
 		// adjust width if this column includes a special icon
 		if block.Tag == prepare.TagWN8 {
-			tierNameSize := common.MeasureString(common.GetWN8TierName(block.Value.Float()), *overviewSpecialRatingLabelStyle(nil).Font)
+			tierNameSize := common.MeasureString(common.GetWN8TierName(block.Value.Float()), overviewSpecialRatingLabelStyle(nil).Font)
 			tierNameWithPadding := tierNameSize.TotalWidth + overviewSpecialRatingPillStyle(nil).PaddingX*2
 			presetBlockWidth[block.Tag.String()] = common.Max(presetBlockWidth[block.Tag.String()], specialRatingIconSize, tierNameWithPadding)
 		}
diff --git a/internal/stats/render/session/v1/constants.go b/internal/stats/render/session/v1/constants.go
index 8ef10208..8215b2e9 100644
--- a/internal/stats/render/session/v1/constants.go
+++ b/internal/stats/render/session/v1/constants.go
@@ -21,7 +21,7 @@ var (
 
 var (
 	specialRatingColumnStyle = common.Style{Direction: common.DirectionVertical, AlignItems: common.AlignItemsCenter, Gap: 5}
-	promoTextStyle           = common.Style{Font: &common.FontMedium, FontColor: common.TextPrimary}
+	promoTextStyle           = common.Style{Font: common.FontMedium, FontColor: common.TextPrimary}
 )
 
 func frameStyle() common.Style {
@@ -30,14 +30,14 @@ func frameStyle() common.Style {
 
 var (
 	overviewStatsBlockStyle = blockStyle{
-		common.Style{Font: &common.FontLarge, FontColor: common.TextPrimary},
-		common.Style{Font: &common.FontMedium, FontColor: common.TextSecondary},
-		common.Style{Font: &common.FontSmall, FontColor: common.TextAlt},
+		common.Style{Font: common.FontLarge, FontColor: common.TextPrimary},
+		common.Style{Font: common.FontMedium, FontColor: common.TextSecondary},
+		common.Style{Font: common.FontSmall, FontColor: common.TextAlt},
 	}
 )
 
 func overviewSpecialRatingLabelStyle(color color.Color) common.Style {
-	return common.Style{FontColor: color, Font: &common.FontSmall}
+	return common.Style{FontColor: color, Font: common.FontSmall}
 }
 
 func overviewSpecialRatingPillStyle(color color.Color) common.Style {
@@ -91,11 +91,11 @@ var (
 		PaddingY:        5,
 		PaddingX:        10,
 	}
-	vehicleCardTitleTextStyle = common.Style{Font: &common.FontMedium, FontColor: common.TextAlt}
+	vehicleCardTitleTextStyle = common.Style{Font: common.FontMedium, FontColor: common.TextAlt}
 	vehicleBlockStyle         = blockStyle{
-		common.Style{Font: &common.FontLarge, FontColor: common.TextPrimary},
-		common.Style{Font: &common.FontMedium, FontColor: common.TextSecondary},
-		common.Style{Font: &common.FontSmall, FontColor: common.TextAlt},
+		common.Style{Font: common.FontLarge, FontColor: common.TextPrimary},
+		common.Style{Font: common.FontMedium, FontColor: common.TextSecondary},
+		common.Style{Font: common.FontSmall, FontColor: common.TextAlt},
 	}
 )
 
@@ -132,11 +132,11 @@ func vehicleBlocksRowStyle(width float64) common.Style {
 
 var (
 	ratingVehicleCardTitleContainerStyle = common.Style{Direction: common.DirectionHorizontal, Gap: 10, JustifyContent: common.JustifyContentSpaceBetween}
-	ratingVehicleCardTitleStyle          = common.Style{Font: &common.FontMedium, FontColor: common.TextSecondary, PaddingX: 5}
+	ratingVehicleCardTitleStyle          = common.Style{Font: common.FontMedium, FontColor: common.TextSecondary, PaddingX: 5}
 	ratingVehicleBlockStyle              = blockStyle{
-		common.Style{Font: &common.FontLarge, FontColor: common.TextPrimary},
-		common.Style{Font: &common.FontMedium, FontColor: common.TextSecondary},
-		common.Style{Font: &common.FontSmall, FontColor: common.TextAlt},
+		common.Style{Font: common.FontLarge, FontColor: common.TextPrimary},
+		common.Style{Font: common.FontMedium, FontColor: common.TextSecondary},
+		common.Style{Font: common.FontSmall, FontColor: common.TextAlt},
 	}
 )
 
@@ -149,8 +149,8 @@ func ratingVehicleBlocksRowStyle(width float64) common.Style {
 }
 
 var (
-	highlightCardTitleTextStyle   = common.Style{Font: &common.FontSmall, FontColor: common.TextSecondary}
-	highlightVehicleNameTextStyle = common.Style{Font: &common.FontMedium, FontColor: common.TextPrimary}
+	highlightCardTitleTextStyle   = common.Style{Font: common.FontSmall, FontColor: common.TextSecondary}
+	highlightVehicleNameTextStyle = common.Style{Font: common.FontMedium, FontColor: common.TextPrimary}
 )
 
 func highlightedVehicleCardStyle(width float64) common.Style {

From 5d4aa00e5243eb1f7278e22a141c28fbdc966549 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Wed, 26 Jun 2024 14:20:46 -0400
Subject: [PATCH 180/341] removed implicit inits

---
 cmds/discord/router/handler.go                |  17 +-
 internal/stats/render/assets/load.go          |  10 --
 internal/stats/render/common/v1/badges.go     | 110 ------------
 internal/stats/render/common/v1/block.go      |  65 ++++++-
 internal/stats/render/common/v1/constants.go  |  75 --------
 internal/stats/render/common/v1/font.go       |  26 +++
 internal/stats/render/common/v1/footer.go     |   2 +-
 internal/stats/render/common/v1/header.go     |   2 +-
 internal/stats/render/common/v1/images.go     |   2 +-
 internal/stats/render/common/v1/init.go       | 167 ++++++++++++++++++
 .../stats/render/common/v1/player_title.go    |   6 +-
 .../stats/render/common/v1/tier_percentage.go |   2 +-
 internal/stats/render/period/v1/constants.go  |  14 +-
 internal/stats/render/session/v1/blocks.go    |  14 +-
 internal/stats/render/session/v1/cards.go     |  73 ++++----
 internal/stats/render/session/v1/constants.go |  71 +++++---
 16 files changed, 371 insertions(+), 285 deletions(-)
 delete mode 100644 internal/stats/render/common/v1/constants.go
 create mode 100644 internal/stats/render/common/v1/font.go
 create mode 100644 internal/stats/render/common/v1/init.go

diff --git a/cmds/discord/router/handler.go b/cmds/discord/router/handler.go
index 53d76f72..0dd79565 100644
--- a/cmds/discord/router/handler.go
+++ b/cmds/discord/router/handler.go
@@ -9,7 +9,6 @@ import (
 	"fmt"
 	"io"
 	"net/http"
-	"runtime/debug"
 	"sync"
 	"time"
 
@@ -209,14 +208,14 @@ func (router *Router) startInteractionHandlerAsync(interaction discordgo.Interac
 	responseCh := make(chan discordgo.InteractionResponseData)
 
 	go func() {
-		defer func() {
-			if r := recover(); r != nil {
-				log.Error().Str("stack", string(debug.Stack())).Msg("panic in interaction handler")
-				state.mx.Lock()
-				router.sendInteractionReply(interaction, state, discordgo.InteractionResponseData{Content: "Something unexpected happened and your command failed. Please try again in a few seconds."})
-				state.mx.Unlock()
-			}
-		}()
+		// defer func() {
+		// 	if r := recover(); r != nil {
+		// 		log.Error().Str("stack", string(debug.Stack())).Msg("panic in interaction handler")
+		// 		state.mx.Lock()
+		// 		router.sendInteractionReply(interaction, state, discordgo.InteractionResponseData{Content: "Something unexpected happened and your command failed. Please try again in a few seconds."})
+		// 		state.mx.Unlock()
+		// 	}
+		// }()
 		router.handleInteraction(workerCtx, cancelWorker, interaction, command, responseCh)
 	}()
 
diff --git a/internal/stats/render/assets/load.go b/internal/stats/render/assets/load.go
index 36940806..abb60925 100644
--- a/internal/stats/render/assets/load.go
+++ b/internal/stats/render/assets/load.go
@@ -81,16 +81,6 @@ func loadImages(files map[string][]byte) (map[string]image.Image, error) {
 func GetLoadedFontFace(name string) ([]byte, bool) {
 	f, ok := fontsMap[name]
 	return f, ok
-	// if !ok {
-	// 	return nil, false
-	// }
-	// faces := make(map[float64]font.Face)
-	// for _, size := range sizes {
-	// 	faces[size] = truetype.NewFace(loadedFont, &truetype.Options{
-	// 		Size: size,
-	// 	})
-	// }
-	// return faces, true
 }
 
 func GetLoadedImage(name string) (image.Image, bool) {
diff --git a/internal/stats/render/common/v1/badges.go b/internal/stats/render/common/v1/badges.go
index a674f8e7..3aa53484 100644
--- a/internal/stats/render/common/v1/badges.go
+++ b/internal/stats/render/common/v1/badges.go
@@ -1,7 +1,6 @@
 package common
 
 import (
-	"image/color"
 	"slices"
 
 	"github.com/pkg/errors"
@@ -33,115 +32,6 @@ func (sub subscriptionHeader) Block() (Block, error) {
 	return Block{}, errors.New("tier icon not found")
 }
 
-var (
-	subscriptionWeight = map[models.SubscriptionType]int{
-		models.SubscriptionTypeDeveloper: 999,
-		// Moderators
-		models.SubscriptionTypeServerModerator:  99,
-		models.SubscriptionTypeContentModerator: 98,
-		// Paid
-		models.SubscriptionTypePro:     89,
-		models.SubscriptionTypeProClan: 88,
-		models.SubscriptionTypePlus:    79,
-		//
-		models.SubscriptionTypeSupporter:     29,
-		models.SubscriptionTypeServerBooster: 28,
-		//
-		models.SubscriptionTypeVerifiedClan: 19,
-	}
-
-	// Personal
-	userSubscriptionSupporter = &subscriptionHeader{
-		Name: "Supporter",
-		Icon: "images/icons/fire",
-		Style: subscriptionPillStyle{
-			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: DefaultCardColorNoAlpha, BorderRadius: 15, PaddingX: 7, PaddingY: 5, Height: 32},
-			Icon:      Style{Width: 16, Height: 16, BackgroundColor: TextSubscriptionPlus},
-			Text:      Style{Font: FontSmall, FontColor: TextSecondary, PaddingX: 5},
-		},
-	}
-	userSubscriptionPlus = &subscriptionHeader{
-		Name: "Aftermath+",
-		Icon: "images/icons/star",
-		Style: subscriptionPillStyle{
-			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: DefaultCardColorNoAlpha, BorderRadius: 15, PaddingX: 5, PaddingY: 5, Height: 32},
-			Icon:      Style{Width: 24, Height: 24, BackgroundColor: TextSubscriptionPlus},
-			Text:      Style{Font: FontSmall, FontColor: TextSecondary, PaddingX: 5},
-		},
-	}
-	userSubscriptionPro = &subscriptionHeader{
-		Name: "Aftermath Pro",
-		Icon: "images/icons/star",
-		Style: subscriptionPillStyle{
-			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: DefaultCardColorNoAlpha, BorderRadius: 15, PaddingX: 5, PaddingY: 5, Height: 32},
-			Icon:      Style{Width: 24, Height: 24, BackgroundColor: TextSubscriptionPremium},
-			Text:      Style{Font: FontSmall, FontColor: TextSecondary, PaddingX: 5},
-		},
-	}
-	// Clans
-	clanSubscriptionVerified = &subscriptionHeader{
-		Icon: "images/icons/verify",
-		Style: subscriptionPillStyle{
-			Icon:      Style{Width: 28, Height: 28, BackgroundColor: TextAlt},
-			Container: Style{Direction: DirectionHorizontal},
-		},
-	}
-	clanSubscriptionPro = &subscriptionHeader{
-		Icon: "images/icons/star-multiple",
-		Style: subscriptionPillStyle{
-			Icon:      Style{Width: 28, Height: 28, BackgroundColor: TextAlt},
-			Container: Style{Direction: DirectionHorizontal},
-		},
-	}
-
-	// Community
-	subscriptionDeveloper = &subscriptionHeader{
-		Name: "Developer",
-		Icon: "images/icons/github",
-		Style: subscriptionPillStyle{
-			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: color.RGBA{64, 32, 128, 180}, BorderRadius: 15, PaddingX: 6, PaddingY: 5, Gap: 5, Height: 32},
-			Icon:      Style{Width: 20, Height: 20, BackgroundColor: TextPrimary},
-			Text:      Style{Font: FontSmall, FontColor: TextPrimary, PaddingX: 5},
-		},
-	}
-	subscriptionServerModerator = &subscriptionHeader{
-		Name: "Community Moderator",
-		Icon: "images/icons/logo-128",
-		Style: subscriptionPillStyle{
-			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: DefaultCardColorNoAlpha, BorderRadius: 15, PaddingX: 7, PaddingY: 5, Gap: 5, Height: 32},
-			Icon:      Style{Width: 20, Height: 20},
-			Text:      Style{Font: FontSmall, FontColor: TextSecondary, PaddingX: 2},
-		},
-	}
-	subscriptionContentModerator = &subscriptionHeader{
-		Name: "Moderator",
-		Icon: "images/icons/logo-128",
-		Style: subscriptionPillStyle{
-			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: DefaultCardColorNoAlpha, BorderRadius: 15, PaddingX: 7, PaddingY: 5, Gap: 5, Height: 32},
-			Icon:      Style{Width: 20, Height: 20},
-			Text:      Style{Font: FontSmall, FontColor: TextSecondary, PaddingX: 2},
-		},
-	}
-	subscriptionServerBooster = &subscriptionHeader{
-		Name: "Booster",
-		Icon: "images/icons/discord-booster",
-		Style: subscriptionPillStyle{
-			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: DefaultCardColorNoAlpha, BorderRadius: 15, PaddingX: 10, PaddingY: 5, Gap: 5, Height: 32},
-			Icon:      Style{Width: 20, Height: 20},
-			Text:      Style{Font: FontSmall, FontColor: TextSecondary},
-		},
-	}
-	subscriptionTranslator = &subscriptionHeader{
-		Name: "Translator",
-		Icon: "images/icons/translator",
-		Style: subscriptionPillStyle{
-			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: DefaultCardColorNoAlpha, BorderRadius: 15, PaddingX: 10, PaddingY: 5, Gap: 5, Height: 32},
-			Icon:      Style{Width: 20, Height: 20, BackgroundColor: TextPrimary},
-			Text:      Style{Font: FontSmall, FontColor: TextSecondary},
-		},
-	}
-)
-
 func SubscriptionsBadges(subscriptions []models.UserSubscription) ([]Block, error) {
 	slices.SortFunc(subscriptions, func(i, j models.UserSubscription) int {
 		return subscriptionWeight[j.Type] - subscriptionWeight[i.Type]
diff --git a/internal/stats/render/common/v1/block.go b/internal/stats/render/common/v1/block.go
index 307ef9ba..86d07cb9 100644
--- a/internal/stats/render/common/v1/block.go
+++ b/internal/stats/render/common/v1/block.go
@@ -1,10 +1,14 @@
 package common
 
 import (
+	"context"
+	"fmt"
 	"image"
 	"strings"
+	"sync"
 
 	"github.com/pkg/errors"
+	"github.com/rs/zerolog/log"
 
 	"github.com/disintegration/imaging"
 	"github.com/fogleman/gg"
@@ -12,6 +16,10 @@ import (
 
 type blockContentType int
 
+func (t blockContentType) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("%d", t)), nil
+}
+
 const (
 	BlockContentTypeText blockContentType = iota
 	BlockContentTypeImage
@@ -54,7 +62,7 @@ func NewTextContent(style Style, value string) Block {
 
 func (content contentText) Render(style Style) (image.Image, error) {
 	if !style.Font.Valid() {
-		return nil, errors.New("font not set")
+		// return nil, errors.New("font not valid")
 	}
 
 	size := MeasureString(content.value, style.Font)
@@ -94,6 +102,15 @@ func NewBlocksContent(style Style, blocks ...Block) Block {
 }
 
 func (content contentBlocks) Render(style Style) (image.Image, error) {
+	if len(content.blocks) < 1 {
+		return nil, errors.New("block content cannot be empty")
+	}
+
+	// avoid the overhead of mutex and goroutines if it is not required
+	if len(content.blocks) > 1 {
+		return content.renderAsync(style)
+	}
+
 	var images []image.Image
 	for _, block := range content.blocks {
 		img, err := block.Render()
@@ -105,6 +122,48 @@ func (content contentBlocks) Render(style Style) (image.Image, error) {
 	return renderImages(images, style)
 }
 
+func (content contentBlocks) renderAsync(style Style) (image.Image, error) {
+	var mx sync.Mutex
+	var wg sync.WaitGroup
+	images := make([]image.Image, len(content.blocks))
+
+	errCh := make(chan error)
+	ctx, cancel := context.WithCancel(context.Background())
+
+	for i, block := range content.blocks {
+		wg.Add(1)
+		go func(i int, b Block) {
+			defer wg.Done()
+
+			img, err := b.Render()
+			if err != nil {
+				select {
+				case errCh <- err:
+					cancel()
+				default:
+					log.Err(err).Any("type", b.content.Type()).Msg("unhandled error while rendering a block")
+				}
+				return
+			}
+			mx.Lock()
+			images[i] = img
+			mx.Unlock()
+		}(i, block)
+	}
+	go func() {
+		wg.Wait()
+		cancel()
+		close(errCh)
+	}()
+
+	select {
+	case <-ctx.Done():
+		return renderImages(images, style)
+	case err := <-errCh:
+		return nil, err
+	}
+}
+
 func (content contentBlocks) Type() blockContentType {
 	return BlockContentTypeBlocks
 }
@@ -120,6 +179,10 @@ func NewImageContent(style Style, image image.Image) Block {
 }
 
 func (content contentImage) Render(style Style) (image.Image, error) {
+	if content.image == nil {
+		return nil, errors.New("image content cannot be nil")
+	}
+
 	if style.Width == 0 {
 		style.Width = float64(content.image.Bounds().Dx())
 	}
diff --git a/internal/stats/render/common/v1/constants.go b/internal/stats/render/common/v1/constants.go
deleted file mode 100644
index bc1c3a25..00000000
--- a/internal/stats/render/common/v1/constants.go
+++ /dev/null
@@ -1,75 +0,0 @@
-package common
-
-import (
-	"image/color"
-
-	"github.com/golang/freetype/truetype"
-	"github.com/pkg/errors"
-	"golang.org/x/image/font"
-
-	"github.com/cufee/aftermath/internal/stats/render/assets"
-)
-
-var DiscordBackgroundColor = color.RGBA{49, 51, 56, 255}
-
-var (
-	FontXL     Font
-	Font2XL    Font
-	FontLarge  Font
-	FontMedium Font
-	FontSmall  Font
-
-	TextPrimary   = color.RGBA{255, 255, 255, 255}
-	TextSecondary = color.RGBA{204, 204, 204, 255}
-	TextAlt       = color.RGBA{150, 150, 150, 255}
-
-	TextSubscriptionPlus    = color.RGBA{72, 167, 250, 255}
-	TextSubscriptionPremium = color.RGBA{255, 223, 0, 255}
-
-	DefaultCardColor        = color.RGBA{10, 10, 10, 180}
-	DefaultCardColorNoAlpha = color.RGBA{10, 10, 10, 255}
-
-	ColorAftermathRed  = color.RGBA{255, 0, 120, 255}
-	ColorAftermathBlue = color.RGBA{90, 90, 255, 255}
-
-	BorderRadiusLG = 25.0
-	BorderRadiusMD = 20.0
-	BorderRadiusSM = 15.0
-	BorderRadiusXS = 10.0
-)
-
-type Font struct {
-	size float64
-	data []byte
-}
-
-func (f *Font) Valid() bool {
-	return f.data != nil && f.size > 0
-}
-
-func (f *Font) Face() font.Face {
-	ttf, _ := truetype.Parse(f.data)
-	return truetype.NewFace(ttf, &truetype.Options{
-		Size: f.size,
-	})
-}
-
-// var fontCache map[float64]font.Face
-
-func InitLoadedAssets() error {
-	// var ok bool
-	// fontCache, ok = assets.GetLoadedFontFaces("default", 36, 32, 24, 18, 14)
-	fontData, ok := assets.GetLoadedFontFace("default")
-	if !ok {
-		return errors.New("default font not found")
-	}
-
-	FontXL = Font{32, fontData}
-	Font2XL = Font{36, fontData}
-
-	FontLarge = Font{24, fontData}
-	FontMedium = Font{18, fontData}
-	FontSmall = Font{14, fontData}
-
-	return nil
-}
diff --git a/internal/stats/render/common/v1/font.go b/internal/stats/render/common/v1/font.go
new file mode 100644
index 00000000..6d548c4b
--- /dev/null
+++ b/internal/stats/render/common/v1/font.go
@@ -0,0 +1,26 @@
+package common
+
+import (
+	"github.com/golang/freetype/truetype"
+	"golang.org/x/image/font"
+)
+
+type Font struct {
+	size float64
+	data []byte
+}
+
+func (f *Font) Size() float64 {
+	return f.size
+}
+
+func (f *Font) Valid() bool {
+	return f.data != nil && f.size > 0
+}
+
+func (f *Font) Face() font.Face {
+	ttf, _ := truetype.Parse(f.data)
+	return truetype.NewFace(ttf, &truetype.Options{
+		Size: f.size,
+	})
+}
diff --git a/internal/stats/render/common/v1/footer.go b/internal/stats/render/common/v1/footer.go
index 16cff210..0bf10acf 100644
--- a/internal/stats/render/common/v1/footer.go
+++ b/internal/stats/render/common/v1/footer.go
@@ -12,5 +12,5 @@ func NewFooterCard(text string) Block {
 		BackgroundColor: backgroundColor,
 		BorderRadius:    BorderRadiusSM,
 		// Debug:           true,
-	}, NewTextContent(Style{Font: FontSmall, FontColor: TextSecondary}, text))
+	}, NewTextContent(Style{Font: FontSmall(), FontColor: TextSecondary}, text))
 }
diff --git a/internal/stats/render/common/v1/header.go b/internal/stats/render/common/v1/header.go
index fc599a61..fb891b27 100644
--- a/internal/stats/render/common/v1/header.go
+++ b/internal/stats/render/common/v1/header.go
@@ -22,7 +22,7 @@ func NewHeaderCard(width float64, subscriptions []models.UserSubscription, promo
 		// Users without a subscription get promo text
 		var textBlocks []Block
 		for _, text := range promoText {
-			textBlocks = append(textBlocks, NewTextContent(Style{Font: FontMedium, FontColor: TextPrimary}, text))
+			textBlocks = append(textBlocks, NewTextContent(Style{Font: FontMedium(), FontColor: TextPrimary}, text))
 		}
 		cards = append(cards, NewBlocksContent(Style{
 			Direction:  DirectionVertical,
diff --git a/internal/stats/render/common/v1/images.go b/internal/stats/render/common/v1/images.go
index 4074fb5e..c28f1ef7 100644
--- a/internal/stats/render/common/v1/images.go
+++ b/internal/stats/render/common/v1/images.go
@@ -34,7 +34,7 @@ func AddBackground(content, background image.Image, style Style) image.Image {
 }
 
 func renderImages(images []image.Image, style Style) (image.Image, error) {
-	if len(images) == 0 {
+	if len(images) < 1 {
 		return nil, errors.New("no images to render")
 	}
 
diff --git a/internal/stats/render/common/v1/init.go b/internal/stats/render/common/v1/init.go
new file mode 100644
index 00000000..3d14784c
--- /dev/null
+++ b/internal/stats/render/common/v1/init.go
@@ -0,0 +1,167 @@
+package common
+
+import (
+	"image/color"
+
+	"github.com/pkg/errors"
+
+	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/stats/render/assets"
+)
+
+var DiscordBackgroundColor = color.RGBA{49, 51, 56, 255}
+
+var (
+	FontXL     func() Font
+	Font2XL    func() Font
+	FontLarge  func() Font
+	FontMedium func() Font
+	FontSmall  func() Font
+
+	TextPrimary   = color.RGBA{255, 255, 255, 255}
+	TextSecondary = color.RGBA{204, 204, 204, 255}
+	TextAlt       = color.RGBA{150, 150, 150, 255}
+
+	TextSubscriptionPlus    = color.RGBA{72, 167, 250, 255}
+	TextSubscriptionPremium = color.RGBA{255, 223, 0, 255}
+
+	DefaultCardColor        = color.RGBA{10, 10, 10, 180}
+	DefaultCardColorNoAlpha = color.RGBA{10, 10, 10, 255}
+
+	ColorAftermathRed  = color.RGBA{255, 0, 120, 255}
+	ColorAftermathBlue = color.RGBA{90, 90, 255, 255}
+
+	BorderRadiusLG = 25.0
+	BorderRadiusMD = 20.0
+	BorderRadiusSM = 15.0
+	BorderRadiusXS = 10.0
+)
+
+var (
+	subscriptionWeight = map[models.SubscriptionType]int{
+		models.SubscriptionTypeDeveloper: 999,
+		// Moderators
+		models.SubscriptionTypeServerModerator:  99,
+		models.SubscriptionTypeContentModerator: 98,
+		// Paid
+		models.SubscriptionTypePro:     89,
+		models.SubscriptionTypeProClan: 88,
+		models.SubscriptionTypePlus:    79,
+		//
+		models.SubscriptionTypeSupporter:     29,
+		models.SubscriptionTypeServerBooster: 28,
+		//
+		models.SubscriptionTypeVerifiedClan: 19,
+	}
+)
+
+var (
+	userSubscriptionSupporter, userSubscriptionPlus, userSubscriptionPro, clanSubscriptionVerified, clanSubscriptionPro, subscriptionDeveloper, subscriptionServerModerator, subscriptionContentModerator, subscriptionServerBooster, subscriptionTranslator *subscriptionHeader
+)
+
+func InitLoadedAssets() error {
+	fontData, ok := assets.GetLoadedFontFace("default")
+	if !ok {
+		return errors.New("default font not found")
+	}
+
+	FontXL = func() Font { return Font{size: 32, data: fontData} }
+	Font2XL = func() Font { return Font{size: 36, data: fontData} }
+
+	FontLarge = func() Font { return Font{size: 24, data: fontData} }
+	FontMedium = func() Font { return Font{size: 18, data: fontData} }
+	FontSmall = func() Font { return Font{size: 14, data: fontData} }
+
+	// Personal
+	userSubscriptionSupporter = &subscriptionHeader{
+		Name: "Supporter",
+		Icon: "images/icons/fire",
+		Style: subscriptionPillStyle{
+			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: DefaultCardColorNoAlpha, BorderRadius: 15, PaddingX: 7, PaddingY: 5, Height: 32},
+			Icon:      Style{Width: 16, Height: 16, BackgroundColor: TextSubscriptionPlus},
+			Text:      Style{Font: FontSmall(), FontColor: TextSecondary, PaddingX: 5},
+		},
+	}
+	userSubscriptionPlus = &subscriptionHeader{
+		Name: "Aftermath+",
+		Icon: "images/icons/star",
+		Style: subscriptionPillStyle{
+			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: DefaultCardColorNoAlpha, BorderRadius: 15, PaddingX: 5, PaddingY: 5, Height: 32},
+			Icon:      Style{Width: 24, Height: 24, BackgroundColor: TextSubscriptionPlus},
+			Text:      Style{Font: FontSmall(), FontColor: TextSecondary, PaddingX: 5},
+		},
+	}
+	userSubscriptionPro = &subscriptionHeader{
+		Name: "Aftermath Pro",
+		Icon: "images/icons/star",
+		Style: subscriptionPillStyle{
+			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: DefaultCardColorNoAlpha, BorderRadius: 15, PaddingX: 5, PaddingY: 5, Height: 32},
+			Icon:      Style{Width: 24, Height: 24, BackgroundColor: TextSubscriptionPremium},
+			Text:      Style{Font: FontSmall(), FontColor: TextSecondary, PaddingX: 5},
+		},
+	}
+	// Clans
+	clanSubscriptionVerified = &subscriptionHeader{
+		Icon: "images/icons/verify",
+		Style: subscriptionPillStyle{
+			Icon:      Style{Width: 28, Height: 28, BackgroundColor: TextAlt},
+			Container: Style{Direction: DirectionHorizontal},
+		},
+	}
+	clanSubscriptionPro = &subscriptionHeader{
+		Icon: "images/icons/star-multiple",
+		Style: subscriptionPillStyle{
+			Icon:      Style{Width: 28, Height: 28, BackgroundColor: TextAlt},
+			Container: Style{Direction: DirectionHorizontal},
+		},
+	}
+
+	// Community
+	subscriptionDeveloper = &subscriptionHeader{
+		Name: "Developer",
+		Icon: "images/icons/github",
+		Style: subscriptionPillStyle{
+			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: color.RGBA{64, 32, 128, 180}, BorderRadius: 15, PaddingX: 6, PaddingY: 5, Gap: 5, Height: 32},
+			Icon:      Style{Width: 20, Height: 20, BackgroundColor: TextPrimary},
+			Text:      Style{Font: FontSmall(), FontColor: TextPrimary, PaddingX: 5},
+		},
+	}
+	subscriptionServerModerator = &subscriptionHeader{
+		Name: "Community Moderator",
+		Icon: "images/icons/logo-128",
+		Style: subscriptionPillStyle{
+			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: DefaultCardColorNoAlpha, BorderRadius: 15, PaddingX: 7, PaddingY: 5, Gap: 5, Height: 32},
+			Icon:      Style{Width: 20, Height: 20},
+			Text:      Style{Font: FontSmall(), FontColor: TextSecondary, PaddingX: 2},
+		},
+	}
+	subscriptionContentModerator = &subscriptionHeader{
+		Name: "Moderator",
+		Icon: "images/icons/logo-128",
+		Style: subscriptionPillStyle{
+			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: DefaultCardColorNoAlpha, BorderRadius: 15, PaddingX: 7, PaddingY: 5, Gap: 5, Height: 32},
+			Icon:      Style{Width: 20, Height: 20},
+			Text:      Style{Font: FontSmall(), FontColor: TextSecondary, PaddingX: 2},
+		},
+	}
+	subscriptionServerBooster = &subscriptionHeader{
+		Name: "Booster",
+		Icon: "images/icons/discord-booster",
+		Style: subscriptionPillStyle{
+			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: DefaultCardColorNoAlpha, BorderRadius: 15, PaddingX: 10, PaddingY: 5, Gap: 5, Height: 32},
+			Icon:      Style{Width: 20, Height: 20},
+			Text:      Style{Font: FontSmall(), FontColor: TextSecondary},
+		},
+	}
+	subscriptionTranslator = &subscriptionHeader{
+		Name: "Translator",
+		Icon: "images/icons/translator",
+		Style: subscriptionPillStyle{
+			Container: Style{Direction: DirectionHorizontal, AlignItems: AlignItemsCenter, BackgroundColor: DefaultCardColorNoAlpha, BorderRadius: 15, PaddingX: 10, PaddingY: 5, Gap: 5, Height: 32},
+			Icon:      Style{Width: 20, Height: 20, BackgroundColor: TextPrimary},
+			Text:      Style{Font: FontSmall(), FontColor: TextSecondary},
+		},
+	}
+
+	return nil
+}
diff --git a/internal/stats/render/common/v1/player_title.go b/internal/stats/render/common/v1/player_title.go
index eceb3f6f..22601331 100644
--- a/internal/stats/render/common/v1/player_title.go
+++ b/internal/stats/render/common/v1/player_title.go
@@ -29,8 +29,8 @@ func DefaultPlayerTitleStyle(containerStyle Style) TitleCardStyle {
 
 	return TitleCardStyle{
 		Container: containerStyle,
-		Nickname:  Style{Font: FontLarge, FontColor: TextPrimary},
-		ClanTag:   Style{Font: FontMedium, FontColor: TextSecondary, PaddingX: 10, PaddingY: 5, BackgroundColor: clanTagBackgroundColor, BorderRadius: BorderRadiusSM},
+		Nickname:  Style{Font: FontLarge(), FontColor: TextPrimary},
+		ClanTag:   Style{Font: FontMedium(), FontColor: TextSecondary, PaddingX: 10, PaddingY: 5, BackgroundColor: clanTagBackgroundColor, BorderRadius: BorderRadiusSM},
 	}
 }
 
@@ -71,7 +71,7 @@ func newClanTagBlock(style Style, clanTag string, subs []models.UserSubscription
 	}
 
 	var blocks []Block
-	blocks = append(blocks, NewTextContent(Style{Font: FontMedium, FontColor: TextSecondary}, clanTag))
+	blocks = append(blocks, NewTextContent(Style{Font: FontMedium(), FontColor: TextSecondary}, clanTag))
 	if sub := ClanSubscriptionsBadges(subs); sub != nil {
 		iconBlock, err := sub.Block()
 		if err == nil {
diff --git a/internal/stats/render/common/v1/tier_percentage.go b/internal/stats/render/common/v1/tier_percentage.go
index 2a6eabaf..96f19f1a 100644
--- a/internal/stats/render/common/v1/tier_percentage.go
+++ b/internal/stats/render/common/v1/tier_percentage.go
@@ -25,7 +25,7 @@ func NewTierPercentageCard(style Style, vehicles map[string]frame.VehicleStatsFr
 			BackgroundColor: shade,
 			Width:           style.Width / float64(elements),
 			JustifyContent:  JustifyContentCenter,
-		}, NewTextContent(Style{Font: FontMedium, FontColor: TextPrimary}, fmt.Sprint(i))))
+		}, NewTextContent(Style{Font: FontMedium(), FontColor: TextPrimary}, fmt.Sprint(i))))
 	}
 
 	return NewBlocksContent(style, blocks...)
diff --git a/internal/stats/render/period/v1/constants.go b/internal/stats/render/period/v1/constants.go
index 4534c18e..1418e0a3 100644
--- a/internal/stats/render/period/v1/constants.go
+++ b/internal/stats/render/period/v1/constants.go
@@ -22,11 +22,11 @@ type highlightStyle struct {
 func (s *overviewStyle) block(block prepare.StatsBlock[period.BlockData]) (common.Style, common.Style) {
 	switch block.Data.Flavor {
 	case period.BlockFlavorSpecial:
-		return common.Style{FontColor: common.TextPrimary, Font: common.FontXL}, common.Style{FontColor: common.TextAlt, Font: common.FontSmall}
+		return common.Style{FontColor: common.TextPrimary, Font: common.FontXL()}, common.Style{FontColor: common.TextAlt, Font: common.FontSmall()}
 	case period.BlockFlavorSecondary:
-		return common.Style{FontColor: common.TextSecondary, Font: common.FontMedium}, common.Style{FontColor: common.TextAlt, Font: common.FontSmall}
+		return common.Style{FontColor: common.TextSecondary, Font: common.FontMedium()}, common.Style{FontColor: common.TextAlt, Font: common.FontSmall()}
 	default:
-		return common.Style{FontColor: common.TextPrimary, Font: common.FontLarge}, common.Style{FontColor: common.TextAlt, Font: common.FontSmall}
+		return common.Style{FontColor: common.TextPrimary, Font: common.FontLarge()}, common.Style{FontColor: common.TextAlt, Font: common.FontSmall()}
 	}
 }
 
@@ -92,9 +92,9 @@ func highlightCardStyle(containerStyle common.Style) highlightStyle {
 
 	return highlightStyle{
 		container:  container,
-		cardTitle:  common.Style{Font: common.FontSmall, FontColor: common.TextSecondary},
-		tankName:   common.Style{Font: common.FontMedium, FontColor: common.TextPrimary},
-		blockValue: common.Style{Font: common.FontMedium, FontColor: common.TextPrimary},
-		blockLabel: common.Style{Font: common.FontSmall, FontColor: common.TextAlt},
+		cardTitle:  common.Style{Font: common.FontSmall(), FontColor: common.TextSecondary},
+		tankName:   common.Style{Font: common.FontMedium(), FontColor: common.TextPrimary},
+		blockValue: common.Style{Font: common.FontMedium(), FontColor: common.TextPrimary},
+		blockLabel: common.Style{Font: common.FontSmall(), FontColor: common.TextAlt},
 	}
 }
diff --git a/internal/stats/render/session/v1/blocks.go b/internal/stats/render/session/v1/blocks.go
index 6dba350c..64220f45 100644
--- a/internal/stats/render/session/v1/blocks.go
+++ b/internal/stats/render/session/v1/blocks.go
@@ -13,6 +13,7 @@ import (
 )
 
 func makeSpecialRatingColumn(block prepare.StatsBlock[session.BlockData], width float64) common.Block {
+	blockStyle := vehicleBlockStyle()
 	switch block.Tag {
 	case prepare.TagWN8:
 		ratingColors := common.GetWN8Colors(block.Value.Float())
@@ -30,13 +31,13 @@ func makeSpecialRatingColumn(block prepare.StatsBlock[session.BlockData], width
 			pillColor = color.Transparent
 		}
 		column = append(column, common.NewBlocksContent(overviewColumnStyle(width),
-			common.NewTextContent(vehicleBlockStyle.session, block.Data.Session.String()),
+			common.NewTextContent(blockStyle.session, block.Data.Session.String()),
 			common.NewBlocksContent(
 				overviewSpecialRatingPillStyle(pillColor),
 				common.NewTextContent(overviewSpecialRatingLabelStyle(ratingColors.Content), common.GetWN8TierName(block.Value.Float())),
 			),
 		))
-		return common.NewBlocksContent(specialRatingColumnStyle, column...)
+		return common.NewBlocksContent(specialRatingColumnStyle(), column...)
 
 	case prepare.TagRankedRating:
 		var column []common.Block
@@ -45,15 +46,14 @@ func makeSpecialRatingColumn(block prepare.StatsBlock[session.BlockData], width
 			column = append(column, icon)
 		}
 		column = append(column, common.NewBlocksContent(overviewColumnStyle(width),
-			blockWithDoubleVehicleIcon(common.NewTextContent(vehicleBlockStyle.session, block.Data.Session.String()), block.Data.Session, block.Data.Career),
+			blockWithDoubleVehicleIcon(common.NewTextContent(blockStyle.session, block.Data.Session.String()), block.Data.Session, block.Data.Career),
 		))
-		return common.NewBlocksContent(specialRatingColumnStyle, column...)
+		return common.NewBlocksContent(specialRatingColumnStyle(), column...)
 
 	default:
 		return common.NewBlocksContent(statsBlockStyle(width),
-			common.NewTextContent(vehicleBlockStyle.session, block.Data.Session.String()),
-			// common.NewTextContent(vehicleBlockStyle.career, block.Data.Career.String()),
-			common.NewTextContent(vehicleBlockStyle.label, block.Label),
+			common.NewTextContent(blockStyle.session, block.Data.Session.String()),
+			common.NewTextContent(blockStyle.label, block.Label),
 		)
 	}
 }
diff --git a/internal/stats/render/session/v1/cards.go b/internal/stats/render/session/v1/cards.go
index ff530a8e..9e1a344a 100644
--- a/internal/stats/render/session/v1/cards.go
+++ b/internal/stats/render/session/v1/cards.go
@@ -61,7 +61,7 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 	}
 	{
 		for _, text := range opts.PromoText {
-			size := common.MeasureString(text, promoTextStyle.Font)
+			size := common.MeasureString(text, promoTextStyle().Font)
 			totalFrameWidth = common.Max(size.TotalWidth, totalFrameWidth)
 		}
 	}
@@ -69,7 +69,7 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 	if shouldRenderUnratedOverview {
 		var totalContentWidth float64 = overviewCardStyle(0).Gap * float64(len(cards.Unrated.Overview.Blocks)-1)
 		for _, column := range cards.Unrated.Overview.Blocks {
-			styleWithIconOffset := overviewStatsBlockStyle
+			styleWithIconOffset := overviewStatsBlockStyle()
 			styleWithIconOffset.session.PaddingX += vehicleComparisonIconSize
 
 			presetBlockWidth, contentWidth := overviewColumnBlocksWidth(column, styleWithIconOffset.session, styleWithIconOffset.career, styleWithIconOffset.label, overviewColumnStyle(0))
@@ -84,7 +84,7 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 	if shouldRenderRatingOverview {
 		var totalContentWidth float64 = overviewCardStyle(0).Gap * float64(len(cards.Rating.Overview.Blocks)-1)
 		for _, column := range cards.Unrated.Overview.Blocks {
-			styleWithIconOffset := overviewStatsBlockStyle
+			styleWithIconOffset := overviewStatsBlockStyle()
 			styleWithIconOffset.session.PaddingX += vehicleComparisonIconSize
 
 			presetBlockWidth, contentWidth := overviewColumnBlocksWidth(column, styleWithIconOffset.session, styleWithIconOffset.career, styleWithIconOffset.label, overviewColumnStyle(0))
@@ -99,8 +99,9 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 	if shouldRenderRatingVehicles {
 		for _, card := range cards.Rating.Vehicles {
 			// [title] [session]
-			titleSize := common.MeasureString(card.Title, ratingVehicleCardTitleStyle.Font)
-			presetBlockWidth, contentWidth := vehicleBlocksWidth(card.Blocks, ratingVehicleBlockStyle.session, ratingVehicleBlockStyle.career, ratingVehicleBlockStyle.label, ratingVehicleBlocksRowStyle(0))
+			style := ratingVehicleBlockStyle()
+			titleSize := common.MeasureString(card.Title, ratingVehicleCardTitleStyle().Font)
+			presetBlockWidth, contentWidth := vehicleBlocksWidth(card.Blocks, style.session, style.career, style.label, ratingVehicleBlocksRowStyle(0))
 			// add the gap and card padding, the gap here accounts for title being inline with content
 			contentWidth += ratingVehicleBlocksRowStyle(0).Gap*float64(len(card.Blocks)) + ratingVehicleCardStyle(0).PaddingX*2 + titleSize.TotalWidth
 
@@ -115,10 +116,12 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 		for _, card := range cards.Unrated.Highlights {
 			// [card label] [session]
 			// [title]  	  [label]
-			labelSize := common.MeasureString(card.Meta, highlightCardTitleTextStyle.Font)
-			titleSize := common.MeasureString(card.Title, highlightVehicleNameTextStyle.Font)
+			titleStyle := highlightCardTitleTextStyle()
+			labelSize := common.MeasureString(card.Meta, titleStyle.Font)
+			titleSize := common.MeasureString(card.Title, titleStyle.Font)
 
-			presetBlockWidth, contentWidth := highlightedVehicleBlocksWidth(card.Blocks, vehicleBlockStyle.session, vehicleBlockStyle.career, vehicleBlockStyle.label, highlightedVehicleBlockRowStyle(0))
+			style := vehicleBlockStyle()
+			presetBlockWidth, contentWidth := highlightedVehicleBlocksWidth(card.Blocks, style.session, style.career, style.label, highlightedVehicleBlockRowStyle(0))
 			// add the gap and card padding, the gap here accounts for title/label being inline with content
 			contentWidth += highlightedVehicleBlockRowStyle(0).Gap*float64(len(card.Blocks)) + highlightedVehicleCardStyle(0).Gap + highlightedVehicleCardStyle(0).PaddingX*2 + common.Max(titleSize.TotalWidth, labelSize.TotalWidth)
 			primaryCardWidth = common.Max(primaryCardWidth, contentWidth)
@@ -134,7 +137,7 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 			// [session]
 			// [career ]
 
-			styleWithIconOffset := vehicleBlockStyle
+			styleWithIconOffset := vehicleBlockStyle()
 			// icon is only on one side, so we divide by 2
 			styleWithIconOffset.label.PaddingX += vehicleComparisonIconSize / 2
 			styleWithIconOffset.session.PaddingX += vehicleComparisonIconSize / 2
@@ -142,7 +145,7 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 			presetBlockWidth, contentWidth := vehicleBlocksWidth(card.Blocks, styleWithIconOffset.session, styleWithIconOffset.career, styleWithIconOffset.label, vehicleBlocksRowStyle(0))
 			contentWidth += vehicleBlocksRowStyle(0).Gap*float64(len(card.Blocks)-1) + vehicleCardStyle(0).PaddingX*2
 
-			titleSize := common.MeasureString(card.Title, vehicleCardTitleTextStyle.Font)
+			titleSize := common.MeasureString(card.Title, vehicleCardTitleTextStyle().Font)
 			secondaryCardWidth = common.Max(secondaryCardWidth, contentWidth, titleSize.TotalWidth+vehicleCardStyle(0).PaddingX*2)
 
 			for key, width := range presetBlockWidth {
@@ -188,20 +191,24 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 	}
 
 	// player title
+	println("making player title")
 	primaryColumn = append(primaryColumn,
 		common.NewPlayerTitleCard(common.DefaultPlayerTitleStyle(playerNameCardStyle(primaryCardWidth)), session.Account.Nickname, session.Account.ClanTag, subs),
 	)
 
 	// overview cards
 	if shouldRenderUnratedOverview {
+		println("making unrated overview")
 		primaryColumn = append(primaryColumn, makeOverviewCard(cards.Unrated.Overview, primaryCardBlockSizes, overviewCardStyle(primaryCardWidth)))
 	}
 	if shouldRenderRatingOverview {
+		println("making rating overview")
 		primaryColumn = append(primaryColumn, makeOverviewCard(cards.Rating.Overview, primaryCardBlockSizes, overviewRatingCardStyle(primaryCardWidth)))
 	}
 
 	// highlights
 	if shouldRenderUnratedHighlights {
+		println("making highlights")
 		for _, vehicle := range cards.Unrated.Highlights {
 			primaryColumn = append(primaryColumn, makeVehicleHighlightCard(vehicle, highlightCardBlockSizes, primaryCardWidth))
 		}
@@ -213,6 +220,7 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 
 	// unrated vehicles
 	if shouldRenderUnratedVehicles {
+		println("making unrated vehicles")
 		for i, vehicle := range cards.Unrated.Vehicles {
 			if i >= renderVehiclesCount {
 				break
@@ -315,16 +323,17 @@ func makeVehicleCard(vehicle session.VehicleCard, blockSizes map[string]float64,
 	var vehicleWN8 frame.Value = frame.InvalidValue
 	var content []common.Block
 	for _, block := range vehicle.Blocks {
+		style := vehicleBlockStyle()
 		var blockContent []common.Block
 		if blockShouldHaveCompareIcon(block) {
-			blockContent = append(blockContent, blockWithVehicleIcon(common.NewTextContent(vehicleBlockStyle.session, block.Data.Session.String()), block.Data.Session, block.Data.Career))
+			blockContent = append(blockContent, blockWithVehicleIcon(common.NewTextContent(style.session, block.Data.Session.String()), block.Data.Session, block.Data.Career))
 		} else {
-			blockContent = append(blockContent, common.NewTextContent(vehicleBlockStyle.session, block.Data.Session.String()))
+			blockContent = append(blockContent, common.NewTextContent(style.session, block.Data.Session.String()))
 		}
 
-		style := statsBlockStyle(blockSizes[block.Tag.String()])
+		containerStyle := statsBlockStyle(blockSizes[block.Tag.String()])
 		content = append(content,
-			common.NewBlocksContent(style, blockContent...),
+			common.NewBlocksContent(containerStyle, blockContent...),
 		)
 
 		if block.Tag == prepare.TagWN8 {
@@ -336,7 +345,7 @@ func makeVehicleCard(vehicle session.VehicleCard, blockSizes map[string]float64,
 	titleStyle.Width -= vehicleCardStyle(0).PaddingX * 2
 	return common.NewBlocksContent(vehicleCardStyle(cardWidth),
 		common.NewBlocksContent(titleStyle,
-			common.NewTextContent(vehicleCardTitleTextStyle, fmt.Sprintf("%s %s", vehicle.Meta, vehicle.Title)), // name and tier
+			common.NewTextContent(vehicleCardTitleTextStyle(), fmt.Sprintf("%s %s", vehicle.Meta, vehicle.Title)), // name and tier
 			vehicleWN8Icon(vehicleWN8),
 		),
 		common.NewBlocksContent(vehicleBlocksRowStyle(0), content...),
@@ -345,19 +354,20 @@ func makeVehicleCard(vehicle session.VehicleCard, blockSizes map[string]float64,
 
 func makeVehicleHighlightCard(vehicle session.VehicleCard, blockSizes map[string]float64, cardWidth float64) common.Block {
 	var content []common.Block
+	style := vehicleBlockStyle()
 	for _, block := range vehicle.Blocks {
 		content = append(content,
 			common.NewBlocksContent(statsBlockStyle(blockSizes[block.Tag.String()]),
-				common.NewTextContent(vehicleBlockStyle.session, block.Data.Session.String()),
-				common.NewTextContent(vehicleBlockStyle.label, block.Label),
+				common.NewTextContent(style.session, block.Data.Session.String()),
+				common.NewTextContent(style.label, block.Label),
 			),
 		)
 	}
 
 	return common.NewBlocksContent(highlightedVehicleCardStyle(cardWidth),
 		common.NewBlocksContent(common.Style{Direction: common.DirectionVertical},
-			common.NewTextContent(highlightCardTitleTextStyle, vehicle.Meta),
-			common.NewTextContent(highlightVehicleNameTextStyle, vehicle.Title),
+			common.NewTextContent(highlightCardTitleTextStyle(), vehicle.Meta),
+			common.NewTextContent(highlightVehicleNameTextStyle(), vehicle.Title),
 		),
 		common.NewBlocksContent(highlightedVehicleBlockRowStyle(0), content...),
 	)
@@ -365,42 +375,45 @@ func makeVehicleHighlightCard(vehicle session.VehicleCard, blockSizes map[string
 
 func makeVehicleLegendCard(reference session.VehicleCard, blockSizes map[string]float64, cardWidth float64) common.Block {
 	var content []common.Block
+	style := vehicleBlockStyle()
 	for _, block := range reference.Blocks {
-		label := common.NewBlocksContent(vehicleLegendLabelContainer, common.NewTextContent(vehicleBlockStyle.label, block.Label))
+		label := common.NewBlocksContent(vehicleLegendLabelContainer, common.NewTextContent(style.label, block.Label))
 		if blockShouldHaveCompareIcon(block) {
-			label = blockWithVehicleIcon(common.NewBlocksContent(vehicleLegendLabelContainer, common.NewTextContent(vehicleBlockStyle.label, block.Label)), frame.InvalidValue, frame.InvalidValue)
+			label = blockWithVehicleIcon(common.NewBlocksContent(vehicleLegendLabelContainer, common.NewTextContent(style.label, block.Label)), frame.InvalidValue, frame.InvalidValue)
 		}
 		containerStyle := statsBlockStyle(blockSizes[block.Tag.String()])
 		content = append(content,
 			common.NewBlocksContent(containerStyle, label),
 		)
 	}
-	style := vehicleCardStyle(cardWidth)
-	style.BackgroundColor = nil
-	style.PaddingY = 0
-	style.PaddingX = 0
-	return common.NewBlocksContent(style, common.NewBlocksContent(vehicleBlocksRowStyle(0), content...))
+	containerStyle := vehicleCardStyle(cardWidth)
+	containerStyle.BackgroundColor = nil
+	containerStyle.PaddingY = 0
+	containerStyle.PaddingX = 0
+	return common.NewBlocksContent(containerStyle, common.NewBlocksContent(vehicleBlocksRowStyle(0), content...))
 }
 
 func makeOverviewCard(card session.OverviewCard, blockSizes map[string]float64, style common.Style) common.Block {
 	// made all columns the same width for things to be centered
 	columnWidth := (style.Width - style.Gap*float64(len(card.Blocks)-1) - style.PaddingX*2) / float64(len(card.Blocks))
 	var content []common.Block // add a blank block to balance the offset added from icons
+	blockStyle := vehicleBlockStyle()
 	for _, column := range card.Blocks {
 		var columnContent []common.Block
 		for _, block := range column {
+			println("making block", block.Label)
 			var col common.Block
 			if block.Tag == prepare.TagWN8 || block.Tag == prepare.TagRankedRating {
 				col = makeSpecialRatingColumn(block, blockSizes[block.Tag.String()])
 			} else if blockShouldHaveCompareIcon(block) {
 				col = common.NewBlocksContent(statsBlockStyle(blockSizes[block.Tag.String()]),
-					blockWithDoubleVehicleIcon(common.NewTextContent(vehicleBlockStyle.session, block.Data.Session.String()), block.Data.Session, block.Data.Career),
-					common.NewTextContent(vehicleBlockStyle.label, block.Label),
+					blockWithDoubleVehicleIcon(common.NewTextContent(blockStyle.session, block.Data.Session.String()), block.Data.Session, block.Data.Career),
+					common.NewTextContent(blockStyle.label, block.Label),
 				)
 			} else {
 				col = common.NewBlocksContent(statsBlockStyle(blockSizes[block.Tag.String()]),
-					common.NewTextContent(vehicleBlockStyle.session, block.Data.Session.String()),
-					common.NewTextContent(vehicleBlockStyle.label, block.Label),
+					common.NewTextContent(blockStyle.session, block.Data.Session.String()),
+					common.NewTextContent(blockStyle.label, block.Label),
 				)
 			}
 			columnContent = append(columnContent, col)
diff --git a/internal/stats/render/session/v1/constants.go b/internal/stats/render/session/v1/constants.go
index 8215b2e9..bdbfd3e1 100644
--- a/internal/stats/render/session/v1/constants.go
+++ b/internal/stats/render/session/v1/constants.go
@@ -19,25 +19,27 @@ var (
 	minPrimaryCardWidth       = 300.0 // making the primary card too small looks bad if there are no battles in a session
 )
 
-var (
-	specialRatingColumnStyle = common.Style{Direction: common.DirectionVertical, AlignItems: common.AlignItemsCenter, Gap: 5}
-	promoTextStyle           = common.Style{Font: common.FontMedium, FontColor: common.TextPrimary}
-)
+func specialRatingColumnStyle() common.Style {
+	return common.Style{Direction: common.DirectionVertical, AlignItems: common.AlignItemsCenter, Gap: 5}
+}
+func promoTextStyle() common.Style {
+	return common.Style{Font: common.FontMedium(), FontColor: common.TextPrimary}
+}
 
 func frameStyle() common.Style {
 	return common.Style{Gap: 10, Direction: common.DirectionHorizontal}
 }
 
-var (
-	overviewStatsBlockStyle = blockStyle{
-		common.Style{Font: common.FontLarge, FontColor: common.TextPrimary},
-		common.Style{Font: common.FontMedium, FontColor: common.TextSecondary},
-		common.Style{Font: common.FontSmall, FontColor: common.TextAlt},
+func overviewStatsBlockStyle() blockStyle {
+	return blockStyle{
+		common.Style{Font: common.FontLarge(), FontColor: common.TextPrimary},
+		common.Style{Font: common.FontMedium(), FontColor: common.TextSecondary},
+		common.Style{Font: common.FontSmall(), FontColor: common.TextAlt},
 	}
-)
+}
 
 func overviewSpecialRatingLabelStyle(color color.Color) common.Style {
-	return common.Style{FontColor: color, Font: common.FontSmall}
+	return common.Style{FontColor: color, Font: common.FontSmall()}
 }
 
 func overviewSpecialRatingPillStyle(color color.Color) common.Style {
@@ -91,14 +93,19 @@ var (
 		PaddingY:        5,
 		PaddingX:        10,
 	}
-	vehicleCardTitleTextStyle = common.Style{Font: common.FontMedium, FontColor: common.TextAlt}
-	vehicleBlockStyle         = blockStyle{
-		common.Style{Font: common.FontLarge, FontColor: common.TextPrimary},
-		common.Style{Font: common.FontMedium, FontColor: common.TextSecondary},
-		common.Style{Font: common.FontSmall, FontColor: common.TextAlt},
-	}
 )
 
+func vehicleCardTitleTextStyle() common.Style {
+	return common.Style{Font: common.FontMedium(), FontColor: common.TextAlt}
+}
+func vehicleBlockStyle() blockStyle {
+	return blockStyle{
+		common.Style{Font: common.FontLarge(), FontColor: common.TextPrimary},
+		common.Style{Font: common.FontMedium(), FontColor: common.TextSecondary},
+		common.Style{Font: common.FontSmall(), FontColor: common.TextAlt},
+	}
+}
+
 func vehicleCardTitleContainerStyle(width float64) common.Style {
 	return common.Style{
 		JustifyContent: common.JustifyContentSpaceBetween,
@@ -130,15 +137,19 @@ func vehicleBlocksRowStyle(width float64) common.Style {
 	}
 }
 
-var (
-	ratingVehicleCardTitleContainerStyle = common.Style{Direction: common.DirectionHorizontal, Gap: 10, JustifyContent: common.JustifyContentSpaceBetween}
-	ratingVehicleCardTitleStyle          = common.Style{Font: common.FontMedium, FontColor: common.TextSecondary, PaddingX: 5}
-	ratingVehicleBlockStyle              = blockStyle{
-		common.Style{Font: common.FontLarge, FontColor: common.TextPrimary},
-		common.Style{Font: common.FontMedium, FontColor: common.TextSecondary},
-		common.Style{Font: common.FontSmall, FontColor: common.TextAlt},
+func ratingVehicleCardTitleContainerStyle() common.Style {
+	return common.Style{Direction: common.DirectionHorizontal, Gap: 10, JustifyContent: common.JustifyContentSpaceBetween}
+}
+func ratingVehicleCardTitleStyle() common.Style {
+	return common.Style{Font: common.FontMedium(), FontColor: common.TextSecondary, PaddingX: 5}
+}
+func ratingVehicleBlockStyle() blockStyle {
+	return blockStyle{
+		common.Style{Font: common.FontLarge(), FontColor: common.TextPrimary},
+		common.Style{Font: common.FontMedium(), FontColor: common.TextSecondary},
+		common.Style{Font: common.FontSmall(), FontColor: common.TextAlt},
 	}
-)
+}
 
 func ratingVehicleCardStyle(width float64) common.Style {
 	return defaultCardStyle(width)
@@ -148,10 +159,12 @@ func ratingVehicleBlocksRowStyle(width float64) common.Style {
 	return vehicleBlocksRowStyle(width)
 }
 
-var (
-	highlightCardTitleTextStyle   = common.Style{Font: common.FontSmall, FontColor: common.TextSecondary}
-	highlightVehicleNameTextStyle = common.Style{Font: common.FontMedium, FontColor: common.TextPrimary}
-)
+func highlightCardTitleTextStyle() common.Style {
+	return common.Style{Font: common.FontSmall(), FontColor: common.TextSecondary}
+}
+func highlightVehicleNameTextStyle() common.Style {
+	return common.Style{Font: common.FontMedium(), FontColor: common.TextPrimary}
+}
 
 func highlightedVehicleCardStyle(width float64) common.Style {
 	style := defaultCardStyle(width)

From 7c5c1850726cedd7b01411731866469263552c6c Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Wed, 26 Jun 2024 14:32:28 -0400
Subject: [PATCH 181/341] fixed width calculations

---
 internal/stats/render/session/v1/cards.go | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/internal/stats/render/session/v1/cards.go b/internal/stats/render/session/v1/cards.go
index 9e1a344a..14348137 100644
--- a/internal/stats/render/session/v1/cards.go
+++ b/internal/stats/render/session/v1/cards.go
@@ -116,14 +116,13 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 		for _, card := range cards.Unrated.Highlights {
 			// [card label] [session]
 			// [title]  	  [label]
-			titleStyle := highlightCardTitleTextStyle()
-			labelSize := common.MeasureString(card.Meta, titleStyle.Font)
-			titleSize := common.MeasureString(card.Title, titleStyle.Font)
+			labelSize := common.MeasureString(card.Meta, highlightCardTitleTextStyle().Font)
+			titleSize := common.MeasureString(card.Title, highlightVehicleNameTextStyle().Font)
 
 			style := vehicleBlockStyle()
 			presetBlockWidth, contentWidth := highlightedVehicleBlocksWidth(card.Blocks, style.session, style.career, style.label, highlightedVehicleBlockRowStyle(0))
 			// add the gap and card padding, the gap here accounts for title/label being inline with content
-			contentWidth += highlightedVehicleBlockRowStyle(0).Gap*float64(len(card.Blocks)) + highlightedVehicleCardStyle(0).Gap + highlightedVehicleCardStyle(0).PaddingX*2 + common.Max(titleSize.TotalWidth, labelSize.TotalWidth)
+			contentWidth += highlightedVehicleBlockRowStyle(0).Gap*float64(len(card.Blocks)-1) + highlightedVehicleCardStyle(0).Gap + highlightedVehicleCardStyle(0).PaddingX*2 + common.Max(titleSize.TotalWidth, labelSize.TotalWidth)
 			primaryCardWidth = common.Max(primaryCardWidth, contentWidth)
 
 			for key, width := range presetBlockWidth {
@@ -226,9 +225,9 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 				break
 			}
 			secondaryColumn = append(secondaryColumn, makeVehicleCard(vehicle, secondaryCardBlockSizes, secondaryCardWidth))
-			if i == len(cards.Unrated.Vehicles)-1 {
-				secondaryColumn = append(secondaryColumn, makeVehicleLegendCard(cards.Unrated.Vehicles[0], secondaryCardBlockSizes, secondaryCardWidth))
-			}
+		}
+		if len(cards.Unrated.Vehicles) > 0 {
+			secondaryColumn = append(secondaryColumn, makeVehicleLegendCard(cards.Unrated.Vehicles[0], secondaryCardBlockSizes, secondaryCardWidth))
 		}
 	}
 

From 869a0311eb6bddec9634a1d63692389902d04572 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Wed, 26 Jun 2024 14:42:49 -0400
Subject: [PATCH 182/341] cleaner card numbers

---
 internal/stats/render/session/v1/cards.go | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/internal/stats/render/session/v1/cards.go b/internal/stats/render/session/v1/cards.go
index 14348137..d0d59417 100644
--- a/internal/stats/render/session/v1/cards.go
+++ b/internal/stats/render/session/v1/cards.go
@@ -14,12 +14,12 @@ import (
 
 func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Cards, subs []models.UserSubscription, opts common.Options) (common.Segments, error) {
 	var (
-		renderVehiclesCount = 3 // minimum number of vehicle cards
+		renderUnratedVehiclesCount = 3 // minimum number of vehicle cards
 		// primary cards
 		// when there are some unrated battles or no battles at all
 		shouldRenderUnratedOverview = session.RegularBattles.Battles > 0 || session.RatingBattles.Battles == 0
 		// when there are 3 vehicle cards and no rating overview cards or there are 6 vehicle cards and some rating battles
-		shouldRenderUnratedHighlights = (session.RegularBattles.Battles > 0 && session.RatingBattles.Battles < 1 && len(cards.Unrated.Vehicles) > renderVehiclesCount) ||
+		shouldRenderUnratedHighlights = (session.RegularBattles.Battles > 0 && session.RatingBattles.Battles < 1 && len(cards.Unrated.Vehicles) > renderUnratedVehiclesCount) ||
 			(session.RegularBattles.Battles > 0 && len(cards.Unrated.Vehicles) > 6)
 		shouldRenderRatingOverview = session.RatingBattles.Battles > 0
 		shouldRenderRatingVehicles = len(cards.Unrated.Vehicles) == 0
@@ -28,14 +28,14 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 	)
 
 	// try to make the columns height roughly similar to primary column
-	if shouldRenderUnratedHighlights && len(cards.Unrated.Highlights) > 1 {
-		renderVehiclesCount += len(cards.Unrated.Highlights)
+	if shouldRenderUnratedHighlights {
+		renderUnratedVehiclesCount += len(cards.Unrated.Highlights)
 	}
 	if shouldRenderRatingOverview {
-		renderVehiclesCount += 2
+		renderUnratedVehiclesCount += 1
 	}
 	if shouldRenderRatingVehicles {
-		renderVehiclesCount += len(cards.Rating.Vehicles)
+		renderUnratedVehiclesCount += len(cards.Rating.Vehicles)
 	}
 
 	var segments common.Segments
@@ -221,7 +221,7 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 	if shouldRenderUnratedVehicles {
 		println("making unrated vehicles")
 		for i, vehicle := range cards.Unrated.Vehicles {
-			if i >= renderVehiclesCount {
+			if i >= renderUnratedVehiclesCount {
 				break
 			}
 			secondaryColumn = append(secondaryColumn, makeVehicleCard(vehicle, secondaryCardBlockSizes, secondaryCardWidth))

From 9cb21867823ef6cb71eaaa4e1d39ab0d76f3597b Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Wed, 26 Jun 2024 18:06:34 -0400
Subject: [PATCH 183/341] added refresh buttons

---
 cmds/core/tasks/cleanup.go                    |   5 +
 cmds/discord/commands/builder/command.go      |   3 +-
 cmds/discord/commands/common.go               |  24 +
 cmds/discord/commands/interactions.go         | 107 ++
 cmds/discord/commands/link.go                 |   6 +-
 cmds/discord/commands/manage.go               |  50 +-
 cmds/discord/commands/options.go              |   2 +-
 cmds/discord/commands/session.go              |  42 +-
 cmds/discord/commands/stats.go                |  38 +-
 cmds/discord/common/context.go                |  29 +-
 cmds/discord/common/reply.go                  |  74 ++
 cmds/discord/discord.go                       |   1 +
 cmds/discord/middleware/middleware.go         |   2 +-
 cmds/discord/router/handler.go                |  13 +-
 go.sum                                        |  10 +
 .../{discord.go => application_commands.go}   |   0
 internal/database/cleanup.go                  |   9 +
 internal/database/client.go                   |   4 +
 internal/database/discord_interactions.go     |  58 ++
 internal/database/ent/db/client.go            | 195 +++-
 .../database/ent/db/discordinteraction.go     | 215 ++++
 .../discordinteraction/discordinteraction.go  | 152 +++
 .../ent/db/discordinteraction/where.go        | 503 +++++++++
 .../ent/db/discordinteraction_create.go       | 370 +++++++
 .../ent/db/discordinteraction_delete.go       |  88 ++
 .../ent/db/discordinteraction_query.go        | 605 +++++++++++
 .../ent/db/discordinteraction_update.go       | 454 ++++++++
 internal/database/ent/db/ent.go               |   2 +
 internal/database/ent/db/hook/hook.go         |  12 +
 internal/database/ent/db/migrate/schema.go    |  55 +
 internal/database/ent/db/mutation.go          | 970 +++++++++++++++++-
 .../database/ent/db/predicate/predicate.go    |   3 +
 internal/database/ent/db/runtime.go           |  29 +
 internal/database/ent/db/tx.go                |   3 +
 internal/database/ent/db/user.go              |  24 +-
 internal/database/ent/db/user/user.go         |  30 +
 internal/database/ent/db/user/where.go        |  23 +
 internal/database/ent/db/user_create.go       |  32 +
 internal/database/ent/db/user_query.go        | 108 +-
 internal/database/ent/db/user_update.go       | 163 +++
 .../ent/migrate/migrations/20240626213554.sql |  12 +
 .../database/ent/migrate/migrations/atlas.sum |   3 +-
 .../ent/schema/application_command.go         |  13 -
 .../ent/schema/discord_interaction.go         |  41 +
 internal/database/ent/schema/user.go          |   1 +
 .../database/ent/schema/user_connection.go    |  21 -
 .../database/models/discord_interaction.go    |  51 +
 internal/permissions/actions.go               |   5 +-
 internal/permissions/roles.go                 |   8 +-
 internal/stats/render/common/v1/options.go    |  22 +-
 50 files changed, 4516 insertions(+), 174 deletions(-)
 create mode 100644 cmds/discord/commands/common.go
 create mode 100644 cmds/discord/commands/interactions.go
 create mode 100644 cmds/discord/common/reply.go
 rename internal/database/{discord.go => application_commands.go} (100%)
 create mode 100644 internal/database/discord_interactions.go
 create mode 100644 internal/database/ent/db/discordinteraction.go
 create mode 100644 internal/database/ent/db/discordinteraction/discordinteraction.go
 create mode 100644 internal/database/ent/db/discordinteraction/where.go
 create mode 100644 internal/database/ent/db/discordinteraction_create.go
 create mode 100644 internal/database/ent/db/discordinteraction_delete.go
 create mode 100644 internal/database/ent/db/discordinteraction_query.go
 create mode 100644 internal/database/ent/db/discordinteraction_update.go
 create mode 100644 internal/database/ent/migrate/migrations/20240626213554.sql
 create mode 100644 internal/database/ent/schema/discord_interaction.go
 create mode 100644 internal/database/models/discord_interaction.go

diff --git a/cmds/core/tasks/cleanup.go b/cmds/core/tasks/cleanup.go
index 18b28de1..efdcf6d9 100644
--- a/cmds/core/tasks/cleanup.go
+++ b/cmds/core/tasks/cleanup.go
@@ -34,6 +34,11 @@ func init() {
 				return "failed to delete expired tasks", err
 			}
 
+			err = client.Database().DeleteExpiredInteractions(ctx, time.Unix(taskExpiration, 0))
+			if err != nil {
+				return "failed to delete expired interactions", err
+			}
+
 			err = client.Database().DeleteExpiredSnapshots(ctx, time.Unix(snapshotExpiration, 0))
 			if err != nil {
 				return "failed to delete expired snapshots", err
diff --git a/cmds/discord/commands/builder/command.go b/cmds/discord/commands/builder/command.go
index 691f95b5..3eb8d470 100644
--- a/cmds/discord/commands/builder/command.go
+++ b/cmds/discord/commands/builder/command.go
@@ -104,8 +104,9 @@ func (c Builder) GuildOnly() Builder {
 	return c
 }
 
-func (c Builder) ComponentType() Builder {
+func (c Builder) ComponentType(matchFn func(string) bool) Builder {
 	c.kind = CommandTypeComponent
+	c.match = matchFn
 	return c
 }
 
diff --git a/cmds/discord/commands/common.go b/cmds/discord/commands/common.go
new file mode 100644
index 00000000..56438bb7
--- /dev/null
+++ b/cmds/discord/commands/common.go
@@ -0,0 +1,24 @@
+package commands
+
+import (
+	"github.com/bwmarrin/discordgo"
+	"github.com/cufee/aftermath/cmds/discord/common"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+func saveInteractionData(ctx *common.Context, command string, opts models.DiscordInteractionOptions) (discordgo.MessageComponent, error) {
+	interaction := models.DiscordInteraction{
+		Command:     command,
+		Locale:      ctx.Locale,
+		UserID:      ctx.User.ID,
+		ReferenceID: ctx.InteractionID(),
+		Type:        models.InteractionTypeStats,
+		Options:     opts,
+	}
+	err := ctx.Core.Database().CreateDiscordInteraction(ctx.Context, interaction)
+	if err != nil {
+		return nil, err
+	}
+
+	return newStatsRefreshButton(interaction), nil
+}
diff --git a/cmds/discord/commands/interactions.go b/cmds/discord/commands/interactions.go
new file mode 100644
index 00000000..7cbf31fd
--- /dev/null
+++ b/cmds/discord/commands/interactions.go
@@ -0,0 +1,107 @@
+package commands
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/bwmarrin/discordgo"
+	"github.com/cufee/aftermath/cmds/discord/commands/builder"
+	"github.com/cufee/aftermath/cmds/discord/common"
+	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/permissions"
+	"github.com/cufee/aftermath/internal/stats/fetch/v1"
+	render "github.com/cufee/aftermath/internal/stats/render/common/v1"
+
+	"github.com/cufee/aftermath/internal/stats/renderer/v1"
+
+	"github.com/pkg/errors"
+	"github.com/rs/zerolog/log"
+)
+
+func newStatsRefreshButton(data models.DiscordInteraction) discordgo.MessageComponent {
+	return discordgo.ActionsRow{
+		Components: []discordgo.MessageComponent{discordgo.Button{
+			Style: discordgo.SecondaryButton,
+			Emoji: &discordgo.ComponentEmoji{
+				Name: "🔃",
+			},
+			CustomID: fmt.Sprintf("refresh_stats_from_button_%s", data.ReferenceID),
+		}},
+	}
+}
+
+func init() {
+	Loaded.add(
+		builder.NewCommand("refresh_stats_from_button").
+			ComponentType(func(customID string) bool {
+				return strings.HasPrefix(customID, "refresh_stats_from_button_")
+			}).
+			Handler(func(ctx *common.Context) error {
+				data, ok := ctx.ComponentData()
+				if !ok {
+					return ctx.Error("failed to get component data on interaction command")
+				}
+				interactionID := strings.ReplaceAll(data.CustomID, "refresh_stats_from_button_", "")
+				if interactionID == "" {
+					return ctx.Error("failed to get interaction id from custom id")
+				}
+
+				interaction, err := ctx.Core.Database().GetDiscordInteraction(ctx.Context, interactionID)
+				if err != nil {
+					return ctx.Reply().Send("refresh_interaction_expired")
+				}
+
+				var image renderer.Image
+				var meta renderer.Metadata
+				switch interaction.Command {
+				case "stats":
+					img, mt, err := ctx.Core.Render(ctx.Locale).Period(context.Background(), interaction.Options.AccountID, interaction.Options.PeriodStart, render.WithBackground(interaction.Options.BackgroundImageURL))
+					if err != nil {
+						return ctx.Err(err)
+					}
+					image = img
+					meta = mt
+
+				case "session":
+					img, mt, err := ctx.Core.Render(ctx.Locale).Session(context.Background(), interaction.Options.AccountID, interaction.Options.PeriodStart, render.WithBackground(interaction.Options.BackgroundImageURL))
+					if err != nil {
+						if errors.Is(err, fetch.ErrSessionNotFound) || errors.Is(err, renderer.ErrAccountNotTracked) {
+							return ctx.Reply().Send("refresh_interaction_expired")
+						}
+						return ctx.Err(err)
+					}
+					image = img
+					meta = mt
+
+				default:
+					log.Error().Str("customId", data.CustomID).Str("command", interaction.Command).Msg("received an unexpected component interaction callback")
+					return ctx.Reply().Send("refresh_interaction_expired")
+				}
+
+				button, saveErr := saveInteractionData(ctx, interaction.Command, interaction.Options)
+				if saveErr != nil {
+					// nil button will not cause an error and will be ignored
+					log.Err(err).Str("interactionId", ctx.ID()).Str("command", "session").Msg("failed to save discord interaction")
+				}
+
+				var buf bytes.Buffer
+				err = image.PNG(&buf)
+				if err != nil {
+					return ctx.Err(err)
+				}
+
+				var timings []string
+				if ctx.User.Permissions.Has(permissions.UseDebugFeatures) {
+					timings = append(timings, "```")
+					for name, duration := range meta.Timings {
+						timings = append(timings, fmt.Sprintf("%s: %v", name, duration.Milliseconds()))
+					}
+					timings = append(timings, "```")
+				}
+
+				return ctx.Reply().File(&buf, interaction.Command+"_command_by_aftermath.png").Component(button).Text(timings...).Send()
+			}),
+	)
+}
diff --git a/cmds/discord/commands/link.go b/cmds/discord/commands/link.go
index ea4c873b..63d801e8 100644
--- a/cmds/discord/commands/link.go
+++ b/cmds/discord/commands/link.go
@@ -38,13 +38,13 @@ func init() {
 				options := getDefaultStatsOptions(ctx)
 				message, valid := options.Validate(ctx)
 				if !valid {
-					return ctx.Reply(message)
+					return ctx.Reply().Send(message)
 				}
 
 				account, err := ctx.Core.Fetch().Search(ctx.Context, options.Nickname, options.Server)
 				if err != nil {
 					if err.Error() == "no results found" {
-						return ctx.ReplyFmt("stats_error_nickname_not_fount_fmt", options.Nickname, strings.ToUpper(options.Server))
+						return ctx.Reply().Fmt("stats_error_nickname_not_fount_fmt", options.Nickname, strings.ToUpper(options.Server)).Send()
 					}
 					return ctx.Err(err)
 				}
@@ -64,7 +64,7 @@ func init() {
 					return ctx.Err(err)
 				}
 
-				return ctx.ReplyFmt("command_link_linked_successfully_fmt", account.Nickname, strings.ToUpper(options.Server))
+				return ctx.Reply().Fmt("command_link_linked_successfully_fmt", account.Nickname, strings.ToUpper(options.Server)).Send()
 			}),
 	)
 }
diff --git a/cmds/discord/commands/manage.go b/cmds/discord/commands/manage.go
index ec1d926c..f75996f0 100644
--- a/cmds/discord/commands/manage.go
+++ b/cmds/discord/commands/manage.go
@@ -19,7 +19,7 @@ func init() {
 	Loaded.add(
 		builder.NewCommand("manage").
 			// ExclusiveToGuilds(os.Getenv("DISCORD_PRIMARY_GUILD_ID")).
-			Middleware(middleware.RequirePermissions(permissions.ContentModerator)).
+			Middleware(middleware.RequirePermissions(permissions.UseDebugFeatures)).
 			Options(
 				builder.NewOption("users", discordgo.ApplicationCommandOptionSubCommandGroup).Options(
 					builder.NewOption("lookup", discordgo.ApplicationCommandOptionSubCommand).Options(
@@ -59,36 +59,36 @@ func init() {
 					userID, _ := opts.Value("user").(string)
 					result, err := ctx.Core.Database().GetUserByID(ctx.Context, userID, database.WithConnections())
 					if err != nil {
-						return ctx.Reply("Database#GetUserByID: " + err.Error())
+						return ctx.Reply().Send("Database#GetUserByID: " + err.Error())
 					}
 
 					data, err := json.MarshalIndent(result, "", "  ")
 					if err != nil {
-						return ctx.Reply("MarshalIndent: " + err.Error())
+						return ctx.Reply().Send("MarshalIndent: " + err.Error())
 					}
-					return ctx.Reply("```" + string(data) + "```")
+					return ctx.Reply().Send("```" + string(data) + "```")
 
 				case "accounts_search":
 					nickname, _ := opts.Value("nickname").(string)
 					server, _ := opts.Value("server").(string)
 					result, err := ctx.Core.Fetch().Search(ctx.Context, nickname, server)
 					if err != nil {
-						return ctx.Reply("Fetch#Search: " + err.Error())
+						return ctx.Reply().Send("Fetch#Search: " + err.Error())
 					}
 					data, err := json.MarshalIndent(result, "", "  ")
 					if err != nil {
-						return ctx.Reply("MarshalIndent: " + err.Error())
+						return ctx.Reply().Send("MarshalIndent: " + err.Error())
 					}
-					return ctx.Reply("```" + string(data) + "```")
+					return ctx.Reply().Send("```" + string(data) + "```")
 
 				case "snapshots_view":
 					accountId, ok := opts.Value("account_id").(string)
 					if !ok {
-						return ctx.Reply("invalid accountId, failed to cast to string")
+						return ctx.Reply().Send("invalid accountId, failed to cast to string")
 					}
 					snapshots, err := ctx.Core.Database().GetLastAccountSnapshots(ctx.Context, accountId, 3)
 					if err != nil {
-						return ctx.Reply("GetLastAccountSnapshots: " + err.Error())
+						return ctx.Reply().Send("GetLastAccountSnapshots: " + err.Error())
 					}
 
 					var data []map[string]string
@@ -106,11 +106,15 @@ func init() {
 
 					bytes, err := json.MarshalIndent(data, "", "  ")
 					if err != nil {
-						return ctx.Reply("json.Marshal: " + err.Error())
+						return ctx.Reply().Send("json.Marshal: " + err.Error())
 					}
-					return ctx.Reply("```" + string(bytes) + "```")
+					return ctx.Reply().Send("```" + string(bytes) + "```")
 
 				case "tasks_view":
+					if !ctx.User.Permissions.Has(permissions.ViewTaskLogs) {
+						ctx.Reply().Send("You do not have access to this sub-command.")
+					}
+
 					hours, _ := opts.Value("hours").(float64)
 					status, _ := opts.Value("status").(string)
 					if hours < 1 {
@@ -119,10 +123,10 @@ func init() {
 
 					tasks, err := ctx.Core.Database().GetRecentTasks(ctx.Context, time.Now().Add(time.Hour*time.Duration(hours)*-1), models.TaskStatus(status))
 					if err != nil {
-						return ctx.Reply("Database#GetRecentTasks: " + err.Error())
+						return ctx.Reply().Send("Database#GetRecentTasks: " + err.Error())
 					}
 					if len(tasks) < 1 {
-						return ctx.Reply("No recent tasks with status " + status)
+						return ctx.Reply().Send("No recent tasks with status " + status)
 					}
 
 					content := fmt.Sprintf("total: %d\n", len(tasks))
@@ -138,34 +142,38 @@ func init() {
 					}
 					data, err := json.MarshalIndent(reduced, "", "  ")
 					if err != nil {
-						return ctx.Reply("json.Marshal: " + err.Error())
+						return ctx.Reply().Send("json.Marshal: " + err.Error())
 					}
 					content += string(data)
 
-					return ctx.File(bytes.NewBufferString(content), "tasks.json")
+					return ctx.Reply().File(bytes.NewBufferString(content), "tasks.json").Send()
 
 				case "tasks_details":
+					if !ctx.User.Permissions.Has(permissions.ViewTaskLogs) {
+						ctx.Reply().Send("You do not have access to this sub-command.")
+					}
+
 					id, _ := opts.Value("id").(string)
 					if id == "" {
-						return ctx.Reply("id cannot be blank")
+						return ctx.Reply().Send("id cannot be blank")
 					}
 
 					tasks, err := ctx.Core.Database().GetTasks(ctx.Context, id)
 					if err != nil {
-						return ctx.Reply("Database#GetTasks: " + err.Error())
+						return ctx.Reply().Send("Database#GetTasks: " + err.Error())
 					}
 					if len(tasks) < 1 {
-						return ctx.Reply("No recent task found")
+						return ctx.Reply().Send("No recent task found")
 					}
 
 					data, err := json.MarshalIndent(tasks, "", "  ")
 					if err != nil {
-						return ctx.Reply("json.Marshal: " + err.Error())
+						return ctx.Reply().Send("json.Marshal: " + err.Error())
 					}
-					return ctx.File(bytes.NewReader(data), "tasks.json")
+					return ctx.Reply().File(bytes.NewReader(data), "tasks.json").Send()
 
 				default:
-					return ctx.Reply("invalid subcommand, thought this should never happen")
+					return ctx.Reply().Send("invalid subcommand, thought this should never happen")
 				}
 			}),
 	)
diff --git a/cmds/discord/commands/options.go b/cmds/discord/commands/options.go
index 0511a87e..e8528249 100644
--- a/cmds/discord/commands/options.go
+++ b/cmds/discord/commands/options.go
@@ -74,7 +74,7 @@ func (o statsOptions) Validate(ctx *common.Context) (string, bool) {
 	}
 	if o.UserID != "" && o.UserID == ctx.User.ID {
 		// mentioning self is redundant - this should not prevent the command from working though
-		ctx.Reply("stats_error_mentioned_self_non_blocking")
+		ctx.Reply().Send("stats_error_mentioned_self_non_blocking")
 	}
 	return "", true
 }
diff --git a/cmds/discord/commands/session.go b/cmds/discord/commands/session.go
index 86a6c644..7a1562ad 100644
--- a/cmds/discord/commands/session.go
+++ b/cmds/discord/commands/session.go
@@ -10,11 +10,12 @@ import (
 	"github.com/cufee/aftermath/cmds/discord/common"
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/permissions"
 	"github.com/cufee/aftermath/internal/stats/fetch/v1"
-	"github.com/cufee/aftermath/internal/stats/render/assets"
 	render "github.com/cufee/aftermath/internal/stats/render/common/v1"
 	stats "github.com/cufee/aftermath/internal/stats/renderer/v1"
 	"github.com/pkg/errors"
+	"github.com/rs/zerolog/log"
 )
 
 func init() {
@@ -25,11 +26,11 @@ func init() {
 				options := getDefaultStatsOptions(ctx)
 				message, valid := options.Validate(ctx)
 				if !valid {
-					return ctx.Reply(message)
+					return ctx.Reply().Send(message)
 				}
 
 				var accountID string
-				background, _ := assets.GetLoadedImage("bg-default")
+				var backgroundURL string
 
 				switch {
 				case options.UserID != "":
@@ -37,7 +38,7 @@ func init() {
 					mentionedUser, _ := ctx.Core.Database().GetUserByID(ctx.Context, options.UserID, database.WithConnections(), database.WithSubscriptions(), database.WithContent())
 					defaultAccount, hasDefaultAccount := mentionedUser.Connection(models.ConnectionTypeWargaming)
 					if !hasDefaultAccount {
-						return ctx.Reply("stats_error_connection_not_found_vague")
+						return ctx.Reply().Send("stats_error_connection_not_found_vague")
 					}
 					accountID = defaultAccount.ReferenceID
 					// TODO: Get user background
@@ -47,7 +48,7 @@ func init() {
 					account, err := ctx.Core.Fetch().Search(ctx.Context, options.Nickname, options.Server)
 					if err != nil {
 						if err.Error() == "no results found" {
-							return ctx.ReplyFmt("stats_error_nickname_not_fount_fmt", options.Nickname, strings.ToUpper(options.Server))
+							return ctx.Reply().Fmt("stats_error_nickname_not_fount_fmt", options.Nickname, strings.ToUpper(options.Server)).Send()
 						}
 						return ctx.Err(err)
 					}
@@ -56,37 +57,50 @@ func init() {
 				default:
 					defaultAccount, hasDefaultAccount := ctx.User.Connection(models.ConnectionTypeWargaming)
 					if !hasDefaultAccount {
-						return ctx.Reply("stats_error_nickname_or_server_missing")
+						return ctx.Reply().Send("stats_error_nickname_or_server_missing")
 					}
 					// command used without options, but user has a default connection
 					accountID = defaultAccount.ReferenceID
 					// TODO: Get user background
 				}
 
-				image, meta, err := ctx.Core.Render(ctx.Locale).Session(context.Background(), accountID, options.PeriodStart, render.WithBackground(background))
+				image, meta, err := ctx.Core.Render(ctx.Locale).Session(context.Background(), accountID, options.PeriodStart, render.WithBackground(backgroundURL))
 				if err != nil {
 					if errors.Is(err, stats.ErrAccountNotTracked) || (errors.Is(err, fetch.ErrSessionNotFound) && options.Days < 1) {
-						return ctx.Reply("session_error_account_was_not_tracked")
+						return ctx.Reply().Send("session_error_account_was_not_tracked")
 					}
 					if errors.Is(err, fetch.ErrSessionNotFound) {
-						return ctx.Reply("session_error_no_session_for_period")
+						return ctx.Reply().Send("session_error_no_session_for_period")
 					}
 					return ctx.Err(err)
 				}
 
+				button, saveErr := saveInteractionData(ctx, "session", models.DiscordInteractionOptions{
+					BackgroundImageURL: backgroundURL,
+					PeriodStart:        options.PeriodStart,
+					AccountID:          accountID,
+				})
+				if saveErr != nil {
+					// nil button will not cause an error and will be ignored
+					log.Err(err).Str("interactionId", ctx.ID()).Str("command", "session").Msg("failed to save discord interaction")
+				}
+
 				var buf bytes.Buffer
 				err = image.PNG(&buf)
 				if err != nil {
 					return ctx.Err(err)
 				}
 
-				var timings = []string{"```"}
-				for name, duration := range meta.Timings {
-					timings = append(timings, fmt.Sprintf("%s: %v", name, duration.Milliseconds()))
+				var timings []string
+				if ctx.User.Permissions.Has(permissions.UseDebugFeatures) {
+					timings = append(timings, "```")
+					for name, duration := range meta.Timings {
+						timings = append(timings, fmt.Sprintf("%s: %v", name, duration.Milliseconds()))
+					}
+					timings = append(timings, "```")
 				}
-				timings = append(timings, "```")
 
-				return ctx.File(&buf, "session_command_by_aftermath.png", timings...)
+				return ctx.Reply().File(&buf, "session_command_by_aftermath.png").Component(button).Text(timings...).Send()
 			}),
 	)
 }
diff --git a/cmds/discord/commands/stats.go b/cmds/discord/commands/stats.go
index b7ee55c6..0b3ded0a 100644
--- a/cmds/discord/commands/stats.go
+++ b/cmds/discord/commands/stats.go
@@ -10,8 +10,9 @@ import (
 	"github.com/cufee/aftermath/cmds/discord/common"
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
-	"github.com/cufee/aftermath/internal/stats/render/assets"
+	"github.com/cufee/aftermath/internal/permissions"
 	render "github.com/cufee/aftermath/internal/stats/render/common/v1"
+	"github.com/rs/zerolog/log"
 )
 
 func init() {
@@ -22,11 +23,11 @@ func init() {
 				options := getDefaultStatsOptions(ctx)
 				message, valid := options.Validate(ctx)
 				if !valid {
-					return ctx.Reply(message)
+					return ctx.Reply().Send(message)
 				}
 
 				var accountID string
-				background, _ := assets.GetLoadedImage("bg-default")
+				var backgroundURL = "static://bg-default"
 
 				switch {
 				case options.UserID != "":
@@ -34,7 +35,7 @@ func init() {
 					mentionedUser, _ := ctx.Core.Database().GetUserByID(ctx.Context, options.UserID, database.WithConnections(), database.WithSubscriptions(), database.WithContent())
 					defaultAccount, hasDefaultAccount := mentionedUser.Connection(models.ConnectionTypeWargaming)
 					if !hasDefaultAccount {
-						return ctx.Reply("stats_error_connection_not_found_vague")
+						return ctx.Reply().Send("stats_error_connection_not_found_vague")
 					}
 					accountID = defaultAccount.ReferenceID
 					// TODO: Get user background
@@ -44,7 +45,7 @@ func init() {
 					account, err := ctx.Core.Fetch().Search(ctx.Context, options.Nickname, options.Server)
 					if err != nil {
 						if err.Error() == "no results found" {
-							return ctx.ReplyFmt("stats_error_nickname_not_fount_fmt", options.Nickname, strings.ToUpper(options.Server))
+							return ctx.Reply().Fmt("stats_error_nickname_not_fount_fmt", options.Nickname, strings.ToUpper(options.Server)).Send()
 						}
 						return ctx.Err(err)
 					}
@@ -53,31 +54,44 @@ func init() {
 				default:
 					defaultAccount, hasDefaultAccount := ctx.User.Connection(models.ConnectionTypeWargaming)
 					if !hasDefaultAccount {
-						return ctx.Reply("stats_error_nickname_or_server_missing")
+						return ctx.Reply().Send("stats_error_nickname_or_server_missing")
 					}
 					// command used without options, but user has a default connection
 					accountID = defaultAccount.ReferenceID
 					// TODO: Get user background
 				}
 
-				image, meta, err := ctx.Core.Render(ctx.Locale).Period(context.Background(), accountID, options.PeriodStart, render.WithBackground(background))
+				image, meta, err := ctx.Core.Render(ctx.Locale).Period(context.Background(), accountID, options.PeriodStart, render.WithBackground(backgroundURL))
 				if err != nil {
 					return ctx.Err(err)
 				}
 
+				button, saveErr := saveInteractionData(ctx, "stats", models.DiscordInteractionOptions{
+					BackgroundImageURL: backgroundURL,
+					PeriodStart:        options.PeriodStart,
+					AccountID:          accountID,
+				})
+				if saveErr != nil {
+					// nil button will not cause an error and will be ignored
+					log.Err(err).Str("interactionId", ctx.ID()).Str("command", "session").Msg("failed to save discord interaction")
+				}
+
 				var buf bytes.Buffer
 				err = image.PNG(&buf)
 				if err != nil {
 					return ctx.Err(err)
 				}
 
-				var timings = []string{"```"}
-				for name, duration := range meta.Timings {
-					timings = append(timings, fmt.Sprintf("%s: %v", name, duration.Milliseconds()))
+				var timings []string
+				if ctx.User.Permissions.Has(permissions.UseDebugFeatures) {
+					timings = append(timings, "```")
+					for name, duration := range meta.Timings {
+						timings = append(timings, fmt.Sprintf("%s: %v", name, duration.Milliseconds()))
+					}
+					timings = append(timings, "```")
 				}
-				timings = append(timings, "```")
 
-				return ctx.File(&buf, "stats_command_by_aftermath.png", timings...)
+				return ctx.Reply().File(&buf, "stats_command_by_aftermath.png").Component(button).Text(timings...).Send()
 			}),
 	)
 }
diff --git a/cmds/discord/common/context.go b/cmds/discord/common/context.go
index 9a09bd6d..004b05ac 100644
--- a/cmds/discord/common/context.go
+++ b/cmds/discord/common/context.go
@@ -2,9 +2,6 @@ package common
 
 import (
 	"context"
-	"fmt"
-	"io"
-	"strings"
 
 	"github.com/pkg/errors"
 
@@ -88,36 +85,22 @@ func (c *Context) respond(data discordgo.InteractionResponseData) error {
 	return nil
 }
 
-func (c *Context) Message(message string) error {
-	if message == "" {
-		return errors.New("bad reply call with blank message")
-	}
-	return c.respond(discordgo.InteractionResponseData{Content: message})
+func (c *Context) InteractionID() string {
+	return c.interaction.ID
 }
 
-func (c *Context) Reply(key string) error {
-	return c.Message(c.Localize(key))
+func (c *Context) Reply() reply {
+	return reply{ctx: c}
 }
 
 func (c *Context) Err(err error) error {
 	log.Err(err).Str("interactionId", c.interaction.ID).Msg("error while handling an interaction")
-	return c.Reply("common_error_unhandled_not_reported")
+	return c.Reply().Send("common_error_unhandled_not_reported")
 }
 
 func (c *Context) Error(message string) error {
 	log.Error().Str("message", message).Str("interactionId", c.interaction.ID).Msg("error while handling an interaction")
-	return c.Reply("common_error_unhandled_not_reported")
-}
-
-func (c *Context) ReplyFmt(key string, args ...any) error {
-	return c.Message(fmt.Sprintf(c.Localize(key), args...))
-}
-
-func (c *Context) File(r io.Reader, name string, message ...string) error {
-	if r == nil {
-		return errors.New("bad Context#File call with nil io.Reader")
-	}
-	return c.respond(discordgo.InteractionResponseData{Files: []*discordgo.File{{Reader: r, Name: name}}, Content: strings.Join(message, "\n")})
+	return c.Reply().Send("common_error_unhandled_not_reported")
 }
 
 func (c *Context) isCommand() bool {
diff --git a/cmds/discord/common/reply.go b/cmds/discord/common/reply.go
new file mode 100644
index 00000000..526cc416
--- /dev/null
+++ b/cmds/discord/common/reply.go
@@ -0,0 +1,74 @@
+package common
+
+import (
+	"fmt"
+	"io"
+	"strings"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+type reply struct {
+	ctx *Context
+
+	text       []string
+	files      []*discordgo.File
+	components []discordgo.MessageComponent
+	embeds     []*discordgo.MessageEmbed
+}
+
+func (r reply) Text(message ...string) reply {
+	r.text = append(r.text, message...)
+	return r
+}
+
+func (r reply) Fmt(format string, args ...any) reply {
+	r.text = append(r.text, fmt.Sprintf(format, args...))
+	return r
+}
+
+func (r reply) File(reader io.Reader, name string) reply {
+	if reader == nil {
+		return r
+	}
+	r.files = append(r.files, &discordgo.File{Reader: reader, Name: name})
+	return r
+}
+
+func (r reply) Component(components ...discordgo.MessageComponent) reply {
+	for _, c := range components {
+		if c == nil {
+			continue
+		}
+		r.components = append(r.components, c)
+	}
+	return r
+}
+
+func (r reply) Embed(embeds ...*discordgo.MessageEmbed) reply {
+	for _, e := range embeds {
+		if e == nil {
+			continue
+		}
+		r.embeds = append(r.embeds, e)
+	}
+	return r
+}
+
+func (r reply) Send(content ...string) error {
+	r.text = append(r.text, content...)
+	return r.ctx.respond(r.data(r.ctx.Localize))
+}
+
+func (r reply) data(localePrinter func(string) string) discordgo.InteractionResponseData {
+	var content []string
+	for _, t := range r.text {
+		content = append(content, localePrinter(t))
+	}
+	return discordgo.InteractionResponseData{
+		Content:    strings.Join(content, "\n"),
+		Components: r.components,
+		Embeds:     r.embeds,
+		Files:      r.files,
+	}
+}
diff --git a/cmds/discord/discord.go b/cmds/discord/discord.go
index 48388227..ab4076ac 100644
--- a/cmds/discord/discord.go
+++ b/cmds/discord/discord.go
@@ -4,6 +4,7 @@ import (
 	"net/http"
 
 	"github.com/cufee/aftermath/cmds/core"
+
 	"github.com/cufee/aftermath/cmds/discord/commands"
 	"github.com/cufee/aftermath/cmds/discord/router"
 )
diff --git a/cmds/discord/middleware/middleware.go b/cmds/discord/middleware/middleware.go
index 2ceb941d..634e6a93 100644
--- a/cmds/discord/middleware/middleware.go
+++ b/cmds/discord/middleware/middleware.go
@@ -11,7 +11,7 @@ func RequirePermissions(required permissions.Permissions) MiddlewareFunc {
 	return func(ctx *common.Context, next func(*common.Context) error) func(*common.Context) error {
 		if !ctx.User.Permissions.Has(required) {
 			return func(ctx *common.Context) error {
-				return ctx.Reply("common_error_command_missing_permissions")
+				return ctx.Reply().Send("common_error_command_missing_permissions")
 			}
 		}
 		return next
diff --git a/cmds/discord/router/handler.go b/cmds/discord/router/handler.go
index 0dd79565..721ea022 100644
--- a/cmds/discord/router/handler.go
+++ b/cmds/discord/router/handler.go
@@ -247,7 +247,7 @@ func (r *Router) sendInteractionReply(interaction discordgo.Interaction, state *
 	var handler func() error
 
 	switch interaction.Type {
-	case discordgo.InteractionApplicationCommand:
+	case discordgo.InteractionApplicationCommand, discordgo.InteractionMessageComponent:
 		if state.replied || state.acked {
 			// We already replied to this interaction - edit the message
 			handler = func() error {
@@ -260,6 +260,17 @@ func (r *Router) sendInteractionReply(interaction discordgo.Interaction, state *
 				return r.restClient.SendInteractionResponse(interaction.ID, interaction.Token, payload)
 			}
 		}
+	default:
+		log.Error().Stack().Any("state", state).Any("data", data).Str("id", interaction.ID).Msg("unknown interaction type received")
+		if state.replied || state.acked {
+			handler = func() error {
+				return r.restClient.UpdateInteractionResponse(interaction.AppID, interaction.Token, discordgo.InteractionResponseData{Content: "Something unexpected happened and your command failed."})
+			}
+		} else {
+			handler = func() error {
+				return r.restClient.SendInteractionResponse(interaction.ID, interaction.Token, discordgo.InteractionResponse{Data: &discordgo.InteractionResponseData{Content: "Something unexpected happened and your command failed."}, Type: discordgo.InteractionResponseChannelMessageWithSource})
+			}
+		}
 	}
 
 	err := handler()
diff --git a/go.sum b/go.sum
index b4bd05ca..ee4f6f7a 100644
--- a/go.sum
+++ b/go.sum
@@ -58,17 +58,23 @@ github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/
 github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
+github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/mattn/go-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o4kU=
 github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
 github.com/mitchellh/go-wordwrap v1.0.1 h1:TLuKupo69TCn6TQSyGxwI1EblZZEsQ0vMlAFQflz0v0=
 github.com/mitchellh/go-wordwrap v1.0.1/go.mod h1:R62XHJLzvMFRBbcrT7m7WgmE1eOyTSsCt+hzestvNj0=
 github.com/nlpodyssey/gopickle v0.3.0 h1:BLUE5gxFLyyNOPzlXxt6GoHEMMxD0qhsE4p0CIQyoLw=
 github.com/nlpodyssey/gopickle v0.3.0/go.mod h1:f070HJ/yR+eLi5WmM1OXJEGaTpuJEUiib19olXgYha0=
+github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
+github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
+github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
 github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=
 github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
@@ -77,6 +83,10 @@ github.com/rogpeppe/go-internal v1.8.1/go.mod h1:JeRgkft04UBgHMgCIwADu4Pn6Mtm5d4
 github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
 github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8=
 github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
+github.com/spf13/cobra v1.7.0 h1:hyqWnYt1ZQShIddO5kBpj3vu05/++x6tJ6dg8EC572I=
+github.com/spf13/cobra v1.7.0/go.mod h1:uLxZILRyS/50WlhOIKD7W6V5bgeIt+4sICxh6uRMrb0=
+github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
diff --git a/internal/database/discord.go b/internal/database/application_commands.go
similarity index 100%
rename from internal/database/discord.go
rename to internal/database/application_commands.go
diff --git a/internal/database/cleanup.go b/internal/database/cleanup.go
index 05d130f5..c6706d6f 100644
--- a/internal/database/cleanup.go
+++ b/internal/database/cleanup.go
@@ -8,6 +8,7 @@ import (
 	"github.com/cufee/aftermath/internal/database/ent/db/accountsnapshot"
 	"github.com/cufee/aftermath/internal/database/ent/db/achievementssnapshot"
 	"github.com/cufee/aftermath/internal/database/ent/db/crontask"
+	"github.com/cufee/aftermath/internal/database/ent/db/discordinteraction"
 	"github.com/cufee/aftermath/internal/database/ent/db/vehiclesnapshot"
 )
 
@@ -19,6 +20,14 @@ func (c *client) DeleteExpiredTasks(ctx context.Context, expiration time.Time) e
 	return err
 }
 
+func (c *client) DeleteExpiredInteractions(ctx context.Context, expiration time.Time) error {
+	err := c.withTx(ctx, func(tx *db.Tx) error {
+		_, err := tx.DiscordInteraction.Delete().Where(discordinteraction.CreatedAtLT(expiration.Unix())).Exec(ctx)
+		return err
+	})
+	return err
+}
+
 func (c *client) DeleteExpiredSnapshots(ctx context.Context, expiration time.Time) error {
 	_, err := c.db.AccountSnapshot.Delete().Where(accountsnapshot.CreatedAtLT(expiration.Unix())).Exec(ctx)
 	if err != nil {
diff --git a/internal/database/client.go b/internal/database/client.go
index 458a86f5..0c5f7770 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -72,6 +72,10 @@ type TasksClient interface {
 type DiscordDataClient interface {
 	UpsertCommands(ctx context.Context, commands ...models.ApplicationCommand) error
 	GetCommandsByID(ctx context.Context, commandIDs ...string) ([]models.ApplicationCommand, error)
+
+	CreateDiscordInteraction(ctx context.Context, data models.DiscordInteraction) error
+	GetDiscordInteraction(ctx context.Context, referenceID string) (models.DiscordInteraction, error)
+	DeleteExpiredInteractions(ctx context.Context, expiration time.Time) error
 }
 
 type Client interface {
diff --git a/internal/database/discord_interactions.go b/internal/database/discord_interactions.go
new file mode 100644
index 00000000..ce81fe5f
--- /dev/null
+++ b/internal/database/discord_interactions.go
@@ -0,0 +1,58 @@
+package database
+
+import (
+	"context"
+	"time"
+
+	"github.com/cufee/aftermath/internal/database/ent/db"
+	"github.com/cufee/aftermath/internal/database/ent/db/discordinteraction"
+	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/pkg/errors"
+	"golang.org/x/text/language"
+)
+
+func (c client) CreateDiscordInteraction(ctx context.Context, data models.DiscordInteraction) error {
+	user, err := c.db.User.Get(ctx, data.UserID)
+	if err != nil {
+		return errors.Wrap(err, "failed to get user")
+	}
+
+	return c.withTx(ctx, func(tx *db.Tx) error {
+		return c.db.DiscordInteraction.Create().
+			SetCommand(data.Command).
+			SetLocale(data.Locale.String()).
+			SetOptions(data.Options).
+			SetReferenceID(data.ReferenceID).
+			SetType(data.Type).
+			SetUser(user).Exec(ctx)
+	})
+}
+
+func toDiscordInteraction(record *db.DiscordInteraction) models.DiscordInteraction {
+	locale, err := language.Parse(record.Locale)
+	if err != nil {
+		locale = language.English
+	}
+	return models.DiscordInteraction{
+		ID:        record.ID,
+		CreatedAt: time.Unix(record.CreatedAt, 0),
+
+		UserID:      record.UserID,
+		Command:     record.Command,
+		ReferenceID: record.ReferenceID,
+
+		Type:   record.Type,
+		Locale: locale,
+
+		Options: record.Options,
+	}
+}
+
+func (c client) GetDiscordInteraction(ctx context.Context, referenceID string) (models.DiscordInteraction, error) {
+	interaction, err := c.db.DiscordInteraction.Query().Where(discordinteraction.ReferenceID(referenceID)).First(ctx)
+	if err != nil {
+		return models.DiscordInteraction{}, err
+	}
+
+	return toDiscordInteraction(interaction), nil
+}
diff --git a/internal/database/ent/db/client.go b/internal/database/ent/db/client.go
index 9d443fe2..9bceec9e 100644
--- a/internal/database/ent/db/client.go
+++ b/internal/database/ent/db/client.go
@@ -22,6 +22,7 @@ import (
 	"github.com/cufee/aftermath/internal/database/ent/db/applicationcommand"
 	"github.com/cufee/aftermath/internal/database/ent/db/clan"
 	"github.com/cufee/aftermath/internal/database/ent/db/crontask"
+	"github.com/cufee/aftermath/internal/database/ent/db/discordinteraction"
 	"github.com/cufee/aftermath/internal/database/ent/db/user"
 	"github.com/cufee/aftermath/internal/database/ent/db/userconnection"
 	"github.com/cufee/aftermath/internal/database/ent/db/usercontent"
@@ -52,6 +53,8 @@ type Client struct {
 	Clan *ClanClient
 	// CronTask is the client for interacting with the CronTask builders.
 	CronTask *CronTaskClient
+	// DiscordInteraction is the client for interacting with the DiscordInteraction builders.
+	DiscordInteraction *DiscordInteractionClient
 	// User is the client for interacting with the User builders.
 	User *UserClient
 	// UserConnection is the client for interacting with the UserConnection builders.
@@ -84,6 +87,7 @@ func (c *Client) init() {
 	c.ApplicationCommand = NewApplicationCommandClient(c.config)
 	c.Clan = NewClanClient(c.config)
 	c.CronTask = NewCronTaskClient(c.config)
+	c.DiscordInteraction = NewDiscordInteractionClient(c.config)
 	c.User = NewUserClient(c.config)
 	c.UserConnection = NewUserConnectionClient(c.config)
 	c.UserContent = NewUserContentClient(c.config)
@@ -190,6 +194,7 @@ func (c *Client) Tx(ctx context.Context) (*Tx, error) {
 		ApplicationCommand:   NewApplicationCommandClient(cfg),
 		Clan:                 NewClanClient(cfg),
 		CronTask:             NewCronTaskClient(cfg),
+		DiscordInteraction:   NewDiscordInteractionClient(cfg),
 		User:                 NewUserClient(cfg),
 		UserConnection:       NewUserConnectionClient(cfg),
 		UserContent:          NewUserContentClient(cfg),
@@ -223,6 +228,7 @@ func (c *Client) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error)
 		ApplicationCommand:   NewApplicationCommandClient(cfg),
 		Clan:                 NewClanClient(cfg),
 		CronTask:             NewCronTaskClient(cfg),
+		DiscordInteraction:   NewDiscordInteractionClient(cfg),
 		User:                 NewUserClient(cfg),
 		UserConnection:       NewUserConnectionClient(cfg),
 		UserContent:          NewUserContentClient(cfg),
@@ -260,9 +266,9 @@ func (c *Client) Close() error {
 func (c *Client) Use(hooks ...Hook) {
 	for _, n := range []interface{ Use(...Hook) }{
 		c.Account, c.AccountSnapshot, c.AchievementsSnapshot, c.AppConfiguration,
-		c.ApplicationCommand, c.Clan, c.CronTask, c.User, c.UserConnection,
-		c.UserContent, c.UserSubscription, c.Vehicle, c.VehicleAverage,
-		c.VehicleSnapshot,
+		c.ApplicationCommand, c.Clan, c.CronTask, c.DiscordInteraction, c.User,
+		c.UserConnection, c.UserContent, c.UserSubscription, c.Vehicle,
+		c.VehicleAverage, c.VehicleSnapshot,
 	} {
 		n.Use(hooks...)
 	}
@@ -273,9 +279,9 @@ func (c *Client) Use(hooks ...Hook) {
 func (c *Client) Intercept(interceptors ...Interceptor) {
 	for _, n := range []interface{ Intercept(...Interceptor) }{
 		c.Account, c.AccountSnapshot, c.AchievementsSnapshot, c.AppConfiguration,
-		c.ApplicationCommand, c.Clan, c.CronTask, c.User, c.UserConnection,
-		c.UserContent, c.UserSubscription, c.Vehicle, c.VehicleAverage,
-		c.VehicleSnapshot,
+		c.ApplicationCommand, c.Clan, c.CronTask, c.DiscordInteraction, c.User,
+		c.UserConnection, c.UserContent, c.UserSubscription, c.Vehicle,
+		c.VehicleAverage, c.VehicleSnapshot,
 	} {
 		n.Intercept(interceptors...)
 	}
@@ -298,6 +304,8 @@ func (c *Client) Mutate(ctx context.Context, m Mutation) (Value, error) {
 		return c.Clan.mutate(ctx, m)
 	case *CronTaskMutation:
 		return c.CronTask.mutate(ctx, m)
+	case *DiscordInteractionMutation:
+		return c.DiscordInteraction.mutate(ctx, m)
 	case *UserMutation:
 		return c.User.mutate(ctx, m)
 	case *UserConnectionMutation:
@@ -1360,6 +1368,155 @@ func (c *CronTaskClient) mutate(ctx context.Context, m *CronTaskMutation) (Value
 	}
 }
 
+// DiscordInteractionClient is a client for the DiscordInteraction schema.
+type DiscordInteractionClient struct {
+	config
+}
+
+// NewDiscordInteractionClient returns a client for the DiscordInteraction from the given config.
+func NewDiscordInteractionClient(c config) *DiscordInteractionClient {
+	return &DiscordInteractionClient{config: c}
+}
+
+// Use adds a list of mutation hooks to the hooks stack.
+// A call to `Use(f, g, h)` equals to `discordinteraction.Hooks(f(g(h())))`.
+func (c *DiscordInteractionClient) Use(hooks ...Hook) {
+	c.hooks.DiscordInteraction = append(c.hooks.DiscordInteraction, hooks...)
+}
+
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `discordinteraction.Intercept(f(g(h())))`.
+func (c *DiscordInteractionClient) Intercept(interceptors ...Interceptor) {
+	c.inters.DiscordInteraction = append(c.inters.DiscordInteraction, interceptors...)
+}
+
+// Create returns a builder for creating a DiscordInteraction entity.
+func (c *DiscordInteractionClient) Create() *DiscordInteractionCreate {
+	mutation := newDiscordInteractionMutation(c.config, OpCreate)
+	return &DiscordInteractionCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// CreateBulk returns a builder for creating a bulk of DiscordInteraction entities.
+func (c *DiscordInteractionClient) CreateBulk(builders ...*DiscordInteractionCreate) *DiscordInteractionCreateBulk {
+	return &DiscordInteractionCreateBulk{config: c.config, builders: builders}
+}
+
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *DiscordInteractionClient) MapCreateBulk(slice any, setFunc func(*DiscordInteractionCreate, int)) *DiscordInteractionCreateBulk {
+	rv := reflect.ValueOf(slice)
+	if rv.Kind() != reflect.Slice {
+		return &DiscordInteractionCreateBulk{err: fmt.Errorf("calling to DiscordInteractionClient.MapCreateBulk with wrong type %T, need slice", slice)}
+	}
+	builders := make([]*DiscordInteractionCreate, rv.Len())
+	for i := 0; i < rv.Len(); i++ {
+		builders[i] = c.Create()
+		setFunc(builders[i], i)
+	}
+	return &DiscordInteractionCreateBulk{config: c.config, builders: builders}
+}
+
+// Update returns an update builder for DiscordInteraction.
+func (c *DiscordInteractionClient) Update() *DiscordInteractionUpdate {
+	mutation := newDiscordInteractionMutation(c.config, OpUpdate)
+	return &DiscordInteractionUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOne returns an update builder for the given entity.
+func (c *DiscordInteractionClient) UpdateOne(di *DiscordInteraction) *DiscordInteractionUpdateOne {
+	mutation := newDiscordInteractionMutation(c.config, OpUpdateOne, withDiscordInteraction(di))
+	return &DiscordInteractionUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOneID returns an update builder for the given id.
+func (c *DiscordInteractionClient) UpdateOneID(id string) *DiscordInteractionUpdateOne {
+	mutation := newDiscordInteractionMutation(c.config, OpUpdateOne, withDiscordInteractionID(id))
+	return &DiscordInteractionUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// Delete returns a delete builder for DiscordInteraction.
+func (c *DiscordInteractionClient) Delete() *DiscordInteractionDelete {
+	mutation := newDiscordInteractionMutation(c.config, OpDelete)
+	return &DiscordInteractionDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// DeleteOne returns a builder for deleting the given entity.
+func (c *DiscordInteractionClient) DeleteOne(di *DiscordInteraction) *DiscordInteractionDeleteOne {
+	return c.DeleteOneID(di.ID)
+}
+
+// DeleteOneID returns a builder for deleting the given entity by its id.
+func (c *DiscordInteractionClient) DeleteOneID(id string) *DiscordInteractionDeleteOne {
+	builder := c.Delete().Where(discordinteraction.ID(id))
+	builder.mutation.id = &id
+	builder.mutation.op = OpDeleteOne
+	return &DiscordInteractionDeleteOne{builder}
+}
+
+// Query returns a query builder for DiscordInteraction.
+func (c *DiscordInteractionClient) Query() *DiscordInteractionQuery {
+	return &DiscordInteractionQuery{
+		config: c.config,
+		ctx:    &QueryContext{Type: TypeDiscordInteraction},
+		inters: c.Interceptors(),
+	}
+}
+
+// Get returns a DiscordInteraction entity by its id.
+func (c *DiscordInteractionClient) Get(ctx context.Context, id string) (*DiscordInteraction, error) {
+	return c.Query().Where(discordinteraction.ID(id)).Only(ctx)
+}
+
+// GetX is like Get, but panics if an error occurs.
+func (c *DiscordInteractionClient) GetX(ctx context.Context, id string) *DiscordInteraction {
+	obj, err := c.Get(ctx, id)
+	if err != nil {
+		panic(err)
+	}
+	return obj
+}
+
+// QueryUser queries the user edge of a DiscordInteraction.
+func (c *DiscordInteractionClient) QueryUser(di *DiscordInteraction) *UserQuery {
+	query := (&UserClient{config: c.config}).Query()
+	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+		id := di.ID
+		step := sqlgraph.NewStep(
+			sqlgraph.From(discordinteraction.Table, discordinteraction.FieldID, id),
+			sqlgraph.To(user.Table, user.FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, discordinteraction.UserTable, discordinteraction.UserColumn),
+		)
+		fromV = sqlgraph.Neighbors(di.driver.Dialect(), step)
+		return fromV, nil
+	}
+	return query
+}
+
+// Hooks returns the client hooks.
+func (c *DiscordInteractionClient) Hooks() []Hook {
+	return c.hooks.DiscordInteraction
+}
+
+// Interceptors returns the client interceptors.
+func (c *DiscordInteractionClient) Interceptors() []Interceptor {
+	return c.inters.DiscordInteraction
+}
+
+func (c *DiscordInteractionClient) mutate(ctx context.Context, m *DiscordInteractionMutation) (Value, error) {
+	switch m.Op() {
+	case OpCreate:
+		return (&DiscordInteractionCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdate:
+		return (&DiscordInteractionUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdateOne:
+		return (&DiscordInteractionUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpDelete, OpDeleteOne:
+		return (&DiscordInteractionDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+	default:
+		return nil, fmt.Errorf("db: unknown DiscordInteraction mutation op: %q", m.Op())
+	}
+}
+
 // UserClient is a client for the User schema.
 type UserClient struct {
 	config
@@ -1468,6 +1625,22 @@ func (c *UserClient) GetX(ctx context.Context, id string) *User {
 	return obj
 }
 
+// QueryDiscordInteractions queries the discord_interactions edge of a User.
+func (c *UserClient) QueryDiscordInteractions(u *User) *DiscordInteractionQuery {
+	query := (&DiscordInteractionClient{config: c.config}).Query()
+	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+		id := u.ID
+		step := sqlgraph.NewStep(
+			sqlgraph.From(user.Table, user.FieldID, id),
+			sqlgraph.To(discordinteraction.Table, discordinteraction.FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, user.DiscordInteractionsTable, user.DiscordInteractionsColumn),
+		)
+		fromV = sqlgraph.Neighbors(u.driver.Dialect(), step)
+		return fromV, nil
+	}
+	return query
+}
+
 // QuerySubscriptions queries the subscriptions edge of a User.
 func (c *UserClient) QuerySubscriptions(u *User) *UserSubscriptionQuery {
 	query := (&UserSubscriptionClient{config: c.config}).Query()
@@ -2407,13 +2580,15 @@ func (c *VehicleSnapshotClient) mutate(ctx context.Context, m *VehicleSnapshotMu
 type (
 	hooks struct {
 		Account, AccountSnapshot, AchievementsSnapshot, AppConfiguration,
-		ApplicationCommand, Clan, CronTask, User, UserConnection, UserContent,
-		UserSubscription, Vehicle, VehicleAverage, VehicleSnapshot []ent.Hook
+		ApplicationCommand, Clan, CronTask, DiscordInteraction, User, UserConnection,
+		UserContent, UserSubscription, Vehicle, VehicleAverage,
+		VehicleSnapshot []ent.Hook
 	}
 	inters struct {
 		Account, AccountSnapshot, AchievementsSnapshot, AppConfiguration,
-		ApplicationCommand, Clan, CronTask, User, UserConnection, UserContent,
-		UserSubscription, Vehicle, VehicleAverage, VehicleSnapshot []ent.Interceptor
+		ApplicationCommand, Clan, CronTask, DiscordInteraction, User, UserConnection,
+		UserContent, UserSubscription, Vehicle, VehicleAverage,
+		VehicleSnapshot []ent.Interceptor
 	}
 )
 
diff --git a/internal/database/ent/db/discordinteraction.go b/internal/database/ent/db/discordinteraction.go
new file mode 100644
index 00000000..9ac0f690
--- /dev/null
+++ b/internal/database/ent/db/discordinteraction.go
@@ -0,0 +1,215 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+	"github.com/cufee/aftermath/internal/database/ent/db/discordinteraction"
+	"github.com/cufee/aftermath/internal/database/ent/db/user"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+// DiscordInteraction is the model entity for the DiscordInteraction schema.
+type DiscordInteraction struct {
+	config `json:"-"`
+	// ID of the ent.
+	ID string `json:"id,omitempty"`
+	// CreatedAt holds the value of the "created_at" field.
+	CreatedAt int64 `json:"created_at,omitempty"`
+	// UpdatedAt holds the value of the "updated_at" field.
+	UpdatedAt int64 `json:"updated_at,omitempty"`
+	// Command holds the value of the "command" field.
+	Command string `json:"command,omitempty"`
+	// UserID holds the value of the "user_id" field.
+	UserID string `json:"user_id,omitempty"`
+	// ReferenceID holds the value of the "reference_id" field.
+	ReferenceID string `json:"reference_id,omitempty"`
+	// Type holds the value of the "type" field.
+	Type models.DiscordInteractionType `json:"type,omitempty"`
+	// Locale holds the value of the "locale" field.
+	Locale string `json:"locale,omitempty"`
+	// Options holds the value of the "options" field.
+	Options models.DiscordInteractionOptions `json:"options,omitempty"`
+	// Edges holds the relations/edges for other nodes in the graph.
+	// The values are being populated by the DiscordInteractionQuery when eager-loading is set.
+	Edges        DiscordInteractionEdges `json:"edges"`
+	selectValues sql.SelectValues
+}
+
+// DiscordInteractionEdges holds the relations/edges for other nodes in the graph.
+type DiscordInteractionEdges struct {
+	// User holds the value of the user edge.
+	User *User `json:"user,omitempty"`
+	// loadedTypes holds the information for reporting if a
+	// type was loaded (or requested) in eager-loading or not.
+	loadedTypes [1]bool
+}
+
+// UserOrErr returns the User value or an error if the edge
+// was not loaded in eager-loading, or loaded but was not found.
+func (e DiscordInteractionEdges) UserOrErr() (*User, error) {
+	if e.User != nil {
+		return e.User, nil
+	} else if e.loadedTypes[0] {
+		return nil, &NotFoundError{label: user.Label}
+	}
+	return nil, &NotLoadedError{edge: "user"}
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*DiscordInteraction) scanValues(columns []string) ([]any, error) {
+	values := make([]any, len(columns))
+	for i := range columns {
+		switch columns[i] {
+		case discordinteraction.FieldOptions:
+			values[i] = new([]byte)
+		case discordinteraction.FieldCreatedAt, discordinteraction.FieldUpdatedAt:
+			values[i] = new(sql.NullInt64)
+		case discordinteraction.FieldID, discordinteraction.FieldCommand, discordinteraction.FieldUserID, discordinteraction.FieldReferenceID, discordinteraction.FieldType, discordinteraction.FieldLocale:
+			values[i] = new(sql.NullString)
+		default:
+			values[i] = new(sql.UnknownType)
+		}
+	}
+	return values, nil
+}
+
+// assignValues assigns the values that were returned from sql.Rows (after scanning)
+// to the DiscordInteraction fields.
+func (di *DiscordInteraction) assignValues(columns []string, values []any) error {
+	if m, n := len(values), len(columns); m < n {
+		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
+	}
+	for i := range columns {
+		switch columns[i] {
+		case discordinteraction.FieldID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field id", values[i])
+			} else if value.Valid {
+				di.ID = value.String
+			}
+		case discordinteraction.FieldCreatedAt:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field created_at", values[i])
+			} else if value.Valid {
+				di.CreatedAt = value.Int64
+			}
+		case discordinteraction.FieldUpdatedAt:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
+			} else if value.Valid {
+				di.UpdatedAt = value.Int64
+			}
+		case discordinteraction.FieldCommand:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field command", values[i])
+			} else if value.Valid {
+				di.Command = value.String
+			}
+		case discordinteraction.FieldUserID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field user_id", values[i])
+			} else if value.Valid {
+				di.UserID = value.String
+			}
+		case discordinteraction.FieldReferenceID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field reference_id", values[i])
+			} else if value.Valid {
+				di.ReferenceID = value.String
+			}
+		case discordinteraction.FieldType:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field type", values[i])
+			} else if value.Valid {
+				di.Type = models.DiscordInteractionType(value.String)
+			}
+		case discordinteraction.FieldLocale:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field locale", values[i])
+			} else if value.Valid {
+				di.Locale = value.String
+			}
+		case discordinteraction.FieldOptions:
+			if value, ok := values[i].(*[]byte); !ok {
+				return fmt.Errorf("unexpected type %T for field options", values[i])
+			} else if value != nil && len(*value) > 0 {
+				if err := json.Unmarshal(*value, &di.Options); err != nil {
+					return fmt.Errorf("unmarshal field options: %w", err)
+				}
+			}
+		default:
+			di.selectValues.Set(columns[i], values[i])
+		}
+	}
+	return nil
+}
+
+// Value returns the ent.Value that was dynamically selected and assigned to the DiscordInteraction.
+// This includes values selected through modifiers, order, etc.
+func (di *DiscordInteraction) Value(name string) (ent.Value, error) {
+	return di.selectValues.Get(name)
+}
+
+// QueryUser queries the "user" edge of the DiscordInteraction entity.
+func (di *DiscordInteraction) QueryUser() *UserQuery {
+	return NewDiscordInteractionClient(di.config).QueryUser(di)
+}
+
+// Update returns a builder for updating this DiscordInteraction.
+// Note that you need to call DiscordInteraction.Unwrap() before calling this method if this DiscordInteraction
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (di *DiscordInteraction) Update() *DiscordInteractionUpdateOne {
+	return NewDiscordInteractionClient(di.config).UpdateOne(di)
+}
+
+// Unwrap unwraps the DiscordInteraction entity that was returned from a transaction after it was closed,
+// so that all future queries will be executed through the driver which created the transaction.
+func (di *DiscordInteraction) Unwrap() *DiscordInteraction {
+	_tx, ok := di.config.driver.(*txDriver)
+	if !ok {
+		panic("db: DiscordInteraction is not a transactional entity")
+	}
+	di.config.driver = _tx.drv
+	return di
+}
+
+// String implements the fmt.Stringer.
+func (di *DiscordInteraction) String() string {
+	var builder strings.Builder
+	builder.WriteString("DiscordInteraction(")
+	builder.WriteString(fmt.Sprintf("id=%v, ", di.ID))
+	builder.WriteString("created_at=")
+	builder.WriteString(fmt.Sprintf("%v", di.CreatedAt))
+	builder.WriteString(", ")
+	builder.WriteString("updated_at=")
+	builder.WriteString(fmt.Sprintf("%v", di.UpdatedAt))
+	builder.WriteString(", ")
+	builder.WriteString("command=")
+	builder.WriteString(di.Command)
+	builder.WriteString(", ")
+	builder.WriteString("user_id=")
+	builder.WriteString(di.UserID)
+	builder.WriteString(", ")
+	builder.WriteString("reference_id=")
+	builder.WriteString(di.ReferenceID)
+	builder.WriteString(", ")
+	builder.WriteString("type=")
+	builder.WriteString(fmt.Sprintf("%v", di.Type))
+	builder.WriteString(", ")
+	builder.WriteString("locale=")
+	builder.WriteString(di.Locale)
+	builder.WriteString(", ")
+	builder.WriteString("options=")
+	builder.WriteString(fmt.Sprintf("%v", di.Options))
+	builder.WriteByte(')')
+	return builder.String()
+}
+
+// DiscordInteractions is a parsable slice of DiscordInteraction.
+type DiscordInteractions []*DiscordInteraction
diff --git a/internal/database/ent/db/discordinteraction/discordinteraction.go b/internal/database/ent/db/discordinteraction/discordinteraction.go
new file mode 100644
index 00000000..3bad3cbe
--- /dev/null
+++ b/internal/database/ent/db/discordinteraction/discordinteraction.go
@@ -0,0 +1,152 @@
+// Code generated by ent, DO NOT EDIT.
+
+package discordinteraction
+
+import (
+	"fmt"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+const (
+	// Label holds the string label denoting the discordinteraction type in the database.
+	Label = "discord_interaction"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// FieldCommand holds the string denoting the command field in the database.
+	FieldCommand = "command"
+	// FieldUserID holds the string denoting the user_id field in the database.
+	FieldUserID = "user_id"
+	// FieldReferenceID holds the string denoting the reference_id field in the database.
+	FieldReferenceID = "reference_id"
+	// FieldType holds the string denoting the type field in the database.
+	FieldType = "type"
+	// FieldLocale holds the string denoting the locale field in the database.
+	FieldLocale = "locale"
+	// FieldOptions holds the string denoting the options field in the database.
+	FieldOptions = "options"
+	// EdgeUser holds the string denoting the user edge name in mutations.
+	EdgeUser = "user"
+	// Table holds the table name of the discordinteraction in the database.
+	Table = "discord_interactions"
+	// UserTable is the table that holds the user relation/edge.
+	UserTable = "discord_interactions"
+	// UserInverseTable is the table name for the User entity.
+	// It exists in this package in order to avoid circular dependency with the "user" package.
+	UserInverseTable = "users"
+	// UserColumn is the table column denoting the user relation/edge.
+	UserColumn = "user_id"
+)
+
+// Columns holds all SQL columns for discordinteraction fields.
+var Columns = []string{
+	FieldID,
+	FieldCreatedAt,
+	FieldUpdatedAt,
+	FieldCommand,
+	FieldUserID,
+	FieldReferenceID,
+	FieldType,
+	FieldLocale,
+	FieldOptions,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() int64
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() int64
+	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
+	UpdateDefaultUpdatedAt func() int64
+	// CommandValidator is a validator for the "command" field. It is called by the builders before save.
+	CommandValidator func(string) error
+	// UserIDValidator is a validator for the "user_id" field. It is called by the builders before save.
+	UserIDValidator func(string) error
+	// ReferenceIDValidator is a validator for the "reference_id" field. It is called by the builders before save.
+	ReferenceIDValidator func(string) error
+	// DefaultID holds the default value on creation for the "id" field.
+	DefaultID func() string
+)
+
+// TypeValidator is a validator for the "type" field enum values. It is called by the builders before save.
+func TypeValidator(_type models.DiscordInteractionType) error {
+	switch _type {
+	case "stats":
+		return nil
+	default:
+		return fmt.Errorf("discordinteraction: invalid enum value for type field: %q", _type)
+	}
+}
+
+// OrderOption defines the ordering options for the DiscordInteraction queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByCommand orders the results by the command field.
+func ByCommand(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCommand, opts...).ToFunc()
+}
+
+// ByUserID orders the results by the user_id field.
+func ByUserID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUserID, opts...).ToFunc()
+}
+
+// ByReferenceID orders the results by the reference_id field.
+func ByReferenceID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldReferenceID, opts...).ToFunc()
+}
+
+// ByType orders the results by the type field.
+func ByType(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldType, opts...).ToFunc()
+}
+
+// ByLocale orders the results by the locale field.
+func ByLocale(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldLocale, opts...).ToFunc()
+}
+
+// ByUserField orders the results by user field.
+func ByUserField(field string, opts ...sql.OrderTermOption) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborTerms(s, newUserStep(), sql.OrderByField(field, opts...))
+	}
+}
+func newUserStep() *sqlgraph.Step {
+	return sqlgraph.NewStep(
+		sqlgraph.From(Table, FieldID),
+		sqlgraph.To(UserInverseTable, FieldID),
+		sqlgraph.Edge(sqlgraph.M2O, true, UserTable, UserColumn),
+	)
+}
diff --git a/internal/database/ent/db/discordinteraction/where.go b/internal/database/ent/db/discordinteraction/where.go
new file mode 100644
index 00000000..1b38d92e
--- /dev/null
+++ b/internal/database/ent/db/discordinteraction/where.go
@@ -0,0 +1,503 @@
+// Code generated by ent, DO NOT EDIT.
+
+package discordinteraction
+
+import (
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldLTE(FieldID, id))
+}
+
+// IDEqualFold applies the EqualFold predicate on the ID field.
+func IDEqualFold(id string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldEqualFold(FieldID, id))
+}
+
+// IDContainsFold applies the ContainsFold predicate on the ID field.
+func IDContainsFold(id string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldContainsFold(FieldID, id))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v int64) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v int64) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// Command applies equality check predicate on the "command" field. It's identical to CommandEQ.
+func Command(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldEQ(FieldCommand, v))
+}
+
+// UserID applies equality check predicate on the "user_id" field. It's identical to UserIDEQ.
+func UserID(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldEQ(FieldUserID, v))
+}
+
+// ReferenceID applies equality check predicate on the "reference_id" field. It's identical to ReferenceIDEQ.
+func ReferenceID(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldEQ(FieldReferenceID, v))
+}
+
+// Locale applies equality check predicate on the "locale" field. It's identical to LocaleEQ.
+func Locale(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldEQ(FieldLocale, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v int64) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v int64) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...int64) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...int64) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v int64) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v int64) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v int64) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v int64) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v int64) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v int64) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...int64) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...int64) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v int64) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v int64) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v int64) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v int64) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// CommandEQ applies the EQ predicate on the "command" field.
+func CommandEQ(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldEQ(FieldCommand, v))
+}
+
+// CommandNEQ applies the NEQ predicate on the "command" field.
+func CommandNEQ(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldNEQ(FieldCommand, v))
+}
+
+// CommandIn applies the In predicate on the "command" field.
+func CommandIn(vs ...string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldIn(FieldCommand, vs...))
+}
+
+// CommandNotIn applies the NotIn predicate on the "command" field.
+func CommandNotIn(vs ...string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldNotIn(FieldCommand, vs...))
+}
+
+// CommandGT applies the GT predicate on the "command" field.
+func CommandGT(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldGT(FieldCommand, v))
+}
+
+// CommandGTE applies the GTE predicate on the "command" field.
+func CommandGTE(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldGTE(FieldCommand, v))
+}
+
+// CommandLT applies the LT predicate on the "command" field.
+func CommandLT(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldLT(FieldCommand, v))
+}
+
+// CommandLTE applies the LTE predicate on the "command" field.
+func CommandLTE(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldLTE(FieldCommand, v))
+}
+
+// CommandContains applies the Contains predicate on the "command" field.
+func CommandContains(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldContains(FieldCommand, v))
+}
+
+// CommandHasPrefix applies the HasPrefix predicate on the "command" field.
+func CommandHasPrefix(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldHasPrefix(FieldCommand, v))
+}
+
+// CommandHasSuffix applies the HasSuffix predicate on the "command" field.
+func CommandHasSuffix(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldHasSuffix(FieldCommand, v))
+}
+
+// CommandEqualFold applies the EqualFold predicate on the "command" field.
+func CommandEqualFold(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldEqualFold(FieldCommand, v))
+}
+
+// CommandContainsFold applies the ContainsFold predicate on the "command" field.
+func CommandContainsFold(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldContainsFold(FieldCommand, v))
+}
+
+// UserIDEQ applies the EQ predicate on the "user_id" field.
+func UserIDEQ(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldEQ(FieldUserID, v))
+}
+
+// UserIDNEQ applies the NEQ predicate on the "user_id" field.
+func UserIDNEQ(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldNEQ(FieldUserID, v))
+}
+
+// UserIDIn applies the In predicate on the "user_id" field.
+func UserIDIn(vs ...string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldIn(FieldUserID, vs...))
+}
+
+// UserIDNotIn applies the NotIn predicate on the "user_id" field.
+func UserIDNotIn(vs ...string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldNotIn(FieldUserID, vs...))
+}
+
+// UserIDGT applies the GT predicate on the "user_id" field.
+func UserIDGT(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldGT(FieldUserID, v))
+}
+
+// UserIDGTE applies the GTE predicate on the "user_id" field.
+func UserIDGTE(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldGTE(FieldUserID, v))
+}
+
+// UserIDLT applies the LT predicate on the "user_id" field.
+func UserIDLT(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldLT(FieldUserID, v))
+}
+
+// UserIDLTE applies the LTE predicate on the "user_id" field.
+func UserIDLTE(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldLTE(FieldUserID, v))
+}
+
+// UserIDContains applies the Contains predicate on the "user_id" field.
+func UserIDContains(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldContains(FieldUserID, v))
+}
+
+// UserIDHasPrefix applies the HasPrefix predicate on the "user_id" field.
+func UserIDHasPrefix(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldHasPrefix(FieldUserID, v))
+}
+
+// UserIDHasSuffix applies the HasSuffix predicate on the "user_id" field.
+func UserIDHasSuffix(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldHasSuffix(FieldUserID, v))
+}
+
+// UserIDEqualFold applies the EqualFold predicate on the "user_id" field.
+func UserIDEqualFold(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldEqualFold(FieldUserID, v))
+}
+
+// UserIDContainsFold applies the ContainsFold predicate on the "user_id" field.
+func UserIDContainsFold(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldContainsFold(FieldUserID, v))
+}
+
+// ReferenceIDEQ applies the EQ predicate on the "reference_id" field.
+func ReferenceIDEQ(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldEQ(FieldReferenceID, v))
+}
+
+// ReferenceIDNEQ applies the NEQ predicate on the "reference_id" field.
+func ReferenceIDNEQ(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldNEQ(FieldReferenceID, v))
+}
+
+// ReferenceIDIn applies the In predicate on the "reference_id" field.
+func ReferenceIDIn(vs ...string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldIn(FieldReferenceID, vs...))
+}
+
+// ReferenceIDNotIn applies the NotIn predicate on the "reference_id" field.
+func ReferenceIDNotIn(vs ...string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldNotIn(FieldReferenceID, vs...))
+}
+
+// ReferenceIDGT applies the GT predicate on the "reference_id" field.
+func ReferenceIDGT(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldGT(FieldReferenceID, v))
+}
+
+// ReferenceIDGTE applies the GTE predicate on the "reference_id" field.
+func ReferenceIDGTE(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldGTE(FieldReferenceID, v))
+}
+
+// ReferenceIDLT applies the LT predicate on the "reference_id" field.
+func ReferenceIDLT(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldLT(FieldReferenceID, v))
+}
+
+// ReferenceIDLTE applies the LTE predicate on the "reference_id" field.
+func ReferenceIDLTE(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldLTE(FieldReferenceID, v))
+}
+
+// ReferenceIDContains applies the Contains predicate on the "reference_id" field.
+func ReferenceIDContains(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldContains(FieldReferenceID, v))
+}
+
+// ReferenceIDHasPrefix applies the HasPrefix predicate on the "reference_id" field.
+func ReferenceIDHasPrefix(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldHasPrefix(FieldReferenceID, v))
+}
+
+// ReferenceIDHasSuffix applies the HasSuffix predicate on the "reference_id" field.
+func ReferenceIDHasSuffix(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldHasSuffix(FieldReferenceID, v))
+}
+
+// ReferenceIDEqualFold applies the EqualFold predicate on the "reference_id" field.
+func ReferenceIDEqualFold(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldEqualFold(FieldReferenceID, v))
+}
+
+// ReferenceIDContainsFold applies the ContainsFold predicate on the "reference_id" field.
+func ReferenceIDContainsFold(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldContainsFold(FieldReferenceID, v))
+}
+
+// TypeEQ applies the EQ predicate on the "type" field.
+func TypeEQ(v models.DiscordInteractionType) predicate.DiscordInteraction {
+	vc := v
+	return predicate.DiscordInteraction(sql.FieldEQ(FieldType, vc))
+}
+
+// TypeNEQ applies the NEQ predicate on the "type" field.
+func TypeNEQ(v models.DiscordInteractionType) predicate.DiscordInteraction {
+	vc := v
+	return predicate.DiscordInteraction(sql.FieldNEQ(FieldType, vc))
+}
+
+// TypeIn applies the In predicate on the "type" field.
+func TypeIn(vs ...models.DiscordInteractionType) predicate.DiscordInteraction {
+	v := make([]any, len(vs))
+	for i := range v {
+		v[i] = vs[i]
+	}
+	return predicate.DiscordInteraction(sql.FieldIn(FieldType, v...))
+}
+
+// TypeNotIn applies the NotIn predicate on the "type" field.
+func TypeNotIn(vs ...models.DiscordInteractionType) predicate.DiscordInteraction {
+	v := make([]any, len(vs))
+	for i := range v {
+		v[i] = vs[i]
+	}
+	return predicate.DiscordInteraction(sql.FieldNotIn(FieldType, v...))
+}
+
+// LocaleEQ applies the EQ predicate on the "locale" field.
+func LocaleEQ(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldEQ(FieldLocale, v))
+}
+
+// LocaleNEQ applies the NEQ predicate on the "locale" field.
+func LocaleNEQ(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldNEQ(FieldLocale, v))
+}
+
+// LocaleIn applies the In predicate on the "locale" field.
+func LocaleIn(vs ...string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldIn(FieldLocale, vs...))
+}
+
+// LocaleNotIn applies the NotIn predicate on the "locale" field.
+func LocaleNotIn(vs ...string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldNotIn(FieldLocale, vs...))
+}
+
+// LocaleGT applies the GT predicate on the "locale" field.
+func LocaleGT(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldGT(FieldLocale, v))
+}
+
+// LocaleGTE applies the GTE predicate on the "locale" field.
+func LocaleGTE(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldGTE(FieldLocale, v))
+}
+
+// LocaleLT applies the LT predicate on the "locale" field.
+func LocaleLT(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldLT(FieldLocale, v))
+}
+
+// LocaleLTE applies the LTE predicate on the "locale" field.
+func LocaleLTE(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldLTE(FieldLocale, v))
+}
+
+// LocaleContains applies the Contains predicate on the "locale" field.
+func LocaleContains(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldContains(FieldLocale, v))
+}
+
+// LocaleHasPrefix applies the HasPrefix predicate on the "locale" field.
+func LocaleHasPrefix(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldHasPrefix(FieldLocale, v))
+}
+
+// LocaleHasSuffix applies the HasSuffix predicate on the "locale" field.
+func LocaleHasSuffix(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldHasSuffix(FieldLocale, v))
+}
+
+// LocaleEqualFold applies the EqualFold predicate on the "locale" field.
+func LocaleEqualFold(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldEqualFold(FieldLocale, v))
+}
+
+// LocaleContainsFold applies the ContainsFold predicate on the "locale" field.
+func LocaleContainsFold(v string) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.FieldContainsFold(FieldLocale, v))
+}
+
+// HasUser applies the HasEdge predicate on the "user" edge.
+func HasUser() predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, UserTable, UserColumn),
+		)
+		sqlgraph.HasNeighbors(s, step)
+	})
+}
+
+// HasUserWith applies the HasEdge predicate on the "user" edge with a given conditions (other predicates).
+func HasUserWith(preds ...predicate.User) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(func(s *sql.Selector) {
+		step := newUserStep()
+		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+			for _, p := range preds {
+				p(s)
+			}
+		})
+	})
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.DiscordInteraction) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.DiscordInteraction) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.DiscordInteraction) predicate.DiscordInteraction {
+	return predicate.DiscordInteraction(sql.NotPredicates(p))
+}
diff --git a/internal/database/ent/db/discordinteraction_create.go b/internal/database/ent/db/discordinteraction_create.go
new file mode 100644
index 00000000..45583113
--- /dev/null
+++ b/internal/database/ent/db/discordinteraction_create.go
@@ -0,0 +1,370 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/discordinteraction"
+	"github.com/cufee/aftermath/internal/database/ent/db/user"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+// DiscordInteractionCreate is the builder for creating a DiscordInteraction entity.
+type DiscordInteractionCreate struct {
+	config
+	mutation *DiscordInteractionMutation
+	hooks    []Hook
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (dic *DiscordInteractionCreate) SetCreatedAt(i int64) *DiscordInteractionCreate {
+	dic.mutation.SetCreatedAt(i)
+	return dic
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (dic *DiscordInteractionCreate) SetNillableCreatedAt(i *int64) *DiscordInteractionCreate {
+	if i != nil {
+		dic.SetCreatedAt(*i)
+	}
+	return dic
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (dic *DiscordInteractionCreate) SetUpdatedAt(i int64) *DiscordInteractionCreate {
+	dic.mutation.SetUpdatedAt(i)
+	return dic
+}
+
+// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
+func (dic *DiscordInteractionCreate) SetNillableUpdatedAt(i *int64) *DiscordInteractionCreate {
+	if i != nil {
+		dic.SetUpdatedAt(*i)
+	}
+	return dic
+}
+
+// SetCommand sets the "command" field.
+func (dic *DiscordInteractionCreate) SetCommand(s string) *DiscordInteractionCreate {
+	dic.mutation.SetCommand(s)
+	return dic
+}
+
+// SetUserID sets the "user_id" field.
+func (dic *DiscordInteractionCreate) SetUserID(s string) *DiscordInteractionCreate {
+	dic.mutation.SetUserID(s)
+	return dic
+}
+
+// SetReferenceID sets the "reference_id" field.
+func (dic *DiscordInteractionCreate) SetReferenceID(s string) *DiscordInteractionCreate {
+	dic.mutation.SetReferenceID(s)
+	return dic
+}
+
+// SetType sets the "type" field.
+func (dic *DiscordInteractionCreate) SetType(mit models.DiscordInteractionType) *DiscordInteractionCreate {
+	dic.mutation.SetType(mit)
+	return dic
+}
+
+// SetLocale sets the "locale" field.
+func (dic *DiscordInteractionCreate) SetLocale(s string) *DiscordInteractionCreate {
+	dic.mutation.SetLocale(s)
+	return dic
+}
+
+// SetOptions sets the "options" field.
+func (dic *DiscordInteractionCreate) SetOptions(mio models.DiscordInteractionOptions) *DiscordInteractionCreate {
+	dic.mutation.SetOptions(mio)
+	return dic
+}
+
+// SetID sets the "id" field.
+func (dic *DiscordInteractionCreate) SetID(s string) *DiscordInteractionCreate {
+	dic.mutation.SetID(s)
+	return dic
+}
+
+// SetNillableID sets the "id" field if the given value is not nil.
+func (dic *DiscordInteractionCreate) SetNillableID(s *string) *DiscordInteractionCreate {
+	if s != nil {
+		dic.SetID(*s)
+	}
+	return dic
+}
+
+// SetUser sets the "user" edge to the User entity.
+func (dic *DiscordInteractionCreate) SetUser(u *User) *DiscordInteractionCreate {
+	return dic.SetUserID(u.ID)
+}
+
+// Mutation returns the DiscordInteractionMutation object of the builder.
+func (dic *DiscordInteractionCreate) Mutation() *DiscordInteractionMutation {
+	return dic.mutation
+}
+
+// Save creates the DiscordInteraction in the database.
+func (dic *DiscordInteractionCreate) Save(ctx context.Context) (*DiscordInteraction, error) {
+	dic.defaults()
+	return withHooks(ctx, dic.sqlSave, dic.mutation, dic.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (dic *DiscordInteractionCreate) SaveX(ctx context.Context) *DiscordInteraction {
+	v, err := dic.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (dic *DiscordInteractionCreate) Exec(ctx context.Context) error {
+	_, err := dic.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (dic *DiscordInteractionCreate) ExecX(ctx context.Context) {
+	if err := dic.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (dic *DiscordInteractionCreate) defaults() {
+	if _, ok := dic.mutation.CreatedAt(); !ok {
+		v := discordinteraction.DefaultCreatedAt()
+		dic.mutation.SetCreatedAt(v)
+	}
+	if _, ok := dic.mutation.UpdatedAt(); !ok {
+		v := discordinteraction.DefaultUpdatedAt()
+		dic.mutation.SetUpdatedAt(v)
+	}
+	if _, ok := dic.mutation.ID(); !ok {
+		v := discordinteraction.DefaultID()
+		dic.mutation.SetID(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (dic *DiscordInteractionCreate) check() error {
+	if _, ok := dic.mutation.CreatedAt(); !ok {
+		return &ValidationError{Name: "created_at", err: errors.New(`db: missing required field "DiscordInteraction.created_at"`)}
+	}
+	if _, ok := dic.mutation.UpdatedAt(); !ok {
+		return &ValidationError{Name: "updated_at", err: errors.New(`db: missing required field "DiscordInteraction.updated_at"`)}
+	}
+	if _, ok := dic.mutation.Command(); !ok {
+		return &ValidationError{Name: "command", err: errors.New(`db: missing required field "DiscordInteraction.command"`)}
+	}
+	if v, ok := dic.mutation.Command(); ok {
+		if err := discordinteraction.CommandValidator(v); err != nil {
+			return &ValidationError{Name: "command", err: fmt.Errorf(`db: validator failed for field "DiscordInteraction.command": %w`, err)}
+		}
+	}
+	if _, ok := dic.mutation.UserID(); !ok {
+		return &ValidationError{Name: "user_id", err: errors.New(`db: missing required field "DiscordInteraction.user_id"`)}
+	}
+	if v, ok := dic.mutation.UserID(); ok {
+		if err := discordinteraction.UserIDValidator(v); err != nil {
+			return &ValidationError{Name: "user_id", err: fmt.Errorf(`db: validator failed for field "DiscordInteraction.user_id": %w`, err)}
+		}
+	}
+	if _, ok := dic.mutation.ReferenceID(); !ok {
+		return &ValidationError{Name: "reference_id", err: errors.New(`db: missing required field "DiscordInteraction.reference_id"`)}
+	}
+	if v, ok := dic.mutation.ReferenceID(); ok {
+		if err := discordinteraction.ReferenceIDValidator(v); err != nil {
+			return &ValidationError{Name: "reference_id", err: fmt.Errorf(`db: validator failed for field "DiscordInteraction.reference_id": %w`, err)}
+		}
+	}
+	if _, ok := dic.mutation.GetType(); !ok {
+		return &ValidationError{Name: "type", err: errors.New(`db: missing required field "DiscordInteraction.type"`)}
+	}
+	if v, ok := dic.mutation.GetType(); ok {
+		if err := discordinteraction.TypeValidator(v); err != nil {
+			return &ValidationError{Name: "type", err: fmt.Errorf(`db: validator failed for field "DiscordInteraction.type": %w`, err)}
+		}
+	}
+	if _, ok := dic.mutation.Locale(); !ok {
+		return &ValidationError{Name: "locale", err: errors.New(`db: missing required field "DiscordInteraction.locale"`)}
+	}
+	if _, ok := dic.mutation.Options(); !ok {
+		return &ValidationError{Name: "options", err: errors.New(`db: missing required field "DiscordInteraction.options"`)}
+	}
+	if _, ok := dic.mutation.UserID(); !ok {
+		return &ValidationError{Name: "user", err: errors.New(`db: missing required edge "DiscordInteraction.user"`)}
+	}
+	return nil
+}
+
+func (dic *DiscordInteractionCreate) sqlSave(ctx context.Context) (*DiscordInteraction, error) {
+	if err := dic.check(); err != nil {
+		return nil, err
+	}
+	_node, _spec := dic.createSpec()
+	if err := sqlgraph.CreateNode(ctx, dic.driver, _spec); err != nil {
+		if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	if _spec.ID.Value != nil {
+		if id, ok := _spec.ID.Value.(string); ok {
+			_node.ID = id
+		} else {
+			return nil, fmt.Errorf("unexpected DiscordInteraction.ID type: %T", _spec.ID.Value)
+		}
+	}
+	dic.mutation.id = &_node.ID
+	dic.mutation.done = true
+	return _node, nil
+}
+
+func (dic *DiscordInteractionCreate) createSpec() (*DiscordInteraction, *sqlgraph.CreateSpec) {
+	var (
+		_node = &DiscordInteraction{config: dic.config}
+		_spec = sqlgraph.NewCreateSpec(discordinteraction.Table, sqlgraph.NewFieldSpec(discordinteraction.FieldID, field.TypeString))
+	)
+	if id, ok := dic.mutation.ID(); ok {
+		_node.ID = id
+		_spec.ID.Value = id
+	}
+	if value, ok := dic.mutation.CreatedAt(); ok {
+		_spec.SetField(discordinteraction.FieldCreatedAt, field.TypeInt64, value)
+		_node.CreatedAt = value
+	}
+	if value, ok := dic.mutation.UpdatedAt(); ok {
+		_spec.SetField(discordinteraction.FieldUpdatedAt, field.TypeInt64, value)
+		_node.UpdatedAt = value
+	}
+	if value, ok := dic.mutation.Command(); ok {
+		_spec.SetField(discordinteraction.FieldCommand, field.TypeString, value)
+		_node.Command = value
+	}
+	if value, ok := dic.mutation.ReferenceID(); ok {
+		_spec.SetField(discordinteraction.FieldReferenceID, field.TypeString, value)
+		_node.ReferenceID = value
+	}
+	if value, ok := dic.mutation.GetType(); ok {
+		_spec.SetField(discordinteraction.FieldType, field.TypeEnum, value)
+		_node.Type = value
+	}
+	if value, ok := dic.mutation.Locale(); ok {
+		_spec.SetField(discordinteraction.FieldLocale, field.TypeString, value)
+		_node.Locale = value
+	}
+	if value, ok := dic.mutation.Options(); ok {
+		_spec.SetField(discordinteraction.FieldOptions, field.TypeJSON, value)
+		_node.Options = value
+	}
+	if nodes := dic.mutation.UserIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   discordinteraction.UserTable,
+			Columns: []string{discordinteraction.UserColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_node.UserID = nodes[0]
+		_spec.Edges = append(_spec.Edges, edge)
+	}
+	return _node, _spec
+}
+
+// DiscordInteractionCreateBulk is the builder for creating many DiscordInteraction entities in bulk.
+type DiscordInteractionCreateBulk struct {
+	config
+	err      error
+	builders []*DiscordInteractionCreate
+}
+
+// Save creates the DiscordInteraction entities in the database.
+func (dicb *DiscordInteractionCreateBulk) Save(ctx context.Context) ([]*DiscordInteraction, error) {
+	if dicb.err != nil {
+		return nil, dicb.err
+	}
+	specs := make([]*sqlgraph.CreateSpec, len(dicb.builders))
+	nodes := make([]*DiscordInteraction, len(dicb.builders))
+	mutators := make([]Mutator, len(dicb.builders))
+	for i := range dicb.builders {
+		func(i int, root context.Context) {
+			builder := dicb.builders[i]
+			builder.defaults()
+			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+				mutation, ok := m.(*DiscordInteractionMutation)
+				if !ok {
+					return nil, fmt.Errorf("unexpected mutation type %T", m)
+				}
+				if err := builder.check(); err != nil {
+					return nil, err
+				}
+				builder.mutation = mutation
+				var err error
+				nodes[i], specs[i] = builder.createSpec()
+				if i < len(mutators)-1 {
+					_, err = mutators[i+1].Mutate(root, dicb.builders[i+1].mutation)
+				} else {
+					spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
+					// Invoke the actual operation on the latest mutation in the chain.
+					if err = sqlgraph.BatchCreate(ctx, dicb.driver, spec); err != nil {
+						if sqlgraph.IsConstraintError(err) {
+							err = &ConstraintError{msg: err.Error(), wrap: err}
+						}
+					}
+				}
+				if err != nil {
+					return nil, err
+				}
+				mutation.id = &nodes[i].ID
+				mutation.done = true
+				return nodes[i], nil
+			})
+			for i := len(builder.hooks) - 1; i >= 0; i-- {
+				mut = builder.hooks[i](mut)
+			}
+			mutators[i] = mut
+		}(i, ctx)
+	}
+	if len(mutators) > 0 {
+		if _, err := mutators[0].Mutate(ctx, dicb.builders[0].mutation); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (dicb *DiscordInteractionCreateBulk) SaveX(ctx context.Context) []*DiscordInteraction {
+	v, err := dicb.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (dicb *DiscordInteractionCreateBulk) Exec(ctx context.Context) error {
+	_, err := dicb.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (dicb *DiscordInteractionCreateBulk) ExecX(ctx context.Context) {
+	if err := dicb.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/database/ent/db/discordinteraction_delete.go b/internal/database/ent/db/discordinteraction_delete.go
new file mode 100644
index 00000000..461aeb8e
--- /dev/null
+++ b/internal/database/ent/db/discordinteraction_delete.go
@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/discordinteraction"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+)
+
+// DiscordInteractionDelete is the builder for deleting a DiscordInteraction entity.
+type DiscordInteractionDelete struct {
+	config
+	hooks    []Hook
+	mutation *DiscordInteractionMutation
+}
+
+// Where appends a list predicates to the DiscordInteractionDelete builder.
+func (did *DiscordInteractionDelete) Where(ps ...predicate.DiscordInteraction) *DiscordInteractionDelete {
+	did.mutation.Where(ps...)
+	return did
+}
+
+// Exec executes the deletion query and returns how many vertices were deleted.
+func (did *DiscordInteractionDelete) Exec(ctx context.Context) (int, error) {
+	return withHooks(ctx, did.sqlExec, did.mutation, did.hooks)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (did *DiscordInteractionDelete) ExecX(ctx context.Context) int {
+	n, err := did.Exec(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return n
+}
+
+func (did *DiscordInteractionDelete) sqlExec(ctx context.Context) (int, error) {
+	_spec := sqlgraph.NewDeleteSpec(discordinteraction.Table, sqlgraph.NewFieldSpec(discordinteraction.FieldID, field.TypeString))
+	if ps := did.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	affected, err := sqlgraph.DeleteNodes(ctx, did.driver, _spec)
+	if err != nil && sqlgraph.IsConstraintError(err) {
+		err = &ConstraintError{msg: err.Error(), wrap: err}
+	}
+	did.mutation.done = true
+	return affected, err
+}
+
+// DiscordInteractionDeleteOne is the builder for deleting a single DiscordInteraction entity.
+type DiscordInteractionDeleteOne struct {
+	did *DiscordInteractionDelete
+}
+
+// Where appends a list predicates to the DiscordInteractionDelete builder.
+func (dido *DiscordInteractionDeleteOne) Where(ps ...predicate.DiscordInteraction) *DiscordInteractionDeleteOne {
+	dido.did.mutation.Where(ps...)
+	return dido
+}
+
+// Exec executes the deletion query.
+func (dido *DiscordInteractionDeleteOne) Exec(ctx context.Context) error {
+	n, err := dido.did.Exec(ctx)
+	switch {
+	case err != nil:
+		return err
+	case n == 0:
+		return &NotFoundError{discordinteraction.Label}
+	default:
+		return nil
+	}
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (dido *DiscordInteractionDeleteOne) ExecX(ctx context.Context) {
+	if err := dido.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/database/ent/db/discordinteraction_query.go b/internal/database/ent/db/discordinteraction_query.go
new file mode 100644
index 00000000..bd085984
--- /dev/null
+++ b/internal/database/ent/db/discordinteraction_query.go
@@ -0,0 +1,605 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"fmt"
+	"math"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/discordinteraction"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/ent/db/user"
+)
+
+// DiscordInteractionQuery is the builder for querying DiscordInteraction entities.
+type DiscordInteractionQuery struct {
+	config
+	ctx        *QueryContext
+	order      []discordinteraction.OrderOption
+	inters     []Interceptor
+	predicates []predicate.DiscordInteraction
+	withUser   *UserQuery
+	// intermediate query (i.e. traversal path).
+	sql  *sql.Selector
+	path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the DiscordInteractionQuery builder.
+func (diq *DiscordInteractionQuery) Where(ps ...predicate.DiscordInteraction) *DiscordInteractionQuery {
+	diq.predicates = append(diq.predicates, ps...)
+	return diq
+}
+
+// Limit the number of records to be returned by this query.
+func (diq *DiscordInteractionQuery) Limit(limit int) *DiscordInteractionQuery {
+	diq.ctx.Limit = &limit
+	return diq
+}
+
+// Offset to start from.
+func (diq *DiscordInteractionQuery) Offset(offset int) *DiscordInteractionQuery {
+	diq.ctx.Offset = &offset
+	return diq
+}
+
+// Unique configures the query builder to filter duplicate records on query.
+// By default, unique is set to true, and can be disabled using this method.
+func (diq *DiscordInteractionQuery) Unique(unique bool) *DiscordInteractionQuery {
+	diq.ctx.Unique = &unique
+	return diq
+}
+
+// Order specifies how the records should be ordered.
+func (diq *DiscordInteractionQuery) Order(o ...discordinteraction.OrderOption) *DiscordInteractionQuery {
+	diq.order = append(diq.order, o...)
+	return diq
+}
+
+// QueryUser chains the current query on the "user" edge.
+func (diq *DiscordInteractionQuery) QueryUser() *UserQuery {
+	query := (&UserClient{config: diq.config}).Query()
+	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+		if err := diq.prepareQuery(ctx); err != nil {
+			return nil, err
+		}
+		selector := diq.sqlQuery(ctx)
+		if err := selector.Err(); err != nil {
+			return nil, err
+		}
+		step := sqlgraph.NewStep(
+			sqlgraph.From(discordinteraction.Table, discordinteraction.FieldID, selector),
+			sqlgraph.To(user.Table, user.FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, discordinteraction.UserTable, discordinteraction.UserColumn),
+		)
+		fromU = sqlgraph.SetNeighbors(diq.driver.Dialect(), step)
+		return fromU, nil
+	}
+	return query
+}
+
+// First returns the first DiscordInteraction entity from the query.
+// Returns a *NotFoundError when no DiscordInteraction was found.
+func (diq *DiscordInteractionQuery) First(ctx context.Context) (*DiscordInteraction, error) {
+	nodes, err := diq.Limit(1).All(setContextOp(ctx, diq.ctx, "First"))
+	if err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nil, &NotFoundError{discordinteraction.Label}
+	}
+	return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (diq *DiscordInteractionQuery) FirstX(ctx context.Context) *DiscordInteraction {
+	node, err := diq.First(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return node
+}
+
+// FirstID returns the first DiscordInteraction ID from the query.
+// Returns a *NotFoundError when no DiscordInteraction ID was found.
+func (diq *DiscordInteractionQuery) FirstID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = diq.Limit(1).IDs(setContextOp(ctx, diq.ctx, "FirstID")); err != nil {
+		return
+	}
+	if len(ids) == 0 {
+		err = &NotFoundError{discordinteraction.Label}
+		return
+	}
+	return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (diq *DiscordInteractionQuery) FirstIDX(ctx context.Context) string {
+	id, err := diq.FirstID(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return id
+}
+
+// Only returns a single DiscordInteraction entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one DiscordInteraction entity is found.
+// Returns a *NotFoundError when no DiscordInteraction entities are found.
+func (diq *DiscordInteractionQuery) Only(ctx context.Context) (*DiscordInteraction, error) {
+	nodes, err := diq.Limit(2).All(setContextOp(ctx, diq.ctx, "Only"))
+	if err != nil {
+		return nil, err
+	}
+	switch len(nodes) {
+	case 1:
+		return nodes[0], nil
+	case 0:
+		return nil, &NotFoundError{discordinteraction.Label}
+	default:
+		return nil, &NotSingularError{discordinteraction.Label}
+	}
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (diq *DiscordInteractionQuery) OnlyX(ctx context.Context) *DiscordInteraction {
+	node, err := diq.Only(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// OnlyID is like Only, but returns the only DiscordInteraction ID in the query.
+// Returns a *NotSingularError when more than one DiscordInteraction ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (diq *DiscordInteractionQuery) OnlyID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = diq.Limit(2).IDs(setContextOp(ctx, diq.ctx, "OnlyID")); err != nil {
+		return
+	}
+	switch len(ids) {
+	case 1:
+		id = ids[0]
+	case 0:
+		err = &NotFoundError{discordinteraction.Label}
+	default:
+		err = &NotSingularError{discordinteraction.Label}
+	}
+	return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (diq *DiscordInteractionQuery) OnlyIDX(ctx context.Context) string {
+	id, err := diq.OnlyID(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return id
+}
+
+// All executes the query and returns a list of DiscordInteractions.
+func (diq *DiscordInteractionQuery) All(ctx context.Context) ([]*DiscordInteraction, error) {
+	ctx = setContextOp(ctx, diq.ctx, "All")
+	if err := diq.prepareQuery(ctx); err != nil {
+		return nil, err
+	}
+	qr := querierAll[[]*DiscordInteraction, *DiscordInteractionQuery]()
+	return withInterceptors[[]*DiscordInteraction](ctx, diq, qr, diq.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (diq *DiscordInteractionQuery) AllX(ctx context.Context) []*DiscordInteraction {
+	nodes, err := diq.All(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return nodes
+}
+
+// IDs executes the query and returns a list of DiscordInteraction IDs.
+func (diq *DiscordInteractionQuery) IDs(ctx context.Context) (ids []string, err error) {
+	if diq.ctx.Unique == nil && diq.path != nil {
+		diq.Unique(true)
+	}
+	ctx = setContextOp(ctx, diq.ctx, "IDs")
+	if err = diq.Select(discordinteraction.FieldID).Scan(ctx, &ids); err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (diq *DiscordInteractionQuery) IDsX(ctx context.Context) []string {
+	ids, err := diq.IDs(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return ids
+}
+
+// Count returns the count of the given query.
+func (diq *DiscordInteractionQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, diq.ctx, "Count")
+	if err := diq.prepareQuery(ctx); err != nil {
+		return 0, err
+	}
+	return withInterceptors[int](ctx, diq, querierCount[*DiscordInteractionQuery](), diq.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (diq *DiscordInteractionQuery) CountX(ctx context.Context) int {
+	count, err := diq.Count(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (diq *DiscordInteractionQuery) Exist(ctx context.Context) (bool, error) {
+	ctx = setContextOp(ctx, diq.ctx, "Exist")
+	switch _, err := diq.FirstID(ctx); {
+	case IsNotFound(err):
+		return false, nil
+	case err != nil:
+		return false, fmt.Errorf("db: check existence: %w", err)
+	default:
+		return true, nil
+	}
+}
+
+// ExistX is like Exist, but panics if an error occurs.
+func (diq *DiscordInteractionQuery) ExistX(ctx context.Context) bool {
+	exist, err := diq.Exist(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return exist
+}
+
+// Clone returns a duplicate of the DiscordInteractionQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (diq *DiscordInteractionQuery) Clone() *DiscordInteractionQuery {
+	if diq == nil {
+		return nil
+	}
+	return &DiscordInteractionQuery{
+		config:     diq.config,
+		ctx:        diq.ctx.Clone(),
+		order:      append([]discordinteraction.OrderOption{}, diq.order...),
+		inters:     append([]Interceptor{}, diq.inters...),
+		predicates: append([]predicate.DiscordInteraction{}, diq.predicates...),
+		withUser:   diq.withUser.Clone(),
+		// clone intermediate query.
+		sql:  diq.sql.Clone(),
+		path: diq.path,
+	}
+}
+
+// WithUser tells the query-builder to eager-load the nodes that are connected to
+// the "user" edge. The optional arguments are used to configure the query builder of the edge.
+func (diq *DiscordInteractionQuery) WithUser(opts ...func(*UserQuery)) *DiscordInteractionQuery {
+	query := (&UserClient{config: diq.config}).Query()
+	for _, opt := range opts {
+		opt(query)
+	}
+	diq.withUser = query
+	return diq
+}
+
+// GroupBy is used to group vertices by one or more fields/columns.
+// It is often used with aggregate functions, like: count, max, mean, min, sum.
+//
+// Example:
+//
+//	var v []struct {
+//		CreatedAt int64 `json:"created_at,omitempty"`
+//		Count int `json:"count,omitempty"`
+//	}
+//
+//	client.DiscordInteraction.Query().
+//		GroupBy(discordinteraction.FieldCreatedAt).
+//		Aggregate(db.Count()).
+//		Scan(ctx, &v)
+func (diq *DiscordInteractionQuery) GroupBy(field string, fields ...string) *DiscordInteractionGroupBy {
+	diq.ctx.Fields = append([]string{field}, fields...)
+	grbuild := &DiscordInteractionGroupBy{build: diq}
+	grbuild.flds = &diq.ctx.Fields
+	grbuild.label = discordinteraction.Label
+	grbuild.scan = grbuild.Scan
+	return grbuild
+}
+
+// Select allows the selection one or more fields/columns for the given query,
+// instead of selecting all fields in the entity.
+//
+// Example:
+//
+//	var v []struct {
+//		CreatedAt int64 `json:"created_at,omitempty"`
+//	}
+//
+//	client.DiscordInteraction.Query().
+//		Select(discordinteraction.FieldCreatedAt).
+//		Scan(ctx, &v)
+func (diq *DiscordInteractionQuery) Select(fields ...string) *DiscordInteractionSelect {
+	diq.ctx.Fields = append(diq.ctx.Fields, fields...)
+	sbuild := &DiscordInteractionSelect{DiscordInteractionQuery: diq}
+	sbuild.label = discordinteraction.Label
+	sbuild.flds, sbuild.scan = &diq.ctx.Fields, sbuild.Scan
+	return sbuild
+}
+
+// Aggregate returns a DiscordInteractionSelect configured with the given aggregations.
+func (diq *DiscordInteractionQuery) Aggregate(fns ...AggregateFunc) *DiscordInteractionSelect {
+	return diq.Select().Aggregate(fns...)
+}
+
+func (diq *DiscordInteractionQuery) prepareQuery(ctx context.Context) error {
+	for _, inter := range diq.inters {
+		if inter == nil {
+			return fmt.Errorf("db: uninitialized interceptor (forgotten import db/runtime?)")
+		}
+		if trv, ok := inter.(Traverser); ok {
+			if err := trv.Traverse(ctx, diq); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range diq.ctx.Fields {
+		if !discordinteraction.ValidColumn(f) {
+			return &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+		}
+	}
+	if diq.path != nil {
+		prev, err := diq.path(ctx)
+		if err != nil {
+			return err
+		}
+		diq.sql = prev
+	}
+	return nil
+}
+
+func (diq *DiscordInteractionQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*DiscordInteraction, error) {
+	var (
+		nodes       = []*DiscordInteraction{}
+		_spec       = diq.querySpec()
+		loadedTypes = [1]bool{
+			diq.withUser != nil,
+		}
+	)
+	_spec.ScanValues = func(columns []string) ([]any, error) {
+		return (*DiscordInteraction).scanValues(nil, columns)
+	}
+	_spec.Assign = func(columns []string, values []any) error {
+		node := &DiscordInteraction{config: diq.config}
+		nodes = append(nodes, node)
+		node.Edges.loadedTypes = loadedTypes
+		return node.assignValues(columns, values)
+	}
+	for i := range hooks {
+		hooks[i](ctx, _spec)
+	}
+	if err := sqlgraph.QueryNodes(ctx, diq.driver, _spec); err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nodes, nil
+	}
+	if query := diq.withUser; query != nil {
+		if err := diq.loadUser(ctx, query, nodes, nil,
+			func(n *DiscordInteraction, e *User) { n.Edges.User = e }); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+func (diq *DiscordInteractionQuery) loadUser(ctx context.Context, query *UserQuery, nodes []*DiscordInteraction, init func(*DiscordInteraction), assign func(*DiscordInteraction, *User)) error {
+	ids := make([]string, 0, len(nodes))
+	nodeids := make(map[string][]*DiscordInteraction)
+	for i := range nodes {
+		fk := nodes[i].UserID
+		if _, ok := nodeids[fk]; !ok {
+			ids = append(ids, fk)
+		}
+		nodeids[fk] = append(nodeids[fk], nodes[i])
+	}
+	if len(ids) == 0 {
+		return nil
+	}
+	query.Where(user.IDIn(ids...))
+	neighbors, err := query.All(ctx)
+	if err != nil {
+		return err
+	}
+	for _, n := range neighbors {
+		nodes, ok := nodeids[n.ID]
+		if !ok {
+			return fmt.Errorf(`unexpected foreign-key "user_id" returned %v`, n.ID)
+		}
+		for i := range nodes {
+			assign(nodes[i], n)
+		}
+	}
+	return nil
+}
+
+func (diq *DiscordInteractionQuery) sqlCount(ctx context.Context) (int, error) {
+	_spec := diq.querySpec()
+	_spec.Node.Columns = diq.ctx.Fields
+	if len(diq.ctx.Fields) > 0 {
+		_spec.Unique = diq.ctx.Unique != nil && *diq.ctx.Unique
+	}
+	return sqlgraph.CountNodes(ctx, diq.driver, _spec)
+}
+
+func (diq *DiscordInteractionQuery) querySpec() *sqlgraph.QuerySpec {
+	_spec := sqlgraph.NewQuerySpec(discordinteraction.Table, discordinteraction.Columns, sqlgraph.NewFieldSpec(discordinteraction.FieldID, field.TypeString))
+	_spec.From = diq.sql
+	if unique := diq.ctx.Unique; unique != nil {
+		_spec.Unique = *unique
+	} else if diq.path != nil {
+		_spec.Unique = true
+	}
+	if fields := diq.ctx.Fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, discordinteraction.FieldID)
+		for i := range fields {
+			if fields[i] != discordinteraction.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+			}
+		}
+		if diq.withUser != nil {
+			_spec.Node.AddColumnOnce(discordinteraction.FieldUserID)
+		}
+	}
+	if ps := diq.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if limit := diq.ctx.Limit; limit != nil {
+		_spec.Limit = *limit
+	}
+	if offset := diq.ctx.Offset; offset != nil {
+		_spec.Offset = *offset
+	}
+	if ps := diq.order; len(ps) > 0 {
+		_spec.Order = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	return _spec
+}
+
+func (diq *DiscordInteractionQuery) sqlQuery(ctx context.Context) *sql.Selector {
+	builder := sql.Dialect(diq.driver.Dialect())
+	t1 := builder.Table(discordinteraction.Table)
+	columns := diq.ctx.Fields
+	if len(columns) == 0 {
+		columns = discordinteraction.Columns
+	}
+	selector := builder.Select(t1.Columns(columns...)...).From(t1)
+	if diq.sql != nil {
+		selector = diq.sql
+		selector.Select(selector.Columns(columns...)...)
+	}
+	if diq.ctx.Unique != nil && *diq.ctx.Unique {
+		selector.Distinct()
+	}
+	for _, p := range diq.predicates {
+		p(selector)
+	}
+	for _, p := range diq.order {
+		p(selector)
+	}
+	if offset := diq.ctx.Offset; offset != nil {
+		// limit is mandatory for offset clause. We start
+		// with default value, and override it below if needed.
+		selector.Offset(*offset).Limit(math.MaxInt32)
+	}
+	if limit := diq.ctx.Limit; limit != nil {
+		selector.Limit(*limit)
+	}
+	return selector
+}
+
+// DiscordInteractionGroupBy is the group-by builder for DiscordInteraction entities.
+type DiscordInteractionGroupBy struct {
+	selector
+	build *DiscordInteractionQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (digb *DiscordInteractionGroupBy) Aggregate(fns ...AggregateFunc) *DiscordInteractionGroupBy {
+	digb.fns = append(digb.fns, fns...)
+	return digb
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (digb *DiscordInteractionGroupBy) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, digb.build.ctx, "GroupBy")
+	if err := digb.build.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*DiscordInteractionQuery, *DiscordInteractionGroupBy](ctx, digb.build, digb, digb.build.inters, v)
+}
+
+func (digb *DiscordInteractionGroupBy) sqlScan(ctx context.Context, root *DiscordInteractionQuery, v any) error {
+	selector := root.sqlQuery(ctx).Select()
+	aggregation := make([]string, 0, len(digb.fns))
+	for _, fn := range digb.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*digb.flds)+len(digb.fns))
+		for _, f := range *digb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*digb.flds...)...)
+	if err := selector.Err(); err != nil {
+		return err
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := digb.build.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
+
+// DiscordInteractionSelect is the builder for selecting fields of DiscordInteraction entities.
+type DiscordInteractionSelect struct {
+	*DiscordInteractionQuery
+	selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (dis *DiscordInteractionSelect) Aggregate(fns ...AggregateFunc) *DiscordInteractionSelect {
+	dis.fns = append(dis.fns, fns...)
+	return dis
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (dis *DiscordInteractionSelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, dis.ctx, "Select")
+	if err := dis.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*DiscordInteractionQuery, *DiscordInteractionSelect](ctx, dis.DiscordInteractionQuery, dis, dis.inters, v)
+}
+
+func (dis *DiscordInteractionSelect) sqlScan(ctx context.Context, root *DiscordInteractionQuery, v any) error {
+	selector := root.sqlQuery(ctx)
+	aggregation := make([]string, 0, len(dis.fns))
+	for _, fn := range dis.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	switch n := len(*dis.selector.flds); {
+	case n == 0 && len(aggregation) > 0:
+		selector.Select(aggregation...)
+	case n != 0 && len(aggregation) > 0:
+		selector.AppendSelect(aggregation...)
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := dis.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
diff --git a/internal/database/ent/db/discordinteraction_update.go b/internal/database/ent/db/discordinteraction_update.go
new file mode 100644
index 00000000..3b039729
--- /dev/null
+++ b/internal/database/ent/db/discordinteraction_update.go
@@ -0,0 +1,454 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/discordinteraction"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+// DiscordInteractionUpdate is the builder for updating DiscordInteraction entities.
+type DiscordInteractionUpdate struct {
+	config
+	hooks    []Hook
+	mutation *DiscordInteractionMutation
+}
+
+// Where appends a list predicates to the DiscordInteractionUpdate builder.
+func (diu *DiscordInteractionUpdate) Where(ps ...predicate.DiscordInteraction) *DiscordInteractionUpdate {
+	diu.mutation.Where(ps...)
+	return diu
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (diu *DiscordInteractionUpdate) SetUpdatedAt(i int64) *DiscordInteractionUpdate {
+	diu.mutation.ResetUpdatedAt()
+	diu.mutation.SetUpdatedAt(i)
+	return diu
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (diu *DiscordInteractionUpdate) AddUpdatedAt(i int64) *DiscordInteractionUpdate {
+	diu.mutation.AddUpdatedAt(i)
+	return diu
+}
+
+// SetCommand sets the "command" field.
+func (diu *DiscordInteractionUpdate) SetCommand(s string) *DiscordInteractionUpdate {
+	diu.mutation.SetCommand(s)
+	return diu
+}
+
+// SetNillableCommand sets the "command" field if the given value is not nil.
+func (diu *DiscordInteractionUpdate) SetNillableCommand(s *string) *DiscordInteractionUpdate {
+	if s != nil {
+		diu.SetCommand(*s)
+	}
+	return diu
+}
+
+// SetReferenceID sets the "reference_id" field.
+func (diu *DiscordInteractionUpdate) SetReferenceID(s string) *DiscordInteractionUpdate {
+	diu.mutation.SetReferenceID(s)
+	return diu
+}
+
+// SetNillableReferenceID sets the "reference_id" field if the given value is not nil.
+func (diu *DiscordInteractionUpdate) SetNillableReferenceID(s *string) *DiscordInteractionUpdate {
+	if s != nil {
+		diu.SetReferenceID(*s)
+	}
+	return diu
+}
+
+// SetType sets the "type" field.
+func (diu *DiscordInteractionUpdate) SetType(mit models.DiscordInteractionType) *DiscordInteractionUpdate {
+	diu.mutation.SetType(mit)
+	return diu
+}
+
+// SetNillableType sets the "type" field if the given value is not nil.
+func (diu *DiscordInteractionUpdate) SetNillableType(mit *models.DiscordInteractionType) *DiscordInteractionUpdate {
+	if mit != nil {
+		diu.SetType(*mit)
+	}
+	return diu
+}
+
+// SetLocale sets the "locale" field.
+func (diu *DiscordInteractionUpdate) SetLocale(s string) *DiscordInteractionUpdate {
+	diu.mutation.SetLocale(s)
+	return diu
+}
+
+// SetNillableLocale sets the "locale" field if the given value is not nil.
+func (diu *DiscordInteractionUpdate) SetNillableLocale(s *string) *DiscordInteractionUpdate {
+	if s != nil {
+		diu.SetLocale(*s)
+	}
+	return diu
+}
+
+// SetOptions sets the "options" field.
+func (diu *DiscordInteractionUpdate) SetOptions(mio models.DiscordInteractionOptions) *DiscordInteractionUpdate {
+	diu.mutation.SetOptions(mio)
+	return diu
+}
+
+// SetNillableOptions sets the "options" field if the given value is not nil.
+func (diu *DiscordInteractionUpdate) SetNillableOptions(mio *models.DiscordInteractionOptions) *DiscordInteractionUpdate {
+	if mio != nil {
+		diu.SetOptions(*mio)
+	}
+	return diu
+}
+
+// Mutation returns the DiscordInteractionMutation object of the builder.
+func (diu *DiscordInteractionUpdate) Mutation() *DiscordInteractionMutation {
+	return diu.mutation
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (diu *DiscordInteractionUpdate) Save(ctx context.Context) (int, error) {
+	diu.defaults()
+	return withHooks(ctx, diu.sqlSave, diu.mutation, diu.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (diu *DiscordInteractionUpdate) SaveX(ctx context.Context) int {
+	affected, err := diu.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return affected
+}
+
+// Exec executes the query.
+func (diu *DiscordInteractionUpdate) Exec(ctx context.Context) error {
+	_, err := diu.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (diu *DiscordInteractionUpdate) ExecX(ctx context.Context) {
+	if err := diu.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (diu *DiscordInteractionUpdate) defaults() {
+	if _, ok := diu.mutation.UpdatedAt(); !ok {
+		v := discordinteraction.UpdateDefaultUpdatedAt()
+		diu.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (diu *DiscordInteractionUpdate) check() error {
+	if v, ok := diu.mutation.Command(); ok {
+		if err := discordinteraction.CommandValidator(v); err != nil {
+			return &ValidationError{Name: "command", err: fmt.Errorf(`db: validator failed for field "DiscordInteraction.command": %w`, err)}
+		}
+	}
+	if v, ok := diu.mutation.ReferenceID(); ok {
+		if err := discordinteraction.ReferenceIDValidator(v); err != nil {
+			return &ValidationError{Name: "reference_id", err: fmt.Errorf(`db: validator failed for field "DiscordInteraction.reference_id": %w`, err)}
+		}
+	}
+	if v, ok := diu.mutation.GetType(); ok {
+		if err := discordinteraction.TypeValidator(v); err != nil {
+			return &ValidationError{Name: "type", err: fmt.Errorf(`db: validator failed for field "DiscordInteraction.type": %w`, err)}
+		}
+	}
+	if _, ok := diu.mutation.UserID(); diu.mutation.UserCleared() && !ok {
+		return errors.New(`db: clearing a required unique edge "DiscordInteraction.user"`)
+	}
+	return nil
+}
+
+func (diu *DiscordInteractionUpdate) sqlSave(ctx context.Context) (n int, err error) {
+	if err := diu.check(); err != nil {
+		return n, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(discordinteraction.Table, discordinteraction.Columns, sqlgraph.NewFieldSpec(discordinteraction.FieldID, field.TypeString))
+	if ps := diu.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := diu.mutation.UpdatedAt(); ok {
+		_spec.SetField(discordinteraction.FieldUpdatedAt, field.TypeInt64, value)
+	}
+	if value, ok := diu.mutation.AddedUpdatedAt(); ok {
+		_spec.AddField(discordinteraction.FieldUpdatedAt, field.TypeInt64, value)
+	}
+	if value, ok := diu.mutation.Command(); ok {
+		_spec.SetField(discordinteraction.FieldCommand, field.TypeString, value)
+	}
+	if value, ok := diu.mutation.ReferenceID(); ok {
+		_spec.SetField(discordinteraction.FieldReferenceID, field.TypeString, value)
+	}
+	if value, ok := diu.mutation.GetType(); ok {
+		_spec.SetField(discordinteraction.FieldType, field.TypeEnum, value)
+	}
+	if value, ok := diu.mutation.Locale(); ok {
+		_spec.SetField(discordinteraction.FieldLocale, field.TypeString, value)
+	}
+	if value, ok := diu.mutation.Options(); ok {
+		_spec.SetField(discordinteraction.FieldOptions, field.TypeJSON, value)
+	}
+	if n, err = sqlgraph.UpdateNodes(ctx, diu.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{discordinteraction.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return 0, err
+	}
+	diu.mutation.done = true
+	return n, nil
+}
+
+// DiscordInteractionUpdateOne is the builder for updating a single DiscordInteraction entity.
+type DiscordInteractionUpdateOne struct {
+	config
+	fields   []string
+	hooks    []Hook
+	mutation *DiscordInteractionMutation
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (diuo *DiscordInteractionUpdateOne) SetUpdatedAt(i int64) *DiscordInteractionUpdateOne {
+	diuo.mutation.ResetUpdatedAt()
+	diuo.mutation.SetUpdatedAt(i)
+	return diuo
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (diuo *DiscordInteractionUpdateOne) AddUpdatedAt(i int64) *DiscordInteractionUpdateOne {
+	diuo.mutation.AddUpdatedAt(i)
+	return diuo
+}
+
+// SetCommand sets the "command" field.
+func (diuo *DiscordInteractionUpdateOne) SetCommand(s string) *DiscordInteractionUpdateOne {
+	diuo.mutation.SetCommand(s)
+	return diuo
+}
+
+// SetNillableCommand sets the "command" field if the given value is not nil.
+func (diuo *DiscordInteractionUpdateOne) SetNillableCommand(s *string) *DiscordInteractionUpdateOne {
+	if s != nil {
+		diuo.SetCommand(*s)
+	}
+	return diuo
+}
+
+// SetReferenceID sets the "reference_id" field.
+func (diuo *DiscordInteractionUpdateOne) SetReferenceID(s string) *DiscordInteractionUpdateOne {
+	diuo.mutation.SetReferenceID(s)
+	return diuo
+}
+
+// SetNillableReferenceID sets the "reference_id" field if the given value is not nil.
+func (diuo *DiscordInteractionUpdateOne) SetNillableReferenceID(s *string) *DiscordInteractionUpdateOne {
+	if s != nil {
+		diuo.SetReferenceID(*s)
+	}
+	return diuo
+}
+
+// SetType sets the "type" field.
+func (diuo *DiscordInteractionUpdateOne) SetType(mit models.DiscordInteractionType) *DiscordInteractionUpdateOne {
+	diuo.mutation.SetType(mit)
+	return diuo
+}
+
+// SetNillableType sets the "type" field if the given value is not nil.
+func (diuo *DiscordInteractionUpdateOne) SetNillableType(mit *models.DiscordInteractionType) *DiscordInteractionUpdateOne {
+	if mit != nil {
+		diuo.SetType(*mit)
+	}
+	return diuo
+}
+
+// SetLocale sets the "locale" field.
+func (diuo *DiscordInteractionUpdateOne) SetLocale(s string) *DiscordInteractionUpdateOne {
+	diuo.mutation.SetLocale(s)
+	return diuo
+}
+
+// SetNillableLocale sets the "locale" field if the given value is not nil.
+func (diuo *DiscordInteractionUpdateOne) SetNillableLocale(s *string) *DiscordInteractionUpdateOne {
+	if s != nil {
+		diuo.SetLocale(*s)
+	}
+	return diuo
+}
+
+// SetOptions sets the "options" field.
+func (diuo *DiscordInteractionUpdateOne) SetOptions(mio models.DiscordInteractionOptions) *DiscordInteractionUpdateOne {
+	diuo.mutation.SetOptions(mio)
+	return diuo
+}
+
+// SetNillableOptions sets the "options" field if the given value is not nil.
+func (diuo *DiscordInteractionUpdateOne) SetNillableOptions(mio *models.DiscordInteractionOptions) *DiscordInteractionUpdateOne {
+	if mio != nil {
+		diuo.SetOptions(*mio)
+	}
+	return diuo
+}
+
+// Mutation returns the DiscordInteractionMutation object of the builder.
+func (diuo *DiscordInteractionUpdateOne) Mutation() *DiscordInteractionMutation {
+	return diuo.mutation
+}
+
+// Where appends a list predicates to the DiscordInteractionUpdate builder.
+func (diuo *DiscordInteractionUpdateOne) Where(ps ...predicate.DiscordInteraction) *DiscordInteractionUpdateOne {
+	diuo.mutation.Where(ps...)
+	return diuo
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (diuo *DiscordInteractionUpdateOne) Select(field string, fields ...string) *DiscordInteractionUpdateOne {
+	diuo.fields = append([]string{field}, fields...)
+	return diuo
+}
+
+// Save executes the query and returns the updated DiscordInteraction entity.
+func (diuo *DiscordInteractionUpdateOne) Save(ctx context.Context) (*DiscordInteraction, error) {
+	diuo.defaults()
+	return withHooks(ctx, diuo.sqlSave, diuo.mutation, diuo.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (diuo *DiscordInteractionUpdateOne) SaveX(ctx context.Context) *DiscordInteraction {
+	node, err := diuo.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// Exec executes the query on the entity.
+func (diuo *DiscordInteractionUpdateOne) Exec(ctx context.Context) error {
+	_, err := diuo.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (diuo *DiscordInteractionUpdateOne) ExecX(ctx context.Context) {
+	if err := diuo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (diuo *DiscordInteractionUpdateOne) defaults() {
+	if _, ok := diuo.mutation.UpdatedAt(); !ok {
+		v := discordinteraction.UpdateDefaultUpdatedAt()
+		diuo.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (diuo *DiscordInteractionUpdateOne) check() error {
+	if v, ok := diuo.mutation.Command(); ok {
+		if err := discordinteraction.CommandValidator(v); err != nil {
+			return &ValidationError{Name: "command", err: fmt.Errorf(`db: validator failed for field "DiscordInteraction.command": %w`, err)}
+		}
+	}
+	if v, ok := diuo.mutation.ReferenceID(); ok {
+		if err := discordinteraction.ReferenceIDValidator(v); err != nil {
+			return &ValidationError{Name: "reference_id", err: fmt.Errorf(`db: validator failed for field "DiscordInteraction.reference_id": %w`, err)}
+		}
+	}
+	if v, ok := diuo.mutation.GetType(); ok {
+		if err := discordinteraction.TypeValidator(v); err != nil {
+			return &ValidationError{Name: "type", err: fmt.Errorf(`db: validator failed for field "DiscordInteraction.type": %w`, err)}
+		}
+	}
+	if _, ok := diuo.mutation.UserID(); diuo.mutation.UserCleared() && !ok {
+		return errors.New(`db: clearing a required unique edge "DiscordInteraction.user"`)
+	}
+	return nil
+}
+
+func (diuo *DiscordInteractionUpdateOne) sqlSave(ctx context.Context) (_node *DiscordInteraction, err error) {
+	if err := diuo.check(); err != nil {
+		return _node, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(discordinteraction.Table, discordinteraction.Columns, sqlgraph.NewFieldSpec(discordinteraction.FieldID, field.TypeString))
+	id, ok := diuo.mutation.ID()
+	if !ok {
+		return nil, &ValidationError{Name: "id", err: errors.New(`db: missing "DiscordInteraction.id" for update`)}
+	}
+	_spec.Node.ID.Value = id
+	if fields := diuo.fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, discordinteraction.FieldID)
+		for _, f := range fields {
+			if !discordinteraction.ValidColumn(f) {
+				return nil, &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+			}
+			if f != discordinteraction.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, f)
+			}
+		}
+	}
+	if ps := diuo.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := diuo.mutation.UpdatedAt(); ok {
+		_spec.SetField(discordinteraction.FieldUpdatedAt, field.TypeInt64, value)
+	}
+	if value, ok := diuo.mutation.AddedUpdatedAt(); ok {
+		_spec.AddField(discordinteraction.FieldUpdatedAt, field.TypeInt64, value)
+	}
+	if value, ok := diuo.mutation.Command(); ok {
+		_spec.SetField(discordinteraction.FieldCommand, field.TypeString, value)
+	}
+	if value, ok := diuo.mutation.ReferenceID(); ok {
+		_spec.SetField(discordinteraction.FieldReferenceID, field.TypeString, value)
+	}
+	if value, ok := diuo.mutation.GetType(); ok {
+		_spec.SetField(discordinteraction.FieldType, field.TypeEnum, value)
+	}
+	if value, ok := diuo.mutation.Locale(); ok {
+		_spec.SetField(discordinteraction.FieldLocale, field.TypeString, value)
+	}
+	if value, ok := diuo.mutation.Options(); ok {
+		_spec.SetField(discordinteraction.FieldOptions, field.TypeJSON, value)
+	}
+	_node = &DiscordInteraction{config: diuo.config}
+	_spec.Assign = _node.assignValues
+	_spec.ScanValues = _node.scanValues
+	if err = sqlgraph.UpdateNode(ctx, diuo.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{discordinteraction.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	diuo.mutation.done = true
+	return _node, nil
+}
diff --git a/internal/database/ent/db/ent.go b/internal/database/ent/db/ent.go
index bcaa9136..22bd881e 100644
--- a/internal/database/ent/db/ent.go
+++ b/internal/database/ent/db/ent.go
@@ -19,6 +19,7 @@ import (
 	"github.com/cufee/aftermath/internal/database/ent/db/applicationcommand"
 	"github.com/cufee/aftermath/internal/database/ent/db/clan"
 	"github.com/cufee/aftermath/internal/database/ent/db/crontask"
+	"github.com/cufee/aftermath/internal/database/ent/db/discordinteraction"
 	"github.com/cufee/aftermath/internal/database/ent/db/user"
 	"github.com/cufee/aftermath/internal/database/ent/db/userconnection"
 	"github.com/cufee/aftermath/internal/database/ent/db/usercontent"
@@ -93,6 +94,7 @@ func checkColumn(table, column string) error {
 			applicationcommand.Table:   applicationcommand.ValidColumn,
 			clan.Table:                 clan.ValidColumn,
 			crontask.Table:             crontask.ValidColumn,
+			discordinteraction.Table:   discordinteraction.ValidColumn,
 			user.Table:                 user.ValidColumn,
 			userconnection.Table:       userconnection.ValidColumn,
 			usercontent.Table:          usercontent.ValidColumn,
diff --git a/internal/database/ent/db/hook/hook.go b/internal/database/ent/db/hook/hook.go
index fe0ba69f..f3a9e239 100644
--- a/internal/database/ent/db/hook/hook.go
+++ b/internal/database/ent/db/hook/hook.go
@@ -93,6 +93,18 @@ func (f CronTaskFunc) Mutate(ctx context.Context, m db.Mutation) (db.Value, erro
 	return nil, fmt.Errorf("unexpected mutation type %T. expect *db.CronTaskMutation", m)
 }
 
+// The DiscordInteractionFunc type is an adapter to allow the use of ordinary
+// function as DiscordInteraction mutator.
+type DiscordInteractionFunc func(context.Context, *db.DiscordInteractionMutation) (db.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f DiscordInteractionFunc) Mutate(ctx context.Context, m db.Mutation) (db.Value, error) {
+	if mv, ok := m.(*db.DiscordInteractionMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *db.DiscordInteractionMutation", m)
+}
+
 // The UserFunc type is an adapter to allow the use of ordinary
 // function as User mutator.
 type UserFunc func(context.Context, *db.UserMutation) (db.Value, error)
diff --git a/internal/database/ent/db/migrate/schema.go b/internal/database/ent/db/migrate/schema.go
index 29a7f768..9432fc41 100644
--- a/internal/database/ent/db/migrate/schema.go
+++ b/internal/database/ent/db/migrate/schema.go
@@ -298,6 +298,59 @@ var (
 			},
 		},
 	}
+	// DiscordInteractionsColumns holds the columns for the "discord_interactions" table.
+	DiscordInteractionsColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeString, Unique: true},
+		{Name: "created_at", Type: field.TypeInt64},
+		{Name: "updated_at", Type: field.TypeInt64},
+		{Name: "command", Type: field.TypeString},
+		{Name: "reference_id", Type: field.TypeString},
+		{Name: "type", Type: field.TypeEnum, Enums: []string{"stats"}},
+		{Name: "locale", Type: field.TypeString},
+		{Name: "options", Type: field.TypeJSON},
+		{Name: "user_id", Type: field.TypeString},
+	}
+	// DiscordInteractionsTable holds the schema information for the "discord_interactions" table.
+	DiscordInteractionsTable = &schema.Table{
+		Name:       "discord_interactions",
+		Columns:    DiscordInteractionsColumns,
+		PrimaryKey: []*schema.Column{DiscordInteractionsColumns[0]},
+		ForeignKeys: []*schema.ForeignKey{
+			{
+				Symbol:     "discord_interactions_users_discord_interactions",
+				Columns:    []*schema.Column{DiscordInteractionsColumns[8]},
+				RefColumns: []*schema.Column{UsersColumns[0]},
+				OnDelete:   schema.NoAction,
+			},
+		},
+		Indexes: []*schema.Index{
+			{
+				Name:    "discordinteraction_id",
+				Unique:  false,
+				Columns: []*schema.Column{DiscordInteractionsColumns[0]},
+			},
+			{
+				Name:    "discordinteraction_command",
+				Unique:  false,
+				Columns: []*schema.Column{DiscordInteractionsColumns[3]},
+			},
+			{
+				Name:    "discordinteraction_user_id",
+				Unique:  false,
+				Columns: []*schema.Column{DiscordInteractionsColumns[8]},
+			},
+			{
+				Name:    "discordinteraction_user_id_type",
+				Unique:  false,
+				Columns: []*schema.Column{DiscordInteractionsColumns[8], DiscordInteractionsColumns[5]},
+			},
+			{
+				Name:    "discordinteraction_reference_id",
+				Unique:  false,
+				Columns: []*schema.Column{DiscordInteractionsColumns[4]},
+			},
+		},
+	}
 	// UsersColumns holds the columns for the "users" table.
 	UsersColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeString, Unique: true},
@@ -584,6 +637,7 @@ var (
 		ApplicationCommandsTable,
 		ClansTable,
 		CronTasksTable,
+		DiscordInteractionsTable,
 		UsersTable,
 		UserConnectionsTable,
 		UserContentsTable,
@@ -598,6 +652,7 @@ func init() {
 	AccountsTable.ForeignKeys[0].RefTable = ClansTable
 	AccountSnapshotsTable.ForeignKeys[0].RefTable = AccountsTable
 	AchievementsSnapshotsTable.ForeignKeys[0].RefTable = AccountsTable
+	DiscordInteractionsTable.ForeignKeys[0].RefTable = UsersTable
 	UserConnectionsTable.ForeignKeys[0].RefTable = UsersTable
 	UserContentsTable.ForeignKeys[0].RefTable = UsersTable
 	UserSubscriptionsTable.ForeignKeys[0].RefTable = UsersTable
diff --git a/internal/database/ent/db/mutation.go b/internal/database/ent/db/mutation.go
index 49983f2e..d34605bc 100644
--- a/internal/database/ent/db/mutation.go
+++ b/internal/database/ent/db/mutation.go
@@ -17,6 +17,7 @@ import (
 	"github.com/cufee/aftermath/internal/database/ent/db/applicationcommand"
 	"github.com/cufee/aftermath/internal/database/ent/db/clan"
 	"github.com/cufee/aftermath/internal/database/ent/db/crontask"
+	"github.com/cufee/aftermath/internal/database/ent/db/discordinteraction"
 	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
 	"github.com/cufee/aftermath/internal/database/ent/db/user"
 	"github.com/cufee/aftermath/internal/database/ent/db/userconnection"
@@ -46,6 +47,7 @@ const (
 	TypeApplicationCommand   = "ApplicationCommand"
 	TypeClan                 = "Clan"
 	TypeCronTask             = "CronTask"
+	TypeDiscordInteraction   = "DiscordInteraction"
 	TypeUser                 = "User"
 	TypeUserConnection       = "UserConnection"
 	TypeUserContent          = "UserContent"
@@ -6209,32 +6211,868 @@ func (m *CronTaskMutation) ResetEdge(name string) error {
 	return fmt.Errorf("unknown CronTask edge %s", name)
 }
 
+// DiscordInteractionMutation represents an operation that mutates the DiscordInteraction nodes in the graph.
+type DiscordInteractionMutation struct {
+	config
+	op            Op
+	typ           string
+	id            *string
+	created_at    *int64
+	addcreated_at *int64
+	updated_at    *int64
+	addupdated_at *int64
+	command       *string
+	reference_id  *string
+	_type         *models.DiscordInteractionType
+	locale        *string
+	options       *models.DiscordInteractionOptions
+	clearedFields map[string]struct{}
+	user          *string
+	cleareduser   bool
+	done          bool
+	oldValue      func(context.Context) (*DiscordInteraction, error)
+	predicates    []predicate.DiscordInteraction
+}
+
+var _ ent.Mutation = (*DiscordInteractionMutation)(nil)
+
+// discordinteractionOption allows management of the mutation configuration using functional options.
+type discordinteractionOption func(*DiscordInteractionMutation)
+
+// newDiscordInteractionMutation creates new mutation for the DiscordInteraction entity.
+func newDiscordInteractionMutation(c config, op Op, opts ...discordinteractionOption) *DiscordInteractionMutation {
+	m := &DiscordInteractionMutation{
+		config:        c,
+		op:            op,
+		typ:           TypeDiscordInteraction,
+		clearedFields: make(map[string]struct{}),
+	}
+	for _, opt := range opts {
+		opt(m)
+	}
+	return m
+}
+
+// withDiscordInteractionID sets the ID field of the mutation.
+func withDiscordInteractionID(id string) discordinteractionOption {
+	return func(m *DiscordInteractionMutation) {
+		var (
+			err   error
+			once  sync.Once
+			value *DiscordInteraction
+		)
+		m.oldValue = func(ctx context.Context) (*DiscordInteraction, error) {
+			once.Do(func() {
+				if m.done {
+					err = errors.New("querying old values post mutation is not allowed")
+				} else {
+					value, err = m.Client().DiscordInteraction.Get(ctx, id)
+				}
+			})
+			return value, err
+		}
+		m.id = &id
+	}
+}
+
+// withDiscordInteraction sets the old DiscordInteraction of the mutation.
+func withDiscordInteraction(node *DiscordInteraction) discordinteractionOption {
+	return func(m *DiscordInteractionMutation) {
+		m.oldValue = func(context.Context) (*DiscordInteraction, error) {
+			return node, nil
+		}
+		m.id = &node.ID
+	}
+}
+
+// Client returns a new `ent.Client` from the mutation. If the mutation was
+// executed in a transaction (ent.Tx), a transactional client is returned.
+func (m DiscordInteractionMutation) Client() *Client {
+	client := &Client{config: m.config}
+	client.init()
+	return client
+}
+
+// Tx returns an `ent.Tx` for mutations that were executed in transactions;
+// it returns an error otherwise.
+func (m DiscordInteractionMutation) Tx() (*Tx, error) {
+	if _, ok := m.driver.(*txDriver); !ok {
+		return nil, errors.New("db: mutation is not running in a transaction")
+	}
+	tx := &Tx{config: m.config}
+	tx.init()
+	return tx, nil
+}
+
+// SetID sets the value of the id field. Note that this
+// operation is only accepted on creation of DiscordInteraction entities.
+func (m *DiscordInteractionMutation) SetID(id string) {
+	m.id = &id
+}
+
+// ID returns the ID value in the mutation. Note that the ID is only available
+// if it was provided to the builder or after it was returned from the database.
+func (m *DiscordInteractionMutation) ID() (id string, exists bool) {
+	if m.id == nil {
+		return
+	}
+	return *m.id, true
+}
+
+// IDs queries the database and returns the entity ids that match the mutation's predicate.
+// That means, if the mutation is applied within a transaction with an isolation level such
+// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
+// or updated by the mutation.
+func (m *DiscordInteractionMutation) IDs(ctx context.Context) ([]string, error) {
+	switch {
+	case m.op.Is(OpUpdateOne | OpDeleteOne):
+		id, exists := m.ID()
+		if exists {
+			return []string{id}, nil
+		}
+		fallthrough
+	case m.op.Is(OpUpdate | OpDelete):
+		return m.Client().DiscordInteraction.Query().Where(m.predicates...).IDs(ctx)
+	default:
+		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
+	}
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (m *DiscordInteractionMutation) SetCreatedAt(i int64) {
+	m.created_at = &i
+	m.addcreated_at = nil
+}
+
+// CreatedAt returns the value of the "created_at" field in the mutation.
+func (m *DiscordInteractionMutation) CreatedAt() (r int64, exists bool) {
+	v := m.created_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldCreatedAt returns the old "created_at" field's value of the DiscordInteraction entity.
+// If the DiscordInteraction object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *DiscordInteractionMutation) OldCreatedAt(ctx context.Context) (v int64, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldCreatedAt requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
+	}
+	return oldValue.CreatedAt, nil
+}
+
+// AddCreatedAt adds i to the "created_at" field.
+func (m *DiscordInteractionMutation) AddCreatedAt(i int64) {
+	if m.addcreated_at != nil {
+		*m.addcreated_at += i
+	} else {
+		m.addcreated_at = &i
+	}
+}
+
+// AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
+func (m *DiscordInteractionMutation) AddedCreatedAt() (r int64, exists bool) {
+	v := m.addcreated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetCreatedAt resets all changes to the "created_at" field.
+func (m *DiscordInteractionMutation) ResetCreatedAt() {
+	m.created_at = nil
+	m.addcreated_at = nil
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (m *DiscordInteractionMutation) SetUpdatedAt(i int64) {
+	m.updated_at = &i
+	m.addupdated_at = nil
+}
+
+// UpdatedAt returns the value of the "updated_at" field in the mutation.
+func (m *DiscordInteractionMutation) UpdatedAt() (r int64, exists bool) {
+	v := m.updated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldUpdatedAt returns the old "updated_at" field's value of the DiscordInteraction entity.
+// If the DiscordInteraction object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *DiscordInteractionMutation) OldUpdatedAt(ctx context.Context) (v int64, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
+	}
+	return oldValue.UpdatedAt, nil
+}
+
+// AddUpdatedAt adds i to the "updated_at" field.
+func (m *DiscordInteractionMutation) AddUpdatedAt(i int64) {
+	if m.addupdated_at != nil {
+		*m.addupdated_at += i
+	} else {
+		m.addupdated_at = &i
+	}
+}
+
+// AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
+func (m *DiscordInteractionMutation) AddedUpdatedAt() (r int64, exists bool) {
+	v := m.addupdated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetUpdatedAt resets all changes to the "updated_at" field.
+func (m *DiscordInteractionMutation) ResetUpdatedAt() {
+	m.updated_at = nil
+	m.addupdated_at = nil
+}
+
+// SetCommand sets the "command" field.
+func (m *DiscordInteractionMutation) SetCommand(s string) {
+	m.command = &s
+}
+
+// Command returns the value of the "command" field in the mutation.
+func (m *DiscordInteractionMutation) Command() (r string, exists bool) {
+	v := m.command
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldCommand returns the old "command" field's value of the DiscordInteraction entity.
+// If the DiscordInteraction object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *DiscordInteractionMutation) OldCommand(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldCommand is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldCommand requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldCommand: %w", err)
+	}
+	return oldValue.Command, nil
+}
+
+// ResetCommand resets all changes to the "command" field.
+func (m *DiscordInteractionMutation) ResetCommand() {
+	m.command = nil
+}
+
+// SetUserID sets the "user_id" field.
+func (m *DiscordInteractionMutation) SetUserID(s string) {
+	m.user = &s
+}
+
+// UserID returns the value of the "user_id" field in the mutation.
+func (m *DiscordInteractionMutation) UserID() (r string, exists bool) {
+	v := m.user
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldUserID returns the old "user_id" field's value of the DiscordInteraction entity.
+// If the DiscordInteraction object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *DiscordInteractionMutation) OldUserID(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldUserID is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldUserID requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldUserID: %w", err)
+	}
+	return oldValue.UserID, nil
+}
+
+// ResetUserID resets all changes to the "user_id" field.
+func (m *DiscordInteractionMutation) ResetUserID() {
+	m.user = nil
+}
+
+// SetReferenceID sets the "reference_id" field.
+func (m *DiscordInteractionMutation) SetReferenceID(s string) {
+	m.reference_id = &s
+}
+
+// ReferenceID returns the value of the "reference_id" field in the mutation.
+func (m *DiscordInteractionMutation) ReferenceID() (r string, exists bool) {
+	v := m.reference_id
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldReferenceID returns the old "reference_id" field's value of the DiscordInteraction entity.
+// If the DiscordInteraction object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *DiscordInteractionMutation) OldReferenceID(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldReferenceID is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldReferenceID requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldReferenceID: %w", err)
+	}
+	return oldValue.ReferenceID, nil
+}
+
+// ResetReferenceID resets all changes to the "reference_id" field.
+func (m *DiscordInteractionMutation) ResetReferenceID() {
+	m.reference_id = nil
+}
+
+// SetType sets the "type" field.
+func (m *DiscordInteractionMutation) SetType(mit models.DiscordInteractionType) {
+	m._type = &mit
+}
+
+// GetType returns the value of the "type" field in the mutation.
+func (m *DiscordInteractionMutation) GetType() (r models.DiscordInteractionType, exists bool) {
+	v := m._type
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldType returns the old "type" field's value of the DiscordInteraction entity.
+// If the DiscordInteraction object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *DiscordInteractionMutation) OldType(ctx context.Context) (v models.DiscordInteractionType, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldType is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldType requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldType: %w", err)
+	}
+	return oldValue.Type, nil
+}
+
+// ResetType resets all changes to the "type" field.
+func (m *DiscordInteractionMutation) ResetType() {
+	m._type = nil
+}
+
+// SetLocale sets the "locale" field.
+func (m *DiscordInteractionMutation) SetLocale(s string) {
+	m.locale = &s
+}
+
+// Locale returns the value of the "locale" field in the mutation.
+func (m *DiscordInteractionMutation) Locale() (r string, exists bool) {
+	v := m.locale
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldLocale returns the old "locale" field's value of the DiscordInteraction entity.
+// If the DiscordInteraction object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *DiscordInteractionMutation) OldLocale(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldLocale is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldLocale requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldLocale: %w", err)
+	}
+	return oldValue.Locale, nil
+}
+
+// ResetLocale resets all changes to the "locale" field.
+func (m *DiscordInteractionMutation) ResetLocale() {
+	m.locale = nil
+}
+
+// SetOptions sets the "options" field.
+func (m *DiscordInteractionMutation) SetOptions(mio models.DiscordInteractionOptions) {
+	m.options = &mio
+}
+
+// Options returns the value of the "options" field in the mutation.
+func (m *DiscordInteractionMutation) Options() (r models.DiscordInteractionOptions, exists bool) {
+	v := m.options
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldOptions returns the old "options" field's value of the DiscordInteraction entity.
+// If the DiscordInteraction object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *DiscordInteractionMutation) OldOptions(ctx context.Context) (v models.DiscordInteractionOptions, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldOptions is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldOptions requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldOptions: %w", err)
+	}
+	return oldValue.Options, nil
+}
+
+// ResetOptions resets all changes to the "options" field.
+func (m *DiscordInteractionMutation) ResetOptions() {
+	m.options = nil
+}
+
+// ClearUser clears the "user" edge to the User entity.
+func (m *DiscordInteractionMutation) ClearUser() {
+	m.cleareduser = true
+	m.clearedFields[discordinteraction.FieldUserID] = struct{}{}
+}
+
+// UserCleared reports if the "user" edge to the User entity was cleared.
+func (m *DiscordInteractionMutation) UserCleared() bool {
+	return m.cleareduser
+}
+
+// UserIDs returns the "user" edge IDs in the mutation.
+// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
+// UserID instead. It exists only for internal usage by the builders.
+func (m *DiscordInteractionMutation) UserIDs() (ids []string) {
+	if id := m.user; id != nil {
+		ids = append(ids, *id)
+	}
+	return
+}
+
+// ResetUser resets all changes to the "user" edge.
+func (m *DiscordInteractionMutation) ResetUser() {
+	m.user = nil
+	m.cleareduser = false
+}
+
+// Where appends a list predicates to the DiscordInteractionMutation builder.
+func (m *DiscordInteractionMutation) Where(ps ...predicate.DiscordInteraction) {
+	m.predicates = append(m.predicates, ps...)
+}
+
+// WhereP appends storage-level predicates to the DiscordInteractionMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *DiscordInteractionMutation) WhereP(ps ...func(*sql.Selector)) {
+	p := make([]predicate.DiscordInteraction, len(ps))
+	for i := range ps {
+		p[i] = ps[i]
+	}
+	m.Where(p...)
+}
+
+// Op returns the operation name.
+func (m *DiscordInteractionMutation) Op() Op {
+	return m.op
+}
+
+// SetOp allows setting the mutation operation.
+func (m *DiscordInteractionMutation) SetOp(op Op) {
+	m.op = op
+}
+
+// Type returns the node type of this mutation (DiscordInteraction).
+func (m *DiscordInteractionMutation) Type() string {
+	return m.typ
+}
+
+// Fields returns all fields that were changed during this mutation. Note that in
+// order to get all numeric fields that were incremented/decremented, call
+// AddedFields().
+func (m *DiscordInteractionMutation) Fields() []string {
+	fields := make([]string, 0, 8)
+	if m.created_at != nil {
+		fields = append(fields, discordinteraction.FieldCreatedAt)
+	}
+	if m.updated_at != nil {
+		fields = append(fields, discordinteraction.FieldUpdatedAt)
+	}
+	if m.command != nil {
+		fields = append(fields, discordinteraction.FieldCommand)
+	}
+	if m.user != nil {
+		fields = append(fields, discordinteraction.FieldUserID)
+	}
+	if m.reference_id != nil {
+		fields = append(fields, discordinteraction.FieldReferenceID)
+	}
+	if m._type != nil {
+		fields = append(fields, discordinteraction.FieldType)
+	}
+	if m.locale != nil {
+		fields = append(fields, discordinteraction.FieldLocale)
+	}
+	if m.options != nil {
+		fields = append(fields, discordinteraction.FieldOptions)
+	}
+	return fields
+}
+
+// Field returns the value of a field with the given name. The second boolean
+// return value indicates that this field was not set, or was not defined in the
+// schema.
+func (m *DiscordInteractionMutation) Field(name string) (ent.Value, bool) {
+	switch name {
+	case discordinteraction.FieldCreatedAt:
+		return m.CreatedAt()
+	case discordinteraction.FieldUpdatedAt:
+		return m.UpdatedAt()
+	case discordinteraction.FieldCommand:
+		return m.Command()
+	case discordinteraction.FieldUserID:
+		return m.UserID()
+	case discordinteraction.FieldReferenceID:
+		return m.ReferenceID()
+	case discordinteraction.FieldType:
+		return m.GetType()
+	case discordinteraction.FieldLocale:
+		return m.Locale()
+	case discordinteraction.FieldOptions:
+		return m.Options()
+	}
+	return nil, false
+}
+
+// OldField returns the old value of the field from the database. An error is
+// returned if the mutation operation is not UpdateOne, or the query to the
+// database failed.
+func (m *DiscordInteractionMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
+	switch name {
+	case discordinteraction.FieldCreatedAt:
+		return m.OldCreatedAt(ctx)
+	case discordinteraction.FieldUpdatedAt:
+		return m.OldUpdatedAt(ctx)
+	case discordinteraction.FieldCommand:
+		return m.OldCommand(ctx)
+	case discordinteraction.FieldUserID:
+		return m.OldUserID(ctx)
+	case discordinteraction.FieldReferenceID:
+		return m.OldReferenceID(ctx)
+	case discordinteraction.FieldType:
+		return m.OldType(ctx)
+	case discordinteraction.FieldLocale:
+		return m.OldLocale(ctx)
+	case discordinteraction.FieldOptions:
+		return m.OldOptions(ctx)
+	}
+	return nil, fmt.Errorf("unknown DiscordInteraction field %s", name)
+}
+
+// SetField sets the value of a field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *DiscordInteractionMutation) SetField(name string, value ent.Value) error {
+	switch name {
+	case discordinteraction.FieldCreatedAt:
+		v, ok := value.(int64)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetCreatedAt(v)
+		return nil
+	case discordinteraction.FieldUpdatedAt:
+		v, ok := value.(int64)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetUpdatedAt(v)
+		return nil
+	case discordinteraction.FieldCommand:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetCommand(v)
+		return nil
+	case discordinteraction.FieldUserID:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetUserID(v)
+		return nil
+	case discordinteraction.FieldReferenceID:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetReferenceID(v)
+		return nil
+	case discordinteraction.FieldType:
+		v, ok := value.(models.DiscordInteractionType)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetType(v)
+		return nil
+	case discordinteraction.FieldLocale:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetLocale(v)
+		return nil
+	case discordinteraction.FieldOptions:
+		v, ok := value.(models.DiscordInteractionOptions)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetOptions(v)
+		return nil
+	}
+	return fmt.Errorf("unknown DiscordInteraction field %s", name)
+}
+
+// AddedFields returns all numeric fields that were incremented/decremented during
+// this mutation.
+func (m *DiscordInteractionMutation) AddedFields() []string {
+	var fields []string
+	if m.addcreated_at != nil {
+		fields = append(fields, discordinteraction.FieldCreatedAt)
+	}
+	if m.addupdated_at != nil {
+		fields = append(fields, discordinteraction.FieldUpdatedAt)
+	}
+	return fields
+}
+
+// AddedField returns the numeric value that was incremented/decremented on a field
+// with the given name. The second boolean return value indicates that this field
+// was not set, or was not defined in the schema.
+func (m *DiscordInteractionMutation) AddedField(name string) (ent.Value, bool) {
+	switch name {
+	case discordinteraction.FieldCreatedAt:
+		return m.AddedCreatedAt()
+	case discordinteraction.FieldUpdatedAt:
+		return m.AddedUpdatedAt()
+	}
+	return nil, false
+}
+
+// AddField adds the value to the field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *DiscordInteractionMutation) AddField(name string, value ent.Value) error {
+	switch name {
+	case discordinteraction.FieldCreatedAt:
+		v, ok := value.(int64)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddCreatedAt(v)
+		return nil
+	case discordinteraction.FieldUpdatedAt:
+		v, ok := value.(int64)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddUpdatedAt(v)
+		return nil
+	}
+	return fmt.Errorf("unknown DiscordInteraction numeric field %s", name)
+}
+
+// ClearedFields returns all nullable fields that were cleared during this
+// mutation.
+func (m *DiscordInteractionMutation) ClearedFields() []string {
+	return nil
+}
+
+// FieldCleared returns a boolean indicating if a field with the given name was
+// cleared in this mutation.
+func (m *DiscordInteractionMutation) FieldCleared(name string) bool {
+	_, ok := m.clearedFields[name]
+	return ok
+}
+
+// ClearField clears the value of the field with the given name. It returns an
+// error if the field is not defined in the schema.
+func (m *DiscordInteractionMutation) ClearField(name string) error {
+	return fmt.Errorf("unknown DiscordInteraction nullable field %s", name)
+}
+
+// ResetField resets all changes in the mutation for the field with the given name.
+// It returns an error if the field is not defined in the schema.
+func (m *DiscordInteractionMutation) ResetField(name string) error {
+	switch name {
+	case discordinteraction.FieldCreatedAt:
+		m.ResetCreatedAt()
+		return nil
+	case discordinteraction.FieldUpdatedAt:
+		m.ResetUpdatedAt()
+		return nil
+	case discordinteraction.FieldCommand:
+		m.ResetCommand()
+		return nil
+	case discordinteraction.FieldUserID:
+		m.ResetUserID()
+		return nil
+	case discordinteraction.FieldReferenceID:
+		m.ResetReferenceID()
+		return nil
+	case discordinteraction.FieldType:
+		m.ResetType()
+		return nil
+	case discordinteraction.FieldLocale:
+		m.ResetLocale()
+		return nil
+	case discordinteraction.FieldOptions:
+		m.ResetOptions()
+		return nil
+	}
+	return fmt.Errorf("unknown DiscordInteraction field %s", name)
+}
+
+// AddedEdges returns all edge names that were set/added in this mutation.
+func (m *DiscordInteractionMutation) AddedEdges() []string {
+	edges := make([]string, 0, 1)
+	if m.user != nil {
+		edges = append(edges, discordinteraction.EdgeUser)
+	}
+	return edges
+}
+
+// AddedIDs returns all IDs (to other nodes) that were added for the given edge
+// name in this mutation.
+func (m *DiscordInteractionMutation) AddedIDs(name string) []ent.Value {
+	switch name {
+	case discordinteraction.EdgeUser:
+		if id := m.user; id != nil {
+			return []ent.Value{*id}
+		}
+	}
+	return nil
+}
+
+// RemovedEdges returns all edge names that were removed in this mutation.
+func (m *DiscordInteractionMutation) RemovedEdges() []string {
+	edges := make([]string, 0, 1)
+	return edges
+}
+
+// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
+// the given name in this mutation.
+func (m *DiscordInteractionMutation) RemovedIDs(name string) []ent.Value {
+	return nil
+}
+
+// ClearedEdges returns all edge names that were cleared in this mutation.
+func (m *DiscordInteractionMutation) ClearedEdges() []string {
+	edges := make([]string, 0, 1)
+	if m.cleareduser {
+		edges = append(edges, discordinteraction.EdgeUser)
+	}
+	return edges
+}
+
+// EdgeCleared returns a boolean which indicates if the edge with the given name
+// was cleared in this mutation.
+func (m *DiscordInteractionMutation) EdgeCleared(name string) bool {
+	switch name {
+	case discordinteraction.EdgeUser:
+		return m.cleareduser
+	}
+	return false
+}
+
+// ClearEdge clears the value of the edge with the given name. It returns an error
+// if that edge is not defined in the schema.
+func (m *DiscordInteractionMutation) ClearEdge(name string) error {
+	switch name {
+	case discordinteraction.EdgeUser:
+		m.ClearUser()
+		return nil
+	}
+	return fmt.Errorf("unknown DiscordInteraction unique edge %s", name)
+}
+
+// ResetEdge resets all changes to the edge with the given name in this mutation.
+// It returns an error if the edge is not defined in the schema.
+func (m *DiscordInteractionMutation) ResetEdge(name string) error {
+	switch name {
+	case discordinteraction.EdgeUser:
+		m.ResetUser()
+		return nil
+	}
+	return fmt.Errorf("unknown DiscordInteraction edge %s", name)
+}
+
 // UserMutation represents an operation that mutates the User nodes in the graph.
 type UserMutation struct {
 	config
-	op                   Op
-	typ                  string
-	id                   *string
-	created_at           *int64
-	addcreated_at        *int64
-	updated_at           *int64
-	addupdated_at        *int64
-	permissions          *string
-	feature_flags        *[]string
-	appendfeature_flags  []string
-	clearedFields        map[string]struct{}
-	subscriptions        map[string]struct{}
-	removedsubscriptions map[string]struct{}
-	clearedsubscriptions bool
-	connections          map[string]struct{}
-	removedconnections   map[string]struct{}
-	clearedconnections   bool
-	content              map[string]struct{}
-	removedcontent       map[string]struct{}
-	clearedcontent       bool
-	done                 bool
-	oldValue             func(context.Context) (*User, error)
-	predicates           []predicate.User
+	op                          Op
+	typ                         string
+	id                          *string
+	created_at                  *int64
+	addcreated_at               *int64
+	updated_at                  *int64
+	addupdated_at               *int64
+	permissions                 *string
+	feature_flags               *[]string
+	appendfeature_flags         []string
+	clearedFields               map[string]struct{}
+	discord_interactions        map[string]struct{}
+	removeddiscord_interactions map[string]struct{}
+	cleareddiscord_interactions bool
+	subscriptions               map[string]struct{}
+	removedsubscriptions        map[string]struct{}
+	clearedsubscriptions        bool
+	connections                 map[string]struct{}
+	removedconnections          map[string]struct{}
+	clearedconnections          bool
+	content                     map[string]struct{}
+	removedcontent              map[string]struct{}
+	clearedcontent              bool
+	done                        bool
+	oldValue                    func(context.Context) (*User, error)
+	predicates                  []predicate.User
 }
 
 var _ ent.Mutation = (*UserMutation)(nil)
@@ -6554,6 +7392,60 @@ func (m *UserMutation) ResetFeatureFlags() {
 	delete(m.clearedFields, user.FieldFeatureFlags)
 }
 
+// AddDiscordInteractionIDs adds the "discord_interactions" edge to the DiscordInteraction entity by ids.
+func (m *UserMutation) AddDiscordInteractionIDs(ids ...string) {
+	if m.discord_interactions == nil {
+		m.discord_interactions = make(map[string]struct{})
+	}
+	for i := range ids {
+		m.discord_interactions[ids[i]] = struct{}{}
+	}
+}
+
+// ClearDiscordInteractions clears the "discord_interactions" edge to the DiscordInteraction entity.
+func (m *UserMutation) ClearDiscordInteractions() {
+	m.cleareddiscord_interactions = true
+}
+
+// DiscordInteractionsCleared reports if the "discord_interactions" edge to the DiscordInteraction entity was cleared.
+func (m *UserMutation) DiscordInteractionsCleared() bool {
+	return m.cleareddiscord_interactions
+}
+
+// RemoveDiscordInteractionIDs removes the "discord_interactions" edge to the DiscordInteraction entity by IDs.
+func (m *UserMutation) RemoveDiscordInteractionIDs(ids ...string) {
+	if m.removeddiscord_interactions == nil {
+		m.removeddiscord_interactions = make(map[string]struct{})
+	}
+	for i := range ids {
+		delete(m.discord_interactions, ids[i])
+		m.removeddiscord_interactions[ids[i]] = struct{}{}
+	}
+}
+
+// RemovedDiscordInteractions returns the removed IDs of the "discord_interactions" edge to the DiscordInteraction entity.
+func (m *UserMutation) RemovedDiscordInteractionsIDs() (ids []string) {
+	for id := range m.removeddiscord_interactions {
+		ids = append(ids, id)
+	}
+	return
+}
+
+// DiscordInteractionsIDs returns the "discord_interactions" edge IDs in the mutation.
+func (m *UserMutation) DiscordInteractionsIDs() (ids []string) {
+	for id := range m.discord_interactions {
+		ids = append(ids, id)
+	}
+	return
+}
+
+// ResetDiscordInteractions resets all changes to the "discord_interactions" edge.
+func (m *UserMutation) ResetDiscordInteractions() {
+	m.discord_interactions = nil
+	m.cleareddiscord_interactions = false
+	m.removeddiscord_interactions = nil
+}
+
 // AddSubscriptionIDs adds the "subscriptions" edge to the UserSubscription entity by ids.
 func (m *UserMutation) AddSubscriptionIDs(ids ...string) {
 	if m.subscriptions == nil {
@@ -6936,7 +7828,10 @@ func (m *UserMutation) ResetField(name string) error {
 
 // AddedEdges returns all edge names that were set/added in this mutation.
 func (m *UserMutation) AddedEdges() []string {
-	edges := make([]string, 0, 3)
+	edges := make([]string, 0, 4)
+	if m.discord_interactions != nil {
+		edges = append(edges, user.EdgeDiscordInteractions)
+	}
 	if m.subscriptions != nil {
 		edges = append(edges, user.EdgeSubscriptions)
 	}
@@ -6953,6 +7848,12 @@ func (m *UserMutation) AddedEdges() []string {
 // name in this mutation.
 func (m *UserMutation) AddedIDs(name string) []ent.Value {
 	switch name {
+	case user.EdgeDiscordInteractions:
+		ids := make([]ent.Value, 0, len(m.discord_interactions))
+		for id := range m.discord_interactions {
+			ids = append(ids, id)
+		}
+		return ids
 	case user.EdgeSubscriptions:
 		ids := make([]ent.Value, 0, len(m.subscriptions))
 		for id := range m.subscriptions {
@@ -6977,7 +7878,10 @@ func (m *UserMutation) AddedIDs(name string) []ent.Value {
 
 // RemovedEdges returns all edge names that were removed in this mutation.
 func (m *UserMutation) RemovedEdges() []string {
-	edges := make([]string, 0, 3)
+	edges := make([]string, 0, 4)
+	if m.removeddiscord_interactions != nil {
+		edges = append(edges, user.EdgeDiscordInteractions)
+	}
 	if m.removedsubscriptions != nil {
 		edges = append(edges, user.EdgeSubscriptions)
 	}
@@ -6994,6 +7898,12 @@ func (m *UserMutation) RemovedEdges() []string {
 // the given name in this mutation.
 func (m *UserMutation) RemovedIDs(name string) []ent.Value {
 	switch name {
+	case user.EdgeDiscordInteractions:
+		ids := make([]ent.Value, 0, len(m.removeddiscord_interactions))
+		for id := range m.removeddiscord_interactions {
+			ids = append(ids, id)
+		}
+		return ids
 	case user.EdgeSubscriptions:
 		ids := make([]ent.Value, 0, len(m.removedsubscriptions))
 		for id := range m.removedsubscriptions {
@@ -7018,7 +7928,10 @@ func (m *UserMutation) RemovedIDs(name string) []ent.Value {
 
 // ClearedEdges returns all edge names that were cleared in this mutation.
 func (m *UserMutation) ClearedEdges() []string {
-	edges := make([]string, 0, 3)
+	edges := make([]string, 0, 4)
+	if m.cleareddiscord_interactions {
+		edges = append(edges, user.EdgeDiscordInteractions)
+	}
 	if m.clearedsubscriptions {
 		edges = append(edges, user.EdgeSubscriptions)
 	}
@@ -7035,6 +7948,8 @@ func (m *UserMutation) ClearedEdges() []string {
 // was cleared in this mutation.
 func (m *UserMutation) EdgeCleared(name string) bool {
 	switch name {
+	case user.EdgeDiscordInteractions:
+		return m.cleareddiscord_interactions
 	case user.EdgeSubscriptions:
 		return m.clearedsubscriptions
 	case user.EdgeConnections:
@@ -7057,6 +7972,9 @@ func (m *UserMutation) ClearEdge(name string) error {
 // It returns an error if the edge is not defined in the schema.
 func (m *UserMutation) ResetEdge(name string) error {
 	switch name {
+	case user.EdgeDiscordInteractions:
+		m.ResetDiscordInteractions()
+		return nil
 	case user.EdgeSubscriptions:
 		m.ResetSubscriptions()
 		return nil
diff --git a/internal/database/ent/db/predicate/predicate.go b/internal/database/ent/db/predicate/predicate.go
index 899084f2..9814087f 100644
--- a/internal/database/ent/db/predicate/predicate.go
+++ b/internal/database/ent/db/predicate/predicate.go
@@ -27,6 +27,9 @@ type Clan func(*sql.Selector)
 // CronTask is the predicate function for crontask builders.
 type CronTask func(*sql.Selector)
 
+// DiscordInteraction is the predicate function for discordinteraction builders.
+type DiscordInteraction func(*sql.Selector)
+
 // User is the predicate function for user builders.
 type User func(*sql.Selector)
 
diff --git a/internal/database/ent/db/runtime.go b/internal/database/ent/db/runtime.go
index 2b639c03..c760c687 100644
--- a/internal/database/ent/db/runtime.go
+++ b/internal/database/ent/db/runtime.go
@@ -10,6 +10,7 @@ import (
 	"github.com/cufee/aftermath/internal/database/ent/db/applicationcommand"
 	"github.com/cufee/aftermath/internal/database/ent/db/clan"
 	"github.com/cufee/aftermath/internal/database/ent/db/crontask"
+	"github.com/cufee/aftermath/internal/database/ent/db/discordinteraction"
 	"github.com/cufee/aftermath/internal/database/ent/db/user"
 	"github.com/cufee/aftermath/internal/database/ent/db/userconnection"
 	"github.com/cufee/aftermath/internal/database/ent/db/usercontent"
@@ -202,6 +203,34 @@ func init() {
 	crontaskDescID := crontaskFields[0].Descriptor()
 	// crontask.DefaultID holds the default value on creation for the id field.
 	crontask.DefaultID = crontaskDescID.Default.(func() string)
+	discordinteractionFields := schema.DiscordInteraction{}.Fields()
+	_ = discordinteractionFields
+	// discordinteractionDescCreatedAt is the schema descriptor for created_at field.
+	discordinteractionDescCreatedAt := discordinteractionFields[1].Descriptor()
+	// discordinteraction.DefaultCreatedAt holds the default value on creation for the created_at field.
+	discordinteraction.DefaultCreatedAt = discordinteractionDescCreatedAt.Default.(func() int64)
+	// discordinteractionDescUpdatedAt is the schema descriptor for updated_at field.
+	discordinteractionDescUpdatedAt := discordinteractionFields[2].Descriptor()
+	// discordinteraction.DefaultUpdatedAt holds the default value on creation for the updated_at field.
+	discordinteraction.DefaultUpdatedAt = discordinteractionDescUpdatedAt.Default.(func() int64)
+	// discordinteraction.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
+	discordinteraction.UpdateDefaultUpdatedAt = discordinteractionDescUpdatedAt.UpdateDefault.(func() int64)
+	// discordinteractionDescCommand is the schema descriptor for command field.
+	discordinteractionDescCommand := discordinteractionFields[3].Descriptor()
+	// discordinteraction.CommandValidator is a validator for the "command" field. It is called by the builders before save.
+	discordinteraction.CommandValidator = discordinteractionDescCommand.Validators[0].(func(string) error)
+	// discordinteractionDescUserID is the schema descriptor for user_id field.
+	discordinteractionDescUserID := discordinteractionFields[4].Descriptor()
+	// discordinteraction.UserIDValidator is a validator for the "user_id" field. It is called by the builders before save.
+	discordinteraction.UserIDValidator = discordinteractionDescUserID.Validators[0].(func(string) error)
+	// discordinteractionDescReferenceID is the schema descriptor for reference_id field.
+	discordinteractionDescReferenceID := discordinteractionFields[5].Descriptor()
+	// discordinteraction.ReferenceIDValidator is a validator for the "reference_id" field. It is called by the builders before save.
+	discordinteraction.ReferenceIDValidator = discordinteractionDescReferenceID.Validators[0].(func(string) error)
+	// discordinteractionDescID is the schema descriptor for id field.
+	discordinteractionDescID := discordinteractionFields[0].Descriptor()
+	// discordinteraction.DefaultID holds the default value on creation for the id field.
+	discordinteraction.DefaultID = discordinteractionDescID.Default.(func() string)
 	userFields := schema.User{}.Fields()
 	_ = userFields
 	// userDescCreatedAt is the schema descriptor for created_at field.
diff --git a/internal/database/ent/db/tx.go b/internal/database/ent/db/tx.go
index f0ab91bb..9852c615 100644
--- a/internal/database/ent/db/tx.go
+++ b/internal/database/ent/db/tx.go
@@ -28,6 +28,8 @@ type Tx struct {
 	Clan *ClanClient
 	// CronTask is the client for interacting with the CronTask builders.
 	CronTask *CronTaskClient
+	// DiscordInteraction is the client for interacting with the DiscordInteraction builders.
+	DiscordInteraction *DiscordInteractionClient
 	// User is the client for interacting with the User builders.
 	User *UserClient
 	// UserConnection is the client for interacting with the UserConnection builders.
@@ -180,6 +182,7 @@ func (tx *Tx) init() {
 	tx.ApplicationCommand = NewApplicationCommandClient(tx.config)
 	tx.Clan = NewClanClient(tx.config)
 	tx.CronTask = NewCronTaskClient(tx.config)
+	tx.DiscordInteraction = NewDiscordInteractionClient(tx.config)
 	tx.User = NewUserClient(tx.config)
 	tx.UserConnection = NewUserConnectionClient(tx.config)
 	tx.UserContent = NewUserContentClient(tx.config)
diff --git a/internal/database/ent/db/user.go b/internal/database/ent/db/user.go
index e8a51556..0c537425 100644
--- a/internal/database/ent/db/user.go
+++ b/internal/database/ent/db/user.go
@@ -33,6 +33,8 @@ type User struct {
 
 // UserEdges holds the relations/edges for other nodes in the graph.
 type UserEdges struct {
+	// DiscordInteractions holds the value of the discord_interactions edge.
+	DiscordInteractions []*DiscordInteraction `json:"discord_interactions,omitempty"`
 	// Subscriptions holds the value of the subscriptions edge.
 	Subscriptions []*UserSubscription `json:"subscriptions,omitempty"`
 	// Connections holds the value of the connections edge.
@@ -41,13 +43,22 @@ type UserEdges struct {
 	Content []*UserContent `json:"content,omitempty"`
 	// loadedTypes holds the information for reporting if a
 	// type was loaded (or requested) in eager-loading or not.
-	loadedTypes [3]bool
+	loadedTypes [4]bool
+}
+
+// DiscordInteractionsOrErr returns the DiscordInteractions value or an error if the edge
+// was not loaded in eager-loading.
+func (e UserEdges) DiscordInteractionsOrErr() ([]*DiscordInteraction, error) {
+	if e.loadedTypes[0] {
+		return e.DiscordInteractions, nil
+	}
+	return nil, &NotLoadedError{edge: "discord_interactions"}
 }
 
 // SubscriptionsOrErr returns the Subscriptions value or an error if the edge
 // was not loaded in eager-loading.
 func (e UserEdges) SubscriptionsOrErr() ([]*UserSubscription, error) {
-	if e.loadedTypes[0] {
+	if e.loadedTypes[1] {
 		return e.Subscriptions, nil
 	}
 	return nil, &NotLoadedError{edge: "subscriptions"}
@@ -56,7 +67,7 @@ func (e UserEdges) SubscriptionsOrErr() ([]*UserSubscription, error) {
 // ConnectionsOrErr returns the Connections value or an error if the edge
 // was not loaded in eager-loading.
 func (e UserEdges) ConnectionsOrErr() ([]*UserConnection, error) {
-	if e.loadedTypes[1] {
+	if e.loadedTypes[2] {
 		return e.Connections, nil
 	}
 	return nil, &NotLoadedError{edge: "connections"}
@@ -65,7 +76,7 @@ func (e UserEdges) ConnectionsOrErr() ([]*UserConnection, error) {
 // ContentOrErr returns the Content value or an error if the edge
 // was not loaded in eager-loading.
 func (e UserEdges) ContentOrErr() ([]*UserContent, error) {
-	if e.loadedTypes[2] {
+	if e.loadedTypes[3] {
 		return e.Content, nil
 	}
 	return nil, &NotLoadedError{edge: "content"}
@@ -142,6 +153,11 @@ func (u *User) Value(name string) (ent.Value, error) {
 	return u.selectValues.Get(name)
 }
 
+// QueryDiscordInteractions queries the "discord_interactions" edge of the User entity.
+func (u *User) QueryDiscordInteractions() *DiscordInteractionQuery {
+	return NewUserClient(u.config).QueryDiscordInteractions(u)
+}
+
 // QuerySubscriptions queries the "subscriptions" edge of the User entity.
 func (u *User) QuerySubscriptions() *UserSubscriptionQuery {
 	return NewUserClient(u.config).QuerySubscriptions(u)
diff --git a/internal/database/ent/db/user/user.go b/internal/database/ent/db/user/user.go
index b16e3e67..524bdf47 100644
--- a/internal/database/ent/db/user/user.go
+++ b/internal/database/ent/db/user/user.go
@@ -20,6 +20,8 @@ const (
 	FieldPermissions = "permissions"
 	// FieldFeatureFlags holds the string denoting the feature_flags field in the database.
 	FieldFeatureFlags = "feature_flags"
+	// EdgeDiscordInteractions holds the string denoting the discord_interactions edge name in mutations.
+	EdgeDiscordInteractions = "discord_interactions"
 	// EdgeSubscriptions holds the string denoting the subscriptions edge name in mutations.
 	EdgeSubscriptions = "subscriptions"
 	// EdgeConnections holds the string denoting the connections edge name in mutations.
@@ -28,6 +30,13 @@ const (
 	EdgeContent = "content"
 	// Table holds the table name of the user in the database.
 	Table = "users"
+	// DiscordInteractionsTable is the table that holds the discord_interactions relation/edge.
+	DiscordInteractionsTable = "discord_interactions"
+	// DiscordInteractionsInverseTable is the table name for the DiscordInteraction entity.
+	// It exists in this package in order to avoid circular dependency with the "discordinteraction" package.
+	DiscordInteractionsInverseTable = "discord_interactions"
+	// DiscordInteractionsColumn is the table column denoting the discord_interactions relation/edge.
+	DiscordInteractionsColumn = "user_id"
 	// SubscriptionsTable is the table that holds the subscriptions relation/edge.
 	SubscriptionsTable = "user_subscriptions"
 	// SubscriptionsInverseTable is the table name for the UserSubscription entity.
@@ -104,6 +113,20 @@ func ByPermissions(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldPermissions, opts...).ToFunc()
 }
 
+// ByDiscordInteractionsCount orders the results by discord_interactions count.
+func ByDiscordInteractionsCount(opts ...sql.OrderTermOption) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborsCount(s, newDiscordInteractionsStep(), opts...)
+	}
+}
+
+// ByDiscordInteractions orders the results by discord_interactions terms.
+func ByDiscordInteractions(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborTerms(s, newDiscordInteractionsStep(), append([]sql.OrderTerm{term}, terms...)...)
+	}
+}
+
 // BySubscriptionsCount orders the results by subscriptions count.
 func BySubscriptionsCount(opts ...sql.OrderTermOption) OrderOption {
 	return func(s *sql.Selector) {
@@ -145,6 +168,13 @@ func ByContent(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
 		sqlgraph.OrderByNeighborTerms(s, newContentStep(), append([]sql.OrderTerm{term}, terms...)...)
 	}
 }
+func newDiscordInteractionsStep() *sqlgraph.Step {
+	return sqlgraph.NewStep(
+		sqlgraph.From(Table, FieldID),
+		sqlgraph.To(DiscordInteractionsInverseTable, FieldID),
+		sqlgraph.Edge(sqlgraph.O2M, false, DiscordInteractionsTable, DiscordInteractionsColumn),
+	)
+}
 func newSubscriptionsStep() *sqlgraph.Step {
 	return sqlgraph.NewStep(
 		sqlgraph.From(Table, FieldID),
diff --git a/internal/database/ent/db/user/where.go b/internal/database/ent/db/user/where.go
index cf752542..c3a5e922 100644
--- a/internal/database/ent/db/user/where.go
+++ b/internal/database/ent/db/user/where.go
@@ -233,6 +233,29 @@ func FeatureFlagsNotNil() predicate.User {
 	return predicate.User(sql.FieldNotNull(FieldFeatureFlags))
 }
 
+// HasDiscordInteractions applies the HasEdge predicate on the "discord_interactions" edge.
+func HasDiscordInteractions() predicate.User {
+	return predicate.User(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, DiscordInteractionsTable, DiscordInteractionsColumn),
+		)
+		sqlgraph.HasNeighbors(s, step)
+	})
+}
+
+// HasDiscordInteractionsWith applies the HasEdge predicate on the "discord_interactions" edge with a given conditions (other predicates).
+func HasDiscordInteractionsWith(preds ...predicate.DiscordInteraction) predicate.User {
+	return predicate.User(func(s *sql.Selector) {
+		step := newDiscordInteractionsStep()
+		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+			for _, p := range preds {
+				p(s)
+			}
+		})
+	})
+}
+
 // HasSubscriptions applies the HasEdge predicate on the "subscriptions" edge.
 func HasSubscriptions() predicate.User {
 	return predicate.User(func(s *sql.Selector) {
diff --git a/internal/database/ent/db/user_create.go b/internal/database/ent/db/user_create.go
index 1db7f19a..1aa4e5e8 100644
--- a/internal/database/ent/db/user_create.go
+++ b/internal/database/ent/db/user_create.go
@@ -9,6 +9,7 @@ import (
 
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/discordinteraction"
 	"github.com/cufee/aftermath/internal/database/ent/db/user"
 	"github.com/cufee/aftermath/internal/database/ent/db/userconnection"
 	"github.com/cufee/aftermath/internal/database/ent/db/usercontent"
@@ -76,6 +77,21 @@ func (uc *UserCreate) SetID(s string) *UserCreate {
 	return uc
 }
 
+// AddDiscordInteractionIDs adds the "discord_interactions" edge to the DiscordInteraction entity by IDs.
+func (uc *UserCreate) AddDiscordInteractionIDs(ids ...string) *UserCreate {
+	uc.mutation.AddDiscordInteractionIDs(ids...)
+	return uc
+}
+
+// AddDiscordInteractions adds the "discord_interactions" edges to the DiscordInteraction entity.
+func (uc *UserCreate) AddDiscordInteractions(d ...*DiscordInteraction) *UserCreate {
+	ids := make([]string, len(d))
+	for i := range d {
+		ids[i] = d[i].ID
+	}
+	return uc.AddDiscordInteractionIDs(ids...)
+}
+
 // AddSubscriptionIDs adds the "subscriptions" edge to the UserSubscription entity by IDs.
 func (uc *UserCreate) AddSubscriptionIDs(ids ...string) *UserCreate {
 	uc.mutation.AddSubscriptionIDs(ids...)
@@ -232,6 +248,22 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) {
 		_spec.SetField(user.FieldFeatureFlags, field.TypeJSON, value)
 		_node.FeatureFlags = value
 	}
+	if nodes := uc.mutation.DiscordInteractionsIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.DiscordInteractionsTable,
+			Columns: []string{user.DiscordInteractionsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(discordinteraction.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges = append(_spec.Edges, edge)
+	}
 	if nodes := uc.mutation.SubscriptionsIDs(); len(nodes) > 0 {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,
diff --git a/internal/database/ent/db/user_query.go b/internal/database/ent/db/user_query.go
index 83ee3ea8..1416b0f7 100644
--- a/internal/database/ent/db/user_query.go
+++ b/internal/database/ent/db/user_query.go
@@ -11,6 +11,7 @@ import (
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/discordinteraction"
 	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
 	"github.com/cufee/aftermath/internal/database/ent/db/user"
 	"github.com/cufee/aftermath/internal/database/ent/db/userconnection"
@@ -21,13 +22,14 @@ import (
 // UserQuery is the builder for querying User entities.
 type UserQuery struct {
 	config
-	ctx               *QueryContext
-	order             []user.OrderOption
-	inters            []Interceptor
-	predicates        []predicate.User
-	withSubscriptions *UserSubscriptionQuery
-	withConnections   *UserConnectionQuery
-	withContent       *UserContentQuery
+	ctx                     *QueryContext
+	order                   []user.OrderOption
+	inters                  []Interceptor
+	predicates              []predicate.User
+	withDiscordInteractions *DiscordInteractionQuery
+	withSubscriptions       *UserSubscriptionQuery
+	withConnections         *UserConnectionQuery
+	withContent             *UserContentQuery
 	// intermediate query (i.e. traversal path).
 	sql  *sql.Selector
 	path func(context.Context) (*sql.Selector, error)
@@ -64,6 +66,28 @@ func (uq *UserQuery) Order(o ...user.OrderOption) *UserQuery {
 	return uq
 }
 
+// QueryDiscordInteractions chains the current query on the "discord_interactions" edge.
+func (uq *UserQuery) QueryDiscordInteractions() *DiscordInteractionQuery {
+	query := (&DiscordInteractionClient{config: uq.config}).Query()
+	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+		if err := uq.prepareQuery(ctx); err != nil {
+			return nil, err
+		}
+		selector := uq.sqlQuery(ctx)
+		if err := selector.Err(); err != nil {
+			return nil, err
+		}
+		step := sqlgraph.NewStep(
+			sqlgraph.From(user.Table, user.FieldID, selector),
+			sqlgraph.To(discordinteraction.Table, discordinteraction.FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, user.DiscordInteractionsTable, user.DiscordInteractionsColumn),
+		)
+		fromU = sqlgraph.SetNeighbors(uq.driver.Dialect(), step)
+		return fromU, nil
+	}
+	return query
+}
+
 // QuerySubscriptions chains the current query on the "subscriptions" edge.
 func (uq *UserQuery) QuerySubscriptions() *UserSubscriptionQuery {
 	query := (&UserSubscriptionClient{config: uq.config}).Query()
@@ -317,20 +341,32 @@ func (uq *UserQuery) Clone() *UserQuery {
 		return nil
 	}
 	return &UserQuery{
-		config:            uq.config,
-		ctx:               uq.ctx.Clone(),
-		order:             append([]user.OrderOption{}, uq.order...),
-		inters:            append([]Interceptor{}, uq.inters...),
-		predicates:        append([]predicate.User{}, uq.predicates...),
-		withSubscriptions: uq.withSubscriptions.Clone(),
-		withConnections:   uq.withConnections.Clone(),
-		withContent:       uq.withContent.Clone(),
+		config:                  uq.config,
+		ctx:                     uq.ctx.Clone(),
+		order:                   append([]user.OrderOption{}, uq.order...),
+		inters:                  append([]Interceptor{}, uq.inters...),
+		predicates:              append([]predicate.User{}, uq.predicates...),
+		withDiscordInteractions: uq.withDiscordInteractions.Clone(),
+		withSubscriptions:       uq.withSubscriptions.Clone(),
+		withConnections:         uq.withConnections.Clone(),
+		withContent:             uq.withContent.Clone(),
 		// clone intermediate query.
 		sql:  uq.sql.Clone(),
 		path: uq.path,
 	}
 }
 
+// WithDiscordInteractions tells the query-builder to eager-load the nodes that are connected to
+// the "discord_interactions" edge. The optional arguments are used to configure the query builder of the edge.
+func (uq *UserQuery) WithDiscordInteractions(opts ...func(*DiscordInteractionQuery)) *UserQuery {
+	query := (&DiscordInteractionClient{config: uq.config}).Query()
+	for _, opt := range opts {
+		opt(query)
+	}
+	uq.withDiscordInteractions = query
+	return uq
+}
+
 // WithSubscriptions tells the query-builder to eager-load the nodes that are connected to
 // the "subscriptions" edge. The optional arguments are used to configure the query builder of the edge.
 func (uq *UserQuery) WithSubscriptions(opts ...func(*UserSubscriptionQuery)) *UserQuery {
@@ -442,7 +478,8 @@ func (uq *UserQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*User, e
 	var (
 		nodes       = []*User{}
 		_spec       = uq.querySpec()
-		loadedTypes = [3]bool{
+		loadedTypes = [4]bool{
+			uq.withDiscordInteractions != nil,
 			uq.withSubscriptions != nil,
 			uq.withConnections != nil,
 			uq.withContent != nil,
@@ -466,6 +503,15 @@ func (uq *UserQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*User, e
 	if len(nodes) == 0 {
 		return nodes, nil
 	}
+	if query := uq.withDiscordInteractions; query != nil {
+		if err := uq.loadDiscordInteractions(ctx, query, nodes,
+			func(n *User) { n.Edges.DiscordInteractions = []*DiscordInteraction{} },
+			func(n *User, e *DiscordInteraction) {
+				n.Edges.DiscordInteractions = append(n.Edges.DiscordInteractions, e)
+			}); err != nil {
+			return nil, err
+		}
+	}
 	if query := uq.withSubscriptions; query != nil {
 		if err := uq.loadSubscriptions(ctx, query, nodes,
 			func(n *User) { n.Edges.Subscriptions = []*UserSubscription{} },
@@ -490,6 +536,36 @@ func (uq *UserQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*User, e
 	return nodes, nil
 }
 
+func (uq *UserQuery) loadDiscordInteractions(ctx context.Context, query *DiscordInteractionQuery, nodes []*User, init func(*User), assign func(*User, *DiscordInteraction)) error {
+	fks := make([]driver.Value, 0, len(nodes))
+	nodeids := make(map[string]*User)
+	for i := range nodes {
+		fks = append(fks, nodes[i].ID)
+		nodeids[nodes[i].ID] = nodes[i]
+		if init != nil {
+			init(nodes[i])
+		}
+	}
+	if len(query.ctx.Fields) > 0 {
+		query.ctx.AppendFieldOnce(discordinteraction.FieldUserID)
+	}
+	query.Where(predicate.DiscordInteraction(func(s *sql.Selector) {
+		s.Where(sql.InValues(s.C(user.DiscordInteractionsColumn), fks...))
+	}))
+	neighbors, err := query.All(ctx)
+	if err != nil {
+		return err
+	}
+	for _, n := range neighbors {
+		fk := n.UserID
+		node, ok := nodeids[fk]
+		if !ok {
+			return fmt.Errorf(`unexpected referenced foreign-key "user_id" returned %v for node %v`, fk, n.ID)
+		}
+		assign(node, n)
+	}
+	return nil
+}
 func (uq *UserQuery) loadSubscriptions(ctx context.Context, query *UserSubscriptionQuery, nodes []*User, init func(*User), assign func(*User, *UserSubscription)) error {
 	fks := make([]driver.Value, 0, len(nodes))
 	nodeids := make(map[string]*User)
diff --git a/internal/database/ent/db/user_update.go b/internal/database/ent/db/user_update.go
index d4ac1622..4a19da4a 100644
--- a/internal/database/ent/db/user_update.go
+++ b/internal/database/ent/db/user_update.go
@@ -11,6 +11,7 @@ import (
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"entgo.io/ent/dialect/sql/sqljson"
 	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/discordinteraction"
 	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
 	"github.com/cufee/aftermath/internal/database/ent/db/user"
 	"github.com/cufee/aftermath/internal/database/ent/db/userconnection"
@@ -76,6 +77,21 @@ func (uu *UserUpdate) ClearFeatureFlags() *UserUpdate {
 	return uu
 }
 
+// AddDiscordInteractionIDs adds the "discord_interactions" edge to the DiscordInteraction entity by IDs.
+func (uu *UserUpdate) AddDiscordInteractionIDs(ids ...string) *UserUpdate {
+	uu.mutation.AddDiscordInteractionIDs(ids...)
+	return uu
+}
+
+// AddDiscordInteractions adds the "discord_interactions" edges to the DiscordInteraction entity.
+func (uu *UserUpdate) AddDiscordInteractions(d ...*DiscordInteraction) *UserUpdate {
+	ids := make([]string, len(d))
+	for i := range d {
+		ids[i] = d[i].ID
+	}
+	return uu.AddDiscordInteractionIDs(ids...)
+}
+
 // AddSubscriptionIDs adds the "subscriptions" edge to the UserSubscription entity by IDs.
 func (uu *UserUpdate) AddSubscriptionIDs(ids ...string) *UserUpdate {
 	uu.mutation.AddSubscriptionIDs(ids...)
@@ -126,6 +142,27 @@ func (uu *UserUpdate) Mutation() *UserMutation {
 	return uu.mutation
 }
 
+// ClearDiscordInteractions clears all "discord_interactions" edges to the DiscordInteraction entity.
+func (uu *UserUpdate) ClearDiscordInteractions() *UserUpdate {
+	uu.mutation.ClearDiscordInteractions()
+	return uu
+}
+
+// RemoveDiscordInteractionIDs removes the "discord_interactions" edge to DiscordInteraction entities by IDs.
+func (uu *UserUpdate) RemoveDiscordInteractionIDs(ids ...string) *UserUpdate {
+	uu.mutation.RemoveDiscordInteractionIDs(ids...)
+	return uu
+}
+
+// RemoveDiscordInteractions removes "discord_interactions" edges to DiscordInteraction entities.
+func (uu *UserUpdate) RemoveDiscordInteractions(d ...*DiscordInteraction) *UserUpdate {
+	ids := make([]string, len(d))
+	for i := range d {
+		ids[i] = d[i].ID
+	}
+	return uu.RemoveDiscordInteractionIDs(ids...)
+}
+
 // ClearSubscriptions clears all "subscriptions" edges to the UserSubscription entity.
 func (uu *UserUpdate) ClearSubscriptions() *UserUpdate {
 	uu.mutation.ClearSubscriptions()
@@ -254,6 +291,51 @@ func (uu *UserUpdate) sqlSave(ctx context.Context) (n int, err error) {
 	if uu.mutation.FeatureFlagsCleared() {
 		_spec.ClearField(user.FieldFeatureFlags, field.TypeJSON)
 	}
+	if uu.mutation.DiscordInteractionsCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.DiscordInteractionsTable,
+			Columns: []string{user.DiscordInteractionsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(discordinteraction.FieldID, field.TypeString),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := uu.mutation.RemovedDiscordInteractionsIDs(); len(nodes) > 0 && !uu.mutation.DiscordInteractionsCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.DiscordInteractionsTable,
+			Columns: []string{user.DiscordInteractionsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(discordinteraction.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := uu.mutation.DiscordInteractionsIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.DiscordInteractionsTable,
+			Columns: []string{user.DiscordInteractionsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(discordinteraction.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
 	if uu.mutation.SubscriptionsCleared() {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,
@@ -454,6 +536,21 @@ func (uuo *UserUpdateOne) ClearFeatureFlags() *UserUpdateOne {
 	return uuo
 }
 
+// AddDiscordInteractionIDs adds the "discord_interactions" edge to the DiscordInteraction entity by IDs.
+func (uuo *UserUpdateOne) AddDiscordInteractionIDs(ids ...string) *UserUpdateOne {
+	uuo.mutation.AddDiscordInteractionIDs(ids...)
+	return uuo
+}
+
+// AddDiscordInteractions adds the "discord_interactions" edges to the DiscordInteraction entity.
+func (uuo *UserUpdateOne) AddDiscordInteractions(d ...*DiscordInteraction) *UserUpdateOne {
+	ids := make([]string, len(d))
+	for i := range d {
+		ids[i] = d[i].ID
+	}
+	return uuo.AddDiscordInteractionIDs(ids...)
+}
+
 // AddSubscriptionIDs adds the "subscriptions" edge to the UserSubscription entity by IDs.
 func (uuo *UserUpdateOne) AddSubscriptionIDs(ids ...string) *UserUpdateOne {
 	uuo.mutation.AddSubscriptionIDs(ids...)
@@ -504,6 +601,27 @@ func (uuo *UserUpdateOne) Mutation() *UserMutation {
 	return uuo.mutation
 }
 
+// ClearDiscordInteractions clears all "discord_interactions" edges to the DiscordInteraction entity.
+func (uuo *UserUpdateOne) ClearDiscordInteractions() *UserUpdateOne {
+	uuo.mutation.ClearDiscordInteractions()
+	return uuo
+}
+
+// RemoveDiscordInteractionIDs removes the "discord_interactions" edge to DiscordInteraction entities by IDs.
+func (uuo *UserUpdateOne) RemoveDiscordInteractionIDs(ids ...string) *UserUpdateOne {
+	uuo.mutation.RemoveDiscordInteractionIDs(ids...)
+	return uuo
+}
+
+// RemoveDiscordInteractions removes "discord_interactions" edges to DiscordInteraction entities.
+func (uuo *UserUpdateOne) RemoveDiscordInteractions(d ...*DiscordInteraction) *UserUpdateOne {
+	ids := make([]string, len(d))
+	for i := range d {
+		ids[i] = d[i].ID
+	}
+	return uuo.RemoveDiscordInteractionIDs(ids...)
+}
+
 // ClearSubscriptions clears all "subscriptions" edges to the UserSubscription entity.
 func (uuo *UserUpdateOne) ClearSubscriptions() *UserUpdateOne {
 	uuo.mutation.ClearSubscriptions()
@@ -662,6 +780,51 @@ func (uuo *UserUpdateOne) sqlSave(ctx context.Context) (_node *User, err error)
 	if uuo.mutation.FeatureFlagsCleared() {
 		_spec.ClearField(user.FieldFeatureFlags, field.TypeJSON)
 	}
+	if uuo.mutation.DiscordInteractionsCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.DiscordInteractionsTable,
+			Columns: []string{user.DiscordInteractionsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(discordinteraction.FieldID, field.TypeString),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := uuo.mutation.RemovedDiscordInteractionsIDs(); len(nodes) > 0 && !uuo.mutation.DiscordInteractionsCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.DiscordInteractionsTable,
+			Columns: []string{user.DiscordInteractionsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(discordinteraction.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := uuo.mutation.DiscordInteractionsIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.DiscordInteractionsTable,
+			Columns: []string{user.DiscordInteractionsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(discordinteraction.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
 	if uuo.mutation.SubscriptionsCleared() {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,
diff --git a/internal/database/ent/migrate/migrations/20240626213554.sql b/internal/database/ent/migrate/migrations/20240626213554.sql
new file mode 100644
index 00000000..378ea14d
--- /dev/null
+++ b/internal/database/ent/migrate/migrations/20240626213554.sql
@@ -0,0 +1,12 @@
+-- Create "discord_interactions" table
+CREATE TABLE `discord_interactions` (`id` text NOT NULL, `created_at` integer NOT NULL, `updated_at` integer NOT NULL, `command` text NOT NULL, `reference_id` text NOT NULL, `type` text NOT NULL, `locale` text NOT NULL, `options` json NOT NULL, `user_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `discord_interactions_users_discord_interactions` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE NO ACTION);
+-- Create index "discordinteraction_id" to table: "discord_interactions"
+CREATE INDEX `discordinteraction_id` ON `discord_interactions` (`id`);
+-- Create index "discordinteraction_command" to table: "discord_interactions"
+CREATE INDEX `discordinteraction_command` ON `discord_interactions` (`command`);
+-- Create index "discordinteraction_user_id" to table: "discord_interactions"
+CREATE INDEX `discordinteraction_user_id` ON `discord_interactions` (`user_id`);
+-- Create index "discordinteraction_user_id_type" to table: "discord_interactions"
+CREATE INDEX `discordinteraction_user_id_type` ON `discord_interactions` (`user_id`, `type`);
+-- Create index "discordinteraction_reference_id" to table: "discord_interactions"
+CREATE INDEX `discordinteraction_reference_id` ON `discord_interactions` (`reference_id`);
diff --git a/internal/database/ent/migrate/migrations/atlas.sum b/internal/database/ent/migrate/migrations/atlas.sum
index 7cf2c24b..cdc03f33 100644
--- a/internal/database/ent/migrate/migrations/atlas.sum
+++ b/internal/database/ent/migrate/migrations/atlas.sum
@@ -1,3 +1,4 @@
-h1:hbF7dyumL2NNWMkQkprSMNkXUEeHsM+GMYMBPXWdjW0=
+h1:mPthURxB95TzDLQ5/ssWicoIRBsv760ADaBxoBMbLjQ=
 20240622203812_init.sql h1:Rt6NGvXbPBEpjg1pUFqn97FV8X3X2d1x7J2zOAAxolc=
 20240623143618_added_indexes_on_id.sql h1:o57d1Hc6+wGscJp3VIWnCNrmQkBSeSKTEVKRSWmsc6k=
+20240626213554.sql h1:sKGMP6giStLCW5lUK8VyaLxmiPRQTxT+y6xRkax1juM=
diff --git a/internal/database/ent/schema/application_command.go b/internal/database/ent/schema/application_command.go
index d15db084..e4cd39b3 100644
--- a/internal/database/ent/schema/application_command.go
+++ b/internal/database/ent/schema/application_command.go
@@ -6,19 +6,6 @@ import (
 	"entgo.io/ent/schema/index"
 )
 
-// model ApplicationCommand {
-//   id        String   @id
-//   createdAt DateTime @default(now())
-//   updatedAt DateTime @updatedAt
-
-//   name        String
-//   version     String
-//   optionsHash String
-
-//   @@index([optionsHash])
-//   @@map("application_commands")
-// }
-
 // ApplicationCommand holds the schema definition for the ApplicationCommand entity.
 type ApplicationCommand struct {
 	ent.Schema
diff --git a/internal/database/ent/schema/discord_interaction.go b/internal/database/ent/schema/discord_interaction.go
new file mode 100644
index 00000000..8b5d1beb
--- /dev/null
+++ b/internal/database/ent/schema/discord_interaction.go
@@ -0,0 +1,41 @@
+package schema
+
+import (
+	"entgo.io/ent"
+	"entgo.io/ent/schema/edge"
+	"entgo.io/ent/schema/field"
+	"entgo.io/ent/schema/index"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+type DiscordInteraction struct {
+	ent.Schema
+}
+
+func (DiscordInteraction) Fields() []ent.Field {
+	return append(defaultFields,
+		field.String("command").NotEmpty(),
+		field.String("user_id").NotEmpty().Immutable(),
+		field.String("reference_id").NotEmpty(),
+		field.Enum("type").
+			GoType(models.DiscordInteractionType("")),
+		field.String("locale"),
+		field.JSON("options", models.DiscordInteractionOptions{}),
+	)
+}
+
+func (DiscordInteraction) Edges() []ent.Edge {
+	return []ent.Edge{
+		edge.From("user", User.Type).Ref("discord_interactions").Field("user_id").Required().Immutable().Unique(),
+	}
+}
+
+func (DiscordInteraction) Indexes() []ent.Index {
+	return []ent.Index{
+		index.Fields("id"),
+		index.Fields("command"),
+		index.Fields("user_id"),
+		index.Fields("user_id", "type"),
+		index.Fields("reference_id"),
+	}
+}
diff --git a/internal/database/ent/schema/user.go b/internal/database/ent/schema/user.go
index be20a1be..6ae361e9 100644
--- a/internal/database/ent/schema/user.go
+++ b/internal/database/ent/schema/user.go
@@ -33,6 +33,7 @@ func (User) Fields() []ent.Field {
 // Edges of the User.
 func (User) Edges() []ent.Edge {
 	return []ent.Edge{
+		edge.To("discord_interactions", DiscordInteraction.Type),
 		edge.To("subscriptions", UserSubscription.Type),
 		edge.To("connections", UserConnection.Type),
 		edge.To("content", UserContent.Type),
diff --git a/internal/database/ent/schema/user_connection.go b/internal/database/ent/schema/user_connection.go
index 8b4a1a28..93073ab2 100644
--- a/internal/database/ent/schema/user_connection.go
+++ b/internal/database/ent/schema/user_connection.go
@@ -8,27 +8,6 @@ import (
 	"github.com/cufee/aftermath/internal/database/models"
 )
 
-// model UserConnection {
-//   id        String   @id @default(cuid())
-//   createdAt DateTime @default(now())
-//   updatedAt DateTime @updatedAt
-
-//   user   User   @relation(fields: [userId], references: [id])
-//   userId String
-
-//   type        String
-//   permissions String
-//   referenceId String
-
-//   metadataEncoded Bytes
-
-//   @@index([userId])
-//   @@index([type, userId])
-//   @@index([referenceId])
-//   @@index([type, referenceId])
-//   @@map("user_connections")
-// }
-
 // UserConnection holds the schema definition for the UserConnection entity.
 type UserConnection struct {
 	ent.Schema
diff --git a/internal/database/models/discord_interaction.go b/internal/database/models/discord_interaction.go
new file mode 100644
index 00000000..f031317b
--- /dev/null
+++ b/internal/database/models/discord_interaction.go
@@ -0,0 +1,51 @@
+package models
+
+import (
+	"slices"
+	"time"
+
+	"golang.org/x/text/language"
+)
+
+type DiscordInteractionType string
+
+const (
+	InteractionTypeStats = "stats"
+)
+
+var discordInteractionTypes = []DiscordInteractionType{
+	InteractionTypeStats,
+}
+
+// Values provides list valid values for Enum.
+func (DiscordInteractionType) Values() []string {
+	var kinds []string
+	for _, s := range discordInteractionTypes {
+		kinds = append(kinds, string(s))
+	}
+	return kinds
+}
+
+func (s DiscordInteractionType) Valid() bool {
+	return slices.Contains(discordInteractionTypes, s)
+}
+
+type DiscordInteraction struct {
+	ID        string
+	CreatedAt time.Time
+
+	UserID      string
+	Command     string
+	ReferenceID string
+
+	Type   DiscordInteractionType
+	Locale language.Tag
+
+	Options DiscordInteractionOptions
+}
+
+type DiscordInteractionOptions struct {
+	BackgroundImageURL string
+	PeriodStart        time.Time
+	AccountID          string
+}
diff --git a/internal/permissions/actions.go b/internal/permissions/actions.go
index 9c5b3b23..c9389344 100644
--- a/internal/permissions/actions.go
+++ b/internal/permissions/actions.go
@@ -57,6 +57,7 @@ var (
 )
 
 var (
-	// Admin
-	ViewLogs Permissions = fromLsh(60)
+	// Technical / Debugging
+	UseDebugFeatures = fromLsh(61)
+	ViewTaskLogs     = fromLsh(62)
 )
diff --git a/internal/permissions/roles.go b/internal/permissions/roles.go
index 364b861d..f4558ef5 100644
--- a/internal/permissions/roles.go
+++ b/internal/permissions/roles.go
@@ -16,6 +16,7 @@ var (
 				Add(CreateSoftUserRestriction)
 
 	GlobalModerator = ContentModerator.
+			Add(UseDebugFeatures).
 			Add(ViewUserSubscriptions).
 			Add(CreateUserSubscription).
 			Add(ExtendUserSubscription).
@@ -30,6 +31,7 @@ var (
 			Add(CreateHardUserRestriction)
 
 	GlobalAdmin = GlobalModerator.
+			Add(DebugAccess).
 			Add(CreateGlobalBackgroundPreset).
 			Add(UpdateGlobalBackgroundPreset).
 			Add(RemoveGlobalBackgroundPreset).
@@ -50,6 +52,8 @@ var (
 			Add(UpdateSoftRestriction).
 			Add(UpdateHardRestriction).
 			Add(RemoveSoftRestriction).
-			Add(RemoveHardRestriction).
-			Add(ViewLogs)
+			Add(RemoveHardRestriction)
+
+	DebugAccess = UseDebugFeatures.
+			Add(ViewTaskLogs)
 )
diff --git a/internal/stats/render/common/v1/options.go b/internal/stats/render/common/v1/options.go
index c334d085..24a80543 100644
--- a/internal/stats/render/common/v1/options.go
+++ b/internal/stats/render/common/v1/options.go
@@ -2,6 +2,9 @@ package common
 
 import (
 	"image"
+	"strings"
+
+	"github.com/cufee/aftermath/internal/stats/render/assets"
 )
 
 type Options struct {
@@ -21,8 +24,23 @@ func WithPromoText(text ...string) Option {
 	}
 }
 
-func WithBackground(bg image.Image) Option {
+func WithBackground(bgURL string) Option {
+	if bgURL == "" {
+		bgURL = "static://bg-default"
+	}
+
+	var image image.Image
+	if strings.HasPrefix(bgURL, "static://") {
+		img, ok := assets.GetLoadedImage(strings.ReplaceAll(bgURL, "static://", ""))
+		if ok {
+			image = img
+		}
+	}
+
+	if image == nil {
+		return func(o *Options) {}
+	}
 	return func(o *Options) {
-		o.Background = bg
+		o.Background = image
 	}
 }

From 2a0a56c55b481a81db492e5e19e07f3e38e356b1 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Wed, 26 Jun 2024 18:14:36 -0400
Subject: [PATCH 184/341] proper localization

---
 cmds/discord/commands/interactions.go     | 6 +++---
 internal/stats/render/session/v1/cards.go | 6 ------
 render_test.go                            | 6 +-----
 static/localization/en/discord.yaml       | 4 ++++
 4 files changed, 8 insertions(+), 14 deletions(-)

diff --git a/cmds/discord/commands/interactions.go b/cmds/discord/commands/interactions.go
index 7cbf31fd..23431a03 100644
--- a/cmds/discord/commands/interactions.go
+++ b/cmds/discord/commands/interactions.go
@@ -50,7 +50,7 @@ func init() {
 
 				interaction, err := ctx.Core.Database().GetDiscordInteraction(ctx.Context, interactionID)
 				if err != nil {
-					return ctx.Reply().Send("refresh_interaction_expired")
+					return ctx.Reply().Send("stats_refresh_interaction_error_expired")
 				}
 
 				var image renderer.Image
@@ -68,7 +68,7 @@ func init() {
 					img, mt, err := ctx.Core.Render(ctx.Locale).Session(context.Background(), interaction.Options.AccountID, interaction.Options.PeriodStart, render.WithBackground(interaction.Options.BackgroundImageURL))
 					if err != nil {
 						if errors.Is(err, fetch.ErrSessionNotFound) || errors.Is(err, renderer.ErrAccountNotTracked) {
-							return ctx.Reply().Send("refresh_interaction_expired")
+							return ctx.Reply().Send("stats_refresh_interaction_error_expired")
 						}
 						return ctx.Err(err)
 					}
@@ -77,7 +77,7 @@ func init() {
 
 				default:
 					log.Error().Str("customId", data.CustomID).Str("command", interaction.Command).Msg("received an unexpected component interaction callback")
-					return ctx.Reply().Send("refresh_interaction_expired")
+					return ctx.Reply().Send("stats_refresh_interaction_error_expired")
 				}
 
 				button, saveErr := saveInteractionData(ctx, interaction.Command, interaction.Options)
diff --git a/internal/stats/render/session/v1/cards.go b/internal/stats/render/session/v1/cards.go
index d0d59417..72afa921 100644
--- a/internal/stats/render/session/v1/cards.go
+++ b/internal/stats/render/session/v1/cards.go
@@ -190,24 +190,20 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 	}
 
 	// player title
-	println("making player title")
 	primaryColumn = append(primaryColumn,
 		common.NewPlayerTitleCard(common.DefaultPlayerTitleStyle(playerNameCardStyle(primaryCardWidth)), session.Account.Nickname, session.Account.ClanTag, subs),
 	)
 
 	// overview cards
 	if shouldRenderUnratedOverview {
-		println("making unrated overview")
 		primaryColumn = append(primaryColumn, makeOverviewCard(cards.Unrated.Overview, primaryCardBlockSizes, overviewCardStyle(primaryCardWidth)))
 	}
 	if shouldRenderRatingOverview {
-		println("making rating overview")
 		primaryColumn = append(primaryColumn, makeOverviewCard(cards.Rating.Overview, primaryCardBlockSizes, overviewRatingCardStyle(primaryCardWidth)))
 	}
 
 	// highlights
 	if shouldRenderUnratedHighlights {
-		println("making highlights")
 		for _, vehicle := range cards.Unrated.Highlights {
 			primaryColumn = append(primaryColumn, makeVehicleHighlightCard(vehicle, highlightCardBlockSizes, primaryCardWidth))
 		}
@@ -219,7 +215,6 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 
 	// unrated vehicles
 	if shouldRenderUnratedVehicles {
-		println("making unrated vehicles")
 		for i, vehicle := range cards.Unrated.Vehicles {
 			if i >= renderUnratedVehiclesCount {
 				break
@@ -400,7 +395,6 @@ func makeOverviewCard(card session.OverviewCard, blockSizes map[string]float64,
 	for _, column := range card.Blocks {
 		var columnContent []common.Block
 		for _, block := range column {
-			println("making block", block.Label)
 			var col common.Block
 			if block.Tag == prepare.TagWN8 || block.Tag == prepare.TagRankedRating {
 				col = makeSpecialRatingColumn(block, blockSizes[block.Tag.String()])
diff --git a/render_test.go b/render_test.go
index 866144a3..77756364 100644
--- a/render_test.go
+++ b/render_test.go
@@ -6,7 +6,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/cufee/aftermath/internal/stats/render/assets"
 	"github.com/cufee/aftermath/internal/stats/render/common/v1"
 	stats "github.com/cufee/aftermath/internal/stats/renderer/v1"
 	"github.com/rs/zerolog"
@@ -29,11 +28,8 @@ func TestRenderSession(t *testing.T) {
 	coreClient, _ := coreClientsFromEnv(db)
 	defer coreClient.Database().Disconnect()
 
-	bgImage, ok := assets.GetLoadedImage("bg-default")
-	assert.True(t, ok, "failed to load a background image")
-
 	renderer := stats.NewRenderer(coreClient.Fetch(), coreClient.Database(), coreClient.Wargaming(), language.English)
-	image, _, err := renderer.Session(context.Background(), "1013072123", time.Now(), common.WithBackground(bgImage))
+	image, _, err := renderer.Session(context.Background(), "1013072123", time.Now(), common.WithBackground(""))
 	assert.NoError(t, err, "failed to render a session image")
 	assert.NotNil(t, image, "image is nil")
 
diff --git a/static/localization/en/discord.yaml b/static/localization/en/discord.yaml
index c62ca987..19885bba 100755
--- a/static/localization/en/discord.yaml
+++ b/static/localization/en/discord.yaml
@@ -139,6 +139,10 @@
   value: "Aftermath does not yet have a session for this period. Try changing the number of days or using `/stats` instead."
   context: This account is being tracked, but there is no session available
 
+- key: stats_refresh_interaction_error_expired
+  value: "This refresh button has expired. Please use the command instead."
+  context: Failed to find required data in order to refresh stats/session
+
 # /background errors
 - key: background_error_payment_required
   value: "This feature of Aftermath is only available for users with an active subscription.\nYou can subscribe by using the `/subscribe` command or pick a background using `/fancy` instead."

From 77bbe10e2d3d768441c11bd831ed1c6e243bb99d Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Wed, 26 Jun 2024 18:38:52 -0400
Subject: [PATCH 185/341] custom refresh button icon

---
 cmds/discord/commands/interactions.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/cmds/discord/commands/interactions.go b/cmds/discord/commands/interactions.go
index 23431a03..edc30dba 100644
--- a/cmds/discord/commands/interactions.go
+++ b/cmds/discord/commands/interactions.go
@@ -25,7 +25,8 @@ func newStatsRefreshButton(data models.DiscordInteraction) discordgo.MessageComp
 		Components: []discordgo.MessageComponent{discordgo.Button{
 			Style: discordgo.SecondaryButton,
 			Emoji: &discordgo.ComponentEmoji{
-				Name: "🔃",
+				ID:   "1255647885723435048",
+				Name: "aftermath_refresh",
 			},
 			CustomID: fmt.Sprintf("refresh_stats_from_button_%s", data.ReferenceID),
 		}},

From e667d35e74a6554b5afea1361d86828e9b5664b4 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Wed, 26 Jun 2024 19:20:45 -0400
Subject: [PATCH 186/341] added content and restrictions

---
 cmds/discord/commands/interactions.go         |  2 +-
 cmds/discord/commands/link.go                 |  4 +-
 cmds/discord/commands/manage.go               |  4 +-
 cmds/discord/commands/session.go              | 14 ++--
 cmds/discord/commands/stats.go                |  4 +-
 cmds/discord/common/reply.go                  |  2 +-
 cmds/discord/middleware/middleware.go         |  2 +-
 internal/database/ent/db/migrate/schema.go    |  2 +-
 internal/database/ent/db/mutation.go          | 12 ++--
 internal/database/ent/db/usercontent.go       | 16 ++---
 .../ent/db/usercontent/usercontent.go         |  5 ++
 internal/database/ent/db/usercontent/where.go | 70 +++++++++++++++++++
 .../database/ent/db/usercontent_create.go     |  6 +-
 .../database/ent/db/usercontent_update.go     | 28 ++++++--
 .../ent/migrate/migrations/20240626225519.sql | 22 ++++++
 .../database/ent/migrate/migrations/atlas.sum |  3 +-
 internal/database/ent/schema/user_content.go  |  2 +-
 internal/database/models/user.go              | 34 ++++++++-
 internal/database/models/user_content.go      | 46 ++++++++++++
 internal/database/models/user_restriction.go  | 32 +++++++++
 ...scription.go => user_subscription copy.go} | 30 --------
 internal/database/users.go                    | 30 ++++----
 22 files changed, 286 insertions(+), 84 deletions(-)
 create mode 100644 internal/database/ent/migrate/migrations/20240626225519.sql
 create mode 100644 internal/database/models/user_content.go
 create mode 100644 internal/database/models/user_restriction.go
 rename internal/database/models/{user_subscription.go => user_subscription copy.go} (75%)

diff --git a/cmds/discord/commands/interactions.go b/cmds/discord/commands/interactions.go
index edc30dba..b75dd28b 100644
--- a/cmds/discord/commands/interactions.go
+++ b/cmds/discord/commands/interactions.go
@@ -94,7 +94,7 @@ func init() {
 				}
 
 				var timings []string
-				if ctx.User.Permissions.Has(permissions.UseDebugFeatures) {
+				if ctx.User.HasPermission(permissions.UseDebugFeatures) {
 					timings = append(timings, "```")
 					for name, duration := range meta.Timings {
 						timings = append(timings, fmt.Sprintf("%s: %v", name, duration.Milliseconds()))
diff --git a/cmds/discord/commands/link.go b/cmds/discord/commands/link.go
index 63d801e8..1866735d 100644
--- a/cmds/discord/commands/link.go
+++ b/cmds/discord/commands/link.go
@@ -44,7 +44,7 @@ func init() {
 				account, err := ctx.Core.Fetch().Search(ctx.Context, options.Nickname, options.Server)
 				if err != nil {
 					if err.Error() == "no results found" {
-						return ctx.Reply().Fmt("stats_error_nickname_not_fount_fmt", options.Nickname, strings.ToUpper(options.Server)).Send()
+						return ctx.Reply().Format("stats_error_nickname_not_fount_fmt", options.Nickname, strings.ToUpper(options.Server)).Send()
 					}
 					return ctx.Err(err)
 				}
@@ -64,7 +64,7 @@ func init() {
 					return ctx.Err(err)
 				}
 
-				return ctx.Reply().Fmt("command_link_linked_successfully_fmt", account.Nickname, strings.ToUpper(options.Server)).Send()
+				return ctx.Reply().Format("command_link_linked_successfully_fmt", account.Nickname, strings.ToUpper(options.Server)).Send()
 			}),
 	)
 }
diff --git a/cmds/discord/commands/manage.go b/cmds/discord/commands/manage.go
index f75996f0..5fd07cbd 100644
--- a/cmds/discord/commands/manage.go
+++ b/cmds/discord/commands/manage.go
@@ -111,7 +111,7 @@ func init() {
 					return ctx.Reply().Send("```" + string(bytes) + "```")
 
 				case "tasks_view":
-					if !ctx.User.Permissions.Has(permissions.ViewTaskLogs) {
+					if !ctx.User.HasPermission(permissions.ViewTaskLogs) {
 						ctx.Reply().Send("You do not have access to this sub-command.")
 					}
 
@@ -149,7 +149,7 @@ func init() {
 					return ctx.Reply().File(bytes.NewBufferString(content), "tasks.json").Send()
 
 				case "tasks_details":
-					if !ctx.User.Permissions.Has(permissions.ViewTaskLogs) {
+					if !ctx.User.HasPermission(permissions.ViewTaskLogs) {
 						ctx.Reply().Send("You do not have access to this sub-command.")
 					}
 
diff --git a/cmds/discord/commands/session.go b/cmds/discord/commands/session.go
index 7a1562ad..641a95bd 100644
--- a/cmds/discord/commands/session.go
+++ b/cmds/discord/commands/session.go
@@ -41,14 +41,17 @@ func init() {
 						return ctx.Reply().Send("stats_error_connection_not_found_vague")
 					}
 					accountID = defaultAccount.ReferenceID
-					// TODO: Get user background
+					background, ok := mentionedUser.Content(models.UserContentTypePersonalBackground)
+					if ok {
+						backgroundURL = background.Value
+					}
 
 				case options.Nickname != "" && options.Server != "":
 					// nickname provided and server selected - lookup the account
 					account, err := ctx.Core.Fetch().Search(ctx.Context, options.Nickname, options.Server)
 					if err != nil {
 						if err.Error() == "no results found" {
-							return ctx.Reply().Fmt("stats_error_nickname_not_fount_fmt", options.Nickname, strings.ToUpper(options.Server)).Send()
+							return ctx.Reply().Format("stats_error_nickname_not_fount_fmt", options.Nickname, strings.ToUpper(options.Server)).Send()
 						}
 						return ctx.Err(err)
 					}
@@ -61,7 +64,10 @@ func init() {
 					}
 					// command used without options, but user has a default connection
 					accountID = defaultAccount.ReferenceID
-					// TODO: Get user background
+					background, ok := ctx.User.Content(models.UserContentTypePersonalBackground)
+					if ok {
+						backgroundURL = background.Value
+					}
 				}
 
 				image, meta, err := ctx.Core.Render(ctx.Locale).Session(context.Background(), accountID, options.PeriodStart, render.WithBackground(backgroundURL))
@@ -92,7 +98,7 @@ func init() {
 				}
 
 				var timings []string
-				if ctx.User.Permissions.Has(permissions.UseDebugFeatures) {
+				if ctx.User.HasPermission(permissions.UseDebugFeatures) {
 					timings = append(timings, "```")
 					for name, duration := range meta.Timings {
 						timings = append(timings, fmt.Sprintf("%s: %v", name, duration.Milliseconds()))
diff --git a/cmds/discord/commands/stats.go b/cmds/discord/commands/stats.go
index 0b3ded0a..ef5eca5f 100644
--- a/cmds/discord/commands/stats.go
+++ b/cmds/discord/commands/stats.go
@@ -45,7 +45,7 @@ func init() {
 					account, err := ctx.Core.Fetch().Search(ctx.Context, options.Nickname, options.Server)
 					if err != nil {
 						if err.Error() == "no results found" {
-							return ctx.Reply().Fmt("stats_error_nickname_not_fount_fmt", options.Nickname, strings.ToUpper(options.Server)).Send()
+							return ctx.Reply().Format("stats_error_nickname_not_fount_fmt", options.Nickname, strings.ToUpper(options.Server)).Send()
 						}
 						return ctx.Err(err)
 					}
@@ -83,7 +83,7 @@ func init() {
 				}
 
 				var timings []string
-				if ctx.User.Permissions.Has(permissions.UseDebugFeatures) {
+				if ctx.User.HasPermission(permissions.UseDebugFeatures) {
 					timings = append(timings, "```")
 					for name, duration := range meta.Timings {
 						timings = append(timings, fmt.Sprintf("%s: %v", name, duration.Milliseconds()))
diff --git a/cmds/discord/common/reply.go b/cmds/discord/common/reply.go
index 526cc416..457a253e 100644
--- a/cmds/discord/common/reply.go
+++ b/cmds/discord/common/reply.go
@@ -22,7 +22,7 @@ func (r reply) Text(message ...string) reply {
 	return r
 }
 
-func (r reply) Fmt(format string, args ...any) reply {
+func (r reply) Format(format string, args ...any) reply {
 	r.text = append(r.text, fmt.Sprintf(format, args...))
 	return r
 }
diff --git a/cmds/discord/middleware/middleware.go b/cmds/discord/middleware/middleware.go
index 634e6a93..26db204e 100644
--- a/cmds/discord/middleware/middleware.go
+++ b/cmds/discord/middleware/middleware.go
@@ -9,7 +9,7 @@ type MiddlewareFunc func(*common.Context, func(*common.Context) error) func(*com
 
 func RequirePermissions(required permissions.Permissions) MiddlewareFunc {
 	return func(ctx *common.Context, next func(*common.Context) error) func(*common.Context) error {
-		if !ctx.User.Permissions.Has(required) {
+		if !ctx.User.HasPermission(required) {
 			return func(ctx *common.Context) error {
 				return ctx.Reply().Send("common_error_command_missing_permissions")
 			}
diff --git a/internal/database/ent/db/migrate/schema.go b/internal/database/ent/db/migrate/schema.go
index 9432fc41..b198249e 100644
--- a/internal/database/ent/db/migrate/schema.go
+++ b/internal/database/ent/db/migrate/schema.go
@@ -436,7 +436,7 @@ var (
 		{Name: "updated_at", Type: field.TypeInt64},
 		{Name: "type", Type: field.TypeEnum, Enums: []string{"clan-background-image", "personal-background-image"}},
 		{Name: "reference_id", Type: field.TypeString},
-		{Name: "value", Type: field.TypeJSON},
+		{Name: "value", Type: field.TypeString},
 		{Name: "metadata", Type: field.TypeJSON},
 		{Name: "user_id", Type: field.TypeString},
 	}
diff --git a/internal/database/ent/db/mutation.go b/internal/database/ent/db/mutation.go
index d34605bc..1dcee88e 100644
--- a/internal/database/ent/db/mutation.go
+++ b/internal/database/ent/db/mutation.go
@@ -8820,7 +8820,7 @@ type UserContentMutation struct {
 	addupdated_at *int64
 	_type         *models.UserContentType
 	reference_id  *string
-	value         *any
+	value         *string
 	metadata      *map[string]interface{}
 	clearedFields map[string]struct{}
 	user          *string
@@ -9155,12 +9155,12 @@ func (m *UserContentMutation) ResetReferenceID() {
 }
 
 // SetValue sets the "value" field.
-func (m *UserContentMutation) SetValue(a any) {
-	m.value = &a
+func (m *UserContentMutation) SetValue(s string) {
+	m.value = &s
 }
 
 // Value returns the value of the "value" field in the mutation.
-func (m *UserContentMutation) Value() (r any, exists bool) {
+func (m *UserContentMutation) Value() (r string, exists bool) {
 	v := m.value
 	if v == nil {
 		return
@@ -9171,7 +9171,7 @@ func (m *UserContentMutation) Value() (r any, exists bool) {
 // OldValue returns the old "value" field's value of the UserContent entity.
 // If the UserContent object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *UserContentMutation) OldValue(ctx context.Context) (v any, err error) {
+func (m *UserContentMutation) OldValue(ctx context.Context) (v string, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldValue is only allowed on UpdateOne operations")
 	}
@@ -9399,7 +9399,7 @@ func (m *UserContentMutation) SetField(name string, value ent.Value) error {
 		m.SetReferenceID(v)
 		return nil
 	case usercontent.FieldValue:
-		v, ok := value.(any)
+		v, ok := value.(string)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
diff --git a/internal/database/ent/db/usercontent.go b/internal/database/ent/db/usercontent.go
index dfa12961..f60b64d1 100644
--- a/internal/database/ent/db/usercontent.go
+++ b/internal/database/ent/db/usercontent.go
@@ -30,7 +30,7 @@ type UserContent struct {
 	// ReferenceID holds the value of the "reference_id" field.
 	ReferenceID string `json:"reference_id,omitempty"`
 	// Value holds the value of the "value" field.
-	Value any `json:"value,omitempty"`
+	Value string `json:"value,omitempty"`
 	// Metadata holds the value of the "metadata" field.
 	Metadata map[string]interface{} `json:"metadata,omitempty"`
 	// Edges holds the relations/edges for other nodes in the graph.
@@ -64,11 +64,11 @@ func (*UserContent) scanValues(columns []string) ([]any, error) {
 	values := make([]any, len(columns))
 	for i := range columns {
 		switch columns[i] {
-		case usercontent.FieldValue, usercontent.FieldMetadata:
+		case usercontent.FieldMetadata:
 			values[i] = new([]byte)
 		case usercontent.FieldCreatedAt, usercontent.FieldUpdatedAt:
 			values[i] = new(sql.NullInt64)
-		case usercontent.FieldID, usercontent.FieldType, usercontent.FieldUserID, usercontent.FieldReferenceID:
+		case usercontent.FieldID, usercontent.FieldType, usercontent.FieldUserID, usercontent.FieldReferenceID, usercontent.FieldValue:
 			values[i] = new(sql.NullString)
 		default:
 			values[i] = new(sql.UnknownType)
@@ -122,12 +122,10 @@ func (uc *UserContent) assignValues(columns []string, values []any) error {
 				uc.ReferenceID = value.String
 			}
 		case usercontent.FieldValue:
-			if value, ok := values[i].(*[]byte); !ok {
+			if value, ok := values[i].(*sql.NullString); !ok {
 				return fmt.Errorf("unexpected type %T for field value", values[i])
-			} else if value != nil && len(*value) > 0 {
-				if err := json.Unmarshal(*value, &uc.Value); err != nil {
-					return fmt.Errorf("unmarshal field value: %w", err)
-				}
+			} else if value.Valid {
+				uc.Value = value.String
 			}
 		case usercontent.FieldMetadata:
 			if value, ok := values[i].(*[]byte); !ok {
@@ -194,7 +192,7 @@ func (uc *UserContent) String() string {
 	builder.WriteString(uc.ReferenceID)
 	builder.WriteString(", ")
 	builder.WriteString("value=")
-	builder.WriteString(fmt.Sprintf("%v", uc.Value))
+	builder.WriteString(uc.Value)
 	builder.WriteString(", ")
 	builder.WriteString("metadata=")
 	builder.WriteString(fmt.Sprintf("%v", uc.Metadata))
diff --git a/internal/database/ent/db/usercontent/usercontent.go b/internal/database/ent/db/usercontent/usercontent.go
index 89a1d190..a05b1dcb 100644
--- a/internal/database/ent/db/usercontent/usercontent.go
+++ b/internal/database/ent/db/usercontent/usercontent.go
@@ -118,6 +118,11 @@ func ByReferenceID(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldReferenceID, opts...).ToFunc()
 }
 
+// ByValue orders the results by the value field.
+func ByValue(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldValue, opts...).ToFunc()
+}
+
 // ByUserField orders the results by user field.
 func ByUserField(field string, opts ...sql.OrderTermOption) OrderOption {
 	return func(s *sql.Selector) {
diff --git a/internal/database/ent/db/usercontent/where.go b/internal/database/ent/db/usercontent/where.go
index b8133da2..db3d4033 100644
--- a/internal/database/ent/db/usercontent/where.go
+++ b/internal/database/ent/db/usercontent/where.go
@@ -84,6 +84,11 @@ func ReferenceID(v string) predicate.UserContent {
 	return predicate.UserContent(sql.FieldEQ(FieldReferenceID, v))
 }
 
+// Value applies equality check predicate on the "value" field. It's identical to ValueEQ.
+func Value(v string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldEQ(FieldValue, v))
+}
+
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
 func CreatedAtEQ(v int64) predicate.UserContent {
 	return predicate.UserContent(sql.FieldEQ(FieldCreatedAt, v))
@@ -324,6 +329,71 @@ func ReferenceIDContainsFold(v string) predicate.UserContent {
 	return predicate.UserContent(sql.FieldContainsFold(FieldReferenceID, v))
 }
 
+// ValueEQ applies the EQ predicate on the "value" field.
+func ValueEQ(v string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldEQ(FieldValue, v))
+}
+
+// ValueNEQ applies the NEQ predicate on the "value" field.
+func ValueNEQ(v string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldNEQ(FieldValue, v))
+}
+
+// ValueIn applies the In predicate on the "value" field.
+func ValueIn(vs ...string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldIn(FieldValue, vs...))
+}
+
+// ValueNotIn applies the NotIn predicate on the "value" field.
+func ValueNotIn(vs ...string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldNotIn(FieldValue, vs...))
+}
+
+// ValueGT applies the GT predicate on the "value" field.
+func ValueGT(v string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldGT(FieldValue, v))
+}
+
+// ValueGTE applies the GTE predicate on the "value" field.
+func ValueGTE(v string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldGTE(FieldValue, v))
+}
+
+// ValueLT applies the LT predicate on the "value" field.
+func ValueLT(v string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldLT(FieldValue, v))
+}
+
+// ValueLTE applies the LTE predicate on the "value" field.
+func ValueLTE(v string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldLTE(FieldValue, v))
+}
+
+// ValueContains applies the Contains predicate on the "value" field.
+func ValueContains(v string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldContains(FieldValue, v))
+}
+
+// ValueHasPrefix applies the HasPrefix predicate on the "value" field.
+func ValueHasPrefix(v string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldHasPrefix(FieldValue, v))
+}
+
+// ValueHasSuffix applies the HasSuffix predicate on the "value" field.
+func ValueHasSuffix(v string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldHasSuffix(FieldValue, v))
+}
+
+// ValueEqualFold applies the EqualFold predicate on the "value" field.
+func ValueEqualFold(v string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldEqualFold(FieldValue, v))
+}
+
+// ValueContainsFold applies the ContainsFold predicate on the "value" field.
+func ValueContainsFold(v string) predicate.UserContent {
+	return predicate.UserContent(sql.FieldContainsFold(FieldValue, v))
+}
+
 // HasUser applies the HasEdge predicate on the "user" edge.
 func HasUser() predicate.UserContent {
 	return predicate.UserContent(func(s *sql.Selector) {
diff --git a/internal/database/ent/db/usercontent_create.go b/internal/database/ent/db/usercontent_create.go
index ac65c16b..d127d2a3 100644
--- a/internal/database/ent/db/usercontent_create.go
+++ b/internal/database/ent/db/usercontent_create.go
@@ -68,8 +68,8 @@ func (ucc *UserContentCreate) SetReferenceID(s string) *UserContentCreate {
 }
 
 // SetValue sets the "value" field.
-func (ucc *UserContentCreate) SetValue(a any) *UserContentCreate {
-	ucc.mutation.SetValue(a)
+func (ucc *UserContentCreate) SetValue(s string) *UserContentCreate {
+	ucc.mutation.SetValue(s)
 	return ucc
 }
 
@@ -230,7 +230,7 @@ func (ucc *UserContentCreate) createSpec() (*UserContent, *sqlgraph.CreateSpec)
 		_node.ReferenceID = value
 	}
 	if value, ok := ucc.mutation.Value(); ok {
-		_spec.SetField(usercontent.FieldValue, field.TypeJSON, value)
+		_spec.SetField(usercontent.FieldValue, field.TypeString, value)
 		_node.Value = value
 	}
 	if value, ok := ucc.mutation.Metadata(); ok {
diff --git a/internal/database/ent/db/usercontent_update.go b/internal/database/ent/db/usercontent_update.go
index 25bb317e..93054653 100644
--- a/internal/database/ent/db/usercontent_update.go
+++ b/internal/database/ent/db/usercontent_update.go
@@ -70,8 +70,16 @@ func (ucu *UserContentUpdate) SetNillableReferenceID(s *string) *UserContentUpda
 }
 
 // SetValue sets the "value" field.
-func (ucu *UserContentUpdate) SetValue(a any) *UserContentUpdate {
-	ucu.mutation.SetValue(a)
+func (ucu *UserContentUpdate) SetValue(s string) *UserContentUpdate {
+	ucu.mutation.SetValue(s)
+	return ucu
+}
+
+// SetNillableValue sets the "value" field if the given value is not nil.
+func (ucu *UserContentUpdate) SetNillableValue(s *string) *UserContentUpdate {
+	if s != nil {
+		ucu.SetValue(*s)
+	}
 	return ucu
 }
 
@@ -160,7 +168,7 @@ func (ucu *UserContentUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		_spec.SetField(usercontent.FieldReferenceID, field.TypeString, value)
 	}
 	if value, ok := ucu.mutation.Value(); ok {
-		_spec.SetField(usercontent.FieldValue, field.TypeJSON, value)
+		_spec.SetField(usercontent.FieldValue, field.TypeString, value)
 	}
 	if value, ok := ucu.mutation.Metadata(); ok {
 		_spec.SetField(usercontent.FieldMetadata, field.TypeJSON, value)
@@ -227,8 +235,16 @@ func (ucuo *UserContentUpdateOne) SetNillableReferenceID(s *string) *UserContent
 }
 
 // SetValue sets the "value" field.
-func (ucuo *UserContentUpdateOne) SetValue(a any) *UserContentUpdateOne {
-	ucuo.mutation.SetValue(a)
+func (ucuo *UserContentUpdateOne) SetValue(s string) *UserContentUpdateOne {
+	ucuo.mutation.SetValue(s)
+	return ucuo
+}
+
+// SetNillableValue sets the "value" field if the given value is not nil.
+func (ucuo *UserContentUpdateOne) SetNillableValue(s *string) *UserContentUpdateOne {
+	if s != nil {
+		ucuo.SetValue(*s)
+	}
 	return ucuo
 }
 
@@ -347,7 +363,7 @@ func (ucuo *UserContentUpdateOne) sqlSave(ctx context.Context) (_node *UserConte
 		_spec.SetField(usercontent.FieldReferenceID, field.TypeString, value)
 	}
 	if value, ok := ucuo.mutation.Value(); ok {
-		_spec.SetField(usercontent.FieldValue, field.TypeJSON, value)
+		_spec.SetField(usercontent.FieldValue, field.TypeString, value)
 	}
 	if value, ok := ucuo.mutation.Metadata(); ok {
 		_spec.SetField(usercontent.FieldMetadata, field.TypeJSON, value)
diff --git a/internal/database/ent/migrate/migrations/20240626225519.sql b/internal/database/ent/migrate/migrations/20240626225519.sql
new file mode 100644
index 00000000..f59ccc1c
--- /dev/null
+++ b/internal/database/ent/migrate/migrations/20240626225519.sql
@@ -0,0 +1,22 @@
+-- Disable the enforcement of foreign-keys constraints
+PRAGMA foreign_keys = off;
+-- Create "new_user_contents" table
+CREATE TABLE `new_user_contents` (`id` text NOT NULL, `created_at` integer NOT NULL, `updated_at` integer NOT NULL, `type` text NOT NULL, `reference_id` text NOT NULL, `value` text NOT NULL, `metadata` json NOT NULL, `user_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `user_contents_users_content` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE NO ACTION);
+-- Copy rows from old table "user_contents" to new temporary table "new_user_contents"
+INSERT INTO `new_user_contents` (`id`, `created_at`, `updated_at`, `type`, `reference_id`, `value`, `metadata`, `user_id`) SELECT `id`, `created_at`, `updated_at`, `type`, `reference_id`, `value`, `metadata`, `user_id` FROM `user_contents`;
+-- Drop "user_contents" table after copying rows
+DROP TABLE `user_contents`;
+-- Rename temporary table "new_user_contents" to "user_contents"
+ALTER TABLE `new_user_contents` RENAME TO `user_contents`;
+-- Create index "usercontent_id" to table: "user_contents"
+CREATE INDEX `usercontent_id` ON `user_contents` (`id`);
+-- Create index "usercontent_user_id" to table: "user_contents"
+CREATE INDEX `usercontent_user_id` ON `user_contents` (`user_id`);
+-- Create index "usercontent_type_user_id" to table: "user_contents"
+CREATE INDEX `usercontent_type_user_id` ON `user_contents` (`type`, `user_id`);
+-- Create index "usercontent_reference_id" to table: "user_contents"
+CREATE INDEX `usercontent_reference_id` ON `user_contents` (`reference_id`);
+-- Create index "usercontent_type_reference_id" to table: "user_contents"
+CREATE INDEX `usercontent_type_reference_id` ON `user_contents` (`type`, `reference_id`);
+-- Enable back the enforcement of foreign-keys constraints
+PRAGMA foreign_keys = on;
diff --git a/internal/database/ent/migrate/migrations/atlas.sum b/internal/database/ent/migrate/migrations/atlas.sum
index cdc03f33..39f948c4 100644
--- a/internal/database/ent/migrate/migrations/atlas.sum
+++ b/internal/database/ent/migrate/migrations/atlas.sum
@@ -1,4 +1,5 @@
-h1:mPthURxB95TzDLQ5/ssWicoIRBsv760ADaBxoBMbLjQ=
+h1:2kxjClSNsbJy3F8cZByPAFN8hIABwG/6FLKLZnieiUs=
 20240622203812_init.sql h1:Rt6NGvXbPBEpjg1pUFqn97FV8X3X2d1x7J2zOAAxolc=
 20240623143618_added_indexes_on_id.sql h1:o57d1Hc6+wGscJp3VIWnCNrmQkBSeSKTEVKRSWmsc6k=
 20240626213554.sql h1:sKGMP6giStLCW5lUK8VyaLxmiPRQTxT+y6xRkax1juM=
+20240626225519.sql h1:/ARpBIJ80fqBpTK0WH4d5+3Z2kOh86SWlOGSu1PTOFc=
diff --git a/internal/database/ent/schema/user_content.go b/internal/database/ent/schema/user_content.go
index 6cc371b0..b68d635a 100644
--- a/internal/database/ent/schema/user_content.go
+++ b/internal/database/ent/schema/user_content.go
@@ -21,7 +21,7 @@ func (UserContent) Fields() []ent.Field {
 		field.String("user_id").Immutable(),
 		field.String("reference_id"),
 		//
-		field.Any("value"),
+		field.String("value"),
 		field.JSON("metadata", map[string]any{}),
 	)
 }
diff --git a/internal/database/models/user.go b/internal/database/models/user.go
index ae6172c4..efdfe56a 100644
--- a/internal/database/models/user.go
+++ b/internal/database/models/user.go
@@ -1,16 +1,39 @@
 package models
 
-import "github.com/cufee/aftermath/internal/permissions"
+import (
+	"github.com/cufee/aftermath/internal/permissions"
+)
 
 type User struct {
 	ID string
 
 	Permissions permissions.Permissions
 
+	Uploads       []UserContent
 	Connections   []UserConnection
+	Restrictions  []UserRestriction
 	Subscriptions []UserSubscription
 }
 
+func (u User) HasPermission(value permissions.Permissions) bool {
+	perms := u.Permissions
+	for _, c := range u.Connections {
+		perms.Add(c.Permissions)
+	}
+	for _, s := range u.Subscriptions {
+		perms.Add(s.Permissions)
+	}
+	for _, r := range u.Restrictions {
+		switch r.Type {
+		case RestrictionTypePartial:
+			perms.Remove(r.Restriction)
+		default:
+			return false
+		}
+	}
+	return perms.Has(value)
+}
+
 func (u User) Connection(kind ConnectionType) (UserConnection, bool) {
 	for _, connection := range u.Connections {
 		if connection.Type == kind {
@@ -28,3 +51,12 @@ func (u User) Subscription(kind SubscriptionType) (UserSubscription, bool) {
 	}
 	return UserSubscription{}, false
 }
+
+func (u User) Content(kind UserContentType) (UserContent, bool) {
+	for _, content := range u.Uploads {
+		if content.Type == kind {
+			return content, true
+		}
+	}
+	return UserContent{}, false
+}
diff --git a/internal/database/models/user_content.go b/internal/database/models/user_content.go
new file mode 100644
index 00000000..eff23973
--- /dev/null
+++ b/internal/database/models/user_content.go
@@ -0,0 +1,46 @@
+package models
+
+import "time"
+
+type UserContentType string
+
+const (
+	UserContentTypeClanBackground     = UserContentType("clan-background-image")
+	UserContentTypePersonalBackground = UserContentType("personal-background-image")
+)
+
+func (t UserContentType) Valid() bool {
+	switch t {
+	case UserContentTypeClanBackground:
+		return true
+	case UserContentTypePersonalBackground:
+		return true
+	default:
+		return false
+	}
+}
+
+// Values provides list valid values for Enum.
+func (UserContentType) Values() []string {
+	var kinds []string
+	for _, s := range []UserContentType{
+		UserContentTypeClanBackground,
+		UserContentTypePersonalBackground,
+	} {
+		kinds = append(kinds, string(s))
+	}
+	return kinds
+}
+
+type UserContent struct {
+	ID        string
+	CreatedAt time.Time
+	UpdatedAt time.Time
+
+	Type        UserContentType
+	UserID      string
+	ReferenceID string
+
+	Value string
+	Meta  map[string]any
+}
diff --git a/internal/database/models/user_restriction.go b/internal/database/models/user_restriction.go
new file mode 100644
index 00000000..9a53729b
--- /dev/null
+++ b/internal/database/models/user_restriction.go
@@ -0,0 +1,32 @@
+package models
+
+import (
+	"time"
+
+	"github.com/cufee/aftermath/internal/permissions"
+)
+
+type UserRestrictionType string
+
+const (
+	RestrictionTypePartial  UserRestrictionType = "partial"  // restrict a specific permissions.Permissions value
+	RestrictionTypeComplete UserRestrictionType = "complete" // restricts user from using any and all features
+)
+
+func (r *UserRestrictionType) Values() []string {
+	return []string{string(RestrictionTypePartial), string(RestrictionTypeComplete)}
+}
+
+type UserRestriction struct {
+	ID     string
+	Type   UserRestrictionType
+	UserID string
+
+	Restriction      permissions.Permissions
+	PublicReason     string
+	ModeratorComment string
+
+	ExpiresAt time.Time
+	CreatedAt time.Time
+	UpdatedAt time.Time
+}
diff --git a/internal/database/models/user_subscription.go b/internal/database/models/user_subscription copy.go
similarity index 75%
rename from internal/database/models/user_subscription.go
rename to internal/database/models/user_subscription copy.go
index 07926bf3..00207004 100644
--- a/internal/database/models/user_subscription.go
+++ b/internal/database/models/user_subscription copy.go	
@@ -66,36 +66,6 @@ func (s SubscriptionType) Valid() bool {
 	return slices.Contains(AllSubscriptionTypes, s)
 }
 
-type UserContentType string
-
-const (
-	UserContentTypeClanBackground     = UserContentType("clan-background-image")
-	UserContentTypePersonalBackground = UserContentType("personal-background-image")
-)
-
-func (t UserContentType) Valid() bool {
-	switch t {
-	case UserContentTypeClanBackground:
-		return true
-	case UserContentTypePersonalBackground:
-		return true
-	default:
-		return false
-	}
-}
-
-// Values provides list valid values for Enum.
-func (UserContentType) Values() []string {
-	var kinds []string
-	for _, s := range []UserContentType{
-		UserContentTypeClanBackground,
-		UserContentTypePersonalBackground,
-	} {
-		kinds = append(kinds, string(s))
-	}
-	return kinds
-}
-
 type UserSubscription struct {
 	ID          string
 	Type        SubscriptionType
diff --git a/internal/database/users.go b/internal/database/users.go
index 19c25e07..839ff321 100644
--- a/internal/database/users.go
+++ b/internal/database/users.go
@@ -21,9 +21,9 @@ func toUser(record *db.User, connections []*db.UserConnection, subscriptions []*
 	for _, s := range subscriptions {
 		user.Subscriptions = append(user.Subscriptions, toUserSubscription(s))
 	}
-	// for _, s := range content {
-	// 	user.Subscriptions = append(user.Subscriptions, toUserSubscription(s))
-	// }
+	for _, c := range content {
+		user.Uploads = append(user.Uploads, toUserContent(c))
+	}
 	return user
 }
 
@@ -49,16 +49,20 @@ func toUserSubscription(record *db.UserSubscription) models.UserSubscription {
 	}
 }
 
-// func toUserContent(record *db.UserSubscription) models.UserConnection {
-// 	return models.UserSubscription{
-// 		ID:          record.ID,
-// 		Type:        record.Type,
-// 		UserID:      record.UserID,
-// 		ReferenceID: record.ReferenceID,
-// 		ExpiresAt:   time.Unix(record.ExpiresAt, 0),
-// 		Permissions: permissions.Parse(record.Permissions, permissions.Blank),
-// 	}
-// }
+func toUserContent(record *db.UserContent) models.UserContent {
+	return models.UserContent{
+		ID:          record.ID,
+		Type:        record.Type,
+		UserID:      record.UserID,
+		ReferenceID: record.ReferenceID,
+
+		Value: record.Value,
+		Meta:  record.Metadata,
+
+		CreatedAt: time.Unix(record.CreatedAt, 0),
+		UpdatedAt: time.Unix(record.UpdatedAt, 0),
+	}
+}
 
 type userGetOpts struct {
 	content       bool

From 3ebc8604dae931a89897d0135e5bb60b4a16d7a3 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Wed, 26 Jun 2024 19:37:34 -0400
Subject: [PATCH 187/341] added a secondary discord endpoint

---
 cmds/discord/commands/interactions.go         |  2 +-
 cmds/discord/commands/link.go                 |  2 +-
 cmds/discord/commands/load.go                 |  3 +-
 cmds/discord/commands/manage.go               |  3 +-
 cmds/discord/commands/session.go              |  2 +-
 cmds/discord/commands/stats.go                |  2 +-
 cmds/discord/discord.go                       |  9 ++--
 internal/database/ent/db/migrate/schema.go    |  2 +-
 .../ent/migrate/migrations/20240626233300.sql |  2 +
 .../database/ent/migrate/migrations/atlas.sum |  3 +-
 .../ent/schema/application_command.go         |  2 +-
 main.go                                       | 54 +++++++++++++++----
 12 files changed, 61 insertions(+), 25 deletions(-)
 create mode 100644 internal/database/ent/migrate/migrations/20240626233300.sql

diff --git a/cmds/discord/commands/interactions.go b/cmds/discord/commands/interactions.go
index b75dd28b..07957f63 100644
--- a/cmds/discord/commands/interactions.go
+++ b/cmds/discord/commands/interactions.go
@@ -34,7 +34,7 @@ func newStatsRefreshButton(data models.DiscordInteraction) discordgo.MessageComp
 }
 
 func init() {
-	Loaded.add(
+	LoadedPublic.add(
 		builder.NewCommand("refresh_stats_from_button").
 			ComponentType(func(customID string) bool {
 				return strings.HasPrefix(customID, "refresh_stats_from_button_")
diff --git a/cmds/discord/commands/link.go b/cmds/discord/commands/link.go
index 1866735d..7a6b0f7e 100644
--- a/cmds/discord/commands/link.go
+++ b/cmds/discord/commands/link.go
@@ -11,7 +11,7 @@ import (
 )
 
 func init() {
-	Loaded.add(
+	LoadedPublic.add(
 		builder.NewCommand("link").
 			Options(
 				builder.NewOption("nickname", discordgo.ApplicationCommandOptionString).
diff --git a/cmds/discord/commands/load.go b/cmds/discord/commands/load.go
index 0d5199ec..0940e41e 100644
--- a/cmds/discord/commands/load.go
+++ b/cmds/discord/commands/load.go
@@ -16,4 +16,5 @@ func (c *commandInit) Compose() []builder.Command {
 	return commands
 }
 
-var Loaded commandInit
+var LoadedPublic commandInit
+var LoadedInternal commandInit
diff --git a/cmds/discord/commands/manage.go b/cmds/discord/commands/manage.go
index 5fd07cbd..4b567039 100644
--- a/cmds/discord/commands/manage.go
+++ b/cmds/discord/commands/manage.go
@@ -16,9 +16,8 @@ import (
 )
 
 func init() {
-	Loaded.add(
+	LoadedInternal.add(
 		builder.NewCommand("manage").
-			// ExclusiveToGuilds(os.Getenv("DISCORD_PRIMARY_GUILD_ID")).
 			Middleware(middleware.RequirePermissions(permissions.UseDebugFeatures)).
 			Options(
 				builder.NewOption("users", discordgo.ApplicationCommandOptionSubCommandGroup).Options(
diff --git a/cmds/discord/commands/session.go b/cmds/discord/commands/session.go
index 641a95bd..e97b2ffb 100644
--- a/cmds/discord/commands/session.go
+++ b/cmds/discord/commands/session.go
@@ -19,7 +19,7 @@ import (
 )
 
 func init() {
-	Loaded.add(
+	LoadedPublic.add(
 		builder.NewCommand("session").
 			Options(defaultStatsOptions...).
 			Handler(func(ctx *common.Context) error {
diff --git a/cmds/discord/commands/stats.go b/cmds/discord/commands/stats.go
index ef5eca5f..0dfdc547 100644
--- a/cmds/discord/commands/stats.go
+++ b/cmds/discord/commands/stats.go
@@ -16,7 +16,7 @@ import (
 )
 
 func init() {
-	Loaded.add(
+	LoadedPublic.add(
 		builder.NewCommand("stats").
 			Options(defaultStatsOptions...).
 			Handler(func(ctx *common.Context) error {
diff --git a/cmds/discord/discord.go b/cmds/discord/discord.go
index ab4076ac..1c841493 100644
--- a/cmds/discord/discord.go
+++ b/cmds/discord/discord.go
@@ -5,20 +5,17 @@ import (
 
 	"github.com/cufee/aftermath/cmds/core"
 
-	"github.com/cufee/aftermath/cmds/discord/commands"
+	"github.com/cufee/aftermath/cmds/discord/commands/builder"
 	"github.com/cufee/aftermath/cmds/discord/router"
 )
 
-func NewRouterHandler(coreClient core.Client, token string, publicKey string) (http.HandlerFunc, error) {
+func NewRouterHandler(coreClient core.Client, token string, publicKey string, commands ...builder.Command) (http.HandlerFunc, error) {
 	rt, err := router.NewRouter(coreClient, token, publicKey)
 	if err != nil {
 		return nil, err
 	}
 
-	rt.LoadCommands(commands.Loaded.Compose()...)
-
-	// should always be loaded last
-	// rt.LoadMiddleware(middleware.FetchUser(common.ContextKeyUser, coreClient.DB))
+	rt.LoadCommands(commands...)
 
 	err = rt.UpdateLoadedCommands()
 	if err != nil {
diff --git a/internal/database/ent/db/migrate/schema.go b/internal/database/ent/db/migrate/schema.go
index b198249e..716a4a3c 100644
--- a/internal/database/ent/db/migrate/schema.go
+++ b/internal/database/ent/db/migrate/schema.go
@@ -196,7 +196,7 @@ var (
 		{Name: "id", Type: field.TypeString, Unique: true},
 		{Name: "created_at", Type: field.TypeInt64},
 		{Name: "updated_at", Type: field.TypeInt64},
-		{Name: "name", Type: field.TypeString, Unique: true},
+		{Name: "name", Type: field.TypeString},
 		{Name: "version", Type: field.TypeString},
 		{Name: "options_hash", Type: field.TypeString},
 	}
diff --git a/internal/database/ent/migrate/migrations/20240626233300.sql b/internal/database/ent/migrate/migrations/20240626233300.sql
new file mode 100644
index 00000000..235896cb
--- /dev/null
+++ b/internal/database/ent/migrate/migrations/20240626233300.sql
@@ -0,0 +1,2 @@
+-- Drop index "application_commands_name_key" from table: "application_commands"
+DROP INDEX `application_commands_name_key`;
diff --git a/internal/database/ent/migrate/migrations/atlas.sum b/internal/database/ent/migrate/migrations/atlas.sum
index 39f948c4..54f7f426 100644
--- a/internal/database/ent/migrate/migrations/atlas.sum
+++ b/internal/database/ent/migrate/migrations/atlas.sum
@@ -1,5 +1,6 @@
-h1:2kxjClSNsbJy3F8cZByPAFN8hIABwG/6FLKLZnieiUs=
+h1:CT0057YWfzRHEDECr8CPEZlaBJOat31j3qFdme4zb/8=
 20240622203812_init.sql h1:Rt6NGvXbPBEpjg1pUFqn97FV8X3X2d1x7J2zOAAxolc=
 20240623143618_added_indexes_on_id.sql h1:o57d1Hc6+wGscJp3VIWnCNrmQkBSeSKTEVKRSWmsc6k=
 20240626213554.sql h1:sKGMP6giStLCW5lUK8VyaLxmiPRQTxT+y6xRkax1juM=
 20240626225519.sql h1:/ARpBIJ80fqBpTK0WH4d5+3Z2kOh86SWlOGSu1PTOFc=
+20240626233300.sql h1:Klr1WjPuZR6NtWPeWwIUHOokVyEEWXbo80DVxNaCzjo=
diff --git a/internal/database/ent/schema/application_command.go b/internal/database/ent/schema/application_command.go
index e4cd39b3..ffffd492 100644
--- a/internal/database/ent/schema/application_command.go
+++ b/internal/database/ent/schema/application_command.go
@@ -14,7 +14,7 @@ type ApplicationCommand struct {
 // Fields of the ApplicationCommand.
 func (ApplicationCommand) Fields() []ent.Field {
 	return append(defaultFields,
-		field.String("name").Unique().NotEmpty(),
+		field.String("name").NotEmpty(),
 		field.String("version").NotEmpty(),
 		field.String("options_hash").NotEmpty(),
 	)
diff --git a/main.go b/main.go
index 9fa06838..6ef9d117 100644
--- a/main.go
+++ b/main.go
@@ -17,6 +17,7 @@ import (
 	"github.com/cufee/aftermath/cmds/core/queue"
 	"github.com/cufee/aftermath/cmds/core/scheduler"
 	"github.com/cufee/aftermath/cmds/core/tasks"
+	"github.com/cufee/aftermath/cmds/discord/commands"
 
 	"github.com/cufee/aftermath/cmds/core/server"
 	"github.com/cufee/aftermath/cmds/core/server/handlers/private"
@@ -71,11 +72,6 @@ func main() {
 	// Load some init options to registered admin accounts and etc
 	logic.ApplyInitOptions(liveCoreClient.Database())
 
-	discordHandler, err := discord.NewRouterHandler(liveCoreClient, os.Getenv("DISCORD_TOKEN"), os.Getenv("DISCORD_PUBLIC_KEY"))
-	if err != nil {
-		log.Fatal().Msgf("discord#NewRouterHandler failed %s", err)
-	}
-
 	if e := os.Getenv("PRIVATE_SERVER_ENABLED"); e == "true" {
 		port := os.Getenv("PRIVATE_SERVER_PORT")
 		servePrivate := server.NewServer(port, []server.Handler{
@@ -96,11 +92,12 @@ func main() {
 		go servePrivate()
 	}
 
+	discordHandlers := discordHandlersFromEnv(liveCoreClient)
+	// /discord/public/callback
+	// /discord/internal/callback
+
 	port := os.Getenv("PORT")
-	servePublic := server.NewServer(port, server.Handler{
-		Path: "POST /discord/callback",
-		Func: discordHandler,
-	})
+	servePublic := server.NewServer(port, discordHandlers...)
 	log.Info().Str("port", port).Msg("starting a public server")
 	go servePublic()
 
@@ -112,6 +109,45 @@ func main() {
 	log.Info().Msgf("received %s, exiting", sig.String())
 }
 
+func discordHandlersFromEnv(coreClient core.Client) []server.Handler {
+	var handlers []server.Handler
+
+	// main Discord with all the user-facing command
+	{
+		if os.Getenv("DISCORD_TOKEN") == "" || os.Getenv("DISCORD_PUBLIC_KEY") == "" {
+			log.Fatal().Msg("DISCORD_TOKEN and DISCORD_PUBLIC_KEY are required")
+
+		}
+		mainDiscordHandler, err := discord.NewRouterHandler(coreClient, os.Getenv("DISCORD_TOKEN"), os.Getenv("DISCORD_PUBLIC_KEY"), commands.LoadedPublic.Compose()...)
+		if err != nil {
+			log.Fatal().Msgf("discord#NewRouterHandler failed %s", err)
+		}
+		handlers = append(handlers, server.Handler{
+			Path: "POST /discord/public/callback",
+			Func: mainDiscordHandler,
+		})
+	}
+
+	// secondary Discord bot with mod/admin commands - permissions are still checked
+	if token := os.Getenv("INTERNAL_DISCORD_TOKEN"); token != "" {
+		publicKey := os.Getenv("INTERNAL_DISCORD_PUBLIC_KEY")
+		if publicKey == "" {
+			log.Fatal().Msg("discordHandlersFromEnv failed missing INTERNAL_DISCORD_PUBLIC_KEY")
+		}
+
+		internalDiscordHandler, err := discord.NewRouterHandler(coreClient, token, publicKey, commands.LoadedInternal.Compose()...)
+		if err != nil {
+			log.Fatal().Msgf("discord#NewRouterHandler failed %s", err)
+		}
+		handlers = append(handlers, server.Handler{
+			Path: "POST /discord/internal/callback",
+			Func: internalDiscordHandler,
+		})
+	}
+
+	return handlers
+}
+
 func startSchedulerFromEnv(ctx context.Context, coreClient core.Client) (func(), error) {
 	if os.Getenv("SCHEDULER_ENABLED") != "true" {
 		return func() {}, nil

From 8c6a42d90b5a3d813586b237958ba43f31f6f3c0 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Wed, 26 Jun 2024 20:58:22 -0400
Subject: [PATCH 188/341] added asset cli, renamed dir

---
 .gitignore                                    |   2 +-
 cmd/assets/README.md                          |   2 +
 cmd/assets/main.go                            |  39 +++++
 cmd/assets/news.go                            | 148 ++++++++++++++++++
 {cmds => cmd}/core/client.go                  |   0
 {cmds => cmd}/core/queue/errors.go            |   0
 {cmds => cmd}/core/queue/queue.go             |   6 +-
 {cmds => cmd}/core/scheduler/scheduler.go     |   2 +-
 {cmds => cmd}/core/scheduler/workers.go       |   4 +-
 .../core/server/handlers/private/accounts.go  |   2 +-
 .../core/server/handlers/private/snapshots.go |   4 +-
 .../core/server/handlers/private/tasks.go     |   4 +-
 {cmds => cmd}/core/server/server.go           |   0
 {cmds => cmd}/core/tasks/cleanup.go           |   2 +-
 {cmds => cmd}/core/tasks/handler.go           |   2 +-
 {cmds => cmd}/core/tasks/sessions.go          |   2 +-
 {cmds => cmd}/core/tasks/split.go             |   0
 .../discord/commands/builder/command.go       |   4 +-
 .../discord/commands/builder/common.go        |   0
 .../discord/commands/builder/option.go        |   2 +-
 .../discord/commands/builder/option_choice.go |   2 +-
 .../discord/commands/builder/params.go        |   0
 {cmds => cmd}/discord/commands/common.go      |   2 +-
 .../discord/commands/interactions.go          |   4 +-
 {cmds => cmd}/discord/commands/link.go        |   4 +-
 {cmds => cmd}/discord/commands/load.go        |   2 +-
 {cmds => cmd}/discord/commands/manage.go      |   6 +-
 {cmds => cmd}/discord/commands/options.go     |   4 +-
 {cmds => cmd}/discord/commands/session.go     |   4 +-
 {cmds => cmd}/discord/commands/stats.go       |   4 +-
 {cmds => cmd}/discord/common/context.go       |   4 +-
 {cmds => cmd}/discord/common/locale.go        |   0
 {cmds => cmd}/discord/common/pointer.go       |   0
 {cmds => cmd}/discord/common/reply.go         |   0
 {cmds => cmd}/discord/discord.go              |   6 +-
 .../discord/middleware/middleware.go          |   2 +-
 {cmds => cmd}/discord/rest/client.go          |   0
 {cmds => cmd}/discord/rest/commands.go        |   0
 {cmds => cmd}/discord/rest/interactions.go    |   0
 {cmds => cmd}/discord/router/handler.go       |   4 +-
 {cmds => cmd}/discord/router/router.go        |   8 +-
 go.mod                                        |   2 +
 go.sum                                        |  12 ++
 main.go                                       |  18 +--
 44 files changed, 258 insertions(+), 55 deletions(-)
 create mode 100644 cmd/assets/README.md
 create mode 100644 cmd/assets/main.go
 create mode 100644 cmd/assets/news.go
 rename {cmds => cmd}/core/client.go (100%)
 rename {cmds => cmd}/core/queue/errors.go (100%)
 rename {cmds => cmd}/core/queue/queue.go (97%)
 rename {cmds => cmd}/core/scheduler/scheduler.go (97%)
 rename {cmds => cmd}/core/scheduler/workers.go (98%)
 rename {cmds => cmd}/core/server/handlers/private/accounts.go (98%)
 rename {cmds => cmd}/core/server/handlers/private/snapshots.go (89%)
 rename {cmds => cmd}/core/server/handlers/private/tasks.go (73%)
 rename {cmds => cmd}/core/server/server.go (100%)
 rename {cmds => cmd}/core/tasks/cleanup.go (98%)
 rename {cmds => cmd}/core/tasks/handler.go (90%)
 rename {cmds => cmd}/core/tasks/sessions.go (98%)
 rename {cmds => cmd}/core/tasks/split.go (100%)
 rename {cmds => cmd}/discord/commands/builder/command.go (96%)
 rename {cmds => cmd}/discord/commands/builder/common.go (100%)
 rename {cmds => cmd}/discord/commands/builder/option.go (98%)
 rename {cmds => cmd}/discord/commands/builder/option_choice.go (95%)
 rename {cmds => cmd}/discord/commands/builder/params.go (100%)
 rename {cmds => cmd}/discord/commands/common.go (92%)
 rename {cmds => cmd}/discord/commands/interactions.go (97%)
 rename {cmds => cmd}/discord/commands/link.go (95%)
 rename {cmds => cmd}/discord/commands/load.go (84%)
 rename {cmds => cmd}/discord/commands/manage.go (97%)
 rename {cmds => cmd}/discord/commands/options.go (96%)
 rename {cmds => cmd}/discord/commands/session.go (97%)
 rename {cmds => cmd}/discord/commands/stats.go (96%)
 rename {cmds => cmd}/discord/common/context.go (98%)
 rename {cmds => cmd}/discord/common/locale.go (100%)
 rename {cmds => cmd}/discord/common/pointer.go (100%)
 rename {cmds => cmd}/discord/common/reply.go (100%)
 rename {cmds => cmd}/discord/discord.go (73%)
 rename {cmds => cmd}/discord/middleware/middleware.go (91%)
 rename {cmds => cmd}/discord/rest/client.go (100%)
 rename {cmds => cmd}/discord/rest/commands.go (100%)
 rename {cmds => cmd}/discord/rest/interactions.go (100%)
 rename {cmds => cmd}/discord/router/handler.go (98%)
 rename {cmds => cmd}/discord/router/router.go (95%)

diff --git a/.gitignore b/.gitignore
index 5957f913..58d86976 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,4 +4,4 @@ tmp
 .vscode
 **/.DS_Store
 
-.env
+**/.env
diff --git a/cmd/assets/README.md b/cmd/assets/README.md
new file mode 100644
index 00000000..c76b5e01
--- /dev/null
+++ b/cmd/assets/README.md
@@ -0,0 +1,2 @@
+# Aftermath Assets
+This application is designed to cache some assets required for Aftermath
\ No newline at end of file
diff --git a/cmd/assets/main.go b/cmd/assets/main.go
new file mode 100644
index 00000000..cb01149c
--- /dev/null
+++ b/cmd/assets/main.go
@@ -0,0 +1,39 @@
+// go:build ignore
+
+package main
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/cufee/aftermath/internal/database"
+)
+
+func main() {
+	// db, err := newDatabaseClientFromEnv()
+	// if err != nil {
+	// 	panic(err)
+	// }
+	// _ = db
+
+	err := ScrapeNewsImages()
+	if err != nil {
+		panic(err)
+	}
+}
+
+func newDatabaseClientFromEnv() (database.Client, error) {
+	err := os.MkdirAll(os.Getenv("DATABASE_PATH"), os.ModePerm)
+	if err != nil {
+		return nil, fmt.Errorf("os#MkdirAll failed %w", err)
+	}
+
+	client, err := database.NewSQLiteClient(filepath.Join(os.Getenv("DATABASE_PATH"), os.Getenv("DATABASE_NAME")))
+	if err != nil {
+
+		return nil, fmt.Errorf("database#NewClient failed %w", err)
+	}
+
+	return client, nil
+}
diff --git a/cmd/assets/news.go b/cmd/assets/news.go
new file mode 100644
index 00000000..4b9d65b7
--- /dev/null
+++ b/cmd/assets/news.go
@@ -0,0 +1,148 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"image"
+	"io"
+	"net/http"
+	"net/url"
+	"os"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/disintegration/imaging"
+	"github.com/pkg/errors"
+	"github.com/rs/zerolog/log"
+
+	_ "github.com/joho/godotenv/autoload"
+)
+
+var httpClient = http.Client{
+	Timeout: time.Second * 15,
+}
+
+type Image struct {
+	image.Image
+	PublishDate time.Time
+	Name        string
+	URL         string
+}
+
+type NewsItem struct {
+	Name   string `json:"name"`
+	Images struct {
+		Medium string `json:"medium"`
+	} `json:"images"`
+	PublishDate       string    `json:"publication_start_at"`
+	PublishDateParsed time.Time `json:"-"`
+}
+
+func ScrapeNewsImages() error {
+	endpoint := os.Getenv("NEWS_ENDPOINT")
+	if endpoint == "" {
+		return errors.New("NEWS_ENDPOINT not set")
+	}
+
+	link, err := url.Parse(endpoint)
+	if err != nil {
+		return errors.Wrap(err, "invalid endpoint url")
+	}
+
+	images, err := scrapeSinceDate(link, time.Now().Add(time.Hour*24*-1), 0)
+	if err != nil {
+		return err
+	}
+
+	var wg sync.WaitGroup
+	validImagesCh := make(chan Image, len(images))
+	for _, img := range images {
+		wg.Add(1)
+		go func(img NewsItem) {
+			defer wg.Done()
+
+			res, err := httpClient.Get(img.Images.Medium)
+			if err != nil {
+				log.Err(err).Msg("failed to get image")
+				return
+			}
+			defer res.Body.Close()
+
+			data, err := io.ReadAll(res.Body)
+			if err != nil {
+				log.Err(err).Msg("failed to read image response body")
+				return
+			}
+
+			decoded, err := imaging.Decode(bytes.NewReader(data))
+			if err != nil {
+				log.Err(err).Msg("failed to decode image")
+				return
+			}
+			validImagesCh <- Image{decoded, img.PublishDateParsed, img.Name, img.Images.Medium}
+
+		}(img)
+	}
+	wg.Wait()
+	close(validImagesCh)
+
+	for img := range validImagesCh {
+		println("image", img.Name)
+	}
+
+	return nil
+}
+
+func scrapeSinceDate(endpoint *url.URL, sinceDate time.Time, page int) ([]NewsItem, error) {
+	query := url.Values{}
+	query.Set("page", strconv.Itoa(page))
+	query.Set("page_size", "10")
+	endpoint.RawQuery = query.Encode()
+
+	var data struct {
+		Count   int        `json:"count"`
+		Results []NewsItem `json:"results"`
+	}
+
+	res, err := httpClient.Get(endpoint.String())
+	if err != nil {
+		return nil, err
+	}
+	defer res.Body.Close()
+	err = json.NewDecoder(res.Body).Decode(&data)
+	if err != nil {
+		return nil, err
+	}
+
+	var validImages []NewsItem
+	var oldestDate = time.Now()
+	for _, img := range data.Results {
+		img.PublishDateParsed, err = time.Parse("2006-01-02T15:04:05", img.PublishDate)
+		if err != nil {
+			log.Err(err).Msg("failed to parse date")
+			continue
+		}
+
+		if img.PublishDateParsed.Before(sinceDate) {
+			oldestDate = img.PublishDateParsed
+			break
+		}
+		if strings.Contains(strings.ToLower(img.Name), "video:") {
+			continue
+		}
+
+		validImages = append(validImages, img)
+		if img.PublishDateParsed.Before(oldestDate) {
+			oldestDate = img.PublishDateParsed
+		}
+	}
+
+	if oldestDate.Before(sinceDate) {
+		return validImages, nil
+	}
+
+	nextPage, err := scrapeSinceDate(endpoint, sinceDate, page+1)
+	return append(validImages, nextPage...), err
+}
diff --git a/cmds/core/client.go b/cmd/core/client.go
similarity index 100%
rename from cmds/core/client.go
rename to cmd/core/client.go
diff --git a/cmds/core/queue/errors.go b/cmd/core/queue/errors.go
similarity index 100%
rename from cmds/core/queue/errors.go
rename to cmd/core/queue/errors.go
diff --git a/cmds/core/queue/queue.go b/cmd/core/queue/queue.go
similarity index 97%
rename from cmds/core/queue/queue.go
rename to cmd/core/queue/queue.go
index e2f13203..f32e7f41 100644
--- a/cmds/core/queue/queue.go
+++ b/cmd/core/queue/queue.go
@@ -8,9 +8,9 @@ import (
 	"sync"
 	"time"
 
-	"github.com/cufee/aftermath/cmds/core"
-	"github.com/cufee/aftermath/cmds/core/scheduler"
-	"github.com/cufee/aftermath/cmds/core/tasks"
+	"github.com/cufee/aftermath/cmd/core"
+	"github.com/cufee/aftermath/cmd/core/scheduler"
+	"github.com/cufee/aftermath/cmd/core/tasks"
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/rs/zerolog/log"
diff --git a/cmds/core/scheduler/scheduler.go b/cmd/core/scheduler/scheduler.go
similarity index 97%
rename from cmds/core/scheduler/scheduler.go
rename to cmd/core/scheduler/scheduler.go
index ae1ac46d..bcadb57e 100644
--- a/cmds/core/scheduler/scheduler.go
+++ b/cmd/core/scheduler/scheduler.go
@@ -4,7 +4,7 @@ import (
 	"context"
 	"time"
 
-	"github.com/cufee/aftermath/cmds/core"
+	"github.com/cufee/aftermath/cmd/core"
 	"github.com/go-co-op/gocron"
 )
 
diff --git a/cmds/core/scheduler/workers.go b/cmd/core/scheduler/workers.go
similarity index 98%
rename from cmds/core/scheduler/workers.go
rename to cmd/core/scheduler/workers.go
index bbd8b2eb..b6697880 100644
--- a/cmds/core/scheduler/workers.go
+++ b/cmd/core/scheduler/workers.go
@@ -4,8 +4,8 @@ import (
 	"context"
 	"time"
 
-	"github.com/cufee/aftermath/cmds/core"
-	"github.com/cufee/aftermath/cmds/core/tasks"
+	"github.com/cufee/aftermath/cmd/core"
+	"github.com/cufee/aftermath/cmd/core/tasks"
 	"golang.org/x/text/language"
 
 	"github.com/cufee/aftermath/internal/database"
diff --git a/cmds/core/server/handlers/private/accounts.go b/cmd/core/server/handlers/private/accounts.go
similarity index 98%
rename from cmds/core/server/handlers/private/accounts.go
rename to cmd/core/server/handlers/private/accounts.go
index 0b8e3945..06734a2b 100644
--- a/cmds/core/server/handlers/private/accounts.go
+++ b/cmd/core/server/handlers/private/accounts.go
@@ -9,7 +9,7 @@ import (
 	"strconv"
 	"sync"
 
-	"github.com/cufee/aftermath/cmds/core"
+	"github.com/cufee/aftermath/cmd/core"
 	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/stats/fetch/v1"
 	"github.com/cufee/am-wg-proxy-next/v2/types"
diff --git a/cmds/core/server/handlers/private/snapshots.go b/cmd/core/server/handlers/private/snapshots.go
similarity index 89%
rename from cmds/core/server/handlers/private/snapshots.go
rename to cmd/core/server/handlers/private/snapshots.go
index c56b563d..c01ea9c5 100644
--- a/cmds/core/server/handlers/private/snapshots.go
+++ b/cmd/core/server/handlers/private/snapshots.go
@@ -5,8 +5,8 @@ import (
 	"slices"
 	"strings"
 
-	"github.com/cufee/aftermath/cmds/core"
-	"github.com/cufee/aftermath/cmds/core/tasks"
+	"github.com/cufee/aftermath/cmd/core"
+	"github.com/cufee/aftermath/cmd/core/tasks"
 )
 
 var validRealms = []string{"na", "eu", "as"}
diff --git a/cmds/core/server/handlers/private/tasks.go b/cmd/core/server/handlers/private/tasks.go
similarity index 73%
rename from cmds/core/server/handlers/private/tasks.go
rename to cmd/core/server/handlers/private/tasks.go
index 1a520aa1..de1961fb 100644
--- a/cmds/core/server/handlers/private/tasks.go
+++ b/cmd/core/server/handlers/private/tasks.go
@@ -3,8 +3,8 @@ package private
 import (
 	"net/http"
 
-	"github.com/cufee/aftermath/cmds/core"
-	"github.com/cufee/aftermath/cmds/core/scheduler"
+	"github.com/cufee/aftermath/cmd/core"
+	"github.com/cufee/aftermath/cmd/core/scheduler"
 )
 
 func RestartStaleTasks(client core.Client) http.HandlerFunc {
diff --git a/cmds/core/server/server.go b/cmd/core/server/server.go
similarity index 100%
rename from cmds/core/server/server.go
rename to cmd/core/server/server.go
diff --git a/cmds/core/tasks/cleanup.go b/cmd/core/tasks/cleanup.go
similarity index 98%
rename from cmds/core/tasks/cleanup.go
rename to cmd/core/tasks/cleanup.go
index efdcf6d9..e931faf4 100644
--- a/cmds/core/tasks/cleanup.go
+++ b/cmd/core/tasks/cleanup.go
@@ -6,7 +6,7 @@ import (
 
 	"github.com/pkg/errors"
 
-	"github.com/cufee/aftermath/cmds/core"
+	"github.com/cufee/aftermath/cmd/core"
 	"github.com/cufee/aftermath/internal/database/models"
 )
 
diff --git a/cmds/core/tasks/handler.go b/cmd/core/tasks/handler.go
similarity index 90%
rename from cmds/core/tasks/handler.go
rename to cmd/core/tasks/handler.go
index 11e49bb1..f54c06c5 100644
--- a/cmds/core/tasks/handler.go
+++ b/cmd/core/tasks/handler.go
@@ -1,7 +1,7 @@
 package tasks
 
 import (
-	"github.com/cufee/aftermath/cmds/core"
+	"github.com/cufee/aftermath/cmd/core"
 	"github.com/cufee/aftermath/internal/database/models"
 )
 
diff --git a/cmds/core/tasks/sessions.go b/cmd/core/tasks/sessions.go
similarity index 98%
rename from cmds/core/tasks/sessions.go
rename to cmd/core/tasks/sessions.go
index 0125d1ea..e3a4cfd1 100644
--- a/cmds/core/tasks/sessions.go
+++ b/cmd/core/tasks/sessions.go
@@ -7,7 +7,7 @@ import (
 
 	"github.com/pkg/errors"
 
-	"github.com/cufee/aftermath/cmds/core"
+	"github.com/cufee/aftermath/cmd/core"
 	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/logic"
 	"github.com/rs/zerolog/log"
diff --git a/cmds/core/tasks/split.go b/cmd/core/tasks/split.go
similarity index 100%
rename from cmds/core/tasks/split.go
rename to cmd/core/tasks/split.go
diff --git a/cmds/discord/commands/builder/command.go b/cmd/discord/commands/builder/command.go
similarity index 96%
rename from cmds/discord/commands/builder/command.go
rename to cmd/discord/commands/builder/command.go
index 3eb8d470..5d654538 100644
--- a/cmds/discord/commands/builder/command.go
+++ b/cmd/discord/commands/builder/command.go
@@ -5,8 +5,8 @@ import (
 	"strings"
 
 	"github.com/bwmarrin/discordgo"
-	"github.com/cufee/aftermath/cmds/discord/common"
-	"github.com/cufee/aftermath/cmds/discord/middleware"
+	"github.com/cufee/aftermath/cmd/discord/common"
+	"github.com/cufee/aftermath/cmd/discord/middleware"
 )
 
 type commandType byte
diff --git a/cmds/discord/commands/builder/common.go b/cmd/discord/commands/builder/common.go
similarity index 100%
rename from cmds/discord/commands/builder/common.go
rename to cmd/discord/commands/builder/common.go
diff --git a/cmds/discord/commands/builder/option.go b/cmd/discord/commands/builder/option.go
similarity index 98%
rename from cmds/discord/commands/builder/option.go
rename to cmd/discord/commands/builder/option.go
index e3133179..17f7b142 100644
--- a/cmds/discord/commands/builder/option.go
+++ b/cmd/discord/commands/builder/option.go
@@ -5,7 +5,7 @@ import (
 	"strings"
 
 	"github.com/bwmarrin/discordgo"
-	"github.com/cufee/aftermath/cmds/discord/common"
+	"github.com/cufee/aftermath/cmd/discord/common"
 )
 
 type Option struct {
diff --git a/cmds/discord/commands/builder/option_choice.go b/cmd/discord/commands/builder/option_choice.go
similarity index 95%
rename from cmds/discord/commands/builder/option_choice.go
rename to cmd/discord/commands/builder/option_choice.go
index 74db9549..96ac2868 100644
--- a/cmds/discord/commands/builder/option_choice.go
+++ b/cmd/discord/commands/builder/option_choice.go
@@ -4,7 +4,7 @@ import (
 	"fmt"
 
 	"github.com/bwmarrin/discordgo"
-	"github.com/cufee/aftermath/cmds/discord/common"
+	"github.com/cufee/aftermath/cmd/discord/common"
 )
 
 type OptionChoice struct {
diff --git a/cmds/discord/commands/builder/params.go b/cmd/discord/commands/builder/params.go
similarity index 100%
rename from cmds/discord/commands/builder/params.go
rename to cmd/discord/commands/builder/params.go
diff --git a/cmds/discord/commands/common.go b/cmd/discord/commands/common.go
similarity index 92%
rename from cmds/discord/commands/common.go
rename to cmd/discord/commands/common.go
index 56438bb7..0d591818 100644
--- a/cmds/discord/commands/common.go
+++ b/cmd/discord/commands/common.go
@@ -2,7 +2,7 @@ package commands
 
 import (
 	"github.com/bwmarrin/discordgo"
-	"github.com/cufee/aftermath/cmds/discord/common"
+	"github.com/cufee/aftermath/cmd/discord/common"
 	"github.com/cufee/aftermath/internal/database/models"
 )
 
diff --git a/cmds/discord/commands/interactions.go b/cmd/discord/commands/interactions.go
similarity index 97%
rename from cmds/discord/commands/interactions.go
rename to cmd/discord/commands/interactions.go
index 07957f63..901c252c 100644
--- a/cmds/discord/commands/interactions.go
+++ b/cmd/discord/commands/interactions.go
@@ -7,8 +7,8 @@ import (
 	"strings"
 
 	"github.com/bwmarrin/discordgo"
-	"github.com/cufee/aftermath/cmds/discord/commands/builder"
-	"github.com/cufee/aftermath/cmds/discord/common"
+	"github.com/cufee/aftermath/cmd/discord/commands/builder"
+	"github.com/cufee/aftermath/cmd/discord/common"
 	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/permissions"
 	"github.com/cufee/aftermath/internal/stats/fetch/v1"
diff --git a/cmds/discord/commands/link.go b/cmd/discord/commands/link.go
similarity index 95%
rename from cmds/discord/commands/link.go
rename to cmd/discord/commands/link.go
index 7a6b0f7e..87705e5a 100644
--- a/cmds/discord/commands/link.go
+++ b/cmd/discord/commands/link.go
@@ -5,8 +5,8 @@ import (
 	"strings"
 
 	"github.com/bwmarrin/discordgo"
-	"github.com/cufee/aftermath/cmds/discord/commands/builder"
-	"github.com/cufee/aftermath/cmds/discord/common"
+	"github.com/cufee/aftermath/cmd/discord/commands/builder"
+	"github.com/cufee/aftermath/cmd/discord/common"
 	"github.com/cufee/aftermath/internal/database/models"
 )
 
diff --git a/cmds/discord/commands/load.go b/cmd/discord/commands/load.go
similarity index 84%
rename from cmds/discord/commands/load.go
rename to cmd/discord/commands/load.go
index 0940e41e..6829651d 100644
--- a/cmds/discord/commands/load.go
+++ b/cmd/discord/commands/load.go
@@ -1,6 +1,6 @@
 package commands
 
-import "github.com/cufee/aftermath/cmds/discord/commands/builder"
+import "github.com/cufee/aftermath/cmd/discord/commands/builder"
 
 type commandInit []builder.Builder
 
diff --git a/cmds/discord/commands/manage.go b/cmd/discord/commands/manage.go
similarity index 97%
rename from cmds/discord/commands/manage.go
rename to cmd/discord/commands/manage.go
index 4b567039..eaaaad67 100644
--- a/cmds/discord/commands/manage.go
+++ b/cmd/discord/commands/manage.go
@@ -7,9 +7,9 @@ import (
 	"time"
 
 	"github.com/bwmarrin/discordgo"
-	"github.com/cufee/aftermath/cmds/discord/commands/builder"
-	"github.com/cufee/aftermath/cmds/discord/common"
-	"github.com/cufee/aftermath/cmds/discord/middleware"
+	"github.com/cufee/aftermath/cmd/discord/commands/builder"
+	"github.com/cufee/aftermath/cmd/discord/common"
+	"github.com/cufee/aftermath/cmd/discord/middleware"
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/permissions"
diff --git a/cmds/discord/commands/options.go b/cmd/discord/commands/options.go
similarity index 96%
rename from cmds/discord/commands/options.go
rename to cmd/discord/commands/options.go
index e8528249..c5f3db1e 100644
--- a/cmds/discord/commands/options.go
+++ b/cmd/discord/commands/options.go
@@ -5,8 +5,8 @@ import (
 	"time"
 
 	"github.com/bwmarrin/discordgo"
-	"github.com/cufee/aftermath/cmds/discord/commands/builder"
-	"github.com/cufee/aftermath/cmds/discord/common"
+	"github.com/cufee/aftermath/cmd/discord/commands/builder"
+	"github.com/cufee/aftermath/cmd/discord/common"
 )
 
 var validNameRegex = regexp.MustCompile(`[^\w\_]`)
diff --git a/cmds/discord/commands/session.go b/cmd/discord/commands/session.go
similarity index 97%
rename from cmds/discord/commands/session.go
rename to cmd/discord/commands/session.go
index e97b2ffb..bd217a0d 100644
--- a/cmds/discord/commands/session.go
+++ b/cmd/discord/commands/session.go
@@ -6,8 +6,8 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/cufee/aftermath/cmds/discord/commands/builder"
-	"github.com/cufee/aftermath/cmds/discord/common"
+	"github.com/cufee/aftermath/cmd/discord/commands/builder"
+	"github.com/cufee/aftermath/cmd/discord/common"
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/permissions"
diff --git a/cmds/discord/commands/stats.go b/cmd/discord/commands/stats.go
similarity index 96%
rename from cmds/discord/commands/stats.go
rename to cmd/discord/commands/stats.go
index 0dfdc547..c64fc7ce 100644
--- a/cmds/discord/commands/stats.go
+++ b/cmd/discord/commands/stats.go
@@ -6,8 +6,8 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/cufee/aftermath/cmds/discord/commands/builder"
-	"github.com/cufee/aftermath/cmds/discord/common"
+	"github.com/cufee/aftermath/cmd/discord/commands/builder"
+	"github.com/cufee/aftermath/cmd/discord/common"
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/permissions"
diff --git a/cmds/discord/common/context.go b/cmd/discord/common/context.go
similarity index 98%
rename from cmds/discord/common/context.go
rename to cmd/discord/common/context.go
index 004b05ac..ea64e3a4 100644
--- a/cmds/discord/common/context.go
+++ b/cmd/discord/common/context.go
@@ -6,8 +6,8 @@ import (
 	"github.com/pkg/errors"
 
 	"github.com/bwmarrin/discordgo"
-	"github.com/cufee/aftermath/cmds/core"
-	"github.com/cufee/aftermath/cmds/discord/rest"
+	"github.com/cufee/aftermath/cmd/core"
+	"github.com/cufee/aftermath/cmd/discord/rest"
 
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
diff --git a/cmds/discord/common/locale.go b/cmd/discord/common/locale.go
similarity index 100%
rename from cmds/discord/common/locale.go
rename to cmd/discord/common/locale.go
diff --git a/cmds/discord/common/pointer.go b/cmd/discord/common/pointer.go
similarity index 100%
rename from cmds/discord/common/pointer.go
rename to cmd/discord/common/pointer.go
diff --git a/cmds/discord/common/reply.go b/cmd/discord/common/reply.go
similarity index 100%
rename from cmds/discord/common/reply.go
rename to cmd/discord/common/reply.go
diff --git a/cmds/discord/discord.go b/cmd/discord/discord.go
similarity index 73%
rename from cmds/discord/discord.go
rename to cmd/discord/discord.go
index 1c841493..5fdcd3f4 100644
--- a/cmds/discord/discord.go
+++ b/cmd/discord/discord.go
@@ -3,10 +3,10 @@ package discord
 import (
 	"net/http"
 
-	"github.com/cufee/aftermath/cmds/core"
+	"github.com/cufee/aftermath/cmd/core"
 
-	"github.com/cufee/aftermath/cmds/discord/commands/builder"
-	"github.com/cufee/aftermath/cmds/discord/router"
+	"github.com/cufee/aftermath/cmd/discord/commands/builder"
+	"github.com/cufee/aftermath/cmd/discord/router"
 )
 
 func NewRouterHandler(coreClient core.Client, token string, publicKey string, commands ...builder.Command) (http.HandlerFunc, error) {
diff --git a/cmds/discord/middleware/middleware.go b/cmd/discord/middleware/middleware.go
similarity index 91%
rename from cmds/discord/middleware/middleware.go
rename to cmd/discord/middleware/middleware.go
index 26db204e..ce1d1aad 100644
--- a/cmds/discord/middleware/middleware.go
+++ b/cmd/discord/middleware/middleware.go
@@ -1,7 +1,7 @@
 package middleware
 
 import (
-	"github.com/cufee/aftermath/cmds/discord/common"
+	"github.com/cufee/aftermath/cmd/discord/common"
 	"github.com/cufee/aftermath/internal/permissions"
 )
 
diff --git a/cmds/discord/rest/client.go b/cmd/discord/rest/client.go
similarity index 100%
rename from cmds/discord/rest/client.go
rename to cmd/discord/rest/client.go
diff --git a/cmds/discord/rest/commands.go b/cmd/discord/rest/commands.go
similarity index 100%
rename from cmds/discord/rest/commands.go
rename to cmd/discord/rest/commands.go
diff --git a/cmds/discord/rest/interactions.go b/cmd/discord/rest/interactions.go
similarity index 100%
rename from cmds/discord/rest/interactions.go
rename to cmd/discord/rest/interactions.go
diff --git a/cmds/discord/router/handler.go b/cmd/discord/router/handler.go
similarity index 98%
rename from cmds/discord/router/handler.go
rename to cmd/discord/router/handler.go
index 721ea022..3f913d94 100644
--- a/cmds/discord/router/handler.go
+++ b/cmd/discord/router/handler.go
@@ -15,8 +15,8 @@ import (
 	"github.com/pkg/errors"
 
 	"github.com/bwmarrin/discordgo"
-	"github.com/cufee/aftermath/cmds/discord/commands/builder"
-	"github.com/cufee/aftermath/cmds/discord/common"
+	"github.com/cufee/aftermath/cmd/discord/commands/builder"
+	"github.com/cufee/aftermath/cmd/discord/common"
 	"github.com/rs/zerolog/log"
 )
 
diff --git a/cmds/discord/router/router.go b/cmd/discord/router/router.go
similarity index 95%
rename from cmds/discord/router/router.go
rename to cmd/discord/router/router.go
index ef30be48..459717fa 100644
--- a/cmds/discord/router/router.go
+++ b/cmd/discord/router/router.go
@@ -5,10 +5,10 @@ import (
 	"fmt"
 
 	"github.com/bwmarrin/discordgo"
-	"github.com/cufee/aftermath/cmds/core"
-	"github.com/cufee/aftermath/cmds/discord/commands/builder"
-	"github.com/cufee/aftermath/cmds/discord/middleware"
-	"github.com/cufee/aftermath/cmds/discord/rest"
+	"github.com/cufee/aftermath/cmd/core"
+	"github.com/cufee/aftermath/cmd/discord/commands/builder"
+	"github.com/cufee/aftermath/cmd/discord/middleware"
+	"github.com/cufee/aftermath/cmd/discord/rest"
 	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/logic"
 	"github.com/rs/zerolog/log"
diff --git a/go.mod b/go.mod
index c2c64c4a..c764876f 100644
--- a/go.mod
+++ b/go.mod
@@ -30,6 +30,7 @@ require (
 	github.com/agext/levenshtein v1.2.3 // indirect
 	github.com/apparentlymart/go-textseg/v15 v15.0.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/deluan/lookup v0.0.7 // indirect
 	github.com/go-openapi/inflect v0.21.0 // indirect
 	github.com/google/go-cmp v0.6.0 // indirect
 	github.com/google/uuid v1.6.0 // indirect
@@ -38,6 +39,7 @@ require (
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mitchellh/go-wordwrap v1.0.1 // indirect
+	github.com/otiai10/gosseract/v2 v2.4.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/robfig/cron/v3 v3.0.1 // indirect
 	github.com/zclconf/go-cty v1.14.4 // indirect
diff --git a/go.sum b/go.sum
index ee4f6f7a..c1f12c43 100644
--- a/go.sum
+++ b/go.sum
@@ -17,6 +17,8 @@ github.com/cufee/am-wg-proxy-next/v2 v2.1.5/go.mod h1:+VxiIdbrdhHdRThASbVmZ5Fz4H
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/deluan/lookup v0.0.7 h1:O86eel067BpK+g4TmgsQPQbc8aU9m0OhlNRHxKVf9ec=
+github.com/deluan/lookup v0.0.7/go.mod h1:mnYfdZ+Pz5it/x8IHBOSdDVzxFmcDf7wxYK8rtVV/tU=
 github.com/disintegration/imaging v1.6.2 h1:w1LecBlG2Lnp8B3jk5zSuNqd7b4DXhcjwek1ei82L+c=
 github.com/disintegration/imaging v1.6.2/go.mod h1:44/5580QXChDfwIclfc/PCwrr44amcmDAg8hxG0Ewe4=
 github.com/fogleman/gg v1.3.0 h1:/7zJX8F6AaYQc57WQCyN9cAIz+4bCJGO9B+dyW29am8=
@@ -35,6 +37,7 @@ github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeN
 github.com/google/uuid v1.4.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
 github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
 github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
@@ -42,6 +45,7 @@ github.com/hashicorp/hcl/v2 v2.21.0 h1:lve4q/o/2rqwYOgUg3y3V2YPyD1/zkCLGjIV74Jit
 github.com/hashicorp/hcl/v2 v2.21.0/go.mod h1:62ZYHrXgPoX8xBnzl8QzbWq4dyDsDtfCRgIq1rbJEvA=
 github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
 github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
+github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
 github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
@@ -68,6 +72,8 @@ github.com/nlpodyssey/gopickle v0.3.0 h1:BLUE5gxFLyyNOPzlXxt6GoHEMMxD0qhsE4p0CIQ
 github.com/nlpodyssey/gopickle v0.3.0/go.mod h1:f070HJ/yR+eLi5WmM1OXJEGaTpuJEUiib19olXgYha0=
 github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
 github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
+github.com/otiai10/gosseract/v2 v2.4.1 h1:G8AyBpXEeSlcq8TI85LH/pM5SXk8Djy2GEXisgyblRw=
+github.com/otiai10/gosseract/v2 v2.4.1/go.mod h1:1gNWP4Hgr2o7yqWfs6r5bZxAatjOIdqWxJLWsTsembk=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
@@ -83,6 +89,8 @@ github.com/rogpeppe/go-internal v1.8.1/go.mod h1:JeRgkft04UBgHMgCIwADu4Pn6Mtm5d4
 github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
 github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8=
 github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
+github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
+github.com/smartystreets/goconvey v0.0.0-20190731233626-505e41936337/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
 github.com/spf13/cobra v1.7.0 h1:hyqWnYt1ZQShIddO5kBpj3vu05/++x6tJ6dg8EC572I=
 github.com/spf13/cobra v1.7.0/go.mod h1:uLxZILRyS/50WlhOIKD7W6V5bgeIt+4sICxh6uRMrb0=
 github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
@@ -113,6 +121,7 @@ go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
 go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE=
 go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0=
 golang.org/x/crypto v0.0.0-20190123085648-057139ce5d2b/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
 golang.org/x/crypto v0.24.0 h1:mnl8DM0o513X8fdIkmyFE/5hTYxbwYOjDS/+rK6qpRI=
 golang.org/x/crypto v0.24.0/go.mod h1:Z1PMYSOR5nyMcyAVAIQSKCDwalqy85Aqn1x3Ws4L5DM=
@@ -123,10 +132,12 @@ golang.org/x/image v0.17.0 h1:nTRVVdajgB8zCMZVsViyzhnMKPwYeroEERRC64JuLco=
 golang.org/x/image v0.17.0/go.mod h1:4yyo5vMFQjVjUcVk4jEQcU9MGy/rulF5WvUILseCM2E=
 golang.org/x/mod v0.18.0 h1:5+9lSbEzPSdWkH32vYPBwEpX8KwDbM52Ud9xBUvNlb0=
 golang.org/x/mod v0.18.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
+golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
 golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20190124100055-b90733256f2e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@@ -139,6 +150,7 @@ golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
 golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.22.0 h1:gqSGLZqv+AI9lIQzniJ0nZDRG5GBPsSi+DRNHWNz6yA=
 golang.org/x/tools v0.22.0/go.mod h1:aCwcsjqvq7Yqt6TNyX7QMU2enbQ/Gt0bo6krSeEri+c=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
diff --git a/main.go b/main.go
index 6ef9d117..fa85a4a9 100644
--- a/main.go
+++ b/main.go
@@ -13,15 +13,15 @@ import (
 	"os"
 	"time"
 
-	"github.com/cufee/aftermath/cmds/core"
-	"github.com/cufee/aftermath/cmds/core/queue"
-	"github.com/cufee/aftermath/cmds/core/scheduler"
-	"github.com/cufee/aftermath/cmds/core/tasks"
-	"github.com/cufee/aftermath/cmds/discord/commands"
-
-	"github.com/cufee/aftermath/cmds/core/server"
-	"github.com/cufee/aftermath/cmds/core/server/handlers/private"
-	"github.com/cufee/aftermath/cmds/discord"
+	"github.com/cufee/aftermath/cmd/core"
+	"github.com/cufee/aftermath/cmd/core/queue"
+	"github.com/cufee/aftermath/cmd/core/scheduler"
+	"github.com/cufee/aftermath/cmd/core/tasks"
+	"github.com/cufee/aftermath/cmd/discord/commands"
+
+	"github.com/cufee/aftermath/cmd/core/server"
+	"github.com/cufee/aftermath/cmd/core/server/handlers/private"
+	"github.com/cufee/aftermath/cmd/discord"
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/external/blitzstars"
 	"github.com/cufee/aftermath/internal/external/wargaming"

From e1d24eb67bd443ca110f18acb6d951b073beb671 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Wed, 26 Jun 2024 20:58:34 -0400
Subject: [PATCH 189/341] added env example

---
 cmd/assets/.env.example |  1 +
 cmd/assets/news.go      | 10 +---------
 2 files changed, 2 insertions(+), 9 deletions(-)
 create mode 100644 cmd/assets/.env.example

diff --git a/cmd/assets/.env.example b/cmd/assets/.env.example
new file mode 100644
index 00000000..198c6b24
--- /dev/null
+++ b/cmd/assets/.env.example
@@ -0,0 +1 @@
+NEWS_ENDPOINT="https://na.wotblitz.com/en/api/cms/news/"
\ No newline at end of file
diff --git a/cmd/assets/news.go b/cmd/assets/news.go
index 4b9d65b7..2801174e 100644
--- a/cmd/assets/news.go
+++ b/cmd/assets/news.go
@@ -1,10 +1,8 @@
 package main
 
 import (
-	"bytes"
 	"encoding/json"
 	"image"
-	"io"
 	"net/http"
 	"net/url"
 	"os"
@@ -70,13 +68,7 @@ func ScrapeNewsImages() error {
 			}
 			defer res.Body.Close()
 
-			data, err := io.ReadAll(res.Body)
-			if err != nil {
-				log.Err(err).Msg("failed to read image response body")
-				return
-			}
-
-			decoded, err := imaging.Decode(bytes.NewReader(data))
+			decoded, err := imaging.Decode(res.Body)
 			if err != nil {
 				log.Err(err).Msg("failed to decode image")
 				return

From 48f600f308478e07c4c06fa14d7ba59097fcc899 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Wed, 26 Jun 2024 20:58:59 -0400
Subject: [PATCH 190/341] tidy

---
 go.mod |  2 --
 go.sum | 22 ----------------------
 2 files changed, 24 deletions(-)

diff --git a/go.mod b/go.mod
index c764876f..c2c64c4a 100644
--- a/go.mod
+++ b/go.mod
@@ -30,7 +30,6 @@ require (
 	github.com/agext/levenshtein v1.2.3 // indirect
 	github.com/apparentlymart/go-textseg/v15 v15.0.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/deluan/lookup v0.0.7 // indirect
 	github.com/go-openapi/inflect v0.21.0 // indirect
 	github.com/google/go-cmp v0.6.0 // indirect
 	github.com/google/uuid v1.6.0 // indirect
@@ -39,7 +38,6 @@ require (
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mitchellh/go-wordwrap v1.0.1 // indirect
-	github.com/otiai10/gosseract/v2 v2.4.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/robfig/cron/v3 v3.0.1 // indirect
 	github.com/zclconf/go-cty v1.14.4 // indirect
diff --git a/go.sum b/go.sum
index c1f12c43..b4bd05ca 100644
--- a/go.sum
+++ b/go.sum
@@ -17,8 +17,6 @@ github.com/cufee/am-wg-proxy-next/v2 v2.1.5/go.mod h1:+VxiIdbrdhHdRThASbVmZ5Fz4H
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/deluan/lookup v0.0.7 h1:O86eel067BpK+g4TmgsQPQbc8aU9m0OhlNRHxKVf9ec=
-github.com/deluan/lookup v0.0.7/go.mod h1:mnYfdZ+Pz5it/x8IHBOSdDVzxFmcDf7wxYK8rtVV/tU=
 github.com/disintegration/imaging v1.6.2 h1:w1LecBlG2Lnp8B3jk5zSuNqd7b4DXhcjwek1ei82L+c=
 github.com/disintegration/imaging v1.6.2/go.mod h1:44/5580QXChDfwIclfc/PCwrr44amcmDAg8hxG0Ewe4=
 github.com/fogleman/gg v1.3.0 h1:/7zJX8F6AaYQc57WQCyN9cAIz+4bCJGO9B+dyW29am8=
@@ -37,7 +35,6 @@ github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeN
 github.com/google/uuid v1.4.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
 github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
 github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
@@ -45,7 +42,6 @@ github.com/hashicorp/hcl/v2 v2.21.0 h1:lve4q/o/2rqwYOgUg3y3V2YPyD1/zkCLGjIV74Jit
 github.com/hashicorp/hcl/v2 v2.21.0/go.mod h1:62ZYHrXgPoX8xBnzl8QzbWq4dyDsDtfCRgIq1rbJEvA=
 github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
 github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
-github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
 github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
@@ -62,25 +58,17 @@ github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/
 github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
-github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/mattn/go-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o4kU=
 github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
 github.com/mitchellh/go-wordwrap v1.0.1 h1:TLuKupo69TCn6TQSyGxwI1EblZZEsQ0vMlAFQflz0v0=
 github.com/mitchellh/go-wordwrap v1.0.1/go.mod h1:R62XHJLzvMFRBbcrT7m7WgmE1eOyTSsCt+hzestvNj0=
 github.com/nlpodyssey/gopickle v0.3.0 h1:BLUE5gxFLyyNOPzlXxt6GoHEMMxD0qhsE4p0CIQyoLw=
 github.com/nlpodyssey/gopickle v0.3.0/go.mod h1:f070HJ/yR+eLi5WmM1OXJEGaTpuJEUiib19olXgYha0=
-github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
-github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
-github.com/otiai10/gosseract/v2 v2.4.1 h1:G8AyBpXEeSlcq8TI85LH/pM5SXk8Djy2GEXisgyblRw=
-github.com/otiai10/gosseract/v2 v2.4.1/go.mod h1:1gNWP4Hgr2o7yqWfs6r5bZxAatjOIdqWxJLWsTsembk=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
-github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
 github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=
 github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
@@ -89,12 +77,6 @@ github.com/rogpeppe/go-internal v1.8.1/go.mod h1:JeRgkft04UBgHMgCIwADu4Pn6Mtm5d4
 github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
 github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8=
 github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
-github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
-github.com/smartystreets/goconvey v0.0.0-20190731233626-505e41936337/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
-github.com/spf13/cobra v1.7.0 h1:hyqWnYt1ZQShIddO5kBpj3vu05/++x6tJ6dg8EC572I=
-github.com/spf13/cobra v1.7.0/go.mod h1:uLxZILRyS/50WlhOIKD7W6V5bgeIt+4sICxh6uRMrb0=
-github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
-github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
@@ -121,7 +103,6 @@ go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
 go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE=
 go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0=
 golang.org/x/crypto v0.0.0-20190123085648-057139ce5d2b/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
 golang.org/x/crypto v0.24.0 h1:mnl8DM0o513X8fdIkmyFE/5hTYxbwYOjDS/+rK6qpRI=
 golang.org/x/crypto v0.24.0/go.mod h1:Z1PMYSOR5nyMcyAVAIQSKCDwalqy85Aqn1x3Ws4L5DM=
@@ -132,12 +113,10 @@ golang.org/x/image v0.17.0 h1:nTRVVdajgB8zCMZVsViyzhnMKPwYeroEERRC64JuLco=
 golang.org/x/image v0.17.0/go.mod h1:4yyo5vMFQjVjUcVk4jEQcU9MGy/rulF5WvUILseCM2E=
 golang.org/x/mod v0.18.0 h1:5+9lSbEzPSdWkH32vYPBwEpX8KwDbM52Ud9xBUvNlb0=
 golang.org/x/mod v0.18.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
-golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
 golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20190124100055-b90733256f2e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@@ -150,7 +129,6 @@ golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
 golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.22.0 h1:gqSGLZqv+AI9lIQzniJ0nZDRG5GBPsSi+DRNHWNz6yA=
 golang.org/x/tools v0.22.0/go.mod h1:aCwcsjqvq7Yqt6TNyX7QMU2enbQ/Gt0bo6krSeEri+c=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=

From 3ecc059eee8d3145624aa17bba46fffa8a686aa2 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 27 Jun 2024 13:25:41 -0400
Subject: [PATCH 191/341] fixed vehicle snapshot queries

---
 .gitignore                                    |    1 +
 Dockerfile.migrate                            |    2 +-
 Taskfile.yaml                                 |    7 +-
 go.sum                                        |   10 +
 internal/commbus/bus.go                       |    1 -
 internal/database/accounts.go                 |   11 +-
 internal/database/cleanup.go                  |   10 +-
 internal/database/client.go                   |   26 +-
 internal/database/discord_interactions.go     |    3 +-
 internal/database/ent/db/account.go           |   37 +-
 internal/database/ent/db/account/account.go   |    8 +-
 internal/database/ent/db/account/where.go     |   74 +-
 internal/database/ent/db/account_create.go    |   37 +-
 internal/database/ent/db/account_query.go     |   26 +-
 internal/database/ent/db/account_update.go    |  147 +-
 internal/database/ent/db/accountsnapshot.go   |   29 +-
 .../ent/db/accountsnapshot/accountsnapshot.go |    7 +-
 .../database/ent/db/accountsnapshot/where.go  |   56 +-
 .../database/ent/db/accountsnapshot_create.go |   31 +-
 .../database/ent/db/accountsnapshot_query.go  |   26 +-
 .../database/ent/db/accountsnapshot_update.go |  103 +-
 .../database/ent/db/achievementssnapshot.go   |   29 +-
 .../achievementssnapshot.go                   |    7 +-
 .../ent/db/achievementssnapshot/where.go      |   56 +-
 .../ent/db/achievementssnapshot_create.go     |   31 +-
 .../ent/db/achievementssnapshot_query.go      |   26 +-
 .../ent/db/achievementssnapshot_update.go     |  103 +-
 internal/database/ent/db/appconfiguration.go  |   21 +-
 .../db/appconfiguration/appconfiguration.go   |    8 +-
 .../database/ent/db/appconfiguration/where.go |   38 +-
 .../ent/db/appconfiguration_create.go         |   25 +-
 .../database/ent/db/appconfiguration_query.go |   26 +-
 .../ent/db/appconfiguration_update.go         |   59 +-
 .../database/ent/db/applicationcommand.go     |   21 +-
 .../applicationcommand/applicationcommand.go  |    8 +-
 .../ent/db/applicationcommand/where.go        |   38 +-
 .../ent/db/applicationcommand_create.go       |   25 +-
 .../ent/db/applicationcommand_query.go        |   26 +-
 .../ent/db/applicationcommand_update.go       |   59 +-
 internal/database/ent/db/clan.go              |   21 +-
 internal/database/ent/db/clan/clan.go         |    8 +-
 internal/database/ent/db/clan/where.go        |   38 +-
 internal/database/ent/db/clan_create.go       |   25 +-
 internal/database/ent/db/clan_query.go        |   26 +-
 internal/database/ent/db/clan_update.go       |   59 +-
 internal/database/ent/db/crontask.go          |   37 +-
 internal/database/ent/db/crontask/crontask.go |    7 +-
 internal/database/ent/db/crontask/where.go    |   74 +-
 internal/database/ent/db/crontask_create.go   |   37 +-
 internal/database/ent/db/crontask_query.go    |   26 +-
 internal/database/ent/db/crontask_update.go   |  147 +-
 .../database/ent/db/discordinteraction.go     |   21 +-
 .../discordinteraction/discordinteraction.go  |    7 +-
 .../ent/db/discordinteraction/where.go        |   38 +-
 .../ent/db/discordinteraction_create.go       |   25 +-
 .../ent/db/discordinteraction_query.go        |   26 +-
 .../ent/db/discordinteraction_update.go       |   59 +-
 internal/database/ent/db/expose.go            |  200 ++
 internal/database/ent/db/migrate/schema.go    |   76 +-
 internal/database/ent/db/mutation.go          | 1894 +++--------------
 internal/database/ent/db/runtime.go           |   92 +-
 internal/database/ent/db/user.go              |   21 +-
 internal/database/ent/db/user/user.go         |    8 +-
 internal/database/ent/db/user/where.go        |   38 +-
 internal/database/ent/db/user_create.go       |   25 +-
 internal/database/ent/db/user_query.go        |   26 +-
 internal/database/ent/db/user_update.go       |   59 +-
 internal/database/ent/db/userconnection.go    |   21 +-
 .../ent/db/userconnection/userconnection.go   |    7 +-
 .../database/ent/db/userconnection/where.go   |   38 +-
 .../database/ent/db/userconnection_create.go  |   25 +-
 .../database/ent/db/userconnection_query.go   |   26 +-
 .../database/ent/db/userconnection_update.go  |   59 +-
 internal/database/ent/db/usercontent.go       |   21 +-
 .../ent/db/usercontent/usercontent.go         |    7 +-
 internal/database/ent/db/usercontent/where.go |   38 +-
 .../database/ent/db/usercontent_create.go     |   25 +-
 internal/database/ent/db/usercontent_query.go |   26 +-
 .../database/ent/db/usercontent_update.go     |   59 +-
 internal/database/ent/db/usersubscription.go  |   29 +-
 .../db/usersubscription/usersubscription.go   |    7 +-
 .../database/ent/db/usersubscription/where.go |   56 +-
 .../ent/db/usersubscription_create.go         |   31 +-
 .../database/ent/db/usersubscription_query.go |   26 +-
 .../ent/db/usersubscription_update.go         |  103 +-
 internal/database/ent/db/vehicle.go           |   21 +-
 internal/database/ent/db/vehicle/vehicle.go   |    8 +-
 internal/database/ent/db/vehicle/where.go     |   38 +-
 internal/database/ent/db/vehicle_create.go    |   25 +-
 internal/database/ent/db/vehicle_query.go     |   26 +-
 internal/database/ent/db/vehicle_update.go    |   59 +-
 internal/database/ent/db/vehicleaverage.go    |   21 +-
 .../ent/db/vehicleaverage/vehicleaverage.go   |    8 +-
 .../database/ent/db/vehicleaverage/where.go   |   38 +-
 .../database/ent/db/vehicleaverage_create.go  |   25 +-
 .../database/ent/db/vehicleaverage_query.go   |   26 +-
 .../database/ent/db/vehicleaverage_update.go  |   59 +-
 internal/database/ent/db/vehiclesnapshot.go   |   29 +-
 .../ent/db/vehiclesnapshot/vehiclesnapshot.go |    7 +-
 .../database/ent/db/vehiclesnapshot/where.go  |   56 +-
 .../database/ent/db/vehiclesnapshot_create.go |   31 +-
 .../database/ent/db/vehiclesnapshot_query.go  |   26 +-
 .../database/ent/db/vehiclesnapshot_update.go |  103 +-
 internal/database/ent/generate.go             |    2 +-
 internal/database/ent/migrate/main.go         |   39 -
 .../migrations/20240622203812_init.sql        |  102 -
 .../20240623143618_added_indexes_on_id.sql    |   30 -
 .../ent/migrate/migrations/20240626213554.sql |   12 -
 .../ent/migrate/migrations/20240626225519.sql |   22 -
 .../ent/migrate/migrations/20240626233300.sql |    2 -
 .../database/ent/migrate/migrations/atlas.sum |    6 -
 .../ent/migrations/20240627171532.sql         |  142 ++
 internal/database/ent/migrations/atlas.sum    |    2 +
 internal/database/ent/schema/account.go       |   12 +-
 .../database/ent/schema/account_snapshot.go   |    2 +-
 .../ent/schema/achievements_snapshot.go       |    2 +-
 internal/database/ent/schema/clan.go          |    8 +-
 internal/database/ent/schema/cron_task.go     |    4 +-
 internal/database/ent/schema/defaults.go      |   10 +-
 internal/database/ent/schema/user.go          |    8 +-
 .../database/ent/schema/user_subscription.go  |    2 +-
 internal/database/ent/schema/vehicle.go       |    8 +-
 .../database/ent/schema/vehicle_average.go    |    8 +-
 .../database/ent/schema/vehicle_snapshot.go   |    2 +-
 internal/database/ent/templates/expose.tmpl   |   24 +
 internal/database/snapshots.go                |  103 +-
 internal/database/snapshots_test.go           |  238 ++-
 internal/database/tasks.go                    |   22 +-
 internal/database/users.go                    |    7 +-
 internal/logic/{sessions.go => snapshots.go}  |    9 +-
 130 files changed, 2796 insertions(+), 3620 deletions(-)
 delete mode 100644 internal/commbus/bus.go
 create mode 100644 internal/database/ent/db/expose.go
 delete mode 100644 internal/database/ent/migrate/main.go
 delete mode 100644 internal/database/ent/migrate/migrations/20240622203812_init.sql
 delete mode 100644 internal/database/ent/migrate/migrations/20240623143618_added_indexes_on_id.sql
 delete mode 100644 internal/database/ent/migrate/migrations/20240626213554.sql
 delete mode 100644 internal/database/ent/migrate/migrations/20240626225519.sql
 delete mode 100644 internal/database/ent/migrate/migrations/20240626233300.sql
 delete mode 100644 internal/database/ent/migrate/migrations/atlas.sum
 create mode 100644 internal/database/ent/migrations/20240627171532.sql
 create mode 100644 internal/database/ent/migrations/atlas.sum
 create mode 100644 internal/database/ent/templates/expose.tmpl
 rename internal/logic/{sessions.go => snapshots.go} (97%)

diff --git a/.gitignore b/.gitignore
index 58d86976..ee8990c0 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,3 +5,4 @@ tmp
 **/.DS_Store
 
 **/.env
+**/.env.test
diff --git a/Dockerfile.migrate b/Dockerfile.migrate
index 5c67306d..83289fbb 100644
--- a/Dockerfile.migrate
+++ b/Dockerfile.migrate
@@ -1,3 +1,3 @@
 FROM arigaio/atlas:latest
 
-COPY ./internal/database/ent/migrate/migrations /migrations
+COPY ./internal/database/ent/migrations /migrations
diff --git a/Taskfile.yaml b/Taskfile.yaml
index c407bc9e..ade58543 100644
--- a/Taskfile.yaml
+++ b/Taskfile.yaml
@@ -21,10 +21,13 @@ tasks:
 
   db-migrate:
     desc: generate migrations
-    cmd: atlas migrate hash --dir "file://internal/database/ent/migrate/migrations" && atlas migrate diff {{.CLI_ARGS}} --dir "file://internal/database/ent/migrate/migrations" --to "ent://internal/database/ent/schema" --dev-url "sqlite://file?mode=memory&_fk=1"
+    cmd: atlas migrate hash --dir "file://internal/database/ent/migrations" && atlas migrate diff {{.CLI_ARGS}} --dir "file://internal/database/ent/migrations" --to "ent://internal/database/ent/schema" --dev-url "sqlite://file?mode=memory&_fk=1"
   db-migrate-apply:
     desc: apply migrations using atlas
-    cmd: atlas migrate apply --allow-dirty --dir "file://internal/database/ent/migrate/migrations" --tx-mode all --url "sqlite://${DATABASE_PATH}/${DATABASE_NAME}?_fk=1"
+    cmd: atlas migrate apply --allow-dirty --dir "file://internal/database/ent/migrations" --tx-mode all --url "sqlite://${DATABASE_PATH}/${DATABASE_NAME}?_fk=1"
+  db-migrate-apply-test:
+    desc: apply migrations to the tests database using atlas
+    cmd: atlas migrate apply --allow-dirty --dir "file://internal/database/ent/migrations" --tx-mode all --url "sqlite://${DATABASE_PATH}/tests.db?_fk=1"
 
   dev:
     desc: Start a local dev server
diff --git a/go.sum b/go.sum
index b4bd05ca..ee4f6f7a 100644
--- a/go.sum
+++ b/go.sum
@@ -58,17 +58,23 @@ github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/
 github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
+github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/mattn/go-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o4kU=
 github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
 github.com/mitchellh/go-wordwrap v1.0.1 h1:TLuKupo69TCn6TQSyGxwI1EblZZEsQ0vMlAFQflz0v0=
 github.com/mitchellh/go-wordwrap v1.0.1/go.mod h1:R62XHJLzvMFRBbcrT7m7WgmE1eOyTSsCt+hzestvNj0=
 github.com/nlpodyssey/gopickle v0.3.0 h1:BLUE5gxFLyyNOPzlXxt6GoHEMMxD0qhsE4p0CIQyoLw=
 github.com/nlpodyssey/gopickle v0.3.0/go.mod h1:f070HJ/yR+eLi5WmM1OXJEGaTpuJEUiib19olXgYha0=
+github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
+github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
+github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
 github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=
 github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
@@ -77,6 +83,10 @@ github.com/rogpeppe/go-internal v1.8.1/go.mod h1:JeRgkft04UBgHMgCIwADu4Pn6Mtm5d4
 github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
 github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8=
 github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
+github.com/spf13/cobra v1.7.0 h1:hyqWnYt1ZQShIddO5kBpj3vu05/++x6tJ6dg8EC572I=
+github.com/spf13/cobra v1.7.0/go.mod h1:uLxZILRyS/50WlhOIKD7W6V5bgeIt+4sICxh6uRMrb0=
+github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
diff --git a/internal/commbus/bus.go b/internal/commbus/bus.go
deleted file mode 100644
index 8d8bf574..00000000
--- a/internal/commbus/bus.go
+++ /dev/null
@@ -1 +0,0 @@
-package commbus
diff --git a/internal/database/accounts.go b/internal/database/accounts.go
index 55c9ecf8..6c73671f 100644
--- a/internal/database/accounts.go
+++ b/internal/database/accounts.go
@@ -3,7 +3,6 @@ package database
 import (
 	"context"
 	"strings"
-	"time"
 
 	"github.com/cufee/aftermath/internal/database/ent/db"
 	"github.com/cufee/aftermath/internal/database/ent/db/account"
@@ -16,8 +15,8 @@ func toAccount(model *db.Account) models.Account {
 		Realm:          model.Realm,
 		Nickname:       model.Nickname,
 		Private:        model.Private,
-		CreatedAt:      time.Unix(int64(model.AccountCreatedAt), 0),
-		LastBattleTime: time.Unix(int64(model.LastBattleTime), 0),
+		CreatedAt:      model.AccountCreatedAt,
+		LastBattleTime: model.LastBattleTime,
 	}
 	if model.Edges.Clan != nil {
 		account.ClanID = model.Edges.Clan.ID
@@ -90,7 +89,7 @@ func (c *client) UpsertAccounts(ctx context.Context, accounts []models.Account)
 				SetRealm(strings.ToUpper(update.Realm)).
 				SetNickname(update.Nickname).
 				SetPrivate(update.Private).
-				SetLastBattleTime(update.LastBattleTime.Unix()).
+				SetLastBattleTime(update.LastBattleTime).
 				Exec(ctx)
 			if err != nil {
 				errors[r.ID] = err
@@ -106,8 +105,8 @@ func (c *client) UpsertAccounts(ctx context.Context, accounts []models.Account)
 				SetRealm(strings.ToUpper(a.Realm)).
 				SetNickname(a.Nickname).
 				SetPrivate(a.Private).
-				SetAccountCreatedAt(a.CreatedAt.Unix()).
-				SetLastBattleTime(a.LastBattleTime.Unix()),
+				SetAccountCreatedAt(a.CreatedAt).
+				SetLastBattleTime(a.LastBattleTime),
 			)
 		}
 
diff --git a/internal/database/cleanup.go b/internal/database/cleanup.go
index c6706d6f..ddc680b1 100644
--- a/internal/database/cleanup.go
+++ b/internal/database/cleanup.go
@@ -14,7 +14,7 @@ import (
 
 func (c *client) DeleteExpiredTasks(ctx context.Context, expiration time.Time) error {
 	err := c.withTx(ctx, func(tx *db.Tx) error {
-		_, err := tx.CronTask.Delete().Where(crontask.CreatedAtLT(expiration.Unix())).Exec(ctx)
+		_, err := tx.CronTask.Delete().Where(crontask.CreatedAtLT(expiration)).Exec(ctx)
 		return err
 	})
 	return err
@@ -22,24 +22,24 @@ func (c *client) DeleteExpiredTasks(ctx context.Context, expiration time.Time) e
 
 func (c *client) DeleteExpiredInteractions(ctx context.Context, expiration time.Time) error {
 	err := c.withTx(ctx, func(tx *db.Tx) error {
-		_, err := tx.DiscordInteraction.Delete().Where(discordinteraction.CreatedAtLT(expiration.Unix())).Exec(ctx)
+		_, err := tx.DiscordInteraction.Delete().Where(discordinteraction.CreatedAtLT(expiration)).Exec(ctx)
 		return err
 	})
 	return err
 }
 
 func (c *client) DeleteExpiredSnapshots(ctx context.Context, expiration time.Time) error {
-	_, err := c.db.AccountSnapshot.Delete().Where(accountsnapshot.CreatedAtLT(expiration.Unix())).Exec(ctx)
+	_, err := c.db.AccountSnapshot.Delete().Where(accountsnapshot.CreatedAtLT(expiration)).Exec(ctx)
 	if err != nil {
 		return err
 	}
 
-	_, err = c.db.VehicleSnapshot.Delete().Where(vehiclesnapshot.CreatedAtLT(expiration.Unix())).Exec(ctx)
+	_, err = c.db.VehicleSnapshot.Delete().Where(vehiclesnapshot.CreatedAtLT(expiration)).Exec(ctx)
 	if err != nil {
 		return err
 	}
 
-	_, err = c.db.AchievementsSnapshot.Delete().Where(achievementssnapshot.CreatedAtLT(expiration.Unix())).Exec(ctx)
+	_, err = c.db.AchievementsSnapshot.Delete().Where(achievementssnapshot.CreatedAtLT(expiration)).Exec(ctx)
 	if err != nil {
 		return err
 	}
diff --git a/internal/database/client.go b/internal/database/client.go
index 0c5f7770..7a99931a 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -130,14 +130,36 @@ func (c *client) Disconnect() error {
 	return c.db.Close()
 }
 
-func NewSQLiteClient(filePath string) (*client, error) {
+type clientOptions struct {
+	debug bool
+}
+
+type ClientOption func(*clientOptions)
+
+func WithDebug() func(*clientOptions) {
+	return func(opts *clientOptions) {
+		opts.debug = true
+	}
+}
+
+func NewSQLiteClient(filePath string, options ...ClientOption) (*client, error) {
 	defer func() {
 		if r := recover(); r != nil {
 			log.Fatal().Interface("error", r).Str("stack", string(debug.Stack())).Msg("NewSQLiteClient panic")
 		}
 	}()
 
-	c, err := db.Open("sqlite3", fmt.Sprintf("file://%s?_fk=1", filePath))
+	opts := clientOptions{}
+	for _, apply := range options {
+		apply(&opts)
+	}
+
+	var dbOptions []db.Option
+	if opts.debug {
+		dbOptions = append(dbOptions, db.Debug())
+	}
+
+	c, err := db.Open("sqlite3", fmt.Sprintf("file://%s?_fk=1", filePath), dbOptions...)
 	if err != nil {
 		return nil, err
 	}
diff --git a/internal/database/discord_interactions.go b/internal/database/discord_interactions.go
index ce81fe5f..3a0eab13 100644
--- a/internal/database/discord_interactions.go
+++ b/internal/database/discord_interactions.go
@@ -2,7 +2,6 @@ package database
 
 import (
 	"context"
-	"time"
 
 	"github.com/cufee/aftermath/internal/database/ent/db"
 	"github.com/cufee/aftermath/internal/database/ent/db/discordinteraction"
@@ -35,7 +34,7 @@ func toDiscordInteraction(record *db.DiscordInteraction) models.DiscordInteracti
 	}
 	return models.DiscordInteraction{
 		ID:        record.ID,
-		CreatedAt: time.Unix(record.CreatedAt, 0),
+		CreatedAt: record.CreatedAt,
 
 		UserID:      record.UserID,
 		Command:     record.Command,
diff --git a/internal/database/ent/db/account.go b/internal/database/ent/db/account.go
index 40cc0fa5..ff1fed1f 100644
--- a/internal/database/ent/db/account.go
+++ b/internal/database/ent/db/account.go
@@ -5,6 +5,7 @@ package db
 import (
 	"fmt"
 	"strings"
+	"time"
 
 	"entgo.io/ent"
 	"entgo.io/ent/dialect/sql"
@@ -18,13 +19,13 @@ type Account struct {
 	// ID of the ent.
 	ID string `json:"id,omitempty"`
 	// CreatedAt holds the value of the "created_at" field.
-	CreatedAt int64 `json:"created_at,omitempty"`
+	CreatedAt time.Time `json:"created_at,omitempty"`
 	// UpdatedAt holds the value of the "updated_at" field.
-	UpdatedAt int64 `json:"updated_at,omitempty"`
+	UpdatedAt time.Time `json:"updated_at,omitempty"`
 	// LastBattleTime holds the value of the "last_battle_time" field.
-	LastBattleTime int64 `json:"last_battle_time,omitempty"`
+	LastBattleTime time.Time `json:"last_battle_time,omitempty"`
 	// AccountCreatedAt holds the value of the "account_created_at" field.
-	AccountCreatedAt int64 `json:"account_created_at,omitempty"`
+	AccountCreatedAt time.Time `json:"account_created_at,omitempty"`
 	// Realm holds the value of the "realm" field.
 	Realm string `json:"realm,omitempty"`
 	// Nickname holds the value of the "nickname" field.
@@ -99,10 +100,10 @@ func (*Account) scanValues(columns []string) ([]any, error) {
 		switch columns[i] {
 		case account.FieldPrivate:
 			values[i] = new(sql.NullBool)
-		case account.FieldCreatedAt, account.FieldUpdatedAt, account.FieldLastBattleTime, account.FieldAccountCreatedAt:
-			values[i] = new(sql.NullInt64)
 		case account.FieldID, account.FieldRealm, account.FieldNickname, account.FieldClanID:
 			values[i] = new(sql.NullString)
+		case account.FieldCreatedAt, account.FieldUpdatedAt, account.FieldLastBattleTime, account.FieldAccountCreatedAt:
+			values[i] = new(sql.NullTime)
 		default:
 			values[i] = new(sql.UnknownType)
 		}
@@ -125,28 +126,28 @@ func (a *Account) assignValues(columns []string, values []any) error {
 				a.ID = value.String
 			}
 		case account.FieldCreatedAt:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field created_at", values[i])
 			} else if value.Valid {
-				a.CreatedAt = value.Int64
+				a.CreatedAt = value.Time
 			}
 		case account.FieldUpdatedAt:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
 			} else if value.Valid {
-				a.UpdatedAt = value.Int64
+				a.UpdatedAt = value.Time
 			}
 		case account.FieldLastBattleTime:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field last_battle_time", values[i])
 			} else if value.Valid {
-				a.LastBattleTime = value.Int64
+				a.LastBattleTime = value.Time
 			}
 		case account.FieldAccountCreatedAt:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field account_created_at", values[i])
 			} else if value.Valid {
-				a.AccountCreatedAt = value.Int64
+				a.AccountCreatedAt = value.Time
 			}
 		case account.FieldRealm:
 			if value, ok := values[i].(*sql.NullString); !ok {
@@ -229,16 +230,16 @@ func (a *Account) String() string {
 	builder.WriteString("Account(")
 	builder.WriteString(fmt.Sprintf("id=%v, ", a.ID))
 	builder.WriteString("created_at=")
-	builder.WriteString(fmt.Sprintf("%v", a.CreatedAt))
+	builder.WriteString(a.CreatedAt.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("updated_at=")
-	builder.WriteString(fmt.Sprintf("%v", a.UpdatedAt))
+	builder.WriteString(a.UpdatedAt.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("last_battle_time=")
-	builder.WriteString(fmt.Sprintf("%v", a.LastBattleTime))
+	builder.WriteString(a.LastBattleTime.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("account_created_at=")
-	builder.WriteString(fmt.Sprintf("%v", a.AccountCreatedAt))
+	builder.WriteString(a.AccountCreatedAt.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("realm=")
 	builder.WriteString(a.Realm)
diff --git a/internal/database/ent/db/account/account.go b/internal/database/ent/db/account/account.go
index 3434e510..14226186 100644
--- a/internal/database/ent/db/account/account.go
+++ b/internal/database/ent/db/account/account.go
@@ -3,6 +3,8 @@
 package account
 
 import (
+	"time"
+
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
 )
@@ -93,11 +95,11 @@ func ValidColumn(column string) bool {
 
 var (
 	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
-	DefaultCreatedAt func() int64
+	DefaultCreatedAt func() time.Time
 	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
-	DefaultUpdatedAt func() int64
+	DefaultUpdatedAt func() time.Time
 	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
-	UpdateDefaultUpdatedAt func() int64
+	UpdateDefaultUpdatedAt func() time.Time
 	// RealmValidator is a validator for the "realm" field. It is called by the builders before save.
 	RealmValidator func(string) error
 	// NicknameValidator is a validator for the "nickname" field. It is called by the builders before save.
diff --git a/internal/database/ent/db/account/where.go b/internal/database/ent/db/account/where.go
index 8f872414..fe718ba5 100644
--- a/internal/database/ent/db/account/where.go
+++ b/internal/database/ent/db/account/where.go
@@ -3,6 +3,8 @@
 package account
 
 import (
+	"time"
+
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
@@ -64,22 +66,22 @@ func IDContainsFold(id string) predicate.Account {
 }
 
 // CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
-func CreatedAt(v int64) predicate.Account {
+func CreatedAt(v time.Time) predicate.Account {
 	return predicate.Account(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
-func UpdatedAt(v int64) predicate.Account {
+func UpdatedAt(v time.Time) predicate.Account {
 	return predicate.Account(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // LastBattleTime applies equality check predicate on the "last_battle_time" field. It's identical to LastBattleTimeEQ.
-func LastBattleTime(v int64) predicate.Account {
+func LastBattleTime(v time.Time) predicate.Account {
 	return predicate.Account(sql.FieldEQ(FieldLastBattleTime, v))
 }
 
 // AccountCreatedAt applies equality check predicate on the "account_created_at" field. It's identical to AccountCreatedAtEQ.
-func AccountCreatedAt(v int64) predicate.Account {
+func AccountCreatedAt(v time.Time) predicate.Account {
 	return predicate.Account(sql.FieldEQ(FieldAccountCreatedAt, v))
 }
 
@@ -104,162 +106,162 @@ func ClanID(v string) predicate.Account {
 }
 
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v int64) predicate.Account {
+func CreatedAtEQ(v time.Time) predicate.Account {
 	return predicate.Account(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v int64) predicate.Account {
+func CreatedAtNEQ(v time.Time) predicate.Account {
 	return predicate.Account(sql.FieldNEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...int64) predicate.Account {
+func CreatedAtIn(vs ...time.Time) predicate.Account {
 	return predicate.Account(sql.FieldIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...int64) predicate.Account {
+func CreatedAtNotIn(vs ...time.Time) predicate.Account {
 	return predicate.Account(sql.FieldNotIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v int64) predicate.Account {
+func CreatedAtGT(v time.Time) predicate.Account {
 	return predicate.Account(sql.FieldGT(FieldCreatedAt, v))
 }
 
 // CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v int64) predicate.Account {
+func CreatedAtGTE(v time.Time) predicate.Account {
 	return predicate.Account(sql.FieldGTE(FieldCreatedAt, v))
 }
 
 // CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v int64) predicate.Account {
+func CreatedAtLT(v time.Time) predicate.Account {
 	return predicate.Account(sql.FieldLT(FieldCreatedAt, v))
 }
 
 // CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v int64) predicate.Account {
+func CreatedAtLTE(v time.Time) predicate.Account {
 	return predicate.Account(sql.FieldLTE(FieldCreatedAt, v))
 }
 
 // UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
-func UpdatedAtEQ(v int64) predicate.Account {
+func UpdatedAtEQ(v time.Time) predicate.Account {
 	return predicate.Account(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
-func UpdatedAtNEQ(v int64) predicate.Account {
+func UpdatedAtNEQ(v time.Time) predicate.Account {
 	return predicate.Account(sql.FieldNEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtIn applies the In predicate on the "updated_at" field.
-func UpdatedAtIn(vs ...int64) predicate.Account {
+func UpdatedAtIn(vs ...time.Time) predicate.Account {
 	return predicate.Account(sql.FieldIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
-func UpdatedAtNotIn(vs ...int64) predicate.Account {
+func UpdatedAtNotIn(vs ...time.Time) predicate.Account {
 	return predicate.Account(sql.FieldNotIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtGT applies the GT predicate on the "updated_at" field.
-func UpdatedAtGT(v int64) predicate.Account {
+func UpdatedAtGT(v time.Time) predicate.Account {
 	return predicate.Account(sql.FieldGT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
-func UpdatedAtGTE(v int64) predicate.Account {
+func UpdatedAtGTE(v time.Time) predicate.Account {
 	return predicate.Account(sql.FieldGTE(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLT applies the LT predicate on the "updated_at" field.
-func UpdatedAtLT(v int64) predicate.Account {
+func UpdatedAtLT(v time.Time) predicate.Account {
 	return predicate.Account(sql.FieldLT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
-func UpdatedAtLTE(v int64) predicate.Account {
+func UpdatedAtLTE(v time.Time) predicate.Account {
 	return predicate.Account(sql.FieldLTE(FieldUpdatedAt, v))
 }
 
 // LastBattleTimeEQ applies the EQ predicate on the "last_battle_time" field.
-func LastBattleTimeEQ(v int64) predicate.Account {
+func LastBattleTimeEQ(v time.Time) predicate.Account {
 	return predicate.Account(sql.FieldEQ(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeNEQ applies the NEQ predicate on the "last_battle_time" field.
-func LastBattleTimeNEQ(v int64) predicate.Account {
+func LastBattleTimeNEQ(v time.Time) predicate.Account {
 	return predicate.Account(sql.FieldNEQ(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeIn applies the In predicate on the "last_battle_time" field.
-func LastBattleTimeIn(vs ...int64) predicate.Account {
+func LastBattleTimeIn(vs ...time.Time) predicate.Account {
 	return predicate.Account(sql.FieldIn(FieldLastBattleTime, vs...))
 }
 
 // LastBattleTimeNotIn applies the NotIn predicate on the "last_battle_time" field.
-func LastBattleTimeNotIn(vs ...int64) predicate.Account {
+func LastBattleTimeNotIn(vs ...time.Time) predicate.Account {
 	return predicate.Account(sql.FieldNotIn(FieldLastBattleTime, vs...))
 }
 
 // LastBattleTimeGT applies the GT predicate on the "last_battle_time" field.
-func LastBattleTimeGT(v int64) predicate.Account {
+func LastBattleTimeGT(v time.Time) predicate.Account {
 	return predicate.Account(sql.FieldGT(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeGTE applies the GTE predicate on the "last_battle_time" field.
-func LastBattleTimeGTE(v int64) predicate.Account {
+func LastBattleTimeGTE(v time.Time) predicate.Account {
 	return predicate.Account(sql.FieldGTE(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeLT applies the LT predicate on the "last_battle_time" field.
-func LastBattleTimeLT(v int64) predicate.Account {
+func LastBattleTimeLT(v time.Time) predicate.Account {
 	return predicate.Account(sql.FieldLT(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeLTE applies the LTE predicate on the "last_battle_time" field.
-func LastBattleTimeLTE(v int64) predicate.Account {
+func LastBattleTimeLTE(v time.Time) predicate.Account {
 	return predicate.Account(sql.FieldLTE(FieldLastBattleTime, v))
 }
 
 // AccountCreatedAtEQ applies the EQ predicate on the "account_created_at" field.
-func AccountCreatedAtEQ(v int64) predicate.Account {
+func AccountCreatedAtEQ(v time.Time) predicate.Account {
 	return predicate.Account(sql.FieldEQ(FieldAccountCreatedAt, v))
 }
 
 // AccountCreatedAtNEQ applies the NEQ predicate on the "account_created_at" field.
-func AccountCreatedAtNEQ(v int64) predicate.Account {
+func AccountCreatedAtNEQ(v time.Time) predicate.Account {
 	return predicate.Account(sql.FieldNEQ(FieldAccountCreatedAt, v))
 }
 
 // AccountCreatedAtIn applies the In predicate on the "account_created_at" field.
-func AccountCreatedAtIn(vs ...int64) predicate.Account {
+func AccountCreatedAtIn(vs ...time.Time) predicate.Account {
 	return predicate.Account(sql.FieldIn(FieldAccountCreatedAt, vs...))
 }
 
 // AccountCreatedAtNotIn applies the NotIn predicate on the "account_created_at" field.
-func AccountCreatedAtNotIn(vs ...int64) predicate.Account {
+func AccountCreatedAtNotIn(vs ...time.Time) predicate.Account {
 	return predicate.Account(sql.FieldNotIn(FieldAccountCreatedAt, vs...))
 }
 
 // AccountCreatedAtGT applies the GT predicate on the "account_created_at" field.
-func AccountCreatedAtGT(v int64) predicate.Account {
+func AccountCreatedAtGT(v time.Time) predicate.Account {
 	return predicate.Account(sql.FieldGT(FieldAccountCreatedAt, v))
 }
 
 // AccountCreatedAtGTE applies the GTE predicate on the "account_created_at" field.
-func AccountCreatedAtGTE(v int64) predicate.Account {
+func AccountCreatedAtGTE(v time.Time) predicate.Account {
 	return predicate.Account(sql.FieldGTE(FieldAccountCreatedAt, v))
 }
 
 // AccountCreatedAtLT applies the LT predicate on the "account_created_at" field.
-func AccountCreatedAtLT(v int64) predicate.Account {
+func AccountCreatedAtLT(v time.Time) predicate.Account {
 	return predicate.Account(sql.FieldLT(FieldAccountCreatedAt, v))
 }
 
 // AccountCreatedAtLTE applies the LTE predicate on the "account_created_at" field.
-func AccountCreatedAtLTE(v int64) predicate.Account {
+func AccountCreatedAtLTE(v time.Time) predicate.Account {
 	return predicate.Account(sql.FieldLTE(FieldAccountCreatedAt, v))
 }
 
diff --git a/internal/database/ent/db/account_create.go b/internal/database/ent/db/account_create.go
index 7afba00e..88cc48f2 100644
--- a/internal/database/ent/db/account_create.go
+++ b/internal/database/ent/db/account_create.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"entgo.io/ent/schema/field"
@@ -24,42 +25,42 @@ type AccountCreate struct {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (ac *AccountCreate) SetCreatedAt(i int64) *AccountCreate {
-	ac.mutation.SetCreatedAt(i)
+func (ac *AccountCreate) SetCreatedAt(t time.Time) *AccountCreate {
+	ac.mutation.SetCreatedAt(t)
 	return ac
 }
 
 // SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
-func (ac *AccountCreate) SetNillableCreatedAt(i *int64) *AccountCreate {
-	if i != nil {
-		ac.SetCreatedAt(*i)
+func (ac *AccountCreate) SetNillableCreatedAt(t *time.Time) *AccountCreate {
+	if t != nil {
+		ac.SetCreatedAt(*t)
 	}
 	return ac
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (ac *AccountCreate) SetUpdatedAt(i int64) *AccountCreate {
-	ac.mutation.SetUpdatedAt(i)
+func (ac *AccountCreate) SetUpdatedAt(t time.Time) *AccountCreate {
+	ac.mutation.SetUpdatedAt(t)
 	return ac
 }
 
 // SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
-func (ac *AccountCreate) SetNillableUpdatedAt(i *int64) *AccountCreate {
-	if i != nil {
-		ac.SetUpdatedAt(*i)
+func (ac *AccountCreate) SetNillableUpdatedAt(t *time.Time) *AccountCreate {
+	if t != nil {
+		ac.SetUpdatedAt(*t)
 	}
 	return ac
 }
 
 // SetLastBattleTime sets the "last_battle_time" field.
-func (ac *AccountCreate) SetLastBattleTime(i int64) *AccountCreate {
-	ac.mutation.SetLastBattleTime(i)
+func (ac *AccountCreate) SetLastBattleTime(t time.Time) *AccountCreate {
+	ac.mutation.SetLastBattleTime(t)
 	return ac
 }
 
 // SetAccountCreatedAt sets the "account_created_at" field.
-func (ac *AccountCreate) SetAccountCreatedAt(i int64) *AccountCreate {
-	ac.mutation.SetAccountCreatedAt(i)
+func (ac *AccountCreate) SetAccountCreatedAt(t time.Time) *AccountCreate {
+	ac.mutation.SetAccountCreatedAt(t)
 	return ac
 }
 
@@ -277,19 +278,19 @@ func (ac *AccountCreate) createSpec() (*Account, *sqlgraph.CreateSpec) {
 		_spec.ID.Value = id
 	}
 	if value, ok := ac.mutation.CreatedAt(); ok {
-		_spec.SetField(account.FieldCreatedAt, field.TypeInt64, value)
+		_spec.SetField(account.FieldCreatedAt, field.TypeTime, value)
 		_node.CreatedAt = value
 	}
 	if value, ok := ac.mutation.UpdatedAt(); ok {
-		_spec.SetField(account.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(account.FieldUpdatedAt, field.TypeTime, value)
 		_node.UpdatedAt = value
 	}
 	if value, ok := ac.mutation.LastBattleTime(); ok {
-		_spec.SetField(account.FieldLastBattleTime, field.TypeInt64, value)
+		_spec.SetField(account.FieldLastBattleTime, field.TypeTime, value)
 		_node.LastBattleTime = value
 	}
 	if value, ok := ac.mutation.AccountCreatedAt(); ok {
-		_spec.SetField(account.FieldAccountCreatedAt, field.TypeInt64, value)
+		_spec.SetField(account.FieldAccountCreatedAt, field.TypeTime, value)
 		_node.AccountCreatedAt = value
 	}
 	if value, ok := ac.mutation.Realm(); ok {
diff --git a/internal/database/ent/db/account_query.go b/internal/database/ent/db/account_query.go
index bd81a273..ed808e7b 100644
--- a/internal/database/ent/db/account_query.go
+++ b/internal/database/ent/db/account_query.go
@@ -30,6 +30,7 @@ type AccountQuery struct {
 	withSnapshots            *AccountSnapshotQuery
 	withVehicleSnapshots     *VehicleSnapshotQuery
 	withAchievementSnapshots *AchievementsSnapshotQuery
+	modifiers                []func(*sql.Selector)
 	// intermediate query (i.e. traversal path).
 	sql  *sql.Selector
 	path func(context.Context) (*sql.Selector, error)
@@ -406,7 +407,7 @@ func (aq *AccountQuery) WithAchievementSnapshots(opts ...func(*AchievementsSnaps
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int64 `json:"created_at,omitempty"`
+//		CreatedAt time.Time `json:"created_at,omitempty"`
 //		Count int `json:"count,omitempty"`
 //	}
 //
@@ -429,7 +430,7 @@ func (aq *AccountQuery) GroupBy(field string, fields ...string) *AccountGroupBy
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int64 `json:"created_at,omitempty"`
+//		CreatedAt time.Time `json:"created_at,omitempty"`
 //	}
 //
 //	client.Account.Query().
@@ -494,6 +495,9 @@ func (aq *AccountQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Acco
 		node.Edges.loadedTypes = loadedTypes
 		return node.assignValues(columns, values)
 	}
+	if len(aq.modifiers) > 0 {
+		_spec.Modifiers = aq.modifiers
+	}
 	for i := range hooks {
 		hooks[i](ctx, _spec)
 	}
@@ -657,6 +661,9 @@ func (aq *AccountQuery) loadAchievementSnapshots(ctx context.Context, query *Ach
 
 func (aq *AccountQuery) sqlCount(ctx context.Context) (int, error) {
 	_spec := aq.querySpec()
+	if len(aq.modifiers) > 0 {
+		_spec.Modifiers = aq.modifiers
+	}
 	_spec.Node.Columns = aq.ctx.Fields
 	if len(aq.ctx.Fields) > 0 {
 		_spec.Unique = aq.ctx.Unique != nil && *aq.ctx.Unique
@@ -722,6 +729,9 @@ func (aq *AccountQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	if aq.ctx.Unique != nil && *aq.ctx.Unique {
 		selector.Distinct()
 	}
+	for _, m := range aq.modifiers {
+		m(selector)
+	}
 	for _, p := range aq.predicates {
 		p(selector)
 	}
@@ -739,6 +749,12 @@ func (aq *AccountQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	return selector
 }
 
+// Modify adds a query modifier for attaching custom logic to queries.
+func (aq *AccountQuery) Modify(modifiers ...func(s *sql.Selector)) *AccountSelect {
+	aq.modifiers = append(aq.modifiers, modifiers...)
+	return aq.Select()
+}
+
 // AccountGroupBy is the group-by builder for Account entities.
 type AccountGroupBy struct {
 	selector
@@ -828,3 +844,9 @@ func (as *AccountSelect) sqlScan(ctx context.Context, root *AccountQuery, v any)
 	defer rows.Close()
 	return sql.ScanSlice(rows, v)
 }
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (as *AccountSelect) Modify(modifiers ...func(s *sql.Selector)) *AccountSelect {
+	as.modifiers = append(as.modifiers, modifiers...)
+	return as
+}
diff --git a/internal/database/ent/db/account_update.go b/internal/database/ent/db/account_update.go
index 7a80ee46..af0b100e 100644
--- a/internal/database/ent/db/account_update.go
+++ b/internal/database/ent/db/account_update.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
@@ -21,8 +22,9 @@ import (
 // AccountUpdate is the builder for updating Account entities.
 type AccountUpdate struct {
 	config
-	hooks    []Hook
-	mutation *AccountMutation
+	hooks     []Hook
+	mutation  *AccountMutation
+	modifiers []func(*sql.UpdateBuilder)
 }
 
 // Where appends a list predicates to the AccountUpdate builder.
@@ -32,60 +34,39 @@ func (au *AccountUpdate) Where(ps ...predicate.Account) *AccountUpdate {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (au *AccountUpdate) SetUpdatedAt(i int64) *AccountUpdate {
-	au.mutation.ResetUpdatedAt()
-	au.mutation.SetUpdatedAt(i)
-	return au
-}
-
-// AddUpdatedAt adds i to the "updated_at" field.
-func (au *AccountUpdate) AddUpdatedAt(i int64) *AccountUpdate {
-	au.mutation.AddUpdatedAt(i)
+func (au *AccountUpdate) SetUpdatedAt(t time.Time) *AccountUpdate {
+	au.mutation.SetUpdatedAt(t)
 	return au
 }
 
 // SetLastBattleTime sets the "last_battle_time" field.
-func (au *AccountUpdate) SetLastBattleTime(i int64) *AccountUpdate {
-	au.mutation.ResetLastBattleTime()
-	au.mutation.SetLastBattleTime(i)
+func (au *AccountUpdate) SetLastBattleTime(t time.Time) *AccountUpdate {
+	au.mutation.SetLastBattleTime(t)
 	return au
 }
 
 // SetNillableLastBattleTime sets the "last_battle_time" field if the given value is not nil.
-func (au *AccountUpdate) SetNillableLastBattleTime(i *int64) *AccountUpdate {
-	if i != nil {
-		au.SetLastBattleTime(*i)
+func (au *AccountUpdate) SetNillableLastBattleTime(t *time.Time) *AccountUpdate {
+	if t != nil {
+		au.SetLastBattleTime(*t)
 	}
 	return au
 }
 
-// AddLastBattleTime adds i to the "last_battle_time" field.
-func (au *AccountUpdate) AddLastBattleTime(i int64) *AccountUpdate {
-	au.mutation.AddLastBattleTime(i)
-	return au
-}
-
 // SetAccountCreatedAt sets the "account_created_at" field.
-func (au *AccountUpdate) SetAccountCreatedAt(i int64) *AccountUpdate {
-	au.mutation.ResetAccountCreatedAt()
-	au.mutation.SetAccountCreatedAt(i)
+func (au *AccountUpdate) SetAccountCreatedAt(t time.Time) *AccountUpdate {
+	au.mutation.SetAccountCreatedAt(t)
 	return au
 }
 
 // SetNillableAccountCreatedAt sets the "account_created_at" field if the given value is not nil.
-func (au *AccountUpdate) SetNillableAccountCreatedAt(i *int64) *AccountUpdate {
-	if i != nil {
-		au.SetAccountCreatedAt(*i)
+func (au *AccountUpdate) SetNillableAccountCreatedAt(t *time.Time) *AccountUpdate {
+	if t != nil {
+		au.SetAccountCreatedAt(*t)
 	}
 	return au
 }
 
-// AddAccountCreatedAt adds i to the "account_created_at" field.
-func (au *AccountUpdate) AddAccountCreatedAt(i int64) *AccountUpdate {
-	au.mutation.AddAccountCreatedAt(i)
-	return au
-}
-
 // SetRealm sets the "realm" field.
 func (au *AccountUpdate) SetRealm(s string) *AccountUpdate {
 	au.mutation.SetRealm(s)
@@ -323,6 +304,12 @@ func (au *AccountUpdate) check() error {
 	return nil
 }
 
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (au *AccountUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *AccountUpdate {
+	au.modifiers = append(au.modifiers, modifiers...)
+	return au
+}
+
 func (au *AccountUpdate) sqlSave(ctx context.Context) (n int, err error) {
 	if err := au.check(); err != nil {
 		return n, err
@@ -336,22 +323,13 @@ func (au *AccountUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 	}
 	if value, ok := au.mutation.UpdatedAt(); ok {
-		_spec.SetField(account.FieldUpdatedAt, field.TypeInt64, value)
-	}
-	if value, ok := au.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(account.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(account.FieldUpdatedAt, field.TypeTime, value)
 	}
 	if value, ok := au.mutation.LastBattleTime(); ok {
-		_spec.SetField(account.FieldLastBattleTime, field.TypeInt64, value)
-	}
-	if value, ok := au.mutation.AddedLastBattleTime(); ok {
-		_spec.AddField(account.FieldLastBattleTime, field.TypeInt64, value)
+		_spec.SetField(account.FieldLastBattleTime, field.TypeTime, value)
 	}
 	if value, ok := au.mutation.AccountCreatedAt(); ok {
-		_spec.SetField(account.FieldAccountCreatedAt, field.TypeInt64, value)
-	}
-	if value, ok := au.mutation.AddedAccountCreatedAt(); ok {
-		_spec.AddField(account.FieldAccountCreatedAt, field.TypeInt64, value)
+		_spec.SetField(account.FieldAccountCreatedAt, field.TypeTime, value)
 	}
 	if value, ok := au.mutation.Realm(); ok {
 		_spec.SetField(account.FieldRealm, field.TypeString, value)
@@ -526,6 +504,7 @@ func (au *AccountUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 		_spec.Edges.Add = append(_spec.Edges.Add, edge)
 	}
+	_spec.AddModifiers(au.modifiers...)
 	if n, err = sqlgraph.UpdateNodes(ctx, au.driver, _spec); err != nil {
 		if _, ok := err.(*sqlgraph.NotFoundError); ok {
 			err = &NotFoundError{account.Label}
@@ -541,66 +520,46 @@ func (au *AccountUpdate) sqlSave(ctx context.Context) (n int, err error) {
 // AccountUpdateOne is the builder for updating a single Account entity.
 type AccountUpdateOne struct {
 	config
-	fields   []string
-	hooks    []Hook
-	mutation *AccountMutation
+	fields    []string
+	hooks     []Hook
+	mutation  *AccountMutation
+	modifiers []func(*sql.UpdateBuilder)
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (auo *AccountUpdateOne) SetUpdatedAt(i int64) *AccountUpdateOne {
-	auo.mutation.ResetUpdatedAt()
-	auo.mutation.SetUpdatedAt(i)
-	return auo
-}
-
-// AddUpdatedAt adds i to the "updated_at" field.
-func (auo *AccountUpdateOne) AddUpdatedAt(i int64) *AccountUpdateOne {
-	auo.mutation.AddUpdatedAt(i)
+func (auo *AccountUpdateOne) SetUpdatedAt(t time.Time) *AccountUpdateOne {
+	auo.mutation.SetUpdatedAt(t)
 	return auo
 }
 
 // SetLastBattleTime sets the "last_battle_time" field.
-func (auo *AccountUpdateOne) SetLastBattleTime(i int64) *AccountUpdateOne {
-	auo.mutation.ResetLastBattleTime()
-	auo.mutation.SetLastBattleTime(i)
+func (auo *AccountUpdateOne) SetLastBattleTime(t time.Time) *AccountUpdateOne {
+	auo.mutation.SetLastBattleTime(t)
 	return auo
 }
 
 // SetNillableLastBattleTime sets the "last_battle_time" field if the given value is not nil.
-func (auo *AccountUpdateOne) SetNillableLastBattleTime(i *int64) *AccountUpdateOne {
-	if i != nil {
-		auo.SetLastBattleTime(*i)
+func (auo *AccountUpdateOne) SetNillableLastBattleTime(t *time.Time) *AccountUpdateOne {
+	if t != nil {
+		auo.SetLastBattleTime(*t)
 	}
 	return auo
 }
 
-// AddLastBattleTime adds i to the "last_battle_time" field.
-func (auo *AccountUpdateOne) AddLastBattleTime(i int64) *AccountUpdateOne {
-	auo.mutation.AddLastBattleTime(i)
-	return auo
-}
-
 // SetAccountCreatedAt sets the "account_created_at" field.
-func (auo *AccountUpdateOne) SetAccountCreatedAt(i int64) *AccountUpdateOne {
-	auo.mutation.ResetAccountCreatedAt()
-	auo.mutation.SetAccountCreatedAt(i)
+func (auo *AccountUpdateOne) SetAccountCreatedAt(t time.Time) *AccountUpdateOne {
+	auo.mutation.SetAccountCreatedAt(t)
 	return auo
 }
 
 // SetNillableAccountCreatedAt sets the "account_created_at" field if the given value is not nil.
-func (auo *AccountUpdateOne) SetNillableAccountCreatedAt(i *int64) *AccountUpdateOne {
-	if i != nil {
-		auo.SetAccountCreatedAt(*i)
+func (auo *AccountUpdateOne) SetNillableAccountCreatedAt(t *time.Time) *AccountUpdateOne {
+	if t != nil {
+		auo.SetAccountCreatedAt(*t)
 	}
 	return auo
 }
 
-// AddAccountCreatedAt adds i to the "account_created_at" field.
-func (auo *AccountUpdateOne) AddAccountCreatedAt(i int64) *AccountUpdateOne {
-	auo.mutation.AddAccountCreatedAt(i)
-	return auo
-}
-
 // SetRealm sets the "realm" field.
 func (auo *AccountUpdateOne) SetRealm(s string) *AccountUpdateOne {
 	auo.mutation.SetRealm(s)
@@ -851,6 +810,12 @@ func (auo *AccountUpdateOne) check() error {
 	return nil
 }
 
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (auo *AccountUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *AccountUpdateOne {
+	auo.modifiers = append(auo.modifiers, modifiers...)
+	return auo
+}
+
 func (auo *AccountUpdateOne) sqlSave(ctx context.Context) (_node *Account, err error) {
 	if err := auo.check(); err != nil {
 		return _node, err
@@ -881,22 +846,13 @@ func (auo *AccountUpdateOne) sqlSave(ctx context.Context) (_node *Account, err e
 		}
 	}
 	if value, ok := auo.mutation.UpdatedAt(); ok {
-		_spec.SetField(account.FieldUpdatedAt, field.TypeInt64, value)
-	}
-	if value, ok := auo.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(account.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(account.FieldUpdatedAt, field.TypeTime, value)
 	}
 	if value, ok := auo.mutation.LastBattleTime(); ok {
-		_spec.SetField(account.FieldLastBattleTime, field.TypeInt64, value)
-	}
-	if value, ok := auo.mutation.AddedLastBattleTime(); ok {
-		_spec.AddField(account.FieldLastBattleTime, field.TypeInt64, value)
+		_spec.SetField(account.FieldLastBattleTime, field.TypeTime, value)
 	}
 	if value, ok := auo.mutation.AccountCreatedAt(); ok {
-		_spec.SetField(account.FieldAccountCreatedAt, field.TypeInt64, value)
-	}
-	if value, ok := auo.mutation.AddedAccountCreatedAt(); ok {
-		_spec.AddField(account.FieldAccountCreatedAt, field.TypeInt64, value)
+		_spec.SetField(account.FieldAccountCreatedAt, field.TypeTime, value)
 	}
 	if value, ok := auo.mutation.Realm(); ok {
 		_spec.SetField(account.FieldRealm, field.TypeString, value)
@@ -1071,6 +1027,7 @@ func (auo *AccountUpdateOne) sqlSave(ctx context.Context) (_node *Account, err e
 		}
 		_spec.Edges.Add = append(_spec.Edges.Add, edge)
 	}
+	_spec.AddModifiers(auo.modifiers...)
 	_node = &Account{config: auo.config}
 	_spec.Assign = _node.assignValues
 	_spec.ScanValues = _node.scanValues
diff --git a/internal/database/ent/db/accountsnapshot.go b/internal/database/ent/db/accountsnapshot.go
index 18d8c5f7..ba9c412e 100644
--- a/internal/database/ent/db/accountsnapshot.go
+++ b/internal/database/ent/db/accountsnapshot.go
@@ -6,6 +6,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"strings"
+	"time"
 
 	"entgo.io/ent"
 	"entgo.io/ent/dialect/sql"
@@ -21,13 +22,13 @@ type AccountSnapshot struct {
 	// ID of the ent.
 	ID string `json:"id,omitempty"`
 	// CreatedAt holds the value of the "created_at" field.
-	CreatedAt int64 `json:"created_at,omitempty"`
+	CreatedAt time.Time `json:"created_at,omitempty"`
 	// UpdatedAt holds the value of the "updated_at" field.
-	UpdatedAt int64 `json:"updated_at,omitempty"`
+	UpdatedAt time.Time `json:"updated_at,omitempty"`
 	// Type holds the value of the "type" field.
 	Type models.SnapshotType `json:"type,omitempty"`
 	// LastBattleTime holds the value of the "last_battle_time" field.
-	LastBattleTime int64 `json:"last_battle_time,omitempty"`
+	LastBattleTime time.Time `json:"last_battle_time,omitempty"`
 	// AccountID holds the value of the "account_id" field.
 	AccountID string `json:"account_id,omitempty"`
 	// ReferenceID holds the value of the "reference_id" field.
@@ -73,10 +74,12 @@ func (*AccountSnapshot) scanValues(columns []string) ([]any, error) {
 		switch columns[i] {
 		case accountsnapshot.FieldRatingFrame, accountsnapshot.FieldRegularFrame:
 			values[i] = new([]byte)
-		case accountsnapshot.FieldCreatedAt, accountsnapshot.FieldUpdatedAt, accountsnapshot.FieldLastBattleTime, accountsnapshot.FieldRatingBattles, accountsnapshot.FieldRegularBattles:
+		case accountsnapshot.FieldRatingBattles, accountsnapshot.FieldRegularBattles:
 			values[i] = new(sql.NullInt64)
 		case accountsnapshot.FieldID, accountsnapshot.FieldType, accountsnapshot.FieldAccountID, accountsnapshot.FieldReferenceID:
 			values[i] = new(sql.NullString)
+		case accountsnapshot.FieldCreatedAt, accountsnapshot.FieldUpdatedAt, accountsnapshot.FieldLastBattleTime:
+			values[i] = new(sql.NullTime)
 		default:
 			values[i] = new(sql.UnknownType)
 		}
@@ -99,16 +102,16 @@ func (as *AccountSnapshot) assignValues(columns []string, values []any) error {
 				as.ID = value.String
 			}
 		case accountsnapshot.FieldCreatedAt:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field created_at", values[i])
 			} else if value.Valid {
-				as.CreatedAt = value.Int64
+				as.CreatedAt = value.Time
 			}
 		case accountsnapshot.FieldUpdatedAt:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
 			} else if value.Valid {
-				as.UpdatedAt = value.Int64
+				as.UpdatedAt = value.Time
 			}
 		case accountsnapshot.FieldType:
 			if value, ok := values[i].(*sql.NullString); !ok {
@@ -117,10 +120,10 @@ func (as *AccountSnapshot) assignValues(columns []string, values []any) error {
 				as.Type = models.SnapshotType(value.String)
 			}
 		case accountsnapshot.FieldLastBattleTime:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field last_battle_time", values[i])
 			} else if value.Valid {
-				as.LastBattleTime = value.Int64
+				as.LastBattleTime = value.Time
 			}
 		case accountsnapshot.FieldAccountID:
 			if value, ok := values[i].(*sql.NullString); !ok {
@@ -204,16 +207,16 @@ func (as *AccountSnapshot) String() string {
 	builder.WriteString("AccountSnapshot(")
 	builder.WriteString(fmt.Sprintf("id=%v, ", as.ID))
 	builder.WriteString("created_at=")
-	builder.WriteString(fmt.Sprintf("%v", as.CreatedAt))
+	builder.WriteString(as.CreatedAt.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("updated_at=")
-	builder.WriteString(fmt.Sprintf("%v", as.UpdatedAt))
+	builder.WriteString(as.UpdatedAt.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("type=")
 	builder.WriteString(fmt.Sprintf("%v", as.Type))
 	builder.WriteString(", ")
 	builder.WriteString("last_battle_time=")
-	builder.WriteString(fmt.Sprintf("%v", as.LastBattleTime))
+	builder.WriteString(as.LastBattleTime.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("account_id=")
 	builder.WriteString(as.AccountID)
diff --git a/internal/database/ent/db/accountsnapshot/accountsnapshot.go b/internal/database/ent/db/accountsnapshot/accountsnapshot.go
index 1a60c4b6..76caf2d3 100644
--- a/internal/database/ent/db/accountsnapshot/accountsnapshot.go
+++ b/internal/database/ent/db/accountsnapshot/accountsnapshot.go
@@ -4,6 +4,7 @@ package accountsnapshot
 
 import (
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
@@ -75,11 +76,11 @@ func ValidColumn(column string) bool {
 
 var (
 	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
-	DefaultCreatedAt func() int64
+	DefaultCreatedAt func() time.Time
 	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
-	DefaultUpdatedAt func() int64
+	DefaultUpdatedAt func() time.Time
 	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
-	UpdateDefaultUpdatedAt func() int64
+	UpdateDefaultUpdatedAt func() time.Time
 	// AccountIDValidator is a validator for the "account_id" field. It is called by the builders before save.
 	AccountIDValidator func(string) error
 	// ReferenceIDValidator is a validator for the "reference_id" field. It is called by the builders before save.
diff --git a/internal/database/ent/db/accountsnapshot/where.go b/internal/database/ent/db/accountsnapshot/where.go
index 6f49d0e8..1bd66d6c 100644
--- a/internal/database/ent/db/accountsnapshot/where.go
+++ b/internal/database/ent/db/accountsnapshot/where.go
@@ -3,6 +3,8 @@
 package accountsnapshot
 
 import (
+	"time"
+
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
@@ -65,17 +67,17 @@ func IDContainsFold(id string) predicate.AccountSnapshot {
 }
 
 // CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
-func CreatedAt(v int64) predicate.AccountSnapshot {
+func CreatedAt(v time.Time) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
-func UpdatedAt(v int64) predicate.AccountSnapshot {
+func UpdatedAt(v time.Time) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // LastBattleTime applies equality check predicate on the "last_battle_time" field. It's identical to LastBattleTimeEQ.
-func LastBattleTime(v int64) predicate.AccountSnapshot {
+func LastBattleTime(v time.Time) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldEQ(FieldLastBattleTime, v))
 }
 
@@ -100,82 +102,82 @@ func RegularBattles(v int) predicate.AccountSnapshot {
 }
 
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v int64) predicate.AccountSnapshot {
+func CreatedAtEQ(v time.Time) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v int64) predicate.AccountSnapshot {
+func CreatedAtNEQ(v time.Time) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldNEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...int64) predicate.AccountSnapshot {
+func CreatedAtIn(vs ...time.Time) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...int64) predicate.AccountSnapshot {
+func CreatedAtNotIn(vs ...time.Time) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldNotIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v int64) predicate.AccountSnapshot {
+func CreatedAtGT(v time.Time) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldGT(FieldCreatedAt, v))
 }
 
 // CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v int64) predicate.AccountSnapshot {
+func CreatedAtGTE(v time.Time) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldGTE(FieldCreatedAt, v))
 }
 
 // CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v int64) predicate.AccountSnapshot {
+func CreatedAtLT(v time.Time) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldLT(FieldCreatedAt, v))
 }
 
 // CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v int64) predicate.AccountSnapshot {
+func CreatedAtLTE(v time.Time) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldLTE(FieldCreatedAt, v))
 }
 
 // UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
-func UpdatedAtEQ(v int64) predicate.AccountSnapshot {
+func UpdatedAtEQ(v time.Time) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
-func UpdatedAtNEQ(v int64) predicate.AccountSnapshot {
+func UpdatedAtNEQ(v time.Time) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldNEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtIn applies the In predicate on the "updated_at" field.
-func UpdatedAtIn(vs ...int64) predicate.AccountSnapshot {
+func UpdatedAtIn(vs ...time.Time) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
-func UpdatedAtNotIn(vs ...int64) predicate.AccountSnapshot {
+func UpdatedAtNotIn(vs ...time.Time) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldNotIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtGT applies the GT predicate on the "updated_at" field.
-func UpdatedAtGT(v int64) predicate.AccountSnapshot {
+func UpdatedAtGT(v time.Time) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldGT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
-func UpdatedAtGTE(v int64) predicate.AccountSnapshot {
+func UpdatedAtGTE(v time.Time) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldGTE(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLT applies the LT predicate on the "updated_at" field.
-func UpdatedAtLT(v int64) predicate.AccountSnapshot {
+func UpdatedAtLT(v time.Time) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldLT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
-func UpdatedAtLTE(v int64) predicate.AccountSnapshot {
+func UpdatedAtLTE(v time.Time) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldLTE(FieldUpdatedAt, v))
 }
 
@@ -210,42 +212,42 @@ func TypeNotIn(vs ...models.SnapshotType) predicate.AccountSnapshot {
 }
 
 // LastBattleTimeEQ applies the EQ predicate on the "last_battle_time" field.
-func LastBattleTimeEQ(v int64) predicate.AccountSnapshot {
+func LastBattleTimeEQ(v time.Time) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldEQ(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeNEQ applies the NEQ predicate on the "last_battle_time" field.
-func LastBattleTimeNEQ(v int64) predicate.AccountSnapshot {
+func LastBattleTimeNEQ(v time.Time) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldNEQ(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeIn applies the In predicate on the "last_battle_time" field.
-func LastBattleTimeIn(vs ...int64) predicate.AccountSnapshot {
+func LastBattleTimeIn(vs ...time.Time) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldIn(FieldLastBattleTime, vs...))
 }
 
 // LastBattleTimeNotIn applies the NotIn predicate on the "last_battle_time" field.
-func LastBattleTimeNotIn(vs ...int64) predicate.AccountSnapshot {
+func LastBattleTimeNotIn(vs ...time.Time) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldNotIn(FieldLastBattleTime, vs...))
 }
 
 // LastBattleTimeGT applies the GT predicate on the "last_battle_time" field.
-func LastBattleTimeGT(v int64) predicate.AccountSnapshot {
+func LastBattleTimeGT(v time.Time) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldGT(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeGTE applies the GTE predicate on the "last_battle_time" field.
-func LastBattleTimeGTE(v int64) predicate.AccountSnapshot {
+func LastBattleTimeGTE(v time.Time) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldGTE(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeLT applies the LT predicate on the "last_battle_time" field.
-func LastBattleTimeLT(v int64) predicate.AccountSnapshot {
+func LastBattleTimeLT(v time.Time) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldLT(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeLTE applies the LTE predicate on the "last_battle_time" field.
-func LastBattleTimeLTE(v int64) predicate.AccountSnapshot {
+func LastBattleTimeLTE(v time.Time) predicate.AccountSnapshot {
 	return predicate.AccountSnapshot(sql.FieldLTE(FieldLastBattleTime, v))
 }
 
diff --git a/internal/database/ent/db/accountsnapshot_create.go b/internal/database/ent/db/accountsnapshot_create.go
index 9cc5742c..e29034fe 100644
--- a/internal/database/ent/db/accountsnapshot_create.go
+++ b/internal/database/ent/db/accountsnapshot_create.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"entgo.io/ent/schema/field"
@@ -23,29 +24,29 @@ type AccountSnapshotCreate struct {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (asc *AccountSnapshotCreate) SetCreatedAt(i int64) *AccountSnapshotCreate {
-	asc.mutation.SetCreatedAt(i)
+func (asc *AccountSnapshotCreate) SetCreatedAt(t time.Time) *AccountSnapshotCreate {
+	asc.mutation.SetCreatedAt(t)
 	return asc
 }
 
 // SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
-func (asc *AccountSnapshotCreate) SetNillableCreatedAt(i *int64) *AccountSnapshotCreate {
-	if i != nil {
-		asc.SetCreatedAt(*i)
+func (asc *AccountSnapshotCreate) SetNillableCreatedAt(t *time.Time) *AccountSnapshotCreate {
+	if t != nil {
+		asc.SetCreatedAt(*t)
 	}
 	return asc
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (asc *AccountSnapshotCreate) SetUpdatedAt(i int64) *AccountSnapshotCreate {
-	asc.mutation.SetUpdatedAt(i)
+func (asc *AccountSnapshotCreate) SetUpdatedAt(t time.Time) *AccountSnapshotCreate {
+	asc.mutation.SetUpdatedAt(t)
 	return asc
 }
 
 // SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
-func (asc *AccountSnapshotCreate) SetNillableUpdatedAt(i *int64) *AccountSnapshotCreate {
-	if i != nil {
-		asc.SetUpdatedAt(*i)
+func (asc *AccountSnapshotCreate) SetNillableUpdatedAt(t *time.Time) *AccountSnapshotCreate {
+	if t != nil {
+		asc.SetUpdatedAt(*t)
 	}
 	return asc
 }
@@ -57,8 +58,8 @@ func (asc *AccountSnapshotCreate) SetType(mt models.SnapshotType) *AccountSnapsh
 }
 
 // SetLastBattleTime sets the "last_battle_time" field.
-func (asc *AccountSnapshotCreate) SetLastBattleTime(i int64) *AccountSnapshotCreate {
-	asc.mutation.SetLastBattleTime(i)
+func (asc *AccountSnapshotCreate) SetLastBattleTime(t time.Time) *AccountSnapshotCreate {
+	asc.mutation.SetLastBattleTime(t)
 	return asc
 }
 
@@ -252,11 +253,11 @@ func (asc *AccountSnapshotCreate) createSpec() (*AccountSnapshot, *sqlgraph.Crea
 		_spec.ID.Value = id
 	}
 	if value, ok := asc.mutation.CreatedAt(); ok {
-		_spec.SetField(accountsnapshot.FieldCreatedAt, field.TypeInt64, value)
+		_spec.SetField(accountsnapshot.FieldCreatedAt, field.TypeTime, value)
 		_node.CreatedAt = value
 	}
 	if value, ok := asc.mutation.UpdatedAt(); ok {
-		_spec.SetField(accountsnapshot.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(accountsnapshot.FieldUpdatedAt, field.TypeTime, value)
 		_node.UpdatedAt = value
 	}
 	if value, ok := asc.mutation.GetType(); ok {
@@ -264,7 +265,7 @@ func (asc *AccountSnapshotCreate) createSpec() (*AccountSnapshot, *sqlgraph.Crea
 		_node.Type = value
 	}
 	if value, ok := asc.mutation.LastBattleTime(); ok {
-		_spec.SetField(accountsnapshot.FieldLastBattleTime, field.TypeInt64, value)
+		_spec.SetField(accountsnapshot.FieldLastBattleTime, field.TypeTime, value)
 		_node.LastBattleTime = value
 	}
 	if value, ok := asc.mutation.ReferenceID(); ok {
diff --git a/internal/database/ent/db/accountsnapshot_query.go b/internal/database/ent/db/accountsnapshot_query.go
index 33acaaf3..8ad15e4a 100644
--- a/internal/database/ent/db/accountsnapshot_query.go
+++ b/internal/database/ent/db/accountsnapshot_query.go
@@ -23,6 +23,7 @@ type AccountSnapshotQuery struct {
 	inters      []Interceptor
 	predicates  []predicate.AccountSnapshot
 	withAccount *AccountQuery
+	modifiers   []func(*sql.Selector)
 	// intermediate query (i.e. traversal path).
 	sql  *sql.Selector
 	path func(context.Context) (*sql.Selector, error)
@@ -297,7 +298,7 @@ func (asq *AccountSnapshotQuery) WithAccount(opts ...func(*AccountQuery)) *Accou
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int64 `json:"created_at,omitempty"`
+//		CreatedAt time.Time `json:"created_at,omitempty"`
 //		Count int `json:"count,omitempty"`
 //	}
 //
@@ -320,7 +321,7 @@ func (asq *AccountSnapshotQuery) GroupBy(field string, fields ...string) *Accoun
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int64 `json:"created_at,omitempty"`
+//		CreatedAt time.Time `json:"created_at,omitempty"`
 //	}
 //
 //	client.AccountSnapshot.Query().
@@ -382,6 +383,9 @@ func (asq *AccountSnapshotQuery) sqlAll(ctx context.Context, hooks ...queryHook)
 		node.Edges.loadedTypes = loadedTypes
 		return node.assignValues(columns, values)
 	}
+	if len(asq.modifiers) > 0 {
+		_spec.Modifiers = asq.modifiers
+	}
 	for i := range hooks {
 		hooks[i](ctx, _spec)
 	}
@@ -432,6 +436,9 @@ func (asq *AccountSnapshotQuery) loadAccount(ctx context.Context, query *Account
 
 func (asq *AccountSnapshotQuery) sqlCount(ctx context.Context) (int, error) {
 	_spec := asq.querySpec()
+	if len(asq.modifiers) > 0 {
+		_spec.Modifiers = asq.modifiers
+	}
 	_spec.Node.Columns = asq.ctx.Fields
 	if len(asq.ctx.Fields) > 0 {
 		_spec.Unique = asq.ctx.Unique != nil && *asq.ctx.Unique
@@ -497,6 +504,9 @@ func (asq *AccountSnapshotQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	if asq.ctx.Unique != nil && *asq.ctx.Unique {
 		selector.Distinct()
 	}
+	for _, m := range asq.modifiers {
+		m(selector)
+	}
 	for _, p := range asq.predicates {
 		p(selector)
 	}
@@ -514,6 +524,12 @@ func (asq *AccountSnapshotQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	return selector
 }
 
+// Modify adds a query modifier for attaching custom logic to queries.
+func (asq *AccountSnapshotQuery) Modify(modifiers ...func(s *sql.Selector)) *AccountSnapshotSelect {
+	asq.modifiers = append(asq.modifiers, modifiers...)
+	return asq.Select()
+}
+
 // AccountSnapshotGroupBy is the group-by builder for AccountSnapshot entities.
 type AccountSnapshotGroupBy struct {
 	selector
@@ -603,3 +619,9 @@ func (ass *AccountSnapshotSelect) sqlScan(ctx context.Context, root *AccountSnap
 	defer rows.Close()
 	return sql.ScanSlice(rows, v)
 }
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (ass *AccountSnapshotSelect) Modify(modifiers ...func(s *sql.Selector)) *AccountSnapshotSelect {
+	ass.modifiers = append(ass.modifiers, modifiers...)
+	return ass
+}
diff --git a/internal/database/ent/db/accountsnapshot_update.go b/internal/database/ent/db/accountsnapshot_update.go
index 407e16bf..0643c23a 100644
--- a/internal/database/ent/db/accountsnapshot_update.go
+++ b/internal/database/ent/db/accountsnapshot_update.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
@@ -19,8 +20,9 @@ import (
 // AccountSnapshotUpdate is the builder for updating AccountSnapshot entities.
 type AccountSnapshotUpdate struct {
 	config
-	hooks    []Hook
-	mutation *AccountSnapshotMutation
+	hooks     []Hook
+	mutation  *AccountSnapshotMutation
+	modifiers []func(*sql.UpdateBuilder)
 }
 
 // Where appends a list predicates to the AccountSnapshotUpdate builder.
@@ -30,15 +32,8 @@ func (asu *AccountSnapshotUpdate) Where(ps ...predicate.AccountSnapshot) *Accoun
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (asu *AccountSnapshotUpdate) SetUpdatedAt(i int64) *AccountSnapshotUpdate {
-	asu.mutation.ResetUpdatedAt()
-	asu.mutation.SetUpdatedAt(i)
-	return asu
-}
-
-// AddUpdatedAt adds i to the "updated_at" field.
-func (asu *AccountSnapshotUpdate) AddUpdatedAt(i int64) *AccountSnapshotUpdate {
-	asu.mutation.AddUpdatedAt(i)
+func (asu *AccountSnapshotUpdate) SetUpdatedAt(t time.Time) *AccountSnapshotUpdate {
+	asu.mutation.SetUpdatedAt(t)
 	return asu
 }
 
@@ -57,26 +52,19 @@ func (asu *AccountSnapshotUpdate) SetNillableType(mt *models.SnapshotType) *Acco
 }
 
 // SetLastBattleTime sets the "last_battle_time" field.
-func (asu *AccountSnapshotUpdate) SetLastBattleTime(i int64) *AccountSnapshotUpdate {
-	asu.mutation.ResetLastBattleTime()
-	asu.mutation.SetLastBattleTime(i)
+func (asu *AccountSnapshotUpdate) SetLastBattleTime(t time.Time) *AccountSnapshotUpdate {
+	asu.mutation.SetLastBattleTime(t)
 	return asu
 }
 
 // SetNillableLastBattleTime sets the "last_battle_time" field if the given value is not nil.
-func (asu *AccountSnapshotUpdate) SetNillableLastBattleTime(i *int64) *AccountSnapshotUpdate {
-	if i != nil {
-		asu.SetLastBattleTime(*i)
+func (asu *AccountSnapshotUpdate) SetNillableLastBattleTime(t *time.Time) *AccountSnapshotUpdate {
+	if t != nil {
+		asu.SetLastBattleTime(*t)
 	}
 	return asu
 }
 
-// AddLastBattleTime adds i to the "last_battle_time" field.
-func (asu *AccountSnapshotUpdate) AddLastBattleTime(i int64) *AccountSnapshotUpdate {
-	asu.mutation.AddLastBattleTime(i)
-	return asu
-}
-
 // SetReferenceID sets the "reference_id" field.
 func (asu *AccountSnapshotUpdate) SetReferenceID(s string) *AccountSnapshotUpdate {
 	asu.mutation.SetReferenceID(s)
@@ -220,6 +208,12 @@ func (asu *AccountSnapshotUpdate) check() error {
 	return nil
 }
 
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (asu *AccountSnapshotUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *AccountSnapshotUpdate {
+	asu.modifiers = append(asu.modifiers, modifiers...)
+	return asu
+}
+
 func (asu *AccountSnapshotUpdate) sqlSave(ctx context.Context) (n int, err error) {
 	if err := asu.check(); err != nil {
 		return n, err
@@ -233,19 +227,13 @@ func (asu *AccountSnapshotUpdate) sqlSave(ctx context.Context) (n int, err error
 		}
 	}
 	if value, ok := asu.mutation.UpdatedAt(); ok {
-		_spec.SetField(accountsnapshot.FieldUpdatedAt, field.TypeInt64, value)
-	}
-	if value, ok := asu.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(accountsnapshot.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(accountsnapshot.FieldUpdatedAt, field.TypeTime, value)
 	}
 	if value, ok := asu.mutation.GetType(); ok {
 		_spec.SetField(accountsnapshot.FieldType, field.TypeEnum, value)
 	}
 	if value, ok := asu.mutation.LastBattleTime(); ok {
-		_spec.SetField(accountsnapshot.FieldLastBattleTime, field.TypeInt64, value)
-	}
-	if value, ok := asu.mutation.AddedLastBattleTime(); ok {
-		_spec.AddField(accountsnapshot.FieldLastBattleTime, field.TypeInt64, value)
+		_spec.SetField(accountsnapshot.FieldLastBattleTime, field.TypeTime, value)
 	}
 	if value, ok := asu.mutation.ReferenceID(); ok {
 		_spec.SetField(accountsnapshot.FieldReferenceID, field.TypeString, value)
@@ -268,6 +256,7 @@ func (asu *AccountSnapshotUpdate) sqlSave(ctx context.Context) (n int, err error
 	if value, ok := asu.mutation.RegularFrame(); ok {
 		_spec.SetField(accountsnapshot.FieldRegularFrame, field.TypeJSON, value)
 	}
+	_spec.AddModifiers(asu.modifiers...)
 	if n, err = sqlgraph.UpdateNodes(ctx, asu.driver, _spec); err != nil {
 		if _, ok := err.(*sqlgraph.NotFoundError); ok {
 			err = &NotFoundError{accountsnapshot.Label}
@@ -283,21 +272,15 @@ func (asu *AccountSnapshotUpdate) sqlSave(ctx context.Context) (n int, err error
 // AccountSnapshotUpdateOne is the builder for updating a single AccountSnapshot entity.
 type AccountSnapshotUpdateOne struct {
 	config
-	fields   []string
-	hooks    []Hook
-	mutation *AccountSnapshotMutation
+	fields    []string
+	hooks     []Hook
+	mutation  *AccountSnapshotMutation
+	modifiers []func(*sql.UpdateBuilder)
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (asuo *AccountSnapshotUpdateOne) SetUpdatedAt(i int64) *AccountSnapshotUpdateOne {
-	asuo.mutation.ResetUpdatedAt()
-	asuo.mutation.SetUpdatedAt(i)
-	return asuo
-}
-
-// AddUpdatedAt adds i to the "updated_at" field.
-func (asuo *AccountSnapshotUpdateOne) AddUpdatedAt(i int64) *AccountSnapshotUpdateOne {
-	asuo.mutation.AddUpdatedAt(i)
+func (asuo *AccountSnapshotUpdateOne) SetUpdatedAt(t time.Time) *AccountSnapshotUpdateOne {
+	asuo.mutation.SetUpdatedAt(t)
 	return asuo
 }
 
@@ -316,26 +299,19 @@ func (asuo *AccountSnapshotUpdateOne) SetNillableType(mt *models.SnapshotType) *
 }
 
 // SetLastBattleTime sets the "last_battle_time" field.
-func (asuo *AccountSnapshotUpdateOne) SetLastBattleTime(i int64) *AccountSnapshotUpdateOne {
-	asuo.mutation.ResetLastBattleTime()
-	asuo.mutation.SetLastBattleTime(i)
+func (asuo *AccountSnapshotUpdateOne) SetLastBattleTime(t time.Time) *AccountSnapshotUpdateOne {
+	asuo.mutation.SetLastBattleTime(t)
 	return asuo
 }
 
 // SetNillableLastBattleTime sets the "last_battle_time" field if the given value is not nil.
-func (asuo *AccountSnapshotUpdateOne) SetNillableLastBattleTime(i *int64) *AccountSnapshotUpdateOne {
-	if i != nil {
-		asuo.SetLastBattleTime(*i)
+func (asuo *AccountSnapshotUpdateOne) SetNillableLastBattleTime(t *time.Time) *AccountSnapshotUpdateOne {
+	if t != nil {
+		asuo.SetLastBattleTime(*t)
 	}
 	return asuo
 }
 
-// AddLastBattleTime adds i to the "last_battle_time" field.
-func (asuo *AccountSnapshotUpdateOne) AddLastBattleTime(i int64) *AccountSnapshotUpdateOne {
-	asuo.mutation.AddLastBattleTime(i)
-	return asuo
-}
-
 // SetReferenceID sets the "reference_id" field.
 func (asuo *AccountSnapshotUpdateOne) SetReferenceID(s string) *AccountSnapshotUpdateOne {
 	asuo.mutation.SetReferenceID(s)
@@ -492,6 +468,12 @@ func (asuo *AccountSnapshotUpdateOne) check() error {
 	return nil
 }
 
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (asuo *AccountSnapshotUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *AccountSnapshotUpdateOne {
+	asuo.modifiers = append(asuo.modifiers, modifiers...)
+	return asuo
+}
+
 func (asuo *AccountSnapshotUpdateOne) sqlSave(ctx context.Context) (_node *AccountSnapshot, err error) {
 	if err := asuo.check(); err != nil {
 		return _node, err
@@ -522,19 +504,13 @@ func (asuo *AccountSnapshotUpdateOne) sqlSave(ctx context.Context) (_node *Accou
 		}
 	}
 	if value, ok := asuo.mutation.UpdatedAt(); ok {
-		_spec.SetField(accountsnapshot.FieldUpdatedAt, field.TypeInt64, value)
-	}
-	if value, ok := asuo.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(accountsnapshot.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(accountsnapshot.FieldUpdatedAt, field.TypeTime, value)
 	}
 	if value, ok := asuo.mutation.GetType(); ok {
 		_spec.SetField(accountsnapshot.FieldType, field.TypeEnum, value)
 	}
 	if value, ok := asuo.mutation.LastBattleTime(); ok {
-		_spec.SetField(accountsnapshot.FieldLastBattleTime, field.TypeInt64, value)
-	}
-	if value, ok := asuo.mutation.AddedLastBattleTime(); ok {
-		_spec.AddField(accountsnapshot.FieldLastBattleTime, field.TypeInt64, value)
+		_spec.SetField(accountsnapshot.FieldLastBattleTime, field.TypeTime, value)
 	}
 	if value, ok := asuo.mutation.ReferenceID(); ok {
 		_spec.SetField(accountsnapshot.FieldReferenceID, field.TypeString, value)
@@ -557,6 +533,7 @@ func (asuo *AccountSnapshotUpdateOne) sqlSave(ctx context.Context) (_node *Accou
 	if value, ok := asuo.mutation.RegularFrame(); ok {
 		_spec.SetField(accountsnapshot.FieldRegularFrame, field.TypeJSON, value)
 	}
+	_spec.AddModifiers(asuo.modifiers...)
 	_node = &AccountSnapshot{config: asuo.config}
 	_spec.Assign = _node.assignValues
 	_spec.ScanValues = _node.scanValues
diff --git a/internal/database/ent/db/achievementssnapshot.go b/internal/database/ent/db/achievementssnapshot.go
index 6a16a84d..00969546 100644
--- a/internal/database/ent/db/achievementssnapshot.go
+++ b/internal/database/ent/db/achievementssnapshot.go
@@ -6,6 +6,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"strings"
+	"time"
 
 	"entgo.io/ent"
 	"entgo.io/ent/dialect/sql"
@@ -21,9 +22,9 @@ type AchievementsSnapshot struct {
 	// ID of the ent.
 	ID string `json:"id,omitempty"`
 	// CreatedAt holds the value of the "created_at" field.
-	CreatedAt int64 `json:"created_at,omitempty"`
+	CreatedAt time.Time `json:"created_at,omitempty"`
 	// UpdatedAt holds the value of the "updated_at" field.
-	UpdatedAt int64 `json:"updated_at,omitempty"`
+	UpdatedAt time.Time `json:"updated_at,omitempty"`
 	// Type holds the value of the "type" field.
 	Type models.SnapshotType `json:"type,omitempty"`
 	// AccountID holds the value of the "account_id" field.
@@ -33,7 +34,7 @@ type AchievementsSnapshot struct {
 	// Battles holds the value of the "battles" field.
 	Battles int `json:"battles,omitempty"`
 	// LastBattleTime holds the value of the "last_battle_time" field.
-	LastBattleTime int64 `json:"last_battle_time,omitempty"`
+	LastBattleTime time.Time `json:"last_battle_time,omitempty"`
 	// Data holds the value of the "data" field.
 	Data types.AchievementsFrame `json:"data,omitempty"`
 	// Edges holds the relations/edges for other nodes in the graph.
@@ -69,10 +70,12 @@ func (*AchievementsSnapshot) scanValues(columns []string) ([]any, error) {
 		switch columns[i] {
 		case achievementssnapshot.FieldData:
 			values[i] = new([]byte)
-		case achievementssnapshot.FieldCreatedAt, achievementssnapshot.FieldUpdatedAt, achievementssnapshot.FieldBattles, achievementssnapshot.FieldLastBattleTime:
+		case achievementssnapshot.FieldBattles:
 			values[i] = new(sql.NullInt64)
 		case achievementssnapshot.FieldID, achievementssnapshot.FieldType, achievementssnapshot.FieldAccountID, achievementssnapshot.FieldReferenceID:
 			values[i] = new(sql.NullString)
+		case achievementssnapshot.FieldCreatedAt, achievementssnapshot.FieldUpdatedAt, achievementssnapshot.FieldLastBattleTime:
+			values[i] = new(sql.NullTime)
 		default:
 			values[i] = new(sql.UnknownType)
 		}
@@ -95,16 +98,16 @@ func (as *AchievementsSnapshot) assignValues(columns []string, values []any) err
 				as.ID = value.String
 			}
 		case achievementssnapshot.FieldCreatedAt:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field created_at", values[i])
 			} else if value.Valid {
-				as.CreatedAt = value.Int64
+				as.CreatedAt = value.Time
 			}
 		case achievementssnapshot.FieldUpdatedAt:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
 			} else if value.Valid {
-				as.UpdatedAt = value.Int64
+				as.UpdatedAt = value.Time
 			}
 		case achievementssnapshot.FieldType:
 			if value, ok := values[i].(*sql.NullString); !ok {
@@ -131,10 +134,10 @@ func (as *AchievementsSnapshot) assignValues(columns []string, values []any) err
 				as.Battles = int(value.Int64)
 			}
 		case achievementssnapshot.FieldLastBattleTime:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field last_battle_time", values[i])
 			} else if value.Valid {
-				as.LastBattleTime = value.Int64
+				as.LastBattleTime = value.Time
 			}
 		case achievementssnapshot.FieldData:
 			if value, ok := values[i].(*[]byte); !ok {
@@ -186,10 +189,10 @@ func (as *AchievementsSnapshot) String() string {
 	builder.WriteString("AchievementsSnapshot(")
 	builder.WriteString(fmt.Sprintf("id=%v, ", as.ID))
 	builder.WriteString("created_at=")
-	builder.WriteString(fmt.Sprintf("%v", as.CreatedAt))
+	builder.WriteString(as.CreatedAt.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("updated_at=")
-	builder.WriteString(fmt.Sprintf("%v", as.UpdatedAt))
+	builder.WriteString(as.UpdatedAt.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("type=")
 	builder.WriteString(fmt.Sprintf("%v", as.Type))
@@ -204,7 +207,7 @@ func (as *AchievementsSnapshot) String() string {
 	builder.WriteString(fmt.Sprintf("%v", as.Battles))
 	builder.WriteString(", ")
 	builder.WriteString("last_battle_time=")
-	builder.WriteString(fmt.Sprintf("%v", as.LastBattleTime))
+	builder.WriteString(as.LastBattleTime.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("data=")
 	builder.WriteString(fmt.Sprintf("%v", as.Data))
diff --git a/internal/database/ent/db/achievementssnapshot/achievementssnapshot.go b/internal/database/ent/db/achievementssnapshot/achievementssnapshot.go
index 959b9e38..cad20938 100644
--- a/internal/database/ent/db/achievementssnapshot/achievementssnapshot.go
+++ b/internal/database/ent/db/achievementssnapshot/achievementssnapshot.go
@@ -4,6 +4,7 @@ package achievementssnapshot
 
 import (
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
@@ -69,11 +70,11 @@ func ValidColumn(column string) bool {
 
 var (
 	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
-	DefaultCreatedAt func() int64
+	DefaultCreatedAt func() time.Time
 	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
-	DefaultUpdatedAt func() int64
+	DefaultUpdatedAt func() time.Time
 	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
-	UpdateDefaultUpdatedAt func() int64
+	UpdateDefaultUpdatedAt func() time.Time
 	// AccountIDValidator is a validator for the "account_id" field. It is called by the builders before save.
 	AccountIDValidator func(string) error
 	// ReferenceIDValidator is a validator for the "reference_id" field. It is called by the builders before save.
diff --git a/internal/database/ent/db/achievementssnapshot/where.go b/internal/database/ent/db/achievementssnapshot/where.go
index 5d0bea81..3d3e0932 100644
--- a/internal/database/ent/db/achievementssnapshot/where.go
+++ b/internal/database/ent/db/achievementssnapshot/where.go
@@ -3,6 +3,8 @@
 package achievementssnapshot
 
 import (
+	"time"
+
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
@@ -65,12 +67,12 @@ func IDContainsFold(id string) predicate.AchievementsSnapshot {
 }
 
 // CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
-func CreatedAt(v int64) predicate.AchievementsSnapshot {
+func CreatedAt(v time.Time) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
-func UpdatedAt(v int64) predicate.AchievementsSnapshot {
+func UpdatedAt(v time.Time) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
@@ -90,87 +92,87 @@ func Battles(v int) predicate.AchievementsSnapshot {
 }
 
 // LastBattleTime applies equality check predicate on the "last_battle_time" field. It's identical to LastBattleTimeEQ.
-func LastBattleTime(v int64) predicate.AchievementsSnapshot {
+func LastBattleTime(v time.Time) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldLastBattleTime, v))
 }
 
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v int64) predicate.AchievementsSnapshot {
+func CreatedAtEQ(v time.Time) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v int64) predicate.AchievementsSnapshot {
+func CreatedAtNEQ(v time.Time) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldNEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...int64) predicate.AchievementsSnapshot {
+func CreatedAtIn(vs ...time.Time) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...int64) predicate.AchievementsSnapshot {
+func CreatedAtNotIn(vs ...time.Time) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldNotIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v int64) predicate.AchievementsSnapshot {
+func CreatedAtGT(v time.Time) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldGT(FieldCreatedAt, v))
 }
 
 // CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v int64) predicate.AchievementsSnapshot {
+func CreatedAtGTE(v time.Time) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldGTE(FieldCreatedAt, v))
 }
 
 // CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v int64) predicate.AchievementsSnapshot {
+func CreatedAtLT(v time.Time) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldLT(FieldCreatedAt, v))
 }
 
 // CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v int64) predicate.AchievementsSnapshot {
+func CreatedAtLTE(v time.Time) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldLTE(FieldCreatedAt, v))
 }
 
 // UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
-func UpdatedAtEQ(v int64) predicate.AchievementsSnapshot {
+func UpdatedAtEQ(v time.Time) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
-func UpdatedAtNEQ(v int64) predicate.AchievementsSnapshot {
+func UpdatedAtNEQ(v time.Time) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldNEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtIn applies the In predicate on the "updated_at" field.
-func UpdatedAtIn(vs ...int64) predicate.AchievementsSnapshot {
+func UpdatedAtIn(vs ...time.Time) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
-func UpdatedAtNotIn(vs ...int64) predicate.AchievementsSnapshot {
+func UpdatedAtNotIn(vs ...time.Time) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldNotIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtGT applies the GT predicate on the "updated_at" field.
-func UpdatedAtGT(v int64) predicate.AchievementsSnapshot {
+func UpdatedAtGT(v time.Time) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldGT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
-func UpdatedAtGTE(v int64) predicate.AchievementsSnapshot {
+func UpdatedAtGTE(v time.Time) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldGTE(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLT applies the LT predicate on the "updated_at" field.
-func UpdatedAtLT(v int64) predicate.AchievementsSnapshot {
+func UpdatedAtLT(v time.Time) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldLT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
-func UpdatedAtLTE(v int64) predicate.AchievementsSnapshot {
+func UpdatedAtLTE(v time.Time) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldLTE(FieldUpdatedAt, v))
 }
 
@@ -375,42 +377,42 @@ func BattlesLTE(v int) predicate.AchievementsSnapshot {
 }
 
 // LastBattleTimeEQ applies the EQ predicate on the "last_battle_time" field.
-func LastBattleTimeEQ(v int64) predicate.AchievementsSnapshot {
+func LastBattleTimeEQ(v time.Time) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeNEQ applies the NEQ predicate on the "last_battle_time" field.
-func LastBattleTimeNEQ(v int64) predicate.AchievementsSnapshot {
+func LastBattleTimeNEQ(v time.Time) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldNEQ(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeIn applies the In predicate on the "last_battle_time" field.
-func LastBattleTimeIn(vs ...int64) predicate.AchievementsSnapshot {
+func LastBattleTimeIn(vs ...time.Time) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldIn(FieldLastBattleTime, vs...))
 }
 
 // LastBattleTimeNotIn applies the NotIn predicate on the "last_battle_time" field.
-func LastBattleTimeNotIn(vs ...int64) predicate.AchievementsSnapshot {
+func LastBattleTimeNotIn(vs ...time.Time) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldNotIn(FieldLastBattleTime, vs...))
 }
 
 // LastBattleTimeGT applies the GT predicate on the "last_battle_time" field.
-func LastBattleTimeGT(v int64) predicate.AchievementsSnapshot {
+func LastBattleTimeGT(v time.Time) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldGT(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeGTE applies the GTE predicate on the "last_battle_time" field.
-func LastBattleTimeGTE(v int64) predicate.AchievementsSnapshot {
+func LastBattleTimeGTE(v time.Time) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldGTE(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeLT applies the LT predicate on the "last_battle_time" field.
-func LastBattleTimeLT(v int64) predicate.AchievementsSnapshot {
+func LastBattleTimeLT(v time.Time) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldLT(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeLTE applies the LTE predicate on the "last_battle_time" field.
-func LastBattleTimeLTE(v int64) predicate.AchievementsSnapshot {
+func LastBattleTimeLTE(v time.Time) predicate.AchievementsSnapshot {
 	return predicate.AchievementsSnapshot(sql.FieldLTE(FieldLastBattleTime, v))
 }
 
diff --git a/internal/database/ent/db/achievementssnapshot_create.go b/internal/database/ent/db/achievementssnapshot_create.go
index 7e18e271..86e3137d 100644
--- a/internal/database/ent/db/achievementssnapshot_create.go
+++ b/internal/database/ent/db/achievementssnapshot_create.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"entgo.io/ent/schema/field"
@@ -23,29 +24,29 @@ type AchievementsSnapshotCreate struct {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (asc *AchievementsSnapshotCreate) SetCreatedAt(i int64) *AchievementsSnapshotCreate {
-	asc.mutation.SetCreatedAt(i)
+func (asc *AchievementsSnapshotCreate) SetCreatedAt(t time.Time) *AchievementsSnapshotCreate {
+	asc.mutation.SetCreatedAt(t)
 	return asc
 }
 
 // SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
-func (asc *AchievementsSnapshotCreate) SetNillableCreatedAt(i *int64) *AchievementsSnapshotCreate {
-	if i != nil {
-		asc.SetCreatedAt(*i)
+func (asc *AchievementsSnapshotCreate) SetNillableCreatedAt(t *time.Time) *AchievementsSnapshotCreate {
+	if t != nil {
+		asc.SetCreatedAt(*t)
 	}
 	return asc
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (asc *AchievementsSnapshotCreate) SetUpdatedAt(i int64) *AchievementsSnapshotCreate {
-	asc.mutation.SetUpdatedAt(i)
+func (asc *AchievementsSnapshotCreate) SetUpdatedAt(t time.Time) *AchievementsSnapshotCreate {
+	asc.mutation.SetUpdatedAt(t)
 	return asc
 }
 
 // SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
-func (asc *AchievementsSnapshotCreate) SetNillableUpdatedAt(i *int64) *AchievementsSnapshotCreate {
-	if i != nil {
-		asc.SetUpdatedAt(*i)
+func (asc *AchievementsSnapshotCreate) SetNillableUpdatedAt(t *time.Time) *AchievementsSnapshotCreate {
+	if t != nil {
+		asc.SetUpdatedAt(*t)
 	}
 	return asc
 }
@@ -75,8 +76,8 @@ func (asc *AchievementsSnapshotCreate) SetBattles(i int) *AchievementsSnapshotCr
 }
 
 // SetLastBattleTime sets the "last_battle_time" field.
-func (asc *AchievementsSnapshotCreate) SetLastBattleTime(i int64) *AchievementsSnapshotCreate {
-	asc.mutation.SetLastBattleTime(i)
+func (asc *AchievementsSnapshotCreate) SetLastBattleTime(t time.Time) *AchievementsSnapshotCreate {
+	asc.mutation.SetLastBattleTime(t)
 	return asc
 }
 
@@ -234,11 +235,11 @@ func (asc *AchievementsSnapshotCreate) createSpec() (*AchievementsSnapshot, *sql
 		_spec.ID.Value = id
 	}
 	if value, ok := asc.mutation.CreatedAt(); ok {
-		_spec.SetField(achievementssnapshot.FieldCreatedAt, field.TypeInt64, value)
+		_spec.SetField(achievementssnapshot.FieldCreatedAt, field.TypeTime, value)
 		_node.CreatedAt = value
 	}
 	if value, ok := asc.mutation.UpdatedAt(); ok {
-		_spec.SetField(achievementssnapshot.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(achievementssnapshot.FieldUpdatedAt, field.TypeTime, value)
 		_node.UpdatedAt = value
 	}
 	if value, ok := asc.mutation.GetType(); ok {
@@ -254,7 +255,7 @@ func (asc *AchievementsSnapshotCreate) createSpec() (*AchievementsSnapshot, *sql
 		_node.Battles = value
 	}
 	if value, ok := asc.mutation.LastBattleTime(); ok {
-		_spec.SetField(achievementssnapshot.FieldLastBattleTime, field.TypeInt64, value)
+		_spec.SetField(achievementssnapshot.FieldLastBattleTime, field.TypeTime, value)
 		_node.LastBattleTime = value
 	}
 	if value, ok := asc.mutation.Data(); ok {
diff --git a/internal/database/ent/db/achievementssnapshot_query.go b/internal/database/ent/db/achievementssnapshot_query.go
index fa60ab7f..74fe01be 100644
--- a/internal/database/ent/db/achievementssnapshot_query.go
+++ b/internal/database/ent/db/achievementssnapshot_query.go
@@ -23,6 +23,7 @@ type AchievementsSnapshotQuery struct {
 	inters      []Interceptor
 	predicates  []predicate.AchievementsSnapshot
 	withAccount *AccountQuery
+	modifiers   []func(*sql.Selector)
 	// intermediate query (i.e. traversal path).
 	sql  *sql.Selector
 	path func(context.Context) (*sql.Selector, error)
@@ -297,7 +298,7 @@ func (asq *AchievementsSnapshotQuery) WithAccount(opts ...func(*AccountQuery)) *
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int64 `json:"created_at,omitempty"`
+//		CreatedAt time.Time `json:"created_at,omitempty"`
 //		Count int `json:"count,omitempty"`
 //	}
 //
@@ -320,7 +321,7 @@ func (asq *AchievementsSnapshotQuery) GroupBy(field string, fields ...string) *A
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int64 `json:"created_at,omitempty"`
+//		CreatedAt time.Time `json:"created_at,omitempty"`
 //	}
 //
 //	client.AchievementsSnapshot.Query().
@@ -382,6 +383,9 @@ func (asq *AchievementsSnapshotQuery) sqlAll(ctx context.Context, hooks ...query
 		node.Edges.loadedTypes = loadedTypes
 		return node.assignValues(columns, values)
 	}
+	if len(asq.modifiers) > 0 {
+		_spec.Modifiers = asq.modifiers
+	}
 	for i := range hooks {
 		hooks[i](ctx, _spec)
 	}
@@ -432,6 +436,9 @@ func (asq *AchievementsSnapshotQuery) loadAccount(ctx context.Context, query *Ac
 
 func (asq *AchievementsSnapshotQuery) sqlCount(ctx context.Context) (int, error) {
 	_spec := asq.querySpec()
+	if len(asq.modifiers) > 0 {
+		_spec.Modifiers = asq.modifiers
+	}
 	_spec.Node.Columns = asq.ctx.Fields
 	if len(asq.ctx.Fields) > 0 {
 		_spec.Unique = asq.ctx.Unique != nil && *asq.ctx.Unique
@@ -497,6 +504,9 @@ func (asq *AchievementsSnapshotQuery) sqlQuery(ctx context.Context) *sql.Selecto
 	if asq.ctx.Unique != nil && *asq.ctx.Unique {
 		selector.Distinct()
 	}
+	for _, m := range asq.modifiers {
+		m(selector)
+	}
 	for _, p := range asq.predicates {
 		p(selector)
 	}
@@ -514,6 +524,12 @@ func (asq *AchievementsSnapshotQuery) sqlQuery(ctx context.Context) *sql.Selecto
 	return selector
 }
 
+// Modify adds a query modifier for attaching custom logic to queries.
+func (asq *AchievementsSnapshotQuery) Modify(modifiers ...func(s *sql.Selector)) *AchievementsSnapshotSelect {
+	asq.modifiers = append(asq.modifiers, modifiers...)
+	return asq.Select()
+}
+
 // AchievementsSnapshotGroupBy is the group-by builder for AchievementsSnapshot entities.
 type AchievementsSnapshotGroupBy struct {
 	selector
@@ -603,3 +619,9 @@ func (ass *AchievementsSnapshotSelect) sqlScan(ctx context.Context, root *Achiev
 	defer rows.Close()
 	return sql.ScanSlice(rows, v)
 }
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (ass *AchievementsSnapshotSelect) Modify(modifiers ...func(s *sql.Selector)) *AchievementsSnapshotSelect {
+	ass.modifiers = append(ass.modifiers, modifiers...)
+	return ass
+}
diff --git a/internal/database/ent/db/achievementssnapshot_update.go b/internal/database/ent/db/achievementssnapshot_update.go
index 834089c4..43b79916 100644
--- a/internal/database/ent/db/achievementssnapshot_update.go
+++ b/internal/database/ent/db/achievementssnapshot_update.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
@@ -19,8 +20,9 @@ import (
 // AchievementsSnapshotUpdate is the builder for updating AchievementsSnapshot entities.
 type AchievementsSnapshotUpdate struct {
 	config
-	hooks    []Hook
-	mutation *AchievementsSnapshotMutation
+	hooks     []Hook
+	mutation  *AchievementsSnapshotMutation
+	modifiers []func(*sql.UpdateBuilder)
 }
 
 // Where appends a list predicates to the AchievementsSnapshotUpdate builder.
@@ -30,15 +32,8 @@ func (asu *AchievementsSnapshotUpdate) Where(ps ...predicate.AchievementsSnapsho
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (asu *AchievementsSnapshotUpdate) SetUpdatedAt(i int64) *AchievementsSnapshotUpdate {
-	asu.mutation.ResetUpdatedAt()
-	asu.mutation.SetUpdatedAt(i)
-	return asu
-}
-
-// AddUpdatedAt adds i to the "updated_at" field.
-func (asu *AchievementsSnapshotUpdate) AddUpdatedAt(i int64) *AchievementsSnapshotUpdate {
-	asu.mutation.AddUpdatedAt(i)
+func (asu *AchievementsSnapshotUpdate) SetUpdatedAt(t time.Time) *AchievementsSnapshotUpdate {
+	asu.mutation.SetUpdatedAt(t)
 	return asu
 }
 
@@ -92,26 +87,19 @@ func (asu *AchievementsSnapshotUpdate) AddBattles(i int) *AchievementsSnapshotUp
 }
 
 // SetLastBattleTime sets the "last_battle_time" field.
-func (asu *AchievementsSnapshotUpdate) SetLastBattleTime(i int64) *AchievementsSnapshotUpdate {
-	asu.mutation.ResetLastBattleTime()
-	asu.mutation.SetLastBattleTime(i)
+func (asu *AchievementsSnapshotUpdate) SetLastBattleTime(t time.Time) *AchievementsSnapshotUpdate {
+	asu.mutation.SetLastBattleTime(t)
 	return asu
 }
 
 // SetNillableLastBattleTime sets the "last_battle_time" field if the given value is not nil.
-func (asu *AchievementsSnapshotUpdate) SetNillableLastBattleTime(i *int64) *AchievementsSnapshotUpdate {
-	if i != nil {
-		asu.SetLastBattleTime(*i)
+func (asu *AchievementsSnapshotUpdate) SetNillableLastBattleTime(t *time.Time) *AchievementsSnapshotUpdate {
+	if t != nil {
+		asu.SetLastBattleTime(*t)
 	}
 	return asu
 }
 
-// AddLastBattleTime adds i to the "last_battle_time" field.
-func (asu *AchievementsSnapshotUpdate) AddLastBattleTime(i int64) *AchievementsSnapshotUpdate {
-	asu.mutation.AddLastBattleTime(i)
-	return asu
-}
-
 // SetData sets the "data" field.
 func (asu *AchievementsSnapshotUpdate) SetData(tf types.AchievementsFrame) *AchievementsSnapshotUpdate {
 	asu.mutation.SetData(tf)
@@ -185,6 +173,12 @@ func (asu *AchievementsSnapshotUpdate) check() error {
 	return nil
 }
 
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (asu *AchievementsSnapshotUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *AchievementsSnapshotUpdate {
+	asu.modifiers = append(asu.modifiers, modifiers...)
+	return asu
+}
+
 func (asu *AchievementsSnapshotUpdate) sqlSave(ctx context.Context) (n int, err error) {
 	if err := asu.check(); err != nil {
 		return n, err
@@ -198,10 +192,7 @@ func (asu *AchievementsSnapshotUpdate) sqlSave(ctx context.Context) (n int, err
 		}
 	}
 	if value, ok := asu.mutation.UpdatedAt(); ok {
-		_spec.SetField(achievementssnapshot.FieldUpdatedAt, field.TypeInt64, value)
-	}
-	if value, ok := asu.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(achievementssnapshot.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(achievementssnapshot.FieldUpdatedAt, field.TypeTime, value)
 	}
 	if value, ok := asu.mutation.GetType(); ok {
 		_spec.SetField(achievementssnapshot.FieldType, field.TypeEnum, value)
@@ -216,14 +207,12 @@ func (asu *AchievementsSnapshotUpdate) sqlSave(ctx context.Context) (n int, err
 		_spec.AddField(achievementssnapshot.FieldBattles, field.TypeInt, value)
 	}
 	if value, ok := asu.mutation.LastBattleTime(); ok {
-		_spec.SetField(achievementssnapshot.FieldLastBattleTime, field.TypeInt64, value)
-	}
-	if value, ok := asu.mutation.AddedLastBattleTime(); ok {
-		_spec.AddField(achievementssnapshot.FieldLastBattleTime, field.TypeInt64, value)
+		_spec.SetField(achievementssnapshot.FieldLastBattleTime, field.TypeTime, value)
 	}
 	if value, ok := asu.mutation.Data(); ok {
 		_spec.SetField(achievementssnapshot.FieldData, field.TypeJSON, value)
 	}
+	_spec.AddModifiers(asu.modifiers...)
 	if n, err = sqlgraph.UpdateNodes(ctx, asu.driver, _spec); err != nil {
 		if _, ok := err.(*sqlgraph.NotFoundError); ok {
 			err = &NotFoundError{achievementssnapshot.Label}
@@ -239,21 +228,15 @@ func (asu *AchievementsSnapshotUpdate) sqlSave(ctx context.Context) (n int, err
 // AchievementsSnapshotUpdateOne is the builder for updating a single AchievementsSnapshot entity.
 type AchievementsSnapshotUpdateOne struct {
 	config
-	fields   []string
-	hooks    []Hook
-	mutation *AchievementsSnapshotMutation
+	fields    []string
+	hooks     []Hook
+	mutation  *AchievementsSnapshotMutation
+	modifiers []func(*sql.UpdateBuilder)
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (asuo *AchievementsSnapshotUpdateOne) SetUpdatedAt(i int64) *AchievementsSnapshotUpdateOne {
-	asuo.mutation.ResetUpdatedAt()
-	asuo.mutation.SetUpdatedAt(i)
-	return asuo
-}
-
-// AddUpdatedAt adds i to the "updated_at" field.
-func (asuo *AchievementsSnapshotUpdateOne) AddUpdatedAt(i int64) *AchievementsSnapshotUpdateOne {
-	asuo.mutation.AddUpdatedAt(i)
+func (asuo *AchievementsSnapshotUpdateOne) SetUpdatedAt(t time.Time) *AchievementsSnapshotUpdateOne {
+	asuo.mutation.SetUpdatedAt(t)
 	return asuo
 }
 
@@ -307,26 +290,19 @@ func (asuo *AchievementsSnapshotUpdateOne) AddBattles(i int) *AchievementsSnapsh
 }
 
 // SetLastBattleTime sets the "last_battle_time" field.
-func (asuo *AchievementsSnapshotUpdateOne) SetLastBattleTime(i int64) *AchievementsSnapshotUpdateOne {
-	asuo.mutation.ResetLastBattleTime()
-	asuo.mutation.SetLastBattleTime(i)
+func (asuo *AchievementsSnapshotUpdateOne) SetLastBattleTime(t time.Time) *AchievementsSnapshotUpdateOne {
+	asuo.mutation.SetLastBattleTime(t)
 	return asuo
 }
 
 // SetNillableLastBattleTime sets the "last_battle_time" field if the given value is not nil.
-func (asuo *AchievementsSnapshotUpdateOne) SetNillableLastBattleTime(i *int64) *AchievementsSnapshotUpdateOne {
-	if i != nil {
-		asuo.SetLastBattleTime(*i)
+func (asuo *AchievementsSnapshotUpdateOne) SetNillableLastBattleTime(t *time.Time) *AchievementsSnapshotUpdateOne {
+	if t != nil {
+		asuo.SetLastBattleTime(*t)
 	}
 	return asuo
 }
 
-// AddLastBattleTime adds i to the "last_battle_time" field.
-func (asuo *AchievementsSnapshotUpdateOne) AddLastBattleTime(i int64) *AchievementsSnapshotUpdateOne {
-	asuo.mutation.AddLastBattleTime(i)
-	return asuo
-}
-
 // SetData sets the "data" field.
 func (asuo *AchievementsSnapshotUpdateOne) SetData(tf types.AchievementsFrame) *AchievementsSnapshotUpdateOne {
 	asuo.mutation.SetData(tf)
@@ -413,6 +389,12 @@ func (asuo *AchievementsSnapshotUpdateOne) check() error {
 	return nil
 }
 
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (asuo *AchievementsSnapshotUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *AchievementsSnapshotUpdateOne {
+	asuo.modifiers = append(asuo.modifiers, modifiers...)
+	return asuo
+}
+
 func (asuo *AchievementsSnapshotUpdateOne) sqlSave(ctx context.Context) (_node *AchievementsSnapshot, err error) {
 	if err := asuo.check(); err != nil {
 		return _node, err
@@ -443,10 +425,7 @@ func (asuo *AchievementsSnapshotUpdateOne) sqlSave(ctx context.Context) (_node *
 		}
 	}
 	if value, ok := asuo.mutation.UpdatedAt(); ok {
-		_spec.SetField(achievementssnapshot.FieldUpdatedAt, field.TypeInt64, value)
-	}
-	if value, ok := asuo.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(achievementssnapshot.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(achievementssnapshot.FieldUpdatedAt, field.TypeTime, value)
 	}
 	if value, ok := asuo.mutation.GetType(); ok {
 		_spec.SetField(achievementssnapshot.FieldType, field.TypeEnum, value)
@@ -461,14 +440,12 @@ func (asuo *AchievementsSnapshotUpdateOne) sqlSave(ctx context.Context) (_node *
 		_spec.AddField(achievementssnapshot.FieldBattles, field.TypeInt, value)
 	}
 	if value, ok := asuo.mutation.LastBattleTime(); ok {
-		_spec.SetField(achievementssnapshot.FieldLastBattleTime, field.TypeInt64, value)
-	}
-	if value, ok := asuo.mutation.AddedLastBattleTime(); ok {
-		_spec.AddField(achievementssnapshot.FieldLastBattleTime, field.TypeInt64, value)
+		_spec.SetField(achievementssnapshot.FieldLastBattleTime, field.TypeTime, value)
 	}
 	if value, ok := asuo.mutation.Data(); ok {
 		_spec.SetField(achievementssnapshot.FieldData, field.TypeJSON, value)
 	}
+	_spec.AddModifiers(asuo.modifiers...)
 	_node = &AchievementsSnapshot{config: asuo.config}
 	_spec.Assign = _node.assignValues
 	_spec.ScanValues = _node.scanValues
diff --git a/internal/database/ent/db/appconfiguration.go b/internal/database/ent/db/appconfiguration.go
index 5aaf0eb8..d88d93b1 100644
--- a/internal/database/ent/db/appconfiguration.go
+++ b/internal/database/ent/db/appconfiguration.go
@@ -6,6 +6,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"strings"
+	"time"
 
 	"entgo.io/ent"
 	"entgo.io/ent/dialect/sql"
@@ -18,9 +19,9 @@ type AppConfiguration struct {
 	// ID of the ent.
 	ID string `json:"id,omitempty"`
 	// CreatedAt holds the value of the "created_at" field.
-	CreatedAt int64 `json:"created_at,omitempty"`
+	CreatedAt time.Time `json:"created_at,omitempty"`
 	// UpdatedAt holds the value of the "updated_at" field.
-	UpdatedAt int64 `json:"updated_at,omitempty"`
+	UpdatedAt time.Time `json:"updated_at,omitempty"`
 	// Key holds the value of the "key" field.
 	Key string `json:"key,omitempty"`
 	// Value holds the value of the "value" field.
@@ -37,10 +38,10 @@ func (*AppConfiguration) scanValues(columns []string) ([]any, error) {
 		switch columns[i] {
 		case appconfiguration.FieldValue, appconfiguration.FieldMetadata:
 			values[i] = new([]byte)
-		case appconfiguration.FieldCreatedAt, appconfiguration.FieldUpdatedAt:
-			values[i] = new(sql.NullInt64)
 		case appconfiguration.FieldID, appconfiguration.FieldKey:
 			values[i] = new(sql.NullString)
+		case appconfiguration.FieldCreatedAt, appconfiguration.FieldUpdatedAt:
+			values[i] = new(sql.NullTime)
 		default:
 			values[i] = new(sql.UnknownType)
 		}
@@ -63,16 +64,16 @@ func (ac *AppConfiguration) assignValues(columns []string, values []any) error {
 				ac.ID = value.String
 			}
 		case appconfiguration.FieldCreatedAt:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field created_at", values[i])
 			} else if value.Valid {
-				ac.CreatedAt = value.Int64
+				ac.CreatedAt = value.Time
 			}
 		case appconfiguration.FieldUpdatedAt:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
 			} else if value.Valid {
-				ac.UpdatedAt = value.Int64
+				ac.UpdatedAt = value.Time
 			}
 		case appconfiguration.FieldKey:
 			if value, ok := values[i].(*sql.NullString); !ok {
@@ -133,10 +134,10 @@ func (ac *AppConfiguration) String() string {
 	builder.WriteString("AppConfiguration(")
 	builder.WriteString(fmt.Sprintf("id=%v, ", ac.ID))
 	builder.WriteString("created_at=")
-	builder.WriteString(fmt.Sprintf("%v", ac.CreatedAt))
+	builder.WriteString(ac.CreatedAt.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("updated_at=")
-	builder.WriteString(fmt.Sprintf("%v", ac.UpdatedAt))
+	builder.WriteString(ac.UpdatedAt.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("key=")
 	builder.WriteString(ac.Key)
diff --git a/internal/database/ent/db/appconfiguration/appconfiguration.go b/internal/database/ent/db/appconfiguration/appconfiguration.go
index facffdce..2f8076a5 100644
--- a/internal/database/ent/db/appconfiguration/appconfiguration.go
+++ b/internal/database/ent/db/appconfiguration/appconfiguration.go
@@ -3,6 +3,8 @@
 package appconfiguration
 
 import (
+	"time"
+
 	"entgo.io/ent/dialect/sql"
 )
 
@@ -47,11 +49,11 @@ func ValidColumn(column string) bool {
 
 var (
 	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
-	DefaultCreatedAt func() int64
+	DefaultCreatedAt func() time.Time
 	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
-	DefaultUpdatedAt func() int64
+	DefaultUpdatedAt func() time.Time
 	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
-	UpdateDefaultUpdatedAt func() int64
+	UpdateDefaultUpdatedAt func() time.Time
 	// KeyValidator is a validator for the "key" field. It is called by the builders before save.
 	KeyValidator func(string) error
 	// DefaultID holds the default value on creation for the "id" field.
diff --git a/internal/database/ent/db/appconfiguration/where.go b/internal/database/ent/db/appconfiguration/where.go
index 6d63474c..11bf5637 100644
--- a/internal/database/ent/db/appconfiguration/where.go
+++ b/internal/database/ent/db/appconfiguration/where.go
@@ -3,6 +3,8 @@
 package appconfiguration
 
 import (
+	"time"
+
 	"entgo.io/ent/dialect/sql"
 	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
 )
@@ -63,12 +65,12 @@ func IDContainsFold(id string) predicate.AppConfiguration {
 }
 
 // CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
-func CreatedAt(v int64) predicate.AppConfiguration {
+func CreatedAt(v time.Time) predicate.AppConfiguration {
 	return predicate.AppConfiguration(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
-func UpdatedAt(v int64) predicate.AppConfiguration {
+func UpdatedAt(v time.Time) predicate.AppConfiguration {
 	return predicate.AppConfiguration(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
@@ -78,82 +80,82 @@ func Key(v string) predicate.AppConfiguration {
 }
 
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v int64) predicate.AppConfiguration {
+func CreatedAtEQ(v time.Time) predicate.AppConfiguration {
 	return predicate.AppConfiguration(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v int64) predicate.AppConfiguration {
+func CreatedAtNEQ(v time.Time) predicate.AppConfiguration {
 	return predicate.AppConfiguration(sql.FieldNEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...int64) predicate.AppConfiguration {
+func CreatedAtIn(vs ...time.Time) predicate.AppConfiguration {
 	return predicate.AppConfiguration(sql.FieldIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...int64) predicate.AppConfiguration {
+func CreatedAtNotIn(vs ...time.Time) predicate.AppConfiguration {
 	return predicate.AppConfiguration(sql.FieldNotIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v int64) predicate.AppConfiguration {
+func CreatedAtGT(v time.Time) predicate.AppConfiguration {
 	return predicate.AppConfiguration(sql.FieldGT(FieldCreatedAt, v))
 }
 
 // CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v int64) predicate.AppConfiguration {
+func CreatedAtGTE(v time.Time) predicate.AppConfiguration {
 	return predicate.AppConfiguration(sql.FieldGTE(FieldCreatedAt, v))
 }
 
 // CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v int64) predicate.AppConfiguration {
+func CreatedAtLT(v time.Time) predicate.AppConfiguration {
 	return predicate.AppConfiguration(sql.FieldLT(FieldCreatedAt, v))
 }
 
 // CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v int64) predicate.AppConfiguration {
+func CreatedAtLTE(v time.Time) predicate.AppConfiguration {
 	return predicate.AppConfiguration(sql.FieldLTE(FieldCreatedAt, v))
 }
 
 // UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
-func UpdatedAtEQ(v int64) predicate.AppConfiguration {
+func UpdatedAtEQ(v time.Time) predicate.AppConfiguration {
 	return predicate.AppConfiguration(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
-func UpdatedAtNEQ(v int64) predicate.AppConfiguration {
+func UpdatedAtNEQ(v time.Time) predicate.AppConfiguration {
 	return predicate.AppConfiguration(sql.FieldNEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtIn applies the In predicate on the "updated_at" field.
-func UpdatedAtIn(vs ...int64) predicate.AppConfiguration {
+func UpdatedAtIn(vs ...time.Time) predicate.AppConfiguration {
 	return predicate.AppConfiguration(sql.FieldIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
-func UpdatedAtNotIn(vs ...int64) predicate.AppConfiguration {
+func UpdatedAtNotIn(vs ...time.Time) predicate.AppConfiguration {
 	return predicate.AppConfiguration(sql.FieldNotIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtGT applies the GT predicate on the "updated_at" field.
-func UpdatedAtGT(v int64) predicate.AppConfiguration {
+func UpdatedAtGT(v time.Time) predicate.AppConfiguration {
 	return predicate.AppConfiguration(sql.FieldGT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
-func UpdatedAtGTE(v int64) predicate.AppConfiguration {
+func UpdatedAtGTE(v time.Time) predicate.AppConfiguration {
 	return predicate.AppConfiguration(sql.FieldGTE(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLT applies the LT predicate on the "updated_at" field.
-func UpdatedAtLT(v int64) predicate.AppConfiguration {
+func UpdatedAtLT(v time.Time) predicate.AppConfiguration {
 	return predicate.AppConfiguration(sql.FieldLT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
-func UpdatedAtLTE(v int64) predicate.AppConfiguration {
+func UpdatedAtLTE(v time.Time) predicate.AppConfiguration {
 	return predicate.AppConfiguration(sql.FieldLTE(FieldUpdatedAt, v))
 }
 
diff --git a/internal/database/ent/db/appconfiguration_create.go b/internal/database/ent/db/appconfiguration_create.go
index c6a9c349..2a3c9e91 100644
--- a/internal/database/ent/db/appconfiguration_create.go
+++ b/internal/database/ent/db/appconfiguration_create.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"entgo.io/ent/schema/field"
@@ -20,29 +21,29 @@ type AppConfigurationCreate struct {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (acc *AppConfigurationCreate) SetCreatedAt(i int64) *AppConfigurationCreate {
-	acc.mutation.SetCreatedAt(i)
+func (acc *AppConfigurationCreate) SetCreatedAt(t time.Time) *AppConfigurationCreate {
+	acc.mutation.SetCreatedAt(t)
 	return acc
 }
 
 // SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
-func (acc *AppConfigurationCreate) SetNillableCreatedAt(i *int64) *AppConfigurationCreate {
-	if i != nil {
-		acc.SetCreatedAt(*i)
+func (acc *AppConfigurationCreate) SetNillableCreatedAt(t *time.Time) *AppConfigurationCreate {
+	if t != nil {
+		acc.SetCreatedAt(*t)
 	}
 	return acc
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (acc *AppConfigurationCreate) SetUpdatedAt(i int64) *AppConfigurationCreate {
-	acc.mutation.SetUpdatedAt(i)
+func (acc *AppConfigurationCreate) SetUpdatedAt(t time.Time) *AppConfigurationCreate {
+	acc.mutation.SetUpdatedAt(t)
 	return acc
 }
 
 // SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
-func (acc *AppConfigurationCreate) SetNillableUpdatedAt(i *int64) *AppConfigurationCreate {
-	if i != nil {
-		acc.SetUpdatedAt(*i)
+func (acc *AppConfigurationCreate) SetNillableUpdatedAt(t *time.Time) *AppConfigurationCreate {
+	if t != nil {
+		acc.SetUpdatedAt(*t)
 	}
 	return acc
 }
@@ -183,11 +184,11 @@ func (acc *AppConfigurationCreate) createSpec() (*AppConfiguration, *sqlgraph.Cr
 		_spec.ID.Value = id
 	}
 	if value, ok := acc.mutation.CreatedAt(); ok {
-		_spec.SetField(appconfiguration.FieldCreatedAt, field.TypeInt64, value)
+		_spec.SetField(appconfiguration.FieldCreatedAt, field.TypeTime, value)
 		_node.CreatedAt = value
 	}
 	if value, ok := acc.mutation.UpdatedAt(); ok {
-		_spec.SetField(appconfiguration.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(appconfiguration.FieldUpdatedAt, field.TypeTime, value)
 		_node.UpdatedAt = value
 	}
 	if value, ok := acc.mutation.Key(); ok {
diff --git a/internal/database/ent/db/appconfiguration_query.go b/internal/database/ent/db/appconfiguration_query.go
index 759954bb..530965f1 100644
--- a/internal/database/ent/db/appconfiguration_query.go
+++ b/internal/database/ent/db/appconfiguration_query.go
@@ -21,6 +21,7 @@ type AppConfigurationQuery struct {
 	order      []appconfiguration.OrderOption
 	inters     []Interceptor
 	predicates []predicate.AppConfiguration
+	modifiers  []func(*sql.Selector)
 	// intermediate query (i.e. traversal path).
 	sql  *sql.Selector
 	path func(context.Context) (*sql.Selector, error)
@@ -261,7 +262,7 @@ func (acq *AppConfigurationQuery) Clone() *AppConfigurationQuery {
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int64 `json:"created_at,omitempty"`
+//		CreatedAt time.Time `json:"created_at,omitempty"`
 //		Count int `json:"count,omitempty"`
 //	}
 //
@@ -284,7 +285,7 @@ func (acq *AppConfigurationQuery) GroupBy(field string, fields ...string) *AppCo
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int64 `json:"created_at,omitempty"`
+//		CreatedAt time.Time `json:"created_at,omitempty"`
 //	}
 //
 //	client.AppConfiguration.Query().
@@ -342,6 +343,9 @@ func (acq *AppConfigurationQuery) sqlAll(ctx context.Context, hooks ...queryHook
 		nodes = append(nodes, node)
 		return node.assignValues(columns, values)
 	}
+	if len(acq.modifiers) > 0 {
+		_spec.Modifiers = acq.modifiers
+	}
 	for i := range hooks {
 		hooks[i](ctx, _spec)
 	}
@@ -356,6 +360,9 @@ func (acq *AppConfigurationQuery) sqlAll(ctx context.Context, hooks ...queryHook
 
 func (acq *AppConfigurationQuery) sqlCount(ctx context.Context) (int, error) {
 	_spec := acq.querySpec()
+	if len(acq.modifiers) > 0 {
+		_spec.Modifiers = acq.modifiers
+	}
 	_spec.Node.Columns = acq.ctx.Fields
 	if len(acq.ctx.Fields) > 0 {
 		_spec.Unique = acq.ctx.Unique != nil && *acq.ctx.Unique
@@ -418,6 +425,9 @@ func (acq *AppConfigurationQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	if acq.ctx.Unique != nil && *acq.ctx.Unique {
 		selector.Distinct()
 	}
+	for _, m := range acq.modifiers {
+		m(selector)
+	}
 	for _, p := range acq.predicates {
 		p(selector)
 	}
@@ -435,6 +445,12 @@ func (acq *AppConfigurationQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	return selector
 }
 
+// Modify adds a query modifier for attaching custom logic to queries.
+func (acq *AppConfigurationQuery) Modify(modifiers ...func(s *sql.Selector)) *AppConfigurationSelect {
+	acq.modifiers = append(acq.modifiers, modifiers...)
+	return acq.Select()
+}
+
 // AppConfigurationGroupBy is the group-by builder for AppConfiguration entities.
 type AppConfigurationGroupBy struct {
 	selector
@@ -524,3 +540,9 @@ func (acs *AppConfigurationSelect) sqlScan(ctx context.Context, root *AppConfigu
 	defer rows.Close()
 	return sql.ScanSlice(rows, v)
 }
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (acs *AppConfigurationSelect) Modify(modifiers ...func(s *sql.Selector)) *AppConfigurationSelect {
+	acs.modifiers = append(acs.modifiers, modifiers...)
+	return acs
+}
diff --git a/internal/database/ent/db/appconfiguration_update.go b/internal/database/ent/db/appconfiguration_update.go
index 12994e32..2da9b3d1 100644
--- a/internal/database/ent/db/appconfiguration_update.go
+++ b/internal/database/ent/db/appconfiguration_update.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
@@ -17,8 +18,9 @@ import (
 // AppConfigurationUpdate is the builder for updating AppConfiguration entities.
 type AppConfigurationUpdate struct {
 	config
-	hooks    []Hook
-	mutation *AppConfigurationMutation
+	hooks     []Hook
+	mutation  *AppConfigurationMutation
+	modifiers []func(*sql.UpdateBuilder)
 }
 
 // Where appends a list predicates to the AppConfigurationUpdate builder.
@@ -28,15 +30,8 @@ func (acu *AppConfigurationUpdate) Where(ps ...predicate.AppConfiguration) *AppC
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (acu *AppConfigurationUpdate) SetUpdatedAt(i int64) *AppConfigurationUpdate {
-	acu.mutation.ResetUpdatedAt()
-	acu.mutation.SetUpdatedAt(i)
-	return acu
-}
-
-// AddUpdatedAt adds i to the "updated_at" field.
-func (acu *AppConfigurationUpdate) AddUpdatedAt(i int64) *AppConfigurationUpdate {
-	acu.mutation.AddUpdatedAt(i)
+func (acu *AppConfigurationUpdate) SetUpdatedAt(t time.Time) *AppConfigurationUpdate {
+	acu.mutation.SetUpdatedAt(t)
 	return acu
 }
 
@@ -123,6 +118,12 @@ func (acu *AppConfigurationUpdate) check() error {
 	return nil
 }
 
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (acu *AppConfigurationUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *AppConfigurationUpdate {
+	acu.modifiers = append(acu.modifiers, modifiers...)
+	return acu
+}
+
 func (acu *AppConfigurationUpdate) sqlSave(ctx context.Context) (n int, err error) {
 	if err := acu.check(); err != nil {
 		return n, err
@@ -136,10 +137,7 @@ func (acu *AppConfigurationUpdate) sqlSave(ctx context.Context) (n int, err erro
 		}
 	}
 	if value, ok := acu.mutation.UpdatedAt(); ok {
-		_spec.SetField(appconfiguration.FieldUpdatedAt, field.TypeInt64, value)
-	}
-	if value, ok := acu.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(appconfiguration.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(appconfiguration.FieldUpdatedAt, field.TypeTime, value)
 	}
 	if value, ok := acu.mutation.Key(); ok {
 		_spec.SetField(appconfiguration.FieldKey, field.TypeString, value)
@@ -153,6 +151,7 @@ func (acu *AppConfigurationUpdate) sqlSave(ctx context.Context) (n int, err erro
 	if acu.mutation.MetadataCleared() {
 		_spec.ClearField(appconfiguration.FieldMetadata, field.TypeJSON)
 	}
+	_spec.AddModifiers(acu.modifiers...)
 	if n, err = sqlgraph.UpdateNodes(ctx, acu.driver, _spec); err != nil {
 		if _, ok := err.(*sqlgraph.NotFoundError); ok {
 			err = &NotFoundError{appconfiguration.Label}
@@ -168,21 +167,15 @@ func (acu *AppConfigurationUpdate) sqlSave(ctx context.Context) (n int, err erro
 // AppConfigurationUpdateOne is the builder for updating a single AppConfiguration entity.
 type AppConfigurationUpdateOne struct {
 	config
-	fields   []string
-	hooks    []Hook
-	mutation *AppConfigurationMutation
+	fields    []string
+	hooks     []Hook
+	mutation  *AppConfigurationMutation
+	modifiers []func(*sql.UpdateBuilder)
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (acuo *AppConfigurationUpdateOne) SetUpdatedAt(i int64) *AppConfigurationUpdateOne {
-	acuo.mutation.ResetUpdatedAt()
-	acuo.mutation.SetUpdatedAt(i)
-	return acuo
-}
-
-// AddUpdatedAt adds i to the "updated_at" field.
-func (acuo *AppConfigurationUpdateOne) AddUpdatedAt(i int64) *AppConfigurationUpdateOne {
-	acuo.mutation.AddUpdatedAt(i)
+func (acuo *AppConfigurationUpdateOne) SetUpdatedAt(t time.Time) *AppConfigurationUpdateOne {
+	acuo.mutation.SetUpdatedAt(t)
 	return acuo
 }
 
@@ -282,6 +275,12 @@ func (acuo *AppConfigurationUpdateOne) check() error {
 	return nil
 }
 
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (acuo *AppConfigurationUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *AppConfigurationUpdateOne {
+	acuo.modifiers = append(acuo.modifiers, modifiers...)
+	return acuo
+}
+
 func (acuo *AppConfigurationUpdateOne) sqlSave(ctx context.Context) (_node *AppConfiguration, err error) {
 	if err := acuo.check(); err != nil {
 		return _node, err
@@ -312,10 +311,7 @@ func (acuo *AppConfigurationUpdateOne) sqlSave(ctx context.Context) (_node *AppC
 		}
 	}
 	if value, ok := acuo.mutation.UpdatedAt(); ok {
-		_spec.SetField(appconfiguration.FieldUpdatedAt, field.TypeInt64, value)
-	}
-	if value, ok := acuo.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(appconfiguration.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(appconfiguration.FieldUpdatedAt, field.TypeTime, value)
 	}
 	if value, ok := acuo.mutation.Key(); ok {
 		_spec.SetField(appconfiguration.FieldKey, field.TypeString, value)
@@ -329,6 +325,7 @@ func (acuo *AppConfigurationUpdateOne) sqlSave(ctx context.Context) (_node *AppC
 	if acuo.mutation.MetadataCleared() {
 		_spec.ClearField(appconfiguration.FieldMetadata, field.TypeJSON)
 	}
+	_spec.AddModifiers(acuo.modifiers...)
 	_node = &AppConfiguration{config: acuo.config}
 	_spec.Assign = _node.assignValues
 	_spec.ScanValues = _node.scanValues
diff --git a/internal/database/ent/db/applicationcommand.go b/internal/database/ent/db/applicationcommand.go
index 0ba69869..88016dc0 100644
--- a/internal/database/ent/db/applicationcommand.go
+++ b/internal/database/ent/db/applicationcommand.go
@@ -5,6 +5,7 @@ package db
 import (
 	"fmt"
 	"strings"
+	"time"
 
 	"entgo.io/ent"
 	"entgo.io/ent/dialect/sql"
@@ -17,9 +18,9 @@ type ApplicationCommand struct {
 	// ID of the ent.
 	ID string `json:"id,omitempty"`
 	// CreatedAt holds the value of the "created_at" field.
-	CreatedAt int64 `json:"created_at,omitempty"`
+	CreatedAt time.Time `json:"created_at,omitempty"`
 	// UpdatedAt holds the value of the "updated_at" field.
-	UpdatedAt int64 `json:"updated_at,omitempty"`
+	UpdatedAt time.Time `json:"updated_at,omitempty"`
 	// Name holds the value of the "name" field.
 	Name string `json:"name,omitempty"`
 	// Version holds the value of the "version" field.
@@ -34,10 +35,10 @@ func (*ApplicationCommand) scanValues(columns []string) ([]any, error) {
 	values := make([]any, len(columns))
 	for i := range columns {
 		switch columns[i] {
-		case applicationcommand.FieldCreatedAt, applicationcommand.FieldUpdatedAt:
-			values[i] = new(sql.NullInt64)
 		case applicationcommand.FieldID, applicationcommand.FieldName, applicationcommand.FieldVersion, applicationcommand.FieldOptionsHash:
 			values[i] = new(sql.NullString)
+		case applicationcommand.FieldCreatedAt, applicationcommand.FieldUpdatedAt:
+			values[i] = new(sql.NullTime)
 		default:
 			values[i] = new(sql.UnknownType)
 		}
@@ -60,16 +61,16 @@ func (ac *ApplicationCommand) assignValues(columns []string, values []any) error
 				ac.ID = value.String
 			}
 		case applicationcommand.FieldCreatedAt:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field created_at", values[i])
 			} else if value.Valid {
-				ac.CreatedAt = value.Int64
+				ac.CreatedAt = value.Time
 			}
 		case applicationcommand.FieldUpdatedAt:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
 			} else if value.Valid {
-				ac.UpdatedAt = value.Int64
+				ac.UpdatedAt = value.Time
 			}
 		case applicationcommand.FieldName:
 			if value, ok := values[i].(*sql.NullString); !ok {
@@ -126,10 +127,10 @@ func (ac *ApplicationCommand) String() string {
 	builder.WriteString("ApplicationCommand(")
 	builder.WriteString(fmt.Sprintf("id=%v, ", ac.ID))
 	builder.WriteString("created_at=")
-	builder.WriteString(fmt.Sprintf("%v", ac.CreatedAt))
+	builder.WriteString(ac.CreatedAt.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("updated_at=")
-	builder.WriteString(fmt.Sprintf("%v", ac.UpdatedAt))
+	builder.WriteString(ac.UpdatedAt.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("name=")
 	builder.WriteString(ac.Name)
diff --git a/internal/database/ent/db/applicationcommand/applicationcommand.go b/internal/database/ent/db/applicationcommand/applicationcommand.go
index 4e67599d..d2885b61 100644
--- a/internal/database/ent/db/applicationcommand/applicationcommand.go
+++ b/internal/database/ent/db/applicationcommand/applicationcommand.go
@@ -3,6 +3,8 @@
 package applicationcommand
 
 import (
+	"time"
+
 	"entgo.io/ent/dialect/sql"
 )
 
@@ -47,11 +49,11 @@ func ValidColumn(column string) bool {
 
 var (
 	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
-	DefaultCreatedAt func() int64
+	DefaultCreatedAt func() time.Time
 	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
-	DefaultUpdatedAt func() int64
+	DefaultUpdatedAt func() time.Time
 	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
-	UpdateDefaultUpdatedAt func() int64
+	UpdateDefaultUpdatedAt func() time.Time
 	// NameValidator is a validator for the "name" field. It is called by the builders before save.
 	NameValidator func(string) error
 	// VersionValidator is a validator for the "version" field. It is called by the builders before save.
diff --git a/internal/database/ent/db/applicationcommand/where.go b/internal/database/ent/db/applicationcommand/where.go
index 81486987..d9b36efd 100644
--- a/internal/database/ent/db/applicationcommand/where.go
+++ b/internal/database/ent/db/applicationcommand/where.go
@@ -3,6 +3,8 @@
 package applicationcommand
 
 import (
+	"time"
+
 	"entgo.io/ent/dialect/sql"
 	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
 )
@@ -63,12 +65,12 @@ func IDContainsFold(id string) predicate.ApplicationCommand {
 }
 
 // CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
-func CreatedAt(v int64) predicate.ApplicationCommand {
+func CreatedAt(v time.Time) predicate.ApplicationCommand {
 	return predicate.ApplicationCommand(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
-func UpdatedAt(v int64) predicate.ApplicationCommand {
+func UpdatedAt(v time.Time) predicate.ApplicationCommand {
 	return predicate.ApplicationCommand(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
@@ -88,82 +90,82 @@ func OptionsHash(v string) predicate.ApplicationCommand {
 }
 
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v int64) predicate.ApplicationCommand {
+func CreatedAtEQ(v time.Time) predicate.ApplicationCommand {
 	return predicate.ApplicationCommand(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v int64) predicate.ApplicationCommand {
+func CreatedAtNEQ(v time.Time) predicate.ApplicationCommand {
 	return predicate.ApplicationCommand(sql.FieldNEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...int64) predicate.ApplicationCommand {
+func CreatedAtIn(vs ...time.Time) predicate.ApplicationCommand {
 	return predicate.ApplicationCommand(sql.FieldIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...int64) predicate.ApplicationCommand {
+func CreatedAtNotIn(vs ...time.Time) predicate.ApplicationCommand {
 	return predicate.ApplicationCommand(sql.FieldNotIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v int64) predicate.ApplicationCommand {
+func CreatedAtGT(v time.Time) predicate.ApplicationCommand {
 	return predicate.ApplicationCommand(sql.FieldGT(FieldCreatedAt, v))
 }
 
 // CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v int64) predicate.ApplicationCommand {
+func CreatedAtGTE(v time.Time) predicate.ApplicationCommand {
 	return predicate.ApplicationCommand(sql.FieldGTE(FieldCreatedAt, v))
 }
 
 // CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v int64) predicate.ApplicationCommand {
+func CreatedAtLT(v time.Time) predicate.ApplicationCommand {
 	return predicate.ApplicationCommand(sql.FieldLT(FieldCreatedAt, v))
 }
 
 // CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v int64) predicate.ApplicationCommand {
+func CreatedAtLTE(v time.Time) predicate.ApplicationCommand {
 	return predicate.ApplicationCommand(sql.FieldLTE(FieldCreatedAt, v))
 }
 
 // UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
-func UpdatedAtEQ(v int64) predicate.ApplicationCommand {
+func UpdatedAtEQ(v time.Time) predicate.ApplicationCommand {
 	return predicate.ApplicationCommand(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
-func UpdatedAtNEQ(v int64) predicate.ApplicationCommand {
+func UpdatedAtNEQ(v time.Time) predicate.ApplicationCommand {
 	return predicate.ApplicationCommand(sql.FieldNEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtIn applies the In predicate on the "updated_at" field.
-func UpdatedAtIn(vs ...int64) predicate.ApplicationCommand {
+func UpdatedAtIn(vs ...time.Time) predicate.ApplicationCommand {
 	return predicate.ApplicationCommand(sql.FieldIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
-func UpdatedAtNotIn(vs ...int64) predicate.ApplicationCommand {
+func UpdatedAtNotIn(vs ...time.Time) predicate.ApplicationCommand {
 	return predicate.ApplicationCommand(sql.FieldNotIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtGT applies the GT predicate on the "updated_at" field.
-func UpdatedAtGT(v int64) predicate.ApplicationCommand {
+func UpdatedAtGT(v time.Time) predicate.ApplicationCommand {
 	return predicate.ApplicationCommand(sql.FieldGT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
-func UpdatedAtGTE(v int64) predicate.ApplicationCommand {
+func UpdatedAtGTE(v time.Time) predicate.ApplicationCommand {
 	return predicate.ApplicationCommand(sql.FieldGTE(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLT applies the LT predicate on the "updated_at" field.
-func UpdatedAtLT(v int64) predicate.ApplicationCommand {
+func UpdatedAtLT(v time.Time) predicate.ApplicationCommand {
 	return predicate.ApplicationCommand(sql.FieldLT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
-func UpdatedAtLTE(v int64) predicate.ApplicationCommand {
+func UpdatedAtLTE(v time.Time) predicate.ApplicationCommand {
 	return predicate.ApplicationCommand(sql.FieldLTE(FieldUpdatedAt, v))
 }
 
diff --git a/internal/database/ent/db/applicationcommand_create.go b/internal/database/ent/db/applicationcommand_create.go
index 830a457d..903f6337 100644
--- a/internal/database/ent/db/applicationcommand_create.go
+++ b/internal/database/ent/db/applicationcommand_create.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"entgo.io/ent/schema/field"
@@ -20,29 +21,29 @@ type ApplicationCommandCreate struct {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (acc *ApplicationCommandCreate) SetCreatedAt(i int64) *ApplicationCommandCreate {
-	acc.mutation.SetCreatedAt(i)
+func (acc *ApplicationCommandCreate) SetCreatedAt(t time.Time) *ApplicationCommandCreate {
+	acc.mutation.SetCreatedAt(t)
 	return acc
 }
 
 // SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
-func (acc *ApplicationCommandCreate) SetNillableCreatedAt(i *int64) *ApplicationCommandCreate {
-	if i != nil {
-		acc.SetCreatedAt(*i)
+func (acc *ApplicationCommandCreate) SetNillableCreatedAt(t *time.Time) *ApplicationCommandCreate {
+	if t != nil {
+		acc.SetCreatedAt(*t)
 	}
 	return acc
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (acc *ApplicationCommandCreate) SetUpdatedAt(i int64) *ApplicationCommandCreate {
-	acc.mutation.SetUpdatedAt(i)
+func (acc *ApplicationCommandCreate) SetUpdatedAt(t time.Time) *ApplicationCommandCreate {
+	acc.mutation.SetUpdatedAt(t)
 	return acc
 }
 
 // SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
-func (acc *ApplicationCommandCreate) SetNillableUpdatedAt(i *int64) *ApplicationCommandCreate {
-	if i != nil {
-		acc.SetUpdatedAt(*i)
+func (acc *ApplicationCommandCreate) SetNillableUpdatedAt(t *time.Time) *ApplicationCommandCreate {
+	if t != nil {
+		acc.SetUpdatedAt(*t)
 	}
 	return acc
 }
@@ -196,11 +197,11 @@ func (acc *ApplicationCommandCreate) createSpec() (*ApplicationCommand, *sqlgrap
 		_spec.ID.Value = id
 	}
 	if value, ok := acc.mutation.CreatedAt(); ok {
-		_spec.SetField(applicationcommand.FieldCreatedAt, field.TypeInt64, value)
+		_spec.SetField(applicationcommand.FieldCreatedAt, field.TypeTime, value)
 		_node.CreatedAt = value
 	}
 	if value, ok := acc.mutation.UpdatedAt(); ok {
-		_spec.SetField(applicationcommand.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(applicationcommand.FieldUpdatedAt, field.TypeTime, value)
 		_node.UpdatedAt = value
 	}
 	if value, ok := acc.mutation.Name(); ok {
diff --git a/internal/database/ent/db/applicationcommand_query.go b/internal/database/ent/db/applicationcommand_query.go
index 5bd7757c..f20b8ac6 100644
--- a/internal/database/ent/db/applicationcommand_query.go
+++ b/internal/database/ent/db/applicationcommand_query.go
@@ -21,6 +21,7 @@ type ApplicationCommandQuery struct {
 	order      []applicationcommand.OrderOption
 	inters     []Interceptor
 	predicates []predicate.ApplicationCommand
+	modifiers  []func(*sql.Selector)
 	// intermediate query (i.e. traversal path).
 	sql  *sql.Selector
 	path func(context.Context) (*sql.Selector, error)
@@ -261,7 +262,7 @@ func (acq *ApplicationCommandQuery) Clone() *ApplicationCommandQuery {
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int64 `json:"created_at,omitempty"`
+//		CreatedAt time.Time `json:"created_at,omitempty"`
 //		Count int `json:"count,omitempty"`
 //	}
 //
@@ -284,7 +285,7 @@ func (acq *ApplicationCommandQuery) GroupBy(field string, fields ...string) *App
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int64 `json:"created_at,omitempty"`
+//		CreatedAt time.Time `json:"created_at,omitempty"`
 //	}
 //
 //	client.ApplicationCommand.Query().
@@ -342,6 +343,9 @@ func (acq *ApplicationCommandQuery) sqlAll(ctx context.Context, hooks ...queryHo
 		nodes = append(nodes, node)
 		return node.assignValues(columns, values)
 	}
+	if len(acq.modifiers) > 0 {
+		_spec.Modifiers = acq.modifiers
+	}
 	for i := range hooks {
 		hooks[i](ctx, _spec)
 	}
@@ -356,6 +360,9 @@ func (acq *ApplicationCommandQuery) sqlAll(ctx context.Context, hooks ...queryHo
 
 func (acq *ApplicationCommandQuery) sqlCount(ctx context.Context) (int, error) {
 	_spec := acq.querySpec()
+	if len(acq.modifiers) > 0 {
+		_spec.Modifiers = acq.modifiers
+	}
 	_spec.Node.Columns = acq.ctx.Fields
 	if len(acq.ctx.Fields) > 0 {
 		_spec.Unique = acq.ctx.Unique != nil && *acq.ctx.Unique
@@ -418,6 +425,9 @@ func (acq *ApplicationCommandQuery) sqlQuery(ctx context.Context) *sql.Selector
 	if acq.ctx.Unique != nil && *acq.ctx.Unique {
 		selector.Distinct()
 	}
+	for _, m := range acq.modifiers {
+		m(selector)
+	}
 	for _, p := range acq.predicates {
 		p(selector)
 	}
@@ -435,6 +445,12 @@ func (acq *ApplicationCommandQuery) sqlQuery(ctx context.Context) *sql.Selector
 	return selector
 }
 
+// Modify adds a query modifier for attaching custom logic to queries.
+func (acq *ApplicationCommandQuery) Modify(modifiers ...func(s *sql.Selector)) *ApplicationCommandSelect {
+	acq.modifiers = append(acq.modifiers, modifiers...)
+	return acq.Select()
+}
+
 // ApplicationCommandGroupBy is the group-by builder for ApplicationCommand entities.
 type ApplicationCommandGroupBy struct {
 	selector
@@ -524,3 +540,9 @@ func (acs *ApplicationCommandSelect) sqlScan(ctx context.Context, root *Applicat
 	defer rows.Close()
 	return sql.ScanSlice(rows, v)
 }
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (acs *ApplicationCommandSelect) Modify(modifiers ...func(s *sql.Selector)) *ApplicationCommandSelect {
+	acs.modifiers = append(acs.modifiers, modifiers...)
+	return acs
+}
diff --git a/internal/database/ent/db/applicationcommand_update.go b/internal/database/ent/db/applicationcommand_update.go
index f681b841..58829e30 100644
--- a/internal/database/ent/db/applicationcommand_update.go
+++ b/internal/database/ent/db/applicationcommand_update.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
@@ -17,8 +18,9 @@ import (
 // ApplicationCommandUpdate is the builder for updating ApplicationCommand entities.
 type ApplicationCommandUpdate struct {
 	config
-	hooks    []Hook
-	mutation *ApplicationCommandMutation
+	hooks     []Hook
+	mutation  *ApplicationCommandMutation
+	modifiers []func(*sql.UpdateBuilder)
 }
 
 // Where appends a list predicates to the ApplicationCommandUpdate builder.
@@ -28,15 +30,8 @@ func (acu *ApplicationCommandUpdate) Where(ps ...predicate.ApplicationCommand) *
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (acu *ApplicationCommandUpdate) SetUpdatedAt(i int64) *ApplicationCommandUpdate {
-	acu.mutation.ResetUpdatedAt()
-	acu.mutation.SetUpdatedAt(i)
-	return acu
-}
-
-// AddUpdatedAt adds i to the "updated_at" field.
-func (acu *ApplicationCommandUpdate) AddUpdatedAt(i int64) *ApplicationCommandUpdate {
-	acu.mutation.AddUpdatedAt(i)
+func (acu *ApplicationCommandUpdate) SetUpdatedAt(t time.Time) *ApplicationCommandUpdate {
+	acu.mutation.SetUpdatedAt(t)
 	return acu
 }
 
@@ -143,6 +138,12 @@ func (acu *ApplicationCommandUpdate) check() error {
 	return nil
 }
 
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (acu *ApplicationCommandUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *ApplicationCommandUpdate {
+	acu.modifiers = append(acu.modifiers, modifiers...)
+	return acu
+}
+
 func (acu *ApplicationCommandUpdate) sqlSave(ctx context.Context) (n int, err error) {
 	if err := acu.check(); err != nil {
 		return n, err
@@ -156,10 +157,7 @@ func (acu *ApplicationCommandUpdate) sqlSave(ctx context.Context) (n int, err er
 		}
 	}
 	if value, ok := acu.mutation.UpdatedAt(); ok {
-		_spec.SetField(applicationcommand.FieldUpdatedAt, field.TypeInt64, value)
-	}
-	if value, ok := acu.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(applicationcommand.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(applicationcommand.FieldUpdatedAt, field.TypeTime, value)
 	}
 	if value, ok := acu.mutation.Name(); ok {
 		_spec.SetField(applicationcommand.FieldName, field.TypeString, value)
@@ -170,6 +168,7 @@ func (acu *ApplicationCommandUpdate) sqlSave(ctx context.Context) (n int, err er
 	if value, ok := acu.mutation.OptionsHash(); ok {
 		_spec.SetField(applicationcommand.FieldOptionsHash, field.TypeString, value)
 	}
+	_spec.AddModifiers(acu.modifiers...)
 	if n, err = sqlgraph.UpdateNodes(ctx, acu.driver, _spec); err != nil {
 		if _, ok := err.(*sqlgraph.NotFoundError); ok {
 			err = &NotFoundError{applicationcommand.Label}
@@ -185,21 +184,15 @@ func (acu *ApplicationCommandUpdate) sqlSave(ctx context.Context) (n int, err er
 // ApplicationCommandUpdateOne is the builder for updating a single ApplicationCommand entity.
 type ApplicationCommandUpdateOne struct {
 	config
-	fields   []string
-	hooks    []Hook
-	mutation *ApplicationCommandMutation
+	fields    []string
+	hooks     []Hook
+	mutation  *ApplicationCommandMutation
+	modifiers []func(*sql.UpdateBuilder)
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (acuo *ApplicationCommandUpdateOne) SetUpdatedAt(i int64) *ApplicationCommandUpdateOne {
-	acuo.mutation.ResetUpdatedAt()
-	acuo.mutation.SetUpdatedAt(i)
-	return acuo
-}
-
-// AddUpdatedAt adds i to the "updated_at" field.
-func (acuo *ApplicationCommandUpdateOne) AddUpdatedAt(i int64) *ApplicationCommandUpdateOne {
-	acuo.mutation.AddUpdatedAt(i)
+func (acuo *ApplicationCommandUpdateOne) SetUpdatedAt(t time.Time) *ApplicationCommandUpdateOne {
+	acuo.mutation.SetUpdatedAt(t)
 	return acuo
 }
 
@@ -319,6 +312,12 @@ func (acuo *ApplicationCommandUpdateOne) check() error {
 	return nil
 }
 
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (acuo *ApplicationCommandUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *ApplicationCommandUpdateOne {
+	acuo.modifiers = append(acuo.modifiers, modifiers...)
+	return acuo
+}
+
 func (acuo *ApplicationCommandUpdateOne) sqlSave(ctx context.Context) (_node *ApplicationCommand, err error) {
 	if err := acuo.check(); err != nil {
 		return _node, err
@@ -349,10 +348,7 @@ func (acuo *ApplicationCommandUpdateOne) sqlSave(ctx context.Context) (_node *Ap
 		}
 	}
 	if value, ok := acuo.mutation.UpdatedAt(); ok {
-		_spec.SetField(applicationcommand.FieldUpdatedAt, field.TypeInt64, value)
-	}
-	if value, ok := acuo.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(applicationcommand.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(applicationcommand.FieldUpdatedAt, field.TypeTime, value)
 	}
 	if value, ok := acuo.mutation.Name(); ok {
 		_spec.SetField(applicationcommand.FieldName, field.TypeString, value)
@@ -363,6 +359,7 @@ func (acuo *ApplicationCommandUpdateOne) sqlSave(ctx context.Context) (_node *Ap
 	if value, ok := acuo.mutation.OptionsHash(); ok {
 		_spec.SetField(applicationcommand.FieldOptionsHash, field.TypeString, value)
 	}
+	_spec.AddModifiers(acuo.modifiers...)
 	_node = &ApplicationCommand{config: acuo.config}
 	_spec.Assign = _node.assignValues
 	_spec.ScanValues = _node.scanValues
diff --git a/internal/database/ent/db/clan.go b/internal/database/ent/db/clan.go
index 1f883f27..22c9c9b5 100644
--- a/internal/database/ent/db/clan.go
+++ b/internal/database/ent/db/clan.go
@@ -6,6 +6,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"strings"
+	"time"
 
 	"entgo.io/ent"
 	"entgo.io/ent/dialect/sql"
@@ -18,9 +19,9 @@ type Clan struct {
 	// ID of the ent.
 	ID string `json:"id,omitempty"`
 	// CreatedAt holds the value of the "created_at" field.
-	CreatedAt int64 `json:"created_at,omitempty"`
+	CreatedAt time.Time `json:"created_at,omitempty"`
 	// UpdatedAt holds the value of the "updated_at" field.
-	UpdatedAt int64 `json:"updated_at,omitempty"`
+	UpdatedAt time.Time `json:"updated_at,omitempty"`
 	// Tag holds the value of the "tag" field.
 	Tag string `json:"tag,omitempty"`
 	// Name holds the value of the "name" field.
@@ -60,10 +61,10 @@ func (*Clan) scanValues(columns []string) ([]any, error) {
 		switch columns[i] {
 		case clan.FieldMembers:
 			values[i] = new([]byte)
-		case clan.FieldCreatedAt, clan.FieldUpdatedAt:
-			values[i] = new(sql.NullInt64)
 		case clan.FieldID, clan.FieldTag, clan.FieldName, clan.FieldEmblemID:
 			values[i] = new(sql.NullString)
+		case clan.FieldCreatedAt, clan.FieldUpdatedAt:
+			values[i] = new(sql.NullTime)
 		default:
 			values[i] = new(sql.UnknownType)
 		}
@@ -86,16 +87,16 @@ func (c *Clan) assignValues(columns []string, values []any) error {
 				c.ID = value.String
 			}
 		case clan.FieldCreatedAt:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field created_at", values[i])
 			} else if value.Valid {
-				c.CreatedAt = value.Int64
+				c.CreatedAt = value.Time
 			}
 		case clan.FieldUpdatedAt:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
 			} else if value.Valid {
-				c.UpdatedAt = value.Int64
+				c.UpdatedAt = value.Time
 			}
 		case clan.FieldTag:
 			if value, ok := values[i].(*sql.NullString); !ok {
@@ -165,10 +166,10 @@ func (c *Clan) String() string {
 	builder.WriteString("Clan(")
 	builder.WriteString(fmt.Sprintf("id=%v, ", c.ID))
 	builder.WriteString("created_at=")
-	builder.WriteString(fmt.Sprintf("%v", c.CreatedAt))
+	builder.WriteString(c.CreatedAt.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("updated_at=")
-	builder.WriteString(fmt.Sprintf("%v", c.UpdatedAt))
+	builder.WriteString(c.UpdatedAt.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("tag=")
 	builder.WriteString(c.Tag)
diff --git a/internal/database/ent/db/clan/clan.go b/internal/database/ent/db/clan/clan.go
index 59a2f6e0..95cdacd5 100644
--- a/internal/database/ent/db/clan/clan.go
+++ b/internal/database/ent/db/clan/clan.go
@@ -3,6 +3,8 @@
 package clan
 
 import (
+	"time"
+
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
 )
@@ -60,11 +62,11 @@ func ValidColumn(column string) bool {
 
 var (
 	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
-	DefaultCreatedAt func() int64
+	DefaultCreatedAt func() time.Time
 	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
-	DefaultUpdatedAt func() int64
+	DefaultUpdatedAt func() time.Time
 	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
-	UpdateDefaultUpdatedAt func() int64
+	UpdateDefaultUpdatedAt func() time.Time
 	// TagValidator is a validator for the "tag" field. It is called by the builders before save.
 	TagValidator func(string) error
 	// NameValidator is a validator for the "name" field. It is called by the builders before save.
diff --git a/internal/database/ent/db/clan/where.go b/internal/database/ent/db/clan/where.go
index 6ab4d8fe..2810326d 100644
--- a/internal/database/ent/db/clan/where.go
+++ b/internal/database/ent/db/clan/where.go
@@ -3,6 +3,8 @@
 package clan
 
 import (
+	"time"
+
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
@@ -64,12 +66,12 @@ func IDContainsFold(id string) predicate.Clan {
 }
 
 // CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
-func CreatedAt(v int64) predicate.Clan {
+func CreatedAt(v time.Time) predicate.Clan {
 	return predicate.Clan(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
-func UpdatedAt(v int64) predicate.Clan {
+func UpdatedAt(v time.Time) predicate.Clan {
 	return predicate.Clan(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
@@ -89,82 +91,82 @@ func EmblemID(v string) predicate.Clan {
 }
 
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v int64) predicate.Clan {
+func CreatedAtEQ(v time.Time) predicate.Clan {
 	return predicate.Clan(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v int64) predicate.Clan {
+func CreatedAtNEQ(v time.Time) predicate.Clan {
 	return predicate.Clan(sql.FieldNEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...int64) predicate.Clan {
+func CreatedAtIn(vs ...time.Time) predicate.Clan {
 	return predicate.Clan(sql.FieldIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...int64) predicate.Clan {
+func CreatedAtNotIn(vs ...time.Time) predicate.Clan {
 	return predicate.Clan(sql.FieldNotIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v int64) predicate.Clan {
+func CreatedAtGT(v time.Time) predicate.Clan {
 	return predicate.Clan(sql.FieldGT(FieldCreatedAt, v))
 }
 
 // CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v int64) predicate.Clan {
+func CreatedAtGTE(v time.Time) predicate.Clan {
 	return predicate.Clan(sql.FieldGTE(FieldCreatedAt, v))
 }
 
 // CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v int64) predicate.Clan {
+func CreatedAtLT(v time.Time) predicate.Clan {
 	return predicate.Clan(sql.FieldLT(FieldCreatedAt, v))
 }
 
 // CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v int64) predicate.Clan {
+func CreatedAtLTE(v time.Time) predicate.Clan {
 	return predicate.Clan(sql.FieldLTE(FieldCreatedAt, v))
 }
 
 // UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
-func UpdatedAtEQ(v int64) predicate.Clan {
+func UpdatedAtEQ(v time.Time) predicate.Clan {
 	return predicate.Clan(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
-func UpdatedAtNEQ(v int64) predicate.Clan {
+func UpdatedAtNEQ(v time.Time) predicate.Clan {
 	return predicate.Clan(sql.FieldNEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtIn applies the In predicate on the "updated_at" field.
-func UpdatedAtIn(vs ...int64) predicate.Clan {
+func UpdatedAtIn(vs ...time.Time) predicate.Clan {
 	return predicate.Clan(sql.FieldIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
-func UpdatedAtNotIn(vs ...int64) predicate.Clan {
+func UpdatedAtNotIn(vs ...time.Time) predicate.Clan {
 	return predicate.Clan(sql.FieldNotIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtGT applies the GT predicate on the "updated_at" field.
-func UpdatedAtGT(v int64) predicate.Clan {
+func UpdatedAtGT(v time.Time) predicate.Clan {
 	return predicate.Clan(sql.FieldGT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
-func UpdatedAtGTE(v int64) predicate.Clan {
+func UpdatedAtGTE(v time.Time) predicate.Clan {
 	return predicate.Clan(sql.FieldGTE(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLT applies the LT predicate on the "updated_at" field.
-func UpdatedAtLT(v int64) predicate.Clan {
+func UpdatedAtLT(v time.Time) predicate.Clan {
 	return predicate.Clan(sql.FieldLT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
-func UpdatedAtLTE(v int64) predicate.Clan {
+func UpdatedAtLTE(v time.Time) predicate.Clan {
 	return predicate.Clan(sql.FieldLTE(FieldUpdatedAt, v))
 }
 
diff --git a/internal/database/ent/db/clan_create.go b/internal/database/ent/db/clan_create.go
index 438f1f4d..bc4a8e94 100644
--- a/internal/database/ent/db/clan_create.go
+++ b/internal/database/ent/db/clan_create.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"entgo.io/ent/schema/field"
@@ -21,29 +22,29 @@ type ClanCreate struct {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (cc *ClanCreate) SetCreatedAt(i int64) *ClanCreate {
-	cc.mutation.SetCreatedAt(i)
+func (cc *ClanCreate) SetCreatedAt(t time.Time) *ClanCreate {
+	cc.mutation.SetCreatedAt(t)
 	return cc
 }
 
 // SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
-func (cc *ClanCreate) SetNillableCreatedAt(i *int64) *ClanCreate {
-	if i != nil {
-		cc.SetCreatedAt(*i)
+func (cc *ClanCreate) SetNillableCreatedAt(t *time.Time) *ClanCreate {
+	if t != nil {
+		cc.SetCreatedAt(*t)
 	}
 	return cc
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (cc *ClanCreate) SetUpdatedAt(i int64) *ClanCreate {
-	cc.mutation.SetUpdatedAt(i)
+func (cc *ClanCreate) SetUpdatedAt(t time.Time) *ClanCreate {
+	cc.mutation.SetUpdatedAt(t)
 	return cc
 }
 
 // SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
-func (cc *ClanCreate) SetNillableUpdatedAt(i *int64) *ClanCreate {
-	if i != nil {
-		cc.SetUpdatedAt(*i)
+func (cc *ClanCreate) SetNillableUpdatedAt(t *time.Time) *ClanCreate {
+	if t != nil {
+		cc.SetUpdatedAt(*t)
 	}
 	return cc
 }
@@ -213,11 +214,11 @@ func (cc *ClanCreate) createSpec() (*Clan, *sqlgraph.CreateSpec) {
 		_spec.ID.Value = id
 	}
 	if value, ok := cc.mutation.CreatedAt(); ok {
-		_spec.SetField(clan.FieldCreatedAt, field.TypeInt64, value)
+		_spec.SetField(clan.FieldCreatedAt, field.TypeTime, value)
 		_node.CreatedAt = value
 	}
 	if value, ok := cc.mutation.UpdatedAt(); ok {
-		_spec.SetField(clan.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(clan.FieldUpdatedAt, field.TypeTime, value)
 		_node.UpdatedAt = value
 	}
 	if value, ok := cc.mutation.Tag(); ok {
diff --git a/internal/database/ent/db/clan_query.go b/internal/database/ent/db/clan_query.go
index 76649a32..046e2ed9 100644
--- a/internal/database/ent/db/clan_query.go
+++ b/internal/database/ent/db/clan_query.go
@@ -24,6 +24,7 @@ type ClanQuery struct {
 	inters       []Interceptor
 	predicates   []predicate.Clan
 	withAccounts *AccountQuery
+	modifiers    []func(*sql.Selector)
 	// intermediate query (i.e. traversal path).
 	sql  *sql.Selector
 	path func(context.Context) (*sql.Selector, error)
@@ -298,7 +299,7 @@ func (cq *ClanQuery) WithAccounts(opts ...func(*AccountQuery)) *ClanQuery {
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int64 `json:"created_at,omitempty"`
+//		CreatedAt time.Time `json:"created_at,omitempty"`
 //		Count int `json:"count,omitempty"`
 //	}
 //
@@ -321,7 +322,7 @@ func (cq *ClanQuery) GroupBy(field string, fields ...string) *ClanGroupBy {
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int64 `json:"created_at,omitempty"`
+//		CreatedAt time.Time `json:"created_at,omitempty"`
 //	}
 //
 //	client.Clan.Query().
@@ -383,6 +384,9 @@ func (cq *ClanQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Clan, e
 		node.Edges.loadedTypes = loadedTypes
 		return node.assignValues(columns, values)
 	}
+	if len(cq.modifiers) > 0 {
+		_spec.Modifiers = cq.modifiers
+	}
 	for i := range hooks {
 		hooks[i](ctx, _spec)
 	}
@@ -435,6 +439,9 @@ func (cq *ClanQuery) loadAccounts(ctx context.Context, query *AccountQuery, node
 
 func (cq *ClanQuery) sqlCount(ctx context.Context) (int, error) {
 	_spec := cq.querySpec()
+	if len(cq.modifiers) > 0 {
+		_spec.Modifiers = cq.modifiers
+	}
 	_spec.Node.Columns = cq.ctx.Fields
 	if len(cq.ctx.Fields) > 0 {
 		_spec.Unique = cq.ctx.Unique != nil && *cq.ctx.Unique
@@ -497,6 +504,9 @@ func (cq *ClanQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	if cq.ctx.Unique != nil && *cq.ctx.Unique {
 		selector.Distinct()
 	}
+	for _, m := range cq.modifiers {
+		m(selector)
+	}
 	for _, p := range cq.predicates {
 		p(selector)
 	}
@@ -514,6 +524,12 @@ func (cq *ClanQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	return selector
 }
 
+// Modify adds a query modifier for attaching custom logic to queries.
+func (cq *ClanQuery) Modify(modifiers ...func(s *sql.Selector)) *ClanSelect {
+	cq.modifiers = append(cq.modifiers, modifiers...)
+	return cq.Select()
+}
+
 // ClanGroupBy is the group-by builder for Clan entities.
 type ClanGroupBy struct {
 	selector
@@ -603,3 +619,9 @@ func (cs *ClanSelect) sqlScan(ctx context.Context, root *ClanQuery, v any) error
 	defer rows.Close()
 	return sql.ScanSlice(rows, v)
 }
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (cs *ClanSelect) Modify(modifiers ...func(s *sql.Selector)) *ClanSelect {
+	cs.modifiers = append(cs.modifiers, modifiers...)
+	return cs
+}
diff --git a/internal/database/ent/db/clan_update.go b/internal/database/ent/db/clan_update.go
index 8a5ae595..f291ac89 100644
--- a/internal/database/ent/db/clan_update.go
+++ b/internal/database/ent/db/clan_update.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
@@ -19,8 +20,9 @@ import (
 // ClanUpdate is the builder for updating Clan entities.
 type ClanUpdate struct {
 	config
-	hooks    []Hook
-	mutation *ClanMutation
+	hooks     []Hook
+	mutation  *ClanMutation
+	modifiers []func(*sql.UpdateBuilder)
 }
 
 // Where appends a list predicates to the ClanUpdate builder.
@@ -30,15 +32,8 @@ func (cu *ClanUpdate) Where(ps ...predicate.Clan) *ClanUpdate {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (cu *ClanUpdate) SetUpdatedAt(i int64) *ClanUpdate {
-	cu.mutation.ResetUpdatedAt()
-	cu.mutation.SetUpdatedAt(i)
-	return cu
-}
-
-// AddUpdatedAt adds i to the "updated_at" field.
-func (cu *ClanUpdate) AddUpdatedAt(i int64) *ClanUpdate {
-	cu.mutation.AddUpdatedAt(i)
+func (cu *ClanUpdate) SetUpdatedAt(t time.Time) *ClanUpdate {
+	cu.mutation.SetUpdatedAt(t)
 	return cu
 }
 
@@ -194,6 +189,12 @@ func (cu *ClanUpdate) check() error {
 	return nil
 }
 
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (cu *ClanUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *ClanUpdate {
+	cu.modifiers = append(cu.modifiers, modifiers...)
+	return cu
+}
+
 func (cu *ClanUpdate) sqlSave(ctx context.Context) (n int, err error) {
 	if err := cu.check(); err != nil {
 		return n, err
@@ -207,10 +208,7 @@ func (cu *ClanUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 	}
 	if value, ok := cu.mutation.UpdatedAt(); ok {
-		_spec.SetField(clan.FieldUpdatedAt, field.TypeInt64, value)
-	}
-	if value, ok := cu.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(clan.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(clan.FieldUpdatedAt, field.TypeTime, value)
 	}
 	if value, ok := cu.mutation.Tag(); ok {
 		_spec.SetField(clan.FieldTag, field.TypeString, value)
@@ -277,6 +275,7 @@ func (cu *ClanUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 		_spec.Edges.Add = append(_spec.Edges.Add, edge)
 	}
+	_spec.AddModifiers(cu.modifiers...)
 	if n, err = sqlgraph.UpdateNodes(ctx, cu.driver, _spec); err != nil {
 		if _, ok := err.(*sqlgraph.NotFoundError); ok {
 			err = &NotFoundError{clan.Label}
@@ -292,21 +291,15 @@ func (cu *ClanUpdate) sqlSave(ctx context.Context) (n int, err error) {
 // ClanUpdateOne is the builder for updating a single Clan entity.
 type ClanUpdateOne struct {
 	config
-	fields   []string
-	hooks    []Hook
-	mutation *ClanMutation
+	fields    []string
+	hooks     []Hook
+	mutation  *ClanMutation
+	modifiers []func(*sql.UpdateBuilder)
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (cuo *ClanUpdateOne) SetUpdatedAt(i int64) *ClanUpdateOne {
-	cuo.mutation.ResetUpdatedAt()
-	cuo.mutation.SetUpdatedAt(i)
-	return cuo
-}
-
-// AddUpdatedAt adds i to the "updated_at" field.
-func (cuo *ClanUpdateOne) AddUpdatedAt(i int64) *ClanUpdateOne {
-	cuo.mutation.AddUpdatedAt(i)
+func (cuo *ClanUpdateOne) SetUpdatedAt(t time.Time) *ClanUpdateOne {
+	cuo.mutation.SetUpdatedAt(t)
 	return cuo
 }
 
@@ -475,6 +468,12 @@ func (cuo *ClanUpdateOne) check() error {
 	return nil
 }
 
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (cuo *ClanUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *ClanUpdateOne {
+	cuo.modifiers = append(cuo.modifiers, modifiers...)
+	return cuo
+}
+
 func (cuo *ClanUpdateOne) sqlSave(ctx context.Context) (_node *Clan, err error) {
 	if err := cuo.check(); err != nil {
 		return _node, err
@@ -505,10 +504,7 @@ func (cuo *ClanUpdateOne) sqlSave(ctx context.Context) (_node *Clan, err error)
 		}
 	}
 	if value, ok := cuo.mutation.UpdatedAt(); ok {
-		_spec.SetField(clan.FieldUpdatedAt, field.TypeInt64, value)
-	}
-	if value, ok := cuo.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(clan.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(clan.FieldUpdatedAt, field.TypeTime, value)
 	}
 	if value, ok := cuo.mutation.Tag(); ok {
 		_spec.SetField(clan.FieldTag, field.TypeString, value)
@@ -575,6 +571,7 @@ func (cuo *ClanUpdateOne) sqlSave(ctx context.Context) (_node *Clan, err error)
 		}
 		_spec.Edges.Add = append(_spec.Edges.Add, edge)
 	}
+	_spec.AddModifiers(cuo.modifiers...)
 	_node = &Clan{config: cuo.config}
 	_spec.Assign = _node.assignValues
 	_spec.ScanValues = _node.scanValues
diff --git a/internal/database/ent/db/crontask.go b/internal/database/ent/db/crontask.go
index c4ba99dd..dcc845a5 100644
--- a/internal/database/ent/db/crontask.go
+++ b/internal/database/ent/db/crontask.go
@@ -6,6 +6,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"strings"
+	"time"
 
 	"entgo.io/ent"
 	"entgo.io/ent/dialect/sql"
@@ -19,9 +20,9 @@ type CronTask struct {
 	// ID of the ent.
 	ID string `json:"id,omitempty"`
 	// CreatedAt holds the value of the "created_at" field.
-	CreatedAt int64 `json:"created_at,omitempty"`
+	CreatedAt time.Time `json:"created_at,omitempty"`
 	// UpdatedAt holds the value of the "updated_at" field.
-	UpdatedAt int64 `json:"updated_at,omitempty"`
+	UpdatedAt time.Time `json:"updated_at,omitempty"`
 	// Type holds the value of the "type" field.
 	Type models.TaskType `json:"type,omitempty"`
 	// ReferenceID holds the value of the "reference_id" field.
@@ -31,9 +32,9 @@ type CronTask struct {
 	// Status holds the value of the "status" field.
 	Status models.TaskStatus `json:"status,omitempty"`
 	// ScheduledAfter holds the value of the "scheduled_after" field.
-	ScheduledAfter int64 `json:"scheduled_after,omitempty"`
+	ScheduledAfter time.Time `json:"scheduled_after,omitempty"`
 	// LastRun holds the value of the "last_run" field.
-	LastRun int64 `json:"last_run,omitempty"`
+	LastRun time.Time `json:"last_run,omitempty"`
 	// Logs holds the value of the "logs" field.
 	Logs []models.TaskLog `json:"logs,omitempty"`
 	// Data holds the value of the "data" field.
@@ -48,10 +49,10 @@ func (*CronTask) scanValues(columns []string) ([]any, error) {
 		switch columns[i] {
 		case crontask.FieldTargets, crontask.FieldLogs, crontask.FieldData:
 			values[i] = new([]byte)
-		case crontask.FieldCreatedAt, crontask.FieldUpdatedAt, crontask.FieldScheduledAfter, crontask.FieldLastRun:
-			values[i] = new(sql.NullInt64)
 		case crontask.FieldID, crontask.FieldType, crontask.FieldReferenceID, crontask.FieldStatus:
 			values[i] = new(sql.NullString)
+		case crontask.FieldCreatedAt, crontask.FieldUpdatedAt, crontask.FieldScheduledAfter, crontask.FieldLastRun:
+			values[i] = new(sql.NullTime)
 		default:
 			values[i] = new(sql.UnknownType)
 		}
@@ -74,16 +75,16 @@ func (ct *CronTask) assignValues(columns []string, values []any) error {
 				ct.ID = value.String
 			}
 		case crontask.FieldCreatedAt:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field created_at", values[i])
 			} else if value.Valid {
-				ct.CreatedAt = value.Int64
+				ct.CreatedAt = value.Time
 			}
 		case crontask.FieldUpdatedAt:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
 			} else if value.Valid {
-				ct.UpdatedAt = value.Int64
+				ct.UpdatedAt = value.Time
 			}
 		case crontask.FieldType:
 			if value, ok := values[i].(*sql.NullString); !ok {
@@ -112,16 +113,16 @@ func (ct *CronTask) assignValues(columns []string, values []any) error {
 				ct.Status = models.TaskStatus(value.String)
 			}
 		case crontask.FieldScheduledAfter:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field scheduled_after", values[i])
 			} else if value.Valid {
-				ct.ScheduledAfter = value.Int64
+				ct.ScheduledAfter = value.Time
 			}
 		case crontask.FieldLastRun:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field last_run", values[i])
 			} else if value.Valid {
-				ct.LastRun = value.Int64
+				ct.LastRun = value.Time
 			}
 		case crontask.FieldLogs:
 			if value, ok := values[i].(*[]byte); !ok {
@@ -176,10 +177,10 @@ func (ct *CronTask) String() string {
 	builder.WriteString("CronTask(")
 	builder.WriteString(fmt.Sprintf("id=%v, ", ct.ID))
 	builder.WriteString("created_at=")
-	builder.WriteString(fmt.Sprintf("%v", ct.CreatedAt))
+	builder.WriteString(ct.CreatedAt.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("updated_at=")
-	builder.WriteString(fmt.Sprintf("%v", ct.UpdatedAt))
+	builder.WriteString(ct.UpdatedAt.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("type=")
 	builder.WriteString(fmt.Sprintf("%v", ct.Type))
@@ -194,10 +195,10 @@ func (ct *CronTask) String() string {
 	builder.WriteString(fmt.Sprintf("%v", ct.Status))
 	builder.WriteString(", ")
 	builder.WriteString("scheduled_after=")
-	builder.WriteString(fmt.Sprintf("%v", ct.ScheduledAfter))
+	builder.WriteString(ct.ScheduledAfter.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("last_run=")
-	builder.WriteString(fmt.Sprintf("%v", ct.LastRun))
+	builder.WriteString(ct.LastRun.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("logs=")
 	builder.WriteString(fmt.Sprintf("%v", ct.Logs))
diff --git a/internal/database/ent/db/crontask/crontask.go b/internal/database/ent/db/crontask/crontask.go
index c83a8067..1e2f95ea 100644
--- a/internal/database/ent/db/crontask/crontask.go
+++ b/internal/database/ent/db/crontask/crontask.go
@@ -4,6 +4,7 @@ package crontask
 
 import (
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql"
 	"github.com/cufee/aftermath/internal/database/models"
@@ -65,11 +66,11 @@ func ValidColumn(column string) bool {
 
 var (
 	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
-	DefaultCreatedAt func() int64
+	DefaultCreatedAt func() time.Time
 	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
-	DefaultUpdatedAt func() int64
+	DefaultUpdatedAt func() time.Time
 	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
-	UpdateDefaultUpdatedAt func() int64
+	UpdateDefaultUpdatedAt func() time.Time
 	// ReferenceIDValidator is a validator for the "reference_id" field. It is called by the builders before save.
 	ReferenceIDValidator func(string) error
 	// DefaultID holds the default value on creation for the "id" field.
diff --git a/internal/database/ent/db/crontask/where.go b/internal/database/ent/db/crontask/where.go
index 3eb15146..3f2568ff 100644
--- a/internal/database/ent/db/crontask/where.go
+++ b/internal/database/ent/db/crontask/where.go
@@ -3,6 +3,8 @@
 package crontask
 
 import (
+	"time"
+
 	"entgo.io/ent/dialect/sql"
 	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
 	"github.com/cufee/aftermath/internal/database/models"
@@ -64,12 +66,12 @@ func IDContainsFold(id string) predicate.CronTask {
 }
 
 // CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
-func CreatedAt(v int64) predicate.CronTask {
+func CreatedAt(v time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
-func UpdatedAt(v int64) predicate.CronTask {
+func UpdatedAt(v time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
@@ -79,92 +81,92 @@ func ReferenceID(v string) predicate.CronTask {
 }
 
 // ScheduledAfter applies equality check predicate on the "scheduled_after" field. It's identical to ScheduledAfterEQ.
-func ScheduledAfter(v int64) predicate.CronTask {
+func ScheduledAfter(v time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldEQ(FieldScheduledAfter, v))
 }
 
 // LastRun applies equality check predicate on the "last_run" field. It's identical to LastRunEQ.
-func LastRun(v int64) predicate.CronTask {
+func LastRun(v time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldEQ(FieldLastRun, v))
 }
 
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v int64) predicate.CronTask {
+func CreatedAtEQ(v time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v int64) predicate.CronTask {
+func CreatedAtNEQ(v time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldNEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...int64) predicate.CronTask {
+func CreatedAtIn(vs ...time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...int64) predicate.CronTask {
+func CreatedAtNotIn(vs ...time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldNotIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v int64) predicate.CronTask {
+func CreatedAtGT(v time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldGT(FieldCreatedAt, v))
 }
 
 // CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v int64) predicate.CronTask {
+func CreatedAtGTE(v time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldGTE(FieldCreatedAt, v))
 }
 
 // CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v int64) predicate.CronTask {
+func CreatedAtLT(v time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldLT(FieldCreatedAt, v))
 }
 
 // CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v int64) predicate.CronTask {
+func CreatedAtLTE(v time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldLTE(FieldCreatedAt, v))
 }
 
 // UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
-func UpdatedAtEQ(v int64) predicate.CronTask {
+func UpdatedAtEQ(v time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
-func UpdatedAtNEQ(v int64) predicate.CronTask {
+func UpdatedAtNEQ(v time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldNEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtIn applies the In predicate on the "updated_at" field.
-func UpdatedAtIn(vs ...int64) predicate.CronTask {
+func UpdatedAtIn(vs ...time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
-func UpdatedAtNotIn(vs ...int64) predicate.CronTask {
+func UpdatedAtNotIn(vs ...time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldNotIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtGT applies the GT predicate on the "updated_at" field.
-func UpdatedAtGT(v int64) predicate.CronTask {
+func UpdatedAtGT(v time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldGT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
-func UpdatedAtGTE(v int64) predicate.CronTask {
+func UpdatedAtGTE(v time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldGTE(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLT applies the LT predicate on the "updated_at" field.
-func UpdatedAtLT(v int64) predicate.CronTask {
+func UpdatedAtLT(v time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldLT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
-func UpdatedAtLTE(v int64) predicate.CronTask {
+func UpdatedAtLTE(v time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldLTE(FieldUpdatedAt, v))
 }
 
@@ -294,82 +296,82 @@ func StatusNotIn(vs ...models.TaskStatus) predicate.CronTask {
 }
 
 // ScheduledAfterEQ applies the EQ predicate on the "scheduled_after" field.
-func ScheduledAfterEQ(v int64) predicate.CronTask {
+func ScheduledAfterEQ(v time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldEQ(FieldScheduledAfter, v))
 }
 
 // ScheduledAfterNEQ applies the NEQ predicate on the "scheduled_after" field.
-func ScheduledAfterNEQ(v int64) predicate.CronTask {
+func ScheduledAfterNEQ(v time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldNEQ(FieldScheduledAfter, v))
 }
 
 // ScheduledAfterIn applies the In predicate on the "scheduled_after" field.
-func ScheduledAfterIn(vs ...int64) predicate.CronTask {
+func ScheduledAfterIn(vs ...time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldIn(FieldScheduledAfter, vs...))
 }
 
 // ScheduledAfterNotIn applies the NotIn predicate on the "scheduled_after" field.
-func ScheduledAfterNotIn(vs ...int64) predicate.CronTask {
+func ScheduledAfterNotIn(vs ...time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldNotIn(FieldScheduledAfter, vs...))
 }
 
 // ScheduledAfterGT applies the GT predicate on the "scheduled_after" field.
-func ScheduledAfterGT(v int64) predicate.CronTask {
+func ScheduledAfterGT(v time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldGT(FieldScheduledAfter, v))
 }
 
 // ScheduledAfterGTE applies the GTE predicate on the "scheduled_after" field.
-func ScheduledAfterGTE(v int64) predicate.CronTask {
+func ScheduledAfterGTE(v time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldGTE(FieldScheduledAfter, v))
 }
 
 // ScheduledAfterLT applies the LT predicate on the "scheduled_after" field.
-func ScheduledAfterLT(v int64) predicate.CronTask {
+func ScheduledAfterLT(v time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldLT(FieldScheduledAfter, v))
 }
 
 // ScheduledAfterLTE applies the LTE predicate on the "scheduled_after" field.
-func ScheduledAfterLTE(v int64) predicate.CronTask {
+func ScheduledAfterLTE(v time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldLTE(FieldScheduledAfter, v))
 }
 
 // LastRunEQ applies the EQ predicate on the "last_run" field.
-func LastRunEQ(v int64) predicate.CronTask {
+func LastRunEQ(v time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldEQ(FieldLastRun, v))
 }
 
 // LastRunNEQ applies the NEQ predicate on the "last_run" field.
-func LastRunNEQ(v int64) predicate.CronTask {
+func LastRunNEQ(v time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldNEQ(FieldLastRun, v))
 }
 
 // LastRunIn applies the In predicate on the "last_run" field.
-func LastRunIn(vs ...int64) predicate.CronTask {
+func LastRunIn(vs ...time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldIn(FieldLastRun, vs...))
 }
 
 // LastRunNotIn applies the NotIn predicate on the "last_run" field.
-func LastRunNotIn(vs ...int64) predicate.CronTask {
+func LastRunNotIn(vs ...time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldNotIn(FieldLastRun, vs...))
 }
 
 // LastRunGT applies the GT predicate on the "last_run" field.
-func LastRunGT(v int64) predicate.CronTask {
+func LastRunGT(v time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldGT(FieldLastRun, v))
 }
 
 // LastRunGTE applies the GTE predicate on the "last_run" field.
-func LastRunGTE(v int64) predicate.CronTask {
+func LastRunGTE(v time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldGTE(FieldLastRun, v))
 }
 
 // LastRunLT applies the LT predicate on the "last_run" field.
-func LastRunLT(v int64) predicate.CronTask {
+func LastRunLT(v time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldLT(FieldLastRun, v))
 }
 
 // LastRunLTE applies the LTE predicate on the "last_run" field.
-func LastRunLTE(v int64) predicate.CronTask {
+func LastRunLTE(v time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldLTE(FieldLastRun, v))
 }
 
diff --git a/internal/database/ent/db/crontask_create.go b/internal/database/ent/db/crontask_create.go
index 78feb06e..70343d77 100644
--- a/internal/database/ent/db/crontask_create.go
+++ b/internal/database/ent/db/crontask_create.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"entgo.io/ent/schema/field"
@@ -21,29 +22,29 @@ type CronTaskCreate struct {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (ctc *CronTaskCreate) SetCreatedAt(i int64) *CronTaskCreate {
-	ctc.mutation.SetCreatedAt(i)
+func (ctc *CronTaskCreate) SetCreatedAt(t time.Time) *CronTaskCreate {
+	ctc.mutation.SetCreatedAt(t)
 	return ctc
 }
 
 // SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
-func (ctc *CronTaskCreate) SetNillableCreatedAt(i *int64) *CronTaskCreate {
-	if i != nil {
-		ctc.SetCreatedAt(*i)
+func (ctc *CronTaskCreate) SetNillableCreatedAt(t *time.Time) *CronTaskCreate {
+	if t != nil {
+		ctc.SetCreatedAt(*t)
 	}
 	return ctc
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (ctc *CronTaskCreate) SetUpdatedAt(i int64) *CronTaskCreate {
-	ctc.mutation.SetUpdatedAt(i)
+func (ctc *CronTaskCreate) SetUpdatedAt(t time.Time) *CronTaskCreate {
+	ctc.mutation.SetUpdatedAt(t)
 	return ctc
 }
 
 // SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
-func (ctc *CronTaskCreate) SetNillableUpdatedAt(i *int64) *CronTaskCreate {
-	if i != nil {
-		ctc.SetUpdatedAt(*i)
+func (ctc *CronTaskCreate) SetNillableUpdatedAt(t *time.Time) *CronTaskCreate {
+	if t != nil {
+		ctc.SetUpdatedAt(*t)
 	}
 	return ctc
 }
@@ -73,14 +74,14 @@ func (ctc *CronTaskCreate) SetStatus(ms models.TaskStatus) *CronTaskCreate {
 }
 
 // SetScheduledAfter sets the "scheduled_after" field.
-func (ctc *CronTaskCreate) SetScheduledAfter(i int64) *CronTaskCreate {
-	ctc.mutation.SetScheduledAfter(i)
+func (ctc *CronTaskCreate) SetScheduledAfter(t time.Time) *CronTaskCreate {
+	ctc.mutation.SetScheduledAfter(t)
 	return ctc
 }
 
 // SetLastRun sets the "last_run" field.
-func (ctc *CronTaskCreate) SetLastRun(i int64) *CronTaskCreate {
-	ctc.mutation.SetLastRun(i)
+func (ctc *CronTaskCreate) SetLastRun(t time.Time) *CronTaskCreate {
+	ctc.mutation.SetLastRun(t)
 	return ctc
 }
 
@@ -242,11 +243,11 @@ func (ctc *CronTaskCreate) createSpec() (*CronTask, *sqlgraph.CreateSpec) {
 		_spec.ID.Value = id
 	}
 	if value, ok := ctc.mutation.CreatedAt(); ok {
-		_spec.SetField(crontask.FieldCreatedAt, field.TypeInt64, value)
+		_spec.SetField(crontask.FieldCreatedAt, field.TypeTime, value)
 		_node.CreatedAt = value
 	}
 	if value, ok := ctc.mutation.UpdatedAt(); ok {
-		_spec.SetField(crontask.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(crontask.FieldUpdatedAt, field.TypeTime, value)
 		_node.UpdatedAt = value
 	}
 	if value, ok := ctc.mutation.GetType(); ok {
@@ -266,11 +267,11 @@ func (ctc *CronTaskCreate) createSpec() (*CronTask, *sqlgraph.CreateSpec) {
 		_node.Status = value
 	}
 	if value, ok := ctc.mutation.ScheduledAfter(); ok {
-		_spec.SetField(crontask.FieldScheduledAfter, field.TypeInt64, value)
+		_spec.SetField(crontask.FieldScheduledAfter, field.TypeTime, value)
 		_node.ScheduledAfter = value
 	}
 	if value, ok := ctc.mutation.LastRun(); ok {
-		_spec.SetField(crontask.FieldLastRun, field.TypeInt64, value)
+		_spec.SetField(crontask.FieldLastRun, field.TypeTime, value)
 		_node.LastRun = value
 	}
 	if value, ok := ctc.mutation.Logs(); ok {
diff --git a/internal/database/ent/db/crontask_query.go b/internal/database/ent/db/crontask_query.go
index 27b8ca39..a8700af9 100644
--- a/internal/database/ent/db/crontask_query.go
+++ b/internal/database/ent/db/crontask_query.go
@@ -21,6 +21,7 @@ type CronTaskQuery struct {
 	order      []crontask.OrderOption
 	inters     []Interceptor
 	predicates []predicate.CronTask
+	modifiers  []func(*sql.Selector)
 	// intermediate query (i.e. traversal path).
 	sql  *sql.Selector
 	path func(context.Context) (*sql.Selector, error)
@@ -261,7 +262,7 @@ func (ctq *CronTaskQuery) Clone() *CronTaskQuery {
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int64 `json:"created_at,omitempty"`
+//		CreatedAt time.Time `json:"created_at,omitempty"`
 //		Count int `json:"count,omitempty"`
 //	}
 //
@@ -284,7 +285,7 @@ func (ctq *CronTaskQuery) GroupBy(field string, fields ...string) *CronTaskGroup
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int64 `json:"created_at,omitempty"`
+//		CreatedAt time.Time `json:"created_at,omitempty"`
 //	}
 //
 //	client.CronTask.Query().
@@ -342,6 +343,9 @@ func (ctq *CronTaskQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Cr
 		nodes = append(nodes, node)
 		return node.assignValues(columns, values)
 	}
+	if len(ctq.modifiers) > 0 {
+		_spec.Modifiers = ctq.modifiers
+	}
 	for i := range hooks {
 		hooks[i](ctx, _spec)
 	}
@@ -356,6 +360,9 @@ func (ctq *CronTaskQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Cr
 
 func (ctq *CronTaskQuery) sqlCount(ctx context.Context) (int, error) {
 	_spec := ctq.querySpec()
+	if len(ctq.modifiers) > 0 {
+		_spec.Modifiers = ctq.modifiers
+	}
 	_spec.Node.Columns = ctq.ctx.Fields
 	if len(ctq.ctx.Fields) > 0 {
 		_spec.Unique = ctq.ctx.Unique != nil && *ctq.ctx.Unique
@@ -418,6 +425,9 @@ func (ctq *CronTaskQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	if ctq.ctx.Unique != nil && *ctq.ctx.Unique {
 		selector.Distinct()
 	}
+	for _, m := range ctq.modifiers {
+		m(selector)
+	}
 	for _, p := range ctq.predicates {
 		p(selector)
 	}
@@ -435,6 +445,12 @@ func (ctq *CronTaskQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	return selector
 }
 
+// Modify adds a query modifier for attaching custom logic to queries.
+func (ctq *CronTaskQuery) Modify(modifiers ...func(s *sql.Selector)) *CronTaskSelect {
+	ctq.modifiers = append(ctq.modifiers, modifiers...)
+	return ctq.Select()
+}
+
 // CronTaskGroupBy is the group-by builder for CronTask entities.
 type CronTaskGroupBy struct {
 	selector
@@ -524,3 +540,9 @@ func (cts *CronTaskSelect) sqlScan(ctx context.Context, root *CronTaskQuery, v a
 	defer rows.Close()
 	return sql.ScanSlice(rows, v)
 }
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (cts *CronTaskSelect) Modify(modifiers ...func(s *sql.Selector)) *CronTaskSelect {
+	cts.modifiers = append(cts.modifiers, modifiers...)
+	return cts
+}
diff --git a/internal/database/ent/db/crontask_update.go b/internal/database/ent/db/crontask_update.go
index ddbf9627..5565a00b 100644
--- a/internal/database/ent/db/crontask_update.go
+++ b/internal/database/ent/db/crontask_update.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
@@ -19,8 +20,9 @@ import (
 // CronTaskUpdate is the builder for updating CronTask entities.
 type CronTaskUpdate struct {
 	config
-	hooks    []Hook
-	mutation *CronTaskMutation
+	hooks     []Hook
+	mutation  *CronTaskMutation
+	modifiers []func(*sql.UpdateBuilder)
 }
 
 // Where appends a list predicates to the CronTaskUpdate builder.
@@ -30,15 +32,8 @@ func (ctu *CronTaskUpdate) Where(ps ...predicate.CronTask) *CronTaskUpdate {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (ctu *CronTaskUpdate) SetUpdatedAt(i int64) *CronTaskUpdate {
-	ctu.mutation.ResetUpdatedAt()
-	ctu.mutation.SetUpdatedAt(i)
-	return ctu
-}
-
-// AddUpdatedAt adds i to the "updated_at" field.
-func (ctu *CronTaskUpdate) AddUpdatedAt(i int64) *CronTaskUpdate {
-	ctu.mutation.AddUpdatedAt(i)
+func (ctu *CronTaskUpdate) SetUpdatedAt(t time.Time) *CronTaskUpdate {
+	ctu.mutation.SetUpdatedAt(t)
 	return ctu
 }
 
@@ -97,47 +92,33 @@ func (ctu *CronTaskUpdate) SetNillableStatus(ms *models.TaskStatus) *CronTaskUpd
 }
 
 // SetScheduledAfter sets the "scheduled_after" field.
-func (ctu *CronTaskUpdate) SetScheduledAfter(i int64) *CronTaskUpdate {
-	ctu.mutation.ResetScheduledAfter()
-	ctu.mutation.SetScheduledAfter(i)
+func (ctu *CronTaskUpdate) SetScheduledAfter(t time.Time) *CronTaskUpdate {
+	ctu.mutation.SetScheduledAfter(t)
 	return ctu
 }
 
 // SetNillableScheduledAfter sets the "scheduled_after" field if the given value is not nil.
-func (ctu *CronTaskUpdate) SetNillableScheduledAfter(i *int64) *CronTaskUpdate {
-	if i != nil {
-		ctu.SetScheduledAfter(*i)
+func (ctu *CronTaskUpdate) SetNillableScheduledAfter(t *time.Time) *CronTaskUpdate {
+	if t != nil {
+		ctu.SetScheduledAfter(*t)
 	}
 	return ctu
 }
 
-// AddScheduledAfter adds i to the "scheduled_after" field.
-func (ctu *CronTaskUpdate) AddScheduledAfter(i int64) *CronTaskUpdate {
-	ctu.mutation.AddScheduledAfter(i)
-	return ctu
-}
-
 // SetLastRun sets the "last_run" field.
-func (ctu *CronTaskUpdate) SetLastRun(i int64) *CronTaskUpdate {
-	ctu.mutation.ResetLastRun()
-	ctu.mutation.SetLastRun(i)
+func (ctu *CronTaskUpdate) SetLastRun(t time.Time) *CronTaskUpdate {
+	ctu.mutation.SetLastRun(t)
 	return ctu
 }
 
 // SetNillableLastRun sets the "last_run" field if the given value is not nil.
-func (ctu *CronTaskUpdate) SetNillableLastRun(i *int64) *CronTaskUpdate {
-	if i != nil {
-		ctu.SetLastRun(*i)
+func (ctu *CronTaskUpdate) SetNillableLastRun(t *time.Time) *CronTaskUpdate {
+	if t != nil {
+		ctu.SetLastRun(*t)
 	}
 	return ctu
 }
 
-// AddLastRun adds i to the "last_run" field.
-func (ctu *CronTaskUpdate) AddLastRun(i int64) *CronTaskUpdate {
-	ctu.mutation.AddLastRun(i)
-	return ctu
-}
-
 // SetLogs sets the "logs" field.
 func (ctu *CronTaskUpdate) SetLogs(ml []models.TaskLog) *CronTaskUpdate {
 	ctu.mutation.SetLogs(ml)
@@ -217,6 +198,12 @@ func (ctu *CronTaskUpdate) check() error {
 	return nil
 }
 
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (ctu *CronTaskUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *CronTaskUpdate {
+	ctu.modifiers = append(ctu.modifiers, modifiers...)
+	return ctu
+}
+
 func (ctu *CronTaskUpdate) sqlSave(ctx context.Context) (n int, err error) {
 	if err := ctu.check(); err != nil {
 		return n, err
@@ -230,10 +217,7 @@ func (ctu *CronTaskUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 	}
 	if value, ok := ctu.mutation.UpdatedAt(); ok {
-		_spec.SetField(crontask.FieldUpdatedAt, field.TypeInt64, value)
-	}
-	if value, ok := ctu.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(crontask.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(crontask.FieldUpdatedAt, field.TypeTime, value)
 	}
 	if value, ok := ctu.mutation.GetType(); ok {
 		_spec.SetField(crontask.FieldType, field.TypeEnum, value)
@@ -253,16 +237,10 @@ func (ctu *CronTaskUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		_spec.SetField(crontask.FieldStatus, field.TypeEnum, value)
 	}
 	if value, ok := ctu.mutation.ScheduledAfter(); ok {
-		_spec.SetField(crontask.FieldScheduledAfter, field.TypeInt64, value)
-	}
-	if value, ok := ctu.mutation.AddedScheduledAfter(); ok {
-		_spec.AddField(crontask.FieldScheduledAfter, field.TypeInt64, value)
+		_spec.SetField(crontask.FieldScheduledAfter, field.TypeTime, value)
 	}
 	if value, ok := ctu.mutation.LastRun(); ok {
-		_spec.SetField(crontask.FieldLastRun, field.TypeInt64, value)
-	}
-	if value, ok := ctu.mutation.AddedLastRun(); ok {
-		_spec.AddField(crontask.FieldLastRun, field.TypeInt64, value)
+		_spec.SetField(crontask.FieldLastRun, field.TypeTime, value)
 	}
 	if value, ok := ctu.mutation.Logs(); ok {
 		_spec.SetField(crontask.FieldLogs, field.TypeJSON, value)
@@ -275,6 +253,7 @@ func (ctu *CronTaskUpdate) sqlSave(ctx context.Context) (n int, err error) {
 	if value, ok := ctu.mutation.Data(); ok {
 		_spec.SetField(crontask.FieldData, field.TypeJSON, value)
 	}
+	_spec.AddModifiers(ctu.modifiers...)
 	if n, err = sqlgraph.UpdateNodes(ctx, ctu.driver, _spec); err != nil {
 		if _, ok := err.(*sqlgraph.NotFoundError); ok {
 			err = &NotFoundError{crontask.Label}
@@ -290,21 +269,15 @@ func (ctu *CronTaskUpdate) sqlSave(ctx context.Context) (n int, err error) {
 // CronTaskUpdateOne is the builder for updating a single CronTask entity.
 type CronTaskUpdateOne struct {
 	config
-	fields   []string
-	hooks    []Hook
-	mutation *CronTaskMutation
+	fields    []string
+	hooks     []Hook
+	mutation  *CronTaskMutation
+	modifiers []func(*sql.UpdateBuilder)
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (ctuo *CronTaskUpdateOne) SetUpdatedAt(i int64) *CronTaskUpdateOne {
-	ctuo.mutation.ResetUpdatedAt()
-	ctuo.mutation.SetUpdatedAt(i)
-	return ctuo
-}
-
-// AddUpdatedAt adds i to the "updated_at" field.
-func (ctuo *CronTaskUpdateOne) AddUpdatedAt(i int64) *CronTaskUpdateOne {
-	ctuo.mutation.AddUpdatedAt(i)
+func (ctuo *CronTaskUpdateOne) SetUpdatedAt(t time.Time) *CronTaskUpdateOne {
+	ctuo.mutation.SetUpdatedAt(t)
 	return ctuo
 }
 
@@ -363,47 +336,33 @@ func (ctuo *CronTaskUpdateOne) SetNillableStatus(ms *models.TaskStatus) *CronTas
 }
 
 // SetScheduledAfter sets the "scheduled_after" field.
-func (ctuo *CronTaskUpdateOne) SetScheduledAfter(i int64) *CronTaskUpdateOne {
-	ctuo.mutation.ResetScheduledAfter()
-	ctuo.mutation.SetScheduledAfter(i)
+func (ctuo *CronTaskUpdateOne) SetScheduledAfter(t time.Time) *CronTaskUpdateOne {
+	ctuo.mutation.SetScheduledAfter(t)
 	return ctuo
 }
 
 // SetNillableScheduledAfter sets the "scheduled_after" field if the given value is not nil.
-func (ctuo *CronTaskUpdateOne) SetNillableScheduledAfter(i *int64) *CronTaskUpdateOne {
-	if i != nil {
-		ctuo.SetScheduledAfter(*i)
+func (ctuo *CronTaskUpdateOne) SetNillableScheduledAfter(t *time.Time) *CronTaskUpdateOne {
+	if t != nil {
+		ctuo.SetScheduledAfter(*t)
 	}
 	return ctuo
 }
 
-// AddScheduledAfter adds i to the "scheduled_after" field.
-func (ctuo *CronTaskUpdateOne) AddScheduledAfter(i int64) *CronTaskUpdateOne {
-	ctuo.mutation.AddScheduledAfter(i)
-	return ctuo
-}
-
 // SetLastRun sets the "last_run" field.
-func (ctuo *CronTaskUpdateOne) SetLastRun(i int64) *CronTaskUpdateOne {
-	ctuo.mutation.ResetLastRun()
-	ctuo.mutation.SetLastRun(i)
+func (ctuo *CronTaskUpdateOne) SetLastRun(t time.Time) *CronTaskUpdateOne {
+	ctuo.mutation.SetLastRun(t)
 	return ctuo
 }
 
 // SetNillableLastRun sets the "last_run" field if the given value is not nil.
-func (ctuo *CronTaskUpdateOne) SetNillableLastRun(i *int64) *CronTaskUpdateOne {
-	if i != nil {
-		ctuo.SetLastRun(*i)
+func (ctuo *CronTaskUpdateOne) SetNillableLastRun(t *time.Time) *CronTaskUpdateOne {
+	if t != nil {
+		ctuo.SetLastRun(*t)
 	}
 	return ctuo
 }
 
-// AddLastRun adds i to the "last_run" field.
-func (ctuo *CronTaskUpdateOne) AddLastRun(i int64) *CronTaskUpdateOne {
-	ctuo.mutation.AddLastRun(i)
-	return ctuo
-}
-
 // SetLogs sets the "logs" field.
 func (ctuo *CronTaskUpdateOne) SetLogs(ml []models.TaskLog) *CronTaskUpdateOne {
 	ctuo.mutation.SetLogs(ml)
@@ -496,6 +455,12 @@ func (ctuo *CronTaskUpdateOne) check() error {
 	return nil
 }
 
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (ctuo *CronTaskUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *CronTaskUpdateOne {
+	ctuo.modifiers = append(ctuo.modifiers, modifiers...)
+	return ctuo
+}
+
 func (ctuo *CronTaskUpdateOne) sqlSave(ctx context.Context) (_node *CronTask, err error) {
 	if err := ctuo.check(); err != nil {
 		return _node, err
@@ -526,10 +491,7 @@ func (ctuo *CronTaskUpdateOne) sqlSave(ctx context.Context) (_node *CronTask, er
 		}
 	}
 	if value, ok := ctuo.mutation.UpdatedAt(); ok {
-		_spec.SetField(crontask.FieldUpdatedAt, field.TypeInt64, value)
-	}
-	if value, ok := ctuo.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(crontask.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(crontask.FieldUpdatedAt, field.TypeTime, value)
 	}
 	if value, ok := ctuo.mutation.GetType(); ok {
 		_spec.SetField(crontask.FieldType, field.TypeEnum, value)
@@ -549,16 +511,10 @@ func (ctuo *CronTaskUpdateOne) sqlSave(ctx context.Context) (_node *CronTask, er
 		_spec.SetField(crontask.FieldStatus, field.TypeEnum, value)
 	}
 	if value, ok := ctuo.mutation.ScheduledAfter(); ok {
-		_spec.SetField(crontask.FieldScheduledAfter, field.TypeInt64, value)
-	}
-	if value, ok := ctuo.mutation.AddedScheduledAfter(); ok {
-		_spec.AddField(crontask.FieldScheduledAfter, field.TypeInt64, value)
+		_spec.SetField(crontask.FieldScheduledAfter, field.TypeTime, value)
 	}
 	if value, ok := ctuo.mutation.LastRun(); ok {
-		_spec.SetField(crontask.FieldLastRun, field.TypeInt64, value)
-	}
-	if value, ok := ctuo.mutation.AddedLastRun(); ok {
-		_spec.AddField(crontask.FieldLastRun, field.TypeInt64, value)
+		_spec.SetField(crontask.FieldLastRun, field.TypeTime, value)
 	}
 	if value, ok := ctuo.mutation.Logs(); ok {
 		_spec.SetField(crontask.FieldLogs, field.TypeJSON, value)
@@ -571,6 +527,7 @@ func (ctuo *CronTaskUpdateOne) sqlSave(ctx context.Context) (_node *CronTask, er
 	if value, ok := ctuo.mutation.Data(); ok {
 		_spec.SetField(crontask.FieldData, field.TypeJSON, value)
 	}
+	_spec.AddModifiers(ctuo.modifiers...)
 	_node = &CronTask{config: ctuo.config}
 	_spec.Assign = _node.assignValues
 	_spec.ScanValues = _node.scanValues
diff --git a/internal/database/ent/db/discordinteraction.go b/internal/database/ent/db/discordinteraction.go
index 9ac0f690..3e28cba8 100644
--- a/internal/database/ent/db/discordinteraction.go
+++ b/internal/database/ent/db/discordinteraction.go
@@ -6,6 +6,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"strings"
+	"time"
 
 	"entgo.io/ent"
 	"entgo.io/ent/dialect/sql"
@@ -20,9 +21,9 @@ type DiscordInteraction struct {
 	// ID of the ent.
 	ID string `json:"id,omitempty"`
 	// CreatedAt holds the value of the "created_at" field.
-	CreatedAt int64 `json:"created_at,omitempty"`
+	CreatedAt time.Time `json:"created_at,omitempty"`
 	// UpdatedAt holds the value of the "updated_at" field.
-	UpdatedAt int64 `json:"updated_at,omitempty"`
+	UpdatedAt time.Time `json:"updated_at,omitempty"`
 	// Command holds the value of the "command" field.
 	Command string `json:"command,omitempty"`
 	// UserID holds the value of the "user_id" field.
@@ -68,10 +69,10 @@ func (*DiscordInteraction) scanValues(columns []string) ([]any, error) {
 		switch columns[i] {
 		case discordinteraction.FieldOptions:
 			values[i] = new([]byte)
-		case discordinteraction.FieldCreatedAt, discordinteraction.FieldUpdatedAt:
-			values[i] = new(sql.NullInt64)
 		case discordinteraction.FieldID, discordinteraction.FieldCommand, discordinteraction.FieldUserID, discordinteraction.FieldReferenceID, discordinteraction.FieldType, discordinteraction.FieldLocale:
 			values[i] = new(sql.NullString)
+		case discordinteraction.FieldCreatedAt, discordinteraction.FieldUpdatedAt:
+			values[i] = new(sql.NullTime)
 		default:
 			values[i] = new(sql.UnknownType)
 		}
@@ -94,16 +95,16 @@ func (di *DiscordInteraction) assignValues(columns []string, values []any) error
 				di.ID = value.String
 			}
 		case discordinteraction.FieldCreatedAt:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field created_at", values[i])
 			} else if value.Valid {
-				di.CreatedAt = value.Int64
+				di.CreatedAt = value.Time
 			}
 		case discordinteraction.FieldUpdatedAt:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
 			} else if value.Valid {
-				di.UpdatedAt = value.Int64
+				di.UpdatedAt = value.Time
 			}
 		case discordinteraction.FieldCommand:
 			if value, ok := values[i].(*sql.NullString); !ok {
@@ -185,10 +186,10 @@ func (di *DiscordInteraction) String() string {
 	builder.WriteString("DiscordInteraction(")
 	builder.WriteString(fmt.Sprintf("id=%v, ", di.ID))
 	builder.WriteString("created_at=")
-	builder.WriteString(fmt.Sprintf("%v", di.CreatedAt))
+	builder.WriteString(di.CreatedAt.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("updated_at=")
-	builder.WriteString(fmt.Sprintf("%v", di.UpdatedAt))
+	builder.WriteString(di.UpdatedAt.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("command=")
 	builder.WriteString(di.Command)
diff --git a/internal/database/ent/db/discordinteraction/discordinteraction.go b/internal/database/ent/db/discordinteraction/discordinteraction.go
index 3bad3cbe..7891a96c 100644
--- a/internal/database/ent/db/discordinteraction/discordinteraction.go
+++ b/internal/database/ent/db/discordinteraction/discordinteraction.go
@@ -4,6 +4,7 @@ package discordinteraction
 
 import (
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
@@ -69,11 +70,11 @@ func ValidColumn(column string) bool {
 
 var (
 	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
-	DefaultCreatedAt func() int64
+	DefaultCreatedAt func() time.Time
 	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
-	DefaultUpdatedAt func() int64
+	DefaultUpdatedAt func() time.Time
 	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
-	UpdateDefaultUpdatedAt func() int64
+	UpdateDefaultUpdatedAt func() time.Time
 	// CommandValidator is a validator for the "command" field. It is called by the builders before save.
 	CommandValidator func(string) error
 	// UserIDValidator is a validator for the "user_id" field. It is called by the builders before save.
diff --git a/internal/database/ent/db/discordinteraction/where.go b/internal/database/ent/db/discordinteraction/where.go
index 1b38d92e..bd219db5 100644
--- a/internal/database/ent/db/discordinteraction/where.go
+++ b/internal/database/ent/db/discordinteraction/where.go
@@ -3,6 +3,8 @@
 package discordinteraction
 
 import (
+	"time"
+
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
@@ -65,12 +67,12 @@ func IDContainsFold(id string) predicate.DiscordInteraction {
 }
 
 // CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
-func CreatedAt(v int64) predicate.DiscordInteraction {
+func CreatedAt(v time.Time) predicate.DiscordInteraction {
 	return predicate.DiscordInteraction(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
-func UpdatedAt(v int64) predicate.DiscordInteraction {
+func UpdatedAt(v time.Time) predicate.DiscordInteraction {
 	return predicate.DiscordInteraction(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
@@ -95,82 +97,82 @@ func Locale(v string) predicate.DiscordInteraction {
 }
 
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v int64) predicate.DiscordInteraction {
+func CreatedAtEQ(v time.Time) predicate.DiscordInteraction {
 	return predicate.DiscordInteraction(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v int64) predicate.DiscordInteraction {
+func CreatedAtNEQ(v time.Time) predicate.DiscordInteraction {
 	return predicate.DiscordInteraction(sql.FieldNEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...int64) predicate.DiscordInteraction {
+func CreatedAtIn(vs ...time.Time) predicate.DiscordInteraction {
 	return predicate.DiscordInteraction(sql.FieldIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...int64) predicate.DiscordInteraction {
+func CreatedAtNotIn(vs ...time.Time) predicate.DiscordInteraction {
 	return predicate.DiscordInteraction(sql.FieldNotIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v int64) predicate.DiscordInteraction {
+func CreatedAtGT(v time.Time) predicate.DiscordInteraction {
 	return predicate.DiscordInteraction(sql.FieldGT(FieldCreatedAt, v))
 }
 
 // CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v int64) predicate.DiscordInteraction {
+func CreatedAtGTE(v time.Time) predicate.DiscordInteraction {
 	return predicate.DiscordInteraction(sql.FieldGTE(FieldCreatedAt, v))
 }
 
 // CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v int64) predicate.DiscordInteraction {
+func CreatedAtLT(v time.Time) predicate.DiscordInteraction {
 	return predicate.DiscordInteraction(sql.FieldLT(FieldCreatedAt, v))
 }
 
 // CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v int64) predicate.DiscordInteraction {
+func CreatedAtLTE(v time.Time) predicate.DiscordInteraction {
 	return predicate.DiscordInteraction(sql.FieldLTE(FieldCreatedAt, v))
 }
 
 // UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
-func UpdatedAtEQ(v int64) predicate.DiscordInteraction {
+func UpdatedAtEQ(v time.Time) predicate.DiscordInteraction {
 	return predicate.DiscordInteraction(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
-func UpdatedAtNEQ(v int64) predicate.DiscordInteraction {
+func UpdatedAtNEQ(v time.Time) predicate.DiscordInteraction {
 	return predicate.DiscordInteraction(sql.FieldNEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtIn applies the In predicate on the "updated_at" field.
-func UpdatedAtIn(vs ...int64) predicate.DiscordInteraction {
+func UpdatedAtIn(vs ...time.Time) predicate.DiscordInteraction {
 	return predicate.DiscordInteraction(sql.FieldIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
-func UpdatedAtNotIn(vs ...int64) predicate.DiscordInteraction {
+func UpdatedAtNotIn(vs ...time.Time) predicate.DiscordInteraction {
 	return predicate.DiscordInteraction(sql.FieldNotIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtGT applies the GT predicate on the "updated_at" field.
-func UpdatedAtGT(v int64) predicate.DiscordInteraction {
+func UpdatedAtGT(v time.Time) predicate.DiscordInteraction {
 	return predicate.DiscordInteraction(sql.FieldGT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
-func UpdatedAtGTE(v int64) predicate.DiscordInteraction {
+func UpdatedAtGTE(v time.Time) predicate.DiscordInteraction {
 	return predicate.DiscordInteraction(sql.FieldGTE(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLT applies the LT predicate on the "updated_at" field.
-func UpdatedAtLT(v int64) predicate.DiscordInteraction {
+func UpdatedAtLT(v time.Time) predicate.DiscordInteraction {
 	return predicate.DiscordInteraction(sql.FieldLT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
-func UpdatedAtLTE(v int64) predicate.DiscordInteraction {
+func UpdatedAtLTE(v time.Time) predicate.DiscordInteraction {
 	return predicate.DiscordInteraction(sql.FieldLTE(FieldUpdatedAt, v))
 }
 
diff --git a/internal/database/ent/db/discordinteraction_create.go b/internal/database/ent/db/discordinteraction_create.go
index 45583113..97f37791 100644
--- a/internal/database/ent/db/discordinteraction_create.go
+++ b/internal/database/ent/db/discordinteraction_create.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"entgo.io/ent/schema/field"
@@ -22,29 +23,29 @@ type DiscordInteractionCreate struct {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (dic *DiscordInteractionCreate) SetCreatedAt(i int64) *DiscordInteractionCreate {
-	dic.mutation.SetCreatedAt(i)
+func (dic *DiscordInteractionCreate) SetCreatedAt(t time.Time) *DiscordInteractionCreate {
+	dic.mutation.SetCreatedAt(t)
 	return dic
 }
 
 // SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
-func (dic *DiscordInteractionCreate) SetNillableCreatedAt(i *int64) *DiscordInteractionCreate {
-	if i != nil {
-		dic.SetCreatedAt(*i)
+func (dic *DiscordInteractionCreate) SetNillableCreatedAt(t *time.Time) *DiscordInteractionCreate {
+	if t != nil {
+		dic.SetCreatedAt(*t)
 	}
 	return dic
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (dic *DiscordInteractionCreate) SetUpdatedAt(i int64) *DiscordInteractionCreate {
-	dic.mutation.SetUpdatedAt(i)
+func (dic *DiscordInteractionCreate) SetUpdatedAt(t time.Time) *DiscordInteractionCreate {
+	dic.mutation.SetUpdatedAt(t)
 	return dic
 }
 
 // SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
-func (dic *DiscordInteractionCreate) SetNillableUpdatedAt(i *int64) *DiscordInteractionCreate {
-	if i != nil {
-		dic.SetUpdatedAt(*i)
+func (dic *DiscordInteractionCreate) SetNillableUpdatedAt(t *time.Time) *DiscordInteractionCreate {
+	if t != nil {
+		dic.SetUpdatedAt(*t)
 	}
 	return dic
 }
@@ -238,11 +239,11 @@ func (dic *DiscordInteractionCreate) createSpec() (*DiscordInteraction, *sqlgrap
 		_spec.ID.Value = id
 	}
 	if value, ok := dic.mutation.CreatedAt(); ok {
-		_spec.SetField(discordinteraction.FieldCreatedAt, field.TypeInt64, value)
+		_spec.SetField(discordinteraction.FieldCreatedAt, field.TypeTime, value)
 		_node.CreatedAt = value
 	}
 	if value, ok := dic.mutation.UpdatedAt(); ok {
-		_spec.SetField(discordinteraction.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(discordinteraction.FieldUpdatedAt, field.TypeTime, value)
 		_node.UpdatedAt = value
 	}
 	if value, ok := dic.mutation.Command(); ok {
diff --git a/internal/database/ent/db/discordinteraction_query.go b/internal/database/ent/db/discordinteraction_query.go
index bd085984..54ded610 100644
--- a/internal/database/ent/db/discordinteraction_query.go
+++ b/internal/database/ent/db/discordinteraction_query.go
@@ -23,6 +23,7 @@ type DiscordInteractionQuery struct {
 	inters     []Interceptor
 	predicates []predicate.DiscordInteraction
 	withUser   *UserQuery
+	modifiers  []func(*sql.Selector)
 	// intermediate query (i.e. traversal path).
 	sql  *sql.Selector
 	path func(context.Context) (*sql.Selector, error)
@@ -297,7 +298,7 @@ func (diq *DiscordInteractionQuery) WithUser(opts ...func(*UserQuery)) *DiscordI
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int64 `json:"created_at,omitempty"`
+//		CreatedAt time.Time `json:"created_at,omitempty"`
 //		Count int `json:"count,omitempty"`
 //	}
 //
@@ -320,7 +321,7 @@ func (diq *DiscordInteractionQuery) GroupBy(field string, fields ...string) *Dis
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int64 `json:"created_at,omitempty"`
+//		CreatedAt time.Time `json:"created_at,omitempty"`
 //	}
 //
 //	client.DiscordInteraction.Query().
@@ -382,6 +383,9 @@ func (diq *DiscordInteractionQuery) sqlAll(ctx context.Context, hooks ...queryHo
 		node.Edges.loadedTypes = loadedTypes
 		return node.assignValues(columns, values)
 	}
+	if len(diq.modifiers) > 0 {
+		_spec.Modifiers = diq.modifiers
+	}
 	for i := range hooks {
 		hooks[i](ctx, _spec)
 	}
@@ -432,6 +436,9 @@ func (diq *DiscordInteractionQuery) loadUser(ctx context.Context, query *UserQue
 
 func (diq *DiscordInteractionQuery) sqlCount(ctx context.Context) (int, error) {
 	_spec := diq.querySpec()
+	if len(diq.modifiers) > 0 {
+		_spec.Modifiers = diq.modifiers
+	}
 	_spec.Node.Columns = diq.ctx.Fields
 	if len(diq.ctx.Fields) > 0 {
 		_spec.Unique = diq.ctx.Unique != nil && *diq.ctx.Unique
@@ -497,6 +504,9 @@ func (diq *DiscordInteractionQuery) sqlQuery(ctx context.Context) *sql.Selector
 	if diq.ctx.Unique != nil && *diq.ctx.Unique {
 		selector.Distinct()
 	}
+	for _, m := range diq.modifiers {
+		m(selector)
+	}
 	for _, p := range diq.predicates {
 		p(selector)
 	}
@@ -514,6 +524,12 @@ func (diq *DiscordInteractionQuery) sqlQuery(ctx context.Context) *sql.Selector
 	return selector
 }
 
+// Modify adds a query modifier for attaching custom logic to queries.
+func (diq *DiscordInteractionQuery) Modify(modifiers ...func(s *sql.Selector)) *DiscordInteractionSelect {
+	diq.modifiers = append(diq.modifiers, modifiers...)
+	return diq.Select()
+}
+
 // DiscordInteractionGroupBy is the group-by builder for DiscordInteraction entities.
 type DiscordInteractionGroupBy struct {
 	selector
@@ -603,3 +619,9 @@ func (dis *DiscordInteractionSelect) sqlScan(ctx context.Context, root *DiscordI
 	defer rows.Close()
 	return sql.ScanSlice(rows, v)
 }
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (dis *DiscordInteractionSelect) Modify(modifiers ...func(s *sql.Selector)) *DiscordInteractionSelect {
+	dis.modifiers = append(dis.modifiers, modifiers...)
+	return dis
+}
diff --git a/internal/database/ent/db/discordinteraction_update.go b/internal/database/ent/db/discordinteraction_update.go
index 3b039729..304c4c49 100644
--- a/internal/database/ent/db/discordinteraction_update.go
+++ b/internal/database/ent/db/discordinteraction_update.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
@@ -18,8 +19,9 @@ import (
 // DiscordInteractionUpdate is the builder for updating DiscordInteraction entities.
 type DiscordInteractionUpdate struct {
 	config
-	hooks    []Hook
-	mutation *DiscordInteractionMutation
+	hooks     []Hook
+	mutation  *DiscordInteractionMutation
+	modifiers []func(*sql.UpdateBuilder)
 }
 
 // Where appends a list predicates to the DiscordInteractionUpdate builder.
@@ -29,15 +31,8 @@ func (diu *DiscordInteractionUpdate) Where(ps ...predicate.DiscordInteraction) *
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (diu *DiscordInteractionUpdate) SetUpdatedAt(i int64) *DiscordInteractionUpdate {
-	diu.mutation.ResetUpdatedAt()
-	diu.mutation.SetUpdatedAt(i)
-	return diu
-}
-
-// AddUpdatedAt adds i to the "updated_at" field.
-func (diu *DiscordInteractionUpdate) AddUpdatedAt(i int64) *DiscordInteractionUpdate {
-	diu.mutation.AddUpdatedAt(i)
+func (diu *DiscordInteractionUpdate) SetUpdatedAt(t time.Time) *DiscordInteractionUpdate {
+	diu.mutation.SetUpdatedAt(t)
 	return diu
 }
 
@@ -175,6 +170,12 @@ func (diu *DiscordInteractionUpdate) check() error {
 	return nil
 }
 
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (diu *DiscordInteractionUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *DiscordInteractionUpdate {
+	diu.modifiers = append(diu.modifiers, modifiers...)
+	return diu
+}
+
 func (diu *DiscordInteractionUpdate) sqlSave(ctx context.Context) (n int, err error) {
 	if err := diu.check(); err != nil {
 		return n, err
@@ -188,10 +189,7 @@ func (diu *DiscordInteractionUpdate) sqlSave(ctx context.Context) (n int, err er
 		}
 	}
 	if value, ok := diu.mutation.UpdatedAt(); ok {
-		_spec.SetField(discordinteraction.FieldUpdatedAt, field.TypeInt64, value)
-	}
-	if value, ok := diu.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(discordinteraction.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(discordinteraction.FieldUpdatedAt, field.TypeTime, value)
 	}
 	if value, ok := diu.mutation.Command(); ok {
 		_spec.SetField(discordinteraction.FieldCommand, field.TypeString, value)
@@ -208,6 +206,7 @@ func (diu *DiscordInteractionUpdate) sqlSave(ctx context.Context) (n int, err er
 	if value, ok := diu.mutation.Options(); ok {
 		_spec.SetField(discordinteraction.FieldOptions, field.TypeJSON, value)
 	}
+	_spec.AddModifiers(diu.modifiers...)
 	if n, err = sqlgraph.UpdateNodes(ctx, diu.driver, _spec); err != nil {
 		if _, ok := err.(*sqlgraph.NotFoundError); ok {
 			err = &NotFoundError{discordinteraction.Label}
@@ -223,21 +222,15 @@ func (diu *DiscordInteractionUpdate) sqlSave(ctx context.Context) (n int, err er
 // DiscordInteractionUpdateOne is the builder for updating a single DiscordInteraction entity.
 type DiscordInteractionUpdateOne struct {
 	config
-	fields   []string
-	hooks    []Hook
-	mutation *DiscordInteractionMutation
+	fields    []string
+	hooks     []Hook
+	mutation  *DiscordInteractionMutation
+	modifiers []func(*sql.UpdateBuilder)
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (diuo *DiscordInteractionUpdateOne) SetUpdatedAt(i int64) *DiscordInteractionUpdateOne {
-	diuo.mutation.ResetUpdatedAt()
-	diuo.mutation.SetUpdatedAt(i)
-	return diuo
-}
-
-// AddUpdatedAt adds i to the "updated_at" field.
-func (diuo *DiscordInteractionUpdateOne) AddUpdatedAt(i int64) *DiscordInteractionUpdateOne {
-	diuo.mutation.AddUpdatedAt(i)
+func (diuo *DiscordInteractionUpdateOne) SetUpdatedAt(t time.Time) *DiscordInteractionUpdateOne {
+	diuo.mutation.SetUpdatedAt(t)
 	return diuo
 }
 
@@ -388,6 +381,12 @@ func (diuo *DiscordInteractionUpdateOne) check() error {
 	return nil
 }
 
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (diuo *DiscordInteractionUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *DiscordInteractionUpdateOne {
+	diuo.modifiers = append(diuo.modifiers, modifiers...)
+	return diuo
+}
+
 func (diuo *DiscordInteractionUpdateOne) sqlSave(ctx context.Context) (_node *DiscordInteraction, err error) {
 	if err := diuo.check(); err != nil {
 		return _node, err
@@ -418,10 +417,7 @@ func (diuo *DiscordInteractionUpdateOne) sqlSave(ctx context.Context) (_node *Di
 		}
 	}
 	if value, ok := diuo.mutation.UpdatedAt(); ok {
-		_spec.SetField(discordinteraction.FieldUpdatedAt, field.TypeInt64, value)
-	}
-	if value, ok := diuo.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(discordinteraction.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(discordinteraction.FieldUpdatedAt, field.TypeTime, value)
 	}
 	if value, ok := diuo.mutation.Command(); ok {
 		_spec.SetField(discordinteraction.FieldCommand, field.TypeString, value)
@@ -438,6 +434,7 @@ func (diuo *DiscordInteractionUpdateOne) sqlSave(ctx context.Context) (_node *Di
 	if value, ok := diuo.mutation.Options(); ok {
 		_spec.SetField(discordinteraction.FieldOptions, field.TypeJSON, value)
 	}
+	_spec.AddModifiers(diuo.modifiers...)
 	_node = &DiscordInteraction{config: diuo.config}
 	_spec.Assign = _node.assignValues
 	_spec.ScanValues = _node.scanValues
diff --git a/internal/database/ent/db/expose.go b/internal/database/ent/db/expose.go
new file mode 100644
index 00000000..4cc0d120
--- /dev/null
+++ b/internal/database/ent/db/expose.go
@@ -0,0 +1,200 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import "fmt"
+
+func (a *Account) AssignValues(columns []string, values []any) error {
+	if a == nil {
+		return fmt.Errorf("Account(nil)")
+	}
+	return a.assignValues(columns, values)
+}
+func (a *Account) ScanValues(columns []string) ([]any, error) {
+	if a == nil {
+		return nil, fmt.Errorf("Account(nil)")
+	}
+	return a.scanValues(columns)
+}
+
+func (as *AccountSnapshot) AssignValues(columns []string, values []any) error {
+	if as == nil {
+		return fmt.Errorf("AccountSnapshot(nil)")
+	}
+	return as.assignValues(columns, values)
+}
+func (as *AccountSnapshot) ScanValues(columns []string) ([]any, error) {
+	if as == nil {
+		return nil, fmt.Errorf("AccountSnapshot(nil)")
+	}
+	return as.scanValues(columns)
+}
+
+func (as *AchievementsSnapshot) AssignValues(columns []string, values []any) error {
+	if as == nil {
+		return fmt.Errorf("AchievementsSnapshot(nil)")
+	}
+	return as.assignValues(columns, values)
+}
+func (as *AchievementsSnapshot) ScanValues(columns []string) ([]any, error) {
+	if as == nil {
+		return nil, fmt.Errorf("AchievementsSnapshot(nil)")
+	}
+	return as.scanValues(columns)
+}
+
+func (ac *AppConfiguration) AssignValues(columns []string, values []any) error {
+	if ac == nil {
+		return fmt.Errorf("AppConfiguration(nil)")
+	}
+	return ac.assignValues(columns, values)
+}
+func (ac *AppConfiguration) ScanValues(columns []string) ([]any, error) {
+	if ac == nil {
+		return nil, fmt.Errorf("AppConfiguration(nil)")
+	}
+	return ac.scanValues(columns)
+}
+
+func (ac *ApplicationCommand) AssignValues(columns []string, values []any) error {
+	if ac == nil {
+		return fmt.Errorf("ApplicationCommand(nil)")
+	}
+	return ac.assignValues(columns, values)
+}
+func (ac *ApplicationCommand) ScanValues(columns []string) ([]any, error) {
+	if ac == nil {
+		return nil, fmt.Errorf("ApplicationCommand(nil)")
+	}
+	return ac.scanValues(columns)
+}
+
+func (c *Clan) AssignValues(columns []string, values []any) error {
+	if c == nil {
+		return fmt.Errorf("Clan(nil)")
+	}
+	return c.assignValues(columns, values)
+}
+func (c *Clan) ScanValues(columns []string) ([]any, error) {
+	if c == nil {
+		return nil, fmt.Errorf("Clan(nil)")
+	}
+	return c.scanValues(columns)
+}
+
+func (ct *CronTask) AssignValues(columns []string, values []any) error {
+	if ct == nil {
+		return fmt.Errorf("CronTask(nil)")
+	}
+	return ct.assignValues(columns, values)
+}
+func (ct *CronTask) ScanValues(columns []string) ([]any, error) {
+	if ct == nil {
+		return nil, fmt.Errorf("CronTask(nil)")
+	}
+	return ct.scanValues(columns)
+}
+
+func (di *DiscordInteraction) AssignValues(columns []string, values []any) error {
+	if di == nil {
+		return fmt.Errorf("DiscordInteraction(nil)")
+	}
+	return di.assignValues(columns, values)
+}
+func (di *DiscordInteraction) ScanValues(columns []string) ([]any, error) {
+	if di == nil {
+		return nil, fmt.Errorf("DiscordInteraction(nil)")
+	}
+	return di.scanValues(columns)
+}
+
+func (u *User) AssignValues(columns []string, values []any) error {
+	if u == nil {
+		return fmt.Errorf("User(nil)")
+	}
+	return u.assignValues(columns, values)
+}
+func (u *User) ScanValues(columns []string) ([]any, error) {
+	if u == nil {
+		return nil, fmt.Errorf("User(nil)")
+	}
+	return u.scanValues(columns)
+}
+
+func (uc *UserConnection) AssignValues(columns []string, values []any) error {
+	if uc == nil {
+		return fmt.Errorf("UserConnection(nil)")
+	}
+	return uc.assignValues(columns, values)
+}
+func (uc *UserConnection) ScanValues(columns []string) ([]any, error) {
+	if uc == nil {
+		return nil, fmt.Errorf("UserConnection(nil)")
+	}
+	return uc.scanValues(columns)
+}
+
+func (uc *UserContent) AssignValues(columns []string, values []any) error {
+	if uc == nil {
+		return fmt.Errorf("UserContent(nil)")
+	}
+	return uc.assignValues(columns, values)
+}
+func (uc *UserContent) ScanValues(columns []string) ([]any, error) {
+	if uc == nil {
+		return nil, fmt.Errorf("UserContent(nil)")
+	}
+	return uc.scanValues(columns)
+}
+
+func (us *UserSubscription) AssignValues(columns []string, values []any) error {
+	if us == nil {
+		return fmt.Errorf("UserSubscription(nil)")
+	}
+	return us.assignValues(columns, values)
+}
+func (us *UserSubscription) ScanValues(columns []string) ([]any, error) {
+	if us == nil {
+		return nil, fmt.Errorf("UserSubscription(nil)")
+	}
+	return us.scanValues(columns)
+}
+
+func (v *Vehicle) AssignValues(columns []string, values []any) error {
+	if v == nil {
+		return fmt.Errorf("Vehicle(nil)")
+	}
+	return v.assignValues(columns, values)
+}
+func (v *Vehicle) ScanValues(columns []string) ([]any, error) {
+	if v == nil {
+		return nil, fmt.Errorf("Vehicle(nil)")
+	}
+	return v.scanValues(columns)
+}
+
+func (va *VehicleAverage) AssignValues(columns []string, values []any) error {
+	if va == nil {
+		return fmt.Errorf("VehicleAverage(nil)")
+	}
+	return va.assignValues(columns, values)
+}
+func (va *VehicleAverage) ScanValues(columns []string) ([]any, error) {
+	if va == nil {
+		return nil, fmt.Errorf("VehicleAverage(nil)")
+	}
+	return va.scanValues(columns)
+}
+
+func (vs *VehicleSnapshot) AssignValues(columns []string, values []any) error {
+	if vs == nil {
+		return fmt.Errorf("VehicleSnapshot(nil)")
+	}
+	return vs.assignValues(columns, values)
+}
+func (vs *VehicleSnapshot) ScanValues(columns []string) ([]any, error) {
+	if vs == nil {
+		return nil, fmt.Errorf("VehicleSnapshot(nil)")
+	}
+	return vs.scanValues(columns)
+}
diff --git a/internal/database/ent/db/migrate/schema.go b/internal/database/ent/db/migrate/schema.go
index 716a4a3c..15f56785 100644
--- a/internal/database/ent/db/migrate/schema.go
+++ b/internal/database/ent/db/migrate/schema.go
@@ -11,10 +11,10 @@ var (
 	// AccountsColumns holds the columns for the "accounts" table.
 	AccountsColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeString, Unique: true},
-		{Name: "created_at", Type: field.TypeInt64},
-		{Name: "updated_at", Type: field.TypeInt64},
-		{Name: "last_battle_time", Type: field.TypeInt64},
-		{Name: "account_created_at", Type: field.TypeInt64},
+		{Name: "created_at", Type: field.TypeTime},
+		{Name: "updated_at", Type: field.TypeTime},
+		{Name: "last_battle_time", Type: field.TypeTime},
+		{Name: "account_created_at", Type: field.TypeTime},
 		{Name: "realm", Type: field.TypeString, Size: 5},
 		{Name: "nickname", Type: field.TypeString},
 		{Name: "private", Type: field.TypeBool, Default: false},
@@ -64,10 +64,10 @@ var (
 	// AccountSnapshotsColumns holds the columns for the "account_snapshots" table.
 	AccountSnapshotsColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeString, Unique: true},
-		{Name: "created_at", Type: field.TypeInt64},
-		{Name: "updated_at", Type: field.TypeInt64},
+		{Name: "created_at", Type: field.TypeTime},
+		{Name: "updated_at", Type: field.TypeTime},
 		{Name: "type", Type: field.TypeEnum, Enums: []string{"live", "daily"}},
-		{Name: "last_battle_time", Type: field.TypeInt64},
+		{Name: "last_battle_time", Type: field.TypeTime},
 		{Name: "reference_id", Type: field.TypeString},
 		{Name: "rating_battles", Type: field.TypeInt},
 		{Name: "rating_frame", Type: field.TypeJSON},
@@ -119,12 +119,12 @@ var (
 	// AchievementsSnapshotsColumns holds the columns for the "achievements_snapshots" table.
 	AchievementsSnapshotsColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeString, Unique: true},
-		{Name: "created_at", Type: field.TypeInt64},
-		{Name: "updated_at", Type: field.TypeInt64},
+		{Name: "created_at", Type: field.TypeTime},
+		{Name: "updated_at", Type: field.TypeTime},
 		{Name: "type", Type: field.TypeEnum, Enums: []string{"live", "daily"}},
 		{Name: "reference_id", Type: field.TypeString},
 		{Name: "battles", Type: field.TypeInt},
-		{Name: "last_battle_time", Type: field.TypeInt64},
+		{Name: "last_battle_time", Type: field.TypeTime},
 		{Name: "data", Type: field.TypeJSON},
 		{Name: "account_id", Type: field.TypeString},
 	}
@@ -167,8 +167,8 @@ var (
 	// AppConfigurationsColumns holds the columns for the "app_configurations" table.
 	AppConfigurationsColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeString, Unique: true},
-		{Name: "created_at", Type: field.TypeInt64},
-		{Name: "updated_at", Type: field.TypeInt64},
+		{Name: "created_at", Type: field.TypeTime},
+		{Name: "updated_at", Type: field.TypeTime},
 		{Name: "key", Type: field.TypeString, Unique: true},
 		{Name: "value", Type: field.TypeJSON},
 		{Name: "metadata", Type: field.TypeJSON, Nullable: true},
@@ -194,8 +194,8 @@ var (
 	// ApplicationCommandsColumns holds the columns for the "application_commands" table.
 	ApplicationCommandsColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeString, Unique: true},
-		{Name: "created_at", Type: field.TypeInt64},
-		{Name: "updated_at", Type: field.TypeInt64},
+		{Name: "created_at", Type: field.TypeTime},
+		{Name: "updated_at", Type: field.TypeTime},
 		{Name: "name", Type: field.TypeString},
 		{Name: "version", Type: field.TypeString},
 		{Name: "options_hash", Type: field.TypeString},
@@ -221,8 +221,8 @@ var (
 	// ClansColumns holds the columns for the "clans" table.
 	ClansColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeString, Unique: true},
-		{Name: "created_at", Type: field.TypeInt64},
-		{Name: "updated_at", Type: field.TypeInt64},
+		{Name: "created_at", Type: field.TypeTime},
+		{Name: "updated_at", Type: field.TypeTime},
 		{Name: "tag", Type: field.TypeString},
 		{Name: "name", Type: field.TypeString},
 		{Name: "emblem_id", Type: field.TypeString, Nullable: true, Default: ""},
@@ -254,14 +254,14 @@ var (
 	// CronTasksColumns holds the columns for the "cron_tasks" table.
 	CronTasksColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeString, Unique: true},
-		{Name: "created_at", Type: field.TypeInt64},
-		{Name: "updated_at", Type: field.TypeInt64},
+		{Name: "created_at", Type: field.TypeTime},
+		{Name: "updated_at", Type: field.TypeTime},
 		{Name: "type", Type: field.TypeEnum, Enums: []string{"UPDATE_CLANS", "RECORD_SNAPSHOTS", "CLEANUP_DATABASE"}},
 		{Name: "reference_id", Type: field.TypeString},
 		{Name: "targets", Type: field.TypeJSON},
 		{Name: "status", Type: field.TypeEnum, Enums: []string{"TASK_SCHEDULED", "TASK_IN_PROGRESS", "TASK_COMPLETE", "TASK_FAILED"}},
-		{Name: "scheduled_after", Type: field.TypeInt64},
-		{Name: "last_run", Type: field.TypeInt64},
+		{Name: "scheduled_after", Type: field.TypeTime},
+		{Name: "last_run", Type: field.TypeTime},
 		{Name: "logs", Type: field.TypeJSON},
 		{Name: "data", Type: field.TypeJSON},
 	}
@@ -301,8 +301,8 @@ var (
 	// DiscordInteractionsColumns holds the columns for the "discord_interactions" table.
 	DiscordInteractionsColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeString, Unique: true},
-		{Name: "created_at", Type: field.TypeInt64},
-		{Name: "updated_at", Type: field.TypeInt64},
+		{Name: "created_at", Type: field.TypeTime},
+		{Name: "updated_at", Type: field.TypeTime},
 		{Name: "command", Type: field.TypeString},
 		{Name: "reference_id", Type: field.TypeString},
 		{Name: "type", Type: field.TypeEnum, Enums: []string{"stats"}},
@@ -354,8 +354,8 @@ var (
 	// UsersColumns holds the columns for the "users" table.
 	UsersColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeString, Unique: true},
-		{Name: "created_at", Type: field.TypeInt64},
-		{Name: "updated_at", Type: field.TypeInt64},
+		{Name: "created_at", Type: field.TypeTime},
+		{Name: "updated_at", Type: field.TypeTime},
 		{Name: "permissions", Type: field.TypeString, Default: ""},
 		{Name: "feature_flags", Type: field.TypeJSON, Nullable: true},
 	}
@@ -375,8 +375,8 @@ var (
 	// UserConnectionsColumns holds the columns for the "user_connections" table.
 	UserConnectionsColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeString, Unique: true},
-		{Name: "created_at", Type: field.TypeInt64},
-		{Name: "updated_at", Type: field.TypeInt64},
+		{Name: "created_at", Type: field.TypeTime},
+		{Name: "updated_at", Type: field.TypeTime},
 		{Name: "type", Type: field.TypeEnum, Enums: []string{"wargaming"}},
 		{Name: "reference_id", Type: field.TypeString},
 		{Name: "permissions", Type: field.TypeString, Nullable: true, Default: ""},
@@ -432,8 +432,8 @@ var (
 	// UserContentsColumns holds the columns for the "user_contents" table.
 	UserContentsColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeString, Unique: true},
-		{Name: "created_at", Type: field.TypeInt64},
-		{Name: "updated_at", Type: field.TypeInt64},
+		{Name: "created_at", Type: field.TypeTime},
+		{Name: "updated_at", Type: field.TypeTime},
 		{Name: "type", Type: field.TypeEnum, Enums: []string{"clan-background-image", "personal-background-image"}},
 		{Name: "reference_id", Type: field.TypeString},
 		{Name: "value", Type: field.TypeString},
@@ -484,10 +484,10 @@ var (
 	// UserSubscriptionsColumns holds the columns for the "user_subscriptions" table.
 	UserSubscriptionsColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeString, Unique: true},
-		{Name: "created_at", Type: field.TypeInt64},
-		{Name: "updated_at", Type: field.TypeInt64},
+		{Name: "created_at", Type: field.TypeTime},
+		{Name: "updated_at", Type: field.TypeTime},
 		{Name: "type", Type: field.TypeEnum, Enums: []string{"aftermath-pro", "aftermath-pro-clan", "aftermath-plus", "supporter", "verified-clan", "server-moderator", "content-moderator", "developer", "server-booster", "content-translator"}},
-		{Name: "expires_at", Type: field.TypeInt64},
+		{Name: "expires_at", Type: field.TypeTime},
 		{Name: "permissions", Type: field.TypeString},
 		{Name: "reference_id", Type: field.TypeString},
 		{Name: "user_id", Type: field.TypeString},
@@ -536,8 +536,8 @@ var (
 	// VehiclesColumns holds the columns for the "vehicles" table.
 	VehiclesColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeString, Unique: true},
-		{Name: "created_at", Type: field.TypeInt64},
-		{Name: "updated_at", Type: field.TypeInt64},
+		{Name: "created_at", Type: field.TypeTime},
+		{Name: "updated_at", Type: field.TypeTime},
 		{Name: "tier", Type: field.TypeInt},
 		{Name: "localized_names", Type: field.TypeJSON},
 	}
@@ -557,8 +557,8 @@ var (
 	// VehicleAveragesColumns holds the columns for the "vehicle_averages" table.
 	VehicleAveragesColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeString, Unique: true},
-		{Name: "created_at", Type: field.TypeInt64},
-		{Name: "updated_at", Type: field.TypeInt64},
+		{Name: "created_at", Type: field.TypeTime},
+		{Name: "updated_at", Type: field.TypeTime},
 		{Name: "data", Type: field.TypeJSON},
 	}
 	// VehicleAveragesTable holds the schema information for the "vehicle_averages" table.
@@ -577,13 +577,13 @@ var (
 	// VehicleSnapshotsColumns holds the columns for the "vehicle_snapshots" table.
 	VehicleSnapshotsColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeString, Unique: true},
-		{Name: "created_at", Type: field.TypeInt64},
-		{Name: "updated_at", Type: field.TypeInt64},
+		{Name: "created_at", Type: field.TypeTime},
+		{Name: "updated_at", Type: field.TypeTime},
 		{Name: "type", Type: field.TypeEnum, Enums: []string{"live", "daily"}},
 		{Name: "vehicle_id", Type: field.TypeString},
 		{Name: "reference_id", Type: field.TypeString},
 		{Name: "battles", Type: field.TypeInt},
-		{Name: "last_battle_time", Type: field.TypeInt64},
+		{Name: "last_battle_time", Type: field.TypeTime},
 		{Name: "frame", Type: field.TypeJSON},
 		{Name: "account_id", Type: field.TypeString},
 	}
diff --git a/internal/database/ent/db/mutation.go b/internal/database/ent/db/mutation.go
index 1dcee88e..c4078845 100644
--- a/internal/database/ent/db/mutation.go
+++ b/internal/database/ent/db/mutation.go
@@ -7,6 +7,7 @@ import (
 	"errors"
 	"fmt"
 	"sync"
+	"time"
 
 	"entgo.io/ent"
 	"entgo.io/ent/dialect/sql"
@@ -63,14 +64,10 @@ type AccountMutation struct {
 	op                           Op
 	typ                          string
 	id                           *string
-	created_at                   *int64
-	addcreated_at                *int64
-	updated_at                   *int64
-	addupdated_at                *int64
-	last_battle_time             *int64
-	addlast_battle_time          *int64
-	account_created_at           *int64
-	addaccount_created_at        *int64
+	created_at                   *time.Time
+	updated_at                   *time.Time
+	last_battle_time             *time.Time
+	account_created_at           *time.Time
 	realm                        *string
 	nickname                     *string
 	private                      *bool
@@ -196,13 +193,12 @@ func (m *AccountMutation) IDs(ctx context.Context) ([]string, error) {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (m *AccountMutation) SetCreatedAt(i int64) {
-	m.created_at = &i
-	m.addcreated_at = nil
+func (m *AccountMutation) SetCreatedAt(t time.Time) {
+	m.created_at = &t
 }
 
 // CreatedAt returns the value of the "created_at" field in the mutation.
-func (m *AccountMutation) CreatedAt() (r int64, exists bool) {
+func (m *AccountMutation) CreatedAt() (r time.Time, exists bool) {
 	v := m.created_at
 	if v == nil {
 		return
@@ -213,7 +209,7 @@ func (m *AccountMutation) CreatedAt() (r int64, exists bool) {
 // OldCreatedAt returns the old "created_at" field's value of the Account entity.
 // If the Account object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *AccountMutation) OldCreatedAt(ctx context.Context) (v int64, err error) {
+func (m *AccountMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
 	}
@@ -227,38 +223,18 @@ func (m *AccountMutation) OldCreatedAt(ctx context.Context) (v int64, err error)
 	return oldValue.CreatedAt, nil
 }
 
-// AddCreatedAt adds i to the "created_at" field.
-func (m *AccountMutation) AddCreatedAt(i int64) {
-	if m.addcreated_at != nil {
-		*m.addcreated_at += i
-	} else {
-		m.addcreated_at = &i
-	}
-}
-
-// AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
-func (m *AccountMutation) AddedCreatedAt() (r int64, exists bool) {
-	v := m.addcreated_at
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetCreatedAt resets all changes to the "created_at" field.
 func (m *AccountMutation) ResetCreatedAt() {
 	m.created_at = nil
-	m.addcreated_at = nil
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (m *AccountMutation) SetUpdatedAt(i int64) {
-	m.updated_at = &i
-	m.addupdated_at = nil
+func (m *AccountMutation) SetUpdatedAt(t time.Time) {
+	m.updated_at = &t
 }
 
 // UpdatedAt returns the value of the "updated_at" field in the mutation.
-func (m *AccountMutation) UpdatedAt() (r int64, exists bool) {
+func (m *AccountMutation) UpdatedAt() (r time.Time, exists bool) {
 	v := m.updated_at
 	if v == nil {
 		return
@@ -269,7 +245,7 @@ func (m *AccountMutation) UpdatedAt() (r int64, exists bool) {
 // OldUpdatedAt returns the old "updated_at" field's value of the Account entity.
 // If the Account object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *AccountMutation) OldUpdatedAt(ctx context.Context) (v int64, err error) {
+func (m *AccountMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
 	}
@@ -283,38 +259,18 @@ func (m *AccountMutation) OldUpdatedAt(ctx context.Context) (v int64, err error)
 	return oldValue.UpdatedAt, nil
 }
 
-// AddUpdatedAt adds i to the "updated_at" field.
-func (m *AccountMutation) AddUpdatedAt(i int64) {
-	if m.addupdated_at != nil {
-		*m.addupdated_at += i
-	} else {
-		m.addupdated_at = &i
-	}
-}
-
-// AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
-func (m *AccountMutation) AddedUpdatedAt() (r int64, exists bool) {
-	v := m.addupdated_at
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetUpdatedAt resets all changes to the "updated_at" field.
 func (m *AccountMutation) ResetUpdatedAt() {
 	m.updated_at = nil
-	m.addupdated_at = nil
 }
 
 // SetLastBattleTime sets the "last_battle_time" field.
-func (m *AccountMutation) SetLastBattleTime(i int64) {
-	m.last_battle_time = &i
-	m.addlast_battle_time = nil
+func (m *AccountMutation) SetLastBattleTime(t time.Time) {
+	m.last_battle_time = &t
 }
 
 // LastBattleTime returns the value of the "last_battle_time" field in the mutation.
-func (m *AccountMutation) LastBattleTime() (r int64, exists bool) {
+func (m *AccountMutation) LastBattleTime() (r time.Time, exists bool) {
 	v := m.last_battle_time
 	if v == nil {
 		return
@@ -325,7 +281,7 @@ func (m *AccountMutation) LastBattleTime() (r int64, exists bool) {
 // OldLastBattleTime returns the old "last_battle_time" field's value of the Account entity.
 // If the Account object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *AccountMutation) OldLastBattleTime(ctx context.Context) (v int64, err error) {
+func (m *AccountMutation) OldLastBattleTime(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldLastBattleTime is only allowed on UpdateOne operations")
 	}
@@ -339,38 +295,18 @@ func (m *AccountMutation) OldLastBattleTime(ctx context.Context) (v int64, err e
 	return oldValue.LastBattleTime, nil
 }
 
-// AddLastBattleTime adds i to the "last_battle_time" field.
-func (m *AccountMutation) AddLastBattleTime(i int64) {
-	if m.addlast_battle_time != nil {
-		*m.addlast_battle_time += i
-	} else {
-		m.addlast_battle_time = &i
-	}
-}
-
-// AddedLastBattleTime returns the value that was added to the "last_battle_time" field in this mutation.
-func (m *AccountMutation) AddedLastBattleTime() (r int64, exists bool) {
-	v := m.addlast_battle_time
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetLastBattleTime resets all changes to the "last_battle_time" field.
 func (m *AccountMutation) ResetLastBattleTime() {
 	m.last_battle_time = nil
-	m.addlast_battle_time = nil
 }
 
 // SetAccountCreatedAt sets the "account_created_at" field.
-func (m *AccountMutation) SetAccountCreatedAt(i int64) {
-	m.account_created_at = &i
-	m.addaccount_created_at = nil
+func (m *AccountMutation) SetAccountCreatedAt(t time.Time) {
+	m.account_created_at = &t
 }
 
 // AccountCreatedAt returns the value of the "account_created_at" field in the mutation.
-func (m *AccountMutation) AccountCreatedAt() (r int64, exists bool) {
+func (m *AccountMutation) AccountCreatedAt() (r time.Time, exists bool) {
 	v := m.account_created_at
 	if v == nil {
 		return
@@ -381,7 +317,7 @@ func (m *AccountMutation) AccountCreatedAt() (r int64, exists bool) {
 // OldAccountCreatedAt returns the old "account_created_at" field's value of the Account entity.
 // If the Account object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *AccountMutation) OldAccountCreatedAt(ctx context.Context) (v int64, err error) {
+func (m *AccountMutation) OldAccountCreatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldAccountCreatedAt is only allowed on UpdateOne operations")
 	}
@@ -395,28 +331,9 @@ func (m *AccountMutation) OldAccountCreatedAt(ctx context.Context) (v int64, err
 	return oldValue.AccountCreatedAt, nil
 }
 
-// AddAccountCreatedAt adds i to the "account_created_at" field.
-func (m *AccountMutation) AddAccountCreatedAt(i int64) {
-	if m.addaccount_created_at != nil {
-		*m.addaccount_created_at += i
-	} else {
-		m.addaccount_created_at = &i
-	}
-}
-
-// AddedAccountCreatedAt returns the value that was added to the "account_created_at" field in this mutation.
-func (m *AccountMutation) AddedAccountCreatedAt() (r int64, exists bool) {
-	v := m.addaccount_created_at
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetAccountCreatedAt resets all changes to the "account_created_at" field.
 func (m *AccountMutation) ResetAccountCreatedAt() {
 	m.account_created_at = nil
-	m.addaccount_created_at = nil
 }
 
 // SetRealm sets the "realm" field.
@@ -883,28 +800,28 @@ func (m *AccountMutation) OldField(ctx context.Context, name string) (ent.Value,
 func (m *AccountMutation) SetField(name string, value ent.Value) error {
 	switch name {
 	case account.FieldCreatedAt:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetCreatedAt(v)
 		return nil
 	case account.FieldUpdatedAt:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetUpdatedAt(v)
 		return nil
 	case account.FieldLastBattleTime:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetLastBattleTime(v)
 		return nil
 	case account.FieldAccountCreatedAt:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -945,36 +862,13 @@ func (m *AccountMutation) SetField(name string, value ent.Value) error {
 // AddedFields returns all numeric fields that were incremented/decremented during
 // this mutation.
 func (m *AccountMutation) AddedFields() []string {
-	var fields []string
-	if m.addcreated_at != nil {
-		fields = append(fields, account.FieldCreatedAt)
-	}
-	if m.addupdated_at != nil {
-		fields = append(fields, account.FieldUpdatedAt)
-	}
-	if m.addlast_battle_time != nil {
-		fields = append(fields, account.FieldLastBattleTime)
-	}
-	if m.addaccount_created_at != nil {
-		fields = append(fields, account.FieldAccountCreatedAt)
-	}
-	return fields
+	return nil
 }
 
 // AddedField returns the numeric value that was incremented/decremented on a field
 // with the given name. The second boolean return value indicates that this field
 // was not set, or was not defined in the schema.
 func (m *AccountMutation) AddedField(name string) (ent.Value, bool) {
-	switch name {
-	case account.FieldCreatedAt:
-		return m.AddedCreatedAt()
-	case account.FieldUpdatedAt:
-		return m.AddedUpdatedAt()
-	case account.FieldLastBattleTime:
-		return m.AddedLastBattleTime()
-	case account.FieldAccountCreatedAt:
-		return m.AddedAccountCreatedAt()
-	}
 	return nil, false
 }
 
@@ -983,34 +877,6 @@ func (m *AccountMutation) AddedField(name string) (ent.Value, bool) {
 // type.
 func (m *AccountMutation) AddField(name string, value ent.Value) error {
 	switch name {
-	case account.FieldCreatedAt:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddCreatedAt(v)
-		return nil
-	case account.FieldUpdatedAt:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddUpdatedAt(v)
-		return nil
-	case account.FieldLastBattleTime:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddLastBattleTime(v)
-		return nil
-	case account.FieldAccountCreatedAt:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddAccountCreatedAt(v)
-		return nil
 	}
 	return fmt.Errorf("unknown Account numeric field %s", name)
 }
@@ -1232,29 +1098,26 @@ func (m *AccountMutation) ResetEdge(name string) error {
 // AccountSnapshotMutation represents an operation that mutates the AccountSnapshot nodes in the graph.
 type AccountSnapshotMutation struct {
 	config
-	op                  Op
-	typ                 string
-	id                  *string
-	created_at          *int64
-	addcreated_at       *int64
-	updated_at          *int64
-	addupdated_at       *int64
-	_type               *models.SnapshotType
-	last_battle_time    *int64
-	addlast_battle_time *int64
-	reference_id        *string
-	rating_battles      *int
-	addrating_battles   *int
-	rating_frame        *frame.StatsFrame
-	regular_battles     *int
-	addregular_battles  *int
-	regular_frame       *frame.StatsFrame
-	clearedFields       map[string]struct{}
-	account             *string
-	clearedaccount      bool
-	done                bool
-	oldValue            func(context.Context) (*AccountSnapshot, error)
-	predicates          []predicate.AccountSnapshot
+	op                 Op
+	typ                string
+	id                 *string
+	created_at         *time.Time
+	updated_at         *time.Time
+	_type              *models.SnapshotType
+	last_battle_time   *time.Time
+	reference_id       *string
+	rating_battles     *int
+	addrating_battles  *int
+	rating_frame       *frame.StatsFrame
+	regular_battles    *int
+	addregular_battles *int
+	regular_frame      *frame.StatsFrame
+	clearedFields      map[string]struct{}
+	account            *string
+	clearedaccount     bool
+	done               bool
+	oldValue           func(context.Context) (*AccountSnapshot, error)
+	predicates         []predicate.AccountSnapshot
 }
 
 var _ ent.Mutation = (*AccountSnapshotMutation)(nil)
@@ -1362,13 +1225,12 @@ func (m *AccountSnapshotMutation) IDs(ctx context.Context) ([]string, error) {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (m *AccountSnapshotMutation) SetCreatedAt(i int64) {
-	m.created_at = &i
-	m.addcreated_at = nil
+func (m *AccountSnapshotMutation) SetCreatedAt(t time.Time) {
+	m.created_at = &t
 }
 
 // CreatedAt returns the value of the "created_at" field in the mutation.
-func (m *AccountSnapshotMutation) CreatedAt() (r int64, exists bool) {
+func (m *AccountSnapshotMutation) CreatedAt() (r time.Time, exists bool) {
 	v := m.created_at
 	if v == nil {
 		return
@@ -1379,7 +1241,7 @@ func (m *AccountSnapshotMutation) CreatedAt() (r int64, exists bool) {
 // OldCreatedAt returns the old "created_at" field's value of the AccountSnapshot entity.
 // If the AccountSnapshot object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *AccountSnapshotMutation) OldCreatedAt(ctx context.Context) (v int64, err error) {
+func (m *AccountSnapshotMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
 	}
@@ -1393,38 +1255,18 @@ func (m *AccountSnapshotMutation) OldCreatedAt(ctx context.Context) (v int64, er
 	return oldValue.CreatedAt, nil
 }
 
-// AddCreatedAt adds i to the "created_at" field.
-func (m *AccountSnapshotMutation) AddCreatedAt(i int64) {
-	if m.addcreated_at != nil {
-		*m.addcreated_at += i
-	} else {
-		m.addcreated_at = &i
-	}
-}
-
-// AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
-func (m *AccountSnapshotMutation) AddedCreatedAt() (r int64, exists bool) {
-	v := m.addcreated_at
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetCreatedAt resets all changes to the "created_at" field.
 func (m *AccountSnapshotMutation) ResetCreatedAt() {
 	m.created_at = nil
-	m.addcreated_at = nil
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (m *AccountSnapshotMutation) SetUpdatedAt(i int64) {
-	m.updated_at = &i
-	m.addupdated_at = nil
+func (m *AccountSnapshotMutation) SetUpdatedAt(t time.Time) {
+	m.updated_at = &t
 }
 
 // UpdatedAt returns the value of the "updated_at" field in the mutation.
-func (m *AccountSnapshotMutation) UpdatedAt() (r int64, exists bool) {
+func (m *AccountSnapshotMutation) UpdatedAt() (r time.Time, exists bool) {
 	v := m.updated_at
 	if v == nil {
 		return
@@ -1435,7 +1277,7 @@ func (m *AccountSnapshotMutation) UpdatedAt() (r int64, exists bool) {
 // OldUpdatedAt returns the old "updated_at" field's value of the AccountSnapshot entity.
 // If the AccountSnapshot object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *AccountSnapshotMutation) OldUpdatedAt(ctx context.Context) (v int64, err error) {
+func (m *AccountSnapshotMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
 	}
@@ -1449,28 +1291,9 @@ func (m *AccountSnapshotMutation) OldUpdatedAt(ctx context.Context) (v int64, er
 	return oldValue.UpdatedAt, nil
 }
 
-// AddUpdatedAt adds i to the "updated_at" field.
-func (m *AccountSnapshotMutation) AddUpdatedAt(i int64) {
-	if m.addupdated_at != nil {
-		*m.addupdated_at += i
-	} else {
-		m.addupdated_at = &i
-	}
-}
-
-// AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
-func (m *AccountSnapshotMutation) AddedUpdatedAt() (r int64, exists bool) {
-	v := m.addupdated_at
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetUpdatedAt resets all changes to the "updated_at" field.
 func (m *AccountSnapshotMutation) ResetUpdatedAt() {
 	m.updated_at = nil
-	m.addupdated_at = nil
 }
 
 // SetType sets the "type" field.
@@ -1510,13 +1333,12 @@ func (m *AccountSnapshotMutation) ResetType() {
 }
 
 // SetLastBattleTime sets the "last_battle_time" field.
-func (m *AccountSnapshotMutation) SetLastBattleTime(i int64) {
-	m.last_battle_time = &i
-	m.addlast_battle_time = nil
+func (m *AccountSnapshotMutation) SetLastBattleTime(t time.Time) {
+	m.last_battle_time = &t
 }
 
 // LastBattleTime returns the value of the "last_battle_time" field in the mutation.
-func (m *AccountSnapshotMutation) LastBattleTime() (r int64, exists bool) {
+func (m *AccountSnapshotMutation) LastBattleTime() (r time.Time, exists bool) {
 	v := m.last_battle_time
 	if v == nil {
 		return
@@ -1527,7 +1349,7 @@ func (m *AccountSnapshotMutation) LastBattleTime() (r int64, exists bool) {
 // OldLastBattleTime returns the old "last_battle_time" field's value of the AccountSnapshot entity.
 // If the AccountSnapshot object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *AccountSnapshotMutation) OldLastBattleTime(ctx context.Context) (v int64, err error) {
+func (m *AccountSnapshotMutation) OldLastBattleTime(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldLastBattleTime is only allowed on UpdateOne operations")
 	}
@@ -1541,28 +1363,9 @@ func (m *AccountSnapshotMutation) OldLastBattleTime(ctx context.Context) (v int6
 	return oldValue.LastBattleTime, nil
 }
 
-// AddLastBattleTime adds i to the "last_battle_time" field.
-func (m *AccountSnapshotMutation) AddLastBattleTime(i int64) {
-	if m.addlast_battle_time != nil {
-		*m.addlast_battle_time += i
-	} else {
-		m.addlast_battle_time = &i
-	}
-}
-
-// AddedLastBattleTime returns the value that was added to the "last_battle_time" field in this mutation.
-func (m *AccountSnapshotMutation) AddedLastBattleTime() (r int64, exists bool) {
-	v := m.addlast_battle_time
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetLastBattleTime resets all changes to the "last_battle_time" field.
 func (m *AccountSnapshotMutation) ResetLastBattleTime() {
 	m.last_battle_time = nil
-	m.addlast_battle_time = nil
 }
 
 // SetAccountID sets the "account_id" field.
@@ -1980,14 +1783,14 @@ func (m *AccountSnapshotMutation) OldField(ctx context.Context, name string) (en
 func (m *AccountSnapshotMutation) SetField(name string, value ent.Value) error {
 	switch name {
 	case accountsnapshot.FieldCreatedAt:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetCreatedAt(v)
 		return nil
 	case accountsnapshot.FieldUpdatedAt:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -2001,7 +1804,7 @@ func (m *AccountSnapshotMutation) SetField(name string, value ent.Value) error {
 		m.SetType(v)
 		return nil
 	case accountsnapshot.FieldLastBattleTime:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -2057,15 +1860,6 @@ func (m *AccountSnapshotMutation) SetField(name string, value ent.Value) error {
 // this mutation.
 func (m *AccountSnapshotMutation) AddedFields() []string {
 	var fields []string
-	if m.addcreated_at != nil {
-		fields = append(fields, accountsnapshot.FieldCreatedAt)
-	}
-	if m.addupdated_at != nil {
-		fields = append(fields, accountsnapshot.FieldUpdatedAt)
-	}
-	if m.addlast_battle_time != nil {
-		fields = append(fields, accountsnapshot.FieldLastBattleTime)
-	}
 	if m.addrating_battles != nil {
 		fields = append(fields, accountsnapshot.FieldRatingBattles)
 	}
@@ -2080,12 +1874,6 @@ func (m *AccountSnapshotMutation) AddedFields() []string {
 // was not set, or was not defined in the schema.
 func (m *AccountSnapshotMutation) AddedField(name string) (ent.Value, bool) {
 	switch name {
-	case accountsnapshot.FieldCreatedAt:
-		return m.AddedCreatedAt()
-	case accountsnapshot.FieldUpdatedAt:
-		return m.AddedUpdatedAt()
-	case accountsnapshot.FieldLastBattleTime:
-		return m.AddedLastBattleTime()
 	case accountsnapshot.FieldRatingBattles:
 		return m.AddedRatingBattles()
 	case accountsnapshot.FieldRegularBattles:
@@ -2099,27 +1887,6 @@ func (m *AccountSnapshotMutation) AddedField(name string) (ent.Value, bool) {
 // type.
 func (m *AccountSnapshotMutation) AddField(name string, value ent.Value) error {
 	switch name {
-	case accountsnapshot.FieldCreatedAt:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddCreatedAt(v)
-		return nil
-	case accountsnapshot.FieldUpdatedAt:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddUpdatedAt(v)
-		return nil
-	case accountsnapshot.FieldLastBattleTime:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddLastBattleTime(v)
-		return nil
 	case accountsnapshot.FieldRatingBattles:
 		v, ok := value.(int)
 		if !ok {
@@ -2272,26 +2039,23 @@ func (m *AccountSnapshotMutation) ResetEdge(name string) error {
 // AchievementsSnapshotMutation represents an operation that mutates the AchievementsSnapshot nodes in the graph.
 type AchievementsSnapshotMutation struct {
 	config
-	op                  Op
-	typ                 string
-	id                  *string
-	created_at          *int64
-	addcreated_at       *int64
-	updated_at          *int64
-	addupdated_at       *int64
-	_type               *models.SnapshotType
-	reference_id        *string
-	battles             *int
-	addbattles          *int
-	last_battle_time    *int64
-	addlast_battle_time *int64
-	data                *types.AchievementsFrame
-	clearedFields       map[string]struct{}
-	account             *string
-	clearedaccount      bool
-	done                bool
-	oldValue            func(context.Context) (*AchievementsSnapshot, error)
-	predicates          []predicate.AchievementsSnapshot
+	op               Op
+	typ              string
+	id               *string
+	created_at       *time.Time
+	updated_at       *time.Time
+	_type            *models.SnapshotType
+	reference_id     *string
+	battles          *int
+	addbattles       *int
+	last_battle_time *time.Time
+	data             *types.AchievementsFrame
+	clearedFields    map[string]struct{}
+	account          *string
+	clearedaccount   bool
+	done             bool
+	oldValue         func(context.Context) (*AchievementsSnapshot, error)
+	predicates       []predicate.AchievementsSnapshot
 }
 
 var _ ent.Mutation = (*AchievementsSnapshotMutation)(nil)
@@ -2399,13 +2163,12 @@ func (m *AchievementsSnapshotMutation) IDs(ctx context.Context) ([]string, error
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (m *AchievementsSnapshotMutation) SetCreatedAt(i int64) {
-	m.created_at = &i
-	m.addcreated_at = nil
+func (m *AchievementsSnapshotMutation) SetCreatedAt(t time.Time) {
+	m.created_at = &t
 }
 
 // CreatedAt returns the value of the "created_at" field in the mutation.
-func (m *AchievementsSnapshotMutation) CreatedAt() (r int64, exists bool) {
+func (m *AchievementsSnapshotMutation) CreatedAt() (r time.Time, exists bool) {
 	v := m.created_at
 	if v == nil {
 		return
@@ -2416,7 +2179,7 @@ func (m *AchievementsSnapshotMutation) CreatedAt() (r int64, exists bool) {
 // OldCreatedAt returns the old "created_at" field's value of the AchievementsSnapshot entity.
 // If the AchievementsSnapshot object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *AchievementsSnapshotMutation) OldCreatedAt(ctx context.Context) (v int64, err error) {
+func (m *AchievementsSnapshotMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
 	}
@@ -2430,38 +2193,18 @@ func (m *AchievementsSnapshotMutation) OldCreatedAt(ctx context.Context) (v int6
 	return oldValue.CreatedAt, nil
 }
 
-// AddCreatedAt adds i to the "created_at" field.
-func (m *AchievementsSnapshotMutation) AddCreatedAt(i int64) {
-	if m.addcreated_at != nil {
-		*m.addcreated_at += i
-	} else {
-		m.addcreated_at = &i
-	}
-}
-
-// AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
-func (m *AchievementsSnapshotMutation) AddedCreatedAt() (r int64, exists bool) {
-	v := m.addcreated_at
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetCreatedAt resets all changes to the "created_at" field.
 func (m *AchievementsSnapshotMutation) ResetCreatedAt() {
 	m.created_at = nil
-	m.addcreated_at = nil
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (m *AchievementsSnapshotMutation) SetUpdatedAt(i int64) {
-	m.updated_at = &i
-	m.addupdated_at = nil
+func (m *AchievementsSnapshotMutation) SetUpdatedAt(t time.Time) {
+	m.updated_at = &t
 }
 
 // UpdatedAt returns the value of the "updated_at" field in the mutation.
-func (m *AchievementsSnapshotMutation) UpdatedAt() (r int64, exists bool) {
+func (m *AchievementsSnapshotMutation) UpdatedAt() (r time.Time, exists bool) {
 	v := m.updated_at
 	if v == nil {
 		return
@@ -2472,7 +2215,7 @@ func (m *AchievementsSnapshotMutation) UpdatedAt() (r int64, exists bool) {
 // OldUpdatedAt returns the old "updated_at" field's value of the AchievementsSnapshot entity.
 // If the AchievementsSnapshot object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *AchievementsSnapshotMutation) OldUpdatedAt(ctx context.Context) (v int64, err error) {
+func (m *AchievementsSnapshotMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
 	}
@@ -2486,28 +2229,9 @@ func (m *AchievementsSnapshotMutation) OldUpdatedAt(ctx context.Context) (v int6
 	return oldValue.UpdatedAt, nil
 }
 
-// AddUpdatedAt adds i to the "updated_at" field.
-func (m *AchievementsSnapshotMutation) AddUpdatedAt(i int64) {
-	if m.addupdated_at != nil {
-		*m.addupdated_at += i
-	} else {
-		m.addupdated_at = &i
-	}
-}
-
-// AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
-func (m *AchievementsSnapshotMutation) AddedUpdatedAt() (r int64, exists bool) {
-	v := m.addupdated_at
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetUpdatedAt resets all changes to the "updated_at" field.
 func (m *AchievementsSnapshotMutation) ResetUpdatedAt() {
 	m.updated_at = nil
-	m.addupdated_at = nil
 }
 
 // SetType sets the "type" field.
@@ -2675,13 +2399,12 @@ func (m *AchievementsSnapshotMutation) ResetBattles() {
 }
 
 // SetLastBattleTime sets the "last_battle_time" field.
-func (m *AchievementsSnapshotMutation) SetLastBattleTime(i int64) {
-	m.last_battle_time = &i
-	m.addlast_battle_time = nil
+func (m *AchievementsSnapshotMutation) SetLastBattleTime(t time.Time) {
+	m.last_battle_time = &t
 }
 
 // LastBattleTime returns the value of the "last_battle_time" field in the mutation.
-func (m *AchievementsSnapshotMutation) LastBattleTime() (r int64, exists bool) {
+func (m *AchievementsSnapshotMutation) LastBattleTime() (r time.Time, exists bool) {
 	v := m.last_battle_time
 	if v == nil {
 		return
@@ -2692,7 +2415,7 @@ func (m *AchievementsSnapshotMutation) LastBattleTime() (r int64, exists bool) {
 // OldLastBattleTime returns the old "last_battle_time" field's value of the AchievementsSnapshot entity.
 // If the AchievementsSnapshot object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *AchievementsSnapshotMutation) OldLastBattleTime(ctx context.Context) (v int64, err error) {
+func (m *AchievementsSnapshotMutation) OldLastBattleTime(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldLastBattleTime is only allowed on UpdateOne operations")
 	}
@@ -2706,28 +2429,9 @@ func (m *AchievementsSnapshotMutation) OldLastBattleTime(ctx context.Context) (v
 	return oldValue.LastBattleTime, nil
 }
 
-// AddLastBattleTime adds i to the "last_battle_time" field.
-func (m *AchievementsSnapshotMutation) AddLastBattleTime(i int64) {
-	if m.addlast_battle_time != nil {
-		*m.addlast_battle_time += i
-	} else {
-		m.addlast_battle_time = &i
-	}
-}
-
-// AddedLastBattleTime returns the value that was added to the "last_battle_time" field in this mutation.
-func (m *AchievementsSnapshotMutation) AddedLastBattleTime() (r int64, exists bool) {
-	v := m.addlast_battle_time
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetLastBattleTime resets all changes to the "last_battle_time" field.
 func (m *AchievementsSnapshotMutation) ResetLastBattleTime() {
 	m.last_battle_time = nil
-	m.addlast_battle_time = nil
 }
 
 // SetData sets the "data" field.
@@ -2911,14 +2615,14 @@ func (m *AchievementsSnapshotMutation) OldField(ctx context.Context, name string
 func (m *AchievementsSnapshotMutation) SetField(name string, value ent.Value) error {
 	switch name {
 	case achievementssnapshot.FieldCreatedAt:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetCreatedAt(v)
 		return nil
 	case achievementssnapshot.FieldUpdatedAt:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -2953,7 +2657,7 @@ func (m *AchievementsSnapshotMutation) SetField(name string, value ent.Value) er
 		m.SetBattles(v)
 		return nil
 	case achievementssnapshot.FieldLastBattleTime:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -2974,18 +2678,9 @@ func (m *AchievementsSnapshotMutation) SetField(name string, value ent.Value) er
 // this mutation.
 func (m *AchievementsSnapshotMutation) AddedFields() []string {
 	var fields []string
-	if m.addcreated_at != nil {
-		fields = append(fields, achievementssnapshot.FieldCreatedAt)
-	}
-	if m.addupdated_at != nil {
-		fields = append(fields, achievementssnapshot.FieldUpdatedAt)
-	}
 	if m.addbattles != nil {
 		fields = append(fields, achievementssnapshot.FieldBattles)
 	}
-	if m.addlast_battle_time != nil {
-		fields = append(fields, achievementssnapshot.FieldLastBattleTime)
-	}
 	return fields
 }
 
@@ -2994,14 +2689,8 @@ func (m *AchievementsSnapshotMutation) AddedFields() []string {
 // was not set, or was not defined in the schema.
 func (m *AchievementsSnapshotMutation) AddedField(name string) (ent.Value, bool) {
 	switch name {
-	case achievementssnapshot.FieldCreatedAt:
-		return m.AddedCreatedAt()
-	case achievementssnapshot.FieldUpdatedAt:
-		return m.AddedUpdatedAt()
 	case achievementssnapshot.FieldBattles:
 		return m.AddedBattles()
-	case achievementssnapshot.FieldLastBattleTime:
-		return m.AddedLastBattleTime()
 	}
 	return nil, false
 }
@@ -3011,20 +2700,6 @@ func (m *AchievementsSnapshotMutation) AddedField(name string) (ent.Value, bool)
 // type.
 func (m *AchievementsSnapshotMutation) AddField(name string, value ent.Value) error {
 	switch name {
-	case achievementssnapshot.FieldCreatedAt:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddCreatedAt(v)
-		return nil
-	case achievementssnapshot.FieldUpdatedAt:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddUpdatedAt(v)
-		return nil
 	case achievementssnapshot.FieldBattles:
 		v, ok := value.(int)
 		if !ok {
@@ -3032,13 +2707,6 @@ func (m *AchievementsSnapshotMutation) AddField(name string, value ent.Value) er
 		}
 		m.AddBattles(v)
 		return nil
-	case achievementssnapshot.FieldLastBattleTime:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddLastBattleTime(v)
-		return nil
 	}
 	return fmt.Errorf("unknown AchievementsSnapshot numeric field %s", name)
 }
@@ -3174,10 +2842,8 @@ type AppConfigurationMutation struct {
 	op            Op
 	typ           string
 	id            *string
-	created_at    *int64
-	addcreated_at *int64
-	updated_at    *int64
-	addupdated_at *int64
+	created_at    *time.Time
+	updated_at    *time.Time
 	key           *string
 	value         *any
 	metadata      *map[string]interface{}
@@ -3292,13 +2958,12 @@ func (m *AppConfigurationMutation) IDs(ctx context.Context) ([]string, error) {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (m *AppConfigurationMutation) SetCreatedAt(i int64) {
-	m.created_at = &i
-	m.addcreated_at = nil
+func (m *AppConfigurationMutation) SetCreatedAt(t time.Time) {
+	m.created_at = &t
 }
 
 // CreatedAt returns the value of the "created_at" field in the mutation.
-func (m *AppConfigurationMutation) CreatedAt() (r int64, exists bool) {
+func (m *AppConfigurationMutation) CreatedAt() (r time.Time, exists bool) {
 	v := m.created_at
 	if v == nil {
 		return
@@ -3309,7 +2974,7 @@ func (m *AppConfigurationMutation) CreatedAt() (r int64, exists bool) {
 // OldCreatedAt returns the old "created_at" field's value of the AppConfiguration entity.
 // If the AppConfiguration object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *AppConfigurationMutation) OldCreatedAt(ctx context.Context) (v int64, err error) {
+func (m *AppConfigurationMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
 	}
@@ -3323,38 +2988,18 @@ func (m *AppConfigurationMutation) OldCreatedAt(ctx context.Context) (v int64, e
 	return oldValue.CreatedAt, nil
 }
 
-// AddCreatedAt adds i to the "created_at" field.
-func (m *AppConfigurationMutation) AddCreatedAt(i int64) {
-	if m.addcreated_at != nil {
-		*m.addcreated_at += i
-	} else {
-		m.addcreated_at = &i
-	}
-}
-
-// AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
-func (m *AppConfigurationMutation) AddedCreatedAt() (r int64, exists bool) {
-	v := m.addcreated_at
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetCreatedAt resets all changes to the "created_at" field.
 func (m *AppConfigurationMutation) ResetCreatedAt() {
 	m.created_at = nil
-	m.addcreated_at = nil
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (m *AppConfigurationMutation) SetUpdatedAt(i int64) {
-	m.updated_at = &i
-	m.addupdated_at = nil
+func (m *AppConfigurationMutation) SetUpdatedAt(t time.Time) {
+	m.updated_at = &t
 }
 
 // UpdatedAt returns the value of the "updated_at" field in the mutation.
-func (m *AppConfigurationMutation) UpdatedAt() (r int64, exists bool) {
+func (m *AppConfigurationMutation) UpdatedAt() (r time.Time, exists bool) {
 	v := m.updated_at
 	if v == nil {
 		return
@@ -3365,7 +3010,7 @@ func (m *AppConfigurationMutation) UpdatedAt() (r int64, exists bool) {
 // OldUpdatedAt returns the old "updated_at" field's value of the AppConfiguration entity.
 // If the AppConfiguration object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *AppConfigurationMutation) OldUpdatedAt(ctx context.Context) (v int64, err error) {
+func (m *AppConfigurationMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
 	}
@@ -3379,28 +3024,9 @@ func (m *AppConfigurationMutation) OldUpdatedAt(ctx context.Context) (v int64, e
 	return oldValue.UpdatedAt, nil
 }
 
-// AddUpdatedAt adds i to the "updated_at" field.
-func (m *AppConfigurationMutation) AddUpdatedAt(i int64) {
-	if m.addupdated_at != nil {
-		*m.addupdated_at += i
-	} else {
-		m.addupdated_at = &i
-	}
-}
-
-// AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
-func (m *AppConfigurationMutation) AddedUpdatedAt() (r int64, exists bool) {
-	v := m.addupdated_at
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetUpdatedAt resets all changes to the "updated_at" field.
 func (m *AppConfigurationMutation) ResetUpdatedAt() {
 	m.updated_at = nil
-	m.addupdated_at = nil
 }
 
 // SetKey sets the "key" field.
@@ -3621,14 +3247,14 @@ func (m *AppConfigurationMutation) OldField(ctx context.Context, name string) (e
 func (m *AppConfigurationMutation) SetField(name string, value ent.Value) error {
 	switch name {
 	case appconfiguration.FieldCreatedAt:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetCreatedAt(v)
 		return nil
 	case appconfiguration.FieldUpdatedAt:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -3662,26 +3288,13 @@ func (m *AppConfigurationMutation) SetField(name string, value ent.Value) error
 // AddedFields returns all numeric fields that were incremented/decremented during
 // this mutation.
 func (m *AppConfigurationMutation) AddedFields() []string {
-	var fields []string
-	if m.addcreated_at != nil {
-		fields = append(fields, appconfiguration.FieldCreatedAt)
-	}
-	if m.addupdated_at != nil {
-		fields = append(fields, appconfiguration.FieldUpdatedAt)
-	}
-	return fields
+	return nil
 }
 
 // AddedField returns the numeric value that was incremented/decremented on a field
 // with the given name. The second boolean return value indicates that this field
 // was not set, or was not defined in the schema.
 func (m *AppConfigurationMutation) AddedField(name string) (ent.Value, bool) {
-	switch name {
-	case appconfiguration.FieldCreatedAt:
-		return m.AddedCreatedAt()
-	case appconfiguration.FieldUpdatedAt:
-		return m.AddedUpdatedAt()
-	}
 	return nil, false
 }
 
@@ -3690,20 +3303,6 @@ func (m *AppConfigurationMutation) AddedField(name string) (ent.Value, bool) {
 // type.
 func (m *AppConfigurationMutation) AddField(name string, value ent.Value) error {
 	switch name {
-	case appconfiguration.FieldCreatedAt:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddCreatedAt(v)
-		return nil
-	case appconfiguration.FieldUpdatedAt:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddUpdatedAt(v)
-		return nil
 	}
 	return fmt.Errorf("unknown AppConfiguration numeric field %s", name)
 }
@@ -3813,10 +3412,8 @@ type ApplicationCommandMutation struct {
 	op            Op
 	typ           string
 	id            *string
-	created_at    *int64
-	addcreated_at *int64
-	updated_at    *int64
-	addupdated_at *int64
+	created_at    *time.Time
+	updated_at    *time.Time
 	name          *string
 	version       *string
 	options_hash  *string
@@ -3931,13 +3528,12 @@ func (m *ApplicationCommandMutation) IDs(ctx context.Context) ([]string, error)
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (m *ApplicationCommandMutation) SetCreatedAt(i int64) {
-	m.created_at = &i
-	m.addcreated_at = nil
+func (m *ApplicationCommandMutation) SetCreatedAt(t time.Time) {
+	m.created_at = &t
 }
 
 // CreatedAt returns the value of the "created_at" field in the mutation.
-func (m *ApplicationCommandMutation) CreatedAt() (r int64, exists bool) {
+func (m *ApplicationCommandMutation) CreatedAt() (r time.Time, exists bool) {
 	v := m.created_at
 	if v == nil {
 		return
@@ -3948,7 +3544,7 @@ func (m *ApplicationCommandMutation) CreatedAt() (r int64, exists bool) {
 // OldCreatedAt returns the old "created_at" field's value of the ApplicationCommand entity.
 // If the ApplicationCommand object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *ApplicationCommandMutation) OldCreatedAt(ctx context.Context) (v int64, err error) {
+func (m *ApplicationCommandMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
 	}
@@ -3962,38 +3558,18 @@ func (m *ApplicationCommandMutation) OldCreatedAt(ctx context.Context) (v int64,
 	return oldValue.CreatedAt, nil
 }
 
-// AddCreatedAt adds i to the "created_at" field.
-func (m *ApplicationCommandMutation) AddCreatedAt(i int64) {
-	if m.addcreated_at != nil {
-		*m.addcreated_at += i
-	} else {
-		m.addcreated_at = &i
-	}
-}
-
-// AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
-func (m *ApplicationCommandMutation) AddedCreatedAt() (r int64, exists bool) {
-	v := m.addcreated_at
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetCreatedAt resets all changes to the "created_at" field.
 func (m *ApplicationCommandMutation) ResetCreatedAt() {
 	m.created_at = nil
-	m.addcreated_at = nil
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (m *ApplicationCommandMutation) SetUpdatedAt(i int64) {
-	m.updated_at = &i
-	m.addupdated_at = nil
+func (m *ApplicationCommandMutation) SetUpdatedAt(t time.Time) {
+	m.updated_at = &t
 }
 
 // UpdatedAt returns the value of the "updated_at" field in the mutation.
-func (m *ApplicationCommandMutation) UpdatedAt() (r int64, exists bool) {
+func (m *ApplicationCommandMutation) UpdatedAt() (r time.Time, exists bool) {
 	v := m.updated_at
 	if v == nil {
 		return
@@ -4004,7 +3580,7 @@ func (m *ApplicationCommandMutation) UpdatedAt() (r int64, exists bool) {
 // OldUpdatedAt returns the old "updated_at" field's value of the ApplicationCommand entity.
 // If the ApplicationCommand object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *ApplicationCommandMutation) OldUpdatedAt(ctx context.Context) (v int64, err error) {
+func (m *ApplicationCommandMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
 	}
@@ -4018,28 +3594,9 @@ func (m *ApplicationCommandMutation) OldUpdatedAt(ctx context.Context) (v int64,
 	return oldValue.UpdatedAt, nil
 }
 
-// AddUpdatedAt adds i to the "updated_at" field.
-func (m *ApplicationCommandMutation) AddUpdatedAt(i int64) {
-	if m.addupdated_at != nil {
-		*m.addupdated_at += i
-	} else {
-		m.addupdated_at = &i
-	}
-}
-
-// AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
-func (m *ApplicationCommandMutation) AddedUpdatedAt() (r int64, exists bool) {
-	v := m.addupdated_at
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetUpdatedAt resets all changes to the "updated_at" field.
 func (m *ApplicationCommandMutation) ResetUpdatedAt() {
 	m.updated_at = nil
-	m.addupdated_at = nil
 }
 
 // SetName sets the "name" field.
@@ -4247,14 +3804,14 @@ func (m *ApplicationCommandMutation) OldField(ctx context.Context, name string)
 func (m *ApplicationCommandMutation) SetField(name string, value ent.Value) error {
 	switch name {
 	case applicationcommand.FieldCreatedAt:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetCreatedAt(v)
 		return nil
 	case applicationcommand.FieldUpdatedAt:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -4288,26 +3845,13 @@ func (m *ApplicationCommandMutation) SetField(name string, value ent.Value) erro
 // AddedFields returns all numeric fields that were incremented/decremented during
 // this mutation.
 func (m *ApplicationCommandMutation) AddedFields() []string {
-	var fields []string
-	if m.addcreated_at != nil {
-		fields = append(fields, applicationcommand.FieldCreatedAt)
-	}
-	if m.addupdated_at != nil {
-		fields = append(fields, applicationcommand.FieldUpdatedAt)
-	}
-	return fields
+	return nil
 }
 
 // AddedField returns the numeric value that was incremented/decremented on a field
 // with the given name. The second boolean return value indicates that this field
 // was not set, or was not defined in the schema.
 func (m *ApplicationCommandMutation) AddedField(name string) (ent.Value, bool) {
-	switch name {
-	case applicationcommand.FieldCreatedAt:
-		return m.AddedCreatedAt()
-	case applicationcommand.FieldUpdatedAt:
-		return m.AddedUpdatedAt()
-	}
 	return nil, false
 }
 
@@ -4316,20 +3860,6 @@ func (m *ApplicationCommandMutation) AddedField(name string) (ent.Value, bool) {
 // type.
 func (m *ApplicationCommandMutation) AddField(name string, value ent.Value) error {
 	switch name {
-	case applicationcommand.FieldCreatedAt:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddCreatedAt(v)
-		return nil
-	case applicationcommand.FieldUpdatedAt:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddUpdatedAt(v)
-		return nil
 	}
 	return fmt.Errorf("unknown ApplicationCommand numeric field %s", name)
 }
@@ -4430,10 +3960,8 @@ type ClanMutation struct {
 	op              Op
 	typ             string
 	id              *string
-	created_at      *int64
-	addcreated_at   *int64
-	updated_at      *int64
-	addupdated_at   *int64
+	created_at      *time.Time
+	updated_at      *time.Time
 	tag             *string
 	name            *string
 	emblem_id       *string
@@ -4553,13 +4081,12 @@ func (m *ClanMutation) IDs(ctx context.Context) ([]string, error) {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (m *ClanMutation) SetCreatedAt(i int64) {
-	m.created_at = &i
-	m.addcreated_at = nil
+func (m *ClanMutation) SetCreatedAt(t time.Time) {
+	m.created_at = &t
 }
 
 // CreatedAt returns the value of the "created_at" field in the mutation.
-func (m *ClanMutation) CreatedAt() (r int64, exists bool) {
+func (m *ClanMutation) CreatedAt() (r time.Time, exists bool) {
 	v := m.created_at
 	if v == nil {
 		return
@@ -4570,7 +4097,7 @@ func (m *ClanMutation) CreatedAt() (r int64, exists bool) {
 // OldCreatedAt returns the old "created_at" field's value of the Clan entity.
 // If the Clan object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *ClanMutation) OldCreatedAt(ctx context.Context) (v int64, err error) {
+func (m *ClanMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
 	}
@@ -4584,38 +4111,18 @@ func (m *ClanMutation) OldCreatedAt(ctx context.Context) (v int64, err error) {
 	return oldValue.CreatedAt, nil
 }
 
-// AddCreatedAt adds i to the "created_at" field.
-func (m *ClanMutation) AddCreatedAt(i int64) {
-	if m.addcreated_at != nil {
-		*m.addcreated_at += i
-	} else {
-		m.addcreated_at = &i
-	}
-}
-
-// AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
-func (m *ClanMutation) AddedCreatedAt() (r int64, exists bool) {
-	v := m.addcreated_at
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetCreatedAt resets all changes to the "created_at" field.
 func (m *ClanMutation) ResetCreatedAt() {
 	m.created_at = nil
-	m.addcreated_at = nil
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (m *ClanMutation) SetUpdatedAt(i int64) {
-	m.updated_at = &i
-	m.addupdated_at = nil
+func (m *ClanMutation) SetUpdatedAt(t time.Time) {
+	m.updated_at = &t
 }
 
 // UpdatedAt returns the value of the "updated_at" field in the mutation.
-func (m *ClanMutation) UpdatedAt() (r int64, exists bool) {
+func (m *ClanMutation) UpdatedAt() (r time.Time, exists bool) {
 	v := m.updated_at
 	if v == nil {
 		return
@@ -4626,7 +4133,7 @@ func (m *ClanMutation) UpdatedAt() (r int64, exists bool) {
 // OldUpdatedAt returns the old "updated_at" field's value of the Clan entity.
 // If the Clan object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *ClanMutation) OldUpdatedAt(ctx context.Context) (v int64, err error) {
+func (m *ClanMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
 	}
@@ -4640,28 +4147,9 @@ func (m *ClanMutation) OldUpdatedAt(ctx context.Context) (v int64, err error) {
 	return oldValue.UpdatedAt, nil
 }
 
-// AddUpdatedAt adds i to the "updated_at" field.
-func (m *ClanMutation) AddUpdatedAt(i int64) {
-	if m.addupdated_at != nil {
-		*m.addupdated_at += i
-	} else {
-		m.addupdated_at = &i
-	}
-}
-
-// AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
-func (m *ClanMutation) AddedUpdatedAt() (r int64, exists bool) {
-	v := m.addupdated_at
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetUpdatedAt resets all changes to the "updated_at" field.
 func (m *ClanMutation) ResetUpdatedAt() {
 	m.updated_at = nil
-	m.addupdated_at = nil
 }
 
 // SetTag sets the "tag" field.
@@ -4994,14 +4482,14 @@ func (m *ClanMutation) OldField(ctx context.Context, name string) (ent.Value, er
 func (m *ClanMutation) SetField(name string, value ent.Value) error {
 	switch name {
 	case clan.FieldCreatedAt:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetCreatedAt(v)
 		return nil
 	case clan.FieldUpdatedAt:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -5042,26 +4530,13 @@ func (m *ClanMutation) SetField(name string, value ent.Value) error {
 // AddedFields returns all numeric fields that were incremented/decremented during
 // this mutation.
 func (m *ClanMutation) AddedFields() []string {
-	var fields []string
-	if m.addcreated_at != nil {
-		fields = append(fields, clan.FieldCreatedAt)
-	}
-	if m.addupdated_at != nil {
-		fields = append(fields, clan.FieldUpdatedAt)
-	}
-	return fields
+	return nil
 }
 
 // AddedField returns the numeric value that was incremented/decremented on a field
 // with the given name. The second boolean return value indicates that this field
 // was not set, or was not defined in the schema.
 func (m *ClanMutation) AddedField(name string) (ent.Value, bool) {
-	switch name {
-	case clan.FieldCreatedAt:
-		return m.AddedCreatedAt()
-	case clan.FieldUpdatedAt:
-		return m.AddedUpdatedAt()
-	}
 	return nil, false
 }
 
@@ -5070,20 +4545,6 @@ func (m *ClanMutation) AddedField(name string) (ent.Value, bool) {
 // type.
 func (m *ClanMutation) AddField(name string, value ent.Value) error {
 	switch name {
-	case clan.FieldCreatedAt:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddCreatedAt(v)
-		return nil
-	case clan.FieldUpdatedAt:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddUpdatedAt(v)
-		return nil
 	}
 	return fmt.Errorf("unknown Clan numeric field %s", name)
 }
@@ -5229,29 +4690,25 @@ func (m *ClanMutation) ResetEdge(name string) error {
 // CronTaskMutation represents an operation that mutates the CronTask nodes in the graph.
 type CronTaskMutation struct {
 	config
-	op                 Op
-	typ                string
-	id                 *string
-	created_at         *int64
-	addcreated_at      *int64
-	updated_at         *int64
-	addupdated_at      *int64
-	_type              *models.TaskType
-	reference_id       *string
-	targets            *[]string
-	appendtargets      []string
-	status             *models.TaskStatus
-	scheduled_after    *int64
-	addscheduled_after *int64
-	last_run           *int64
-	addlast_run        *int64
-	logs               *[]models.TaskLog
-	appendlogs         []models.TaskLog
-	data               *map[string]interface{}
-	clearedFields      map[string]struct{}
-	done               bool
-	oldValue           func(context.Context) (*CronTask, error)
-	predicates         []predicate.CronTask
+	op              Op
+	typ             string
+	id              *string
+	created_at      *time.Time
+	updated_at      *time.Time
+	_type           *models.TaskType
+	reference_id    *string
+	targets         *[]string
+	appendtargets   []string
+	status          *models.TaskStatus
+	scheduled_after *time.Time
+	last_run        *time.Time
+	logs            *[]models.TaskLog
+	appendlogs      []models.TaskLog
+	data            *map[string]interface{}
+	clearedFields   map[string]struct{}
+	done            bool
+	oldValue        func(context.Context) (*CronTask, error)
+	predicates      []predicate.CronTask
 }
 
 var _ ent.Mutation = (*CronTaskMutation)(nil)
@@ -5359,13 +4816,12 @@ func (m *CronTaskMutation) IDs(ctx context.Context) ([]string, error) {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (m *CronTaskMutation) SetCreatedAt(i int64) {
-	m.created_at = &i
-	m.addcreated_at = nil
+func (m *CronTaskMutation) SetCreatedAt(t time.Time) {
+	m.created_at = &t
 }
 
 // CreatedAt returns the value of the "created_at" field in the mutation.
-func (m *CronTaskMutation) CreatedAt() (r int64, exists bool) {
+func (m *CronTaskMutation) CreatedAt() (r time.Time, exists bool) {
 	v := m.created_at
 	if v == nil {
 		return
@@ -5376,7 +4832,7 @@ func (m *CronTaskMutation) CreatedAt() (r int64, exists bool) {
 // OldCreatedAt returns the old "created_at" field's value of the CronTask entity.
 // If the CronTask object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *CronTaskMutation) OldCreatedAt(ctx context.Context) (v int64, err error) {
+func (m *CronTaskMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
 	}
@@ -5390,38 +4846,18 @@ func (m *CronTaskMutation) OldCreatedAt(ctx context.Context) (v int64, err error
 	return oldValue.CreatedAt, nil
 }
 
-// AddCreatedAt adds i to the "created_at" field.
-func (m *CronTaskMutation) AddCreatedAt(i int64) {
-	if m.addcreated_at != nil {
-		*m.addcreated_at += i
-	} else {
-		m.addcreated_at = &i
-	}
-}
-
-// AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
-func (m *CronTaskMutation) AddedCreatedAt() (r int64, exists bool) {
-	v := m.addcreated_at
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetCreatedAt resets all changes to the "created_at" field.
 func (m *CronTaskMutation) ResetCreatedAt() {
 	m.created_at = nil
-	m.addcreated_at = nil
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (m *CronTaskMutation) SetUpdatedAt(i int64) {
-	m.updated_at = &i
-	m.addupdated_at = nil
+func (m *CronTaskMutation) SetUpdatedAt(t time.Time) {
+	m.updated_at = &t
 }
 
 // UpdatedAt returns the value of the "updated_at" field in the mutation.
-func (m *CronTaskMutation) UpdatedAt() (r int64, exists bool) {
+func (m *CronTaskMutation) UpdatedAt() (r time.Time, exists bool) {
 	v := m.updated_at
 	if v == nil {
 		return
@@ -5432,7 +4868,7 @@ func (m *CronTaskMutation) UpdatedAt() (r int64, exists bool) {
 // OldUpdatedAt returns the old "updated_at" field's value of the CronTask entity.
 // If the CronTask object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *CronTaskMutation) OldUpdatedAt(ctx context.Context) (v int64, err error) {
+func (m *CronTaskMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
 	}
@@ -5446,28 +4882,9 @@ func (m *CronTaskMutation) OldUpdatedAt(ctx context.Context) (v int64, err error
 	return oldValue.UpdatedAt, nil
 }
 
-// AddUpdatedAt adds i to the "updated_at" field.
-func (m *CronTaskMutation) AddUpdatedAt(i int64) {
-	if m.addupdated_at != nil {
-		*m.addupdated_at += i
-	} else {
-		m.addupdated_at = &i
-	}
-}
-
-// AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
-func (m *CronTaskMutation) AddedUpdatedAt() (r int64, exists bool) {
-	v := m.addupdated_at
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetUpdatedAt resets all changes to the "updated_at" field.
 func (m *CronTaskMutation) ResetUpdatedAt() {
 	m.updated_at = nil
-	m.addupdated_at = nil
 }
 
 // SetType sets the "type" field.
@@ -5630,13 +5047,12 @@ func (m *CronTaskMutation) ResetStatus() {
 }
 
 // SetScheduledAfter sets the "scheduled_after" field.
-func (m *CronTaskMutation) SetScheduledAfter(i int64) {
-	m.scheduled_after = &i
-	m.addscheduled_after = nil
+func (m *CronTaskMutation) SetScheduledAfter(t time.Time) {
+	m.scheduled_after = &t
 }
 
 // ScheduledAfter returns the value of the "scheduled_after" field in the mutation.
-func (m *CronTaskMutation) ScheduledAfter() (r int64, exists bool) {
+func (m *CronTaskMutation) ScheduledAfter() (r time.Time, exists bool) {
 	v := m.scheduled_after
 	if v == nil {
 		return
@@ -5647,7 +5063,7 @@ func (m *CronTaskMutation) ScheduledAfter() (r int64, exists bool) {
 // OldScheduledAfter returns the old "scheduled_after" field's value of the CronTask entity.
 // If the CronTask object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *CronTaskMutation) OldScheduledAfter(ctx context.Context) (v int64, err error) {
+func (m *CronTaskMutation) OldScheduledAfter(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldScheduledAfter is only allowed on UpdateOne operations")
 	}
@@ -5661,38 +5077,18 @@ func (m *CronTaskMutation) OldScheduledAfter(ctx context.Context) (v int64, err
 	return oldValue.ScheduledAfter, nil
 }
 
-// AddScheduledAfter adds i to the "scheduled_after" field.
-func (m *CronTaskMutation) AddScheduledAfter(i int64) {
-	if m.addscheduled_after != nil {
-		*m.addscheduled_after += i
-	} else {
-		m.addscheduled_after = &i
-	}
-}
-
-// AddedScheduledAfter returns the value that was added to the "scheduled_after" field in this mutation.
-func (m *CronTaskMutation) AddedScheduledAfter() (r int64, exists bool) {
-	v := m.addscheduled_after
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetScheduledAfter resets all changes to the "scheduled_after" field.
 func (m *CronTaskMutation) ResetScheduledAfter() {
 	m.scheduled_after = nil
-	m.addscheduled_after = nil
 }
 
 // SetLastRun sets the "last_run" field.
-func (m *CronTaskMutation) SetLastRun(i int64) {
-	m.last_run = &i
-	m.addlast_run = nil
+func (m *CronTaskMutation) SetLastRun(t time.Time) {
+	m.last_run = &t
 }
 
 // LastRun returns the value of the "last_run" field in the mutation.
-func (m *CronTaskMutation) LastRun() (r int64, exists bool) {
+func (m *CronTaskMutation) LastRun() (r time.Time, exists bool) {
 	v := m.last_run
 	if v == nil {
 		return
@@ -5703,7 +5099,7 @@ func (m *CronTaskMutation) LastRun() (r int64, exists bool) {
 // OldLastRun returns the old "last_run" field's value of the CronTask entity.
 // If the CronTask object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *CronTaskMutation) OldLastRun(ctx context.Context) (v int64, err error) {
+func (m *CronTaskMutation) OldLastRun(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldLastRun is only allowed on UpdateOne operations")
 	}
@@ -5717,28 +5113,9 @@ func (m *CronTaskMutation) OldLastRun(ctx context.Context) (v int64, err error)
 	return oldValue.LastRun, nil
 }
 
-// AddLastRun adds i to the "last_run" field.
-func (m *CronTaskMutation) AddLastRun(i int64) {
-	if m.addlast_run != nil {
-		*m.addlast_run += i
-	} else {
-		m.addlast_run = &i
-	}
-}
-
-// AddedLastRun returns the value that was added to the "last_run" field in this mutation.
-func (m *CronTaskMutation) AddedLastRun() (r int64, exists bool) {
-	v := m.addlast_run
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetLastRun resets all changes to the "last_run" field.
 func (m *CronTaskMutation) ResetLastRun() {
 	m.last_run = nil
-	m.addlast_run = nil
 }
 
 // SetLogs sets the "logs" field.
@@ -5960,14 +5337,14 @@ func (m *CronTaskMutation) OldField(ctx context.Context, name string) (ent.Value
 func (m *CronTaskMutation) SetField(name string, value ent.Value) error {
 	switch name {
 	case crontask.FieldCreatedAt:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetCreatedAt(v)
 		return nil
 	case crontask.FieldUpdatedAt:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -6002,14 +5379,14 @@ func (m *CronTaskMutation) SetField(name string, value ent.Value) error {
 		m.SetStatus(v)
 		return nil
 	case crontask.FieldScheduledAfter:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetScheduledAfter(v)
 		return nil
 	case crontask.FieldLastRun:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -6036,36 +5413,13 @@ func (m *CronTaskMutation) SetField(name string, value ent.Value) error {
 // AddedFields returns all numeric fields that were incremented/decremented during
 // this mutation.
 func (m *CronTaskMutation) AddedFields() []string {
-	var fields []string
-	if m.addcreated_at != nil {
-		fields = append(fields, crontask.FieldCreatedAt)
-	}
-	if m.addupdated_at != nil {
-		fields = append(fields, crontask.FieldUpdatedAt)
-	}
-	if m.addscheduled_after != nil {
-		fields = append(fields, crontask.FieldScheduledAfter)
-	}
-	if m.addlast_run != nil {
-		fields = append(fields, crontask.FieldLastRun)
-	}
-	return fields
+	return nil
 }
 
 // AddedField returns the numeric value that was incremented/decremented on a field
 // with the given name. The second boolean return value indicates that this field
 // was not set, or was not defined in the schema.
 func (m *CronTaskMutation) AddedField(name string) (ent.Value, bool) {
-	switch name {
-	case crontask.FieldCreatedAt:
-		return m.AddedCreatedAt()
-	case crontask.FieldUpdatedAt:
-		return m.AddedUpdatedAt()
-	case crontask.FieldScheduledAfter:
-		return m.AddedScheduledAfter()
-	case crontask.FieldLastRun:
-		return m.AddedLastRun()
-	}
 	return nil, false
 }
 
@@ -6074,34 +5428,6 @@ func (m *CronTaskMutation) AddedField(name string) (ent.Value, bool) {
 // type.
 func (m *CronTaskMutation) AddField(name string, value ent.Value) error {
 	switch name {
-	case crontask.FieldCreatedAt:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddCreatedAt(v)
-		return nil
-	case crontask.FieldUpdatedAt:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddUpdatedAt(v)
-		return nil
-	case crontask.FieldScheduledAfter:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddScheduledAfter(v)
-		return nil
-	case crontask.FieldLastRun:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddLastRun(v)
-		return nil
 	}
 	return fmt.Errorf("unknown CronTask numeric field %s", name)
 }
@@ -6217,10 +5543,8 @@ type DiscordInteractionMutation struct {
 	op            Op
 	typ           string
 	id            *string
-	created_at    *int64
-	addcreated_at *int64
-	updated_at    *int64
-	addupdated_at *int64
+	created_at    *time.Time
+	updated_at    *time.Time
 	command       *string
 	reference_id  *string
 	_type         *models.DiscordInteractionType
@@ -6339,13 +5663,12 @@ func (m *DiscordInteractionMutation) IDs(ctx context.Context) ([]string, error)
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (m *DiscordInteractionMutation) SetCreatedAt(i int64) {
-	m.created_at = &i
-	m.addcreated_at = nil
+func (m *DiscordInteractionMutation) SetCreatedAt(t time.Time) {
+	m.created_at = &t
 }
 
 // CreatedAt returns the value of the "created_at" field in the mutation.
-func (m *DiscordInteractionMutation) CreatedAt() (r int64, exists bool) {
+func (m *DiscordInteractionMutation) CreatedAt() (r time.Time, exists bool) {
 	v := m.created_at
 	if v == nil {
 		return
@@ -6356,7 +5679,7 @@ func (m *DiscordInteractionMutation) CreatedAt() (r int64, exists bool) {
 // OldCreatedAt returns the old "created_at" field's value of the DiscordInteraction entity.
 // If the DiscordInteraction object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *DiscordInteractionMutation) OldCreatedAt(ctx context.Context) (v int64, err error) {
+func (m *DiscordInteractionMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
 	}
@@ -6370,38 +5693,18 @@ func (m *DiscordInteractionMutation) OldCreatedAt(ctx context.Context) (v int64,
 	return oldValue.CreatedAt, nil
 }
 
-// AddCreatedAt adds i to the "created_at" field.
-func (m *DiscordInteractionMutation) AddCreatedAt(i int64) {
-	if m.addcreated_at != nil {
-		*m.addcreated_at += i
-	} else {
-		m.addcreated_at = &i
-	}
-}
-
-// AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
-func (m *DiscordInteractionMutation) AddedCreatedAt() (r int64, exists bool) {
-	v := m.addcreated_at
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetCreatedAt resets all changes to the "created_at" field.
 func (m *DiscordInteractionMutation) ResetCreatedAt() {
 	m.created_at = nil
-	m.addcreated_at = nil
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (m *DiscordInteractionMutation) SetUpdatedAt(i int64) {
-	m.updated_at = &i
-	m.addupdated_at = nil
+func (m *DiscordInteractionMutation) SetUpdatedAt(t time.Time) {
+	m.updated_at = &t
 }
 
 // UpdatedAt returns the value of the "updated_at" field in the mutation.
-func (m *DiscordInteractionMutation) UpdatedAt() (r int64, exists bool) {
+func (m *DiscordInteractionMutation) UpdatedAt() (r time.Time, exists bool) {
 	v := m.updated_at
 	if v == nil {
 		return
@@ -6412,7 +5715,7 @@ func (m *DiscordInteractionMutation) UpdatedAt() (r int64, exists bool) {
 // OldUpdatedAt returns the old "updated_at" field's value of the DiscordInteraction entity.
 // If the DiscordInteraction object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *DiscordInteractionMutation) OldUpdatedAt(ctx context.Context) (v int64, err error) {
+func (m *DiscordInteractionMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
 	}
@@ -6426,28 +5729,9 @@ func (m *DiscordInteractionMutation) OldUpdatedAt(ctx context.Context) (v int64,
 	return oldValue.UpdatedAt, nil
 }
 
-// AddUpdatedAt adds i to the "updated_at" field.
-func (m *DiscordInteractionMutation) AddUpdatedAt(i int64) {
-	if m.addupdated_at != nil {
-		*m.addupdated_at += i
-	} else {
-		m.addupdated_at = &i
-	}
-}
-
-// AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
-func (m *DiscordInteractionMutation) AddedUpdatedAt() (r int64, exists bool) {
-	v := m.addupdated_at
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetUpdatedAt resets all changes to the "updated_at" field.
 func (m *DiscordInteractionMutation) ResetUpdatedAt() {
 	m.updated_at = nil
-	m.addupdated_at = nil
 }
 
 // SetCommand sets the "command" field.
@@ -6811,14 +6095,14 @@ func (m *DiscordInteractionMutation) OldField(ctx context.Context, name string)
 func (m *DiscordInteractionMutation) SetField(name string, value ent.Value) error {
 	switch name {
 	case discordinteraction.FieldCreatedAt:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetCreatedAt(v)
 		return nil
 	case discordinteraction.FieldUpdatedAt:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -6873,26 +6157,13 @@ func (m *DiscordInteractionMutation) SetField(name string, value ent.Value) erro
 // AddedFields returns all numeric fields that were incremented/decremented during
 // this mutation.
 func (m *DiscordInteractionMutation) AddedFields() []string {
-	var fields []string
-	if m.addcreated_at != nil {
-		fields = append(fields, discordinteraction.FieldCreatedAt)
-	}
-	if m.addupdated_at != nil {
-		fields = append(fields, discordinteraction.FieldUpdatedAt)
-	}
-	return fields
+	return nil
 }
 
 // AddedField returns the numeric value that was incremented/decremented on a field
 // with the given name. The second boolean return value indicates that this field
 // was not set, or was not defined in the schema.
 func (m *DiscordInteractionMutation) AddedField(name string) (ent.Value, bool) {
-	switch name {
-	case discordinteraction.FieldCreatedAt:
-		return m.AddedCreatedAt()
-	case discordinteraction.FieldUpdatedAt:
-		return m.AddedUpdatedAt()
-	}
 	return nil, false
 }
 
@@ -6901,20 +6172,6 @@ func (m *DiscordInteractionMutation) AddedField(name string) (ent.Value, bool) {
 // type.
 func (m *DiscordInteractionMutation) AddField(name string, value ent.Value) error {
 	switch name {
-	case discordinteraction.FieldCreatedAt:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddCreatedAt(v)
-		return nil
-	case discordinteraction.FieldUpdatedAt:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddUpdatedAt(v)
-		return nil
 	}
 	return fmt.Errorf("unknown DiscordInteraction numeric field %s", name)
 }
@@ -7050,10 +6307,8 @@ type UserMutation struct {
 	op                          Op
 	typ                         string
 	id                          *string
-	created_at                  *int64
-	addcreated_at               *int64
-	updated_at                  *int64
-	addupdated_at               *int64
+	created_at                  *time.Time
+	updated_at                  *time.Time
 	permissions                 *string
 	feature_flags               *[]string
 	appendfeature_flags         []string
@@ -7180,13 +6435,12 @@ func (m *UserMutation) IDs(ctx context.Context) ([]string, error) {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (m *UserMutation) SetCreatedAt(i int64) {
-	m.created_at = &i
-	m.addcreated_at = nil
+func (m *UserMutation) SetCreatedAt(t time.Time) {
+	m.created_at = &t
 }
 
 // CreatedAt returns the value of the "created_at" field in the mutation.
-func (m *UserMutation) CreatedAt() (r int64, exists bool) {
+func (m *UserMutation) CreatedAt() (r time.Time, exists bool) {
 	v := m.created_at
 	if v == nil {
 		return
@@ -7197,7 +6451,7 @@ func (m *UserMutation) CreatedAt() (r int64, exists bool) {
 // OldCreatedAt returns the old "created_at" field's value of the User entity.
 // If the User object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *UserMutation) OldCreatedAt(ctx context.Context) (v int64, err error) {
+func (m *UserMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
 	}
@@ -7211,38 +6465,18 @@ func (m *UserMutation) OldCreatedAt(ctx context.Context) (v int64, err error) {
 	return oldValue.CreatedAt, nil
 }
 
-// AddCreatedAt adds i to the "created_at" field.
-func (m *UserMutation) AddCreatedAt(i int64) {
-	if m.addcreated_at != nil {
-		*m.addcreated_at += i
-	} else {
-		m.addcreated_at = &i
-	}
-}
-
-// AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
-func (m *UserMutation) AddedCreatedAt() (r int64, exists bool) {
-	v := m.addcreated_at
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetCreatedAt resets all changes to the "created_at" field.
 func (m *UserMutation) ResetCreatedAt() {
 	m.created_at = nil
-	m.addcreated_at = nil
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (m *UserMutation) SetUpdatedAt(i int64) {
-	m.updated_at = &i
-	m.addupdated_at = nil
+func (m *UserMutation) SetUpdatedAt(t time.Time) {
+	m.updated_at = &t
 }
 
 // UpdatedAt returns the value of the "updated_at" field in the mutation.
-func (m *UserMutation) UpdatedAt() (r int64, exists bool) {
+func (m *UserMutation) UpdatedAt() (r time.Time, exists bool) {
 	v := m.updated_at
 	if v == nil {
 		return
@@ -7253,7 +6487,7 @@ func (m *UserMutation) UpdatedAt() (r int64, exists bool) {
 // OldUpdatedAt returns the old "updated_at" field's value of the User entity.
 // If the User object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *UserMutation) OldUpdatedAt(ctx context.Context) (v int64, err error) {
+func (m *UserMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
 	}
@@ -7267,28 +6501,9 @@ func (m *UserMutation) OldUpdatedAt(ctx context.Context) (v int64, err error) {
 	return oldValue.UpdatedAt, nil
 }
 
-// AddUpdatedAt adds i to the "updated_at" field.
-func (m *UserMutation) AddUpdatedAt(i int64) {
-	if m.addupdated_at != nil {
-		*m.addupdated_at += i
-	} else {
-		m.addupdated_at = &i
-	}
-}
-
-// AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
-func (m *UserMutation) AddedUpdatedAt() (r int64, exists bool) {
-	v := m.addupdated_at
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetUpdatedAt resets all changes to the "updated_at" field.
 func (m *UserMutation) ResetUpdatedAt() {
 	m.updated_at = nil
-	m.addupdated_at = nil
 }
 
 // SetPermissions sets the "permissions" field.
@@ -7698,14 +6913,14 @@ func (m *UserMutation) OldField(ctx context.Context, name string) (ent.Value, er
 func (m *UserMutation) SetField(name string, value ent.Value) error {
 	switch name {
 	case user.FieldCreatedAt:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetCreatedAt(v)
 		return nil
 	case user.FieldUpdatedAt:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -7732,26 +6947,13 @@ func (m *UserMutation) SetField(name string, value ent.Value) error {
 // AddedFields returns all numeric fields that were incremented/decremented during
 // this mutation.
 func (m *UserMutation) AddedFields() []string {
-	var fields []string
-	if m.addcreated_at != nil {
-		fields = append(fields, user.FieldCreatedAt)
-	}
-	if m.addupdated_at != nil {
-		fields = append(fields, user.FieldUpdatedAt)
-	}
-	return fields
+	return nil
 }
 
 // AddedField returns the numeric value that was incremented/decremented on a field
 // with the given name. The second boolean return value indicates that this field
 // was not set, or was not defined in the schema.
 func (m *UserMutation) AddedField(name string) (ent.Value, bool) {
-	switch name {
-	case user.FieldCreatedAt:
-		return m.AddedCreatedAt()
-	case user.FieldUpdatedAt:
-		return m.AddedUpdatedAt()
-	}
 	return nil, false
 }
 
@@ -7760,20 +6962,6 @@ func (m *UserMutation) AddedField(name string) (ent.Value, bool) {
 // type.
 func (m *UserMutation) AddField(name string, value ent.Value) error {
 	switch name {
-	case user.FieldCreatedAt:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddCreatedAt(v)
-		return nil
-	case user.FieldUpdatedAt:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddUpdatedAt(v)
-		return nil
 	}
 	return fmt.Errorf("unknown User numeric field %s", name)
 }
@@ -7994,10 +7182,8 @@ type UserConnectionMutation struct {
 	op            Op
 	typ           string
 	id            *string
-	created_at    *int64
-	addcreated_at *int64
-	updated_at    *int64
-	addupdated_at *int64
+	created_at    *time.Time
+	updated_at    *time.Time
 	_type         *models.ConnectionType
 	reference_id  *string
 	permissions   *string
@@ -8115,13 +7301,12 @@ func (m *UserConnectionMutation) IDs(ctx context.Context) ([]string, error) {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (m *UserConnectionMutation) SetCreatedAt(i int64) {
-	m.created_at = &i
-	m.addcreated_at = nil
+func (m *UserConnectionMutation) SetCreatedAt(t time.Time) {
+	m.created_at = &t
 }
 
 // CreatedAt returns the value of the "created_at" field in the mutation.
-func (m *UserConnectionMutation) CreatedAt() (r int64, exists bool) {
+func (m *UserConnectionMutation) CreatedAt() (r time.Time, exists bool) {
 	v := m.created_at
 	if v == nil {
 		return
@@ -8132,7 +7317,7 @@ func (m *UserConnectionMutation) CreatedAt() (r int64, exists bool) {
 // OldCreatedAt returns the old "created_at" field's value of the UserConnection entity.
 // If the UserConnection object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *UserConnectionMutation) OldCreatedAt(ctx context.Context) (v int64, err error) {
+func (m *UserConnectionMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
 	}
@@ -8146,38 +7331,18 @@ func (m *UserConnectionMutation) OldCreatedAt(ctx context.Context) (v int64, err
 	return oldValue.CreatedAt, nil
 }
 
-// AddCreatedAt adds i to the "created_at" field.
-func (m *UserConnectionMutation) AddCreatedAt(i int64) {
-	if m.addcreated_at != nil {
-		*m.addcreated_at += i
-	} else {
-		m.addcreated_at = &i
-	}
-}
-
-// AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
-func (m *UserConnectionMutation) AddedCreatedAt() (r int64, exists bool) {
-	v := m.addcreated_at
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetCreatedAt resets all changes to the "created_at" field.
 func (m *UserConnectionMutation) ResetCreatedAt() {
 	m.created_at = nil
-	m.addcreated_at = nil
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (m *UserConnectionMutation) SetUpdatedAt(i int64) {
-	m.updated_at = &i
-	m.addupdated_at = nil
+func (m *UserConnectionMutation) SetUpdatedAt(t time.Time) {
+	m.updated_at = &t
 }
 
 // UpdatedAt returns the value of the "updated_at" field in the mutation.
-func (m *UserConnectionMutation) UpdatedAt() (r int64, exists bool) {
+func (m *UserConnectionMutation) UpdatedAt() (r time.Time, exists bool) {
 	v := m.updated_at
 	if v == nil {
 		return
@@ -8188,7 +7353,7 @@ func (m *UserConnectionMutation) UpdatedAt() (r int64, exists bool) {
 // OldUpdatedAt returns the old "updated_at" field's value of the UserConnection entity.
 // If the UserConnection object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *UserConnectionMutation) OldUpdatedAt(ctx context.Context) (v int64, err error) {
+func (m *UserConnectionMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
 	}
@@ -8196,34 +7361,15 @@ func (m *UserConnectionMutation) OldUpdatedAt(ctx context.Context) (v int64, err
 		return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
 	}
 	oldValue, err := m.oldValue(ctx)
-	if err != nil {
-		return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
-	}
-	return oldValue.UpdatedAt, nil
-}
-
-// AddUpdatedAt adds i to the "updated_at" field.
-func (m *UserConnectionMutation) AddUpdatedAt(i int64) {
-	if m.addupdated_at != nil {
-		*m.addupdated_at += i
-	} else {
-		m.addupdated_at = &i
-	}
-}
-
-// AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
-func (m *UserConnectionMutation) AddedUpdatedAt() (r int64, exists bool) {
-	v := m.addupdated_at
-	if v == nil {
-		return
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
 	}
-	return *v, true
+	return oldValue.UpdatedAt, nil
 }
 
 // ResetUpdatedAt resets all changes to the "updated_at" field.
 func (m *UserConnectionMutation) ResetUpdatedAt() {
 	m.updated_at = nil
-	m.addupdated_at = nil
 }
 
 // SetType sets the "type" field.
@@ -8570,14 +7716,14 @@ func (m *UserConnectionMutation) OldField(ctx context.Context, name string) (ent
 func (m *UserConnectionMutation) SetField(name string, value ent.Value) error {
 	switch name {
 	case userconnection.FieldCreatedAt:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetCreatedAt(v)
 		return nil
 	case userconnection.FieldUpdatedAt:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -8625,26 +7771,13 @@ func (m *UserConnectionMutation) SetField(name string, value ent.Value) error {
 // AddedFields returns all numeric fields that were incremented/decremented during
 // this mutation.
 func (m *UserConnectionMutation) AddedFields() []string {
-	var fields []string
-	if m.addcreated_at != nil {
-		fields = append(fields, userconnection.FieldCreatedAt)
-	}
-	if m.addupdated_at != nil {
-		fields = append(fields, userconnection.FieldUpdatedAt)
-	}
-	return fields
+	return nil
 }
 
 // AddedField returns the numeric value that was incremented/decremented on a field
 // with the given name. The second boolean return value indicates that this field
 // was not set, or was not defined in the schema.
 func (m *UserConnectionMutation) AddedField(name string) (ent.Value, bool) {
-	switch name {
-	case userconnection.FieldCreatedAt:
-		return m.AddedCreatedAt()
-	case userconnection.FieldUpdatedAt:
-		return m.AddedUpdatedAt()
-	}
 	return nil, false
 }
 
@@ -8653,20 +7786,6 @@ func (m *UserConnectionMutation) AddedField(name string) (ent.Value, bool) {
 // type.
 func (m *UserConnectionMutation) AddField(name string, value ent.Value) error {
 	switch name {
-	case userconnection.FieldCreatedAt:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddCreatedAt(v)
-		return nil
-	case userconnection.FieldUpdatedAt:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddUpdatedAt(v)
-		return nil
 	}
 	return fmt.Errorf("unknown UserConnection numeric field %s", name)
 }
@@ -8814,10 +7933,8 @@ type UserContentMutation struct {
 	op            Op
 	typ           string
 	id            *string
-	created_at    *int64
-	addcreated_at *int64
-	updated_at    *int64
-	addupdated_at *int64
+	created_at    *time.Time
+	updated_at    *time.Time
 	_type         *models.UserContentType
 	reference_id  *string
 	value         *string
@@ -8935,13 +8052,12 @@ func (m *UserContentMutation) IDs(ctx context.Context) ([]string, error) {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (m *UserContentMutation) SetCreatedAt(i int64) {
-	m.created_at = &i
-	m.addcreated_at = nil
+func (m *UserContentMutation) SetCreatedAt(t time.Time) {
+	m.created_at = &t
 }
 
 // CreatedAt returns the value of the "created_at" field in the mutation.
-func (m *UserContentMutation) CreatedAt() (r int64, exists bool) {
+func (m *UserContentMutation) CreatedAt() (r time.Time, exists bool) {
 	v := m.created_at
 	if v == nil {
 		return
@@ -8952,7 +8068,7 @@ func (m *UserContentMutation) CreatedAt() (r int64, exists bool) {
 // OldCreatedAt returns the old "created_at" field's value of the UserContent entity.
 // If the UserContent object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *UserContentMutation) OldCreatedAt(ctx context.Context) (v int64, err error) {
+func (m *UserContentMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
 	}
@@ -8966,38 +8082,18 @@ func (m *UserContentMutation) OldCreatedAt(ctx context.Context) (v int64, err er
 	return oldValue.CreatedAt, nil
 }
 
-// AddCreatedAt adds i to the "created_at" field.
-func (m *UserContentMutation) AddCreatedAt(i int64) {
-	if m.addcreated_at != nil {
-		*m.addcreated_at += i
-	} else {
-		m.addcreated_at = &i
-	}
-}
-
-// AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
-func (m *UserContentMutation) AddedCreatedAt() (r int64, exists bool) {
-	v := m.addcreated_at
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetCreatedAt resets all changes to the "created_at" field.
 func (m *UserContentMutation) ResetCreatedAt() {
 	m.created_at = nil
-	m.addcreated_at = nil
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (m *UserContentMutation) SetUpdatedAt(i int64) {
-	m.updated_at = &i
-	m.addupdated_at = nil
+func (m *UserContentMutation) SetUpdatedAt(t time.Time) {
+	m.updated_at = &t
 }
 
 // UpdatedAt returns the value of the "updated_at" field in the mutation.
-func (m *UserContentMutation) UpdatedAt() (r int64, exists bool) {
+func (m *UserContentMutation) UpdatedAt() (r time.Time, exists bool) {
 	v := m.updated_at
 	if v == nil {
 		return
@@ -9008,7 +8104,7 @@ func (m *UserContentMutation) UpdatedAt() (r int64, exists bool) {
 // OldUpdatedAt returns the old "updated_at" field's value of the UserContent entity.
 // If the UserContent object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *UserContentMutation) OldUpdatedAt(ctx context.Context) (v int64, err error) {
+func (m *UserContentMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
 	}
@@ -9022,28 +8118,9 @@ func (m *UserContentMutation) OldUpdatedAt(ctx context.Context) (v int64, err er
 	return oldValue.UpdatedAt, nil
 }
 
-// AddUpdatedAt adds i to the "updated_at" field.
-func (m *UserContentMutation) AddUpdatedAt(i int64) {
-	if m.addupdated_at != nil {
-		*m.addupdated_at += i
-	} else {
-		m.addupdated_at = &i
-	}
-}
-
-// AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
-func (m *UserContentMutation) AddedUpdatedAt() (r int64, exists bool) {
-	v := m.addupdated_at
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetUpdatedAt resets all changes to the "updated_at" field.
 func (m *UserContentMutation) ResetUpdatedAt() {
 	m.updated_at = nil
-	m.addupdated_at = nil
 }
 
 // SetType sets the "type" field.
@@ -9364,14 +8441,14 @@ func (m *UserContentMutation) OldField(ctx context.Context, name string) (ent.Va
 func (m *UserContentMutation) SetField(name string, value ent.Value) error {
 	switch name {
 	case usercontent.FieldCreatedAt:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetCreatedAt(v)
 		return nil
 	case usercontent.FieldUpdatedAt:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -9419,26 +8496,13 @@ func (m *UserContentMutation) SetField(name string, value ent.Value) error {
 // AddedFields returns all numeric fields that were incremented/decremented during
 // this mutation.
 func (m *UserContentMutation) AddedFields() []string {
-	var fields []string
-	if m.addcreated_at != nil {
-		fields = append(fields, usercontent.FieldCreatedAt)
-	}
-	if m.addupdated_at != nil {
-		fields = append(fields, usercontent.FieldUpdatedAt)
-	}
-	return fields
+	return nil
 }
 
 // AddedField returns the numeric value that was incremented/decremented on a field
 // with the given name. The second boolean return value indicates that this field
 // was not set, or was not defined in the schema.
 func (m *UserContentMutation) AddedField(name string) (ent.Value, bool) {
-	switch name {
-	case usercontent.FieldCreatedAt:
-		return m.AddedCreatedAt()
-	case usercontent.FieldUpdatedAt:
-		return m.AddedUpdatedAt()
-	}
 	return nil, false
 }
 
@@ -9447,20 +8511,6 @@ func (m *UserContentMutation) AddedField(name string) (ent.Value, bool) {
 // type.
 func (m *UserContentMutation) AddField(name string, value ent.Value) error {
 	switch name {
-	case usercontent.FieldCreatedAt:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddCreatedAt(v)
-		return nil
-	case usercontent.FieldUpdatedAt:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddUpdatedAt(v)
-		return nil
 	}
 	return fmt.Errorf("unknown UserContent numeric field %s", name)
 }
@@ -9593,13 +8643,10 @@ type UserSubscriptionMutation struct {
 	op            Op
 	typ           string
 	id            *string
-	created_at    *int64
-	addcreated_at *int64
-	updated_at    *int64
-	addupdated_at *int64
+	created_at    *time.Time
+	updated_at    *time.Time
 	_type         *models.SubscriptionType
-	expires_at    *int64
-	addexpires_at *int64
+	expires_at    *time.Time
 	permissions   *string
 	reference_id  *string
 	clearedFields map[string]struct{}
@@ -9715,13 +8762,12 @@ func (m *UserSubscriptionMutation) IDs(ctx context.Context) ([]string, error) {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (m *UserSubscriptionMutation) SetCreatedAt(i int64) {
-	m.created_at = &i
-	m.addcreated_at = nil
+func (m *UserSubscriptionMutation) SetCreatedAt(t time.Time) {
+	m.created_at = &t
 }
 
 // CreatedAt returns the value of the "created_at" field in the mutation.
-func (m *UserSubscriptionMutation) CreatedAt() (r int64, exists bool) {
+func (m *UserSubscriptionMutation) CreatedAt() (r time.Time, exists bool) {
 	v := m.created_at
 	if v == nil {
 		return
@@ -9732,7 +8778,7 @@ func (m *UserSubscriptionMutation) CreatedAt() (r int64, exists bool) {
 // OldCreatedAt returns the old "created_at" field's value of the UserSubscription entity.
 // If the UserSubscription object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *UserSubscriptionMutation) OldCreatedAt(ctx context.Context) (v int64, err error) {
+func (m *UserSubscriptionMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
 	}
@@ -9746,38 +8792,18 @@ func (m *UserSubscriptionMutation) OldCreatedAt(ctx context.Context) (v int64, e
 	return oldValue.CreatedAt, nil
 }
 
-// AddCreatedAt adds i to the "created_at" field.
-func (m *UserSubscriptionMutation) AddCreatedAt(i int64) {
-	if m.addcreated_at != nil {
-		*m.addcreated_at += i
-	} else {
-		m.addcreated_at = &i
-	}
-}
-
-// AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
-func (m *UserSubscriptionMutation) AddedCreatedAt() (r int64, exists bool) {
-	v := m.addcreated_at
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetCreatedAt resets all changes to the "created_at" field.
 func (m *UserSubscriptionMutation) ResetCreatedAt() {
 	m.created_at = nil
-	m.addcreated_at = nil
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (m *UserSubscriptionMutation) SetUpdatedAt(i int64) {
-	m.updated_at = &i
-	m.addupdated_at = nil
+func (m *UserSubscriptionMutation) SetUpdatedAt(t time.Time) {
+	m.updated_at = &t
 }
 
 // UpdatedAt returns the value of the "updated_at" field in the mutation.
-func (m *UserSubscriptionMutation) UpdatedAt() (r int64, exists bool) {
+func (m *UserSubscriptionMutation) UpdatedAt() (r time.Time, exists bool) {
 	v := m.updated_at
 	if v == nil {
 		return
@@ -9788,7 +8814,7 @@ func (m *UserSubscriptionMutation) UpdatedAt() (r int64, exists bool) {
 // OldUpdatedAt returns the old "updated_at" field's value of the UserSubscription entity.
 // If the UserSubscription object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *UserSubscriptionMutation) OldUpdatedAt(ctx context.Context) (v int64, err error) {
+func (m *UserSubscriptionMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
 	}
@@ -9802,28 +8828,9 @@ func (m *UserSubscriptionMutation) OldUpdatedAt(ctx context.Context) (v int64, e
 	return oldValue.UpdatedAt, nil
 }
 
-// AddUpdatedAt adds i to the "updated_at" field.
-func (m *UserSubscriptionMutation) AddUpdatedAt(i int64) {
-	if m.addupdated_at != nil {
-		*m.addupdated_at += i
-	} else {
-		m.addupdated_at = &i
-	}
-}
-
-// AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
-func (m *UserSubscriptionMutation) AddedUpdatedAt() (r int64, exists bool) {
-	v := m.addupdated_at
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetUpdatedAt resets all changes to the "updated_at" field.
 func (m *UserSubscriptionMutation) ResetUpdatedAt() {
 	m.updated_at = nil
-	m.addupdated_at = nil
 }
 
 // SetType sets the "type" field.
@@ -9863,13 +8870,12 @@ func (m *UserSubscriptionMutation) ResetType() {
 }
 
 // SetExpiresAt sets the "expires_at" field.
-func (m *UserSubscriptionMutation) SetExpiresAt(i int64) {
-	m.expires_at = &i
-	m.addexpires_at = nil
+func (m *UserSubscriptionMutation) SetExpiresAt(t time.Time) {
+	m.expires_at = &t
 }
 
 // ExpiresAt returns the value of the "expires_at" field in the mutation.
-func (m *UserSubscriptionMutation) ExpiresAt() (r int64, exists bool) {
+func (m *UserSubscriptionMutation) ExpiresAt() (r time.Time, exists bool) {
 	v := m.expires_at
 	if v == nil {
 		return
@@ -9880,7 +8886,7 @@ func (m *UserSubscriptionMutation) ExpiresAt() (r int64, exists bool) {
 // OldExpiresAt returns the old "expires_at" field's value of the UserSubscription entity.
 // If the UserSubscription object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *UserSubscriptionMutation) OldExpiresAt(ctx context.Context) (v int64, err error) {
+func (m *UserSubscriptionMutation) OldExpiresAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldExpiresAt is only allowed on UpdateOne operations")
 	}
@@ -9894,28 +8900,9 @@ func (m *UserSubscriptionMutation) OldExpiresAt(ctx context.Context) (v int64, e
 	return oldValue.ExpiresAt, nil
 }
 
-// AddExpiresAt adds i to the "expires_at" field.
-func (m *UserSubscriptionMutation) AddExpiresAt(i int64) {
-	if m.addexpires_at != nil {
-		*m.addexpires_at += i
-	} else {
-		m.addexpires_at = &i
-	}
-}
-
-// AddedExpiresAt returns the value that was added to the "expires_at" field in this mutation.
-func (m *UserSubscriptionMutation) AddedExpiresAt() (r int64, exists bool) {
-	v := m.addexpires_at
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetExpiresAt resets all changes to the "expires_at" field.
 func (m *UserSubscriptionMutation) ResetExpiresAt() {
 	m.expires_at = nil
-	m.addexpires_at = nil
 }
 
 // SetUserID sets the "user_id" field.
@@ -10164,14 +9151,14 @@ func (m *UserSubscriptionMutation) OldField(ctx context.Context, name string) (e
 func (m *UserSubscriptionMutation) SetField(name string, value ent.Value) error {
 	switch name {
 	case usersubscription.FieldCreatedAt:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetCreatedAt(v)
 		return nil
 	case usersubscription.FieldUpdatedAt:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -10185,7 +9172,7 @@ func (m *UserSubscriptionMutation) SetField(name string, value ent.Value) error
 		m.SetType(v)
 		return nil
 	case usersubscription.FieldExpiresAt:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -10219,31 +9206,13 @@ func (m *UserSubscriptionMutation) SetField(name string, value ent.Value) error
 // AddedFields returns all numeric fields that were incremented/decremented during
 // this mutation.
 func (m *UserSubscriptionMutation) AddedFields() []string {
-	var fields []string
-	if m.addcreated_at != nil {
-		fields = append(fields, usersubscription.FieldCreatedAt)
-	}
-	if m.addupdated_at != nil {
-		fields = append(fields, usersubscription.FieldUpdatedAt)
-	}
-	if m.addexpires_at != nil {
-		fields = append(fields, usersubscription.FieldExpiresAt)
-	}
-	return fields
+	return nil
 }
 
 // AddedField returns the numeric value that was incremented/decremented on a field
 // with the given name. The second boolean return value indicates that this field
 // was not set, or was not defined in the schema.
 func (m *UserSubscriptionMutation) AddedField(name string) (ent.Value, bool) {
-	switch name {
-	case usersubscription.FieldCreatedAt:
-		return m.AddedCreatedAt()
-	case usersubscription.FieldUpdatedAt:
-		return m.AddedUpdatedAt()
-	case usersubscription.FieldExpiresAt:
-		return m.AddedExpiresAt()
-	}
 	return nil, false
 }
 
@@ -10252,27 +9221,6 @@ func (m *UserSubscriptionMutation) AddedField(name string) (ent.Value, bool) {
 // type.
 func (m *UserSubscriptionMutation) AddField(name string, value ent.Value) error {
 	switch name {
-	case usersubscription.FieldCreatedAt:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddCreatedAt(v)
-		return nil
-	case usersubscription.FieldUpdatedAt:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddUpdatedAt(v)
-		return nil
-	case usersubscription.FieldExpiresAt:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddExpiresAt(v)
-		return nil
 	}
 	return fmt.Errorf("unknown UserSubscription numeric field %s", name)
 }
@@ -10405,10 +9353,8 @@ type VehicleMutation struct {
 	op              Op
 	typ             string
 	id              *string
-	created_at      *int64
-	addcreated_at   *int64
-	updated_at      *int64
-	addupdated_at   *int64
+	created_at      *time.Time
+	updated_at      *time.Time
 	tier            *int
 	addtier         *int
 	localized_names *map[string]string
@@ -10523,13 +9469,12 @@ func (m *VehicleMutation) IDs(ctx context.Context) ([]string, error) {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (m *VehicleMutation) SetCreatedAt(i int64) {
-	m.created_at = &i
-	m.addcreated_at = nil
+func (m *VehicleMutation) SetCreatedAt(t time.Time) {
+	m.created_at = &t
 }
 
 // CreatedAt returns the value of the "created_at" field in the mutation.
-func (m *VehicleMutation) CreatedAt() (r int64, exists bool) {
+func (m *VehicleMutation) CreatedAt() (r time.Time, exists bool) {
 	v := m.created_at
 	if v == nil {
 		return
@@ -10540,7 +9485,7 @@ func (m *VehicleMutation) CreatedAt() (r int64, exists bool) {
 // OldCreatedAt returns the old "created_at" field's value of the Vehicle entity.
 // If the Vehicle object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *VehicleMutation) OldCreatedAt(ctx context.Context) (v int64, err error) {
+func (m *VehicleMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
 	}
@@ -10554,38 +9499,18 @@ func (m *VehicleMutation) OldCreatedAt(ctx context.Context) (v int64, err error)
 	return oldValue.CreatedAt, nil
 }
 
-// AddCreatedAt adds i to the "created_at" field.
-func (m *VehicleMutation) AddCreatedAt(i int64) {
-	if m.addcreated_at != nil {
-		*m.addcreated_at += i
-	} else {
-		m.addcreated_at = &i
-	}
-}
-
-// AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
-func (m *VehicleMutation) AddedCreatedAt() (r int64, exists bool) {
-	v := m.addcreated_at
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetCreatedAt resets all changes to the "created_at" field.
 func (m *VehicleMutation) ResetCreatedAt() {
 	m.created_at = nil
-	m.addcreated_at = nil
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (m *VehicleMutation) SetUpdatedAt(i int64) {
-	m.updated_at = &i
-	m.addupdated_at = nil
+func (m *VehicleMutation) SetUpdatedAt(t time.Time) {
+	m.updated_at = &t
 }
 
 // UpdatedAt returns the value of the "updated_at" field in the mutation.
-func (m *VehicleMutation) UpdatedAt() (r int64, exists bool) {
+func (m *VehicleMutation) UpdatedAt() (r time.Time, exists bool) {
 	v := m.updated_at
 	if v == nil {
 		return
@@ -10596,7 +9521,7 @@ func (m *VehicleMutation) UpdatedAt() (r int64, exists bool) {
 // OldUpdatedAt returns the old "updated_at" field's value of the Vehicle entity.
 // If the Vehicle object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *VehicleMutation) OldUpdatedAt(ctx context.Context) (v int64, err error) {
+func (m *VehicleMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
 	}
@@ -10610,28 +9535,9 @@ func (m *VehicleMutation) OldUpdatedAt(ctx context.Context) (v int64, err error)
 	return oldValue.UpdatedAt, nil
 }
 
-// AddUpdatedAt adds i to the "updated_at" field.
-func (m *VehicleMutation) AddUpdatedAt(i int64) {
-	if m.addupdated_at != nil {
-		*m.addupdated_at += i
-	} else {
-		m.addupdated_at = &i
-	}
-}
-
-// AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
-func (m *VehicleMutation) AddedUpdatedAt() (r int64, exists bool) {
-	v := m.addupdated_at
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetUpdatedAt resets all changes to the "updated_at" field.
 func (m *VehicleMutation) ResetUpdatedAt() {
 	m.updated_at = nil
-	m.addupdated_at = nil
 }
 
 // SetTier sets the "tier" field.
@@ -10816,14 +9722,14 @@ func (m *VehicleMutation) OldField(ctx context.Context, name string) (ent.Value,
 func (m *VehicleMutation) SetField(name string, value ent.Value) error {
 	switch name {
 	case vehicle.FieldCreatedAt:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetCreatedAt(v)
 		return nil
 	case vehicle.FieldUpdatedAt:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -10851,12 +9757,6 @@ func (m *VehicleMutation) SetField(name string, value ent.Value) error {
 // this mutation.
 func (m *VehicleMutation) AddedFields() []string {
 	var fields []string
-	if m.addcreated_at != nil {
-		fields = append(fields, vehicle.FieldCreatedAt)
-	}
-	if m.addupdated_at != nil {
-		fields = append(fields, vehicle.FieldUpdatedAt)
-	}
 	if m.addtier != nil {
 		fields = append(fields, vehicle.FieldTier)
 	}
@@ -10868,10 +9768,6 @@ func (m *VehicleMutation) AddedFields() []string {
 // was not set, or was not defined in the schema.
 func (m *VehicleMutation) AddedField(name string) (ent.Value, bool) {
 	switch name {
-	case vehicle.FieldCreatedAt:
-		return m.AddedCreatedAt()
-	case vehicle.FieldUpdatedAt:
-		return m.AddedUpdatedAt()
 	case vehicle.FieldTier:
 		return m.AddedTier()
 	}
@@ -10883,20 +9779,6 @@ func (m *VehicleMutation) AddedField(name string) (ent.Value, bool) {
 // type.
 func (m *VehicleMutation) AddField(name string, value ent.Value) error {
 	switch name {
-	case vehicle.FieldCreatedAt:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddCreatedAt(v)
-		return nil
-	case vehicle.FieldUpdatedAt:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddUpdatedAt(v)
-		return nil
 	case vehicle.FieldTier:
 		v, ok := value.(int)
 		if !ok {
@@ -11001,10 +9883,8 @@ type VehicleAverageMutation struct {
 	op            Op
 	typ           string
 	id            *string
-	created_at    *int64
-	addcreated_at *int64
-	updated_at    *int64
-	addupdated_at *int64
+	created_at    *time.Time
+	updated_at    *time.Time
 	data          *frame.StatsFrame
 	clearedFields map[string]struct{}
 	done          bool
@@ -11117,13 +9997,12 @@ func (m *VehicleAverageMutation) IDs(ctx context.Context) ([]string, error) {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (m *VehicleAverageMutation) SetCreatedAt(i int64) {
-	m.created_at = &i
-	m.addcreated_at = nil
+func (m *VehicleAverageMutation) SetCreatedAt(t time.Time) {
+	m.created_at = &t
 }
 
 // CreatedAt returns the value of the "created_at" field in the mutation.
-func (m *VehicleAverageMutation) CreatedAt() (r int64, exists bool) {
+func (m *VehicleAverageMutation) CreatedAt() (r time.Time, exists bool) {
 	v := m.created_at
 	if v == nil {
 		return
@@ -11134,7 +10013,7 @@ func (m *VehicleAverageMutation) CreatedAt() (r int64, exists bool) {
 // OldCreatedAt returns the old "created_at" field's value of the VehicleAverage entity.
 // If the VehicleAverage object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *VehicleAverageMutation) OldCreatedAt(ctx context.Context) (v int64, err error) {
+func (m *VehicleAverageMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
 	}
@@ -11148,38 +10027,18 @@ func (m *VehicleAverageMutation) OldCreatedAt(ctx context.Context) (v int64, err
 	return oldValue.CreatedAt, nil
 }
 
-// AddCreatedAt adds i to the "created_at" field.
-func (m *VehicleAverageMutation) AddCreatedAt(i int64) {
-	if m.addcreated_at != nil {
-		*m.addcreated_at += i
-	} else {
-		m.addcreated_at = &i
-	}
-}
-
-// AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
-func (m *VehicleAverageMutation) AddedCreatedAt() (r int64, exists bool) {
-	v := m.addcreated_at
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetCreatedAt resets all changes to the "created_at" field.
 func (m *VehicleAverageMutation) ResetCreatedAt() {
 	m.created_at = nil
-	m.addcreated_at = nil
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (m *VehicleAverageMutation) SetUpdatedAt(i int64) {
-	m.updated_at = &i
-	m.addupdated_at = nil
+func (m *VehicleAverageMutation) SetUpdatedAt(t time.Time) {
+	m.updated_at = &t
 }
 
 // UpdatedAt returns the value of the "updated_at" field in the mutation.
-func (m *VehicleAverageMutation) UpdatedAt() (r int64, exists bool) {
+func (m *VehicleAverageMutation) UpdatedAt() (r time.Time, exists bool) {
 	v := m.updated_at
 	if v == nil {
 		return
@@ -11190,7 +10049,7 @@ func (m *VehicleAverageMutation) UpdatedAt() (r int64, exists bool) {
 // OldUpdatedAt returns the old "updated_at" field's value of the VehicleAverage entity.
 // If the VehicleAverage object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *VehicleAverageMutation) OldUpdatedAt(ctx context.Context) (v int64, err error) {
+func (m *VehicleAverageMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
 	}
@@ -11204,28 +10063,9 @@ func (m *VehicleAverageMutation) OldUpdatedAt(ctx context.Context) (v int64, err
 	return oldValue.UpdatedAt, nil
 }
 
-// AddUpdatedAt adds i to the "updated_at" field.
-func (m *VehicleAverageMutation) AddUpdatedAt(i int64) {
-	if m.addupdated_at != nil {
-		*m.addupdated_at += i
-	} else {
-		m.addupdated_at = &i
-	}
-}
-
-// AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
-func (m *VehicleAverageMutation) AddedUpdatedAt() (r int64, exists bool) {
-	v := m.addupdated_at
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetUpdatedAt resets all changes to the "updated_at" field.
 func (m *VehicleAverageMutation) ResetUpdatedAt() {
 	m.updated_at = nil
-	m.addupdated_at = nil
 }
 
 // SetData sets the "data" field.
@@ -11347,14 +10187,14 @@ func (m *VehicleAverageMutation) OldField(ctx context.Context, name string) (ent
 func (m *VehicleAverageMutation) SetField(name string, value ent.Value) error {
 	switch name {
 	case vehicleaverage.FieldCreatedAt:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetCreatedAt(v)
 		return nil
 	case vehicleaverage.FieldUpdatedAt:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -11374,26 +10214,13 @@ func (m *VehicleAverageMutation) SetField(name string, value ent.Value) error {
 // AddedFields returns all numeric fields that were incremented/decremented during
 // this mutation.
 func (m *VehicleAverageMutation) AddedFields() []string {
-	var fields []string
-	if m.addcreated_at != nil {
-		fields = append(fields, vehicleaverage.FieldCreatedAt)
-	}
-	if m.addupdated_at != nil {
-		fields = append(fields, vehicleaverage.FieldUpdatedAt)
-	}
-	return fields
+	return nil
 }
 
 // AddedField returns the numeric value that was incremented/decremented on a field
 // with the given name. The second boolean return value indicates that this field
 // was not set, or was not defined in the schema.
 func (m *VehicleAverageMutation) AddedField(name string) (ent.Value, bool) {
-	switch name {
-	case vehicleaverage.FieldCreatedAt:
-		return m.AddedCreatedAt()
-	case vehicleaverage.FieldUpdatedAt:
-		return m.AddedUpdatedAt()
-	}
 	return nil, false
 }
 
@@ -11402,20 +10229,6 @@ func (m *VehicleAverageMutation) AddedField(name string) (ent.Value, bool) {
 // type.
 func (m *VehicleAverageMutation) AddField(name string, value ent.Value) error {
 	switch name {
-	case vehicleaverage.FieldCreatedAt:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddCreatedAt(v)
-		return nil
-	case vehicleaverage.FieldUpdatedAt:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddUpdatedAt(v)
-		return nil
 	}
 	return fmt.Errorf("unknown VehicleAverage numeric field %s", name)
 }
@@ -11507,27 +10320,24 @@ func (m *VehicleAverageMutation) ResetEdge(name string) error {
 // VehicleSnapshotMutation represents an operation that mutates the VehicleSnapshot nodes in the graph.
 type VehicleSnapshotMutation struct {
 	config
-	op                  Op
-	typ                 string
-	id                  *string
-	created_at          *int64
-	addcreated_at       *int64
-	updated_at          *int64
-	addupdated_at       *int64
-	_type               *models.SnapshotType
-	vehicle_id          *string
-	reference_id        *string
-	battles             *int
-	addbattles          *int
-	last_battle_time    *int64
-	addlast_battle_time *int64
-	frame               *frame.StatsFrame
-	clearedFields       map[string]struct{}
-	account             *string
-	clearedaccount      bool
-	done                bool
-	oldValue            func(context.Context) (*VehicleSnapshot, error)
-	predicates          []predicate.VehicleSnapshot
+	op               Op
+	typ              string
+	id               *string
+	created_at       *time.Time
+	updated_at       *time.Time
+	_type            *models.SnapshotType
+	vehicle_id       *string
+	reference_id     *string
+	battles          *int
+	addbattles       *int
+	last_battle_time *time.Time
+	frame            *frame.StatsFrame
+	clearedFields    map[string]struct{}
+	account          *string
+	clearedaccount   bool
+	done             bool
+	oldValue         func(context.Context) (*VehicleSnapshot, error)
+	predicates       []predicate.VehicleSnapshot
 }
 
 var _ ent.Mutation = (*VehicleSnapshotMutation)(nil)
@@ -11635,13 +10445,12 @@ func (m *VehicleSnapshotMutation) IDs(ctx context.Context) ([]string, error) {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (m *VehicleSnapshotMutation) SetCreatedAt(i int64) {
-	m.created_at = &i
-	m.addcreated_at = nil
+func (m *VehicleSnapshotMutation) SetCreatedAt(t time.Time) {
+	m.created_at = &t
 }
 
 // CreatedAt returns the value of the "created_at" field in the mutation.
-func (m *VehicleSnapshotMutation) CreatedAt() (r int64, exists bool) {
+func (m *VehicleSnapshotMutation) CreatedAt() (r time.Time, exists bool) {
 	v := m.created_at
 	if v == nil {
 		return
@@ -11652,7 +10461,7 @@ func (m *VehicleSnapshotMutation) CreatedAt() (r int64, exists bool) {
 // OldCreatedAt returns the old "created_at" field's value of the VehicleSnapshot entity.
 // If the VehicleSnapshot object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *VehicleSnapshotMutation) OldCreatedAt(ctx context.Context) (v int64, err error) {
+func (m *VehicleSnapshotMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
 	}
@@ -11666,38 +10475,18 @@ func (m *VehicleSnapshotMutation) OldCreatedAt(ctx context.Context) (v int64, er
 	return oldValue.CreatedAt, nil
 }
 
-// AddCreatedAt adds i to the "created_at" field.
-func (m *VehicleSnapshotMutation) AddCreatedAt(i int64) {
-	if m.addcreated_at != nil {
-		*m.addcreated_at += i
-	} else {
-		m.addcreated_at = &i
-	}
-}
-
-// AddedCreatedAt returns the value that was added to the "created_at" field in this mutation.
-func (m *VehicleSnapshotMutation) AddedCreatedAt() (r int64, exists bool) {
-	v := m.addcreated_at
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetCreatedAt resets all changes to the "created_at" field.
 func (m *VehicleSnapshotMutation) ResetCreatedAt() {
 	m.created_at = nil
-	m.addcreated_at = nil
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (m *VehicleSnapshotMutation) SetUpdatedAt(i int64) {
-	m.updated_at = &i
-	m.addupdated_at = nil
+func (m *VehicleSnapshotMutation) SetUpdatedAt(t time.Time) {
+	m.updated_at = &t
 }
 
 // UpdatedAt returns the value of the "updated_at" field in the mutation.
-func (m *VehicleSnapshotMutation) UpdatedAt() (r int64, exists bool) {
+func (m *VehicleSnapshotMutation) UpdatedAt() (r time.Time, exists bool) {
 	v := m.updated_at
 	if v == nil {
 		return
@@ -11708,7 +10497,7 @@ func (m *VehicleSnapshotMutation) UpdatedAt() (r int64, exists bool) {
 // OldUpdatedAt returns the old "updated_at" field's value of the VehicleSnapshot entity.
 // If the VehicleSnapshot object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *VehicleSnapshotMutation) OldUpdatedAt(ctx context.Context) (v int64, err error) {
+func (m *VehicleSnapshotMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
 	}
@@ -11722,28 +10511,9 @@ func (m *VehicleSnapshotMutation) OldUpdatedAt(ctx context.Context) (v int64, er
 	return oldValue.UpdatedAt, nil
 }
 
-// AddUpdatedAt adds i to the "updated_at" field.
-func (m *VehicleSnapshotMutation) AddUpdatedAt(i int64) {
-	if m.addupdated_at != nil {
-		*m.addupdated_at += i
-	} else {
-		m.addupdated_at = &i
-	}
-}
-
-// AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation.
-func (m *VehicleSnapshotMutation) AddedUpdatedAt() (r int64, exists bool) {
-	v := m.addupdated_at
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetUpdatedAt resets all changes to the "updated_at" field.
 func (m *VehicleSnapshotMutation) ResetUpdatedAt() {
 	m.updated_at = nil
-	m.addupdated_at = nil
 }
 
 // SetType sets the "type" field.
@@ -11947,13 +10717,12 @@ func (m *VehicleSnapshotMutation) ResetBattles() {
 }
 
 // SetLastBattleTime sets the "last_battle_time" field.
-func (m *VehicleSnapshotMutation) SetLastBattleTime(i int64) {
-	m.last_battle_time = &i
-	m.addlast_battle_time = nil
+func (m *VehicleSnapshotMutation) SetLastBattleTime(t time.Time) {
+	m.last_battle_time = &t
 }
 
 // LastBattleTime returns the value of the "last_battle_time" field in the mutation.
-func (m *VehicleSnapshotMutation) LastBattleTime() (r int64, exists bool) {
+func (m *VehicleSnapshotMutation) LastBattleTime() (r time.Time, exists bool) {
 	v := m.last_battle_time
 	if v == nil {
 		return
@@ -11964,7 +10733,7 @@ func (m *VehicleSnapshotMutation) LastBattleTime() (r int64, exists bool) {
 // OldLastBattleTime returns the old "last_battle_time" field's value of the VehicleSnapshot entity.
 // If the VehicleSnapshot object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *VehicleSnapshotMutation) OldLastBattleTime(ctx context.Context) (v int64, err error) {
+func (m *VehicleSnapshotMutation) OldLastBattleTime(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldLastBattleTime is only allowed on UpdateOne operations")
 	}
@@ -11978,28 +10747,9 @@ func (m *VehicleSnapshotMutation) OldLastBattleTime(ctx context.Context) (v int6
 	return oldValue.LastBattleTime, nil
 }
 
-// AddLastBattleTime adds i to the "last_battle_time" field.
-func (m *VehicleSnapshotMutation) AddLastBattleTime(i int64) {
-	if m.addlast_battle_time != nil {
-		*m.addlast_battle_time += i
-	} else {
-		m.addlast_battle_time = &i
-	}
-}
-
-// AddedLastBattleTime returns the value that was added to the "last_battle_time" field in this mutation.
-func (m *VehicleSnapshotMutation) AddedLastBattleTime() (r int64, exists bool) {
-	v := m.addlast_battle_time
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
 // ResetLastBattleTime resets all changes to the "last_battle_time" field.
 func (m *VehicleSnapshotMutation) ResetLastBattleTime() {
 	m.last_battle_time = nil
-	m.addlast_battle_time = nil
 }
 
 // SetFrame sets the "frame" field.
@@ -12190,14 +10940,14 @@ func (m *VehicleSnapshotMutation) OldField(ctx context.Context, name string) (en
 func (m *VehicleSnapshotMutation) SetField(name string, value ent.Value) error {
 	switch name {
 	case vehiclesnapshot.FieldCreatedAt:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetCreatedAt(v)
 		return nil
 	case vehiclesnapshot.FieldUpdatedAt:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -12239,7 +10989,7 @@ func (m *VehicleSnapshotMutation) SetField(name string, value ent.Value) error {
 		m.SetBattles(v)
 		return nil
 	case vehiclesnapshot.FieldLastBattleTime:
-		v, ok := value.(int64)
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -12260,18 +11010,9 @@ func (m *VehicleSnapshotMutation) SetField(name string, value ent.Value) error {
 // this mutation.
 func (m *VehicleSnapshotMutation) AddedFields() []string {
 	var fields []string
-	if m.addcreated_at != nil {
-		fields = append(fields, vehiclesnapshot.FieldCreatedAt)
-	}
-	if m.addupdated_at != nil {
-		fields = append(fields, vehiclesnapshot.FieldUpdatedAt)
-	}
 	if m.addbattles != nil {
 		fields = append(fields, vehiclesnapshot.FieldBattles)
 	}
-	if m.addlast_battle_time != nil {
-		fields = append(fields, vehiclesnapshot.FieldLastBattleTime)
-	}
 	return fields
 }
 
@@ -12280,14 +11021,8 @@ func (m *VehicleSnapshotMutation) AddedFields() []string {
 // was not set, or was not defined in the schema.
 func (m *VehicleSnapshotMutation) AddedField(name string) (ent.Value, bool) {
 	switch name {
-	case vehiclesnapshot.FieldCreatedAt:
-		return m.AddedCreatedAt()
-	case vehiclesnapshot.FieldUpdatedAt:
-		return m.AddedUpdatedAt()
 	case vehiclesnapshot.FieldBattles:
 		return m.AddedBattles()
-	case vehiclesnapshot.FieldLastBattleTime:
-		return m.AddedLastBattleTime()
 	}
 	return nil, false
 }
@@ -12297,20 +11032,6 @@ func (m *VehicleSnapshotMutation) AddedField(name string) (ent.Value, bool) {
 // type.
 func (m *VehicleSnapshotMutation) AddField(name string, value ent.Value) error {
 	switch name {
-	case vehiclesnapshot.FieldCreatedAt:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddCreatedAt(v)
-		return nil
-	case vehiclesnapshot.FieldUpdatedAt:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddUpdatedAt(v)
-		return nil
 	case vehiclesnapshot.FieldBattles:
 		v, ok := value.(int)
 		if !ok {
@@ -12318,13 +11039,6 @@ func (m *VehicleSnapshotMutation) AddField(name string, value ent.Value) error {
 		}
 		m.AddBattles(v)
 		return nil
-	case vehiclesnapshot.FieldLastBattleTime:
-		v, ok := value.(int64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddLastBattleTime(v)
-		return nil
 	}
 	return fmt.Errorf("unknown VehicleSnapshot numeric field %s", name)
 }
diff --git a/internal/database/ent/db/runtime.go b/internal/database/ent/db/runtime.go
index c760c687..61052e6b 100644
--- a/internal/database/ent/db/runtime.go
+++ b/internal/database/ent/db/runtime.go
@@ -3,6 +3,8 @@
 package db
 
 import (
+	"time"
+
 	"github.com/cufee/aftermath/internal/database/ent/db/account"
 	"github.com/cufee/aftermath/internal/database/ent/db/accountsnapshot"
 	"github.com/cufee/aftermath/internal/database/ent/db/achievementssnapshot"
@@ -30,13 +32,13 @@ func init() {
 	// accountDescCreatedAt is the schema descriptor for created_at field.
 	accountDescCreatedAt := accountFields[1].Descriptor()
 	// account.DefaultCreatedAt holds the default value on creation for the created_at field.
-	account.DefaultCreatedAt = accountDescCreatedAt.Default.(func() int64)
+	account.DefaultCreatedAt = accountDescCreatedAt.Default.(func() time.Time)
 	// accountDescUpdatedAt is the schema descriptor for updated_at field.
 	accountDescUpdatedAt := accountFields[2].Descriptor()
 	// account.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	account.DefaultUpdatedAt = accountDescUpdatedAt.Default.(func() int64)
+	account.DefaultUpdatedAt = accountDescUpdatedAt.Default.(func() time.Time)
 	// account.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	account.UpdateDefaultUpdatedAt = accountDescUpdatedAt.UpdateDefault.(func() int64)
+	account.UpdateDefaultUpdatedAt = accountDescUpdatedAt.UpdateDefault.(func() time.Time)
 	// accountDescRealm is the schema descriptor for realm field.
 	accountDescRealm := accountFields[5].Descriptor()
 	// account.RealmValidator is a validator for the "realm" field. It is called by the builders before save.
@@ -68,13 +70,13 @@ func init() {
 	// accountsnapshotDescCreatedAt is the schema descriptor for created_at field.
 	accountsnapshotDescCreatedAt := accountsnapshotFields[1].Descriptor()
 	// accountsnapshot.DefaultCreatedAt holds the default value on creation for the created_at field.
-	accountsnapshot.DefaultCreatedAt = accountsnapshotDescCreatedAt.Default.(func() int64)
+	accountsnapshot.DefaultCreatedAt = accountsnapshotDescCreatedAt.Default.(func() time.Time)
 	// accountsnapshotDescUpdatedAt is the schema descriptor for updated_at field.
 	accountsnapshotDescUpdatedAt := accountsnapshotFields[2].Descriptor()
 	// accountsnapshot.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	accountsnapshot.DefaultUpdatedAt = accountsnapshotDescUpdatedAt.Default.(func() int64)
+	accountsnapshot.DefaultUpdatedAt = accountsnapshotDescUpdatedAt.Default.(func() time.Time)
 	// accountsnapshot.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	accountsnapshot.UpdateDefaultUpdatedAt = accountsnapshotDescUpdatedAt.UpdateDefault.(func() int64)
+	accountsnapshot.UpdateDefaultUpdatedAt = accountsnapshotDescUpdatedAt.UpdateDefault.(func() time.Time)
 	// accountsnapshotDescAccountID is the schema descriptor for account_id field.
 	accountsnapshotDescAccountID := accountsnapshotFields[5].Descriptor()
 	// accountsnapshot.AccountIDValidator is a validator for the "account_id" field. It is called by the builders before save.
@@ -92,13 +94,13 @@ func init() {
 	// achievementssnapshotDescCreatedAt is the schema descriptor for created_at field.
 	achievementssnapshotDescCreatedAt := achievementssnapshotFields[1].Descriptor()
 	// achievementssnapshot.DefaultCreatedAt holds the default value on creation for the created_at field.
-	achievementssnapshot.DefaultCreatedAt = achievementssnapshotDescCreatedAt.Default.(func() int64)
+	achievementssnapshot.DefaultCreatedAt = achievementssnapshotDescCreatedAt.Default.(func() time.Time)
 	// achievementssnapshotDescUpdatedAt is the schema descriptor for updated_at field.
 	achievementssnapshotDescUpdatedAt := achievementssnapshotFields[2].Descriptor()
 	// achievementssnapshot.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	achievementssnapshot.DefaultUpdatedAt = achievementssnapshotDescUpdatedAt.Default.(func() int64)
+	achievementssnapshot.DefaultUpdatedAt = achievementssnapshotDescUpdatedAt.Default.(func() time.Time)
 	// achievementssnapshot.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	achievementssnapshot.UpdateDefaultUpdatedAt = achievementssnapshotDescUpdatedAt.UpdateDefault.(func() int64)
+	achievementssnapshot.UpdateDefaultUpdatedAt = achievementssnapshotDescUpdatedAt.UpdateDefault.(func() time.Time)
 	// achievementssnapshotDescAccountID is the schema descriptor for account_id field.
 	achievementssnapshotDescAccountID := achievementssnapshotFields[4].Descriptor()
 	// achievementssnapshot.AccountIDValidator is a validator for the "account_id" field. It is called by the builders before save.
@@ -116,13 +118,13 @@ func init() {
 	// appconfigurationDescCreatedAt is the schema descriptor for created_at field.
 	appconfigurationDescCreatedAt := appconfigurationFields[1].Descriptor()
 	// appconfiguration.DefaultCreatedAt holds the default value on creation for the created_at field.
-	appconfiguration.DefaultCreatedAt = appconfigurationDescCreatedAt.Default.(func() int64)
+	appconfiguration.DefaultCreatedAt = appconfigurationDescCreatedAt.Default.(func() time.Time)
 	// appconfigurationDescUpdatedAt is the schema descriptor for updated_at field.
 	appconfigurationDescUpdatedAt := appconfigurationFields[2].Descriptor()
 	// appconfiguration.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	appconfiguration.DefaultUpdatedAt = appconfigurationDescUpdatedAt.Default.(func() int64)
+	appconfiguration.DefaultUpdatedAt = appconfigurationDescUpdatedAt.Default.(func() time.Time)
 	// appconfiguration.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	appconfiguration.UpdateDefaultUpdatedAt = appconfigurationDescUpdatedAt.UpdateDefault.(func() int64)
+	appconfiguration.UpdateDefaultUpdatedAt = appconfigurationDescUpdatedAt.UpdateDefault.(func() time.Time)
 	// appconfigurationDescKey is the schema descriptor for key field.
 	appconfigurationDescKey := appconfigurationFields[3].Descriptor()
 	// appconfiguration.KeyValidator is a validator for the "key" field. It is called by the builders before save.
@@ -136,13 +138,13 @@ func init() {
 	// applicationcommandDescCreatedAt is the schema descriptor for created_at field.
 	applicationcommandDescCreatedAt := applicationcommandFields[1].Descriptor()
 	// applicationcommand.DefaultCreatedAt holds the default value on creation for the created_at field.
-	applicationcommand.DefaultCreatedAt = applicationcommandDescCreatedAt.Default.(func() int64)
+	applicationcommand.DefaultCreatedAt = applicationcommandDescCreatedAt.Default.(func() time.Time)
 	// applicationcommandDescUpdatedAt is the schema descriptor for updated_at field.
 	applicationcommandDescUpdatedAt := applicationcommandFields[2].Descriptor()
 	// applicationcommand.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	applicationcommand.DefaultUpdatedAt = applicationcommandDescUpdatedAt.Default.(func() int64)
+	applicationcommand.DefaultUpdatedAt = applicationcommandDescUpdatedAt.Default.(func() time.Time)
 	// applicationcommand.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	applicationcommand.UpdateDefaultUpdatedAt = applicationcommandDescUpdatedAt.UpdateDefault.(func() int64)
+	applicationcommand.UpdateDefaultUpdatedAt = applicationcommandDescUpdatedAt.UpdateDefault.(func() time.Time)
 	// applicationcommandDescName is the schema descriptor for name field.
 	applicationcommandDescName := applicationcommandFields[3].Descriptor()
 	// applicationcommand.NameValidator is a validator for the "name" field. It is called by the builders before save.
@@ -164,13 +166,13 @@ func init() {
 	// clanDescCreatedAt is the schema descriptor for created_at field.
 	clanDescCreatedAt := clanFields[1].Descriptor()
 	// clan.DefaultCreatedAt holds the default value on creation for the created_at field.
-	clan.DefaultCreatedAt = clanDescCreatedAt.Default.(func() int64)
+	clan.DefaultCreatedAt = clanDescCreatedAt.Default.(func() time.Time)
 	// clanDescUpdatedAt is the schema descriptor for updated_at field.
 	clanDescUpdatedAt := clanFields[2].Descriptor()
 	// clan.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	clan.DefaultUpdatedAt = clanDescUpdatedAt.Default.(func() int64)
+	clan.DefaultUpdatedAt = clanDescUpdatedAt.Default.(func() time.Time)
 	// clan.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	clan.UpdateDefaultUpdatedAt = clanDescUpdatedAt.UpdateDefault.(func() int64)
+	clan.UpdateDefaultUpdatedAt = clanDescUpdatedAt.UpdateDefault.(func() time.Time)
 	// clanDescTag is the schema descriptor for tag field.
 	clanDescTag := clanFields[3].Descriptor()
 	// clan.TagValidator is a validator for the "tag" field. It is called by the builders before save.
@@ -188,13 +190,13 @@ func init() {
 	// crontaskDescCreatedAt is the schema descriptor for created_at field.
 	crontaskDescCreatedAt := crontaskFields[1].Descriptor()
 	// crontask.DefaultCreatedAt holds the default value on creation for the created_at field.
-	crontask.DefaultCreatedAt = crontaskDescCreatedAt.Default.(func() int64)
+	crontask.DefaultCreatedAt = crontaskDescCreatedAt.Default.(func() time.Time)
 	// crontaskDescUpdatedAt is the schema descriptor for updated_at field.
 	crontaskDescUpdatedAt := crontaskFields[2].Descriptor()
 	// crontask.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	crontask.DefaultUpdatedAt = crontaskDescUpdatedAt.Default.(func() int64)
+	crontask.DefaultUpdatedAt = crontaskDescUpdatedAt.Default.(func() time.Time)
 	// crontask.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	crontask.UpdateDefaultUpdatedAt = crontaskDescUpdatedAt.UpdateDefault.(func() int64)
+	crontask.UpdateDefaultUpdatedAt = crontaskDescUpdatedAt.UpdateDefault.(func() time.Time)
 	// crontaskDescReferenceID is the schema descriptor for reference_id field.
 	crontaskDescReferenceID := crontaskFields[4].Descriptor()
 	// crontask.ReferenceIDValidator is a validator for the "reference_id" field. It is called by the builders before save.
@@ -208,13 +210,13 @@ func init() {
 	// discordinteractionDescCreatedAt is the schema descriptor for created_at field.
 	discordinteractionDescCreatedAt := discordinteractionFields[1].Descriptor()
 	// discordinteraction.DefaultCreatedAt holds the default value on creation for the created_at field.
-	discordinteraction.DefaultCreatedAt = discordinteractionDescCreatedAt.Default.(func() int64)
+	discordinteraction.DefaultCreatedAt = discordinteractionDescCreatedAt.Default.(func() time.Time)
 	// discordinteractionDescUpdatedAt is the schema descriptor for updated_at field.
 	discordinteractionDescUpdatedAt := discordinteractionFields[2].Descriptor()
 	// discordinteraction.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	discordinteraction.DefaultUpdatedAt = discordinteractionDescUpdatedAt.Default.(func() int64)
+	discordinteraction.DefaultUpdatedAt = discordinteractionDescUpdatedAt.Default.(func() time.Time)
 	// discordinteraction.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	discordinteraction.UpdateDefaultUpdatedAt = discordinteractionDescUpdatedAt.UpdateDefault.(func() int64)
+	discordinteraction.UpdateDefaultUpdatedAt = discordinteractionDescUpdatedAt.UpdateDefault.(func() time.Time)
 	// discordinteractionDescCommand is the schema descriptor for command field.
 	discordinteractionDescCommand := discordinteractionFields[3].Descriptor()
 	// discordinteraction.CommandValidator is a validator for the "command" field. It is called by the builders before save.
@@ -236,13 +238,13 @@ func init() {
 	// userDescCreatedAt is the schema descriptor for created_at field.
 	userDescCreatedAt := userFields[1].Descriptor()
 	// user.DefaultCreatedAt holds the default value on creation for the created_at field.
-	user.DefaultCreatedAt = userDescCreatedAt.Default.(func() int64)
+	user.DefaultCreatedAt = userDescCreatedAt.Default.(func() time.Time)
 	// userDescUpdatedAt is the schema descriptor for updated_at field.
 	userDescUpdatedAt := userFields[2].Descriptor()
 	// user.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	user.DefaultUpdatedAt = userDescUpdatedAt.Default.(func() int64)
+	user.DefaultUpdatedAt = userDescUpdatedAt.Default.(func() time.Time)
 	// user.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	user.UpdateDefaultUpdatedAt = userDescUpdatedAt.UpdateDefault.(func() int64)
+	user.UpdateDefaultUpdatedAt = userDescUpdatedAt.UpdateDefault.(func() time.Time)
 	// userDescPermissions is the schema descriptor for permissions field.
 	userDescPermissions := userFields[3].Descriptor()
 	// user.DefaultPermissions holds the default value on creation for the permissions field.
@@ -252,13 +254,13 @@ func init() {
 	// userconnectionDescCreatedAt is the schema descriptor for created_at field.
 	userconnectionDescCreatedAt := userconnectionFields[1].Descriptor()
 	// userconnection.DefaultCreatedAt holds the default value on creation for the created_at field.
-	userconnection.DefaultCreatedAt = userconnectionDescCreatedAt.Default.(func() int64)
+	userconnection.DefaultCreatedAt = userconnectionDescCreatedAt.Default.(func() time.Time)
 	// userconnectionDescUpdatedAt is the schema descriptor for updated_at field.
 	userconnectionDescUpdatedAt := userconnectionFields[2].Descriptor()
 	// userconnection.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	userconnection.DefaultUpdatedAt = userconnectionDescUpdatedAt.Default.(func() int64)
+	userconnection.DefaultUpdatedAt = userconnectionDescUpdatedAt.Default.(func() time.Time)
 	// userconnection.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	userconnection.UpdateDefaultUpdatedAt = userconnectionDescUpdatedAt.UpdateDefault.(func() int64)
+	userconnection.UpdateDefaultUpdatedAt = userconnectionDescUpdatedAt.UpdateDefault.(func() time.Time)
 	// userconnectionDescPermissions is the schema descriptor for permissions field.
 	userconnectionDescPermissions := userconnectionFields[6].Descriptor()
 	// userconnection.DefaultPermissions holds the default value on creation for the permissions field.
@@ -272,13 +274,13 @@ func init() {
 	// usercontentDescCreatedAt is the schema descriptor for created_at field.
 	usercontentDescCreatedAt := usercontentFields[1].Descriptor()
 	// usercontent.DefaultCreatedAt holds the default value on creation for the created_at field.
-	usercontent.DefaultCreatedAt = usercontentDescCreatedAt.Default.(func() int64)
+	usercontent.DefaultCreatedAt = usercontentDescCreatedAt.Default.(func() time.Time)
 	// usercontentDescUpdatedAt is the schema descriptor for updated_at field.
 	usercontentDescUpdatedAt := usercontentFields[2].Descriptor()
 	// usercontent.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	usercontent.DefaultUpdatedAt = usercontentDescUpdatedAt.Default.(func() int64)
+	usercontent.DefaultUpdatedAt = usercontentDescUpdatedAt.Default.(func() time.Time)
 	// usercontent.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	usercontent.UpdateDefaultUpdatedAt = usercontentDescUpdatedAt.UpdateDefault.(func() int64)
+	usercontent.UpdateDefaultUpdatedAt = usercontentDescUpdatedAt.UpdateDefault.(func() time.Time)
 	// usercontentDescID is the schema descriptor for id field.
 	usercontentDescID := usercontentFields[0].Descriptor()
 	// usercontent.DefaultID holds the default value on creation for the id field.
@@ -288,13 +290,13 @@ func init() {
 	// usersubscriptionDescCreatedAt is the schema descriptor for created_at field.
 	usersubscriptionDescCreatedAt := usersubscriptionFields[1].Descriptor()
 	// usersubscription.DefaultCreatedAt holds the default value on creation for the created_at field.
-	usersubscription.DefaultCreatedAt = usersubscriptionDescCreatedAt.Default.(func() int64)
+	usersubscription.DefaultCreatedAt = usersubscriptionDescCreatedAt.Default.(func() time.Time)
 	// usersubscriptionDescUpdatedAt is the schema descriptor for updated_at field.
 	usersubscriptionDescUpdatedAt := usersubscriptionFields[2].Descriptor()
 	// usersubscription.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	usersubscription.DefaultUpdatedAt = usersubscriptionDescUpdatedAt.Default.(func() int64)
+	usersubscription.DefaultUpdatedAt = usersubscriptionDescUpdatedAt.Default.(func() time.Time)
 	// usersubscription.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	usersubscription.UpdateDefaultUpdatedAt = usersubscriptionDescUpdatedAt.UpdateDefault.(func() int64)
+	usersubscription.UpdateDefaultUpdatedAt = usersubscriptionDescUpdatedAt.UpdateDefault.(func() time.Time)
 	// usersubscriptionDescUserID is the schema descriptor for user_id field.
 	usersubscriptionDescUserID := usersubscriptionFields[5].Descriptor()
 	// usersubscription.UserIDValidator is a validator for the "user_id" field. It is called by the builders before save.
@@ -316,13 +318,13 @@ func init() {
 	// vehicleDescCreatedAt is the schema descriptor for created_at field.
 	vehicleDescCreatedAt := vehicleFields[1].Descriptor()
 	// vehicle.DefaultCreatedAt holds the default value on creation for the created_at field.
-	vehicle.DefaultCreatedAt = vehicleDescCreatedAt.Default.(func() int64)
+	vehicle.DefaultCreatedAt = vehicleDescCreatedAt.Default.(func() time.Time)
 	// vehicleDescUpdatedAt is the schema descriptor for updated_at field.
 	vehicleDescUpdatedAt := vehicleFields[2].Descriptor()
 	// vehicle.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	vehicle.DefaultUpdatedAt = vehicleDescUpdatedAt.Default.(func() int64)
+	vehicle.DefaultUpdatedAt = vehicleDescUpdatedAt.Default.(func() time.Time)
 	// vehicle.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	vehicle.UpdateDefaultUpdatedAt = vehicleDescUpdatedAt.UpdateDefault.(func() int64)
+	vehicle.UpdateDefaultUpdatedAt = vehicleDescUpdatedAt.UpdateDefault.(func() time.Time)
 	// vehicleDescTier is the schema descriptor for tier field.
 	vehicleDescTier := vehicleFields[3].Descriptor()
 	// vehicle.TierValidator is a validator for the "tier" field. It is called by the builders before save.
@@ -346,25 +348,25 @@ func init() {
 	// vehicleaverageDescCreatedAt is the schema descriptor for created_at field.
 	vehicleaverageDescCreatedAt := vehicleaverageFields[1].Descriptor()
 	// vehicleaverage.DefaultCreatedAt holds the default value on creation for the created_at field.
-	vehicleaverage.DefaultCreatedAt = vehicleaverageDescCreatedAt.Default.(func() int64)
+	vehicleaverage.DefaultCreatedAt = vehicleaverageDescCreatedAt.Default.(func() time.Time)
 	// vehicleaverageDescUpdatedAt is the schema descriptor for updated_at field.
 	vehicleaverageDescUpdatedAt := vehicleaverageFields[2].Descriptor()
 	// vehicleaverage.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	vehicleaverage.DefaultUpdatedAt = vehicleaverageDescUpdatedAt.Default.(func() int64)
+	vehicleaverage.DefaultUpdatedAt = vehicleaverageDescUpdatedAt.Default.(func() time.Time)
 	// vehicleaverage.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	vehicleaverage.UpdateDefaultUpdatedAt = vehicleaverageDescUpdatedAt.UpdateDefault.(func() int64)
+	vehicleaverage.UpdateDefaultUpdatedAt = vehicleaverageDescUpdatedAt.UpdateDefault.(func() time.Time)
 	vehiclesnapshotFields := schema.VehicleSnapshot{}.Fields()
 	_ = vehiclesnapshotFields
 	// vehiclesnapshotDescCreatedAt is the schema descriptor for created_at field.
 	vehiclesnapshotDescCreatedAt := vehiclesnapshotFields[1].Descriptor()
 	// vehiclesnapshot.DefaultCreatedAt holds the default value on creation for the created_at field.
-	vehiclesnapshot.DefaultCreatedAt = vehiclesnapshotDescCreatedAt.Default.(func() int64)
+	vehiclesnapshot.DefaultCreatedAt = vehiclesnapshotDescCreatedAt.Default.(func() time.Time)
 	// vehiclesnapshotDescUpdatedAt is the schema descriptor for updated_at field.
 	vehiclesnapshotDescUpdatedAt := vehiclesnapshotFields[2].Descriptor()
 	// vehiclesnapshot.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	vehiclesnapshot.DefaultUpdatedAt = vehiclesnapshotDescUpdatedAt.Default.(func() int64)
+	vehiclesnapshot.DefaultUpdatedAt = vehiclesnapshotDescUpdatedAt.Default.(func() time.Time)
 	// vehiclesnapshot.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	vehiclesnapshot.UpdateDefaultUpdatedAt = vehiclesnapshotDescUpdatedAt.UpdateDefault.(func() int64)
+	vehiclesnapshot.UpdateDefaultUpdatedAt = vehiclesnapshotDescUpdatedAt.UpdateDefault.(func() time.Time)
 	// vehiclesnapshotDescAccountID is the schema descriptor for account_id field.
 	vehiclesnapshotDescAccountID := vehiclesnapshotFields[4].Descriptor()
 	// vehiclesnapshot.AccountIDValidator is a validator for the "account_id" field. It is called by the builders before save.
diff --git a/internal/database/ent/db/user.go b/internal/database/ent/db/user.go
index 0c537425..f94bd4f6 100644
--- a/internal/database/ent/db/user.go
+++ b/internal/database/ent/db/user.go
@@ -6,6 +6,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"strings"
+	"time"
 
 	"entgo.io/ent"
 	"entgo.io/ent/dialect/sql"
@@ -18,9 +19,9 @@ type User struct {
 	// ID of the ent.
 	ID string `json:"id,omitempty"`
 	// CreatedAt holds the value of the "created_at" field.
-	CreatedAt int64 `json:"created_at,omitempty"`
+	CreatedAt time.Time `json:"created_at,omitempty"`
 	// UpdatedAt holds the value of the "updated_at" field.
-	UpdatedAt int64 `json:"updated_at,omitempty"`
+	UpdatedAt time.Time `json:"updated_at,omitempty"`
 	// Permissions holds the value of the "permissions" field.
 	Permissions string `json:"permissions,omitempty"`
 	// FeatureFlags holds the value of the "feature_flags" field.
@@ -89,10 +90,10 @@ func (*User) scanValues(columns []string) ([]any, error) {
 		switch columns[i] {
 		case user.FieldFeatureFlags:
 			values[i] = new([]byte)
-		case user.FieldCreatedAt, user.FieldUpdatedAt:
-			values[i] = new(sql.NullInt64)
 		case user.FieldID, user.FieldPermissions:
 			values[i] = new(sql.NullString)
+		case user.FieldCreatedAt, user.FieldUpdatedAt:
+			values[i] = new(sql.NullTime)
 		default:
 			values[i] = new(sql.UnknownType)
 		}
@@ -115,16 +116,16 @@ func (u *User) assignValues(columns []string, values []any) error {
 				u.ID = value.String
 			}
 		case user.FieldCreatedAt:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field created_at", values[i])
 			} else if value.Valid {
-				u.CreatedAt = value.Int64
+				u.CreatedAt = value.Time
 			}
 		case user.FieldUpdatedAt:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
 			} else if value.Valid {
-				u.UpdatedAt = value.Int64
+				u.UpdatedAt = value.Time
 			}
 		case user.FieldPermissions:
 			if value, ok := values[i].(*sql.NullString); !ok {
@@ -197,10 +198,10 @@ func (u *User) String() string {
 	builder.WriteString("User(")
 	builder.WriteString(fmt.Sprintf("id=%v, ", u.ID))
 	builder.WriteString("created_at=")
-	builder.WriteString(fmt.Sprintf("%v", u.CreatedAt))
+	builder.WriteString(u.CreatedAt.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("updated_at=")
-	builder.WriteString(fmt.Sprintf("%v", u.UpdatedAt))
+	builder.WriteString(u.UpdatedAt.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("permissions=")
 	builder.WriteString(u.Permissions)
diff --git a/internal/database/ent/db/user/user.go b/internal/database/ent/db/user/user.go
index 524bdf47..e4787254 100644
--- a/internal/database/ent/db/user/user.go
+++ b/internal/database/ent/db/user/user.go
@@ -3,6 +3,8 @@
 package user
 
 import (
+	"time"
+
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
 )
@@ -81,11 +83,11 @@ func ValidColumn(column string) bool {
 
 var (
 	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
-	DefaultCreatedAt func() int64
+	DefaultCreatedAt func() time.Time
 	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
-	DefaultUpdatedAt func() int64
+	DefaultUpdatedAt func() time.Time
 	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
-	UpdateDefaultUpdatedAt func() int64
+	UpdateDefaultUpdatedAt func() time.Time
 	// DefaultPermissions holds the default value on creation for the "permissions" field.
 	DefaultPermissions string
 )
diff --git a/internal/database/ent/db/user/where.go b/internal/database/ent/db/user/where.go
index c3a5e922..989d46ba 100644
--- a/internal/database/ent/db/user/where.go
+++ b/internal/database/ent/db/user/where.go
@@ -3,6 +3,8 @@
 package user
 
 import (
+	"time"
+
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
@@ -64,12 +66,12 @@ func IDContainsFold(id string) predicate.User {
 }
 
 // CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
-func CreatedAt(v int64) predicate.User {
+func CreatedAt(v time.Time) predicate.User {
 	return predicate.User(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
-func UpdatedAt(v int64) predicate.User {
+func UpdatedAt(v time.Time) predicate.User {
 	return predicate.User(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
@@ -79,82 +81,82 @@ func Permissions(v string) predicate.User {
 }
 
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v int64) predicate.User {
+func CreatedAtEQ(v time.Time) predicate.User {
 	return predicate.User(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v int64) predicate.User {
+func CreatedAtNEQ(v time.Time) predicate.User {
 	return predicate.User(sql.FieldNEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...int64) predicate.User {
+func CreatedAtIn(vs ...time.Time) predicate.User {
 	return predicate.User(sql.FieldIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...int64) predicate.User {
+func CreatedAtNotIn(vs ...time.Time) predicate.User {
 	return predicate.User(sql.FieldNotIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v int64) predicate.User {
+func CreatedAtGT(v time.Time) predicate.User {
 	return predicate.User(sql.FieldGT(FieldCreatedAt, v))
 }
 
 // CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v int64) predicate.User {
+func CreatedAtGTE(v time.Time) predicate.User {
 	return predicate.User(sql.FieldGTE(FieldCreatedAt, v))
 }
 
 // CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v int64) predicate.User {
+func CreatedAtLT(v time.Time) predicate.User {
 	return predicate.User(sql.FieldLT(FieldCreatedAt, v))
 }
 
 // CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v int64) predicate.User {
+func CreatedAtLTE(v time.Time) predicate.User {
 	return predicate.User(sql.FieldLTE(FieldCreatedAt, v))
 }
 
 // UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
-func UpdatedAtEQ(v int64) predicate.User {
+func UpdatedAtEQ(v time.Time) predicate.User {
 	return predicate.User(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
-func UpdatedAtNEQ(v int64) predicate.User {
+func UpdatedAtNEQ(v time.Time) predicate.User {
 	return predicate.User(sql.FieldNEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtIn applies the In predicate on the "updated_at" field.
-func UpdatedAtIn(vs ...int64) predicate.User {
+func UpdatedAtIn(vs ...time.Time) predicate.User {
 	return predicate.User(sql.FieldIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
-func UpdatedAtNotIn(vs ...int64) predicate.User {
+func UpdatedAtNotIn(vs ...time.Time) predicate.User {
 	return predicate.User(sql.FieldNotIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtGT applies the GT predicate on the "updated_at" field.
-func UpdatedAtGT(v int64) predicate.User {
+func UpdatedAtGT(v time.Time) predicate.User {
 	return predicate.User(sql.FieldGT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
-func UpdatedAtGTE(v int64) predicate.User {
+func UpdatedAtGTE(v time.Time) predicate.User {
 	return predicate.User(sql.FieldGTE(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLT applies the LT predicate on the "updated_at" field.
-func UpdatedAtLT(v int64) predicate.User {
+func UpdatedAtLT(v time.Time) predicate.User {
 	return predicate.User(sql.FieldLT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
-func UpdatedAtLTE(v int64) predicate.User {
+func UpdatedAtLTE(v time.Time) predicate.User {
 	return predicate.User(sql.FieldLTE(FieldUpdatedAt, v))
 }
 
diff --git a/internal/database/ent/db/user_create.go b/internal/database/ent/db/user_create.go
index 1aa4e5e8..8cf24699 100644
--- a/internal/database/ent/db/user_create.go
+++ b/internal/database/ent/db/user_create.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"entgo.io/ent/schema/field"
@@ -24,29 +25,29 @@ type UserCreate struct {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (uc *UserCreate) SetCreatedAt(i int64) *UserCreate {
-	uc.mutation.SetCreatedAt(i)
+func (uc *UserCreate) SetCreatedAt(t time.Time) *UserCreate {
+	uc.mutation.SetCreatedAt(t)
 	return uc
 }
 
 // SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
-func (uc *UserCreate) SetNillableCreatedAt(i *int64) *UserCreate {
-	if i != nil {
-		uc.SetCreatedAt(*i)
+func (uc *UserCreate) SetNillableCreatedAt(t *time.Time) *UserCreate {
+	if t != nil {
+		uc.SetCreatedAt(*t)
 	}
 	return uc
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (uc *UserCreate) SetUpdatedAt(i int64) *UserCreate {
-	uc.mutation.SetUpdatedAt(i)
+func (uc *UserCreate) SetUpdatedAt(t time.Time) *UserCreate {
+	uc.mutation.SetUpdatedAt(t)
 	return uc
 }
 
 // SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
-func (uc *UserCreate) SetNillableUpdatedAt(i *int64) *UserCreate {
-	if i != nil {
-		uc.SetUpdatedAt(*i)
+func (uc *UserCreate) SetNillableUpdatedAt(t *time.Time) *UserCreate {
+	if t != nil {
+		uc.SetUpdatedAt(*t)
 	}
 	return uc
 }
@@ -233,11 +234,11 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) {
 		_spec.ID.Value = id
 	}
 	if value, ok := uc.mutation.CreatedAt(); ok {
-		_spec.SetField(user.FieldCreatedAt, field.TypeInt64, value)
+		_spec.SetField(user.FieldCreatedAt, field.TypeTime, value)
 		_node.CreatedAt = value
 	}
 	if value, ok := uc.mutation.UpdatedAt(); ok {
-		_spec.SetField(user.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(user.FieldUpdatedAt, field.TypeTime, value)
 		_node.UpdatedAt = value
 	}
 	if value, ok := uc.mutation.Permissions(); ok {
diff --git a/internal/database/ent/db/user_query.go b/internal/database/ent/db/user_query.go
index 1416b0f7..2e37a52c 100644
--- a/internal/database/ent/db/user_query.go
+++ b/internal/database/ent/db/user_query.go
@@ -30,6 +30,7 @@ type UserQuery struct {
 	withSubscriptions       *UserSubscriptionQuery
 	withConnections         *UserConnectionQuery
 	withContent             *UserContentQuery
+	modifiers               []func(*sql.Selector)
 	// intermediate query (i.e. traversal path).
 	sql  *sql.Selector
 	path func(context.Context) (*sql.Selector, error)
@@ -406,7 +407,7 @@ func (uq *UserQuery) WithContent(opts ...func(*UserContentQuery)) *UserQuery {
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int64 `json:"created_at,omitempty"`
+//		CreatedAt time.Time `json:"created_at,omitempty"`
 //		Count int `json:"count,omitempty"`
 //	}
 //
@@ -429,7 +430,7 @@ func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy {
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int64 `json:"created_at,omitempty"`
+//		CreatedAt time.Time `json:"created_at,omitempty"`
 //	}
 //
 //	client.User.Query().
@@ -494,6 +495,9 @@ func (uq *UserQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*User, e
 		node.Edges.loadedTypes = loadedTypes
 		return node.assignValues(columns, values)
 	}
+	if len(uq.modifiers) > 0 {
+		_spec.Modifiers = uq.modifiers
+	}
 	for i := range hooks {
 		hooks[i](ctx, _spec)
 	}
@@ -659,6 +663,9 @@ func (uq *UserQuery) loadContent(ctx context.Context, query *UserContentQuery, n
 
 func (uq *UserQuery) sqlCount(ctx context.Context) (int, error) {
 	_spec := uq.querySpec()
+	if len(uq.modifiers) > 0 {
+		_spec.Modifiers = uq.modifiers
+	}
 	_spec.Node.Columns = uq.ctx.Fields
 	if len(uq.ctx.Fields) > 0 {
 		_spec.Unique = uq.ctx.Unique != nil && *uq.ctx.Unique
@@ -721,6 +728,9 @@ func (uq *UserQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	if uq.ctx.Unique != nil && *uq.ctx.Unique {
 		selector.Distinct()
 	}
+	for _, m := range uq.modifiers {
+		m(selector)
+	}
 	for _, p := range uq.predicates {
 		p(selector)
 	}
@@ -738,6 +748,12 @@ func (uq *UserQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	return selector
 }
 
+// Modify adds a query modifier for attaching custom logic to queries.
+func (uq *UserQuery) Modify(modifiers ...func(s *sql.Selector)) *UserSelect {
+	uq.modifiers = append(uq.modifiers, modifiers...)
+	return uq.Select()
+}
+
 // UserGroupBy is the group-by builder for User entities.
 type UserGroupBy struct {
 	selector
@@ -827,3 +843,9 @@ func (us *UserSelect) sqlScan(ctx context.Context, root *UserQuery, v any) error
 	defer rows.Close()
 	return sql.ScanSlice(rows, v)
 }
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (us *UserSelect) Modify(modifiers ...func(s *sql.Selector)) *UserSelect {
+	us.modifiers = append(us.modifiers, modifiers...)
+	return us
+}
diff --git a/internal/database/ent/db/user_update.go b/internal/database/ent/db/user_update.go
index 4a19da4a..57c92a14 100644
--- a/internal/database/ent/db/user_update.go
+++ b/internal/database/ent/db/user_update.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
@@ -22,8 +23,9 @@ import (
 // UserUpdate is the builder for updating User entities.
 type UserUpdate struct {
 	config
-	hooks    []Hook
-	mutation *UserMutation
+	hooks     []Hook
+	mutation  *UserMutation
+	modifiers []func(*sql.UpdateBuilder)
 }
 
 // Where appends a list predicates to the UserUpdate builder.
@@ -33,15 +35,8 @@ func (uu *UserUpdate) Where(ps ...predicate.User) *UserUpdate {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (uu *UserUpdate) SetUpdatedAt(i int64) *UserUpdate {
-	uu.mutation.ResetUpdatedAt()
-	uu.mutation.SetUpdatedAt(i)
-	return uu
-}
-
-// AddUpdatedAt adds i to the "updated_at" field.
-func (uu *UserUpdate) AddUpdatedAt(i int64) *UserUpdate {
-	uu.mutation.AddUpdatedAt(i)
+func (uu *UserUpdate) SetUpdatedAt(t time.Time) *UserUpdate {
+	uu.mutation.SetUpdatedAt(t)
 	return uu
 }
 
@@ -262,6 +257,12 @@ func (uu *UserUpdate) defaults() {
 	}
 }
 
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (uu *UserUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *UserUpdate {
+	uu.modifiers = append(uu.modifiers, modifiers...)
+	return uu
+}
+
 func (uu *UserUpdate) sqlSave(ctx context.Context) (n int, err error) {
 	_spec := sqlgraph.NewUpdateSpec(user.Table, user.Columns, sqlgraph.NewFieldSpec(user.FieldID, field.TypeString))
 	if ps := uu.mutation.predicates; len(ps) > 0 {
@@ -272,10 +273,7 @@ func (uu *UserUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 	}
 	if value, ok := uu.mutation.UpdatedAt(); ok {
-		_spec.SetField(user.FieldUpdatedAt, field.TypeInt64, value)
-	}
-	if value, ok := uu.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(user.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(user.FieldUpdatedAt, field.TypeTime, value)
 	}
 	if value, ok := uu.mutation.Permissions(); ok {
 		_spec.SetField(user.FieldPermissions, field.TypeString, value)
@@ -471,6 +469,7 @@ func (uu *UserUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 		_spec.Edges.Add = append(_spec.Edges.Add, edge)
 	}
+	_spec.AddModifiers(uu.modifiers...)
 	if n, err = sqlgraph.UpdateNodes(ctx, uu.driver, _spec); err != nil {
 		if _, ok := err.(*sqlgraph.NotFoundError); ok {
 			err = &NotFoundError{user.Label}
@@ -486,21 +485,15 @@ func (uu *UserUpdate) sqlSave(ctx context.Context) (n int, err error) {
 // UserUpdateOne is the builder for updating a single User entity.
 type UserUpdateOne struct {
 	config
-	fields   []string
-	hooks    []Hook
-	mutation *UserMutation
+	fields    []string
+	hooks     []Hook
+	mutation  *UserMutation
+	modifiers []func(*sql.UpdateBuilder)
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (uuo *UserUpdateOne) SetUpdatedAt(i int64) *UserUpdateOne {
-	uuo.mutation.ResetUpdatedAt()
-	uuo.mutation.SetUpdatedAt(i)
-	return uuo
-}
-
-// AddUpdatedAt adds i to the "updated_at" field.
-func (uuo *UserUpdateOne) AddUpdatedAt(i int64) *UserUpdateOne {
-	uuo.mutation.AddUpdatedAt(i)
+func (uuo *UserUpdateOne) SetUpdatedAt(t time.Time) *UserUpdateOne {
+	uuo.mutation.SetUpdatedAt(t)
 	return uuo
 }
 
@@ -734,6 +727,12 @@ func (uuo *UserUpdateOne) defaults() {
 	}
 }
 
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (uuo *UserUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *UserUpdateOne {
+	uuo.modifiers = append(uuo.modifiers, modifiers...)
+	return uuo
+}
+
 func (uuo *UserUpdateOne) sqlSave(ctx context.Context) (_node *User, err error) {
 	_spec := sqlgraph.NewUpdateSpec(user.Table, user.Columns, sqlgraph.NewFieldSpec(user.FieldID, field.TypeString))
 	id, ok := uuo.mutation.ID()
@@ -761,10 +760,7 @@ func (uuo *UserUpdateOne) sqlSave(ctx context.Context) (_node *User, err error)
 		}
 	}
 	if value, ok := uuo.mutation.UpdatedAt(); ok {
-		_spec.SetField(user.FieldUpdatedAt, field.TypeInt64, value)
-	}
-	if value, ok := uuo.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(user.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(user.FieldUpdatedAt, field.TypeTime, value)
 	}
 	if value, ok := uuo.mutation.Permissions(); ok {
 		_spec.SetField(user.FieldPermissions, field.TypeString, value)
@@ -960,6 +956,7 @@ func (uuo *UserUpdateOne) sqlSave(ctx context.Context) (_node *User, err error)
 		}
 		_spec.Edges.Add = append(_spec.Edges.Add, edge)
 	}
+	_spec.AddModifiers(uuo.modifiers...)
 	_node = &User{config: uuo.config}
 	_spec.Assign = _node.assignValues
 	_spec.ScanValues = _node.scanValues
diff --git a/internal/database/ent/db/userconnection.go b/internal/database/ent/db/userconnection.go
index 100553b6..c595e122 100644
--- a/internal/database/ent/db/userconnection.go
+++ b/internal/database/ent/db/userconnection.go
@@ -6,6 +6,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"strings"
+	"time"
 
 	"entgo.io/ent"
 	"entgo.io/ent/dialect/sql"
@@ -20,9 +21,9 @@ type UserConnection struct {
 	// ID of the ent.
 	ID string `json:"id,omitempty"`
 	// CreatedAt holds the value of the "created_at" field.
-	CreatedAt int64 `json:"created_at,omitempty"`
+	CreatedAt time.Time `json:"created_at,omitempty"`
 	// UpdatedAt holds the value of the "updated_at" field.
-	UpdatedAt int64 `json:"updated_at,omitempty"`
+	UpdatedAt time.Time `json:"updated_at,omitempty"`
 	// Type holds the value of the "type" field.
 	Type models.ConnectionType `json:"type,omitempty"`
 	// UserID holds the value of the "user_id" field.
@@ -66,10 +67,10 @@ func (*UserConnection) scanValues(columns []string) ([]any, error) {
 		switch columns[i] {
 		case userconnection.FieldMetadata:
 			values[i] = new([]byte)
-		case userconnection.FieldCreatedAt, userconnection.FieldUpdatedAt:
-			values[i] = new(sql.NullInt64)
 		case userconnection.FieldID, userconnection.FieldType, userconnection.FieldUserID, userconnection.FieldReferenceID, userconnection.FieldPermissions:
 			values[i] = new(sql.NullString)
+		case userconnection.FieldCreatedAt, userconnection.FieldUpdatedAt:
+			values[i] = new(sql.NullTime)
 		default:
 			values[i] = new(sql.UnknownType)
 		}
@@ -92,16 +93,16 @@ func (uc *UserConnection) assignValues(columns []string, values []any) error {
 				uc.ID = value.String
 			}
 		case userconnection.FieldCreatedAt:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field created_at", values[i])
 			} else if value.Valid {
-				uc.CreatedAt = value.Int64
+				uc.CreatedAt = value.Time
 			}
 		case userconnection.FieldUpdatedAt:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
 			} else if value.Valid {
-				uc.UpdatedAt = value.Int64
+				uc.UpdatedAt = value.Time
 			}
 		case userconnection.FieldType:
 			if value, ok := values[i].(*sql.NullString); !ok {
@@ -177,10 +178,10 @@ func (uc *UserConnection) String() string {
 	builder.WriteString("UserConnection(")
 	builder.WriteString(fmt.Sprintf("id=%v, ", uc.ID))
 	builder.WriteString("created_at=")
-	builder.WriteString(fmt.Sprintf("%v", uc.CreatedAt))
+	builder.WriteString(uc.CreatedAt.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("updated_at=")
-	builder.WriteString(fmt.Sprintf("%v", uc.UpdatedAt))
+	builder.WriteString(uc.UpdatedAt.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("type=")
 	builder.WriteString(fmt.Sprintf("%v", uc.Type))
diff --git a/internal/database/ent/db/userconnection/userconnection.go b/internal/database/ent/db/userconnection/userconnection.go
index 0b1c4114..67c3b49d 100644
--- a/internal/database/ent/db/userconnection/userconnection.go
+++ b/internal/database/ent/db/userconnection/userconnection.go
@@ -4,6 +4,7 @@ package userconnection
 
 import (
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
@@ -66,11 +67,11 @@ func ValidColumn(column string) bool {
 
 var (
 	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
-	DefaultCreatedAt func() int64
+	DefaultCreatedAt func() time.Time
 	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
-	DefaultUpdatedAt func() int64
+	DefaultUpdatedAt func() time.Time
 	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
-	UpdateDefaultUpdatedAt func() int64
+	UpdateDefaultUpdatedAt func() time.Time
 	// DefaultPermissions holds the default value on creation for the "permissions" field.
 	DefaultPermissions string
 	// DefaultID holds the default value on creation for the "id" field.
diff --git a/internal/database/ent/db/userconnection/where.go b/internal/database/ent/db/userconnection/where.go
index 9726b22e..65f6ba25 100644
--- a/internal/database/ent/db/userconnection/where.go
+++ b/internal/database/ent/db/userconnection/where.go
@@ -3,6 +3,8 @@
 package userconnection
 
 import (
+	"time"
+
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
@@ -65,12 +67,12 @@ func IDContainsFold(id string) predicate.UserConnection {
 }
 
 // CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
-func CreatedAt(v int64) predicate.UserConnection {
+func CreatedAt(v time.Time) predicate.UserConnection {
 	return predicate.UserConnection(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
-func UpdatedAt(v int64) predicate.UserConnection {
+func UpdatedAt(v time.Time) predicate.UserConnection {
 	return predicate.UserConnection(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
@@ -90,82 +92,82 @@ func Permissions(v string) predicate.UserConnection {
 }
 
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v int64) predicate.UserConnection {
+func CreatedAtEQ(v time.Time) predicate.UserConnection {
 	return predicate.UserConnection(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v int64) predicate.UserConnection {
+func CreatedAtNEQ(v time.Time) predicate.UserConnection {
 	return predicate.UserConnection(sql.FieldNEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...int64) predicate.UserConnection {
+func CreatedAtIn(vs ...time.Time) predicate.UserConnection {
 	return predicate.UserConnection(sql.FieldIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...int64) predicate.UserConnection {
+func CreatedAtNotIn(vs ...time.Time) predicate.UserConnection {
 	return predicate.UserConnection(sql.FieldNotIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v int64) predicate.UserConnection {
+func CreatedAtGT(v time.Time) predicate.UserConnection {
 	return predicate.UserConnection(sql.FieldGT(FieldCreatedAt, v))
 }
 
 // CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v int64) predicate.UserConnection {
+func CreatedAtGTE(v time.Time) predicate.UserConnection {
 	return predicate.UserConnection(sql.FieldGTE(FieldCreatedAt, v))
 }
 
 // CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v int64) predicate.UserConnection {
+func CreatedAtLT(v time.Time) predicate.UserConnection {
 	return predicate.UserConnection(sql.FieldLT(FieldCreatedAt, v))
 }
 
 // CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v int64) predicate.UserConnection {
+func CreatedAtLTE(v time.Time) predicate.UserConnection {
 	return predicate.UserConnection(sql.FieldLTE(FieldCreatedAt, v))
 }
 
 // UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
-func UpdatedAtEQ(v int64) predicate.UserConnection {
+func UpdatedAtEQ(v time.Time) predicate.UserConnection {
 	return predicate.UserConnection(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
-func UpdatedAtNEQ(v int64) predicate.UserConnection {
+func UpdatedAtNEQ(v time.Time) predicate.UserConnection {
 	return predicate.UserConnection(sql.FieldNEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtIn applies the In predicate on the "updated_at" field.
-func UpdatedAtIn(vs ...int64) predicate.UserConnection {
+func UpdatedAtIn(vs ...time.Time) predicate.UserConnection {
 	return predicate.UserConnection(sql.FieldIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
-func UpdatedAtNotIn(vs ...int64) predicate.UserConnection {
+func UpdatedAtNotIn(vs ...time.Time) predicate.UserConnection {
 	return predicate.UserConnection(sql.FieldNotIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtGT applies the GT predicate on the "updated_at" field.
-func UpdatedAtGT(v int64) predicate.UserConnection {
+func UpdatedAtGT(v time.Time) predicate.UserConnection {
 	return predicate.UserConnection(sql.FieldGT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
-func UpdatedAtGTE(v int64) predicate.UserConnection {
+func UpdatedAtGTE(v time.Time) predicate.UserConnection {
 	return predicate.UserConnection(sql.FieldGTE(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLT applies the LT predicate on the "updated_at" field.
-func UpdatedAtLT(v int64) predicate.UserConnection {
+func UpdatedAtLT(v time.Time) predicate.UserConnection {
 	return predicate.UserConnection(sql.FieldLT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
-func UpdatedAtLTE(v int64) predicate.UserConnection {
+func UpdatedAtLTE(v time.Time) predicate.UserConnection {
 	return predicate.UserConnection(sql.FieldLTE(FieldUpdatedAt, v))
 }
 
diff --git a/internal/database/ent/db/userconnection_create.go b/internal/database/ent/db/userconnection_create.go
index 8478c906..22c040fd 100644
--- a/internal/database/ent/db/userconnection_create.go
+++ b/internal/database/ent/db/userconnection_create.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"entgo.io/ent/schema/field"
@@ -22,29 +23,29 @@ type UserConnectionCreate struct {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (ucc *UserConnectionCreate) SetCreatedAt(i int64) *UserConnectionCreate {
-	ucc.mutation.SetCreatedAt(i)
+func (ucc *UserConnectionCreate) SetCreatedAt(t time.Time) *UserConnectionCreate {
+	ucc.mutation.SetCreatedAt(t)
 	return ucc
 }
 
 // SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
-func (ucc *UserConnectionCreate) SetNillableCreatedAt(i *int64) *UserConnectionCreate {
-	if i != nil {
-		ucc.SetCreatedAt(*i)
+func (ucc *UserConnectionCreate) SetNillableCreatedAt(t *time.Time) *UserConnectionCreate {
+	if t != nil {
+		ucc.SetCreatedAt(*t)
 	}
 	return ucc
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (ucc *UserConnectionCreate) SetUpdatedAt(i int64) *UserConnectionCreate {
-	ucc.mutation.SetUpdatedAt(i)
+func (ucc *UserConnectionCreate) SetUpdatedAt(t time.Time) *UserConnectionCreate {
+	ucc.mutation.SetUpdatedAt(t)
 	return ucc
 }
 
 // SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
-func (ucc *UserConnectionCreate) SetNillableUpdatedAt(i *int64) *UserConnectionCreate {
-	if i != nil {
-		ucc.SetUpdatedAt(*i)
+func (ucc *UserConnectionCreate) SetNillableUpdatedAt(t *time.Time) *UserConnectionCreate {
+	if t != nil {
+		ucc.SetUpdatedAt(*t)
 	}
 	return ucc
 }
@@ -220,11 +221,11 @@ func (ucc *UserConnectionCreate) createSpec() (*UserConnection, *sqlgraph.Create
 		_spec.ID.Value = id
 	}
 	if value, ok := ucc.mutation.CreatedAt(); ok {
-		_spec.SetField(userconnection.FieldCreatedAt, field.TypeInt64, value)
+		_spec.SetField(userconnection.FieldCreatedAt, field.TypeTime, value)
 		_node.CreatedAt = value
 	}
 	if value, ok := ucc.mutation.UpdatedAt(); ok {
-		_spec.SetField(userconnection.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(userconnection.FieldUpdatedAt, field.TypeTime, value)
 		_node.UpdatedAt = value
 	}
 	if value, ok := ucc.mutation.GetType(); ok {
diff --git a/internal/database/ent/db/userconnection_query.go b/internal/database/ent/db/userconnection_query.go
index 164e8e87..17f6603d 100644
--- a/internal/database/ent/db/userconnection_query.go
+++ b/internal/database/ent/db/userconnection_query.go
@@ -23,6 +23,7 @@ type UserConnectionQuery struct {
 	inters     []Interceptor
 	predicates []predicate.UserConnection
 	withUser   *UserQuery
+	modifiers  []func(*sql.Selector)
 	// intermediate query (i.e. traversal path).
 	sql  *sql.Selector
 	path func(context.Context) (*sql.Selector, error)
@@ -297,7 +298,7 @@ func (ucq *UserConnectionQuery) WithUser(opts ...func(*UserQuery)) *UserConnecti
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int64 `json:"created_at,omitempty"`
+//		CreatedAt time.Time `json:"created_at,omitempty"`
 //		Count int `json:"count,omitempty"`
 //	}
 //
@@ -320,7 +321,7 @@ func (ucq *UserConnectionQuery) GroupBy(field string, fields ...string) *UserCon
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int64 `json:"created_at,omitempty"`
+//		CreatedAt time.Time `json:"created_at,omitempty"`
 //	}
 //
 //	client.UserConnection.Query().
@@ -382,6 +383,9 @@ func (ucq *UserConnectionQuery) sqlAll(ctx context.Context, hooks ...queryHook)
 		node.Edges.loadedTypes = loadedTypes
 		return node.assignValues(columns, values)
 	}
+	if len(ucq.modifiers) > 0 {
+		_spec.Modifiers = ucq.modifiers
+	}
 	for i := range hooks {
 		hooks[i](ctx, _spec)
 	}
@@ -432,6 +436,9 @@ func (ucq *UserConnectionQuery) loadUser(ctx context.Context, query *UserQuery,
 
 func (ucq *UserConnectionQuery) sqlCount(ctx context.Context) (int, error) {
 	_spec := ucq.querySpec()
+	if len(ucq.modifiers) > 0 {
+		_spec.Modifiers = ucq.modifiers
+	}
 	_spec.Node.Columns = ucq.ctx.Fields
 	if len(ucq.ctx.Fields) > 0 {
 		_spec.Unique = ucq.ctx.Unique != nil && *ucq.ctx.Unique
@@ -497,6 +504,9 @@ func (ucq *UserConnectionQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	if ucq.ctx.Unique != nil && *ucq.ctx.Unique {
 		selector.Distinct()
 	}
+	for _, m := range ucq.modifiers {
+		m(selector)
+	}
 	for _, p := range ucq.predicates {
 		p(selector)
 	}
@@ -514,6 +524,12 @@ func (ucq *UserConnectionQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	return selector
 }
 
+// Modify adds a query modifier for attaching custom logic to queries.
+func (ucq *UserConnectionQuery) Modify(modifiers ...func(s *sql.Selector)) *UserConnectionSelect {
+	ucq.modifiers = append(ucq.modifiers, modifiers...)
+	return ucq.Select()
+}
+
 // UserConnectionGroupBy is the group-by builder for UserConnection entities.
 type UserConnectionGroupBy struct {
 	selector
@@ -603,3 +619,9 @@ func (ucs *UserConnectionSelect) sqlScan(ctx context.Context, root *UserConnecti
 	defer rows.Close()
 	return sql.ScanSlice(rows, v)
 }
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (ucs *UserConnectionSelect) Modify(modifiers ...func(s *sql.Selector)) *UserConnectionSelect {
+	ucs.modifiers = append(ucs.modifiers, modifiers...)
+	return ucs
+}
diff --git a/internal/database/ent/db/userconnection_update.go b/internal/database/ent/db/userconnection_update.go
index 8744515f..e41384cd 100644
--- a/internal/database/ent/db/userconnection_update.go
+++ b/internal/database/ent/db/userconnection_update.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
@@ -18,8 +19,9 @@ import (
 // UserConnectionUpdate is the builder for updating UserConnection entities.
 type UserConnectionUpdate struct {
 	config
-	hooks    []Hook
-	mutation *UserConnectionMutation
+	hooks     []Hook
+	mutation  *UserConnectionMutation
+	modifiers []func(*sql.UpdateBuilder)
 }
 
 // Where appends a list predicates to the UserConnectionUpdate builder.
@@ -29,15 +31,8 @@ func (ucu *UserConnectionUpdate) Where(ps ...predicate.UserConnection) *UserConn
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (ucu *UserConnectionUpdate) SetUpdatedAt(i int64) *UserConnectionUpdate {
-	ucu.mutation.ResetUpdatedAt()
-	ucu.mutation.SetUpdatedAt(i)
-	return ucu
-}
-
-// AddUpdatedAt adds i to the "updated_at" field.
-func (ucu *UserConnectionUpdate) AddUpdatedAt(i int64) *UserConnectionUpdate {
-	ucu.mutation.AddUpdatedAt(i)
+func (ucu *UserConnectionUpdate) SetUpdatedAt(t time.Time) *UserConnectionUpdate {
+	ucu.mutation.SetUpdatedAt(t)
 	return ucu
 }
 
@@ -155,6 +150,12 @@ func (ucu *UserConnectionUpdate) check() error {
 	return nil
 }
 
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (ucu *UserConnectionUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *UserConnectionUpdate {
+	ucu.modifiers = append(ucu.modifiers, modifiers...)
+	return ucu
+}
+
 func (ucu *UserConnectionUpdate) sqlSave(ctx context.Context) (n int, err error) {
 	if err := ucu.check(); err != nil {
 		return n, err
@@ -168,10 +169,7 @@ func (ucu *UserConnectionUpdate) sqlSave(ctx context.Context) (n int, err error)
 		}
 	}
 	if value, ok := ucu.mutation.UpdatedAt(); ok {
-		_spec.SetField(userconnection.FieldUpdatedAt, field.TypeInt64, value)
-	}
-	if value, ok := ucu.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(userconnection.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(userconnection.FieldUpdatedAt, field.TypeTime, value)
 	}
 	if value, ok := ucu.mutation.GetType(); ok {
 		_spec.SetField(userconnection.FieldType, field.TypeEnum, value)
@@ -191,6 +189,7 @@ func (ucu *UserConnectionUpdate) sqlSave(ctx context.Context) (n int, err error)
 	if ucu.mutation.MetadataCleared() {
 		_spec.ClearField(userconnection.FieldMetadata, field.TypeJSON)
 	}
+	_spec.AddModifiers(ucu.modifiers...)
 	if n, err = sqlgraph.UpdateNodes(ctx, ucu.driver, _spec); err != nil {
 		if _, ok := err.(*sqlgraph.NotFoundError); ok {
 			err = &NotFoundError{userconnection.Label}
@@ -206,21 +205,15 @@ func (ucu *UserConnectionUpdate) sqlSave(ctx context.Context) (n int, err error)
 // UserConnectionUpdateOne is the builder for updating a single UserConnection entity.
 type UserConnectionUpdateOne struct {
 	config
-	fields   []string
-	hooks    []Hook
-	mutation *UserConnectionMutation
+	fields    []string
+	hooks     []Hook
+	mutation  *UserConnectionMutation
+	modifiers []func(*sql.UpdateBuilder)
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (ucuo *UserConnectionUpdateOne) SetUpdatedAt(i int64) *UserConnectionUpdateOne {
-	ucuo.mutation.ResetUpdatedAt()
-	ucuo.mutation.SetUpdatedAt(i)
-	return ucuo
-}
-
-// AddUpdatedAt adds i to the "updated_at" field.
-func (ucuo *UserConnectionUpdateOne) AddUpdatedAt(i int64) *UserConnectionUpdateOne {
-	ucuo.mutation.AddUpdatedAt(i)
+func (ucuo *UserConnectionUpdateOne) SetUpdatedAt(t time.Time) *UserConnectionUpdateOne {
+	ucuo.mutation.SetUpdatedAt(t)
 	return ucuo
 }
 
@@ -351,6 +344,12 @@ func (ucuo *UserConnectionUpdateOne) check() error {
 	return nil
 }
 
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (ucuo *UserConnectionUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *UserConnectionUpdateOne {
+	ucuo.modifiers = append(ucuo.modifiers, modifiers...)
+	return ucuo
+}
+
 func (ucuo *UserConnectionUpdateOne) sqlSave(ctx context.Context) (_node *UserConnection, err error) {
 	if err := ucuo.check(); err != nil {
 		return _node, err
@@ -381,10 +380,7 @@ func (ucuo *UserConnectionUpdateOne) sqlSave(ctx context.Context) (_node *UserCo
 		}
 	}
 	if value, ok := ucuo.mutation.UpdatedAt(); ok {
-		_spec.SetField(userconnection.FieldUpdatedAt, field.TypeInt64, value)
-	}
-	if value, ok := ucuo.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(userconnection.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(userconnection.FieldUpdatedAt, field.TypeTime, value)
 	}
 	if value, ok := ucuo.mutation.GetType(); ok {
 		_spec.SetField(userconnection.FieldType, field.TypeEnum, value)
@@ -404,6 +400,7 @@ func (ucuo *UserConnectionUpdateOne) sqlSave(ctx context.Context) (_node *UserCo
 	if ucuo.mutation.MetadataCleared() {
 		_spec.ClearField(userconnection.FieldMetadata, field.TypeJSON)
 	}
+	_spec.AddModifiers(ucuo.modifiers...)
 	_node = &UserConnection{config: ucuo.config}
 	_spec.Assign = _node.assignValues
 	_spec.ScanValues = _node.scanValues
diff --git a/internal/database/ent/db/usercontent.go b/internal/database/ent/db/usercontent.go
index f60b64d1..7144a59f 100644
--- a/internal/database/ent/db/usercontent.go
+++ b/internal/database/ent/db/usercontent.go
@@ -6,6 +6,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"strings"
+	"time"
 
 	"entgo.io/ent"
 	"entgo.io/ent/dialect/sql"
@@ -20,9 +21,9 @@ type UserContent struct {
 	// ID of the ent.
 	ID string `json:"id,omitempty"`
 	// CreatedAt holds the value of the "created_at" field.
-	CreatedAt int64 `json:"created_at,omitempty"`
+	CreatedAt time.Time `json:"created_at,omitempty"`
 	// UpdatedAt holds the value of the "updated_at" field.
-	UpdatedAt int64 `json:"updated_at,omitempty"`
+	UpdatedAt time.Time `json:"updated_at,omitempty"`
 	// Type holds the value of the "type" field.
 	Type models.UserContentType `json:"type,omitempty"`
 	// UserID holds the value of the "user_id" field.
@@ -66,10 +67,10 @@ func (*UserContent) scanValues(columns []string) ([]any, error) {
 		switch columns[i] {
 		case usercontent.FieldMetadata:
 			values[i] = new([]byte)
-		case usercontent.FieldCreatedAt, usercontent.FieldUpdatedAt:
-			values[i] = new(sql.NullInt64)
 		case usercontent.FieldID, usercontent.FieldType, usercontent.FieldUserID, usercontent.FieldReferenceID, usercontent.FieldValue:
 			values[i] = new(sql.NullString)
+		case usercontent.FieldCreatedAt, usercontent.FieldUpdatedAt:
+			values[i] = new(sql.NullTime)
 		default:
 			values[i] = new(sql.UnknownType)
 		}
@@ -92,16 +93,16 @@ func (uc *UserContent) assignValues(columns []string, values []any) error {
 				uc.ID = value.String
 			}
 		case usercontent.FieldCreatedAt:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field created_at", values[i])
 			} else if value.Valid {
-				uc.CreatedAt = value.Int64
+				uc.CreatedAt = value.Time
 			}
 		case usercontent.FieldUpdatedAt:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
 			} else if value.Valid {
-				uc.UpdatedAt = value.Int64
+				uc.UpdatedAt = value.Time
 			}
 		case usercontent.FieldType:
 			if value, ok := values[i].(*sql.NullString); !ok {
@@ -177,10 +178,10 @@ func (uc *UserContent) String() string {
 	builder.WriteString("UserContent(")
 	builder.WriteString(fmt.Sprintf("id=%v, ", uc.ID))
 	builder.WriteString("created_at=")
-	builder.WriteString(fmt.Sprintf("%v", uc.CreatedAt))
+	builder.WriteString(uc.CreatedAt.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("updated_at=")
-	builder.WriteString(fmt.Sprintf("%v", uc.UpdatedAt))
+	builder.WriteString(uc.UpdatedAt.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("type=")
 	builder.WriteString(fmt.Sprintf("%v", uc.Type))
diff --git a/internal/database/ent/db/usercontent/usercontent.go b/internal/database/ent/db/usercontent/usercontent.go
index a05b1dcb..ab3dc61b 100644
--- a/internal/database/ent/db/usercontent/usercontent.go
+++ b/internal/database/ent/db/usercontent/usercontent.go
@@ -4,6 +4,7 @@ package usercontent
 
 import (
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
@@ -66,11 +67,11 @@ func ValidColumn(column string) bool {
 
 var (
 	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
-	DefaultCreatedAt func() int64
+	DefaultCreatedAt func() time.Time
 	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
-	DefaultUpdatedAt func() int64
+	DefaultUpdatedAt func() time.Time
 	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
-	UpdateDefaultUpdatedAt func() int64
+	UpdateDefaultUpdatedAt func() time.Time
 	// DefaultID holds the default value on creation for the "id" field.
 	DefaultID func() string
 )
diff --git a/internal/database/ent/db/usercontent/where.go b/internal/database/ent/db/usercontent/where.go
index db3d4033..40dfbac4 100644
--- a/internal/database/ent/db/usercontent/where.go
+++ b/internal/database/ent/db/usercontent/where.go
@@ -3,6 +3,8 @@
 package usercontent
 
 import (
+	"time"
+
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
@@ -65,12 +67,12 @@ func IDContainsFold(id string) predicate.UserContent {
 }
 
 // CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
-func CreatedAt(v int64) predicate.UserContent {
+func CreatedAt(v time.Time) predicate.UserContent {
 	return predicate.UserContent(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
-func UpdatedAt(v int64) predicate.UserContent {
+func UpdatedAt(v time.Time) predicate.UserContent {
 	return predicate.UserContent(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
@@ -90,82 +92,82 @@ func Value(v string) predicate.UserContent {
 }
 
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v int64) predicate.UserContent {
+func CreatedAtEQ(v time.Time) predicate.UserContent {
 	return predicate.UserContent(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v int64) predicate.UserContent {
+func CreatedAtNEQ(v time.Time) predicate.UserContent {
 	return predicate.UserContent(sql.FieldNEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...int64) predicate.UserContent {
+func CreatedAtIn(vs ...time.Time) predicate.UserContent {
 	return predicate.UserContent(sql.FieldIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...int64) predicate.UserContent {
+func CreatedAtNotIn(vs ...time.Time) predicate.UserContent {
 	return predicate.UserContent(sql.FieldNotIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v int64) predicate.UserContent {
+func CreatedAtGT(v time.Time) predicate.UserContent {
 	return predicate.UserContent(sql.FieldGT(FieldCreatedAt, v))
 }
 
 // CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v int64) predicate.UserContent {
+func CreatedAtGTE(v time.Time) predicate.UserContent {
 	return predicate.UserContent(sql.FieldGTE(FieldCreatedAt, v))
 }
 
 // CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v int64) predicate.UserContent {
+func CreatedAtLT(v time.Time) predicate.UserContent {
 	return predicate.UserContent(sql.FieldLT(FieldCreatedAt, v))
 }
 
 // CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v int64) predicate.UserContent {
+func CreatedAtLTE(v time.Time) predicate.UserContent {
 	return predicate.UserContent(sql.FieldLTE(FieldCreatedAt, v))
 }
 
 // UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
-func UpdatedAtEQ(v int64) predicate.UserContent {
+func UpdatedAtEQ(v time.Time) predicate.UserContent {
 	return predicate.UserContent(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
-func UpdatedAtNEQ(v int64) predicate.UserContent {
+func UpdatedAtNEQ(v time.Time) predicate.UserContent {
 	return predicate.UserContent(sql.FieldNEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtIn applies the In predicate on the "updated_at" field.
-func UpdatedAtIn(vs ...int64) predicate.UserContent {
+func UpdatedAtIn(vs ...time.Time) predicate.UserContent {
 	return predicate.UserContent(sql.FieldIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
-func UpdatedAtNotIn(vs ...int64) predicate.UserContent {
+func UpdatedAtNotIn(vs ...time.Time) predicate.UserContent {
 	return predicate.UserContent(sql.FieldNotIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtGT applies the GT predicate on the "updated_at" field.
-func UpdatedAtGT(v int64) predicate.UserContent {
+func UpdatedAtGT(v time.Time) predicate.UserContent {
 	return predicate.UserContent(sql.FieldGT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
-func UpdatedAtGTE(v int64) predicate.UserContent {
+func UpdatedAtGTE(v time.Time) predicate.UserContent {
 	return predicate.UserContent(sql.FieldGTE(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLT applies the LT predicate on the "updated_at" field.
-func UpdatedAtLT(v int64) predicate.UserContent {
+func UpdatedAtLT(v time.Time) predicate.UserContent {
 	return predicate.UserContent(sql.FieldLT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
-func UpdatedAtLTE(v int64) predicate.UserContent {
+func UpdatedAtLTE(v time.Time) predicate.UserContent {
 	return predicate.UserContent(sql.FieldLTE(FieldUpdatedAt, v))
 }
 
diff --git a/internal/database/ent/db/usercontent_create.go b/internal/database/ent/db/usercontent_create.go
index d127d2a3..ba70058f 100644
--- a/internal/database/ent/db/usercontent_create.go
+++ b/internal/database/ent/db/usercontent_create.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"entgo.io/ent/schema/field"
@@ -22,29 +23,29 @@ type UserContentCreate struct {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (ucc *UserContentCreate) SetCreatedAt(i int64) *UserContentCreate {
-	ucc.mutation.SetCreatedAt(i)
+func (ucc *UserContentCreate) SetCreatedAt(t time.Time) *UserContentCreate {
+	ucc.mutation.SetCreatedAt(t)
 	return ucc
 }
 
 // SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
-func (ucc *UserContentCreate) SetNillableCreatedAt(i *int64) *UserContentCreate {
-	if i != nil {
-		ucc.SetCreatedAt(*i)
+func (ucc *UserContentCreate) SetNillableCreatedAt(t *time.Time) *UserContentCreate {
+	if t != nil {
+		ucc.SetCreatedAt(*t)
 	}
 	return ucc
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (ucc *UserContentCreate) SetUpdatedAt(i int64) *UserContentCreate {
-	ucc.mutation.SetUpdatedAt(i)
+func (ucc *UserContentCreate) SetUpdatedAt(t time.Time) *UserContentCreate {
+	ucc.mutation.SetUpdatedAt(t)
 	return ucc
 }
 
 // SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
-func (ucc *UserContentCreate) SetNillableUpdatedAt(i *int64) *UserContentCreate {
-	if i != nil {
-		ucc.SetUpdatedAt(*i)
+func (ucc *UserContentCreate) SetNillableUpdatedAt(t *time.Time) *UserContentCreate {
+	if t != nil {
+		ucc.SetUpdatedAt(*t)
 	}
 	return ucc
 }
@@ -214,11 +215,11 @@ func (ucc *UserContentCreate) createSpec() (*UserContent, *sqlgraph.CreateSpec)
 		_spec.ID.Value = id
 	}
 	if value, ok := ucc.mutation.CreatedAt(); ok {
-		_spec.SetField(usercontent.FieldCreatedAt, field.TypeInt64, value)
+		_spec.SetField(usercontent.FieldCreatedAt, field.TypeTime, value)
 		_node.CreatedAt = value
 	}
 	if value, ok := ucc.mutation.UpdatedAt(); ok {
-		_spec.SetField(usercontent.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(usercontent.FieldUpdatedAt, field.TypeTime, value)
 		_node.UpdatedAt = value
 	}
 	if value, ok := ucc.mutation.GetType(); ok {
diff --git a/internal/database/ent/db/usercontent_query.go b/internal/database/ent/db/usercontent_query.go
index 8c189429..7552a40f 100644
--- a/internal/database/ent/db/usercontent_query.go
+++ b/internal/database/ent/db/usercontent_query.go
@@ -23,6 +23,7 @@ type UserContentQuery struct {
 	inters     []Interceptor
 	predicates []predicate.UserContent
 	withUser   *UserQuery
+	modifiers  []func(*sql.Selector)
 	// intermediate query (i.e. traversal path).
 	sql  *sql.Selector
 	path func(context.Context) (*sql.Selector, error)
@@ -297,7 +298,7 @@ func (ucq *UserContentQuery) WithUser(opts ...func(*UserQuery)) *UserContentQuer
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int64 `json:"created_at,omitempty"`
+//		CreatedAt time.Time `json:"created_at,omitempty"`
 //		Count int `json:"count,omitempty"`
 //	}
 //
@@ -320,7 +321,7 @@ func (ucq *UserContentQuery) GroupBy(field string, fields ...string) *UserConten
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int64 `json:"created_at,omitempty"`
+//		CreatedAt time.Time `json:"created_at,omitempty"`
 //	}
 //
 //	client.UserContent.Query().
@@ -382,6 +383,9 @@ func (ucq *UserContentQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]
 		node.Edges.loadedTypes = loadedTypes
 		return node.assignValues(columns, values)
 	}
+	if len(ucq.modifiers) > 0 {
+		_spec.Modifiers = ucq.modifiers
+	}
 	for i := range hooks {
 		hooks[i](ctx, _spec)
 	}
@@ -432,6 +436,9 @@ func (ucq *UserContentQuery) loadUser(ctx context.Context, query *UserQuery, nod
 
 func (ucq *UserContentQuery) sqlCount(ctx context.Context) (int, error) {
 	_spec := ucq.querySpec()
+	if len(ucq.modifiers) > 0 {
+		_spec.Modifiers = ucq.modifiers
+	}
 	_spec.Node.Columns = ucq.ctx.Fields
 	if len(ucq.ctx.Fields) > 0 {
 		_spec.Unique = ucq.ctx.Unique != nil && *ucq.ctx.Unique
@@ -497,6 +504,9 @@ func (ucq *UserContentQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	if ucq.ctx.Unique != nil && *ucq.ctx.Unique {
 		selector.Distinct()
 	}
+	for _, m := range ucq.modifiers {
+		m(selector)
+	}
 	for _, p := range ucq.predicates {
 		p(selector)
 	}
@@ -514,6 +524,12 @@ func (ucq *UserContentQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	return selector
 }
 
+// Modify adds a query modifier for attaching custom logic to queries.
+func (ucq *UserContentQuery) Modify(modifiers ...func(s *sql.Selector)) *UserContentSelect {
+	ucq.modifiers = append(ucq.modifiers, modifiers...)
+	return ucq.Select()
+}
+
 // UserContentGroupBy is the group-by builder for UserContent entities.
 type UserContentGroupBy struct {
 	selector
@@ -603,3 +619,9 @@ func (ucs *UserContentSelect) sqlScan(ctx context.Context, root *UserContentQuer
 	defer rows.Close()
 	return sql.ScanSlice(rows, v)
 }
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (ucs *UserContentSelect) Modify(modifiers ...func(s *sql.Selector)) *UserContentSelect {
+	ucs.modifiers = append(ucs.modifiers, modifiers...)
+	return ucs
+}
diff --git a/internal/database/ent/db/usercontent_update.go b/internal/database/ent/db/usercontent_update.go
index 93054653..b6595543 100644
--- a/internal/database/ent/db/usercontent_update.go
+++ b/internal/database/ent/db/usercontent_update.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
@@ -18,8 +19,9 @@ import (
 // UserContentUpdate is the builder for updating UserContent entities.
 type UserContentUpdate struct {
 	config
-	hooks    []Hook
-	mutation *UserContentMutation
+	hooks     []Hook
+	mutation  *UserContentMutation
+	modifiers []func(*sql.UpdateBuilder)
 }
 
 // Where appends a list predicates to the UserContentUpdate builder.
@@ -29,15 +31,8 @@ func (ucu *UserContentUpdate) Where(ps ...predicate.UserContent) *UserContentUpd
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (ucu *UserContentUpdate) SetUpdatedAt(i int64) *UserContentUpdate {
-	ucu.mutation.ResetUpdatedAt()
-	ucu.mutation.SetUpdatedAt(i)
-	return ucu
-}
-
-// AddUpdatedAt adds i to the "updated_at" field.
-func (ucu *UserContentUpdate) AddUpdatedAt(i int64) *UserContentUpdate {
-	ucu.mutation.AddUpdatedAt(i)
+func (ucu *UserContentUpdate) SetUpdatedAt(t time.Time) *UserContentUpdate {
+	ucu.mutation.SetUpdatedAt(t)
 	return ucu
 }
 
@@ -143,6 +138,12 @@ func (ucu *UserContentUpdate) check() error {
 	return nil
 }
 
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (ucu *UserContentUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *UserContentUpdate {
+	ucu.modifiers = append(ucu.modifiers, modifiers...)
+	return ucu
+}
+
 func (ucu *UserContentUpdate) sqlSave(ctx context.Context) (n int, err error) {
 	if err := ucu.check(); err != nil {
 		return n, err
@@ -156,10 +157,7 @@ func (ucu *UserContentUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 	}
 	if value, ok := ucu.mutation.UpdatedAt(); ok {
-		_spec.SetField(usercontent.FieldUpdatedAt, field.TypeInt64, value)
-	}
-	if value, ok := ucu.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(usercontent.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(usercontent.FieldUpdatedAt, field.TypeTime, value)
 	}
 	if value, ok := ucu.mutation.GetType(); ok {
 		_spec.SetField(usercontent.FieldType, field.TypeEnum, value)
@@ -173,6 +171,7 @@ func (ucu *UserContentUpdate) sqlSave(ctx context.Context) (n int, err error) {
 	if value, ok := ucu.mutation.Metadata(); ok {
 		_spec.SetField(usercontent.FieldMetadata, field.TypeJSON, value)
 	}
+	_spec.AddModifiers(ucu.modifiers...)
 	if n, err = sqlgraph.UpdateNodes(ctx, ucu.driver, _spec); err != nil {
 		if _, ok := err.(*sqlgraph.NotFoundError); ok {
 			err = &NotFoundError{usercontent.Label}
@@ -188,21 +187,15 @@ func (ucu *UserContentUpdate) sqlSave(ctx context.Context) (n int, err error) {
 // UserContentUpdateOne is the builder for updating a single UserContent entity.
 type UserContentUpdateOne struct {
 	config
-	fields   []string
-	hooks    []Hook
-	mutation *UserContentMutation
+	fields    []string
+	hooks     []Hook
+	mutation  *UserContentMutation
+	modifiers []func(*sql.UpdateBuilder)
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (ucuo *UserContentUpdateOne) SetUpdatedAt(i int64) *UserContentUpdateOne {
-	ucuo.mutation.ResetUpdatedAt()
-	ucuo.mutation.SetUpdatedAt(i)
-	return ucuo
-}
-
-// AddUpdatedAt adds i to the "updated_at" field.
-func (ucuo *UserContentUpdateOne) AddUpdatedAt(i int64) *UserContentUpdateOne {
-	ucuo.mutation.AddUpdatedAt(i)
+func (ucuo *UserContentUpdateOne) SetUpdatedAt(t time.Time) *UserContentUpdateOne {
+	ucuo.mutation.SetUpdatedAt(t)
 	return ucuo
 }
 
@@ -321,6 +314,12 @@ func (ucuo *UserContentUpdateOne) check() error {
 	return nil
 }
 
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (ucuo *UserContentUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *UserContentUpdateOne {
+	ucuo.modifiers = append(ucuo.modifiers, modifiers...)
+	return ucuo
+}
+
 func (ucuo *UserContentUpdateOne) sqlSave(ctx context.Context) (_node *UserContent, err error) {
 	if err := ucuo.check(); err != nil {
 		return _node, err
@@ -351,10 +350,7 @@ func (ucuo *UserContentUpdateOne) sqlSave(ctx context.Context) (_node *UserConte
 		}
 	}
 	if value, ok := ucuo.mutation.UpdatedAt(); ok {
-		_spec.SetField(usercontent.FieldUpdatedAt, field.TypeInt64, value)
-	}
-	if value, ok := ucuo.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(usercontent.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(usercontent.FieldUpdatedAt, field.TypeTime, value)
 	}
 	if value, ok := ucuo.mutation.GetType(); ok {
 		_spec.SetField(usercontent.FieldType, field.TypeEnum, value)
@@ -368,6 +364,7 @@ func (ucuo *UserContentUpdateOne) sqlSave(ctx context.Context) (_node *UserConte
 	if value, ok := ucuo.mutation.Metadata(); ok {
 		_spec.SetField(usercontent.FieldMetadata, field.TypeJSON, value)
 	}
+	_spec.AddModifiers(ucuo.modifiers...)
 	_node = &UserContent{config: ucuo.config}
 	_spec.Assign = _node.assignValues
 	_spec.ScanValues = _node.scanValues
diff --git a/internal/database/ent/db/usersubscription.go b/internal/database/ent/db/usersubscription.go
index 11cdb283..945701a8 100644
--- a/internal/database/ent/db/usersubscription.go
+++ b/internal/database/ent/db/usersubscription.go
@@ -5,6 +5,7 @@ package db
 import (
 	"fmt"
 	"strings"
+	"time"
 
 	"entgo.io/ent"
 	"entgo.io/ent/dialect/sql"
@@ -19,13 +20,13 @@ type UserSubscription struct {
 	// ID of the ent.
 	ID string `json:"id,omitempty"`
 	// CreatedAt holds the value of the "created_at" field.
-	CreatedAt int64 `json:"created_at,omitempty"`
+	CreatedAt time.Time `json:"created_at,omitempty"`
 	// UpdatedAt holds the value of the "updated_at" field.
-	UpdatedAt int64 `json:"updated_at,omitempty"`
+	UpdatedAt time.Time `json:"updated_at,omitempty"`
 	// Type holds the value of the "type" field.
 	Type models.SubscriptionType `json:"type,omitempty"`
 	// ExpiresAt holds the value of the "expires_at" field.
-	ExpiresAt int64 `json:"expires_at,omitempty"`
+	ExpiresAt time.Time `json:"expires_at,omitempty"`
 	// UserID holds the value of the "user_id" field.
 	UserID string `json:"user_id,omitempty"`
 	// Permissions holds the value of the "permissions" field.
@@ -63,10 +64,10 @@ func (*UserSubscription) scanValues(columns []string) ([]any, error) {
 	values := make([]any, len(columns))
 	for i := range columns {
 		switch columns[i] {
-		case usersubscription.FieldCreatedAt, usersubscription.FieldUpdatedAt, usersubscription.FieldExpiresAt:
-			values[i] = new(sql.NullInt64)
 		case usersubscription.FieldID, usersubscription.FieldType, usersubscription.FieldUserID, usersubscription.FieldPermissions, usersubscription.FieldReferenceID:
 			values[i] = new(sql.NullString)
+		case usersubscription.FieldCreatedAt, usersubscription.FieldUpdatedAt, usersubscription.FieldExpiresAt:
+			values[i] = new(sql.NullTime)
 		default:
 			values[i] = new(sql.UnknownType)
 		}
@@ -89,16 +90,16 @@ func (us *UserSubscription) assignValues(columns []string, values []any) error {
 				us.ID = value.String
 			}
 		case usersubscription.FieldCreatedAt:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field created_at", values[i])
 			} else if value.Valid {
-				us.CreatedAt = value.Int64
+				us.CreatedAt = value.Time
 			}
 		case usersubscription.FieldUpdatedAt:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
 			} else if value.Valid {
-				us.UpdatedAt = value.Int64
+				us.UpdatedAt = value.Time
 			}
 		case usersubscription.FieldType:
 			if value, ok := values[i].(*sql.NullString); !ok {
@@ -107,10 +108,10 @@ func (us *UserSubscription) assignValues(columns []string, values []any) error {
 				us.Type = models.SubscriptionType(value.String)
 			}
 		case usersubscription.FieldExpiresAt:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field expires_at", values[i])
 			} else if value.Valid {
-				us.ExpiresAt = value.Int64
+				us.ExpiresAt = value.Time
 			}
 		case usersubscription.FieldUserID:
 			if value, ok := values[i].(*sql.NullString); !ok {
@@ -172,16 +173,16 @@ func (us *UserSubscription) String() string {
 	builder.WriteString("UserSubscription(")
 	builder.WriteString(fmt.Sprintf("id=%v, ", us.ID))
 	builder.WriteString("created_at=")
-	builder.WriteString(fmt.Sprintf("%v", us.CreatedAt))
+	builder.WriteString(us.CreatedAt.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("updated_at=")
-	builder.WriteString(fmt.Sprintf("%v", us.UpdatedAt))
+	builder.WriteString(us.UpdatedAt.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("type=")
 	builder.WriteString(fmt.Sprintf("%v", us.Type))
 	builder.WriteString(", ")
 	builder.WriteString("expires_at=")
-	builder.WriteString(fmt.Sprintf("%v", us.ExpiresAt))
+	builder.WriteString(us.ExpiresAt.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("user_id=")
 	builder.WriteString(us.UserID)
diff --git a/internal/database/ent/db/usersubscription/usersubscription.go b/internal/database/ent/db/usersubscription/usersubscription.go
index 5a34f32b..7bdea462 100644
--- a/internal/database/ent/db/usersubscription/usersubscription.go
+++ b/internal/database/ent/db/usersubscription/usersubscription.go
@@ -4,6 +4,7 @@ package usersubscription
 
 import (
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
@@ -66,11 +67,11 @@ func ValidColumn(column string) bool {
 
 var (
 	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
-	DefaultCreatedAt func() int64
+	DefaultCreatedAt func() time.Time
 	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
-	DefaultUpdatedAt func() int64
+	DefaultUpdatedAt func() time.Time
 	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
-	UpdateDefaultUpdatedAt func() int64
+	UpdateDefaultUpdatedAt func() time.Time
 	// UserIDValidator is a validator for the "user_id" field. It is called by the builders before save.
 	UserIDValidator func(string) error
 	// PermissionsValidator is a validator for the "permissions" field. It is called by the builders before save.
diff --git a/internal/database/ent/db/usersubscription/where.go b/internal/database/ent/db/usersubscription/where.go
index 9111e4f8..7dbc9b0b 100644
--- a/internal/database/ent/db/usersubscription/where.go
+++ b/internal/database/ent/db/usersubscription/where.go
@@ -3,6 +3,8 @@
 package usersubscription
 
 import (
+	"time"
+
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
@@ -65,17 +67,17 @@ func IDContainsFold(id string) predicate.UserSubscription {
 }
 
 // CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
-func CreatedAt(v int64) predicate.UserSubscription {
+func CreatedAt(v time.Time) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
-func UpdatedAt(v int64) predicate.UserSubscription {
+func UpdatedAt(v time.Time) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // ExpiresAt applies equality check predicate on the "expires_at" field. It's identical to ExpiresAtEQ.
-func ExpiresAt(v int64) predicate.UserSubscription {
+func ExpiresAt(v time.Time) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldEQ(FieldExpiresAt, v))
 }
 
@@ -95,82 +97,82 @@ func ReferenceID(v string) predicate.UserSubscription {
 }
 
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v int64) predicate.UserSubscription {
+func CreatedAtEQ(v time.Time) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v int64) predicate.UserSubscription {
+func CreatedAtNEQ(v time.Time) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldNEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...int64) predicate.UserSubscription {
+func CreatedAtIn(vs ...time.Time) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...int64) predicate.UserSubscription {
+func CreatedAtNotIn(vs ...time.Time) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldNotIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v int64) predicate.UserSubscription {
+func CreatedAtGT(v time.Time) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldGT(FieldCreatedAt, v))
 }
 
 // CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v int64) predicate.UserSubscription {
+func CreatedAtGTE(v time.Time) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldGTE(FieldCreatedAt, v))
 }
 
 // CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v int64) predicate.UserSubscription {
+func CreatedAtLT(v time.Time) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldLT(FieldCreatedAt, v))
 }
 
 // CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v int64) predicate.UserSubscription {
+func CreatedAtLTE(v time.Time) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldLTE(FieldCreatedAt, v))
 }
 
 // UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
-func UpdatedAtEQ(v int64) predicate.UserSubscription {
+func UpdatedAtEQ(v time.Time) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
-func UpdatedAtNEQ(v int64) predicate.UserSubscription {
+func UpdatedAtNEQ(v time.Time) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldNEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtIn applies the In predicate on the "updated_at" field.
-func UpdatedAtIn(vs ...int64) predicate.UserSubscription {
+func UpdatedAtIn(vs ...time.Time) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
-func UpdatedAtNotIn(vs ...int64) predicate.UserSubscription {
+func UpdatedAtNotIn(vs ...time.Time) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldNotIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtGT applies the GT predicate on the "updated_at" field.
-func UpdatedAtGT(v int64) predicate.UserSubscription {
+func UpdatedAtGT(v time.Time) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldGT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
-func UpdatedAtGTE(v int64) predicate.UserSubscription {
+func UpdatedAtGTE(v time.Time) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldGTE(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLT applies the LT predicate on the "updated_at" field.
-func UpdatedAtLT(v int64) predicate.UserSubscription {
+func UpdatedAtLT(v time.Time) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldLT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
-func UpdatedAtLTE(v int64) predicate.UserSubscription {
+func UpdatedAtLTE(v time.Time) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldLTE(FieldUpdatedAt, v))
 }
 
@@ -205,42 +207,42 @@ func TypeNotIn(vs ...models.SubscriptionType) predicate.UserSubscription {
 }
 
 // ExpiresAtEQ applies the EQ predicate on the "expires_at" field.
-func ExpiresAtEQ(v int64) predicate.UserSubscription {
+func ExpiresAtEQ(v time.Time) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldEQ(FieldExpiresAt, v))
 }
 
 // ExpiresAtNEQ applies the NEQ predicate on the "expires_at" field.
-func ExpiresAtNEQ(v int64) predicate.UserSubscription {
+func ExpiresAtNEQ(v time.Time) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldNEQ(FieldExpiresAt, v))
 }
 
 // ExpiresAtIn applies the In predicate on the "expires_at" field.
-func ExpiresAtIn(vs ...int64) predicate.UserSubscription {
+func ExpiresAtIn(vs ...time.Time) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldIn(FieldExpiresAt, vs...))
 }
 
 // ExpiresAtNotIn applies the NotIn predicate on the "expires_at" field.
-func ExpiresAtNotIn(vs ...int64) predicate.UserSubscription {
+func ExpiresAtNotIn(vs ...time.Time) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldNotIn(FieldExpiresAt, vs...))
 }
 
 // ExpiresAtGT applies the GT predicate on the "expires_at" field.
-func ExpiresAtGT(v int64) predicate.UserSubscription {
+func ExpiresAtGT(v time.Time) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldGT(FieldExpiresAt, v))
 }
 
 // ExpiresAtGTE applies the GTE predicate on the "expires_at" field.
-func ExpiresAtGTE(v int64) predicate.UserSubscription {
+func ExpiresAtGTE(v time.Time) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldGTE(FieldExpiresAt, v))
 }
 
 // ExpiresAtLT applies the LT predicate on the "expires_at" field.
-func ExpiresAtLT(v int64) predicate.UserSubscription {
+func ExpiresAtLT(v time.Time) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldLT(FieldExpiresAt, v))
 }
 
 // ExpiresAtLTE applies the LTE predicate on the "expires_at" field.
-func ExpiresAtLTE(v int64) predicate.UserSubscription {
+func ExpiresAtLTE(v time.Time) predicate.UserSubscription {
 	return predicate.UserSubscription(sql.FieldLTE(FieldExpiresAt, v))
 }
 
diff --git a/internal/database/ent/db/usersubscription_create.go b/internal/database/ent/db/usersubscription_create.go
index 64971258..28c8bebf 100644
--- a/internal/database/ent/db/usersubscription_create.go
+++ b/internal/database/ent/db/usersubscription_create.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"entgo.io/ent/schema/field"
@@ -22,29 +23,29 @@ type UserSubscriptionCreate struct {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (usc *UserSubscriptionCreate) SetCreatedAt(i int64) *UserSubscriptionCreate {
-	usc.mutation.SetCreatedAt(i)
+func (usc *UserSubscriptionCreate) SetCreatedAt(t time.Time) *UserSubscriptionCreate {
+	usc.mutation.SetCreatedAt(t)
 	return usc
 }
 
 // SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
-func (usc *UserSubscriptionCreate) SetNillableCreatedAt(i *int64) *UserSubscriptionCreate {
-	if i != nil {
-		usc.SetCreatedAt(*i)
+func (usc *UserSubscriptionCreate) SetNillableCreatedAt(t *time.Time) *UserSubscriptionCreate {
+	if t != nil {
+		usc.SetCreatedAt(*t)
 	}
 	return usc
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (usc *UserSubscriptionCreate) SetUpdatedAt(i int64) *UserSubscriptionCreate {
-	usc.mutation.SetUpdatedAt(i)
+func (usc *UserSubscriptionCreate) SetUpdatedAt(t time.Time) *UserSubscriptionCreate {
+	usc.mutation.SetUpdatedAt(t)
 	return usc
 }
 
 // SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
-func (usc *UserSubscriptionCreate) SetNillableUpdatedAt(i *int64) *UserSubscriptionCreate {
-	if i != nil {
-		usc.SetUpdatedAt(*i)
+func (usc *UserSubscriptionCreate) SetNillableUpdatedAt(t *time.Time) *UserSubscriptionCreate {
+	if t != nil {
+		usc.SetUpdatedAt(*t)
 	}
 	return usc
 }
@@ -56,8 +57,8 @@ func (usc *UserSubscriptionCreate) SetType(mt models.SubscriptionType) *UserSubs
 }
 
 // SetExpiresAt sets the "expires_at" field.
-func (usc *UserSubscriptionCreate) SetExpiresAt(i int64) *UserSubscriptionCreate {
-	usc.mutation.SetExpiresAt(i)
+func (usc *UserSubscriptionCreate) SetExpiresAt(t time.Time) *UserSubscriptionCreate {
+	usc.mutation.SetExpiresAt(t)
 	return usc
 }
 
@@ -229,11 +230,11 @@ func (usc *UserSubscriptionCreate) createSpec() (*UserSubscription, *sqlgraph.Cr
 		_spec.ID.Value = id
 	}
 	if value, ok := usc.mutation.CreatedAt(); ok {
-		_spec.SetField(usersubscription.FieldCreatedAt, field.TypeInt64, value)
+		_spec.SetField(usersubscription.FieldCreatedAt, field.TypeTime, value)
 		_node.CreatedAt = value
 	}
 	if value, ok := usc.mutation.UpdatedAt(); ok {
-		_spec.SetField(usersubscription.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(usersubscription.FieldUpdatedAt, field.TypeTime, value)
 		_node.UpdatedAt = value
 	}
 	if value, ok := usc.mutation.GetType(); ok {
@@ -241,7 +242,7 @@ func (usc *UserSubscriptionCreate) createSpec() (*UserSubscription, *sqlgraph.Cr
 		_node.Type = value
 	}
 	if value, ok := usc.mutation.ExpiresAt(); ok {
-		_spec.SetField(usersubscription.FieldExpiresAt, field.TypeInt64, value)
+		_spec.SetField(usersubscription.FieldExpiresAt, field.TypeTime, value)
 		_node.ExpiresAt = value
 	}
 	if value, ok := usc.mutation.Permissions(); ok {
diff --git a/internal/database/ent/db/usersubscription_query.go b/internal/database/ent/db/usersubscription_query.go
index 25027d45..8e30a79f 100644
--- a/internal/database/ent/db/usersubscription_query.go
+++ b/internal/database/ent/db/usersubscription_query.go
@@ -23,6 +23,7 @@ type UserSubscriptionQuery struct {
 	inters     []Interceptor
 	predicates []predicate.UserSubscription
 	withUser   *UserQuery
+	modifiers  []func(*sql.Selector)
 	// intermediate query (i.e. traversal path).
 	sql  *sql.Selector
 	path func(context.Context) (*sql.Selector, error)
@@ -297,7 +298,7 @@ func (usq *UserSubscriptionQuery) WithUser(opts ...func(*UserQuery)) *UserSubscr
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int64 `json:"created_at,omitempty"`
+//		CreatedAt time.Time `json:"created_at,omitempty"`
 //		Count int `json:"count,omitempty"`
 //	}
 //
@@ -320,7 +321,7 @@ func (usq *UserSubscriptionQuery) GroupBy(field string, fields ...string) *UserS
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int64 `json:"created_at,omitempty"`
+//		CreatedAt time.Time `json:"created_at,omitempty"`
 //	}
 //
 //	client.UserSubscription.Query().
@@ -382,6 +383,9 @@ func (usq *UserSubscriptionQuery) sqlAll(ctx context.Context, hooks ...queryHook
 		node.Edges.loadedTypes = loadedTypes
 		return node.assignValues(columns, values)
 	}
+	if len(usq.modifiers) > 0 {
+		_spec.Modifiers = usq.modifiers
+	}
 	for i := range hooks {
 		hooks[i](ctx, _spec)
 	}
@@ -432,6 +436,9 @@ func (usq *UserSubscriptionQuery) loadUser(ctx context.Context, query *UserQuery
 
 func (usq *UserSubscriptionQuery) sqlCount(ctx context.Context) (int, error) {
 	_spec := usq.querySpec()
+	if len(usq.modifiers) > 0 {
+		_spec.Modifiers = usq.modifiers
+	}
 	_spec.Node.Columns = usq.ctx.Fields
 	if len(usq.ctx.Fields) > 0 {
 		_spec.Unique = usq.ctx.Unique != nil && *usq.ctx.Unique
@@ -497,6 +504,9 @@ func (usq *UserSubscriptionQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	if usq.ctx.Unique != nil && *usq.ctx.Unique {
 		selector.Distinct()
 	}
+	for _, m := range usq.modifiers {
+		m(selector)
+	}
 	for _, p := range usq.predicates {
 		p(selector)
 	}
@@ -514,6 +524,12 @@ func (usq *UserSubscriptionQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	return selector
 }
 
+// Modify adds a query modifier for attaching custom logic to queries.
+func (usq *UserSubscriptionQuery) Modify(modifiers ...func(s *sql.Selector)) *UserSubscriptionSelect {
+	usq.modifiers = append(usq.modifiers, modifiers...)
+	return usq.Select()
+}
+
 // UserSubscriptionGroupBy is the group-by builder for UserSubscription entities.
 type UserSubscriptionGroupBy struct {
 	selector
@@ -603,3 +619,9 @@ func (uss *UserSubscriptionSelect) sqlScan(ctx context.Context, root *UserSubscr
 	defer rows.Close()
 	return sql.ScanSlice(rows, v)
 }
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (uss *UserSubscriptionSelect) Modify(modifiers ...func(s *sql.Selector)) *UserSubscriptionSelect {
+	uss.modifiers = append(uss.modifiers, modifiers...)
+	return uss
+}
diff --git a/internal/database/ent/db/usersubscription_update.go b/internal/database/ent/db/usersubscription_update.go
index b2806f54..256a1fe3 100644
--- a/internal/database/ent/db/usersubscription_update.go
+++ b/internal/database/ent/db/usersubscription_update.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
@@ -18,8 +19,9 @@ import (
 // UserSubscriptionUpdate is the builder for updating UserSubscription entities.
 type UserSubscriptionUpdate struct {
 	config
-	hooks    []Hook
-	mutation *UserSubscriptionMutation
+	hooks     []Hook
+	mutation  *UserSubscriptionMutation
+	modifiers []func(*sql.UpdateBuilder)
 }
 
 // Where appends a list predicates to the UserSubscriptionUpdate builder.
@@ -29,15 +31,8 @@ func (usu *UserSubscriptionUpdate) Where(ps ...predicate.UserSubscription) *User
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (usu *UserSubscriptionUpdate) SetUpdatedAt(i int64) *UserSubscriptionUpdate {
-	usu.mutation.ResetUpdatedAt()
-	usu.mutation.SetUpdatedAt(i)
-	return usu
-}
-
-// AddUpdatedAt adds i to the "updated_at" field.
-func (usu *UserSubscriptionUpdate) AddUpdatedAt(i int64) *UserSubscriptionUpdate {
-	usu.mutation.AddUpdatedAt(i)
+func (usu *UserSubscriptionUpdate) SetUpdatedAt(t time.Time) *UserSubscriptionUpdate {
+	usu.mutation.SetUpdatedAt(t)
 	return usu
 }
 
@@ -56,26 +51,19 @@ func (usu *UserSubscriptionUpdate) SetNillableType(mt *models.SubscriptionType)
 }
 
 // SetExpiresAt sets the "expires_at" field.
-func (usu *UserSubscriptionUpdate) SetExpiresAt(i int64) *UserSubscriptionUpdate {
-	usu.mutation.ResetExpiresAt()
-	usu.mutation.SetExpiresAt(i)
+func (usu *UserSubscriptionUpdate) SetExpiresAt(t time.Time) *UserSubscriptionUpdate {
+	usu.mutation.SetExpiresAt(t)
 	return usu
 }
 
 // SetNillableExpiresAt sets the "expires_at" field if the given value is not nil.
-func (usu *UserSubscriptionUpdate) SetNillableExpiresAt(i *int64) *UserSubscriptionUpdate {
-	if i != nil {
-		usu.SetExpiresAt(*i)
+func (usu *UserSubscriptionUpdate) SetNillableExpiresAt(t *time.Time) *UserSubscriptionUpdate {
+	if t != nil {
+		usu.SetExpiresAt(*t)
 	}
 	return usu
 }
 
-// AddExpiresAt adds i to the "expires_at" field.
-func (usu *UserSubscriptionUpdate) AddExpiresAt(i int64) *UserSubscriptionUpdate {
-	usu.mutation.AddExpiresAt(i)
-	return usu
-}
-
 // SetPermissions sets the "permissions" field.
 func (usu *UserSubscriptionUpdate) SetPermissions(s string) *UserSubscriptionUpdate {
 	usu.mutation.SetPermissions(s)
@@ -168,6 +156,12 @@ func (usu *UserSubscriptionUpdate) check() error {
 	return nil
 }
 
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (usu *UserSubscriptionUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *UserSubscriptionUpdate {
+	usu.modifiers = append(usu.modifiers, modifiers...)
+	return usu
+}
+
 func (usu *UserSubscriptionUpdate) sqlSave(ctx context.Context) (n int, err error) {
 	if err := usu.check(); err != nil {
 		return n, err
@@ -181,19 +175,13 @@ func (usu *UserSubscriptionUpdate) sqlSave(ctx context.Context) (n int, err erro
 		}
 	}
 	if value, ok := usu.mutation.UpdatedAt(); ok {
-		_spec.SetField(usersubscription.FieldUpdatedAt, field.TypeInt64, value)
-	}
-	if value, ok := usu.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(usersubscription.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(usersubscription.FieldUpdatedAt, field.TypeTime, value)
 	}
 	if value, ok := usu.mutation.GetType(); ok {
 		_spec.SetField(usersubscription.FieldType, field.TypeEnum, value)
 	}
 	if value, ok := usu.mutation.ExpiresAt(); ok {
-		_spec.SetField(usersubscription.FieldExpiresAt, field.TypeInt64, value)
-	}
-	if value, ok := usu.mutation.AddedExpiresAt(); ok {
-		_spec.AddField(usersubscription.FieldExpiresAt, field.TypeInt64, value)
+		_spec.SetField(usersubscription.FieldExpiresAt, field.TypeTime, value)
 	}
 	if value, ok := usu.mutation.Permissions(); ok {
 		_spec.SetField(usersubscription.FieldPermissions, field.TypeString, value)
@@ -201,6 +189,7 @@ func (usu *UserSubscriptionUpdate) sqlSave(ctx context.Context) (n int, err erro
 	if value, ok := usu.mutation.ReferenceID(); ok {
 		_spec.SetField(usersubscription.FieldReferenceID, field.TypeString, value)
 	}
+	_spec.AddModifiers(usu.modifiers...)
 	if n, err = sqlgraph.UpdateNodes(ctx, usu.driver, _spec); err != nil {
 		if _, ok := err.(*sqlgraph.NotFoundError); ok {
 			err = &NotFoundError{usersubscription.Label}
@@ -216,21 +205,15 @@ func (usu *UserSubscriptionUpdate) sqlSave(ctx context.Context) (n int, err erro
 // UserSubscriptionUpdateOne is the builder for updating a single UserSubscription entity.
 type UserSubscriptionUpdateOne struct {
 	config
-	fields   []string
-	hooks    []Hook
-	mutation *UserSubscriptionMutation
+	fields    []string
+	hooks     []Hook
+	mutation  *UserSubscriptionMutation
+	modifiers []func(*sql.UpdateBuilder)
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (usuo *UserSubscriptionUpdateOne) SetUpdatedAt(i int64) *UserSubscriptionUpdateOne {
-	usuo.mutation.ResetUpdatedAt()
-	usuo.mutation.SetUpdatedAt(i)
-	return usuo
-}
-
-// AddUpdatedAt adds i to the "updated_at" field.
-func (usuo *UserSubscriptionUpdateOne) AddUpdatedAt(i int64) *UserSubscriptionUpdateOne {
-	usuo.mutation.AddUpdatedAt(i)
+func (usuo *UserSubscriptionUpdateOne) SetUpdatedAt(t time.Time) *UserSubscriptionUpdateOne {
+	usuo.mutation.SetUpdatedAt(t)
 	return usuo
 }
 
@@ -249,26 +232,19 @@ func (usuo *UserSubscriptionUpdateOne) SetNillableType(mt *models.SubscriptionTy
 }
 
 // SetExpiresAt sets the "expires_at" field.
-func (usuo *UserSubscriptionUpdateOne) SetExpiresAt(i int64) *UserSubscriptionUpdateOne {
-	usuo.mutation.ResetExpiresAt()
-	usuo.mutation.SetExpiresAt(i)
+func (usuo *UserSubscriptionUpdateOne) SetExpiresAt(t time.Time) *UserSubscriptionUpdateOne {
+	usuo.mutation.SetExpiresAt(t)
 	return usuo
 }
 
 // SetNillableExpiresAt sets the "expires_at" field if the given value is not nil.
-func (usuo *UserSubscriptionUpdateOne) SetNillableExpiresAt(i *int64) *UserSubscriptionUpdateOne {
-	if i != nil {
-		usuo.SetExpiresAt(*i)
+func (usuo *UserSubscriptionUpdateOne) SetNillableExpiresAt(t *time.Time) *UserSubscriptionUpdateOne {
+	if t != nil {
+		usuo.SetExpiresAt(*t)
 	}
 	return usuo
 }
 
-// AddExpiresAt adds i to the "expires_at" field.
-func (usuo *UserSubscriptionUpdateOne) AddExpiresAt(i int64) *UserSubscriptionUpdateOne {
-	usuo.mutation.AddExpiresAt(i)
-	return usuo
-}
-
 // SetPermissions sets the "permissions" field.
 func (usuo *UserSubscriptionUpdateOne) SetPermissions(s string) *UserSubscriptionUpdateOne {
 	usuo.mutation.SetPermissions(s)
@@ -374,6 +350,12 @@ func (usuo *UserSubscriptionUpdateOne) check() error {
 	return nil
 }
 
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (usuo *UserSubscriptionUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *UserSubscriptionUpdateOne {
+	usuo.modifiers = append(usuo.modifiers, modifiers...)
+	return usuo
+}
+
 func (usuo *UserSubscriptionUpdateOne) sqlSave(ctx context.Context) (_node *UserSubscription, err error) {
 	if err := usuo.check(); err != nil {
 		return _node, err
@@ -404,19 +386,13 @@ func (usuo *UserSubscriptionUpdateOne) sqlSave(ctx context.Context) (_node *User
 		}
 	}
 	if value, ok := usuo.mutation.UpdatedAt(); ok {
-		_spec.SetField(usersubscription.FieldUpdatedAt, field.TypeInt64, value)
-	}
-	if value, ok := usuo.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(usersubscription.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(usersubscription.FieldUpdatedAt, field.TypeTime, value)
 	}
 	if value, ok := usuo.mutation.GetType(); ok {
 		_spec.SetField(usersubscription.FieldType, field.TypeEnum, value)
 	}
 	if value, ok := usuo.mutation.ExpiresAt(); ok {
-		_spec.SetField(usersubscription.FieldExpiresAt, field.TypeInt64, value)
-	}
-	if value, ok := usuo.mutation.AddedExpiresAt(); ok {
-		_spec.AddField(usersubscription.FieldExpiresAt, field.TypeInt64, value)
+		_spec.SetField(usersubscription.FieldExpiresAt, field.TypeTime, value)
 	}
 	if value, ok := usuo.mutation.Permissions(); ok {
 		_spec.SetField(usersubscription.FieldPermissions, field.TypeString, value)
@@ -424,6 +400,7 @@ func (usuo *UserSubscriptionUpdateOne) sqlSave(ctx context.Context) (_node *User
 	if value, ok := usuo.mutation.ReferenceID(); ok {
 		_spec.SetField(usersubscription.FieldReferenceID, field.TypeString, value)
 	}
+	_spec.AddModifiers(usuo.modifiers...)
 	_node = &UserSubscription{config: usuo.config}
 	_spec.Assign = _node.assignValues
 	_spec.ScanValues = _node.scanValues
diff --git a/internal/database/ent/db/vehicle.go b/internal/database/ent/db/vehicle.go
index 639c60e9..78a302ba 100644
--- a/internal/database/ent/db/vehicle.go
+++ b/internal/database/ent/db/vehicle.go
@@ -6,6 +6,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"strings"
+	"time"
 
 	"entgo.io/ent"
 	"entgo.io/ent/dialect/sql"
@@ -18,9 +19,9 @@ type Vehicle struct {
 	// ID of the ent.
 	ID string `json:"id,omitempty"`
 	// CreatedAt holds the value of the "created_at" field.
-	CreatedAt int64 `json:"created_at,omitempty"`
+	CreatedAt time.Time `json:"created_at,omitempty"`
 	// UpdatedAt holds the value of the "updated_at" field.
-	UpdatedAt int64 `json:"updated_at,omitempty"`
+	UpdatedAt time.Time `json:"updated_at,omitempty"`
 	// Tier holds the value of the "tier" field.
 	Tier int `json:"tier,omitempty"`
 	// LocalizedNames holds the value of the "localized_names" field.
@@ -35,10 +36,12 @@ func (*Vehicle) scanValues(columns []string) ([]any, error) {
 		switch columns[i] {
 		case vehicle.FieldLocalizedNames:
 			values[i] = new([]byte)
-		case vehicle.FieldCreatedAt, vehicle.FieldUpdatedAt, vehicle.FieldTier:
+		case vehicle.FieldTier:
 			values[i] = new(sql.NullInt64)
 		case vehicle.FieldID:
 			values[i] = new(sql.NullString)
+		case vehicle.FieldCreatedAt, vehicle.FieldUpdatedAt:
+			values[i] = new(sql.NullTime)
 		default:
 			values[i] = new(sql.UnknownType)
 		}
@@ -61,16 +64,16 @@ func (v *Vehicle) assignValues(columns []string, values []any) error {
 				v.ID = value.String
 			}
 		case vehicle.FieldCreatedAt:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field created_at", values[i])
 			} else if value.Valid {
-				v.CreatedAt = value.Int64
+				v.CreatedAt = value.Time
 			}
 		case vehicle.FieldUpdatedAt:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
 			} else if value.Valid {
-				v.UpdatedAt = value.Int64
+				v.UpdatedAt = value.Time
 			}
 		case vehicle.FieldTier:
 			if value, ok := values[i].(*sql.NullInt64); !ok {
@@ -123,10 +126,10 @@ func (v *Vehicle) String() string {
 	builder.WriteString("Vehicle(")
 	builder.WriteString(fmt.Sprintf("id=%v, ", v.ID))
 	builder.WriteString("created_at=")
-	builder.WriteString(fmt.Sprintf("%v", v.CreatedAt))
+	builder.WriteString(v.CreatedAt.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("updated_at=")
-	builder.WriteString(fmt.Sprintf("%v", v.UpdatedAt))
+	builder.WriteString(v.UpdatedAt.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("tier=")
 	builder.WriteString(fmt.Sprintf("%v", v.Tier))
diff --git a/internal/database/ent/db/vehicle/vehicle.go b/internal/database/ent/db/vehicle/vehicle.go
index 5e417ea2..f29f3a64 100644
--- a/internal/database/ent/db/vehicle/vehicle.go
+++ b/internal/database/ent/db/vehicle/vehicle.go
@@ -3,6 +3,8 @@
 package vehicle
 
 import (
+	"time"
+
 	"entgo.io/ent/dialect/sql"
 )
 
@@ -44,11 +46,11 @@ func ValidColumn(column string) bool {
 
 var (
 	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
-	DefaultCreatedAt func() int64
+	DefaultCreatedAt func() time.Time
 	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
-	DefaultUpdatedAt func() int64
+	DefaultUpdatedAt func() time.Time
 	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
-	UpdateDefaultUpdatedAt func() int64
+	UpdateDefaultUpdatedAt func() time.Time
 	// TierValidator is a validator for the "tier" field. It is called by the builders before save.
 	TierValidator func(int) error
 )
diff --git a/internal/database/ent/db/vehicle/where.go b/internal/database/ent/db/vehicle/where.go
index 5bf6a6dc..b0f84e66 100644
--- a/internal/database/ent/db/vehicle/where.go
+++ b/internal/database/ent/db/vehicle/where.go
@@ -3,6 +3,8 @@
 package vehicle
 
 import (
+	"time"
+
 	"entgo.io/ent/dialect/sql"
 	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
 )
@@ -63,12 +65,12 @@ func IDContainsFold(id string) predicate.Vehicle {
 }
 
 // CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
-func CreatedAt(v int64) predicate.Vehicle {
+func CreatedAt(v time.Time) predicate.Vehicle {
 	return predicate.Vehicle(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
-func UpdatedAt(v int64) predicate.Vehicle {
+func UpdatedAt(v time.Time) predicate.Vehicle {
 	return predicate.Vehicle(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
@@ -78,82 +80,82 @@ func Tier(v int) predicate.Vehicle {
 }
 
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v int64) predicate.Vehicle {
+func CreatedAtEQ(v time.Time) predicate.Vehicle {
 	return predicate.Vehicle(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v int64) predicate.Vehicle {
+func CreatedAtNEQ(v time.Time) predicate.Vehicle {
 	return predicate.Vehicle(sql.FieldNEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...int64) predicate.Vehicle {
+func CreatedAtIn(vs ...time.Time) predicate.Vehicle {
 	return predicate.Vehicle(sql.FieldIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...int64) predicate.Vehicle {
+func CreatedAtNotIn(vs ...time.Time) predicate.Vehicle {
 	return predicate.Vehicle(sql.FieldNotIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v int64) predicate.Vehicle {
+func CreatedAtGT(v time.Time) predicate.Vehicle {
 	return predicate.Vehicle(sql.FieldGT(FieldCreatedAt, v))
 }
 
 // CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v int64) predicate.Vehicle {
+func CreatedAtGTE(v time.Time) predicate.Vehicle {
 	return predicate.Vehicle(sql.FieldGTE(FieldCreatedAt, v))
 }
 
 // CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v int64) predicate.Vehicle {
+func CreatedAtLT(v time.Time) predicate.Vehicle {
 	return predicate.Vehicle(sql.FieldLT(FieldCreatedAt, v))
 }
 
 // CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v int64) predicate.Vehicle {
+func CreatedAtLTE(v time.Time) predicate.Vehicle {
 	return predicate.Vehicle(sql.FieldLTE(FieldCreatedAt, v))
 }
 
 // UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
-func UpdatedAtEQ(v int64) predicate.Vehicle {
+func UpdatedAtEQ(v time.Time) predicate.Vehicle {
 	return predicate.Vehicle(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
-func UpdatedAtNEQ(v int64) predicate.Vehicle {
+func UpdatedAtNEQ(v time.Time) predicate.Vehicle {
 	return predicate.Vehicle(sql.FieldNEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtIn applies the In predicate on the "updated_at" field.
-func UpdatedAtIn(vs ...int64) predicate.Vehicle {
+func UpdatedAtIn(vs ...time.Time) predicate.Vehicle {
 	return predicate.Vehicle(sql.FieldIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
-func UpdatedAtNotIn(vs ...int64) predicate.Vehicle {
+func UpdatedAtNotIn(vs ...time.Time) predicate.Vehicle {
 	return predicate.Vehicle(sql.FieldNotIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtGT applies the GT predicate on the "updated_at" field.
-func UpdatedAtGT(v int64) predicate.Vehicle {
+func UpdatedAtGT(v time.Time) predicate.Vehicle {
 	return predicate.Vehicle(sql.FieldGT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
-func UpdatedAtGTE(v int64) predicate.Vehicle {
+func UpdatedAtGTE(v time.Time) predicate.Vehicle {
 	return predicate.Vehicle(sql.FieldGTE(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLT applies the LT predicate on the "updated_at" field.
-func UpdatedAtLT(v int64) predicate.Vehicle {
+func UpdatedAtLT(v time.Time) predicate.Vehicle {
 	return predicate.Vehicle(sql.FieldLT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
-func UpdatedAtLTE(v int64) predicate.Vehicle {
+func UpdatedAtLTE(v time.Time) predicate.Vehicle {
 	return predicate.Vehicle(sql.FieldLTE(FieldUpdatedAt, v))
 }
 
diff --git a/internal/database/ent/db/vehicle_create.go b/internal/database/ent/db/vehicle_create.go
index b94dc90c..a11e8725 100644
--- a/internal/database/ent/db/vehicle_create.go
+++ b/internal/database/ent/db/vehicle_create.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"entgo.io/ent/schema/field"
@@ -20,29 +21,29 @@ type VehicleCreate struct {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (vc *VehicleCreate) SetCreatedAt(i int64) *VehicleCreate {
-	vc.mutation.SetCreatedAt(i)
+func (vc *VehicleCreate) SetCreatedAt(t time.Time) *VehicleCreate {
+	vc.mutation.SetCreatedAt(t)
 	return vc
 }
 
 // SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
-func (vc *VehicleCreate) SetNillableCreatedAt(i *int64) *VehicleCreate {
-	if i != nil {
-		vc.SetCreatedAt(*i)
+func (vc *VehicleCreate) SetNillableCreatedAt(t *time.Time) *VehicleCreate {
+	if t != nil {
+		vc.SetCreatedAt(*t)
 	}
 	return vc
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (vc *VehicleCreate) SetUpdatedAt(i int64) *VehicleCreate {
-	vc.mutation.SetUpdatedAt(i)
+func (vc *VehicleCreate) SetUpdatedAt(t time.Time) *VehicleCreate {
+	vc.mutation.SetUpdatedAt(t)
 	return vc
 }
 
 // SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
-func (vc *VehicleCreate) SetNillableUpdatedAt(i *int64) *VehicleCreate {
-	if i != nil {
-		vc.SetUpdatedAt(*i)
+func (vc *VehicleCreate) SetNillableUpdatedAt(t *time.Time) *VehicleCreate {
+	if t != nil {
+		vc.SetUpdatedAt(*t)
 	}
 	return vc
 }
@@ -165,11 +166,11 @@ func (vc *VehicleCreate) createSpec() (*Vehicle, *sqlgraph.CreateSpec) {
 		_spec.ID.Value = id
 	}
 	if value, ok := vc.mutation.CreatedAt(); ok {
-		_spec.SetField(vehicle.FieldCreatedAt, field.TypeInt64, value)
+		_spec.SetField(vehicle.FieldCreatedAt, field.TypeTime, value)
 		_node.CreatedAt = value
 	}
 	if value, ok := vc.mutation.UpdatedAt(); ok {
-		_spec.SetField(vehicle.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(vehicle.FieldUpdatedAt, field.TypeTime, value)
 		_node.UpdatedAt = value
 	}
 	if value, ok := vc.mutation.Tier(); ok {
diff --git a/internal/database/ent/db/vehicle_query.go b/internal/database/ent/db/vehicle_query.go
index 6b09ce3b..3cc19a05 100644
--- a/internal/database/ent/db/vehicle_query.go
+++ b/internal/database/ent/db/vehicle_query.go
@@ -21,6 +21,7 @@ type VehicleQuery struct {
 	order      []vehicle.OrderOption
 	inters     []Interceptor
 	predicates []predicate.Vehicle
+	modifiers  []func(*sql.Selector)
 	// intermediate query (i.e. traversal path).
 	sql  *sql.Selector
 	path func(context.Context) (*sql.Selector, error)
@@ -261,7 +262,7 @@ func (vq *VehicleQuery) Clone() *VehicleQuery {
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int64 `json:"created_at,omitempty"`
+//		CreatedAt time.Time `json:"created_at,omitempty"`
 //		Count int `json:"count,omitempty"`
 //	}
 //
@@ -284,7 +285,7 @@ func (vq *VehicleQuery) GroupBy(field string, fields ...string) *VehicleGroupBy
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int64 `json:"created_at,omitempty"`
+//		CreatedAt time.Time `json:"created_at,omitempty"`
 //	}
 //
 //	client.Vehicle.Query().
@@ -342,6 +343,9 @@ func (vq *VehicleQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Vehi
 		nodes = append(nodes, node)
 		return node.assignValues(columns, values)
 	}
+	if len(vq.modifiers) > 0 {
+		_spec.Modifiers = vq.modifiers
+	}
 	for i := range hooks {
 		hooks[i](ctx, _spec)
 	}
@@ -356,6 +360,9 @@ func (vq *VehicleQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Vehi
 
 func (vq *VehicleQuery) sqlCount(ctx context.Context) (int, error) {
 	_spec := vq.querySpec()
+	if len(vq.modifiers) > 0 {
+		_spec.Modifiers = vq.modifiers
+	}
 	_spec.Node.Columns = vq.ctx.Fields
 	if len(vq.ctx.Fields) > 0 {
 		_spec.Unique = vq.ctx.Unique != nil && *vq.ctx.Unique
@@ -418,6 +425,9 @@ func (vq *VehicleQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	if vq.ctx.Unique != nil && *vq.ctx.Unique {
 		selector.Distinct()
 	}
+	for _, m := range vq.modifiers {
+		m(selector)
+	}
 	for _, p := range vq.predicates {
 		p(selector)
 	}
@@ -435,6 +445,12 @@ func (vq *VehicleQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	return selector
 }
 
+// Modify adds a query modifier for attaching custom logic to queries.
+func (vq *VehicleQuery) Modify(modifiers ...func(s *sql.Selector)) *VehicleSelect {
+	vq.modifiers = append(vq.modifiers, modifiers...)
+	return vq.Select()
+}
+
 // VehicleGroupBy is the group-by builder for Vehicle entities.
 type VehicleGroupBy struct {
 	selector
@@ -524,3 +540,9 @@ func (vs *VehicleSelect) sqlScan(ctx context.Context, root *VehicleQuery, v any)
 	defer rows.Close()
 	return sql.ScanSlice(rows, v)
 }
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (vs *VehicleSelect) Modify(modifiers ...func(s *sql.Selector)) *VehicleSelect {
+	vs.modifiers = append(vs.modifiers, modifiers...)
+	return vs
+}
diff --git a/internal/database/ent/db/vehicle_update.go b/internal/database/ent/db/vehicle_update.go
index f5cec932..6ef632ed 100644
--- a/internal/database/ent/db/vehicle_update.go
+++ b/internal/database/ent/db/vehicle_update.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
@@ -17,8 +18,9 @@ import (
 // VehicleUpdate is the builder for updating Vehicle entities.
 type VehicleUpdate struct {
 	config
-	hooks    []Hook
-	mutation *VehicleMutation
+	hooks     []Hook
+	mutation  *VehicleMutation
+	modifiers []func(*sql.UpdateBuilder)
 }
 
 // Where appends a list predicates to the VehicleUpdate builder.
@@ -28,15 +30,8 @@ func (vu *VehicleUpdate) Where(ps ...predicate.Vehicle) *VehicleUpdate {
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (vu *VehicleUpdate) SetUpdatedAt(i int64) *VehicleUpdate {
-	vu.mutation.ResetUpdatedAt()
-	vu.mutation.SetUpdatedAt(i)
-	return vu
-}
-
-// AddUpdatedAt adds i to the "updated_at" field.
-func (vu *VehicleUpdate) AddUpdatedAt(i int64) *VehicleUpdate {
-	vu.mutation.AddUpdatedAt(i)
+func (vu *VehicleUpdate) SetUpdatedAt(t time.Time) *VehicleUpdate {
+	vu.mutation.SetUpdatedAt(t)
 	return vu
 }
 
@@ -118,6 +113,12 @@ func (vu *VehicleUpdate) check() error {
 	return nil
 }
 
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (vu *VehicleUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *VehicleUpdate {
+	vu.modifiers = append(vu.modifiers, modifiers...)
+	return vu
+}
+
 func (vu *VehicleUpdate) sqlSave(ctx context.Context) (n int, err error) {
 	if err := vu.check(); err != nil {
 		return n, err
@@ -131,10 +132,7 @@ func (vu *VehicleUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 	}
 	if value, ok := vu.mutation.UpdatedAt(); ok {
-		_spec.SetField(vehicle.FieldUpdatedAt, field.TypeInt64, value)
-	}
-	if value, ok := vu.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(vehicle.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(vehicle.FieldUpdatedAt, field.TypeTime, value)
 	}
 	if value, ok := vu.mutation.Tier(); ok {
 		_spec.SetField(vehicle.FieldTier, field.TypeInt, value)
@@ -145,6 +143,7 @@ func (vu *VehicleUpdate) sqlSave(ctx context.Context) (n int, err error) {
 	if value, ok := vu.mutation.LocalizedNames(); ok {
 		_spec.SetField(vehicle.FieldLocalizedNames, field.TypeJSON, value)
 	}
+	_spec.AddModifiers(vu.modifiers...)
 	if n, err = sqlgraph.UpdateNodes(ctx, vu.driver, _spec); err != nil {
 		if _, ok := err.(*sqlgraph.NotFoundError); ok {
 			err = &NotFoundError{vehicle.Label}
@@ -160,21 +159,15 @@ func (vu *VehicleUpdate) sqlSave(ctx context.Context) (n int, err error) {
 // VehicleUpdateOne is the builder for updating a single Vehicle entity.
 type VehicleUpdateOne struct {
 	config
-	fields   []string
-	hooks    []Hook
-	mutation *VehicleMutation
+	fields    []string
+	hooks     []Hook
+	mutation  *VehicleMutation
+	modifiers []func(*sql.UpdateBuilder)
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (vuo *VehicleUpdateOne) SetUpdatedAt(i int64) *VehicleUpdateOne {
-	vuo.mutation.ResetUpdatedAt()
-	vuo.mutation.SetUpdatedAt(i)
-	return vuo
-}
-
-// AddUpdatedAt adds i to the "updated_at" field.
-func (vuo *VehicleUpdateOne) AddUpdatedAt(i int64) *VehicleUpdateOne {
-	vuo.mutation.AddUpdatedAt(i)
+func (vuo *VehicleUpdateOne) SetUpdatedAt(t time.Time) *VehicleUpdateOne {
+	vuo.mutation.SetUpdatedAt(t)
 	return vuo
 }
 
@@ -269,6 +262,12 @@ func (vuo *VehicleUpdateOne) check() error {
 	return nil
 }
 
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (vuo *VehicleUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *VehicleUpdateOne {
+	vuo.modifiers = append(vuo.modifiers, modifiers...)
+	return vuo
+}
+
 func (vuo *VehicleUpdateOne) sqlSave(ctx context.Context) (_node *Vehicle, err error) {
 	if err := vuo.check(); err != nil {
 		return _node, err
@@ -299,10 +298,7 @@ func (vuo *VehicleUpdateOne) sqlSave(ctx context.Context) (_node *Vehicle, err e
 		}
 	}
 	if value, ok := vuo.mutation.UpdatedAt(); ok {
-		_spec.SetField(vehicle.FieldUpdatedAt, field.TypeInt64, value)
-	}
-	if value, ok := vuo.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(vehicle.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(vehicle.FieldUpdatedAt, field.TypeTime, value)
 	}
 	if value, ok := vuo.mutation.Tier(); ok {
 		_spec.SetField(vehicle.FieldTier, field.TypeInt, value)
@@ -313,6 +309,7 @@ func (vuo *VehicleUpdateOne) sqlSave(ctx context.Context) (_node *Vehicle, err e
 	if value, ok := vuo.mutation.LocalizedNames(); ok {
 		_spec.SetField(vehicle.FieldLocalizedNames, field.TypeJSON, value)
 	}
+	_spec.AddModifiers(vuo.modifiers...)
 	_node = &Vehicle{config: vuo.config}
 	_spec.Assign = _node.assignValues
 	_spec.ScanValues = _node.scanValues
diff --git a/internal/database/ent/db/vehicleaverage.go b/internal/database/ent/db/vehicleaverage.go
index f24062ab..84c88a04 100644
--- a/internal/database/ent/db/vehicleaverage.go
+++ b/internal/database/ent/db/vehicleaverage.go
@@ -6,6 +6,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"strings"
+	"time"
 
 	"entgo.io/ent"
 	"entgo.io/ent/dialect/sql"
@@ -19,9 +20,9 @@ type VehicleAverage struct {
 	// ID of the ent.
 	ID string `json:"id,omitempty"`
 	// CreatedAt holds the value of the "created_at" field.
-	CreatedAt int64 `json:"created_at,omitempty"`
+	CreatedAt time.Time `json:"created_at,omitempty"`
 	// UpdatedAt holds the value of the "updated_at" field.
-	UpdatedAt int64 `json:"updated_at,omitempty"`
+	UpdatedAt time.Time `json:"updated_at,omitempty"`
 	// Data holds the value of the "data" field.
 	Data         frame.StatsFrame `json:"data,omitempty"`
 	selectValues sql.SelectValues
@@ -34,10 +35,10 @@ func (*VehicleAverage) scanValues(columns []string) ([]any, error) {
 		switch columns[i] {
 		case vehicleaverage.FieldData:
 			values[i] = new([]byte)
-		case vehicleaverage.FieldCreatedAt, vehicleaverage.FieldUpdatedAt:
-			values[i] = new(sql.NullInt64)
 		case vehicleaverage.FieldID:
 			values[i] = new(sql.NullString)
+		case vehicleaverage.FieldCreatedAt, vehicleaverage.FieldUpdatedAt:
+			values[i] = new(sql.NullTime)
 		default:
 			values[i] = new(sql.UnknownType)
 		}
@@ -60,16 +61,16 @@ func (va *VehicleAverage) assignValues(columns []string, values []any) error {
 				va.ID = value.String
 			}
 		case vehicleaverage.FieldCreatedAt:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field created_at", values[i])
 			} else if value.Valid {
-				va.CreatedAt = value.Int64
+				va.CreatedAt = value.Time
 			}
 		case vehicleaverage.FieldUpdatedAt:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
 			} else if value.Valid {
-				va.UpdatedAt = value.Int64
+				va.UpdatedAt = value.Time
 			}
 		case vehicleaverage.FieldData:
 			if value, ok := values[i].(*[]byte); !ok {
@@ -116,10 +117,10 @@ func (va *VehicleAverage) String() string {
 	builder.WriteString("VehicleAverage(")
 	builder.WriteString(fmt.Sprintf("id=%v, ", va.ID))
 	builder.WriteString("created_at=")
-	builder.WriteString(fmt.Sprintf("%v", va.CreatedAt))
+	builder.WriteString(va.CreatedAt.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("updated_at=")
-	builder.WriteString(fmt.Sprintf("%v", va.UpdatedAt))
+	builder.WriteString(va.UpdatedAt.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("data=")
 	builder.WriteString(fmt.Sprintf("%v", va.Data))
diff --git a/internal/database/ent/db/vehicleaverage/vehicleaverage.go b/internal/database/ent/db/vehicleaverage/vehicleaverage.go
index ab45c826..1c658ae4 100644
--- a/internal/database/ent/db/vehicleaverage/vehicleaverage.go
+++ b/internal/database/ent/db/vehicleaverage/vehicleaverage.go
@@ -3,6 +3,8 @@
 package vehicleaverage
 
 import (
+	"time"
+
 	"entgo.io/ent/dialect/sql"
 )
 
@@ -41,11 +43,11 @@ func ValidColumn(column string) bool {
 
 var (
 	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
-	DefaultCreatedAt func() int64
+	DefaultCreatedAt func() time.Time
 	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
-	DefaultUpdatedAt func() int64
+	DefaultUpdatedAt func() time.Time
 	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
-	UpdateDefaultUpdatedAt func() int64
+	UpdateDefaultUpdatedAt func() time.Time
 )
 
 // OrderOption defines the ordering options for the VehicleAverage queries.
diff --git a/internal/database/ent/db/vehicleaverage/where.go b/internal/database/ent/db/vehicleaverage/where.go
index e9f20546..5053b2dd 100644
--- a/internal/database/ent/db/vehicleaverage/where.go
+++ b/internal/database/ent/db/vehicleaverage/where.go
@@ -3,6 +3,8 @@
 package vehicleaverage
 
 import (
+	"time"
+
 	"entgo.io/ent/dialect/sql"
 	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
 )
@@ -63,92 +65,92 @@ func IDContainsFold(id string) predicate.VehicleAverage {
 }
 
 // CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
-func CreatedAt(v int64) predicate.VehicleAverage {
+func CreatedAt(v time.Time) predicate.VehicleAverage {
 	return predicate.VehicleAverage(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
-func UpdatedAt(v int64) predicate.VehicleAverage {
+func UpdatedAt(v time.Time) predicate.VehicleAverage {
 	return predicate.VehicleAverage(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v int64) predicate.VehicleAverage {
+func CreatedAtEQ(v time.Time) predicate.VehicleAverage {
 	return predicate.VehicleAverage(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v int64) predicate.VehicleAverage {
+func CreatedAtNEQ(v time.Time) predicate.VehicleAverage {
 	return predicate.VehicleAverage(sql.FieldNEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...int64) predicate.VehicleAverage {
+func CreatedAtIn(vs ...time.Time) predicate.VehicleAverage {
 	return predicate.VehicleAverage(sql.FieldIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...int64) predicate.VehicleAverage {
+func CreatedAtNotIn(vs ...time.Time) predicate.VehicleAverage {
 	return predicate.VehicleAverage(sql.FieldNotIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v int64) predicate.VehicleAverage {
+func CreatedAtGT(v time.Time) predicate.VehicleAverage {
 	return predicate.VehicleAverage(sql.FieldGT(FieldCreatedAt, v))
 }
 
 // CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v int64) predicate.VehicleAverage {
+func CreatedAtGTE(v time.Time) predicate.VehicleAverage {
 	return predicate.VehicleAverage(sql.FieldGTE(FieldCreatedAt, v))
 }
 
 // CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v int64) predicate.VehicleAverage {
+func CreatedAtLT(v time.Time) predicate.VehicleAverage {
 	return predicate.VehicleAverage(sql.FieldLT(FieldCreatedAt, v))
 }
 
 // CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v int64) predicate.VehicleAverage {
+func CreatedAtLTE(v time.Time) predicate.VehicleAverage {
 	return predicate.VehicleAverage(sql.FieldLTE(FieldCreatedAt, v))
 }
 
 // UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
-func UpdatedAtEQ(v int64) predicate.VehicleAverage {
+func UpdatedAtEQ(v time.Time) predicate.VehicleAverage {
 	return predicate.VehicleAverage(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
-func UpdatedAtNEQ(v int64) predicate.VehicleAverage {
+func UpdatedAtNEQ(v time.Time) predicate.VehicleAverage {
 	return predicate.VehicleAverage(sql.FieldNEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtIn applies the In predicate on the "updated_at" field.
-func UpdatedAtIn(vs ...int64) predicate.VehicleAverage {
+func UpdatedAtIn(vs ...time.Time) predicate.VehicleAverage {
 	return predicate.VehicleAverage(sql.FieldIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
-func UpdatedAtNotIn(vs ...int64) predicate.VehicleAverage {
+func UpdatedAtNotIn(vs ...time.Time) predicate.VehicleAverage {
 	return predicate.VehicleAverage(sql.FieldNotIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtGT applies the GT predicate on the "updated_at" field.
-func UpdatedAtGT(v int64) predicate.VehicleAverage {
+func UpdatedAtGT(v time.Time) predicate.VehicleAverage {
 	return predicate.VehicleAverage(sql.FieldGT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
-func UpdatedAtGTE(v int64) predicate.VehicleAverage {
+func UpdatedAtGTE(v time.Time) predicate.VehicleAverage {
 	return predicate.VehicleAverage(sql.FieldGTE(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLT applies the LT predicate on the "updated_at" field.
-func UpdatedAtLT(v int64) predicate.VehicleAverage {
+func UpdatedAtLT(v time.Time) predicate.VehicleAverage {
 	return predicate.VehicleAverage(sql.FieldLT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
-func UpdatedAtLTE(v int64) predicate.VehicleAverage {
+func UpdatedAtLTE(v time.Time) predicate.VehicleAverage {
 	return predicate.VehicleAverage(sql.FieldLTE(FieldUpdatedAt, v))
 }
 
diff --git a/internal/database/ent/db/vehicleaverage_create.go b/internal/database/ent/db/vehicleaverage_create.go
index 1ed5f96c..73d73a36 100644
--- a/internal/database/ent/db/vehicleaverage_create.go
+++ b/internal/database/ent/db/vehicleaverage_create.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"entgo.io/ent/schema/field"
@@ -21,29 +22,29 @@ type VehicleAverageCreate struct {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (vac *VehicleAverageCreate) SetCreatedAt(i int64) *VehicleAverageCreate {
-	vac.mutation.SetCreatedAt(i)
+func (vac *VehicleAverageCreate) SetCreatedAt(t time.Time) *VehicleAverageCreate {
+	vac.mutation.SetCreatedAt(t)
 	return vac
 }
 
 // SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
-func (vac *VehicleAverageCreate) SetNillableCreatedAt(i *int64) *VehicleAverageCreate {
-	if i != nil {
-		vac.SetCreatedAt(*i)
+func (vac *VehicleAverageCreate) SetNillableCreatedAt(t *time.Time) *VehicleAverageCreate {
+	if t != nil {
+		vac.SetCreatedAt(*t)
 	}
 	return vac
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (vac *VehicleAverageCreate) SetUpdatedAt(i int64) *VehicleAverageCreate {
-	vac.mutation.SetUpdatedAt(i)
+func (vac *VehicleAverageCreate) SetUpdatedAt(t time.Time) *VehicleAverageCreate {
+	vac.mutation.SetUpdatedAt(t)
 	return vac
 }
 
 // SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
-func (vac *VehicleAverageCreate) SetNillableUpdatedAt(i *int64) *VehicleAverageCreate {
-	if i != nil {
-		vac.SetUpdatedAt(*i)
+func (vac *VehicleAverageCreate) SetNillableUpdatedAt(t *time.Time) *VehicleAverageCreate {
+	if t != nil {
+		vac.SetUpdatedAt(*t)
 	}
 	return vac
 }
@@ -152,11 +153,11 @@ func (vac *VehicleAverageCreate) createSpec() (*VehicleAverage, *sqlgraph.Create
 		_spec.ID.Value = id
 	}
 	if value, ok := vac.mutation.CreatedAt(); ok {
-		_spec.SetField(vehicleaverage.FieldCreatedAt, field.TypeInt64, value)
+		_spec.SetField(vehicleaverage.FieldCreatedAt, field.TypeTime, value)
 		_node.CreatedAt = value
 	}
 	if value, ok := vac.mutation.UpdatedAt(); ok {
-		_spec.SetField(vehicleaverage.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(vehicleaverage.FieldUpdatedAt, field.TypeTime, value)
 		_node.UpdatedAt = value
 	}
 	if value, ok := vac.mutation.Data(); ok {
diff --git a/internal/database/ent/db/vehicleaverage_query.go b/internal/database/ent/db/vehicleaverage_query.go
index b5c7891d..cbddd69c 100644
--- a/internal/database/ent/db/vehicleaverage_query.go
+++ b/internal/database/ent/db/vehicleaverage_query.go
@@ -21,6 +21,7 @@ type VehicleAverageQuery struct {
 	order      []vehicleaverage.OrderOption
 	inters     []Interceptor
 	predicates []predicate.VehicleAverage
+	modifiers  []func(*sql.Selector)
 	// intermediate query (i.e. traversal path).
 	sql  *sql.Selector
 	path func(context.Context) (*sql.Selector, error)
@@ -261,7 +262,7 @@ func (vaq *VehicleAverageQuery) Clone() *VehicleAverageQuery {
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int64 `json:"created_at,omitempty"`
+//		CreatedAt time.Time `json:"created_at,omitempty"`
 //		Count int `json:"count,omitempty"`
 //	}
 //
@@ -284,7 +285,7 @@ func (vaq *VehicleAverageQuery) GroupBy(field string, fields ...string) *Vehicle
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int64 `json:"created_at,omitempty"`
+//		CreatedAt time.Time `json:"created_at,omitempty"`
 //	}
 //
 //	client.VehicleAverage.Query().
@@ -342,6 +343,9 @@ func (vaq *VehicleAverageQuery) sqlAll(ctx context.Context, hooks ...queryHook)
 		nodes = append(nodes, node)
 		return node.assignValues(columns, values)
 	}
+	if len(vaq.modifiers) > 0 {
+		_spec.Modifiers = vaq.modifiers
+	}
 	for i := range hooks {
 		hooks[i](ctx, _spec)
 	}
@@ -356,6 +360,9 @@ func (vaq *VehicleAverageQuery) sqlAll(ctx context.Context, hooks ...queryHook)
 
 func (vaq *VehicleAverageQuery) sqlCount(ctx context.Context) (int, error) {
 	_spec := vaq.querySpec()
+	if len(vaq.modifiers) > 0 {
+		_spec.Modifiers = vaq.modifiers
+	}
 	_spec.Node.Columns = vaq.ctx.Fields
 	if len(vaq.ctx.Fields) > 0 {
 		_spec.Unique = vaq.ctx.Unique != nil && *vaq.ctx.Unique
@@ -418,6 +425,9 @@ func (vaq *VehicleAverageQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	if vaq.ctx.Unique != nil && *vaq.ctx.Unique {
 		selector.Distinct()
 	}
+	for _, m := range vaq.modifiers {
+		m(selector)
+	}
 	for _, p := range vaq.predicates {
 		p(selector)
 	}
@@ -435,6 +445,12 @@ func (vaq *VehicleAverageQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	return selector
 }
 
+// Modify adds a query modifier for attaching custom logic to queries.
+func (vaq *VehicleAverageQuery) Modify(modifiers ...func(s *sql.Selector)) *VehicleAverageSelect {
+	vaq.modifiers = append(vaq.modifiers, modifiers...)
+	return vaq.Select()
+}
+
 // VehicleAverageGroupBy is the group-by builder for VehicleAverage entities.
 type VehicleAverageGroupBy struct {
 	selector
@@ -524,3 +540,9 @@ func (vas *VehicleAverageSelect) sqlScan(ctx context.Context, root *VehicleAvera
 	defer rows.Close()
 	return sql.ScanSlice(rows, v)
 }
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (vas *VehicleAverageSelect) Modify(modifiers ...func(s *sql.Selector)) *VehicleAverageSelect {
+	vas.modifiers = append(vas.modifiers, modifiers...)
+	return vas
+}
diff --git a/internal/database/ent/db/vehicleaverage_update.go b/internal/database/ent/db/vehicleaverage_update.go
index 199f96c2..1152f2d8 100644
--- a/internal/database/ent/db/vehicleaverage_update.go
+++ b/internal/database/ent/db/vehicleaverage_update.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
@@ -18,8 +19,9 @@ import (
 // VehicleAverageUpdate is the builder for updating VehicleAverage entities.
 type VehicleAverageUpdate struct {
 	config
-	hooks    []Hook
-	mutation *VehicleAverageMutation
+	hooks     []Hook
+	mutation  *VehicleAverageMutation
+	modifiers []func(*sql.UpdateBuilder)
 }
 
 // Where appends a list predicates to the VehicleAverageUpdate builder.
@@ -29,15 +31,8 @@ func (vau *VehicleAverageUpdate) Where(ps ...predicate.VehicleAverage) *VehicleA
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (vau *VehicleAverageUpdate) SetUpdatedAt(i int64) *VehicleAverageUpdate {
-	vau.mutation.ResetUpdatedAt()
-	vau.mutation.SetUpdatedAt(i)
-	return vau
-}
-
-// AddUpdatedAt adds i to the "updated_at" field.
-func (vau *VehicleAverageUpdate) AddUpdatedAt(i int64) *VehicleAverageUpdate {
-	vau.mutation.AddUpdatedAt(i)
+func (vau *VehicleAverageUpdate) SetUpdatedAt(t time.Time) *VehicleAverageUpdate {
+	vau.mutation.SetUpdatedAt(t)
 	return vau
 }
 
@@ -96,6 +91,12 @@ func (vau *VehicleAverageUpdate) defaults() {
 	}
 }
 
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (vau *VehicleAverageUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *VehicleAverageUpdate {
+	vau.modifiers = append(vau.modifiers, modifiers...)
+	return vau
+}
+
 func (vau *VehicleAverageUpdate) sqlSave(ctx context.Context) (n int, err error) {
 	_spec := sqlgraph.NewUpdateSpec(vehicleaverage.Table, vehicleaverage.Columns, sqlgraph.NewFieldSpec(vehicleaverage.FieldID, field.TypeString))
 	if ps := vau.mutation.predicates; len(ps) > 0 {
@@ -106,14 +107,12 @@ func (vau *VehicleAverageUpdate) sqlSave(ctx context.Context) (n int, err error)
 		}
 	}
 	if value, ok := vau.mutation.UpdatedAt(); ok {
-		_spec.SetField(vehicleaverage.FieldUpdatedAt, field.TypeInt64, value)
-	}
-	if value, ok := vau.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(vehicleaverage.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(vehicleaverage.FieldUpdatedAt, field.TypeTime, value)
 	}
 	if value, ok := vau.mutation.Data(); ok {
 		_spec.SetField(vehicleaverage.FieldData, field.TypeJSON, value)
 	}
+	_spec.AddModifiers(vau.modifiers...)
 	if n, err = sqlgraph.UpdateNodes(ctx, vau.driver, _spec); err != nil {
 		if _, ok := err.(*sqlgraph.NotFoundError); ok {
 			err = &NotFoundError{vehicleaverage.Label}
@@ -129,21 +128,15 @@ func (vau *VehicleAverageUpdate) sqlSave(ctx context.Context) (n int, err error)
 // VehicleAverageUpdateOne is the builder for updating a single VehicleAverage entity.
 type VehicleAverageUpdateOne struct {
 	config
-	fields   []string
-	hooks    []Hook
-	mutation *VehicleAverageMutation
+	fields    []string
+	hooks     []Hook
+	mutation  *VehicleAverageMutation
+	modifiers []func(*sql.UpdateBuilder)
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (vauo *VehicleAverageUpdateOne) SetUpdatedAt(i int64) *VehicleAverageUpdateOne {
-	vauo.mutation.ResetUpdatedAt()
-	vauo.mutation.SetUpdatedAt(i)
-	return vauo
-}
-
-// AddUpdatedAt adds i to the "updated_at" field.
-func (vauo *VehicleAverageUpdateOne) AddUpdatedAt(i int64) *VehicleAverageUpdateOne {
-	vauo.mutation.AddUpdatedAt(i)
+func (vauo *VehicleAverageUpdateOne) SetUpdatedAt(t time.Time) *VehicleAverageUpdateOne {
+	vauo.mutation.SetUpdatedAt(t)
 	return vauo
 }
 
@@ -215,6 +208,12 @@ func (vauo *VehicleAverageUpdateOne) defaults() {
 	}
 }
 
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (vauo *VehicleAverageUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *VehicleAverageUpdateOne {
+	vauo.modifiers = append(vauo.modifiers, modifiers...)
+	return vauo
+}
+
 func (vauo *VehicleAverageUpdateOne) sqlSave(ctx context.Context) (_node *VehicleAverage, err error) {
 	_spec := sqlgraph.NewUpdateSpec(vehicleaverage.Table, vehicleaverage.Columns, sqlgraph.NewFieldSpec(vehicleaverage.FieldID, field.TypeString))
 	id, ok := vauo.mutation.ID()
@@ -242,14 +241,12 @@ func (vauo *VehicleAverageUpdateOne) sqlSave(ctx context.Context) (_node *Vehicl
 		}
 	}
 	if value, ok := vauo.mutation.UpdatedAt(); ok {
-		_spec.SetField(vehicleaverage.FieldUpdatedAt, field.TypeInt64, value)
-	}
-	if value, ok := vauo.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(vehicleaverage.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(vehicleaverage.FieldUpdatedAt, field.TypeTime, value)
 	}
 	if value, ok := vauo.mutation.Data(); ok {
 		_spec.SetField(vehicleaverage.FieldData, field.TypeJSON, value)
 	}
+	_spec.AddModifiers(vauo.modifiers...)
 	_node = &VehicleAverage{config: vauo.config}
 	_spec.Assign = _node.assignValues
 	_spec.ScanValues = _node.scanValues
diff --git a/internal/database/ent/db/vehiclesnapshot.go b/internal/database/ent/db/vehiclesnapshot.go
index 03565cf0..126b4036 100644
--- a/internal/database/ent/db/vehiclesnapshot.go
+++ b/internal/database/ent/db/vehiclesnapshot.go
@@ -6,6 +6,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"strings"
+	"time"
 
 	"entgo.io/ent"
 	"entgo.io/ent/dialect/sql"
@@ -21,9 +22,9 @@ type VehicleSnapshot struct {
 	// ID of the ent.
 	ID string `json:"id,omitempty"`
 	// CreatedAt holds the value of the "created_at" field.
-	CreatedAt int64 `json:"created_at,omitempty"`
+	CreatedAt time.Time `json:"created_at,omitempty"`
 	// UpdatedAt holds the value of the "updated_at" field.
-	UpdatedAt int64 `json:"updated_at,omitempty"`
+	UpdatedAt time.Time `json:"updated_at,omitempty"`
 	// Type holds the value of the "type" field.
 	Type models.SnapshotType `json:"type,omitempty"`
 	// AccountID holds the value of the "account_id" field.
@@ -35,7 +36,7 @@ type VehicleSnapshot struct {
 	// Battles holds the value of the "battles" field.
 	Battles int `json:"battles,omitempty"`
 	// LastBattleTime holds the value of the "last_battle_time" field.
-	LastBattleTime int64 `json:"last_battle_time,omitempty"`
+	LastBattleTime time.Time `json:"last_battle_time,omitempty"`
 	// Frame holds the value of the "frame" field.
 	Frame frame.StatsFrame `json:"frame,omitempty"`
 	// Edges holds the relations/edges for other nodes in the graph.
@@ -71,10 +72,12 @@ func (*VehicleSnapshot) scanValues(columns []string) ([]any, error) {
 		switch columns[i] {
 		case vehiclesnapshot.FieldFrame:
 			values[i] = new([]byte)
-		case vehiclesnapshot.FieldCreatedAt, vehiclesnapshot.FieldUpdatedAt, vehiclesnapshot.FieldBattles, vehiclesnapshot.FieldLastBattleTime:
+		case vehiclesnapshot.FieldBattles:
 			values[i] = new(sql.NullInt64)
 		case vehiclesnapshot.FieldID, vehiclesnapshot.FieldType, vehiclesnapshot.FieldAccountID, vehiclesnapshot.FieldVehicleID, vehiclesnapshot.FieldReferenceID:
 			values[i] = new(sql.NullString)
+		case vehiclesnapshot.FieldCreatedAt, vehiclesnapshot.FieldUpdatedAt, vehiclesnapshot.FieldLastBattleTime:
+			values[i] = new(sql.NullTime)
 		default:
 			values[i] = new(sql.UnknownType)
 		}
@@ -97,16 +100,16 @@ func (vs *VehicleSnapshot) assignValues(columns []string, values []any) error {
 				vs.ID = value.String
 			}
 		case vehiclesnapshot.FieldCreatedAt:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field created_at", values[i])
 			} else if value.Valid {
-				vs.CreatedAt = value.Int64
+				vs.CreatedAt = value.Time
 			}
 		case vehiclesnapshot.FieldUpdatedAt:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
 			} else if value.Valid {
-				vs.UpdatedAt = value.Int64
+				vs.UpdatedAt = value.Time
 			}
 		case vehiclesnapshot.FieldType:
 			if value, ok := values[i].(*sql.NullString); !ok {
@@ -139,10 +142,10 @@ func (vs *VehicleSnapshot) assignValues(columns []string, values []any) error {
 				vs.Battles = int(value.Int64)
 			}
 		case vehiclesnapshot.FieldLastBattleTime:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
+			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field last_battle_time", values[i])
 			} else if value.Valid {
-				vs.LastBattleTime = value.Int64
+				vs.LastBattleTime = value.Time
 			}
 		case vehiclesnapshot.FieldFrame:
 			if value, ok := values[i].(*[]byte); !ok {
@@ -194,10 +197,10 @@ func (vs *VehicleSnapshot) String() string {
 	builder.WriteString("VehicleSnapshot(")
 	builder.WriteString(fmt.Sprintf("id=%v, ", vs.ID))
 	builder.WriteString("created_at=")
-	builder.WriteString(fmt.Sprintf("%v", vs.CreatedAt))
+	builder.WriteString(vs.CreatedAt.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("updated_at=")
-	builder.WriteString(fmt.Sprintf("%v", vs.UpdatedAt))
+	builder.WriteString(vs.UpdatedAt.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("type=")
 	builder.WriteString(fmt.Sprintf("%v", vs.Type))
@@ -215,7 +218,7 @@ func (vs *VehicleSnapshot) String() string {
 	builder.WriteString(fmt.Sprintf("%v", vs.Battles))
 	builder.WriteString(", ")
 	builder.WriteString("last_battle_time=")
-	builder.WriteString(fmt.Sprintf("%v", vs.LastBattleTime))
+	builder.WriteString(vs.LastBattleTime.Format(time.ANSIC))
 	builder.WriteString(", ")
 	builder.WriteString("frame=")
 	builder.WriteString(fmt.Sprintf("%v", vs.Frame))
diff --git a/internal/database/ent/db/vehiclesnapshot/vehiclesnapshot.go b/internal/database/ent/db/vehiclesnapshot/vehiclesnapshot.go
index 0d13bf1a..e0a3d4dc 100644
--- a/internal/database/ent/db/vehiclesnapshot/vehiclesnapshot.go
+++ b/internal/database/ent/db/vehiclesnapshot/vehiclesnapshot.go
@@ -4,6 +4,7 @@ package vehiclesnapshot
 
 import (
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
@@ -72,11 +73,11 @@ func ValidColumn(column string) bool {
 
 var (
 	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
-	DefaultCreatedAt func() int64
+	DefaultCreatedAt func() time.Time
 	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
-	DefaultUpdatedAt func() int64
+	DefaultUpdatedAt func() time.Time
 	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
-	UpdateDefaultUpdatedAt func() int64
+	UpdateDefaultUpdatedAt func() time.Time
 	// AccountIDValidator is a validator for the "account_id" field. It is called by the builders before save.
 	AccountIDValidator func(string) error
 	// VehicleIDValidator is a validator for the "vehicle_id" field. It is called by the builders before save.
diff --git a/internal/database/ent/db/vehiclesnapshot/where.go b/internal/database/ent/db/vehiclesnapshot/where.go
index d0489259..18ff9c52 100644
--- a/internal/database/ent/db/vehiclesnapshot/where.go
+++ b/internal/database/ent/db/vehiclesnapshot/where.go
@@ -3,6 +3,8 @@
 package vehiclesnapshot
 
 import (
+	"time"
+
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
@@ -65,12 +67,12 @@ func IDContainsFold(id string) predicate.VehicleSnapshot {
 }
 
 // CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
-func CreatedAt(v int64) predicate.VehicleSnapshot {
+func CreatedAt(v time.Time) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
-func UpdatedAt(v int64) predicate.VehicleSnapshot {
+func UpdatedAt(v time.Time) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
@@ -95,87 +97,87 @@ func Battles(v int) predicate.VehicleSnapshot {
 }
 
 // LastBattleTime applies equality check predicate on the "last_battle_time" field. It's identical to LastBattleTimeEQ.
-func LastBattleTime(v int64) predicate.VehicleSnapshot {
+func LastBattleTime(v time.Time) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldEQ(FieldLastBattleTime, v))
 }
 
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v int64) predicate.VehicleSnapshot {
+func CreatedAtEQ(v time.Time) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v int64) predicate.VehicleSnapshot {
+func CreatedAtNEQ(v time.Time) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldNEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...int64) predicate.VehicleSnapshot {
+func CreatedAtIn(vs ...time.Time) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...int64) predicate.VehicleSnapshot {
+func CreatedAtNotIn(vs ...time.Time) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldNotIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v int64) predicate.VehicleSnapshot {
+func CreatedAtGT(v time.Time) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldGT(FieldCreatedAt, v))
 }
 
 // CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v int64) predicate.VehicleSnapshot {
+func CreatedAtGTE(v time.Time) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldGTE(FieldCreatedAt, v))
 }
 
 // CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v int64) predicate.VehicleSnapshot {
+func CreatedAtLT(v time.Time) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldLT(FieldCreatedAt, v))
 }
 
 // CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v int64) predicate.VehicleSnapshot {
+func CreatedAtLTE(v time.Time) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldLTE(FieldCreatedAt, v))
 }
 
 // UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
-func UpdatedAtEQ(v int64) predicate.VehicleSnapshot {
+func UpdatedAtEQ(v time.Time) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
-func UpdatedAtNEQ(v int64) predicate.VehicleSnapshot {
+func UpdatedAtNEQ(v time.Time) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldNEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtIn applies the In predicate on the "updated_at" field.
-func UpdatedAtIn(vs ...int64) predicate.VehicleSnapshot {
+func UpdatedAtIn(vs ...time.Time) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
-func UpdatedAtNotIn(vs ...int64) predicate.VehicleSnapshot {
+func UpdatedAtNotIn(vs ...time.Time) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldNotIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtGT applies the GT predicate on the "updated_at" field.
-func UpdatedAtGT(v int64) predicate.VehicleSnapshot {
+func UpdatedAtGT(v time.Time) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldGT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
-func UpdatedAtGTE(v int64) predicate.VehicleSnapshot {
+func UpdatedAtGTE(v time.Time) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldGTE(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLT applies the LT predicate on the "updated_at" field.
-func UpdatedAtLT(v int64) predicate.VehicleSnapshot {
+func UpdatedAtLT(v time.Time) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldLT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
-func UpdatedAtLTE(v int64) predicate.VehicleSnapshot {
+func UpdatedAtLTE(v time.Time) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldLTE(FieldUpdatedAt, v))
 }
 
@@ -445,42 +447,42 @@ func BattlesLTE(v int) predicate.VehicleSnapshot {
 }
 
 // LastBattleTimeEQ applies the EQ predicate on the "last_battle_time" field.
-func LastBattleTimeEQ(v int64) predicate.VehicleSnapshot {
+func LastBattleTimeEQ(v time.Time) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldEQ(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeNEQ applies the NEQ predicate on the "last_battle_time" field.
-func LastBattleTimeNEQ(v int64) predicate.VehicleSnapshot {
+func LastBattleTimeNEQ(v time.Time) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldNEQ(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeIn applies the In predicate on the "last_battle_time" field.
-func LastBattleTimeIn(vs ...int64) predicate.VehicleSnapshot {
+func LastBattleTimeIn(vs ...time.Time) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldIn(FieldLastBattleTime, vs...))
 }
 
 // LastBattleTimeNotIn applies the NotIn predicate on the "last_battle_time" field.
-func LastBattleTimeNotIn(vs ...int64) predicate.VehicleSnapshot {
+func LastBattleTimeNotIn(vs ...time.Time) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldNotIn(FieldLastBattleTime, vs...))
 }
 
 // LastBattleTimeGT applies the GT predicate on the "last_battle_time" field.
-func LastBattleTimeGT(v int64) predicate.VehicleSnapshot {
+func LastBattleTimeGT(v time.Time) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldGT(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeGTE applies the GTE predicate on the "last_battle_time" field.
-func LastBattleTimeGTE(v int64) predicate.VehicleSnapshot {
+func LastBattleTimeGTE(v time.Time) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldGTE(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeLT applies the LT predicate on the "last_battle_time" field.
-func LastBattleTimeLT(v int64) predicate.VehicleSnapshot {
+func LastBattleTimeLT(v time.Time) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldLT(FieldLastBattleTime, v))
 }
 
 // LastBattleTimeLTE applies the LTE predicate on the "last_battle_time" field.
-func LastBattleTimeLTE(v int64) predicate.VehicleSnapshot {
+func LastBattleTimeLTE(v time.Time) predicate.VehicleSnapshot {
 	return predicate.VehicleSnapshot(sql.FieldLTE(FieldLastBattleTime, v))
 }
 
diff --git a/internal/database/ent/db/vehiclesnapshot_create.go b/internal/database/ent/db/vehiclesnapshot_create.go
index 32c64243..c0801288 100644
--- a/internal/database/ent/db/vehiclesnapshot_create.go
+++ b/internal/database/ent/db/vehiclesnapshot_create.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"entgo.io/ent/schema/field"
@@ -23,29 +24,29 @@ type VehicleSnapshotCreate struct {
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (vsc *VehicleSnapshotCreate) SetCreatedAt(i int64) *VehicleSnapshotCreate {
-	vsc.mutation.SetCreatedAt(i)
+func (vsc *VehicleSnapshotCreate) SetCreatedAt(t time.Time) *VehicleSnapshotCreate {
+	vsc.mutation.SetCreatedAt(t)
 	return vsc
 }
 
 // SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
-func (vsc *VehicleSnapshotCreate) SetNillableCreatedAt(i *int64) *VehicleSnapshotCreate {
-	if i != nil {
-		vsc.SetCreatedAt(*i)
+func (vsc *VehicleSnapshotCreate) SetNillableCreatedAt(t *time.Time) *VehicleSnapshotCreate {
+	if t != nil {
+		vsc.SetCreatedAt(*t)
 	}
 	return vsc
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (vsc *VehicleSnapshotCreate) SetUpdatedAt(i int64) *VehicleSnapshotCreate {
-	vsc.mutation.SetUpdatedAt(i)
+func (vsc *VehicleSnapshotCreate) SetUpdatedAt(t time.Time) *VehicleSnapshotCreate {
+	vsc.mutation.SetUpdatedAt(t)
 	return vsc
 }
 
 // SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
-func (vsc *VehicleSnapshotCreate) SetNillableUpdatedAt(i *int64) *VehicleSnapshotCreate {
-	if i != nil {
-		vsc.SetUpdatedAt(*i)
+func (vsc *VehicleSnapshotCreate) SetNillableUpdatedAt(t *time.Time) *VehicleSnapshotCreate {
+	if t != nil {
+		vsc.SetUpdatedAt(*t)
 	}
 	return vsc
 }
@@ -81,8 +82,8 @@ func (vsc *VehicleSnapshotCreate) SetBattles(i int) *VehicleSnapshotCreate {
 }
 
 // SetLastBattleTime sets the "last_battle_time" field.
-func (vsc *VehicleSnapshotCreate) SetLastBattleTime(i int64) *VehicleSnapshotCreate {
-	vsc.mutation.SetLastBattleTime(i)
+func (vsc *VehicleSnapshotCreate) SetLastBattleTime(t time.Time) *VehicleSnapshotCreate {
+	vsc.mutation.SetLastBattleTime(t)
 	return vsc
 }
 
@@ -248,11 +249,11 @@ func (vsc *VehicleSnapshotCreate) createSpec() (*VehicleSnapshot, *sqlgraph.Crea
 		_spec.ID.Value = id
 	}
 	if value, ok := vsc.mutation.CreatedAt(); ok {
-		_spec.SetField(vehiclesnapshot.FieldCreatedAt, field.TypeInt64, value)
+		_spec.SetField(vehiclesnapshot.FieldCreatedAt, field.TypeTime, value)
 		_node.CreatedAt = value
 	}
 	if value, ok := vsc.mutation.UpdatedAt(); ok {
-		_spec.SetField(vehiclesnapshot.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(vehiclesnapshot.FieldUpdatedAt, field.TypeTime, value)
 		_node.UpdatedAt = value
 	}
 	if value, ok := vsc.mutation.GetType(); ok {
@@ -272,7 +273,7 @@ func (vsc *VehicleSnapshotCreate) createSpec() (*VehicleSnapshot, *sqlgraph.Crea
 		_node.Battles = value
 	}
 	if value, ok := vsc.mutation.LastBattleTime(); ok {
-		_spec.SetField(vehiclesnapshot.FieldLastBattleTime, field.TypeInt64, value)
+		_spec.SetField(vehiclesnapshot.FieldLastBattleTime, field.TypeTime, value)
 		_node.LastBattleTime = value
 	}
 	if value, ok := vsc.mutation.Frame(); ok {
diff --git a/internal/database/ent/db/vehiclesnapshot_query.go b/internal/database/ent/db/vehiclesnapshot_query.go
index c6c9730e..4796b165 100644
--- a/internal/database/ent/db/vehiclesnapshot_query.go
+++ b/internal/database/ent/db/vehiclesnapshot_query.go
@@ -23,6 +23,7 @@ type VehicleSnapshotQuery struct {
 	inters      []Interceptor
 	predicates  []predicate.VehicleSnapshot
 	withAccount *AccountQuery
+	modifiers   []func(*sql.Selector)
 	// intermediate query (i.e. traversal path).
 	sql  *sql.Selector
 	path func(context.Context) (*sql.Selector, error)
@@ -297,7 +298,7 @@ func (vsq *VehicleSnapshotQuery) WithAccount(opts ...func(*AccountQuery)) *Vehic
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int64 `json:"created_at,omitempty"`
+//		CreatedAt time.Time `json:"created_at,omitempty"`
 //		Count int `json:"count,omitempty"`
 //	}
 //
@@ -320,7 +321,7 @@ func (vsq *VehicleSnapshotQuery) GroupBy(field string, fields ...string) *Vehicl
 // Example:
 //
 //	var v []struct {
-//		CreatedAt int64 `json:"created_at,omitempty"`
+//		CreatedAt time.Time `json:"created_at,omitempty"`
 //	}
 //
 //	client.VehicleSnapshot.Query().
@@ -382,6 +383,9 @@ func (vsq *VehicleSnapshotQuery) sqlAll(ctx context.Context, hooks ...queryHook)
 		node.Edges.loadedTypes = loadedTypes
 		return node.assignValues(columns, values)
 	}
+	if len(vsq.modifiers) > 0 {
+		_spec.Modifiers = vsq.modifiers
+	}
 	for i := range hooks {
 		hooks[i](ctx, _spec)
 	}
@@ -432,6 +436,9 @@ func (vsq *VehicleSnapshotQuery) loadAccount(ctx context.Context, query *Account
 
 func (vsq *VehicleSnapshotQuery) sqlCount(ctx context.Context) (int, error) {
 	_spec := vsq.querySpec()
+	if len(vsq.modifiers) > 0 {
+		_spec.Modifiers = vsq.modifiers
+	}
 	_spec.Node.Columns = vsq.ctx.Fields
 	if len(vsq.ctx.Fields) > 0 {
 		_spec.Unique = vsq.ctx.Unique != nil && *vsq.ctx.Unique
@@ -497,6 +504,9 @@ func (vsq *VehicleSnapshotQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	if vsq.ctx.Unique != nil && *vsq.ctx.Unique {
 		selector.Distinct()
 	}
+	for _, m := range vsq.modifiers {
+		m(selector)
+	}
 	for _, p := range vsq.predicates {
 		p(selector)
 	}
@@ -514,6 +524,12 @@ func (vsq *VehicleSnapshotQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	return selector
 }
 
+// Modify adds a query modifier for attaching custom logic to queries.
+func (vsq *VehicleSnapshotQuery) Modify(modifiers ...func(s *sql.Selector)) *VehicleSnapshotSelect {
+	vsq.modifiers = append(vsq.modifiers, modifiers...)
+	return vsq.Select()
+}
+
 // VehicleSnapshotGroupBy is the group-by builder for VehicleSnapshot entities.
 type VehicleSnapshotGroupBy struct {
 	selector
@@ -603,3 +619,9 @@ func (vss *VehicleSnapshotSelect) sqlScan(ctx context.Context, root *VehicleSnap
 	defer rows.Close()
 	return sql.ScanSlice(rows, v)
 }
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (vss *VehicleSnapshotSelect) Modify(modifiers ...func(s *sql.Selector)) *VehicleSnapshotSelect {
+	vss.modifiers = append(vss.modifiers, modifiers...)
+	return vss
+}
diff --git a/internal/database/ent/db/vehiclesnapshot_update.go b/internal/database/ent/db/vehiclesnapshot_update.go
index ec24d4d9..e8d7b5a6 100644
--- a/internal/database/ent/db/vehiclesnapshot_update.go
+++ b/internal/database/ent/db/vehiclesnapshot_update.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"time"
 
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
@@ -19,8 +20,9 @@ import (
 // VehicleSnapshotUpdate is the builder for updating VehicleSnapshot entities.
 type VehicleSnapshotUpdate struct {
 	config
-	hooks    []Hook
-	mutation *VehicleSnapshotMutation
+	hooks     []Hook
+	mutation  *VehicleSnapshotMutation
+	modifiers []func(*sql.UpdateBuilder)
 }
 
 // Where appends a list predicates to the VehicleSnapshotUpdate builder.
@@ -30,15 +32,8 @@ func (vsu *VehicleSnapshotUpdate) Where(ps ...predicate.VehicleSnapshot) *Vehicl
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (vsu *VehicleSnapshotUpdate) SetUpdatedAt(i int64) *VehicleSnapshotUpdate {
-	vsu.mutation.ResetUpdatedAt()
-	vsu.mutation.SetUpdatedAt(i)
-	return vsu
-}
-
-// AddUpdatedAt adds i to the "updated_at" field.
-func (vsu *VehicleSnapshotUpdate) AddUpdatedAt(i int64) *VehicleSnapshotUpdate {
-	vsu.mutation.AddUpdatedAt(i)
+func (vsu *VehicleSnapshotUpdate) SetUpdatedAt(t time.Time) *VehicleSnapshotUpdate {
+	vsu.mutation.SetUpdatedAt(t)
 	return vsu
 }
 
@@ -92,26 +87,19 @@ func (vsu *VehicleSnapshotUpdate) AddBattles(i int) *VehicleSnapshotUpdate {
 }
 
 // SetLastBattleTime sets the "last_battle_time" field.
-func (vsu *VehicleSnapshotUpdate) SetLastBattleTime(i int64) *VehicleSnapshotUpdate {
-	vsu.mutation.ResetLastBattleTime()
-	vsu.mutation.SetLastBattleTime(i)
+func (vsu *VehicleSnapshotUpdate) SetLastBattleTime(t time.Time) *VehicleSnapshotUpdate {
+	vsu.mutation.SetLastBattleTime(t)
 	return vsu
 }
 
 // SetNillableLastBattleTime sets the "last_battle_time" field if the given value is not nil.
-func (vsu *VehicleSnapshotUpdate) SetNillableLastBattleTime(i *int64) *VehicleSnapshotUpdate {
-	if i != nil {
-		vsu.SetLastBattleTime(*i)
+func (vsu *VehicleSnapshotUpdate) SetNillableLastBattleTime(t *time.Time) *VehicleSnapshotUpdate {
+	if t != nil {
+		vsu.SetLastBattleTime(*t)
 	}
 	return vsu
 }
 
-// AddLastBattleTime adds i to the "last_battle_time" field.
-func (vsu *VehicleSnapshotUpdate) AddLastBattleTime(i int64) *VehicleSnapshotUpdate {
-	vsu.mutation.AddLastBattleTime(i)
-	return vsu
-}
-
 // SetFrame sets the "frame" field.
 func (vsu *VehicleSnapshotUpdate) SetFrame(ff frame.StatsFrame) *VehicleSnapshotUpdate {
 	vsu.mutation.SetFrame(ff)
@@ -185,6 +173,12 @@ func (vsu *VehicleSnapshotUpdate) check() error {
 	return nil
 }
 
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (vsu *VehicleSnapshotUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *VehicleSnapshotUpdate {
+	vsu.modifiers = append(vsu.modifiers, modifiers...)
+	return vsu
+}
+
 func (vsu *VehicleSnapshotUpdate) sqlSave(ctx context.Context) (n int, err error) {
 	if err := vsu.check(); err != nil {
 		return n, err
@@ -198,10 +192,7 @@ func (vsu *VehicleSnapshotUpdate) sqlSave(ctx context.Context) (n int, err error
 		}
 	}
 	if value, ok := vsu.mutation.UpdatedAt(); ok {
-		_spec.SetField(vehiclesnapshot.FieldUpdatedAt, field.TypeInt64, value)
-	}
-	if value, ok := vsu.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(vehiclesnapshot.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(vehiclesnapshot.FieldUpdatedAt, field.TypeTime, value)
 	}
 	if value, ok := vsu.mutation.GetType(); ok {
 		_spec.SetField(vehiclesnapshot.FieldType, field.TypeEnum, value)
@@ -216,14 +207,12 @@ func (vsu *VehicleSnapshotUpdate) sqlSave(ctx context.Context) (n int, err error
 		_spec.AddField(vehiclesnapshot.FieldBattles, field.TypeInt, value)
 	}
 	if value, ok := vsu.mutation.LastBattleTime(); ok {
-		_spec.SetField(vehiclesnapshot.FieldLastBattleTime, field.TypeInt64, value)
-	}
-	if value, ok := vsu.mutation.AddedLastBattleTime(); ok {
-		_spec.AddField(vehiclesnapshot.FieldLastBattleTime, field.TypeInt64, value)
+		_spec.SetField(vehiclesnapshot.FieldLastBattleTime, field.TypeTime, value)
 	}
 	if value, ok := vsu.mutation.Frame(); ok {
 		_spec.SetField(vehiclesnapshot.FieldFrame, field.TypeJSON, value)
 	}
+	_spec.AddModifiers(vsu.modifiers...)
 	if n, err = sqlgraph.UpdateNodes(ctx, vsu.driver, _spec); err != nil {
 		if _, ok := err.(*sqlgraph.NotFoundError); ok {
 			err = &NotFoundError{vehiclesnapshot.Label}
@@ -239,21 +228,15 @@ func (vsu *VehicleSnapshotUpdate) sqlSave(ctx context.Context) (n int, err error
 // VehicleSnapshotUpdateOne is the builder for updating a single VehicleSnapshot entity.
 type VehicleSnapshotUpdateOne struct {
 	config
-	fields   []string
-	hooks    []Hook
-	mutation *VehicleSnapshotMutation
+	fields    []string
+	hooks     []Hook
+	mutation  *VehicleSnapshotMutation
+	modifiers []func(*sql.UpdateBuilder)
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (vsuo *VehicleSnapshotUpdateOne) SetUpdatedAt(i int64) *VehicleSnapshotUpdateOne {
-	vsuo.mutation.ResetUpdatedAt()
-	vsuo.mutation.SetUpdatedAt(i)
-	return vsuo
-}
-
-// AddUpdatedAt adds i to the "updated_at" field.
-func (vsuo *VehicleSnapshotUpdateOne) AddUpdatedAt(i int64) *VehicleSnapshotUpdateOne {
-	vsuo.mutation.AddUpdatedAt(i)
+func (vsuo *VehicleSnapshotUpdateOne) SetUpdatedAt(t time.Time) *VehicleSnapshotUpdateOne {
+	vsuo.mutation.SetUpdatedAt(t)
 	return vsuo
 }
 
@@ -307,26 +290,19 @@ func (vsuo *VehicleSnapshotUpdateOne) AddBattles(i int) *VehicleSnapshotUpdateOn
 }
 
 // SetLastBattleTime sets the "last_battle_time" field.
-func (vsuo *VehicleSnapshotUpdateOne) SetLastBattleTime(i int64) *VehicleSnapshotUpdateOne {
-	vsuo.mutation.ResetLastBattleTime()
-	vsuo.mutation.SetLastBattleTime(i)
+func (vsuo *VehicleSnapshotUpdateOne) SetLastBattleTime(t time.Time) *VehicleSnapshotUpdateOne {
+	vsuo.mutation.SetLastBattleTime(t)
 	return vsuo
 }
 
 // SetNillableLastBattleTime sets the "last_battle_time" field if the given value is not nil.
-func (vsuo *VehicleSnapshotUpdateOne) SetNillableLastBattleTime(i *int64) *VehicleSnapshotUpdateOne {
-	if i != nil {
-		vsuo.SetLastBattleTime(*i)
+func (vsuo *VehicleSnapshotUpdateOne) SetNillableLastBattleTime(t *time.Time) *VehicleSnapshotUpdateOne {
+	if t != nil {
+		vsuo.SetLastBattleTime(*t)
 	}
 	return vsuo
 }
 
-// AddLastBattleTime adds i to the "last_battle_time" field.
-func (vsuo *VehicleSnapshotUpdateOne) AddLastBattleTime(i int64) *VehicleSnapshotUpdateOne {
-	vsuo.mutation.AddLastBattleTime(i)
-	return vsuo
-}
-
 // SetFrame sets the "frame" field.
 func (vsuo *VehicleSnapshotUpdateOne) SetFrame(ff frame.StatsFrame) *VehicleSnapshotUpdateOne {
 	vsuo.mutation.SetFrame(ff)
@@ -413,6 +389,12 @@ func (vsuo *VehicleSnapshotUpdateOne) check() error {
 	return nil
 }
 
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (vsuo *VehicleSnapshotUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *VehicleSnapshotUpdateOne {
+	vsuo.modifiers = append(vsuo.modifiers, modifiers...)
+	return vsuo
+}
+
 func (vsuo *VehicleSnapshotUpdateOne) sqlSave(ctx context.Context) (_node *VehicleSnapshot, err error) {
 	if err := vsuo.check(); err != nil {
 		return _node, err
@@ -443,10 +425,7 @@ func (vsuo *VehicleSnapshotUpdateOne) sqlSave(ctx context.Context) (_node *Vehic
 		}
 	}
 	if value, ok := vsuo.mutation.UpdatedAt(); ok {
-		_spec.SetField(vehiclesnapshot.FieldUpdatedAt, field.TypeInt64, value)
-	}
-	if value, ok := vsuo.mutation.AddedUpdatedAt(); ok {
-		_spec.AddField(vehiclesnapshot.FieldUpdatedAt, field.TypeInt64, value)
+		_spec.SetField(vehiclesnapshot.FieldUpdatedAt, field.TypeTime, value)
 	}
 	if value, ok := vsuo.mutation.GetType(); ok {
 		_spec.SetField(vehiclesnapshot.FieldType, field.TypeEnum, value)
@@ -461,14 +440,12 @@ func (vsuo *VehicleSnapshotUpdateOne) sqlSave(ctx context.Context) (_node *Vehic
 		_spec.AddField(vehiclesnapshot.FieldBattles, field.TypeInt, value)
 	}
 	if value, ok := vsuo.mutation.LastBattleTime(); ok {
-		_spec.SetField(vehiclesnapshot.FieldLastBattleTime, field.TypeInt64, value)
-	}
-	if value, ok := vsuo.mutation.AddedLastBattleTime(); ok {
-		_spec.AddField(vehiclesnapshot.FieldLastBattleTime, field.TypeInt64, value)
+		_spec.SetField(vehiclesnapshot.FieldLastBattleTime, field.TypeTime, value)
 	}
 	if value, ok := vsuo.mutation.Frame(); ok {
 		_spec.SetField(vehiclesnapshot.FieldFrame, field.TypeJSON, value)
 	}
+	_spec.AddModifiers(vsuo.modifiers...)
 	_node = &VehicleSnapshot{config: vsuo.config}
 	_spec.Assign = _node.assignValues
 	_spec.ScanValues = _node.scanValues
diff --git a/internal/database/ent/generate.go b/internal/database/ent/generate.go
index f92ce718..ef051213 100644
--- a/internal/database/ent/generate.go
+++ b/internal/database/ent/generate.go
@@ -1,3 +1,3 @@
 package ent
 
-//go:generate go run -mod=mod entgo.io/ent/cmd/ent generate --feature sql/versioned-migration,sql/execquery --target ./db ./schema
+//go:generate go run -mod=mod entgo.io/ent/cmd/ent generate --feature sql/versioned-migration,sql/execquery,sql/modifier --template ./templates/expose.tmpl --target ./db ./schema
diff --git a/internal/database/ent/migrate/main.go b/internal/database/ent/migrate/main.go
deleted file mode 100644
index 5932cafc..00000000
--- a/internal/database/ent/migrate/main.go
+++ /dev/null
@@ -1,39 +0,0 @@
-// go:build ignore
-
-package main
-
-import (
-	"context"
-	"log"
-	"os"
-
-	atlas "ariga.io/atlas/sql/migrate"
-	"entgo.io/ent/dialect"
-	"entgo.io/ent/dialect/sql/schema"
-	"github.com/cufee/aftermath/internal/database/ent/db/migrate"
-)
-
-func main() {
-	ctx := context.Background()
-	// Create a local migration directory able to understand Atlas migration file format for replay.
-	dir, err := atlas.NewLocalDir("internal/database/ent/migrate/migrations")
-	if err != nil {
-		log.Fatalf("failed creating atlas migration directory: %v", err)
-	}
-	// Migrate diff options.
-	opts := []schema.MigrateOption{
-		schema.WithForeignKeys(false),
-		schema.WithDir(dir),                         // provide migration directory
-		schema.WithMigrationMode(schema.ModeReplay), // provide migration mode
-		schema.WithDialect(dialect.SQLite),          // Ent dialect to use
-		schema.WithFormatter(atlas.DefaultFormatter),
-	}
-	if len(os.Args) != 2 {
-		log.Fatalln("migration name is required. Use: 'go run -mod=mod ent/migrate/main.go <name>'")
-	}
-	// Generate migrations using Atlas support for MySQL (note the Ent dialect option passed above).
-	err = migrate.NamedDiff(ctx, os.Getenv("DATABASE_URL"), os.Args[1], opts...)
-	if err != nil {
-		log.Fatalf("failed generating migration file: %v", err)
-	}
-}
diff --git a/internal/database/ent/migrate/migrations/20240622203812_init.sql b/internal/database/ent/migrate/migrations/20240622203812_init.sql
deleted file mode 100644
index 55d46318..00000000
--- a/internal/database/ent/migrate/migrations/20240622203812_init.sql
+++ /dev/null
@@ -1,102 +0,0 @@
--- Create "accounts" table
-CREATE TABLE `accounts` (`id` text NOT NULL, `created_at` integer NOT NULL, `updated_at` integer NOT NULL, `last_battle_time` integer NOT NULL, `account_created_at` integer NOT NULL, `realm` text NOT NULL, `nickname` text NOT NULL, `private` bool NOT NULL DEFAULT (false), `clan_id` text NULL, PRIMARY KEY (`id`), CONSTRAINT `accounts_clans_accounts` FOREIGN KEY (`clan_id`) REFERENCES `clans` (`id`) ON DELETE SET NULL);
--- Create index "account_id_last_battle_time" to table: "accounts"
-CREATE INDEX `account_id_last_battle_time` ON `accounts` (`id`, `last_battle_time`);
--- Create index "account_realm" to table: "accounts"
-CREATE INDEX `account_realm` ON `accounts` (`realm`);
--- Create index "account_realm_last_battle_time" to table: "accounts"
-CREATE INDEX `account_realm_last_battle_time` ON `accounts` (`realm`, `last_battle_time`);
--- Create index "account_clan_id" to table: "accounts"
-CREATE INDEX `account_clan_id` ON `accounts` (`clan_id`);
--- Create "account_snapshots" table
-CREATE TABLE `account_snapshots` (`id` text NOT NULL, `created_at` integer NOT NULL, `updated_at` integer NOT NULL, `type` text NOT NULL, `last_battle_time` integer NOT NULL, `reference_id` text NOT NULL, `rating_battles` integer NOT NULL, `rating_frame` json NOT NULL, `regular_battles` integer NOT NULL, `regular_frame` json NOT NULL, `account_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `account_snapshots_accounts_snapshots` FOREIGN KEY (`account_id`) REFERENCES `accounts` (`id`) ON DELETE NO ACTION);
--- Create index "accountsnapshot_created_at" to table: "account_snapshots"
-CREATE INDEX `accountsnapshot_created_at` ON `account_snapshots` (`created_at`);
--- Create index "accountsnapshot_type_account_id_created_at" to table: "account_snapshots"
-CREATE INDEX `accountsnapshot_type_account_id_created_at` ON `account_snapshots` (`type`, `account_id`, `created_at`);
--- Create index "accountsnapshot_type_account_id_reference_id" to table: "account_snapshots"
-CREATE INDEX `accountsnapshot_type_account_id_reference_id` ON `account_snapshots` (`type`, `account_id`, `reference_id`);
--- Create index "accountsnapshot_type_account_id_reference_id_created_at" to table: "account_snapshots"
-CREATE INDEX `accountsnapshot_type_account_id_reference_id_created_at` ON `account_snapshots` (`type`, `account_id`, `reference_id`, `created_at`);
--- Create "achievements_snapshots" table
-CREATE TABLE `achievements_snapshots` (`id` text NOT NULL, `created_at` integer NOT NULL, `updated_at` integer NOT NULL, `type` text NOT NULL, `reference_id` text NOT NULL, `battles` integer NOT NULL, `last_battle_time` integer NOT NULL, `data` json NOT NULL, `account_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `achievements_snapshots_accounts_achievement_snapshots` FOREIGN KEY (`account_id`) REFERENCES `accounts` (`id`) ON DELETE NO ACTION);
--- Create index "achievementssnapshot_created_at" to table: "achievements_snapshots"
-CREATE INDEX `achievementssnapshot_created_at` ON `achievements_snapshots` (`created_at`);
--- Create index "achievementssnapshot_account_id_reference_id" to table: "achievements_snapshots"
-CREATE INDEX `achievementssnapshot_account_id_reference_id` ON `achievements_snapshots` (`account_id`, `reference_id`);
--- Create index "achievementssnapshot_account_id_reference_id_created_at" to table: "achievements_snapshots"
-CREATE INDEX `achievementssnapshot_account_id_reference_id_created_at` ON `achievements_snapshots` (`account_id`, `reference_id`, `created_at`);
--- Create "app_configurations" table
-CREATE TABLE `app_configurations` (`id` text NOT NULL, `created_at` integer NOT NULL, `updated_at` integer NOT NULL, `key` text NOT NULL, `value` json NOT NULL, `metadata` json NULL, PRIMARY KEY (`id`));
--- Create index "app_configurations_key_key" to table: "app_configurations"
-CREATE UNIQUE INDEX `app_configurations_key_key` ON `app_configurations` (`key`);
--- Create index "appconfiguration_key" to table: "app_configurations"
-CREATE INDEX `appconfiguration_key` ON `app_configurations` (`key`);
--- Create "application_commands" table
-CREATE TABLE `application_commands` (`id` text NOT NULL, `created_at` integer NOT NULL, `updated_at` integer NOT NULL, `name` text NOT NULL, `version` text NOT NULL, `options_hash` text NOT NULL, PRIMARY KEY (`id`));
--- Create index "application_commands_name_key" to table: "application_commands"
-CREATE UNIQUE INDEX `application_commands_name_key` ON `application_commands` (`name`);
--- Create index "applicationcommand_options_hash" to table: "application_commands"
-CREATE INDEX `applicationcommand_options_hash` ON `application_commands` (`options_hash`);
--- Create "clans" table
-CREATE TABLE `clans` (`id` text NOT NULL, `created_at` integer NOT NULL, `updated_at` integer NOT NULL, `tag` text NOT NULL, `name` text NOT NULL, `emblem_id` text NULL DEFAULT (''), `members` json NOT NULL, PRIMARY KEY (`id`));
--- Create index "clan_tag" to table: "clans"
-CREATE INDEX `clan_tag` ON `clans` (`tag`);
--- Create index "clan_name" to table: "clans"
-CREATE INDEX `clan_name` ON `clans` (`name`);
--- Create "cron_tasks" table
-CREATE TABLE `cron_tasks` (`id` text NOT NULL, `created_at` integer NOT NULL, `updated_at` integer NOT NULL, `type` text NOT NULL, `reference_id` text NOT NULL, `targets` json NOT NULL, `status` text NOT NULL, `scheduled_after` integer NOT NULL, `last_run` integer NOT NULL, `logs` json NOT NULL, `data` json NOT NULL, PRIMARY KEY (`id`));
--- Create index "crontask_reference_id" to table: "cron_tasks"
-CREATE INDEX `crontask_reference_id` ON `cron_tasks` (`reference_id`);
--- Create index "crontask_status_last_run" to table: "cron_tasks"
-CREATE INDEX `crontask_status_last_run` ON `cron_tasks` (`status`, `last_run`);
--- Create index "crontask_status_created_at" to table: "cron_tasks"
-CREATE INDEX `crontask_status_created_at` ON `cron_tasks` (`status`, `created_at`);
--- Create index "crontask_status_scheduled_after" to table: "cron_tasks"
-CREATE INDEX `crontask_status_scheduled_after` ON `cron_tasks` (`status`, `scheduled_after`);
--- Create "users" table
-CREATE TABLE `users` (`id` text NOT NULL, `created_at` integer NOT NULL, `updated_at` integer NOT NULL, `permissions` text NOT NULL DEFAULT (''), `feature_flags` json NULL, PRIMARY KEY (`id`));
--- Create "user_connections" table
-CREATE TABLE `user_connections` (`id` text NOT NULL, `created_at` integer NOT NULL, `updated_at` integer NOT NULL, `type` text NOT NULL, `reference_id` text NOT NULL, `permissions` text NULL DEFAULT (''), `metadata` json NULL, `user_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `user_connections_users_connections` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE NO ACTION);
--- Create index "userconnection_user_id" to table: "user_connections"
-CREATE INDEX `userconnection_user_id` ON `user_connections` (`user_id`);
--- Create index "userconnection_type_user_id" to table: "user_connections"
-CREATE INDEX `userconnection_type_user_id` ON `user_connections` (`type`, `user_id`);
--- Create index "userconnection_reference_id" to table: "user_connections"
-CREATE INDEX `userconnection_reference_id` ON `user_connections` (`reference_id`);
--- Create index "userconnection_type_reference_id" to table: "user_connections"
-CREATE INDEX `userconnection_type_reference_id` ON `user_connections` (`type`, `reference_id`);
--- Create "user_contents" table
-CREATE TABLE `user_contents` (`id` text NOT NULL, `created_at` integer NOT NULL, `updated_at` integer NOT NULL, `type` text NOT NULL, `reference_id` text NOT NULL, `value` json NOT NULL, `metadata` json NOT NULL, `user_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `user_contents_users_content` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE NO ACTION);
--- Create index "usercontent_user_id" to table: "user_contents"
-CREATE INDEX `usercontent_user_id` ON `user_contents` (`user_id`);
--- Create index "usercontent_type_user_id" to table: "user_contents"
-CREATE INDEX `usercontent_type_user_id` ON `user_contents` (`type`, `user_id`);
--- Create index "usercontent_reference_id" to table: "user_contents"
-CREATE INDEX `usercontent_reference_id` ON `user_contents` (`reference_id`);
--- Create index "usercontent_type_reference_id" to table: "user_contents"
-CREATE INDEX `usercontent_type_reference_id` ON `user_contents` (`type`, `reference_id`);
--- Create "user_subscriptions" table
-CREATE TABLE `user_subscriptions` (`id` text NOT NULL, `created_at` integer NOT NULL, `updated_at` integer NOT NULL, `type` text NOT NULL, `expires_at` integer NOT NULL, `permissions` text NOT NULL, `reference_id` text NOT NULL, `user_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `user_subscriptions_users_subscriptions` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE NO ACTION);
--- Create index "usersubscription_user_id" to table: "user_subscriptions"
-CREATE INDEX `usersubscription_user_id` ON `user_subscriptions` (`user_id`);
--- Create index "usersubscription_type_user_id" to table: "user_subscriptions"
-CREATE INDEX `usersubscription_type_user_id` ON `user_subscriptions` (`type`, `user_id`);
--- Create index "usersubscription_expires_at" to table: "user_subscriptions"
-CREATE INDEX `usersubscription_expires_at` ON `user_subscriptions` (`expires_at`);
--- Create index "usersubscription_expires_at_user_id" to table: "user_subscriptions"
-CREATE INDEX `usersubscription_expires_at_user_id` ON `user_subscriptions` (`expires_at`, `user_id`);
--- Create "vehicles" table
-CREATE TABLE `vehicles` (`id` text NOT NULL, `created_at` integer NOT NULL, `updated_at` integer NOT NULL, `tier` integer NOT NULL, `localized_names` json NOT NULL, PRIMARY KEY (`id`));
--- Create "vehicle_averages" table
-CREATE TABLE `vehicle_averages` (`id` text NOT NULL, `created_at` integer NOT NULL, `updated_at` integer NOT NULL, `data` json NOT NULL, PRIMARY KEY (`id`));
--- Create "vehicle_snapshots" table
-CREATE TABLE `vehicle_snapshots` (`id` text NOT NULL, `created_at` integer NOT NULL, `updated_at` integer NOT NULL, `type` text NOT NULL, `vehicle_id` text NOT NULL, `reference_id` text NOT NULL, `battles` integer NOT NULL, `last_battle_time` integer NOT NULL, `frame` json NOT NULL, `account_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `vehicle_snapshots_accounts_vehicle_snapshots` FOREIGN KEY (`account_id`) REFERENCES `accounts` (`id`) ON DELETE NO ACTION);
--- Create index "vehiclesnapshot_created_at" to table: "vehicle_snapshots"
-CREATE INDEX `vehiclesnapshot_created_at` ON `vehicle_snapshots` (`created_at`);
--- Create index "vehiclesnapshot_vehicle_id_created_at" to table: "vehicle_snapshots"
-CREATE INDEX `vehiclesnapshot_vehicle_id_created_at` ON `vehicle_snapshots` (`vehicle_id`, `created_at`);
--- Create index "vehiclesnapshot_account_id_created_at" to table: "vehicle_snapshots"
-CREATE INDEX `vehiclesnapshot_account_id_created_at` ON `vehicle_snapshots` (`account_id`, `created_at`);
--- Create index "vehiclesnapshot_account_id_type_created_at" to table: "vehicle_snapshots"
-CREATE INDEX `vehiclesnapshot_account_id_type_created_at` ON `vehicle_snapshots` (`account_id`, `type`, `created_at`);
diff --git a/internal/database/ent/migrate/migrations/20240623143618_added_indexes_on_id.sql b/internal/database/ent/migrate/migrations/20240623143618_added_indexes_on_id.sql
deleted file mode 100644
index 7314180c..00000000
--- a/internal/database/ent/migrate/migrations/20240623143618_added_indexes_on_id.sql
+++ /dev/null
@@ -1,30 +0,0 @@
--- Create index "account_id" to table: "accounts"
-CREATE INDEX `account_id` ON `accounts` (`id`);
--- Create index "accountsnapshot_id" to table: "account_snapshots"
-CREATE INDEX `accountsnapshot_id` ON `account_snapshots` (`id`);
--- Create index "achievementssnapshot_id" to table: "achievements_snapshots"
-CREATE INDEX `achievementssnapshot_id` ON `achievements_snapshots` (`id`);
--- Create index "appconfiguration_id" to table: "app_configurations"
-CREATE INDEX `appconfiguration_id` ON `app_configurations` (`id`);
--- Create index "applicationcommand_id" to table: "application_commands"
-CREATE INDEX `applicationcommand_id` ON `application_commands` (`id`);
--- Create index "clan_id" to table: "clans"
-CREATE INDEX `clan_id` ON `clans` (`id`);
--- Create index "crontask_id" to table: "cron_tasks"
-CREATE INDEX `crontask_id` ON `cron_tasks` (`id`);
--- Create index "user_id" to table: "users"
-CREATE INDEX `user_id` ON `users` (`id`);
--- Create index "userconnection_id" to table: "user_connections"
-CREATE INDEX `userconnection_id` ON `user_connections` (`id`);
--- Create index "userconnection_reference_id_user_id_type" to table: "user_connections"
-CREATE UNIQUE INDEX `userconnection_reference_id_user_id_type` ON `user_connections` (`reference_id`, `user_id`, `type`);
--- Create index "usercontent_id" to table: "user_contents"
-CREATE INDEX `usercontent_id` ON `user_contents` (`id`);
--- Create index "usersubscription_id" to table: "user_subscriptions"
-CREATE INDEX `usersubscription_id` ON `user_subscriptions` (`id`);
--- Create index "vehicle_id" to table: "vehicles"
-CREATE INDEX `vehicle_id` ON `vehicles` (`id`);
--- Create index "vehicleaverage_id" to table: "vehicle_averages"
-CREATE INDEX `vehicleaverage_id` ON `vehicle_averages` (`id`);
--- Create index "vehiclesnapshot_id" to table: "vehicle_snapshots"
-CREATE INDEX `vehiclesnapshot_id` ON `vehicle_snapshots` (`id`);
diff --git a/internal/database/ent/migrate/migrations/20240626213554.sql b/internal/database/ent/migrate/migrations/20240626213554.sql
deleted file mode 100644
index 378ea14d..00000000
--- a/internal/database/ent/migrate/migrations/20240626213554.sql
+++ /dev/null
@@ -1,12 +0,0 @@
--- Create "discord_interactions" table
-CREATE TABLE `discord_interactions` (`id` text NOT NULL, `created_at` integer NOT NULL, `updated_at` integer NOT NULL, `command` text NOT NULL, `reference_id` text NOT NULL, `type` text NOT NULL, `locale` text NOT NULL, `options` json NOT NULL, `user_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `discord_interactions_users_discord_interactions` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE NO ACTION);
--- Create index "discordinteraction_id" to table: "discord_interactions"
-CREATE INDEX `discordinteraction_id` ON `discord_interactions` (`id`);
--- Create index "discordinteraction_command" to table: "discord_interactions"
-CREATE INDEX `discordinteraction_command` ON `discord_interactions` (`command`);
--- Create index "discordinteraction_user_id" to table: "discord_interactions"
-CREATE INDEX `discordinteraction_user_id` ON `discord_interactions` (`user_id`);
--- Create index "discordinteraction_user_id_type" to table: "discord_interactions"
-CREATE INDEX `discordinteraction_user_id_type` ON `discord_interactions` (`user_id`, `type`);
--- Create index "discordinteraction_reference_id" to table: "discord_interactions"
-CREATE INDEX `discordinteraction_reference_id` ON `discord_interactions` (`reference_id`);
diff --git a/internal/database/ent/migrate/migrations/20240626225519.sql b/internal/database/ent/migrate/migrations/20240626225519.sql
deleted file mode 100644
index f59ccc1c..00000000
--- a/internal/database/ent/migrate/migrations/20240626225519.sql
+++ /dev/null
@@ -1,22 +0,0 @@
--- Disable the enforcement of foreign-keys constraints
-PRAGMA foreign_keys = off;
--- Create "new_user_contents" table
-CREATE TABLE `new_user_contents` (`id` text NOT NULL, `created_at` integer NOT NULL, `updated_at` integer NOT NULL, `type` text NOT NULL, `reference_id` text NOT NULL, `value` text NOT NULL, `metadata` json NOT NULL, `user_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `user_contents_users_content` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE NO ACTION);
--- Copy rows from old table "user_contents" to new temporary table "new_user_contents"
-INSERT INTO `new_user_contents` (`id`, `created_at`, `updated_at`, `type`, `reference_id`, `value`, `metadata`, `user_id`) SELECT `id`, `created_at`, `updated_at`, `type`, `reference_id`, `value`, `metadata`, `user_id` FROM `user_contents`;
--- Drop "user_contents" table after copying rows
-DROP TABLE `user_contents`;
--- Rename temporary table "new_user_contents" to "user_contents"
-ALTER TABLE `new_user_contents` RENAME TO `user_contents`;
--- Create index "usercontent_id" to table: "user_contents"
-CREATE INDEX `usercontent_id` ON `user_contents` (`id`);
--- Create index "usercontent_user_id" to table: "user_contents"
-CREATE INDEX `usercontent_user_id` ON `user_contents` (`user_id`);
--- Create index "usercontent_type_user_id" to table: "user_contents"
-CREATE INDEX `usercontent_type_user_id` ON `user_contents` (`type`, `user_id`);
--- Create index "usercontent_reference_id" to table: "user_contents"
-CREATE INDEX `usercontent_reference_id` ON `user_contents` (`reference_id`);
--- Create index "usercontent_type_reference_id" to table: "user_contents"
-CREATE INDEX `usercontent_type_reference_id` ON `user_contents` (`type`, `reference_id`);
--- Enable back the enforcement of foreign-keys constraints
-PRAGMA foreign_keys = on;
diff --git a/internal/database/ent/migrate/migrations/20240626233300.sql b/internal/database/ent/migrate/migrations/20240626233300.sql
deleted file mode 100644
index 235896cb..00000000
--- a/internal/database/ent/migrate/migrations/20240626233300.sql
+++ /dev/null
@@ -1,2 +0,0 @@
--- Drop index "application_commands_name_key" from table: "application_commands"
-DROP INDEX `application_commands_name_key`;
diff --git a/internal/database/ent/migrate/migrations/atlas.sum b/internal/database/ent/migrate/migrations/atlas.sum
deleted file mode 100644
index 54f7f426..00000000
--- a/internal/database/ent/migrate/migrations/atlas.sum
+++ /dev/null
@@ -1,6 +0,0 @@
-h1:CT0057YWfzRHEDECr8CPEZlaBJOat31j3qFdme4zb/8=
-20240622203812_init.sql h1:Rt6NGvXbPBEpjg1pUFqn97FV8X3X2d1x7J2zOAAxolc=
-20240623143618_added_indexes_on_id.sql h1:o57d1Hc6+wGscJp3VIWnCNrmQkBSeSKTEVKRSWmsc6k=
-20240626213554.sql h1:sKGMP6giStLCW5lUK8VyaLxmiPRQTxT+y6xRkax1juM=
-20240626225519.sql h1:/ARpBIJ80fqBpTK0WH4d5+3Z2kOh86SWlOGSu1PTOFc=
-20240626233300.sql h1:Klr1WjPuZR6NtWPeWwIUHOokVyEEWXbo80DVxNaCzjo=
diff --git a/internal/database/ent/migrations/20240627171532.sql b/internal/database/ent/migrations/20240627171532.sql
new file mode 100644
index 00000000..16b6cc27
--- /dev/null
+++ b/internal/database/ent/migrations/20240627171532.sql
@@ -0,0 +1,142 @@
+-- Create "accounts" table
+CREATE TABLE `accounts` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `last_battle_time` datetime NOT NULL, `account_created_at` datetime NOT NULL, `realm` text NOT NULL, `nickname` text NOT NULL, `private` bool NOT NULL DEFAULT (false), `clan_id` text NULL, PRIMARY KEY (`id`), CONSTRAINT `accounts_clans_accounts` FOREIGN KEY (`clan_id`) REFERENCES `clans` (`id`) ON DELETE SET NULL);
+-- Create index "account_id" to table: "accounts"
+CREATE INDEX `account_id` ON `accounts` (`id`);
+-- Create index "account_id_last_battle_time" to table: "accounts"
+CREATE INDEX `account_id_last_battle_time` ON `accounts` (`id`, `last_battle_time`);
+-- Create index "account_realm" to table: "accounts"
+CREATE INDEX `account_realm` ON `accounts` (`realm`);
+-- Create index "account_realm_last_battle_time" to table: "accounts"
+CREATE INDEX `account_realm_last_battle_time` ON `accounts` (`realm`, `last_battle_time`);
+-- Create index "account_clan_id" to table: "accounts"
+CREATE INDEX `account_clan_id` ON `accounts` (`clan_id`);
+-- Create "account_snapshots" table
+CREATE TABLE `account_snapshots` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `last_battle_time` datetime NOT NULL, `reference_id` text NOT NULL, `rating_battles` integer NOT NULL, `rating_frame` json NOT NULL, `regular_battles` integer NOT NULL, `regular_frame` json NOT NULL, `account_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `account_snapshots_accounts_snapshots` FOREIGN KEY (`account_id`) REFERENCES `accounts` (`id`) ON DELETE NO ACTION);
+-- Create index "accountsnapshot_id" to table: "account_snapshots"
+CREATE INDEX `accountsnapshot_id` ON `account_snapshots` (`id`);
+-- Create index "accountsnapshot_created_at" to table: "account_snapshots"
+CREATE INDEX `accountsnapshot_created_at` ON `account_snapshots` (`created_at`);
+-- Create index "accountsnapshot_type_account_id_created_at" to table: "account_snapshots"
+CREATE INDEX `accountsnapshot_type_account_id_created_at` ON `account_snapshots` (`type`, `account_id`, `created_at`);
+-- Create index "accountsnapshot_type_account_id_reference_id" to table: "account_snapshots"
+CREATE INDEX `accountsnapshot_type_account_id_reference_id` ON `account_snapshots` (`type`, `account_id`, `reference_id`);
+-- Create index "accountsnapshot_type_account_id_reference_id_created_at" to table: "account_snapshots"
+CREATE INDEX `accountsnapshot_type_account_id_reference_id_created_at` ON `account_snapshots` (`type`, `account_id`, `reference_id`, `created_at`);
+-- Create "achievements_snapshots" table
+CREATE TABLE `achievements_snapshots` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `reference_id` text NOT NULL, `battles` integer NOT NULL, `last_battle_time` datetime NOT NULL, `data` json NOT NULL, `account_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `achievements_snapshots_accounts_achievement_snapshots` FOREIGN KEY (`account_id`) REFERENCES `accounts` (`id`) ON DELETE NO ACTION);
+-- Create index "achievementssnapshot_id" to table: "achievements_snapshots"
+CREATE INDEX `achievementssnapshot_id` ON `achievements_snapshots` (`id`);
+-- Create index "achievementssnapshot_created_at" to table: "achievements_snapshots"
+CREATE INDEX `achievementssnapshot_created_at` ON `achievements_snapshots` (`created_at`);
+-- Create index "achievementssnapshot_account_id_reference_id" to table: "achievements_snapshots"
+CREATE INDEX `achievementssnapshot_account_id_reference_id` ON `achievements_snapshots` (`account_id`, `reference_id`);
+-- Create index "achievementssnapshot_account_id_reference_id_created_at" to table: "achievements_snapshots"
+CREATE INDEX `achievementssnapshot_account_id_reference_id_created_at` ON `achievements_snapshots` (`account_id`, `reference_id`, `created_at`);
+-- Create "app_configurations" table
+CREATE TABLE `app_configurations` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `key` text NOT NULL, `value` json NOT NULL, `metadata` json NULL, PRIMARY KEY (`id`));
+-- Create index "app_configurations_key_key" to table: "app_configurations"
+CREATE UNIQUE INDEX `app_configurations_key_key` ON `app_configurations` (`key`);
+-- Create index "appconfiguration_id" to table: "app_configurations"
+CREATE INDEX `appconfiguration_id` ON `app_configurations` (`id`);
+-- Create index "appconfiguration_key" to table: "app_configurations"
+CREATE INDEX `appconfiguration_key` ON `app_configurations` (`key`);
+-- Create "application_commands" table
+CREATE TABLE `application_commands` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `name` text NOT NULL, `version` text NOT NULL, `options_hash` text NOT NULL, PRIMARY KEY (`id`));
+-- Create index "applicationcommand_id" to table: "application_commands"
+CREATE INDEX `applicationcommand_id` ON `application_commands` (`id`);
+-- Create index "applicationcommand_options_hash" to table: "application_commands"
+CREATE INDEX `applicationcommand_options_hash` ON `application_commands` (`options_hash`);
+-- Create "clans" table
+CREATE TABLE `clans` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `tag` text NOT NULL, `name` text NOT NULL, `emblem_id` text NULL DEFAULT (''), `members` json NOT NULL, PRIMARY KEY (`id`));
+-- Create index "clan_id" to table: "clans"
+CREATE INDEX `clan_id` ON `clans` (`id`);
+-- Create index "clan_tag" to table: "clans"
+CREATE INDEX `clan_tag` ON `clans` (`tag`);
+-- Create index "clan_name" to table: "clans"
+CREATE INDEX `clan_name` ON `clans` (`name`);
+-- Create "cron_tasks" table
+CREATE TABLE `cron_tasks` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `reference_id` text NOT NULL, `targets` json NOT NULL, `status` text NOT NULL, `scheduled_after` datetime NOT NULL, `last_run` datetime NOT NULL, `logs` json NOT NULL, `data` json NOT NULL, PRIMARY KEY (`id`));
+-- Create index "crontask_id" to table: "cron_tasks"
+CREATE INDEX `crontask_id` ON `cron_tasks` (`id`);
+-- Create index "crontask_reference_id" to table: "cron_tasks"
+CREATE INDEX `crontask_reference_id` ON `cron_tasks` (`reference_id`);
+-- Create index "crontask_status_last_run" to table: "cron_tasks"
+CREATE INDEX `crontask_status_last_run` ON `cron_tasks` (`status`, `last_run`);
+-- Create index "crontask_status_created_at" to table: "cron_tasks"
+CREATE INDEX `crontask_status_created_at` ON `cron_tasks` (`status`, `created_at`);
+-- Create index "crontask_status_scheduled_after" to table: "cron_tasks"
+CREATE INDEX `crontask_status_scheduled_after` ON `cron_tasks` (`status`, `scheduled_after`);
+-- Create "discord_interactions" table
+CREATE TABLE `discord_interactions` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `command` text NOT NULL, `reference_id` text NOT NULL, `type` text NOT NULL, `locale` text NOT NULL, `options` json NOT NULL, `user_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `discord_interactions_users_discord_interactions` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE NO ACTION);
+-- Create index "discordinteraction_id" to table: "discord_interactions"
+CREATE INDEX `discordinteraction_id` ON `discord_interactions` (`id`);
+-- Create index "discordinteraction_command" to table: "discord_interactions"
+CREATE INDEX `discordinteraction_command` ON `discord_interactions` (`command`);
+-- Create index "discordinteraction_user_id" to table: "discord_interactions"
+CREATE INDEX `discordinteraction_user_id` ON `discord_interactions` (`user_id`);
+-- Create index "discordinteraction_user_id_type" to table: "discord_interactions"
+CREATE INDEX `discordinteraction_user_id_type` ON `discord_interactions` (`user_id`, `type`);
+-- Create index "discordinteraction_reference_id" to table: "discord_interactions"
+CREATE INDEX `discordinteraction_reference_id` ON `discord_interactions` (`reference_id`);
+-- Create "users" table
+CREATE TABLE `users` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `permissions` text NOT NULL DEFAULT (''), `feature_flags` json NULL, PRIMARY KEY (`id`));
+-- Create index "user_id" to table: "users"
+CREATE INDEX `user_id` ON `users` (`id`);
+-- Create "user_connections" table
+CREATE TABLE `user_connections` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `reference_id` text NOT NULL, `permissions` text NULL DEFAULT (''), `metadata` json NULL, `user_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `user_connections_users_connections` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE NO ACTION);
+-- Create index "userconnection_id" to table: "user_connections"
+CREATE INDEX `userconnection_id` ON `user_connections` (`id`);
+-- Create index "userconnection_user_id" to table: "user_connections"
+CREATE INDEX `userconnection_user_id` ON `user_connections` (`user_id`);
+-- Create index "userconnection_type_user_id" to table: "user_connections"
+CREATE INDEX `userconnection_type_user_id` ON `user_connections` (`type`, `user_id`);
+-- Create index "userconnection_reference_id" to table: "user_connections"
+CREATE INDEX `userconnection_reference_id` ON `user_connections` (`reference_id`);
+-- Create index "userconnection_type_reference_id" to table: "user_connections"
+CREATE INDEX `userconnection_type_reference_id` ON `user_connections` (`type`, `reference_id`);
+-- Create index "userconnection_reference_id_user_id_type" to table: "user_connections"
+CREATE UNIQUE INDEX `userconnection_reference_id_user_id_type` ON `user_connections` (`reference_id`, `user_id`, `type`);
+-- Create "user_contents" table
+CREATE TABLE `user_contents` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `reference_id` text NOT NULL, `value` text NOT NULL, `metadata` json NOT NULL, `user_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `user_contents_users_content` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE NO ACTION);
+-- Create index "usercontent_id" to table: "user_contents"
+CREATE INDEX `usercontent_id` ON `user_contents` (`id`);
+-- Create index "usercontent_user_id" to table: "user_contents"
+CREATE INDEX `usercontent_user_id` ON `user_contents` (`user_id`);
+-- Create index "usercontent_type_user_id" to table: "user_contents"
+CREATE INDEX `usercontent_type_user_id` ON `user_contents` (`type`, `user_id`);
+-- Create index "usercontent_reference_id" to table: "user_contents"
+CREATE INDEX `usercontent_reference_id` ON `user_contents` (`reference_id`);
+-- Create index "usercontent_type_reference_id" to table: "user_contents"
+CREATE INDEX `usercontent_type_reference_id` ON `user_contents` (`type`, `reference_id`);
+-- Create "user_subscriptions" table
+CREATE TABLE `user_subscriptions` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `expires_at` datetime NOT NULL, `permissions` text NOT NULL, `reference_id` text NOT NULL, `user_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `user_subscriptions_users_subscriptions` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE NO ACTION);
+-- Create index "usersubscription_id" to table: "user_subscriptions"
+CREATE INDEX `usersubscription_id` ON `user_subscriptions` (`id`);
+-- Create index "usersubscription_user_id" to table: "user_subscriptions"
+CREATE INDEX `usersubscription_user_id` ON `user_subscriptions` (`user_id`);
+-- Create index "usersubscription_type_user_id" to table: "user_subscriptions"
+CREATE INDEX `usersubscription_type_user_id` ON `user_subscriptions` (`type`, `user_id`);
+-- Create index "usersubscription_expires_at" to table: "user_subscriptions"
+CREATE INDEX `usersubscription_expires_at` ON `user_subscriptions` (`expires_at`);
+-- Create index "usersubscription_expires_at_user_id" to table: "user_subscriptions"
+CREATE INDEX `usersubscription_expires_at_user_id` ON `user_subscriptions` (`expires_at`, `user_id`);
+-- Create "vehicles" table
+CREATE TABLE `vehicles` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `tier` integer NOT NULL, `localized_names` json NOT NULL, PRIMARY KEY (`id`));
+-- Create index "vehicle_id" to table: "vehicles"
+CREATE INDEX `vehicle_id` ON `vehicles` (`id`);
+-- Create "vehicle_averages" table
+CREATE TABLE `vehicle_averages` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `data` json NOT NULL, PRIMARY KEY (`id`));
+-- Create index "vehicleaverage_id" to table: "vehicle_averages"
+CREATE INDEX `vehicleaverage_id` ON `vehicle_averages` (`id`);
+-- Create "vehicle_snapshots" table
+CREATE TABLE `vehicle_snapshots` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `vehicle_id` text NOT NULL, `reference_id` text NOT NULL, `battles` integer NOT NULL, `last_battle_time` datetime NOT NULL, `frame` json NOT NULL, `account_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `vehicle_snapshots_accounts_vehicle_snapshots` FOREIGN KEY (`account_id`) REFERENCES `accounts` (`id`) ON DELETE NO ACTION);
+-- Create index "vehiclesnapshot_id" to table: "vehicle_snapshots"
+CREATE INDEX `vehiclesnapshot_id` ON `vehicle_snapshots` (`id`);
+-- Create index "vehiclesnapshot_created_at" to table: "vehicle_snapshots"
+CREATE INDEX `vehiclesnapshot_created_at` ON `vehicle_snapshots` (`created_at`);
+-- Create index "vehiclesnapshot_vehicle_id_created_at" to table: "vehicle_snapshots"
+CREATE INDEX `vehiclesnapshot_vehicle_id_created_at` ON `vehicle_snapshots` (`vehicle_id`, `created_at`);
+-- Create index "vehiclesnapshot_account_id_created_at" to table: "vehicle_snapshots"
+CREATE INDEX `vehiclesnapshot_account_id_created_at` ON `vehicle_snapshots` (`account_id`, `created_at`);
+-- Create index "vehiclesnapshot_account_id_type_created_at" to table: "vehicle_snapshots"
+CREATE INDEX `vehiclesnapshot_account_id_type_created_at` ON `vehicle_snapshots` (`account_id`, `type`, `created_at`);
diff --git a/internal/database/ent/migrations/atlas.sum b/internal/database/ent/migrations/atlas.sum
new file mode 100644
index 00000000..078d2ca9
--- /dev/null
+++ b/internal/database/ent/migrations/atlas.sum
@@ -0,0 +1,2 @@
+h1:xMoifuEeyeG1Wp9DhNcR2c+9QM7POMSSmax2AhvV6Z0=
+20240627171532.sql h1:480JhjRCpyyix192z/L92yEI7LSsgJhuiK0ljat55TI=
diff --git a/internal/database/ent/schema/account.go b/internal/database/ent/schema/account.go
index ea686293..b9518e57 100644
--- a/internal/database/ent/schema/account.go
+++ b/internal/database/ent/schema/account.go
@@ -17,14 +17,14 @@ func (Account) Fields() []ent.Field {
 	return []ent.Field{field.String("id").
 		Unique().
 		Immutable(),
-		field.Int64("created_at").
+		field.Time("created_at").
 			Immutable().
-			DefaultFunc(timeNow),
-		field.Int64("updated_at").
-			DefaultFunc(timeNow).
+			Default(timeNow),
+		field.Time("updated_at").
+			Default(timeNow).
 			UpdateDefault(timeNow),
-		field.Int64("last_battle_time"),
-		field.Int64("account_created_at"),
+		field.Time("last_battle_time"),
+		field.Time("account_created_at"),
 		//
 		field.String("realm").
 			MinLen(2).
diff --git a/internal/database/ent/schema/account_snapshot.go b/internal/database/ent/schema/account_snapshot.go
index 67473711..b7bff591 100644
--- a/internal/database/ent/schema/account_snapshot.go
+++ b/internal/database/ent/schema/account_snapshot.go
@@ -19,7 +19,7 @@ func (AccountSnapshot) Fields() []ent.Field {
 	return append(defaultFields,
 		field.Enum("type").
 			GoType(models.SnapshotType("")),
-		field.Int64("last_battle_time"),
+		field.Time("last_battle_time"),
 		//
 		field.String("account_id").NotEmpty().Immutable(),
 		field.String("reference_id").NotEmpty(),
diff --git a/internal/database/ent/schema/achievements_snapshot.go b/internal/database/ent/schema/achievements_snapshot.go
index 70d56852..b5f24775 100644
--- a/internal/database/ent/schema/achievements_snapshot.go
+++ b/internal/database/ent/schema/achievements_snapshot.go
@@ -23,7 +23,7 @@ func (AchievementsSnapshot) Fields() []ent.Field {
 		field.String("reference_id").NotEmpty(),
 		//
 		field.Int("battles"),
-		field.Int64("last_battle_time"),
+		field.Time("last_battle_time"),
 		field.JSON("data", types.AchievementsFrame{}),
 	)
 }
diff --git a/internal/database/ent/schema/clan.go b/internal/database/ent/schema/clan.go
index 0aa605e3..f5afceba 100644
--- a/internal/database/ent/schema/clan.go
+++ b/internal/database/ent/schema/clan.go
@@ -18,11 +18,11 @@ func (Clan) Fields() []ent.Field {
 		field.String("id").
 			Unique().
 			Immutable(),
-		field.Int64("created_at").
+		field.Time("created_at").
 			Immutable().
-			DefaultFunc(timeNow),
-		field.Int64("updated_at").
-			DefaultFunc(timeNow).
+			Default(timeNow),
+		field.Time("updated_at").
+			Default(timeNow).
 			UpdateDefault(timeNow),
 		//
 		field.String("tag").NotEmpty(),
diff --git a/internal/database/ent/schema/cron_task.go b/internal/database/ent/schema/cron_task.go
index 34a6640e..e20544a2 100644
--- a/internal/database/ent/schema/cron_task.go
+++ b/internal/database/ent/schema/cron_task.go
@@ -22,8 +22,8 @@ func (CronTask) Fields() []ent.Field {
 		//
 		field.Enum("status").
 			GoType(models.TaskStatus("")),
-		field.Int64("scheduled_after"),
-		field.Int64("last_run"),
+		field.Time("scheduled_after"),
+		field.Time("last_run"),
 		//
 		field.JSON("logs", []models.TaskLog{}),
 		field.JSON("data", map[string]any{}),
diff --git a/internal/database/ent/schema/defaults.go b/internal/database/ent/schema/defaults.go
index 97d60c1d..04bfaf9e 100644
--- a/internal/database/ent/schema/defaults.go
+++ b/internal/database/ent/schema/defaults.go
@@ -13,12 +13,12 @@ var defaultFields = []ent.Field{
 		Unique().
 		Immutable().
 		DefaultFunc(cuid.New),
-	field.Int64("created_at").
+	field.Time("created_at").
 		Immutable().
-		DefaultFunc(timeNow),
-	field.Int64("updated_at").
-		DefaultFunc(timeNow).
+		Default(timeNow),
+	field.Time("updated_at").
+		Default(timeNow).
 		UpdateDefault(timeNow),
 }
 
-func timeNow() int64 { return time.Now().Unix() }
+func timeNow() time.Time { return time.Now() }
diff --git a/internal/database/ent/schema/user.go b/internal/database/ent/schema/user.go
index 6ae361e9..aec9bc0f 100644
--- a/internal/database/ent/schema/user.go
+++ b/internal/database/ent/schema/user.go
@@ -18,11 +18,11 @@ func (User) Fields() []ent.Field {
 		field.String("id").
 			Unique().
 			Immutable(),
-		field.Int64("created_at").
+		field.Time("created_at").
 			Immutable().
-			DefaultFunc(timeNow),
-		field.Int64("updated_at").
-			DefaultFunc(timeNow).
+			Default(timeNow),
+		field.Time("updated_at").
+			Default(timeNow).
 			UpdateDefault(timeNow),
 		//
 		field.String("permissions").Default(""),
diff --git a/internal/database/ent/schema/user_subscription.go b/internal/database/ent/schema/user_subscription.go
index ad0b5439..5b87f395 100644
--- a/internal/database/ent/schema/user_subscription.go
+++ b/internal/database/ent/schema/user_subscription.go
@@ -18,7 +18,7 @@ func (UserSubscription) Fields() []ent.Field {
 	return append(defaultFields,
 		field.Enum("type").
 			GoType(models.SubscriptionType("")),
-		field.Int64("expires_at"),
+		field.Time("expires_at"),
 		//
 		field.String("user_id").NotEmpty().Immutable(),
 		field.String("permissions").NotEmpty(),
diff --git a/internal/database/ent/schema/vehicle.go b/internal/database/ent/schema/vehicle.go
index 167259db..0ee5a3d3 100644
--- a/internal/database/ent/schema/vehicle.go
+++ b/internal/database/ent/schema/vehicle.go
@@ -17,11 +17,11 @@ func (Vehicle) Fields() []ent.Field {
 		field.String("id").
 			Unique().
 			Immutable(),
-		field.Int64("created_at").
+		field.Time("created_at").
 			Immutable().
-			DefaultFunc(timeNow),
-		field.Int64("updated_at").
-			DefaultFunc(timeNow).
+			Default(timeNow),
+		field.Time("updated_at").
+			Default(timeNow).
 			UpdateDefault(timeNow),
 		//
 		field.Int("tier").
diff --git a/internal/database/ent/schema/vehicle_average.go b/internal/database/ent/schema/vehicle_average.go
index 57d1a05a..fde82571 100644
--- a/internal/database/ent/schema/vehicle_average.go
+++ b/internal/database/ent/schema/vehicle_average.go
@@ -18,11 +18,11 @@ func (VehicleAverage) Fields() []ent.Field {
 		field.String("id").
 			Unique().
 			Immutable(),
-		field.Int64("created_at").
+		field.Time("created_at").
 			Immutable().
-			DefaultFunc(timeNow),
-		field.Int64("updated_at").
-			DefaultFunc(timeNow).
+			Default(timeNow),
+		field.Time("updated_at").
+			Default(timeNow).
 			UpdateDefault(timeNow),
 		//
 		field.JSON("data", frame.StatsFrame{}),
diff --git a/internal/database/ent/schema/vehicle_snapshot.go b/internal/database/ent/schema/vehicle_snapshot.go
index 13fc124f..b2f69e9d 100644
--- a/internal/database/ent/schema/vehicle_snapshot.go
+++ b/internal/database/ent/schema/vehicle_snapshot.go
@@ -25,7 +25,7 @@ func (VehicleSnapshot) Fields() []ent.Field {
 		field.String("reference_id").NotEmpty(),
 		//
 		field.Int("battles"),
-		field.Int64("last_battle_time"),
+		field.Time("last_battle_time"),
 		field.JSON("frame", frame.StatsFrame{}),
 	)
 }
diff --git a/internal/database/ent/templates/expose.tmpl b/internal/database/ent/templates/expose.tmpl
new file mode 100644
index 00000000..cb503a91
--- /dev/null
+++ b/internal/database/ent/templates/expose.tmpl
@@ -0,0 +1,24 @@
+{{ define "expose" }}
+
+{{/* Add the base header for the generated file */}}
+{{ $pkg := base $.Config.Package }}
+{{ template "header" $ }}
+
+{{/* Loop over all nodes and implement the "GoStringer" interface */}}
+{{ range $n := $.Nodes }}
+    {{ $receiver := $n.Receiver }}
+    func ({{ $receiver }} *{{ $n.Name }}) AssignValues(columns []string, values []any) error {
+        if {{ $receiver }} == nil {
+            return fmt.Errorf("{{ $n.Name }}(nil)")
+        }
+        return {{ $receiver }}.assignValues(columns, values)
+    }
+    func ({{ $receiver }} *{{ $n.Name }}) ScanValues(columns []string) ([]any, error) {
+        if {{ $receiver }} == nil {
+            return nil, fmt.Errorf("{{ $n.Name }}(nil)")
+        }
+        return {{ $receiver }}.scanValues(columns)
+    }
+{{ end }}
+
+{{ end }}
\ No newline at end of file
diff --git a/internal/database/snapshots.go b/internal/database/snapshots.go
index 34613a5c..a0809469 100644
--- a/internal/database/snapshots.go
+++ b/internal/database/snapshots.go
@@ -41,8 +41,8 @@ func toVehicleSnapshot(record *db.VehicleSnapshot) models.VehicleSnapshot {
 	return models.VehicleSnapshot{
 		ID:             record.ID,
 		Type:           record.Type,
-		CreatedAt:      time.Unix(record.CreatedAt, 0),
-		LastBattleTime: time.Unix(record.LastBattleTime, 0),
+		CreatedAt:      record.CreatedAt,
+		LastBattleTime: record.LastBattleTime,
 		ReferenceID:    record.ReferenceID,
 		AccountID:      record.AccountID,
 		VehicleID:      record.VehicleID,
@@ -56,15 +56,16 @@ func (c *client) CreateAccountVehicleSnapshots(ctx context.Context, accountID st
 	}
 
 	var errors = make(map[string]error)
-	return errors, c.withTx(ctx, func(tx *db.Tx) error {
+	err := c.withTx(ctx, func(tx *db.Tx) error {
 		for _, data := range snapshots {
 			err := c.db.VehicleSnapshot.Create().
 				SetType(data.Type).
 				SetFrame(data.Stats).
 				SetVehicleID(data.VehicleID).
 				SetReferenceID(data.ReferenceID).
+				SetCreatedAt(data.CreatedAt).
 				SetBattles(int(data.Stats.Battles.Float())).
-				SetLastBattleTime(data.LastBattleTime.Unix()).
+				SetLastBattleTime(data.LastBattleTime).
 				SetAccount(c.db.Account.GetX(ctx, accountID)).
 				Exec(ctx)
 			if err != nil {
@@ -73,6 +74,13 @@ func (c *client) CreateAccountVehicleSnapshots(ctx context.Context, accountID st
 		}
 		return nil
 	})
+	if err != nil {
+		return nil, err
+	}
+	if len(errors) > 0 {
+		return errors, nil
+	}
+	return nil, nil
 }
 
 func (c *client) GetVehicleSnapshots(ctx context.Context, accountID, referenceID string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.VehicleSnapshot, error) {
@@ -81,31 +89,65 @@ func (c *client) GetVehicleSnapshots(ctx context.Context, accountID, referenceID
 		apply(&query)
 	}
 
-	var where []predicate.VehicleSnapshot
-	where = append(where, vehiclesnapshot.AccountID(accountID))
-	where = append(where, vehiclesnapshot.ReferenceID(referenceID))
-	where = append(where, vehiclesnapshot.TypeEQ(kind))
+	// this query is impossible to build using the db.VehicleSnapshots methods, so we do it manually
+	var innerWhere []*sql.Predicate
+	innerWhere = append(innerWhere,
+		sql.EQ(vehiclesnapshot.FieldType, kind),
+		sql.EQ(vehiclesnapshot.FieldAccountID, accountID),
+		sql.EQ(vehiclesnapshot.FieldReferenceID, referenceID),
+	)
+	innerOrder := sql.Desc(vehiclesnapshot.FieldCreatedAt)
 
-	order := vehiclesnapshot.ByCreatedAt(sql.OrderDesc())
 	if query.createdAfter != nil {
-		order = vehiclesnapshot.ByCreatedAt(sql.OrderAsc())
-		where = append(where, vehiclesnapshot.CreatedAtGT(query.createdAfter.Unix()))
+		innerWhere = append(innerWhere, sql.GT(vehiclesnapshot.FieldCreatedAt, *query.createdAfter))
+		innerOrder = sql.Asc(vehiclesnapshot.FieldCreatedAt)
 	}
 	if query.createdBefore != nil {
-		where = append(where, vehiclesnapshot.CreatedAtLT(query.createdBefore.Unix()))
+		innerWhere = append(innerWhere, sql.LT(vehiclesnapshot.FieldCreatedAt, *query.createdBefore))
+		innerOrder = sql.Desc(vehiclesnapshot.FieldCreatedAt)
 	}
-	if query.vehicleIDs != nil {
-		where = append(where, vehiclesnapshot.VehicleIDIn(query.vehicleIDs...))
+	if len(query.vehicleIDs) > 0 {
+		var ids []any
+		for _, id := range query.vehicleIDs {
+			ids = append(ids, id)
+		}
+		innerWhere = append(innerWhere, sql.In(vehiclesnapshot.FieldVehicleID, ids...))
 	}
 
-	var records db.VehicleSnapshots
-	err := c.db.VehicleSnapshot.Query().Where(where...).Order(order).GroupBy(vehiclesnapshot.FieldVehicleID).Aggregate(func(s *sql.Selector) string { return s.Select("*").String() }).Scan(ctx, &records)
+	innerQuery := sql.Select(vehiclesnapshot.Columns...).From(sql.Table(vehiclesnapshot.Table))
+	innerQuery = innerQuery.Where(sql.And(innerWhere...))
+	innerQuery = innerQuery.OrderBy(innerOrder)
+
+	innerQueryString, innerQueryArgs := innerQuery.Query()
+
+	// wrap the inner query in a GROUP BY
+	wrapper := &sql.Builder{}
+	wrapped := wrapper.Wrap(func(b *sql.Builder) { b.WriteString(innerQueryString) })
+	queryString, _ := sql.Select("*").FromExpr(wrapped).GroupBy(vehiclesnapshot.FieldVehicleID).Query()
+
+	rows, err := c.db.VehicleSnapshot.QueryContext(ctx, queryString, innerQueryArgs...)
 	if err != nil {
 		return nil, err
 	}
+	defer rows.Close()
+
 	var snapshots []models.VehicleSnapshot
-	for _, r := range records {
-		snapshots = append(snapshots, toVehicleSnapshot(r))
+	for rows.Next() {
+		var record db.VehicleSnapshot
+
+		values, err := record.ScanValues(vehiclesnapshot.Columns)
+		if err != nil {
+			return nil, err
+		}
+		if err := rows.Scan(values...); err != nil {
+			return nil, err
+		}
+
+		err = record.AssignValues(vehiclesnapshot.Columns, values)
+		if err != nil {
+			return nil, err
+		}
+		snapshots = append(snapshots, toVehicleSnapshot(&record))
 	}
 
 	return snapshots, nil
@@ -119,8 +161,8 @@ func toAccountSnapshot(record *db.AccountSnapshot) models.AccountSnapshot {
 		ReferenceID:    record.ReferenceID,
 		RatingBattles:  record.RatingFrame,
 		RegularBattles: record.RegularFrame,
-		CreatedAt:      time.Unix(record.CreatedAt, 0),
-		LastBattleTime: time.Unix(record.LastBattleTime, 0),
+		CreatedAt:      record.CreatedAt,
+		LastBattleTime: record.LastBattleTime,
 	}
 }
 
@@ -130,12 +172,12 @@ func (c *client) CreateAccountSnapshots(ctx context.Context, snapshots ...models
 	}
 
 	var errors = make(map[string]error)
-	return errors, c.withTx(ctx, func(tx *db.Tx) error {
+	err := c.withTx(ctx, func(tx *db.Tx) error {
 		for _, s := range snapshots {
 			err := c.db.AccountSnapshot.Create().
 				SetAccount(c.db.Account.GetX(ctx, s.AccountID)). // we assume the account exists here
-				SetCreatedAt(s.CreatedAt.Unix()).
-				SetLastBattleTime(s.LastBattleTime.Unix()).
+				SetCreatedAt(s.CreatedAt).
+				SetLastBattleTime(s.LastBattleTime).
 				SetRatingBattles(int(s.RatingBattles.Battles.Float())).
 				SetRatingFrame(s.RatingBattles).
 				SetReferenceID(s.ReferenceID).
@@ -148,6 +190,13 @@ func (c *client) CreateAccountSnapshots(ctx context.Context, snapshots ...models
 		}
 		return nil
 	})
+	if err != nil {
+		return nil, err
+	}
+	if len(errors) > 0 {
+		return errors, nil
+	}
+	return nil, nil
 }
 
 func (c *client) GetLastAccountSnapshots(ctx context.Context, accountID string, limit int) ([]models.AccountSnapshot, error) {
@@ -175,10 +224,10 @@ func (c *client) GetAccountSnapshot(ctx context.Context, accountID, referenceID
 	where = append(where, accountsnapshot.AccountID(accountID), accountsnapshot.ReferenceID(referenceID), accountsnapshot.TypeEQ(kind))
 	if query.createdAfter != nil {
 		order = accountsnapshot.ByCreatedAt(sql.OrderAsc())
-		where = append(where, accountsnapshot.CreatedAtGT(query.createdAfter.Unix()))
+		where = append(where, accountsnapshot.CreatedAtGT(*query.createdAfter))
 	}
 	if query.createdBefore != nil {
-		where = append(where, accountsnapshot.CreatedAtLT(query.createdBefore.Unix()))
+		where = append(where, accountsnapshot.CreatedAtLT(*query.createdBefore))
 	}
 
 	record, err := c.db.AccountSnapshot.Query().Where(where...).Order(order).First(ctx)
@@ -198,10 +247,10 @@ func (c *client) GetManyAccountSnapshots(ctx context.Context, accountIDs []strin
 	var where []predicate.AccountSnapshot
 	where = append(where, accountsnapshot.AccountIDIn(accountIDs...), accountsnapshot.TypeEQ(kind))
 	if query.createdAfter != nil {
-		where = append(where, accountsnapshot.CreatedAtGT(query.createdAfter.Unix()))
+		where = append(where, accountsnapshot.CreatedAtGT(*query.createdAfter))
 	}
 	if query.createdBefore != nil {
-		where = append(where, accountsnapshot.CreatedAtLT(query.createdAfter.Unix()))
+		where = append(where, accountsnapshot.CreatedAtLT(*query.createdAfter))
 	}
 
 	records, err := c.db.AccountSnapshot.Query().Where(where...).All(ctx)
diff --git a/internal/database/snapshots_test.go b/internal/database/snapshots_test.go
index 06653cf5..0726554d 100644
--- a/internal/database/snapshots_test.go
+++ b/internal/database/snapshots_test.go
@@ -1,113 +1,129 @@
 package database
 
-// /*
-// DATABASE_URL needs to be set and migrations need to be applied
-// */
-// func TestGetVehicleSnapshots(t *testing.T) {
-// 	client, err := NewClient()
-// 	assert.NoError(t, err, "new client should not error")
-// 	defer client.prisma.Disconnect()
-
-// 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*15)
-// 	defer cancel()
-
-// 	client.prisma.VehicleSnapshot.FindMany().Delete().Exec(ctx)
-// 	defer client.prisma.VehicleSnapshot.FindMany().Delete().Exec(ctx)
-
-// 	createdAtVehicle1 := time.Date(2023, 6, 1, 0, 0, 0, 0, time.UTC)
-// 	createdAtVehicle2 := time.Date(2023, 8, 1, 0, 0, 0, 0, time.UTC)
-// 	createdAtVehicle3 := time.Date(2023, 10, 1, 0, 0, 0, 0, time.UTC)
-
-// 	createdAtVehicle4 := time.Date(2023, 9, 1, 0, 0, 0, 0, time.UTC)
-// 	createdAtVehicle5 := time.Date(2023, 9, 2, 0, 0, 0, 0, time.UTC)
-
-// 	vehicle1 := VehicleSnapshot{
-// 		VehicleID:   "v1",
-// 		AccountID:   "a1",
-// 		ReferenceID: "r1",
-
-// 		Type:           SnapshotTypeDaily,
-// 		CreatedAt:      createdAtVehicle1,
-// 		LastBattleTime: createdAtVehicle1,
-// 	}
-// 	vehicle2 := VehicleSnapshot{
-// 		VehicleID:   "v1",
-// 		AccountID:   "a1",
-// 		ReferenceID: "r1",
-
-// 		Type:           SnapshotTypeDaily,
-// 		CreatedAt:      createdAtVehicle2,
-// 		LastBattleTime: createdAtVehicle2,
-// 	}
-// 	vehicle3 := VehicleSnapshot{
-// 		VehicleID:   "v1",
-// 		AccountID:   "a1",
-// 		ReferenceID: "r1",
-
-// 		Type:           SnapshotTypeDaily,
-// 		CreatedAt:      createdAtVehicle3,
-// 		LastBattleTime: createdAtVehicle3,
-// 	}
-// 	vehicle4 := VehicleSnapshot{
-// 		VehicleID:   "v4",
-// 		AccountID:   "a1",
-// 		ReferenceID: "r2",
-
-// 		Type:           SnapshotTypeDaily,
-// 		CreatedAt:      createdAtVehicle4,
-// 		LastBattleTime: createdAtVehicle4,
-// 	}
-// 	vehicle5 := VehicleSnapshot{
-// 		VehicleID:   "v5",
-// 		AccountID:   "a1",
-// 		ReferenceID: "r2",
-
-// 		Type:           SnapshotTypeDaily,
-// 		CreatedAt:      createdAtVehicle5,
-// 		LastBattleTime: createdAtVehicle5,
-// 	}
-// 	vehicle6 := VehicleSnapshot{
-// 		VehicleID:   "v5",
-// 		AccountID:   "a1",
-// 		ReferenceID: "r2",
-
-// 		Type:           SnapshotTypeDaily,
-// 		CreatedAt:      createdAtVehicle5,
-// 		LastBattleTime: createdAtVehicle5,
-// 	}
-
-// 	{ // create snapshots
-// 		snaphots := []VehicleSnapshot{vehicle1, vehicle2, vehicle3, vehicle4, vehicle5, vehicle6}
-// 		err = client.CreateVehicleSnapshots(ctx, snaphots...)
-// 		assert.NoError(t, err, "create vehicle snapshot should not error")
-// 	}
-// 	{ // when we check created after, vehicles need to be ordered by createdAt ASC, so we expect to get vehicle2 back
-// 		vehicles, err := client.GetVehicleSnapshots(ctx, "a1", "r1", SnapshotTypeDaily, WithCreatedAfter(createdAtVehicle1))
-// 		assert.NoError(t, err, "get vehicle snapshot error")
-// 		assert.Len(t, vehicles, 1, "should return exactly 1 snapshots")
-// 		assert.True(t, vehicles[0].CreatedAt.Equal(createdAtVehicle2), "wrong vehicle snapshot returned", vehicles)
-// 	}
-// 	{ // when we check created before, vehicles need to be ordered by createdAt DESC, so we expect to get vehicle2 back
-// 		vehicles, err := client.GetVehicleSnapshots(ctx, "a1", "r1", SnapshotTypeDaily, WithCreatedBefore(createdAtVehicle3))
-// 		assert.NoError(t, err, "get vehicle snapshot error")
-// 		assert.Len(t, vehicles, 1, "should return exactly 1 snapshots")
-// 		assert.True(t, vehicles[0].CreatedAt.Equal(createdAtVehicle2), "wrong vehicle snapshot returned", vehicles)
-// 	}
-// 	{ // make sure only 1 vehicle is returned per ID
-// 		vehicles, err := client.GetVehicleSnapshots(ctx, "a1", "r2", SnapshotTypeDaily, WithCreatedBefore(createdAtVehicle5.Add(time.Hour)))
-// 		assert.NoError(t, err, "get vehicle snapshot error")
-// 		assert.Len(t, vehicles, 2, "should return exactly 2 snapshots")
-// 		assert.NotEqual(t, vehicles[0].ID, vehicles[1].ID, "each vehicle id should only be returned once", vehicles)
-// 	}
-// 	{ // get a cehicle with a specific id
-// 		vehicles, err := client.GetVehicleSnapshots(ctx, "a1", "r2", SnapshotTypeDaily, WithVehicleIDs([]string{"v5"}))
-// 		assert.NoError(t, err, "get vehicle snapshot error")
-// 		assert.Len(t, vehicles, 1, "should return exactly 1 snapshots")
-// 		assert.NotEqual(t, vehicles[0].ID, "v5", "incorrect vehicle returned", vehicles)
-// 	}
-// 	{ // this should return no result
-// 		vehicles, err := client.GetVehicleSnapshots(ctx, "a1", "r1", SnapshotTypeDaily, WithCreatedBefore(createdAtVehicle1))
-// 		assert.NoError(t, err, "no results from a raw query does not trigger an error")
-// 		assert.Len(t, vehicles, 0, "return should have no results", vehicles)
-// 	}
-// }
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/cufee/aftermath/internal/database/models"
+	_ "github.com/joho/godotenv/autoload"
+	"github.com/stretchr/testify/assert"
+)
+
+/*
+DATABASE_PATH, DATABASE_NAME need to be set, and migrations need to be applied
+*/
+func TestGetVehicleSnapshots(t *testing.T) {
+	client, err := NewSQLiteClient(filepath.Join(os.Getenv("DATABASE_PATH"), os.Getenv("DATABASE_NAME")), WithDebug())
+	assert.NoError(t, err, "new client should not error")
+	defer client.Disconnect()
+
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*15)
+	defer cancel()
+
+	client.db.VehicleSnapshot.Delete().Where().Exec(ctx)
+	defer client.db.VehicleSnapshot.Delete().Exec(ctx)
+
+	_, err = client.UpsertAccounts(ctx, []models.Account{{ID: "a1", Realm: "test", Nickname: "test_account"}})
+	assert.NoError(t, err, "failed to upsert an account")
+
+	createdAtVehicle1 := time.Date(2023, 6, 1, 0, 0, 0, 0, time.UTC)
+	createdAtVehicle2 := time.Date(2023, 8, 1, 0, 0, 0, 0, time.UTC)
+	createdAtVehicle3 := time.Date(2023, 10, 1, 0, 0, 0, 0, time.UTC)
+
+	createdAtVehicle4 := time.Date(2023, 9, 1, 0, 0, 0, 0, time.UTC)
+	createdAtVehicle5 := time.Date(2023, 9, 2, 0, 0, 0, 0, time.UTC)
+
+	vehicle1 := models.VehicleSnapshot{
+		VehicleID:   "v1",
+		AccountID:   "a1",
+		ReferenceID: "r1",
+
+		Type:           models.SnapshotTypeDaily,
+		CreatedAt:      createdAtVehicle1,
+		LastBattleTime: createdAtVehicle1,
+	}
+	vehicle2 := models.VehicleSnapshot{
+		VehicleID:   "v1",
+		AccountID:   "a1",
+		ReferenceID: "r1",
+
+		Type:           models.SnapshotTypeDaily,
+		CreatedAt:      createdAtVehicle2,
+		LastBattleTime: createdAtVehicle2,
+	}
+	vehicle3 := models.VehicleSnapshot{
+		VehicleID:   "v1",
+		AccountID:   "a1",
+		ReferenceID: "r1",
+
+		Type:           models.SnapshotTypeDaily,
+		CreatedAt:      createdAtVehicle3,
+		LastBattleTime: createdAtVehicle3,
+	}
+	vehicle4 := models.VehicleSnapshot{
+		VehicleID:   "v4",
+		AccountID:   "a1",
+		ReferenceID: "r2",
+
+		Type:           models.SnapshotTypeDaily,
+		CreatedAt:      createdAtVehicle4,
+		LastBattleTime: createdAtVehicle4,
+	}
+	vehicle5 := models.VehicleSnapshot{
+		VehicleID:   "v5",
+		AccountID:   "a1",
+		ReferenceID: "r2",
+
+		Type:           models.SnapshotTypeDaily,
+		CreatedAt:      createdAtVehicle5,
+		LastBattleTime: createdAtVehicle5,
+	}
+	vehicle6 := models.VehicleSnapshot{
+		VehicleID:   "v5",
+		AccountID:   "a1",
+		ReferenceID: "r2",
+
+		Type:           models.SnapshotTypeDaily,
+		CreatedAt:      createdAtVehicle5,
+		LastBattleTime: createdAtVehicle5,
+	}
+
+	{ // create snapshots
+		snapshots := []models.VehicleSnapshot{vehicle1, vehicle2, vehicle3, vehicle4, vehicle5, vehicle6}
+		aErr, err := client.CreateAccountVehicleSnapshots(ctx, "a1", snapshots...)
+		assert.NoError(t, err, "create vehicle snapshot should not error")
+		assert.Nil(t, aErr, "insert returned some errors")
+	}
+	{ // when we check created after, vehicles need to be ordered by createdAt ASC, so we expect to get vehicle2 back
+		vehicles, err := client.GetVehicleSnapshots(ctx, "a1", "r1", models.SnapshotTypeDaily, WithCreatedAfter(createdAtVehicle1))
+		assert.NoError(t, err, "get vehicle snapshot error")
+		assert.Len(t, vehicles, 1, "should return exactly 1 snapshot")
+		assert.True(t, vehicles[0].CreatedAt.Equal(createdAtVehicle2), "wrong vehicle snapshot returned\nvehicles:%#v\nexpected:%#v", vehicles, createdAtVehicle2)
+	}
+	{ // when we check created before, vehicles need to be ordered by createdAt DESC, so we expect to get vehicle2 back
+		vehicles, err := client.GetVehicleSnapshots(ctx, "a1", "r1", models.SnapshotTypeDaily, WithCreatedBefore(createdAtVehicle3))
+		assert.NoError(t, err, "get vehicle snapshot error")
+		assert.Len(t, vehicles, 1, "should return exactly 1 snapshot")
+		assert.True(t, vehicles[0].CreatedAt.Equal(createdAtVehicle2), "wrong vehicle snapshot returned\nvehicles:%#v\nexpected:%#v", vehicles, createdAtVehicle2)
+	}
+	{ // make sure only 1 vehicle is returned per ID
+		vehicles, err := client.GetVehicleSnapshots(ctx, "a1", "r2", models.SnapshotTypeDaily, WithCreatedBefore(createdAtVehicle5.Add(time.Hour)))
+		assert.NoError(t, err, "get vehicle snapshot error")
+		assert.Len(t, vehicles, 2, "should return exactly 2 snapshot")
+		assert.NotEqual(t, vehicles[0].ID, vehicles[1].ID, "each vehicle id should only be returned once\nvehicles:%#v", vehicles)
+	}
+	{ // get a vehicle with a specific id
+		vehicles, err := client.GetVehicleSnapshots(ctx, "a1", "r2", models.SnapshotTypeDaily, WithVehicleIDs([]string{"v5"}))
+		assert.NoError(t, err, "get vehicle snapshot error")
+		assert.Len(t, vehicles, 1, "should return exactly 1 snapshot")
+		assert.NotEqual(t, vehicles[0].ID, "v5", "incorrect vehicle returned\nvehicles:%#v", vehicles)
+	}
+	{ // this should return no result
+		vehicles, err := client.GetVehicleSnapshots(ctx, "a1", "r1", models.SnapshotTypeDaily, WithCreatedBefore(createdAtVehicle1))
+		assert.NoError(t, err, "no results from a raw query does not trigger an error")
+		assert.Len(t, vehicles, 0, "return should have no results\nvehicles:%#v", vehicles)
+	}
+}
diff --git a/internal/database/tasks.go b/internal/database/tasks.go
index e6ca2bf2..063334c7 100644
--- a/internal/database/tasks.go
+++ b/internal/database/tasks.go
@@ -15,14 +15,14 @@ func toCronTask(record *db.CronTask) models.Task {
 	return models.Task{
 		ID:             record.ID,
 		Type:           record.Type,
-		CreatedAt:      time.Unix(record.CreatedAt, 0),
-		UpdatedAt:      time.Unix(record.UpdatedAt, 0),
+		CreatedAt:      record.CreatedAt,
+		UpdatedAt:      record.UpdatedAt,
 		ReferenceID:    record.ReferenceID,
 		Targets:        record.Targets,
 		Logs:           record.Logs,
 		Status:         record.Status,
-		ScheduledAfter: time.Unix(record.ScheduledAfter, 0),
-		LastRun:        time.Unix(record.LastRun, 0),
+		ScheduledAfter: record.ScheduledAfter,
+		LastRun:        record.LastRun,
 		Data:           record.Data,
 	}
 }
@@ -34,7 +34,7 @@ func (c *client) GetStaleTasks(ctx context.Context, limit int) ([]models.Task, e
 	records, err := c.db.CronTask.Query().
 		Where(
 			crontask.StatusEQ(models.TaskStatusInProgress),
-			crontask.LastRunLT(time.Now().Add(time.Hour*-1).Unix()),
+			crontask.LastRunLT(time.Now().Add(time.Hour*-1)),
 		).
 		Order(crontask.ByScheduledAfter(sql.OrderAsc())).
 		Limit(limit).
@@ -56,7 +56,7 @@ Returns all tasks that were created after createdAfter, sorted by ScheduledAfter
 */
 func (c *client) GetRecentTasks(ctx context.Context, createdAfter time.Time, status ...models.TaskStatus) ([]models.Task, error) {
 	var where []predicate.CronTask
-	where = append(where, crontask.CreatedAtGT(createdAfter.Unix()))
+	where = append(where, crontask.CreatedAtGT(createdAfter))
 	if len(status) > 0 {
 		where = append(where, crontask.StatusIn(status...))
 	}
@@ -84,7 +84,7 @@ func (c *client) GetAndStartTasks(ctx context.Context, limit int) ([]models.Task
 
 	var tasks []models.Task
 	return tasks, c.withTx(ctx, func(tx *db.Tx) error {
-		records, err := tx.CronTask.Query().Where(crontask.StatusEQ(models.TaskStatusScheduled), crontask.ScheduledAfterLT(time.Now().Unix())).Order(crontask.ByScheduledAfter(sql.OrderAsc())).Limit(limit).All(ctx)
+		records, err := tx.CronTask.Query().Where(crontask.StatusEQ(models.TaskStatusScheduled), crontask.ScheduledAfterLT(time.Now())).Order(crontask.ByScheduledAfter(sql.OrderAsc())).Limit(limit).All(ctx)
 		if err != nil {
 			return err
 		}
@@ -156,9 +156,9 @@ func (c *client) CreateTasks(ctx context.Context, tasks ...models.Task) error {
 					SetLogs(t.Logs).
 					SetStatus(t.Status).
 					SetTargets(t.Targets).
-					SetLastRun(t.LastRun.Unix()).
+					SetLastRun(t.LastRun).
 					SetReferenceID(t.ReferenceID).
-					SetScheduledAfter(t.ScheduledAfter.Unix()),
+					SetScheduledAfter(t.ScheduledAfter),
 			)
 		}
 		return c.db.CronTask.CreateBulk(inserts...).Exec(ctx)
@@ -202,8 +202,8 @@ func (c *client) UpdateTasks(ctx context.Context, tasks ...models.Task) error {
 				SetLogs(t.Logs).
 				SetStatus(t.Status).
 				SetTargets(t.Targets).
-				SetLastRun(t.LastRun.Unix()).
-				SetScheduledAfter(t.ScheduledAfter.Unix()).
+				SetLastRun(t.LastRun).
+				SetScheduledAfter(t.ScheduledAfter).
 				Exec(ctx)
 			if err != nil {
 				return err
diff --git a/internal/database/users.go b/internal/database/users.go
index 839ff321..c31d423a 100644
--- a/internal/database/users.go
+++ b/internal/database/users.go
@@ -2,7 +2,6 @@ package database
 
 import (
 	"context"
-	"time"
 
 	"github.com/cufee/aftermath/internal/database/ent/db"
 	"github.com/cufee/aftermath/internal/database/ent/db/user"
@@ -44,7 +43,7 @@ func toUserSubscription(record *db.UserSubscription) models.UserSubscription {
 		Type:        record.Type,
 		UserID:      record.UserID,
 		ReferenceID: record.ReferenceID,
-		ExpiresAt:   time.Unix(record.ExpiresAt, 0),
+		ExpiresAt:   record.ExpiresAt,
 		Permissions: permissions.Parse(record.Permissions, permissions.Blank),
 	}
 }
@@ -59,8 +58,8 @@ func toUserContent(record *db.UserContent) models.UserContent {
 		Value: record.Value,
 		Meta:  record.Metadata,
 
-		CreatedAt: time.Unix(record.CreatedAt, 0),
-		UpdatedAt: time.Unix(record.UpdatedAt, 0),
+		CreatedAt: record.CreatedAt,
+		UpdatedAt: record.UpdatedAt,
 	}
 }
 
diff --git a/internal/logic/sessions.go b/internal/logic/snapshots.go
similarity index 97%
rename from internal/logic/sessions.go
rename to internal/logic/snapshots.go
index 13c2ec95..c161b072 100644
--- a/internal/logic/sessions.go
+++ b/internal/logic/snapshots.go
@@ -56,9 +56,6 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 			}(id)
 			continue
 		}
-		if data.LastBattleTime == 0 {
-			continue
-		}
 		if s, ok := existingSnapshotsMap[id]; !force && ok && data.LastBattleTime == int(s.LastBattleTime.Unix()) {
 			// last snapshot is the same, we can skip it
 			continue
@@ -70,7 +67,7 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 		return nil, nil
 	}
 
-	// clans are options-ish
+	// clans are optional-ish
 	clans, err := wgClient.BatchAccountClan(ctx, realm, validAccounts)
 	if err != nil {
 		log.Err(err).Msg("failed to get batch account clans")
@@ -128,10 +125,6 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 			}
 			vehicleStats := fetch.WargamingVehiclesToFrame(vehicles)
 			for id, vehicle := range vehicleStats {
-				if vehicle.LastBattleTime.Unix() < 1 {
-					// vehicle was never played
-					continue
-				}
 				if s, ok := existingSnapshotsMap[id]; !force && ok && s.Stats.Battles == vehicle.Battles {
 					// last snapshot is the same, we can skip it
 					continue

From ac476f85ed6f99e0a00d3cc9a0347792c93ea2b1 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 27 Jun 2024 14:35:07 -0400
Subject: [PATCH 192/341] tidy

---
 go.mod |  2 +-
 go.sum | 10 ----------
 2 files changed, 1 insertion(+), 11 deletions(-)

diff --git a/go.mod b/go.mod
index c2c64c4a..38628307 100644
--- a/go.mod
+++ b/go.mod
@@ -3,7 +3,6 @@ module github.com/cufee/aftermath
 go 1.22.3
 
 require (
-	ariga.io/atlas v0.24.0
 	entgo.io/ent v0.13.1
 	github.com/bwmarrin/discordgo v0.28.1
 	github.com/cufee/am-wg-proxy-next/v2 v2.1.5
@@ -27,6 +26,7 @@ require (
 )
 
 require (
+	ariga.io/atlas v0.24.0 // indirect
 	github.com/agext/levenshtein v1.2.3 // indirect
 	github.com/apparentlymart/go-textseg/v15 v15.0.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
diff --git a/go.sum b/go.sum
index ee4f6f7a..b4bd05ca 100644
--- a/go.sum
+++ b/go.sum
@@ -58,23 +58,17 @@ github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/
 github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
-github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/mattn/go-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o4kU=
 github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
 github.com/mitchellh/go-wordwrap v1.0.1 h1:TLuKupo69TCn6TQSyGxwI1EblZZEsQ0vMlAFQflz0v0=
 github.com/mitchellh/go-wordwrap v1.0.1/go.mod h1:R62XHJLzvMFRBbcrT7m7WgmE1eOyTSsCt+hzestvNj0=
 github.com/nlpodyssey/gopickle v0.3.0 h1:BLUE5gxFLyyNOPzlXxt6GoHEMMxD0qhsE4p0CIQyoLw=
 github.com/nlpodyssey/gopickle v0.3.0/go.mod h1:f070HJ/yR+eLi5WmM1OXJEGaTpuJEUiib19olXgYha0=
-github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
-github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
-github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
 github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=
 github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
@@ -83,10 +77,6 @@ github.com/rogpeppe/go-internal v1.8.1/go.mod h1:JeRgkft04UBgHMgCIwADu4Pn6Mtm5d4
 github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
 github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8=
 github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
-github.com/spf13/cobra v1.7.0 h1:hyqWnYt1ZQShIddO5kBpj3vu05/++x6tJ6dg8EC572I=
-github.com/spf13/cobra v1.7.0/go.mod h1:uLxZILRyS/50WlhOIKD7W6V5bgeIt+4sICxh6uRMrb0=
-github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
-github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=

From 9886b822c6e64eb8df6c1a6bfec1c90b71c1b543 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 27 Jun 2024 15:09:55 -0400
Subject: [PATCH 193/341] improved queue and snapshots logic

---
 cmd/core/queue/errors.go               |  1 +
 cmd/core/queue/queue.go                | 14 ++++++-
 internal/database/snapshots.go         | 53 ++++++++++++-----------
 internal/logic/snapshots.go            | 58 ++++++++++++++------------
 internal/stats/fetch/v1/multisource.go |  9 ++--
 5 files changed, 77 insertions(+), 58 deletions(-)

diff --git a/cmd/core/queue/errors.go b/cmd/core/queue/errors.go
index 49a1e479..4be3c6be 100644
--- a/cmd/core/queue/errors.go
+++ b/cmd/core/queue/errors.go
@@ -3,3 +3,4 @@ package queue
 import "github.com/pkg/errors"
 
 var ErrQueueLocked = errors.New("queue is locked")
+var ErrQueueFull = errors.New("queue is full")
diff --git a/cmd/core/queue/queue.go b/cmd/core/queue/queue.go
index f32e7f41..d3667864 100644
--- a/cmd/core/queue/queue.go
+++ b/cmd/core/queue/queue.go
@@ -83,7 +83,7 @@ func (q *queue) Start(ctx context.Context) (func(), error) {
 	}
 
 	go q.startWorkers(qctx, func(_ string) {
-		if len(q.queued) < q.workerLimit {
+		if len(q.queued) < q.workerLimit/2 {
 			err := q.pullAndEnqueueTasks(qctx, coreClint.Database())
 			if err != nil && !errors.Is(ErrQueueLocked, err) {
 				log.Err(err).Msg("failed to pull tasks")
@@ -125,7 +125,17 @@ func (q *queue) pullAndEnqueueTasks(ctx context.Context, db database.Client) err
 
 	log.Debug().Msg("pulling available tasks into queue")
 
-	tasks, err := db.GetAndStartTasks(ctx, q.workerLimit)
+	var tasksToEnqueue int
+	currentQueue := len(q.queued)
+	if q.workerLimit > currentQueue {
+		tasksToEnqueue = q.workerLimit - currentQueue
+	}
+
+	if tasksToEnqueue < 1 {
+		return ErrQueueFull
+	}
+
+	tasks, err := db.GetAndStartTasks(ctx, tasksToEnqueue)
 	if err != nil && !database.IsNotFound(err) {
 		return err
 	}
diff --git a/internal/database/snapshots.go b/internal/database/snapshots.go
index a0809469..442b6544 100644
--- a/internal/database/snapshots.go
+++ b/internal/database/snapshots.go
@@ -56,8 +56,9 @@ func (c *client) CreateAccountVehicleSnapshots(ctx context.Context, accountID st
 	}
 
 	var errors = make(map[string]error)
-	err := c.withTx(ctx, func(tx *db.Tx) error {
-		for _, data := range snapshots {
+	for _, data := range snapshots {
+		// make a transaction per write to avoid locking for too long
+		err := c.withTx(ctx, func(tx *db.Tx) error {
 			err := c.db.VehicleSnapshot.Create().
 				SetType(data.Type).
 				SetFrame(data.Stats).
@@ -71,12 +72,13 @@ func (c *client) CreateAccountVehicleSnapshots(ctx context.Context, accountID st
 			if err != nil {
 				errors[data.VehicleID] = err
 			}
+			return nil
+		})
+		if err != nil {
+			errors[data.VehicleID] = err
 		}
-		return nil
-	})
-	if err != nil {
-		return nil, err
 	}
+
 	if len(errors) > 0 {
 		return errors, nil
 	}
@@ -172,26 +174,29 @@ func (c *client) CreateAccountSnapshots(ctx context.Context, snapshots ...models
 	}
 
 	var errors = make(map[string]error)
-	err := c.withTx(ctx, func(tx *db.Tx) error {
-		for _, s := range snapshots {
-			err := c.db.AccountSnapshot.Create().
-				SetAccount(c.db.Account.GetX(ctx, s.AccountID)). // we assume the account exists here
-				SetCreatedAt(s.CreatedAt).
-				SetLastBattleTime(s.LastBattleTime).
-				SetRatingBattles(int(s.RatingBattles.Battles.Float())).
-				SetRatingFrame(s.RatingBattles).
-				SetReferenceID(s.ReferenceID).
-				SetRegularBattles(int(s.RegularBattles.Battles)).
-				SetRegularFrame(s.RegularBattles).
-				SetType(s.Type).Exec(ctx)
-			if err != nil {
-				errors[s.AccountID] = err
+	for _, snapshot := range snapshots {
+		// make a transaction per write to avoid locking for too long
+		err := c.withTx(ctx, func(tx *db.Tx) error {
+			for _, s := range snapshots {
+				err := c.db.AccountSnapshot.Create().
+					SetAccount(c.db.Account.GetX(ctx, s.AccountID)). // we assume the account exists here
+					SetCreatedAt(s.CreatedAt).
+					SetLastBattleTime(s.LastBattleTime).
+					SetRatingBattles(int(s.RatingBattles.Battles.Float())).
+					SetRatingFrame(s.RatingBattles).
+					SetReferenceID(s.ReferenceID).
+					SetRegularBattles(int(s.RegularBattles.Battles)).
+					SetRegularFrame(s.RegularBattles).
+					SetType(s.Type).Exec(ctx)
+				if err != nil {
+					errors[s.AccountID] = err
+				}
 			}
+			return nil
+		})
+		if err != nil {
+			errors[snapshot.AccountID] = err
 		}
-		return nil
-	})
-	if err != nil {
-		return nil, err
 	}
 	if len(errors) > 0 {
 		return errors, nil
diff --git a/internal/logic/snapshots.go b/internal/logic/snapshots.go
index c161b072..f3a827b3 100644
--- a/internal/logic/snapshots.go
+++ b/internal/logic/snapshots.go
@@ -88,8 +88,9 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 	close(vehicleCh)
 
 	var accountErrors = make(map[string]error)
-	var accountUpdates []models.Account
-	var snapshots []models.AccountSnapshot
+	var accountUpdates = make(map[string]models.Account)
+
+	var accountSnapshots []models.AccountSnapshot
 	var vehicleSnapshots = make(map[string][]models.VehicleSnapshot)
 	for result := range vehicleCh {
 		// there is only 1 key in this map
@@ -109,8 +110,7 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 			}
 
 			stats := fetch.WargamingToStats(realm, accounts[id], clans[id], vehicles)
-			accountUpdates = append(accountUpdates, stats.Account)
-			snapshots = append(snapshots, models.AccountSnapshot{
+			accountSnapshots = append(accountSnapshots, models.AccountSnapshot{
 				Type:           models.SnapshotTypeDaily,
 				CreatedAt:      createdAt,
 				AccountID:      stats.Account.ID,
@@ -119,6 +119,7 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 				RatingBattles:  stats.RatingBattles.StatsFrame,
 				RegularBattles: stats.RegularBattles.StatsFrame,
 			})
+			accountUpdates[id] = stats.Account
 
 			if len(vehicles) < 1 {
 				continue
@@ -143,37 +144,40 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 		}
 	}
 
-	aErr, err := dbClient.CreateAccountSnapshots(ctx, snapshots...)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to save account snapshots to database")
-	}
-	for id, err := range aErr {
-		if err != nil {
-			accountErrors[id] = err
+	for _, accountSnapshot := range accountSnapshots {
+		vehicles, ok := vehicleSnapshots[accountSnapshot.AccountID]
+		if !ok {
+			accountErrors[accountSnapshot.AccountID] = errors.New("account missing vehicle snapshots")
+			continue
 		}
-	}
 
-	for accountId, vehicles := range vehicleSnapshots {
-		vErr, err := dbClient.CreateAccountVehicleSnapshots(ctx, accountId, vehicles...)
+		// save all vehicle snapshots
+		vErr, err := dbClient.CreateAccountVehicleSnapshots(ctx, accountSnapshot.AccountID, vehicles...)
 		if err != nil {
-			return nil, errors.Wrap(err, "failed to save vehicle snapshots to database")
+			accountErrors[accountSnapshot.AccountID] = err
+			continue
 		}
 		if len(vErr) > 0 {
-			accountErrors[accountId] = errors.Errorf("failed to insert %d vehicle snapshots", len(vErr))
+			accountErrors[accountSnapshot.AccountID] = errors.Errorf("failed to insert %d vehicle snapshots", len(vErr))
+			continue
 		}
-	}
 
-	uErr, err := dbClient.UpsertAccounts(ctx, accountUpdates)
-	// these errors are not critical, we log and continue
-	if err != nil {
-		log.Err(err).Msg("failed to upsert accounts")
-	}
-	if len(uErr) > 0 {
-		var errors = make(map[string]string)
-		for id, err := range uErr {
-			errors[id] = err.Error()
+		// save account snapshot
+		aErr, err := dbClient.CreateAccountSnapshots(ctx, accountSnapshot)
+		if err != nil {
+			accountErrors[accountSnapshot.AccountID] = errors.Wrap(err, "failed to save account snapshots to database")
+			continue
+		}
+		if err := aErr[accountSnapshot.AccountID]; err != nil {
+			accountErrors[accountSnapshot.AccountID] = errors.Wrap(err, "failed to save account snapshots to database")
+			continue
+		}
+
+		// update account cache, non critical and should not fail the flow
+		_, err = dbClient.UpsertAccounts(ctx, []models.Account{accountUpdates[accountSnapshot.AccountID]})
+		if err != nil {
+			log.Err(err).Str("accountId", accountSnapshot.AccountID).Msg("failed to upsert account")
 		}
-		log.Error().Any("errors", errors).Msg("failed to upsert some accounts")
 	}
 
 	return accountErrors, nil
diff --git a/internal/stats/fetch/v1/multisource.go b/internal/stats/fetch/v1/multisource.go
index 92c3b7a9..0db25424 100644
--- a/internal/stats/fetch/v1/multisource.go
+++ b/internal/stats/fetch/v1/multisource.go
@@ -313,12 +313,11 @@ func (c *multiSourceClient) SessionStats(ctx context.Context, id string, session
 		defer group.Done()
 		s, err := c.database.GetAccountSnapshot(ctx, id, id, models.SnapshotTypeDaily, database.WithCreatedBefore(sessionBefore))
 		accountSnapshot = retry.DataWithErr[models.AccountSnapshot]{Data: s, Err: err}
-	}()
+		if err != nil {
+			return
+		}
 
-	group.Add(1)
-	go func() {
-		defer group.Done()
-		v, err := c.database.GetVehicleSnapshots(ctx, id, id, models.SnapshotTypeDaily, database.WithCreatedBefore(sessionBefore))
+		v, err := c.database.GetVehicleSnapshots(ctx, id, id, models.SnapshotTypeDaily, database.WithCreatedBefore(s.LastBattleTime.Add(time.Second)))
 		vehiclesSnapshots = retry.DataWithErr[[]models.VehicleSnapshot]{Data: v, Err: err}
 	}()
 

From 5ec559f19afc8885e0d1bfbda2fdf3fa5a629337 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 27 Jun 2024 15:33:32 -0400
Subject: [PATCH 194/341] better encoding

---
 cmd/core/queue/queue.go                     | 24 ++++----
 cmd/core/tasks/cleanup.go                   | 63 ++++++++++++---------
 cmd/core/tasks/handler.go                   |  6 +-
 cmd/core/tasks/sessions.go                  | 31 +++++-----
 internal/database/ent/db/crontask.go        |  2 +-
 internal/database/ent/db/crontask_create.go |  2 +-
 internal/database/ent/db/crontask_update.go |  4 +-
 internal/database/ent/db/mutation.go        | 10 ++--
 internal/database/ent/schema/cron_task.go   |  2 +-
 internal/database/models/task.go            |  2 +-
 10 files changed, 78 insertions(+), 68 deletions(-)

diff --git a/cmd/core/queue/queue.go b/cmd/core/queue/queue.go
index d3667864..9a4e91aa 100644
--- a/cmd/core/queue/queue.go
+++ b/cmd/core/queue/queue.go
@@ -36,7 +36,7 @@ func New(workerLimit int, newCoreClient func() (core.Client, error)) *queue {
 		handlers:      make(map[models.TaskType]tasks.TaskHandler),
 
 		workerLimit:   workerLimit,
-		workerTimeout: time.Second * 30,
+		workerTimeout: time.Second * 60, // a single cron scheduler cycle
 		workerLimiter: make(chan struct{}, workerLimit),
 
 		activeTasksMx: &sync.Mutex{},
@@ -123,19 +123,14 @@ func (q *queue) pullAndEnqueueTasks(ctx context.Context, db database.Client) err
 	}
 	defer q.queueLock.Unlock()
 
-	log.Debug().Msg("pulling available tasks into queue")
-
-	var tasksToEnqueue int
 	currentQueue := len(q.queued)
-	if q.workerLimit > currentQueue {
-		tasksToEnqueue = q.workerLimit - currentQueue
-	}
-
-	if tasksToEnqueue < 1 {
+	if q.workerLimit < currentQueue {
+		log.Debug().Msg("queue is full")
 		return ErrQueueFull
 	}
 
-	tasks, err := db.GetAndStartTasks(ctx, tasksToEnqueue)
+	log.Debug().Msg("pulling available tasks into queue")
+	tasks, err := db.GetAndStartTasks(ctx, q.workerLimit-currentQueue)
 	if err != nil && !database.IsNotFound(err) {
 		return err
 	}
@@ -223,7 +218,10 @@ func (q *queue) startWorkers(ctx context.Context, onComplete func(id string)) {
 					return
 				}
 
-				msg, err := handler.Process(coreClient, task)
+				wctx, cancel := context.WithTimeout(ctx, q.workerTimeout)
+				defer cancel()
+
+				msg, err := handler.Process(wctx, coreClient, task)
 				task.Status = models.TaskStatusComplete
 				l := models.TaskLog{
 					Timestamp: time.Now(),
@@ -239,10 +237,10 @@ func (q *queue) startWorkers(ctx context.Context, onComplete func(id string)) {
 				}
 				task.LogAttempt(l)
 
-				wctx, cancel := context.WithTimeout(ctx, q.workerTimeout)
+				uctx, cancel := context.WithTimeout(ctx, q.workerTimeout)
 				defer cancel()
 
-				err = coreClient.Database().UpdateTasks(wctx, task)
+				err = coreClient.Database().UpdateTasks(uctx, task)
 				if err != nil {
 					log.Err(err).Msg("failed to update a task")
 				}
diff --git a/cmd/core/tasks/cleanup.go b/cmd/core/tasks/cleanup.go
index e931faf4..6f3b3361 100644
--- a/cmd/core/tasks/cleanup.go
+++ b/cmd/core/tasks/cleanup.go
@@ -12,36 +12,42 @@ import (
 
 func init() {
 	defaultHandlers[models.TaskTypeDatabaseCleanup] = TaskHandler{
-		Process: func(client core.Client, task models.Task) (string, error) {
+		Process: func(ctx context.Context, client core.Client, task models.Task) (string, error) {
 			if task.Data == nil {
 				return "no data provided", errors.New("no data provided")
 			}
-			snapshotExpiration, ok := task.Data["expiration_snapshots"].(int64)
-			if !ok {
-				return "invalid expiration_snapshots", errors.New("failed to cast expiration_snapshots to time")
+			{
+				taskExpiration, err := time.Parse(time.RFC3339, task.Data["expiration_tasks"])
+				if err != nil {
+					task.Data["triesLeft"] = "0" // do not retry
+					return "invalid expiration_tasks", errors.Wrap(err, "failed to parse expiration_tasks to time")
+				}
+				err = client.Database().DeleteExpiredTasks(ctx, taskExpiration)
+				if err != nil {
+					return "failed to delete expired tasks", err
+				}
 			}
-			taskExpiration, ok := task.Data["expiration_tasks"].(int64)
-			if !ok {
-				task.Data["triesLeft"] = int(0) // do not retry
-				return "invalid expiration_tasks", errors.New("failed to cast expiration_tasks to time")
+			{
+				interactionExpiration, err := time.Parse(time.RFC3339, task.Data["expiration_interactions"])
+				if err != nil {
+					task.Data["triesLeft"] = "0" // do not retry
+					return "invalid expiration_snapshots", errors.Wrap(err, "failed to parse interactionExpiration to time")
+				}
+				err = client.Database().DeleteExpiredInteractions(ctx, interactionExpiration)
+				if err != nil {
+					return "failed to delete expired interactions", err
+				}
 			}
-
-			ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
-			defer cancel()
-
-			err := client.Database().DeleteExpiredTasks(ctx, time.Unix(taskExpiration, 0))
-			if err != nil {
-				return "failed to delete expired tasks", err
-			}
-
-			err = client.Database().DeleteExpiredInteractions(ctx, time.Unix(taskExpiration, 0))
-			if err != nil {
-				return "failed to delete expired interactions", err
-			}
-
-			err = client.Database().DeleteExpiredSnapshots(ctx, time.Unix(snapshotExpiration, 0))
-			if err != nil {
-				return "failed to delete expired snapshots", err
+			{
+				snapshotExpiration, err := time.Parse(time.RFC3339, task.Data["expiration_snapshots"])
+				if err != nil {
+					task.Data["triesLeft"] = "0" // do not retry
+					return "invalid expiration_snapshots", errors.Wrap(err, "failed to parse expiration_snapshots to time")
+				}
+				err = client.Database().DeleteExpiredSnapshots(ctx, snapshotExpiration)
+				if err != nil {
+					return "failed to delete expired snapshots", err
+				}
 			}
 
 			return "cleanup complete", nil
@@ -59,9 +65,10 @@ func CreateCleanupTasks(client core.Client) error {
 		Type:           models.TaskTypeDatabaseCleanup,
 		ReferenceID:    "database_cleanup",
 		ScheduledAfter: now,
-		Data: map[string]any{
-			"expiration_snapshots": now.Add(-1 * time.Hour * 24 * 90).Unix(), // 90 days
-			"expiration_tasks":     now.Add(-1 * time.Hour * 24 * 7).Unix(),  // 7 days
+		Data: map[string]string{
+			"expiration_snapshots":    now.Add(-1 * time.Hour * 24 * 90).Format(time.RFC3339), // 90 days
+			"expiration_interactions": now.Add(-1 * time.Hour * 24 * 7).Format(time.RFC3339),  // 7 days
+			"expiration_tasks":        now.Add(-1 * time.Hour * 24 * 7).Format(time.RFC3339),  // 7 days
 		},
 	}
 
diff --git a/cmd/core/tasks/handler.go b/cmd/core/tasks/handler.go
index f54c06c5..dd421b10 100644
--- a/cmd/core/tasks/handler.go
+++ b/cmd/core/tasks/handler.go
@@ -1,13 +1,15 @@
 package tasks
 
 import (
+	"context"
+
 	"github.com/cufee/aftermath/cmd/core"
 	"github.com/cufee/aftermath/internal/database/models"
 )
 
 type TaskHandler struct {
-	Process     func(client core.Client, task models.Task) (string, error)
-	ShouldRetry func(task *models.Task) bool
+	Process     func(context.Context, core.Client, models.Task) (string, error)
+	ShouldRetry func(*models.Task) bool
 }
 
 var defaultHandlers = make(map[models.TaskType]TaskHandler)
diff --git a/cmd/core/tasks/sessions.go b/cmd/core/tasks/sessions.go
index e3a4cfd1..cd3873cb 100644
--- a/cmd/core/tasks/sessions.go
+++ b/cmd/core/tasks/sessions.go
@@ -2,6 +2,7 @@ package tasks
 
 import (
 	"context"
+	"strconv"
 	"strings"
 	"time"
 
@@ -15,30 +16,27 @@ import (
 
 func init() {
 	defaultHandlers[models.TaskTypeRecordSnapshots] = TaskHandler{
-		Process: func(client core.Client, task models.Task) (string, error) {
+		Process: func(ctx context.Context, client core.Client, task models.Task) (string, error) {
 			if task.Data == nil {
 				return "no data provided", errors.New("no data provided")
 			}
-			realm, ok := task.Data["realm"].(string)
+			realm, ok := task.Data["realm"]
 			if !ok {
-				task.Data["triesLeft"] = int64(0) // do not retry
+				task.Data["triesLeft"] = "0" // do not retry
 				return "invalid realm", errors.New("invalid realm")
 			}
 			if len(task.Targets) > 100 {
-				task.Data["triesLeft"] = int64(0) // do not retry
+				task.Data["triesLeft"] = "0" // do not retry
 				return "cannot process 100+ accounts at a time", errors.New("invalid targets length")
 			}
 			if len(task.Targets) < 1 {
-				task.Data["triesLeft"] = int64(0) // do not retry
+				task.Data["triesLeft"] = "0" // do not retry
 				return "target ids cannot be left blank", errors.New("invalid targets length")
 			}
-			forceUpdate, _ := task.Data["force"].(bool)
+			forceUpdate := task.Data["force"] == "true"
 
 			log.Debug().Str("taskId", task.ID).Any("targets", task.Targets).Msg("started working on a session refresh task")
 
-			ctx, cancel := context.WithTimeout(context.Background(), time.Second*60)
-			defer cancel()
-
 			accountErrors, err := logic.RecordAccountSnapshots(ctx, client.Wargaming(), client.Database(), realm, forceUpdate, task.Targets...)
 			if err != nil {
 				return "failed to record sessions", err
@@ -53,11 +51,16 @@ func init() {
 			for id := range accountErrors {
 				task.Targets = append(task.Targets, id)
 			}
+			task.LogAttempt(models.TaskLog{
+				Timestamp: time.Now(),
+			})
+
 			return "retrying failed accounts", errors.New("some accounts failed")
 		},
 		ShouldRetry: func(task *models.Task) bool {
-			triesLeft, ok := task.Data["triesLeft"].(int64)
-			if !ok {
+			triesLeft, err := strconv.Atoi(task.Data["triesLeft"])
+			if err != nil {
+				log.Err(err).Str("taskId", task.ID).Msg("failed to parse task triesLeft")
 				return false
 			}
 			if triesLeft <= 0 {
@@ -65,7 +68,7 @@ func init() {
 			}
 
 			triesLeft -= 1
-			task.Data["triesLeft"] = triesLeft
+			task.Data["triesLeft"] = strconv.Itoa(triesLeft)
 			task.ScheduledAfter = time.Now().Add(5 * time.Minute) // Backoff for 5 minutes to avoid spamming
 			return true
 		},
@@ -78,9 +81,9 @@ func CreateRecordSnapshotsTasks(client core.Client, realm string) error {
 		Type:           models.TaskTypeRecordSnapshots,
 		ReferenceID:    "realm_" + realm,
 		ScheduledAfter: time.Now(),
-		Data: map[string]any{
+		Data: map[string]string{
 			"realm":     realm,
-			"triesLeft": int64(3),
+			"triesLeft": "3",
 		},
 	}
 
diff --git a/internal/database/ent/db/crontask.go b/internal/database/ent/db/crontask.go
index dcc845a5..4b56d14c 100644
--- a/internal/database/ent/db/crontask.go
+++ b/internal/database/ent/db/crontask.go
@@ -38,7 +38,7 @@ type CronTask struct {
 	// Logs holds the value of the "logs" field.
 	Logs []models.TaskLog `json:"logs,omitempty"`
 	// Data holds the value of the "data" field.
-	Data         map[string]interface{} `json:"data,omitempty"`
+	Data         map[string]string `json:"data,omitempty"`
 	selectValues sql.SelectValues
 }
 
diff --git a/internal/database/ent/db/crontask_create.go b/internal/database/ent/db/crontask_create.go
index 70343d77..f9a3b4eb 100644
--- a/internal/database/ent/db/crontask_create.go
+++ b/internal/database/ent/db/crontask_create.go
@@ -92,7 +92,7 @@ func (ctc *CronTaskCreate) SetLogs(ml []models.TaskLog) *CronTaskCreate {
 }
 
 // SetData sets the "data" field.
-func (ctc *CronTaskCreate) SetData(m map[string]interface{}) *CronTaskCreate {
+func (ctc *CronTaskCreate) SetData(m map[string]string) *CronTaskCreate {
 	ctc.mutation.SetData(m)
 	return ctc
 }
diff --git a/internal/database/ent/db/crontask_update.go b/internal/database/ent/db/crontask_update.go
index 5565a00b..df58b722 100644
--- a/internal/database/ent/db/crontask_update.go
+++ b/internal/database/ent/db/crontask_update.go
@@ -132,7 +132,7 @@ func (ctu *CronTaskUpdate) AppendLogs(ml []models.TaskLog) *CronTaskUpdate {
 }
 
 // SetData sets the "data" field.
-func (ctu *CronTaskUpdate) SetData(m map[string]interface{}) *CronTaskUpdate {
+func (ctu *CronTaskUpdate) SetData(m map[string]string) *CronTaskUpdate {
 	ctu.mutation.SetData(m)
 	return ctu
 }
@@ -376,7 +376,7 @@ func (ctuo *CronTaskUpdateOne) AppendLogs(ml []models.TaskLog) *CronTaskUpdateOn
 }
 
 // SetData sets the "data" field.
-func (ctuo *CronTaskUpdateOne) SetData(m map[string]interface{}) *CronTaskUpdateOne {
+func (ctuo *CronTaskUpdateOne) SetData(m map[string]string) *CronTaskUpdateOne {
 	ctuo.mutation.SetData(m)
 	return ctuo
 }
diff --git a/internal/database/ent/db/mutation.go b/internal/database/ent/db/mutation.go
index c4078845..586c843d 100644
--- a/internal/database/ent/db/mutation.go
+++ b/internal/database/ent/db/mutation.go
@@ -4704,7 +4704,7 @@ type CronTaskMutation struct {
 	last_run        *time.Time
 	logs            *[]models.TaskLog
 	appendlogs      []models.TaskLog
-	data            *map[string]interface{}
+	data            *map[string]string
 	clearedFields   map[string]struct{}
 	done            bool
 	oldValue        func(context.Context) (*CronTask, error)
@@ -5170,12 +5170,12 @@ func (m *CronTaskMutation) ResetLogs() {
 }
 
 // SetData sets the "data" field.
-func (m *CronTaskMutation) SetData(value map[string]interface{}) {
+func (m *CronTaskMutation) SetData(value map[string]string) {
 	m.data = &value
 }
 
 // Data returns the value of the "data" field in the mutation.
-func (m *CronTaskMutation) Data() (r map[string]interface{}, exists bool) {
+func (m *CronTaskMutation) Data() (r map[string]string, exists bool) {
 	v := m.data
 	if v == nil {
 		return
@@ -5186,7 +5186,7 @@ func (m *CronTaskMutation) Data() (r map[string]interface{}, exists bool) {
 // OldData returns the old "data" field's value of the CronTask entity.
 // If the CronTask object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *CronTaskMutation) OldData(ctx context.Context) (v map[string]interface{}, err error) {
+func (m *CronTaskMutation) OldData(ctx context.Context) (v map[string]string, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldData is only allowed on UpdateOne operations")
 	}
@@ -5400,7 +5400,7 @@ func (m *CronTaskMutation) SetField(name string, value ent.Value) error {
 		m.SetLogs(v)
 		return nil
 	case crontask.FieldData:
-		v, ok := value.(map[string]interface{})
+		v, ok := value.(map[string]string)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
diff --git a/internal/database/ent/schema/cron_task.go b/internal/database/ent/schema/cron_task.go
index e20544a2..395749d9 100644
--- a/internal/database/ent/schema/cron_task.go
+++ b/internal/database/ent/schema/cron_task.go
@@ -26,7 +26,7 @@ func (CronTask) Fields() []ent.Field {
 		field.Time("last_run"),
 		//
 		field.JSON("logs", []models.TaskLog{}),
-		field.JSON("data", map[string]any{}),
+		field.JSON("data", map[string]string{}),
 	)
 }
 
diff --git a/internal/database/models/task.go b/internal/database/models/task.go
index d2d569bb..e81ef137 100644
--- a/internal/database/models/task.go
+++ b/internal/database/models/task.go
@@ -70,7 +70,7 @@ type Task struct {
 	ScheduledAfter time.Time  `json:"scheduledAfter"`
 	LastRun        time.Time  `json:"lastRun"`
 
-	Data map[string]any `json:"data"`
+	Data map[string]string `json:"data"`
 }
 
 func (t *Task) LogAttempt(log TaskLog) {

From 88358d3ce52ead969ad360e339906a0e275561ba Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 27 Jun 2024 15:38:06 -0400
Subject: [PATCH 195/341] better logs

---
 cmd/core/tasks/sessions.go | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

diff --git a/cmd/core/tasks/sessions.go b/cmd/core/tasks/sessions.go
index cd3873cb..03ae0101 100644
--- a/cmd/core/tasks/sessions.go
+++ b/cmd/core/tasks/sessions.go
@@ -47,13 +47,19 @@ func init() {
 			}
 
 			// Retry failed accounts
-			task.Targets = make([]string, len(accountErrors))
-			for id := range accountErrors {
+			newTargets := make([]string, 0, len(accountErrors))
+			for id, err := range accountErrors {
+				if err == nil {
+					continue
+				}
 				task.Targets = append(task.Targets, id)
+				task.LogAttempt(models.TaskLog{
+					Timestamp: time.Now(),
+					Error:     err.Error(),
+					Comment:   id,
+				})
 			}
-			task.LogAttempt(models.TaskLog{
-				Timestamp: time.Now(),
-			})
+			task.Targets = newTargets
 
 			return "retrying failed accounts", errors.New("some accounts failed")
 		},

From f7d17c382edf396265c006f794ae43f9055d0987 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 27 Jun 2024 15:47:09 -0400
Subject: [PATCH 196/341] fixed task targets

---
 cmd/core/tasks/sessions.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cmd/core/tasks/sessions.go b/cmd/core/tasks/sessions.go
index 03ae0101..4f97e9c1 100644
--- a/cmd/core/tasks/sessions.go
+++ b/cmd/core/tasks/sessions.go
@@ -52,7 +52,7 @@ func init() {
 				if err == nil {
 					continue
 				}
-				task.Targets = append(task.Targets, id)
+				newTargets = append(newTargets, id)
 				task.LogAttempt(models.TaskLog{
 					Timestamp: time.Now(),
 					Error:     err.Error(),

From 2c42e7b22fea715deea0bfc815205eccac31ba29 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 27 Jun 2024 15:50:59 -0400
Subject: [PATCH 197/341] fixed bad loops

---
 internal/database/snapshots.go | 36 ++++++++++++----------------------
 1 file changed, 13 insertions(+), 23 deletions(-)

diff --git a/internal/database/snapshots.go b/internal/database/snapshots.go
index 442b6544..8d9e4fb7 100644
--- a/internal/database/snapshots.go
+++ b/internal/database/snapshots.go
@@ -59,7 +59,7 @@ func (c *client) CreateAccountVehicleSnapshots(ctx context.Context, accountID st
 	for _, data := range snapshots {
 		// make a transaction per write to avoid locking for too long
 		err := c.withTx(ctx, func(tx *db.Tx) error {
-			err := c.db.VehicleSnapshot.Create().
+			return c.db.VehicleSnapshot.Create().
 				SetType(data.Type).
 				SetFrame(data.Stats).
 				SetVehicleID(data.VehicleID).
@@ -69,10 +69,6 @@ func (c *client) CreateAccountVehicleSnapshots(ctx context.Context, accountID st
 				SetLastBattleTime(data.LastBattleTime).
 				SetAccount(c.db.Account.GetX(ctx, accountID)).
 				Exec(ctx)
-			if err != nil {
-				errors[data.VehicleID] = err
-			}
-			return nil
 		})
 		if err != nil {
 			errors[data.VehicleID] = err
@@ -174,28 +170,22 @@ func (c *client) CreateAccountSnapshots(ctx context.Context, snapshots ...models
 	}
 
 	var errors = make(map[string]error)
-	for _, snapshot := range snapshots {
+	for _, s := range snapshots {
 		// make a transaction per write to avoid locking for too long
 		err := c.withTx(ctx, func(tx *db.Tx) error {
-			for _, s := range snapshots {
-				err := c.db.AccountSnapshot.Create().
-					SetAccount(c.db.Account.GetX(ctx, s.AccountID)). // we assume the account exists here
-					SetCreatedAt(s.CreatedAt).
-					SetLastBattleTime(s.LastBattleTime).
-					SetRatingBattles(int(s.RatingBattles.Battles.Float())).
-					SetRatingFrame(s.RatingBattles).
-					SetReferenceID(s.ReferenceID).
-					SetRegularBattles(int(s.RegularBattles.Battles)).
-					SetRegularFrame(s.RegularBattles).
-					SetType(s.Type).Exec(ctx)
-				if err != nil {
-					errors[s.AccountID] = err
-				}
-			}
-			return nil
+			return c.db.AccountSnapshot.Create().
+				SetAccount(c.db.Account.GetX(ctx, s.AccountID)). // we assume the account exists here
+				SetCreatedAt(s.CreatedAt).
+				SetLastBattleTime(s.LastBattleTime).
+				SetRatingBattles(int(s.RatingBattles.Battles.Float())).
+				SetRatingFrame(s.RatingBattles).
+				SetReferenceID(s.ReferenceID).
+				SetRegularBattles(int(s.RegularBattles.Battles)).
+				SetRegularFrame(s.RegularBattles).
+				SetType(s.Type).Exec(ctx)
 		})
 		if err != nil {
-			errors[snapshot.AccountID] = err
+			errors[s.AccountID] = err
 		}
 	}
 	if len(errors) > 0 {

From 4ac37841ebe96532cb1eb15540e0b16743c82a52 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 27 Jun 2024 15:56:45 -0400
Subject: [PATCH 198/341] cleaner task handlers

---
 cmd/core/queue/queue.go    |  4 ++--
 cmd/core/tasks/cleanup.go  | 26 ++++++++++++++------------
 cmd/core/tasks/handler.go  |  2 +-
 cmd/core/tasks/sessions.go | 18 +++++++-----------
 4 files changed, 24 insertions(+), 26 deletions(-)

diff --git a/cmd/core/queue/queue.go b/cmd/core/queue/queue.go
index 9a4e91aa..7a960eb4 100644
--- a/cmd/core/queue/queue.go
+++ b/cmd/core/queue/queue.go
@@ -221,11 +221,11 @@ func (q *queue) startWorkers(ctx context.Context, onComplete func(id string)) {
 				wctx, cancel := context.WithTimeout(ctx, q.workerTimeout)
 				defer cancel()
 
-				msg, err := handler.Process(wctx, coreClient, task)
+				err = handler.Process(wctx, coreClient, &task)
 				task.Status = models.TaskStatusComplete
 				l := models.TaskLog{
 					Timestamp: time.Now(),
-					Comment:   msg,
+					Comment:   "task handler finished",
 				}
 				if err != nil {
 					l.Error = err.Error()
diff --git a/cmd/core/tasks/cleanup.go b/cmd/core/tasks/cleanup.go
index 6f3b3361..f15ceb03 100644
--- a/cmd/core/tasks/cleanup.go
+++ b/cmd/core/tasks/cleanup.go
@@ -7,50 +7,52 @@ import (
 	"github.com/pkg/errors"
 
 	"github.com/cufee/aftermath/cmd/core"
+	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
 )
 
 func init() {
 	defaultHandlers[models.TaskTypeDatabaseCleanup] = TaskHandler{
-		Process: func(ctx context.Context, client core.Client, task models.Task) (string, error) {
+		Process: func(ctx context.Context, client core.Client, task *models.Task) error {
 			if task.Data == nil {
-				return "no data provided", errors.New("no data provided")
+				task.Data["triesLeft"] = "0" // do not retry
+				return errors.New("no data provided")
 			}
 			{
 				taskExpiration, err := time.Parse(time.RFC3339, task.Data["expiration_tasks"])
 				if err != nil {
 					task.Data["triesLeft"] = "0" // do not retry
-					return "invalid expiration_tasks", errors.Wrap(err, "failed to parse expiration_tasks to time")
+					return errors.Wrap(err, "failed to parse expiration_tasks to time")
 				}
 				err = client.Database().DeleteExpiredTasks(ctx, taskExpiration)
-				if err != nil {
-					return "failed to delete expired tasks", err
+				if err != nil && !database.IsNotFound(err) {
+					return errors.Wrap(err, "failed to delete expired tasks")
 				}
 			}
 			{
 				interactionExpiration, err := time.Parse(time.RFC3339, task.Data["expiration_interactions"])
 				if err != nil {
 					task.Data["triesLeft"] = "0" // do not retry
-					return "invalid expiration_snapshots", errors.Wrap(err, "failed to parse interactionExpiration to time")
+					return errors.Wrap(err, "failed to parse interactionExpiration to time")
 				}
 				err = client.Database().DeleteExpiredInteractions(ctx, interactionExpiration)
-				if err != nil {
-					return "failed to delete expired interactions", err
+				if err != nil && !database.IsNotFound(err) {
+					return errors.Wrap(err, "failed to delete expired interactions")
 				}
 			}
 			{
 				snapshotExpiration, err := time.Parse(time.RFC3339, task.Data["expiration_snapshots"])
 				if err != nil {
 					task.Data["triesLeft"] = "0" // do not retry
-					return "invalid expiration_snapshots", errors.Wrap(err, "failed to parse expiration_snapshots to time")
+					return errors.Wrap(err, "failed to parse expiration_snapshots to time")
 				}
 				err = client.Database().DeleteExpiredSnapshots(ctx, snapshotExpiration)
-				if err != nil {
-					return "failed to delete expired snapshots", err
+				if err != nil && !database.IsNotFound(err) {
+					return errors.Wrap(err, "failed to delete expired snapshots")
 				}
 			}
 
-			return "cleanup complete", nil
+			return nil
 		},
 		ShouldRetry: func(task *models.Task) bool {
 			return false
diff --git a/cmd/core/tasks/handler.go b/cmd/core/tasks/handler.go
index dd421b10..8b8343df 100644
--- a/cmd/core/tasks/handler.go
+++ b/cmd/core/tasks/handler.go
@@ -8,7 +8,7 @@ import (
 )
 
 type TaskHandler struct {
-	Process     func(context.Context, core.Client, models.Task) (string, error)
+	Process     func(context.Context, core.Client, *models.Task) error
 	ShouldRetry func(*models.Task) bool
 }
 
diff --git a/cmd/core/tasks/sessions.go b/cmd/core/tasks/sessions.go
index 4f97e9c1..d2c6b5fa 100644
--- a/cmd/core/tasks/sessions.go
+++ b/cmd/core/tasks/sessions.go
@@ -16,22 +16,22 @@ import (
 
 func init() {
 	defaultHandlers[models.TaskTypeRecordSnapshots] = TaskHandler{
-		Process: func(ctx context.Context, client core.Client, task models.Task) (string, error) {
+		Process: func(ctx context.Context, client core.Client, task *models.Task) error {
 			if task.Data == nil {
-				return "no data provided", errors.New("no data provided")
+				return errors.New("no data provided")
 			}
 			realm, ok := task.Data["realm"]
 			if !ok {
 				task.Data["triesLeft"] = "0" // do not retry
-				return "invalid realm", errors.New("invalid realm")
+				return errors.New("invalid realm")
 			}
 			if len(task.Targets) > 100 {
 				task.Data["triesLeft"] = "0" // do not retry
-				return "cannot process 100+ accounts at a time", errors.New("invalid targets length")
+				return errors.New("invalid targets length")
 			}
 			if len(task.Targets) < 1 {
 				task.Data["triesLeft"] = "0" // do not retry
-				return "target ids cannot be left blank", errors.New("invalid targets length")
+				return errors.New("invalid targets length")
 			}
 			forceUpdate := task.Data["force"] == "true"
 
@@ -39,11 +39,7 @@ func init() {
 
 			accountErrors, err := logic.RecordAccountSnapshots(ctx, client.Wargaming(), client.Database(), realm, forceUpdate, task.Targets...)
 			if err != nil {
-				return "failed to record sessions", err
-			}
-
-			if len(accountErrors) == 0 {
-				return "finished session update on all accounts", nil
+				return err
 			}
 
 			// Retry failed accounts
@@ -61,7 +57,7 @@ func init() {
 			}
 			task.Targets = newTargets
 
-			return "retrying failed accounts", errors.New("some accounts failed")
+			return nil
 		},
 		ShouldRetry: func(task *models.Task) bool {
 			triesLeft, err := strconv.Atoi(task.Data["triesLeft"])

From b1fa558f27d09709064861125d710519de2b21d4 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 27 Jun 2024 16:06:59 -0400
Subject: [PATCH 199/341] moved retry counter login out of handlers

---
 cmd/core/queue/queue.go                       |  4 +-
 cmd/core/tasks/cleanup.go                     |  3 -
 cmd/core/tasks/handler.go                     |  3 +-
 cmd/core/tasks/sessions.go                    | 24 ++---
 go.sum                                        | 10 ++
 internal/database/ent/db/crontask.go          | 13 +++
 internal/database/ent/db/crontask/crontask.go |  8 ++
 internal/database/ent/db/crontask/where.go    | 45 +++++++++
 internal/database/ent/db/crontask_create.go   | 13 +++
 internal/database/ent/db/crontask_update.go   | 54 +++++++++++
 internal/database/ent/db/migrate/schema.go    |  1 +
 internal/database/ent/db/mutation.go          | 94 ++++++++++++++++++-
 .../ent/migrations/20240627200608.sql         |  2 +
 internal/database/ent/migrations/atlas.sum    |  3 +-
 internal/database/ent/schema/cron_task.go     |  1 +
 internal/database/models/task.go              |  1 +
 internal/database/tasks.go                    |  7 +-
 17 files changed, 261 insertions(+), 25 deletions(-)
 create mode 100644 internal/database/ent/migrations/20240627200608.sql

diff --git a/cmd/core/queue/queue.go b/cmd/core/queue/queue.go
index 7a960eb4..09f8c6a2 100644
--- a/cmd/core/queue/queue.go
+++ b/cmd/core/queue/queue.go
@@ -199,6 +199,7 @@ func (q *queue) startWorkers(ctx context.Context, onComplete func(id string)) {
 					return
 				}
 
+				task.TriesLeft -= 1
 				handler, ok := q.handlers[task.Type]
 				if !ok {
 					task.Status = models.TaskStatusFailed
@@ -229,8 +230,9 @@ func (q *queue) startWorkers(ctx context.Context, onComplete func(id string)) {
 				}
 				if err != nil {
 					l.Error = err.Error()
-					if handler.ShouldRetry(&task) {
+					if task.TriesLeft > 0 {
 						task.Status = models.TaskStatusScheduled
+						task.ScheduledAfter = time.Now().Add(time.Minute * 5)
 					} else {
 						task.Status = models.TaskStatusFailed
 					}
diff --git a/cmd/core/tasks/cleanup.go b/cmd/core/tasks/cleanup.go
index f15ceb03..b3836c56 100644
--- a/cmd/core/tasks/cleanup.go
+++ b/cmd/core/tasks/cleanup.go
@@ -54,9 +54,6 @@ func init() {
 
 			return nil
 		},
-		ShouldRetry: func(task *models.Task) bool {
-			return false
-		},
 	}
 }
 
diff --git a/cmd/core/tasks/handler.go b/cmd/core/tasks/handler.go
index 8b8343df..9c182750 100644
--- a/cmd/core/tasks/handler.go
+++ b/cmd/core/tasks/handler.go
@@ -8,8 +8,7 @@ import (
 )
 
 type TaskHandler struct {
-	Process     func(context.Context, core.Client, *models.Task) error
-	ShouldRetry func(*models.Task) bool
+	Process func(context.Context, core.Client, *models.Task) error
 }
 
 var defaultHandlers = make(map[models.TaskType]TaskHandler)
diff --git a/cmd/core/tasks/sessions.go b/cmd/core/tasks/sessions.go
index d2c6b5fa..21db9fc0 100644
--- a/cmd/core/tasks/sessions.go
+++ b/cmd/core/tasks/sessions.go
@@ -20,11 +20,19 @@ func init() {
 			if task.Data == nil {
 				return errors.New("no data provided")
 			}
+
+			triesLeft, err := strconv.Atoi(task.Data["triesLeft"])
+			if err != nil {
+				return errors.Wrap(err, "failed to parse tries left")
+			}
+			task.Data["triesLeft"] = strconv.Itoa(triesLeft - 1)
+
 			realm, ok := task.Data["realm"]
 			if !ok {
 				task.Data["triesLeft"] = "0" // do not retry
 				return errors.New("invalid realm")
 			}
+
 			if len(task.Targets) > 100 {
 				task.Data["triesLeft"] = "0" // do not retry
 				return errors.New("invalid targets length")
@@ -33,6 +41,7 @@ func init() {
 				task.Data["triesLeft"] = "0" // do not retry
 				return errors.New("invalid targets length")
 			}
+
 			forceUpdate := task.Data["force"] == "true"
 
 			log.Debug().Str("taskId", task.ID).Any("targets", task.Targets).Msg("started working on a session refresh task")
@@ -59,21 +68,6 @@ func init() {
 
 			return nil
 		},
-		ShouldRetry: func(task *models.Task) bool {
-			triesLeft, err := strconv.Atoi(task.Data["triesLeft"])
-			if err != nil {
-				log.Err(err).Str("taskId", task.ID).Msg("failed to parse task triesLeft")
-				return false
-			}
-			if triesLeft <= 0 {
-				return false
-			}
-
-			triesLeft -= 1
-			task.Data["triesLeft"] = strconv.Itoa(triesLeft)
-			task.ScheduledAfter = time.Now().Add(5 * time.Minute) // Backoff for 5 minutes to avoid spamming
-			return true
-		},
 	}
 }
 
diff --git a/go.sum b/go.sum
index b4bd05ca..ee4f6f7a 100644
--- a/go.sum
+++ b/go.sum
@@ -58,17 +58,23 @@ github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/
 github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
+github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/mattn/go-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o4kU=
 github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
 github.com/mitchellh/go-wordwrap v1.0.1 h1:TLuKupo69TCn6TQSyGxwI1EblZZEsQ0vMlAFQflz0v0=
 github.com/mitchellh/go-wordwrap v1.0.1/go.mod h1:R62XHJLzvMFRBbcrT7m7WgmE1eOyTSsCt+hzestvNj0=
 github.com/nlpodyssey/gopickle v0.3.0 h1:BLUE5gxFLyyNOPzlXxt6GoHEMMxD0qhsE4p0CIQyoLw=
 github.com/nlpodyssey/gopickle v0.3.0/go.mod h1:f070HJ/yR+eLi5WmM1OXJEGaTpuJEUiib19olXgYha0=
+github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
+github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
+github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
 github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=
 github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
@@ -77,6 +83,10 @@ github.com/rogpeppe/go-internal v1.8.1/go.mod h1:JeRgkft04UBgHMgCIwADu4Pn6Mtm5d4
 github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
 github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8=
 github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
+github.com/spf13/cobra v1.7.0 h1:hyqWnYt1ZQShIddO5kBpj3vu05/++x6tJ6dg8EC572I=
+github.com/spf13/cobra v1.7.0/go.mod h1:uLxZILRyS/50WlhOIKD7W6V5bgeIt+4sICxh6uRMrb0=
+github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
diff --git a/internal/database/ent/db/crontask.go b/internal/database/ent/db/crontask.go
index 4b56d14c..38595bf1 100644
--- a/internal/database/ent/db/crontask.go
+++ b/internal/database/ent/db/crontask.go
@@ -35,6 +35,8 @@ type CronTask struct {
 	ScheduledAfter time.Time `json:"scheduled_after,omitempty"`
 	// LastRun holds the value of the "last_run" field.
 	LastRun time.Time `json:"last_run,omitempty"`
+	// TriesLeft holds the value of the "tries_left" field.
+	TriesLeft int `json:"tries_left,omitempty"`
 	// Logs holds the value of the "logs" field.
 	Logs []models.TaskLog `json:"logs,omitempty"`
 	// Data holds the value of the "data" field.
@@ -49,6 +51,8 @@ func (*CronTask) scanValues(columns []string) ([]any, error) {
 		switch columns[i] {
 		case crontask.FieldTargets, crontask.FieldLogs, crontask.FieldData:
 			values[i] = new([]byte)
+		case crontask.FieldTriesLeft:
+			values[i] = new(sql.NullInt64)
 		case crontask.FieldID, crontask.FieldType, crontask.FieldReferenceID, crontask.FieldStatus:
 			values[i] = new(sql.NullString)
 		case crontask.FieldCreatedAt, crontask.FieldUpdatedAt, crontask.FieldScheduledAfter, crontask.FieldLastRun:
@@ -124,6 +128,12 @@ func (ct *CronTask) assignValues(columns []string, values []any) error {
 			} else if value.Valid {
 				ct.LastRun = value.Time
 			}
+		case crontask.FieldTriesLeft:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field tries_left", values[i])
+			} else if value.Valid {
+				ct.TriesLeft = int(value.Int64)
+			}
 		case crontask.FieldLogs:
 			if value, ok := values[i].(*[]byte); !ok {
 				return fmt.Errorf("unexpected type %T for field logs", values[i])
@@ -200,6 +210,9 @@ func (ct *CronTask) String() string {
 	builder.WriteString("last_run=")
 	builder.WriteString(ct.LastRun.Format(time.ANSIC))
 	builder.WriteString(", ")
+	builder.WriteString("tries_left=")
+	builder.WriteString(fmt.Sprintf("%v", ct.TriesLeft))
+	builder.WriteString(", ")
 	builder.WriteString("logs=")
 	builder.WriteString(fmt.Sprintf("%v", ct.Logs))
 	builder.WriteString(", ")
diff --git a/internal/database/ent/db/crontask/crontask.go b/internal/database/ent/db/crontask/crontask.go
index 1e2f95ea..34eaf930 100644
--- a/internal/database/ent/db/crontask/crontask.go
+++ b/internal/database/ent/db/crontask/crontask.go
@@ -31,6 +31,8 @@ const (
 	FieldScheduledAfter = "scheduled_after"
 	// FieldLastRun holds the string denoting the last_run field in the database.
 	FieldLastRun = "last_run"
+	// FieldTriesLeft holds the string denoting the tries_left field in the database.
+	FieldTriesLeft = "tries_left"
 	// FieldLogs holds the string denoting the logs field in the database.
 	FieldLogs = "logs"
 	// FieldData holds the string denoting the data field in the database.
@@ -50,6 +52,7 @@ var Columns = []string{
 	FieldStatus,
 	FieldScheduledAfter,
 	FieldLastRun,
+	FieldTriesLeft,
 	FieldLogs,
 	FieldData,
 }
@@ -139,3 +142,8 @@ func ByScheduledAfter(opts ...sql.OrderTermOption) OrderOption {
 func ByLastRun(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldLastRun, opts...).ToFunc()
 }
+
+// ByTriesLeft orders the results by the tries_left field.
+func ByTriesLeft(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldTriesLeft, opts...).ToFunc()
+}
diff --git a/internal/database/ent/db/crontask/where.go b/internal/database/ent/db/crontask/where.go
index 3f2568ff..82c5119d 100644
--- a/internal/database/ent/db/crontask/where.go
+++ b/internal/database/ent/db/crontask/where.go
@@ -90,6 +90,11 @@ func LastRun(v time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldEQ(FieldLastRun, v))
 }
 
+// TriesLeft applies equality check predicate on the "tries_left" field. It's identical to TriesLeftEQ.
+func TriesLeft(v int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldEQ(FieldTriesLeft, v))
+}
+
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
 func CreatedAtEQ(v time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldEQ(FieldCreatedAt, v))
@@ -375,6 +380,46 @@ func LastRunLTE(v time.Time) predicate.CronTask {
 	return predicate.CronTask(sql.FieldLTE(FieldLastRun, v))
 }
 
+// TriesLeftEQ applies the EQ predicate on the "tries_left" field.
+func TriesLeftEQ(v int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldEQ(FieldTriesLeft, v))
+}
+
+// TriesLeftNEQ applies the NEQ predicate on the "tries_left" field.
+func TriesLeftNEQ(v int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldNEQ(FieldTriesLeft, v))
+}
+
+// TriesLeftIn applies the In predicate on the "tries_left" field.
+func TriesLeftIn(vs ...int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldIn(FieldTriesLeft, vs...))
+}
+
+// TriesLeftNotIn applies the NotIn predicate on the "tries_left" field.
+func TriesLeftNotIn(vs ...int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldNotIn(FieldTriesLeft, vs...))
+}
+
+// TriesLeftGT applies the GT predicate on the "tries_left" field.
+func TriesLeftGT(v int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldGT(FieldTriesLeft, v))
+}
+
+// TriesLeftGTE applies the GTE predicate on the "tries_left" field.
+func TriesLeftGTE(v int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldGTE(FieldTriesLeft, v))
+}
+
+// TriesLeftLT applies the LT predicate on the "tries_left" field.
+func TriesLeftLT(v int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldLT(FieldTriesLeft, v))
+}
+
+// TriesLeftLTE applies the LTE predicate on the "tries_left" field.
+func TriesLeftLTE(v int) predicate.CronTask {
+	return predicate.CronTask(sql.FieldLTE(FieldTriesLeft, v))
+}
+
 // And groups predicates with the AND operator between them.
 func And(predicates ...predicate.CronTask) predicate.CronTask {
 	return predicate.CronTask(sql.AndPredicates(predicates...))
diff --git a/internal/database/ent/db/crontask_create.go b/internal/database/ent/db/crontask_create.go
index f9a3b4eb..085e2871 100644
--- a/internal/database/ent/db/crontask_create.go
+++ b/internal/database/ent/db/crontask_create.go
@@ -85,6 +85,12 @@ func (ctc *CronTaskCreate) SetLastRun(t time.Time) *CronTaskCreate {
 	return ctc
 }
 
+// SetTriesLeft sets the "tries_left" field.
+func (ctc *CronTaskCreate) SetTriesLeft(i int) *CronTaskCreate {
+	ctc.mutation.SetTriesLeft(i)
+	return ctc
+}
+
 // SetLogs sets the "logs" field.
 func (ctc *CronTaskCreate) SetLogs(ml []models.TaskLog) *CronTaskCreate {
 	ctc.mutation.SetLogs(ml)
@@ -201,6 +207,9 @@ func (ctc *CronTaskCreate) check() error {
 	if _, ok := ctc.mutation.LastRun(); !ok {
 		return &ValidationError{Name: "last_run", err: errors.New(`db: missing required field "CronTask.last_run"`)}
 	}
+	if _, ok := ctc.mutation.TriesLeft(); !ok {
+		return &ValidationError{Name: "tries_left", err: errors.New(`db: missing required field "CronTask.tries_left"`)}
+	}
 	if _, ok := ctc.mutation.Logs(); !ok {
 		return &ValidationError{Name: "logs", err: errors.New(`db: missing required field "CronTask.logs"`)}
 	}
@@ -274,6 +283,10 @@ func (ctc *CronTaskCreate) createSpec() (*CronTask, *sqlgraph.CreateSpec) {
 		_spec.SetField(crontask.FieldLastRun, field.TypeTime, value)
 		_node.LastRun = value
 	}
+	if value, ok := ctc.mutation.TriesLeft(); ok {
+		_spec.SetField(crontask.FieldTriesLeft, field.TypeInt, value)
+		_node.TriesLeft = value
+	}
 	if value, ok := ctc.mutation.Logs(); ok {
 		_spec.SetField(crontask.FieldLogs, field.TypeJSON, value)
 		_node.Logs = value
diff --git a/internal/database/ent/db/crontask_update.go b/internal/database/ent/db/crontask_update.go
index df58b722..e448816b 100644
--- a/internal/database/ent/db/crontask_update.go
+++ b/internal/database/ent/db/crontask_update.go
@@ -119,6 +119,27 @@ func (ctu *CronTaskUpdate) SetNillableLastRun(t *time.Time) *CronTaskUpdate {
 	return ctu
 }
 
+// SetTriesLeft sets the "tries_left" field.
+func (ctu *CronTaskUpdate) SetTriesLeft(i int) *CronTaskUpdate {
+	ctu.mutation.ResetTriesLeft()
+	ctu.mutation.SetTriesLeft(i)
+	return ctu
+}
+
+// SetNillableTriesLeft sets the "tries_left" field if the given value is not nil.
+func (ctu *CronTaskUpdate) SetNillableTriesLeft(i *int) *CronTaskUpdate {
+	if i != nil {
+		ctu.SetTriesLeft(*i)
+	}
+	return ctu
+}
+
+// AddTriesLeft adds i to the "tries_left" field.
+func (ctu *CronTaskUpdate) AddTriesLeft(i int) *CronTaskUpdate {
+	ctu.mutation.AddTriesLeft(i)
+	return ctu
+}
+
 // SetLogs sets the "logs" field.
 func (ctu *CronTaskUpdate) SetLogs(ml []models.TaskLog) *CronTaskUpdate {
 	ctu.mutation.SetLogs(ml)
@@ -242,6 +263,12 @@ func (ctu *CronTaskUpdate) sqlSave(ctx context.Context) (n int, err error) {
 	if value, ok := ctu.mutation.LastRun(); ok {
 		_spec.SetField(crontask.FieldLastRun, field.TypeTime, value)
 	}
+	if value, ok := ctu.mutation.TriesLeft(); ok {
+		_spec.SetField(crontask.FieldTriesLeft, field.TypeInt, value)
+	}
+	if value, ok := ctu.mutation.AddedTriesLeft(); ok {
+		_spec.AddField(crontask.FieldTriesLeft, field.TypeInt, value)
+	}
 	if value, ok := ctu.mutation.Logs(); ok {
 		_spec.SetField(crontask.FieldLogs, field.TypeJSON, value)
 	}
@@ -363,6 +390,27 @@ func (ctuo *CronTaskUpdateOne) SetNillableLastRun(t *time.Time) *CronTaskUpdateO
 	return ctuo
 }
 
+// SetTriesLeft sets the "tries_left" field.
+func (ctuo *CronTaskUpdateOne) SetTriesLeft(i int) *CronTaskUpdateOne {
+	ctuo.mutation.ResetTriesLeft()
+	ctuo.mutation.SetTriesLeft(i)
+	return ctuo
+}
+
+// SetNillableTriesLeft sets the "tries_left" field if the given value is not nil.
+func (ctuo *CronTaskUpdateOne) SetNillableTriesLeft(i *int) *CronTaskUpdateOne {
+	if i != nil {
+		ctuo.SetTriesLeft(*i)
+	}
+	return ctuo
+}
+
+// AddTriesLeft adds i to the "tries_left" field.
+func (ctuo *CronTaskUpdateOne) AddTriesLeft(i int) *CronTaskUpdateOne {
+	ctuo.mutation.AddTriesLeft(i)
+	return ctuo
+}
+
 // SetLogs sets the "logs" field.
 func (ctuo *CronTaskUpdateOne) SetLogs(ml []models.TaskLog) *CronTaskUpdateOne {
 	ctuo.mutation.SetLogs(ml)
@@ -516,6 +564,12 @@ func (ctuo *CronTaskUpdateOne) sqlSave(ctx context.Context) (_node *CronTask, er
 	if value, ok := ctuo.mutation.LastRun(); ok {
 		_spec.SetField(crontask.FieldLastRun, field.TypeTime, value)
 	}
+	if value, ok := ctuo.mutation.TriesLeft(); ok {
+		_spec.SetField(crontask.FieldTriesLeft, field.TypeInt, value)
+	}
+	if value, ok := ctuo.mutation.AddedTriesLeft(); ok {
+		_spec.AddField(crontask.FieldTriesLeft, field.TypeInt, value)
+	}
 	if value, ok := ctuo.mutation.Logs(); ok {
 		_spec.SetField(crontask.FieldLogs, field.TypeJSON, value)
 	}
diff --git a/internal/database/ent/db/migrate/schema.go b/internal/database/ent/db/migrate/schema.go
index 15f56785..82bd0479 100644
--- a/internal/database/ent/db/migrate/schema.go
+++ b/internal/database/ent/db/migrate/schema.go
@@ -262,6 +262,7 @@ var (
 		{Name: "status", Type: field.TypeEnum, Enums: []string{"TASK_SCHEDULED", "TASK_IN_PROGRESS", "TASK_COMPLETE", "TASK_FAILED"}},
 		{Name: "scheduled_after", Type: field.TypeTime},
 		{Name: "last_run", Type: field.TypeTime},
+		{Name: "tries_left", Type: field.TypeInt},
 		{Name: "logs", Type: field.TypeJSON},
 		{Name: "data", Type: field.TypeJSON},
 	}
diff --git a/internal/database/ent/db/mutation.go b/internal/database/ent/db/mutation.go
index 586c843d..024970b4 100644
--- a/internal/database/ent/db/mutation.go
+++ b/internal/database/ent/db/mutation.go
@@ -4702,6 +4702,8 @@ type CronTaskMutation struct {
 	status          *models.TaskStatus
 	scheduled_after *time.Time
 	last_run        *time.Time
+	tries_left      *int
+	addtries_left   *int
 	logs            *[]models.TaskLog
 	appendlogs      []models.TaskLog
 	data            *map[string]string
@@ -5118,6 +5120,62 @@ func (m *CronTaskMutation) ResetLastRun() {
 	m.last_run = nil
 }
 
+// SetTriesLeft sets the "tries_left" field.
+func (m *CronTaskMutation) SetTriesLeft(i int) {
+	m.tries_left = &i
+	m.addtries_left = nil
+}
+
+// TriesLeft returns the value of the "tries_left" field in the mutation.
+func (m *CronTaskMutation) TriesLeft() (r int, exists bool) {
+	v := m.tries_left
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldTriesLeft returns the old "tries_left" field's value of the CronTask entity.
+// If the CronTask object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *CronTaskMutation) OldTriesLeft(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldTriesLeft is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldTriesLeft requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldTriesLeft: %w", err)
+	}
+	return oldValue.TriesLeft, nil
+}
+
+// AddTriesLeft adds i to the "tries_left" field.
+func (m *CronTaskMutation) AddTriesLeft(i int) {
+	if m.addtries_left != nil {
+		*m.addtries_left += i
+	} else {
+		m.addtries_left = &i
+	}
+}
+
+// AddedTriesLeft returns the value that was added to the "tries_left" field in this mutation.
+func (m *CronTaskMutation) AddedTriesLeft() (r int, exists bool) {
+	v := m.addtries_left
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetTriesLeft resets all changes to the "tries_left" field.
+func (m *CronTaskMutation) ResetTriesLeft() {
+	m.tries_left = nil
+	m.addtries_left = nil
+}
+
 // SetLogs sets the "logs" field.
 func (m *CronTaskMutation) SetLogs(ml []models.TaskLog) {
 	m.logs = &ml
@@ -5239,7 +5297,7 @@ func (m *CronTaskMutation) Type() string {
 // order to get all numeric fields that were incremented/decremented, call
 // AddedFields().
 func (m *CronTaskMutation) Fields() []string {
-	fields := make([]string, 0, 10)
+	fields := make([]string, 0, 11)
 	if m.created_at != nil {
 		fields = append(fields, crontask.FieldCreatedAt)
 	}
@@ -5264,6 +5322,9 @@ func (m *CronTaskMutation) Fields() []string {
 	if m.last_run != nil {
 		fields = append(fields, crontask.FieldLastRun)
 	}
+	if m.tries_left != nil {
+		fields = append(fields, crontask.FieldTriesLeft)
+	}
 	if m.logs != nil {
 		fields = append(fields, crontask.FieldLogs)
 	}
@@ -5294,6 +5355,8 @@ func (m *CronTaskMutation) Field(name string) (ent.Value, bool) {
 		return m.ScheduledAfter()
 	case crontask.FieldLastRun:
 		return m.LastRun()
+	case crontask.FieldTriesLeft:
+		return m.TriesLeft()
 	case crontask.FieldLogs:
 		return m.Logs()
 	case crontask.FieldData:
@@ -5323,6 +5386,8 @@ func (m *CronTaskMutation) OldField(ctx context.Context, name string) (ent.Value
 		return m.OldScheduledAfter(ctx)
 	case crontask.FieldLastRun:
 		return m.OldLastRun(ctx)
+	case crontask.FieldTriesLeft:
+		return m.OldTriesLeft(ctx)
 	case crontask.FieldLogs:
 		return m.OldLogs(ctx)
 	case crontask.FieldData:
@@ -5392,6 +5457,13 @@ func (m *CronTaskMutation) SetField(name string, value ent.Value) error {
 		}
 		m.SetLastRun(v)
 		return nil
+	case crontask.FieldTriesLeft:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetTriesLeft(v)
+		return nil
 	case crontask.FieldLogs:
 		v, ok := value.([]models.TaskLog)
 		if !ok {
@@ -5413,13 +5485,21 @@ func (m *CronTaskMutation) SetField(name string, value ent.Value) error {
 // AddedFields returns all numeric fields that were incremented/decremented during
 // this mutation.
 func (m *CronTaskMutation) AddedFields() []string {
-	return nil
+	var fields []string
+	if m.addtries_left != nil {
+		fields = append(fields, crontask.FieldTriesLeft)
+	}
+	return fields
 }
 
 // AddedField returns the numeric value that was incremented/decremented on a field
 // with the given name. The second boolean return value indicates that this field
 // was not set, or was not defined in the schema.
 func (m *CronTaskMutation) AddedField(name string) (ent.Value, bool) {
+	switch name {
+	case crontask.FieldTriesLeft:
+		return m.AddedTriesLeft()
+	}
 	return nil, false
 }
 
@@ -5428,6 +5508,13 @@ func (m *CronTaskMutation) AddedField(name string) (ent.Value, bool) {
 // type.
 func (m *CronTaskMutation) AddField(name string, value ent.Value) error {
 	switch name {
+	case crontask.FieldTriesLeft:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddTriesLeft(v)
+		return nil
 	}
 	return fmt.Errorf("unknown CronTask numeric field %s", name)
 }
@@ -5479,6 +5566,9 @@ func (m *CronTaskMutation) ResetField(name string) error {
 	case crontask.FieldLastRun:
 		m.ResetLastRun()
 		return nil
+	case crontask.FieldTriesLeft:
+		m.ResetTriesLeft()
+		return nil
 	case crontask.FieldLogs:
 		m.ResetLogs()
 		return nil
diff --git a/internal/database/ent/migrations/20240627200608.sql b/internal/database/ent/migrations/20240627200608.sql
new file mode 100644
index 00000000..e61ae19b
--- /dev/null
+++ b/internal/database/ent/migrations/20240627200608.sql
@@ -0,0 +1,2 @@
+-- Add column "tries_left" to table: "cron_tasks"
+ALTER TABLE `cron_tasks` ADD COLUMN `tries_left` integer NOT NULL;
diff --git a/internal/database/ent/migrations/atlas.sum b/internal/database/ent/migrations/atlas.sum
index 078d2ca9..c8ae9d2d 100644
--- a/internal/database/ent/migrations/atlas.sum
+++ b/internal/database/ent/migrations/atlas.sum
@@ -1,2 +1,3 @@
-h1:xMoifuEeyeG1Wp9DhNcR2c+9QM7POMSSmax2AhvV6Z0=
+h1:D1oLv8vS98PlDAuqVaSups+M9YQhXif84Hs7QmNKe1A=
 20240627171532.sql h1:480JhjRCpyyix192z/L92yEI7LSsgJhuiK0ljat55TI=
+20240627200608.sql h1:S0XjBX2P92O6vWPa/g5FRSp06Oo73opQttFzN3eoDQA=
diff --git a/internal/database/ent/schema/cron_task.go b/internal/database/ent/schema/cron_task.go
index 395749d9..dafa5b90 100644
--- a/internal/database/ent/schema/cron_task.go
+++ b/internal/database/ent/schema/cron_task.go
@@ -24,6 +24,7 @@ func (CronTask) Fields() []ent.Field {
 			GoType(models.TaskStatus("")),
 		field.Time("scheduled_after"),
 		field.Time("last_run"),
+		field.Int("tries_left"),
 		//
 		field.JSON("logs", []models.TaskLog{}),
 		field.JSON("data", map[string]string{}),
diff --git a/internal/database/models/task.go b/internal/database/models/task.go
index e81ef137..9d3faca3 100644
--- a/internal/database/models/task.go
+++ b/internal/database/models/task.go
@@ -68,6 +68,7 @@ type Task struct {
 
 	Status         TaskStatus `json:"status"`
 	ScheduledAfter time.Time  `json:"scheduledAfter"`
+	TriesLeft      int        `json:triesLeft`
 	LastRun        time.Time  `json:"lastRun"`
 
 	Data map[string]string `json:"data"`
diff --git a/internal/database/tasks.go b/internal/database/tasks.go
index 063334c7..9698dd8e 100644
--- a/internal/database/tasks.go
+++ b/internal/database/tasks.go
@@ -84,7 +84,11 @@ func (c *client) GetAndStartTasks(ctx context.Context, limit int) ([]models.Task
 
 	var tasks []models.Task
 	return tasks, c.withTx(ctx, func(tx *db.Tx) error {
-		records, err := tx.CronTask.Query().Where(crontask.StatusEQ(models.TaskStatusScheduled), crontask.ScheduledAfterLT(time.Now())).Order(crontask.ByScheduledAfter(sql.OrderAsc())).Limit(limit).All(ctx)
+		records, err := tx.CronTask.Query().Where(
+			crontask.TriesLeftGT(0),
+			crontask.ScheduledAfterLT(time.Now()),
+			crontask.StatusEQ(models.TaskStatusScheduled),
+		).Order(crontask.ByScheduledAfter(sql.OrderAsc())).Limit(limit).All(ctx)
 		if err != nil {
 			return err
 		}
@@ -157,6 +161,7 @@ func (c *client) CreateTasks(ctx context.Context, tasks ...models.Task) error {
 					SetStatus(t.Status).
 					SetTargets(t.Targets).
 					SetLastRun(t.LastRun).
+					SetTriesLeft(t.TriesLeft).
 					SetReferenceID(t.ReferenceID).
 					SetScheduledAfter(t.ScheduledAfter),
 			)

From 3c981a74654c9d6a5a197a216b294dd8ff1698b0 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 27 Jun 2024 16:10:26 -0400
Subject: [PATCH 200/341] added default value

---
 .../ent/migrations/20240627200608.sql         |  2 --
 .../ent/migrations/20240627200953.sql         | 22 +++++++++++++++++++
 internal/database/ent/migrations/atlas.sum    |  4 ++--
 internal/database/ent/schema/cron_task.go     |  2 +-
 4 files changed, 25 insertions(+), 5 deletions(-)
 delete mode 100644 internal/database/ent/migrations/20240627200608.sql
 create mode 100644 internal/database/ent/migrations/20240627200953.sql

diff --git a/internal/database/ent/migrations/20240627200608.sql b/internal/database/ent/migrations/20240627200608.sql
deleted file mode 100644
index e61ae19b..00000000
--- a/internal/database/ent/migrations/20240627200608.sql
+++ /dev/null
@@ -1,2 +0,0 @@
--- Add column "tries_left" to table: "cron_tasks"
-ALTER TABLE `cron_tasks` ADD COLUMN `tries_left` integer NOT NULL;
diff --git a/internal/database/ent/migrations/20240627200953.sql b/internal/database/ent/migrations/20240627200953.sql
new file mode 100644
index 00000000..be677edd
--- /dev/null
+++ b/internal/database/ent/migrations/20240627200953.sql
@@ -0,0 +1,22 @@
+-- Disable the enforcement of foreign-keys constraints
+PRAGMA foreign_keys = off;
+-- Create "new_cron_tasks" table
+CREATE TABLE `new_cron_tasks` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `reference_id` text NOT NULL, `targets` json NOT NULL, `status` text NOT NULL, `scheduled_after` datetime NOT NULL, `last_run` datetime NOT NULL, `tries_left` integer NOT NULL DEFAULT (0), `logs` json NOT NULL, `data` json NOT NULL, PRIMARY KEY (`id`));
+-- Copy rows from old table "cron_tasks" to new temporary table "new_cron_tasks"
+INSERT INTO `new_cron_tasks` (`id`, `created_at`, `updated_at`, `type`, `reference_id`, `targets`, `status`, `scheduled_after`, `last_run`, `logs`, `data`) SELECT `id`, `created_at`, `updated_at`, `type`, `reference_id`, `targets`, `status`, `scheduled_after`, `last_run`, `logs`, `data` FROM `cron_tasks`;
+-- Drop "cron_tasks" table after copying rows
+DROP TABLE `cron_tasks`;
+-- Rename temporary table "new_cron_tasks" to "cron_tasks"
+ALTER TABLE `new_cron_tasks` RENAME TO `cron_tasks`;
+-- Create index "crontask_id" to table: "cron_tasks"
+CREATE INDEX `crontask_id` ON `cron_tasks` (`id`);
+-- Create index "crontask_reference_id" to table: "cron_tasks"
+CREATE INDEX `crontask_reference_id` ON `cron_tasks` (`reference_id`);
+-- Create index "crontask_status_last_run" to table: "cron_tasks"
+CREATE INDEX `crontask_status_last_run` ON `cron_tasks` (`status`, `last_run`);
+-- Create index "crontask_status_created_at" to table: "cron_tasks"
+CREATE INDEX `crontask_status_created_at` ON `cron_tasks` (`status`, `created_at`);
+-- Create index "crontask_status_scheduled_after" to table: "cron_tasks"
+CREATE INDEX `crontask_status_scheduled_after` ON `cron_tasks` (`status`, `scheduled_after`);
+-- Enable back the enforcement of foreign-keys constraints
+PRAGMA foreign_keys = on;
diff --git a/internal/database/ent/migrations/atlas.sum b/internal/database/ent/migrations/atlas.sum
index c8ae9d2d..2251e9e6 100644
--- a/internal/database/ent/migrations/atlas.sum
+++ b/internal/database/ent/migrations/atlas.sum
@@ -1,3 +1,3 @@
-h1:D1oLv8vS98PlDAuqVaSups+M9YQhXif84Hs7QmNKe1A=
+h1:ZYxvqqhpfA/QIZSU/etxpGhuHYFfgwF3/i9HL04YT0E=
 20240627171532.sql h1:480JhjRCpyyix192z/L92yEI7LSsgJhuiK0ljat55TI=
-20240627200608.sql h1:S0XjBX2P92O6vWPa/g5FRSp06Oo73opQttFzN3eoDQA=
+20240627200953.sql h1:VUQZd1HQrxITMUtNO9HRtnDE8wgtWgRyzduACb3D3u4=
diff --git a/internal/database/ent/schema/cron_task.go b/internal/database/ent/schema/cron_task.go
index dafa5b90..d5209573 100644
--- a/internal/database/ent/schema/cron_task.go
+++ b/internal/database/ent/schema/cron_task.go
@@ -24,7 +24,7 @@ func (CronTask) Fields() []ent.Field {
 			GoType(models.TaskStatus("")),
 		field.Time("scheduled_after"),
 		field.Time("last_run"),
-		field.Int("tries_left"),
+		field.Int("tries_left").Default(0),
 		//
 		field.JSON("logs", []models.TaskLog{}),
 		field.JSON("data", map[string]string{}),

From 37af5202fa1b36d38ffa7f7ca638d1df281d4f56 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 27 Jun 2024 16:17:14 -0400
Subject: [PATCH 201/341] typo

---
 internal/database/models/task.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/internal/database/models/task.go b/internal/database/models/task.go
index 9d3faca3..9ded8cd4 100644
--- a/internal/database/models/task.go
+++ b/internal/database/models/task.go
@@ -68,7 +68,7 @@ type Task struct {
 
 	Status         TaskStatus `json:"status"`
 	ScheduledAfter time.Time  `json:"scheduledAfter"`
-	TriesLeft      int        `json:triesLeft`
+	TriesLeft      int        `json:"triesLeft"`
 	LastRun        time.Time  `json:"lastRun"`
 
 	Data map[string]string `json:"data"`

From df5f55bcb87e4dabfa7e785a8eef50d1f35fbf4b Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 27 Jun 2024 16:19:45 -0400
Subject: [PATCH 202/341] added tries for new tasks

---
 cmd/core/tasks/cleanup.go  | 1 +
 cmd/core/tasks/sessions.go | 4 ++--
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/cmd/core/tasks/cleanup.go b/cmd/core/tasks/cleanup.go
index b3836c56..9a2d8871 100644
--- a/cmd/core/tasks/cleanup.go
+++ b/cmd/core/tasks/cleanup.go
@@ -61,6 +61,7 @@ func CreateCleanupTasks(client core.Client) error {
 	now := time.Now()
 
 	task := models.Task{
+		TriesLeft:      1,
 		Type:           models.TaskTypeDatabaseCleanup,
 		ReferenceID:    "database_cleanup",
 		ScheduledAfter: now,
diff --git a/cmd/core/tasks/sessions.go b/cmd/core/tasks/sessions.go
index 21db9fc0..a009f0d8 100644
--- a/cmd/core/tasks/sessions.go
+++ b/cmd/core/tasks/sessions.go
@@ -74,12 +74,12 @@ func init() {
 func CreateRecordSnapshotsTasks(client core.Client, realm string) error {
 	realm = strings.ToUpper(realm)
 	task := models.Task{
+		TriesLeft:      3,
 		Type:           models.TaskTypeRecordSnapshots,
 		ReferenceID:    "realm_" + realm,
 		ScheduledAfter: time.Now(),
 		Data: map[string]string{
-			"realm":     realm,
-			"triesLeft": "3",
+			"realm": realm,
 		},
 	}
 

From 0ec84885aa7f5e79914eb47c078a625ada684dcd Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 27 Jun 2024 16:26:33 -0400
Subject: [PATCH 203/341] removed old checks

---
 cmd/core/tasks/cleanup.go  |  7 -------
 cmd/core/tasks/sessions.go | 19 +------------------
 2 files changed, 1 insertion(+), 25 deletions(-)

diff --git a/cmd/core/tasks/cleanup.go b/cmd/core/tasks/cleanup.go
index 9a2d8871..3d1524dc 100644
--- a/cmd/core/tasks/cleanup.go
+++ b/cmd/core/tasks/cleanup.go
@@ -14,14 +14,9 @@ import (
 func init() {
 	defaultHandlers[models.TaskTypeDatabaseCleanup] = TaskHandler{
 		Process: func(ctx context.Context, client core.Client, task *models.Task) error {
-			if task.Data == nil {
-				task.Data["triesLeft"] = "0" // do not retry
-				return errors.New("no data provided")
-			}
 			{
 				taskExpiration, err := time.Parse(time.RFC3339, task.Data["expiration_tasks"])
 				if err != nil {
-					task.Data["triesLeft"] = "0" // do not retry
 					return errors.Wrap(err, "failed to parse expiration_tasks to time")
 				}
 				err = client.Database().DeleteExpiredTasks(ctx, taskExpiration)
@@ -32,7 +27,6 @@ func init() {
 			{
 				interactionExpiration, err := time.Parse(time.RFC3339, task.Data["expiration_interactions"])
 				if err != nil {
-					task.Data["triesLeft"] = "0" // do not retry
 					return errors.Wrap(err, "failed to parse interactionExpiration to time")
 				}
 				err = client.Database().DeleteExpiredInteractions(ctx, interactionExpiration)
@@ -43,7 +37,6 @@ func init() {
 			{
 				snapshotExpiration, err := time.Parse(time.RFC3339, task.Data["expiration_snapshots"])
 				if err != nil {
-					task.Data["triesLeft"] = "0" // do not retry
 					return errors.Wrap(err, "failed to parse expiration_snapshots to time")
 				}
 				err = client.Database().DeleteExpiredSnapshots(ctx, snapshotExpiration)
diff --git a/cmd/core/tasks/sessions.go b/cmd/core/tasks/sessions.go
index a009f0d8..7e459ff2 100644
--- a/cmd/core/tasks/sessions.go
+++ b/cmd/core/tasks/sessions.go
@@ -2,7 +2,6 @@ package tasks
 
 import (
 	"context"
-	"strconv"
 	"strings"
 	"time"
 
@@ -17,35 +16,19 @@ import (
 func init() {
 	defaultHandlers[models.TaskTypeRecordSnapshots] = TaskHandler{
 		Process: func(ctx context.Context, client core.Client, task *models.Task) error {
-			if task.Data == nil {
-				return errors.New("no data provided")
-			}
-
-			triesLeft, err := strconv.Atoi(task.Data["triesLeft"])
-			if err != nil {
-				return errors.Wrap(err, "failed to parse tries left")
-			}
-			task.Data["triesLeft"] = strconv.Itoa(triesLeft - 1)
-
+			forceUpdate := task.Data["force"] == "true"
 			realm, ok := task.Data["realm"]
 			if !ok {
-				task.Data["triesLeft"] = "0" // do not retry
 				return errors.New("invalid realm")
 			}
-
 			if len(task.Targets) > 100 {
-				task.Data["triesLeft"] = "0" // do not retry
 				return errors.New("invalid targets length")
 			}
 			if len(task.Targets) < 1 {
-				task.Data["triesLeft"] = "0" // do not retry
 				return errors.New("invalid targets length")
 			}
 
-			forceUpdate := task.Data["force"] == "true"
-
 			log.Debug().Str("taskId", task.ID).Any("targets", task.Targets).Msg("started working on a session refresh task")
-
 			accountErrors, err := logic.RecordAccountSnapshots(ctx, client.Wargaming(), client.Database(), realm, forceUpdate, task.Targets...)
 			if err != nil {
 				return err

From d5a66b33f0be2671a70c53bb807d4c78faca21f6 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 27 Jun 2024 16:27:16 -0400
Subject: [PATCH 204/341] pretty

---
 cmd/core/tasks/cleanup.go  | 4 ++--
 cmd/core/tasks/sessions.go | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/cmd/core/tasks/cleanup.go b/cmd/core/tasks/cleanup.go
index 3d1524dc..5f2c5fc7 100644
--- a/cmd/core/tasks/cleanup.go
+++ b/cmd/core/tasks/cleanup.go
@@ -55,9 +55,9 @@ func CreateCleanupTasks(client core.Client) error {
 
 	task := models.Task{
 		TriesLeft:      1,
-		Type:           models.TaskTypeDatabaseCleanup,
-		ReferenceID:    "database_cleanup",
 		ScheduledAfter: now,
+		ReferenceID:    "database_cleanup",
+		Type:           models.TaskTypeDatabaseCleanup,
 		Data: map[string]string{
 			"expiration_snapshots":    now.Add(-1 * time.Hour * 24 * 90).Format(time.RFC3339), // 90 days
 			"expiration_interactions": now.Add(-1 * time.Hour * 24 * 7).Format(time.RFC3339),  // 7 days
diff --git a/cmd/core/tasks/sessions.go b/cmd/core/tasks/sessions.go
index 7e459ff2..fd324e69 100644
--- a/cmd/core/tasks/sessions.go
+++ b/cmd/core/tasks/sessions.go
@@ -57,13 +57,13 @@ func init() {
 func CreateRecordSnapshotsTasks(client core.Client, realm string) error {
 	realm = strings.ToUpper(realm)
 	task := models.Task{
-		TriesLeft:      3,
 		Type:           models.TaskTypeRecordSnapshots,
 		ReferenceID:    "realm_" + realm,
 		ScheduledAfter: time.Now(),
 		Data: map[string]string{
 			"realm": realm,
 		},
+		TriesLeft: 3,
 	}
 
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)

From e6ba90c15a37c648fff8f93b35851a9a8a769b46 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 27 Jun 2024 16:36:30 -0400
Subject: [PATCH 205/341] retrying on some accounts failed

---
 cmd/core/tasks/sessions.go  |  5 ++++-
 internal/logic/snapshots.go | 11 +++++++----
 2 files changed, 11 insertions(+), 5 deletions(-)

diff --git a/cmd/core/tasks/sessions.go b/cmd/core/tasks/sessions.go
index fd324e69..b0b7c844 100644
--- a/cmd/core/tasks/sessions.go
+++ b/cmd/core/tasks/sessions.go
@@ -47,8 +47,11 @@ func init() {
 					Comment:   id,
 				})
 			}
-			task.Targets = newTargets
 
+			if len(newTargets) > 0 {
+				task.Targets = newTargets
+				return errors.New("some accounts failed")
+			}
 			return nil
 		},
 	}
diff --git a/internal/logic/snapshots.go b/internal/logic/snapshots.go
index f3a827b3..0349fe75 100644
--- a/internal/logic/snapshots.go
+++ b/internal/logic/snapshots.go
@@ -56,7 +56,10 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 			}(id)
 			continue
 		}
-		if s, ok := existingSnapshotsMap[id]; !force && ok && data.LastBattleTime == int(s.LastBattleTime.Unix()) {
+		if data.LastBattleTime < 1 {
+			continue
+		}
+		if s, ok := existingSnapshotsMap[id]; !force && (ok && data.LastBattleTime == int(s.LastBattleTime.Unix())) {
 			// last snapshot is the same, we can skip it
 			continue
 		}
@@ -132,13 +135,13 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 				}
 
 				vehicleSnapshots[stats.Account.ID] = append(vehicleSnapshots[stats.Account.ID], models.VehicleSnapshot{
-					CreatedAt:      createdAt,
 					Type:           models.SnapshotTypeDaily,
 					LastBattleTime: vehicle.LastBattleTime,
-					AccountID:      stats.Account.ID,
+					Stats:          *vehicle.StatsFrame,
 					VehicleID:      vehicle.VehicleID,
+					AccountID:      stats.Account.ID,
 					ReferenceID:    stats.Account.ID,
-					Stats:          *vehicle.StatsFrame,
+					CreatedAt:      createdAt,
 				})
 			}
 		}

From 04ee807473b2d574516d635686f4b79da7c6c401 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 27 Jun 2024 16:49:14 -0400
Subject: [PATCH 206/341] saving snapshots without vehicles (rating battles)

---
 cmd/core/tasks/sessions.go  |  2 +-
 internal/logic/snapshots.go | 27 ++++++++++++---------------
 2 files changed, 13 insertions(+), 16 deletions(-)

diff --git a/cmd/core/tasks/sessions.go b/cmd/core/tasks/sessions.go
index b0b7c844..7a02dea7 100644
--- a/cmd/core/tasks/sessions.go
+++ b/cmd/core/tasks/sessions.go
@@ -34,7 +34,7 @@ func init() {
 				return err
 			}
 
-			// Retry failed accounts
+			// retry failed accounts
 			newTargets := make([]string, 0, len(accountErrors))
 			for id, err := range accountErrors {
 				if err == nil {
diff --git a/internal/logic/snapshots.go b/internal/logic/snapshots.go
index 0349fe75..314a4224 100644
--- a/internal/logic/snapshots.go
+++ b/internal/logic/snapshots.go
@@ -148,21 +148,18 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 	}
 
 	for _, accountSnapshot := range accountSnapshots {
-		vehicles, ok := vehicleSnapshots[accountSnapshot.AccountID]
-		if !ok {
-			accountErrors[accountSnapshot.AccountID] = errors.New("account missing vehicle snapshots")
-			continue
-		}
-
-		// save all vehicle snapshots
-		vErr, err := dbClient.CreateAccountVehicleSnapshots(ctx, accountSnapshot.AccountID, vehicles...)
-		if err != nil {
-			accountErrors[accountSnapshot.AccountID] = err
-			continue
-		}
-		if len(vErr) > 0 {
-			accountErrors[accountSnapshot.AccountID] = errors.Errorf("failed to insert %d vehicle snapshots", len(vErr))
-			continue
+		vehicles := vehicleSnapshots[accountSnapshot.AccountID]
+		if len(vehicles) > 0 {
+			// save all vehicle snapshots)
+			vErr, err := dbClient.CreateAccountVehicleSnapshots(ctx, accountSnapshot.AccountID, vehicles...)
+			if err != nil {
+				accountErrors[accountSnapshot.AccountID] = err
+				continue
+			}
+			if len(vErr) > 0 {
+				accountErrors[accountSnapshot.AccountID] = errors.Errorf("failed to insert %d vehicle snapshots", len(vErr))
+				continue
+			}
 		}
 
 		// save account snapshot

From c06a7b83f44a02fbcd32e8583c9b725e78f81334 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 27 Jun 2024 16:50:53 -0400
Subject: [PATCH 207/341] better snapshot compare

---
 internal/logic/snapshots.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/internal/logic/snapshots.go b/internal/logic/snapshots.go
index 314a4224..73ed394b 100644
--- a/internal/logic/snapshots.go
+++ b/internal/logic/snapshots.go
@@ -129,7 +129,7 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 			}
 			vehicleStats := fetch.WargamingVehiclesToFrame(vehicles)
 			for id, vehicle := range vehicleStats {
-				if s, ok := existingSnapshotsMap[id]; !force && ok && s.Stats.Battles == vehicle.Battles {
+				if s, ok := existingSnapshotsMap[id]; !force && ok && s.LastBattleTime.Equal(vehicle.LastBattleTime) {
 					// last snapshot is the same, we can skip it
 					continue
 				}

From 8bcdfb48a890dcbb31f61f6f075ac72d23b3c660 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 27 Jun 2024 17:03:56 -0400
Subject: [PATCH 208/341] minor UI tweaks

---
 internal/database/models/vehicle.go       | 8 ++++++--
 internal/stats/render/session/v1/cards.go | 8 ++++----
 2 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/internal/database/models/vehicle.go b/internal/database/models/vehicle.go
index 53787d30..4db8346e 100644
--- a/internal/database/models/vehicle.go
+++ b/internal/database/models/vehicle.go
@@ -1,6 +1,10 @@
 package models
 
-import "golang.org/x/text/language"
+import (
+	"fmt"
+
+	"golang.org/x/text/language"
+)
 
 type Vehicle struct {
 	ID             string
@@ -15,5 +19,5 @@ func (v Vehicle) Name(locale language.Tag) string {
 	if n := v.LocalizedNames[language.English.String()]; n != "" {
 		return n
 	}
-	return "Secret Tank"
+	return fmt.Sprintf("Secret Tank %s", v.ID)
 }
diff --git a/internal/stats/render/session/v1/cards.go b/internal/stats/render/session/v1/cards.go
index 72afa921..e089214f 100644
--- a/internal/stats/render/session/v1/cards.go
+++ b/internal/stats/render/session/v1/cards.go
@@ -17,14 +17,14 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 		renderUnratedVehiclesCount = 3 // minimum number of vehicle cards
 		// primary cards
 		// when there are some unrated battles or no battles at all
-		shouldRenderUnratedOverview = session.RegularBattles.Battles > 0 || session.RatingBattles.Battles == 0
+		shouldRenderUnratedOverview = session.RegularBattles.Battles > 0 || session.RatingBattles.Battles < 1
 		// when there are 3 vehicle cards and no rating overview cards or there are 6 vehicle cards and some rating battles
 		shouldRenderUnratedHighlights = (session.RegularBattles.Battles > 0 && session.RatingBattles.Battles < 1 && len(cards.Unrated.Vehicles) > renderUnratedVehiclesCount) ||
-			(session.RegularBattles.Battles > 0 && len(cards.Unrated.Vehicles) > 6)
+			(session.RegularBattles.Battles > 0 && len(cards.Unrated.Vehicles) > 3)
 		shouldRenderRatingOverview = session.RatingBattles.Battles > 0
-		shouldRenderRatingVehicles = len(cards.Unrated.Vehicles) == 0
+		shouldRenderRatingVehicles = session.RatingBattles.Battles > 0 && len(cards.Rating.Vehicles) > 0 && len(cards.Unrated.Vehicles) < 1
 		// secondary cards
-		shouldRenderUnratedVehicles = len(cards.Unrated.Vehicles) > 0
+		shouldRenderUnratedVehicles = session.RegularBattles.Battles > 0 && len(cards.Unrated.Vehicles) > 0
 	)
 
 	// try to make the columns height roughly similar to primary column

From 6143f01c07c03000b9b217db5695174425ac976d Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 27 Jun 2024 20:46:45 -0400
Subject: [PATCH 209/341] added testing client for db and fetch

---
 internal/database/client.go               |   4 +-
 internal/database/users.go                |  12 +-
 internal/stats/fetch/v1/client.go         |  10 +-
 internal/stats/fetch/v1/multisource.go    |   6 +-
 internal/stats/render/session/v1/cards.go |  20 +--
 render_test.go                            |  11 +-
 tests/static_data.go                      | 109 +++++++++++++++
 tests/static_database.go                  | 159 ++++++++++++++++++++++
 tests/static_fetch.go                     |  93 +++++++++++++
 9 files changed, 392 insertions(+), 32 deletions(-)
 create mode 100644 tests/static_data.go
 create mode 100644 tests/static_database.go
 create mode 100644 tests/static_fetch.go

diff --git a/internal/database/client.go b/internal/database/client.go
index 7a99931a..d192ca4b 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -35,8 +35,8 @@ type GlossaryClient interface {
 }
 
 type UsersClient interface {
-	GetUserByID(ctx context.Context, id string, opts ...userGetOption) (models.User, error)
-	GetOrCreateUserByID(ctx context.Context, id string, opts ...userGetOption) (models.User, error)
+	GetUserByID(ctx context.Context, id string, opts ...UserGetOption) (models.User, error)
+	GetOrCreateUserByID(ctx context.Context, id string, opts ...UserGetOption) (models.User, error)
 	UpsertUserWithPermissions(ctx context.Context, userID string, perms permissions.Permissions) (models.User, error)
 
 	UpdateConnection(ctx context.Context, connection models.UserConnection) (models.UserConnection, error)
diff --git a/internal/database/users.go b/internal/database/users.go
index c31d423a..e172ae0b 100644
--- a/internal/database/users.go
+++ b/internal/database/users.go
@@ -69,19 +69,19 @@ type userGetOpts struct {
 	subscriptions bool
 }
 
-type userGetOption func(*userGetOpts)
+type UserGetOption func(*userGetOpts)
 
-func WithConnections() userGetOption {
+func WithConnections() UserGetOption {
 	return func(ugo *userGetOpts) {
 		ugo.connections = true
 	}
 }
-func WithSubscriptions() userGetOption {
+func WithSubscriptions() UserGetOption {
 	return func(ugo *userGetOpts) {
 		ugo.subscriptions = true
 	}
 }
-func WithContent() userGetOption {
+func WithContent() UserGetOption {
 	return func(ugo *userGetOpts) {
 		ugo.content = true
 	}
@@ -91,7 +91,7 @@ func WithContent() userGetOption {
 Gets or creates a user with specified ID
   - assumes the ID is valid
 */
-func (c *client) GetOrCreateUserByID(ctx context.Context, id string, opts ...userGetOption) (models.User, error) {
+func (c *client) GetOrCreateUserByID(ctx context.Context, id string, opts ...UserGetOption) (models.User, error) {
 	user, err := c.GetUserByID(ctx, id, opts...)
 	if err != nil && !IsNotFound(err) {
 		return models.User{}, err
@@ -115,7 +115,7 @@ func (c *client) GetOrCreateUserByID(ctx context.Context, id string, opts ...use
 Gets a user with specified ID
   - assumes the ID is valid
 */
-func (c *client) GetUserByID(ctx context.Context, id string, opts ...userGetOption) (models.User, error) {
+func (c *client) GetUserByID(ctx context.Context, id string, opts ...UserGetOption) (models.User, error) {
 	var options userGetOpts
 	for _, apply := range opts {
 		apply(&options)
diff --git a/internal/stats/fetch/v1/client.go b/internal/stats/fetch/v1/client.go
index f15e157b..8bcef83b 100644
--- a/internal/stats/fetch/v1/client.go
+++ b/internal/stats/fetch/v1/client.go
@@ -49,10 +49,10 @@ type StatsWithVehicles struct {
 type Client interface {
 	Account(ctx context.Context, id string) (models.Account, error)
 	Search(ctx context.Context, nickname, realm string) (types.Account, error)
-	CurrentStats(ctx context.Context, id string, opts ...statsOption) (AccountStatsOverPeriod, error)
+	CurrentStats(ctx context.Context, id string, opts ...StatsOption) (AccountStatsOverPeriod, error)
 
-	PeriodStats(ctx context.Context, id string, from time.Time, opts ...statsOption) (AccountStatsOverPeriod, error)
-	SessionStats(ctx context.Context, id string, sessionStart time.Time, opts ...statsOption) (AccountStatsOverPeriod, AccountStatsOverPeriod, error)
+	PeriodStats(ctx context.Context, id string, from time.Time, opts ...StatsOption) (AccountStatsOverPeriod, error)
+	SessionStats(ctx context.Context, id string, sessionStart time.Time, opts ...StatsOption) (AccountStatsOverPeriod, AccountStatsOverPeriod, error)
 
 	CurrentTankAverages(ctx context.Context) (map[string]frame.StatsFrame, error)
 }
@@ -61,9 +61,9 @@ type statsOptions struct {
 	withWN8 bool
 }
 
-type statsOption func(*statsOptions)
+type StatsOption func(*statsOptions)
 
-func WithWN8() statsOption {
+func WithWN8() StatsOption {
 	return func(so *statsOptions) {
 		so.withWN8 = true
 	}
diff --git a/internal/stats/fetch/v1/multisource.go b/internal/stats/fetch/v1/multisource.go
index 0db25424..558b07a3 100644
--- a/internal/stats/fetch/v1/multisource.go
+++ b/internal/stats/fetch/v1/multisource.go
@@ -106,7 +106,7 @@ Get live account stats from wargaming
   - Each request will be retried c.retriesPerRequest times
   - This function will assume the player ID is valid and optimistically run all request concurrently, returning the first error once all request finish
 */
-func (c *multiSourceClient) CurrentStats(ctx context.Context, id string, opts ...statsOption) (AccountStatsOverPeriod, error) {
+func (c *multiSourceClient) CurrentStats(ctx context.Context, id string, opts ...StatsOption) (AccountStatsOverPeriod, error) {
 	var options statsOptions
 	for _, apply := range opts {
 		apply(&options)
@@ -187,7 +187,7 @@ func (c *multiSourceClient) CurrentStats(ctx context.Context, id string, opts ..
 	return stats, nil
 }
 
-func (c *multiSourceClient) PeriodStats(ctx context.Context, id string, periodStart time.Time, opts ...statsOption) (AccountStatsOverPeriod, error) {
+func (c *multiSourceClient) PeriodStats(ctx context.Context, id string, periodStart time.Time, opts ...StatsOption) (AccountStatsOverPeriod, error) {
 	var options statsOptions
 	for _, apply := range opts {
 		apply(&options)
@@ -271,7 +271,7 @@ func (c *multiSourceClient) PeriodStats(ctx context.Context, id string, periodSt
 	return stats, nil
 }
 
-func (c *multiSourceClient) SessionStats(ctx context.Context, id string, sessionStart time.Time, opts ...statsOption) (AccountStatsOverPeriod, AccountStatsOverPeriod, error) {
+func (c *multiSourceClient) SessionStats(ctx context.Context, id string, sessionStart time.Time, opts ...StatsOption) (AccountStatsOverPeriod, AccountStatsOverPeriod, error) {
 	var options statsOptions
 	for _, apply := range opts {
 		apply(&options)
diff --git a/internal/stats/render/session/v1/cards.go b/internal/stats/render/session/v1/cards.go
index e089214f..2ce92711 100644
--- a/internal/stats/render/session/v1/cards.go
+++ b/internal/stats/render/session/v1/cards.go
@@ -48,6 +48,7 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 	highlightCardBlockSizes := make(map[string]float64)
 	var primaryCardWidth float64 = minPrimaryCardWidth
 	var secondaryCardWidth, totalFrameWidth float64
+	var overviewColumnMaxWidth float64
 	// rating and unrated battles > 0	 	   unrated battles > 0		   rating battles > 0
 	// [title card		] | [vehicle]    [title card	  ] | [vehicle]    [title card	  	]
 	// [overview unrated] | [vehicle] OR [overview unrated] | [vehicle] OR [overview rating ]
@@ -73,6 +74,7 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 			styleWithIconOffset.session.PaddingX += vehicleComparisonIconSize
 
 			presetBlockWidth, contentWidth := overviewColumnBlocksWidth(column, styleWithIconOffset.session, styleWithIconOffset.career, styleWithIconOffset.label, overviewColumnStyle(0))
+			overviewColumnMaxWidth = common.Max(overviewColumnMaxWidth, contentWidth)
 			totalContentWidth += contentWidth
 			for key, width := range presetBlockWidth {
 				primaryCardBlockSizes[key] = common.Max(primaryCardBlockSizes[key], width)
@@ -88,6 +90,7 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 			styleWithIconOffset.session.PaddingX += vehicleComparisonIconSize
 
 			presetBlockWidth, contentWidth := overviewColumnBlocksWidth(column, styleWithIconOffset.session, styleWithIconOffset.career, styleWithIconOffset.label, overviewColumnStyle(0))
+			overviewColumnMaxWidth = common.Max(overviewColumnMaxWidth, contentWidth)
 			totalContentWidth += contentWidth
 			for key, width := range presetBlockWidth {
 				primaryCardBlockSizes[key] = common.Max(primaryCardBlockSizes[key], width)
@@ -196,10 +199,10 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 
 	// overview cards
 	if shouldRenderUnratedOverview {
-		primaryColumn = append(primaryColumn, makeOverviewCard(cards.Unrated.Overview, primaryCardBlockSizes, overviewCardStyle(primaryCardWidth)))
+		primaryColumn = append(primaryColumn, makeOverviewCard(cards.Unrated.Overview, primaryCardBlockSizes, overviewCardStyle(primaryCardWidth), overviewColumnMaxWidth))
 	}
 	if shouldRenderRatingOverview {
-		primaryColumn = append(primaryColumn, makeOverviewCard(cards.Rating.Overview, primaryCardBlockSizes, overviewRatingCardStyle(primaryCardWidth)))
+		primaryColumn = append(primaryColumn, makeOverviewCard(cards.Rating.Overview, primaryCardBlockSizes, overviewRatingCardStyle(primaryCardWidth), overviewColumnMaxWidth))
 	}
 
 	// highlights
@@ -387,31 +390,32 @@ func makeVehicleLegendCard(reference session.VehicleCard, blockSizes map[string]
 	return common.NewBlocksContent(containerStyle, common.NewBlocksContent(vehicleBlocksRowStyle(0), content...))
 }
 
-func makeOverviewCard(card session.OverviewCard, blockSizes map[string]float64, style common.Style) common.Block {
+func makeOverviewCard(card session.OverviewCard, blockSizes map[string]float64, style common.Style, columnWidth float64) common.Block {
 	// made all columns the same width for things to be centered
-	columnWidth := (style.Width - style.Gap*float64(len(card.Blocks)-1) - style.PaddingX*2) / float64(len(card.Blocks))
 	var content []common.Block // add a blank block to balance the offset added from icons
 	blockStyle := vehicleBlockStyle()
 	for _, column := range card.Blocks {
 		var columnContent []common.Block
 		for _, block := range column {
 			var col common.Block
+			blockWidth := columnWidth // fit the block to column width to make things look even
 			if block.Tag == prepare.TagWN8 || block.Tag == prepare.TagRankedRating {
-				col = makeSpecialRatingColumn(block, blockSizes[block.Tag.String()])
+				blockWidth = blockSizes[block.Tag.String()]
+				col = makeSpecialRatingColumn(block, blockWidth)
 			} else if blockShouldHaveCompareIcon(block) {
-				col = common.NewBlocksContent(statsBlockStyle(blockSizes[block.Tag.String()]),
+				col = common.NewBlocksContent(statsBlockStyle(blockWidth),
 					blockWithDoubleVehicleIcon(common.NewTextContent(blockStyle.session, block.Data.Session.String()), block.Data.Session, block.Data.Career),
 					common.NewTextContent(blockStyle.label, block.Label),
 				)
 			} else {
-				col = common.NewBlocksContent(statsBlockStyle(blockSizes[block.Tag.String()]),
+				col = common.NewBlocksContent(statsBlockStyle(blockWidth),
 					common.NewTextContent(blockStyle.session, block.Data.Session.String()),
 					common.NewTextContent(blockStyle.label, block.Label),
 				)
 			}
 			columnContent = append(columnContent, col)
 		}
-		content = append(content, common.NewBlocksContent(overviewColumnStyle(columnWidth), columnContent...))
+		content = append(content, common.NewBlocksContent(overviewColumnStyle(0), columnContent...))
 	}
 	return common.NewBlocksContent(style, content...)
 }
diff --git a/render_test.go b/render_test.go
index 77756364..855dccf0 100644
--- a/render_test.go
+++ b/render_test.go
@@ -8,6 +8,7 @@ import (
 
 	"github.com/cufee/aftermath/internal/stats/render/common/v1"
 	stats "github.com/cufee/aftermath/internal/stats/renderer/v1"
+	"github.com/cufee/aftermath/tests"
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/assert"
 	"golang.org/x/text/language"
@@ -22,14 +23,8 @@ func TestRenderSession(t *testing.T) {
 
 	loadStaticAssets(static)
 
-	db, err := newDatabaseClientFromEnv()
-	assert.NoError(t, err)
-
-	coreClient, _ := coreClientsFromEnv(db)
-	defer coreClient.Database().Disconnect()
-
-	renderer := stats.NewRenderer(coreClient.Fetch(), coreClient.Database(), coreClient.Wargaming(), language.English)
-	image, _, err := renderer.Session(context.Background(), "1013072123", time.Now(), common.WithBackground(""))
+	renderer := stats.NewRenderer(tests.StaticTestingFetch(), tests.StaticTestingDatabase(), nil, language.English)
+	image, _, err := renderer.Session(context.Background(), tests.DefaultAccountNA, time.Now(), common.WithBackground(""))
 	assert.NoError(t, err, "failed to render a session image")
 	assert.NotNil(t, image, "image is nil")
 
diff --git a/tests/static_data.go b/tests/static_data.go
new file mode 100644
index 00000000..36f37df5
--- /dev/null
+++ b/tests/static_data.go
@@ -0,0 +1,109 @@
+package tests
+
+import (
+	"time"
+
+	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/stats/frame"
+)
+
+const DefaultAccountNA = "account1"
+const DefaultAccountEU = "account2"
+const DefaultAccountAS = "account3"
+
+var staticAccounts = map[string]models.Account{
+	DefaultAccountNA: {ID: DefaultAccountNA, Realm: "NA", Nickname: "@test_account_na_1", CreatedAt: time.Now(), LastBattleTime: time.Now(), ClanID: "clan1", ClanTag: "TEST1"},
+	DefaultAccountEU: {ID: DefaultAccountEU, Realm: "EU", Nickname: "@test_account_eu_1", CreatedAt: time.Now(), LastBattleTime: time.Now(), ClanID: "clan2", ClanTag: "TEST2"},
+	DefaultAccountAS: {ID: DefaultAccountAS, Realm: "AS", Nickname: "@test_account_as_1", CreatedAt: time.Now(), LastBattleTime: time.Now(), ClanID: "clan3", ClanTag: "TEST3"},
+}
+
+var (
+	DefaultStatsFrameBig1 = frame.StatsFrame{
+		Battles:              100,
+		BattlesWon:           80,
+		BattlesSurvived:      70,
+		DamageDealt:          234567,
+		DamageReceived:       123567,
+		ShotsHit:             690,
+		ShotsFired:           1000,
+		Frags:                420,
+		MaxFrags:             50,
+		EnemiesSpotted:       240,
+		CapturePoints:        0,
+		DroppedCapturePoints: 0,
+		Rating:               100,
+	}
+	DefaultStatsFrameBig2 = frame.StatsFrame{
+		Battles:              45,
+		BattlesWon:           34,
+		BattlesSurvived:      60,
+		DamageDealt:          234567 / 2,
+		DamageReceived:       123567 / 2,
+		ShotsHit:             690 / 2,
+		ShotsFired:           1000 / 2,
+		Frags:                420 / 2,
+		MaxFrags:             50 / 2,
+		EnemiesSpotted:       240 / 2,
+		CapturePoints:        0,
+		DroppedCapturePoints: 0,
+		Rating:               100,
+	}
+	DefaultStatsFrameSmall1 = frame.StatsFrame{
+		Battles:              20,
+		BattlesWon:           16,
+		BattlesSurvived:      14,
+		DamageDealt:          23456 * 2,
+		DamageReceived:       12356 * 2,
+		ShotsHit:             69 * 2,
+		ShotsFired:           100 * 2,
+		Frags:                42 * 2,
+		MaxFrags:             5 * 2,
+		EnemiesSpotted:       24 * 2,
+		CapturePoints:        0,
+		DroppedCapturePoints: 0,
+		Rating:               100,
+	}
+	DefaultStatsFrameSmall2 = frame.StatsFrame{
+		Battles:              10,
+		BattlesWon:           8,
+		BattlesSurvived:      7,
+		DamageDealt:          23456,
+		DamageReceived:       12356,
+		ShotsHit:             69,
+		ShotsFired:           100,
+		Frags:                42,
+		MaxFrags:             5,
+		EnemiesSpotted:       24,
+		CapturePoints:        0,
+		DroppedCapturePoints: 0,
+		Rating:               100,
+	}
+)
+
+func DefaultVehicleStatsFrameBig1(id string) frame.VehicleStatsFrame {
+	return frame.VehicleStatsFrame{
+		VehicleID:  id,
+		StatsFrame: &DefaultStatsFrameBig1,
+	}
+}
+
+func DefaultVehicleStatsFrameBig2(id string) frame.VehicleStatsFrame {
+	return frame.VehicleStatsFrame{
+		VehicleID:  id,
+		StatsFrame: &DefaultStatsFrameBig2,
+	}
+}
+
+func DefaultVehicleStatsFrameSmall1(id string) frame.VehicleStatsFrame {
+	return frame.VehicleStatsFrame{
+		VehicleID:  id,
+		StatsFrame: &DefaultStatsFrameSmall1,
+	}
+}
+
+func DefaultVehicleStatsFrameSmall2(id string) frame.VehicleStatsFrame {
+	return frame.VehicleStatsFrame{
+		VehicleID:  id,
+		StatsFrame: &DefaultStatsFrameSmall2,
+	}
+}
diff --git a/tests/static_database.go b/tests/static_database.go
new file mode 100644
index 00000000..29fdfab6
--- /dev/null
+++ b/tests/static_database.go
@@ -0,0 +1,159 @@
+package tests
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/ent/db"
+	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/permissions"
+	"github.com/cufee/aftermath/internal/stats/frame"
+)
+
+var ErrNotFound = &db.NotFoundError{}
+
+var _ database.Client = &staticTestingDatabase{}
+
+type staticTestingDatabase struct{}
+
+func StaticTestingDatabase() *staticTestingDatabase {
+	return &staticTestingDatabase{}
+}
+
+func (c *staticTestingDatabase) Disconnect() error {
+	return nil
+}
+
+func (c *staticTestingDatabase) GetAccounts(ctx context.Context, ids []string) ([]models.Account, error) {
+	var accounts []models.Account
+	for _, id := range ids {
+		if a, ok := staticAccounts[id]; ok {
+			accounts = append(accounts, a)
+		}
+	}
+	return accounts, nil
+}
+func (c *staticTestingDatabase) GetAccountByID(ctx context.Context, id string) (models.Account, error) {
+	if account, ok := staticAccounts[id]; ok {
+		return account, nil
+	}
+	return models.Account{}, ErrNotFound
+}
+func (c *staticTestingDatabase) GetRealmAccountIDs(ctx context.Context, realm string) ([]string, error) {
+	return nil, errors.New("GetRealmAccountIDs not implemented")
+}
+func (c *staticTestingDatabase) AccountSetPrivate(ctx context.Context, id string, value bool) error {
+	return errors.New("AccountSetPrivate not implemented")
+}
+func (c *staticTestingDatabase) UpsertAccounts(ctx context.Context, accounts []models.Account) (map[string]error, error) {
+	for _, acc := range accounts {
+		if account, ok := staticAccounts[acc.ID]; ok {
+			staticAccounts[acc.ID] = account
+		}
+	}
+	return nil, nil
+}
+
+func (c *staticTestingDatabase) GetVehicles(ctx context.Context, ids []string) (map[string]models.Vehicle, error) {
+	vehicles := make(map[string]models.Vehicle)
+	for _, id := range ids {
+		vehicles[id] = models.Vehicle{ID: id, Tier: 10, LocalizedNames: map[string]string{"en": "Test Vehicle " + id}}
+	}
+	return vehicles, nil
+}
+func (c *staticTestingDatabase) GetVehicleAverages(ctx context.Context, ids []string) (map[string]frame.StatsFrame, error) {
+	// TODO: get some kind of data in
+	return map[string]frame.StatsFrame{}, nil
+}
+func (c *staticTestingDatabase) UpsertVehicles(ctx context.Context, vehicles map[string]models.Vehicle) (map[string]error, error) {
+	return nil, errors.New("UpsertVehicles not implemented")
+}
+func (c *staticTestingDatabase) UpsertVehicleAverages(ctx context.Context, averages map[string]frame.StatsFrame) (map[string]error, error) {
+	return nil, errors.New("UpsertVehicleAverages not implemented")
+}
+
+func (c *staticTestingDatabase) GetUserByID(ctx context.Context, id string, opts ...database.UserGetOption) (models.User, error) {
+	return models.User{}, errors.New("GetUserByID not implemented")
+}
+func (c *staticTestingDatabase) GetOrCreateUserByID(ctx context.Context, id string, opts ...database.UserGetOption) (models.User, error) {
+	return models.User{}, errors.New("GetOrCreateUserByID not implemented")
+}
+func (c *staticTestingDatabase) UpsertUserWithPermissions(ctx context.Context, userID string, perms permissions.Permissions) (models.User, error) {
+	return models.User{}, errors.New("UpsertUserWithPermissions not implemented")
+}
+func (c *staticTestingDatabase) UpdateConnection(ctx context.Context, connection models.UserConnection) (models.UserConnection, error) {
+	return models.UserConnection{}, errors.New("UpdateConnection not implemented")
+}
+func (c *staticTestingDatabase) UpsertConnection(ctx context.Context, connection models.UserConnection) (models.UserConnection, error) {
+	return models.UserConnection{}, errors.New("UpsertConnection not implemented")
+}
+
+func (c *staticTestingDatabase) GetAccountSnapshot(ctx context.Context, accountID, referenceID string, kind models.SnapshotType, options ...database.SnapshotQuery) (models.AccountSnapshot, error) {
+	return models.AccountSnapshot{}, errors.New("GetAccountSnapshot not implemented")
+}
+func (c *staticTestingDatabase) CreateAccountSnapshots(ctx context.Context, snapshots ...models.AccountSnapshot) (map[string]error, error) {
+	return nil, errors.New("CreateAccountSnapshots not implemented")
+}
+func (c *staticTestingDatabase) GetLastAccountSnapshots(ctx context.Context, accountID string, limit int) ([]models.AccountSnapshot, error) {
+	return nil, errors.New("GetLastAccountSnapshots not implemented")
+}
+func (c *staticTestingDatabase) GetManyAccountSnapshots(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...database.SnapshotQuery) ([]models.AccountSnapshot, error) {
+	return nil, errors.New("GetManyAccountSnapshots not implemented")
+}
+func (c *staticTestingDatabase) GetVehicleSnapshots(ctx context.Context, accountID, referenceID string, kind models.SnapshotType, options ...database.SnapshotQuery) ([]models.VehicleSnapshot, error) {
+	return nil, errors.New("GetVehicleSnapshots not implemented")
+}
+func (c *staticTestingDatabase) CreateAccountVehicleSnapshots(ctx context.Context, accountID string, snapshots ...models.VehicleSnapshot) (map[string]error, error) {
+	return nil, errors.New("CreateAccountVehicleSnapshots not implemented")
+}
+func (c *staticTestingDatabase) DeleteExpiredSnapshots(ctx context.Context, expiration time.Time) error {
+	return errors.New("DeleteExpiredSnapshots not implemented")
+}
+
+func (c *staticTestingDatabase) CreateTasks(ctx context.Context, tasks ...models.Task) error {
+	return errors.New("not implemented")
+}
+func (c *staticTestingDatabase) GetTasks(ctx context.Context, ids ...string) ([]models.Task, error) {
+	return nil, errors.New("CreateTasks not implemented")
+}
+func (c *staticTestingDatabase) UpdateTasks(ctx context.Context, tasks ...models.Task) error {
+	return errors.New("UpdateTasks not implemented")
+}
+func (c *staticTestingDatabase) DeleteTasks(ctx context.Context, ids ...string) error {
+	return errors.New("DeleteTasks not implemented")
+}
+func (c *staticTestingDatabase) AbandonTasks(ctx context.Context, ids ...string) error {
+	return errors.New("AbandonTasks not implemented")
+}
+
+func (c *staticTestingDatabase) GetStaleTasks(ctx context.Context, limit int) ([]models.Task, error) {
+	return nil, errors.New("GetStaleTasks not implemented")
+}
+func (c *staticTestingDatabase) GetRecentTasks(ctx context.Context, createdAfter time.Time, status ...models.TaskStatus) ([]models.Task, error) {
+	return nil, errors.New("GetRecentTasks not implemented")
+}
+func (c *staticTestingDatabase) GetAndStartTasks(ctx context.Context, limit int) ([]models.Task, error) {
+	return nil, errors.New("GetAndStartTasks not implemented")
+}
+func (c *staticTestingDatabase) DeleteExpiredTasks(ctx context.Context, expiration time.Time) error {
+	return errors.New("DeleteExpiredTasks not implemented")
+}
+
+func (c *staticTestingDatabase) UpsertCommands(ctx context.Context, commands ...models.ApplicationCommand) error {
+	return errors.New("UpsertCommands not implemented")
+}
+func (c *staticTestingDatabase) GetCommandsByID(ctx context.Context, commandIDs ...string) ([]models.ApplicationCommand, error) {
+	return nil, errors.New("GetCommandsByID not implemented")
+}
+
+func (c *staticTestingDatabase) CreateDiscordInteraction(ctx context.Context, data models.DiscordInteraction) error {
+	return errors.New("CreateDiscordInteraction not implemented")
+}
+func (c *staticTestingDatabase) GetDiscordInteraction(ctx context.Context, referenceID string) (models.DiscordInteraction, error) {
+	return models.DiscordInteraction{}, errors.New("GetDiscordInteraction not implemented")
+}
+func (c *staticTestingDatabase) DeleteExpiredInteractions(ctx context.Context, expiration time.Time) error {
+	return errors.New("DeleteExpiredInteractions not implemented")
+}
diff --git a/tests/static_fetch.go b/tests/static_fetch.go
new file mode 100644
index 00000000..41dfc92f
--- /dev/null
+++ b/tests/static_fetch.go
@@ -0,0 +1,93 @@
+package tests
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/stats/fetch/v1"
+	"github.com/cufee/aftermath/internal/stats/frame"
+	"github.com/cufee/am-wg-proxy-next/v2/types"
+	"github.com/pkg/errors"
+)
+
+var _ fetch.Client = &staticTestingFetch{}
+
+type staticTestingFetch struct{}
+
+func StaticTestingFetch() *staticTestingFetch {
+	return &staticTestingFetch{}
+}
+
+func (c *staticTestingFetch) Account(ctx context.Context, id string) (models.Account, error) {
+	if account, ok := staticAccounts[id]; ok {
+		return account, nil
+	}
+	return models.Account{}, errors.New("account not found")
+}
+func (c *staticTestingFetch) Search(ctx context.Context, nickname, realm string) (types.Account, error) {
+	return types.Account{}, nil
+}
+func (c *staticTestingFetch) CurrentStats(ctx context.Context, id string, opts ...fetch.StatsOption) (fetch.AccountStatsOverPeriod, error) {
+	account, err := c.Account(ctx, id)
+	if err != nil {
+		return fetch.AccountStatsOverPeriod{}, err
+	}
+
+	var vehicles = make(map[string]frame.VehicleStatsFrame)
+	for id := range 10 {
+		vehicles[fmt.Sprint(id)] = DefaultVehicleStatsFrameBig1(fmt.Sprint(id))
+	}
+
+	return fetch.AccountStatsOverPeriod{
+		Account: account,
+		Realm:   account.Realm,
+
+		PeriodEnd:      time.Now(),
+		PeriodStart:    time.Now().Add(time.Hour * 25 * 1),
+		LastBattleTime: time.Now(),
+
+		RegularBattles: fetch.StatsWithVehicles{
+			Vehicles:   vehicles,
+			StatsFrame: DefaultStatsFrameBig1,
+		},
+		RatingBattles: fetch.StatsWithVehicles{
+			StatsFrame: DefaultStatsFrameBig2,
+		},
+	}, nil
+}
+
+func (c *staticTestingFetch) PeriodStats(ctx context.Context, id string, from time.Time, opts ...fetch.StatsOption) (fetch.AccountStatsOverPeriod, error) {
+	current, err := c.CurrentStats(ctx, id, opts...)
+	if err != nil {
+		return fetch.AccountStatsOverPeriod{}, err
+	}
+
+	current.PeriodStart = from
+	current.RegularBattles.StatsFrame.Subtract(DefaultStatsFrameSmall1)
+	current.RatingBattles.StatsFrame.Subtract(DefaultStatsFrameSmall2)
+
+	for id, stats := range current.RegularBattles.Vehicles {
+		stats.StatsFrame.Subtract(DefaultStatsFrameSmall1)
+		current.RegularBattles.Vehicles[id] = stats
+	}
+	return current, nil
+}
+func (c *staticTestingFetch) SessionStats(ctx context.Context, id string, sessionStart time.Time, opts ...fetch.StatsOption) (fetch.AccountStatsOverPeriod, fetch.AccountStatsOverPeriod, error) {
+	session, err := c.PeriodStats(ctx, id, sessionStart, opts...)
+	if err != nil {
+		return fetch.AccountStatsOverPeriod{}, fetch.AccountStatsOverPeriod{}, err
+	}
+	career, err := c.CurrentStats(ctx, id, opts...)
+	if err != nil {
+		return fetch.AccountStatsOverPeriod{}, fetch.AccountStatsOverPeriod{}, err
+	}
+
+	return session, career, nil
+}
+
+func (c *staticTestingFetch) CurrentTankAverages(ctx context.Context) (map[string]frame.StatsFrame, error) {
+	// TODO: add some data
+	return map[string]frame.StatsFrame{}, nil
+}

From 7ef12ea50ee7f6611c7f9a03919134a512635108 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 27 Jun 2024 20:49:17 -0400
Subject: [PATCH 210/341] fixed vehicle frames

---
 tests/static_data.go  | 12 ++++++++----
 tests/static_fetch.go |  1 +
 2 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/tests/static_data.go b/tests/static_data.go
index 36f37df5..2344548c 100644
--- a/tests/static_data.go
+++ b/tests/static_data.go
@@ -81,29 +81,33 @@ var (
 )
 
 func DefaultVehicleStatsFrameBig1(id string) frame.VehicleStatsFrame {
+	f := DefaultStatsFrameBig1
 	return frame.VehicleStatsFrame{
 		VehicleID:  id,
-		StatsFrame: &DefaultStatsFrameBig1,
+		StatsFrame: &f,
 	}
 }
 
 func DefaultVehicleStatsFrameBig2(id string) frame.VehicleStatsFrame {
+	f := DefaultStatsFrameBig2
 	return frame.VehicleStatsFrame{
 		VehicleID:  id,
-		StatsFrame: &DefaultStatsFrameBig2,
+		StatsFrame: &f,
 	}
 }
 
 func DefaultVehicleStatsFrameSmall1(id string) frame.VehicleStatsFrame {
+	f := DefaultStatsFrameSmall1
 	return frame.VehicleStatsFrame{
 		VehicleID:  id,
-		StatsFrame: &DefaultStatsFrameSmall1,
+		StatsFrame: &f,
 	}
 }
 
 func DefaultVehicleStatsFrameSmall2(id string) frame.VehicleStatsFrame {
+	f := DefaultStatsFrameSmall2
 	return frame.VehicleStatsFrame{
 		VehicleID:  id,
-		StatsFrame: &DefaultStatsFrameSmall2,
+		StatsFrame: &f,
 	}
 }
diff --git a/tests/static_fetch.go b/tests/static_fetch.go
index 41dfc92f..530cff6f 100644
--- a/tests/static_fetch.go
+++ b/tests/static_fetch.go
@@ -71,6 +71,7 @@ func (c *staticTestingFetch) PeriodStats(ctx context.Context, id string, from ti
 	for id, stats := range current.RegularBattles.Vehicles {
 		stats.StatsFrame.Subtract(DefaultStatsFrameSmall1)
 		current.RegularBattles.Vehicles[id] = stats
+		fmt.Printf("%#v\n", stats.StatsFrame)
 	}
 	return current, nil
 }

From a1c18aa52bcc0c9d53b60e31fa90628988825ade Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 27 Jun 2024 20:52:46 -0400
Subject: [PATCH 211/341] added short nickname option

---
 render_test.go        | 2 +-
 tests/static_data.go  | 8 +++++---
 tests/static_fetch.go | 1 -
 3 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/render_test.go b/render_test.go
index 855dccf0..66b12f79 100644
--- a/render_test.go
+++ b/render_test.go
@@ -24,7 +24,7 @@ func TestRenderSession(t *testing.T) {
 	loadStaticAssets(static)
 
 	renderer := stats.NewRenderer(tests.StaticTestingFetch(), tests.StaticTestingDatabase(), nil, language.English)
-	image, _, err := renderer.Session(context.Background(), tests.DefaultAccountNA, time.Now(), common.WithBackground(""))
+	image, _, err := renderer.Session(context.Background(), tests.DefaultAccountNAShort, time.Now(), common.WithBackground(""))
 	assert.NoError(t, err, "failed to render a session image")
 	assert.NotNil(t, image, "image is nil")
 
diff --git a/tests/static_data.go b/tests/static_data.go
index 2344548c..93dcc80c 100644
--- a/tests/static_data.go
+++ b/tests/static_data.go
@@ -8,13 +8,15 @@ import (
 )
 
 const DefaultAccountNA = "account1"
+const DefaultAccountNAShort = "account11"
 const DefaultAccountEU = "account2"
 const DefaultAccountAS = "account3"
 
 var staticAccounts = map[string]models.Account{
-	DefaultAccountNA: {ID: DefaultAccountNA, Realm: "NA", Nickname: "@test_account_na_1", CreatedAt: time.Now(), LastBattleTime: time.Now(), ClanID: "clan1", ClanTag: "TEST1"},
-	DefaultAccountEU: {ID: DefaultAccountEU, Realm: "EU", Nickname: "@test_account_eu_1", CreatedAt: time.Now(), LastBattleTime: time.Now(), ClanID: "clan2", ClanTag: "TEST2"},
-	DefaultAccountAS: {ID: DefaultAccountAS, Realm: "AS", Nickname: "@test_account_as_1", CreatedAt: time.Now(), LastBattleTime: time.Now(), ClanID: "clan3", ClanTag: "TEST3"},
+	DefaultAccountNA:      {ID: DefaultAccountNA, Realm: "NA", Nickname: "@test_account_na_1", CreatedAt: time.Now(), LastBattleTime: time.Now(), ClanID: "clan1", ClanTag: "TEST1"},
+	DefaultAccountNAShort: {ID: DefaultAccountNA, Realm: "NA", Nickname: "@test_acc", CreatedAt: time.Now(), LastBattleTime: time.Now(), ClanID: "clan1", ClanTag: "TEST1"},
+	DefaultAccountEU:      {ID: DefaultAccountEU, Realm: "EU", Nickname: "@test_account_eu_1", CreatedAt: time.Now(), LastBattleTime: time.Now(), ClanID: "clan2", ClanTag: "TEST2"},
+	DefaultAccountAS:      {ID: DefaultAccountAS, Realm: "AS", Nickname: "@test_account_as_1", CreatedAt: time.Now(), LastBattleTime: time.Now(), ClanID: "clan3", ClanTag: "TEST3"},
 }
 
 var (
diff --git a/tests/static_fetch.go b/tests/static_fetch.go
index 530cff6f..41dfc92f 100644
--- a/tests/static_fetch.go
+++ b/tests/static_fetch.go
@@ -71,7 +71,6 @@ func (c *staticTestingFetch) PeriodStats(ctx context.Context, id string, from ti
 	for id, stats := range current.RegularBattles.Vehicles {
 		stats.StatsFrame.Subtract(DefaultStatsFrameSmall1)
 		current.RegularBattles.Vehicles[id] = stats
-		fmt.Printf("%#v\n", stats.StatsFrame)
 	}
 	return current, nil
 }

From a67474e7be8e24751bf70cf5324d6d647ad58de5 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 27 Jun 2024 20:57:20 -0400
Subject: [PATCH 212/341] minot ui tweaks

---
 internal/stats/render/session/v1/constants.go |  3 +-
 render_test.go                                | 33 ++++++++++++++-----
 2 files changed, 26 insertions(+), 10 deletions(-)

diff --git a/internal/stats/render/session/v1/constants.go b/internal/stats/render/session/v1/constants.go
index bdbfd3e1..fa46eb4f 100644
--- a/internal/stats/render/session/v1/constants.go
+++ b/internal/stats/render/session/v1/constants.go
@@ -63,7 +63,8 @@ func overviewColumnStyle(width float64) common.Style {
 
 func overviewCardStyle(width float64) common.Style {
 	style := defaultCardStyle(width)
-	style.JustifyContent = common.JustifyContentSpaceBetween
+	// style.JustifyContent = common.JustifyContentSpaceBetween
+	style.JustifyContent = common.JustifyContentSpaceAround
 	style.Direction = common.DirectionHorizontal
 	style.AlignItems = common.AlignItemsEnd
 	style.PaddingY = 20
diff --git a/render_test.go b/render_test.go
index 66b12f79..e995f5f6 100644
--- a/render_test.go
+++ b/render_test.go
@@ -24,14 +24,29 @@ func TestRenderSession(t *testing.T) {
 	loadStaticAssets(static)
 
 	renderer := stats.NewRenderer(tests.StaticTestingFetch(), tests.StaticTestingDatabase(), nil, language.English)
-	image, _, err := renderer.Session(context.Background(), tests.DefaultAccountNAShort, time.Now(), common.WithBackground(""))
-	assert.NoError(t, err, "failed to render a session image")
-	assert.NotNil(t, image, "image is nil")
 
-	f, err := os.Create("tmp/render_test_session.png")
-	assert.NoError(t, err, "failed to create a file")
-	defer f.Close()
-
-	err = image.PNG(f)
-	assert.NoError(t, err, "failed to encode a png image")
+	{
+		image, _, err := renderer.Session(context.Background(), tests.DefaultAccountNAShort, time.Now(), common.WithBackground(""))
+		assert.NoError(t, err, "failed to render a session image")
+		assert.NotNil(t, image, "image is nil")
+
+		f, err := os.Create("tmp/render_test_session_full_small.png")
+		assert.NoError(t, err, "failed to create a file")
+		defer f.Close()
+
+		err = image.PNG(f)
+		assert.NoError(t, err, "failed to encode a png image")
+	}
+	{
+		image, _, err := renderer.Session(context.Background(), tests.DefaultAccountNA, time.Now(), common.WithBackground(""))
+		assert.NoError(t, err, "failed to render a session image")
+		assert.NotNil(t, image, "image is nil")
+
+		f, err := os.Create("tmp/render_test_session_full_large.png")
+		assert.NoError(t, err, "failed to create a file")
+		defer f.Close()
+
+		err = image.PNG(f)
+		assert.NoError(t, err, "failed to encode a png image")
+	}
 }

From 38d46b9c89ed6fdb6ed5cb1ce3dec5e4690888ed Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 27 Jun 2024 21:22:50 -0400
Subject: [PATCH 213/341] fixed localization on fmt strings

---
 cmd/discord/common/reply.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/cmd/discord/common/reply.go b/cmd/discord/common/reply.go
index 457a253e..70fe2080 100644
--- a/cmd/discord/common/reply.go
+++ b/cmd/discord/common/reply.go
@@ -23,7 +23,7 @@ func (r reply) Text(message ...string) reply {
 }
 
 func (r reply) Format(format string, args ...any) reply {
-	r.text = append(r.text, fmt.Sprintf(format, args...))
+	r.text = append(r.text, fmt.Sprintf(r.ctx.Localize(format), args...))
 	return r
 }
 
@@ -63,7 +63,7 @@ func (r reply) Send(content ...string) error {
 func (r reply) data(localePrinter func(string) string) discordgo.InteractionResponseData {
 	var content []string
 	for _, t := range r.text {
-		content = append(content, localePrinter(t))
+		content = append(content, r.ctx.Localize(t))
 	}
 	return discordgo.InteractionResponseData{
 		Content:    strings.Join(content, "\n"),

From b0dec9db2d06cbbc68710ca85a481b285dbb3f40 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 27 Jun 2024 22:39:39 -0400
Subject: [PATCH 214/341] fixed special col width calculations

---
 internal/stats/fetch/v1/multisource.go        |  9 ++--
 internal/stats/prepare/period/v1/card.go      |  4 +-
 internal/stats/prepare/period/v1/constants.go | 18 ++++++-
 internal/stats/prepare/session/v1/card.go     | 15 +++---
 .../stats/prepare/session/v1/constants.go     | 33 +++++++++++--
 internal/stats/render/period/v1/cards.go      |  4 +-
 internal/stats/render/session/v1/cards.go     | 49 ++++++++++++-------
 tests/static_fetch.go                         | 12 +++--
 8 files changed, 104 insertions(+), 40 deletions(-)

diff --git a/internal/stats/fetch/v1/multisource.go b/internal/stats/fetch/v1/multisource.go
index 558b07a3..060398e7 100644
--- a/internal/stats/fetch/v1/multisource.go
+++ b/internal/stats/fetch/v1/multisource.go
@@ -317,7 +317,7 @@ func (c *multiSourceClient) SessionStats(ctx context.Context, id string, session
 			return
 		}
 
-		v, err := c.database.GetVehicleSnapshots(ctx, id, id, models.SnapshotTypeDaily, database.WithCreatedBefore(s.LastBattleTime.Add(time.Second)))
+		v, err := c.database.GetVehicleSnapshots(ctx, id, id, models.SnapshotTypeDaily, database.WithCreatedBefore(sessionBefore))
 		vehiclesSnapshots = retry.DataWithErr[[]models.VehicleSnapshot]{Data: v, Err: err}
 	}()
 
@@ -378,8 +378,11 @@ func (c *multiSourceClient) SessionStats(ctx context.Context, id string, session
 			continue
 		}
 
-		current.StatsFrame.Subtract(snapshot.Stats)
-		session.RegularBattles.Vehicles[id] = current
+		sessionFrame := current
+		stats := *current.StatsFrame
+		stats.Subtract(snapshot.Stats)
+		sessionFrame.StatsFrame = &stats
+		session.RegularBattles.Vehicles[id] = sessionFrame
 	}
 
 	if options.withWN8 {
diff --git a/internal/stats/prepare/period/v1/card.go b/internal/stats/prepare/period/v1/card.go
index ce1e0407..a6ffca86 100644
--- a/internal/stats/prepare/period/v1/card.go
+++ b/internal/stats/prepare/period/v1/card.go
@@ -23,7 +23,7 @@ func NewCards(stats fetch.AccountStatsOverPeriod, glossary map[string]models.Veh
 	// Overview Card
 	for _, column := range overviewBlocks {
 		var columnBlocks []common.StatsBlock[BlockData]
-		for _, preset := range column {
+		for _, preset := range column.blocks {
 			var block common.StatsBlock[BlockData]
 			b, err := presetToBlock(preset, stats.RegularBattles.StatsFrame, stats.RegularBattles.Vehicles, glossary)
 			if err != nil {
@@ -36,7 +36,7 @@ func NewCards(stats fetch.AccountStatsOverPeriod, glossary map[string]models.Veh
 		}
 
 		cards.Overview.Type = common.CardTypeOverview
-		cards.Overview.Blocks = append(cards.Overview.Blocks, columnBlocks)
+		cards.Overview.Blocks = append(cards.Overview.Blocks, OverviewColumn{columnBlocks, column.flavor})
 	}
 
 	if len(stats.RegularBattles.Vehicles) < 1 || len(highlights) < 1 {
diff --git a/internal/stats/prepare/period/v1/constants.go b/internal/stats/prepare/period/v1/constants.go
index eebf62fc..2b3b9bb4 100644
--- a/internal/stats/prepare/period/v1/constants.go
+++ b/internal/stats/prepare/period/v1/constants.go
@@ -6,7 +6,16 @@ import (
 
 const TagAvgTier common.Tag = "avg_tier"
 
-var overviewBlocks = [][]common.Tag{{common.TagDamageRatio, common.TagAvgDamage, common.TagAccuracy}, {common.TagWN8, common.TagBattles}, {TagAvgTier, common.TagWinrate, common.TagSurvivalPercent}}
+type overviewColumnBlocks struct {
+	blocks []common.Tag
+	flavor blockFlavor
+}
+
+var overviewBlocks = []overviewColumnBlocks{
+	{[]common.Tag{common.TagDamageRatio, common.TagAvgDamage, common.TagAccuracy}, BlockFlavorDefault},
+	{[]common.Tag{common.TagWN8, common.TagBattles}, BlockFlavorSpecial},
+	{[]common.Tag{TagAvgTier, common.TagWinrate, common.TagSurvivalPercent}, BlockFlavorDefault},
+}
 var highlights = []common.Highlight{common.HighlightBattles, common.HighlightWN8, common.HighlightAvgDamage}
 
 type Cards struct {
@@ -14,7 +23,12 @@ type Cards struct {
 	Highlights []VehicleCard `json:"highlights"`
 }
 
-type OverviewCard common.StatsCard[[]common.StatsBlock[BlockData], string]
+type OverviewColumn struct {
+	Blocks []common.StatsBlock[BlockData]
+	Flavor blockFlavor
+}
+
+type OverviewCard common.StatsCard[OverviewColumn, string]
 type VehicleCard common.StatsCard[common.StatsBlock[BlockData], string]
 
 type BlockData struct {
diff --git a/internal/stats/prepare/session/v1/card.go b/internal/stats/prepare/session/v1/card.go
index b74511bc..d9a1a6bb 100644
--- a/internal/stats/prepare/session/v1/card.go
+++ b/internal/stats/prepare/session/v1/card.go
@@ -67,7 +67,7 @@ func NewCards(session, career fetch.AccountStatsOverPeriod, glossary map[string]
 		return int(b.LastBattleTime.Unix() - a.LastBattleTime.Unix())
 	})
 	for _, data := range ratingVehicles {
-		if len(cards.Rating.Vehicles) >= 5 {
+		if len(cards.Rating.Vehicles) >= 10 {
 			break
 		}
 
@@ -221,11 +221,11 @@ func makeHighlightCard(highlight common.Highlight, session, career frame.Vehicle
 	}, nil
 }
 
-func makeOverviewCard(columns [][]common.Tag, session, career frame.StatsFrame, label string, printer func(string) string, replace func(common.Tag) common.Tag) (OverviewCard, error) {
-	var blocks [][]common.StatsBlock[BlockData]
-	for _, presets := range columns {
+func makeOverviewCard(columns []overviewColumnBlocks, session, career frame.StatsFrame, label string, printer func(string) string, replace func(common.Tag) common.Tag) (OverviewCard, error) {
+	var blocks []OverviewColumn
+	for _, columnBlocks := range columns {
 		var column []common.StatsBlock[BlockData]
-		for _, p := range presets {
+		for _, p := range columnBlocks.blocks {
 			preset := p
 			if replace != nil {
 				preset = replace(p)
@@ -237,7 +237,10 @@ func makeOverviewCard(columns [][]common.Tag, session, career frame.StatsFrame,
 			block.Localize(printer)
 			column = append(column, block)
 		}
-		blocks = append(blocks, column)
+		blocks = append(blocks, OverviewColumn{
+			Flavor: columnBlocks.flavor,
+			Blocks: column,
+		})
 	}
 	return OverviewCard{
 		Type:   common.CardTypeOverview,
diff --git a/internal/stats/prepare/session/v1/constants.go b/internal/stats/prepare/session/v1/constants.go
index b663a651..6996f9bf 100644
--- a/internal/stats/prepare/session/v1/constants.go
+++ b/internal/stats/prepare/session/v1/constants.go
@@ -5,8 +5,23 @@ import (
 	"github.com/cufee/aftermath/internal/stats/prepare/common/v1"
 )
 
-var unratedOverviewBlocks = [][]common.Tag{{common.TagBattles, common.TagWinrate}, {common.TagWN8}, {common.TagAvgDamage, common.TagDamageRatio}}
-var ratingOverviewBlocks = [][]common.Tag{{common.TagBattles, common.TagWinrate}, {common.TagRankedRating}, {common.TagAvgDamage, common.TagDamageRatio}}
+type overviewColumnBlocks struct {
+	blocks []common.Tag
+	flavor blockFlavor
+}
+
+var unratedOverviewBlocks = []overviewColumnBlocks{
+	{[]common.Tag{common.TagBattles, common.TagWinrate}, BlockFlavorDefault},
+	{[]common.Tag{common.TagWN8}, BlockFlavorRating},
+	{[]common.Tag{common.TagAvgDamage, common.TagDamageRatio}, BlockFlavorDefault},
+}
+
+var ratingOverviewBlocks = []overviewColumnBlocks{
+	{[]common.Tag{common.TagBattles, common.TagWinrate}, BlockFlavorDefault},
+	{[]common.Tag{common.TagRankedRating}, BlockFlavorRating},
+	{[]common.Tag{common.TagAvgDamage, common.TagDamageRatio}, BlockFlavorDefault},
+}
+
 var vehicleBlocks = []common.Tag{common.TagBattles, common.TagWinrate, common.TagAvgDamage, common.TagWN8}
 var highlights = []common.Highlight{common.HighlightBattles, common.HighlightWN8, common.HighlightAvgDamage}
 
@@ -26,10 +41,22 @@ type RatingCards struct {
 	Vehicles []VehicleCard
 }
 
-type OverviewCard common.StatsCard[[]common.StatsBlock[BlockData], string]
+type OverviewColumn struct {
+	Blocks []common.StatsBlock[BlockData]
+	Flavor blockFlavor
+}
+
+type OverviewCard common.StatsCard[OverviewColumn, string]
 type VehicleCard common.StatsCard[common.StatsBlock[BlockData], string]
 
 type BlockData struct {
 	Session frame.Value
 	Career  frame.Value
 }
+
+type blockFlavor string
+
+const (
+	BlockFlavorDefault blockFlavor = "default"
+	BlockFlavorRating  blockFlavor = "rating"
+)
diff --git a/internal/stats/render/period/v1/cards.go b/internal/stats/render/period/v1/cards.go
index e3f4a350..87551ddc 100644
--- a/internal/stats/render/period/v1/cards.go
+++ b/internal/stats/render/period/v1/cards.go
@@ -35,7 +35,7 @@ func generateCards(stats fetch.AccountStatsOverPeriod, cards period.Cards, subs
 		{
 			rowStyle := getOverviewStyle(cardWidth)
 			for _, column := range cards.Overview.Blocks {
-				for _, block := range column {
+				for _, block := range column.Blocks {
 					valueStyle, labelStyle := rowStyle.block(block)
 
 					label := block.Label
@@ -120,7 +120,7 @@ func generateCards(stats fetch.AccountStatsOverPeriod, cards period.Cards, subs
 	{
 		var overviewCardBlocks []common.Block
 		for _, column := range cards.Overview.Blocks {
-			columnBlock, err := statsBlocksToColumnBlock(getOverviewStyle(overviewColumnWidth), column)
+			columnBlock, err := statsBlocksToColumnBlock(getOverviewStyle(overviewColumnWidth), column.Blocks)
 			if err != nil {
 				return segments, err
 			}
diff --git a/internal/stats/render/session/v1/cards.go b/internal/stats/render/session/v1/cards.go
index 2ce92711..ae0cda4c 100644
--- a/internal/stats/render/session/v1/cards.go
+++ b/internal/stats/render/session/v1/cards.go
@@ -43,12 +43,12 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 	var secondaryColumn []common.Block
 
 	// Calculate minimal card width to fit all the content
+	overviewColumnSizes := make(map[string]float64)
 	primaryCardBlockSizes := make(map[string]float64)
 	secondaryCardBlockSizes := make(map[string]float64)
 	highlightCardBlockSizes := make(map[string]float64)
 	var primaryCardWidth float64 = minPrimaryCardWidth
 	var secondaryCardWidth, totalFrameWidth float64
-	var overviewColumnMaxWidth float64
 	// rating and unrated battles > 0	 	   unrated battles > 0		   rating battles > 0
 	// [title card		] | [vehicle]    [title card	  ] | [vehicle]    [title card	  	]
 	// [overview unrated] | [vehicle] OR [overview unrated] | [vehicle] OR [overview rating ]
@@ -68,36 +68,45 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 	}
 
 	if shouldRenderUnratedOverview {
-		var totalContentWidth float64 = overviewCardStyle(0).Gap * float64(len(cards.Unrated.Overview.Blocks)-1)
 		for _, column := range cards.Unrated.Overview.Blocks {
 			styleWithIconOffset := overviewStatsBlockStyle()
 			styleWithIconOffset.session.PaddingX += vehicleComparisonIconSize
 
-			presetBlockWidth, contentWidth := overviewColumnBlocksWidth(column, styleWithIconOffset.session, styleWithIconOffset.career, styleWithIconOffset.label, overviewColumnStyle(0))
-			overviewColumnMaxWidth = common.Max(overviewColumnMaxWidth, contentWidth)
-			totalContentWidth += contentWidth
+			presetBlockWidth, contentWidth := overviewColumnBlocksWidth(column.Blocks, styleWithIconOffset.session, styleWithIconOffset.career, styleWithIconOffset.label, overviewColumnStyle(0))
+			overviewColumnSizes[string(column.Flavor)] = common.Max(overviewColumnSizes[string(column.Flavor)], contentWidth)
 			for key, width := range presetBlockWidth {
 				primaryCardBlockSizes[key] = common.Max(primaryCardBlockSizes[key], width)
 			}
 		}
-		primaryCardWidth = common.Max(primaryCardWidth, totalContentWidth)
 	}
-
 	if shouldRenderRatingOverview {
-		var totalContentWidth float64 = overviewCardStyle(0).Gap * float64(len(cards.Rating.Overview.Blocks)-1)
-		for _, column := range cards.Unrated.Overview.Blocks {
+		for _, column := range cards.Rating.Overview.Blocks {
 			styleWithIconOffset := overviewStatsBlockStyle()
 			styleWithIconOffset.session.PaddingX += vehicleComparisonIconSize
 
-			presetBlockWidth, contentWidth := overviewColumnBlocksWidth(column, styleWithIconOffset.session, styleWithIconOffset.career, styleWithIconOffset.label, overviewColumnStyle(0))
-			overviewColumnMaxWidth = common.Max(overviewColumnMaxWidth, contentWidth)
-			totalContentWidth += contentWidth
+			presetBlockWidth, contentWidth := overviewColumnBlocksWidth(column.Blocks, styleWithIconOffset.session, styleWithIconOffset.career, styleWithIconOffset.label, overviewColumnStyle(0))
+			overviewColumnSizes[string(column.Flavor)] = common.Max(overviewColumnSizes[string(column.Flavor)], contentWidth)
 			for key, width := range presetBlockWidth {
 				primaryCardBlockSizes[key] = common.Max(primaryCardBlockSizes[key], width)
 			}
 		}
+	}
+	// we now have column width for both unrated and rating overviews
+	if shouldRenderUnratedOverview {
+		var totalContentWidth float64 = overviewCardStyle(0).Gap*float64(len(cards.Unrated.Overview.Blocks)-1) + overviewCardStyle(0).PaddingX*2
+		for _, column := range cards.Unrated.Overview.Blocks {
+			totalContentWidth += overviewColumnSizes[string(column.Flavor)]
+		}
+		primaryCardWidth = common.Max(primaryCardWidth, totalContentWidth)
+	}
+	if shouldRenderRatingOverview {
+		var totalContentWidth float64 = overviewCardStyle(0).Gap*float64(len(cards.Rating.Overview.Blocks)-1) + overviewCardStyle(0).PaddingX*2
+		for _, column := range cards.Rating.Overview.Blocks {
+			totalContentWidth += overviewColumnSizes[string(column.Flavor)]
+		}
 		primaryCardWidth = common.Max(primaryCardWidth, totalContentWidth)
 	}
+
 	// rating vehicle cards go on the primary block - only show if there are no unrated battles/vehicles
 	if shouldRenderRatingVehicles {
 		for _, card := range cards.Rating.Vehicles {
@@ -199,10 +208,10 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 
 	// overview cards
 	if shouldRenderUnratedOverview {
-		primaryColumn = append(primaryColumn, makeOverviewCard(cards.Unrated.Overview, primaryCardBlockSizes, overviewCardStyle(primaryCardWidth), overviewColumnMaxWidth))
+		primaryColumn = append(primaryColumn, makeOverviewCard(cards.Unrated.Overview, overviewColumnSizes, overviewCardStyle(primaryCardWidth)))
 	}
 	if shouldRenderRatingOverview {
-		primaryColumn = append(primaryColumn, makeOverviewCard(cards.Rating.Overview, primaryCardBlockSizes, overviewRatingCardStyle(primaryCardWidth), overviewColumnMaxWidth))
+		primaryColumn = append(primaryColumn, makeOverviewCard(cards.Rating.Overview, overviewColumnSizes, overviewRatingCardStyle(primaryCardWidth)))
 	}
 
 	// highlights
@@ -308,9 +317,12 @@ func overviewColumnBlocksWidth(blocks []prepare.StatsBlock[session.BlockData], s
 			tierNameSize := common.MeasureString(common.GetWN8TierName(block.Value.Float()), overviewSpecialRatingLabelStyle(nil).Font)
 			tierNameWithPadding := tierNameSize.TotalWidth + overviewSpecialRatingPillStyle(nil).PaddingX*2
 			presetBlockWidth[block.Tag.String()] = common.Max(presetBlockWidth[block.Tag.String()], specialRatingIconSize, tierNameWithPadding)
+			contentWidth = common.Max(contentWidth, tierNameWithPadding)
 		}
 		if block.Tag == prepare.TagRankedRating {
-			presetBlockWidth[block.Tag.String()] = common.Max(presetBlockWidth[block.Tag.String()], specialRatingIconSize)
+			valueSize := common.MeasureString(block.Value.String(), overviewSpecialRatingLabelStyle(nil).Font)
+			presetBlockWidth[block.Tag.String()] = common.Max(presetBlockWidth[block.Tag.String()], specialRatingIconSize, valueSize.TotalWidth)
+			contentWidth = common.Max(contentWidth, valueSize.TotalWidth)
 		}
 	}
 	return presetBlockWidth, contentWidth
@@ -390,17 +402,16 @@ func makeVehicleLegendCard(reference session.VehicleCard, blockSizes map[string]
 	return common.NewBlocksContent(containerStyle, common.NewBlocksContent(vehicleBlocksRowStyle(0), content...))
 }
 
-func makeOverviewCard(card session.OverviewCard, blockSizes map[string]float64, style common.Style, columnWidth float64) common.Block {
+func makeOverviewCard(card session.OverviewCard, columnSizes map[string]float64, style common.Style) common.Block {
 	// made all columns the same width for things to be centered
 	var content []common.Block // add a blank block to balance the offset added from icons
 	blockStyle := vehicleBlockStyle()
 	for _, column := range card.Blocks {
 		var columnContent []common.Block
-		for _, block := range column {
+		for _, block := range column.Blocks {
 			var col common.Block
-			blockWidth := columnWidth // fit the block to column width to make things look even
+			blockWidth := columnSizes[string(column.Flavor)] // fit the block to column width to make things look even
 			if block.Tag == prepare.TagWN8 || block.Tag == prepare.TagRankedRating {
-				blockWidth = blockSizes[block.Tag.String()]
 				col = makeSpecialRatingColumn(block, blockWidth)
 			} else if blockShouldHaveCompareIcon(block) {
 				col = common.NewBlocksContent(statsBlockStyle(blockWidth),
diff --git a/tests/static_fetch.go b/tests/static_fetch.go
index 41dfc92f..9977dfff 100644
--- a/tests/static_fetch.go
+++ b/tests/static_fetch.go
@@ -37,10 +37,12 @@ func (c *staticTestingFetch) CurrentStats(ctx context.Context, id string, opts .
 
 	var vehicles = make(map[string]frame.VehicleStatsFrame)
 	for id := range 10 {
-		vehicles[fmt.Sprint(id)] = DefaultVehicleStatsFrameBig1(fmt.Sprint(id))
+		f := DefaultVehicleStatsFrameBig1(fmt.Sprint(id))
+		f.SetWN8(9999)
+		vehicles[fmt.Sprint(id)] = f
 	}
 
-	return fetch.AccountStatsOverPeriod{
+	stats := fetch.AccountStatsOverPeriod{
 		Account: account,
 		Realm:   account.Realm,
 
@@ -55,7 +57,9 @@ func (c *staticTestingFetch) CurrentStats(ctx context.Context, id string, opts .
 		RatingBattles: fetch.StatsWithVehicles{
 			StatsFrame: DefaultStatsFrameBig2,
 		},
-	}, nil
+	}
+	stats.RegularBattles.SetWN8(9999)
+	return stats, nil
 }
 
 func (c *staticTestingFetch) PeriodStats(ctx context.Context, id string, from time.Time, opts ...fetch.StatsOption) (fetch.AccountStatsOverPeriod, error) {
@@ -65,10 +69,12 @@ func (c *staticTestingFetch) PeriodStats(ctx context.Context, id string, from ti
 	}
 
 	current.PeriodStart = from
+	current.RegularBattles.SetWN8(9999)
 	current.RegularBattles.StatsFrame.Subtract(DefaultStatsFrameSmall1)
 	current.RatingBattles.StatsFrame.Subtract(DefaultStatsFrameSmall2)
 
 	for id, stats := range current.RegularBattles.Vehicles {
+		stats.SetWN8(9999)
 		stats.StatsFrame.Subtract(DefaultStatsFrameSmall1)
 		current.RegularBattles.Vehicles[id] = stats
 	}

From 9adeef1fa960781b85ec6617dc3d7f124fa4f6ce Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 28 Jun 2024 13:53:21 -0400
Subject: [PATCH 215/341] work on asset downloader

---
 cmd/assets/.env.example                   |   9 +-
 cmd/assets/Dockerfile                     |  33 +++
 cmd/assets/main.go                        |   2 +
 cmd/assets/strings.go                     | 255 ++++++++++++++++++++++
 go.mod                                    |   1 +
 go.sum                                    |  12 +-
 internal/stats/render/session/v1/cards.go |  11 -
 7 files changed, 301 insertions(+), 22 deletions(-)
 create mode 100644 cmd/assets/Dockerfile
 create mode 100644 cmd/assets/strings.go

diff --git a/cmd/assets/.env.example b/cmd/assets/.env.example
index 198c6b24..8be29a1b 100644
--- a/cmd/assets/.env.example
+++ b/cmd/assets/.env.example
@@ -1 +1,8 @@
-NEWS_ENDPOINT="https://na.wotblitz.com/en/api/cms/news/"
\ No newline at end of file
+NEWS_ENDPOINT="https://na.wotblitz.com/en/api/cms/news/"
+
+DOWNLOADER_STEAM_USERNAME=""
+DOWNLOADER_STEAM_PASSWORD=""
+DOWNLOADER_STEAM_AUTH_CODE=""
+DOWNLOADER_CMD_PATH="./DepotDownloader"
+DOWNLOADER_DEPOT_ID="444202"
+DOWNLOADER_APP_ID="444200"
\ No newline at end of file
diff --git a/cmd/assets/Dockerfile b/cmd/assets/Dockerfile
new file mode 100644
index 00000000..6f8450ab
--- /dev/null
+++ b/cmd/assets/Dockerfile
@@ -0,0 +1,33 @@
+# Download required assets/binaries
+FROM debian:stable-slim as downloader
+
+WORKDIR /tmp
+
+RUN apt-get update
+RUN apt-get install unzip wget -y
+
+RUN wget https://github.com/SteamRE/DepotDownloader/releases/download/DepotDownloader_2.6.0/DepotDownloader-linux-x64.zip -O downloader.zip
+RUN unzip downloader.zip -d /downloader
+
+# Build the application
+FROM golang:1.22.3-bookworm as builder
+
+WORKDIR /workspace
+
+COPY go.mod go.sum ./
+RUN --mount=type=cache,target=$GOPATH/pkg/mod go mod download
+
+COPY ./ ./
+
+# build a fully standalone binary with zero dependencies
+RUN --mount=type=cache,target=$GOPATH/pkg/mod CGO_ENABLED=0 GOOS=linux go build -o /bin/app cmd/assets/*.go
+
+# Run
+FROM scratch
+
+COPY --from=downloader /downloader /downloader
+COPY --from=builder /bin/app /usr/bin/app
+
+ENV DOWNLOADER_CMD_PATH=/downloader/DepotDownloader
+
+ENTRYPOINT [ "app" ]
\ No newline at end of file
diff --git a/cmd/assets/main.go b/cmd/assets/main.go
index cb01149c..158ebc96 100644
--- a/cmd/assets/main.go
+++ b/cmd/assets/main.go
@@ -10,6 +10,8 @@ import (
 	"github.com/cufee/aftermath/internal/database"
 )
 
+// os.Getenv("DOWNLOADER_CMD_PATH")
+
 func main() {
 	// db, err := newDatabaseClientFromEnv()
 	// if err != nil {
diff --git a/cmd/assets/strings.go b/cmd/assets/strings.go
new file mode 100644
index 00000000..bd1dac3e
--- /dev/null
+++ b/cmd/assets/strings.go
@@ -0,0 +1,255 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"io/fs"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"sync"
+
+	"golang.org/x/text/language"
+	"gopkg.in/yaml.v3"
+
+	"encoding/binary"
+	"errors"
+	"hash/crc32"
+
+	_ "github.com/joho/godotenv/autoload"
+	"github.com/pierrec/lz4/v4"
+)
+
+type steamDownloader struct {
+	cmdPath string
+	outDir  string
+
+	steamUsername string
+	steamPassword string
+	steamAuthCode string
+}
+
+func NewDownloader(cmdPath string) *steamDownloader {
+	return &steamDownloader{cmdPath: cmdPath, outDir: "/tmp"}
+}
+
+func (d *steamDownloader) DownloadDepot(appID, depotID string, fileListPath ...string) (string, error) {
+	var args []string
+
+	if len(fileListPath) > 0 {
+		args = append(args, "-filelist")
+		args = append(args, fileListPath[0])
+	}
+
+	args = append(args, "-username")
+	args = append(args, d.steamUsername)
+	args = append(args, "-password")
+	args = append(args, d.steamPassword)
+	if d.steamAuthCode != "" {
+		// args = append(args, "-filelist")
+		// args = append(args, "filelist.txt")
+	}
+
+	args = append(args, "-app")
+	args = append(args, appID)
+	args = append(args, "-depot")
+	args = append(args, depotID)
+	args = append(args, "-dir")
+	args = append(args, d.outDir)
+
+	cmd := exec.Command(d.cmdPath, args...)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+
+	err := cmd.Run()
+	if err != nil {
+		return "", err
+	}
+
+	if cmd.ProcessState.ExitCode() != 0 {
+		return "", fmt.Errorf("bad exit code from downloader: %d", cmd.ProcessState.ExitCode())
+	}
+	return d.outDir, nil
+
+}
+
+type localizationString struct {
+	Key   string `yaml:"key"`
+	Value string `yaml:"value"`
+	Notes string `yaml:"notes"`
+}
+
+type parsedData struct {
+	data         []localizationString
+	existingKeys map[string]struct{}
+}
+
+func (d *parsedData) Encode(w io.Writer) error {
+	return yaml.NewEncoder(w).Encode(d.data)
+}
+
+type parsedKey string
+
+func (d *parsedData) Add(category, key, value string) {
+	if d.existingKeys == nil {
+		d.existingKeys = make(map[string]struct{})
+	}
+	if _, ok := d.existingKeys[key]; ok {
+		return
+	}
+
+	d.data = append(d.data, localizationString{Key: category + "_" + key, Value: value, Notes: "Generated from game files"})
+}
+
+func (k parsedKey) IsMap() bool {
+	return strings.HasPrefix(string(k), "#maps:") && strings.HasSuffix(string(k), ".sc2")
+}
+
+func (k parsedKey) MapName() string {
+	split := strings.Split(string(k), ":")
+	if len(split) < 2 {
+		return ""
+	}
+	return split[1]
+}
+
+func (k parsedKey) IsBattleType() bool {
+	return strings.HasPrefix(string(k), "battleType/") && len(strings.Split(string(k), "/")) == 2
+}
+
+func (k parsedKey) BattleTypeName() string {
+	return strings.Split(string(k), "/")[1]
+}
+
+func ParseGameStrings(dl *steamDownloader, fileList string) error {
+	path, err := dl.DownloadDepot(os.Getenv("DOWNLOADER_APP_ID"), os.Getenv("DOWNLOADER_DEPOT_ID"), fileList)
+	if err != nil {
+		return err
+	}
+
+	dirPath := filepath.Join(path, "/Data/Strings")
+	dir, err := os.ReadDir(dirPath)
+	if err != nil {
+		return err
+	}
+
+	var wg sync.WaitGroup
+	errCh := make(chan error, len(dir))
+
+	for _, entry := range dir {
+		wg.Add(1)
+		go func(entry fs.DirEntry) {
+			defer wg.Done()
+			if entry.IsDir() || !strings.Contains(entry.Name(), ".yaml") {
+				return
+			}
+			log.Println("decrypting and parsing", entry.Name())
+
+			raw, err := os.ReadFile(filepath.Join(dirPath, entry.Name()))
+			if err != nil {
+				errCh <- err
+				return
+			}
+
+			lang := strings.Split(entry.Name(), ".")[0]
+			locale, err := language.Parse(lang)
+			if err != nil {
+				errCh <- err
+				return
+			}
+
+			path := filepath.Join("./assets/", locale.String(), "game_strings.yaml")
+			err = parseAndSaveFile(raw, path)
+			if err != nil {
+				errCh <- err
+				return
+			}
+
+			log.Println("saved assets to", path)
+		}(entry)
+	}
+
+	wg.Wait()
+	close(errCh)
+	if len(errCh) > 0 {
+		return <-errCh
+	}
+	return nil
+}
+
+func parseAndSaveFile(encrypted []byte, outPath string) error {
+	raw, err := decryptDVPL(encrypted)
+	if err != nil {
+		return err
+	}
+
+	data, err := decodeYAML(bytes.NewBuffer(raw))
+	if err != nil {
+		return err
+	}
+
+	var parsed parsedData
+
+	for key, value := range data {
+		if key.IsMap() {
+			parsed.Add("maps", key.MapName(), value)
+		}
+		if key.IsBattleType() {
+			parsed.Add("battle_types", key.BattleTypeName(), value)
+		}
+	}
+
+	err = os.MkdirAll(filepath.Dir(outPath), os.ModePerm)
+	if err != nil {
+		return err
+	}
+
+	f, err := os.Create(outPath)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	err = parsed.Encode(f)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func decryptDVPL(inputBuf []byte) ([]byte, error) {
+	dataBuf := inputBuf[:len(inputBuf)-20]
+	footerBuf := inputBuf[len(inputBuf)-20:]
+
+	originalSize := binary.LittleEndian.Uint32(footerBuf[:4])
+	compressedSize := binary.LittleEndian.Uint32(footerBuf[4:8])
+	if int(compressedSize) != len(dataBuf) {
+		return nil, errors.New("invalid compressed data length")
+	}
+
+	crc32DataSum := binary.LittleEndian.Uint32(footerBuf[8:12])
+	if crc32DataSum != crc32.ChecksumIEEE(dataBuf) {
+		return nil, errors.New("invalid crc32 sum")
+	}
+
+	compressType := binary.LittleEndian.Uint32(footerBuf[12:16])
+	outputBuf := make([]byte, originalSize)
+	if compressType == 0 {
+		outputBuf = dataBuf
+	} else {
+		actualOutputSize, err := lz4.UncompressBlock(dataBuf, outputBuf)
+		if err != nil {
+			return nil, errors.New("failed to uncompressed lz4")
+		}
+		outputBuf = outputBuf[:actualOutputSize]
+	}
+	return outputBuf, nil
+}
+
+func decodeYAML(r io.Reader) (map[parsedKey]string, error) {
+	decoded := make(map[parsedKey]string)
+	return decoded, yaml.NewDecoder(r).Decode(&decoded)
+}
diff --git a/go.mod b/go.mod
index 38628307..c1b268b1 100644
--- a/go.mod
+++ b/go.mod
@@ -14,6 +14,7 @@ require (
 	github.com/lucsky/cuid v1.2.1
 	github.com/mattn/go-sqlite3 v1.14.22
 	github.com/nlpodyssey/gopickle v0.3.0
+	github.com/pierrec/lz4/v4 v4.1.21
 	github.com/pkg/errors v0.9.1
 	github.com/rs/zerolog v1.33.0
 	github.com/stretchr/testify v1.9.0
diff --git a/go.sum b/go.sum
index ee4f6f7a..59719986 100644
--- a/go.sum
+++ b/go.sum
@@ -58,23 +58,19 @@ github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/
 github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
-github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/mattn/go-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o4kU=
 github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
 github.com/mitchellh/go-wordwrap v1.0.1 h1:TLuKupo69TCn6TQSyGxwI1EblZZEsQ0vMlAFQflz0v0=
 github.com/mitchellh/go-wordwrap v1.0.1/go.mod h1:R62XHJLzvMFRBbcrT7m7WgmE1eOyTSsCt+hzestvNj0=
 github.com/nlpodyssey/gopickle v0.3.0 h1:BLUE5gxFLyyNOPzlXxt6GoHEMMxD0qhsE4p0CIQyoLw=
 github.com/nlpodyssey/gopickle v0.3.0/go.mod h1:f070HJ/yR+eLi5WmM1OXJEGaTpuJEUiib19olXgYha0=
-github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
-github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
+github.com/pierrec/lz4/v4 v4.1.21 h1:yOVMLb6qSIDP67pl/5F7RepeKYu/VmTyEXvuMI5d9mQ=
+github.com/pierrec/lz4/v4 v4.1.21/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
-github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
 github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=
 github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
@@ -83,10 +79,6 @@ github.com/rogpeppe/go-internal v1.8.1/go.mod h1:JeRgkft04UBgHMgCIwADu4Pn6Mtm5d4
 github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
 github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8=
 github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
-github.com/spf13/cobra v1.7.0 h1:hyqWnYt1ZQShIddO5kBpj3vu05/++x6tJ6dg8EC572I=
-github.com/spf13/cobra v1.7.0/go.mod h1:uLxZILRyS/50WlhOIKD7W6V5bgeIt+4sICxh6uRMrb0=
-github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
-github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
diff --git a/internal/stats/render/session/v1/cards.go b/internal/stats/render/session/v1/cards.go
index ae0cda4c..9ba757eb 100644
--- a/internal/stats/render/session/v1/cards.go
+++ b/internal/stats/render/session/v1/cards.go
@@ -49,10 +49,6 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 	highlightCardBlockSizes := make(map[string]float64)
 	var primaryCardWidth float64 = minPrimaryCardWidth
 	var secondaryCardWidth, totalFrameWidth float64
-	// rating and unrated battles > 0	 	   unrated battles > 0		   rating battles > 0
-	// [title card		] | [vehicle]    [title card	  ] | [vehicle]    [title card	  	]
-	// [overview unrated] | [vehicle] OR [overview unrated] | [vehicle] OR [overview rating ]
-	// [overview rating ] | [...    ]    [highlight       ] | [...    ]    [vehicle			]
 
 	{
 		titleStyle := common.DefaultPlayerTitleStyle(playerNameCardStyle(0))
@@ -110,7 +106,6 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 	// rating vehicle cards go on the primary block - only show if there are no unrated battles/vehicles
 	if shouldRenderRatingVehicles {
 		for _, card := range cards.Rating.Vehicles {
-			// [title] [session]
 			style := ratingVehicleBlockStyle()
 			titleSize := common.MeasureString(card.Title, ratingVehicleCardTitleStyle().Font)
 			presetBlockWidth, contentWidth := vehicleBlocksWidth(card.Blocks, style.session, style.career, style.label, ratingVehicleBlocksRowStyle(0))
@@ -126,8 +121,6 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 	// highlighted vehicles go on the primary block
 	if shouldRenderUnratedHighlights {
 		for _, card := range cards.Unrated.Highlights {
-			// [card label] [session]
-			// [title]  	  [label]
 			labelSize := common.MeasureString(card.Meta, highlightCardTitleTextStyle().Font)
 			titleSize := common.MeasureString(card.Title, highlightVehicleNameTextStyle().Font)
 
@@ -144,10 +137,6 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 	}
 	if shouldRenderUnratedVehicles { // unrated vehicles go on the secondary block
 		for _, card := range cards.Unrated.Vehicles {
-			// 		[ label ]
-			// [session]
-			// [career ]
-
 			styleWithIconOffset := vehicleBlockStyle()
 			// icon is only on one side, so we divide by 2
 			styleWithIconOffset.label.PaddingX += vehicleComparisonIconSize / 2

From 4a40d4ce7e322e92de68148307ac05f79b05974a Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 28 Jun 2024 20:05:00 -0400
Subject: [PATCH 216/341] added achievement snapshots

---
 cmd/core/tasks/{sessions.go => snapshots.go}  |   7 +-
 go.mod                                        |   2 +-
 go.sum                                        |   4 +-
 internal/database/client.go                   |   3 +
 internal/database/ent/db/account.go           |  18 +-
 internal/database/ent/db/account/account.go   |  34 +--
 internal/database/ent/db/account/where.go     |  12 +-
 internal/database/ent/db/account_create.go    |  18 +-
 internal/database/ent/db/account_query.go     |  32 +--
 internal/database/ent/db/account_update.go    |  96 ++++----
 internal/database/ent/db/client.go            |   6 +-
 internal/database/ent/db/crontask/crontask.go |   2 +
 internal/database/ent/db/crontask_create.go   |  12 +
 internal/database/ent/db/migrate/schema.go    |   4 +-
 internal/database/ent/db/mutation.go          |  94 ++++----
 internal/database/ent/db/runtime.go           |   4 +
 internal/database/ent/schema/account.go       |   4 +-
 .../database/ent/schema/account_snapshot.go   |   2 +-
 .../ent/schema/achievements_snapshot.go       |   3 -
 .../database/models/achievements_snapshot.go  |  19 ++
 internal/database/models/task.go              |   5 -
 internal/database/snapshots.go                | 112 +++++++++
 internal/logic/snapshots.go                   | 225 ++++++++++++++----
 tests/static_database.go                      |   6 +
 24 files changed, 500 insertions(+), 224 deletions(-)
 rename cmd/core/tasks/{sessions.go => snapshots.go} (90%)
 create mode 100644 internal/database/models/achievements_snapshot.go

diff --git a/cmd/core/tasks/sessions.go b/cmd/core/tasks/snapshots.go
similarity index 90%
rename from cmd/core/tasks/sessions.go
rename to cmd/core/tasks/snapshots.go
index 7a02dea7..e6deda26 100644
--- a/cmd/core/tasks/sessions.go
+++ b/cmd/core/tasks/snapshots.go
@@ -81,7 +81,12 @@ func CreateRecordSnapshotsTasks(client core.Client, realm string) error {
 	}
 	task.Targets = append(task.Targets, accounts...)
 
-	// This update requires (2 + n) requests per n players
+	// This update requires (3 + 2n) requests per n players
+	// 1 - get all account stats
+	// 1 - get all clan profiles
+	// 1 - get all account achievements
+	// n - get vehicle stats for each account
+	// n - get vehicle achievements for each account
 	tasks := splitTaskByTargets(task, 50)
 	err = client.Database().CreateTasks(ctx, tasks...)
 	if err != nil {
diff --git a/go.mod b/go.mod
index c1b268b1..d39d25ff 100644
--- a/go.mod
+++ b/go.mod
@@ -5,7 +5,7 @@ go 1.22.3
 require (
 	entgo.io/ent v0.13.1
 	github.com/bwmarrin/discordgo v0.28.1
-	github.com/cufee/am-wg-proxy-next/v2 v2.1.5
+	github.com/cufee/am-wg-proxy-next/v2 v2.1.6
 	github.com/disintegration/imaging v1.6.2
 	github.com/fogleman/gg v1.3.0
 	github.com/go-co-op/gocron v1.37.0
diff --git a/go.sum b/go.sum
index 59719986..b64339d0 100644
--- a/go.sum
+++ b/go.sum
@@ -12,8 +12,8 @@ github.com/bwmarrin/discordgo v0.28.1 h1:gXsuo2GBO7NbR6uqmrrBDplPUx2T3nzu775q/Rd
 github.com/bwmarrin/discordgo v0.28.1/go.mod h1:NJZpH+1AfhIcyQsPeuBKsUtYrRnjkyu0kIVMCHkZtRY=
 github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
-github.com/cufee/am-wg-proxy-next/v2 v2.1.5 h1:F16XkZ8l+vZcRtgSYfxIphldsGBAc4+kWcIly3F3x+U=
-github.com/cufee/am-wg-proxy-next/v2 v2.1.5/go.mod h1:+VxiIdbrdhHdRThASbVmZ5Fz4H6XPCzL3S2Ix6TO/84=
+github.com/cufee/am-wg-proxy-next/v2 v2.1.6 h1:LNGXS9n1FANtblhEUxMAZehfcTIH6FsGfF0snhf2hHM=
+github.com/cufee/am-wg-proxy-next/v2 v2.1.6/go.mod h1:+VxiIdbrdhHdRThASbVmZ5Fz4H6XPCzL3S2Ix6TO/84=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
diff --git a/internal/database/client.go b/internal/database/client.go
index d192ca4b..8d682d4a 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -52,6 +52,9 @@ type SnapshotsClient interface {
 	GetVehicleSnapshots(ctx context.Context, accountID, referenceID string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.VehicleSnapshot, error)
 	CreateAccountVehicleSnapshots(ctx context.Context, accountID string, snapshots ...models.VehicleSnapshot) (map[string]error, error)
 
+	CreateAccountAchievementSnapshots(ctx context.Context, accountID string, snapshots ...models.AchievementsSnapshot) (map[string]error, error)
+	GetAchievementsSnapshots(ctx context.Context, accountID string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.AchievementsSnapshot, error)
+
 	DeleteExpiredSnapshots(ctx context.Context, expiration time.Time) error
 }
 
diff --git a/internal/database/ent/db/account.go b/internal/database/ent/db/account.go
index ff1fed1f..c2ac1943 100644
--- a/internal/database/ent/db/account.go
+++ b/internal/database/ent/db/account.go
@@ -44,8 +44,8 @@ type Account struct {
 type AccountEdges struct {
 	// Clan holds the value of the clan edge.
 	Clan *Clan `json:"clan,omitempty"`
-	// Snapshots holds the value of the snapshots edge.
-	Snapshots []*AccountSnapshot `json:"snapshots,omitempty"`
+	// AccountSnapshots holds the value of the account_snapshots edge.
+	AccountSnapshots []*AccountSnapshot `json:"account_snapshots,omitempty"`
 	// VehicleSnapshots holds the value of the vehicle_snapshots edge.
 	VehicleSnapshots []*VehicleSnapshot `json:"vehicle_snapshots,omitempty"`
 	// AchievementSnapshots holds the value of the achievement_snapshots edge.
@@ -66,13 +66,13 @@ func (e AccountEdges) ClanOrErr() (*Clan, error) {
 	return nil, &NotLoadedError{edge: "clan"}
 }
 
-// SnapshotsOrErr returns the Snapshots value or an error if the edge
+// AccountSnapshotsOrErr returns the AccountSnapshots value or an error if the edge
 // was not loaded in eager-loading.
-func (e AccountEdges) SnapshotsOrErr() ([]*AccountSnapshot, error) {
+func (e AccountEdges) AccountSnapshotsOrErr() ([]*AccountSnapshot, error) {
 	if e.loadedTypes[1] {
-		return e.Snapshots, nil
+		return e.AccountSnapshots, nil
 	}
-	return nil, &NotLoadedError{edge: "snapshots"}
+	return nil, &NotLoadedError{edge: "account_snapshots"}
 }
 
 // VehicleSnapshotsOrErr returns the VehicleSnapshots value or an error if the edge
@@ -191,9 +191,9 @@ func (a *Account) QueryClan() *ClanQuery {
 	return NewAccountClient(a.config).QueryClan(a)
 }
 
-// QuerySnapshots queries the "snapshots" edge of the Account entity.
-func (a *Account) QuerySnapshots() *AccountSnapshotQuery {
-	return NewAccountClient(a.config).QuerySnapshots(a)
+// QueryAccountSnapshots queries the "account_snapshots" edge of the Account entity.
+func (a *Account) QueryAccountSnapshots() *AccountSnapshotQuery {
+	return NewAccountClient(a.config).QueryAccountSnapshots(a)
 }
 
 // QueryVehicleSnapshots queries the "vehicle_snapshots" edge of the Account entity.
diff --git a/internal/database/ent/db/account/account.go b/internal/database/ent/db/account/account.go
index 14226186..adb50e4e 100644
--- a/internal/database/ent/db/account/account.go
+++ b/internal/database/ent/db/account/account.go
@@ -32,8 +32,8 @@ const (
 	FieldClanID = "clan_id"
 	// EdgeClan holds the string denoting the clan edge name in mutations.
 	EdgeClan = "clan"
-	// EdgeSnapshots holds the string denoting the snapshots edge name in mutations.
-	EdgeSnapshots = "snapshots"
+	// EdgeAccountSnapshots holds the string denoting the account_snapshots edge name in mutations.
+	EdgeAccountSnapshots = "account_snapshots"
 	// EdgeVehicleSnapshots holds the string denoting the vehicle_snapshots edge name in mutations.
 	EdgeVehicleSnapshots = "vehicle_snapshots"
 	// EdgeAchievementSnapshots holds the string denoting the achievement_snapshots edge name in mutations.
@@ -47,13 +47,13 @@ const (
 	ClanInverseTable = "clans"
 	// ClanColumn is the table column denoting the clan relation/edge.
 	ClanColumn = "clan_id"
-	// SnapshotsTable is the table that holds the snapshots relation/edge.
-	SnapshotsTable = "account_snapshots"
-	// SnapshotsInverseTable is the table name for the AccountSnapshot entity.
+	// AccountSnapshotsTable is the table that holds the account_snapshots relation/edge.
+	AccountSnapshotsTable = "account_snapshots"
+	// AccountSnapshotsInverseTable is the table name for the AccountSnapshot entity.
 	// It exists in this package in order to avoid circular dependency with the "accountsnapshot" package.
-	SnapshotsInverseTable = "account_snapshots"
-	// SnapshotsColumn is the table column denoting the snapshots relation/edge.
-	SnapshotsColumn = "account_id"
+	AccountSnapshotsInverseTable = "account_snapshots"
+	// AccountSnapshotsColumn is the table column denoting the account_snapshots relation/edge.
+	AccountSnapshotsColumn = "account_id"
 	// VehicleSnapshotsTable is the table that holds the vehicle_snapshots relation/edge.
 	VehicleSnapshotsTable = "vehicle_snapshots"
 	// VehicleSnapshotsInverseTable is the table name for the VehicleSnapshot entity.
@@ -163,17 +163,17 @@ func ByClanField(field string, opts ...sql.OrderTermOption) OrderOption {
 	}
 }
 
-// BySnapshotsCount orders the results by snapshots count.
-func BySnapshotsCount(opts ...sql.OrderTermOption) OrderOption {
+// ByAccountSnapshotsCount orders the results by account_snapshots count.
+func ByAccountSnapshotsCount(opts ...sql.OrderTermOption) OrderOption {
 	return func(s *sql.Selector) {
-		sqlgraph.OrderByNeighborsCount(s, newSnapshotsStep(), opts...)
+		sqlgraph.OrderByNeighborsCount(s, newAccountSnapshotsStep(), opts...)
 	}
 }
 
-// BySnapshots orders the results by snapshots terms.
-func BySnapshots(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+// ByAccountSnapshots orders the results by account_snapshots terms.
+func ByAccountSnapshots(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
 	return func(s *sql.Selector) {
-		sqlgraph.OrderByNeighborTerms(s, newSnapshotsStep(), append([]sql.OrderTerm{term}, terms...)...)
+		sqlgraph.OrderByNeighborTerms(s, newAccountSnapshotsStep(), append([]sql.OrderTerm{term}, terms...)...)
 	}
 }
 
@@ -211,11 +211,11 @@ func newClanStep() *sqlgraph.Step {
 		sqlgraph.Edge(sqlgraph.M2O, true, ClanTable, ClanColumn),
 	)
 }
-func newSnapshotsStep() *sqlgraph.Step {
+func newAccountSnapshotsStep() *sqlgraph.Step {
 	return sqlgraph.NewStep(
 		sqlgraph.From(Table, FieldID),
-		sqlgraph.To(SnapshotsInverseTable, FieldID),
-		sqlgraph.Edge(sqlgraph.O2M, false, SnapshotsTable, SnapshotsColumn),
+		sqlgraph.To(AccountSnapshotsInverseTable, FieldID),
+		sqlgraph.Edge(sqlgraph.O2M, false, AccountSnapshotsTable, AccountSnapshotsColumn),
 	)
 }
 func newVehicleSnapshotsStep() *sqlgraph.Step {
diff --git a/internal/database/ent/db/account/where.go b/internal/database/ent/db/account/where.go
index fe718ba5..2b170a4f 100644
--- a/internal/database/ent/db/account/where.go
+++ b/internal/database/ent/db/account/where.go
@@ -503,21 +503,21 @@ func HasClanWith(preds ...predicate.Clan) predicate.Account {
 	})
 }
 
-// HasSnapshots applies the HasEdge predicate on the "snapshots" edge.
-func HasSnapshots() predicate.Account {
+// HasAccountSnapshots applies the HasEdge predicate on the "account_snapshots" edge.
+func HasAccountSnapshots() predicate.Account {
 	return predicate.Account(func(s *sql.Selector) {
 		step := sqlgraph.NewStep(
 			sqlgraph.From(Table, FieldID),
-			sqlgraph.Edge(sqlgraph.O2M, false, SnapshotsTable, SnapshotsColumn),
+			sqlgraph.Edge(sqlgraph.O2M, false, AccountSnapshotsTable, AccountSnapshotsColumn),
 		)
 		sqlgraph.HasNeighbors(s, step)
 	})
 }
 
-// HasSnapshotsWith applies the HasEdge predicate on the "snapshots" edge with a given conditions (other predicates).
-func HasSnapshotsWith(preds ...predicate.AccountSnapshot) predicate.Account {
+// HasAccountSnapshotsWith applies the HasEdge predicate on the "account_snapshots" edge with a given conditions (other predicates).
+func HasAccountSnapshotsWith(preds ...predicate.AccountSnapshot) predicate.Account {
 	return predicate.Account(func(s *sql.Selector) {
-		step := newSnapshotsStep()
+		step := newAccountSnapshotsStep()
 		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
 			for _, p := range preds {
 				p(s)
diff --git a/internal/database/ent/db/account_create.go b/internal/database/ent/db/account_create.go
index 88cc48f2..c54cc2b3 100644
--- a/internal/database/ent/db/account_create.go
+++ b/internal/database/ent/db/account_create.go
@@ -115,19 +115,19 @@ func (ac *AccountCreate) SetClan(c *Clan) *AccountCreate {
 	return ac.SetClanID(c.ID)
 }
 
-// AddSnapshotIDs adds the "snapshots" edge to the AccountSnapshot entity by IDs.
-func (ac *AccountCreate) AddSnapshotIDs(ids ...string) *AccountCreate {
-	ac.mutation.AddSnapshotIDs(ids...)
+// AddAccountSnapshotIDs adds the "account_snapshots" edge to the AccountSnapshot entity by IDs.
+func (ac *AccountCreate) AddAccountSnapshotIDs(ids ...string) *AccountCreate {
+	ac.mutation.AddAccountSnapshotIDs(ids...)
 	return ac
 }
 
-// AddSnapshots adds the "snapshots" edges to the AccountSnapshot entity.
-func (ac *AccountCreate) AddSnapshots(a ...*AccountSnapshot) *AccountCreate {
+// AddAccountSnapshots adds the "account_snapshots" edges to the AccountSnapshot entity.
+func (ac *AccountCreate) AddAccountSnapshots(a ...*AccountSnapshot) *AccountCreate {
 	ids := make([]string, len(a))
 	for i := range a {
 		ids[i] = a[i].ID
 	}
-	return ac.AddSnapshotIDs(ids...)
+	return ac.AddAccountSnapshotIDs(ids...)
 }
 
 // AddVehicleSnapshotIDs adds the "vehicle_snapshots" edge to the VehicleSnapshot entity by IDs.
@@ -322,12 +322,12 @@ func (ac *AccountCreate) createSpec() (*Account, *sqlgraph.CreateSpec) {
 		_node.ClanID = nodes[0]
 		_spec.Edges = append(_spec.Edges, edge)
 	}
-	if nodes := ac.mutation.SnapshotsIDs(); len(nodes) > 0 {
+	if nodes := ac.mutation.AccountSnapshotsIDs(); len(nodes) > 0 {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,
 			Inverse: false,
-			Table:   account.SnapshotsTable,
-			Columns: []string{account.SnapshotsColumn},
+			Table:   account.AccountSnapshotsTable,
+			Columns: []string{account.AccountSnapshotsColumn},
 			Bidi:    false,
 			Target: &sqlgraph.EdgeTarget{
 				IDSpec: sqlgraph.NewFieldSpec(accountsnapshot.FieldID, field.TypeString),
diff --git a/internal/database/ent/db/account_query.go b/internal/database/ent/db/account_query.go
index ed808e7b..d3dc8f75 100644
--- a/internal/database/ent/db/account_query.go
+++ b/internal/database/ent/db/account_query.go
@@ -27,7 +27,7 @@ type AccountQuery struct {
 	inters                   []Interceptor
 	predicates               []predicate.Account
 	withClan                 *ClanQuery
-	withSnapshots            *AccountSnapshotQuery
+	withAccountSnapshots     *AccountSnapshotQuery
 	withVehicleSnapshots     *VehicleSnapshotQuery
 	withAchievementSnapshots *AchievementsSnapshotQuery
 	modifiers                []func(*sql.Selector)
@@ -89,8 +89,8 @@ func (aq *AccountQuery) QueryClan() *ClanQuery {
 	return query
 }
 
-// QuerySnapshots chains the current query on the "snapshots" edge.
-func (aq *AccountQuery) QuerySnapshots() *AccountSnapshotQuery {
+// QueryAccountSnapshots chains the current query on the "account_snapshots" edge.
+func (aq *AccountQuery) QueryAccountSnapshots() *AccountSnapshotQuery {
 	query := (&AccountSnapshotClient{config: aq.config}).Query()
 	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
 		if err := aq.prepareQuery(ctx); err != nil {
@@ -103,7 +103,7 @@ func (aq *AccountQuery) QuerySnapshots() *AccountSnapshotQuery {
 		step := sqlgraph.NewStep(
 			sqlgraph.From(account.Table, account.FieldID, selector),
 			sqlgraph.To(accountsnapshot.Table, accountsnapshot.FieldID),
-			sqlgraph.Edge(sqlgraph.O2M, false, account.SnapshotsTable, account.SnapshotsColumn),
+			sqlgraph.Edge(sqlgraph.O2M, false, account.AccountSnapshotsTable, account.AccountSnapshotsColumn),
 		)
 		fromU = sqlgraph.SetNeighbors(aq.driver.Dialect(), step)
 		return fromU, nil
@@ -348,7 +348,7 @@ func (aq *AccountQuery) Clone() *AccountQuery {
 		inters:                   append([]Interceptor{}, aq.inters...),
 		predicates:               append([]predicate.Account{}, aq.predicates...),
 		withClan:                 aq.withClan.Clone(),
-		withSnapshots:            aq.withSnapshots.Clone(),
+		withAccountSnapshots:     aq.withAccountSnapshots.Clone(),
 		withVehicleSnapshots:     aq.withVehicleSnapshots.Clone(),
 		withAchievementSnapshots: aq.withAchievementSnapshots.Clone(),
 		// clone intermediate query.
@@ -368,14 +368,14 @@ func (aq *AccountQuery) WithClan(opts ...func(*ClanQuery)) *AccountQuery {
 	return aq
 }
 
-// WithSnapshots tells the query-builder to eager-load the nodes that are connected to
-// the "snapshots" edge. The optional arguments are used to configure the query builder of the edge.
-func (aq *AccountQuery) WithSnapshots(opts ...func(*AccountSnapshotQuery)) *AccountQuery {
+// WithAccountSnapshots tells the query-builder to eager-load the nodes that are connected to
+// the "account_snapshots" edge. The optional arguments are used to configure the query builder of the edge.
+func (aq *AccountQuery) WithAccountSnapshots(opts ...func(*AccountSnapshotQuery)) *AccountQuery {
 	query := (&AccountSnapshotClient{config: aq.config}).Query()
 	for _, opt := range opts {
 		opt(query)
 	}
-	aq.withSnapshots = query
+	aq.withAccountSnapshots = query
 	return aq
 }
 
@@ -481,7 +481,7 @@ func (aq *AccountQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Acco
 		_spec       = aq.querySpec()
 		loadedTypes = [4]bool{
 			aq.withClan != nil,
-			aq.withSnapshots != nil,
+			aq.withAccountSnapshots != nil,
 			aq.withVehicleSnapshots != nil,
 			aq.withAchievementSnapshots != nil,
 		}
@@ -513,10 +513,10 @@ func (aq *AccountQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Acco
 			return nil, err
 		}
 	}
-	if query := aq.withSnapshots; query != nil {
-		if err := aq.loadSnapshots(ctx, query, nodes,
-			func(n *Account) { n.Edges.Snapshots = []*AccountSnapshot{} },
-			func(n *Account, e *AccountSnapshot) { n.Edges.Snapshots = append(n.Edges.Snapshots, e) }); err != nil {
+	if query := aq.withAccountSnapshots; query != nil {
+		if err := aq.loadAccountSnapshots(ctx, query, nodes,
+			func(n *Account) { n.Edges.AccountSnapshots = []*AccountSnapshot{} },
+			func(n *Account, e *AccountSnapshot) { n.Edges.AccountSnapshots = append(n.Edges.AccountSnapshots, e) }); err != nil {
 			return nil, err
 		}
 	}
@@ -568,7 +568,7 @@ func (aq *AccountQuery) loadClan(ctx context.Context, query *ClanQuery, nodes []
 	}
 	return nil
 }
-func (aq *AccountQuery) loadSnapshots(ctx context.Context, query *AccountSnapshotQuery, nodes []*Account, init func(*Account), assign func(*Account, *AccountSnapshot)) error {
+func (aq *AccountQuery) loadAccountSnapshots(ctx context.Context, query *AccountSnapshotQuery, nodes []*Account, init func(*Account), assign func(*Account, *AccountSnapshot)) error {
 	fks := make([]driver.Value, 0, len(nodes))
 	nodeids := make(map[string]*Account)
 	for i := range nodes {
@@ -582,7 +582,7 @@ func (aq *AccountQuery) loadSnapshots(ctx context.Context, query *AccountSnapsho
 		query.ctx.AppendFieldOnce(accountsnapshot.FieldAccountID)
 	}
 	query.Where(predicate.AccountSnapshot(func(s *sql.Selector) {
-		s.Where(sql.InValues(s.C(account.SnapshotsColumn), fks...))
+		s.Where(sql.InValues(s.C(account.AccountSnapshotsColumn), fks...))
 	}))
 	neighbors, err := query.All(ctx)
 	if err != nil {
diff --git a/internal/database/ent/db/account_update.go b/internal/database/ent/db/account_update.go
index af0b100e..7aca76d5 100644
--- a/internal/database/ent/db/account_update.go
+++ b/internal/database/ent/db/account_update.go
@@ -134,19 +134,19 @@ func (au *AccountUpdate) SetClan(c *Clan) *AccountUpdate {
 	return au.SetClanID(c.ID)
 }
 
-// AddSnapshotIDs adds the "snapshots" edge to the AccountSnapshot entity by IDs.
-func (au *AccountUpdate) AddSnapshotIDs(ids ...string) *AccountUpdate {
-	au.mutation.AddSnapshotIDs(ids...)
+// AddAccountSnapshotIDs adds the "account_snapshots" edge to the AccountSnapshot entity by IDs.
+func (au *AccountUpdate) AddAccountSnapshotIDs(ids ...string) *AccountUpdate {
+	au.mutation.AddAccountSnapshotIDs(ids...)
 	return au
 }
 
-// AddSnapshots adds the "snapshots" edges to the AccountSnapshot entity.
-func (au *AccountUpdate) AddSnapshots(a ...*AccountSnapshot) *AccountUpdate {
+// AddAccountSnapshots adds the "account_snapshots" edges to the AccountSnapshot entity.
+func (au *AccountUpdate) AddAccountSnapshots(a ...*AccountSnapshot) *AccountUpdate {
 	ids := make([]string, len(a))
 	for i := range a {
 		ids[i] = a[i].ID
 	}
-	return au.AddSnapshotIDs(ids...)
+	return au.AddAccountSnapshotIDs(ids...)
 }
 
 // AddVehicleSnapshotIDs adds the "vehicle_snapshots" edge to the VehicleSnapshot entity by IDs.
@@ -190,25 +190,25 @@ func (au *AccountUpdate) ClearClan() *AccountUpdate {
 	return au
 }
 
-// ClearSnapshots clears all "snapshots" edges to the AccountSnapshot entity.
-func (au *AccountUpdate) ClearSnapshots() *AccountUpdate {
-	au.mutation.ClearSnapshots()
+// ClearAccountSnapshots clears all "account_snapshots" edges to the AccountSnapshot entity.
+func (au *AccountUpdate) ClearAccountSnapshots() *AccountUpdate {
+	au.mutation.ClearAccountSnapshots()
 	return au
 }
 
-// RemoveSnapshotIDs removes the "snapshots" edge to AccountSnapshot entities by IDs.
-func (au *AccountUpdate) RemoveSnapshotIDs(ids ...string) *AccountUpdate {
-	au.mutation.RemoveSnapshotIDs(ids...)
+// RemoveAccountSnapshotIDs removes the "account_snapshots" edge to AccountSnapshot entities by IDs.
+func (au *AccountUpdate) RemoveAccountSnapshotIDs(ids ...string) *AccountUpdate {
+	au.mutation.RemoveAccountSnapshotIDs(ids...)
 	return au
 }
 
-// RemoveSnapshots removes "snapshots" edges to AccountSnapshot entities.
-func (au *AccountUpdate) RemoveSnapshots(a ...*AccountSnapshot) *AccountUpdate {
+// RemoveAccountSnapshots removes "account_snapshots" edges to AccountSnapshot entities.
+func (au *AccountUpdate) RemoveAccountSnapshots(a ...*AccountSnapshot) *AccountUpdate {
 	ids := make([]string, len(a))
 	for i := range a {
 		ids[i] = a[i].ID
 	}
-	return au.RemoveSnapshotIDs(ids...)
+	return au.RemoveAccountSnapshotIDs(ids...)
 }
 
 // ClearVehicleSnapshots clears all "vehicle_snapshots" edges to the VehicleSnapshot entity.
@@ -369,12 +369,12 @@ func (au *AccountUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 		_spec.Edges.Add = append(_spec.Edges.Add, edge)
 	}
-	if au.mutation.SnapshotsCleared() {
+	if au.mutation.AccountSnapshotsCleared() {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,
 			Inverse: false,
-			Table:   account.SnapshotsTable,
-			Columns: []string{account.SnapshotsColumn},
+			Table:   account.AccountSnapshotsTable,
+			Columns: []string{account.AccountSnapshotsColumn},
 			Bidi:    false,
 			Target: &sqlgraph.EdgeTarget{
 				IDSpec: sqlgraph.NewFieldSpec(accountsnapshot.FieldID, field.TypeString),
@@ -382,12 +382,12 @@ func (au *AccountUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
 	}
-	if nodes := au.mutation.RemovedSnapshotsIDs(); len(nodes) > 0 && !au.mutation.SnapshotsCleared() {
+	if nodes := au.mutation.RemovedAccountSnapshotsIDs(); len(nodes) > 0 && !au.mutation.AccountSnapshotsCleared() {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,
 			Inverse: false,
-			Table:   account.SnapshotsTable,
-			Columns: []string{account.SnapshotsColumn},
+			Table:   account.AccountSnapshotsTable,
+			Columns: []string{account.AccountSnapshotsColumn},
 			Bidi:    false,
 			Target: &sqlgraph.EdgeTarget{
 				IDSpec: sqlgraph.NewFieldSpec(accountsnapshot.FieldID, field.TypeString),
@@ -398,12 +398,12 @@ func (au *AccountUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
 	}
-	if nodes := au.mutation.SnapshotsIDs(); len(nodes) > 0 {
+	if nodes := au.mutation.AccountSnapshotsIDs(); len(nodes) > 0 {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,
 			Inverse: false,
-			Table:   account.SnapshotsTable,
-			Columns: []string{account.SnapshotsColumn},
+			Table:   account.AccountSnapshotsTable,
+			Columns: []string{account.AccountSnapshotsColumn},
 			Bidi:    false,
 			Target: &sqlgraph.EdgeTarget{
 				IDSpec: sqlgraph.NewFieldSpec(accountsnapshot.FieldID, field.TypeString),
@@ -627,19 +627,19 @@ func (auo *AccountUpdateOne) SetClan(c *Clan) *AccountUpdateOne {
 	return auo.SetClanID(c.ID)
 }
 
-// AddSnapshotIDs adds the "snapshots" edge to the AccountSnapshot entity by IDs.
-func (auo *AccountUpdateOne) AddSnapshotIDs(ids ...string) *AccountUpdateOne {
-	auo.mutation.AddSnapshotIDs(ids...)
+// AddAccountSnapshotIDs adds the "account_snapshots" edge to the AccountSnapshot entity by IDs.
+func (auo *AccountUpdateOne) AddAccountSnapshotIDs(ids ...string) *AccountUpdateOne {
+	auo.mutation.AddAccountSnapshotIDs(ids...)
 	return auo
 }
 
-// AddSnapshots adds the "snapshots" edges to the AccountSnapshot entity.
-func (auo *AccountUpdateOne) AddSnapshots(a ...*AccountSnapshot) *AccountUpdateOne {
+// AddAccountSnapshots adds the "account_snapshots" edges to the AccountSnapshot entity.
+func (auo *AccountUpdateOne) AddAccountSnapshots(a ...*AccountSnapshot) *AccountUpdateOne {
 	ids := make([]string, len(a))
 	for i := range a {
 		ids[i] = a[i].ID
 	}
-	return auo.AddSnapshotIDs(ids...)
+	return auo.AddAccountSnapshotIDs(ids...)
 }
 
 // AddVehicleSnapshotIDs adds the "vehicle_snapshots" edge to the VehicleSnapshot entity by IDs.
@@ -683,25 +683,25 @@ func (auo *AccountUpdateOne) ClearClan() *AccountUpdateOne {
 	return auo
 }
 
-// ClearSnapshots clears all "snapshots" edges to the AccountSnapshot entity.
-func (auo *AccountUpdateOne) ClearSnapshots() *AccountUpdateOne {
-	auo.mutation.ClearSnapshots()
+// ClearAccountSnapshots clears all "account_snapshots" edges to the AccountSnapshot entity.
+func (auo *AccountUpdateOne) ClearAccountSnapshots() *AccountUpdateOne {
+	auo.mutation.ClearAccountSnapshots()
 	return auo
 }
 
-// RemoveSnapshotIDs removes the "snapshots" edge to AccountSnapshot entities by IDs.
-func (auo *AccountUpdateOne) RemoveSnapshotIDs(ids ...string) *AccountUpdateOne {
-	auo.mutation.RemoveSnapshotIDs(ids...)
+// RemoveAccountSnapshotIDs removes the "account_snapshots" edge to AccountSnapshot entities by IDs.
+func (auo *AccountUpdateOne) RemoveAccountSnapshotIDs(ids ...string) *AccountUpdateOne {
+	auo.mutation.RemoveAccountSnapshotIDs(ids...)
 	return auo
 }
 
-// RemoveSnapshots removes "snapshots" edges to AccountSnapshot entities.
-func (auo *AccountUpdateOne) RemoveSnapshots(a ...*AccountSnapshot) *AccountUpdateOne {
+// RemoveAccountSnapshots removes "account_snapshots" edges to AccountSnapshot entities.
+func (auo *AccountUpdateOne) RemoveAccountSnapshots(a ...*AccountSnapshot) *AccountUpdateOne {
 	ids := make([]string, len(a))
 	for i := range a {
 		ids[i] = a[i].ID
 	}
-	return auo.RemoveSnapshotIDs(ids...)
+	return auo.RemoveAccountSnapshotIDs(ids...)
 }
 
 // ClearVehicleSnapshots clears all "vehicle_snapshots" edges to the VehicleSnapshot entity.
@@ -892,12 +892,12 @@ func (auo *AccountUpdateOne) sqlSave(ctx context.Context) (_node *Account, err e
 		}
 		_spec.Edges.Add = append(_spec.Edges.Add, edge)
 	}
-	if auo.mutation.SnapshotsCleared() {
+	if auo.mutation.AccountSnapshotsCleared() {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,
 			Inverse: false,
-			Table:   account.SnapshotsTable,
-			Columns: []string{account.SnapshotsColumn},
+			Table:   account.AccountSnapshotsTable,
+			Columns: []string{account.AccountSnapshotsColumn},
 			Bidi:    false,
 			Target: &sqlgraph.EdgeTarget{
 				IDSpec: sqlgraph.NewFieldSpec(accountsnapshot.FieldID, field.TypeString),
@@ -905,12 +905,12 @@ func (auo *AccountUpdateOne) sqlSave(ctx context.Context) (_node *Account, err e
 		}
 		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
 	}
-	if nodes := auo.mutation.RemovedSnapshotsIDs(); len(nodes) > 0 && !auo.mutation.SnapshotsCleared() {
+	if nodes := auo.mutation.RemovedAccountSnapshotsIDs(); len(nodes) > 0 && !auo.mutation.AccountSnapshotsCleared() {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,
 			Inverse: false,
-			Table:   account.SnapshotsTable,
-			Columns: []string{account.SnapshotsColumn},
+			Table:   account.AccountSnapshotsTable,
+			Columns: []string{account.AccountSnapshotsColumn},
 			Bidi:    false,
 			Target: &sqlgraph.EdgeTarget{
 				IDSpec: sqlgraph.NewFieldSpec(accountsnapshot.FieldID, field.TypeString),
@@ -921,12 +921,12 @@ func (auo *AccountUpdateOne) sqlSave(ctx context.Context) (_node *Account, err e
 		}
 		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
 	}
-	if nodes := auo.mutation.SnapshotsIDs(); len(nodes) > 0 {
+	if nodes := auo.mutation.AccountSnapshotsIDs(); len(nodes) > 0 {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,
 			Inverse: false,
-			Table:   account.SnapshotsTable,
-			Columns: []string{account.SnapshotsColumn},
+			Table:   account.AccountSnapshotsTable,
+			Columns: []string{account.AccountSnapshotsColumn},
 			Bidi:    false,
 			Target: &sqlgraph.EdgeTarget{
 				IDSpec: sqlgraph.NewFieldSpec(accountsnapshot.FieldID, field.TypeString),
diff --git a/internal/database/ent/db/client.go b/internal/database/ent/db/client.go
index 9bceec9e..e77ab304 100644
--- a/internal/database/ent/db/client.go
+++ b/internal/database/ent/db/client.go
@@ -449,15 +449,15 @@ func (c *AccountClient) QueryClan(a *Account) *ClanQuery {
 	return query
 }
 
-// QuerySnapshots queries the snapshots edge of a Account.
-func (c *AccountClient) QuerySnapshots(a *Account) *AccountSnapshotQuery {
+// QueryAccountSnapshots queries the account_snapshots edge of a Account.
+func (c *AccountClient) QueryAccountSnapshots(a *Account) *AccountSnapshotQuery {
 	query := (&AccountSnapshotClient{config: c.config}).Query()
 	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
 		id := a.ID
 		step := sqlgraph.NewStep(
 			sqlgraph.From(account.Table, account.FieldID, id),
 			sqlgraph.To(accountsnapshot.Table, accountsnapshot.FieldID),
-			sqlgraph.Edge(sqlgraph.O2M, false, account.SnapshotsTable, account.SnapshotsColumn),
+			sqlgraph.Edge(sqlgraph.O2M, false, account.AccountSnapshotsTable, account.AccountSnapshotsColumn),
 		)
 		fromV = sqlgraph.Neighbors(a.driver.Dialect(), step)
 		return fromV, nil
diff --git a/internal/database/ent/db/crontask/crontask.go b/internal/database/ent/db/crontask/crontask.go
index 34eaf930..7c6b7ab4 100644
--- a/internal/database/ent/db/crontask/crontask.go
+++ b/internal/database/ent/db/crontask/crontask.go
@@ -76,6 +76,8 @@ var (
 	UpdateDefaultUpdatedAt func() time.Time
 	// ReferenceIDValidator is a validator for the "reference_id" field. It is called by the builders before save.
 	ReferenceIDValidator func(string) error
+	// DefaultTriesLeft holds the default value on creation for the "tries_left" field.
+	DefaultTriesLeft int
 	// DefaultID holds the default value on creation for the "id" field.
 	DefaultID func() string
 )
diff --git a/internal/database/ent/db/crontask_create.go b/internal/database/ent/db/crontask_create.go
index 085e2871..2936ce48 100644
--- a/internal/database/ent/db/crontask_create.go
+++ b/internal/database/ent/db/crontask_create.go
@@ -91,6 +91,14 @@ func (ctc *CronTaskCreate) SetTriesLeft(i int) *CronTaskCreate {
 	return ctc
 }
 
+// SetNillableTriesLeft sets the "tries_left" field if the given value is not nil.
+func (ctc *CronTaskCreate) SetNillableTriesLeft(i *int) *CronTaskCreate {
+	if i != nil {
+		ctc.SetTriesLeft(*i)
+	}
+	return ctc
+}
+
 // SetLogs sets the "logs" field.
 func (ctc *CronTaskCreate) SetLogs(ml []models.TaskLog) *CronTaskCreate {
 	ctc.mutation.SetLogs(ml)
@@ -160,6 +168,10 @@ func (ctc *CronTaskCreate) defaults() {
 		v := crontask.DefaultUpdatedAt()
 		ctc.mutation.SetUpdatedAt(v)
 	}
+	if _, ok := ctc.mutation.TriesLeft(); !ok {
+		v := crontask.DefaultTriesLeft
+		ctc.mutation.SetTriesLeft(v)
+	}
 	if _, ok := ctc.mutation.ID(); !ok {
 		v := crontask.DefaultID()
 		ctc.mutation.SetID(v)
diff --git a/internal/database/ent/db/migrate/schema.go b/internal/database/ent/db/migrate/schema.go
index 82bd0479..8017db8f 100644
--- a/internal/database/ent/db/migrate/schema.go
+++ b/internal/database/ent/db/migrate/schema.go
@@ -82,7 +82,7 @@ var (
 		PrimaryKey: []*schema.Column{AccountSnapshotsColumns[0]},
 		ForeignKeys: []*schema.ForeignKey{
 			{
-				Symbol:     "account_snapshots_accounts_snapshots",
+				Symbol:     "account_snapshots_accounts_account_snapshots",
 				Columns:    []*schema.Column{AccountSnapshotsColumns[10]},
 				RefColumns: []*schema.Column{AccountsColumns[0]},
 				OnDelete:   schema.NoAction,
@@ -262,7 +262,7 @@ var (
 		{Name: "status", Type: field.TypeEnum, Enums: []string{"TASK_SCHEDULED", "TASK_IN_PROGRESS", "TASK_COMPLETE", "TASK_FAILED"}},
 		{Name: "scheduled_after", Type: field.TypeTime},
 		{Name: "last_run", Type: field.TypeTime},
-		{Name: "tries_left", Type: field.TypeInt},
+		{Name: "tries_left", Type: field.TypeInt, Default: 0},
 		{Name: "logs", Type: field.TypeJSON},
 		{Name: "data", Type: field.TypeJSON},
 	}
diff --git a/internal/database/ent/db/mutation.go b/internal/database/ent/db/mutation.go
index 024970b4..23952010 100644
--- a/internal/database/ent/db/mutation.go
+++ b/internal/database/ent/db/mutation.go
@@ -74,9 +74,9 @@ type AccountMutation struct {
 	clearedFields                map[string]struct{}
 	clan                         *string
 	clearedclan                  bool
-	snapshots                    map[string]struct{}
-	removedsnapshots             map[string]struct{}
-	clearedsnapshots             bool
+	account_snapshots            map[string]struct{}
+	removedaccount_snapshots     map[string]struct{}
+	clearedaccount_snapshots     bool
 	vehicle_snapshots            map[string]struct{}
 	removedvehicle_snapshots     map[string]struct{}
 	clearedvehicle_snapshots     bool
@@ -520,58 +520,58 @@ func (m *AccountMutation) ResetClan() {
 	m.clearedclan = false
 }
 
-// AddSnapshotIDs adds the "snapshots" edge to the AccountSnapshot entity by ids.
-func (m *AccountMutation) AddSnapshotIDs(ids ...string) {
-	if m.snapshots == nil {
-		m.snapshots = make(map[string]struct{})
+// AddAccountSnapshotIDs adds the "account_snapshots" edge to the AccountSnapshot entity by ids.
+func (m *AccountMutation) AddAccountSnapshotIDs(ids ...string) {
+	if m.account_snapshots == nil {
+		m.account_snapshots = make(map[string]struct{})
 	}
 	for i := range ids {
-		m.snapshots[ids[i]] = struct{}{}
+		m.account_snapshots[ids[i]] = struct{}{}
 	}
 }
 
-// ClearSnapshots clears the "snapshots" edge to the AccountSnapshot entity.
-func (m *AccountMutation) ClearSnapshots() {
-	m.clearedsnapshots = true
+// ClearAccountSnapshots clears the "account_snapshots" edge to the AccountSnapshot entity.
+func (m *AccountMutation) ClearAccountSnapshots() {
+	m.clearedaccount_snapshots = true
 }
 
-// SnapshotsCleared reports if the "snapshots" edge to the AccountSnapshot entity was cleared.
-func (m *AccountMutation) SnapshotsCleared() bool {
-	return m.clearedsnapshots
+// AccountSnapshotsCleared reports if the "account_snapshots" edge to the AccountSnapshot entity was cleared.
+func (m *AccountMutation) AccountSnapshotsCleared() bool {
+	return m.clearedaccount_snapshots
 }
 
-// RemoveSnapshotIDs removes the "snapshots" edge to the AccountSnapshot entity by IDs.
-func (m *AccountMutation) RemoveSnapshotIDs(ids ...string) {
-	if m.removedsnapshots == nil {
-		m.removedsnapshots = make(map[string]struct{})
+// RemoveAccountSnapshotIDs removes the "account_snapshots" edge to the AccountSnapshot entity by IDs.
+func (m *AccountMutation) RemoveAccountSnapshotIDs(ids ...string) {
+	if m.removedaccount_snapshots == nil {
+		m.removedaccount_snapshots = make(map[string]struct{})
 	}
 	for i := range ids {
-		delete(m.snapshots, ids[i])
-		m.removedsnapshots[ids[i]] = struct{}{}
+		delete(m.account_snapshots, ids[i])
+		m.removedaccount_snapshots[ids[i]] = struct{}{}
 	}
 }
 
-// RemovedSnapshots returns the removed IDs of the "snapshots" edge to the AccountSnapshot entity.
-func (m *AccountMutation) RemovedSnapshotsIDs() (ids []string) {
-	for id := range m.removedsnapshots {
+// RemovedAccountSnapshots returns the removed IDs of the "account_snapshots" edge to the AccountSnapshot entity.
+func (m *AccountMutation) RemovedAccountSnapshotsIDs() (ids []string) {
+	for id := range m.removedaccount_snapshots {
 		ids = append(ids, id)
 	}
 	return
 }
 
-// SnapshotsIDs returns the "snapshots" edge IDs in the mutation.
-func (m *AccountMutation) SnapshotsIDs() (ids []string) {
-	for id := range m.snapshots {
+// AccountSnapshotsIDs returns the "account_snapshots" edge IDs in the mutation.
+func (m *AccountMutation) AccountSnapshotsIDs() (ids []string) {
+	for id := range m.account_snapshots {
 		ids = append(ids, id)
 	}
 	return
 }
 
-// ResetSnapshots resets all changes to the "snapshots" edge.
-func (m *AccountMutation) ResetSnapshots() {
-	m.snapshots = nil
-	m.clearedsnapshots = false
-	m.removedsnapshots = nil
+// ResetAccountSnapshots resets all changes to the "account_snapshots" edge.
+func (m *AccountMutation) ResetAccountSnapshots() {
+	m.account_snapshots = nil
+	m.clearedaccount_snapshots = false
+	m.removedaccount_snapshots = nil
 }
 
 // AddVehicleSnapshotIDs adds the "vehicle_snapshots" edge to the VehicleSnapshot entity by ids.
@@ -947,8 +947,8 @@ func (m *AccountMutation) AddedEdges() []string {
 	if m.clan != nil {
 		edges = append(edges, account.EdgeClan)
 	}
-	if m.snapshots != nil {
-		edges = append(edges, account.EdgeSnapshots)
+	if m.account_snapshots != nil {
+		edges = append(edges, account.EdgeAccountSnapshots)
 	}
 	if m.vehicle_snapshots != nil {
 		edges = append(edges, account.EdgeVehicleSnapshots)
@@ -967,9 +967,9 @@ func (m *AccountMutation) AddedIDs(name string) []ent.Value {
 		if id := m.clan; id != nil {
 			return []ent.Value{*id}
 		}
-	case account.EdgeSnapshots:
-		ids := make([]ent.Value, 0, len(m.snapshots))
-		for id := range m.snapshots {
+	case account.EdgeAccountSnapshots:
+		ids := make([]ent.Value, 0, len(m.account_snapshots))
+		for id := range m.account_snapshots {
 			ids = append(ids, id)
 		}
 		return ids
@@ -992,8 +992,8 @@ func (m *AccountMutation) AddedIDs(name string) []ent.Value {
 // RemovedEdges returns all edge names that were removed in this mutation.
 func (m *AccountMutation) RemovedEdges() []string {
 	edges := make([]string, 0, 4)
-	if m.removedsnapshots != nil {
-		edges = append(edges, account.EdgeSnapshots)
+	if m.removedaccount_snapshots != nil {
+		edges = append(edges, account.EdgeAccountSnapshots)
 	}
 	if m.removedvehicle_snapshots != nil {
 		edges = append(edges, account.EdgeVehicleSnapshots)
@@ -1008,9 +1008,9 @@ func (m *AccountMutation) RemovedEdges() []string {
 // the given name in this mutation.
 func (m *AccountMutation) RemovedIDs(name string) []ent.Value {
 	switch name {
-	case account.EdgeSnapshots:
-		ids := make([]ent.Value, 0, len(m.removedsnapshots))
-		for id := range m.removedsnapshots {
+	case account.EdgeAccountSnapshots:
+		ids := make([]ent.Value, 0, len(m.removedaccount_snapshots))
+		for id := range m.removedaccount_snapshots {
 			ids = append(ids, id)
 		}
 		return ids
@@ -1036,8 +1036,8 @@ func (m *AccountMutation) ClearedEdges() []string {
 	if m.clearedclan {
 		edges = append(edges, account.EdgeClan)
 	}
-	if m.clearedsnapshots {
-		edges = append(edges, account.EdgeSnapshots)
+	if m.clearedaccount_snapshots {
+		edges = append(edges, account.EdgeAccountSnapshots)
 	}
 	if m.clearedvehicle_snapshots {
 		edges = append(edges, account.EdgeVehicleSnapshots)
@@ -1054,8 +1054,8 @@ func (m *AccountMutation) EdgeCleared(name string) bool {
 	switch name {
 	case account.EdgeClan:
 		return m.clearedclan
-	case account.EdgeSnapshots:
-		return m.clearedsnapshots
+	case account.EdgeAccountSnapshots:
+		return m.clearedaccount_snapshots
 	case account.EdgeVehicleSnapshots:
 		return m.clearedvehicle_snapshots
 	case account.EdgeAchievementSnapshots:
@@ -1082,8 +1082,8 @@ func (m *AccountMutation) ResetEdge(name string) error {
 	case account.EdgeClan:
 		m.ResetClan()
 		return nil
-	case account.EdgeSnapshots:
-		m.ResetSnapshots()
+	case account.EdgeAccountSnapshots:
+		m.ResetAccountSnapshots()
 		return nil
 	case account.EdgeVehicleSnapshots:
 		m.ResetVehicleSnapshots()
diff --git a/internal/database/ent/db/runtime.go b/internal/database/ent/db/runtime.go
index 61052e6b..7e0f56ad 100644
--- a/internal/database/ent/db/runtime.go
+++ b/internal/database/ent/db/runtime.go
@@ -201,6 +201,10 @@ func init() {
 	crontaskDescReferenceID := crontaskFields[4].Descriptor()
 	// crontask.ReferenceIDValidator is a validator for the "reference_id" field. It is called by the builders before save.
 	crontask.ReferenceIDValidator = crontaskDescReferenceID.Validators[0].(func(string) error)
+	// crontaskDescTriesLeft is the schema descriptor for tries_left field.
+	crontaskDescTriesLeft := crontaskFields[9].Descriptor()
+	// crontask.DefaultTriesLeft holds the default value on creation for the tries_left field.
+	crontask.DefaultTriesLeft = crontaskDescTriesLeft.Default.(int)
 	// crontaskDescID is the schema descriptor for id field.
 	crontaskDescID := crontaskFields[0].Descriptor()
 	// crontask.DefaultID holds the default value on creation for the id field.
diff --git a/internal/database/ent/schema/account.go b/internal/database/ent/schema/account.go
index b9518e57..c27e22df 100644
--- a/internal/database/ent/schema/account.go
+++ b/internal/database/ent/schema/account.go
@@ -41,9 +41,9 @@ func (Account) Fields() []ent.Field {
 func (Account) Edges() []ent.Edge {
 	return []ent.Edge{
 		edge.From("clan", Clan.Type).Ref("accounts").Field("clan_id").Unique(),
-		edge.To("snapshots", AccountSnapshot.Type),
-		edge.To("vehicle_snapshots", VehicleSnapshot.Type),
 		edge.To("achievement_snapshots", AchievementsSnapshot.Type),
+		edge.To("vehicle_snapshots", VehicleSnapshot.Type),
+		edge.To("account_snapshots", AccountSnapshot.Type),
 	}
 }
 
diff --git a/internal/database/ent/schema/account_snapshot.go b/internal/database/ent/schema/account_snapshot.go
index b7bff591..738d8386 100644
--- a/internal/database/ent/schema/account_snapshot.go
+++ b/internal/database/ent/schema/account_snapshot.go
@@ -35,7 +35,7 @@ func (AccountSnapshot) Fields() []ent.Field {
 // Edges of the AccountSnapshot.
 func (AccountSnapshot) Edges() []ent.Edge {
 	return []ent.Edge{
-		edge.From("account", Account.Type).Ref("snapshots").Field("account_id").Required().Immutable().Unique(),
+		edge.From("account", Account.Type).Ref("account_snapshots").Field("account_id").Required().Immutable().Unique(),
 	}
 }
 
diff --git a/internal/database/ent/schema/achievements_snapshot.go b/internal/database/ent/schema/achievements_snapshot.go
index b5f24775..9c9c1158 100644
--- a/internal/database/ent/schema/achievements_snapshot.go
+++ b/internal/database/ent/schema/achievements_snapshot.go
@@ -9,12 +9,10 @@ import (
 	"github.com/cufee/am-wg-proxy-next/v2/types"
 )
 
-// AchievementsSnapshot holds the schema definition for the AchievementsSnapshot entity.
 type AchievementsSnapshot struct {
 	ent.Schema
 }
 
-// Fields of the AchievementsSnapshot.
 func (AchievementsSnapshot) Fields() []ent.Field {
 	return append(defaultFields,
 		field.Enum("type").
@@ -28,7 +26,6 @@ func (AchievementsSnapshot) Fields() []ent.Field {
 	)
 }
 
-// Edges of the AchievementsSnapshot.
 func (AchievementsSnapshot) Edges() []ent.Edge {
 	return []ent.Edge{
 		edge.From("account", Account.Type).Ref("achievement_snapshots").Field("account_id").Required().Immutable().Unique(),
diff --git a/internal/database/models/achievements_snapshot.go b/internal/database/models/achievements_snapshot.go
new file mode 100644
index 00000000..11872587
--- /dev/null
+++ b/internal/database/models/achievements_snapshot.go
@@ -0,0 +1,19 @@
+package models
+
+import (
+	"time"
+
+	"github.com/cufee/am-wg-proxy-next/v2/types"
+)
+
+type AchievementsSnapshot struct {
+	ID          string
+	Type        SnapshotType
+	CreatedAt   time.Time
+	AccountID   string
+	ReferenceID string // accountID or vehicleID
+
+	Battles        int
+	LastBattleTime time.Time
+	Data           types.AchievementsFrame
+}
diff --git a/internal/database/models/task.go b/internal/database/models/task.go
index 9ded8cd4..9ea7ed03 100644
--- a/internal/database/models/task.go
+++ b/internal/database/models/task.go
@@ -9,8 +9,6 @@ type TaskType string
 const (
 	TaskTypeUpdateClans     TaskType = "UPDATE_CLANS"
 	TaskTypeRecordSnapshots TaskType = "RECORD_SNAPSHOTS"
-	// TaskTypeUpdateAccountWN8         TaskType = "UPDATE_ACCOUNT_WN8"
-	// TaskTypeRecordPlayerAchievements TaskType = "UPDATE_ACCOUNT_ACHIEVEMENTS"
 
 	TaskTypeDatabaseCleanup TaskType = "CLEANUP_DATABASE"
 )
@@ -21,9 +19,6 @@ func (TaskType) Values() []string {
 	for _, s := range []TaskType{
 		TaskTypeUpdateClans,
 		TaskTypeRecordSnapshots,
-		// TaskTypeUpdateAccountWN8,
-		// TaskTypeRecordPlayerAchievements,
-		//
 		TaskTypeDatabaseCleanup,
 	} {
 		kinds = append(kinds, string(s))
diff --git a/internal/database/snapshots.go b/internal/database/snapshots.go
index 8d9e4fb7..25902362 100644
--- a/internal/database/snapshots.go
+++ b/internal/database/snapshots.go
@@ -7,6 +7,7 @@ import (
 	"entgo.io/ent/dialect/sql"
 	"github.com/cufee/aftermath/internal/database/ent/db"
 	"github.com/cufee/aftermath/internal/database/ent/db/accountsnapshot"
+	"github.com/cufee/aftermath/internal/database/ent/db/achievementssnapshot"
 	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
 	"github.com/cufee/aftermath/internal/database/ent/db/vehiclesnapshot"
 	"github.com/cufee/aftermath/internal/database/models"
@@ -259,5 +260,116 @@ func (c *client) GetManyAccountSnapshots(ctx context.Context, accountIDs []strin
 	}
 
 	return snapshots, nil
+}
+
+func toAchievementsSnapshot(record *db.AchievementsSnapshot) models.AchievementsSnapshot {
+	return models.AchievementsSnapshot{
+		ID:             record.ID,
+		Type:           record.Type,
+		CreatedAt:      record.CreatedAt,
+		LastBattleTime: record.LastBattleTime,
+		ReferenceID:    record.ReferenceID,
+		AccountID:      record.AccountID,
+		Battles:        record.Battles,
+		Data:           record.Data,
+	}
+}
+
+func (c *client) CreateAccountAchievementSnapshots(ctx context.Context, accountID string, snapshots ...models.AchievementsSnapshot) (map[string]error, error) {
+	if len(snapshots) < 1 {
+		return nil, nil
+	}
+
+	var errors = make(map[string]error)
+	for _, data := range snapshots {
+		// make a transaction per write to avoid locking for too long
+		err := c.withTx(ctx, func(tx *db.Tx) error {
+			return c.db.AchievementsSnapshot.Create().
+				SetType(data.Type).
+				SetData(data.Data).
+				SetBattles(data.Battles).
+				SetCreatedAt(data.CreatedAt).
+				SetReferenceID(data.ReferenceID).
+				SetLastBattleTime(data.LastBattleTime).
+				SetAccount(c.db.Account.GetX(ctx, accountID)).
+				Exec(ctx)
+		})
+		if err != nil {
+			errors[data.ReferenceID] = err
+		}
+	}
+
+	if len(errors) > 0 {
+		return errors, nil
+	}
+	return nil, nil
+}
+
+func (c *client) GetAchievementsSnapshots(ctx context.Context, accountID string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.AchievementsSnapshot, error) {
+	var query getSnapshotQuery
+	for _, apply := range options {
+		apply(&query)
+	}
+
+	// this query is impossible to build using the db.AchievementSnapshot methods, so we do it manually
+	var innerWhere []*sql.Predicate
+	innerWhere = append(innerWhere,
+		sql.EQ(achievementssnapshot.FieldType, kind),
+		sql.EQ(achievementssnapshot.FieldAccountID, accountID),
+	)
+	innerOrder := sql.Desc(achievementssnapshot.FieldCreatedAt)
+
+	if query.createdAfter != nil {
+		innerWhere = append(innerWhere, sql.GT(achievementssnapshot.FieldCreatedAt, *query.createdAfter))
+		innerOrder = sql.Asc(achievementssnapshot.FieldCreatedAt)
+	}
+	if query.createdBefore != nil {
+		innerWhere = append(innerWhere, sql.LT(achievementssnapshot.FieldCreatedAt, *query.createdBefore))
+		innerOrder = sql.Desc(achievementssnapshot.FieldCreatedAt)
+	}
+	if len(query.vehicleIDs) > 0 {
+		var ids []any
+		for _, id := range query.vehicleIDs {
+			ids = append(ids, id)
+		}
+		innerWhere = append(innerWhere, sql.In(achievementssnapshot.FieldReferenceID, append(ids, accountID)...))
+	}
+
+	innerQuery := sql.Select(achievementssnapshot.Columns...).From(sql.Table(achievementssnapshot.Table))
+	innerQuery = innerQuery.Where(sql.And(innerWhere...))
+	innerQuery = innerQuery.OrderBy(innerOrder)
+
+	innerQueryString, innerQueryArgs := innerQuery.Query()
+
+	// wrap the inner query in a GROUP BY
+	wrapper := &sql.Builder{}
+	wrapped := wrapper.Wrap(func(b *sql.Builder) { b.WriteString(innerQueryString) })
+	queryString, _ := sql.Select("*").FromExpr(wrapped).GroupBy(achievementssnapshot.FieldReferenceID).Query()
+
+	rows, err := c.db.AchievementsSnapshot.QueryContext(ctx, queryString, innerQueryArgs...)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
 
+	var snapshots []models.AchievementsSnapshot
+	for rows.Next() {
+		var record db.AchievementsSnapshot
+
+		values, err := record.ScanValues(achievementssnapshot.Columns)
+		if err != nil {
+			return nil, err
+		}
+		if err := rows.Scan(values...); err != nil {
+			return nil, err
+		}
+
+		err = record.AssignValues(achievementssnapshot.Columns, values)
+		if err != nil {
+			return nil, err
+		}
+		snapshots = append(snapshots, toAchievementsSnapshot(&record))
+	}
+
+	return snapshots, nil
 }
diff --git a/internal/logic/snapshots.go b/internal/logic/snapshots.go
index 73ed394b..c71db3f1 100644
--- a/internal/logic/snapshots.go
+++ b/internal/logic/snapshots.go
@@ -16,23 +16,26 @@ import (
 	"github.com/rs/zerolog/log"
 )
 
-type vehicleResponseData map[string][]types.VehicleStatsFrame
-
-func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbClient database.Client, realm string, force bool, accountIDs ...string) (map[string]error, error) {
-	if len(accountIDs) < 1 {
-		return nil, nil
-	}
+type vehicleBattleData struct {
+	LastBattle time.Time
+	Battles    int
+}
 
-	createdAt := time.Now()
+/*
+Gets all accounts from WH and their respective snapshots
+  - an account is considered valid is it has played a battle since the last snapshot, or has no snapshots
+  - as side effect, invalid accounts will be set as private
+*/
+func getAndValidateAccounts(ctx context.Context, wgClient wargaming.Client, dbClient database.Client, force bool, realm string, accountIDs ...string) (map[string]types.ExtendedAccount, []string, map[string]*models.AccountSnapshot, error) {
 	accounts, err := wgClient.BatchAccountByID(ctx, realm, accountIDs)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to fetch accounts")
+		return nil, nil, nil, errors.Wrap(err, "failed to fetch accounts")
 	}
 
 	// existing snapshots for accounts
 	existingSnapshots, err := dbClient.GetManyAccountSnapshots(ctx, accountIDs, models.SnapshotTypeDaily)
 	if err != nil && !database.IsNotFound(err) {
-		return nil, errors.Wrap(err, "failed to get existing snapshots")
+		return nil, nil, nil, errors.Wrap(err, "failed to get existing snapshots")
 	}
 	existingSnapshotsMap := make(map[string]*models.AccountSnapshot)
 	for _, snapshot := range existingSnapshots {
@@ -40,7 +43,7 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 	}
 
 	// make a new slice just in case some accounts were not returned/are private
-	var validAccounts []string
+	var needAnUpdate []string
 	for _, id := range accountIDs {
 		data, ok := accounts[id]
 		if !ok {
@@ -63,85 +66,182 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 			// last snapshot is the same, we can skip it
 			continue
 		}
-		validAccounts = append(validAccounts, id)
+		needAnUpdate = append(needAnUpdate, id)
 	}
+	return accounts, needAnUpdate, existingSnapshotsMap, nil
+}
 
-	if len(validAccounts) < 1 {
+func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbClient database.Client, realm string, force bool, accountIDs ...string) (map[string]error, error) {
+	if len(accountIDs) < 1 {
 		return nil, nil
 	}
+	createdAt := time.Now()
 
-	// clans are optional-ish
-	clans, err := wgClient.BatchAccountClan(ctx, realm, validAccounts)
+	accounts, accountsNeedAnUpdate, _, err := getAndValidateAccounts(ctx, wgClient, dbClient, force, realm, accountIDs...)
 	if err != nil {
-		log.Err(err).Msg("failed to get batch account clans")
-		clans = make(map[string]types.ClanMember)
+		return nil, err
+	}
+	if len(accountsNeedAnUpdate) < 1 {
+		return nil, nil
 	}
 
-	vehicleCh := make(chan retry.DataWithErr[vehicleResponseData], len(validAccounts))
 	var group sync.WaitGroup
-	group.Add(len(validAccounts))
-	for _, id := range validAccounts {
+	var clans = make(map[string]types.ClanMember)
+	var accountAchievements retry.DataWithErr[map[string]types.AchievementsFrame]
+
+	var accountVehiclesMx sync.Mutex
+	var accountVehicleAchievementsMx sync.Mutex
+	accountVehicles := make(map[string]retry.DataWithErr[[]types.VehicleStatsFrame], len(accountsNeedAnUpdate))
+	accountVehicleAchievements := make(map[string]retry.DataWithErr[map[string]types.AchievementsFrame], len(accountsNeedAnUpdate))
+
+	for _, id := range accountsNeedAnUpdate {
+		group.Add(1)
+		// get account vehicle stats
 		go func(id string) {
 			defer group.Done()
 			data, err := wgClient.AccountVehicles(ctx, realm, id)
-			vehicleCh <- retry.DataWithErr[vehicleResponseData]{Data: vehicleResponseData{id: data}, Err: err}
+
+			accountVehiclesMx.Lock()
+			accountVehicles[id] = retry.DataWithErr[[]types.VehicleStatsFrame]{Data: data, Err: err}
+			accountVehiclesMx.Unlock()
+		}(id)
+
+		group.Add(1)
+		// get account vehicle achievements
+		go func(id string) {
+			defer group.Done()
+			data, err := wgClient.AccountVehicleAchievements(ctx, realm, id)
+
+			accountVehicleAchievementsMx.Lock()
+			accountVehicleAchievements[id] = retry.DataWithErr[map[string]types.AchievementsFrame]{Data: data, Err: err}
+			accountVehicleAchievementsMx.Unlock()
 		}(id)
 	}
+
+	group.Add(1)
+	// get account clans, not critical
+	go func() {
+		defer group.Done()
+		// clans are optional-ish
+		data, err := wgClient.BatchAccountClan(ctx, realm, accountsNeedAnUpdate)
+		if err != nil {
+			log.Err(err).Msg("failed to get batch account clans")
+		}
+		clans = data
+	}()
+
+	group.Add(1)
+	// get account achievements, not critical
+	go func() {
+		defer group.Done()
+		// clans are optional-ish
+		data, err := wgClient.BatchAccountAchievements(ctx, realm, accountsNeedAnUpdate)
+		if err != nil {
+			log.Err(err).Msg("failed to get batch account achievements")
+		}
+		accountAchievements.Data = data
+		accountAchievements.Err = err
+	}()
+
 	group.Wait()
-	close(vehicleCh)
 
 	var accountErrors = make(map[string]error)
 	var accountUpdates = make(map[string]models.Account)
 
 	var accountSnapshots []models.AccountSnapshot
 	var vehicleSnapshots = make(map[string][]models.VehicleSnapshot)
-	for result := range vehicleCh {
-		// there is only 1 key in this map
-		for id, vehicles := range result.Data {
-			if result.Err != nil {
-				accountErrors[id] = result.Err
-				continue
-			}
-			existingSnapshots, err := dbClient.GetVehicleSnapshots(ctx, id, id, models.SnapshotTypeDaily)
-			if err != nil && !database.IsNotFound(err) {
-				accountErrors[id] = err
-				continue
-			}
-			existingSnapshotsMap := make(map[string]*models.VehicleSnapshot)
-			for _, snapshot := range existingSnapshots {
-				existingSnapshotsMap[snapshot.VehicleID] = &snapshot
-			}
+	var achievementsSnapshots = make(map[string][]models.AchievementsSnapshot)
 
-			stats := fetch.WargamingToStats(realm, accounts[id], clans[id], vehicles)
+	for _, accountID := range accountsNeedAnUpdate {
+		vehicles := accountVehicles[accountID]
+		if vehicles.Err != nil {
+			accountErrors[accountID] = vehicles.Err
+			continue
+		}
+
+		// get existing vehicle snapshots from db
+		existingSnapshots, err := dbClient.GetVehicleSnapshots(ctx, accountID, accountID, models.SnapshotTypeDaily)
+		if err != nil && !database.IsNotFound(err) {
+			accountErrors[accountID] = err
+			continue
+		}
+		existingSnapshotsMap := make(map[string]*models.VehicleSnapshot)
+		for _, snapshot := range existingSnapshots {
+			existingSnapshotsMap[snapshot.VehicleID] = &snapshot
+		}
+
+		snapshotStats := fetch.WargamingToStats(realm, accounts[accountID], clans[accountID], vehicles.Data)
+		{ // account snapshot
 			accountSnapshots = append(accountSnapshots, models.AccountSnapshot{
 				Type:           models.SnapshotTypeDaily,
 				CreatedAt:      createdAt,
-				AccountID:      stats.Account.ID,
-				ReferenceID:    stats.Account.ID,
-				LastBattleTime: stats.LastBattleTime,
-				RatingBattles:  stats.RatingBattles.StatsFrame,
-				RegularBattles: stats.RegularBattles.StatsFrame,
+				AccountID:      snapshotStats.Account.ID,
+				ReferenceID:    snapshotStats.Account.ID,
+				LastBattleTime: snapshotStats.LastBattleTime,
+				RatingBattles:  snapshotStats.RatingBattles.StatsFrame,
+				RegularBattles: snapshotStats.RegularBattles.StatsFrame,
 			})
-			accountUpdates[id] = stats.Account
+			accountUpdates[accountID] = snapshotStats.Account
+		}
 
-			if len(vehicles) < 1 {
-				continue
-			}
-			vehicleStats := fetch.WargamingVehiclesToFrame(vehicles)
+		// vehicle snapshots
+		var vehicleLastBattleTimes = make(map[string]vehicleBattleData)
+		vehicleStats := fetch.WargamingVehiclesToFrame(vehicles.Data)
+		if len(vehicles.Data) > 0 {
 			for id, vehicle := range vehicleStats {
 				if s, ok := existingSnapshotsMap[id]; !force && ok && s.LastBattleTime.Equal(vehicle.LastBattleTime) {
 					// last snapshot is the same, we can skip it
 					continue
 				}
-
-				vehicleSnapshots[stats.Account.ID] = append(vehicleSnapshots[stats.Account.ID], models.VehicleSnapshot{
+				vehicleLastBattleTimes[id] = vehicleBattleData{vehicle.LastBattleTime, int(vehicle.Battles.Float())}
+				vehicleSnapshots[accountID] = append(vehicleSnapshots[accountID], models.VehicleSnapshot{
 					Type:           models.SnapshotTypeDaily,
 					LastBattleTime: vehicle.LastBattleTime,
 					Stats:          *vehicle.StatsFrame,
 					VehicleID:      vehicle.VehicleID,
-					AccountID:      stats.Account.ID,
-					ReferenceID:    stats.Account.ID,
+					AccountID:      accountID,
+					ReferenceID:    accountID,
+					CreatedAt:      createdAt,
+				})
+			}
+		}
+
+		// account achievement snapshot
+		if accountAchievements.Err != nil {
+			accountErrors[accountID] = errors.Wrap(accountAchievements.Err, "failed to get account achievements")
+		}
+		if achievements, ok := accountAchievements.Data[accountID]; ok {
+			achievementsSnapshots[accountID] = append(achievementsSnapshots[accountID], models.AchievementsSnapshot{
+				Data:           achievements,
+				CreatedAt:      createdAt,
+				AccountID:      accountID,
+				ReferenceID:    accountID,
+				Type:           models.SnapshotTypeDaily,
+				LastBattleTime: snapshotStats.LastBattleTime,
+				Battles:        int(snapshotStats.RegularBattles.Battles.Float()),
+			})
+		}
+
+		// account vehicle achievement snapshots
+		if achievements, ok := accountVehicleAchievements[accountID]; ok {
+			if achievements.Err != nil {
+				accountErrors[accountID] = errors.Wrap(achievements.Err, "failed to get vehicle achievements")
+			}
+			for vehicleID, a := range achievements.Data {
+				battleData, ok := vehicleLastBattleTimes[vehicleID]
+				if !ok {
+					// vehicle was not played, no need to save achievements
+					continue
+				}
+
+				achievementsSnapshots[accountID] = append(achievementsSnapshots[accountID], models.AchievementsSnapshot{
+					Data:           a,
 					CreatedAt:      createdAt,
+					AccountID:      accountID,
+					ReferenceID:    vehicleID,
+					Battles:        battleData.Battles,
+					LastBattleTime: battleData.LastBattle,
+					Type:           models.SnapshotTypeDaily,
 				})
 			}
 		}
@@ -162,6 +262,27 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 			}
 		}
 
+		achievements := achievementsSnapshots[accountSnapshot.AccountID]
+		if len(achievements) > 0 {
+			achErr, err := dbClient.CreateAccountAchievementSnapshots(ctx, accountSnapshot.AccountID, achievements...)
+			if err != nil {
+				accountErrors[accountSnapshot.AccountID] = errors.Wrap(err, "failed to save account achievements to database")
+				continue
+			}
+
+			for id, e := range achErr {
+				if e != nil {
+					err = errors.Wrapf(e, "failed to save some achievement snapshots, id %s", id)
+					break
+				}
+			}
+			if err != nil {
+				accountErrors[accountSnapshot.AccountID] = err
+				continue
+			}
+
+		}
+
 		// save account snapshot
 		aErr, err := dbClient.CreateAccountSnapshots(ctx, accountSnapshot)
 		if err != nil {
diff --git a/tests/static_database.go b/tests/static_database.go
index 29fdfab6..8c18c841 100644
--- a/tests/static_database.go
+++ b/tests/static_database.go
@@ -111,6 +111,12 @@ func (c *staticTestingDatabase) CreateAccountVehicleSnapshots(ctx context.Contex
 func (c *staticTestingDatabase) DeleteExpiredSnapshots(ctx context.Context, expiration time.Time) error {
 	return errors.New("DeleteExpiredSnapshots not implemented")
 }
+func (c *staticTestingDatabase) CreateAccountAchievementSnapshots(ctx context.Context, accountID string, snapshots ...models.AchievementsSnapshot) (map[string]error, error) {
+	return nil, errors.New("CreateAccountAchievementSnapshots not implemented")
+}
+func (c *staticTestingDatabase) GetAchievementsSnapshots(ctx context.Context, accountID string, kind models.SnapshotType, options ...database.SnapshotQuery) ([]models.AchievementsSnapshot, error) {
+	return nil, errors.New("GetAchievementsSnapshots not implemented")
+}
 
 func (c *staticTestingDatabase) CreateTasks(ctx context.Context, tasks ...models.Task) error {
 	return errors.New("not implemented")

From ccb20db5b67a7b4c3fdb0be5dbaaf6a44789cf4f Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 28 Jun 2024 21:23:03 -0400
Subject: [PATCH 217/341] fixing a memory leak

---
 cmd/core/queue/queue.go       |  6 +++---
 cmd/discord/common/reply.go   |  4 ++--
 cmd/discord/router/handler.go | 17 +++++++++--------
 3 files changed, 14 insertions(+), 13 deletions(-)

diff --git a/cmd/core/queue/queue.go b/cmd/core/queue/queue.go
index 09f8c6a2..68561820 100644
--- a/cmd/core/queue/queue.go
+++ b/cmd/core/queue/queue.go
@@ -25,7 +25,7 @@ type queue struct {
 	workerLimiter chan struct{}
 	workerTimeout time.Duration
 
-	activeTasks   map[string]struct{}
+	activeTasks   map[string]*struct{}
 	activeTasksMx *sync.Mutex
 	newCoreClient func() (core.Client, error)
 }
@@ -40,7 +40,7 @@ func New(workerLimit int, newCoreClient func() (core.Client, error)) *queue {
 		workerLimiter: make(chan struct{}, workerLimit),
 
 		activeTasksMx: &sync.Mutex{},
-		activeTasks:   make(map[string]struct{}),
+		activeTasks:   make(map[string]*struct{}, workerLimit*2),
 
 		queueLock: &sync.Mutex{},
 		queued:    make(chan models.Task, workerLimit*2),
@@ -152,7 +152,7 @@ func (q *queue) startWorkers(ctx context.Context, onComplete func(id string)) {
 			go func() {
 				q.workerLimiter <- struct{}{}
 				q.activeTasksMx.Lock()
-				q.activeTasks[task.ID] = struct{}{}
+				q.activeTasks[task.ID] = &struct{}{}
 				q.activeTasksMx.Unlock()
 				defer func() {
 					<-q.workerLimiter
diff --git a/cmd/discord/common/reply.go b/cmd/discord/common/reply.go
index 70fe2080..4e608a65 100644
--- a/cmd/discord/common/reply.go
+++ b/cmd/discord/common/reply.go
@@ -57,10 +57,10 @@ func (r reply) Embed(embeds ...*discordgo.MessageEmbed) reply {
 
 func (r reply) Send(content ...string) error {
 	r.text = append(r.text, content...)
-	return r.ctx.respond(r.data(r.ctx.Localize))
+	return r.ctx.respond(r.data())
 }
 
-func (r reply) data(localePrinter func(string) string) discordgo.InteractionResponseData {
+func (r reply) data() discordgo.InteractionResponseData {
 	var content []string
 	for _, t := range r.text {
 		content = append(content, r.ctx.Localize(t))
diff --git a/cmd/discord/router/handler.go b/cmd/discord/router/handler.go
index 3f913d94..419f55ac 100644
--- a/cmd/discord/router/handler.go
+++ b/cmd/discord/router/handler.go
@@ -9,6 +9,7 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	"runtime/debug"
 	"sync"
 	"time"
 
@@ -208,14 +209,14 @@ func (router *Router) startInteractionHandlerAsync(interaction discordgo.Interac
 	responseCh := make(chan discordgo.InteractionResponseData)
 
 	go func() {
-		// defer func() {
-		// 	if r := recover(); r != nil {
-		// 		log.Error().Str("stack", string(debug.Stack())).Msg("panic in interaction handler")
-		// 		state.mx.Lock()
-		// 		router.sendInteractionReply(interaction, state, discordgo.InteractionResponseData{Content: "Something unexpected happened and your command failed. Please try again in a few seconds."})
-		// 		state.mx.Unlock()
-		// 	}
-		// }()
+		defer func() {
+			if r := recover(); r != nil {
+				log.Error().Str("stack", string(debug.Stack())).Msg("panic in interaction handler")
+				state.mx.Lock()
+				router.sendInteractionReply(interaction, state, discordgo.InteractionResponseData{Content: "Something unexpected happened and your command failed. Please try again in a few seconds."})
+				state.mx.Unlock()
+			}
+		}()
 		router.handleInteraction(workerCtx, cancelWorker, interaction, command, responseCh)
 	}()
 

From 5ab12859b36b90057ae413fb4bbfc26dfe18791d Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sat, 29 Jun 2024 17:38:26 -0400
Subject: [PATCH 218/341] hopefully fixed a leak

---
 cmd/core/queue/queue.go | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/cmd/core/queue/queue.go b/cmd/core/queue/queue.go
index 68561820..037c2662 100644
--- a/cmd/core/queue/queue.go
+++ b/cmd/core/queue/queue.go
@@ -134,13 +134,12 @@ func (q *queue) pullAndEnqueueTasks(ctx context.Context, db database.Client) err
 	if err != nil && !database.IsNotFound(err) {
 		return err
 	}
-	log.Debug().Msgf("pulled %d tasks into queue", len(tasks))
 
-	go func(tasks []models.Task) {
-		for _, t := range tasks {
-			q.Enqueue(t)
-		}
-	}(tasks)
+	log.Debug().Msgf("adding %d tasks into queue", len(tasks))
+	for _, t := range tasks {
+		q.Enqueue(t)
+	}
+	log.Debug().Msgf("added %d tasks into queue", len(tasks))
 
 	return nil
 }

From 638f3aef5a375737747488edc1fce5470ae93497 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 30 Jun 2024 11:27:32 -0400
Subject: [PATCH 219/341] enabled pprof

---
 internal/database/snapshots.go | 23 +++++++++++++++++++----
 main.go                        | 10 ++++++++++
 2 files changed, 29 insertions(+), 4 deletions(-)

diff --git a/internal/database/snapshots.go b/internal/database/snapshots.go
index 25902362..d6e3fcb6 100644
--- a/internal/database/snapshots.go
+++ b/internal/database/snapshots.go
@@ -56,6 +56,11 @@ func (c *client) CreateAccountVehicleSnapshots(ctx context.Context, accountID st
 		return nil, nil
 	}
 
+	account, err := c.db.Account.Get(ctx, accountID)
+	if err != nil {
+		return nil, err
+	}
+
 	var errors = make(map[string]error)
 	for _, data := range snapshots {
 		// make a transaction per write to avoid locking for too long
@@ -68,7 +73,7 @@ func (c *client) CreateAccountVehicleSnapshots(ctx context.Context, accountID st
 				SetCreatedAt(data.CreatedAt).
 				SetBattles(int(data.Stats.Battles.Float())).
 				SetLastBattleTime(data.LastBattleTime).
-				SetAccount(c.db.Account.GetX(ctx, accountID)).
+				SetAccount(account).
 				Exec(ctx)
 		})
 		if err != nil {
@@ -172,10 +177,15 @@ func (c *client) CreateAccountSnapshots(ctx context.Context, snapshots ...models
 
 	var errors = make(map[string]error)
 	for _, s := range snapshots {
+		account, err := c.db.Account.Get(ctx, s.AccountID)
+		if err != nil {
+			errors[s.AccountID] = err
+			continue
+		}
 		// make a transaction per write to avoid locking for too long
-		err := c.withTx(ctx, func(tx *db.Tx) error {
+		err = c.withTx(ctx, func(tx *db.Tx) error {
 			return c.db.AccountSnapshot.Create().
-				SetAccount(c.db.Account.GetX(ctx, s.AccountID)). // we assume the account exists here
+				SetAccount(account).
 				SetCreatedAt(s.CreatedAt).
 				SetLastBattleTime(s.LastBattleTime).
 				SetRatingBattles(int(s.RatingBattles.Battles.Float())).
@@ -280,6 +290,11 @@ func (c *client) CreateAccountAchievementSnapshots(ctx context.Context, accountI
 		return nil, nil
 	}
 
+	account, err := c.db.Account.Get(ctx, accountID)
+	if err != nil {
+		return nil, err
+	}
+
 	var errors = make(map[string]error)
 	for _, data := range snapshots {
 		// make a transaction per write to avoid locking for too long
@@ -291,7 +306,7 @@ func (c *client) CreateAccountAchievementSnapshots(ctx context.Context, accountI
 				SetCreatedAt(data.CreatedAt).
 				SetReferenceID(data.ReferenceID).
 				SetLastBattleTime(data.LastBattleTime).
-				SetAccount(c.db.Account.GetX(ctx, accountID)).
+				SetAccount(account).
 				Exec(ctx)
 		})
 		if err != nil {
diff --git a/main.go b/main.go
index fa85a4a9..929ec2e9 100644
--- a/main.go
+++ b/main.go
@@ -35,6 +35,10 @@ import (
 	"github.com/rs/zerolog/log"
 
 	_ "github.com/joho/godotenv/autoload"
+
+	"net/http"
+	"net/http/pprof"
+	//  "github.com/pkg/profile"
 )
 
 //go:generate go generate ./internal/database/ent
@@ -75,6 +79,12 @@ func main() {
 	if e := os.Getenv("PRIVATE_SERVER_ENABLED"); e == "true" {
 		port := os.Getenv("PRIVATE_SERVER_PORT")
 		servePrivate := server.NewServer(port, []server.Handler{
+			{
+				Path: "GET /debug/profile/{name}",
+				Func: func(w http.ResponseWriter, r *http.Request) {
+					pprof.Handler(r.PathValue("name")).ServeHTTP(w, r)
+				},
+			},
 			{
 				Path: "POST /v1/tasks/restart",
 				Func: private.RestartStaleTasks(cacheCoreClient),

From 7bed4565aa344d49c831da97bec7d2716c2e00c2 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 30 Jun 2024 11:45:21 -0400
Subject: [PATCH 220/341] checking queue length from map instead of chan

---
 cmd/core/queue/queue.go | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/cmd/core/queue/queue.go b/cmd/core/queue/queue.go
index 037c2662..499a4e34 100644
--- a/cmd/core/queue/queue.go
+++ b/cmd/core/queue/queue.go
@@ -123,7 +123,10 @@ func (q *queue) pullAndEnqueueTasks(ctx context.Context, db database.Client) err
 	}
 	defer q.queueLock.Unlock()
 
-	currentQueue := len(q.queued)
+	q.activeTasksMx.Lock()
+	currentQueue := len(q.activeTasks)
+	q.activeTasksMx.Unlock()
+
 	if q.workerLimit < currentQueue {
 		log.Debug().Msg("queue is full")
 		return ErrQueueFull

From a3f1924bd7cf1f03480462992cf79288d7f3f792 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 30 Jun 2024 12:21:54 -0400
Subject: [PATCH 221/341] simplified interaction handlers

---
 cmd/discord/common/context.go    |  30 +++++-
 cmd/discord/discord.go           |   7 +-
 cmd/discord/rest/client.go       |  14 ++-
 cmd/discord/rest/commands.go     |  26 +++---
 cmd/discord/rest/interactions.go |  17 ++--
 cmd/discord/router/handler.go    | 154 ++++++++++---------------------
 cmd/discord/router/router.go     |  10 +-
 internal/retry/retry.go          |   9 +-
 8 files changed, 125 insertions(+), 142 deletions(-)

diff --git a/cmd/discord/common/context.go b/cmd/discord/common/context.go
index ea64e3a4..7354802b 100644
--- a/cmd/discord/common/context.go
+++ b/cmd/discord/common/context.go
@@ -2,6 +2,9 @@ package common
 
 import (
 	"context"
+	"os"
+	"sync"
+	"time"
 
 	"github.com/pkg/errors"
 
@@ -12,6 +15,7 @@ import (
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/localization"
+	"github.com/cufee/aftermath/internal/retry"
 
 	"github.com/rs/zerolog/log"
 	"golang.org/x/text/language"
@@ -25,6 +29,11 @@ const (
 	ContextKeyInteraction
 )
 
+type interactionState struct {
+	mx      *sync.Mutex
+	replied bool
+}
+
 type Context struct {
 	context.Context
 	User   models.User
@@ -37,11 +46,10 @@ type Context struct {
 
 	rest        *rest.Client
 	interaction discordgo.Interaction
-	respondCh   chan<- discordgo.InteractionResponseData
 }
 
-func NewContext(ctx context.Context, interaction discordgo.Interaction, respondCh chan<- discordgo.InteractionResponseData, rest *rest.Client, client core.Client) (*Context, error) {
-	c := &Context{Context: ctx, Locale: language.English, Core: client, rest: rest, interaction: interaction, respondCh: respondCh}
+func NewContext(ctx context.Context, interaction discordgo.Interaction, rest *rest.Client, client core.Client) (*Context, error) {
+	c := &Context{Context: ctx, Locale: language.English, Core: client, rest: rest, interaction: interaction}
 
 	if interaction.User != nil {
 		c.Member = *interaction.User
@@ -80,9 +88,21 @@ func (c *Context) respond(data discordgo.InteractionResponseData) error {
 	case <-c.Context.Done():
 		return c.Context.Err()
 	default:
-		c.respondCh <- data
+		res := retry.Retry(
+			func() (struct{}, error) {
+				ctx, cancel := context.WithTimeout(c.Context, time.Millisecond*500)
+				defer cancel()
+				return struct{}{}, c.rest.SendInteractionResponse(ctx, c.interaction.ID, c.interaction.Token, discordgo.InteractionResponse{Data: &data})
+			},
+			3, // 3 tries
+			time.Millisecond*100,
+			func(err error) bool {
+				// stop trying if the error is not caused by a timeout
+				return c.Context.Err() != nil || (err != nil && !os.IsTimeout(err))
+			},
+		)
+		return res.Err
 	}
-	return nil
 }
 
 func (c *Context) InteractionID() string {
diff --git a/cmd/discord/discord.go b/cmd/discord/discord.go
index 5fdcd3f4..cb02b5e3 100644
--- a/cmd/discord/discord.go
+++ b/cmd/discord/discord.go
@@ -1,7 +1,9 @@
 package discord
 
 import (
+	"context"
 	"net/http"
+	"time"
 
 	"github.com/cufee/aftermath/cmd/core"
 
@@ -17,7 +19,10 @@ func NewRouterHandler(coreClient core.Client, token string, publicKey string, co
 
 	rt.LoadCommands(commands...)
 
-	err = rt.UpdateLoadedCommands()
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*15)
+	defer cancel()
+
+	err = rt.UpdateLoadedCommands(ctx)
 	if err != nil {
 		return nil, err
 	}
diff --git a/cmd/discord/rest/client.go b/cmd/discord/rest/client.go
index 74cdc95f..ffaecea3 100644
--- a/cmd/discord/rest/client.go
+++ b/cmd/discord/rest/client.go
@@ -2,6 +2,7 @@ package rest
 
 import (
 	"bytes"
+	"context"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -28,7 +29,10 @@ func NewClient(token string) (*Client, error) {
 		http:  http.Client{Timeout: time.Millisecond * 5000}, // discord is very slow sometimes
 	}
 
-	_, err := client.lookupApplicationID()
+	ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*500)
+	defer cancel()
+
+	_, err := client.lookupApplicationID(ctx)
 	if err != nil {
 		return nil, err
 	}
@@ -108,7 +112,9 @@ func partHeader(contentDisposition string, contentType string) textproto.MIMEHea
 	}
 }
 
-func (c *Client) do(req *http.Request, target any) error {
+func (c *Client) do(ctx context.Context, req *http.Request, target any) error {
+	req = req.WithContext(ctx)
+
 	res, err := c.http.Do(req)
 	if err != nil {
 		return err
@@ -140,14 +146,14 @@ func (c *Client) do(req *http.Request, target any) error {
 	return nil
 }
 
-func (c *Client) lookupApplicationID() (string, error) {
+func (c *Client) lookupApplicationID(ctx context.Context) (string, error) {
 	req, err := c.request("GET", discordgo.EndpointApplication("@me"), nil)
 	if err != nil {
 		return "", err
 	}
 
 	var data discordgo.Application
-	err = c.do(req, &data)
+	err = c.do(ctx, req, &data)
 	if err != nil {
 		return "", err
 	}
diff --git a/cmd/discord/rest/commands.go b/cmd/discord/rest/commands.go
index 1a6599e2..c2cfce02 100644
--- a/cmd/discord/rest/commands.go
+++ b/cmd/discord/rest/commands.go
@@ -1,47 +1,51 @@
 package rest
 
-import "github.com/bwmarrin/discordgo"
+import (
+	"context"
 
-func (c *Client) OverwriteGlobalApplicationCommands(data []discordgo.ApplicationCommand) error {
+	"github.com/bwmarrin/discordgo"
+)
+
+func (c *Client) OverwriteGlobalApplicationCommands(ctx context.Context, data []discordgo.ApplicationCommand) error {
 	req, err := c.request("PUT", discordgo.EndpointApplicationGlobalCommands(c.applicationID), data)
 	if err != nil {
 		return err
 	}
-	return c.do(req, nil)
+	return c.do(ctx, req, nil)
 }
 
-func (c *Client) CreateGlobalApplicationCommand(data discordgo.ApplicationCommand) (discordgo.ApplicationCommand, error) {
+func (c *Client) CreateGlobalApplicationCommand(ctx context.Context, data discordgo.ApplicationCommand) (discordgo.ApplicationCommand, error) {
 	req, err := c.request("POST", discordgo.EndpointApplicationGlobalCommands(c.applicationID), data)
 	if err != nil {
 		return discordgo.ApplicationCommand{}, err
 	}
 	var command discordgo.ApplicationCommand
-	return command, c.do(req, &command)
+	return command, c.do(ctx, req, &command)
 }
 
-func (c *Client) GetGlobalApplicationCommands() ([]discordgo.ApplicationCommand, error) {
+func (c *Client) GetGlobalApplicationCommands(ctx context.Context) ([]discordgo.ApplicationCommand, error) {
 	req, err := c.request("GET", discordgo.EndpointApplicationGlobalCommands(c.applicationID), nil)
 	if err != nil {
 		return nil, err
 	}
 
 	var data []discordgo.ApplicationCommand
-	return data, c.do(req, &data)
+	return data, c.do(ctx, req, &data)
 }
 
-func (c *Client) UpdateGlobalApplicationCommand(id string, data discordgo.ApplicationCommand) (discordgo.ApplicationCommand, error) {
+func (c *Client) UpdateGlobalApplicationCommand(ctx context.Context, id string, data discordgo.ApplicationCommand) (discordgo.ApplicationCommand, error) {
 	req, err := c.request("PATCH", discordgo.EndpointApplicationGlobalCommand(c.applicationID, id), data)
 	if err != nil {
 		return discordgo.ApplicationCommand{}, err
 	}
 	var command discordgo.ApplicationCommand
-	return command, c.do(req, &command)
+	return command, c.do(ctx, req, &command)
 }
 
-func (c *Client) DeleteGlobalApplicationCommand(id string) error {
+func (c *Client) DeleteGlobalApplicationCommand(ctx context.Context, id string) error {
 	req, err := c.request("DELETE", discordgo.EndpointApplicationGlobalCommand(c.applicationID, id), nil)
 	if err != nil {
 		return err
 	}
-	return c.do(req, nil)
+	return c.do(ctx, req, nil)
 }
diff --git a/cmd/discord/rest/interactions.go b/cmd/discord/rest/interactions.go
index 692b2b7d..1c47d71e 100644
--- a/cmd/discord/rest/interactions.go
+++ b/cmd/discord/rest/interactions.go
@@ -1,12 +1,13 @@
 package rest
 
 import (
+	"context"
 	"net/http"
 
 	"github.com/bwmarrin/discordgo"
 )
 
-func (c *Client) SendInteractionResponse(id, token string, data discordgo.InteractionResponse) error {
+func (c *Client) SendInteractionResponse(ctx context.Context, id, token string, data discordgo.InteractionResponse) error {
 	var files []*discordgo.File
 	if data.Data != nil {
 		files = data.Data.Files
@@ -15,31 +16,31 @@ func (c *Client) SendInteractionResponse(id, token string, data discordgo.Intera
 	if err != nil {
 		return err
 	}
-	return c.do(req, nil)
+	return c.do(ctx, req, nil)
 }
 
-func (c *Client) UpdateInteractionResponse(id, token string, data discordgo.InteractionResponseData) error {
+func (c *Client) UpdateInteractionResponse(ctx context.Context, id, token string, data discordgo.InteractionResponseData) error {
 	req, err := c.interactionRequest("PATCH", discordgo.EndpointInteractionResponseActions(id, token), data, data.Files)
 	if err != nil {
 		return err
 	}
-	return c.do(req, nil)
+	return c.do(ctx, req, nil)
 }
 
-func (c *Client) SendInteractionFollowup(id, token string, data discordgo.InteractionResponse) error {
+func (c *Client) SendInteractionFollowup(ctx context.Context, id, token string, data discordgo.InteractionResponse) error {
 	req, err := c.interactionRequest("POST", discordgo.EndpointFollowupMessage(id, token), data, data.Data.Files)
 	if err != nil {
 		return err
 	}
-	return c.do(req, nil)
+	return c.do(ctx, req, nil)
 }
 
-func (c *Client) EditInteractionFollowup(id, token string, data discordgo.InteractionResponseData) error {
+func (c *Client) EditInteractionFollowup(ctx context.Context, id, token string, data discordgo.InteractionResponseData) error {
 	req, err := c.interactionRequest("PATCH", discordgo.EndpointFollowupMessage(id, token), data, data.Files)
 	if err != nil {
 		return err
 	}
-	return c.do(req, nil)
+	return c.do(ctx, req, nil)
 }
 
 func (c *Client) interactionRequest(method string, url string, payload any, files []*discordgo.File) (*http.Request, error) {
diff --git a/cmd/discord/router/handler.go b/cmd/discord/router/handler.go
index 419f55ac..c905c375 100644
--- a/cmd/discord/router/handler.go
+++ b/cmd/discord/router/handler.go
@@ -10,7 +10,6 @@ import (
 	"io"
 	"net/http"
 	"runtime/debug"
-	"sync"
 	"time"
 
 	"github.com/pkg/errors"
@@ -18,15 +17,10 @@ import (
 	"github.com/bwmarrin/discordgo"
 	"github.com/cufee/aftermath/cmd/discord/commands/builder"
 	"github.com/cufee/aftermath/cmd/discord/common"
+	"github.com/cufee/aftermath/internal/retry"
 	"github.com/rs/zerolog/log"
 )
 
-type interactionState struct {
-	mx      *sync.Mutex
-	acked   bool
-	replied bool
-}
-
 // https://github.com/bsdlp/discord-interactions-go/blob/main/interactions/verify.go
 func verifyPublicKey(r *http.Request, key ed25519.PublicKey) bool {
 	var msg bytes.Buffer
@@ -105,7 +99,7 @@ func (router *Router) HTTPHandler() (http.HandlerFunc, error) {
 			return
 		}
 
-		command, err := router.routeInteraction(data)
+		cmd, err := router.routeInteraction(data)
 		if err != nil {
 			http.Error(w, err.Error(), http.StatusInternalServerError)
 			log.Err(err).Str("id", data.ID).Msg("failed to route interaction")
@@ -113,27 +107,31 @@ func (router *Router) HTTPHandler() (http.HandlerFunc, error) {
 		}
 
 		// ack the interaction proactively
-		err = router.restClient.SendInteractionResponse(data.ID, data.Token, discordgo.InteractionResponse{Type: discordgo.InteractionResponseDeferredChannelMessageWithSource})
-		if err != nil {
-			http.Error(w, err.Error(), http.StatusInternalServerError)
+		res := retry.Retry(func() (struct{}, error) {
+			ctx, cancel := context.WithTimeout(r.Context(), time.Millisecond*250)
+			defer cancel()
+			return struct{}{}, router.restClient.SendInteractionResponse(ctx, data.ID, data.Token, discordgo.InteractionResponse{Type: discordgo.InteractionResponseDeferredChannelMessageWithSource})
+		}, 2, time.Millisecond*50)
+		if res.Err != nil {
+			http.Error(w, res.Err.Error(), http.StatusInternalServerError)
 			log.Err(err).Str("id", data.ID).Msg("failed to ack an interaction")
-			return
+			// cross our fingers and hope discord registered one of those requests
 		}
+
 		// write the ack into response
-		err = writeDeferredInteractionResponseAck(w, data.Type, command.Ephemeral)
+		err = writeDeferredInteractionResponseAck(w, data.Type, cmd.Ephemeral)
 		if err != nil {
 			http.Error(w, err.Error(), http.StatusInternalServerError)
 			log.Err(err).Str("id", data.ID).Msg("failed to write an interaction ack response")
 			return
 		}
 
-		// route the interaction to a proper handler for a later reply
-		state := &interactionState{mx: &sync.Mutex{}, acked: true}
-		router.startInteractionHandlerAsync(data, state, command)
+		// run the interaction handler
+		go router.handleInteraction(data, cmd)
 	}, nil
 }
 
-func (r *Router) routeInteraction(interaction discordgo.Interaction) (*builder.Command, error) {
+func (r *Router) routeInteraction(interaction discordgo.Interaction) (builder.Command, error) {
 	var matchKey string
 
 	switch interaction.Type {
@@ -146,29 +144,27 @@ func (r *Router) routeInteraction(interaction discordgo.Interaction) (*builder.C
 	}
 
 	if matchKey == "" {
-		return nil, errors.New("match key not found")
+		return builder.Command{}, errors.New("match key not found")
 	}
 
 	for _, cmd := range r.commands {
 		if cmd.Match(matchKey) {
-			return &cmd, nil
+			return cmd, nil
 		}
 	}
-	return nil, fmt.Errorf("failed to match %s to a command handler", matchKey)
+	return builder.Command{}, fmt.Errorf("failed to match %s to a command handler", matchKey)
 }
 
-func (r *Router) handleInteraction(ctx context.Context, cancel context.CancelFunc, interaction discordgo.Interaction, command *builder.Command, reply chan<- discordgo.InteractionResponseData) {
+func (r *Router) handleInteraction(interaction discordgo.Interaction, command builder.Command) {
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
 	defer cancel()
 
-	cCtx, err := common.NewContext(ctx, interaction, reply, r.restClient, r.core)
+	cCtx, err := common.NewContext(ctx, interaction, r.restClient, r.core)
 	if err != nil {
+		ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+		defer cancel()
 		log.Err(err).Msg("failed to create a common.Context for a handler")
-		select {
-		case <-ctx.Done():
-			return
-		default:
-			reply <- discordgo.InteractionResponseData{Content: cCtx.Localize("common_error_unhandled_not_reported")}
-		}
+		r.sendInteractionReply(ctx, interaction, discordgo.InteractionResponseData{Content: "Something unexpected happened and your command failed. Please try again in a few seconds."})
 		return
 	}
 
@@ -177,17 +173,24 @@ func (r *Router) handleInteraction(ctx context.Context, cancel context.CancelFun
 		handler = command.Middleware[i](cCtx, handler)
 	}
 
-	err = handler(cCtx)
-	if err != nil {
-		log.Err(err).Msg("handler returned an error")
-		select {
-		case <-ctx.Done():
+	func() {
+		defer func() {
+			if rec := recover(); rec != nil {
+				ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+				defer cancel()
+				log.Error().Str("stack", string(debug.Stack())).Msg("panic in interaction handler")
+				r.sendInteractionReply(ctx, interaction, discordgo.InteractionResponseData{Content: cCtx.Localize("common_error_unhandled_not_reported")})
+			}
+		}()
+		err = handler(cCtx)
+		if err != nil {
+			ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+			defer cancel()
+			log.Err(err).Msg("handler returned an error")
+			r.sendInteractionReply(ctx, interaction, discordgo.InteractionResponseData{Content: cCtx.Localize("common_error_unhandled_not_reported")})
 			return
-		default:
-			reply <- discordgo.InteractionResponseData{Content: cCtx.Localize("common_error_unhandled_not_reported")}
 		}
-		return
-	}
+	}()
 }
 
 func sendPingReply(w http.ResponseWriter) {
@@ -198,89 +201,26 @@ func sendPingReply(w http.ResponseWriter) {
 	}
 }
 
-func (router *Router) startInteractionHandlerAsync(interaction discordgo.Interaction, state *interactionState, command *builder.Command) {
-	log.Info().Str("id", interaction.ID).Msg("started handling an interaction")
-
-	// create a new context and cancel it on reply
-	// we need to respond within 15 minutes, but it's safe to assume something failed if we did not reply quickly
-	workerCtx, cancelWorker := context.WithTimeout(context.Background(), time.Second*10)
-
-	// handle the interaction
-	responseCh := make(chan discordgo.InteractionResponseData)
-
-	go func() {
-		defer func() {
-			if r := recover(); r != nil {
-				log.Error().Str("stack", string(debug.Stack())).Msg("panic in interaction handler")
-				state.mx.Lock()
-				router.sendInteractionReply(interaction, state, discordgo.InteractionResponseData{Content: "Something unexpected happened and your command failed. Please try again in a few seconds."})
-				state.mx.Unlock()
-			}
-		}()
-		router.handleInteraction(workerCtx, cancelWorker, interaction, command, responseCh)
-	}()
-
-	go func() {
-		defer close(responseCh)
-		defer cancelWorker()
-
-		for {
-			select {
-			case <-workerCtx.Done():
-				state.mx.Lock()
-				defer state.mx.Unlock()
-				// we are done, there is nothing else we should do here
-				// lock in case responseCh is still busy sending some data over
-				log.Info().Str("id", interaction.ID).Msg("finished handling an interaction")
-				return
-
-			case data := <-responseCh:
-				state.mx.Lock()
-				log.Debug().Str("id", interaction.ID).Msg("sending an interaction reply")
-				router.sendInteractionReply(interaction, state, data)
-				state.mx.Unlock()
-			}
-		}
-	}()
-}
-
-func (r *Router) sendInteractionReply(interaction discordgo.Interaction, state *interactionState, data discordgo.InteractionResponseData) {
+func (r *Router) sendInteractionReply(ctx context.Context, interaction discordgo.Interaction, data discordgo.InteractionResponseData) {
 	var handler func() error
 
 	switch interaction.Type {
 	case discordgo.InteractionApplicationCommand, discordgo.InteractionMessageComponent:
-		if state.replied || state.acked {
-			// We already replied to this interaction - edit the message
-			handler = func() error {
-				return r.restClient.UpdateInteractionResponse(interaction.AppID, interaction.Token, data)
-			}
-		} else {
-			// We never replied to this message, create a new reply
-			handler = func() error {
-				payload := discordgo.InteractionResponse{Data: &data, Type: discordgo.InteractionResponseChannelMessageWithSource}
-				return r.restClient.SendInteractionResponse(interaction.ID, interaction.Token, payload)
-			}
+		handler = func() error {
+			return r.restClient.UpdateInteractionResponse(ctx, interaction.AppID, interaction.Token, data)
 		}
 	default:
-		log.Error().Stack().Any("state", state).Any("data", data).Str("id", interaction.ID).Msg("unknown interaction type received")
-		if state.replied || state.acked {
-			handler = func() error {
-				return r.restClient.UpdateInteractionResponse(interaction.AppID, interaction.Token, discordgo.InteractionResponseData{Content: "Something unexpected happened and your command failed."})
-			}
-		} else {
-			handler = func() error {
-				return r.restClient.SendInteractionResponse(interaction.ID, interaction.Token, discordgo.InteractionResponse{Data: &discordgo.InteractionResponseData{Content: "Something unexpected happened and your command failed."}, Type: discordgo.InteractionResponseChannelMessageWithSource})
-			}
+		log.Error().Stack().Any("data", data).Str("id", interaction.ID).Msg("unknown interaction type received")
+		handler = func() error {
+			return r.restClient.UpdateInteractionResponse(ctx, interaction.AppID, interaction.Token, discordgo.InteractionResponseData{Content: "Something unexpected happened and your command failed."})
 		}
 	}
 
 	err := handler()
 	if err != nil {
-		log.Err(err).Stack().Any("state", state).Any("data", data).Str("id", interaction.ID).Msg("failed to send an interaction response")
+		log.Err(err).Stack().Any("data", data).Str("id", interaction.ID).Msg("failed to send an interaction response")
 		return
 	}
-	state.acked = true
-	state.replied = true
 }
 
 func writeDeferredInteractionResponseAck(w http.ResponseWriter, t discordgo.InteractionType, ephemeral bool) error {
diff --git a/cmd/discord/router/router.go b/cmd/discord/router/router.go
index 459717fa..bb829bb0 100644
--- a/cmd/discord/router/router.go
+++ b/cmd/discord/router/router.go
@@ -64,13 +64,13 @@ Updates all loaded commands using the Discord REST API
   - any commands that are loaded will be created/updated
   - any commands that were not loaded will be deleted
 */
-func (r *Router) UpdateLoadedCommands() error {
+func (r *Router) UpdateLoadedCommands(ctx context.Context) error {
 	var commandByName = make(map[string]command)
 	for _, cmd := range r.commands {
 		commandByName[cmd.Name] = command{requested: &cmd}
 	}
 
-	current, err := r.restClient.GetGlobalApplicationCommands()
+	current, err := r.restClient.GetGlobalApplicationCommands(ctx)
 	if err != nil {
 		return err
 	}
@@ -103,7 +103,7 @@ func (r *Router) UpdateLoadedCommands() error {
 			if err != nil {
 				return err
 			}
-			command, err := r.restClient.CreateGlobalApplicationCommand(data.requested.ApplicationCommand)
+			command, err := r.restClient.CreateGlobalApplicationCommand(ctx, data.requested.ApplicationCommand)
 			if err != nil {
 				return err
 			}
@@ -115,7 +115,7 @@ func (r *Router) UpdateLoadedCommands() error {
 
 		case data.requested == nil && data.current != nil:
 			log.Debug().Str("name", data.current.Name).Str("id", data.current.ID).Msg("deleting a global command")
-			err := r.restClient.DeleteGlobalApplicationCommand(data.current.ID)
+			err := r.restClient.DeleteGlobalApplicationCommand(ctx, data.current.ID)
 			if err != nil {
 				return err
 			}
@@ -132,7 +132,7 @@ func (r *Router) UpdateLoadedCommands() error {
 				if err != nil {
 					return err
 				}
-				command, err := r.restClient.UpdateGlobalApplicationCommand(data.current.ID, data.requested.ApplicationCommand)
+				command, err := r.restClient.UpdateGlobalApplicationCommand(ctx, data.current.ID, data.requested.ApplicationCommand)
 				if err != nil {
 					return err
 				}
diff --git a/internal/retry/retry.go b/internal/retry/retry.go
index 7585e5c6..ebe873ef 100644
--- a/internal/retry/retry.go
+++ b/internal/retry/retry.go
@@ -11,7 +11,7 @@ type DataWithErr[T any] struct {
 	Err  error
 }
 
-func Retry[T any](fn func() (T, error), tries int, sleepOnFail time.Duration) DataWithErr[T] {
+func Retry[T any](fn func() (T, error), tries int, sleepOnFail time.Duration, breakIf ...func(error) bool) DataWithErr[T] {
 	if tries < 1 {
 		return DataWithErr[T]{Err: errors.New("invalid number of tries provided")}
 	}
@@ -22,6 +22,13 @@ func Retry[T any](fn func() (T, error), tries int, sleepOnFail time.Duration) Da
 		return DataWithErr[T]{Data: data, Err: err}
 	}
 
+	for _, check := range breakIf {
+		shouldBreak := check(err)
+		if shouldBreak {
+			return DataWithErr[T]{Err: err}
+		}
+	}
+
 	time.Sleep(sleepOnFail)
 	return Retry(fn, tries, sleepOnFail)
 }

From f07ec88e8aab00e3de7847f5bd051d2fbfab95d5 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 30 Jun 2024 12:35:59 -0400
Subject: [PATCH 222/341] added known errors to rest

---
 cmd/discord/rest/client.go    |  6 ++++--
 cmd/discord/rest/errors.go    | 25 +++++++++++++++++++++++++
 cmd/discord/router/handler.go | 18 ++++++++++++------
 internal/retry/retry.go       |  6 ++++++
 4 files changed, 47 insertions(+), 8 deletions(-)
 create mode 100644 cmd/discord/rest/errors.go

diff --git a/cmd/discord/rest/client.go b/cmd/discord/rest/client.go
index ffaecea3..ba101f16 100644
--- a/cmd/discord/rest/client.go
+++ b/cmd/discord/rest/client.go
@@ -133,8 +133,10 @@ func (c *Client) do(ctx context.Context, req *http.Request, target any) error {
 		if message == "" {
 			message = res.Status + ", response was not valid json"
 		}
-
-		return errors.New("discord error: " + message)
+		if err := knownError(body.Code); err != nil {
+			return err
+		}
+		return errors.New("discord api: " + message)
 	}
 
 	if target != nil {
diff --git a/cmd/discord/rest/errors.go b/cmd/discord/rest/errors.go
new file mode 100644
index 00000000..dadd264e
--- /dev/null
+++ b/cmd/discord/rest/errors.go
@@ -0,0 +1,25 @@
+package rest
+
+import (
+	"github.com/bwmarrin/discordgo"
+	"github.com/pkg/errors"
+)
+
+var (
+	ErrUnknownWebhook          = errors.New("discord api: unknown webhook")
+	ErrUnknownInteraction      = errors.New("discord api: unknown interaction")
+	ErrInteractionAlreadyAcked = errors.New("discord api: interaction already acked")
+)
+
+func knownError(code int) error {
+	switch code {
+	default:
+		return nil
+	case discordgo.ErrCodeUnknownWebhook:
+		return ErrUnknownWebhook
+	case discordgo.ErrCodeUnknownInteraction:
+		return ErrUnknownInteraction
+	case discordgo.ErrCodeInteractionHasAlreadyBeenAcknowledged:
+		return ErrInteractionAlreadyAcked
+	}
+}
diff --git a/cmd/discord/router/handler.go b/cmd/discord/router/handler.go
index c905c375..944f31f1 100644
--- a/cmd/discord/router/handler.go
+++ b/cmd/discord/router/handler.go
@@ -17,6 +17,7 @@ import (
 	"github.com/bwmarrin/discordgo"
 	"github.com/cufee/aftermath/cmd/discord/commands/builder"
 	"github.com/cufee/aftermath/cmd/discord/common"
+	"github.com/cufee/aftermath/cmd/discord/rest"
 	"github.com/cufee/aftermath/internal/retry"
 	"github.com/rs/zerolog/log"
 )
@@ -107,12 +108,17 @@ func (router *Router) HTTPHandler() (http.HandlerFunc, error) {
 		}
 
 		// ack the interaction proactively
-		res := retry.Retry(func() (struct{}, error) {
-			ctx, cancel := context.WithTimeout(r.Context(), time.Millisecond*250)
-			defer cancel()
-			return struct{}{}, router.restClient.SendInteractionResponse(ctx, data.ID, data.Token, discordgo.InteractionResponse{Type: discordgo.InteractionResponseDeferredChannelMessageWithSource})
-		}, 2, time.Millisecond*50)
-		if res.Err != nil {
+		res := retry.Retry(
+			func() (struct{}, error) {
+				ctx, cancel := context.WithTimeout(r.Context(), time.Millisecond*250)
+				defer cancel()
+				return struct{}{}, router.restClient.SendInteractionResponse(ctx, data.ID, data.Token, discordgo.InteractionResponse{Type: discordgo.InteractionResponseDeferredChannelMessageWithSource})
+			},
+			3,
+			time.Millisecond*50,
+			// break if the error
+			func(err error) bool { return errors.Is(err, rest.ErrInteractionAlreadyAcked) })
+		if res.Err != nil && !errors.Is(res.Err, rest.ErrInteractionAlreadyAcked) {
 			http.Error(w, res.Err.Error(), http.StatusInternalServerError)
 			log.Err(err).Str("id", data.ID).Msg("failed to ack an interaction")
 			// cross our fingers and hope discord registered one of those requests
diff --git a/internal/retry/retry.go b/internal/retry/retry.go
index ebe873ef..9cbc25be 100644
--- a/internal/retry/retry.go
+++ b/internal/retry/retry.go
@@ -32,3 +32,9 @@ func Retry[T any](fn func() (T, error), tries int, sleepOnFail time.Duration, br
 	time.Sleep(sleepOnFail)
 	return Retry(fn, tries, sleepOnFail)
 }
+
+func IfErrNot(notErr error) func(error) bool {
+	return func(err error) bool {
+		return !errors.Is(err, notErr)
+	}
+}

From 60b805a75003c8814175085e39a08b34c74439bd Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 30 Jun 2024 12:45:24 -0400
Subject: [PATCH 223/341] adjuster retries on response

---
 cmd/discord/common/context.go | 7 ++++---
 cmd/discord/router/handler.go | 2 +-
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/cmd/discord/common/context.go b/cmd/discord/common/context.go
index 7354802b..3497a1aa 100644
--- a/cmd/discord/common/context.go
+++ b/cmd/discord/common/context.go
@@ -92,13 +92,14 @@ func (c *Context) respond(data discordgo.InteractionResponseData) error {
 			func() (struct{}, error) {
 				ctx, cancel := context.WithTimeout(c.Context, time.Millisecond*500)
 				defer cancel()
-				return struct{}{}, c.rest.SendInteractionResponse(ctx, c.interaction.ID, c.interaction.Token, discordgo.InteractionResponse{Data: &data})
+				return struct{}{}, c.rest.SendInteractionResponse(ctx, c.interaction.ID, c.interaction.Token, discordgo.InteractionResponse{Type: discordgo.InteractionResponseDeferredMessageUpdate, Data: &data})
 			},
 			3, // 3 tries
 			time.Millisecond*100,
+			// stop trying if the parent context was cancelled, or the error is not caused by a timeout and is not indicating that interaction was not acked
+			// the rest.ErrUnknownWebhook error specifically is likely caused by discord being slow and not propagating the state of out initial ack -- all interaction we handle are always acked
 			func(err error) bool {
-				// stop trying if the error is not caused by a timeout
-				return c.Context.Err() != nil || (err != nil && !os.IsTimeout(err))
+				return c.Context.Err() != nil || (!os.IsTimeout(err) && !errors.Is(err, rest.ErrUnknownWebhook))
 			},
 		)
 		return res.Err
diff --git a/cmd/discord/router/handler.go b/cmd/discord/router/handler.go
index 944f31f1..e64b7c8b 100644
--- a/cmd/discord/router/handler.go
+++ b/cmd/discord/router/handler.go
@@ -121,7 +121,7 @@ func (router *Router) HTTPHandler() (http.HandlerFunc, error) {
 		if res.Err != nil && !errors.Is(res.Err, rest.ErrInteractionAlreadyAcked) {
 			http.Error(w, res.Err.Error(), http.StatusInternalServerError)
 			log.Err(err).Str("id", data.ID).Msg("failed to ack an interaction")
-			// cross our fingers and hope discord registered one of those requests
+			// cross our fingers and hope discord registered one of those requests, or will propagate the ack from the response body
 		}
 
 		// write the ack into response

From 5f869e622ac12a94eaf543a3e7d1012709d15128 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 30 Jun 2024 13:25:47 -0400
Subject: [PATCH 224/341] updated deps

---
 go.mod                                | 2 +-
 go.sum                                | 4 ++--
 internal/external/wargaming/client.go | 3 ++-
 3 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/go.mod b/go.mod
index d39d25ff..68658f09 100644
--- a/go.mod
+++ b/go.mod
@@ -5,7 +5,7 @@ go 1.22.3
 require (
 	entgo.io/ent v0.13.1
 	github.com/bwmarrin/discordgo v0.28.1
-	github.com/cufee/am-wg-proxy-next/v2 v2.1.6
+	github.com/cufee/am-wg-proxy-next/v2 v2.1.7
 	github.com/disintegration/imaging v1.6.2
 	github.com/fogleman/gg v1.3.0
 	github.com/go-co-op/gocron v1.37.0
diff --git a/go.sum b/go.sum
index b64339d0..bf5c2b86 100644
--- a/go.sum
+++ b/go.sum
@@ -12,8 +12,8 @@ github.com/bwmarrin/discordgo v0.28.1 h1:gXsuo2GBO7NbR6uqmrrBDplPUx2T3nzu775q/Rd
 github.com/bwmarrin/discordgo v0.28.1/go.mod h1:NJZpH+1AfhIcyQsPeuBKsUtYrRnjkyu0kIVMCHkZtRY=
 github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
-github.com/cufee/am-wg-proxy-next/v2 v2.1.6 h1:LNGXS9n1FANtblhEUxMAZehfcTIH6FsGfF0snhf2hHM=
-github.com/cufee/am-wg-proxy-next/v2 v2.1.6/go.mod h1:+VxiIdbrdhHdRThASbVmZ5Fz4H6XPCzL3S2Ix6TO/84=
+github.com/cufee/am-wg-proxy-next/v2 v2.1.7 h1:cNIQ6hLM/eqqKLuNH0K52AEjzQQqwo7qoi9VOXD6bSM=
+github.com/cufee/am-wg-proxy-next/v2 v2.1.7/go.mod h1:+VxiIdbrdhHdRThASbVmZ5Fz4H6XPCzL3S2Ix6TO/84=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
diff --git a/internal/external/wargaming/client.go b/internal/external/wargaming/client.go
index 130de06b..738c4cac 100644
--- a/internal/external/wargaming/client.go
+++ b/internal/external/wargaming/client.go
@@ -6,6 +6,7 @@ import (
 	"time"
 
 	"github.com/cufee/am-wg-proxy-next/v2/client"
+	"github.com/rs/zerolog"
 )
 
 type Client interface {
@@ -25,5 +26,5 @@ func NewClientFromEnv(primaryAppId, primaryAppRps, requestTimeout, proxyHostList
 	}
 	timeout := time.Second * time.Duration(timeoutInt)
 
-	return client.NewEmbeddedClient(primaryAppId, primaryRps, proxyHostList, timeout)
+	return client.NewEmbeddedClient(primaryAppId, primaryRps, proxyHostList, timeout, client.WithLogLevel(zerolog.WarnLevel))
 }

From fb087fa3807136b86fcf4934924f4c3b9e9cc2a4 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 30 Jun 2024 13:37:59 -0400
Subject: [PATCH 225/341] removed io.ReadAll calls

---
 cmd/core/server/handlers/private/accounts.go | 9 +--------
 cmd/discord/rest/client.go                   | 7 +------
 2 files changed, 2 insertions(+), 14 deletions(-)

diff --git a/cmd/core/server/handlers/private/accounts.go b/cmd/core/server/handlers/private/accounts.go
index 06734a2b..d42b260b 100644
--- a/cmd/core/server/handlers/private/accounts.go
+++ b/cmd/core/server/handlers/private/accounts.go
@@ -4,7 +4,6 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"io"
 	"net/http"
 	"strconv"
 	"sync"
@@ -22,15 +21,9 @@ This function is temporary and does not need to be good :D
 */
 func LoadAccountsHandler(client core.Client) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		payload, err := io.ReadAll(r.Body)
-		if err != nil {
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
 		defer r.Body.Close()
-
 		var accounts []string
-		err = json.Unmarshal(payload, &accounts)
+		err := json.NewDecoder(r.Body).Decode(&accounts)
 		if err != nil {
 			http.Error(w, err.Error(), http.StatusInternalServerError)
 			return
diff --git a/cmd/discord/rest/client.go b/cmd/discord/rest/client.go
index ba101f16..4adaad56 100644
--- a/cmd/discord/rest/client.go
+++ b/cmd/discord/rest/client.go
@@ -123,12 +123,7 @@ func (c *Client) do(ctx context.Context, req *http.Request, target any) error {
 
 	if res.StatusCode > 299 {
 		var body discordgo.APIErrorMessage
-		data, err := io.ReadAll(res.Body)
-		if err != nil {
-			return fmt.Errorf("failed to read body: %w", err)
-		}
-
-		_ = json.Unmarshal(data, &body)
+		_ = json.NewDecoder(res.Body).Decode(&body)
 		message := body.Message
 		if message == "" {
 			message = res.Status + ", response was not valid json"

From f26515710ea86bd14d0a6314e482361c256d1840 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 30 Jun 2024 13:47:39 -0400
Subject: [PATCH 226/341] typo

---
 cmd/discord/common/context.go | 2 +-
 docker-compose.yaml           | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/cmd/discord/common/context.go b/cmd/discord/common/context.go
index 3497a1aa..846cf7a6 100644
--- a/cmd/discord/common/context.go
+++ b/cmd/discord/common/context.go
@@ -92,7 +92,7 @@ func (c *Context) respond(data discordgo.InteractionResponseData) error {
 			func() (struct{}, error) {
 				ctx, cancel := context.WithTimeout(c.Context, time.Millisecond*500)
 				defer cancel()
-				return struct{}{}, c.rest.SendInteractionResponse(ctx, c.interaction.ID, c.interaction.Token, discordgo.InteractionResponse{Type: discordgo.InteractionResponseDeferredMessageUpdate, Data: &data})
+				return struct{}{}, c.rest.UpdateInteractionResponse(ctx, c.interaction.ID, c.interaction.Token, data)
 			},
 			3, // 3 tries
 			time.Millisecond*100,
diff --git a/docker-compose.yaml b/docker-compose.yaml
index e808c713..ca895eef 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -28,7 +28,7 @@ services:
     deploy:
       resources:
         reservations:
-          memory: 512m
+          memory: 128m
     networks:
       - dokploy-network
     labels:

From 5fd365e507eda20e4916c52a76579a5c1312dee2 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 30 Jun 2024 13:52:30 -0400
Subject: [PATCH 227/341] proper error

---
 cmd/discord/router/handler.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cmd/discord/router/handler.go b/cmd/discord/router/handler.go
index e64b7c8b..56f55245 100644
--- a/cmd/discord/router/handler.go
+++ b/cmd/discord/router/handler.go
@@ -120,7 +120,7 @@ func (router *Router) HTTPHandler() (http.HandlerFunc, error) {
 			func(err error) bool { return errors.Is(err, rest.ErrInteractionAlreadyAcked) })
 		if res.Err != nil && !errors.Is(res.Err, rest.ErrInteractionAlreadyAcked) {
 			http.Error(w, res.Err.Error(), http.StatusInternalServerError)
-			log.Err(err).Str("id", data.ID).Msg("failed to ack an interaction")
+			log.Err(res.Err).Str("id", data.ID).Msg("failed to ack an interaction")
 			// cross our fingers and hope discord registered one of those requests, or will propagate the ack from the response body
 		}
 

From 8e2fb4b1608e02ceda7c60381ef504c3a7cf10b6 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 30 Jun 2024 14:06:34 -0400
Subject: [PATCH 228/341] simplified response code

---
 cmd/discord/common/context.go | 20 +++-----------------
 cmd/discord/router/handler.go | 35 +++++++++++++++++++++++------------
 2 files changed, 26 insertions(+), 29 deletions(-)

diff --git a/cmd/discord/common/context.go b/cmd/discord/common/context.go
index 846cf7a6..52895dc0 100644
--- a/cmd/discord/common/context.go
+++ b/cmd/discord/common/context.go
@@ -2,7 +2,6 @@ package common
 
 import (
 	"context"
-	"os"
 	"sync"
 	"time"
 
@@ -15,7 +14,6 @@ import (
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/localization"
-	"github.com/cufee/aftermath/internal/retry"
 
 	"github.com/rs/zerolog/log"
 	"golang.org/x/text/language"
@@ -88,21 +86,9 @@ func (c *Context) respond(data discordgo.InteractionResponseData) error {
 	case <-c.Context.Done():
 		return c.Context.Err()
 	default:
-		res := retry.Retry(
-			func() (struct{}, error) {
-				ctx, cancel := context.WithTimeout(c.Context, time.Millisecond*500)
-				defer cancel()
-				return struct{}{}, c.rest.UpdateInteractionResponse(ctx, c.interaction.ID, c.interaction.Token, data)
-			},
-			3, // 3 tries
-			time.Millisecond*100,
-			// stop trying if the parent context was cancelled, or the error is not caused by a timeout and is not indicating that interaction was not acked
-			// the rest.ErrUnknownWebhook error specifically is likely caused by discord being slow and not propagating the state of out initial ack -- all interaction we handle are always acked
-			func(err error) bool {
-				return c.Context.Err() != nil || (!os.IsTimeout(err) && !errors.Is(err, rest.ErrUnknownWebhook))
-			},
-		)
-		return res.Err
+		ctx, cancel := context.WithTimeout(c.Context, time.Millisecond*3000)
+		defer cancel()
+		return c.rest.UpdateInteractionResponse(ctx, c.interaction.AppID, c.interaction.Token, data)
 	}
 }
 
diff --git a/cmd/discord/router/handler.go b/cmd/discord/router/handler.go
index 56f55245..76536aec 100644
--- a/cmd/discord/router/handler.go
+++ b/cmd/discord/router/handler.go
@@ -108,27 +108,40 @@ func (router *Router) HTTPHandler() (http.HandlerFunc, error) {
 		}
 
 		// ack the interaction proactively
+		payload, err := deferredInteractionResponsePayload(data.Type, cmd.Ephemeral)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			log.Err(err).Str("id", data.ID).Msg("failed to make an ack response payload")
+			return
+		}
+
 		res := retry.Retry(
 			func() (struct{}, error) {
-				ctx, cancel := context.WithTimeout(r.Context(), time.Millisecond*250)
+				ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*500)
 				defer cancel()
-				return struct{}{}, router.restClient.SendInteractionResponse(ctx, data.ID, data.Token, discordgo.InteractionResponse{Type: discordgo.InteractionResponseDeferredChannelMessageWithSource})
+				err := router.restClient.SendInteractionResponse(ctx, data.ID, data.Token, payload)
+				return struct{}{}, err
 			},
 			3,
 			time.Millisecond*50,
-			// break if the error
+			// break if the error means we were able to ack on the last request
 			func(err error) bool { return errors.Is(err, rest.ErrInteractionAlreadyAcked) })
 		if res.Err != nil && !errors.Is(res.Err, rest.ErrInteractionAlreadyAcked) {
-			http.Error(w, res.Err.Error(), http.StatusInternalServerError)
 			log.Err(res.Err).Str("id", data.ID).Msg("failed to ack an interaction")
 			// cross our fingers and hope discord registered one of those requests, or will propagate the ack from the response body
 		}
 
-		// write the ack into response
-		err = writeDeferredInteractionResponseAck(w, data.Type, cmd.Ephemeral)
+		// write the ack into response, this typically does nothing/is flaky
+		body, err := json.Marshal(payload)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			log.Err(err).Str("id", data.ID).Msg("failed to encode interaction ack payload")
+			return
+		}
+		_, err = w.Write(body)
 		if err != nil {
 			http.Error(w, err.Error(), http.StatusInternalServerError)
-			log.Err(err).Str("id", data.ID).Msg("failed to write an interaction ack response")
+			log.Err(err).Str("id", data.ID).Msg("failed to write interaction ack payload")
 			return
 		}
 
@@ -229,7 +242,7 @@ func (r *Router) sendInteractionReply(ctx context.Context, interaction discordgo
 	}
 }
 
-func writeDeferredInteractionResponseAck(w http.ResponseWriter, t discordgo.InteractionType, ephemeral bool) error {
+func deferredInteractionResponsePayload(t discordgo.InteractionType, ephemeral bool) (discordgo.InteractionResponse, error) {
 	var response discordgo.InteractionResponse
 	if ephemeral {
 		response.Data.Flags = discordgo.MessageFlagsEphemeral
@@ -242,10 +255,8 @@ func writeDeferredInteractionResponseAck(w http.ResponseWriter, t discordgo.Inte
 		response.Type = discordgo.InteractionResponseDeferredMessageUpdate
 
 	default:
-		return fmt.Errorf("interaction type %s not supported", t.String())
+		return response, fmt.Errorf("interaction type %s not supported", t.String())
 	}
 
-	body, _ := json.Marshal(response)
-	_, err := w.Write(body)
-	return err
+	return response, nil
 }

From 33b9cc93133b0403f46934a91567fdc7dabf335e Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 30 Jun 2024 14:11:37 -0400
Subject: [PATCH 229/341] fixed response type

---
 cmd/discord/router/handler.go | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/cmd/discord/router/handler.go b/cmd/discord/router/handler.go
index 76536aec..71f35a6d 100644
--- a/cmd/discord/router/handler.go
+++ b/cmd/discord/router/handler.go
@@ -249,10 +249,8 @@ func deferredInteractionResponsePayload(t discordgo.InteractionType, ephemeral b
 	}
 
 	switch t {
-	case discordgo.InteractionApplicationCommand:
+	case discordgo.InteractionApplicationCommand, discordgo.InteractionMessageComponent:
 		response.Type = discordgo.InteractionResponseDeferredChannelMessageWithSource
-	case discordgo.InteractionMessageComponent:
-		response.Type = discordgo.InteractionResponseDeferredMessageUpdate
 
 	default:
 		return response, fmt.Errorf("interaction type %s not supported", t.String())

From 20adb25339c2a216cce0874a46a7915139742211 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 30 Jun 2024 14:19:25 -0400
Subject: [PATCH 230/341] blaming discord

---
 cmd/discord/common/context.go       | 17 ++++++++++-------
 static/localization/en/discord.yaml |  3 +++
 2 files changed, 13 insertions(+), 7 deletions(-)

diff --git a/cmd/discord/common/context.go b/cmd/discord/common/context.go
index 52895dc0..64e755be 100644
--- a/cmd/discord/common/context.go
+++ b/cmd/discord/common/context.go
@@ -2,7 +2,7 @@ package common
 
 import (
 	"context"
-	"sync"
+	"os"
 	"time"
 
 	"github.com/pkg/errors"
@@ -27,11 +27,6 @@ const (
 	ContextKeyInteraction
 )
 
-type interactionState struct {
-	mx      *sync.Mutex
-	replied bool
-}
-
 type Context struct {
 	context.Context
 	User   models.User
@@ -88,7 +83,15 @@ func (c *Context) respond(data discordgo.InteractionResponseData) error {
 	default:
 		ctx, cancel := context.WithTimeout(c.Context, time.Millisecond*3000)
 		defer cancel()
-		return c.rest.UpdateInteractionResponse(ctx, c.interaction.AppID, c.interaction.Token, data)
+		err := c.rest.UpdateInteractionResponse(ctx, c.interaction.AppID, c.interaction.Token, data)
+		if os.IsTimeout(err) {
+			// request timed out, most likely a discord issue
+			log.Error().Str("id", c.ID()).Str("interactionId", c.interaction.ID).Msg("discord api: request timed out while responding to an interaction")
+			ctx, cancel := context.WithTimeout(c.Context, time.Millisecond*1000)
+			defer cancel()
+			return c.rest.UpdateInteractionResponse(ctx, c.interaction.AppID, c.interaction.Token, discordgo.InteractionResponseData{Content: c.Localize("common_error_discord_outage")})
+		}
+		return err
 	}
 }
 
diff --git a/static/localization/en/discord.yaml b/static/localization/en/discord.yaml
index 19885bba..0de71987 100755
--- a/static/localization/en/discord.yaml
+++ b/static/localization/en/discord.yaml
@@ -66,6 +66,9 @@
 - key: common_error_service_outage
   value: "Aftermath is currently undergoing maintenance and is temporarily unavailable. Please try again in a few moments."
   context: Failed to reach some internal service
+- key: common_error_discord_outage
+  value: "It looks like Discord is having some temporary issues. Please try again in a few seconds."
+  context: Discord request timed out for unknown reasons
 
 - key: common_error_unhandled_reported
   value: Something unexpected happened and your command failed.\n*This error was reported automatically, you can also reach out to our team on Aftermath Official*"

From fe4ae9e120f90e900fa26227eab676566582275c Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 30 Jun 2024 14:50:08 -0400
Subject: [PATCH 231/341] removed some unused files

---
 .air.toml                                     |   1 +
 static/images/icons/chevron-down-double.png   | Bin 306 -> 0 bytes
 static/images/icons/chevron-down-single.png   | Bin 243 -> 0 bytes
 static/images/icons/chevron-up-double.png     | Bin 285 -> 0 bytes
 static/images/icons/chevron-up-single.png     | Bin 239 -> 0 bytes
 static/images/icons/logo-128.png              | Bin 24744 -> 0 bytes
 static/images/icons/triangle-down-outline.png | Bin 739 -> 0 bytes
 static/images/icons/triangle-up-outline.png   | Bin 710 -> 0 bytes
 8 files changed, 1 insertion(+)
 delete mode 100644 static/images/icons/chevron-down-double.png
 delete mode 100644 static/images/icons/chevron-down-single.png
 delete mode 100644 static/images/icons/chevron-up-double.png
 delete mode 100644 static/images/icons/chevron-up-single.png
 delete mode 100644 static/images/icons/logo-128.png
 delete mode 100644 static/images/icons/triangle-down-outline.png
 delete mode 100644 static/images/icons/triangle-up-outline.png

diff --git a/.air.toml b/.air.toml
index 44d5d232..4a197927 100644
--- a/.air.toml
+++ b/.air.toml
@@ -1,2 +1,3 @@
 [build]
+# cmd = "go build -gcflags=-m=3 -o ./tmp/main ."
 stop_on_error = true
diff --git a/static/images/icons/chevron-down-double.png b/static/images/icons/chevron-down-double.png
deleted file mode 100644
index 6a9282929a2f726c0aec110be4d35f9d44f71c36..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 306
zcmeAS@N?(olHy`uVBq!ia0vp^3LwnE1|*BCs=ffJpPnv`ArbD$DG~_>EDn4#?y*WR
zVd>yxWKD4DWq;J_@TcK~3-@JX!4?0Q?QD-&Fr=)sxuW2%P}|s`%+v7ccVh&@s%sOX
z_!wp~f8w=sSBT~d`Y+JoxUf-JK$uCvnV-SX{)$LUpTqV)$^m<s7YZmJV^pZ-v~1Ej
z?Z_tlnxUqT;pD+bGDp--J>OuVc$9I645JXcs>LK-byJpvKDU0p85W*)>gFs3ARQ-p
z8B^SI8j6@WmX^&>E15OJgrVzxje^{UNdh6CUNRdlbmFi~ar1Usv{}V4lObM_W%Ud<
z??V?S6;w=b+2IwqszZ1-@5&@eGiNth11Tnk%h6$q+<J9ufPui^>FVdQ&MBb@0N%`I
AL;wH)

diff --git a/static/images/icons/chevron-down-single.png b/static/images/icons/chevron-down-single.png
deleted file mode 100644
index f10eb35fec042d58632a4b717c813c129981fd05..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 243
zcmeAS@N?(olHy`uVBq!ia0vp^3LwnE1|*BCs=ffJU7jwEArbCxryS&MFyLWM3`$^1
zV3J@oYw%R83+d8|y7c8@zxLB+q1!vdzQjJhZ2s-NL<5Tl5FKzzn127OTB*m{WAWxy
z=_@^7ojM!AWaGt<Byd*t3(qRW*NL10+c;<K6xjGv)7e{>@yzi<@rsY;ML#>XUwgB_
zh1uC#tXfXX98zTrQdzLDd8QeE^i;MVTnjbDXI678S;u_8`)oGT5tW!{TNw@H<1FPC
qzOJ~}a9YFk2!o0PlgfoT2e^MU$SUqSKl=pG7Yv@RelF{r5}E)cWnKRO

diff --git a/static/images/icons/chevron-up-double.png b/static/images/icons/chevron-up-double.png
deleted file mode 100644
index 9495bf8a75ae666314dbaf22c52d73605b78cbd8..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 285
zcmeAS@N?(olHy`uVBq!ia0vp^3LwnE1|*BCs=ffJC!Q{jArbCxrv&mc849?(7inNV
zz$oOv#5bWqMCAbkrvjr)19QQFoK3$kZz-|<`{KOWO_P^fXI|g=_RQr6hWyv&GbzZt
zC`{;P+m|IQZ(u*8EsfFTPg~Tg7wn(sH6}0w74EiRy~s78t3I^$pw&gD3BvbRevmb0
zeaNcO8U6TVIoBcP0O9R&3lwY^^flImxc=LDBd)4Qvt`cRKh^Ve8B9OU5%$;N3Ms5$
zc(QhWfcTU<CycM%C~=t^_{nBBgIBvUr*7NXg&v1MFh*$KMvaA6L|tq>BYge+MXDD~
hzbDM_@IV23UEZHC#WRBTx<LOjc)I$ztaD0e0sy`IZrA_-

diff --git a/static/images/icons/chevron-up-single.png b/static/images/icons/chevron-up-single.png
deleted file mode 100644
index 4ad6276935191d974328c41313db06c5ed6a5fe4..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 239
zcmeAS@N?(olHy`uVBq!ia0vp^3LwnE1|*BCs=ffJZJsWUArbCxr`+XiFyLV;4Ju`l
zbyN>9zu;-g$h`E*3^o3JHBOFy9<IBdb^A}v7W>cA919q@7C3Bi@VDR8eeC7mg{~}o
zO=bKu&a?Noge$aiUsru7sB!SF&{ihPm}_y<np{_TUE!GWU=Jtjt4SNUGCr8pZ*6f+
zP(C!{O~E-m<MZZqdb=(&PySXK!Scg;x^wgXsR5E=jPnk9JuWuuToDre;+Bl=g1z$l
k(lrIzKo$d0L)Zhhpt*92_anAD0DZvV>FVdQ&MBb@0IQ%|zyJUM

diff --git a/static/images/icons/logo-128.png b/static/images/icons/logo-128.png
deleted file mode 100644
index 184987bdff489e37da61ec8ce58adbe5ee96c9b3..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 24744
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
Hu0mjfJpb%D

diff --git a/static/images/icons/triangle-down-outline.png b/static/images/icons/triangle-down-outline.png
deleted file mode 100644
index 0d278a923ff2db7161105aeffd7a705301035226..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 739
zcmV<90v!E`P)<h;3K|Lk000e1NJLTq001xm001xu1^@s6R|5Hm00082Nkl<ZXhZFo
zjcwFG5QUQppo4@80u|(_08&9r1%V23sQ{<|Q$a!n92Gz+$fbj%1Kua?N+Sz<XMb#T
zl1EzEmUrLGo0;7i`}pX<<@mtuKUxX=?+C6DSR+vBfi;CH9az2G8-Z(Sdav=iTB8r(
zkEY#e+@z*^2z(PrmjasUeJ|V(Q`jj2r&|0llW|_ySDLsVo17x>Q42qZ#XmwCc@@{p
zBYoZlfKR%9DJ8Jc!k=L=Ucehm2vH~c$XktFDFN0!X}kyk<YPZGgHHJDJLFm8<&?fu
z3bA&p!6_8U5CurhAsCDIqtTo~=pPji0T%ByP6A32w1Sy+)}wGvQ&?UCoq%Fk@&21Y
zDuti(9%FwS@4M2~O8`SCE@#1_@47;&rSt;341o8#x{78FfsH`piG-fX^Es0l-naE;
z^5n7DIRsd@(>M<R+@q+4;20c){4)1R>|6rHo|>?vDzdo*u%p+Axyrs^L)Qo!H|Bfx
z-YOwL6fnF+aqEO*ixx!oIo>EC0RC1Z7B>`@wivc$D5@`|1gMl49-~mA+&Y1lfyic8
z_)-Ey!G<5jIW5MpWpEX(f2CFp0q}@IY%#v-p7z@#w8vLrqN`;X1Fa>%XXdQ|_Y^l$
z#TKm#J=6aeNi6}C?lfX?^BjY{=Eq|=t7y%ULSSw*Y>P3~2IS0jMWjUpP-MMIM8;YS
z+cJ2fl_b%MfG4j@_RC@fP-IV*y`G1~%@(bk6Kj%0s|cWESlsN{-s!z<8HiYR(VA-$
zTimT4hTqS;&-%_y=8c)qG6E5n^ohkSp6}#8QdP8;hyXf<o7L*ADq2esK#%>S7xhm5
zVarJyJ9my0ium;QoA9vHm2ZgVGADuN#x9vcix`iRH3EyddPLD0fi(h^9ys_E`U^&s
Vb}|38Y`_2j002ovPDHLkV1fzsQY-)f

diff --git a/static/images/icons/triangle-up-outline.png b/static/images/icons/triangle-up-outline.png
deleted file mode 100644
index 24fa2dac44f9e3e78900011a048ee379722df765..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 710
zcmV;%0y+JOP)<h;3K|Lk000e1NJLTq001xm001xu1^@s6R|5Hm0007wNkl<ZXhZE-
zfl<RS3~VO=CLl}zOhB0cn1C_?Faco#U;@enzyy>DfC(rQ02`pclQ@w}ZP{{KdKca0
z?52+WFUfu-!@-K%aK-TtdIHOiU>|`#0!|O~DHL$v4*j>s|36dv>U4JN<6TAIj8?m9
ztawhpuS=8Yg1{kxyq^Q~i0(g>B+&(dcLG>3$VYAuxSdhE^`8mU1nz<Xek&pXzQ*@2
zsl~V=Rx$$Xgb3b83p=4}!u>I|x7`2YD4=y)NdnlQr;O-Bd0#*x3Y+}nhFWZNx0NDL
zvG)Z~+h%QUZtMk+a#<+?NR?wof-`?K2i27Bi#FU*f9yg}50@YSuulreKJ@{#%~Hmi
zxRoFP@ZxccS9P>N6oj+QOCTq&D?*FYO3Wp0UIJRQQcf0qV$Fz2wzzo+U<1n8E}~^U
z+o2TzF5;#&BPpG72{c73M_p?|Dyp3=Zn*^X;%%a3^&+Am;+ErttYZ|L@P)3nlEDgG
z#_2Rf6m~ha%=6?#U_!HtXuVM%FD@R#i_SJrU^#~Wtd&Xt-q%N9NVKe^Ml?_hVN!{a
zN<fQNsARB$mvK|-NQr^IS=>?xxI7hMlpWa=0@%2c@5#Ap2#MZX*caH)QL_>l(@a{l
zKx7u3J#7G@0N_dDW+k9YhOG12$fc%nB5rU{w8XFw(37T?3`X3)!<r>V)L9k+pEP|5
z(Xx`!=?Zb%2t61hFrtU$jP{faR`4<o=_4gZP-|iY^cOaKkV5Ug2*ZalylcRMU-V)G
zDw;qm?;^lA*9a<ei~uH^&?U9cq6tLx#zFv~YYwRtU0oAFk%*MVx<RuNh|ROK|9b*U
sb3HHIN1%^@(*u19IUVSJeB~qX1A!WLF}PHA+yDRo07*qoM6N<$g2byfs{jB1


From bee9ff68ef5980088874e8daf3fd9fca44509e0c Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 30 Jun 2024 18:50:24 -0400
Subject: [PATCH 232/341] passing files as slices instead of readers, handling
 bad discord event propagation

---
 cmd/discord/commands/interactions.go |  2 +-
 cmd/discord/commands/manage.go       |  5 ++-
 cmd/discord/commands/session.go      |  2 +-
 cmd/discord/commands/stats.go        |  2 +-
 cmd/discord/common/context.go        |  6 ++--
 cmd/discord/common/reply.go          | 16 +++++-----
 cmd/discord/rest/interactions.go     | 47 ++++++++++++++++++++--------
 cmd/discord/router/handler.go        |  6 ++--
 8 files changed, 53 insertions(+), 33 deletions(-)

diff --git a/cmd/discord/commands/interactions.go b/cmd/discord/commands/interactions.go
index 901c252c..5d529612 100644
--- a/cmd/discord/commands/interactions.go
+++ b/cmd/discord/commands/interactions.go
@@ -102,7 +102,7 @@ func init() {
 					timings = append(timings, "```")
 				}
 
-				return ctx.Reply().File(&buf, interaction.Command+"_command_by_aftermath.png").Component(button).Text(timings...).Send()
+				return ctx.Reply().File(buf.Bytes(), interaction.Command+"_command_by_aftermath.png").Component(button).Text(timings...).Send()
 			}),
 	)
 }
diff --git a/cmd/discord/commands/manage.go b/cmd/discord/commands/manage.go
index eaaaad67..dff707d1 100644
--- a/cmd/discord/commands/manage.go
+++ b/cmd/discord/commands/manage.go
@@ -1,7 +1,6 @@
 package commands
 
 import (
-	"bytes"
 	"encoding/json"
 	"fmt"
 	"time"
@@ -145,7 +144,7 @@ func init() {
 					}
 					content += string(data)
 
-					return ctx.Reply().File(bytes.NewBufferString(content), "tasks.json").Send()
+					return ctx.Reply().File([]byte(content), "tasks.json").Send()
 
 				case "tasks_details":
 					if !ctx.User.HasPermission(permissions.ViewTaskLogs) {
@@ -169,7 +168,7 @@ func init() {
 					if err != nil {
 						return ctx.Reply().Send("json.Marshal: " + err.Error())
 					}
-					return ctx.Reply().File(bytes.NewReader(data), "tasks.json").Send()
+					return ctx.Reply().File(data, "tasks.json").Send()
 
 				default:
 					return ctx.Reply().Send("invalid subcommand, thought this should never happen")
diff --git a/cmd/discord/commands/session.go b/cmd/discord/commands/session.go
index bd217a0d..c5386b4a 100644
--- a/cmd/discord/commands/session.go
+++ b/cmd/discord/commands/session.go
@@ -106,7 +106,7 @@ func init() {
 					timings = append(timings, "```")
 				}
 
-				return ctx.Reply().File(&buf, "session_command_by_aftermath.png").Component(button).Text(timings...).Send()
+				return ctx.Reply().File(buf.Bytes(), "session_command_by_aftermath.png").Component(button).Text(timings...).Send()
 			}),
 	)
 }
diff --git a/cmd/discord/commands/stats.go b/cmd/discord/commands/stats.go
index c64fc7ce..61a1f0cb 100644
--- a/cmd/discord/commands/stats.go
+++ b/cmd/discord/commands/stats.go
@@ -91,7 +91,7 @@ func init() {
 					timings = append(timings, "```")
 				}
 
-				return ctx.Reply().File(&buf, "stats_command_by_aftermath.png").Component(button).Text(timings...).Send()
+				return ctx.Reply().File(buf.Bytes(), "stats_command_by_aftermath.png").Component(button).Text(timings...).Send()
 			}),
 	)
 }
diff --git a/cmd/discord/common/context.go b/cmd/discord/common/context.go
index 64e755be..2edd93d3 100644
--- a/cmd/discord/common/context.go
+++ b/cmd/discord/common/context.go
@@ -76,20 +76,20 @@ func NewContext(ctx context.Context, interaction discordgo.Interaction, rest *re
 	return c, nil
 }
 
-func (c *Context) respond(data discordgo.InteractionResponseData) error {
+func (c *Context) respond(data discordgo.InteractionResponseData, files []rest.File) error {
 	select {
 	case <-c.Context.Done():
 		return c.Context.Err()
 	default:
 		ctx, cancel := context.WithTimeout(c.Context, time.Millisecond*3000)
 		defer cancel()
-		err := c.rest.UpdateInteractionResponse(ctx, c.interaction.AppID, c.interaction.Token, data)
+		err := c.rest.UpdateOrSendInteractionResponse(ctx, c.interaction.AppID, c.interaction.ID, c.interaction.Token, discordgo.InteractionResponse{Type: discordgo.InteractionResponseChannelMessageWithSource, Data: &data}, files)
 		if os.IsTimeout(err) {
 			// request timed out, most likely a discord issue
 			log.Error().Str("id", c.ID()).Str("interactionId", c.interaction.ID).Msg("discord api: request timed out while responding to an interaction")
 			ctx, cancel := context.WithTimeout(c.Context, time.Millisecond*1000)
 			defer cancel()
-			return c.rest.UpdateInteractionResponse(ctx, c.interaction.AppID, c.interaction.Token, discordgo.InteractionResponseData{Content: c.Localize("common_error_discord_outage")})
+			return c.rest.UpdateOrSendInteractionResponse(ctx, c.interaction.AppID, c.interaction.ID, c.interaction.Token, discordgo.InteractionResponse{Data: &discordgo.InteractionResponseData{Content: c.Localize("common_error_discord_outage")}, Type: discordgo.InteractionResponseChannelMessageWithSource}, nil)
 		}
 		return err
 	}
diff --git a/cmd/discord/common/reply.go b/cmd/discord/common/reply.go
index 4e608a65..89662a07 100644
--- a/cmd/discord/common/reply.go
+++ b/cmd/discord/common/reply.go
@@ -2,17 +2,17 @@ package common
 
 import (
 	"fmt"
-	"io"
 	"strings"
 
 	"github.com/bwmarrin/discordgo"
+	"github.com/cufee/aftermath/cmd/discord/rest"
 )
 
 type reply struct {
 	ctx *Context
 
 	text       []string
-	files      []*discordgo.File
+	files      []rest.File
 	components []discordgo.MessageComponent
 	embeds     []*discordgo.MessageEmbed
 }
@@ -27,11 +27,11 @@ func (r reply) Format(format string, args ...any) reply {
 	return r
 }
 
-func (r reply) File(reader io.Reader, name string) reply {
-	if reader == nil {
+func (r reply) File(data []byte, name string) reply {
+	if data == nil {
 		return r
 	}
-	r.files = append(r.files, &discordgo.File{Reader: reader, Name: name})
+	r.files = append(r.files, rest.File{Data: data, Name: name})
 	return r
 }
 
@@ -60,15 +60,15 @@ func (r reply) Send(content ...string) error {
 	return r.ctx.respond(r.data())
 }
 
-func (r reply) data() discordgo.InteractionResponseData {
+func (r reply) data() (discordgo.InteractionResponseData, []rest.File) {
 	var content []string
 	for _, t := range r.text {
 		content = append(content, r.ctx.Localize(t))
 	}
+
 	return discordgo.InteractionResponseData{
 		Content:    strings.Join(content, "\n"),
 		Components: r.components,
 		Embeds:     r.embeds,
-		Files:      r.files,
-	}
+	}, r.files
 }
diff --git a/cmd/discord/rest/interactions.go b/cmd/discord/rest/interactions.go
index 1c47d71e..382a76b8 100644
--- a/cmd/discord/rest/interactions.go
+++ b/cmd/discord/rest/interactions.go
@@ -1,51 +1,72 @@
 package rest
 
 import (
+	"bytes"
 	"context"
+	"errors"
 	"net/http"
 
 	"github.com/bwmarrin/discordgo"
 )
 
-func (c *Client) SendInteractionResponse(ctx context.Context, id, token string, data discordgo.InteractionResponse) error {
-	var files []*discordgo.File
-	if data.Data != nil {
-		files = data.Data.Files
+type File struct {
+	Data []byte
+	Name string
+}
+
+/*
+Optimistically send an interaction response update request with fallback to interaction response send request
+*/
+func (c *Client) UpdateOrSendInteractionResponse(ctx context.Context, appID, interactionID, token string, data discordgo.InteractionResponse, files []File) error {
+	err := c.UpdateInteractionResponse(ctx, appID, token, *data.Data, files)
+	if err != nil {
+		if errors.Is(err, ErrUnknownWebhook) {
+			return c.SendInteractionResponse(ctx, interactionID, token, data, files)
+		}
+		return err
 	}
-	req, err := c.interactionRequest("POST", discordgo.EndpointInteractionResponse(id, token), data, files)
+	return nil
+}
+
+func (c *Client) SendInteractionResponse(ctx context.Context, interactionID, token string, data discordgo.InteractionResponse, files []File) error {
+	req, err := c.interactionRequest("POST", discordgo.EndpointInteractionResponse(interactionID, token), data, files)
 	if err != nil {
 		return err
 	}
 	return c.do(ctx, req, nil)
 }
 
-func (c *Client) UpdateInteractionResponse(ctx context.Context, id, token string, data discordgo.InteractionResponseData) error {
-	req, err := c.interactionRequest("PATCH", discordgo.EndpointInteractionResponseActions(id, token), data, data.Files)
+func (c *Client) UpdateInteractionResponse(ctx context.Context, appID, token string, data discordgo.InteractionResponseData, files []File) error {
+	req, err := c.interactionRequest("PATCH", discordgo.EndpointInteractionResponseActions(appID, token), data, files)
 	if err != nil {
 		return err
 	}
 	return c.do(ctx, req, nil)
 }
 
-func (c *Client) SendInteractionFollowup(ctx context.Context, id, token string, data discordgo.InteractionResponse) error {
-	req, err := c.interactionRequest("POST", discordgo.EndpointFollowupMessage(id, token), data, data.Data.Files)
+func (c *Client) SendInteractionFollowup(ctx context.Context, appID, token string, data discordgo.InteractionResponse, files []File) error {
+	req, err := c.interactionRequest("POST", discordgo.EndpointFollowupMessage(appID, token), data, files)
 	if err != nil {
 		return err
 	}
 	return c.do(ctx, req, nil)
 }
 
-func (c *Client) EditInteractionFollowup(ctx context.Context, id, token string, data discordgo.InteractionResponseData) error {
-	req, err := c.interactionRequest("PATCH", discordgo.EndpointFollowupMessage(id, token), data, data.Files)
+func (c *Client) EditInteractionFollowup(ctx context.Context, appID, token string, data discordgo.InteractionResponseData, files []File) error {
+	req, err := c.interactionRequest("PATCH", discordgo.EndpointFollowupMessage(appID, token), data, files)
 	if err != nil {
 		return err
 	}
 	return c.do(ctx, req, nil)
 }
 
-func (c *Client) interactionRequest(method string, url string, payload any, files []*discordgo.File) (*http.Request, error) {
+func (c *Client) interactionRequest(method string, url string, payload any, files []File) (*http.Request, error) {
 	if len(files) > 0 {
-		return c.requestWithFiles(method, url, payload, files)
+		var df []*discordgo.File
+		for _, f := range files {
+			df = append(df, &discordgo.File{Name: f.Name, Reader: bytes.NewReader(f.Data)})
+		}
+		return c.requestWithFiles(method, url, payload, df)
 	}
 	return c.request(method, url, payload)
 }
diff --git a/cmd/discord/router/handler.go b/cmd/discord/router/handler.go
index 71f35a6d..5b41fc03 100644
--- a/cmd/discord/router/handler.go
+++ b/cmd/discord/router/handler.go
@@ -119,7 +119,7 @@ func (router *Router) HTTPHandler() (http.HandlerFunc, error) {
 			func() (struct{}, error) {
 				ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*500)
 				defer cancel()
-				err := router.restClient.SendInteractionResponse(ctx, data.ID, data.Token, payload)
+				err := router.restClient.SendInteractionResponse(ctx, data.ID, data.Token, payload, nil)
 				return struct{}{}, err
 			},
 			3,
@@ -226,12 +226,12 @@ func (r *Router) sendInteractionReply(ctx context.Context, interaction discordgo
 	switch interaction.Type {
 	case discordgo.InteractionApplicationCommand, discordgo.InteractionMessageComponent:
 		handler = func() error {
-			return r.restClient.UpdateInteractionResponse(ctx, interaction.AppID, interaction.Token, data)
+			return r.restClient.UpdateOrSendInteractionResponse(ctx, interaction.AppID, interaction.ID, interaction.Token, discordgo.InteractionResponse{Data: &data, Type: discordgo.InteractionResponseChannelMessageWithSource}, nil)
 		}
 	default:
 		log.Error().Stack().Any("data", data).Str("id", interaction.ID).Msg("unknown interaction type received")
 		handler = func() error {
-			return r.restClient.UpdateInteractionResponse(ctx, interaction.AppID, interaction.Token, discordgo.InteractionResponseData{Content: "Something unexpected happened and your command failed."})
+			return r.restClient.UpdateOrSendInteractionResponse(ctx, interaction.AppID, interaction.ID, interaction.Token, discordgo.InteractionResponse{Data: &discordgo.InteractionResponseData{Content: "Something unexpected happened and your command failed."}, Type: discordgo.InteractionResponseChannelMessageWithSource}, nil)
 		}
 	}
 

From bbded92cf6696757fb41474a2d742cc517cd92b7 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 30 Jun 2024 21:25:02 -0400
Subject: [PATCH 233/341] added accounts commands

---
 cmd/discord/commands/accounts.go       | 176 +++++++++++++++++++++++++
 cmd/discord/commands/builder/option.go |   8 ++
 cmd/discord/commands/link.go           |   1 +
 cmd/discord/common/context.go          |  26 +++-
 cmd/discord/common/reply.go            |  27 +++-
 cmd/discord/rest/interactions.go       |   2 +-
 cmd/discord/router/handler.go          |  30 +++--
 cmd/discord/router/router.go           |   3 +
 static/localization/en/discord.yaml    |  25 ++++
 9 files changed, 279 insertions(+), 19 deletions(-)
 create mode 100644 cmd/discord/commands/accounts.go

diff --git a/cmd/discord/commands/accounts.go b/cmd/discord/commands/accounts.go
new file mode 100644
index 00000000..62e81a95
--- /dev/null
+++ b/cmd/discord/commands/accounts.go
@@ -0,0 +1,176 @@
+package commands
+
+import (
+	"fmt"
+	"strings"
+	"unicode/utf8"
+
+	"github.com/bwmarrin/discordgo"
+	"github.com/cufee/aftermath/cmd/discord/commands/builder"
+	"github.com/cufee/aftermath/cmd/discord/common"
+	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/lucsky/cuid"
+	"github.com/rs/zerolog/log"
+)
+
+func init() {
+	LoadedPublic.add(
+		builder.NewCommand("accounts").
+			Ephemeral().
+			Options(
+				builder.NewOption("default", discordgo.ApplicationCommandOptionSubCommand).
+					Params(builder.SetNameKey("command_option_accounts_default_name"), builder.SetDescKey("command_option_accounts_default_description")).
+					Options(
+						builder.NewOption("selected", discordgo.ApplicationCommandOptionString).
+							Autocomplete().
+							Required(),
+					),
+				builder.NewOption("linked", discordgo.ApplicationCommandOptionSubCommand).
+					Params(builder.SetNameKey("command_option_accounts_linked_name"), builder.SetDescKey("command_option_accounts_linked_description")),
+			).
+			Handler(func(ctx *common.Context) error {
+				// handle subcommand
+				subcommand, subOptions, _ := ctx.Options().Subcommand()
+				switch subcommand {
+				default:
+					return ctx.Error("received an unexpected subcommand: " + subcommand)
+
+				case "default":
+					value, _ := subOptions.Value("selected").(string)
+					parts := strings.Split(value, "#")
+					if len(parts) != 4 || parts[0] != "valid" {
+						return ctx.Reply().Send("accounts_error_connection_not_found")
+					}
+					connectionID := parts[1]
+					nickname := parts[2]
+					realm := parts[3]
+
+					if err := cuid.IsCuid(connectionID); err != nil {
+						return ctx.Reply().Send("accounts_error_connection_not_found")
+					}
+
+					for _, conn := range ctx.User.Connections {
+						if conn.ID != connectionID {
+							continue
+						}
+						conn.Metadata["default"] = true
+						_, err := ctx.Core.Database().UpdateConnection(ctx.Context, conn)
+						if err != nil {
+							if database.IsNotFound(err) {
+								return ctx.Reply().Send("accounts_error_connection_not_found")
+							}
+							return ctx.Err(err)
+						}
+
+						var content = []string{fmt.Sprintf(ctx.Localize("command_accounts_set_default_successfully_fmt"), nickname, realm)}
+						if verified, _ := conn.Metadata["verified"].(bool); !verified {
+							content = append(content, ctx.Localize("command_accounts_verify_cta"))
+						}
+						return ctx.Reply().Text(content...).Send()
+					}
+					return ctx.Reply().Send("accounts_error_connection_not_found")
+
+				case "linked":
+					var currentDefault string
+					var linkedAccounts []string
+					for _, conn := range ctx.User.Connections {
+						if conn.Type != models.ConnectionTypeWargaming {
+							continue
+						}
+						linkedAccounts = append(linkedAccounts, conn.ReferenceID)
+						if def, _ := conn.Metadata["default"].(bool); def {
+							currentDefault = conn.ReferenceID
+						}
+					}
+					accounts, err := ctx.Core.Database().GetAccounts(ctx.Context, linkedAccounts)
+					if err != nil && !database.IsNotFound(err) {
+						return ctx.Err(err)
+					}
+					if len(accounts) == 0 {
+						return ctx.Reply().Send("stats_error_connection_not_found_personal")
+					}
+
+					var longestName int
+					for _, a := range accounts {
+						if l := utf8.RuneCountInString(a.Nickname); l > longestName {
+							longestName = l
+						}
+					}
+
+					var nicknames []string
+					for _, a := range accounts {
+						nicknames = append(nicknames, accountToRow(a, longestName, currentDefault == a.ID || len(linkedAccounts) == 1))
+					}
+					return ctx.Reply().Send(strings.Join(nicknames, "\n"))
+				}
+			}),
+	)
+
+	LoadedPublic.add(
+		builder.NewCommand("autocomplete_accounts").
+			ComponentType(func(s string) bool {
+				return s == "autocomplete_accounts"
+			}).
+			Handler(func(ctx *common.Context) error {
+				command, _, ok := ctx.Options().Subcommand()
+				if !ok {
+					log.Error().Str("command", "autocomplete_accounts").Msg("interaction is not a subcommand")
+					return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: ctx.Localize("stats_error_connection_not_found_personal"), Value: "error#stats_error_connection_not_found_personal"})
+				}
+				if command != "default" {
+					log.Error().Str("command", command).Msg("invalid subcommand received in autocomplete_accounts")
+					return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: ctx.Localize("stats_error_connection_not_found_personal"), Value: "error#stats_error_connection_not_found_personal"})
+				}
+
+				var currentDefault string
+				var linkedAccounts []string
+				var accountToConnection = make(map[string]string)
+				for _, conn := range ctx.User.Connections {
+					if conn.Type != models.ConnectionTypeWargaming {
+						continue
+					}
+					linkedAccounts = append(linkedAccounts, conn.ReferenceID)
+					accountToConnection[conn.ReferenceID] = conn.ID
+					if def, _ := conn.Metadata["default"].(bool); def {
+						currentDefault = conn.ReferenceID
+					}
+
+				}
+				if len(linkedAccounts) < 1 {
+					return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: ctx.Localize("stats_error_connection_not_found_personal"), Value: "error#stats_error_connection_not_found_personal"})
+				}
+
+				accounts, err := ctx.Core.Database().GetAccounts(ctx.Context, linkedAccounts)
+				if err != nil {
+					return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: ctx.Localize("stats_error_connection_not_found_personal"), Value: "error#stats_error_connection_not_found_personal"})
+				}
+
+				var longestName int
+				for _, a := range accounts {
+					if l := utf8.RuneCountInString(a.Nickname); l > longestName {
+						longestName = l
+					}
+				}
+
+				var opts []*discordgo.ApplicationCommandOptionChoice
+				for _, a := range accounts {
+					opts = append(opts, &discordgo.ApplicationCommandOptionChoice{Name: accountToRow(a, longestName, currentDefault == a.ID || len(linkedAccounts) == 1), Value: fmt.Sprintf("valid#%s#%s#%s", accountToConnection[a.ID], a.Nickname, a.Realm)})
+				}
+				return ctx.Reply().Choices(opts...)
+			}),
+	)
+}
+
+func accountToRow(account models.Account, padding int, isDefault bool) string {
+	var row string
+	row += account.Nickname + strings.Repeat(" ", padding-utf8.RuneCountInString(account.Nickname))
+	row += " [" + account.Realm + "]"
+	if isDefault {
+		row += " ✅"
+	}
+	if account.Private {
+		row += " 🔒"
+	}
+	return row
+}
diff --git a/cmd/discord/commands/builder/option.go b/cmd/discord/commands/builder/option.go
index 17f7b142..1b72c088 100644
--- a/cmd/discord/commands/builder/option.go
+++ b/cmd/discord/commands/builder/option.go
@@ -27,6 +27,8 @@ type Option struct {
 	choices []OptionChoice
 
 	options []Option
+
+	autocomplete bool
 }
 
 func NewOption(name string, kind discordgo.ApplicationCommandOptionType) Option {
@@ -81,6 +83,11 @@ func (o Option) Choices(choices ...OptionChoice) Option {
 	return o
 }
 
+func (o Option) Autocomplete() Option {
+	o.autocomplete = true
+	return o
+}
+
 func (o Option) Build(command string) discordgo.ApplicationCommandOption {
 	if o.kind == 0 {
 		panic("option type is not set")
@@ -104,6 +111,7 @@ func (o Option) Build(command string) discordgo.ApplicationCommandOption {
 	return discordgo.ApplicationCommandOption{
 		Name:                     strings.ToLower(stringOr(nameLocalized[discordgo.EnglishUS], o.name)),
 		Description:              stringOr(descLocalized[discordgo.EnglishUS], o.name),
+		Autocomplete:             o.autocomplete,
 		NameLocalizations:        nameLocalized,
 		DescriptionLocalizations: descLocalized,
 		MinLength:                o.minLength,
diff --git a/cmd/discord/commands/link.go b/cmd/discord/commands/link.go
index 87705e5a..6ce21e3c 100644
--- a/cmd/discord/commands/link.go
+++ b/cmd/discord/commands/link.go
@@ -56,6 +56,7 @@ func init() {
 					currentConnection.Type = models.ConnectionTypeWargaming
 				}
 
+				currentConnection.Metadata["default"] = true
 				currentConnection.Metadata["verified"] = false
 				currentConnection.ReferenceID = fmt.Sprint(account.ID)
 
diff --git a/cmd/discord/common/context.go b/cmd/discord/common/context.go
index 2edd93d3..2868c437 100644
--- a/cmd/discord/common/context.go
+++ b/cmd/discord/common/context.go
@@ -76,14 +76,14 @@ func NewContext(ctx context.Context, interaction discordgo.Interaction, rest *re
 	return c, nil
 }
 
-func (c *Context) respond(data discordgo.InteractionResponseData, files []rest.File) error {
+func (c *Context) respond(data discordgo.InteractionResponse, files []rest.File) error {
 	select {
 	case <-c.Context.Done():
 		return c.Context.Err()
 	default:
 		ctx, cancel := context.WithTimeout(c.Context, time.Millisecond*3000)
 		defer cancel()
-		err := c.rest.UpdateOrSendInteractionResponse(ctx, c.interaction.AppID, c.interaction.ID, c.interaction.Token, discordgo.InteractionResponse{Type: discordgo.InteractionResponseChannelMessageWithSource, Data: &data}, files)
+		err := c.rest.UpdateOrSendInteractionResponse(ctx, c.interaction.AppID, c.interaction.ID, c.interaction.Token, data, files)
 		if os.IsTimeout(err) {
 			// request timed out, most likely a discord issue
 			log.Error().Str("id", c.ID()).Str("interactionId", c.interaction.ID).Msg("discord api: request timed out while responding to an interaction")
@@ -105,12 +105,12 @@ func (c *Context) Reply() reply {
 
 func (c *Context) Err(err error) error {
 	log.Err(err).Str("interactionId", c.interaction.ID).Msg("error while handling an interaction")
-	return c.Reply().Send("common_error_unhandled_not_reported")
+	return c.Reply().Send("common_error_unhandled_reported")
 }
 
 func (c *Context) Error(message string) error {
 	log.Error().Str("message", message).Str("interactionId", c.interaction.ID).Msg("error while handling an interaction")
-	return c.Reply().Send("common_error_unhandled_not_reported")
+	return c.Reply().Send("common_error_unhandled_reported")
 }
 
 func (c *Context) isCommand() bool {
@@ -121,6 +121,14 @@ func (c *Context) isComponentInteraction() bool {
 	return c.interaction.Type == discordgo.InteractionMessageComponent
 }
 
+func (c *Context) isAutocompleteInteraction() bool {
+	return c.interaction.Type == discordgo.InteractionApplicationCommandAutocomplete
+}
+
+func (c *Context) isModalSubmit() bool {
+	return c.interaction.Type == discordgo.InteractionModalSubmit
+}
+
 func (c *Context) ID() string {
 	if c.isCommand() {
 		d, _ := c.CommandData()
@@ -134,7 +142,7 @@ func (c *Context) ID() string {
 }
 
 func (c *Context) Options() options {
-	if data, ok := c.CommandData(); ok {
+	if data, ok := c.interaction.Data.(discordgo.ApplicationCommandInteractionData); ok {
 		return data.Options
 	}
 	return options{}
@@ -193,3 +201,11 @@ func (c *Context) ComponentData() (discordgo.MessageComponentInteractionData, bo
 	data, ok := c.interaction.Data.(discordgo.MessageComponentInteractionData)
 	return data, ok
 }
+
+func (c *Context) AutocompleteData() (discordgo.ApplicationCommandInteractionData, bool) {
+	if !c.isAutocompleteInteraction() {
+		return discordgo.ApplicationCommandInteractionData{}, false
+	}
+	data, ok := c.interaction.Data.(discordgo.ApplicationCommandInteractionData)
+	return data, ok
+}
diff --git a/cmd/discord/common/reply.go b/cmd/discord/common/reply.go
index 89662a07..d107ceff 100644
--- a/cmd/discord/common/reply.go
+++ b/cmd/discord/common/reply.go
@@ -1,11 +1,14 @@
 package common
 
 import (
+	"context"
 	"fmt"
 	"strings"
+	"time"
 
 	"github.com/bwmarrin/discordgo"
 	"github.com/cufee/aftermath/cmd/discord/rest"
+	"github.com/rs/zerolog/log"
 )
 
 type reply struct {
@@ -17,6 +20,17 @@ type reply struct {
 	embeds     []*discordgo.MessageEmbed
 }
 
+func (r reply) Choices(data ...*discordgo.ApplicationCommandOptionChoice) error {
+	ctx, cancel := context.WithTimeout(r.ctx.Context, time.Millisecond*3000)
+	defer cancel()
+	err := r.ctx.rest.UpdateOrSendInteractionResponse(ctx, r.ctx.interaction.AppID, r.ctx.interaction.ID, r.ctx.interaction.Token, discordgo.InteractionResponse{Type: discordgo.InteractionApplicationCommandAutocompleteResult, Data: &discordgo.InteractionResponseData{Choices: data}}, nil)
+	if err != nil {
+		log.Err(err).Str("interactionId", r.ctx.interaction.ID).Msg("failed to send an autocomplete response")
+	}
+	return nil
+
+}
+
 func (r reply) Text(message ...string) reply {
 	r.text = append(r.text, message...)
 	return r
@@ -60,15 +74,18 @@ func (r reply) Send(content ...string) error {
 	return r.ctx.respond(r.data())
 }
 
-func (r reply) data() (discordgo.InteractionResponseData, []rest.File) {
+func (r reply) data() (discordgo.InteractionResponse, []rest.File) {
 	var content []string
 	for _, t := range r.text {
 		content = append(content, r.ctx.Localize(t))
 	}
 
-	return discordgo.InteractionResponseData{
-		Content:    strings.Join(content, "\n"),
-		Components: r.components,
-		Embeds:     r.embeds,
+	return discordgo.InteractionResponse{
+		Type: discordgo.InteractionResponseChannelMessageWithSource,
+		Data: &discordgo.InteractionResponseData{
+			Content:    strings.Join(content, "\n"),
+			Components: r.components,
+			Embeds:     r.embeds,
+		},
 	}, r.files
 }
diff --git a/cmd/discord/rest/interactions.go b/cmd/discord/rest/interactions.go
index 382a76b8..bd280f67 100644
--- a/cmd/discord/rest/interactions.go
+++ b/cmd/discord/rest/interactions.go
@@ -20,7 +20,7 @@ Optimistically send an interaction response update request with fallback to inte
 func (c *Client) UpdateOrSendInteractionResponse(ctx context.Context, appID, interactionID, token string, data discordgo.InteractionResponse, files []File) error {
 	err := c.UpdateInteractionResponse(ctx, appID, token, *data.Data, files)
 	if err != nil {
-		if errors.Is(err, ErrUnknownWebhook) {
+		if errors.Is(err, ErrUnknownWebhook) || errors.Is(err, ErrUnknownInteraction) {
 			return c.SendInteractionResponse(ctx, interactionID, token, data, files)
 		}
 		return err
diff --git a/cmd/discord/router/handler.go b/cmd/discord/router/handler.go
index 5b41fc03..226dfbfb 100644
--- a/cmd/discord/router/handler.go
+++ b/cmd/discord/router/handler.go
@@ -10,6 +10,7 @@ import (
 	"io"
 	"net/http"
 	"runtime/debug"
+	"slices"
 	"time"
 
 	"github.com/pkg/errors"
@@ -22,6 +23,8 @@ import (
 	"github.com/rs/zerolog/log"
 )
 
+var supportedInteractionTypes = []discordgo.InteractionType{discordgo.InteractionApplicationCommand, discordgo.InteractionMessageComponent, discordgo.InteractionApplicationCommandAutocomplete, discordgo.InteractionModalSubmit}
+
 // https://github.com/bsdlp/discord-interactions-go/blob/main/interactions/verify.go
 func verifyPublicKey(r *http.Request, key ed25519.PublicKey) bool {
 	var msg bytes.Buffer
@@ -108,12 +111,16 @@ func (router *Router) HTTPHandler() (http.HandlerFunc, error) {
 		}
 
 		// ack the interaction proactively
-		payload, err := deferredInteractionResponsePayload(data.Type, cmd.Ephemeral)
+		payload, needsAck, err := deferredInteractionResponsePayload(data.Type, cmd.Ephemeral)
 		if err != nil {
 			http.Error(w, err.Error(), http.StatusInternalServerError)
 			log.Err(err).Str("id", data.ID).Msg("failed to make an ack response payload")
 			return
 		}
+		if !needsAck {
+			router.handleInteraction(data, cmd) // we wait for the handler to reply
+			return
+		}
 
 		res := retry.Retry(
 			func() (struct{}, error) {
@@ -160,6 +167,9 @@ func (r *Router) routeInteraction(interaction discordgo.Interaction) (builder.Co
 	case discordgo.InteractionMessageComponent:
 		data, _ := interaction.Data.(discordgo.MessageComponentInteractionData)
 		matchKey = data.CustomID
+	case discordgo.InteractionApplicationCommandAutocomplete:
+		data, _ := interaction.Data.(discordgo.ApplicationCommandInteractionData)
+		matchKey = "autocomplete_" + data.Name
 	}
 
 	if matchKey == "" {
@@ -223,12 +233,11 @@ func sendPingReply(w http.ResponseWriter) {
 func (r *Router) sendInteractionReply(ctx context.Context, interaction discordgo.Interaction, data discordgo.InteractionResponseData) {
 	var handler func() error
 
-	switch interaction.Type {
-	case discordgo.InteractionApplicationCommand, discordgo.InteractionMessageComponent:
+	if slices.Contains(supportedInteractionTypes, interaction.Type) {
 		handler = func() error {
 			return r.restClient.UpdateOrSendInteractionResponse(ctx, interaction.AppID, interaction.ID, interaction.Token, discordgo.InteractionResponse{Data: &data, Type: discordgo.InteractionResponseChannelMessageWithSource}, nil)
 		}
-	default:
+	} else {
 		log.Error().Stack().Any("data", data).Str("id", interaction.ID).Msg("unknown interaction type received")
 		handler = func() error {
 			return r.restClient.UpdateOrSendInteractionResponse(ctx, interaction.AppID, interaction.ID, interaction.Token, discordgo.InteractionResponse{Data: &discordgo.InteractionResponseData{Content: "Something unexpected happened and your command failed."}, Type: discordgo.InteractionResponseChannelMessageWithSource}, nil)
@@ -242,19 +251,24 @@ func (r *Router) sendInteractionReply(ctx context.Context, interaction discordgo
 	}
 }
 
-func deferredInteractionResponsePayload(t discordgo.InteractionType, ephemeral bool) (discordgo.InteractionResponse, error) {
+func deferredInteractionResponsePayload(t discordgo.InteractionType, ephemeral bool) (discordgo.InteractionResponse, bool, error) {
 	var response discordgo.InteractionResponse
 	if ephemeral {
+		if response.Data == nil {
+			response.Data = &discordgo.InteractionResponseData{}
+		}
 		response.Data.Flags = discordgo.MessageFlagsEphemeral
 	}
 
 	switch t {
-	case discordgo.InteractionApplicationCommand, discordgo.InteractionMessageComponent:
+	case discordgo.InteractionApplicationCommand, discordgo.InteractionMessageComponent, discordgo.InteractionModalSubmit:
 		response.Type = discordgo.InteractionResponseDeferredChannelMessageWithSource
+	case discordgo.InteractionApplicationCommandAutocomplete:
+		return response, false, nil
 
 	default:
-		return response, fmt.Errorf("interaction type %s not supported", t.String())
+		return response, false, fmt.Errorf("interaction type %s not supported", t.String())
 	}
 
-	return response, nil
+	return response, true, nil
 }
diff --git a/cmd/discord/router/router.go b/cmd/discord/router/router.go
index bb829bb0..71f8dcfd 100644
--- a/cmd/discord/router/router.go
+++ b/cmd/discord/router/router.go
@@ -67,6 +67,9 @@ Updates all loaded commands using the Discord REST API
 func (r *Router) UpdateLoadedCommands(ctx context.Context) error {
 	var commandByName = make(map[string]command)
 	for _, cmd := range r.commands {
+		if cmd.Type != builder.CommandTypeChat {
+			continue
+		}
 		commandByName[cmd.Name] = command{requested: &cmd}
 	}
 
diff --git a/static/localization/en/discord.yaml b/static/localization/en/discord.yaml
index 0de71987..ae295ab9 100755
--- a/static/localization/en/discord.yaml
+++ b/static/localization/en/discord.yaml
@@ -20,6 +20,25 @@
   value: Link your Blitz account to Aftermath
 - key: command_link_linked_successfully_fmt
   value: "Your account has been linked! Aftermath will now default to **%s** on **%s** when checking stats.\nYou can also verify your account with `/verify`"
+# /accounts
+- key: command_accounts_name
+  value: accounts
+- key: command_accounts_description
+  value: View and manage your linked accounts
+- key: command_option_accounts_default_name
+  value: default
+- key: command_option_accounts_default_description
+  value: Set the default account Aftermath will check when using commands
+- key: command_option_accounts_linked_name
+  value: linked
+- key: command_option_accounts_linked_description
+  value: View your linked Blitz accounts
+
+- key: command_accounts_set_default_successfully_fmt
+  value: "Your default account has been updated! Aftermath will now default to **%s** on **%s** when checking stats."
+- key: command_accounts_verify_cta
+  value: "You can also verify your account with `/verify`"
+  context: A new default account was set, but it is not verified
 
 # Common command options
 # days
@@ -178,6 +197,12 @@
   value: "Please select a server your account is registered on."
   context: Server not selected
 
+  # /accounts errors
+- key: accounts_error_connection_not_found
+  value: "I was not able to find your linked account with this nickname. Try adding it through `/link` instead."
+  context: Nickname is invalid or failed to find a valid connection
+
+
   # Wargaming specific errors
 - key: wargaming_error_private_account
   value: "This account is marked private by Wargaming and no stats are available for it at this time."

From 6afdadc69ddb1eb54edc28ad6f7abd63e4ebd51f Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 30 Jun 2024 22:26:11 -0400
Subject: [PATCH 234/341] multiple accounts linking support

---
 cmd/discord/commands/accounts.go    | 83 +++++++++++++++++++----------
 cmd/discord/commands/link.go        | 57 +++++++++++++++-----
 cmd/discord/commands/session.go     |  4 +-
 cmd/discord/commands/stats.go       |  4 +-
 internal/database/client.go         |  1 +
 internal/database/models/user.go    |  8 ++-
 internal/database/users.go          |  4 ++
 static/localization/en/discord.yaml | 12 +++++
 8 files changed, 128 insertions(+), 45 deletions(-)

diff --git a/cmd/discord/commands/accounts.go b/cmd/discord/commands/accounts.go
index 62e81a95..b2157651 100644
--- a/cmd/discord/commands/accounts.go
+++ b/cmd/discord/commands/accounts.go
@@ -10,7 +10,6 @@ import (
 	"github.com/cufee/aftermath/cmd/discord/common"
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
-	"github.com/lucsky/cuid"
 	"github.com/rs/zerolog/log"
 )
 
@@ -26,6 +25,13 @@ func init() {
 							Autocomplete().
 							Required(),
 					),
+				builder.NewOption("unlink", discordgo.ApplicationCommandOptionSubCommand).
+					Params(builder.SetNameKey("command_option_accounts_unlink_name"), builder.SetDescKey("command_option_accounts_unlink_description")).
+					Options(
+						builder.NewOption("selected", discordgo.ApplicationCommandOptionString).
+							Autocomplete().
+							Required(),
+					),
 				builder.NewOption("linked", discordgo.ApplicationCommandOptionSubCommand).
 					Params(builder.SetNameKey("command_option_accounts_linked_name"), builder.SetDescKey("command_option_accounts_linked_description")),
 			).
@@ -42,19 +48,22 @@ func init() {
 					if len(parts) != 4 || parts[0] != "valid" {
 						return ctx.Reply().Send("accounts_error_connection_not_found")
 					}
-					connectionID := parts[1]
+					accountID := parts[1]
 					nickname := parts[2]
 					realm := parts[3]
 
-					if err := cuid.IsCuid(connectionID); err != nil {
-						return ctx.Reply().Send("accounts_error_connection_not_found")
-					}
-
+					var found bool
+					var newConnectionVerified bool
 					for _, conn := range ctx.User.Connections {
-						if conn.ID != connectionID {
+						if conn.Type != models.ConnectionTypeWargaming {
 							continue
 						}
-						conn.Metadata["default"] = true
+						if conn.ReferenceID == accountID {
+							newConnectionVerified, _ = conn.Metadata["verified"].(bool)
+							found = true
+						}
+						conn.Metadata["default"] = conn.ReferenceID == accountID
+
 						_, err := ctx.Core.Database().UpdateConnection(ctx.Context, conn)
 						if err != nil {
 							if database.IsNotFound(err) {
@@ -62,14 +71,38 @@ func init() {
 							}
 							return ctx.Err(err)
 						}
+					}
+					if !found {
+						return ctx.Reply().Send("accounts_error_connection_not_found")
+					}
 
-						var content = []string{fmt.Sprintf(ctx.Localize("command_accounts_set_default_successfully_fmt"), nickname, realm)}
-						if verified, _ := conn.Metadata["verified"].(bool); !verified {
-							content = append(content, ctx.Localize("command_accounts_verify_cta"))
+					var content = []string{fmt.Sprintf(ctx.Localize("command_accounts_set_default_successfully_fmt"), nickname, realm)}
+					if !newConnectionVerified {
+						content = append(content, ctx.Localize("command_accounts_verify_cta"))
+					}
+					return ctx.Reply().Text(content...).Send()
+
+				case "unlink":
+					value, _ := subOptions.Value("selected").(string)
+					parts := strings.Split(value, "#")
+					if len(parts) != 4 || parts[0] != "valid" {
+						return ctx.Reply().Send("accounts_error_connection_not_found_selected")
+					}
+					accountID := parts[1]
+
+					for _, conn := range ctx.User.Connections {
+						if conn.Type != models.ConnectionTypeWargaming {
+							continue
+						}
+						if conn.ReferenceID == accountID {
+							err := ctx.Core.Database().DeleteConnection(ctx.Context, conn.ID)
+							if err != nil {
+								return ctx.Err(err)
+							}
+							return ctx.Reply().Send("command_accounts_unlinked_successfully")
 						}
-						return ctx.Reply().Text(content...).Send()
 					}
-					return ctx.Reply().Send("accounts_error_connection_not_found")
+					return ctx.Reply().Send("accounts_error_connection_not_found_selected")
 
 				case "linked":
 					var currentDefault string
@@ -83,6 +116,7 @@ func init() {
 							currentDefault = conn.ReferenceID
 						}
 					}
+
 					accounts, err := ctx.Core.Database().GetAccounts(ctx.Context, linkedAccounts)
 					if err != nil && !database.IsNotFound(err) {
 						return ctx.Err(err)
@@ -100,7 +134,7 @@ func init() {
 
 					var nicknames []string
 					for _, a := range accounts {
-						nicknames = append(nicknames, accountToRow(a, longestName, currentDefault == a.ID || len(linkedAccounts) == 1))
+						nicknames = append(nicknames, accountToRow(a, longestName, currentDefault == a.ID))
 					}
 					return ctx.Reply().Send(strings.Join(nicknames, "\n"))
 				}
@@ -116,34 +150,32 @@ func init() {
 				command, _, ok := ctx.Options().Subcommand()
 				if !ok {
 					log.Error().Str("command", "autocomplete_accounts").Msg("interaction is not a subcommand")
-					return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: ctx.Localize("stats_error_connection_not_found_personal"), Value: "error#stats_error_connection_not_found_personal"})
+					return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: ctx.Localize("accounts_error_connection_not_found"), Value: "error#accounts_error_connection_not_found"})
 				}
-				if command != "default" {
+				if command != "default" && command != "unlink" {
 					log.Error().Str("command", command).Msg("invalid subcommand received in autocomplete_accounts")
-					return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: ctx.Localize("stats_error_connection_not_found_personal"), Value: "error#stats_error_connection_not_found_personal"})
+					return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: ctx.Localize("accounts_error_connection_not_found"), Value: "error#accounts_error_connection_not_found"})
 				}
 
 				var currentDefault string
 				var linkedAccounts []string
-				var accountToConnection = make(map[string]string)
 				for _, conn := range ctx.User.Connections {
 					if conn.Type != models.ConnectionTypeWargaming {
 						continue
 					}
 					linkedAccounts = append(linkedAccounts, conn.ReferenceID)
-					accountToConnection[conn.ReferenceID] = conn.ID
 					if def, _ := conn.Metadata["default"].(bool); def {
 						currentDefault = conn.ReferenceID
 					}
 
 				}
 				if len(linkedAccounts) < 1 {
-					return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: ctx.Localize("stats_error_connection_not_found_personal"), Value: "error#stats_error_connection_not_found_personal"})
+					return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: ctx.Localize("accounts_error_connection_not_found"), Value: "error#accounts_error_connection_not_found"})
 				}
 
 				accounts, err := ctx.Core.Database().GetAccounts(ctx.Context, linkedAccounts)
 				if err != nil {
-					return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: ctx.Localize("stats_error_connection_not_found_personal"), Value: "error#stats_error_connection_not_found_personal"})
+					return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: ctx.Localize("accounts_error_connection_not_found"), Value: "error#accounts_error_connection_not_found"})
 				}
 
 				var longestName int
@@ -155,7 +187,7 @@ func init() {
 
 				var opts []*discordgo.ApplicationCommandOptionChoice
 				for _, a := range accounts {
-					opts = append(opts, &discordgo.ApplicationCommandOptionChoice{Name: accountToRow(a, longestName, currentDefault == a.ID || len(linkedAccounts) == 1), Value: fmt.Sprintf("valid#%s#%s#%s", accountToConnection[a.ID], a.Nickname, a.Realm)})
+					opts = append(opts, &discordgo.ApplicationCommandOptionChoice{Name: accountToRow(a, longestName, currentDefault == a.ID), Value: fmt.Sprintf("valid#%s#%s#%s", a.ID, a.Nickname, a.Realm)})
 				}
 				return ctx.Reply().Choices(opts...)
 			}),
@@ -164,13 +196,10 @@ func init() {
 
 func accountToRow(account models.Account, padding int, isDefault bool) string {
 	var row string
+	row += "[" + account.Realm + "] "
 	row += account.Nickname + strings.Repeat(" ", padding-utf8.RuneCountInString(account.Nickname))
-	row += " [" + account.Realm + "]"
 	if isDefault {
-		row += " ✅"
-	}
-	if account.Private {
-		row += " 🔒"
+		row += " ⭐"
 	}
 	return row
 }
diff --git a/cmd/discord/commands/link.go b/cmd/discord/commands/link.go
index 6ce21e3c..dc2856c1 100644
--- a/cmd/discord/commands/link.go
+++ b/cmd/discord/commands/link.go
@@ -1,8 +1,10 @@
 package commands
 
 import (
+	"context"
 	"fmt"
 	"strings"
+	"time"
 
 	"github.com/bwmarrin/discordgo"
 	"github.com/cufee/aftermath/cmd/discord/commands/builder"
@@ -35,6 +37,17 @@ func init() {
 					),
 			).
 			Handler(func(ctx *common.Context) error {
+				var wgConnections []models.UserConnection
+				for _, conn := range ctx.User.Connections {
+					if conn.Type != models.ConnectionTypeWargaming {
+						continue
+					}
+					wgConnections = append(wgConnections, conn)
+				}
+				if len(wgConnections) >= 3 {
+					return ctx.Reply().Send("link_error_too_many_connections")
+				}
+
 				options := getDefaultStatsOptions(ctx)
 				message, valid := options.Validate(ctx)
 				if !valid {
@@ -49,21 +62,39 @@ func init() {
 					return ctx.Err(err)
 				}
 
-				currentConnection, exists := ctx.User.Connection(models.ConnectionTypeWargaming)
-				if !exists {
-					currentConnection.UserID = ctx.User.ID
-					currentConnection.Metadata = make(map[string]any)
-					currentConnection.Type = models.ConnectionTypeWargaming
-				}
-
-				currentConnection.Metadata["default"] = true
-				currentConnection.Metadata["verified"] = false
-				currentConnection.ReferenceID = fmt.Sprint(account.ID)
+				var found bool
+				for _, conn := range wgConnections {
+					if conn.ReferenceID == fmt.Sprint(account.ID) {
+						conn.Metadata["verified"] = false
+						found = true
+					}
+					conn.Metadata["default"] = conn.ReferenceID == fmt.Sprint(account.ID)
 
-				_, err = ctx.Core.Database().UpsertConnection(ctx.Context, currentConnection)
-				if err != nil {
-					return ctx.Err(err)
+					_, err = ctx.Core.Database().UpsertConnection(ctx.Context, conn)
+					if err != nil {
+						return ctx.Err(err)
+					}
 				}
+				if !found {
+					meta := make(map[string]any)
+					meta["verified"] = false
+					meta["default"] = true
+					_, err = ctx.Core.Database().UpsertConnection(ctx.Context, models.UserConnection{
+						Type:        models.ConnectionTypeWargaming,
+						ReferenceID: fmt.Sprint(account.ID),
+						UserID:      ctx.User.ID,
+						Metadata:    meta,
+					})
+					if err != nil {
+						return ctx.Err(err)
+					}
+				}
+
+				go func(id string) {
+					c, cancel := context.WithTimeout(context.Background(), time.Second)
+					defer cancel()
+					_, _ = ctx.Core.Fetch().Account(c, id) // Make sure the account is cached
+				}(fmt.Sprint(account.ID))
 
 				return ctx.Reply().Format("command_link_linked_successfully_fmt", account.Nickname, strings.ToUpper(options.Server)).Send()
 			}),
diff --git a/cmd/discord/commands/session.go b/cmd/discord/commands/session.go
index c5386b4a..1fbd9564 100644
--- a/cmd/discord/commands/session.go
+++ b/cmd/discord/commands/session.go
@@ -36,7 +36,7 @@ func init() {
 				case options.UserID != "":
 					// mentioned another user, check if the user has an account linked
 					mentionedUser, _ := ctx.Core.Database().GetUserByID(ctx.Context, options.UserID, database.WithConnections(), database.WithSubscriptions(), database.WithContent())
-					defaultAccount, hasDefaultAccount := mentionedUser.Connection(models.ConnectionTypeWargaming)
+					defaultAccount, hasDefaultAccount := mentionedUser.Connection(models.ConnectionTypeWargaming, map[string]any{"default": true})
 					if !hasDefaultAccount {
 						return ctx.Reply().Send("stats_error_connection_not_found_vague")
 					}
@@ -58,7 +58,7 @@ func init() {
 					accountID = fmt.Sprint(account.ID)
 
 				default:
-					defaultAccount, hasDefaultAccount := ctx.User.Connection(models.ConnectionTypeWargaming)
+					defaultAccount, hasDefaultAccount := ctx.User.Connection(models.ConnectionTypeWargaming, map[string]any{"default": true})
 					if !hasDefaultAccount {
 						return ctx.Reply().Send("stats_error_nickname_or_server_missing")
 					}
diff --git a/cmd/discord/commands/stats.go b/cmd/discord/commands/stats.go
index 61a1f0cb..e0251ef4 100644
--- a/cmd/discord/commands/stats.go
+++ b/cmd/discord/commands/stats.go
@@ -33,7 +33,7 @@ func init() {
 				case options.UserID != "":
 					// mentioned another user, check if the user has an account linked
 					mentionedUser, _ := ctx.Core.Database().GetUserByID(ctx.Context, options.UserID, database.WithConnections(), database.WithSubscriptions(), database.WithContent())
-					defaultAccount, hasDefaultAccount := mentionedUser.Connection(models.ConnectionTypeWargaming)
+					defaultAccount, hasDefaultAccount := mentionedUser.Connection(models.ConnectionTypeWargaming, map[string]any{"default": true})
 					if !hasDefaultAccount {
 						return ctx.Reply().Send("stats_error_connection_not_found_vague")
 					}
@@ -52,7 +52,7 @@ func init() {
 					accountID = fmt.Sprint(account.ID)
 
 				default:
-					defaultAccount, hasDefaultAccount := ctx.User.Connection(models.ConnectionTypeWargaming)
+					defaultAccount, hasDefaultAccount := ctx.User.Connection(models.ConnectionTypeWargaming, map[string]any{"default": true})
 					if !hasDefaultAccount {
 						return ctx.Reply().Send("stats_error_nickname_or_server_missing")
 					}
diff --git a/internal/database/client.go b/internal/database/client.go
index 8d682d4a..cdcb8670 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -41,6 +41,7 @@ type UsersClient interface {
 
 	UpdateConnection(ctx context.Context, connection models.UserConnection) (models.UserConnection, error)
 	UpsertConnection(ctx context.Context, connection models.UserConnection) (models.UserConnection, error)
+	DeleteConnection(ctx context.Context, connectionID string) error
 }
 
 type SnapshotsClient interface {
diff --git a/internal/database/models/user.go b/internal/database/models/user.go
index efdfe56a..e0c8b1fc 100644
--- a/internal/database/models/user.go
+++ b/internal/database/models/user.go
@@ -34,9 +34,15 @@ func (u User) HasPermission(value permissions.Permissions) bool {
 	return perms.Has(value)
 }
 
-func (u User) Connection(kind ConnectionType) (UserConnection, bool) {
+func (u User) Connection(kind ConnectionType, conditions map[string]any) (UserConnection, bool) {
+outerLoop:
 	for _, connection := range u.Connections {
 		if connection.Type == kind {
+			for key, value := range conditions {
+				if connection.Metadata[key] != value {
+					continue outerLoop
+				}
+			}
 			return connection, true
 		}
 	}
diff --git a/internal/database/users.go b/internal/database/users.go
index e172ae0b..27d8fed7 100644
--- a/internal/database/users.go
+++ b/internal/database/users.go
@@ -207,3 +207,7 @@ func (c *client) UpsertConnection(ctx context.Context, connection models.UserCon
 
 	return connection, nil
 }
+
+func (c *client) DeleteConnection(ctx context.Context, connectionID string) error {
+	return c.db.UserConnection.DeleteOneID(connectionID).Exec(ctx)
+}
diff --git a/static/localization/en/discord.yaml b/static/localization/en/discord.yaml
index ae295ab9..aefa15a3 100755
--- a/static/localization/en/discord.yaml
+++ b/static/localization/en/discord.yaml
@@ -33,9 +33,15 @@
   value: linked
 - key: command_option_accounts_linked_description
   value: View your linked Blitz accounts
+- key: command_option_accounts_unlink_name
+  value: unlink
+- key: command_option_accounts_unlink_description
+  value: Unlink your Blitz account
 
 - key: command_accounts_set_default_successfully_fmt
   value: "Your default account has been updated! Aftermath will now default to **%s** on **%s** when checking stats."
+- key: command_accounts_unlinked_successfully
+  value: "Your linked account was removed."
 - key: command_accounts_verify_cta
   value: "You can also verify your account with `/verify`"
   context: A new default account was set, but it is not verified
@@ -191,6 +197,9 @@
 - key: link_error_missing_input
   value: "I need both the nickname and server to find your account."
   context: Nickname or server not provided
+- key: link_error_too_many_connections
+  value: "It looks like you have reached the limit for the number of Blitz accounts linked.\nTry removing an existing account with `/accounts unlink` before adding a new one."
+  context: User reached their connection limit for Blitz accounts
 
   # /verify errors
 - key: verify_error_missing_server
@@ -201,6 +210,9 @@
 - key: accounts_error_connection_not_found
   value: "I was not able to find your linked account with this nickname. Try adding it through `/link` instead."
   context: Nickname is invalid or failed to find a valid connection
+- key: accounts_error_connection_not_found_selected
+  value: "I was not able to the account you have selected."
+  context: Failed to find the selected account by ID
 
 
   # Wargaming specific errors

From 61ca515672fa4112d2d16ca94524daede2d1c57d Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 30 Jun 2024 22:48:48 -0400
Subject: [PATCH 235/341] unified commands

---
 cmd/discord/commands/link.go                  | 102 -------------
 .../commands/{accounts.go => links.go}        | 143 ++++++++++++++----
 cmd/discord/commands/options.go               |  10 +-
 cmd/discord/commands/session.go               |   2 +-
 cmd/discord/commands/stats.go                 |   2 +-
 cmd/discord/common/context.go                 |  13 +-
 cmd/discord/discord.go                        |   2 +-
 static/localization/en/discord.yaml           |  71 +++++----
 tests/static_database.go                      |   3 +
 9 files changed, 160 insertions(+), 188 deletions(-)
 delete mode 100644 cmd/discord/commands/link.go
 rename cmd/discord/commands/{accounts.go => links.go} (51%)

diff --git a/cmd/discord/commands/link.go b/cmd/discord/commands/link.go
deleted file mode 100644
index dc2856c1..00000000
--- a/cmd/discord/commands/link.go
+++ /dev/null
@@ -1,102 +0,0 @@
-package commands
-
-import (
-	"context"
-	"fmt"
-	"strings"
-	"time"
-
-	"github.com/bwmarrin/discordgo"
-	"github.com/cufee/aftermath/cmd/discord/commands/builder"
-	"github.com/cufee/aftermath/cmd/discord/common"
-	"github.com/cufee/aftermath/internal/database/models"
-)
-
-func init() {
-	LoadedPublic.add(
-		builder.NewCommand("link").
-			Options(
-				builder.NewOption("nickname", discordgo.ApplicationCommandOptionString).
-					Required().
-					Min(5).
-					Max(30).
-					Params(
-						builder.SetNameKey("common_option_stats_nickname_name"),
-						builder.SetDescKey("common_option_stats_nickname_description"),
-					),
-				builder.NewOption("server", discordgo.ApplicationCommandOptionString).
-					Required().
-					Params(
-						builder.SetNameKey("common_option_stats_realm_name"),
-						builder.SetDescKey("common_option_stats_realm_description"),
-					).
-					Choices(
-						builder.NewChoice("realm_na", "na").Params(builder.SetNameKey("common_label_realm_na")),
-						builder.NewChoice("realm_eu", "eu").Params(builder.SetNameKey("common_label_realm_eu")),
-						builder.NewChoice("realm_as", "as").Params(builder.SetNameKey("common_label_realm_as")),
-					),
-			).
-			Handler(func(ctx *common.Context) error {
-				var wgConnections []models.UserConnection
-				for _, conn := range ctx.User.Connections {
-					if conn.Type != models.ConnectionTypeWargaming {
-						continue
-					}
-					wgConnections = append(wgConnections, conn)
-				}
-				if len(wgConnections) >= 3 {
-					return ctx.Reply().Send("link_error_too_many_connections")
-				}
-
-				options := getDefaultStatsOptions(ctx)
-				message, valid := options.Validate(ctx)
-				if !valid {
-					return ctx.Reply().Send(message)
-				}
-
-				account, err := ctx.Core.Fetch().Search(ctx.Context, options.Nickname, options.Server)
-				if err != nil {
-					if err.Error() == "no results found" {
-						return ctx.Reply().Format("stats_error_nickname_not_fount_fmt", options.Nickname, strings.ToUpper(options.Server)).Send()
-					}
-					return ctx.Err(err)
-				}
-
-				var found bool
-				for _, conn := range wgConnections {
-					if conn.ReferenceID == fmt.Sprint(account.ID) {
-						conn.Metadata["verified"] = false
-						found = true
-					}
-					conn.Metadata["default"] = conn.ReferenceID == fmt.Sprint(account.ID)
-
-					_, err = ctx.Core.Database().UpsertConnection(ctx.Context, conn)
-					if err != nil {
-						return ctx.Err(err)
-					}
-				}
-				if !found {
-					meta := make(map[string]any)
-					meta["verified"] = false
-					meta["default"] = true
-					_, err = ctx.Core.Database().UpsertConnection(ctx.Context, models.UserConnection{
-						Type:        models.ConnectionTypeWargaming,
-						ReferenceID: fmt.Sprint(account.ID),
-						UserID:      ctx.User.ID,
-						Metadata:    meta,
-					})
-					if err != nil {
-						return ctx.Err(err)
-					}
-				}
-
-				go func(id string) {
-					c, cancel := context.WithTimeout(context.Background(), time.Second)
-					defer cancel()
-					_, _ = ctx.Core.Fetch().Account(c, id) // Make sure the account is cached
-				}(fmt.Sprint(account.ID))
-
-				return ctx.Reply().Format("command_link_linked_successfully_fmt", account.Nickname, strings.ToUpper(options.Server)).Send()
-			}),
-	)
-}
diff --git a/cmd/discord/commands/accounts.go b/cmd/discord/commands/links.go
similarity index 51%
rename from cmd/discord/commands/accounts.go
rename to cmd/discord/commands/links.go
index b2157651..1ddd7b7c 100644
--- a/cmd/discord/commands/accounts.go
+++ b/cmd/discord/commands/links.go
@@ -1,8 +1,10 @@
 package commands
 
 import (
+	"context"
 	"fmt"
 	"strings"
+	"time"
 	"unicode/utf8"
 
 	"github.com/bwmarrin/discordgo"
@@ -10,30 +12,53 @@ import (
 	"github.com/cufee/aftermath/cmd/discord/common"
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
-	"github.com/rs/zerolog/log"
 )
 
 func init() {
 	LoadedPublic.add(
-		builder.NewCommand("accounts").
+		builder.NewCommand("links").
 			Ephemeral().
 			Options(
-				builder.NewOption("default", discordgo.ApplicationCommandOptionSubCommand).
-					Params(builder.SetNameKey("command_option_accounts_default_name"), builder.SetDescKey("command_option_accounts_default_description")).
+				builder.NewOption("add", discordgo.ApplicationCommandOptionSubCommand).
+					Params(builder.SetNameKey("command_option_links_add_name"), builder.SetDescKey("command_option_links_add_desc")).
+					Options(
+						builder.NewOption("nickname", discordgo.ApplicationCommandOptionString).
+							Required().
+							Min(5).
+							Max(30).
+							Params(
+								builder.SetNameKey("common_option_stats_nickname_name"),
+								builder.SetDescKey("common_option_stats_nickname_description"),
+							),
+						builder.NewOption("server", discordgo.ApplicationCommandOptionString).
+							Required().
+							Params(
+								builder.SetNameKey("common_option_stats_realm_name"),
+								builder.SetDescKey("common_option_stats_realm_description"),
+							).
+							Choices(
+								builder.NewChoice("realm_na", "NA").Params(builder.SetNameKey("common_label_realm_na")),
+								builder.NewChoice("realm_eu", "EU").Params(builder.SetNameKey("common_label_realm_eu")),
+								builder.NewChoice("realm_as", "AS").Params(builder.SetNameKey("common_label_realm_as")),
+							),
+					),
+				builder.NewOption("favorite", discordgo.ApplicationCommandOptionSubCommand).
+					Params(builder.SetNameKey("command_option_links_fav_name"), builder.SetDescKey("command_option_links_fav_desc")).
 					Options(
 						builder.NewOption("selected", discordgo.ApplicationCommandOptionString).
 							Autocomplete().
 							Required(),
 					),
-				builder.NewOption("unlink", discordgo.ApplicationCommandOptionSubCommand).
-					Params(builder.SetNameKey("command_option_accounts_unlink_name"), builder.SetDescKey("command_option_accounts_unlink_description")).
+
+				builder.NewOption("view", discordgo.ApplicationCommandOptionSubCommand).
+					Params(builder.SetNameKey("command_option_links_view_name"), builder.SetDescKey("command_option_links_view_desc")),
+				builder.NewOption("remove", discordgo.ApplicationCommandOptionSubCommand).
+					Params(builder.SetNameKey("command_option_links_remove_name"), builder.SetDescKey("command_option_links_remove_desc")).
 					Options(
 						builder.NewOption("selected", discordgo.ApplicationCommandOptionString).
 							Autocomplete().
 							Required(),
 					),
-				builder.NewOption("linked", discordgo.ApplicationCommandOptionSubCommand).
-					Params(builder.SetNameKey("command_option_accounts_linked_name"), builder.SetDescKey("command_option_accounts_linked_description")),
 			).
 			Handler(func(ctx *common.Context) error {
 				// handle subcommand
@@ -42,11 +67,11 @@ func init() {
 				default:
 					return ctx.Error("received an unexpected subcommand: " + subcommand)
 
-				case "default":
+				case "favorite":
 					value, _ := subOptions.Value("selected").(string)
 					parts := strings.Split(value, "#")
 					if len(parts) != 4 || parts[0] != "valid" {
-						return ctx.Reply().Send("accounts_error_connection_not_found")
+						return ctx.Reply().Send("links_error_connection_not_found")
 					}
 					accountID := parts[1]
 					nickname := parts[2]
@@ -67,26 +92,26 @@ func init() {
 						_, err := ctx.Core.Database().UpdateConnection(ctx.Context, conn)
 						if err != nil {
 							if database.IsNotFound(err) {
-								return ctx.Reply().Send("accounts_error_connection_not_found")
+								return ctx.Reply().Send("links_error_connection_not_found")
 							}
 							return ctx.Err(err)
 						}
 					}
 					if !found {
-						return ctx.Reply().Send("accounts_error_connection_not_found")
+						return ctx.Reply().Send("links_error_connection_not_found")
 					}
 
-					var content = []string{fmt.Sprintf(ctx.Localize("command_accounts_set_default_successfully_fmt"), nickname, realm)}
+					var content = []string{fmt.Sprintf(ctx.Localize("command_links_set_default_successfully_fmt"), nickname, realm)}
 					if !newConnectionVerified {
-						content = append(content, ctx.Localize("command_accounts_verify_cta"))
+						content = append(content, ctx.Localize("command_links_verify_cta"))
 					}
 					return ctx.Reply().Text(content...).Send()
 
-				case "unlink":
+				case "remove":
 					value, _ := subOptions.Value("selected").(string)
 					parts := strings.Split(value, "#")
 					if len(parts) != 4 || parts[0] != "valid" {
-						return ctx.Reply().Send("accounts_error_connection_not_found_selected")
+						return ctx.Reply().Send("links_error_connection_not_found_selected")
 					}
 					accountID := parts[1]
 
@@ -99,12 +124,12 @@ func init() {
 							if err != nil {
 								return ctx.Err(err)
 							}
-							return ctx.Reply().Send("command_accounts_unlinked_successfully")
+							return ctx.Reply().Send("command_links_unlinked_successfully")
 						}
 					}
-					return ctx.Reply().Send("accounts_error_connection_not_found_selected")
+					return ctx.Reply().Send("links_error_connection_not_found_selected")
 
-				case "linked":
+				case "view":
 					var currentDefault string
 					var linkedAccounts []string
 					for _, conn := range ctx.User.Connections {
@@ -137,26 +162,78 @@ func init() {
 						nicknames = append(nicknames, accountToRow(a, longestName, currentDefault == a.ID))
 					}
 					return ctx.Reply().Send(strings.Join(nicknames, "\n"))
+
+				case "add":
+					var wgConnections []models.UserConnection
+					for _, conn := range ctx.User.Connections {
+						if conn.Type != models.ConnectionTypeWargaming {
+							continue
+						}
+						wgConnections = append(wgConnections, conn)
+					}
+					if len(wgConnections) >= 3 {
+						return ctx.Reply().Send("links_error_too_many_connections")
+					}
+
+					options := getDefaultStatsOptions(subOptions)
+					message, valid := options.Validate(ctx)
+					if !valid {
+						return ctx.Reply().Send(message)
+					}
+
+					account, err := ctx.Core.Fetch().Search(ctx.Context, options.Nickname, options.Server)
+					if err != nil {
+						if err.Error() == "no results found" {
+							return ctx.Reply().Format("stats_error_nickname_not_fount_fmt", options.Nickname, strings.ToUpper(options.Server)).Send()
+						}
+						return ctx.Err(err)
+					}
+
+					var found bool
+					for _, conn := range wgConnections {
+						if conn.ReferenceID == fmt.Sprint(account.ID) {
+							conn.Metadata["verified"] = false
+							found = true
+						}
+						conn.Metadata["default"] = conn.ReferenceID == fmt.Sprint(account.ID)
+
+						_, err = ctx.Core.Database().UpsertConnection(ctx.Context, conn)
+						if err != nil {
+							return ctx.Err(err)
+						}
+					}
+					if !found {
+						meta := make(map[string]any)
+						meta["verified"] = false
+						meta["default"] = true
+						_, err = ctx.Core.Database().UpsertConnection(ctx.Context, models.UserConnection{
+							Type:        models.ConnectionTypeWargaming,
+							ReferenceID: fmt.Sprint(account.ID),
+							UserID:      ctx.User.ID,
+							Metadata:    meta,
+						})
+						if err != nil {
+							return ctx.Err(err)
+						}
+					}
+
+					go func(id string) {
+						c, cancel := context.WithTimeout(context.Background(), time.Second)
+						defer cancel()
+						_, _ = ctx.Core.Fetch().Account(c, id) // Make sure the account is cached
+					}(fmt.Sprint(account.ID))
+
+					return ctx.Reply().Format("command_links_linked_successfully_fmt", account.Nickname, strings.ToUpper(options.Server)).Send()
 				}
 			}),
 	)
 
 	LoadedPublic.add(
-		builder.NewCommand("autocomplete_accounts").
+		builder.NewCommand("autocomplete_links").
 			ComponentType(func(s string) bool {
-				return s == "autocomplete_accounts"
+				return s == "autocomplete_links"
 			}).
 			Handler(func(ctx *common.Context) error {
-				command, _, ok := ctx.Options().Subcommand()
-				if !ok {
-					log.Error().Str("command", "autocomplete_accounts").Msg("interaction is not a subcommand")
-					return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: ctx.Localize("accounts_error_connection_not_found"), Value: "error#accounts_error_connection_not_found"})
-				}
-				if command != "default" && command != "unlink" {
-					log.Error().Str("command", command).Msg("invalid subcommand received in autocomplete_accounts")
-					return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: ctx.Localize("accounts_error_connection_not_found"), Value: "error#accounts_error_connection_not_found"})
-				}
-
 				var currentDefault string
 				var linkedAccounts []string
 				for _, conn := range ctx.User.Connections {
@@ -170,12 +247,12 @@ func init() {
 
 				}
 				if len(linkedAccounts) < 1 {
-					return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: ctx.Localize("accounts_error_connection_not_found"), Value: "error#accounts_error_connection_not_found"})
+					return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: ctx.Localize("links_error_connection_not_found"), Value: "error#links_error_connection_not_found"})
 				}
 
 				accounts, err := ctx.Core.Database().GetAccounts(ctx.Context, linkedAccounts)
 				if err != nil {
-					return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: ctx.Localize("accounts_error_connection_not_found"), Value: "error#accounts_error_connection_not_found"})
+					return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: ctx.Localize("links_error_connection_not_found"), Value: "error#links_error_connection_not_found"})
 				}
 
 				var longestName int
diff --git a/cmd/discord/commands/options.go b/cmd/discord/commands/options.go
index c5f3db1e..701a13b9 100644
--- a/cmd/discord/commands/options.go
+++ b/cmd/discord/commands/options.go
@@ -79,14 +79,14 @@ func (o statsOptions) Validate(ctx *common.Context) (string, bool) {
 	return "", true
 }
 
-func getDefaultStatsOptions(ctx *common.Context) statsOptions {
+func getDefaultStatsOptions(data []*discordgo.ApplicationCommandInteractionDataOption) statsOptions {
 	var options statsOptions
 
-	options.Nickname, _ = common.GetOption[string](ctx, "nickname")
-	options.Server, _ = common.GetOption[string](ctx, "server")
-	options.UserID, _ = common.GetOption[string](ctx, "user")
+	options.Nickname, _ = common.GetOption[string](data, "nickname")
+	options.Server, _ = common.GetOption[string](data, "server")
+	options.UserID, _ = common.GetOption[string](data, "user")
 
-	if days, _ := common.GetOption[float64](ctx, "days"); days > 0 {
+	if days, _ := common.GetOption[float64](data, "days"); days > 0 {
 		options.Days = int(days)
 		options.PeriodStart = time.Now().Add(time.Hour * 24 * time.Duration(days) * -1)
 	}
diff --git a/cmd/discord/commands/session.go b/cmd/discord/commands/session.go
index 1fbd9564..2fe129a9 100644
--- a/cmd/discord/commands/session.go
+++ b/cmd/discord/commands/session.go
@@ -23,7 +23,7 @@ func init() {
 		builder.NewCommand("session").
 			Options(defaultStatsOptions...).
 			Handler(func(ctx *common.Context) error {
-				options := getDefaultStatsOptions(ctx)
+				options := getDefaultStatsOptions(ctx.Options())
 				message, valid := options.Validate(ctx)
 				if !valid {
 					return ctx.Reply().Send(message)
diff --git a/cmd/discord/commands/stats.go b/cmd/discord/commands/stats.go
index e0251ef4..f2a7be15 100644
--- a/cmd/discord/commands/stats.go
+++ b/cmd/discord/commands/stats.go
@@ -20,7 +20,7 @@ func init() {
 		builder.NewCommand("stats").
 			Options(defaultStatsOptions...).
 			Handler(func(ctx *common.Context) error {
-				options := getDefaultStatsOptions(ctx)
+				options := getDefaultStatsOptions(ctx.Options())
 				message, valid := options.Validate(ctx)
 				if !valid {
 					return ctx.Reply().Send(message)
diff --git a/cmd/discord/common/context.go b/cmd/discord/common/context.go
index 2868c437..93780453 100644
--- a/cmd/discord/common/context.go
+++ b/cmd/discord/common/context.go
@@ -172,15 +172,12 @@ func (o options) Subcommand() (string, options, bool) {
 	return "", options{}, false
 }
 
-func GetOption[T any](c *Context, name string) (T, bool) {
+func GetOption[T any](data []*discordgo.ApplicationCommandInteractionDataOption, name string) (T, bool) {
 	var v T
-	if data, ok := c.CommandData(); ok {
-		for _, opt := range data.Options {
-			if opt.Name == name {
-				v, _ = opt.Value.(T)
-
-				return v, true
-			}
+	for _, opt := range data {
+		if opt.Name == name {
+			v, _ = opt.Value.(T)
+			return v, true
 		}
 	}
 	return v, false
diff --git a/cmd/discord/discord.go b/cmd/discord/discord.go
index cb02b5e3..58e1de5c 100644
--- a/cmd/discord/discord.go
+++ b/cmd/discord/discord.go
@@ -19,7 +19,7 @@ func NewRouterHandler(coreClient core.Client, token string, publicKey string, co
 
 	rt.LoadCommands(commands...)
 
-	ctx, cancel := context.WithTimeout(context.Background(), time.Second*15)
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*30)
 	defer cancel()
 
 	err = rt.UpdateLoadedCommands(ctx)
diff --git a/static/localization/en/discord.yaml b/static/localization/en/discord.yaml
index aefa15a3..3b53befb 100755
--- a/static/localization/en/discord.yaml
+++ b/static/localization/en/discord.yaml
@@ -13,36 +13,35 @@
   value: session
 - key: command_session_description
   value: Get detailed stats for your recent session
-# /link
-- key: command_link_name
-  value: link
-- key: command_link_description
-  value: Link your Blitz account to Aftermath
-- key: command_link_linked_successfully_fmt
-  value: "Your account has been linked! Aftermath will now default to **%s** on **%s** when checking stats.\nYou can also verify your account with `/verify`"
-# /accounts
-- key: command_accounts_name
-  value: accounts
-- key: command_accounts_description
-  value: View and manage your linked accounts
-- key: command_option_accounts_default_name
-  value: default
-- key: command_option_accounts_default_description
-  value: Set the default account Aftermath will check when using commands
-- key: command_option_accounts_linked_name
-  value: linked
-- key: command_option_accounts_linked_description
+# /links
+- key: command_links_name
+  value: links
+- key: command_links_description
+  value: Manage your linked Blitz accounts
+- key: command_option_links_add_name
+  value: add
+- key: command_option_links_add_desc
+  value: Link a new Blitz account
+- key: command_option_links_remove_name
+  value: remove
+- key: command_option_links_remove_desc
+  value: Remove your linked Blitz account
+- key: command_option_links_fav_name
+  value: favorite
+- key: command_option_links_fav_desc
+  value: Mark your linked account as default for Aftermath to check
+- key: command_option_links_view_name
+  value: view
+- key: command_option_links_view_desc
   value: View your linked Blitz accounts
-- key: command_option_accounts_unlink_name
-  value: unlink
-- key: command_option_accounts_unlink_description
-  value: Unlink your Blitz account
+- key: command_links_linked_successfully_fmt
+  value: "Your account has been linked! Aftermath will now default to **%s** on **%s** when checking stats.\nYou can also verify your account with `/verify`"
 
-- key: command_accounts_set_default_successfully_fmt
+- key: command_links_set_default_successfully_fmt
   value: "Your default account has been updated! Aftermath will now default to **%s** on **%s** when checking stats."
-- key: command_accounts_unlinked_successfully
+- key: command_links_unlinked_successfully
   value: "Your linked account was removed."
-- key: command_accounts_verify_cta
+- key: command_links_verify_cta
   value: "You can also verify your account with `/verify`"
   context: A new default account was set, but it is not verified
 
@@ -193,27 +192,25 @@
   value: "You need to provide a link or attach a WoT Blitz replay file."
   context: Invalid file attached
 
-  # /link errors
-- key: link_error_missing_input
+  # /links errors
+- key: links_error_missing_input
   value: "I need both the nickname and server to find your account."
   context: Nickname or server not provided
-- key: link_error_too_many_connections
+- key: links_error_too_many_connections
   value: "It looks like you have reached the limit for the number of Blitz accounts linked.\nTry removing an existing account with `/accounts unlink` before adding a new one."
   context: User reached their connection limit for Blitz accounts
+- key: links_error_connection_not_found
+  value: "I was not able to find your linked account with this nickname. Try adding it through `/link` instead."
+  context: Nickname is invalid or failed to find a valid connection
+- key: links_error_connection_not_found_selected
+  value: "I was not able to the account you have selected."
+  context: Failed to find the selected account by ID
 
   # /verify errors
 - key: verify_error_missing_server
   value: "Please select a server your account is registered on."
   context: Server not selected
 
-  # /accounts errors
-- key: accounts_error_connection_not_found
-  value: "I was not able to find your linked account with this nickname. Try adding it through `/link` instead."
-  context: Nickname is invalid or failed to find a valid connection
-- key: accounts_error_connection_not_found_selected
-  value: "I was not able to the account you have selected."
-  context: Failed to find the selected account by ID
-
 
   # Wargaming specific errors
 - key: wargaming_error_private_account
diff --git a/tests/static_database.go b/tests/static_database.go
index 8c18c841..065c0c7a 100644
--- a/tests/static_database.go
+++ b/tests/static_database.go
@@ -89,6 +89,9 @@ func (c *staticTestingDatabase) UpdateConnection(ctx context.Context, connection
 func (c *staticTestingDatabase) UpsertConnection(ctx context.Context, connection models.UserConnection) (models.UserConnection, error) {
 	return models.UserConnection{}, errors.New("UpsertConnection not implemented")
 }
+func (c *staticTestingDatabase) DeleteConnection(ctx context.Context, connectionID string) error {
+	return errors.New("DeleteConnection not implemented")
+}
 
 func (c *staticTestingDatabase) GetAccountSnapshot(ctx context.Context, accountID, referenceID string, kind models.SnapshotType, options ...database.SnapshotQuery) (models.AccountSnapshot, error) {
 	return models.AccountSnapshot{}, errors.New("GetAccountSnapshot not implemented")

From f23502411d30596a67b207da05b38a8e3f26b2bc Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 30 Jun 2024 22:53:51 -0400
Subject: [PATCH 236/341] new string

---
 cmd/discord/commands/links.go       | 4 ++--
 static/localization/en/discord.yaml | 2 ++
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/cmd/discord/commands/links.go b/cmd/discord/commands/links.go
index 1ddd7b7c..506d2a3d 100644
--- a/cmd/discord/commands/links.go
+++ b/cmd/discord/commands/links.go
@@ -247,12 +247,12 @@ func init() {
 
 				}
 				if len(linkedAccounts) < 1 {
-					return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: ctx.Localize("links_error_connection_not_found"), Value: "error#links_error_connection_not_found"})
+					return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: ctx.Localize("links_error_no_accounts_linked"), Value: "error#links_error_no_accounts_linked"})
 				}
 
 				accounts, err := ctx.Core.Database().GetAccounts(ctx.Context, linkedAccounts)
 				if err != nil {
-					return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: ctx.Localize("links_error_connection_not_found"), Value: "error#links_error_connection_not_found"})
+					return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: ctx.Localize("links_error_no_accounts_linked"), Value: "error#links_error_no_accounts_linked"})
 				}
 
 				var longestName int
diff --git a/static/localization/en/discord.yaml b/static/localization/en/discord.yaml
index 3b53befb..7c69c8df 100755
--- a/static/localization/en/discord.yaml
+++ b/static/localization/en/discord.yaml
@@ -205,6 +205,8 @@
 - key: links_error_connection_not_found_selected
   value: "I was not able to the account you have selected."
   context: Failed to find the selected account by ID
+- key: links_error_no_accounts_linked
+  value: "You don't have any linked accounts."
 
   # /verify errors
 - key: verify_error_missing_server

From c133573a89250406c47bb3e3ca86fe1b0c420d5d Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 30 Jun 2024 22:56:07 -0400
Subject: [PATCH 237/341] typos

---
 static/localization/en/discord.yaml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/static/localization/en/discord.yaml b/static/localization/en/discord.yaml
index 7c69c8df..0db84573 100755
--- a/static/localization/en/discord.yaml
+++ b/static/localization/en/discord.yaml
@@ -138,11 +138,11 @@
   context: Mentioned self when checking stats, will not prevent the command from running
 
 - key: stats_error_connection_not_found_personal
-  value: "Looks like we haven't got your Blitz nickname yet. Give the `/link` command a shot."
+  value: "Looks like you don't have a Blitz account linked yet. Give the `/links` command a shot."
   context: No Blitz account linked
 
 - key: stats_error_nickname_or_server_missing
-  value: "I need both the name and server to find your account. You can also use the `/link` command to setup a default account."
+  value: "I need both the name and server to find your account. You can also use the `/links` command to setup a default account."
   context: User provided a nickname, but no server
 
 - key: stats_error_nickname_invalid
@@ -200,7 +200,7 @@
   value: "It looks like you have reached the limit for the number of Blitz accounts linked.\nTry removing an existing account with `/accounts unlink` before adding a new one."
   context: User reached their connection limit for Blitz accounts
 - key: links_error_connection_not_found
-  value: "I was not able to find your linked account with this nickname. Try adding it through `/link` instead."
+  value: "I was not able to find a linked account with this nickname. Try adding a new one with `/links add`."
   context: Nickname is invalid or failed to find a valid connection
 - key: links_error_connection_not_found_selected
   value: "I was not able to the account you have selected."

From 719768905a78a219de5732a36fec267f0762661e Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Tue, 2 Jul 2024 20:43:15 -0400
Subject: [PATCH 238/341] added a basic frontend

---
 .air.toml                                     |  10 +-
 .air.web.toml                                 |  13 +
 .env.example                                  |   4 +
 Taskfile.yaml                                 |   4 +
 cmd/core/client.go                            |   8 +-
 cmd/discord/commands/interactions.go          |  13 +-
 cmd/discord/commands/session.go               |   5 +-
 cmd/discord/commands/stats.go                 |   4 +-
 cmd/frontend/assets/assets.go                 |   3 +
 cmd/frontend/assets/gen.go                    |  56 ++
 cmd/frontend/assets/rating.go                 |  11 +
 cmd/frontend/assets/wn8.go                    |  24 +
 cmd/frontend/components/logo.templ            |   7 +
 cmd/frontend/components/logo_templ.go         |  50 ++
 cmd/frontend/components/widget/default.templ  | 141 +++++
 .../components/widget/default_templ.go        | 535 ++++++++++++++++++
 cmd/frontend/components/widget/widget.templ   | 124 ++++
 .../components/widget/widget_templ.go         | 196 +++++++
 cmd/frontend/handler/context.go               | 100 ++++
 cmd/frontend/handlers.go                      |  75 +++
 cmd/frontend/layouts/main.templ               |  58 ++
 cmd/frontend/layouts/main_templ.go            |  69 +++
 cmd/frontend/logic/scripts.go                 |  75 +++
 cmd/frontend/public/favicon.ico               | Bin 0 -> 3890 bytes
 cmd/frontend/public/favicon.png               | Bin 0 -> 692 bytes
 cmd/frontend/public/icon-128.png              | Bin 0 -> 2378 bytes
 cmd/frontend/public/icon-256.png              | Bin 0 -> 4905 bytes
 cmd/frontend/public/icon-32.png               | Bin 0 -> 692 bytes
 cmd/frontend/public/icon-512.png              | Bin 0 -> 10321 bytes
 cmd/frontend/public/icon-64.png               | Bin 0 -> 1235 bytes
 cmd/frontend/public/og-widget.jpg             | Bin 0 -> 40334 bytes
 cmd/frontend/public/og.jpg                    | Bin 0 -> 40334 bytes
 cmd/frontend/public/og.png                    | Bin 0 -> 14493 bytes
 cmd/frontend/public/promo-invite.jpg          | Bin 0 -> 279770 bytes
 cmd/frontend/public/promo-join.jpg            | Bin 0 -> 61040 bytes
 cmd/frontend/public/rating/bronze.png         | Bin 0 -> 52350 bytes
 cmd/frontend/public/rating/calibration.png    | Bin 0 -> 2231 bytes
 cmd/frontend/public/rating/diamond.png        | Bin 0 -> 58867 bytes
 cmd/frontend/public/rating/gold.png           | Bin 0 -> 57541 bytes
 cmd/frontend/public/rating/platinum.png       | Bin 0 -> 68497 bytes
 cmd/frontend/public/rating/silver.png         | Bin 0 -> 56479 bytes
 cmd/frontend/public/wn8/.gitignore            |   1 +
 cmd/frontend/routes/errors.templ              |  33 ++
 cmd/frontend/routes/errors_templ.go           | 103 ++++
 cmd/frontend/routes/index.templ               |  37 ++
 cmd/frontend/routes/index_templ.go            |  51 ++
 cmd/frontend/routes/widget/configure.templ    |  72 +++
 cmd/frontend/routes/widget/configure_templ.go |  93 +++
 cmd/frontend/routes/widget/live.templ         |  45 ++
 cmd/frontend/routes/widget/live_templ.go      |  76 +++
 dev_web.go                                    |  73 +++
 go.mod                                        |   3 +
 go.sum                                        |   9 +
 internal/database/models/vehicle_snapshot.go  |   5 +-
 internal/stats/client/v1/client.go            |  35 ++
 .../stats/{renderer => client}/v1/errors.go   |   2 +-
 .../stats/{renderer => client}/v1/image.go    |   2 +-
 .../stats/{renderer => client}/v1/metadata.go |   2 +-
 internal/stats/client/v1/options.go           |  58 ++
 .../stats/{renderer => client}/v1/period.go   |  31 +-
 internal/stats/client/v1/replay.go            |   1 +
 .../stats/{renderer => client}/v1/session.go  |  56 +-
 internal/stats/fetch/v1/client.go             |  14 +-
 internal/stats/fetch/v1/multisource.go        |   6 +-
 .../stats/prepare/session/v1/constants.go     |   3 +-
 internal/stats/render/common/v1/rating.go     |  45 ++
 internal/stats/render/session/v1/blocks.go    |   2 +-
 internal/stats/render/session/v1/icons.go     |  40 --
 internal/stats/renderer/v1/renderer.go        |  32 --
 internal/stats/renderer/v1/replay.go          |   1 -
 main.go                                       |  36 +-
 render_test.go                                |   9 +-
 tests/static_database.go                      |   7 +-
 73 files changed, 2430 insertions(+), 138 deletions(-)
 create mode 100644 .air.web.toml
 create mode 100644 cmd/frontend/assets/assets.go
 create mode 100644 cmd/frontend/assets/gen.go
 create mode 100644 cmd/frontend/assets/rating.go
 create mode 100644 cmd/frontend/assets/wn8.go
 create mode 100644 cmd/frontend/components/logo.templ
 create mode 100644 cmd/frontend/components/logo_templ.go
 create mode 100644 cmd/frontend/components/widget/default.templ
 create mode 100644 cmd/frontend/components/widget/default_templ.go
 create mode 100644 cmd/frontend/components/widget/widget.templ
 create mode 100644 cmd/frontend/components/widget/widget_templ.go
 create mode 100644 cmd/frontend/handler/context.go
 create mode 100644 cmd/frontend/handlers.go
 create mode 100644 cmd/frontend/layouts/main.templ
 create mode 100644 cmd/frontend/layouts/main_templ.go
 create mode 100644 cmd/frontend/logic/scripts.go
 create mode 100644 cmd/frontend/public/favicon.ico
 create mode 100644 cmd/frontend/public/favicon.png
 create mode 100644 cmd/frontend/public/icon-128.png
 create mode 100644 cmd/frontend/public/icon-256.png
 create mode 100644 cmd/frontend/public/icon-32.png
 create mode 100644 cmd/frontend/public/icon-512.png
 create mode 100644 cmd/frontend/public/icon-64.png
 create mode 100644 cmd/frontend/public/og-widget.jpg
 create mode 100644 cmd/frontend/public/og.jpg
 create mode 100644 cmd/frontend/public/og.png
 create mode 100644 cmd/frontend/public/promo-invite.jpg
 create mode 100644 cmd/frontend/public/promo-join.jpg
 create mode 100644 cmd/frontend/public/rating/bronze.png
 create mode 100644 cmd/frontend/public/rating/calibration.png
 create mode 100644 cmd/frontend/public/rating/diamond.png
 create mode 100644 cmd/frontend/public/rating/gold.png
 create mode 100644 cmd/frontend/public/rating/platinum.png
 create mode 100644 cmd/frontend/public/rating/silver.png
 create mode 100644 cmd/frontend/public/wn8/.gitignore
 create mode 100644 cmd/frontend/routes/errors.templ
 create mode 100644 cmd/frontend/routes/errors_templ.go
 create mode 100644 cmd/frontend/routes/index.templ
 create mode 100644 cmd/frontend/routes/index_templ.go
 create mode 100644 cmd/frontend/routes/widget/configure.templ
 create mode 100644 cmd/frontend/routes/widget/configure_templ.go
 create mode 100644 cmd/frontend/routes/widget/live.templ
 create mode 100644 cmd/frontend/routes/widget/live_templ.go
 create mode 100644 dev_web.go
 create mode 100644 internal/stats/client/v1/client.go
 rename internal/stats/{renderer => client}/v1/errors.go (85%)
 rename internal/stats/{renderer => client}/v1/image.go (97%)
 rename internal/stats/{renderer => client}/v1/metadata.go (97%)
 create mode 100644 internal/stats/client/v1/options.go
 rename internal/stats/{renderer => client}/v1/period.go (63%)
 create mode 100644 internal/stats/client/v1/replay.go
 rename internal/stats/{renderer => client}/v1/session.go (59%)
 create mode 100644 internal/stats/render/common/v1/rating.go
 delete mode 100644 internal/stats/render/session/v1/icons.go
 delete mode 100644 internal/stats/renderer/v1/renderer.go
 delete mode 100644 internal/stats/renderer/v1/replay.go

diff --git a/.air.toml b/.air.toml
index 4a197927..9de18a51 100644
--- a/.air.toml
+++ b/.air.toml
@@ -1,3 +1,11 @@
 [build]
-# cmd = "go build -gcflags=-m=3 -o ./tmp/main ."
+include_ext = ["go", "tmpl", "templ", "html"]
+exclude_regex = [".*_templ.go"]
+pre_cmd = ["templ generate"]
+send_interrupt = true
 stop_on_error = true
+
+[proxy]
+enabled = true
+proxy_port = 8080
+app_port = 9092
diff --git a/.air.web.toml b/.air.web.toml
new file mode 100644
index 00000000..181cb47e
--- /dev/null
+++ b/.air.web.toml
@@ -0,0 +1,13 @@
+[build]
+include_ext = ["go", "templ", "html"]
+exclude_regex = [".*_templ.go"]
+pre_cmd = ["templ generate"]
+send_interrupt = true
+stop_on_error = true
+cmd = "go build -o ./tmp/web dev_web.go"
+bin = "tmp/web"
+
+[proxy]
+enabled = true
+proxy_port = 8081
+app_port = 9092
diff --git a/.env.example b/.env.example
index fbe664d0..79768cef 100644
--- a/.env.example
+++ b/.env.example
@@ -33,6 +33,10 @@ SCHEDULER_CONCURRENT_WORKERS="5"
 PRIVATE_SERVER_ENABLED="true" # A private server can be used to access some managemenet endpoints
 PRIVATE_SERVER_PORT="9093"
 
+# Discord Invites
+PRIMARY_GUILD_INVITE_LINK="https://discord.gg/8PVq2qvafw"
+BOT_INVITE_LINK="https://discord.com/application-directory/1196247108215386142"
+
 # Misc configuration
 # This is not required for local deployment using compose. When deploying with Dokploy, this is the domain aftermath service will be available on.
 TRAEFIK_HOST="local.amth.one"
diff --git a/Taskfile.yaml b/Taskfile.yaml
index ade58543..394154d4 100644
--- a/Taskfile.yaml
+++ b/Taskfile.yaml
@@ -33,3 +33,7 @@ tasks:
     desc: Start a local dev server
     cmds:
       - air
+  dev-web: 
+    desc: Start a local web server for frontend only
+    cmds:
+      - air -c .air.web.toml
\ No newline at end of file
diff --git a/cmd/core/client.go b/cmd/core/client.go
index 3653c1d1..242ef1e0 100644
--- a/cmd/core/client.go
+++ b/cmd/core/client.go
@@ -3,15 +3,15 @@ package core
 import (
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/external/wargaming"
+	stats "github.com/cufee/aftermath/internal/stats/client/v1"
 	"github.com/cufee/aftermath/internal/stats/fetch/v1"
-	stats "github.com/cufee/aftermath/internal/stats/renderer/v1"
 	"golang.org/x/text/language"
 )
 
 var _ Client = &client{}
 
 type Client interface {
-	Render(locale language.Tag) stats.Renderer
+	Stats(locale language.Tag) stats.Client
 
 	Wargaming() wargaming.Client
 	Database() database.Client
@@ -36,8 +36,8 @@ func (c *client) Fetch() fetch.Client {
 	return c.fetch
 }
 
-func (c *client) Render(locale language.Tag) stats.Renderer {
-	return stats.NewRenderer(c.fetch, c.db, c.wargaming, locale)
+func (c *client) Stats(locale language.Tag) stats.Client {
+	return stats.NewClient(c.fetch, c.db, c.wargaming, locale)
 }
 
 func NewClient(fetch fetch.Client, wargaming wargaming.Client, database database.Client) *client {
diff --git a/cmd/discord/commands/interactions.go b/cmd/discord/commands/interactions.go
index 5d529612..a06720ae 100644
--- a/cmd/discord/commands/interactions.go
+++ b/cmd/discord/commands/interactions.go
@@ -12,9 +12,8 @@ import (
 	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/permissions"
 	"github.com/cufee/aftermath/internal/stats/fetch/v1"
-	render "github.com/cufee/aftermath/internal/stats/render/common/v1"
 
-	"github.com/cufee/aftermath/internal/stats/renderer/v1"
+	stats "github.com/cufee/aftermath/internal/stats/client/v1"
 
 	"github.com/pkg/errors"
 	"github.com/rs/zerolog/log"
@@ -54,11 +53,11 @@ func init() {
 					return ctx.Reply().Send("stats_refresh_interaction_error_expired")
 				}
 
-				var image renderer.Image
-				var meta renderer.Metadata
+				var image stats.Image
+				var meta stats.Metadata
 				switch interaction.Command {
 				case "stats":
-					img, mt, err := ctx.Core.Render(ctx.Locale).Period(context.Background(), interaction.Options.AccountID, interaction.Options.PeriodStart, render.WithBackground(interaction.Options.BackgroundImageURL))
+					img, mt, err := ctx.Core.Stats(ctx.Locale).PeriodImage(context.Background(), interaction.Options.AccountID, interaction.Options.PeriodStart, stats.WithBackgroundURL(interaction.Options.BackgroundImageURL))
 					if err != nil {
 						return ctx.Err(err)
 					}
@@ -66,9 +65,9 @@ func init() {
 					meta = mt
 
 				case "session":
-					img, mt, err := ctx.Core.Render(ctx.Locale).Session(context.Background(), interaction.Options.AccountID, interaction.Options.PeriodStart, render.WithBackground(interaction.Options.BackgroundImageURL))
+					img, mt, err := ctx.Core.Stats(ctx.Locale).SessionImage(context.Background(), interaction.Options.AccountID, interaction.Options.PeriodStart, stats.WithBackgroundURL(interaction.Options.BackgroundImageURL))
 					if err != nil {
-						if errors.Is(err, fetch.ErrSessionNotFound) || errors.Is(err, renderer.ErrAccountNotTracked) {
+						if errors.Is(err, fetch.ErrSessionNotFound) || errors.Is(err, stats.ErrAccountNotTracked) {
 							return ctx.Reply().Send("stats_refresh_interaction_error_expired")
 						}
 						return ctx.Err(err)
diff --git a/cmd/discord/commands/session.go b/cmd/discord/commands/session.go
index 2fe129a9..23a709db 100644
--- a/cmd/discord/commands/session.go
+++ b/cmd/discord/commands/session.go
@@ -11,9 +11,8 @@ import (
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/permissions"
+	stats "github.com/cufee/aftermath/internal/stats/client/v1"
 	"github.com/cufee/aftermath/internal/stats/fetch/v1"
-	render "github.com/cufee/aftermath/internal/stats/render/common/v1"
-	stats "github.com/cufee/aftermath/internal/stats/renderer/v1"
 	"github.com/pkg/errors"
 	"github.com/rs/zerolog/log"
 )
@@ -70,7 +69,7 @@ func init() {
 					}
 				}
 
-				image, meta, err := ctx.Core.Render(ctx.Locale).Session(context.Background(), accountID, options.PeriodStart, render.WithBackground(backgroundURL))
+				image, meta, err := ctx.Core.Stats(ctx.Locale).SessionImage(context.Background(), accountID, options.PeriodStart, stats.WithBackgroundURL(backgroundURL))
 				if err != nil {
 					if errors.Is(err, stats.ErrAccountNotTracked) || (errors.Is(err, fetch.ErrSessionNotFound) && options.Days < 1) {
 						return ctx.Reply().Send("session_error_account_was_not_tracked")
diff --git a/cmd/discord/commands/stats.go b/cmd/discord/commands/stats.go
index f2a7be15..3483ea2c 100644
--- a/cmd/discord/commands/stats.go
+++ b/cmd/discord/commands/stats.go
@@ -11,7 +11,7 @@ import (
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/permissions"
-	render "github.com/cufee/aftermath/internal/stats/render/common/v1"
+	stats "github.com/cufee/aftermath/internal/stats/client/v1"
 	"github.com/rs/zerolog/log"
 )
 
@@ -61,7 +61,7 @@ func init() {
 					// TODO: Get user background
 				}
 
-				image, meta, err := ctx.Core.Render(ctx.Locale).Period(context.Background(), accountID, options.PeriodStart, render.WithBackground(backgroundURL))
+				image, meta, err := ctx.Core.Stats(ctx.Locale).PeriodImage(context.Background(), accountID, options.PeriodStart, stats.WithBackgroundURL(backgroundURL))
 				if err != nil {
 					return ctx.Err(err)
 				}
diff --git a/cmd/frontend/assets/assets.go b/cmd/frontend/assets/assets.go
new file mode 100644
index 00000000..85f48bc9
--- /dev/null
+++ b/cmd/frontend/assets/assets.go
@@ -0,0 +1,3 @@
+package assets
+
+//go:generate go run gen.go
diff --git a/cmd/frontend/assets/gen.go b/cmd/frontend/assets/gen.go
new file mode 100644
index 00000000..5b233b97
--- /dev/null
+++ b/cmd/frontend/assets/gen.go
@@ -0,0 +1,56 @@
+//go:build ignore
+
+package main
+
+import (
+	"image/png"
+	"os"
+	"path/filepath"
+
+	"github.com/cufee/aftermath/cmd/frontend/assets"
+	"github.com/cufee/aftermath/internal/stats/render/common/v1"
+	"github.com/rs/zerolog/log"
+)
+
+func main() {
+	generateWN8Icons()
+}
+
+var wn8Tiers = []int{0, 1, 301, 451, 651, 901, 1201, 1601, 2001, 2451, 2901}
+
+func generateWN8Icons() {
+	log.Debug().Msg("generating wn8 image assets")
+
+	for _, tier := range wn8Tiers {
+		color := common.GetWN8Colors(float32(tier)).Background
+		if tier < 1 {
+			color = common.TextAlt
+		}
+		{
+			filename := assets.WN8IconFilename(float32(tier))
+			img := common.AftermathLogo(color, common.DefaultLogoOptions())
+			f, err := os.Create(filepath.Join("../public", "wn8", filename))
+			if err != nil {
+				panic(err)
+			}
+			err = png.Encode(f, img)
+			if err != nil {
+				panic(err)
+			}
+			f.Close()
+		}
+		{
+			filename := "small_" + assets.WN8IconFilename(float32(tier))
+			img := common.AftermathLogo(color, common.SmallLogoOptions())
+			f, err := os.Create(filepath.Join("../public", "wn8", filename))
+			if err != nil {
+				panic(err)
+			}
+			err = png.Encode(f, img)
+			if err != nil {
+				panic(err)
+			}
+			f.Close()
+		}
+	}
+}
diff --git a/cmd/frontend/assets/rating.go b/cmd/frontend/assets/rating.go
new file mode 100644
index 00000000..baeea494
--- /dev/null
+++ b/cmd/frontend/assets/rating.go
@@ -0,0 +1,11 @@
+package assets
+
+import (
+	"path/filepath"
+
+	"github.com/cufee/aftermath/internal/stats/render/common/v1"
+)
+
+func RatingIconPath(rating float32) string {
+	return filepath.Join("/assets", "rating", common.GetRatingIconName(rating)+".png")
+}
diff --git a/cmd/frontend/assets/wn8.go b/cmd/frontend/assets/wn8.go
new file mode 100644
index 00000000..9d8d2cc1
--- /dev/null
+++ b/cmd/frontend/assets/wn8.go
@@ -0,0 +1,24 @@
+package assets
+
+import (
+	"path/filepath"
+	"strings"
+
+	"github.com/cufee/aftermath/internal/stats/render/common/v1"
+)
+
+func WN8IconFilename(rating float32) string {
+	name := strings.ReplaceAll(strings.ToLower(common.GetWN8TierName(rating)), " ", "_")
+	if rating < 1 {
+		name = "invalid"
+	}
+	return name + ".png"
+}
+
+func WN8IconPath(rating float32) string {
+	return filepath.Join("/assets", "wn8", WN8IconFilename(rating))
+}
+
+func WN8IconPathSmall(rating float32) string {
+	return filepath.Join("/assets", "wn8", "small_"+WN8IconFilename(rating))
+}
diff --git a/cmd/frontend/components/logo.templ b/cmd/frontend/components/logo.templ
new file mode 100644
index 00000000..c4b602e8
--- /dev/null
+++ b/cmd/frontend/components/logo.templ
@@ -0,0 +1,7 @@
+package components
+
+import "fmt"
+
+templ Logo(size string) {
+	<div class="flex flex-row items-center pointer-events-none select-none cursor-inherit"><img draggable="false" src={ fmt.Sprintf("/assets/icon-%s.png", size) } alt="Aftermath"/></div>
+}
diff --git a/cmd/frontend/components/logo_templ.go b/cmd/frontend/components/logo_templ.go
new file mode 100644
index 00000000..fe08297b
--- /dev/null
+++ b/cmd/frontend/components/logo_templ.go
@@ -0,0 +1,50 @@
+// Code generated by templ - DO NOT EDIT.
+
+// templ: version: v0.2.696
+package components
+
+//lint:file-ignore SA4006 This context is only used if a nested component is present.
+
+import "github.com/a-h/templ"
+import "context"
+import "io"
+import "bytes"
+
+import "fmt"
+
+func Logo(size string) templ.Component {
+	return templ.ComponentFunc(func(ctx context.Context, templ_7745c5c3_W io.Writer) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templ_7745c5c3_W.(*bytes.Buffer)
+		if !templ_7745c5c3_IsBuffer {
+			templ_7745c5c3_Buffer = templ.GetBuffer()
+			defer templ.ReleaseBuffer(templ_7745c5c3_Buffer)
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var1 == nil {
+			templ_7745c5c3_Var1 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-row items-center pointer-events-none select-none cursor-inherit\"><img draggable=\"false\" src=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var2 string
+		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprintf("/assets/icon-%s.png", size))
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/logo.templ`, Line: 6, Col: 157}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\" alt=\"Aftermath\"></div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		if !templ_7745c5c3_IsBuffer {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteTo(templ_7745c5c3_W)
+		}
+		return templ_7745c5c3_Err
+	})
+}
diff --git a/cmd/frontend/components/widget/default.templ b/cmd/frontend/components/widget/default.templ
new file mode 100644
index 00000000..07ad5388
--- /dev/null
+++ b/cmd/frontend/components/widget/default.templ
@@ -0,0 +1,141 @@
+package widget
+
+import "fmt"
+import "github.com/cufee/aftermath/internal/stats/prepare/session/v1"
+import "github.com/cufee/aftermath/internal/stats/prepare/common/v1"
+import "github.com/cufee/aftermath/cmd/frontend/assets"
+import "github.com/cufee/aftermath/internal/stats/frame"
+
+type defaultWidget struct {
+	widget
+	vehicleCards []vehicleExtended
+}
+
+type vehicleExtended struct {
+	session.VehicleCard
+	wn8 frame.Value
+}
+
+func (v vehicleExtended) fromCard(card session.VehicleCard) vehicleExtended {
+	var wn8 frame.Value = frame.InvalidValue
+	for _, block := range card.Blocks {
+		if block.Tag == common.TagWN8 {
+			wn8 = block.Value
+			break
+		}
+	}
+
+	return vehicleExtended{card, wn8}
+}
+
+func (w widget) defaultWidget() templ.Component {
+	var vehicles []vehicleExtended
+	for i, card := range w.cards.Unrated.Vehicles {
+		if i >= w.unratedVehiclesLimit {
+			break
+		}
+		vehicles = append(vehicles, vehicleExtended{}.fromCard(card))
+	}
+
+	return defaultWidget{w, vehicles}.Render()
+}
+
+templ (w defaultWidget) Render() {
+	<div class="flex flex-col w-full gap-2 widget">
+		if w.showRatingOverview {
+			@w.overviewCard(w.cards.Rating.Overview)
+		}
+		if w.showUnratedOverview {
+			@w.overviewCard(w.cards.Unrated.Overview)
+		}
+		for _, card := range w.vehicleCards {
+			@w.vehicleCard(card)
+		}
+		if len(w.vehicleCards) > 0 {
+			@w.vehicleLegendCard(w.vehicleCards[0].Blocks)
+		}
+	</div>
+}
+
+templ (w defaultWidget) overviewCard(card session.OverviewCard) {
+	<div class="flex flex-col gap-1 card overview-card grow">
+		if w.overviewStyle.showTitle {
+			<span class="text-center text-gray-300 title">
+				{ card.Title }
+			</span>
+		}
+		<div class={ fmt.Sprintf("columns overview-columns grid grid-cols-%d gap-1 items-center bg-black rounded-xl bg-opacity-95 p-4", len(card.Blocks)) }>
+			for _, column := range card.Blocks {
+				@w.overviewColumn(column)
+			}
+		</div>
+	</div>
+}
+
+templ (w defaultWidget) vehicleCard(card vehicleExtended) {
+	<div class="flex flex-col gap-1 card vehicle-card grow bg-black rounded-lg bg-opacity-95 p-4">
+		if w.vehicleStyle.showTitle {
+			<div class="flex flex-row gap-2 justify-between">
+				<span class="text-gray-300 title">
+					{ card.Title }
+				</span>
+				<img src={ assets.WN8IconPathSmall(card.wn8.Float()) } class="w-5 h-5"/>
+			</div>
+		}
+		<div class={ fmt.Sprintf("blocks vehicle-blocks grid grid-cols-%d gap-1 items-center", len(card.Blocks)) }>
+			for _, block := range card.Blocks {
+				@w.block(block, w.vehicleStyle)
+			}
+		</div>
+	</div>
+}
+
+templ (w defaultWidget) vehicleLegendCard(blocks []common.StatsBlock[session.BlockData]) {
+	<div class="flex flex-col gap-1 card legend-card grow">
+		<div class={ fmt.Sprintf("blocks legend-blocks grid grid-cols-%d gap-1 items-center justify-center px-4", len(blocks)) }>
+			for _, block := range blocks {
+				<div class="bg-black rounded-full bg-opacity-95 m-auto px-3 py-1">
+					{ block.Label }
+				</div>
+			}
+		</div>
+	</div>
+}
+
+templ (w defaultWidget) overviewColumn(column session.OverviewColumn) {
+	if column.Flavor == session.BlockFlavorRating || column.Flavor == session.BlockFlavorWN8 {
+		@w.specialOverviewColumn(column)
+	} else {
+		<div class="flex flex-col items-center justify-center column overview-column gap-2">
+			for _, block := range column.Blocks {
+				@w.block(block, w.overviewStyle)
+			}
+		</div>
+	}
+}
+
+templ (w defaultWidget) specialOverviewColumn(column session.OverviewColumn) {
+	<div class="flex flex-col items-center justify-center column overview-column special-overview-column gap-1">
+		for _, block := range column.Blocks {
+			if column.Flavor == session.BlockFlavorRating {
+				<img src={ assets.RatingIconPath(block.Value.Float()) } class="w-16 h-16"/>
+			}
+			if column.Flavor == session.BlockFlavorWN8 {
+				<img src={ assets.WN8IconPath(block.Value.Float()) } class="w-18 h-18"/>
+			}
+			@w.block(block, w.overviewStyle)
+		}
+	</div>
+}
+
+templ (w defaultWidget) block(block common.StatsBlock[session.BlockData], style styleOptions) {
+	<div class="flex flex-col items-center justify-between block">
+		<span class="text-2xl text-white">{ block.Data.Session.String() }</span>
+		if style.showCareer {
+			<span class="text-xl text-gray-300">{ block.Data.Career.String() }</span>
+		}
+		if style.showLabel {
+			<span class="text-sm text-gray-600">{ block.Label }</span>
+		}
+	</div>
+}
diff --git a/cmd/frontend/components/widget/default_templ.go b/cmd/frontend/components/widget/default_templ.go
new file mode 100644
index 00000000..23a95c88
--- /dev/null
+++ b/cmd/frontend/components/widget/default_templ.go
@@ -0,0 +1,535 @@
+// Code generated by templ - DO NOT EDIT.
+
+// templ: version: v0.2.696
+package widget
+
+//lint:file-ignore SA4006 This context is only used if a nested component is present.
+
+import "github.com/a-h/templ"
+import "context"
+import "io"
+import "bytes"
+
+import "fmt"
+import "github.com/cufee/aftermath/internal/stats/prepare/session/v1"
+import "github.com/cufee/aftermath/internal/stats/prepare/common/v1"
+import "github.com/cufee/aftermath/cmd/frontend/assets"
+import "github.com/cufee/aftermath/internal/stats/frame"
+
+type defaultWidget struct {
+	widget
+	vehicleCards []vehicleExtended
+}
+
+type vehicleExtended struct {
+	session.VehicleCard
+	wn8 frame.Value
+}
+
+func (v vehicleExtended) fromCard(card session.VehicleCard) vehicleExtended {
+	var wn8 frame.Value = frame.InvalidValue
+	for _, block := range card.Blocks {
+		if block.Tag == common.TagWN8 {
+			wn8 = block.Value
+			break
+		}
+	}
+
+	return vehicleExtended{card, wn8}
+}
+
+func (w widget) defaultWidget() templ.Component {
+	var vehicles []vehicleExtended
+	for i, card := range w.cards.Unrated.Vehicles {
+		if i >= w.unratedVehiclesLimit {
+			break
+		}
+		vehicles = append(vehicles, vehicleExtended{}.fromCard(card))
+	}
+
+	return defaultWidget{w, vehicles}.Render()
+}
+
+func (w defaultWidget) Render() templ.Component {
+	return templ.ComponentFunc(func(ctx context.Context, templ_7745c5c3_W io.Writer) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templ_7745c5c3_W.(*bytes.Buffer)
+		if !templ_7745c5c3_IsBuffer {
+			templ_7745c5c3_Buffer = templ.GetBuffer()
+			defer templ.ReleaseBuffer(templ_7745c5c3_Buffer)
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var1 == nil {
+			templ_7745c5c3_Var1 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-col w-full gap-2 widget\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		if w.showRatingOverview {
+			templ_7745c5c3_Err = w.overviewCard(w.cards.Rating.Overview).Render(ctx, templ_7745c5c3_Buffer)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		if w.showUnratedOverview {
+			templ_7745c5c3_Err = w.overviewCard(w.cards.Unrated.Overview).Render(ctx, templ_7745c5c3_Buffer)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		for _, card := range w.vehicleCards {
+			templ_7745c5c3_Err = w.vehicleCard(card).Render(ctx, templ_7745c5c3_Buffer)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		if len(w.vehicleCards) > 0 {
+			templ_7745c5c3_Err = w.vehicleLegendCard(w.vehicleCards[0].Blocks).Render(ctx, templ_7745c5c3_Buffer)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		if !templ_7745c5c3_IsBuffer {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteTo(templ_7745c5c3_W)
+		}
+		return templ_7745c5c3_Err
+	})
+}
+
+func (w defaultWidget) overviewCard(card session.OverviewCard) templ.Component {
+	return templ.ComponentFunc(func(ctx context.Context, templ_7745c5c3_W io.Writer) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templ_7745c5c3_W.(*bytes.Buffer)
+		if !templ_7745c5c3_IsBuffer {
+			templ_7745c5c3_Buffer = templ.GetBuffer()
+			defer templ.ReleaseBuffer(templ_7745c5c3_Buffer)
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var2 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var2 == nil {
+			templ_7745c5c3_Var2 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-col gap-1 card overview-card grow\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		if w.overviewStyle.showTitle {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<span class=\"text-center text-gray-300 title\">")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			var templ_7745c5c3_Var3 string
+			templ_7745c5c3_Var3, templ_7745c5c3_Err = templ.JoinStringErrs(card.Title)
+			if templ_7745c5c3_Err != nil {
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 64, Col: 16}
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var3))
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</span>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		var templ_7745c5c3_Var4 = []any{fmt.Sprintf("columns overview-columns grid grid-cols-%d gap-1 items-center bg-black rounded-xl bg-opacity-95 p-4", len(card.Blocks))}
+		templ_7745c5c3_Err = templ.RenderCSSItems(ctx, templ_7745c5c3_Buffer, templ_7745c5c3_Var4...)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var5 string
+		templ_7745c5c3_Var5, templ_7745c5c3_Err = templ.JoinStringErrs(templ.CSSClasses(templ_7745c5c3_Var4).String())
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 1, Col: 0}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var5))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		for _, column := range card.Blocks {
+			templ_7745c5c3_Err = w.overviewColumn(column).Render(ctx, templ_7745c5c3_Buffer)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		if !templ_7745c5c3_IsBuffer {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteTo(templ_7745c5c3_W)
+		}
+		return templ_7745c5c3_Err
+	})
+}
+
+func (w defaultWidget) vehicleCard(card vehicleExtended) templ.Component {
+	return templ.ComponentFunc(func(ctx context.Context, templ_7745c5c3_W io.Writer) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templ_7745c5c3_W.(*bytes.Buffer)
+		if !templ_7745c5c3_IsBuffer {
+			templ_7745c5c3_Buffer = templ.GetBuffer()
+			defer templ.ReleaseBuffer(templ_7745c5c3_Buffer)
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var6 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var6 == nil {
+			templ_7745c5c3_Var6 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-col gap-1 card vehicle-card grow bg-black rounded-lg bg-opacity-95 p-4\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		if w.vehicleStyle.showTitle {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-row gap-2 justify-between\"><span class=\"text-gray-300 title\">")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			var templ_7745c5c3_Var7 string
+			templ_7745c5c3_Var7, templ_7745c5c3_Err = templ.JoinStringErrs(card.Title)
+			if templ_7745c5c3_Err != nil {
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 80, Col: 17}
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var7))
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</span> <img src=\"")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			var templ_7745c5c3_Var8 string
+			templ_7745c5c3_Var8, templ_7745c5c3_Err = templ.JoinStringErrs(assets.WN8IconPathSmall(card.wn8.Float()))
+			if templ_7745c5c3_Err != nil {
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 82, Col: 56}
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var8))
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\" class=\"w-5 h-5\"></div>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		var templ_7745c5c3_Var9 = []any{fmt.Sprintf("blocks vehicle-blocks grid grid-cols-%d gap-1 items-center", len(card.Blocks))}
+		templ_7745c5c3_Err = templ.RenderCSSItems(ctx, templ_7745c5c3_Buffer, templ_7745c5c3_Var9...)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var10 string
+		templ_7745c5c3_Var10, templ_7745c5c3_Err = templ.JoinStringErrs(templ.CSSClasses(templ_7745c5c3_Var9).String())
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 1, Col: 0}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var10))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		for _, block := range card.Blocks {
+			templ_7745c5c3_Err = w.block(block, w.vehicleStyle).Render(ctx, templ_7745c5c3_Buffer)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		if !templ_7745c5c3_IsBuffer {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteTo(templ_7745c5c3_W)
+		}
+		return templ_7745c5c3_Err
+	})
+}
+
+func (w defaultWidget) vehicleLegendCard(blocks []common.StatsBlock[session.BlockData]) templ.Component {
+	return templ.ComponentFunc(func(ctx context.Context, templ_7745c5c3_W io.Writer) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templ_7745c5c3_W.(*bytes.Buffer)
+		if !templ_7745c5c3_IsBuffer {
+			templ_7745c5c3_Buffer = templ.GetBuffer()
+			defer templ.ReleaseBuffer(templ_7745c5c3_Buffer)
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var11 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var11 == nil {
+			templ_7745c5c3_Var11 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-col gap-1 card legend-card grow\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var12 = []any{fmt.Sprintf("blocks legend-blocks grid grid-cols-%d gap-1 items-center justify-center px-4", len(blocks))}
+		templ_7745c5c3_Err = templ.RenderCSSItems(ctx, templ_7745c5c3_Buffer, templ_7745c5c3_Var12...)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var13 string
+		templ_7745c5c3_Var13, templ_7745c5c3_Err = templ.JoinStringErrs(templ.CSSClasses(templ_7745c5c3_Var12).String())
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 1, Col: 0}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var13))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		for _, block := range blocks {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"bg-black rounded-full bg-opacity-95 m-auto px-3 py-1\">")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			var templ_7745c5c3_Var14 string
+			templ_7745c5c3_Var14, templ_7745c5c3_Err = templ.JoinStringErrs(block.Label)
+			if templ_7745c5c3_Err != nil {
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 98, Col: 18}
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var14))
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		if !templ_7745c5c3_IsBuffer {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteTo(templ_7745c5c3_W)
+		}
+		return templ_7745c5c3_Err
+	})
+}
+
+func (w defaultWidget) overviewColumn(column session.OverviewColumn) templ.Component {
+	return templ.ComponentFunc(func(ctx context.Context, templ_7745c5c3_W io.Writer) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templ_7745c5c3_W.(*bytes.Buffer)
+		if !templ_7745c5c3_IsBuffer {
+			templ_7745c5c3_Buffer = templ.GetBuffer()
+			defer templ.ReleaseBuffer(templ_7745c5c3_Buffer)
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var15 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var15 == nil {
+			templ_7745c5c3_Var15 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		if column.Flavor == session.BlockFlavorRating || column.Flavor == session.BlockFlavorWN8 {
+			templ_7745c5c3_Err = w.specialOverviewColumn(column).Render(ctx, templ_7745c5c3_Buffer)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		} else {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-col items-center justify-center column overview-column gap-2\">")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			for _, block := range column.Blocks {
+				templ_7745c5c3_Err = w.block(block, w.overviewStyle).Render(ctx, templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err != nil {
+					return templ_7745c5c3_Err
+				}
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		if !templ_7745c5c3_IsBuffer {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteTo(templ_7745c5c3_W)
+		}
+		return templ_7745c5c3_Err
+	})
+}
+
+func (w defaultWidget) specialOverviewColumn(column session.OverviewColumn) templ.Component {
+	return templ.ComponentFunc(func(ctx context.Context, templ_7745c5c3_W io.Writer) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templ_7745c5c3_W.(*bytes.Buffer)
+		if !templ_7745c5c3_IsBuffer {
+			templ_7745c5c3_Buffer = templ.GetBuffer()
+			defer templ.ReleaseBuffer(templ_7745c5c3_Buffer)
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var16 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var16 == nil {
+			templ_7745c5c3_Var16 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-col items-center justify-center column overview-column special-overview-column gap-1\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		for _, block := range column.Blocks {
+			if column.Flavor == session.BlockFlavorRating {
+				_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<img src=\"")
+				if templ_7745c5c3_Err != nil {
+					return templ_7745c5c3_Err
+				}
+				var templ_7745c5c3_Var17 string
+				templ_7745c5c3_Var17, templ_7745c5c3_Err = templ.JoinStringErrs(assets.RatingIconPath(block.Value.Float()))
+				if templ_7745c5c3_Err != nil {
+					return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 121, Col: 57}
+				}
+				_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var17))
+				if templ_7745c5c3_Err != nil {
+					return templ_7745c5c3_Err
+				}
+				_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\" class=\"w-16 h-16\">")
+				if templ_7745c5c3_Err != nil {
+					return templ_7745c5c3_Err
+				}
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" ")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			if column.Flavor == session.BlockFlavorWN8 {
+				_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<img src=\"")
+				if templ_7745c5c3_Err != nil {
+					return templ_7745c5c3_Err
+				}
+				var templ_7745c5c3_Var18 string
+				templ_7745c5c3_Var18, templ_7745c5c3_Err = templ.JoinStringErrs(assets.WN8IconPath(block.Value.Float()))
+				if templ_7745c5c3_Err != nil {
+					return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 124, Col: 54}
+				}
+				_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var18))
+				if templ_7745c5c3_Err != nil {
+					return templ_7745c5c3_Err
+				}
+				_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\" class=\"w-18 h-18\">")
+				if templ_7745c5c3_Err != nil {
+					return templ_7745c5c3_Err
+				}
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" ")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			templ_7745c5c3_Err = w.block(block, w.overviewStyle).Render(ctx, templ_7745c5c3_Buffer)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		if !templ_7745c5c3_IsBuffer {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteTo(templ_7745c5c3_W)
+		}
+		return templ_7745c5c3_Err
+	})
+}
+
+func (w defaultWidget) block(block common.StatsBlock[session.BlockData], style styleOptions) templ.Component {
+	return templ.ComponentFunc(func(ctx context.Context, templ_7745c5c3_W io.Writer) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templ_7745c5c3_W.(*bytes.Buffer)
+		if !templ_7745c5c3_IsBuffer {
+			templ_7745c5c3_Buffer = templ.GetBuffer()
+			defer templ.ReleaseBuffer(templ_7745c5c3_Buffer)
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var19 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var19 == nil {
+			templ_7745c5c3_Var19 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-col items-center justify-between block\"><span class=\"text-2xl text-white\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var20 string
+		templ_7745c5c3_Var20, templ_7745c5c3_Err = templ.JoinStringErrs(block.Data.Session.String())
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 133, Col: 65}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var20))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</span> ")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		if style.showCareer {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<span class=\"text-xl text-gray-300\">")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			var templ_7745c5c3_Var21 string
+			templ_7745c5c3_Var21, templ_7745c5c3_Err = templ.JoinStringErrs(block.Data.Career.String())
+			if templ_7745c5c3_Err != nil {
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 135, Col: 67}
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var21))
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</span> ")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		if style.showLabel {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<span class=\"text-sm text-gray-600\">")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			var templ_7745c5c3_Var22 string
+			templ_7745c5c3_Var22, templ_7745c5c3_Err = templ.JoinStringErrs(block.Label)
+			if templ_7745c5c3_Err != nil {
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 138, Col: 52}
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var22))
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</span>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		if !templ_7745c5c3_IsBuffer {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteTo(templ_7745c5c3_W)
+		}
+		return templ_7745c5c3_Err
+	})
+}
diff --git a/cmd/frontend/components/widget/widget.templ b/cmd/frontend/components/widget/widget.templ
new file mode 100644
index 00000000..ac781198
--- /dev/null
+++ b/cmd/frontend/components/widget/widget.templ
@@ -0,0 +1,124 @@
+package widget
+
+import "github.com/cufee/aftermath/cmd/frontend/logic"
+import "fmt"
+import "github.com/cufee/aftermath/internal/database/models"
+import prepare "github.com/cufee/aftermath/internal/stats/prepare/session/v1"
+
+type WidgetFlavor string
+
+const (
+	// WidgetFlavorTicker WidgetFlavor = "ticker"
+	WidgetFlavorDefault WidgetFlavor = "default"
+)
+
+type WidgetOption func(*widget)
+
+func WithAutoReload() WidgetOption {
+	return func(w *widget) { w.autoReload = true }
+}
+func WithVehicleLimit(limit int) WidgetOption {
+	return func(w *widget) { w.unratedVehiclesLimit = limit }
+}
+func WithRatingOverview(shown bool) WidgetOption {
+	return func(w *widget) { w.showRatingOverview = shown }
+}
+func WithUnratedOverview(shown bool) WidgetOption {
+	return func(w *widget) { w.showUnratedOverview = shown }
+}
+func WithFlavor(flavor WidgetFlavor) WidgetOption {
+	return func(w *widget) { w.flavor = flavor }
+}
+
+func Widget(account models.Account, cards prepare.Cards, options ...WidgetOption) templ.Component {
+	widget := widget{
+		cards:         cards,
+		account:       account,
+		flavor:        WidgetFlavorDefault,
+		autoReload:    false,
+		vehicleStyle:  styleOptions{showTitle: true},
+		overviewStyle: styleOptions{showLabel: true},
+
+		showRatingOverview:   true,
+		showUnratedOverview:  true,
+		unratedVehiclesLimit: 3,
+	}
+	for _, apply := range options {
+		apply(&widget)
+	}
+
+	return widget.Render()
+}
+
+type styleOptions struct {
+	showTitle  bool
+	showCareer bool
+	showLabel  bool
+}
+
+type widget struct {
+	cards   prepare.Cards
+	account models.Account
+
+	vehicleStyle  styleOptions
+	overviewStyle styleOptions
+
+	showRatingOverview   bool
+	showUnratedOverview  bool
+	unratedVehiclesLimit int
+
+	flavor     WidgetFlavor
+	autoReload bool
+}
+
+templ (w widget) Render() {
+	<head>
+		<title>Aftermath - { w.account.Nickname }</title>
+		<meta property="og:type" content="website"/>
+		<meta property="og:title" content="Aftermath - Streaming Widget"/>
+		<meta property="og:image" content="https://amth.one/assets/og-widget.jpg"/>
+		<meta property="og:description" content={ fmt.Sprintf("Aftermath streaming widget for %s [%s]", w.account.Nickname, w.account.Realm) }/>
+		<meta name="twitter:card" content="summary_large_image"/>
+		<meta name="twitter:title" content="Aftermath - Streaming Widget"/>
+		<meta name="twitter:image:alt" content="Aftermath Streaming Widget"/>
+		<meta name="twitter:image" content="https://amth.one/assets/og-widget.jpg"/>
+		<meta name="twitter:description" content={ fmt.Sprintf("Aftermath streaming widget for %s [%s]", w.account.Nickname, w.account.Realm) }/>
+	</head>
+	<div class="text-nowrap whitespace-nowrap min-w-max" id="widget-container">
+		switch w.flavor {
+			default:
+				@w.defaultWidget()
+		}
+		if w.autoReload {
+			@logic.EmbedMinifiedScript(widgetRefresh(w.account.Realm, w.account.ID, w.account.LastBattleTime.Unix()), w.account.Realm, w.account.ID, w.account.LastBattleTime.Unix())
+		}
+	</div>
+}
+
+script widgetRefresh(realm string, accountID string, lastBattle int64) {
+  let apiHost = ""
+  switch (realm.toLowerCase()) {
+    case 'na':
+      apiHost = "wotblitz.com"
+      break;
+    case 'eu':
+      apiHost = "wotblitz.eu"
+      break;
+    case 'as':
+      apiHost = "wotblitz.asia"
+      break;
+    default:
+      throw new Error("Unknown realm: " + realm)
+  }
+  const refresh = () => {
+    fetch(`https://api.${apiHost}/wotb/account/info/?application_id=f44aa6f863c9327c63ba26be3db0d07f&account_id=${accountID}&fields=last_battle_time`)
+      .then(response => response.json())
+      .then(data => {
+        if (data.data[accountID.toString()].last_battle_time > lastBattle) {
+          location.reload()
+        }
+      })
+      .catch(error => { console.error(error); setTimeout(()=>location.reload(), 10000) })
+  }
+  setInterval(refresh, 5000)
+}
diff --git a/cmd/frontend/components/widget/widget_templ.go b/cmd/frontend/components/widget/widget_templ.go
new file mode 100644
index 00000000..33366abe
--- /dev/null
+++ b/cmd/frontend/components/widget/widget_templ.go
@@ -0,0 +1,196 @@
+// Code generated by templ - DO NOT EDIT.
+
+// templ: version: v0.2.696
+package widget
+
+//lint:file-ignore SA4006 This context is only used if a nested component is present.
+
+import "github.com/a-h/templ"
+import "context"
+import "io"
+import "bytes"
+
+import "github.com/cufee/aftermath/cmd/frontend/logic"
+import "fmt"
+import "github.com/cufee/aftermath/internal/database/models"
+import prepare "github.com/cufee/aftermath/internal/stats/prepare/session/v1"
+
+type WidgetFlavor string
+
+const (
+	// WidgetFlavorTicker WidgetFlavor = "ticker"
+	WidgetFlavorDefault WidgetFlavor = "default"
+)
+
+type WidgetOption func(*widget)
+
+func WithAutoReload() WidgetOption {
+	return func(w *widget) { w.autoReload = true }
+}
+func WithVehicleLimit(limit int) WidgetOption {
+	return func(w *widget) { w.unratedVehiclesLimit = limit }
+}
+func WithRatingOverview(shown bool) WidgetOption {
+	return func(w *widget) { w.showRatingOverview = shown }
+}
+func WithUnratedOverview(shown bool) WidgetOption {
+	return func(w *widget) { w.showUnratedOverview = shown }
+}
+func WithFlavor(flavor WidgetFlavor) WidgetOption {
+	return func(w *widget) { w.flavor = flavor }
+}
+
+func Widget(account models.Account, cards prepare.Cards, options ...WidgetOption) templ.Component {
+	widget := widget{
+		cards:         cards,
+		account:       account,
+		flavor:        WidgetFlavorDefault,
+		autoReload:    false,
+		vehicleStyle:  styleOptions{showTitle: true},
+		overviewStyle: styleOptions{showLabel: true},
+
+		showRatingOverview:   true,
+		showUnratedOverview:  true,
+		unratedVehiclesLimit: 3,
+	}
+	for _, apply := range options {
+		apply(&widget)
+	}
+
+	return widget.Render()
+}
+
+type styleOptions struct {
+	showTitle  bool
+	showCareer bool
+	showLabel  bool
+}
+
+type widget struct {
+	cards   prepare.Cards
+	account models.Account
+
+	vehicleStyle  styleOptions
+	overviewStyle styleOptions
+
+	showRatingOverview   bool
+	showUnratedOverview  bool
+	unratedVehiclesLimit int
+
+	flavor     WidgetFlavor
+	autoReload bool
+}
+
+func (w widget) Render() templ.Component {
+	return templ.ComponentFunc(func(ctx context.Context, templ_7745c5c3_W io.Writer) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templ_7745c5c3_W.(*bytes.Buffer)
+		if !templ_7745c5c3_IsBuffer {
+			templ_7745c5c3_Buffer = templ.GetBuffer()
+			defer templ.ReleaseBuffer(templ_7745c5c3_Buffer)
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var1 == nil {
+			templ_7745c5c3_Var1 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<head><title>Aftermath - ")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var2 string
+		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(w.account.Nickname)
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/widget.templ`, Line: 76, Col: 41}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</title><meta property=\"og:type\" content=\"website\"><meta property=\"og:title\" content=\"Aftermath - Streaming Widget\"><meta property=\"og:image\" content=\"https://amth.one/assets/og-widget.jpg\"><meta property=\"og:description\" content=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var3 string
+		templ_7745c5c3_Var3, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprintf("Aftermath streaming widget for %s [%s]", w.account.Nickname, w.account.Realm))
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/widget.templ`, Line: 80, Col: 134}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var3))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><meta name=\"twitter:card\" content=\"summary_large_image\"><meta name=\"twitter:title\" content=\"Aftermath - Streaming Widget\"><meta name=\"twitter:image:alt\" content=\"Aftermath Streaming Widget\"><meta name=\"twitter:image\" content=\"https://amth.one/assets/og-widget.jpg\"><meta name=\"twitter:description\" content=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var4 string
+		templ_7745c5c3_Var4, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprintf("Aftermath streaming widget for %s [%s]", w.account.Nickname, w.account.Realm))
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/widget.templ`, Line: 85, Col: 135}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var4))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"></head><div class=\"text-nowrap whitespace-nowrap min-w-max\" id=\"widget-container\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		switch w.flavor {
+		default:
+			templ_7745c5c3_Err = w.defaultWidget().Render(ctx, templ_7745c5c3_Buffer)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		if w.autoReload {
+			templ_7745c5c3_Err = logic.EmbedMinifiedScript(widgetRefresh(w.account.Realm, w.account.ID, w.account.LastBattleTime.Unix()), w.account.Realm, w.account.ID, w.account.LastBattleTime.Unix()).Render(ctx, templ_7745c5c3_Buffer)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		if !templ_7745c5c3_IsBuffer {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteTo(templ_7745c5c3_W)
+		}
+		return templ_7745c5c3_Err
+	})
+}
+
+func widgetRefresh(realm string, accountID string, lastBattle int64) templ.ComponentScript {
+	return templ.ComponentScript{
+		Name: `__templ_widgetRefresh_731f`,
+		Function: `function __templ_widgetRefresh_731f(realm, accountID, lastBattle){let apiHost = ""
+  switch (realm.toLowerCase()) {
+    case 'na':
+      apiHost = "wotblitz.com"
+      break;
+    case 'eu':
+      apiHost = "wotblitz.eu"
+      break;
+    case 'as':
+      apiHost = "wotblitz.asia"
+      break;
+    default:
+      throw new Error("Unknown realm: " + realm)
+  }
+  const refresh = () => {
+    fetch(` + "`" + `https://api.${apiHost}/wotb/account/info/?application_id=f44aa6f863c9327c63ba26be3db0d07f&account_id=${accountID}&fields=last_battle_time` + "`" + `)
+      .then(response => response.json())
+      .then(data => {
+        if (data.data[accountID.toString()].last_battle_time > lastBattle) {
+          location.reload()
+        }
+      })
+      .catch(error => { console.error(error); setTimeout(()=>location.reload(), 10000) })
+  }
+  setInterval(refresh, 5000)
+}`,
+		Call:       templ.SafeScript(`__templ_widgetRefresh_731f`, realm, accountID, lastBattle),
+		CallInline: templ.SafeScriptInline(`__templ_widgetRefresh_731f`, realm, accountID, lastBattle),
+	}
+}
diff --git a/cmd/frontend/handler/context.go b/cmd/frontend/handler/context.go
new file mode 100644
index 00000000..c6b39e94
--- /dev/null
+++ b/cmd/frontend/handler/context.go
@@ -0,0 +1,100 @@
+package handler
+
+import (
+	"context"
+	"net/http"
+	"net/url"
+	"strings"
+
+	"github.com/a-h/templ"
+	"github.com/cufee/aftermath/cmd/core"
+	"github.com/rs/zerolog/log"
+)
+
+type Renderable interface {
+	Render(ctx *Context) error
+}
+
+type Context struct {
+	core.Client
+	context.Context
+
+	w http.ResponseWriter
+	r *http.Request
+}
+
+func (ctx *Context) Req() *http.Request {
+	return ctx.r
+}
+
+func (ctx *Context) Error(err error, context ...string) error {
+
+	query := make(url.Values)
+	if err != nil {
+		query.Set("message", err.Error())
+	}
+	if len(context) > 1 {
+		log.Err(err).Msg("error while rendering") // end user does not get any context, so we log the error instead
+		query.Set("message", strings.Join(context, ", "))
+	}
+
+	http.Redirect(ctx.w, ctx.r, "/error?"+query.Encode(), http.StatusTemporaryRedirect)
+	return nil // this would never cause an error
+}
+
+func (ctx *Context) SetStatus(code int) {
+	ctx.w.WriteHeader(code)
+}
+
+func newContext(core core.Client, w http.ResponseWriter, r *http.Request) *Context {
+	return &Context{core, r.Context(), w, r}
+}
+
+type Layout func(ctx *Context, children ...templ.Component) (templ.Component, error)
+
+type Partial func(ctx *Context) (templ.Component, error)
+
+func (partial Partial) Render(ctx *Context) error {
+	content, err := partial(ctx)
+	if err != nil {
+		return ctx.Error(err)
+	}
+
+	err = content.Render(ctx.Context, ctx.w)
+	if err != nil {
+		return ctx.Error(err)
+	}
+
+	return nil
+}
+
+type Page func(ctx *Context) (Layout, templ.Component, error)
+
+func (page Page) Render(ctx *Context) error {
+	layout, body, err := page(ctx)
+	if err != nil {
+		return ctx.Error(err, "failed to render the page")
+	}
+
+	content, err := layout(ctx, body)
+	if err != nil {
+		return ctx.Error(err, "failed to render the layout")
+	}
+
+	err = content.Render(ctx.Context, ctx.w)
+	if err != nil {
+		return ctx.Error(err, "failed to render content")
+	}
+
+	return nil
+}
+
+func Handler(core core.Client, content Renderable) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		err := content.Render(newContext(core, w, r))
+		if err != nil {
+			// this should never be the case, we return an error to make early returns more convenient
+			log.Err(err).Msg("handler failed to render, this should never happen")
+		}
+	}
+}
diff --git a/cmd/frontend/handlers.go b/cmd/frontend/handlers.go
new file mode 100644
index 00000000..f0f3d89c
--- /dev/null
+++ b/cmd/frontend/handlers.go
@@ -0,0 +1,75 @@
+package frontend
+
+import (
+	"embed"
+	"io/fs"
+	"net/http"
+	"path/filepath"
+
+	"github.com/cufee/aftermath/cmd/core"
+	"github.com/cufee/aftermath/cmd/core/server"
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/cmd/frontend/routes"
+	"github.com/cufee/aftermath/cmd/frontend/routes/widget"
+	"github.com/pkg/errors"
+)
+
+//go:embed public
+var publicFS embed.FS
+
+/*
+Returns a slice of all handlers registered by the frontend
+*/
+func Handlers(core core.Client) ([]server.Handler, error) {
+	assetsFS, err := fs.Sub(publicFS, "public")
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to get embedded assets")
+	}
+
+	// https://go.dev/blog/routing-enhancements
+	return []server.Handler{
+		// assets
+		{
+			Path: "GET /assets/{$}",
+			Func: redirect("/"),
+		},
+		{
+			Path: "GET /assets/{_...}",
+			Func: http.StripPrefix("/assets/", http.FileServerFS(assetsFS)).ServeHTTP,
+		},
+		// wildcard to catch all invalid requests
+		{
+			Path: "GET /{pathname...}",
+			Func: handler.Handler(core, routes.ErrorNotFound),
+		},
+		// common routes
+		{
+			Path: get("/"),
+			Func: handler.Handler(core, routes.Index),
+		},
+		{
+			Path: get("/error"),
+			Func: handler.Handler(core, routes.GenericError),
+		},
+		// widget
+		{
+			Path: get("/widget/{accountId}"),
+			Func: handler.Handler(core, widget.ConfigureWidget),
+		},
+		{
+			Path: get("/widget/{accountId}/live"),
+			Func: handler.Handler(core, widget.LiveWidget),
+		},
+		// app routes
+		//
+	}, nil
+}
+
+func get(path string) string {
+	// we add the suffix in order to route past the wildcard handler correctly
+	return "GET " + filepath.Join(path, "{$}")
+}
+
+func redirect(path string) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) { http.Redirect(w, r, path, http.StatusPermanentRedirect) }
+}
diff --git a/cmd/frontend/layouts/main.templ b/cmd/frontend/layouts/main.templ
new file mode 100644
index 00000000..6a10ee55
--- /dev/null
+++ b/cmd/frontend/layouts/main.templ
@@ -0,0 +1,58 @@
+package layouts
+
+import (
+	"os"
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+)
+
+var appName = os.Getenv("WEBAPP_NAME")
+
+var Main handler.Layout = func(ctx *handler.Context, children ...templ.Component) (templ.Component, error) {
+	return main(children...), nil
+}
+
+templ main(children ...templ.Component) {
+	<!DOCTYPE html>
+	<html lang="en" data-theme="dark">
+		<head>
+			<meta charset="utf-8"/>
+			<meta name="color-scheme" content="light"/>
+			<meta name="viewport" content="width=device-width, initial-scale=1"/>
+			<link href="https://cdn.jsdelivr.net/npm/daisyui@4.11.1/dist/full.min.css" rel="stylesheet" type="text/css"/>
+			<script src="https://unpkg.com/htmx.org@1.9.12"></script>
+			<script src="https://unpkg.com/htmx.org/dist/ext/head-support.js"></script>
+			<script src="https://unpkg.com/htmx.org@1.9.12/dist/ext/multi-swap.js"></script>
+			<script src="https://cdn.tailwindcss.com"></script>
+			<script>
+				tailwind.config = {
+					theme: {
+						borderRadius: {
+							"sm": "10px",
+							"md": "15px",
+							"lg": "20px",
+							"xl": "25px",
+							'full': '9999px',
+						}
+					}
+				}
+			</script>
+			<title>{ appName }</title>
+		</head>
+		<body hx-ext="multi-swap,head-support">
+			<main class="mx-auto min-h-screen max-w-7xl p-2 flex flex-col gap-2 underline-offset-4">
+				for _, render := range children {
+					@render
+				}
+			</main>
+			<script>
+				// enable swap on 422, this status code is used for validation errors and returns error messages bound to elements
+				document.body.addEventListener('htmx:beforeOnLoad', function (evt) {
+						if (evt.detail.xhr.status === 422) {
+								evt.detail.shouldSwap = true;
+								evt.detail.isError = false;
+						}
+				});
+			</script>
+		</body>
+	</html>
+}
diff --git a/cmd/frontend/layouts/main_templ.go b/cmd/frontend/layouts/main_templ.go
new file mode 100644
index 00000000..3b602fb6
--- /dev/null
+++ b/cmd/frontend/layouts/main_templ.go
@@ -0,0 +1,69 @@
+// Code generated by templ - DO NOT EDIT.
+
+// templ: version: v0.2.696
+package layouts
+
+//lint:file-ignore SA4006 This context is only used if a nested component is present.
+
+import "github.com/a-h/templ"
+import "context"
+import "io"
+import "bytes"
+
+import (
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"os"
+)
+
+var appName = os.Getenv("WEBAPP_NAME")
+
+var Main handler.Layout = func(ctx *handler.Context, children ...templ.Component) (templ.Component, error) {
+	return main(children...), nil
+}
+
+func main(children ...templ.Component) templ.Component {
+	return templ.ComponentFunc(func(ctx context.Context, templ_7745c5c3_W io.Writer) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templ_7745c5c3_W.(*bytes.Buffer)
+		if !templ_7745c5c3_IsBuffer {
+			templ_7745c5c3_Buffer = templ.GetBuffer()
+			defer templ.ReleaseBuffer(templ_7745c5c3_Buffer)
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var1 == nil {
+			templ_7745c5c3_Var1 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<!doctype html><html lang=\"en\" data-theme=\"dark\"><head><meta charset=\"utf-8\"><meta name=\"color-scheme\" content=\"light\"><meta name=\"viewport\" content=\"width=device-width, initial-scale=1\"><link href=\"https://cdn.jsdelivr.net/npm/daisyui@4.11.1/dist/full.min.css\" rel=\"stylesheet\" type=\"text/css\"><script src=\"https://unpkg.com/htmx.org@1.9.12\"></script><script src=\"https://unpkg.com/htmx.org/dist/ext/head-support.js\"></script><script src=\"https://unpkg.com/htmx.org@1.9.12/dist/ext/multi-swap.js\"></script><script src=\"https://cdn.tailwindcss.com\"></script><script>\n\t\t\t\ttailwind.config = {\n\t\t\t\t\ttheme: {\n\t\t\t\t\t\tborderRadius: {\n\t\t\t\t\t\t\t\"sm\": \"10px\",\n\t\t\t\t\t\t\t\"md\": \"15px\",\n\t\t\t\t\t\t\t\"lg\": \"20px\",\n\t\t\t\t\t\t\t\"xl\": \"25px\",\n\t\t\t\t\t\t\t'full': '9999px',\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t</script><title>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var2 string
+		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(appName)
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/layouts/main.templ`, Line: 39, Col: 19}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</title></head><body hx-ext=\"multi-swap,head-support\"><main class=\"mx-auto min-h-screen max-w-7xl p-2 flex flex-col gap-2 underline-offset-4\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		for _, render := range children {
+			templ_7745c5c3_Err = render.Render(ctx, templ_7745c5c3_Buffer)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</main><script>\n\t\t\t\t// enable swap on 422, this status code is used for validation errors and returns error messages bound to elements\n\t\t\t\tdocument.body.addEventListener('htmx:beforeOnLoad', function (evt) {\n\t\t\t\t\t\tif (evt.detail.xhr.status === 422) {\n\t\t\t\t\t\t\t\tevt.detail.shouldSwap = true;\n\t\t\t\t\t\t\t\tevt.detail.isError = false;\n\t\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t</script></body></html>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		if !templ_7745c5c3_IsBuffer {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteTo(templ_7745c5c3_W)
+		}
+		return templ_7745c5c3_Err
+	})
+}
diff --git a/cmd/frontend/logic/scripts.go b/cmd/frontend/logic/scripts.go
new file mode 100644
index 00000000..e885f7e4
--- /dev/null
+++ b/cmd/frontend/logic/scripts.go
@@ -0,0 +1,75 @@
+package logic
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"io"
+
+	"github.com/a-h/templ"
+	"github.com/tdewolff/minify/v2"
+	"github.com/tdewolff/minify/v2/js"
+)
+
+func EmbedScript(script templ.ComponentScript, params ...interface{}) templ.Component {
+	return templ.ComponentFunc(func(ctx context.Context, w io.Writer) (err error) {
+		if _, err = io.WriteString(w, `<script type="text/javascript">`+"\r\n"+script.Function+"\r\n"+script.Name+"("); err != nil {
+			return err
+		}
+		paramsLen := len(params)
+		for i, param := range params {
+			paramEncodedBytes, err := json.Marshal(param)
+			if err != nil {
+				return err
+			}
+			if _, err = w.Write(paramEncodedBytes); err != nil {
+				return err
+			}
+			if i+1 != paramsLen {
+				if _, err = io.WriteString(w, ", "); err != nil {
+					return err
+				}
+			}
+		}
+		if _, err = io.WriteString(w, ")\r\n</script>"); err != nil {
+			return err
+		}
+		return nil
+	})
+}
+
+var m = minify.New()
+
+func EmbedMinifiedScript(script templ.ComponentScript, params ...interface{}) templ.Component {
+	r := bytes.NewReader([]byte(script.Function))
+	w := bytes.NewBuffer(nil)
+	err := js.Minify(m, w, r, nil)
+	if err == nil {
+		script.Function = w.String()
+	}
+
+	return templ.ComponentFunc(func(ctx context.Context, w io.Writer) (err error) {
+		if _, err = io.WriteString(w, `<script type="text/javascript">`+"\r\n"+script.Function+"\r\n"+script.Name+"("); err != nil {
+			return err
+		}
+		paramsLen := len(params)
+		for i, param := range params {
+			paramEncodedBytes, err := json.Marshal(param)
+			if err != nil {
+				return err
+			}
+			if _, err = w.Write(paramEncodedBytes); err != nil {
+				return err
+			}
+			if i+1 != paramsLen {
+				if _, err = io.WriteString(w, ", "); err != nil {
+					return err
+				}
+			}
+		}
+		if _, err = io.WriteString(w, ")\r\n</script>"); err != nil {
+			return err
+		}
+		return nil
+	})
+}
diff --git a/cmd/frontend/public/favicon.ico b/cmd/frontend/public/favicon.ico
new file mode 100644
index 0000000000000000000000000000000000000000..c3e53a365e285c5778cde17f07f767a785254e2b
GIT binary patch
literal 3890
zcmeH~O=}ZT6oyYyHHg~Sg^CifAWHoKMN~BIvu+l;Z$T96w;OG6=U)&?Rdnah{($1f
zuDjB%0t&8#T3lEtJw9)8JMB#Ll1UR>*n~It+`0F>&&>UpnV1#$j-E9ATBU4u)Xc`v
zD7uJrT%X2pt4RGkFu(NJ{0n+@%e<6o96&`3Sg*wt`;qxI;x+V<xIAIL@3#42GcWcJ
z??rh|n(q}uEHTA?XnsBL7b!=mPg8!lZ+^aCe0j+;c#jZ^wI(*_a0M-+mq_RKo^pe7
zQv5sS`!yzc&qX=PRi3<pr@YHZtYyaka@Bkf<r(JXNSK>>^+i+D=Eo`DqUW1l-JFN|
zDhKYH;4wvA*EBDNSYnF3-7m{$+%Ayw1AUSYYoeg*Qn@{^9dEU%uX2<t57;SwXKwpQ
zmd`nAZ>*xv%+(2eYQ*m-wXISg9SdzW^;Hg9l}DfW6?|Uc>G;pI;o2kZeWGJ(Qy=2W
zAozIBih-Unt_NT}C4Qn<$3oj|uYB!KJm%0(yz80q*EJ>lyXI%9f0aTU<JaYh=EO)%
zT&4o^H0&B{VK~O;8qeYPO$zZ}`SOydyfe6HwO{-wB+|IcPwoHI`pYx_ks*#Yv9`up
zH{U6j!aXfn|1o~(yA*QAqmW1=j6<+*;!~gCzDwK{UwxIM+#BWxBZwSLUhI~?c~8t?
z-bL44{=Xi7)>QKR%dUUw$@6b8^KS+}dH!elv?b5~E*4XdUAEqFvV6T0Y2T^r(L7gL
zCqGyEjywPF{CnnO?8nyohvFR%XifwEPaT7=|1pb-bEYTV%kC=$_eM+A^@g4LWzC_5
fQcK0FrKVX+D`w>lvzb517lyn;&62ycUhU9tq7ivL

literal 0
HcmV?d00001

diff --git a/cmd/frontend/public/favicon.png b/cmd/frontend/public/favicon.png
new file mode 100644
index 0000000000000000000000000000000000000000..09440087a38dd5fa71c6c56c6fca09dee349acc6
GIT binary patch
literal 692
zcmV;l0!#ggP)<h;3K|Lk000e1NJLTq001BW0012b1^@s6%bsqB0007eNkl<Zc%1B)
zKWG$D5XOJAyZPgZ(J0a4{DY=Rqh&CHSOp}75hRU`joJk(lO`zyn~;E}Fol(sAT|ax
zjaVs&TG@$`M8P1YkRxakLvBZA-^SdUyG?dU6d@lh_wLQSZ@!zEz4u-~PAJz7z>abE
zZJ}Ej{hEg-w*Uy5fg=^;TmroO0(_}H{%Zm@2mhA<1yOqH?K6vQ(*!_&7qs4o{*EfP
zj@Z_<B?8p>b^{kcJF9qfIvd@Zfj46Y#E+NxRjB-=&z1<-d~6Fy{VP`bc7b;ZbQY!_
zZJf3zP>!7k*$;E~gt70r1c28DdIMwziqAJLptuiY0JI2AuYfl-Bcv0R>p|*(2B^=_
z-H~sDTWcJ(@y~l;TfmwoRIazW=9|yZbm>rfo1kzS!gs>(WTnkZI$o^<e*okG6wap8
zE|;xK-4l&dU|h!O54aes_#*=iCa49p0N62WrZ%ZJ19~^wg`;sQnjNRK#4&0KSPxou
z+kIFTMt&&Vv{`{r=_|X0>N?p-B8z|!uv73}kf$qwSIyDf@z^KaDCs(HfrjoVV9%1m
z&;(3ggrS#feQhqXO*r3`b($(BP|gI<eiRl<z+BS2{1N=ez-N$>M1&8Qsu5M%6e)p@
zgA`+q6N#TiZwoZ;f!EU>oIC~I6DSNrp)po&lq%f*0!x=+YEZbfke;ndG3Glp2tThl
z4$<GSqZk&;Vzze#pohS-3&uBBlJFULyJ7k5Dp__&B2&f{yokB2>}~E+BZs}DI;+?8
z7%ZHFk(xVLb{Lm&mhM#aRg~ob!cXAO0`FmdF;-r+&UxY9mQm|5tN$YG`~V!Z*uMe*
a0RR6kc*Nc+SuQmI0000<MNUMnLSTYD-8w%2

literal 0
HcmV?d00001

diff --git a/cmd/frontend/public/icon-128.png b/cmd/frontend/public/icon-128.png
new file mode 100644
index 0000000000000000000000000000000000000000..7c8566d8f547ac7ce318a8c074353e01ea63e21e
GIT binary patch
literal 2378
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

literal 0
HcmV?d00001

diff --git a/cmd/frontend/public/icon-256.png b/cmd/frontend/public/icon-256.png
new file mode 100644
index 0000000000000000000000000000000000000000..ac3ed4fa79383f352d421b8423dcbd720ac0154b
GIT binary patch
literal 4905
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
AdH?_b

literal 0
HcmV?d00001

diff --git a/cmd/frontend/public/icon-32.png b/cmd/frontend/public/icon-32.png
new file mode 100644
index 0000000000000000000000000000000000000000..09440087a38dd5fa71c6c56c6fca09dee349acc6
GIT binary patch
literal 692
zcmV;l0!#ggP)<h;3K|Lk000e1NJLTq001BW0012b1^@s6%bsqB0007eNkl<Zc%1B)
zKWG$D5XOJAyZPgZ(J0a4{DY=Rqh&CHSOp}75hRU`joJk(lO`zyn~;E}Fol(sAT|ax
zjaVs&TG@$`M8P1YkRxakLvBZA-^SdUyG?dU6d@lh_wLQSZ@!zEz4u-~PAJz7z>abE
zZJ}Ej{hEg-w*Uy5fg=^;TmroO0(_}H{%Zm@2mhA<1yOqH?K6vQ(*!_&7qs4o{*EfP
zj@Z_<B?8p>b^{kcJF9qfIvd@Zfj46Y#E+NxRjB-=&z1<-d~6Fy{VP`bc7b;ZbQY!_
zZJf3zP>!7k*$;E~gt70r1c28DdIMwziqAJLptuiY0JI2AuYfl-Bcv0R>p|*(2B^=_
z-H~sDTWcJ(@y~l;TfmwoRIazW=9|yZbm>rfo1kzS!gs>(WTnkZI$o^<e*okG6wap8
zE|;xK-4l&dU|h!O54aes_#*=iCa49p0N62WrZ%ZJ19~^wg`;sQnjNRK#4&0KSPxou
z+kIFTMt&&Vv{`{r=_|X0>N?p-B8z|!uv73}kf$qwSIyDf@z^KaDCs(HfrjoVV9%1m
z&;(3ggrS#feQhqXO*r3`b($(BP|gI<eiRl<z+BS2{1N=ez-N$>M1&8Qsu5M%6e)p@
zgA`+q6N#TiZwoZ;f!EU>oIC~I6DSNrp)po&lq%f*0!x=+YEZbfke;ndG3Glp2tThl
z4$<GSqZk&;Vzze#pohS-3&uBBlJFULyJ7k5Dp__&B2&f{yokB2>}~E+BZs}DI;+?8
z7%ZHFk(xVLb{Lm&mhM#aRg~ob!cXAO0`FmdF;-r+&UxY9mQm|5tN$YG`~V!Z*uMe*
a0RR6kc*Nc+SuQmI0000<MNUMnLSTYD-8w%2

literal 0
HcmV?d00001

diff --git a/cmd/frontend/public/icon-512.png b/cmd/frontend/public/icon-512.png
new file mode 100644
index 0000000000000000000000000000000000000000..d09fa52fbf5bde2e762c895d9747b700ed7e730e
GIT binary patch
literal 10321
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

literal 0
HcmV?d00001

diff --git a/cmd/frontend/public/icon-64.png b/cmd/frontend/public/icon-64.png
new file mode 100644
index 0000000000000000000000000000000000000000..87796e6a2fb35983a6c048aa874988ce4d900fc2
GIT binary patch
literal 1235
zcmV;^1T6cBP)<h;3K|Lk000e1NJLTq002M$0027(1^@s6%Z!ZN000D<Nkl<Zc%1B;
zOK2Tc7{`C#+#8cL_NB!%Xe(8GfScmRn+g`8;G<AM$wCq0s!&4gCPu_AT-ZfRN|BJJ
zxX^YfNyIMdrVq@@6j7u_Ta^%-6pN37ZPQ1Rn|yNSoU8YSBs0m}$q6_=xG;Az-#7p7
zKXbl2GiQ>=1IqS1G`EB9vuor-__|vdEH1Z}V7Yf_Y2FOl26CVMm}RqW`SD}`>uupB
z!sYcog!nRG#gG}`TYzse1AGhcO=f^^0lvu$@GZbMsoo1HdmEvy0D2o35)R&s7uUHO
zD1fYjyF<c9zo(@!wKG6zyC3R~f_w(S=McQFwA>RNXSR`jHpax(_u5?Pkm3-y_bHGa
zK&|-#yat;ZqvOmr@~Vq5u{&(8bV$(vt)Df-Y9SYS2Doi%%U0C5T&eKCZ-SWtz6JOu
zGr+e1-(&{(7T}xAfNCUBw&!&j%{2S6a|_8yl*EcC>;!3n=HHZJuh2D84Po=|vttY7
z_W(^wp&y1$CYex4=;AY5L3)4(ff>j*D($<4?ulf1=SFF*gZu};oA&IL=b`xu41T-R
zoC!}`c^qgg%e56)lPu>#tXb{$QPSNA`b3h92@TMkaiKC_tt8925Ml0e&EhmHne11<
zw*cQ{2KW}>o6G>;0(_Gh;9G!iVqFR=9Sx9gf~mjZ&@~C~M^+vhUKq7+fQGeDyef3v
zii(Lm1MKWh{s?duYEHmA+p4Cx>b(0bG<;#T=6bC5g^4i)YF`9i2Q~rQAb2~@49{}o
zG__leMytF5buUE4#V{b)XeTF1$VPa$CYjusabUb`#W+mHnm3#uqseId7xTR-D#}w6
z92o&U3XIv0Sswe<hY~MuiVA&`N=p}P8L(?cM$9@NTD%y5GXeO?*ZxbSI0WPlQ2wZD
z0;Xde<#3zwCrVQ;S1P1v!1xcqDOZeXcmpsN<3)#Xn*kSNVo$qVsgT+b5PGgDd-qhn
zArd{#ZGY(851aw&Vd9+0m6py_dw_ej<;3FS!dGcdrK75nqz^@>sJJZFBIrzFRr6wU
zYk6N$r(ww??Ex2nVYh6W)gauwo-pSEnA~O`l!_jP;`t;Q!y%xw<lxb#LAS!pCAdB$
zd>q5s0~ew5Es&icSK(G)ytt)dax3loq2XuHCeV{`=u(_mWp@p%EkN)j$oDY(ozOS!
zdcc<FfMXyJLGCYD*9P=Q3t|Qi4w(j*yu5e_-G2f{79Y9p6$pBO4Zsz6q!suou(yz6
zZg@7kA@KkNyX;vJGJ8y?IK~q*r&e1_u*=pK)@W*d$<*$8fUK&F(|Y*BO>j(K1a6ci
zJP+TbGWC@Vqe(B6nQ#O2N4schnf<1jtvSZeVDSv(-UD6+{RKGe<G;J2Fq)J?7w9y|
zW5Aa%c{VC8(g5M`9fe+K{RD1LnZ{8y)m26~Fsih4z^WQJJ`v~1l`}xKa*9v1GO<Z?
z{BHFnS08tP<~T?)%M1;_2evr5{9jP`hfx?@$<1z&gtd&8ing`NWmCIrf>ZtO+Is@z
x9O$RAvb+7Fu(cGA+1gBvdfL^@KLG#$|Np@BMy5_cex?8b002ovPDHLkV1lR}O+Wwu

literal 0
HcmV?d00001

diff --git a/cmd/frontend/public/og-widget.jpg b/cmd/frontend/public/og-widget.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..a1c8eb84a7fb5615033062be6668c5ca368a6e90
GIT binary patch
literal 40334
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
Bll1@q

literal 0
HcmV?d00001

diff --git a/cmd/frontend/public/og.jpg b/cmd/frontend/public/og.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..a1c8eb84a7fb5615033062be6668c5ca368a6e90
GIT binary patch
literal 40334
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
Bll1@q

literal 0
HcmV?d00001

diff --git a/cmd/frontend/public/og.png b/cmd/frontend/public/og.png
new file mode 100644
index 0000000000000000000000000000000000000000..df904fb569107ec0fdbf3795f2eab2e1ba1e627e
GIT binary patch
literal 14493
zcmeHu_ghn0*LD;~tiY&%L)8%l=?F+CV*}|@q!$sT_ZA=|U_l0HBS>!}hzJNsCsG9i
zLmzreLWv|&5(tn42ua?}^L)>L@O;;Iz27xI<Xk5?`|Pv!K6~A3-S^swdtj`4_LRUW
z2n2Fg@BUpg2!!Lu;pfCr@Jr{{JGBsq>Jz=Yw=BYP*O}pe_)OiJW^A+$YwlnWM0l}O
zZ;JHXiQ$@xu-6JNzP`+Ak~iLcW)xFkzR|jrtZ9}O5k+|=CU-B4dV>2lB=*sLk(*Cl
z%ONgyH*Zc)PuD1~B_Wy_w8;Gdw+$<+z?aoe_PE^U=M0G3*I7jyj&>w%MkHO`tI9lb
zrGFz10*PkIphm=jU6C%G!Vt*OOPC{&OOSs~|Cxt>7QsKx@DCFFKSxBgAmS**zE!o~
z(}O}Y#*-%p97v^h8i^b)^bv3GnvTmRSn9X-c#=3*n+v>rq1Ij@siu5AD*JDbH0e_e
zoRGtb+MJL|ogj;*X65Y$D#v__O0%j2Z*6BSYg%5!LHexr9A=-nmo}^nqn#>RLw<lH
zJoD!~VWJT4)S$7QY?a*l81~^!y6m<S>FNs;6F+7Kha39?N-?1}clhUM1t}rzz;&Gh
z4v5vC3X%sMvv1gom<l;>mHrvtPhrw-F*#rA;h}sw0sHP1TKDTTe!Kq?d|YGEqBdHz
z%CsE9t7X+MOFyjzTu>QZGN8GpNJPAEm@*iRG(I0qIZuXsbx%08VXMYUnm9kWlik4g
z@kwu9Ua4xI$j8QkW{#J)n>b#+%S1zK0@rmdlawnfW(&-QQZ&@fTg8}<T~zAF&ir;_
z9nZz{DuXoC;zFHXhQ8iEtE`KLRSGc(lRHgZCw{9020^lmIyEelhtKxowbl<lZzWB*
z435-pTshg%_ABNHty#6-u}x$9HFidmi`ADmlR+N(mX$_^F!KC4r#G^TmSB~lWhJPA
zc$Lvnn2(TmQskSP9Z2!RJ2lh?{bqA|H+Er-uD)wZTN>IBm&@QnJ?OGdMN4HMKqu1I
zIwAl*>-kGG!nlcJ-HTcmW>?}k5EzN9%j5<3c;Tm?o{K&>0gFadC`gKIOl*rRTUUAd
z{ipqeQkH0v&jzi^&G~_>8}4TaO*z8@wEY8Jf6y3NS{(D3aN6PsO?i>)a}|1ont4*r
zHDGDRBARK`!~yvY@=^l=IriH>r~ljM;m@!l6UZaz>ss$nYxUVG9L^Uv;vuqbB~bME
z+&z+*gA6_YBU#IO4qiCxC`GMNZ5t66Oc0Cb<6O>Zrh;V(jvP#VEu&G1S*bH}Z{ge%
zw%ikT#6E1rQimV!Le@)-j(KzaqVui$b~pK*nrp)hN+$0c4DY+VP(>8ZvcB(h7YtTH
zt>;J=MgfRiE=^3)m>X2_lWB{9EfRd|GkNo=J+zdsF7-pqu{F_rJ1z5-Gm(;KHXnkH
zt-jfWesn^t5uR<>L&FNK<em<vB^FDE-zo{OnG5SDjOw~gve!oUddf-TN)$ygo8THd
z_SgC%y6>>u*)sGx3aOh|x0BL3nnxl)G3uL)ZGKi5GNgE1nZdPrVUdeR>mdoYG02+U
zinFS7Enle}=7gFn#B<ZV<{Lx5qv7W5Vc*BaOKx)NrEh1wdjGb&Y9=d+zGVcf%Zcen
zmX*D|+883RVbiwvv?9w%EqH%B(TBvvbI){f^Nowjz7WLs^KHIXXD^D|P|E_Ew6YXr
zTn8-|d!2E7!iqe^h2I&mg}0EjRis-HOn*|%#??w=m0u9<i=D0>s@*P=x-p`T8e6!a
zM%;M0_y}(XOu@i+b;1#st>v_mUlE)i^g-m&uh!5LhF{DCTAv23IOU?4)>R@7;ZE8<
z0T055w|b)j7sGtMj|xoa^d>u~vhe*XGH3dy{4;mMs#ws1HvC|Y!EkH$@ki&vU`MXm
z=02^O&13g&i)S348qIJT5#o(<Cr!h=g>pBkH}v=rQ~O^<?KNmr5mM`~oX3~x((?xZ
z^i*@!ouuR`FE!*xl6JfRCL;^2TGLUqs+-D^Z9&Vs!lcr;iUHMrvbRdq6KYtHQf1G_
zrBti|TTz&7)f4<%^re%qM}fSxyPT6;^VsaTo(Kiak@D6c>h!q#nbg6{*&=Dk;N{(F
zN1ueAgre`o6*C*nVc(wr@+jr-J}l0+#fP~W<i`kmxCC$HcWl&xK1(GBq+^@4*k4F{
z0f^_6I<xdh;{H4Sx*WWg^l!fbOW&Qc*_j;VINfDWK<5-KHG0bqI*bKn-O3hBpZ^m6
zNZMeoz{BGKD}4}sG71UFe9|eL`QY@6KCe(hx3<DT9e-nqFKIkTeYcJJ+!$Zkx`N>n
zZ4Y(xbrwqgnd9aCCXQ5zp&E_ZL`r2BOQ5!ER0>AC=2>qD<`<Kf_seqA@<FvDKFRn>
zJDy|R4fK5%EsZM2ekxW&!h;p0T0Uz%91i-O`QeS@zKN`>+AFx03}z-@vUo2M@;M3&
z`rN~@?~`N;T#*pj%I($p3uMKv(U9qCO1f`R3bFM_N844*Gd+uerD7!6px7-IZL5AO
z&PJ5iZ97T?R_fGnT}&Q0t$bXHM83e>6bHhAT4${%{^N$-P>OB-X-vTlElFN*{mr!>
z!apr|P*PLL;mKwL*VcX&)U~<X$8^R7X8#rX=!Vfa{1oJ?IjQ5@IWh#o16kyPK#uVI
zbNat`9-@~LwU0b{{>{d6=oDB|M%dL}Uxc%@Z-Rb|^xD-K*XpP?47_gAR*FhLRixB5
zLhO5DQ1ekiQu=IPV`#SS{shXoG^M*p6(@B@HvPDX1<m+j^BnpXROD$j)N(=nXL1LX
z$IV7drtOK}YJMInquw={<~gBs{b|hO&=q!;&WyY<T(7}lJ?dTCcE(svlyZH@JB;A<
zUn`q$^8u`Is@7nXfh23)$RxQhO-a^O?;Luh7&`9GldRtR!@iiFMVNFl_G9_Dl;oXR
z*6<fT0lNe%R*InD2Dqz);b`*u`sa&Kmp6{*(9545h}<(TTB>$rCeFo|NMh$5>{&&7
zX{65I&IKU8+1%8SMlia+ZrDO2&8uvU3ikMZ;jjIe$?N42fV2*$IBt{HVzssE_gEan
zcI$Z&>&R2z4VyUj)G_5C(;aE763rF0l-(|{7+Vs~Bd~*M4JzI;2PJn(po;ZcAU`%q
z)w9ws%BUx>R$|V}c@6T`_J6TTD0<>+ja(yq&Da=Xl9%?_4Rw+4F#T-9XT89mTR<d)
zm+TD>W4B&oQD&j&+BaxvB$bS*b|g)4=k5L78RMHm2+HOG*w8E|5<%>vTw$&jUuwU7
zx@$|r${2&o-)~RSrukPaEB<;(Tzi@$@MpJ~USDR(Fow38w^#m=R>B=r=Y*i|<;)`~
zkMtT-lg$JWbo8AK$F{xIGNu$~Z_3pA0CQ(%4g?|m0O#G`WM69h5zq0W4-Sl~nKTTn
zzq&Jz29Gn5E@*+d-QrdV)#GbL!WXgqDj<Wlav+&pzuVgnb7QfIzBU5(<TCkasb4YA
zC^-UrtlpUObYD5mZME_8T6t;qILeOfY2pRz20+SBGGdPJ+2wzt1qjLOJGQs(R;HaF
zG<BBdJhtoEDSWY3wIA0~ze^J2Jmu2bnY%uTLj`)<Kl{n_!r<Bd4SO|YP@{IY3t#Q7
z#w2%(hu4VFHTlrP+koYBQ`{!W`gkpGp{w-uf!0trM{Whaf5i@Z8Ft3Y{_?h=V$tZF
zoQSP}MGxE>U|hnCmPQbuF+C!8OfMKE>-%9f<(0{HN3V^gMj3PVAY=F5?^e>r%jK}=
zAPK4doZY22_1k>#kCX>Jp7|XNR;)D7n(qna_6APj#<3MEnq+yoR-Vz$MqlX(9o&;=
z0f9zGx>pFkOq#Lm7|EnG`8C~l&heEOuiMO8BhhPk3;WSUaB+w>9*0x48s<0wd*r<&
z-CRGHDNNWM^zAJc@g&UH8NQ6LZK>4?8HA^4XP}%{(v!5X&jQYoJEkube*Y<t(9{rp
z5W#h(?=(k026Zj|g&D57qQ|67D6mxpaxD?qd~K)@kHx@7GlkP#bzDK4+O93be9^O7
zfL~;TV0cjwOoY)nbWj(D*jesTEsH_joT&2`=CdE<?ynKPcm-TGzuwO*GaD#;Zev(!
zbUD7N>(_Ms>~HCP5d0O)vxRSuf4{V=_*1vRKm6i<JHPlhMSQKYe=M5vd#$&xwf1z?
zK*DRPX*JKi7ph*ouLRMoK-8SksC1Iwj@nVw@3o(@`MBs(r(XnKkx8!!yKs-x>0hpD
zFGIZ<kC2NBL-LS$8pPtc&Pd967_|n#DYVd_P;1}!F@f1)rkV-0j+z*mBp_`JD>rTw
z;C9UrutwD{BPC}N2FE}9TftYAHMRk#=Hikx@49_eimz5Ru?Cq!zFJiAnEftdZP-l?
z1PECDxWP}FFAbaSd|Z;&m@G#SyT7XV2&>MN^5$1>Rb-;kpT>V=a8b(vIXGCD9T`?>
zfPQX@Wbe3^%gb|cE&?*;X%Rsh!qDwCw^CYHJZ*QgMei3jW%HGJI6GUn)z2NI557pY
zqO-h1NpwETp)?Ig7LUXt*R8U|6nH2R7qa;6^qhI|dX0!>>4z9A(hzpU7x^TV*_bhe
zK;drCk6)I2GLlDH0r~dUtBRNv)9bI>C{n0QwA>FRKk}qgt0LVicIaSv+_mHn$BfjU
zy7ijwgnf7wvjGT8tYxzBMT^SKf^Nm4t+`2V+@#0B(i?GY?bdhL%hGy$hnaEya;luW
zO8%bOT#(e$UM#$py%bDR;m&2|p||;lZuzfEay-it;6tt+^olyQt@M>MrB0a!g4uO5
z#<B<%=-W5R+Z=)B14~g&s2#-;zjgpO#S^SLfT_uH1-re=IVG>0nmdk96JKh)e1B6P
zR~xxachs~usG{I&b{GEKA9Hiu+$a4+;<_dAWJIum5VgNvVen#AS)}YudRr9fhl%vO
zz0p(1%WqPA&rS7<0L*UEs9k7p&Fv?EdH|dDhG-VKaj@yBC29BwZX7(-{>yCgY@5z?
z1J=m?yGCCj30J;>Tk<b8j^WdN@xtXjIYkQE+2`hQz6YDDBZQAiZ7xUgD$0_~&DrWX
zb!vb31?mlD-D21$k>=%5g=g|7U?=V%EOv46y4@^3yWdk(yybAsicnnFQ9PBqfw+Nn
zY+4N=ISu>db%Rx4FBo^^#EU7(my1{7V}2Oh``s!tv^v7a%~r42l2}^ibA+d>^+A5T
zZgvp`YLI=GlGBjx*rK9LyTTC;7JM{daN%Cg$Ol8jO$yNQnrDrqu+E|po*@kIO+hwg
z&-3()(VRxUis0Bwz_N~|KLcT2uImLU(28`vjhU=r7j@Al9lZ;HhLE%76V+v7Bv5d_
zQ0IkP{3oLQV<AEt6UIARi0E~|pCY(Kzi~``)Rx3xvj;<d2TB}X&B-~s`p^#kh7x_X
zsGgP4KO^5qRpi{^aDjcY5}e}u!^uR=i0rNsD17wd=|!$1sw3sRfsQ?+LcIJzNgNB3
z(p-Hm*kd#su?*Q8u9(Z9MsQR<W6Gs8swBJHT&?GbKW}!?W3_(zpnB3$%z@mEj{5W9
zX|~zl>)w4Edu?N893=b<ArrrTz0M@9MwKn&v?LB1A&D`kZZ&Z+TEA7F?reM8Jt9BE
z{NTyscBT0g$$%0vL%!Y{ZYFy1w46mW!iT4%;x>7)%}(g-R=XBt!S-LmSk8NXgVq*Z
z8#&sSI3UVR0a2lC(pbk$lGLKBX1-E)x~N6>$bZ@<h<w}#O?9rk6IojA)h+y}00@l?
zTfUyCF^r=uvB{PYiDJwULXkb3kEB6I$VPiIA~51gpI1-!`uQ<I{;d`T$iJ^l8R^gm
zD}DGl!-XP?rrZ5|EBNgexIWLHghexD<MDDzp{ysqS7Y_)>&XPG_UY-t$IU?EgLMjD
zg1iumnEzVKJr3)cCC~7$HM5sHW}Mf(%#R#a9XdbTlUZAf=5CUC3P3;oGP+mXRg&J1
z4G=mTjRBp@KM6RXtR%9-evJ32wk5CJM$x5WjiVk%V1NB3`oRUios$rM)Nwsp>~?ux
z=Z{vRui9j}6E$GSVipS9sZJiU7s_lsav~P!yuFut$vF;ovM~0{o?RPC*}<r4{RYnH
zRe^^uyYr1Wn5j%J&J*#Vr6FIB)29uVoC;#EB8RgLfnVtLB?WG^=A02NZ(#c)sU`$V
zx%7xK;Y+Gue3~{wRq2fO`e0g-;#$>weiWA0d0Kst@G<j=>E+i&KT0KrbxhN{M|_<(
z{VSN&S@EJdHc%(BHcC^cp5vu1&~-ikxLZ<|$F^5vz_+Dh854G267AHfcV2k91eXrd
zPpt%^7-98H_xe`*6>t9It}{oTUjq}Dj;6SJG}(A+{q3$r<Sq-1{yg&lR5$<YrJNIb
zp+Ik2&;e{mtgq1hBGECrOI3ec#0A=07<K_2o;+$|M&dHOw#a2zsMHsF`bCSbhj^Fc
zjaw_Y<grlaOuB?d%vT9^j%+mIP)KmU=vKar#1(n-#^&jrqK7&+ISepE-77HdTm|Wn
z^*e{^0agt0X|@mkb~%u){&JmF?I0wb(Hx$<WgSw*pS&gV(<4!k`-us3uW(Q;#d`xB
zdgMhArEPOVKx1%~L+uo34%C*>Q@&=bHFIn@bleT3a9jhG0`5sW;3WsIrX{(c%B@*w
z6!a4+3M{YE(hAb;q(x-IDExCeL-#6#0n*%S<7hMX`7t{bNj4Mlu6o-&M6Te)hEwu5
zt?lpWA=2hdkDF{|#x-~9&mC6h$sI5C@jw2xDgwjr)<3++>cz}Xipls#^|@BF7g6zW
zJz4gmSFr)7iTDr2Gtuqft*5Rn?&CIwtIjM{`yHe((F6NEB`ViE^9IaoR9Vvl`#=cn
zVVQPcGKSWDKKMQ4M#nMmnC}AJGf@uebd^Dp_a~>f!Cywh=f5ge9MI$D3&70Ng*D+H
zMt{L8)JiZ7gBUQr4BhiEsbib4LoEw9m6KN3ew-)FUh!LV%wm<OCez=??`X+f!PfYT
z_6?1&P?)z<_ggJT(!uOI^C{;ly=W#Nf#+r7@rTur*skQNB$sM<x%}=Rha2mWb4cfu
zb4kDskRXv>E8bp0q&BlvX6Kt8wx=ij@kR_J->e1H+x=gh#jl$XC--}QL}|k3;v8jO
zSJrS%>0_NV!U!Dk{aC&IhViNr^ZQZMzq3e73%XXu(q|>D;F;^e#oK<#T3eK?#FOp(
zM}ZKNk+Aeb&ULc!b(d(f{}OL=ZT(JPWnz~qBM?F4=PuYEAAhxRJi@kFexFplT~bD(
z=R(8Xnr)gohr={_H^<E9*p$D|JGrj|KL@=zy+Komf^+P(xY+qG)jJJ|cT`|&#p{Bx
z1bLB)^nKAR2ew~)#;J)<n^PCXW|(6+#D1)(wZ{HF30-`vI1_=NH-(C5nUW50oiW_Q
z6_tm8uyDOoctHwC&JV~;!n0b@yqVqf!Qv_M!2GC>lI}1vFY<=$TtO~ww|0ga>sev^
zbt}^?qk9BM#qH4jY0=@THV-e#gvPdbJIlzlTt2LBwk^t)*%jpF27+g<1GVpJG*NVs
zYm<H^<p;%<kx^!HKzkOX3!j)%ALI`fh-K85nqD3%Y`y)(jGS8*EK=5J{7{{LkkcvO
z_%btxFhmrXi{~5y>MKwg!BKSGO0Y;Qz6jgtj=~_CCL`WYs#~r2@*hW*Lx#mLNAmCS
z_1K{oEvu>M?w}}qa$Cz$0Cs5%uVt2#kq?x}y<c%u^R$WSk^fuO6}(bHZA<LMdn*!b
z(=em~UMYUGMfVqb0rb42{7pdHa-{ogV{YM!c2YiNBy5Sq5E~tHX(^a4M2YHKQpZIg
zEqd2T*j=Y@ixfY+NalMLp4_=@S1#|#8`#clen7tG3dlOZwP~=h-q}iRn98O{@Ef4!
zMK%vY5v<oDl_ZB)v`fc#9?;}{z|N!AiM}9p&G=F9>hccwzi%EiJQUKjpBoIx0$vgJ
zxgiG~fV=}q)oJ3u2bYa%KlC8N4jfaEff43s0uq5+e;>Dm4!0Nel##|JjFUJZsQ?G?
zbq|Fw&|2+2pI^7*Jc*|h^K!X{?(RhfF)Wm;at54p5sxFfbnkS8fx+a0K2lNjL214s
zoEzwsSfXV?<N|l)L?8+_kMV>KE&n`Gn??gaBb1IMWB}f~9_Pt;5zqexKVPlDun$^G
zCRm!wd{YHu;oO!g@FOQ6@EOK84i-AMuCG0b4gd&~nYi==L~w1jdNrIlTQ+^aJ!Ap%
zdL^`*2qG`5IA{$WAnV>+xRW|&7p2**9vFKvAqPCjuXvnEz2hb#I-lSI6=Al=6QOGL
z9$)el04{<=qP;d4$&*aFwoUOQA~;Q|(lO3Q@#0|e`<HgN6G;Ucv>*DVaMBvj@qqnz
zF{j%DHoZ&!U|2ca@KBH0fr_eb!%y?Sa<N{|m&wpzlc$Rc{MN0pT;FdsaiH$wf4GdT
zLE%g9bj#sWHLk9W@{#OkLC~lj%G#z@hT#Y7(vNvj#5y1%4*e=yuBQ9<E10$7B5hF-
zSmN#9jQ_>+h!xUFQ0>}kJ0a$e7(9J_=;2r=FLPU|&)8~i!%3YEvWsT4Q2Y4FhWIWv
zadV|M4aZ#}qBT<9ZKYa1q4x^7G{|wr2(!=ZPr@$gdI%vZtEue;KO!03@1lY!e~&oU
z`~RZ%_TGx4^G@$d#k{IN!GMZIE*ao^vBm+r8u7$-d%sqf<sVwjL5Ze|fm?`+Zp6Mk
zZdnjE4pwbT%m3Z66Y##b41m=8MT-3MHK^U}ygiUC5I*jFf&wDBy*vZ}jXvmbFfg9J
ztYB}#6l3HNXhjo~{kDqpHQ@_r_?Yf~{bSm?3{LWlNI4k`Z4IBttd@Ebd$pceX#63!
z$TfU*sK(PaQy@*C=(d_cinKodQ^tFEuY0qq{Q1Z|oq!$p3Z^x6oWY&jUTW72NRnMi
zfd7Lm5x&!=7-OBaV%Ca2v7d_7^@K|;v*c;b%iYs5N!mA>DU__iJIp@7ErdygI7c7n
z2bCo;rf*3XV)^@8!JBic+{iBr4L!wCyKYsM+pXATc16ZwRIGPNDQQ38i`7LE-*N1d
z@AQ+yx0<?Y0pm{R^IM&Ctk<A-hHkr8HK<Ccj6S{`|0-Zy^30^{Lsy1D;-r&`%CN<k
zPz{u!jgTLIELiTychz=(6^iLE8MKom5{s1jYE%X8l{Wg&UO4CGRRj;GX^7^`+^>;H
zS`v$|QSB>~NE|g4V$#JQFj0<`vl42!^0pRb*p%aTSXG;ngo<u4ka;WH9$u{EXSm5>
zzcgwq*N2zQu87^qI2s1>A*XU6m3jE>%j6h<GMm#y3(1+O%Ah;}UQmw9K)Omf$WXO!
z22qlUlOkms)N^}C)M!=kuws-8u53oPMpZ;-CN(Ne`{<X5G$m9KHVi1KQJ=LMl|EXI
zefM%)88oFlXx}fSjSDuWx3vfFo*&Dh4^}XJTzYa(M4nybiW;W)l5{PTTLZiT0v_z^
zB!55yNvqI`-IIYtu5c5qkZvmnF@fwad6FG0Sd-OWTfFXJuKNzTC+KJ)WfNKF#BPh9
z04$L;vp&n<%2%_ZJhVK_B_i)#Pjp0S&<_iFBOdl6Eq+2*!MciySo{VGL&!t_^zvrB
z<iFHg=;v$1-VSPPbN5>fY)Fl;6}oEhqK~^$7}1Lx7#2nBROQ%l%&T*lY?(#>D2**{
zbHOjPYa)8mEE!{fp3`wV?dl;tYoUa8+|3J+^M#pcps5~|o5PS}xE<by468V&X<t^q
zIV^IH@U=#+{<-)`*zYOQ5&eW`Fu4LvOqKndz}hZQ9|18ypvi{0Hb0*>{3sUhSg**y
z1&N#Ncus|xYRy))F%Aa(aJF@E{3l>d-(yInpcEK9IKg_m+hEMpBAVbveG-;2kmo@L
zjTE3XG=^4faSXI?m^HJ%@1?>Ta$M9@PGtMLjT&*sv)2y>d*IXnlG{1mUIW?(c2vL0
zgsv6sEE_V+K{Z_zPxp%e^nUkd+-sAaRcJT}3V+{A(-X&Jxud074T&68(|Lj$&Z!be
zJgpNto!|KAc&0=^Iw-m>Qtje<n;JtA6Xf+qUy+?-Kc6>lQXJu;N%_sGT10dklcp-O
z`P$)3|DY%MYmc5Q=@tXw9!Z#TvTqKw44d2k%E8>4PCj$wXR=`>*p-3OfZLVik5Qaj
zRH%itIz8B<+uv+x-$VQ)OYrS~jzyx$pW-D`4Vx5EA9RYRe1@k+TdslP;%MvKcG^Ip
z;iF$I#yWw9yUloCozF+c_EL5~vrodVO}#@d-y^Nq$A;~ZF#~_Y&&dDms#BcN;2J2r
zbPuk`$vI&kdze@%qI^j=xAIY0qUlLgPZZaY&n7|}mi&R0tEHxkPkh$|o!RGsp?IwA
z)j|5z2clPF8P{T?<NV({RS+XhWlDM}`M^8_&=08WKOP!ZeOR+}@aNl&ix5WF!Dss+
zHB7usjnc>O>c>DyGOzccL8>Y-<2Qw7CH=}fkc6&_9~2}#%>LRd%)T3dOWprmu(#$G
zn8;+@$~UsV*n{jY3R6l-4VSffoAfy6)7Q4tdmenn;mJ4dcW-W)RQ5Ms;SHJ=6S)nt
z=%b&l?)Tgfr3vi^j2i_4qF!ks-g_K1Z{b$aDNno{t#GJ9q?yTWoNNSS$42P8<_Ujv
zL;MTlA(aV_3l0+0|0ob)O*s7^)`^H_Rcl$;wlGIiAW;fSdfYa)=#i^!@3pLcOr8&@
z5St)rFZp{o<ahHl8rrPw4#dj2VjSw=Lsb7}8L;c_BR6&V-^vGIPm7WBmbLA<IDu~{
zD1_6#6sfu2UplB+5ZEhHRv)=={MMmud7TS*MM11sRdT<TeyfRzk1K^b{qxbLUu}e<
zJUzW+8kK)w#ag2xy1Ghvjsd0QuccieI%=m3zh_A3LvO$-ak<cV&dOPQJx$kjQg_e$
z)ZT*%>YJGmI_a>zGZ+oD>2pg)LKHq@Y=X?mFPG5b)rC|}s0Hz@pdukk*`QqhU}0(N
zr?n@ScshkU<zE*;3mn>`Tn7vs0FB#_&5f$_ymNATN~E%0yGfN`N0-)z-fU&@E3T2}
zE??*reqL>}&hC3>o@}LoS6`6O-^gj+g`bw<usS+De_U?|WE4^ADnmahg6r)OKXzP4
zLd|&2_)YO7NGFMw)w8IS*dfc=DeaAXotc6`$Ag$FCf;u&H_jb<RHU@qo~%iGGeZqN
zBij5F(8nmm!JAkwnew^ImpX-SZ;i9gv3n@7q8~RL`*UD&#!$`1eZORAjb%*(@AGQg
zRb~#Jo4tZT<CMK|**Y^ER4kjc+f|S~`+&rgepsDc=mW`E+{&P(^G@Yyaq>)7)f1}-
zMqUL!XOwFDmLTWwr?(8#?>>Uh0b2oJ&DNy-<yp$`5#%JqE=wU!(wBD5E3UOiZ0_(2
zHkS!Mzk<1}S){se@4|31(cEd}=Wa(Z|9*$O+SXz+{3?L9*G&VFoB3^r;OP98oplrs
zdxv3w;YL<gZ+Cg=I@PF{56G6c*GjZLAV>LA4mkNTrs5G3T$j(0dEQGWP4zLIv?EvB
zQ1vQ4GHsv`M({0Ci=bHr3p@pp|4#j+=wKBF+FJckC~WxEpCn!&8C9^T<CBK~?t|~}
z$s=_BnH!lmL$`F^1d0ZDe^J_S3dK{Sb;rCC!XpM2mmqqisGjCBVcy;v%t{Ky4-Jj?
z8Z-a?^M-~rf6d2?_dt7}(WifnSbJx?W>G(8lyA$wrX~1115MHK*nAh02ACLjyaI^N
z7+jY2WcdJhf11)S=n=~R|99hvmPwWwg8tRE{NcqfF0p@~gq?8Y>(M|jmXtI?HR{dv
z@sIiV3sr{-m6Ap!1jTIRM8dmX5zBp3w5{jiA1BM6@EdsK-VI2(XCssdgpiUKVuIZ!
zT7Qv$g?v3v-aJr9sC8bnY0Rd)Iy)R>BLu_Oc~z-~Ic}fhghWG5z#tHyTmH9BuT4qx
z6&kQJilp^p0{{lBpD$7!WE2YAo9VchcJdk~%RaADVle!7)7+3#MY)_uruo0<-AvdP
zeth96T(-<mesSo#tqc|1x`H#RiAN&=B(9%dD@H<z@vHJlmIkf=!Dx^rQd1-6U1%wb
zGy39Fmm##c+O#1@=RekXm|}>+FBxk*p9>CA|NO*|j>0@W^Yk(<usCOp2g3M<3WOEs
zZUpZ}l+y1`c%S$eR!{a}Iaf7MT$CBYWaV;Z$CK&nT+lJhP{{9KTjyGOpZwRC8mV4#
zzaWBLiymGi1Rqo^Ex0HOw&q&lfrVhRBalWyFIREGZDYRnxK7f~)m}D~1*7R(+BF}`
zadQ8z4Bc5N9hAEn8l<k;p}iB+O)e>E2vpxC3TObg>s!i&RX#(2=reLN{sp(R{j@=M
z`zWGZb+=<F5PDPbnBgCen)@9~TgF_e<ciMC7xDdeYS7GMj9h=W!s37(AVwq)dneEh
z?z{>JonK#d%b9b16&;s?rnr?fY~<Jp(qY3-fxy=u6>%lR=xGg@83&+808JB+$;5K(
zm;|G|bkIp7xO+A9(b169ohh#Ty)}X*U*eiTrj~^lbL*YB`cM21uQ~jm9ajs-=Ok$b
z9~(A)7|NV6Fby`^R<n7FboFG+3&VFP*=PHsPu80YX`6XrM}34=t(Lr+KWaZDu?f3H
zPTqChArU;Xi(IA`dZd<dS)Pm!jtGwjZL5u0rf*r))Ctyu3SJvA4#UrbOACv$xWTDO
zvd3GHKoW_`+N`Y7iUDP?ZASBId=ZEwz~dgYM>IJZR37+z$T<U5ucZX_h#=li*3=1S
z`r8OONK-}J>(Y;>buj}KnwN@EU15i?cF64JZ^CpcOE-ac1IcB?7R4@I8T7rOuJq9`
z@l=MI!CRe~EA_2T&|m^oSUsd|RB;OIV%u{j0DrbJ&&ff5eReA()cVUnyeD5VP>JVl
z)!Cv++Q_n5<tZ+cc&Gg>xbKcy2P@^t$RKuBu#s=Rr9QaO$}j2E@Rv=k_|d%1O^bSF
z&$gFnmW`7v%&?9_(>(VnP+1QlEM&XG2s=Ce@gkIgyJ%A`ukJ9@?B`3mq9|BW<^%t$
zV~U5ox&GRwWn8YkPMNXPO7OuFMjS(s53ak;T#CE-nyHvJl(AMJr_=zQpT<g15ecU^
zF{f<m<Rzj&f*Mc%u;H$fO!wUG3cQ~9Dxk%5HLpBaw32ivD9#W-^p3(b>ve9w{1+@t
z_xykIuasT(bOpyRK#GpO#hN7UT3$E;;aCEDss1_qGY9{ygMZxMzYGOGK_F~)o5VSy
UAA4yCpbkXup7Gtv+mD|A52cumk^lez

literal 0
HcmV?d00001

diff --git a/cmd/frontend/public/promo-invite.jpg b/cmd/frontend/public/promo-invite.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..adbfe7d3babdaa0e6eabd6aa467c4d1b4de2dd3d
GIT binary patch
literal 279770
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%0AOuOhP=Y{DM
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
IX*y^B+0mmaxBvhE

literal 0
HcmV?d00001

diff --git a/cmd/frontend/public/promo-join.jpg b/cmd/frontend/public/promo-join.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..2d1dd84326bd450776fd66ef3445bb2691f0ab94
GIT binary patch
literal 61040
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
LIdbT({X71DViG1(

literal 0
HcmV?d00001

diff --git a/cmd/frontend/public/rating/bronze.png b/cmd/frontend/public/rating/bronze.png
new file mode 100644
index 0000000000000000000000000000000000000000..9c9759bb506c9e79f0dcc30f336429b5ddd50e44
GIT binary patch
literal 52350
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
LNkvXXu0mjfTChFp

literal 0
HcmV?d00001

diff --git a/cmd/frontend/public/rating/calibration.png b/cmd/frontend/public/rating/calibration.png
new file mode 100644
index 0000000000000000000000000000000000000000..5cb133a82817b856c40187e40ae193d01fb45ef0
GIT binary patch
literal 2231
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
N0O7oYHOq>4^Zy4%*~|a{

literal 0
HcmV?d00001

diff --git a/cmd/frontend/public/rating/diamond.png b/cmd/frontend/public/rating/diamond.png
new file mode 100644
index 0000000000000000000000000000000000000000..8ae642921cf8723d44e57f9d9c65dd14c87b3402
GIT binary patch
literal 58867
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

literal 0
HcmV?d00001

diff --git a/cmd/frontend/public/rating/gold.png b/cmd/frontend/public/rating/gold.png
new file mode 100644
index 0000000000000000000000000000000000000000..deb5feb38ed4582fd50b3b4e101dff6669852343
GIT binary patch
literal 57541
zcmV)NK)1h%P)<h;3K|Lk000e1NJLTq005-`007Mh1^@s6*^IF500001b5ch_0Itp)
z=>Px#L}ge>W=%~1DgXcg2mk?xX#fNO00031000^Q000001E2u_0{{R30RRC20H6W@
z1ONa40RR91rJw@<1ONa40RR91%>V!Z05af4`2YYw07*naRCodGy$76SXLTodUe2-V
zRj%r)uCA``R;yb%3y=tsWw3!2VQk}FjJ<<{jLj^|IN@PE2#?2Uj3Zt!>lwgfu>uQ`
zl~9&i>Y&b{x~eO`daqv2>CXTE-S<`9F10|w?vBRmQ@>aDzMI|+|L^2;u1)@hUez7A
z_uk*=5h?Xo3fVrpk(=rrbWIft%^lpiU2R<(O4Q5i>E5i*TU`l-UFXs(&9fa_^sGM|
zTN4Q;fAcp#x&Eqt=wCJx+rQic^A2nUU90UK4TNiZt2N(XPj5OVO=CJ&vWwf}lX}}N
zL9b)u)-_re-^NC(C2prve9ns0nj(Hz+1%D;J6$OSPH50_;lBWP<2G*0Tzoe-7XR~`
zx%b|C_Gm6gzzvMFz2tNRo!cmmI0B9lebru<C@}H6%jFY-P6LfoO;+F;How}2>$u!z
zR74+#Q%wXZi9oG11Dk;5!Y*hztAXqA@65Se&Ex-n;<o=RK)IF6@u6z*>JOIp@H;sj
zL7<5s3i=_CD|*T1R0B_gi=2`3n)G^p_c$7gb8@|Pxn8ID(E!!oc}(uh<<*u6XnyB;
zk;9Vg(&ez254ha;);z6MgmS@q%;~5t{Bs2D{}7<u3OWLg4~?9Tp!0b`)Ao9ei=^0e
zNn3p4c7wY$3~@L;Qmr)rDnqT;|F(+U&E=-(wSMQk2IW@Z>Fr)=8;W`U7CGmoh~Oj<
zkR&TtRSUZRcugdI-dm5?s8_|&axXS)p+&9Nt}Z%i1g=&Qe)Bg!b)tK?*YxBy4@!#N
z*WcPX{?tQXlyKiI8#l9QcsAx6b@RcxJ?4Ye-#0eEjKglOvo0fOw~_|4UQQ5bKx;s}
z5->Gq)%$X)IpJ0iX-;VcB~^uHv-&b%Qsi?xJuvj~x1NVy&*hp6b6*0M)Nc1Y`|t0)
z??%1<YjtXWt)7@ZulL^l_IKWR^PkDYW$%%>bL--8L*{m=-PO+sI4kJ%cY>7j8mxLh
zP6<c?P=QeCjMN)#N}O+kZ*$D*W!7VCohKMH$n=z=nMAQnfLb}B-bQoDQmw7F<MsrT
z)<3zgCW4!vt$^fuF0(Gr*W5}crg4^wTqec%zzrY&_=n%6kM&xeZYoNz(KC$pZT~-b
zYIncuHzb$;-(~&GSqW_0E*g+}>gXC1`aAd0^PFCaD^i~%7i_fJ-25VHbnO`eri6$4
zYKhxxu4c%lo~ePSfu_G}VDk8CnbA;S<Z``@$*IjprH?JLX>eK3O>@gSR&#&)2y&r8
z=+rQkTq%h~>eph?eb#+mYxA#ZPD#-ni#TjH+maZ@u>Abb|A7MJ(#*01g3#5#?b;m^
zFcjGugaoJtDR20tj2Y{L&<~PR{o#5()R%$Ax+CTbmBz-0tE}7WO?gamJ94f|t-sVV
z?#q1$Vk?*Cv8>#X=cvzFujBfNx1lWiRT+?S)29GwNKn?+oVV)pdaX`3<<o2M49}l=
z__rsfrhd;nwKOKZYW8pb@>gVKwIm~BeNwBp6&N)q^aX6{y9TA^k`&Wc(%b6?{{8eu
zg6~q)8}>_opXswK6dcN^N*7*k)FeXY-UOfqJEvCC;MB|coj{|w*7LN?Y4q^Cxt!_%
zzf%|0`}3GQM$R=L4ToRc?TWa(=JgYx{SCS7wQTfU{G_aR=ru4uf9^Zg(aCAA2m#3t
zX_xwc?<amyDexMYTu1;Cj8=|WEt|R{mp96li*!;AOl{myr_*EwA%W-fx+NTLOVm@B
z7=Z7?L-smL5|3@VnYeEOHbt`&mR!p%P5fS_BvPriq+Dt%j=dGI8mwB^Bxls~+T!MM
z0e4O|NUyV=vtCI+Rze{uH4|_pZSF@vs_zTA-@Eq@zw|M^{cCOdn$;=k1~LJuZ<)y@
zMNVPCF8Re@`E%nx{m}<(i}P#JpBRxw8!iz5&+BnW+lEL=!((z#TF;R1E?ZsNFp>zw
zmpw?+n<R-Ir`q4|b4olIkg(q+9+x35dqKj!s>Hp^>SWdnn`7B%6ePD?#4%fl@;D_N
z?1()ak*OZjvgfuoH*`7>0h>yDq=IuQ0w9@OT@4hjBN#QOOBEXuaaUoWnE=%Q47r+;
zs^B6)E=&kiT<*(Aamc3sB0yR<vb$|>#`o7OC^zq}^{ih5^P8eui*3y*d2*cJCB@2$
z{L%0Kh6?@l^@o%wCn&8VeXCfDhn-3f_4Ea$-(#0p438YF$<r!JPoSW#JTYkAmUebY
zeJ8Lwg}f9HW-LiSS{1uE?OCbRz2a^arC6)0?Lyv7H<emo`R5F{E&^>&*bp9<fNp!k
z=I_)4(g2qwSwTy{riyB@`WN<JY<Q6~63|wWZRL>MiCmJz<(&Ud|J$ctv(NrDabnsz
z-fX%qYgf)h83z2|2mkd)HbpmYrv@cC=6NmvT_+1Or)!`2zdq@u+k<{S67?;LTMaxe
zBlr^TG&r7!&l43_z%L%p3Relir@0@&M<M_T7Duh1xFDAigrrs(DCrWxR;A8Yafrv?
z7FU;(>GgW*_n7QhA0r&!R26u<XpedBn$vQ>^^6TVYFjF{Fmy%?wiaAFb&nc!sr60k
zo2mvmtIOLXDbIk?A>H1x(6HG`aC(U|fNhq~eOZSxP3QXP(br1S$p0sxq!rDZqd~`r
zOky~AIhS>6uIYTXHBoJXW4Rnss#YYH7?YoW|F2=K2BMyllWn&w$1IGW!$(iaxx@EK
zY%s9_yr#WRhWb<70LH?sR8yPWMFUW+#J|Pmj+zZ3kVi4BL8k#!l8&?t7!2U7od%Rd
zklh`Wjw6f#-~>oaQC)5}By5M{+6kir0OGXSY>Cg^P=IZ=BI0jcYy@erHk=`GV^CFc
zCbw2Uf`433z!Iz^ss<ziwk9T5EyLJ5n~ci2+JLgM)drS-8k_;2`P&WL8+T_-dYUDr
z>vB_uG>bX!BD0-z(g>IT_sDkoe*}~|*}>)OOT;3x^n(dON5FAjY>kOp&Ey0{xNcmC
z<GP*ZPd8cy9-L`~Mk5hfyl_^o*>|Pf@z$Tgj?^DXTAwt(ZT=@%d%+Q2kmAwLiX%3x
zxZdV^h`mMgA(Qj*!E#DkUWPl#Fu9_`W<F>xuUMS(jkZ@h_D#pNy;DIFg-?YtDN;#{
zmXJ%+I4P9OdA*!duG`2GDkIkIMi|orE)Kvtsr#1O;tiOJVGz*xengO3RRM1A>B-Al
zZm;~q;SnK++)4x`Ii%lb7XngKIByPGYZzAR+qPDI<GL8I@Ve{5P_B-@m$S{YzJPO1
zhcS7~fB*ac<uQHiA7%O@gYv+^Km4=xrN%u=$ys$C1RcTEY?$JTpxa6Wp$4YC1D(tQ
z)Z?d5%m4h-KP^{WPAgk;NPPr?(*&Y9H92Qy=CiW;;%CJ-ykF^ldTXTvS~wq<Te%;<
zw;Y>*CjiOyIv%fj09?;lI>~B?SjA;LWDYiRdQI(C9RqDMTu4J@tM$xn$(^=l3VE9*
zHzNpaIEK+xNjOjNI?7e)iC=8p@S28(Z1Q4$ugqP{i1jHcKyG~L&ctd?;d!g5m*eHv
zVFfF9VIF}dUL&uGfX!yiR8fX8{lS3`{HX4xAIbVAhdg}l$URa@$Y}qBI^Ts<T9V1E
zn)i6^3Vfwv*Sy72E+Y|`O<J6|F~ESLg@svh#Rs~8<e~z&U<RXnT&*|%X%KO0f;4;P
z5m~Q~f&D?m)gWrSI-dzZK0v4i77<Ji=!8kWRrFSx=Iv-?OJX=9%16jdA~znG56>(T
z???!Sf*%jZ<%vij;FgKepqw~yPF^@!gAw6YfaZBR+#zXJO_jmrqa+B4-DWx~>lM>5
zs=^v4hi!Hx0fF3cnJ%W90gmU4!Gn%%6i|^^Qo=mWyInUWi_a)Zqr!8h+JS4zo|N`V
zP&`48;&MC>Qcn!`0QZ{t0tL4@$hbV~g{rYqYnOr!Y+$;MsEbpLG6}y0@TqWY7qnEb
z2u>5A@NnRk`=irP16HM!I&uTj0KbKON4p33p(Z~Pr~I=&ea9bkTtgqJ0|*4$uCZZt
z5(FjzM#nENQj^0Q1qeIp0=UlQH38-X_&6%*!@KjAn<2Wd!LyhXqXSOZ&gk8xo-c_v
zz9^OD&C^b;KzM)WptJ*sT7dTue4J7YJMjP-Z91Aa^*$bqx}Q$i<#!rLL7!g;9@8Df
zrMTJ7jx-^%Jnf=*Ar^~ENu}RKhq|6{Y~ymx%d-!;WO*$pZeLn#0F@^cRQq?jAawZy
zQW2BO=-9mmC^zf?TqJ^+t}Rj<x+l3aK})ixvGF@~S4~=XJuzqMol!fi`i?1~IPdV8
z2l4pKbEsGAQuRhu@PWUXEv#=OZSa^hn9T6&=6$w;RZE3dSEtP`z9hA33S7J)cKAnQ
zBX9VTobx{tr|jv8-JJq%G)J6SNlC!(lhH)4`kb0yl1!Q*!2xyuyx=6I+@hK%Ae%K)
zJmcO2I4#8`i`4~bu6{|J&J$A4K>1%Yxe9k8ym{Ljh0RDv+qPYzqnF8gwFW@)I8IrH
z2rd>kIf8z;3{4Ugeegq$fRhE?Mdgc(d7#%~V3^d9kYi=T1w`F5TRsDkIi^Iv6E2}P
zj0{pw+>p<IX+W0GUyzCIFg!2-qR{#38}1vP5x}Mojro=bRTUPZerX`;LY0A%Is)L(
z*>1NDsjW0uZ9}!7^Pfb37CM$k*9fUW)`TiSE1Y*nYr@46?jP{mt{0Hn<~66Du!NxN
z(xFcdN#J|CY6A6QMvC0HPxS9HM9XK>D7D~?!2JW4BquE*H+5xgUL=23j4V`*m`4H9
z1#p%!EAPdDKZef_MV2f3!S?^{fBQ3UsMQ@4+)L|+%4mTuIkQq#;3Vf<g?>qKP5?H&
zeTqB!6lY8;E=ukhLN*WeN^;TEY8f{{9afw$F3VWHl^mOPiP+)mi#u8}b1tA9=G4Xf
zjJou~n1HqH!p+x2&gX;^z0=NNo0OFEIdR(^;`JL+ru!wAQNUY=?~%qt1;5=k(&F~_
zOCA#Likqe-y}GL0G!xqv<>1pcSvXOZx4enJ(Uj$63xm#(mb-&%+ca8?rfGb%Tz%A6
z#05~1s#G<=5uH9b*uh~5SdCwTl^m9mwC;u&uTq6DuY~|5F>>XHu|~buaJnTTrs2kQ
zG_YudZHn?J7Xy4zal;+v==hYUgDQh|rEz^M?pIuz^CUbz1RmPz-V&fLJd{i^E%~KG
zQctdnCjkl3V|oG1J@^}?_hbHt2BlUW^zmNx^cO$0|F4SG=#EYYiZUJ;bqjLIP8%Z%
z^K^w|aTP&;W1^>5+IE*@)8IfY#A|~P58i;-o!}1Oo>dHOPHpy%R2nWBfRz}G;O2B<
zV$_Pts`iG~;afy%muF1uzVOD!=!}3X+TnsRWLv_J>2bU4+~yXq0}q=3Xs<}bm4{WH
zf%spM%IcapDr<0ctRTt5BmSUEGFhk}frwOb90$Teq5h!MDqe8BDtv@)Y1upya>H1u
zrDS!!hVwGSTV0Z4=Ug(mZ%q6)r_4Z~z3GkQ*de)a;<yZs^gtY!#OA<t;nQ*eSRf6^
zCOEDgTnDJZZ+36H(=WFAy4WDX+ohybldIB!+oqAvOA{%0ZCJ#C&brtQ46b%v4dw>!
zp$%Nl>*Bcsv;eHni*v<w*uc;oP5>5(9c~v?DIe~O8~4tDZxsfP-R_iT8+Atr9n~8h
zJcqVa>m2~kEwx%zGOH<RK-IB3dvLED(n2;>VfCD(PQ3)K4Zs7CF1x7`bgw|_4krg%
z`1Uux<-3nR`O=(T{)0?^C{9UdcPTe}Cx3`wB54<op4V3Q+I&vdB&YOEigoInnXIWd
z1w*EVLk?N5nZ{7M)sW*!Bn=EhVTW^@ZXOc3XDJhrr4>^oI(;oEB#XFtHRyW{8IP6~
zr^~k^vW|!g{e9JPS$qNLbKrWUKqMhe7o5lTw!|<{BK^a7;HxS^Q$Z}d0j}YX@FqJp
z_U{`W6sMn@&ml8Mm!;Hb%HHkUB)K#w<!n|$!w{<wx#Lq!Y%?g&KKFv`07I-<;^+jR
zvun*YyV^(#gN;Ov%Jl?m3xfz}skUuliiNaK)Vd%M2C5fIYWrXai6;=t2EwU)h<<R^
zwhJ5-`%o1iHQ`&eCOnf_6g#FNMLnLhsVl-whk;F(5V<FbT$cJJbw`To#@e#@T3H1~
zwZSF+5u_C19e?e1tbXhgn|$9zKNKjN&HC+B)ZGr7l%X^em@c<h$`$zO;D6MBq=l`G
zAgjLVa+i=BnHO5+)JF+Ua@l}83)i??MPE*xUQ-DVnIz)T09~_ElG#*J`S<9=CRMU|
z=>_2UoXeQD$_|L#x&j{s97QmRPHB>X2N4;JN@^ZAy<V5X@@ciae>;E-uB502ak$=u
zMcHTWUtNRSCIsO6B-9s`et>p8S&=?Cw0j0>a`c%Q*>we-_AdDk|MtH~6zcP~ojYY^
zsfGt0Pypg_O~B!tw5tKjG}qKq_50mzxy*n#=YC!c2%0UWA~H0w%zS82LzE%a*f@3z
zdLv2y2DfVwsGtr(4)VZ}PZfujI7K))CiO!;2OkVNhm(3H#5>fgD4uIJwI~;kJu9B-
zvbduWNT?7bMR#Oj%O>Wxa!dZsk0Qd&;m4!=0QANC-uI1CF`+mmK^f>;bp)dZr4^8x
zn`#i!k2w$tiqCdT?41lmbXJCfCg;euqEgHllCHGGmQAU%Dif%F*ssA}72%+(hi)Hj
zVHc8V<->~x;0gf%UH+i5mbr7ShKGTNS_bGCr*?uvR`PY3n=eZLs6%?9rdVyQrxgf!
z+%@QuJXUTtE51Zqh9<|PcVIxWb7y2NkJvfD=BSmWFVd3SdR68Y=V3I&rG)V2uKi(2
zE^PWN$pu@spg0Ya!}FZBf{@F&9Z7G?ZS*p7MG})tG;IYrb<hS}MKyqsE+noeIQ4dV
zKQ1FEc`WWjDipy&LB9T8wLDWW>y%0`QuFh(YF)73G|&jbt#m0+avM*0|7|~vLtSe#
zTYu*jzf*Kag85IE>vS}mPH-=Dm|DH5e2>&!9B@OFN)$X8wcwo8ISEo9z)Kx;W<4)E
zBj+XBI036JBSDPL<VsD_%QMpBPeZZqlSCX3A7Ye$;g}Zy>J^*QE~_~hL>&jX5IlcK
zfS^6mgbqZ#tquJu6bwQH+p#VDdS#d5upJDXb_cpHL`yYOgPzur(H&zFkGjO$DoJJC
z<S<;$aG%$0@}fpCEMwzwWo37=OXBNAEW8Pwvf-B8D%@T$${v2KB+njb$+6iM^f5%`
z&tX0Mp#Ct*XG0zdfV%`3g+Ye9+hY@ty{2@{8hxTp=#zk+1|RPiVlF0_pz9HsT;Fa$
zpTwtyWp=pINYvdGfE_TF0Kh7AaVO@T9rM0(J-6kj(Lv$}qzk9qriKCUXd_}{LvqH-
zGSs9d?qy91=NILcYi%;HeL|jk5Qfb9S@HJA#RoSJ!Pqen+s8fR)Jpu$j{~~3CR_O|
zT*hOLXJ0t=WxedxPB)M8D)*@6kG?ZkncCP|>yiYW7UP$4o>M$<+Y(0QbrWtWWLM?r
zd{_p?;*zI<0T)DNfnxTgOx<8dY}XXKISA(=JXDGla=5T5ktJPnNYrNPjR=;5OW=WE
z;D?bdL|v0aalM>v$xzI#L^{8V(izQl)tqUqGPcZ^w=Ze}koz*WjN~<N?Y!Lgxl@us
zVx%V!mJ17I@x&23MmAC~6cbmUORl~uCZSfeoy?zg<kk$CT`tSwYLbTm=Qg>00KUSw
z-ytDCU0;0?hQ&(G=0Wl?`5z-TML56}7p<2u-6UG+PH$*q9mRPSNhKaggmxvTHe~ox
zb4M<?h)aS~*BVa6t>Ft-$Kl{8rlC)}$HWtxlq!x>hWMtGy5WuM^5En)DbMgoP@OKp
z9l2&JSw*?i9u>Pc^*(I#vs<_Oe&2s!@lDa4Tnpc+MKX0k>XIbRQ&-e_r1i%s;wkF6
zZr@~4=8m1&5FfFG7y4mVB{7_S=D6H^Ye0!il_3KlQtXPa4_powplwb?G3x#v=?%6O
zIBDrmjzcevL?yohpkh0pB@2gXW+Z~nN;(6mfbFS&&L-WGU&}z8m81j_R<41&fg97x
z^!gIgA2MWc*eAPpAzyOO2!6x#mv-9baqSM%(cfHqULO7Y5&7=%gtR&)Xqxp1{Ey&F
z$R@IL^njWj<UGQC<?iX1K@2=s$PX6`fD12!j*IK_tr}5fnd|RX?y3REsV0JuM72S$
zSKqM>Eqr%pUafD~$CPU-nh3+&0KI*tD(`uFT&mG)<#V4tAc0=<8r8=5M^5?uK&r(#
z4Ia<<PrdthfA^2?)BC@g=?}yyDY`59^qmA2N08Pf`9m6<TLG!Jp&?X<)lH6B&8<T3
zS(3r&J$NVx0d{)ftBc4jx9*aUzpx;WesfWN;_cuc0Af$SAEVc&bj*egqZWR^c(f({
zUN7{y3=ELA^o=3I8agTgNqw?sA|&}F#4R`qshEi&VIe1}vzvNdF4dF^%O<C+0W5V`
zogQaRR?;rGup08Nw{~RDtpm_Gp>|ACpX$K1GN_JcGgdIg2i6Cd*&J(dIK#yxn8(!B
zlaiWaP@-cM8H-J*3?c4Vuf%0OOAcy^*zzjsd-6z4%go4J3oaZ7c_xfDq^FUBA@FJ+
zvfCqJ3Btt%pSLo4{IQ6V3`H1rT9;HibpI)iiFt~5O&YLV7X+7FUkix?8Ascu`=LT*
zVOiT`=gvO4?AnNY<3B$nuY2E!1i&pF%f}HdGY1imrMcnv0;b+ZZC_vbFsA?Sfimbn
z_0eK|2*BdcVbpXjZVgCn$f$L&+_Y%tcP41i-Lnlzw&R{vL{paKNcB3bDM`>s$_Rke
zsM+M<XA1J;H(-Q=b5-E{wR`%Z3p&9`q2C}Op?4&q+%`6d^YHc%3?DO`rU6OuO*hY@
z-$+65!#e=|sa$PJ5jt+R2q$okd55O;&hrYv-4jF}qzA(@5cUFAHQ9d!Y}GKtcN&QX
zQG^sbi`*1P!_+>a=J{^}r0oN0xlQ`83@h@7z|E<5g-j5djGDVB>T~z1Y2@ne0=T^s
z$Pq0U3|Yz|UQ_8HD;?nMxFio9I=N~N9&*@n)g!TR38B0mBqc+St`;Od;FVY(V)c%i
z0&5d0feXIeBBTsptbT-GBuF9GaPM7mGF6dgz9N&?3`!Qi*+dj;V$XJ&Pe$a4!*;p#
zZF917_&PZ>6GV)^f#U`+08FR<_X4E8B5u>fDDqa9Zy+=KL2@;JAWo^niu#AO*yeW)
zNX;p!W4d8%XqOSc_u{6;Y$zRow$`cI<iJ-RlUwh;UhI(oe3vEpli&Ia7(0gC4y>+&
z8@nn^=^$q3g|$05wM`i<k-@Oyh!@t@kRTDj18d1SxQ|k4Q-yFLCcL_C$Xc?5RJBdb
zjNpqPo)#H!!4-n2PY4D8jI&l_Q-jGs`i3wV&dqi35xMK;ro1s+7b9L28+@FGO7%*q
zd0w+^6Wd*Yu5mF!ZdW2J{soLI_4Q@{)*5Dbb#2L9)eH5c<>z_WFh~T>e|=7jZ(~q(
z!J2}TpR~MUld~^oWe(u-KpJ@G;ZB3jT4{$Q5voeKm(iPw1iWx<g~47y42hOYW$3Pu
zOs=5px!NuN@VPmxc~Y*wZLhdv{VH1Z$$#@8H<ugU?3bR>q#Szup!%)>slMRf_Y&h;
zd~;iSZboYE*gG-%xBUKU=oN0;%Xei)P_15@;2KkW<HYdH$tB4JDV8-LIn|DF>Ym!b
z8R;)dk0&Xoa}yHktjbGAS7d(SVTj*|9DWHS7|!*te<7mWEGJ$vN4R5&qn#h*My{?)
zrE)>iYbBJcnx~#kn<AM2Y!b*g4=>y~<0D=rj@=$4WdMA2#C<h6-Kh260!VHLrwhW8
zUMYebg?w;zfm;?3XD|N~+(gKN>FXxi1_n*zC3>AXC16dFzR5kw?Yj92>Sv8q9!U%4
z8NgX_5tWs+wktq#1wlwE)J@cfAq@!DVbgmh+lLWaJx5&+K1UoYlP<{88uabPsuWjn
z6(^P<#av={;W~n81y~&lbXD8ne1;$<Aa}fdSn|ttxjg!e%)eBZw|$U_CVsj1qp<q>
zeoFQXj6;M!ubk!@lp2g$L~rGqRzUI^NF9go=P-HIpwvTB?fkv|F(ati_J2fYh7g20
zZ;}xjie_>`F4uab_F>Y0Nlr=wCzsAi8VSEF<jS2sA;*r+tDo(i9+&sMV?uGpe|PVx
zjZ>+WO+XTGBm^I!f1*YP@!}#PHw2)|=yFLs2rH3`P*>ba<dn6R`M|x1hsQ#QVnB6B
zSDn&}NRi8HU>JC0+aRreJoFp{b9eZr0GRCqBIzZ&^bU7qH{4nA%b|x(nfj}DM@VK5
zm*tax4Xc05uEcK>nc)OE$%{fX62jVw;$&)F3i#~+o_U>m8G#x0Y%V)|9#RCZuF<%u
zmufLzhhY|v8nT=T0Ms>vAUnt>Ft4!$<BHU(8e;g74FxYq1_6L~ynR4^`NJ`lmH*;X
zDS6`gIoWsPq`dtDw}ZvK3GTZ&`Sw>2%isUiQ_?@-+HjI<AZmc>bJbHTFu5&_#Bk!O
zSDiWZsySu5llzI)R$PXICP(B6P<#_?1SE-o)K)nGsY!`$IGRg^vdkca*c&w?3O$!!
zBX60W1XqQR&Et`SdA~gUgdzSCGFkvSQg6_Fh{#7%R7V0u4Nhu;2?&MA!s2eOA7VOc
z8yYO+jM{i17o<_pM2L|3BiDJIrU<XVMa75bhG_2v=LzCrCg7|t*lLnpM$RD;K4K{H
z5^zldvW{?Hv4ZmgAd3~7Jds6A|3pVt5p6LkE2p7?M0*hLMrMu9Q>?fhG7!XfBsgdy
zAPGb(SwTonjdY+5j(L6wKE^J$UC5XNFrCz{W@PSQT@h*@_2U(s7r7;`S=}rAhzC}^
z%Tttm+Cb49w2Rif7(Kryp@E9rcG*F>?SG~JGma0>XbwKpb8;ozcV8Xi$bmB-0J9Rm
zUkaFdIk)Bdt_Z&wUr$)~f2H|X1xjWFIo<W?Uc<D)tl;DPa95e;k5E)=*H1jgTt+-d
zaJfXJD(kQ`sc7luRIEB=ok^uwhZ7gh+n!OZPs#vXFIgP7o&xY7QR)C8(s_7zMfxW5
zrlaZ<Nd?^%T}EjY)m%eS4MP?W1qKfQNS6!GgUf>~p;g8b1`2e#64u|b6X$C)<aEI<
zahwb3;2Bg0fkXCmK{XAahJ64GbmONNaDHbDIZ^UT3gN{)lgR5t`rLBPDMRoSpjsC-
z*tiY=+Q5|DQj2hkc@0d8Xe+IxY~Ygk9Sf(V@zaCrpk8@lnHLO|r7Iyg7@J6}Xf{ls
zQX(Kf0yhBnv3viZR;qh&<1KC3RcM2;+-$@mSzLgrJJPLHUQQvpgT&orN)o%L<w|5n
zJ@TdJ6t}b*Jl1pdcSD>N7&j3lDChB$nq%^L*na>Ku7{cR_%EBk`|inKsy6#>CP(yi
zAUXj&MrNuoL~14E&z17x^TW9d{ZU7A2v+zw)Un(cx(WZfq;fDa5P1=J|B>i|6E%Oz
zfz&7;A~EaWK&giwK)M**KD`F~dWfUrCNg8oiDjzEKpXL2eDAcGK!MT)8=^9>HWeXr
zhS4KUd`Kj6O60*H2^Z;J7+4gg5je54Ifo1mvdR(rLu3yC6x*ip+j!Q&1T6iSO(yyc
z>4PpeIAE7Cl-}+cHRL)hgXdl%C5V1RYFgl+-#zbugWWE--x83i9SBh(V$(!jcMJEx
zgX||H=!oBe{agSVY!4*wsKJB)7@}PUz}~$EoUaGR)cT~Juj6{N;Kp`jRpb%9DOZsj
z35UPe3+@SjYQ4ieM`ZNiCt4lzSe!bsAc$+TwE$j3l&Uz_;c*y~)42a7Lslv_+r<8#
z#c=$(x>x+?^piP&H)fDkgkVD-5;LBCdJ!pnh}t+Ysw~7vPTn;xC3iofxg8bNY1)x3
z){XLT>ccttjl#&A-u~|U9)9?FQxUfuW9#gz;*`yL<0J8ePg=|KvXX%$L)|g!RJ@HG
zEGw{fBzm$BV{~|@a-J(dT7Ic7ih`p;9SNhz@b;Uco{a;T!NQJcjKeznhoo}uv>MfI
zs0igO#5hFY+HxCGT8m|JHQaCjG~I$?4;{&cCINK&k!O%&kUP+jA@xK%T^+71VfbpC
zNNv;Ag9E*GdBapo`V#P)BA=3$Z!Cf?7~t9_b)=t;$S(E6QLm}EioDM`o509NeTq|_
zST(o1>kc@-;qp2%3;&@bFOxe%vXrh!G7bG3`W{=Sgux{%7-;-ZucSC8*IZ3+a!l&V
zByvuIlj}&-B}vpDG1N9Z2)ynfx^-+NN|d0B+4JW4kxNo7+TGugNq8d!iOGeTKSPS!
zhv7ZAN@e;}WRuK5fKz4r5AO)d_!Zk^?(hZWOt*4N&g<|~Gc+c7Fe*ixyaAxa7)~95
z-+1M{Sobk=gIE6leL+dleZx%=$t;|Z{;7bxbk45I7R+`dNEk&Ce4~MsFoel;v6$8?
z_0M{YHCcsm!!#)eMl*?q4&!UO)e4uDP9EY!Dd`os=KS6|^i7AX7oE`c=u1R~c=rZV
zH>6Ifm3V$<d>2(CGB8L7yE>E*d=!6(5Q0n&LhubLOM3Ipg~J$Vu(X34x}mv00eArb
zB%ND#$gv_gRv9jtv_lHeQ%S><F4=Q4;=`DqQ@S4F)C}!mFvVktIm7>%O9FlCCa^si
zR4DP;Agw1-6l<bLw*r;R1NNr!U3vg~a0T2yrlwIfX=7?igc8&Nt=_1?*&SC@f!Y|v
zLsKF*f!mMw+hi^Y&Wi!X+WFDRYcOO!jWgJRU&<gVMpX^x;~hc1W>l`)J1@tcH~~<)
zV90V%(A{Ukr{7st%!z=EpsR=mCg(}~o=fbP*sDzb{l1{Q>}uObZ@T3+IdUv42cDfp
zGbjFxA4-2kaZHwCl5}HEZISErHLo4D#o#^-gxSaytsqpugxkUvi6hkuxr!@jRo7$Q
zMRG*sJ}Aq$1W@vZ)-lQnOs*S1_6|8s1tqF+_@Wbd_&5t#uZD8v@SF%fk_kYFqZI__
z2EkRJzls?iSL+EpIBXR72)xvKN0Km1PU3+T>&QF=_)4fD@*vTJ<d62s6<5LKggS>b
zB*y5rkgUOYAcb*_BsWsV4J1X_9A1f|_mCTE#f2q@EYEbHi$Yw3+wnSR=~J!f1Eb5p
zsMES;1+jcT2CZ@}sUxBqYlx0@WJi&i<JxI_)Kr8Mx*>E;8%jb#T?3J8*K=@+cL#9}
z9)#(=hTOTwkbUD^3rT{(fiz?}`oPD%qrd(Ib78k8%7gNcS~Ck)z6gumE?3=rjePZ=
zj$<3JTmJ6?QhmWc4MaWVay?IQMy95uwRB;GOz!(-4t-xx?z>{go&16Qdv8O0c}l+d
zjRVLCO2dFbW=<E7g<M4v&^zoXmxYg9kv4duFmRgrO+AESn?z$r>4=zj`U0}{#8V1*
zd_WB_6+SGwY509~sD+rU9kFL517pMk$1*YuCo?{@P&N3}fxG{d7{*{wBDf1c1K>+1
zJ2E$G<$AQ7oyuZ1cO@6&n;jeyM~HJ8$;P{PA__GYk{!bhNsNS%&el+Flt29wWZVZj
z$f!qlIP|&zculQMw3yec!-kY-G<L?v4CUB|vlXHkU{9MIm~O7q*o&^NAPg&t+yDj_
zT|6XuiEIF$1}MR*Nzcc-zX{z&fi?sGyceM3nNWS`@9iKMV8}JfMP`?m<}iQ&;AB65
z{=~DAdf#bD^u7}o_x)WiiHc5eUC$Uq41k*G9hci~8<+b(e^_EeYD7pim=GUq3fBM7
znoqXO<yLOlJ2DD23{s?wY%C05Tfz7_oYG_Xydr&1P=4&AZ~cYcI|kLxhRmS=Oc0a4
zSswk?Jkr7rLS&;be?6zxvnGT^P7N3`<d$?7(O>EAlx3-bl&>xAoi_m48<*uJBvGuN
zK?u<VBo9bHl9G$if%ejE!+G=O24RuLq4@X0;6mU6saPfmjC5O4D$WP412IeL11CKR
z{gZyhldE<~)|m{9<3k-F@cI$q>75SBRj)^^dxujln+|UPPaOdNba#!^B4X9gACUVO
z2ITo;c;NWi2)J<*`dxn?x>z8Rl3ZAnyo&K7($cM|;c;^C6_R@n^wgzydt8PRaJ{&h
zEssb`F)uk}O64nvc44~`&b<Zqk0vkbytRHvuxei?_2ia?yK;Milpm&%7BH|&P&LTu
zfBj##r3b%taE1O#=+~<l2m$l)lTRFZ@N4p>|Ak>{2yItf?9Gh$x{`raq@Ku}+<MDp
z^6dxCs%`j>fFzM?hVh%4G>07AF@_SBAW{QOt`I;KsK=hWO>g%~)9(q&-Pgq4iP(X1
zqN-9?M;tdcjuP0NGMMnl3&&0=P==$3L*t`WBCT6SgH>3jP3WA++JOio>GXUp%CQ0^
zv!{_X+d*ct^)yXR$tCAc*<@-LGJ+OSrhw~<Veqc!4SDL2$w}xhTwOFI1@KW!Ei2v4
zT*uM|4>E6theNXeX0O~e0Hu34AeWE8T{D?Nahhpq@^=V6wsc7?BGc*QoQiS~+^0`a
zkA$Tiu*))>?#m6kOpP)X4-Xh!+=ddU??D>cvyY#UyWVrF?1}D`NB--VVZ`L{V24q%
zkWql-Z?G0-X(f%C9k)ufpk6&NfD}HgV@@N<fXjjIvK+3pv|fkvo(&t|W`c-cg<)kS
z>e_Vokh{{yY9L%`tC-hbDTvH3Ipvq{ZpsAIf$uyHy>bG2@FHDX=qv}WY=>u|1Gn4S
zp+A@GJ3eGY{BaursfmCj(eQ~3UM7Q=Psz&Bvl8v2>+j-o(HxS~@v(8q!t0>{$z!mG
zQKnNIVT<eUl{s|rQMqTA7({>Tol|$R82~M^j$;Q3jrL)!*&txw^|#63<UaYX`!8j2
zC97KK*->C+bUW)(eAB>L$Ia9YOEq`2a?Mn(BQ$WRUp1gNQe2bFsUgVkm4#*0h|i)o
zB*fW?8R~fsIdvYuguY!@zE9IxO|G}^riR?nH!RzSnzCakBjNFwndvj(mF7B9$qEZ7
z+bu#|x8&qE5I#(06jvq4$xR79ZNv=6p}XS2-F(}yR9!83@`ak%qk}T-Od-7u{ztg6
z2K!ym74vfZrL4T;UtKA`@aw;?dK)cvI<oxDhoq26BGlK_S$JLOkj9>cOtMHWF2liY
z0*K<>4<~34MvM#kY!scig7J_HY(ujylrU&wn-|vqWHV?$umM=A1@uOk1E1Sc6-Xj5
zz+dLIed>T+21b|(MBgX5u=%?ksEs7o0`Bvv`)#r7@0RAuFG+CM?aK15p%g?>rifI%
z<8tHvfZTr+phhxCk14Iui_?psN)dSlK{;A7#q}D*b+cp+GV=hC7P+=EHJ!FI{|d|Q
z)62I`UlEkd2=XImk^V%3`GU&O)Ez7EUDD7q3Uc-KRasgefyl;?BcZSfeI!J2Ntn=u
zQk2Y4>5ps$O+ZqwBtV@I-3Dr=o2fNb+d^HEA59vdTBjTthL7-;eid^c8|bJ6o?g`V
z^pARFWIGaW(HNk<jye*gWSOn|(EI>K%k12oEPgd3r&0K&fw$Tf?*uqQa>K*mz@wwG
zeRM#sMW#{HGbTIwTkvC|s|2D}|Mk8X!Q~bakU>Qzz!(K!NoUTi$T=7<@4e?;^1)yE
zJ1jYZ0d-b}hWlmc13xWC{_!6rb#6u?u^{}ah^WBup|0tHPu1q@MZzxzRvBg%tmypd
zoGih54=d-s>4kv%7vKa~;V<+fF7F8;jEe-8=wJ^33!Mf;&=RcK9Q?+NvH`4A2Le^Q
z?4JzC*<%YbwNvDccbSG?4F+EteoKmTq?f2;tRfgtd*DCIzU$wm0BLiLWBD<Oz+X(N
z*GI%a;_mBjJ|>TR+uVoE4VYZ)K@vnc?UE^XQnn3^!>M2F_B86E7W>m3h8jwdp+TwV
z*5C2HGKXFfl#{oQ|EkRnISDeL=vI*c>hm82IB^$Ygkrn_uwRhxK3$QJ_P=1;Fh+X0
zfmABToTOp-skVITDCR$H=&(+t1+*4cjw2P#Tt^TRlv<xG)?w&C1lVEuQe5;+jLNRT
zki`3t{o<)Xp*NE(3XnF>pIVkwxg|#Kv<m+*B)GI>-aIn~4DJI?yKO2V12EV3Al)lE
z&?g-fNR32X;va}f1P!NpqMNs*fF3#D{nj!0#=}`8#untdEBcY09grN#OPS+1JD*m5
z)ZhH$k98YzJq!`Ms7iftCGygW-Pr%`ciWbpe_qaf`|AiifKw!t`$Ao?0bru46(8gb
z_`UM_54~A62src7IcXM=L{d&k1<e5}7tp{8dzjZ@-YXg|yl<{R6oVY<kuNA=xX)~k
zpbSj)NvP(M9RSV#?S_nuUr>=Jf>G<;R7=p$Ly2(CPhSp6F@Fr%Ry26-hD`r7I3x5$
zs8)6_Vs<ce*s;XhyBGEE8F}jA<8t|AOJ%epMH@zr7cCLtJ+YPLEX#>6W|DZOrk|EN
zW_}q}s{Z=zxROh9%grZXUaR`gjG#Mr`8-B*PJyr`d!SP+W8MrvQ_rLrUwYv=$r)2J
zLcdv;nz#}qqN#4R^Eo`|F5naxVVaXe5|Au^SkJ7Akvxw&>&^YWh#MC4u^@Krcv}Kv
zwUO;T%8*!0t;^THv!q-@7#3<vay|XPLQn(9UE<q%<?4MS5(h_VIR|7a6qml;rv4ZU
zFGw&NK#6S(T{vL0Atu%==b#tnAZ~GG7#Qqh`M~GT$dd<G5ur)IIgLaIbii1_KnNi1
z?eLK~<*5I}r|*@^ulqG{!7qYaoP-~5x175G)dhgKcDvXPoJY9ky6bFJFA{ve^#H<*
zK%pWu{Rf!*@Y~uDyH988a_pgJ<o&<>Q}X7w?v<6fCAHP;0-DgktFgMetn_z!IvVRq
zv?R<U!h^!K8GX09au|DY@YRrm>Hz?@qjSaNM}9+QANq=P4xN+(=*zB&I%Npz0R?mn
zoVbHd7iSNBK@xAi2X_|3z<wvfjdP|LPai|u#w7_1CFI&&L4Z;p#hfxLe{sPpQ~Q!U
znp#NiNHAK7Iwt!?IqR=1!Z*=i+4IeJZu=m`wes%UuY#;aY8rf1<eaL%4|B3Q_sa`M
zP@3r*+t`zUYye0x=ogDAq>Q0>ohl-MNKoq1PVP{T4N2<2X+&=D0C6}?^gSAAt71c9
zF2ix24C2vnU9e<e$kmqTAQ~7`?)Nms1;;qjPvnZLdnJLu^h9irw0rxM5!T-a?iNDz
zBO0FuQ2<8WxRPI%dO8hGj<+>HwOBfhbU7sPqE=t&Uhc#oLTM16*d_{B$c`u1<e8^W
zOBGE8$_ATaAwd`&Ef&tKqPE76d;j)pa5_(W2}n|G@JevXf&wJJvuDrkyCb&M831wL
z4(N<Ot@KQK8hkxF5jxE%%bnW}!lzPBE=%F$BPiUuQhbedgi_10vo9`As7CwtPeTNv
z6aig>^SKfdbK$&)uQP{4T{fZ0tgZ+FTLO3+X&5DNv~RQLkP_IDx3mXk@{ZR@=HLnb
zl%j2W5mMbhApK+ga`y3402Gda!F~4ge=nEc{6Q3;-GJXmoi_$E9sM@PDHxgiAi{^x
zfME_EikMu0ny{@0z6VrAvK98(W#n@%Ey{HR{c?DT=Xx<9^>6d#0CmIliX!}ypp5mk
z?y=i<pz057L*}5X5sUx}IH##=kgcOz#9CAmJ59Zz+=y)$DNSUIX8|T3ZXzQM)FYLV
z0|z4==JZjfVc--|PfUFdTPP6fbS_3N=p1&IU{%BLa7M#21^}j!WV;4YHiWqIK-`e`
zfBZkl_RC@$pwk!4^Q6^SMO&6;GXjpH*FgV*o5O<$1<3|ilGj!2a!UA?(5r_g1vw@`
zdDpMP0-iJE{+B#5K5D807v|RF>MOU)hyLhu2m`vjwc0<Sa|E-pO?^!r82<=JQV|*7
z1Cw64Ze^Q1kMGnoXTSX*x@auJCm9DvM$@h)YT%K~Ja$<xobkw<zpw@o3XYw}J;43y
zWM{BvLHQi*9z1v?Jtz7xkou9#0;hSs$=?o16?p)p=bl@VtE%5bD6uV{c+epy9)D1-
zddn{$8|c&0hpNlYZU<aoaq;fBURrB&Y9DRzoINA*^dk>L9l2A=i=Tk?HLcbgauWaw
z)e61T-L9+T*4L%w{x2MW#lw76zCa6ZF>uS&IxO!#_^};Rs-v)#Te7XSo5{!BmjkeW
z01kei`T@(oO<vwzs6_Xh_x!TWwg^^9J_j;zgS(!7yJI`J&WbD@eL{{dq00p7MMzDE
zHmFFdp+LQe;w!idyvU+q@&yeXw*6qCJCiSrfe9(BuZZpRL2<)kCI~|~43iYlOG!m1
z+%`0{M^^YUTr}~4giQB(<U9be0IPX=cSnBq-~6QPy>S#b18qq<N$6jw23$A;g&b*X
za1l9S<?@CE;`nXciZ;q;2|!XUTSgUN1v+wb6OdR=Ft#8S*nT=R0C;v@l)cy2P)-{a
z)VZM~V_B}caj)F-$-f04^Kg|ti(@BnUFL0cASGuZwXgw5{#F~(0xnhAK7!<lR$7W}
zhcU1l1HO%BDw(6ujaknFD;fG`4UMYWXlLy(kaLO>-XfYUl%P`@xQAuv*BMCaCI(s_
z-OW}Ov$DE0E6r9_^6-?Gas3Vysj)qvCo(Q0(=nNDpO+;3sq>Xtx%Q4XN@HwXDi1#|
zm0lYXPmt4!Do+P|l|c^%Fp_;c$mpWTIQ!BGdBZz@RouaYXmc|!F4Wr-3zVD=JJQ{3
zQ4G?CJoV%<GTFgE><FY_$i$GzGK1o~2wDsVV8o`-`bMqijQ}~AA_YRVGgK;{*vhHV
z$DcUy8MV;z5AyF~qUd%yRuu@9q0<GU=8&Dv9FF=;Sv;SGiaD-!rr6d*H&7mKAl+b7
zTip6pbWFaW8>n&mxY~tcT8Gy3F*qfctV6Urpz92dp-8@t*MFeQm7KL_cLXI0(@LG-
zwmeU75LSNwn0SG1UkqM9#BAx#s8-z2hcUV#mgyAc#|8_5pTaWS7T}KTe@-G8`LPm9
z8-Dg@;AI%k%j@3u2Kne85ReN1<VyfBey2-rmlt{^21J)bQm51(ZgPGxBV#>w7#~?%
z@r5UB(X|(m%~MbVkd=<rwyB2=4kOJAt*iNQ2V=<CfhWNMr!$&tg>hYME93B@;Xn_1
z7!B@G%X<dKQK>lqV<&;m!*SJ3?&-7W8HAv~d*9NLBZusA;lMYAp~K(=crM*^=w?@)
zIoB=YK#)P@0>IKAK?`l9tT7%gNc1IDlc$yL&A7N38&`{EKcv)rH(7+$lXZw|a?9*m
zUV7?F=0=wP$^r+YAaNcHU)AqeHc_)L1LfGL^Bz8Af>7y?u(o;g^*q-Vk1xydc|<-U
zkS`XZ)4UERZJ}gl|7b_Kwz$=%Xf!~IrcNqdMSa0PCMEF07_KJz3?tE?Dmz`tw3NX!
z47bqO(3LX1V@PdQ@4lI#R?30<Km>!@C?O>goCGA7(;>`HLq~t0Qxc5)5SS#+lUqt?
z2>Wyg8j8lesL}a_U*0J{|7+jCR%!SNS1tmi+8O^;9d{RudKsq#Y7;$=nl99*<9t)k
zpvfx~exutr(%pd_3@#VzH3tW4*hwB3Z6p_T=_&?g3kJ_TI8g=f2I_&$$q!$DvJMvN
z!ZkXn*nz?jk8N9@9Lnwm$G6K6l(Yk=66Le&f7|t9ykN+~&mpV@Vi|`HAdKz9Kte)_
zCuYcF-}*yDDc>RfAyY3@{z@<?9)nmQKCZp<7Ih5$kJlfD%c=~^e|5bi6OfeDAFW{2
z+ftNQ(VDT8Ir|~KOiwQYC4=RO?u{`G8gnzvIUC?|)YlmGu;GEb(c@7Q!-{_Q8X_Df
zi>B^K?x;B=x8pK;`J?mCgWDiA9}gvm)F;Mit)z5HET|&u$BDxI0Ai+V7=5I{Ns-B`
z_9M&Pd;n_UmVX4ICL6?r{!T7QPO8PY-bRCy-;D;;3K&RgP&%&Fn@ISwE7Uw)KCeU-
zh+fSp^)~vu%Zu6{s1~z_Uy>#UCb=Z9lb>1>Y6g-##<#l^cZ~G2d;mUHs6;M=jR?Xf
zUKUwF?NHC?HavK=hFMvWB<g-h%-Sba5w2vDR}vY<;UqfLfm`0Xttrnu4zY`87rJZ+
zdUyvuTR8H;Et@H1kM~_C{Xf2cBXK1>g3O`E9+vd_BT&oUsS<wasUYzfROM`)gEG-q
zK%^}qXBWUtEX3ONdK!I+AT{~6v#kaXLCWO~#6r98^s($s1KUDB`R*&;$*=l{InR;7
zlc?9DNGP2~ROeA8x?L!JC25PB^K89L(XB&@1R+0~bjEoEC8<>yG8Em>ZrLXD3$0v|
zVM9m6Cqunxtp|6>`dR@FZe(E(T`gndWAw185o-k}!ACEF@)Q7!nq%_!ZNVuMoXC1n
z-ys%h^yv65m+5(0?0Qfd0H&&Bq!$82;MwVi>k`Gbl_;`F1fvEdzjJwVc0tz9WyJ`Z
z9FWU-%{4S7Nc5tCRu8x{+5wU?wrfx;07%ZmQHV0*kOE(;l13~W`mQ^!midu274w-~
zkKB}>BI1kVF|_h4#AL2GBCo#@+4iu=zy0-j+_yft;tnL4K)?U;<0xT12N4eUj|*XA
zO>hdRur1@^ZrAIS<xLFeW(%CM;Q}r4%dgt0e5%}+BAnbZ1QmnSf}fSi7$hq&^*q5@
zkAxw@@7bd^>i)Y3l$T9)?$HlJImxk+`VJ9JosCHu99i@E1OR&R=!p7LXd7ZSPU6W_
z;Tqvb6Tz8=6LzqEUWo`MtTN?{+)|4%GkFyc9`_gmLc+u33b4Af6&2Hl7fHtV?!*K1
z<6Lm(aHBYYc#b?jg0YUw7IJiw=8*avs!7u)NsdXE5dD*;j}oI9BAoO7&~9Z(DsF%W
z$cLzEy^Rk@t}t%|Txhgv0V4HCtxu8@UWzEXLx{#K&o0BjhaO9hd6zgaJuE#&Un5PG
zd|By{J`Yq2l*Ez~vH>i~aIjS%lA^oI2*MOp8xprCaUZ&qdQlhk^z7&cw><dJOG+(q
zT#qIMNbqeSpOQJGw7{ufGN-f`nM}-rX9Vb}hyD=&N0Wv2E_Gb~)4+80jjMaZ8lIlf
zh%AFM>OshQ^8^x9;CoZAMxhATqyeeFbK33vyRm2klnjzPJVS~zQgqqv_)&04e$>2-
zD*((NLM@Fkp+q;iWD!l8NX!PhfZmY?8bKxCieTq2vTy>^$}Pv;^J;t6nP{R2BQTk~
z%K18^lDE%~QI?R>B6{4wf5!-h52d(M*X&ihZ44fK(|Qh9P+S|ZNUif+My^Ri$kW@a
ze3dkGnh2X&N$Hl*CkZlr^OY0XwqI@5YM$F<an>C%PY$8EqkcHtgn-ndJ3YSyofhsf
z3|c)9DY^#-oHBsxts?@axT8O;I3#t*Cfa3lu#+S5qlvmZi6Ets!_r^^l;rgHs;(nD
z2Fe(^JJd3A%lfI4a_|Tme98Ny_X@N$girav$*x80f1Q*gdsOH#gR%{#%B`PI%FN6R
zN_F3$?g!m~U-`@<@;CqPJM!)OO;1K_Vp%S~dSW9vL${0ZfD5Wlb5Ogq3rL*^{_(Xc
z<dPbok-^08=yjZKfby=l4c+Q;;RWXqi%K-&a`b}$VL+b0S6m4jlU<)%f{O)>G)b;1
zwmJWd<PSU`um7=MLYIr(C|$V#zKtgG@F|WD<0jF4fj7?1xB3wIS(illxbU5Uz9|3z
zKmbWZK~$nudKIuk5L(4HkIUjM-{1fecAb($c!d$20c1<lz!`$bB`LK69Go0opQl=;
z)?WNigOmxYBm$D;Mrs#H>y(w^N%h_OPuFvEStOEF+?U*OD^aW~V}=F|K31aWo;!J7
z8t6)a0z6ZP#C4NA=rK7l6;oEVs|!XYvayc3B%<YtE7G9J;yVFqB?486bcUipd@C8N
zMo9%ME9KVYTXUByZn+nh@sp1nRQHUfz!c%^$UzYv7(}hOXGUzjj*UV#CU89b#V?^`
z>WxZV-}iq$E3C(7AEU!h%*tQ?)>jmlebXJ+Ap3qu1vk_W;~%*t8zI0k1U!`#2=zKn
z^^2wmPS$?Wp3&>o6J~Jy>MO%abQ6FYgnA=R=>n;pdqT3d5t*JSBetEC^qCi>a^kR@
zI(<sM{;fyl$8KCxEkPD%(duvCkaBBmkIl=3cTv3$@CxsYIwUivyKn7K-w8|-r*s7|
z!IzbAWkfFWYp{kv(F9(LvS*hP(Q1MIN2R;V(Yc5^CPld>a!Gzjv><7H(>=tGCJj=4
z4<zV^H6O6zlCZwD8zh%UA56=!xxE(U6y1!rkjNQH8k`i}sSC?U21X7+6^XOmu<Ysz
z5|okfF*F1xI9_!}FjDmLL!FYO#Wv@IXfGH>c8(3AnFb{@`cv5kaxhV(21AHkliTQh
z$Ym$C!M~fwv)I*;H(uS6mFJF_c?^>~ln5^^!svnTmui_0%Xa@*RQ4xCc0l5e4~krP
z?4KMoc+Q>Khn!G1oaR1x-J5pEP1iViO0u*t4yKco+2;=_x1H|8NoP8_CELaLiwG?u
z<Vnt`Up`f?c2$k;vc7@xUFv}Nr$G7MyWjMSibLYzZg3rPOnleGdEbuz39XYea`N$K
z<&g)E$lM8Zc}4bgY;c<#`oI4`{^(<0!FyUpWam}Lr9&z{T^m>4aW?|>QRxGhoOB#i
z*(qk}f_Y?eNh_yhA_bESXy6nU@NO2g;$vNjcWf6*JV#%4P8aFEI3yzun#dtFm$d4a
z1g3Tkaa-z_6y5r5vr12e@~^q1-F~||q^rqM5AM8$7+NgB(d|bsN)o|X>9!dpK+~Ad
zq1QTzksA&^>dho_NfH}<@k3xn!NC;4z|kU`;+h<=P=s$2$r_|4GK=_H7WF}cFurtv
z(KK$$sV@vCHw>Oiy;sg3*sk0|USx4S@z^<ti~UN3Q-5TLF*%=9$K<~?mNtXx-Da&c
zc$%Ke!5B<D%$&um?f1Mv_TBzt^4EX*to+q)|AqAXVOSwRv3@=+Swy7rbMvw|4>uNS
zmHdsYIv$N4zV(cxIVI=0Y^F8x5zdno+@1E$Z^65T8%`b4T*3cZf#OXM_#c$d{_&c;
zfQSGK-B}PdhWx(>$`RT~SPhSkOJ;FhRxcDV0{ier)uim1-iB7r%W{6XDsT9S{<<uP
zhmKpF*3aM2;+s=C(J8uPlY`2@nM0=mCiU*Q5}7Vg4JHN=vxZSavJM#iojyyWMSta{
zUdeUZ3a2}WK1%|UK-5&oAlU>&$9Vt^18nRr%mv_*B*WORj2v)ReM{7G{g0x1D-oas
zCq?(!7mi7F1<5C{y1mHHAf*aOUYHEY5W=Ob0}4Y>BS~CQ0lFa_<}Bh=mNu4pVAzn#
zMI?koQ7{bPF|z4|0i^Xyb{`>7U2waxKLi{clEi=rxdL)1JuTzYi*OGW<ZIu2Ufy!o
z-4c5<k}D1`%3prRE+eDx3S4tNe3o_DJCQ*XSo{`@MvCyGFWfJ$AG|?To!Y!HG;PSr
z$Tqip_VY*O8{bUIoo@)s^!9DYcYqOyO4km0BdsE3P!~e^5`G!ki>4DX4rs7plBb&!
zhuLs6(<mf6o=~@b$4SwhsXpS(9K%VldHovvUtq0$2!<xtSB0Xue<XnBPAB9uf9I4P
z`+H>1p6=blg*TCj4IT|W!y|EY0=sbLgk<ss365`<Ck`gXSbA2XZ+efsIq_YOJ@1A!
z$Jd#lQ9f>}CJjjXE1B-ExFix(Y2ZW<60>21PVGj2Mhhp``&y?I-P!=wBAcAj$|bGa
z>v@7vJIx7tn{fodGy$o*tkKBvB9d|`eUit~qMK7DPLQ-1Up_mB2MXP-wWNyOC>dCL
zJ~%Wi=>{JZ+qs(J+Vo8#pA({&`lJ@cJRZSEuBbss3!I|d<3S7SuC5vFH4RU_4GpK!
z-Zgot6jzq^RTId5`r3>fJ&gjgJ=cO;qT#^dmYg`(lo13)5EMd-M$}9pyqP(VdY^<L
zM-IZ6xn>B@2ENY&%SgsZ$nSjk0XcnSRc^ixtPFZSBW{{n@P44h6nvcM$C<^u(y_jE
z@H=RWgVGNpgnUrEcnh-K;qR(hVYi3Q_HsV@b2!FhPA2m{`uB%X^goZb$LKeX6fP3p
z{D~WBf-mkui#h+W-1fRWoW5y@k(kQiL$_mAxhm@LrXVeUY_eD8XBN@G9l3z(4H>w4
zQu+|be)!Lis2b~?+YmWN=ZBQZ(Us^XC`q)sZ4=uSmz+7Vq70n9*BUZ9dXwxJ#RH(|
z#BUNfieo~bw2E)-3Q`BdKLS#Nlgp~;9;`$)tnN*XQg4mlhSS{6my~J_31iKOyiZ9F
zLyli`EWH;&O7Tn}Y7lZA#W$BxY}124?!lf!EC!?Ni_UWN#gcjnZ<y#IFbO(xQMjiN
zDs(wph~JywRx9z3dL%(f;=CDghc8oA7{YUbcGea2;UxK^Q3cd6qEtTUb_11wJd?Rv
z?s)xCx%I`0Jo@!#<nrm8z%38R9nUPu(`O*@77mMR&y{Fczy<_m+zBMrltr%IiR`<p
zpH)GVU;5KisHHlkx|d8stzt7UKQd{mC?sq$aiL2DB*~51X6n(b(T^MJxJD#1BW`a)
z0}BRFSjv*ZcAOvEcK!RnB!AtReBsc$dm<gVZ09cIMxt>$<z<(ccFz|RonJ;)@vt8`
zcLh1SN}+&qQzSV+Mx*Zpnt67i*}<E#O30WQL)0Y*tFVq&ePwegSwH%M%oY<eSV^f0
z#B>o3N_8swmtch88rark8~SUrF+2?%7S8*StuqESAQ0ILegd)D72gCPss>D7B_>Ql
zwj;6Om52bPaf3Hw<IE9F!ob$yMef5_G1CVr;F5||AIcQmAy={Yfw`#bG^hJVrE9@;
zw3c2J=05U8_HNXv>+~}2K#<NObVA>xm6*u9YZ_rfyaXVv+l1&1;1oyVA|9~WYFcwl
zt|sV6<ciRk6es2P4JOs0UTbn6f-`^~P0Vm-@1tQnyHkrpa@%!hVDJ>=V~-z|{QGW}
zX#cgc{l=7h>omCKQcG^efb^ksM4m9qC<b@h<sC3?R`4dczyB*pu}PO~AH@1`=$?q|
zxw<9AJP#L|AJFAxrAD~`W)y)h7QF+2S=fB&WQ^+okZtJa)H4=D`kf7x3TSp4waW`d
zym_QrX+KKQlEzyRtbnXSp=NJwFMzj-c6_NUE)rQKcH99cy3Uds$ZTmt2PE-?NC-s2
zE#Z(AoNxvW>ka5sKARUW6g4gG!{>QZIW{(ly5zzvbjd;FMZ)PyM=T>a{Rnrt{QG3b
zE(}SKiZpe1qo{5mPml>0CLlG>?rwmI=8^<t4IwzIabxvS(k0|Y=64{pYH~>e5)Vg3
zauENe)0{?*wzRjVsS%KxwD_h@Nqw?{`$jHF2}CYQ1BZs(z;@&i)cGPLTG8-v(nkrG
z&<3H{j21PCB3z4cEta+Od}DjeWK(E=&=unjG)<*5J%u8&T&AO}`8ql#A3r@Mk=KWj
zFj0^vpE#u)<I(Fxt_!#143d+pvo%=p*NR*|fNXS;H(p`#W0sj@@!Va&1Hs4-sn=(&
zFQCv(6PThR<aDb-HamRT^=>(~-iFg=3ptlCyaMQ1O7VXNi8{^dTFM@r+W$0fn)PKw
ztfnIvNvx_%gwT>0ac$Pau)BlPy=f$<jqp$DmYA}JL=y|3NL8bz-dm`b(;cL{LePn>
z=f|MCk{WnhgX-omXs9rjj^Gf4n#eKT@cEG(c()7zxb>sA)l-UYZQ!_&0HOVpG<0ee
zJPcUe7m?zY7)0O0X-?72zUTque3~NM6yrLqNYU*@LNJ}>tQuKLIgof^a=hX?)DMsr
z$(*OyrXHxmjhGUA1R_6l0g<R{>SYAACiP-c^qeP`B#7zPWQdY)rC?@J%r+zE)=)kR
z_YmXZ&wlf;Qh%5U#R$*SPoW{}40H+*yBJ@)dvmZIKV6Vj_*q*3W*t_P{`g=y2O$xt
zzHQ}_JP!S^E^tJW0wI8CB}!9L*n>BCGzZ#jRABc;CZ3|quNTk_7Q&5yB-z|}*CE6=
zbpem!1jC4F2f!^YqgibU@zJ%@H88u2)r6e1fXoxV-9XnQGsH;!O1pxTuC)!Nuz36H
z*<~ohT?5D8gObki;f=#7?g+8XP$EB?$O$!Z-uj)(30CcwwE86VKGiBx-@qwfM%_pb
z^+{UpTa6rkr-e;0T8a83qdN1aFDTJX-JE(edr1z(0<w1utxX^-JcxV+Lh$DSG=3C=
zX{R|kqyi=mN|z7;##fgRyqaqgj8({GTHt(bUJ>C!k^`<GzBH8vkOL8+3PB1m7hoCp
zqAm5o^?q48-=pH;#Zz-~5JpU=bDL~`9h~?uY7QMbD+hn~EArgaO<5_K42Ge|#}7K;
z4@GZKOM@%+-6T<;Brz~xr6N>8^gKglrO8z_IIY`o9zE{VqPnl~0B7v#h2hS~1+w2X
zs`f}4kkluGD5T<Ny@q-c6l)FiqZ1dJG`$j0uOyL6GREtG?~KHBCQTcL4HSM_+$@Pu
z920<BU&t#1XLO<?@#%f42#aEyr3_l1)Etq(WI7r}Gu=K`Fftq5O0>WUNTpY%P&xqa
zNS%_OD&AooKvkahOX~f!)12QKg0+&0cSE<-q^)m$H}y*RD!Zb)fDkNI6pC&-%iZYs
z#{TU-)L~F`^CQr`NlheEG$_j9ucR}ap+mR50BaU6LG9MglVcK~K6Jn;!DmSjdI4+_
zm$Tnze!Z;3c?BtA9lWox<1m@Y06Nhfo-rdlw+`6k+uu5^xFzG^cT9KW%we+yB5QZD
zd8DEt9!_u;szK>TUr|lum=xv8$blr(L<7g!F`0xNZ+4Br4@$Zem*nzB2Wo~BJ=Iay
z(=v8`k;~LjpkC>~!F))GB9TM#-7RV!U@hekEdW4CiNGdDX`=|rp~@LHxux0&|2%Me
z5ST7EPuSeo=}D+a4j&Ms8qAKNIP0MC)!=1sQduUflQs>Ui0qv1!#SBQ4jz{vyc8!S
z7o!L#(GS^%C(VhbOWf89P6CoOIwTr44U~D1e0bM)e8L<|+6Bb^=GtklHoC;WWF9Xb
zMayft(ySDO=Yq>9x*hmUJqV3fSd|4=A=3CpGm^^*D;*!c#f*_0a?EJlu5`dw6;6Go
ztRX>zAx8p~Vw=FzoU#T0^F!YxKjfa|j-)mQq6RCw-m&3+$d-~bD?J+#p5<qrRri(g
za5lSI!)?$`bGE~2^dY+`Gbl@VlLq@DF?oc5Bt_64iK4rS)`TRwf;3T|q?$*4Qgz4c
zitw%6(u+6#lGasrRP#9J6(}S7-}QC24k7W)0h;)_Uw+7bd0@UC&VkX&n;XJNCRMS#
zjpzXl9Ex!*!s`%M1SW|hyp3!af}SE=lh<C6;Y3@tac+W*{N!6u_&=K2FmPgn$kJg{
z3Gr>MH|l*kCC60R<NzW8NI+_EYKJ);+jIpnL#Wivrs2L6*KRbZ%0Rhx>VejE1#KER
zrqkSN<Zxe26w#*DO+C^q>e3vO89@vyHsEpKAf!Z~DC-U3b;J<cRha(;yb{?B#~?W-
z4IMjPu0&#pQMreZL%=+O27&?94H?&_8236&PDC&gbo>yg+B&BQCwFw<evk;(SbtP~
z{75fcg=PQbqx+S?Gu@k$M`u^+xp{M7?HEV@%GjoA#GFf(GQ07twCLv4K-mbdheUnS
zK!UfG%6R6Ks9Qluj%g*Xr#@M1h8LC8#!3~@ak)H?7%1~(F?$uSy~tNkY!8Pgt#7LV
z#De#Wg(7YsOGdj!5rL^mrDt_dnj*Z@LKofICYL4m7y;fG=6doB+zV?bW&WI3GMK;l
zJyUY|kKcxN%rHJ+(3tw;rryZkAP5OcD``NYbCB4;IrA$?B$6T-0OhpW+GZuAfI||H
zbeLCBOO!xDEh<^MnlX+|g)e@WI<(92sLf`HlXD?OH=|tCCu!u6wAD>FP<CZamR~$8
z4RC=L1}0M&NK}2`oWb>&2A~IZK8$dXOZs7m5RBxCB<h(I>n7MBs-ZkGx<iejfdSrD
z#^|QU!Q`AU8Ua+CjXDMm9}=TH9x@xanqtw8OrTb#xa+36eej6KF>A;p|MANnw|h?3
zP_GkEZ>carsk_z9%%b8HK4@}Dk~xLI#j`W@NmI(u>Q;clHdTN&3Wh?4mR%>Pk%tOb
z5IsGbJ9h92LXVg3K_;mL|BlBdDNf0Eoa8#OXV?X-i~zrf{b{<y*QJrv!2wztJADaL
zPhb%|iLRlF4yE9G6U_*$L=oOH%#o;DDU*AU9(~CsPdyJ2g!v<fGjiX7kQ{iis+`Ug
z-SkIl9nv~2)=&%vJyMl9P+tT<wP+{DBp^v{FOJb|mZh_T)G~|czLY*$%Z#Y~$!Q7p
ztws))Tg5iZ97wdfSJ3r?&8w)s&{0mq&JjTEICOKqnwf)}H8|vuB))u<IwiRy!Klk1
zxGvF$)Io623+LBVEL(F!azb)IExHLjQg5$Y>6DD@Q0L?}Zdmk6_r&oTF><z6#c}$W
z=P&MU%HJHbNq%8TK7A%EUwskf2}sb;o$Tl;T0wQe<42Hw=)n6N@w{nu^G$3die{@T
zNb8am-7rTLXdO)$kr<rZmZSm6dA*GKq$f0Xl*>q_d4(DO@a~7mg83Gz5%|;8>wLSG
zxONY52flPEjOsT2up5qF4NR`1_~wT%0M+gwEyBq;`Ht&)+tmH&20EPd%IrG2w4q~f
z8GgyZSW|XR)a5&0TaX7n_1B6+(&Dy~))T|1@1Wn2nLh*}mlLS`Xfe$QjV5x;1`Hem
zlI|dKO6rv)opH`yLz;ZOZ`HGK%Evb5^$cA>Rk$<gkJQ#Txg|yV(%A(xCV&fN74HCo
z2vare7+^FYHFX-OAcP24fW$)1YckNuj>{(}(YF)%1P^}xIjIy7t^>y=$7$i^p;UKB
z1R=Sp1|Yd1-AW{KPp+dBBse+sL;Ye~n9qFtQTfEDLb81d_p51#epppavbZ00$%!kV
zx*_C5|6~<Syx0SYQjuJ;*@0mNaZXZ^JT<rZuZEV|G;-**DM6aN64~&sN{a3UL<=dc
z^>!Pe48{llfhK(&y>)15Q*77q)>D3H=+rR6xGslRh{WPR<Q8HVF-=;p<ag?pI@6l_
z6X4V<=?<!(!vkNs6pu3z!{oYbC>n&}v%Ut0{=%|4q_(WJ$fglPVquuFrU_2y#6~f#
zJ{pY9{5cgm<hJxf7Em8ea8iV8BZvB=H@?VCR7n6+xJb+)q|=<o&`xu;0{_T0>Gq*M
zsk48ypOVoXrfX$eXe~W!-X|x-Sj3M6Xbf^6Txtw2($HzP@W25^e#kZHx}ooq?;mH?
z;^PmUkw+gmq<)s=tGVPEW$;jE^vBG|O#`p+Blt7`+4P>4H!XC!i@037jp#ZuT>Ub0
z6zU1+iiwJPMGIfw!se<>8D!XxSwo88r!BzpW;Zw*IpmULLhS58|KlqWyNyKAOVmmf
z+gmBnwK=L4|FhONl5K2BCDV@A3TsP>);B+u3@#WgRtP8t(yNHlwCR-HLLIc1-bw^x
zt=q1d#tz*@1UZQ=Ahthdzi#$kY{6H`9ztvyN?Jr8ptU3%dmx=qL93cXkkWW5l+acg
zfYd%nt|K5rUbI5NlzJqAN+5<&d%@2u5{w)I(&;<_>vE6Uj85~deogHPB6p-d$q)5N
zigI$w>`F?Cs|B1t+-bNLW|q^zJcQOX1SH8-0l+Z0D@b>veo1hW0)e7TqEQ!La{u5z
zoRQ-P7FDZkw##PgY&yW{ztlzzMLD@2iOZNvN#ZM=N$GTVP{0At2oIg;)dIM1m&<V*
zwhwID$VvIOvyh5Gb9wEYX>={aZ_M_EVYI68`%r|(_o+iY<@}|H5|qSiW@wQFxB5k5
zTQ5^9@vqY`zN6<k-2f%Oq}SV@bGec02OzS07hf$$7E7X@nLvw<<RW?}Vw8`LLTtbv
zMG<}}vUlAB+GXTLZl2<rFqNoR>L`w*I|D(c4#Pf+BsTh-pE;xEwJu2mhTM`sq@Jj(
zVu&;yJ|qyij9imb%`qvmtwhnSi4Co``X^h?Th!`8{l!Z<&8bgn!$zm5>Eo@Qok0&t
zv{k`-Ao+grRwIHWUcBNtiT8mcV}``ObR=?2TH>DiisF`6T(MVXR($fs&mKctlcMau
z5=;R?!R<%h05Y&N(SgozB0mIX5PnZCV-6*COL9wcMQxR92R!|sBr*rxdx`l5HZ*1+
zI2orVjUf3Yc-0;?NS7B(U6o+uM-x-jG*Ru-2^d^P(M?yF4lQEn>P<JMdRYN4N44sc
zYX6O`FvF0e(T48T6~)%~y0Eb6{BbthN9SAUl>;mcdKsBwRqK|fUWrIWH{3|hNhdn>
zN*X$<Weco2O?-O+MTn-;ht4CZqbp9kE*}Dp_0!A{Cor|&k^2yc+Nj}oa!E}}rv%5;
zL~%~i`XuLdMV})A4Ijje@vTmCE~h?8B8Q{}PJl)S;P=F|fb1t)%5BW^O%=O#=A@^$
zU%A6nPy$AdCOaJWt<<b^5PQG;uAh_B$!p}P&poC}KZd{^RX7%$HWo*7E%=LdsV)7N
z)E%v)!;sV+2~2WO8ao8*@+vabu@93qXuU6>+b{<`8(}dwwkKffpkbtaO~JmS)y;ds
zCbBcAyCRp=#3r#!YoWn%DUr;<6ac^px=Xo#=mO%0{!LQBy|=x!f$AnAumMAkF6a$f
zgmWiyOCR2evpffP1oXoo;^0i)pcPIQO>U{&LfDo*OHG^ZA-t&yVAOgg*Hb?w>Hd?{
zX{bwTy%G)16s<0&H>_xaksOhLB>0-e8Hi5QLtBc!G$1)G<;($M9%=JGxg>Q<9adx~
zF-6@tH|JSaN}?LDm8@1c0cj;wtyo@z-j-2|$@TemicAju(D5LRE~m*Mr7v~i40`{B
zBzE2V<>q(%1z!I=CXf8xe-ysLhFS&%2tPEG;)Cd92VL9)V?;%J7#k;9fT?v##W@kt
z;gm7()O=EblVU#t2}d0miA~DbVWU?4dKB}3xMoCh%DpC6W_|zZd2nM$OM;QqfNM`1
zx3nFs{z-~%W<b$@sU@uTQ|hVy9ZqTF=+L5d`9+|lUYRY2FK`1dvNSnDnIu6=+!saF
zU7uG0lo>?Ta#_7IhQQ=W5}4`(5kgXqbbyhhIVR_uh&T}Bn)Eww_?>zsiG~k}{mzpM
zCpHo<xQu`#;Alw`e6*yQWWjlILjtt`Pc=ohp67QGx#JQ>esO(PN{9s$n5qMW#c57`
z(lCbcZkZ)z)mx1mtxxJ)Np(>CqkhR{Ge_rDpn$KYqXE~C&bFn7Y2lw+uF2VxCAokG
zs?E}zOx<+5OyB-Ha@|cIkd>L2<i0=oFf8EW1|WHC<^*_Q%n{h+lyv8~q08y)Ap(sC
z4Qq60%#bUp@7;0<Wo^SC%Hc%;+$Rq`Hos;L7^+K@N_@AaCU(Z~!O#i&MpZkPxpO!s
zB$?kLs=2L><mmmZqMOTz2}8Y~5IE>2T<9<(r+OJ(LFIz?m_Cl4Zla^Rgds=jl{_eY
zlmz5z(gX`PVYrde9TI()Oy;n<hS>X?L{6#2HowzXNnNK}hkOIk0@nppY61Rfy^^IC
zB)0rxJqV*Z+L$5u2sqo&KDCW<hO0TKA8?X$Jq;S_lLW3N0<u*`^D2fEkreUYh<gwC
zxbExD_Y5!q2Ed^AMu1=eyGW4~)hOAjwu&uTmK}TJL}~lUW;eTuca!(t=EW(S_}OWj
zO|jz^+p(XkY^&L_)e9|=k|>J3qW9iAX7GOB|D8WDgeaM$w4ZlAxHE%0_uiSg_uSLZ
z?|4eKCxg++!8?G5LdlYm|FI__R5y#KfzCcndk~|`b{^6QWWrl()=XGSk2%o(<0mv;
zZlu*V?!MA)_~>8RwRil5z-HTQr1jf&;@GpQNEP&9<+9!Ak6WjrX<86a-M&b}y{8Nh
zwU(ZUL!!bVDqLYiq$SMitI@GRXH}~TS}+qSAcn2t<UkbKMl{le=@*=rjx&LPac?F)
zU{4b2NsdkPHmVzYl6<(AjO4bH3Dc1HWJG0kqpE);>XZCFua|#S;vMYD^ob)6Abxw~
zz0GKpLY`2?!ou`JJWr_AQ^MI|*&6(*SA&_%I}Bo$QsjZuL|V!o3xep&YSfRVqeYWE
zcxbv`M<740T<)}*;<f4Uplqlj>`1NC|E;IHm+VTdTq5sPFRd7-U_<Q+3irUYgX*$e
zN*^w5M4VN2qRQ~6Rgh7r_}ogG%lv>lDL6Sf(Kj;*U5i0VF|Z}EBMAqcIxU^39Di17
zzZ?(!Ce=*7bTr)#EBsQVv&<Od>pya@=9d5NVmPfY)N}Hy*3{gnW-d)>lS<|0R!Pix
zUk5m6W|~997XdhfV9pukpUHDmd;voyQ>6wljSR@Um-@!zUJwc%q<OL$f{G$kY*_Z>
zxaNaL;uFrviRoTjw@WIuuE5fYgz0{w$_^Y>Q<X*-qPkJr;q>%`JsFnThjjv5lw(7v
zZZrf8>FvoJHIzaA|MXZOw9?h*GrX{|<5SYkZiA$UH(ixT-qs&Z$>mF#3r>b`%Veah
zjZ@6Xf&n|C#D0JCkfhgwQ{mW^NJtEPPpEGwq+oKgO*x?q$GmE|GE!C5qZ&h;9VV?p
z*pk#y`qw-+H;wDF8r?dipeIx{1Orm(Lk^qDAJj7HI+-E8{m43`CEJYl2+g-Ja9I2?
zdCt!JfcrP9;C3WZk^GjEnshCC2?;|I5}H&~SpTVZU65dN#_t`MlxbFf)BV2^wg2+h
zAF+S;hhMaYO&?V&$iIb-KKEC4?ASTSkX_wz>uVfXs;2QDi0THEpX|=q=(u0)p1p)5
zV4hG+E;vq3JYQo|P~l{8aBRHCT~<-yK&P0>OYj_fa#$d#$;70HqI@xp?Cbsx1^*|7
zyD8HQN*7Keb8!4M#+H<#bY3^Y%7=omCt<(~IYAtU)M9Elke<UMk!M-AlHSCW1ThC@
z%3n@SACY>bnj9yHm{Z*<6*1@=VZeLBu5^{?vMpiIS>ZCG!l^tDiZ+%%3Z};cC;yGJ
zgE@db$pCpDs=)DqhJ+|aywb-i{pSTXBPqmyIayC#WHK|tfa5BPfC(Y~hbUFct59)B
zr9LBJPc8?|6P=4mQ2_SAo}}*^PaE<nMx<t2TfbXZmOtnUFX&sjVb_fP!KbdZ|MExw
zVDJ0jr<IO7XfOTb|F-rw_DLL-3zDYZN!aQBCg}<R@hAGB+=29f)WM$5$q1wod2#GQ
zg5@wG_9IN_vpMWXsT*M-)OK-k-cl7hxI<8QV#p18;<b-*Fu@I?Yq2<-xJEiBhYqO#
zBSorRG08=#tQ3u!<|c#@A!G-(q-RD{H#5@H5^+<ufdL_GNSKrb)$L2w^2_TVbsMaB
zKnA~wNI9mCzIM%GOa&4;CrE%|m%388LI1-<12cjeDNyWE(x*p^3VAQwduOZ*>`K}u
z_)q_5Y1of4-Ci+bSLPSRZDde!HvLdS6*R50Zb<VF@f5oyiFRadkyMh0zQU`<R+RR4
z%!owvp&l3z=7V^~-}h+hQ)A<ns|gTGB*_pCA96u+PRPW-x!I_yzLwrkyg+qxVdkW6
zA<~RW`&dugkZiOO>pmmo4~0bUyL-Dey!UP^jDB?S#Hp7<Q|-TRXO5q<njL#=&(&Ak
zsZ+-U8at}8H`&cC0yt0-VRCL+Y7?8xEiBd43;lj!l+#`7s)qFC=)2(>P{a$9E;zNS
z;$KN9>_`YHxgZIPnoraAlNtox-l6Isr9UCYnTTavd@?tis7H#`OYLHoL9|31KcQf}
zp!_1L2AcsXSlmZ-5H%SyN}#};wBz_np>f^!3`__Lea~krXG11pvzUdEG~wMRm8!W9
zO?o(g@5CD^;m9*;k@(|Kc9l4AMyR){LY6h*)zc^{SU<q!#1rO>3!*D*fwXk5WjoBO
zNJ9LQU`&6FB}tu%*8buYIq|Ytf|HRclwXDGH6=?nlwgZFaWHAiNnw>!OX+&G1Dlbr
zij;J!StrahB+Q7kWC;RKY#A^l;QB&=am4E-Cnq5-37T_4GV+c`(j_8RIyuQ0LBUai
z$6l$ys{9dKwXMQxZ~25(mfs{VUr~bLFNV(Ud&<JmGTZy{kJ*~4wXV^u<z%x}uC8>I
z={QFM8$OT70@VrGg0eO$g`}Wdk*;{mk<V>U=-kXmY*Ge0t=J?nN+c)Yp;-j1<2~K9
z3MCDUMP0iqHhiX_bce^~Cy2AC{f+88lU{_t;v9KJs(qnMIc^n>D2$cvI_JdrdOs^G
zOHAoDebYlmwo<4PGFY!vg+WNkxp=0FYa%&w)hC2KIk>QH|6g3do@Ad3G9`TypZ={n
z6}f60iL;Z$klL6IMeItV^<K_osvfdH&dH1%A%WNF?1)+PV<4D<%#I7DOPymdM^ZJ>
zR4Qn6N`M7&mS(%Tdjq?LeXuKuS4Q10558V^hdkSU_2f`Fo)Uz9*w&NJWAnea8=Z8N
zr|qR>rqXQsSdpr@RhCy$p^M;Ew+b=BVa*tfY-a-p-k+9H>|XPL>ZVj}q`5`EK{j%R
zfLsOU3S!4I-+RX5LkI1i-zm3@`mYKid+p-Mqkj|XJ$*=clBu@ieRpZR-sYuawY9YA
z*Q!KN7YhkX@rsv{+@wA>2^s~`5he?WFE1aRqF>pJ&gpPf{c<$bu8^Y&@e(!m0pr3x
z!viV|R-p>eDOnoGni?B1>`5OqCpHXNKN+18T~jG(H)1+|D&39^Rtm5xh%(G4bz(*Y
za}D|024_DeF=&ZE5~MGeLO#9<2t|tOCQm|ak}OU<bbe~l9XRojFd~vy1+Pgt`n52l
z?@;8K_+>It4T1_Hznz?Rr1%$xWV!-BE;~!9F@*%EG?`AsGdWIHB4dDENvL8eUYP(<
z=;<C0Vvo8Rk_o#KqV#Mf5&H2I&QuSzBqxM~46A-|CCv=w2+;o)x7vq&lDA<UK=&{t
zgc_%AvhV0Y`^W>oWO-YD=;Dn{hyE<odGr;_)%b;5f9XEQkVsq>7<;s>#fl1ZopUy&
zbR<<jo?u8HoAh3{dk<BY=yb$!fgvHH8A!*1Vx?|nNA|R}x)uyq2rTstL$WQ+XH*$6
zq|`e(<hvQZO1;6DLNlZC#OcQeSLoDXNzMsjm`4U3!Z0Yq6k~W*?LIv55DKf_HDOP#
z?9o9o;y;l6p*b<=^^)9DPtVHKV)8NHk|`tgd)i4kGAxL8SqdwVnuLcK!3LxDXh7%i
zlmI^y7u-w8<PYFAgNLvsQQP4}NMLL<U?d-_M3q3;J3d~SUxuue-PJg+!1Gb}+7$YM
zU`X%e_*f+>+&eR#2|aU8E7O8a+0moao(g+G8S}(wJRp_{n)`NI{~l73-tKd!&bq1~
zzh1q)cJA;QyZv{5)pow;<JQ#lkR5&XA^XZ_ziF#?@3ot6`LLB1S372Oed0P!n>>Cx
z471A0W&e%1fl>ZK`Qy?ek}s*ZR8uL2Tq4CLbFyZfT}fXKEww&qPWXoo$ZSpSq#Yt9
zF6bB4TvFzS{n@RWg(20;LbRXED3I<W9oUov?iFEj)UQhO_<X_%&>FrIO=1MaA)o8^
zP7bpmGgU=|VDf=+x1k;=^6?IjFVL7440dv<n%~wxza>**SK@8Q^o5{mscDUzu~DgE
zPy7g1j-~fvsmiS;IXuY{b8<>Hs3fId7m|*~R+*X>gojiJ5GGJyfCopX#?Q?$)W4{l
zrZeL~;f3%cA;Lb+$w^2{UbCRCS(0r_wqKx-Rx~fbEDHrr1;KJ(Lpisw+PzO@kPp;*
zwT;S6CfDaJNxX5-R##8?uYdFB_U!kcx96U06v)5^+qLVL#f(D6kYt2>pEzkryk<Oh
zR4&qEXe@|LqPlT#=%WUV-#IqyoM?&QCAK8%DNRE{QocrvvhjGgLOA_wq6~=w<Z={Y
zNNO&Tl&JjP1bQ7II0n}z6U7)1LWgECV0R$mq%3GQ-z4VVSn+@fkSeLn4Yu+oBTnfY
z9Wks|-4ki`=as6hINbSFLdkDpSCVo}C6<`DS?Sk_$OeKLk)Hb5ZkIU)QnS*E-JL{L
z5V0&THBsT&St{GoI#f3cYTVl@RKO7afV{NiHRFZx<~$Ab4F>7OL<ndqqrf>gNJ~OK
zUPAiq9dk-Lrp1NBE{052*#+6bNvDX_(_HEX_mXy6D$PAZ9(m)S8>YmY#3X6?#g-&s
zzW;^e_T@kRoSjkO$brXSb!Zg7`#%r6<HTmWmY9(hFeqW9qRMjDY&O)=<RpvRSPw4O
zEe9v3RG+P>5ZI$QEG!U6YcLnm(5YnEjYvtdH`%gph0Ws_7?llCkscs<s2xEP6<9@x
zraUrhX|ic~?L$Lkb1F*2%#pROb1_4iJO%8W+D3JgT7<9-lhri+S`a;3NJ$o$kPsIO
z|05}b)(^Mon@ZJ!wabrhDJj{6lp_E?i)wG+;J%}gFb^2rMVjF1ihy<EDD}^k?SWkh
z<9Vsbafnyar$g}7*IhFIdQz@8<^l07YAQVuuk?0hrpA0g?X4qAk`alRrF13FLy6)J
zwqda6qS9BW?3`jvwGcB7^z=xbsa{jBy|gUSa7^#yupbmo1kHI(&>R~OhQuMksi6vp
zMz*%&XPtBNwSWGB?R)4&O(4@idU?Rl9a5dZO&?)*6-fVFmht(HlDAV~=&m!Zazqq&
zB)*bFNF~6;yy_mG6pXZ-J31W6%s7$?C;v@PH&QZBLI5WxyP&`^ERq$*q-+iBact23
zKDC$h1@TCN=2P<m_m{gxj1rrY>LB1*pvFeU8z+SZqDpg^$vZ3Fp2W$C3HoNi&sfqv
z$?-`Tk^NBRkY`RZc+ilr+tI@ApSO6pp!e;!b?6yG#~w)0Sh{%)wQTPVL_CEV0jV!p
zg}_A#yzV~z;Kd$^Jpp@q3i`g~*~!^S)6YrQARx*L(^62`s8rdT3MGZ5QWg>g!Gwm?
z8Kb*4MW_;~nv$zA#j-2=HQ%Ljt!75I2VoziWBTNBep_Xln!u%NBO4b9DRe3^NWknc
zCej((Hg}VxhF1Gg%Y4^p<}PPX3QtH^zuHcoKJFwV%;@3#zzlC{?$l(1QQKIi!dt~+
z4xUw2l|G}s)a+v){1DN3cXGVS=Gc%gcOxT&TFuirN?B}oVKJm6svG2t?5NJqfDR*x
zh<Xky`4F4Y*gXj<3Nk>)KzhdLq|6H#KPFEZY)V=Dma0q(bucM&fmx6)2dH0dz?eXO
zIxf9_KKIRcqYxuELxBEb;*QsIb#wQr-(DSxx=G~HDH<YsQkCyPCPu9%`V0t0Wfplz
z`R=Hi`~uazY#NXQhhWkI)s|9#F&8fB_>2GNo6os7-s0hHnUa)ayzk{NF2<{*=XF6{
zU8G`(x(Fk(iBRQ8I_V8}_|zDc#(^_46O%`-@DGfq>~J7C6LCzKGa`>0HA3+)Hj7G!
zU8Oc^+o^Fbl-eaSR2)Lch?B~g4zsNmRrjIK(!hiv@QvhQt9wYbe=7Qr+8&o=OvHk<
zk4WlB;=zT3f)&e;evS+|X)Kb)&T~?0!Hq|I!)s3*v~#Z>alI^I#pzi1T@0HV6Y?;*
z?bX}j8t;5lgz6#+ku9mO2dV4ZCb}Ejb%V*Pl|4xiJehEC9Kn!crmSo^BQwK^z_~tC
zQWA!wUNY(?vCcbbN&GUVdP(fakWzTFa$+)6rJk<NRLGl3*z9qghx8#O6C`0N#0c!k
zgcR1cDM}}%g`^e5kf?2sg5ep=J2{%;s;OZVJ1es!-h(00rVvFKL>0(^vkrel;!Gxm
z<a1v5RkzXGJOncPEjA$KI6a@!%G)qsvBsN01MLFm)a{4|P8Bm{S#;?^U=flF4;WG>
zOX?g#VvbA(c8$l<A#Mqri_ZZ0GB#i1M=XsochH3FONxFSB1XcYVLj3j!lNFZ5b(bk
z5;cuvWPus8atrjm2&+VwDuld)!@lE_*YYIWx!pNagnFL%;j;pq|GItupT1+q-e__j
zE8p+*xk-Ed$c#PslDY<UVXI10t!q%d>szmI$1ni&l3IVUO-WCZ!NCq~S6AYNnyqqF
zz~PZ{eaMG)TZf(@CQT-s98!%QbO28rhJ<)sP!h2`O^DCTR~M$#H>p}EDgiJ#r`WAV
z5+)P&Bpr-^4lphndva(@+sed(a71CSWb`;fK@c|S%6^=nomOU<7!vi3zX4tVp`h7G
zd))2#HV<zrDcKLZG7_DCASy$8RAtrk=^FT6N03yZ9wAe7pNpB`aI9AIvomF@^iOw4
zRp*KcRrQjvFV*7bw$B&tH4adpfc0}FHPxFY^j}5!^TKi_ltDoP=)_61O6t+KBaV})
z<m^gyJ)V`lb5@YnNJJm%ao-~mB#+1#M@UVLsVZ7sjUm+vW~K&Gz}u59Xzsqv@<V#r
zmF}PRll$x||Lgn8#wbZJIOx_D$(}^ww07!y2<CW=^5v|fy80uVX6>c+Iop3Q$98Vo
z>$b=1b^}C{t~=?;T%jH#eQ`KIsGAq!uqRY^d2Oy!-7Z)j4!$!W1nH8>FczVmtUM;^
zN{vdK!;~<h5B<QX5K@%wZGj{~ww#=Cm#XDGSJbO#oE(|)?xteBr@<lBDQRX=Sy7<9
z5EfI@F^3jMIA<^^kdA``RuDv}$V*9oEL1iGYDS4V73k~gPRY}?Uj1{w&09Uct)yh9
zto1j3Jv6KEhK%9tV!@6`#ZWm8+65htHDv<jPXyDs8+>0k`@(=YHaz=YohhYND5qEC
z!i{fB&zf?_^kE9-R70qmvFYIAlnAB{NlBgJm_`W~3dhhB>YK$oI8(ZDQk3p0s40;%
zrgP8m?_WUK*}tlRRnN@)+DE_Sde51qT~;bECrQRpop`?6*2)>XreVSE-WjvIwvVWx
zOCy;zNr4Fqx9^^?hP`(>T^WxB^`ibGQQb&hJogia)a)i4_mFB!VZ>xYV=QHF2m^^o
z54z`slS47anC$9d6{ygIgNKb&O=d`5(<BB&3q>3Q9ZEbT>`CI2G=V{!7DgtQNJ27?
zk+#|nnbY$c8cO>tz1`!Il&J6Qbah=OK&;%(dhn8x`bnIc<WLaO(Nid0j);gXPF5sm
z2?fKyf1&5)t9zk$wJs~SCK0vPh4<CON&~`>4nac<+NQwlnXcdfgpbNH1m%}d+slVl
z0j`)6`w=41U!s0*%HW{vTzQo`p;0wbL3rQPQ({-b9JJjI4XM7evERMF@*zz&3}K+S
zLQGId<Lr>A5ccMjrod8!LD1Y+1Q9fktljGv@)P&}a-^bIGqNj@H1js7K?20|>NQ?v
zqh|Q*ZV0IsvPwfzt1MQs!3rxQZph~FP}p`|Ell<#d(t~OUUf5{8|r92>7J=2@C0+B
zx}z!%P7VRl`ry5AwnbXQT%L$W;$fq%k&d2tO`Rn{bcT$MXu2&ow2uK#Aw@+Rxggs&
z5za|i2Xw4b^gE$uw+U&fIeA1rhU`^$a%B+5@v3{Jq~txA6NdKmR;6nGegFImnbMcC
zu>&zGs4z`^Cp|IQA97;!Lx#svth+BTsx!0KJ17<y(31}j@r+7f;We2aza1@`URt8U
zIf*V0PR$=LMD(_R!A`E*XKZkCAQ*5ahMg-!Gh%A;ys<H7CFz{%)=fl;F_}QDo$3nN
zZ~w}#M@r`hrIzCgGOLP31qd)A9(Kc~MaPWkWz`lfjk+ZiFR)dGa`+Mz`Rg`qO&oUF
zo+L&H;dOh&V1`|x830gCIHqo!a87|`rU%=z0_Ma6_W^Wr-E*qgDlP=QA~2nNJd*8^
zj>IfIm6pa`=^B$H+FEoci)ap;Qv`*EHf}cNUZQ@nC!vg-ItSUv>uiOT$_1WJZw^FQ
zXeIU}MI%tQOt_VViRTHRT{I|@Bi^c1&2Q_Ue<4${A*E~~A-@tDg7^UcdQ7m+oF_bS
zh~AwsO}rwzlbJ{zvYsHiSK)DBtQE^7OhmaGjE!CCtA)g|>>?X1cqV3+;7jZ399asM
zd$sL0)`Mfl#6QE6fm1duH8it8gkYKI)MI(*Ynj4vf7Igry~6R9xgl-2wK8T`Tv6y4
zv0{CV<<&P>X-!x`ZNekmAA#-0>&&v?`&DfH1pm4$jz@VzT6(V=WDD9Q=ucWHB>^hP
z&y&r#i0w$W#j96II!Qtp($m!Nu+EWk(Bf$C3`JG2i*zJrNy%D4!LsV?RiW;9kD?mV
zG7!?w*^_#WlLi1TM9>@}^X6Mos5Bo}N!3c&N1s~cToL0WE47kHMf><Bp`htW^$Dex
zy=`hS`53>@(P3j>%0_5tW~xt_6!ieBGCd<VU_=_hP~mvtYo*q5HPo_9ajzb$v-l#+
zv8-NTKGL+KN@t}ZF~dPvC_NV3l`tk@A;`rmWmo3wq!$*-iJ44ypVK8slvT9~3?}e2
zk%rUiS;otTW>VyNMgs2;XG|EzvT3GN85F210_VT?(QbS8`9<3ywG7ZaR9aQ-?rL7s
ztqB9ByADK!IJ7Q3KM=KDp=qlt?6xw+RSP6BE7ojd7d4s<%LEC&1FD;x`NGJQWtA7$
zsY9=8fWfFxk(na4Owl6sSPSBJJ`o>EOIyAq&huUfm~?rM;1y~cCY%D>GU4!~Q+O#F
z5F_RlsdTt+$OXxXPZIv|W9P6Z378X~l>g=E)R~Y&>dns)o{&_2NM;Md0Mo)#a)THQ
zSy-qUIl4i-Q{%Vee{WYJC1(_Z3TLi++ti}pm*<O;l%yPeXb7hUCZsYQ#$+LGIXRVK
zeS`WTYLTefwbu0y7p4!p-VS1xNJi{TLP_Hakz}RKS)~Blxg)_;$40}saBZo&&_3me
zT?wQ5j1P9@P_Jx36<?sbVaTaLnGVDuMKB~x=m-!iz2^ON4Vc27>^RtF_wF6AR}ZAw
zZ{BTo+wOoFYqwW8)$Ce_6AT#~<ow6!A@xhE3OiR4tVIJi3%9BdzUZd&Hu9?5O(9eK
zj*22wH!$74OwI4W`2_vKGb68Ycu?UG{}V{}gvae28yFKJ7|+-_yzc3dL7gzoH;<`}
zWO%`uJZyuLL(m+eI%rm=fO{=l7AL29P|QfPU?R`Wdn7e*V(7<lC9rM}?XRjJ7Ygzm
zomlUmJVOSxm4x#&4{`+xhTrx=&lkm%?C5}1<&}ZtfBNi%BKboOSq$bRkiKz!*h-5+
z)_6{H74r*S|8ToNt0whBCk0)HWW?hpU>;Q+C3Yp#X=#RHJspz-Y>Q+MF-yloxuCX*
zSNifc?8@G5LB}ap2`wzD7`Bj5L*l}T3FDHQsBPw7dn#4Y?2F$Twm<k!eVR}au|N6b
zoWY2w=ls<|{Ss&wlF_T@1@*Q=VONo@3#1q)l&&^|T-`Jf(SdlqxLOnnJ?)-(@Qx1I
z8;UpR2d9`9mFB%}o>AR6i(X~3@8rbXc`DnzCnj^usrT`?y<<Z-Xg*Q*NahJ*d$z?U
z_4cH9a=blBdXe!k*poP>#3x%?q-oMr@S%V?j2TLm`JiV4;X?@r7u5}T70AoEO4SlY
z7#v(y-!S92s%WXVB@{&J8Pz=*lU7YaRdZkTZ620&#oKJeTdtICdY>)CWRxdt#r^@!
z&8b#qM<IQfs<B;aTz%C8Q%zQpt3glw3(Bxa%c?dnCmPsd1k9sCb{m$xLNNvC3uE%I
zXEjM{U3IFRYYS929=AK0vR!Dun9EWrz95;w45a9n6eD3E+LmW!bT7<ELbzQOwAHk(
zeAO&EwJzp_2AjL>=%KLPaqDKQ+dzA0Eup%EdUl&EJ)oxN64*!!Q<7q0NS_s9qhSpq
z+Oj@P4Q=yQS$dz_kNBh~U(7-FhWI4?;MmWD>exKb!AaamFcHk;rDdSXRpg?qj^v<o
za!4IglAW8bRBZysXJVWxZ~>0VK2BF{r76BSEM(-&sUQYAEkS@i8C9PTG0!w56{h7E
z<jIjt&(?)eGB;PY<+vnyS05EVVmSQ9ESxU2JfsfmdD$L^A!9n9RB)wfTw&)h8Jn1`
zSLC#a5qJ82IKzuVQ3<DuJ?DW6RCq}h^tnl>YC7oK(nT{R{kgHT^M9NoX;PBo-B?sW
zfSz$mJs^X_fpj^1a?VcZ1i^5=7nuemI^qJ7n9zR2?x<Aeu8a%u&8zI>s-d(+;+68;
zv?U+~Xs4z#DyJXqkv&xIJnRMC%`+(~>X(G%M5ie%G~M6n0_a-d2*%pFBanQdNVyW9
zBArmrY+e#NGeGM}NqX`*bN-+17`38kk6uYLl&Fv)VNV7sTdFv)B3$hxU{Vg>M-C2J
zWQ6K@?TM7cdo53-6_Jj3-(Xe-w0v2>D$fGQRMIl299s6$$#)|mfn<?@bK4Xs1)H5y
zXy*={UW)S;6e(~$5!9&?3c?m7^G5!kOitHGk>bgkBvv4%bT_f$%ApBoPf~!965@IV
z3<(%2Cf2~D`nF|PW~ubBdjtfOafe$P(QiQAXG^F+sP1rH<we_*>~qoT8}tlsS5gPr
z(IXWgulewaX?x|Q0<@BLF43<JIEWx@991AGz=E2_euOCY#TbT3XN2<&!;<9z@s*-q
zRD(}1;_N`)uH??|>QjraOarJOs*3S6RW~aPM9>^5Ij5RQpV2|JXB8<#At{ii*Qwdn
z>WmCROzh9Pl?>^baA`doia6$MZrp0GD03H?#(i&30=|_@AZC=6msn$q5aJTyA*7^d
zNG6Vf&jcVpg!k=(=SWVZr1!i_3RTr38#YV%ZoF<haL_LR`u90+Y|UB0PxBu0b6VPH
z#uJdfoE!q&#3y|b20&I!{Gu-hdvdH(#o7Yo!la@(3`}#M^CtU5C6o`{`QJ!ev^H1b
zBGV-`2rsosb0R6}&Lo&l0S0s__9WY1G*hxMb|s-9nu1CS!b-g<<|Z|aM07t|9v;8~
zX_AuIC&@%0))NK3*ekScE=x~+8L5^H)k<qA6H}5K*o=N3SE!M=`<z|b6SO!C_DUiu
zKAB9U7g?ZrrTDNfXPIs*2^d!uHvjY5k$=`dGb1Dglp#sjk4#MT1f$Lkj9PK}P|zE#
zH!`cPaBqh~hy7+tb(jt@LqYPXc6nwh-T?bNnXu(xNT3zH+Qzv-YNE;s2i2}Ak<B+F
zSimFJey&ptrgJ9L02mWyOp(LEYaAUGAG_?)u=wGz;QV0%A>FViJyB^+`$JfvAmWo`
z>tHZq$Jo7SuH>TLkSdS~-EkZUEK5(GF#$HfYwuOWfnF`rk`!P}hw@$Y#&3Ty&zHoM
zeh?ISYZwwICL;T$XCSz1_`vzapvq+Bhtt#!1BTNBn~}SccqP)4><*F?ND(d;kS?e<
z?{RZ1Utj6tmF<mf&aNbblblL)As}tPs7e_Yh}nc0@<x%O{(qifG`B9{xkvJ2fmC%{
zVWKKXpKx>%t2FlZNzVWPKmbWZK~&6CRWa)L1DPzp{s4ABiN7YddT#!NE5h&&4s8z*
zqmZc?&0i(ETNaO(l4t|GZlog&84d-G3^R4|N=p<oEp&w#Z#;cSg&_y*_^}~t*ikQu
z3n)L8LekYz=ajDT8s^MU4>$yqGNxoqMHqoSsc45XL6p})1ks66(*Cebf(%epzGG2=
z5H}>zxfa<f?50k^L$72}K%5{7uV=-)4%1TEAB0by3U&IZ_)Ab*$MOvj%c<-jdgI@_
znCDAkN=n%f``lRtN{?VKwsos{Np~625u)tL(|l~%HuCE-6j){P&Jyb#bLvjS%NrOM
zNI|0XCvbMe8VO(mw)IHAc$TCUOQ;4BkxGQ7)RPS}A}LYbZk<9x#4yQ)dkKlEkLOgl
z_nj1lF}>7GFez`sn2?j6k}M@m4-iGx3NfwXM)#WdWHJP`1HclzA034_I4dbLQX~oG
z?MHpA-~oY~1{9U_;@N#i?4^fax5I}uT|&IJ_xj+R4s>+8bR!IjswUM4!N}pnL|B}l
zq3%KJ3+@X+;K*B-pn$v=PK*-I8$^te!D*Rd6E0p!r8$J4pwbIzhfRqJr*nWloMeJA
zQR6IGGTVkGBG%fKX4^Hr476wPDN{3laj9DJF?oGSOi9XdDx<m;^<AL~={2fsfoMX)
zhJ;em0=3C&nvc>_meshIlKepI${E!PLLe~ske6yk9f8kCy3do(`)0}pf&eM#LK?`h
zCtgYE8sybB(vg%S<e77<SGF%I#ToN~1Z6u2#)MHFB{3(`)Jw}8O<~R5(CIcoS^`16
zR6iN)>DnIVlzAbw*x%Hn*lQr2DdhD;QA<eP{e<9a`n!g7{2Wcg_$7PoOuqf}bNj8M
zTjgWApVn<sct;X8H&^qAWK*&a1Ot+8WI;00|Lqx+&P9rPUA|j3Y+Uvw*9Lo%es6;4
zLC{=zX*oHB!0-n=VdKwEj>^`gdR>xS42fBlEG^mA0b?Zu5zI-s;gArB3AbIjy}*Tn
zm?U;FrE31O{qrR;B|A;!Y=0rFP{Bz5yp>5>-gHf&U|fVufvTKWK}1p)9NPohj_O7w
zI4LRb5At>;DM~PNkeo0r*&?sPeZ11w|KaT9$Z&_KVWfcyq%}fAEW|7!m=I5#R3n+6
zY}sPG?w2|xhz=vdn5camq%^4~)?sh5AB^Zo%n3sxEm>DB=x0yNGla&cx}EBF{V>Yn
zFz|`q@czzz*MOB$Fl3p^<e<JWNkH}mq@VFH(b7r>dUf^v_uF&Nj@ZBpKXmw%K5W$0
zEe7J;s3OZbKN=c^`u436I6Ev5_9P4nvf9W{aA$iB!?p2Jl5NLAs<BkY1}EpG*8+z0
z=q9|6J?X1{vSnX0@D=7vm+t@(H-^xPjv*y&spPunwi3JHhDu541sfQZCR5iUn5S;z
zOL%y*e*FbIXXi!#HP$=-2|`0-O8-$3zin-WB!bk=xqc%y=A{{j!UIneqrq@UNQmm@
z42?dU(0g8La#E%govkhp7z-3zpLfLrPs@%g{fJj8NrCe$o4dcQ!=YxN?P;H_P<Ui)
zTnyNbQ^9A=TF0@&dX_ZS4DFosfT_sv;F0^Vk$Vl3CLE?1^R^=a^Ji;7JrzcCqtjNT
zN~T~US-+cSsPan7NINTL)~6+Y8v*kvT{PfWxCxVq%A=zEQCq)zhik*Ft$V*riX!{+
zSHEeG{`EiGHP;7QV|zNrR1IPd87dJDkaLK1#k^M@SD7EF#*{b!1nScfM9Zj(iF=e;
zgIrOsE7T2s%e1!7lf=wjREkim2%3}iK}(^!$vi<tFr`$tuODC?z1uiKWQI&3I>(G7
zY#+00b{E*@x*&Mp)lMu;j*_ORO{n$ZLa1sS@9pT4nUYercyDk>a4bRnRl&QHn%P&>
zIn~pCRw{{3IeFp`4o<$ZIG#}dFeAn^X3^Y?hO+BUUlia_Tf16$vr45ddIU45{aw@;
zh>@U~j397srW&Diur{3lkk+K&B$0D%VL*4M>M27mFdTf^$auD*14tSQWK|rXEDts(
z5)oCNk=Qm+<GC&+=|V`_9mxqpLQHD_w~-SLrKG(_>YHs;B(V_0Cn>;iSm?4RnXrb}
zJ<!5MQs}5I%RY4F23xb`KHIkEejy~Ew$_%%)tsgwo<DxfcJ9oUBQ)kB4=^PQ<QuSf
zO;9~s^D&W@o^W(vNTes-j>CPU0t6GhA3<|DH3KTbz{w%r&R_tBf(DgAnx7*rF{+!5
zFi=De7p*rW9CBrHpt`4%hRV~Qlb1bV{X=L6jyY|s>LPZ-wi3&#&QVFBx+9hGtBXoJ
zsCE*%*itqBTm17St8eVeq0y|b@dfA!N9sWyrEP;e$K5+CrIH1XrJyPi|3Z~O`R$fI
zSo@I=C!_>J!laxWuSP(xbu$eU6+`UjKni4kB8fTa&CLP00A*}QOYUqJ(oqdxnwEJD
zeag%)cdubc)GEy9)VsX)XhE&}->ZE-1BQedQR}2GUHVeLVRlAo$kIA-p`Qc3Y)>L3
zeeERDrdPHVc40++zhlPt-uq#D;6HuW?){B_QoUz|y|nMMcHqgswYk1lJNn`=v8*(P
zZaSnRwx?I$JV#3l94s|bGEK$1gp0B=6(vy2l8PYL%aa&9&-Vv(V0KhyhxSFP`S>I$
z(Sn>nV#?HY>YK?Fqr(%f*PQbnBs0#x5jZ9&X;8K7cgo*j^7p-`%zo+4O2@p-r-hR#
zlnqK6Aqs*=W(zO6RL$*_^l-_Nl6^@z#z$Wh=o0E%eZ4xZ5E4+>SE?k>vfZ1q?4a;@
z!i!2J3VvlJuqWHoa+|H9-b`gCe1MtU>xANkQE3C_W0O6QUz+GEQQ_}|)T}xjQ8;**
z{ep$7T^o_)8FJqB1dIb1fh2HNYVf`ItTDw5NrNRbAnUO$lYBE)x!^jn&j`(DqS3A{
ztJqkrSAhg@L)!Hp(k{9zv|Q~Z7q)5NL8~k4wVQtDQ&v;?J`Q2cNB2o8p0<+o0UPgA
zd{G6s(;5ZS(R|QK$s;SOk(AMM`_L1Q-Ra5MjP4&Xm+;Of6WyP48s~?kL?iUczJt6y
zNqiDk@qu&f$)2GU`@s5Ds{9wOsLZXYD%rWxR+K?fY)z~(S#|rWbK;KcstfGO^$XUp
zrrORmtBf$FaVAptL}U_`jgE<ja;s(9WIW@(%q2ctvZUnriBh(={3xU*UvlUA5?jB%
z!XaU-+!&Ap!b)TgP~q4#1l0Mzr*}>&LMKS#j{*%$0iW3c{AxiXHjo5(n4OJ5&KV}6
zRf1A67*JyXmx$MC0((MQdLpRKf|KI|?4Dtfl1R&BT3aEeNzkHQ>s|p|K$Dm+Q==!m
zrCF1^R+rg*|NSp*Re6nL#;3mjN7ixnhYrYK+YP_%z*4j1IMDyijY+WCIUkDkxuI8y
zkB$lsknj(SSJ6C^ZltynM)V6vzr-==v4MP1FH#K+Q>LP2Jo)~yh?U^9q_*0jb4mf~
z+)^2jwjx%{HSm)gyo7WI)C0^}q3lwz0JF}i4<AB8CO@OP2?fPsMVFLXbO%X1TozOM
zQZ{c>CLhqhc2ZLehRw<Am4wZetrD>u1%L_I0`^WUkjYjvX?eQXx*#G{*vcR}($g0J
zpExn#ihf<1F@d~GQ7w|v?XOzK3{6<@LG^H6fn!e8I}8c&%mUML90;`ys)n~IQws#n
zFC6e-<nl*ck2nz502hFM@%qnSbNgj1_6b~nvm1x^H~;OA?O#9pe^|qHd+m;2{u6;+
zU88jB2^;L{aiI9EN86meJuFoZ6$<j1k$HIOZkD6U%3N`VO4ndMh-XxGURjCzpKuUN
z%k+r8&I#-69CxM-p&v{q2q{Uq8r3}nzt^qDRIhcZ;-X@;<?5Ux6lT-|L?i@z@~sHQ
zOqQZ=wcVwr7L$*2Sxm_RNICj}^Zd`e@QWdDTY5&tD<?MQiIk=HS|=$j7ZF5<U_|bE
zs#L(%hK3cBV>1vjV7}~Vur2R}^Ht3)yNxO$$T6x^JB0K^Lc)lIjJy=}DN9-?d>chx
zy<l1@#RN<CWR*KcuHgEh1N-;8><!YmDo;bHPPf_*|Moj};^)0~{l|Vw%y_q}N|zDg
zRD4!pkyNiLbNbbGD+n7T7&jkM5+dpV0*SLDWlLg1QY-1Y6x|m3?s95^GC&oy#8scF
zqUtea#LlxP)m;ih`fw1L9EvfR98BjT$q&vqCI?cIrl_cju2&LT?-x<BR3$$7i%>A$
z?s&iW)81llpK|nX$C6-${kjW1!;CPdXHEz5F1u%9Ofb+|pur&lj*j&>^-X+_o)U;s
zeu{oo9pI#=FU}YkP+nL?!^s3gW@uw7h&-__nUJ25xUw$eJ-W)ubF)wwoJ5lX!KxBA
z`l1D9g109D!iq%m?eMXKZuA`>sL+#7H`?iEU$@p%=WO-PuzmRcd$qR7y@z++-O_29
z8f^?VB@WKyNFXKgwv(k~NoAq#93*6LiI9+ld>lG22)$Z>0z_>Ct{R^mx0chL);E^p
z>`A9_h#e=0_F5=1CdX#gqMN@t&@X3I4vtSPQUpWj$CI}uy^8khFZ9f|v9zF8fL7Y%
zhQkYO|90yxn<+086#Yfg(ler$lGv3HZJ*dOkoUf4r-BqAd2l3&FKc5P+HjMLetTq_
z(M;wl(Fss<EhG_>C8S@+{!1h#9O{#|s%#DpkGCm#-veUJP7J7+wPI-(Z%<}M+U4lT
zhLfbO+ql{Q)PMAQ2d(`?i`({<BXO(S`4PR|;MBYK&Uq7@%YI?t__!@<8<h=tDG4(&
zn;UXf=u*-1Qv~+aE2TVsnoJ&2lC;r6?Yd{qwW@q9SL$2!lJw*Fd^hKgA__oLp^{Y_
zt#MF8>Lnp5Rio{htQy7F*pn;ObFvh42hhXHb^Om5W$ekEf`T6rrSaQd>honYWpXJS
z%t&uI^j3`Nyz~`PGE*U%;sSw-D~RT2NaKA&R4{wHlKd}rC29x<XGW?A;x%;UTyTd1
zP=E@DU_utuv|s!>w}BpDMADMpru6H{qocY(*hmfKIn-YdMV*pzli$o?R`SojNB7%v
zU;mzEh{=J(d*+oOeR|zhSGaBc)Ll9osYGvXp(0=NvlAKswe1rHb16Yd8=;?J1>1>9
zQd3EM7RkxN`jH_4ktPaE$eHv0c*66h@h&;D7EyXpI9ZMyZjg#e;^Sgq-3*Ych!?Io
z$Y~d{C%wdU8|wiEOkS7FpiG9i(7-0Y@5MY{R!GPn7`rk%bNT^tqbV767FPxCVupsM
z`wfzwGpSnk(+85)BRxq$s_MyNN)u9CO1tfZCcR3ZIu)KyK}I4cPN)Nb{(R+Ya|BI7
z85_kJv`3H!59@hRDEh<;@x(o2@{uqnM7&a8)WtE~3VE%buruRGA9<~)?kqvAxG53|
zQ+09i3YYJ0di^mwesIFNkDk+Z3ZSc-v$<biQ*#i7WMi8)hHdrMM2f~AT+g7mHNW&~
zP+OW%-KcE{X<1Q|<KmJyI2sZn9;CckU)PyOiWW$1dmGz911hgwrYifBN4wp*z@!PQ
zI(=vYdr}bw-2^72;~X%MggaR$SnaNXxSO(DSt{oyVb7De@Sv#f1NE?y`TY81hGgA<
z+F`(<Bnvd>;=gYm*yQ)UnCA=e&&BNLw!yBP5eivaRf84W^kFMdo;h<-qkF|<$qO5k
z2leFDHtTrp3pFVAg(0aLB2+Rm6{vKIGw`?}U&6*~%BHvoZ5?thTKiP(ED5JJi87@m
zG2XEu9V1GDo=0Lx*5jqKtn|Vu0tOcys#{B?P^oiryghm1+*j>$fA^Ffe)^!Qc!sTK
zI^9m55D0)`en@kijc8GkE);72l=8?KPK5)S+TYqG6(^i{6$?XNLh?GAk)t}wKnqZo
z7PLcf6M@DXIFc|Tl|a;0;`o4sF(k~P6DI;~;gQvdPvR8%P#T538>B_BCy%$~nztwU
zTvs-zOb(riD^)k|ucTzjIIQ?^{pL)ouU%&|1C0(<4K2EIpG*1w9Wf=PY^a0iw(C_D
zBOv?Q9jfHcw{#V>0-xu}Ga>)`*Z!I9@V2>ANk?MeP&&nln%0~iiZdX(=N!(EUb`5j
z+HmP9fsmH10*+!fH`yKL?u0Zm21*xhqsvqzF(wS@q@~*;c<_uF4r#)wJa}(Ymey7-
zIXR(}kGqZk`O^<6psqf4sp>PGG3yi_Qlb13s8=2^6cgq-aMd$2r^VETZhRh~sZDRR
zxf_lusbq#kN&=V)iZ28sqLP7b@i9slvvlw3hLTpm`Jo4#VNYX2z3v_7X?wdyYp4w3
zhNfH%Vph(mZW`=KU#iA>g64kc68}RhC1S94d3~31j+uGAcGrEItZc_x#g^40^cDk~
z{Jt0S{EnCsW48VyANwgEv`ArVrjUMxKE|w+*^#~_#`Fy88FA$o!{8@)3o}xR4-qp{
z-Gr#h75(yxz`08`>a~-YGS2<^?-xc76UmU2vs&q#9639bk)g^RW3peu)<k`~*HY!E
z>}0~8BoGgwy1hMVc9nhmOP{x6`%YQusyyrKp}2O&Y84@(xs6m_ouo9hIU02$&w~@t
zZcC^L=w@QFGc+3|5mK_eO#LwGaUq=u!I%WfeT>rCmAs*B&OB;Y(14^G!5BjFp*6U1
ziBIC>5Do&ZmrxK?A^_S@WrH;~&uR#1aGtsOIoBSk*KPPV57UdP<k!-x^sp`T+WjBD
zN+o!CR$VCYuUl@^#J1?azRm6z_0~IL%1?j#|0=Sw^|#Ltv{*<{{)~9Ps*;r&+kL%&
zMO6`<z|KydKa(8^>?i;2crQ)j5FB*Zx1&24!ugpF7r4*`nH~Ce@FF?UES@=iI_=Dv
zZij<T%#u(Lgp@2PlqA;wFsHXKy>00>(u0$dsC1bVzKR`e^lSm<J7Tm+>Ydi!czWjV
zKl4e|3@$i$J)cYN>yo+_Gu*y?-fq3U-YNwIP*Hc26XQ5J9^?us>EI7_ZumW(kdk2q
z>$6mvMxPF98|mnueSFe&F^UoSAGm1%R11Zy)^bjDnVrFnl_h*8ih4N(NKFqIR;I$1
z`5Ln$0(l)$>0E&%ql-=IOQb0BLA95&A;oYj2_}pQ#f@i@A#@1DCR^;z5AU*Y;T~&L
zGu^aOomcK$w{q9Z`u`m<<?3}E-yG~44)xE<GZf9vO4m*+v{0ZjvF+DdO0Js55^9|1
zl?+K%$1f|tJ@)0?V6W>lPkzs-C#~S56Fm0C86f>)SB8tR<3v)|DT5sj{g=uY$TOp7
zPPa0_jP5;o&uok84yO#Oj7~QT_GC)628^Z~AXrF3>O3I|jZ-C&c5N-R`|hc-owsdq
z-Yap{O{z1c02rdyl1UO2X%H-*neKDz{R92(#Zuicq?d+1CJ7_5IKZoryn0DVW-hV-
z2}oRZaB?n)Ppa0Gf{F3bWyWGwj#u3cvSY_*gqJxu=z8%nnK;i-dS*fJLXR*X#It|R
z^jVT6L|3LJTkYCwDs1zWyH!5e<+g3>3(%7{ZchLIPg4HbpMCOvHCMl{UxPYJ^2OUy
z-B3oxlnsJk)3AB5T+k`8-cxQpGh<X$=8A*C)M24Fgk?css(|$qn(*Ws%D6KjhKu@i
zqw^@WjxzkzxP}EO3qjHEfEv3h%FCSkMmkQ+(+9IG{W#7_TatC22obSN2%UF4R1^$=
zO1$~&_k6(?l};>HT}ESL*fHZ3yYuX>yQ*!M>Ip&C7?@B`ql#Orsurzw)isWDadIa6
zo7^;BFPZ%3@tejJJ0!JNRzVe0phdhSWV<W@mS%_<J=hg0J4;{!0aC7zj^(@zcLb(@
zPcopoy;(yj2)iEwy0A^PmN~+?gc-@^Ky(LC#OrNHm~UiEab7Y+TKJ#E&%@buMUCyb
z={8B|K6Q}DX;VijS+Ta>JiE4GWc5G%{k?zX4t$vpmn|uG-MjdW!BGM7!;lFoRNH8@
zeEnikZS`XH$j?L3sdh`B8MW|OvtvHSjF4IbQ-`V`yikY%P|4&Ol6Ag%s3=>N+6fOF
zkCKy)9S78Np=t~v#&+aJWrK+kuqly#oGc$i=K}h4qT3<y0Hb;|4NBW60w(t7Qj4)4
z+i%}@+)kWaaB3S2ovT&*2s3WorY=7PoaY6U00HO1Fr(_aJXK1q(vJ$VHG_h!0U-mZ
z8m9Q-;J}cCf&j5+Fep;ex7czlUr|nQe0)lIdG!+!mqcZcNit$nR#d1gPY{S_P7b@E
zIrbxcQD_lN9Ek5btDHCX<YeI*2guK0dCoCW4sI0ec^D3<=tm#3FY~-vM)i3ty($PE
z=n^*P)(w_kQlSu%;=-!BrofuS#Z*iXij%nlkj?*tPk;J%H*t*1q2N}z#67?L{ZBkT
z+DfivS`49}tt4D-_QK*|Ye%U6m9wF)lYMsAbt9HjU1vq(GVYnN;~+gU96}pC#3^D(
z>?@6vULsBu&JN_C2{JSBwxnRty13&5r`qMg0VyaI2$L_)c;QDUtf2IJcJ;k?YRuY{
zbqn5wfDX(EV|wP)8I*k)*si>$QXF~gTO!8gv2Izt)_L9k=Wq4f%P-E`M{kyQtb992
zY()awqCi%GCo!TVTms^S@12%8Vq11><)v)N6HX$%ap0^&1Su8J{;=k76ChWOxQk2H
z)aF~w`f?`;acZ=em{SgmFqsJd%xTb)Q`eG?0@bwwR}Ca|G?^*0%I<vSU-vJ^C*@mB
zBtTIyb13R{PL4e9f<gsPMNEDuROce+*PU;r8FS>A;(5o_@-cIPDD$F<JRMw%w8$!D
zQyY&q*>gW>wbh%8tz0z$w497eIONKqoK$Q$KX=qtuUq(Aecb!qhhE}C5=&g%p4<Vs
z4dM58bkc$umC@Xyi2~2r{6J@j-jD@32)$}bAKp=Cm1~Nv`(*3Vfqg?eW%ZmQRQ5{Z
z&Q*Naov?ZR<2-Un#Dx?lsuIi7ASwN?wtMTGRM1@*-Z@zlHZ9Lna>2g&4+re*u_n9i
zzS|ty84eD2vAV*XqZ53d7*foL2hQSP7}c=9uqaPlqjZ6qS-Ydp{^rl0vwcs7?6dzt
zDzLg%(pe!ZF$p=Rz=~e}_PiGx56q8}n)U7tY)RB)`{9!=0)Q#PNVzoKiL;WJWU4l9
z3_NXG99%<~^4n0rkQ((OPn?NiV^W_njr&MT8@E+eIo8(MZD07zbBfUlI!2BaZ3#%N
z_O8UJI~8cG*O$ytb69?_1VA~EII=&7`(!JJRCftLL?8gX=j}Te`FyXvxMndWKA@0d
zotxIC$oY)fk$p{q!Z{=RT6jn*q%KzV`8w5{ItE>=v-hqac^@X;pZv++ec$bT2@h}P
zieIqv6?cVSZ$3Pg(V>jS%yhqvslXs6#4k#vveoPnT2*DS=$Hdk-Mm!*>_Wa>?Cem9
z7mUQ5Mpe5YDTCkXRJgASTKUmjP<qQ5Qko(m2`CeV1scxh7?bT&(xP_b?dz=R$phA-
z*d=xq)j2c6|7IWf)q5<xwALn6Z{eLB{~4%p9G)fS)Jq>40*C0qFC4e#17r4?&#ZNT
zUDLV{Q~I4i1JX<e#*oJw;+ROw5kUk(;ru=BIXk*wC(m_Tx4`YO-<;}}{RqL3Ibxy=
z6*&X>7X-?gpG_M{P;en5Ti;vEGpl{{8l;gN&1ih#sk8Ru@0@bTzN@O!Tr6_$PE|;4
z*=Q&Kr;3J!s8%A$s-4_t^$JU7WA!Rky687b+5&RRxrHaOC)3qKh3dwxgfWxJ6>Mlw
zD3X#`aV&eC^7cZitCfkO0inPH!kn$AQmpy)vsP78CAjK*n`wyJo-5aWPZ65pOU;8P
zSR?ssy!Gq<{@*_Q=jWby=BCrnzi5*!9kN$6%w3@LnaZ5Zf#sv-beY(S>%|4nENP=I
z$J`v<;p&T#va(cFl1%GI^Ft|qnbrkJ5m0_OB{&i3uADxISI#K+OKBsLE0Ph_zDnUK
z?6IJ>PW%C2FLRkkEqf+a7qNOrgVkkqnA)e+R;uGF!O_!q%0Uult=^)Or&dvk+7wmj
z#N`~Nq-vsqo?*mP)f2+BA&qlmX3V(kCs51Y^ZpHry9w`G`DcoGXJSZfeZJITni_O6
zgyl$4a*8fG%S5McyvzaHdB-Oei(IYX`SbS3kB->M*G>rDMLjV3P2mJ$@7$ycHa3)L
zuDQ&BxT?MRvE;T@crl|fAPfji3F}-+O458sh9@3du%G_$pgsPBHX-*aJEQi7Jms<1
zZ!ERp;;nYzg?7tZq}N(@aa`v>zd0^PC#?AC_Pyoy;?V`=$Au9TrQu9m849YciiH_U
z!G@QVaqT;&^8$tS*&f)ctXvLkPQGTB4>(xqITe<q=t86`vQoeZ6)|{UN2fJu6!xhj
zgO)P#sz9(J75iU1^`p1usyDxL{%!H*_s?4sPMvA*Jk_ac@CqwlTkQ&T$(@pgA!qFg
zM}uDCmbP)7^gz*N2BAaO5l2iCY3b98em^FYp|0H>oVb%cKo)~1Wlr0uFo%G$laO%>
zfK8pJT3y*ztaguG_ugt-UmYB==~T#`_{J+X-~7Cls3wu`<q9@X+X<qN2g2C_g9yqK
zL#*AnN{o{2P=K@20~L$&<H<`)|G$5(Dv*>?ha%yi(cWP@^}>FcDU$Y5*Pwzxqa%t7
z3XGKO&7$l}$c2K$kT7Gu0?`h%O3*A&S!InIF#3&udeV;X?@}q9Q0$};@bVkBR9jzq
znZ5j+a`2r!mRBrqUfRT$s-a!*zGIPG=j2qBfzY;`+Vz!6D<!1+U_AiY0?kTw*HkL*
zDUC6aI8WG`o;((Mx_alUt4bWxHl7+#R3hBsx4GEoOJd4D|LkL5ise<bg8@Wt+B1;P
z!o(JtEQ?(x38z8<kAps>@CqrY<j%b0FPQ9wdxoUe(8bXtB7qHrV8F_CX7wBBs|h^z
zew-A&j;r0a``AhAoy>92&{S8~$|>mSSagipbK*J6lk>9}Ep$>5CPanPmVgRhVn|gD
z&1*UY5|r=|MA&0e5)sPHQ@x^=3sHLMtX0>*@WuMQ-S+y+Cta~fG&jgWre%yeTQWs9
z?&|s+H-iyoqzZ_vO)~I)I5W>Ry@dtU{mQ=6_T4W%?VzGzMkL|t^*L6uZnHHHN7WN_
z+`w#KR~&rDOi5(gNEk4$6uF8pl>TfQbwP8oNl>!Ml$>6KIlVo}cAoK2-9^P^vSFq2
z^<Bpkg&bg3`h@^IBnwR%M<B8KexLrE2R{|8z4*sVVoDCXap$)GL5d9Kfv`;gM1mnb
z0cKSo&krQEzR|E7y-Zstlc#btgxmpJ;q1u!hB!emCXzBwor)ZrQnp0_DpeJX2{Nx&
zDyQ9wH<(eJ(bFB&2Xb<dniG=3TmTAK2alh&)7`2fs@m#6^vkOQ#(e7E8m;-cFDWnI
z;xauh%_zp?83s&-dGWtv<ufe@o<flV*S<mPEep10rZ9Z~y&~t$ps15?oO9p_ejerg
ztW=!HOG#b>U<E@`tm{kB2=^4}bOIyz!*9M}Kl}D;F8l>U5+~iVMeVMVp2yCPTlblB
zuKxxJ3Biz@i@`o6F7$D{rU)Y@wVpE2<v<k>Cfw+pXYu!&i0c4(#}rJ;a-H|MT8Dvn
z$&fUJQ0vLhFek)*j9Z?Jtp6XunoE0JKFb%m-}65|^ZK^6nSYwDVo-=5hD6hYTRb90
zSlrsFAbOcvW$PPs;fDleqQuIq&=z8<A9P<lBzseFHEhXPTqi=dCHCc{Jk2p>CHB-z
z+a338v{;rVGgR-8Z(U?Zf8Hg7Ta8hrQsLPOdFaH)6z)mYNtjnzTdpd-=6mI6&7@g*
zd97{UE)2)?Q5)<J*^$EvI**>Qk{a2+Ib}+YC~k=@Da$mj-;gRB4&vD_nYs`Y@{F@H
zWmjsh<f3fSC2~+T`t6Fvs`bV4)0%9}uH8zq+;1lve_${D_%$5|bv+?97M!nv!C9+c
zt>L2U<q(DxO-$hYq^T_=Rj3uQkibV3vpjUL$A0|1{WdHFwOrYa>ALwURtw5y%?4{x
z`|44FUS&*nDa|Nm(Wy_BtsT+%5bnLsv5uwB9oAI86vZGL-g}cOu5xtF6c!unH7ez%
zW&j+Ua)YX-biR`bNx3NdHAQF}(8Sod00%Uze!kL<yxyho5>qDhS^CTc5E(=~FD=UT
z=9CMfv3k$%JpJ@5{ceLxc(`Oq$+7dZ3cp64dWj(u9|%K2NJ<vqLQvt+h%U0ca0nF+
zcoKnIPsAc2uf};@l{IPGZ(e67=eAq_oC35$<6wkv#npS<T}w|3kb%`YtXEZ}(+Ct7
zS1EoO@3dpGHIJUkw2jwqun$}<>7AWo`(IT(=J$SPncdI3(l$CDQQyf`LVP~b6ZJkR
zr^nOE4o5IA9YusYkq8H6mNmFlN1lJxNh54-U{DByVS7`Jv*8L=Xv?u!n9}$aJ(EIY
z<Q;)>vNf;mZ?&f%dR<(lA`6AU&<04y`c)h3Sf@Z34xY5i^qv5`O8cWRe9;9T&eVtS
zsK(Qk3%%s}E3NtTsP*@&mAP)KMGDGQgsYlSIWUBRsD({d*U7KFJ;|}dC95@WNT_Tw
zcVNh5TKRvPrm3Y=>{U18<(05q7E>1Qy63O?VW@6To+17JJd@69Zev=QjC`pl2o=64
zZw(a=V<tO0-p&Dzy0}szPZxW!|D;{DrAQ}z+^R|@?e1I31v0f)KnH3#OW4^B>p;{E
z40;$6!d$4%8FT9V!N-N0Sa_{{@Gi3tY!X1|kZztQj@#nNFQ~VN(lG2md78v7MKB~x
z>YO6|&uh<+4xvr!@cN-l&zSB%Nel}T8K+)7<m_u~Y+5}Q(}o-~Y~QH98}-z9=oL!S
zm`;m>GqqT1kBb?9^3Vy#jM$E#rfs;gSms5Qy>NKUsq30br3Gc<iKmws5>=hN)L*~K
zZvLeY>KbIYW#iUtD@!}&a_qy?jP_F)N;!3(#^vjKhGe`9ggpruYC)ym6L7)VR<Jpj
z%`}*CB}4N6qL7EvGHU+L9po||E{iF-17=gp+mV*gg&30cQH5-%H9T=vU|2O$f3o*s
zBtMM|#`Jb2+j~h##-U{}!^Rb#130u-Dvyg+wfzP=^U8kv_^;n%TkihPLS4%ibF!z(
zvI<m5RDJ#(OxNDtT1nW6R(s+=yN%}WviClaYuk6l?A)LL4h|^gclHsf@ot+}*lA3-
zjyN|kVX~C;%!)To)`!kPNAg5HEvkS6z^L@J8(jNs<C%Wv?PC{5q7ydWyP%sYX65x7
zQKxVdJviV|GCvWgrn@I@4}NW*^R6rN1I<xXnrj;xHdy<VP&HoDOiGQBh9OBEvJ|M&
z2q^{=KvWyCl<(YY<+pvnqSIY&ej_o^lSe0Q=k<5khWeXa+XT{kC3#zt^_W-KjC>AW
zH#Mt7RG3Lg9jT|}*Q|?c>~u7{y7h8`=Kh$M#gy!f!-KT+42e2mA%wFW#tGaprb#3d
z>YG?43r4pmFDU^js4JS4*V$rBkV_MY)9%fc_WyqVG5g66dabnh2K&ul`(?ZFH-Fbg
zri(SLf{`hz-cgAga|U5X7Klv7?G16eE81!U55H>Pdc5B1Z^*H0?vytv+beWTP%jVv
z)Y69!2SYv85AOEE2}+Rn!jYCN42w!p{Ub=f1l0+od&0?i<gqV>CLFL7k}SCR<3i7^
zt1pqHQQx_u002PY#b-)t9y~T|k9_R~8*RrCq=`;b&elY&a&^^`x~_;wVo7Q`=_o1b
znGxwoE}g;-5ZX50a))JYyWM@A)2EtkQ1FK^eQmv(Bh)JLy&peiH(x)eRH-VU1c|{!
zUC)e2N-rgSn?$nLEiXw?2xdMm-~7q1m(D@?u7C5dFX#Eqx64Hy1&3!-RrpU+QEg&I
zPjLa~Ltz=gj${C{Zgr(>nzRCeP^oDurh(*fVPh+9x1i@(oXH3Rv67R+2|CfNMyJXW
zyZz3+cJjqjcJN@QJ^b)td+Esz`}^<ym6cVm)}aS%>-t^lX{oZqXFDZ{`W5q&mngvd
z)M&`^^qSy2m2*=%*{fB7wz(p1?MDXena(w~=kC>3vq9>xSCUlTdst3GdbWy!(~F(d
zOjXSz5^_QT|A+$Pb2=6dT3ApuI6G>`*84mwvm@zGIa=LTB@3#4-=6-?=VN{CXHru1
zewG|UCNAV=&e@i$%57>cs&k{FjdG=6N3!jQ-#u+7gxH&%8rY6G)fu*aU4@*bQhWW_
zh|RV&E1oIoq|fu}n%DXh$IH=BpnGaEWUG|YZMg9+o3Fakbpd3Fac2d*b@r7vWK#~P
zRU>9k{b;{6T)Wze*6*=1FC4Vuk{ku@m!+P3X6N8A_lRqvyU%iRX5_tB+WtcV!BV@4
z0@5x;j4bCn5Mt+<WJXLu(OjW=<kntwSq_d4<LI)PlD%)+U0F9VF|b|f40&P#0+lhZ
zq?pjRgz2c)5UDZXr;CfS#F#>H=ooQK857PAl2Ywt$^xY-3zTAo@}37K;?~qPE443)
zB!hj|&G*^5ZM&?pY|Q@j3%_Ue>))fJHfceU3GJ<Vvu)UL!%XYQK)B;nqovD{QmweE
z-vh?fMvf$GEkjat*Lq2tre1sKRYu#D*cIESW$UTxrbC-)7-?=zqokX#b<#?ef)iw+
zkke9Bl>`78YCTW6WU;6_W=O94qL_C=;g#u;X4`uG&Cc`w+86#(j%i?X<`$~pLohVk
zwinxmja6b4sommoJ8^p69(nMv^=Z<ok3E(M)2DV#t#zs{74JH0rpI~QGZP9IX}^ff
zIT#X01_=p6LR)s!TKVlCvhhg0Y7koVhWdpjG!m~?qe7I(Ul{FFOf=8x@3>Z}(5U_B
z^UoLwovchbVTp(X$MH<Lpn2enQ?hjxFyFCVQ!Qr7?7*QB*ZoL4bl8upW+xF$3C(FF
zOWxMo_W#MBe)TiKn#+59M@)J5Cw}#8^RYMnV?<#Sq~)UQ5Xz!v=9n_TiBy1HHV$gO
zv^34?%EQ*7*yV%<63wX<(-VxDsk?qMo@%FC;!;iOtWzn~D^H!Xj+Vpr>%V`qU47%{
zWvk$^!;qdhhEkn{#o;YG_FBtWnl-(CP*DM;CS~`)m=X2cP_v4kl`2m)UsANLMqp67
zIUag?*k-bK+U{#dEUvcNsSX+LP2#?kR;#R4>P;c2VX5H^1@NP}xnc&zSXDm94LBi$
zH>4#@Io>C)Ii=qkZvLPhIni(5{o=o=O+iDf)ReX$p#Aj7jNN!crLrnz3Y&y&|1&-I
z<fBKW4F&Ke37INXjoSKRId|pOBHQxZ(MGFCAJPAcH>#bMi;fzF8B_U9N-Tj1l&4Cf
z9q+l;BAf5DAt0*9&X2ypm}$AGw&9N5vt?J*#@=}JSoo=bepbCrO0`OBrOKwy6?3L4
zlrf`}q*vWj^AakG8)phKdc!sKcC0zo#?<hZp$-AAaZKq}&zM{Zz8?~kNxOM<w|(-t
z=UzU+`pczv#FWIKwr;Hajnu_yXNcj^P0lKXri(~iZIRrlE^S0QG^_x7i4619G^r9X
zM>wunm!#z)@kvok@yoU@g-M9HN$o-9Ravh0<X=Ah6W!KLwtLUjT3euHn72hpOO|1I
z%Efl|?knY`)~Idaq>T%w8pf2E6HtL#w^a9;p_4rum3dL2k~6iyuFagccBSnOjWpO5
zx7SJ?cUybAdRzLHx;)fwh2>|gVpXm6Efi}|5w@ASB?V(07Z|{NOwNY#*YgYN2~t5t
zZgkLA?f!T6?86iG$_r2E^K?;l6ZLkD+4jw<PQPxgHFbvVsYlM*>-$>7+<}xUmYuk9
zn;Od^#dhNOsEu^ATYZ(x0^NT|$Yh4}(h+rCTM@Ml@4we3tFKdBS8li}{ykA>4Xh$d
z<%Z(fu2TaU-}%&o;S>AXEWfT;Dp{z<I?pj(gB*=}Nt4+0Qj%lLCy+IYmFq68U2psM
zNos3ccCO;5^SY*J!BpkVJ?S=f6+|WF)vbU250C$Qzy5Nc-w{*tp&$Cl-G>Gm4?hrA
z<#{|L`zuw=T#6MT=K1m&Y6_D-A-iYFYU*;WwoEBC75R>;7$P2*YEcRg+p<^r;1LCB
z^VDv@od|I^W~n4BQyAgT{NPnP^x8hV`lcJ?&|IN+6|hs{QOYc_$Z(U?T)X}z%dg#F
zZ=CA3DV4Jjlt-P1<v@fLzL}J5I5H%O*gh|~zL0H@IzRVPzdiPbiaNGb+SPjnts*<K
zyG{14%!o))tEz4^-mhO%$0QCi6`F#Ol4)Xk?8>P@0V<?-*s7hMu&+FKP+_PyR8vU2
zRwhZV5&-wghHDMkcfWbUI%VHc>qwVj?OM&`Szl-ElSRt@v@1$I;=F5)kJpQIL|uar
zf^@{0QB2#`Z>_Oa_uPM;x@I3wF>J#0d{yy8?Bp|N!;gOMarLI_#;H<ZR|G?5Dp)_R
zivQU~4PuhnME^YjbL`2u8rD$Vt5-{S;D{-ZU#`#+(h&b38OPooP!A!&if6CC=^tNw
z>BO^s-Q_;NW2Ssz-;tKh>k9uAX5`1hkfa^4D;LyI&;O~Zf?FPlSzVn*7H=rD!KO|d
zl3BK>z;dcY!pNlT&i+ZICWEg7GbXDCGCl>Rg?41Wic25*u5G!pT(;zG`ppAcu-%ZB
z-W(WESKyU)#m=qPr0J>cjpx)5rSOIV>oDeo+5x5&(t$x$qbrLs<m}9XE_uMm!~q5C
zY|m~DClUv?sO_Qum?U0$x7BXYoS20YNhOVWQ?nZdC{sdESP&!4Di(QVo#5{(Zm}=?
z(Z8q)T(fR6)KRG$^X6M?g`t^ZU;G!vMW<ClD+x(Je4UP0R9R__T@k0Qt0Gf!JS2I=
zjM$HO*Qja_u{o;x$4sT%ufF{n%iZ%HO<YrT(F%2~li-LBfUM}O9r(fHw(m!WZ84(k
ziah<0aFarE(pVN`TIsSl(1KKHwQQkdK-iNZ_4Ul_H(s@;+|D*;SjV{@jei!%f!@!M
zghVoWBIK2#uF))&Ef%i1^}eT{-j|3T`z<d0`5iMQA9?$ZqPnq(vF#c1G+{`xIhiW=
zPm!ZQ`{shY1Z>L`g@V?ulM|tf6d%)&D2aekg>qW^Bw+<Ckj#iHf6BZPtHl*Xnl?6W
zkNn_i1#~BE)8>1%8O(?}PiD*}Nz*F3>Z-jq5YD$Ijf9J-M?ghpmZyptC`)SHk7|Q4
z>#NObvc~OaFLqnoP=l@7Q>a1)LH!9HW&b{fkLEkAW{0LOOcz@JgzQ9BbvjZ}=9B`=
zn{TbN7hYOrKlt(^R#U55O@-HMDpB<zd-TC3Im*H3f*V=Arc_`B6?XKD25z>tSxu3)
zmJ>tRhzsw-J;4XyKq!k=6}D^cxYHIZb~*bIb&Z-vDkf7=xe$~U;dtU7zh|9q^lHB{
zr?D31Cmj<qS_a43Q%Fok2#>0I2|;O<ux66aS$@H^RjIV@S@9TQutn7;L{>OB93!MU
z&xHx8`CadqgY$)d^v8WC&+iIT-u;RHxUc!xD}R`+*)T9<j_T?NgkyKXjEH=s-ME0|
ztL1@bst93JiTx=V+ATdAsiBx)mLwPWHzD-Z3R=*pwK=I2?(QN%{)yM^C*OEUjY<b>
z&)!>|J$XK3!l*r3VlHe{RKL?+6Rb&pZ;y_l@RK3}5#i{}NkYSz*&1gzEU&*>jIm8E
z1+PEbX9v2Yw(06}Yq)CG#@lD?$RUMGTE=8!b&2V6RVAa0lkCX_Rlbk5PujZcZnH<8
z85Uf$LM`foEY_UEtn9EIIM8o%YQ923mg=_??wMBE+Ch1<^FzH(T_YJa+Cz>UIGTZ~
z77w^k59%7vecg>8v-zA=N)|{v$h(Fip(Uo2`BbFFu#+#f*^6I((1ook)~^%Jms&q0
z1mkg{BC^+YGqS*#Fer;MxH5ADZ!PDN{QmUtfb+WJX{+q{mj;!X2<+cknN=)aco3sT
z8%7oG$|~Fb3ACpBQt$BLU13T@_WN#VxIMNoP?Mr=yO{1C87S@x!;n6V!2Cb*t!rw8
zI;Kgh&CRMrSBeckH$6qRsM39?eP_4GS>hRr)5k1^gyt11%$DPnRghx`pFU|XKl>wF
zt5(nQvTO8iVDGsNm(=-`-dkl2Yxm5w4)le)+FC7@;t@&Bm_DmS4#m6}5<+683BG#E
z8qK(F9=E4Y0c*X%uG-tD31g}cO{nvN+5wplV`~4+waMPFYDQJqP_@>+^|N!9HmoXp
zP3)z0qqzl;0AWH(U01Ej5i?g>>rli_pHLWRa?r&ei9J$KLDwO+BjjU`{J-PIt1ai+
zTb2J8vj9PzAe<Noru6Fi#c#b}#~%B+aMtq$>0PZt5@`o9Q8H7)jGiIcpRpt4vnMrh
zU|uE;^%ZFv5PIEJwRW;CVl9NM)Qp!*o+)v5W;I&5YE^aXUw-a|-%H-+oxDE()84_6
zZn^9B#_`5C9>~%KNmH0(LTVXrd|oHbhY$!2WeX2|%jOJgYf_)bNfk-ROARfG;Z*nw
zvO`RjH|m?xe#;UwMb$)#hPacNE@n;9-OPzDtIXA$>Op(z!AGqoXWr_!->qNZ?M!cD
z@}q*V(KXlIWTW!HPaZj<o^TyN7s5)E3F(vcRHz8js2z0zn$=gvtz3@4)30{hKzx(!
zysyqmvpWS79kLV8&s+Yi=IUG}CrU1Hxtg*X`}6FFUw_$ZDgryYr$;b>Vn|Ykt2dRp
zaL@6^DeFDeV&zdLpas&AVv0OTNbE;Xgn>%b(y;6O@3*uoZd@E3(ictguG!8xGYN*A
zoNlwHKmV|G2<)JszRKOi6XTj9q3^gT2^m+|3MuKOBKBg6L~*v5FGV*fiwpJ0L>e0q
zT1HOXuD-d!9(qipS=3g{O_oet&!|*6wq=Uy1PZoZ`-db`lDBy$uirJMM0BrNTm2iA
zIWu{aD(@$Y0YgIk2$l?03(e`h24yYiEg4XH?)Y)Vwm^%}$%{!H0E0p>-b+bTH})jt
zRF9Y!f+^E<VoJ*L9J24j-+N9OkCxcAH@{D(zd&1{zRzb&*lpA1+bte0uveSgEF!$2
zIeD~m$^vC*W_E^9Bw$V$)0CdX&McG^Z9LRxKOZc$hHZJar$RVMs$y+yl_!5<)HZMK
zx5`_?_Uxk*n)=YLQoU3g8V?KXX+|g+Spvu^cb@IBGs0qT>vr{!WFDyjWuTSwuoDc4
z?TEVGx})0aZ@k0C%XZ2kAAA!->f1S@mAT{4@z7&me!`{{dV(RR<uy;sp$Z(CfYH6m
z9-h>oD8*UV%3PULa9rp#s^O$uP%2qV-+*Gpqal0XS4ypKw%ne5UR?&dfnq5dEHAB+
zOoWCO)s#mELT>fVzxHl8IR5zW8dGw>dp>k)!DRoD8)uZ>nv>`0iGCYY1}CSlW7zVl
zDs01+JS$QcVy9w)-F;GB5|54{*(t%4sQa)y!BjCKcRZ9XPa1WenFgMY0`>}NWQo~P
z=P&;3wUpOidc>}|_4Y*A2&tJ&*kJ=MY*b!bZ-+XE%=%iK#9WXxMwRzzfaaVM0N9#~
z3S=`41a&@gyx*zwf-6?3989rEO%K4%JofXLUD>c`k3Tu7s%$Z}Iu+-n5h}|hC2PyA
ze>~I9H3`n9cgQg$Q`6>@JEmO$hD1frX!Hx9Q{=p_x@oiJ?Yhr~)w=7v>qKpUk3BjY
zGGRZy{@`PwXCFKuqeB2zWu;Cs@@pf~CTRl5N4+|nN}ap$2@L{O57kxM6q-|vGhG8i
z=QZSsuodP)mqJ!iK?wfNzh`vx9((Ag1J<X>xdkPl;3*}%f+>kZ$0czit8VzlUw-z>
z-{N!MEqYg(^8I&x@JQ1e2mUZ!J;2FK=~XXGIi%v<0@*05)si`*lXuMqd5gLrZJl$D
zF=uqa<`mS;(*UOiIR^bmGC4UoLf#BOonxm$Fe{9jD(|OAG0-z-`s}f9e_vHe`HuO5
z6BRfG!D}9yWM{6koqOJE$5e<s(09a2wYE<cM=2$$<y6RMx>wEl3b6L7iA!dzUA;q6
zrAJ<^oEfq}JMPw$wOEHWH45HYQ(K=IRJY>1fc#~jRh0_Cta_bw3z@A$-JWT(hYQPP
z+le6|!YX*%o*^-7Rw-O|?FVkQlr1+e4vncTGf7>0rv_LY?8o?gxBc{=pR}Vdw7J+L
za}>Qcaii(fSr?~iObaxmd#^k?uav58==5?M>{ccxM^G>-+e;U-jR;O~{n`cl=x?r8
z4t<?8SeosBzRSinV<%N{=1egwnL5tDr&-ynQ88@grW-zfIfcCbI2U?;SD6wKPCk5e
za%#J7q9rel9|J=|F_nMK&df+sN<b-vHyM*hx=QgwWhsV-XRM)i&gvCot1VFOwnnKv
z>AKcd&3u#v4r4-|A$iTo;(sqe>8>0fp0p=^{HzKyMs3HH?`JbnGGhkbIa#3Hd+xHf
z#Y}tg`BQ4fS5d9byR?{%$SbWZmZz%h6O<|ks6tjjg@Pv7nP)n3t>OA&+gvYP9?kW6
z_<$TX73rpC7l}F3#poJLs@`mda%L$wO=u`X9!*$xD0U=Xwv&(oC)g@1qRqG58+g~f
zJu=n;t>8Xb58i%6T@Ri)5&GFzp0KXd!vaPqaT)_@h*V?&%El82A|v8&0J%1Ak8473
zu?znc=tquEj<_<n@j=~$>h1Z^J#}i7i`t+Va#T<}&+qF|kX&BAv=BjcmjUqy*7KB*
z5lTwyUjEDf_1I^UR=+DR-&LmM8{PcD4~(|FapZv%-C^EKOIF|E6d~SrELy!%eKi$A
z;vG@@XxhA07e_2IJz@<NQbr2b42!AzhjIk72lh>dV@xtX91|v|F%3rdcQ5Oape#8G
z^kxaJ<)`0zSw+TA+STv9OHyIAzFo39hcN?nzIFZktgK;^ooZ~h@ow3o@+%fJiDFEj
zQJ~Mt6hvQ#I2DPxeuGk$vNI2z9kyc~*|znr_o$V3#vXn`ZKowsg~D`EHAgY5&`qRF
z-~sa2a3p}7aV-mykOhVM?s6VN3WaUov(YMVzw1rjHRp1P66*TYvj;*y{>n2FqN-0_
zt#QiAO((-hdxiu~dPYHb;1bubiP@@}JPmXL9XW0V8A_GvcTGwAKttW8#DL<UtBTYz
zGH+Ft8TP_!<7yod)0YK40nCmA8dgOVgcF*kf`XboAN#NGG|%l0xZ>emXG$ENE4C^h
z9-GSZF~>O-NI)=Apu!hb6PaNf*B01pTy`Ozx{3>CRMOVlEtuk5rE=x(j0wp%Cbhh#
zN(H<sa5#5v!bwby;cZkTB@F4qPX70?jx5mO*IEUT|9#tf^%j@uIiE58)?|TJsVL&Q
znWF;(;hwH@mM4J&W8$zas<i;fL6~!(SD^VyFK(2Y9y+I7^}#dthNR6KjcIBU69Z0;
z>bosiesOvry_8OcA+aBkjwPCnNY`If5_Ri!yDe+aofq`3ePA4QJuOMK|LafL{zr~j
zs(=zoG%6*TAp!Y<@x$`|sQ#Hq)OW7iAlO9pn~#nw)TSGniY>C-_>HP$bwPO{zu1P&
zO4ycw5~tCBCFOSDr7=lj>`58fBAAkq+1|EXRN|vRDa*h9+!G)1XYk#8e%G0jFZbd5
z_fB*-p1T`N9Edoibi<N#3+c?ob!N70(r93TK9v;7aZ&4MNGfhnc3Z!~jV*n-)~}Wa
z5Q{RhBDPixkrPok=d{`vq*4fPKuAiaxH6m+#^irvy!RCV03ZuVL_t&-5<+Sgl@?o9
z`=CAgorf$WD7-6o+~wZ8kazB@jXK1HP4blUX9Nc$J8)2vGq+4&16?Y>)kUZLj5hZy
zNxW*cT|7CEZ#h%LwoQZAPY<XcN3-!#6_3qIQz%NA67m5#WeKzkrSXbOs;zR@d&Hqz
zY^D8}0j3{W;P`T`m?FP=^<s0&+0ec({J_qh?zW<uQiYFnoFoYeLqg6pkRWUC4{J8$
zynd&m9V+^zgEFF2Zw$j;B)3t;zUnj-V+xDkR<DWM`)}W<bDFC{jSPWQrQ1_ac8bZ>
zf~@n*&Cj*t93y0Kc;=<X3OBv?8<z?);J&~`Jp6BA%G>X}ul3ZSSN@P<3J63A)UA>|
zj?$4b0*Ws$W1?5oUVnYU4xgB_SB?pkN{}Lb<JoGl4ZO&ZVE)pTY3S3WhE+<n5#;Ue
zm{ws#P-v@5E+&z;EQX~3#51IqoQpb{FlJcZ;*;Ng-erMqx&01(k9As-)j40S$1&ZG
zD>o}?S#4*UnstK=EBGC<0cA2_&O~}%VIP?o>h;;NDQ-`7=2(GRLuRBA`cew4Qge$7
z@)lfSFS%=^m8XU+yR2l>bvBTe9|Xf!*pF;Sst`;{)b&$ee9}3GB^70IN>u%`IOP%z
zgwJ3|m{DM7Hmd5Sll`*Sg+P4WRl1q=nZBiWPC!|cv#JeMg*r5;o0n>?NtsS5!YXR(
z*1nyDsIu+Mi7|WeWmWelR5#ZQ0f4lGDHnC4MoVORZF|qV?%=pDr-wkK`2XI;=TCm9
z=BrJe0}o_qeDZ|wfL0Pe7W->Zy&uW6u~wd*92x@Ys0?ULt%^}q{T-2)oi7#Gd}h`T
zo>f3th!<I67znSE?P12`*Qj@hcxSqtrsJ=+*;Ut<*{A;Q>oYZL8l<02x%ZbJg5q3-
z&+Uz)r|h}Mzi4BpUbM9uNyp&!wM5oM;U0y8R_nXSJO8ggE>So~uzvbI8&)a!oPYjr
z0uh6CSKoY#%@kZ=Lo{Y3dDp=agGU$=B0ID1;UiWe6peg=`jflocfp8$It0U0f!qex
z`b=|%)e8(^@AWc=RCmB<dc041sQ`>{)5Ub-jwmTGDJPS2%%tJo(LkeRs;DND9CyAN
z*(9#K5aBgL4>-S}aX|sDUH|gmfBX2g!8d;QAOE*VO1|d**WQ^2$623u{3m&JTlZo4
zkS)a**ccm|!vPzx!&zV&D1=N>3Nsy;l1yhx+D=m@?&O$ZrcIazlHre(78;Y8lm-Y;
zj*?(%urUy0d|*qqY}v97>$GHPb*(IKzn|akW4|nGgK=bAvY#30efNF$efNFe{qA!g
z7(C6@JMK%D{574D?fmKx38Yb`$XlFW5K`^3k|X3mE|!ZTO@NFl1&#=V>7+$M;sm*m
zsFfK|W>JMQ$d%3J8V*E!M=%~3EtTPt{BbOQa8cu&xJ<~?oK#Wj_SJT{m!JEuP;$2s
zKLkW#mv<Y@zhtG`BNxifz11#Hh6DYE5a}6mxKF!0!#(r9N-P?WXb3y=5fxG_A<hva
zI8|7{nYk$B7GHUT8z`$(GpiQQ?fe+&cyPhq@2%^mgDEdR`fImkUA-%xnJ?XwoKs1K
zI3VGSINx!6H+P5Jfxax|fKG6Ws`}kcw<u9r&!MwJ1#arEB#lNPLgEr~8R@ce1y%~e
zqB4RM#r8f*nP%!!q%O;P{-{t{`aGgP21u@r*CxUh%5YPbesfd|9D5F<21+w{qLIFQ
zZpiB<{sv<S0B{uw@F8v*kVcd&ktO2-Fd87?vblOtg?ez(7^S3ZTCKj2ifJlm(6)yC
za=qY;mLY<gfKCY*5jQ4s;GUjT{GTH6m#?IbL48Xv{KsqYD9|0c0&)!z=f){zZN<g;
zWml|J6lkg<9(y!cO1(B^=qUW|w(W?zmpA3R#TU!kmJ!jf1dnXFTe32X#hH{Hr3R`C
z7EEz-7OR3Vzubkp<S>jAK1VZVgapOTCq?VtelO*v$A9a^_2jC_K68q<1ITRk8OqWR
z5evRUqPku|hrRV#D%ExF)@7<xTzW(nc8QD{RYxiVoQ`NDgbb@)PS2o1iu%FiiRJZ6
zlv7W0SpRUGN3o35h=Ct9#P`7WVc&^ugP9N%D5#p_9)04)Q894*1?b<Xfszlv;A!}{
z_BPx@W_hDqa^s;ugn$P?JQl)bWCoIVcL>no0g?`4BJqeohbW&QP!~&gn^TeQnp%~0
zq%Q|x0z^QG;bXuCsEBcMy2CLGWCUPczWK`L)Q>j4;jX=PW!!Bf<;oKrlRrQ@;vMms
z<+I&;GB`rr8bmLS`F6d^0~AXyEF5ta1^N06@+iynBat~ST71<NE^Em(u4zC8S_83d
zZ1=t4wfsaf#p>5n)~K*6O~rGCiq4=vdhW=NOClRUlG3(chD=>YmTPHB^WA&zyd|RX
z)lnHZu>@Z9#yrG`sJB;%)4fs^WSP@u8>>G};yI$eNd2mHMlXeMvZu)?HSWmw!(WiR
zgi|`vmzG@lqd!I>Z}8lS>!S)vg7g(-8Q;eN3k8iG^b~HKC3IL%gq%JD6Yh%%ipOHS
z^r`;4xlM@+>hV~l1_x9brb*O<lp>d{wssfH%2Jd2VXq&-X)%0I88A3aq{lubX05Xg
zphCEf_SZJL*Pngb&0Ao}!$SB`0+>)N3bb&ErXeUDY)9=b&2<z9Q~WwFFW)Vh)#0Xy
z*)*#r*t>g{uQ;0f$kdD=ndnAb_jT8$y!z7@+@`hrTwZyxy6nQ`kBMtsJ&0^LB!Jx4
zouwAf^7Bf6yzLf+4hu@%ZW&r3>AOZpQq)~pzEmm_X+P6DD8o@4GpweqMTNtzNZI`Z
zN>x*;t9Q2JWKY$zl+ySqFxolkc7h*v`usmmBCnk{*>Y4t$p_xPth}=QK=&fJC3$<0
z0TEDoE-9lYDjyraa$G5Rk^p1BM4ZLBm80)kW$ij;6y-}q`mA=HAfl%8=>p>HstniO
zbwoovm8Bzn3Oy5!X)Yp~t73_pjv2d>nA-?(-qsv;&;R%D;!&VKi|=mH(m**RJ#3G3
zuL8Gt@g+(gp5nUeR12hbEAk1r+0$hjiTk%_SGkFoU#m7J<vtlV5s>z|(=W;&s(xdO
zFIA{lqpE2aOp&grUYYX2!Xcrc(|vEJB*LLg4@lD=BdO)CzDfFcX3UVJ<49Nl8xkkX
zRilGp{m{F^(&_aYBM<8CO;e9aHOf-Vo&J|Y`hgwNkDk0&o?D{m<`}-O0gXtRGiRD2
zIM4r_ZKFw}4oWH>H*VPY?T|ppXg0tXmCk75At<_wi`Bi1>~#ThSV;;VQ1Zz^fQk5a
zeT&lh1vVNxb*iu`Mcc{pKCEAI<@Av25|iuhLdTQ1(wA$%v|==Sm{{Y8b2u_>0Rg6Z
zSotVWPv=^<@T!~jBe_6tKc;6&lhkX}j0`0Y$D%;{>Z{#IxWj|8J@Z0$aLz3<zH(G@
zs~~_{)EFVM;gF1T!QHdrnKwf({@Vrx2WVV1*^6rfq!-spH$!C8%yds{nyaZzKdL`2
zzeXX$aH$v1=|YS=vuYeGE+=dbOE1q=KTL}A>JP}mmOh=>#ybYgELWb3YYiXfpxj%E
zh-rObSjLb-zay$F#SrEDLW;quFSz>dQ8jSvS&f=Y$UcDOUDr+Df3UT)A|qE{yo?*%
z8<24X!ef)l<wsNLYB%xl0ksy?d%PYf4hJ0>4*Mnlc+g}H&8=ckr4lJrcT=oN!wD*B
zohW}~t+I8t?;4OHq<%oe#^nM*Ex@HgrKRO+avt^rOiBXarqJ$PP3nx6@4oxf$K0X?
z%d`cz5xOPD4`k~l;>?|H?OV?)X{6V6WtRE9$K#Fw5@Y9`r`~Xz-|tXewkFo9Ji^GH
z2SyF?@vsb$JrdOo4KY8|y?69F`X=q%Tk5T7j!RVwLWq8$P@Wk3ezm-5R_r}TsOEVa
z8Mn08)76EfRLuqk<xObUgx!`y3hs+6bcykU%GK5yc9&f{-#zh^(xOfSot6(_GFg95
z!-DL*!Zz-y;lt;)(-ak=4<&UyjPn4HzU@mKEdC8i{?Vg|dDgj#AD0!!ENk;)^7bGw
z@nz;`9{b|)ff^`zFC3Ey3BZIq1Af*IHXZW*zkB}iLA8h>sTz)1#~~uXc?_5X9Z$Pw
zR@b;lX_b!c_wPvj$0(P&n(CA_KYP(n2gBWiSj2#U0His?0VEdo?gKG#%?$5veqEoM
zSL$}{JEl7VNLt;{wa(h#v?*JuL%rDnq|xz!iCCYd-b4U1kr*}8JM-ojQbJYV>+k6*
z<GcH!UDOiK{aLS13n&vW0>^sa$f5gi?$S<>x}IcU1TYYwfr}Zp1dNKD>C1@eQdJV$
z(4e9$G-ZWj;$-iW7=M3<M%KweY(^Bnez;?hV{)u<N!AUR1K|O;b9<k={oB{L@Bi>8
z?2@S5DD|PzuOB(G)vf>4lkSP1?NM97iEi%9a#y-wwwq9@+J-p69ic6+Zd7}}KlpW`
zGgKBrfYJa-j2v;@C_NB|HU<s)<1M!;lRr}GB?5`TOj`5f^uz^OW~!Bp(mUOby4dpw
z0@8m-{2$;9a!Wu788G3PK^m#N_iLxps494_lUbKD=JXRInQ35e1cw5Eh-4#PBf<eB
z1W*7DT+FCIx)Xm*2gsV%m!qi5u$ndv9#+&sx@Asbx?6cww!8Y$7$*Rn008ksG$Tj`
zc((C5TvLAGL}l@mxL2Q9=k8Y@!G=AZay#Focfcj_Q+B#XepKh?FPY`8x@NZ8w;XbN
zw(s@(_-BB8=_fC_SO4=pH7rO|pYm9#EBk|h<Tc_NKyI&AR=xmv<7HuY_cv75J5r^Y
z+8X&srn=l=a7SyQ$XGq~);|hJ&eNy%Df}fPfM|a?nq~$_x9ywY8oG0R?@*4Bd89HA
zwXI3ZSd;7=qrL6eH$2*(6gYooe%1PjOmRP<K-)>-2Yd!V-fDX1QOCEorO9^}B%ML=
z1!b(u`AZ*2fN2CU2UU~?&6`!>mMzMXuT!N80;boM#4+vM26j8Y0Td37A+b=SSD5Pc
ztvhbZ{NMk1MrXWSe?9Jl-+kz2s`q%+Ty->ygxrc1Wp4gdjpf^W(08T??`w5WJ-ph7
zHWAmE^i!9P1_8*-sFG;o2^CTjr3b1!M1X|uzAdb&W+|%n)F(*-O!QODG)6f>sYy&7
zVcXv3Ecf2#*bmnq82<;i3<5JK!g&i|<c9}9akaInF35lxk^vbloY8o)qeg<Ce=6&v
zZha@aI5L&z&YJp{vVQZsdKBbW7|mQYa7f%hB<-3%ktHIV7BC?q5F&Ywyyz!VMD-+5
zjIdJv4=dL%UE@UvOFCJwQYjT*SBY=BI<iTR&zDZwDa*M3a4gdZ3m?ney2RPKZ`3c~
z&`5#y*(GI);p@1UUwkW`ZB*e>8(((22d23)C0|749AA9xHR>hQ>vHE#b$i}z4E^fy
zSCo+x@z!<F`Zqw@vl*0MwN2UI#IMmG|Ke*AH$%;-w(eCr86Dn~kP=q%E!{qP!$ab@
z${AH2+}53k<uC1V#hP53NW-$4A%0X4FR5vQOoRhS)^nutpl5d}=|w3Tn!2IR85s*7
z8*L}KznCQd&Il;EjvH@WamoH|+ZL++$R`SzGaEMze?|t@42i9D)xTt_Lee8rZvdDU
zzErh~bVYGYd4vzN4k+hPy^Bh+6(5%Yq3#b6)uAv*bIOc#H@QI39i_=ND>;{GT3J#F
z_<TU`WA1WE8At&Fd4%lCEy`6SNMlfbyWTZ*wz{d6^Bg@OTMsIcR`V6#eXHJ84+=;U
z<G*?QP5(n8I%E1H_hcd)A0!l3W;hWV;@5MkhTLD>Cp9EnoLL4<rb=_AgviyS1_5y&
zT4BB%-x}ffQO%I6s}Cmyq(3o7#<?ZH401~D)t>hRCGMKx$9j8xyVRZ{S6I39l-l{(
zHGGlf83QG`cz53O)d}5Awbx)!5L!f>8VK!XFi4od1;+w}@}PO&BL>n@K#G&msR3a6
z#3zLSySkWwApKC5eX61z^uatL|7cf_yn5me(<_wFs<(Hv3@DZ!>t_@pPci^Vy9Sm9
z%rxn&<&&~q_5an#XFBATUcX3@jw;us!mxd6O%vYN>^8k#<BDcz=#^sjaJnEdnmAoQ
zI=CZA6&9hn_KE>_-(4dL7Z%Gsqgc4+ln=!x_*#eK(n2L*s6)q=tzDWY)S*sxa-GSa
zcsvSnOE_haTiP)I5%PLwxXmq?S6-hp_wEN)t$J*&z2|f<kAFv};Ytt>cYNcnwOySZ
zU+Hh}$`6)M@bLf=OBs=kwT&AI9TEbNh*iKyY}fwi+CZh9oJ#^591n|GCA%_gqKYF=
zRyi+R6ZcbDfm$a|Mz@l&)F6ku!l88XfQwiwL*tzOGvgeS&nlUk=bCDpR6-DOmoF`m
zA=2meY;AQ-buB(SoKn_AN>eo<MD<{=vctDjE2&ln8UDxXma9Ex>kQS-kf<WVO!^*i
zY8rsiOtwhv0_i)neqDo_WA%w^D|b@y|Ib4v!g;TWaMlssfU&c!Ln(k#85Ul@x?t9d
zJ65gw@kaKaDf*-j;7nbGKKG#qzxvC@kJsFTBb^*f$Uw>HUn6hae3JS2T^J=$Vn;AD
zW=f@Zne|FuW@fgs-sMtC3n@QQR&A%UwKwiyjB%<m!(+~BEPd-zOi#)n`I&}NSjkn~
zEmustM)Z;Uh+h<nt8%gRI2du@bAMD9n*NCYu}mS!+Woo~sVGKSnhuPC!$h#O^kMgh
zt;%Yz>-FNA+)e27g3``ut|AlV19B$~^&WIf7nati&%WdD&xHHOt}VDc_7s9!&%iq3
z+_+{W+?|g&_hOqY8L61QeX%;{rpn63unErYfpZ~VAzw$LV~kJ-;F?GD9z}PRKpZc=
z7wbKw`7vtiq+Xe_Ze^Lzs*>A92R5sVu=u8rLvub8-H3K0|9MLJ4yCINpz;*cB&vh4
zV|yRmk+NHg{YesOYE$8yQqD-I_}2aU?DP^>vtP3fWxSwbK%o@1gV7HLK=$Zf*RJo<
zblL&clIso>Uk8jV`8$#LwrgN%fMgvp-q)>PhK^sbbmdvW9l0)}V=TzFoCQm`W_!)6
z_i!nhxh4LJ5Z?guu(*Vc-3wkSVjJ#d%iuoNX;}xAPnLtbgid4X6Qm6Aa;2T&I_g%7
z>B@3d_9^pwXMLYr|NcRDphLxA3RRM^jdLG@dqc)K5smynIu+(NcaMLA{uv;7jX`7j
z<MIo_?&d#LH;QnP%0D!sTH=~KQ8*<o9|%D1SG~_JwY(-fA3#DU%N_ke@qcFc^mli;
z%9-U27cIZ@Z_gI)7`)E25|muv_rCk**G3!HJzd|_JcBvb4Esc<98zI_GEmx0B?F~3
zgW@>ASy)=?N|h#-p^5f@GecJHG?n!>s!$D)UNl96JR^Ndf>8WsTP&%<L^_|72uwzK
z91oBfG^hkY|KqYtQ{3)m=2hxk0g-L@fapel-0(q@qeP*wB&N==KM|BxhGEB^XbBi8
zcUW@WjjKy5E_~=r`5{kqjqE#XL1`DB$Ti_gfb2xT<XFI$qLIl#^37aThDbCiBS%f|
z)xO#YU>ZQ#7K*4_TbXhf)hKGs`u<p`Qe2aW5b<*eSBmMKM2Px_W8qFSXn2q5kE}oR
zK(D(%tpK;~R0rdz8b?XD1(-2X2}4|e+_H1TZL99~`r||u$i>y=q=4kuM4-k`cys}$
zO;w|+xr?WswcPRO#cJiO2PGH#gCBh7uEuR|JUh_2OK8dQ7CGC4z)J>H<B+^JIM9^W
zG;@V6y0F+U+q;yQAeT#iwnp5iDfLV~%}h-Ln=&Z|v^Uocx?Ni}TfBJU(IP4iG*EU)
zJVVI<i9`Hv9+XqMbe4+z)#h2@P$P^PTt0*jhqJQX_RZa{{Xnbdju=acfDCd*Gk7@H
z@qh^+;kL_e`jfMoJKFPLdF<%~x1NRTWE!<MRR62#nyE~YC0jZ`fRtfMa6%iZWV=HW
z-HG}rmN~lNv~taSl=Hh!<*DeIh)*~tS?ob@*4Fg9->*?a1SMaPd1M?DF6p~dq>1xt
z01}zpraxXfZ_wR)_lP)du`<M&81ZS>0iQ>o_08(+8x=<@k{=XxAQ>RJ9|PctK*@QS
z5;j)2qkT^-#|$X#qT!kccRcrOYon?H)kq6JW{`|~2DxN#KVm<qcLGd6HG7uyOc_9l
zgh-E$gniagNp7aA-{0fjUmr`z$e64_rV`;f>HTh+blnfbO14lxA_L^@*M;56<uUz{
zoX@;`wc-;1A#?W>l%}aq=MitvgyddAcjcP;l`RzHl)>vt21@qZ_OYTn2Jb1jKITBl
z#V2x23?U;x387CW0yC(G0!$-(k%-^P>XtTtZiX_CB0dp<RJaK$)*_J@zviHNI!;!j
zR*axcZ?q^SBSlj#($rrl>Molz;{N5y6om_8dg_Ds^tweCPj;JX#PQ;mHJ@jo^g65~
zI&;wLk672#uqPT!#x3nygG)eY+%gErv)Qr^UjOmd$0R82X5gAFTYvp*S4*do2q?=v
zX4sf02Z+h^P4-9Bq9jNp4r|DPn>H=e1BrcD#~37J9huX;a&|0|^3k(<U3E*;U46a!
zrfV+b!~dM)6DrUji%TYXKynTPBI{6rN;$d*3*6i5+r0i*Hc4(FC4VFX<ng#A=P@9%
z4tFFq?&4+Fj~U&O>rO^v8kF2nBG<&P=^g9ZXPh#~AvwmlDeFOCq6+l%#5!%zm7`SE
zRfum05e~OR&x8sTAxcf3=r;a-x7)g{&xbV2G?eo@50tu28A&^~W~$P$_vrDC$xNDE
zn3JFFy4Brm!`841w|BVQ;+Q!1C)K~>fz$Q}mw*!8aX^OBSm%zx`x^70w43>-f4KGj
zrjIxLqE98R468RXE@?&$#*u*%K+>1pfQiw=e%_0&I8##~Fn|sZDnK14K$)So6GOeR
znjzLdmM?SG)IoRYm0wbu!(mrfqX}pQW&Q|;Y#vr$a43|KskxH_?t=|&>W~)pj`>9H
z$ol{$Wc!kdZ~!^hbw_`bN&bx+P;zgNJo4A``ok^%zI*LUOX;_hOxH932A_oi(?H2S
zfQdMtH@m=9%v8sVII!3UxOlD3;U1u6YS+vR@5a3v3MH#Oq+v?gn&sG|Q6)xzbK9O_
zxqLL^P=3~+{s`z0(*{O-p;okI#|ME)RcKFmcwBKuyHA$m3Y2zZaLwlGO}_{q&>(n~
z&O#V7fX^rqoQUqA@nak_tX3s6D$Cr(mnx|@+AGo9<3)HhBj(@C&5_gnu;%;>Mcm+_
zb`MBC1K^U4?#B`9^`_1JZs(Rgu87N#>&Unu?==FHTnFVE=7={inr_+E5gs?XquqDn
za$JIvn}ln&ZCmqX%kEuYR#CM}&nq~Z@nf8k_aUY&8;RFY5S+a3IVd0&l)Ec0*El&j
zzQeN03yV}vAus~eG}`rwdX*}duBZ$ImjsXibKTpG@)>p>b@v1TX<X7Dl;of7XE~_M
z_enEK$3#>n$*p|uP2(1n_5>dOyE}i_xc!|~0Bd62G3(s+vxGY(Bfv=_2B2+ITpVt7
z>#eg?qaJci%K8SNM^a+$sD5>~g*yUD)(gw>U3>e8d+oIv--KbR#+h+0Yl|4<fQg@-
zXzcWM(v2>4Tv*nL_nPeWxCbRSZCrC-UEP;`8kwB#iS&7Zi74+^4bk!?lYFt*usXLH
zDB+lc5zS<ju8BVR;f_A{@wyt{mbze)8t925djl$7IF|VNybgjfnkoZJ^Ar)+<H@p4
zcHfEH&IwT3O~W<oHoUxw%$;Oh(|`$w42Cex8s|K$_iF6QqD7^eJQ33?5!;!n5AtF>
zl<nSCXX2e3clla#OIWsJ5#1(|*%n;qH3T4W7oAJoF?Q#%|K}7axn)w~!u20L0@oxH
z+~U{lO9n~+YT4(ee-f6YRJU?^rdx5-JV!!upSl60W#_ne-fD82)ttXl4tVP<Z09vj
zX`-9YG(t6i*mthzj<Gxb^#5}Xl=cYVn)^R|X;oOYI&d@eMzhX?k)a@$v|}xwvRhS?
zh~^bH%=d=P+BG{p7q#3=jx|7X?1@0he!$2SirH7)H0Gl++|L)Ka~705uw+~lU<N^H
zoDwc+gv-V_EP7_1#)weZ-+MsAoJw*%_;@e=MhK1x0ZI}rEIep&>+$Y)^f!MJ|ITSp
z+H-<y?s(^wRivE3`GVZ-vq0(3q4qNL_c3ve-bjB;$a)vCj^!QJl!hRU*QiYJ9#3}t
zJSgK&46eCz<J-R+?rpD_sQyG24GMx1u?@$xR(TxCkkfSab;Q_#0AY{};E7xkFb-)Z
z<yg#j4Bp>pte*#E!c#R1oy|DhAq<_M_y%A`zC1#}gi}HWO1Py(Xo9*VqPwfUL-`pK
z##A=A-S6pGo(E-;r%X!R$M5{+(FunRRM6s&n7CCl^7ddD5a5~a$Uci%v)#xdIP?u4
z&oOJe-&0*4dvd3Grg3(BFeQ$W$WaDH2FSP{n{1Ac?KUpS(%e7iLd@Fk|5TUfLHQX^
z5Uv@ieg4PWYg=bni)s!Df-)G139g&ZalGX_e#Rp^<=t_Y?J1vU+@65Z!8d>X!PV(G
z`I9>vcP$)}lbk7P^c%7UTQty5TnCVFN9N)zz2WB7GZ(GA{Y>}h87p7Xc}{r}-<0W^
z18r>;^dB15yc)n~X=N<ol=vdg#hCR;JjxTk^*ks~_;^0O({#<+^{?N<piaseOmF1f
zIKt_#UbXn_?n3eDJ3GH+%s&CRCZkv`t4fdFa9L6GD+_X>th0@MWBvxu-@w>>0&q>*
z$^gczXJ<uOXWQ7koAXyauATr6cS<nE)lHqjoB4mJ!sPbh9w1);0000<MNUMnLSTYz
C(8Q?#

literal 0
HcmV?d00001

diff --git a/cmd/frontend/public/rating/platinum.png b/cmd/frontend/public/rating/platinum.png
new file mode 100644
index 0000000000000000000000000000000000000000..9ae479a44195c6af49e768d01435b3214b19ccda
GIT binary patch
literal 68497
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

literal 0
HcmV?d00001

diff --git a/cmd/frontend/public/rating/silver.png b/cmd/frontend/public/rating/silver.png
new file mode 100644
index 0000000000000000000000000000000000000000..4643af0b30bbf7b56ffd4701bdd95b018830b08e
GIT binary patch
literal 56479
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

literal 0
HcmV?d00001

diff --git a/cmd/frontend/public/wn8/.gitignore b/cmd/frontend/public/wn8/.gitignore
new file mode 100644
index 00000000..3f644593
--- /dev/null
+++ b/cmd/frontend/public/wn8/.gitignore
@@ -0,0 +1 @@
+**.*
\ No newline at end of file
diff --git a/cmd/frontend/routes/errors.templ b/cmd/frontend/routes/errors.templ
new file mode 100644
index 00000000..cbd34c87
--- /dev/null
+++ b/cmd/frontend/routes/errors.templ
@@ -0,0 +1,33 @@
+package routes
+
+import "github.com/cufee/aftermath/cmd/frontend/handler"
+import "github.com/cufee/aftermath/cmd/frontend/layouts"
+import "net/http"
+
+var GenericError handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
+	message := ctx.Req().URL.Query().Get("message")
+
+	ctx.SetStatus(http.StatusInternalServerError)
+	return layouts.Main, errorPage(message), nil
+}
+
+templ errorPage(message string) {
+	<div class="flex flex-col gap-2">
+		<span>Something did not work</span>
+		<span>{ message }</span>
+	</div>
+}
+
+var ErrorNotFound handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
+	path := ctx.Req().PathValue("pathname")
+
+	ctx.SetStatus(http.StatusNotFound)
+	return layouts.Main, notFoundPage(path), nil
+}
+
+templ notFoundPage(path string) {
+	<div class="flex flex-col gap-2">
+		<span>404 - Not Found</span>
+		<span>/{ path }</span>
+	</div>
+}
diff --git a/cmd/frontend/routes/errors_templ.go b/cmd/frontend/routes/errors_templ.go
new file mode 100644
index 00000000..bb761d1a
--- /dev/null
+++ b/cmd/frontend/routes/errors_templ.go
@@ -0,0 +1,103 @@
+// Code generated by templ - DO NOT EDIT.
+
+// templ: version: v0.2.696
+package routes
+
+//lint:file-ignore SA4006 This context is only used if a nested component is present.
+
+import "github.com/a-h/templ"
+import "context"
+import "io"
+import "bytes"
+
+import "github.com/cufee/aftermath/cmd/frontend/handler"
+import "github.com/cufee/aftermath/cmd/frontend/layouts"
+import "net/http"
+
+var GenericError handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
+	message := ctx.Req().URL.Query().Get("message")
+
+	ctx.SetStatus(http.StatusInternalServerError)
+	return layouts.Main, errorPage(message), nil
+}
+
+func errorPage(message string) templ.Component {
+	return templ.ComponentFunc(func(ctx context.Context, templ_7745c5c3_W io.Writer) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templ_7745c5c3_W.(*bytes.Buffer)
+		if !templ_7745c5c3_IsBuffer {
+			templ_7745c5c3_Buffer = templ.GetBuffer()
+			defer templ.ReleaseBuffer(templ_7745c5c3_Buffer)
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var1 == nil {
+			templ_7745c5c3_Var1 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-col gap-2\"><span>Something did not work</span> <span>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var2 string
+		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(message)
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/errors.templ`, Line: 17, Col: 17}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</span></div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		if !templ_7745c5c3_IsBuffer {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteTo(templ_7745c5c3_W)
+		}
+		return templ_7745c5c3_Err
+	})
+}
+
+var ErrorNotFound handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
+	path := ctx.Req().PathValue("pathname")
+
+	ctx.SetStatus(http.StatusNotFound)
+	return layouts.Main, notFoundPage(path), nil
+}
+
+func notFoundPage(path string) templ.Component {
+	return templ.ComponentFunc(func(ctx context.Context, templ_7745c5c3_W io.Writer) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templ_7745c5c3_W.(*bytes.Buffer)
+		if !templ_7745c5c3_IsBuffer {
+			templ_7745c5c3_Buffer = templ.GetBuffer()
+			defer templ.ReleaseBuffer(templ_7745c5c3_Buffer)
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var3 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var3 == nil {
+			templ_7745c5c3_Var3 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-col gap-2\"><span>404 - Not Found</span> <span>/")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var4 string
+		templ_7745c5c3_Var4, templ_7745c5c3_Err = templ.JoinStringErrs(path)
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/errors.templ`, Line: 31, Col: 15}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var4))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</span></div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		if !templ_7745c5c3_IsBuffer {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteTo(templ_7745c5c3_W)
+		}
+		return templ_7745c5c3_Err
+	})
+}
diff --git a/cmd/frontend/routes/index.templ b/cmd/frontend/routes/index.templ
new file mode 100644
index 00000000..581aaa5b
--- /dev/null
+++ b/cmd/frontend/routes/index.templ
@@ -0,0 +1,37 @@
+package routes
+
+import "github.com/cufee/aftermath/cmd/frontend/handler"
+import "github.com/cufee/aftermath/cmd/frontend/layouts"
+import "github.com/cufee/aftermath/cmd/frontend/components"
+
+var Index handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
+	return layouts.Main, index(), nil
+}
+
+templ index() {
+	<div class="flex flex-col justify-center gap-8 m-auto" id="landing">
+		<div class="flex items-center justify-center">
+			@components.Logo("128")
+		</div>
+		<div class="grid gap-4 p-4 md:grid-cols-2">
+			<div class="shadow-xl card bg-base-300">
+				<figure><img src="/assets/promo-join.jpg" alt="Join Aftermath Official"/></figure>
+				<div class="card-body">
+					<p>Aftermath is making a comeback! We've revamped everything to be faster and more beautiful. Join our community server for the latest features and updates.</p>
+					<div class="justify-center card-actions">
+						<a href="/join" class="btn btn-primary">Join Aftermath Official</a>
+					</div>
+				</div>
+			</div>
+			<div class="shadow-xl card bg-base-300">
+				<figure><img src="/assets/promo-invite.jpg" alt="Invite Aftermath"/></figure>
+				<div class="card-body">
+					<p>The new bot is here! Add it to your server for an easier time tracking sessions. It's that simple – give Aftermath a try on your favorite server!</p>
+					<div class="justify-center card-actions">
+						<a href="/invite" class="btn btn-primary">Invite Aftermath</a>
+					</div>
+				</div>
+			</div>
+		</div>
+	</div>
+}
diff --git a/cmd/frontend/routes/index_templ.go b/cmd/frontend/routes/index_templ.go
new file mode 100644
index 00000000..279553da
--- /dev/null
+++ b/cmd/frontend/routes/index_templ.go
@@ -0,0 +1,51 @@
+// Code generated by templ - DO NOT EDIT.
+
+// templ: version: v0.2.696
+package routes
+
+//lint:file-ignore SA4006 This context is only used if a nested component is present.
+
+import "github.com/a-h/templ"
+import "context"
+import "io"
+import "bytes"
+
+import "github.com/cufee/aftermath/cmd/frontend/handler"
+import "github.com/cufee/aftermath/cmd/frontend/layouts"
+import "github.com/cufee/aftermath/cmd/frontend/components"
+
+var Index handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
+	return layouts.Main, index(), nil
+}
+
+func index() templ.Component {
+	return templ.ComponentFunc(func(ctx context.Context, templ_7745c5c3_W io.Writer) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templ_7745c5c3_W.(*bytes.Buffer)
+		if !templ_7745c5c3_IsBuffer {
+			templ_7745c5c3_Buffer = templ.GetBuffer()
+			defer templ.ReleaseBuffer(templ_7745c5c3_Buffer)
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var1 == nil {
+			templ_7745c5c3_Var1 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-col justify-center gap-8 m-auto\" id=\"landing\"><div class=\"flex items-center justify-center\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = components.Logo("128").Render(ctx, templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div><div class=\"grid gap-4 p-4 md:grid-cols-2\"><div class=\"shadow-xl card bg-base-300\"><figure><img src=\"/assets/promo-join.jpg\" alt=\"Join Aftermath Official\"></figure><div class=\"card-body\"><p>Aftermath is making a comeback! We've revamped everything to be faster and more beautiful. Join our community server for the latest features and updates.</p><div class=\"justify-center card-actions\"><a href=\"/join\" class=\"btn btn-primary\">Join Aftermath Official</a></div></div></div><div class=\"shadow-xl card bg-base-300\"><figure><img src=\"/assets/promo-invite.jpg\" alt=\"Invite Aftermath\"></figure><div class=\"card-body\"><p>The new bot is here! Add it to your server for an easier time tracking sessions. It's that simple – give Aftermath a try on your favorite server!</p><div class=\"justify-center card-actions\"><a href=\"/invite\" class=\"btn btn-primary\">Invite Aftermath</a></div></div></div></div></div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		if !templ_7745c5c3_IsBuffer {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteTo(templ_7745c5c3_W)
+		}
+		return templ_7745c5c3_Err
+	})
+}
diff --git a/cmd/frontend/routes/widget/configure.templ b/cmd/frontend/routes/widget/configure.templ
new file mode 100644
index 00000000..0019d498
--- /dev/null
+++ b/cmd/frontend/routes/widget/configure.templ
@@ -0,0 +1,72 @@
+package widget 
+
+import "github.com/cufee/aftermath/cmd/frontend/handler"
+import "github.com/cufee/aftermath/cmd/frontend/layouts"
+import "github.com/cufee/aftermath/cmd/frontend/components/widget"
+import "golang.org/x/text/language"
+import "time"
+import "github.com/pkg/errors"
+import "fmt"
+
+var ConfigureWidget handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
+	accountID := ctx.Req().PathValue("accountId")
+	if accountID == "" {
+		return nil, nil, errors.New("invalid account id")
+	}
+
+	account, err := ctx.Fetch().Account(ctx.Context, accountID)
+	if err != nil {
+		return nil, nil, errors.New("invalid account id")
+	}
+
+	cards, _, err := ctx.Client.Stats(language.English).SessionCards(context.Background(), account.ID, time.Now())
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return layouts.Main, configureWidgetPage(widget.Widget(account, cards)), nil
+}
+
+templ configureWidgetPage(widget templ.Component) {
+	<div class="flex flex-row justify-center gap-4 flex-wrap min-w-max">
+		<div class="grow flex flex-col max-w-xl gap-2">
+			<div class="flex flex-col items-center justify-center gap-4">
+				<div class="form-control w-full flex gap-2">
+					<div class="flex flex-col bg-base-200 rounded-lg p-4">
+						<span class="text-lg">Regular Battles</span>
+						<label class="label cursor-pointer">
+							<span class="label-text">Show Overview Card</span>
+							<input type="checkbox" class="toggle toggle-secondary" checked="checked" disabled/>
+						</label>
+						<label class="label cursor-pointer flex flex-col items-start gap-1">
+							<span class="label-text">Vehicle Cards</span>
+							<input type="range" min="0" max="10" value="3" class="range" step="1" disabled/>
+							<div class="flex w-full justify-between px-2 text-xs">
+								for i := range 11 {
+									<div class="flex flex-col items-center">
+										<span>{ fmt.Sprint(i) }</span>
+									</div>
+								}
+							</div>
+						</label>
+					</div>
+					<div class="flex flex-col bg-base-200 rounded-lg p-4">
+						<span class="text-lg">Rating Battles</span>
+						<label class="label cursor-pointer">
+							<span class="label-text">Show Overview Card</span>
+							<input type="checkbox" class="toggle toggle-secondary" checked="checked" disabled/>
+						</label>
+					</div>
+				</div>
+				<button class="btn btn-primary">
+					copy link
+				</button>
+			</div>
+		</div>
+		<div class="flex flex-col gap-2">
+			<div class="max-m-max">
+				@widget
+			</div>
+		</div>
+	</div>
+}
diff --git a/cmd/frontend/routes/widget/configure_templ.go b/cmd/frontend/routes/widget/configure_templ.go
new file mode 100644
index 00000000..15b2e371
--- /dev/null
+++ b/cmd/frontend/routes/widget/configure_templ.go
@@ -0,0 +1,93 @@
+// Code generated by templ - DO NOT EDIT.
+
+// templ: version: v0.2.696
+package widget
+
+//lint:file-ignore SA4006 This context is only used if a nested component is present.
+
+import "github.com/a-h/templ"
+import "context"
+import "io"
+import "bytes"
+
+import "github.com/cufee/aftermath/cmd/frontend/handler"
+import "github.com/cufee/aftermath/cmd/frontend/layouts"
+import "github.com/cufee/aftermath/cmd/frontend/components/widget"
+import "golang.org/x/text/language"
+import "time"
+import "github.com/pkg/errors"
+import "fmt"
+
+var ConfigureWidget handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
+	accountID := ctx.Req().PathValue("accountId")
+	if accountID == "" {
+		return nil, nil, errors.New("invalid account id")
+	}
+
+	account, err := ctx.Fetch().Account(ctx.Context, accountID)
+	if err != nil {
+		return nil, nil, errors.New("invalid account id")
+	}
+
+	cards, _, err := ctx.Client.Stats(language.English).SessionCards(context.Background(), account.ID, time.Now())
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return layouts.Main, configureWidgetPage(widget.Widget(account, cards)), nil
+}
+
+func configureWidgetPage(widget templ.Component) templ.Component {
+	return templ.ComponentFunc(func(ctx context.Context, templ_7745c5c3_W io.Writer) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templ_7745c5c3_W.(*bytes.Buffer)
+		if !templ_7745c5c3_IsBuffer {
+			templ_7745c5c3_Buffer = templ.GetBuffer()
+			defer templ.ReleaseBuffer(templ_7745c5c3_Buffer)
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var1 == nil {
+			templ_7745c5c3_Var1 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-row justify-center gap-4 flex-wrap min-w-max\"><div class=\"grow flex flex-col max-w-xl gap-2\"><div class=\"flex flex-col items-center justify-center gap-4\"><div class=\"form-control w-full flex gap-2\"><div class=\"flex flex-col bg-base-200 rounded-lg p-4\"><span class=\"text-lg\">Regular Battles</span> <label class=\"label cursor-pointer\"><span class=\"label-text\">Show Overview Card</span> <input type=\"checkbox\" class=\"toggle toggle-secondary\" checked=\"checked\" disabled></label> <label class=\"label cursor-pointer flex flex-col items-start gap-1\"><span class=\"label-text\">Vehicle Cards</span> <input type=\"range\" min=\"0\" max=\"10\" value=\"3\" class=\"range\" step=\"1\" disabled><div class=\"flex w-full justify-between px-2 text-xs\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		for i := range 11 {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-col items-center\"><span>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			var templ_7745c5c3_Var2 string
+			templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprint(i))
+			if templ_7745c5c3_Err != nil {
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/widget/configure.templ`, Line: 47, Col: 31}
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</span></div>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></label></div><div class=\"flex flex-col bg-base-200 rounded-lg p-4\"><span class=\"text-lg\">Rating Battles</span> <label class=\"label cursor-pointer\"><span class=\"label-text\">Show Overview Card</span> <input type=\"checkbox\" class=\"toggle toggle-secondary\" checked=\"checked\" disabled></label></div></div><button class=\"btn btn-primary\">copy link</button></div></div><div class=\"flex flex-col gap-2\"><div class=\"max-m-max\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = widget.Render(ctx, templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></div></div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		if !templ_7745c5c3_IsBuffer {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteTo(templ_7745c5c3_W)
+		}
+		return templ_7745c5c3_Err
+	})
+}
diff --git a/cmd/frontend/routes/widget/live.templ b/cmd/frontend/routes/widget/live.templ
new file mode 100644
index 00000000..34e4f295
--- /dev/null
+++ b/cmd/frontend/routes/widget/live.templ
@@ -0,0 +1,45 @@
+package widget
+
+import "github.com/cufee/aftermath/cmd/frontend/handler"
+import "github.com/pkg/errors"
+import "golang.org/x/text/language"
+import "time"
+import "github.com/cufee/aftermath/cmd/frontend/layouts"
+import "github.com/cufee/aftermath/cmd/frontend/components/widget"
+import "github.com/cufee/aftermath/internal/database/models"
+import "github.com/cufee/aftermath/internal/stats/client/v1"
+import "slices"
+
+var LiveWidget handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
+	accountID := ctx.Req().PathValue("accountId")
+	if accountID == "" {
+		return nil, nil, errors.New("invalid account id")
+	}
+
+	account, err := ctx.Fetch().Account(ctx.Context, accountID)
+	if err != nil {
+		return nil, nil, errors.New("invalid account id")
+	}
+
+	var opts []client.RequestOption
+	if ref := ctx.Req().URL.Query().Get("ref"); ref != "" {
+		opts = append(opts, client.WithReferenceID(ref))
+	}
+	if t := ctx.Req().URL.Query().Get("type"); t != "" && slices.Contains(models.SnapshotType("").Values(), t) {
+		opts = append(opts, client.WithType(models.SnapshotType(t)))
+	}
+
+	cards, _, err := ctx.Client.Stats(language.English).SessionCards(context.Background(), account.ID, time.Now(), opts...)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return layouts.Main, liveWidget(widget.Widget(account, cards, widget.WithAutoReload())), nil
+}
+
+templ liveWidget(widget templ.Component) {
+	@widget
+	<style>
+    :root { background-color: rgba(0, 0, 0, 0); white-space: nowrap; }
+  </style>
+}
diff --git a/cmd/frontend/routes/widget/live_templ.go b/cmd/frontend/routes/widget/live_templ.go
new file mode 100644
index 00000000..1b66362b
--- /dev/null
+++ b/cmd/frontend/routes/widget/live_templ.go
@@ -0,0 +1,76 @@
+// Code generated by templ - DO NOT EDIT.
+
+// templ: version: v0.2.696
+package widget
+
+//lint:file-ignore SA4006 This context is only used if a nested component is present.
+
+import "github.com/a-h/templ"
+import "context"
+import "io"
+import "bytes"
+
+import "github.com/cufee/aftermath/cmd/frontend/handler"
+import "github.com/pkg/errors"
+import "golang.org/x/text/language"
+import "time"
+import "github.com/cufee/aftermath/cmd/frontend/layouts"
+import "github.com/cufee/aftermath/cmd/frontend/components/widget"
+import "github.com/cufee/aftermath/internal/database/models"
+import "github.com/cufee/aftermath/internal/stats/client/v1"
+import "slices"
+
+var LiveWidget handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
+	accountID := ctx.Req().PathValue("accountId")
+	if accountID == "" {
+		return nil, nil, errors.New("invalid account id")
+	}
+
+	account, err := ctx.Fetch().Account(ctx.Context, accountID)
+	if err != nil {
+		return nil, nil, errors.New("invalid account id")
+	}
+
+	var opts []client.RequestOption
+	if ref := ctx.Req().URL.Query().Get("ref"); ref != "" {
+		opts = append(opts, client.WithReferenceID(ref))
+	}
+	if t := ctx.Req().URL.Query().Get("type"); t != "" && slices.Contains(models.SnapshotType("").Values(), t) {
+		opts = append(opts, client.WithType(models.SnapshotType(t)))
+	}
+
+	cards, _, err := ctx.Client.Stats(language.English).SessionCards(context.Background(), account.ID, time.Now(), opts...)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return layouts.Main, liveWidget(widget.Widget(account, cards, widget.WithAutoReload())), nil
+}
+
+func liveWidget(widget templ.Component) templ.Component {
+	return templ.ComponentFunc(func(ctx context.Context, templ_7745c5c3_W io.Writer) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templ_7745c5c3_W.(*bytes.Buffer)
+		if !templ_7745c5c3_IsBuffer {
+			templ_7745c5c3_Buffer = templ.GetBuffer()
+			defer templ.ReleaseBuffer(templ_7745c5c3_Buffer)
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var1 == nil {
+			templ_7745c5c3_Var1 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		templ_7745c5c3_Err = widget.Render(ctx, templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<style>\n    :root { background-color: rgba(0, 0, 0, 0); white-space: nowrap; }\n  </style>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		if !templ_7745c5c3_IsBuffer {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteTo(templ_7745c5c3_W)
+		}
+		return templ_7745c5c3_Err
+	})
+}
diff --git a/dev_web.go b/dev_web.go
new file mode 100644
index 00000000..c358a669
--- /dev/null
+++ b/dev_web.go
@@ -0,0 +1,73 @@
+//go:build ignore
+
+package main
+
+import (
+	"embed"
+	"net/http"
+	"os"
+
+	"github.com/cufee/aftermath/cmd/core"
+	"github.com/cufee/aftermath/cmd/core/server"
+	"github.com/cufee/aftermath/cmd/frontend"
+	"github.com/cufee/aftermath/internal/localization"
+	"github.com/cufee/aftermath/internal/stats/render/assets"
+	render "github.com/cufee/aftermath/internal/stats/render/common/v1"
+	"github.com/cufee/aftermath/tests"
+	"github.com/joho/godotenv"
+	"github.com/rs/zerolog/log"
+)
+
+//go:generate go generate ./cmd/frontend/assets
+
+//go:embed static/*
+var static embed.FS
+
+func main() {
+	err := godotenv.Load(".env")
+	if err != nil {
+		panic(err)
+	}
+
+	// Assets for rendering
+	err = assets.LoadAssets(static, "static")
+	if err != nil {
+		log.Fatal().Msgf("assets#LoadAssets failed to load assets from static/ embed.FS %s", err)
+	}
+	err = render.InitLoadedAssets()
+	if err != nil {
+		log.Fatal().Msgf("render#InitLoadedAssets failed %s", err)
+	}
+	err = localization.LoadAssets(static, "static/localization")
+	if err != nil {
+		log.Fatal().Msgf("localization#LoadAssets failed %s", err)
+	}
+
+	coreClient := core.NewClient(tests.StaticTestingFetch(), nil, tests.StaticTestingDatabase())
+	handlers, err := frontend.Handlers(coreClient)
+	if err != nil {
+		panic(err)
+	}
+
+	handlers = append(handlers, redirectHandlersFromEnv()...)
+
+	listen := server.NewServer(os.Getenv("PORT"), handlers...)
+	listen()
+}
+
+func redirectHandlersFromEnv() []server.Handler {
+	return []server.Handler{
+		{
+			Path: "GET /invite/{$}",
+			Func: func(w http.ResponseWriter, r *http.Request) {
+				http.Redirect(w, r, os.Getenv("BOT_INVITE_LINK"), http.StatusTemporaryRedirect)
+			},
+		},
+		{
+			Path: "GET /join/{$}",
+			Func: func(w http.ResponseWriter, r *http.Request) {
+				http.Redirect(w, r, os.Getenv("PRIMARY_GUILD_INVITE_LINK"), http.StatusTemporaryRedirect)
+			},
+		},
+	}
+}
diff --git a/go.mod b/go.mod
index 68658f09..224245ef 100644
--- a/go.mod
+++ b/go.mod
@@ -4,6 +4,7 @@ go 1.22.3
 
 require (
 	entgo.io/ent v0.13.1
+	github.com/a-h/templ v0.2.731
 	github.com/bwmarrin/discordgo v0.28.1
 	github.com/cufee/am-wg-proxy-next/v2 v2.1.7
 	github.com/disintegration/imaging v1.6.2
@@ -18,6 +19,7 @@ require (
 	github.com/pkg/errors v0.9.1
 	github.com/rs/zerolog v1.33.0
 	github.com/stretchr/testify v1.9.0
+	github.com/tdewolff/minify/v2 v2.20.34
 	go.dedis.ch/protobuf v1.0.11
 	golang.org/x/exp v0.0.0-20240613232115-7f521ea00fb8
 	golang.org/x/image v0.17.0
@@ -41,6 +43,7 @@ require (
 	github.com/mitchellh/go-wordwrap v1.0.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/robfig/cron/v3 v3.0.1 // indirect
+	github.com/tdewolff/parse/v2 v2.7.15 // indirect
 	github.com/zclconf/go-cty v1.14.4 // indirect
 	go.uber.org/atomic v1.11.0 // indirect
 	golang.org/x/crypto v0.24.0 // indirect
diff --git a/go.sum b/go.sum
index bf5c2b86..1b86d9e9 100644
--- a/go.sum
+++ b/go.sum
@@ -4,6 +4,8 @@ entgo.io/ent v0.13.1 h1:uD8QwN1h6SNphdCCzmkMN3feSUzNnVvV/WIkHKMbzOE=
 entgo.io/ent v0.13.1/go.mod h1:qCEmo+biw3ccBn9OyL4ZK5dfpwg++l1Gxwac5B1206A=
 github.com/DATA-DOG/go-sqlmock v1.5.0 h1:Shsta01QNfFxHCfpW6YH2STWB0MudeXXEWMr20OEh60=
 github.com/DATA-DOG/go-sqlmock v1.5.0/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM=
+github.com/a-h/templ v0.2.731 h1:yiv4C7whSUsa36y65O06DPr/U/j3+WGB0RmvLOoVFXc=
+github.com/a-h/templ v0.2.731/go.mod h1:IejA/ecDD0ul0dCvgCwp9t7bUZXVpGClEAdsqZQigi8=
 github.com/agext/levenshtein v1.2.3 h1:YB2fHEn0UJagG8T1rrWknE3ZQzWM06O8AMAatNn7lmo=
 github.com/agext/levenshtein v1.2.3/go.mod h1:JEDfjyjHDjOF/1e4FlBE/PkbqA9OfWu2ki2W0IB5558=
 github.com/apparentlymart/go-textseg/v15 v15.0.0 h1:uYvfpb3DyLSCGWnctWKGj857c6ew1u1fNQOlOtuGxQY=
@@ -88,6 +90,13 @@ github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO
 github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
 github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/tdewolff/minify/v2 v2.20.34 h1:XueI6sQtgS7du45fyBCNkNfPQ9SINaYavMFNOxp37SA=
+github.com/tdewolff/minify/v2 v2.20.34/go.mod h1:L1VYef/jwKw6Wwyk5A+T0mBjjn3mMPgmjjA688RNsxU=
+github.com/tdewolff/parse/v2 v2.7.15 h1:hysDXtdGZIRF5UZXwpfn3ZWRbm+ru4l53/ajBRGpCTw=
+github.com/tdewolff/parse/v2 v2.7.15/go.mod h1:3FbJWZp3XT9OWVN3Hmfp0p/a08v4h8J9W1aghka0soA=
+github.com/tdewolff/test v1.0.11-0.20231101010635-f1265d231d52/go.mod h1:6DAvZliBAAnD7rhVgwaM7DE5/d9NMOAJ09SqYqeK4QE=
+github.com/tdewolff/test v1.0.11-0.20240106005702-7de5f7df4739 h1:IkjBCtQOOjIn03u/dMQK9g+Iw9ewps4mCl1nB8Sscbo=
+github.com/tdewolff/test v1.0.11-0.20240106005702-7de5f7df4739/go.mod h1:XPuWBzvdUzhCuxWO1ojpXsyzsA5bFoS3tO/Q3kFuTG8=
 github.com/zclconf/go-cty v1.14.4 h1:uXXczd9QDGsgu0i/QFR/hzI5NYCHLf6NQw/atrbnhq8=
 github.com/zclconf/go-cty v1.14.4/go.mod h1:VvMs5i0vgZdhYawQNq5kePSpLAoz8u1xvZgrPIxfnZE=
 github.com/zclconf/go-cty-debug v0.0.0-20240509010212-0d6042c53940 h1:4r45xpDWB6ZMSMNJFMOjqrGHynW3DIBuR2H9j0ug+Mo=
diff --git a/internal/database/models/vehicle_snapshot.go b/internal/database/models/vehicle_snapshot.go
index c3152ce5..cff0cca7 100644
--- a/internal/database/models/vehicle_snapshot.go
+++ b/internal/database/models/vehicle_snapshot.go
@@ -9,8 +9,9 @@ import (
 type SnapshotType string
 
 const (
-	SnapshotTypeLive  SnapshotType = "live"
-	SnapshotTypeDaily SnapshotType = "daily"
+	SnapshotTypeLive   SnapshotType = "live"
+	SnapshotTypeDaily  SnapshotType = "daily"
+	SnapshotTypeWidget SnapshotType = "widget"
 )
 
 // Values provides list valid values for Enum.
diff --git a/internal/stats/client/v1/client.go b/internal/stats/client/v1/client.go
new file mode 100644
index 00000000..0dd9ebb9
--- /dev/null
+++ b/internal/stats/client/v1/client.go
@@ -0,0 +1,35 @@
+package client
+
+import (
+	"context"
+	"time"
+
+	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/external/wargaming"
+	"github.com/cufee/aftermath/internal/stats/fetch/v1"
+	period "github.com/cufee/aftermath/internal/stats/prepare/period/v1"
+	session "github.com/cufee/aftermath/internal/stats/prepare/session/v1"
+	"golang.org/x/text/language"
+)
+
+var _ Client = &client{}
+
+type client struct {
+	fetchClient fetch.Client
+	wargaming   wargaming.Client
+	database    database.Client
+	locale      language.Tag
+}
+
+type Client interface {
+	PeriodCards(ctx context.Context, accountId string, from time.Time, opts ...RequestOption) (period.Cards, Metadata, error)
+	PeriodImage(ctx context.Context, accountId string, from time.Time, opts ...RequestOption) (Image, Metadata, error)
+	SessionCards(ctx context.Context, accountId string, from time.Time, opts ...RequestOption) (session.Cards, Metadata, error)
+	SessionImage(ctx context.Context, accountId string, from time.Time, opts ...RequestOption) (Image, Metadata, error)
+
+	// Replay(accountId string, from time.Time) (image.Image, error)
+}
+
+func NewClient(fetch fetch.Client, database database.Client, wargaming wargaming.Client, locale language.Tag) Client {
+	return &client{fetch, wargaming, database, locale}
+}
diff --git a/internal/stats/renderer/v1/errors.go b/internal/stats/client/v1/errors.go
similarity index 85%
rename from internal/stats/renderer/v1/errors.go
rename to internal/stats/client/v1/errors.go
index a09051b0..d61d7179 100644
--- a/internal/stats/renderer/v1/errors.go
+++ b/internal/stats/client/v1/errors.go
@@ -1,4 +1,4 @@
-package renderer
+package client
 
 import (
 	"github.com/pkg/errors"
diff --git a/internal/stats/renderer/v1/image.go b/internal/stats/client/v1/image.go
similarity index 97%
rename from internal/stats/renderer/v1/image.go
rename to internal/stats/client/v1/image.go
index d82f9507..1a651052 100644
--- a/internal/stats/renderer/v1/image.go
+++ b/internal/stats/client/v1/image.go
@@ -1,4 +1,4 @@
-package renderer
+package client
 
 import (
 	"image"
diff --git a/internal/stats/renderer/v1/metadata.go b/internal/stats/client/v1/metadata.go
similarity index 97%
rename from internal/stats/renderer/v1/metadata.go
rename to internal/stats/client/v1/metadata.go
index e5ffd158..65b96fc4 100644
--- a/internal/stats/renderer/v1/metadata.go
+++ b/internal/stats/client/v1/metadata.go
@@ -1,4 +1,4 @@
-package renderer
+package client
 
 import (
 	"time"
diff --git a/internal/stats/client/v1/options.go b/internal/stats/client/v1/options.go
new file mode 100644
index 00000000..26cdbb4f
--- /dev/null
+++ b/internal/stats/client/v1/options.go
@@ -0,0 +1,58 @@
+package client
+
+import (
+	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/stats/fetch/v1"
+	"github.com/cufee/aftermath/internal/stats/render/common/v1"
+)
+
+type requestOptions struct {
+	snapshotType  models.SnapshotType
+	backgroundURL string
+	referenceID   string
+	promoText     []string
+	withWN8       bool
+}
+
+type RequestOption func(o *requestOptions)
+
+func WithWN8() RequestOption {
+	return func(o *requestOptions) { o.withWN8 = true }
+}
+func WithReferenceID(refID string) RequestOption {
+	return func(o *requestOptions) { o.referenceID = refID }
+}
+func WithPromoText(text ...string) RequestOption {
+	return func(o *requestOptions) { o.promoText = append(o.promoText, text...) }
+}
+func WithType(t models.SnapshotType) RequestOption {
+	return func(o *requestOptions) { o.snapshotType = t }
+}
+func WithBackgroundURL(url string) RequestOption {
+	return func(o *requestOptions) { o.backgroundURL = url }
+}
+
+func (o requestOptions) RenderOpts() []common.Option {
+	var copts []common.Option
+	if o.promoText != nil {
+		copts = append(copts, common.WithPromoText(o.promoText...))
+	}
+	if o.backgroundURL != "" {
+		copts = append(copts, common.WithBackground(o.backgroundURL))
+	}
+	return copts
+}
+
+func (o requestOptions) FetchOpts() []fetch.StatsOption {
+	var opts []fetch.StatsOption
+	if o.snapshotType != "" {
+		opts = append(opts, fetch.WithType(o.snapshotType))
+	}
+	if o.referenceID != "" {
+		opts = append(opts, fetch.WithReferenceID(o.referenceID))
+	}
+	if o.withWN8 {
+		opts = append(opts, fetch.WithWN8())
+	}
+	return opts
+}
diff --git a/internal/stats/renderer/v1/period.go b/internal/stats/client/v1/period.go
similarity index 63%
rename from internal/stats/renderer/v1/period.go
rename to internal/stats/client/v1/period.go
index bea9d49f..ced5231d 100644
--- a/internal/stats/renderer/v1/period.go
+++ b/internal/stats/client/v1/period.go
@@ -1,4 +1,4 @@
-package renderer
+package client
 
 import (
 	"context"
@@ -9,23 +9,27 @@ import (
 	"github.com/cufee/aftermath/internal/stats/fetch/v1"
 	pcommon "github.com/cufee/aftermath/internal/stats/prepare/common/v1"
 	prepare "github.com/cufee/aftermath/internal/stats/prepare/period/v1"
-	rcommon "github.com/cufee/aftermath/internal/stats/render/common/v1"
 	render "github.com/cufee/aftermath/internal/stats/render/period/v1"
 )
 
-func (r *renderer) Period(ctx context.Context, accountId string, from time.Time, opts ...rcommon.Option) (Image, Metadata, error) {
+func (r *client) PeriodCards(ctx context.Context, accountId string, from time.Time, o ...RequestOption) (prepare.Cards, Metadata, error) {
+	var opts = requestOptions{}
+	for _, apply := range o {
+		apply(&opts)
+	}
+
 	meta := Metadata{Stats: make(map[string]fetch.AccountStatsOverPeriod)}
 
 	printer, err := localization.NewPrinter("stats", r.locale)
 	if err != nil {
-		return nil, meta, err
+		return prepare.Cards{}, meta, err
 	}
 
 	stop := meta.Timer("fetchClient#PeriodStats")
 	stats, err := r.fetchClient.PeriodStats(ctx, accountId, from, fetch.WithWN8())
 	stop()
 	if err != nil {
-		return nil, meta, err
+		return prepare.Cards{}, meta, err
 	}
 	meta.Stats["period"] = stats
 
@@ -42,19 +46,30 @@ func (r *renderer) Period(ctx context.Context, accountId string, from time.Time,
 
 	glossary, err := r.database.GetVehicles(ctx, vehicles)
 	if err != nil {
-		return nil, meta, err
+		return prepare.Cards{}, meta, err
 	}
 	stop()
 
 	stop = meta.Timer("prepare#NewCards")
 	cards, err := prepare.NewCards(stats, glossary, pcommon.WithPrinter(printer, r.locale))
 	stop()
+
+	return cards, meta, err
+}
+
+func (r *client) PeriodImage(ctx context.Context, accountId string, from time.Time, o ...RequestOption) (Image, Metadata, error) {
+	var opts = requestOptions{}
+	for _, apply := range o {
+		apply(&opts)
+	}
+
+	cards, meta, err := r.PeriodCards(ctx, accountId, from, o...)
 	if err != nil {
 		return nil, meta, err
 	}
 
-	stop = meta.Timer("render#CardsToImage")
-	image, err := render.CardsToImage(stats, cards, nil, opts...)
+	stop := meta.Timer("render#CardsToImage")
+	image, err := render.CardsToImage(meta.Stats["period"], cards, nil, opts.RenderOpts()...)
 	stop()
 	if err != nil {
 		return nil, meta, err
diff --git a/internal/stats/client/v1/replay.go b/internal/stats/client/v1/replay.go
new file mode 100644
index 00000000..da13c8ef
--- /dev/null
+++ b/internal/stats/client/v1/replay.go
@@ -0,0 +1 @@
+package client
diff --git a/internal/stats/renderer/v1/session.go b/internal/stats/client/v1/session.go
similarity index 59%
rename from internal/stats/renderer/v1/session.go
rename to internal/stats/client/v1/session.go
index f1123e8b..15fb026a 100644
--- a/internal/stats/renderer/v1/session.go
+++ b/internal/stats/client/v1/session.go
@@ -1,4 +1,4 @@
-package renderer
+package client
 
 import (
 	"context"
@@ -12,48 +12,52 @@ import (
 	"github.com/cufee/aftermath/internal/stats/fetch/v1"
 	"github.com/cufee/aftermath/internal/stats/prepare/common/v1"
 	prepare "github.com/cufee/aftermath/internal/stats/prepare/session/v1"
-	options "github.com/cufee/aftermath/internal/stats/render/common/v1"
 	render "github.com/cufee/aftermath/internal/stats/render/session/v1"
 	"github.com/rs/zerolog/log"
 )
 
-func (r *renderer) Session(ctx context.Context, accountId string, from time.Time, opts ...options.Option) (Image, Metadata, error) {
+func (c *client) SessionCards(ctx context.Context, accountId string, from time.Time, o ...RequestOption) (prepare.Cards, Metadata, error) {
+	var opts = requestOptions{}
+	for _, apply := range o {
+		apply(&opts)
+	}
+
 	meta := Metadata{Stats: make(map[string]fetch.AccountStatsOverPeriod)}
 
 	stop := meta.Timer("database#GetAccountByID")
-	_, err := r.database.GetAccountByID(ctx, accountId)
+	_, err := c.database.GetAccountByID(ctx, accountId)
 	stop()
 	if err != nil {
 		if database.IsNotFound(err) {
-			_, err := r.fetchClient.Account(ctx, accountId) // this will cache the account
+			_, err := c.fetchClient.Account(ctx, accountId) // this will cache the account
 			if err != nil {
-				return nil, meta, err
+				return prepare.Cards{}, meta, err
 			}
 			go func(id string) {
 				// record a session in the background
 				ctx, cancel := context.WithTimeout(context.Background(), time.Second*15)
 				defer cancel()
 
-				_, err := logic.RecordAccountSnapshots(ctx, r.wargaming, r.database, r.wargaming.RealmFromAccountID(id), false, id)
+				_, err := logic.RecordAccountSnapshots(ctx, c.wargaming, c.database, c.wargaming.RealmFromAccountID(id), false, id)
 				if err != nil {
 					log.Err(err).Str("accountId", id).Msg("failed to record account snapshot")
 				}
 			}(accountId)
-			return nil, meta, ErrAccountNotTracked
+			return prepare.Cards{}, meta, ErrAccountNotTracked
 		}
-		return nil, meta, err
+		return prepare.Cards{}, meta, err
 	}
 
-	printer, err := localization.NewPrinter("stats", r.locale)
+	printer, err := localization.NewPrinter("stats", c.locale)
 	if err != nil {
-		return nil, meta, err
+		return prepare.Cards{}, meta, err
 	}
 
 	stop = meta.Timer("fetchClient#SessionStats")
 	if from.IsZero() {
 		from = time.Now()
 	}
-	session, career, err := r.fetchClient.SessionStats(ctx, accountId, from, fetch.WithWN8())
+	session, career, err := c.fetchClient.SessionStats(ctx, accountId, from, opts.FetchOpts()...)
 	stop()
 	if err != nil {
 		if errors.Is(fetch.ErrSessionNotFound, err) {
@@ -62,13 +66,13 @@ func (r *renderer) Session(ctx context.Context, accountId string, from time.Time
 				ctx, cancel := context.WithTimeout(context.Background(), time.Second*15)
 				defer cancel()
 
-				_, err := logic.RecordAccountSnapshots(ctx, r.wargaming, r.database, r.wargaming.RealmFromAccountID(id), false, id)
+				_, err := logic.RecordAccountSnapshots(ctx, c.wargaming, c.database, c.wargaming.RealmFromAccountID(id), false, id)
 				if err != nil {
 					log.Err(err).Str("accountId", id).Msg("failed to record account snapshot")
 				}
 			}(accountId)
 		}
-		return nil, meta, err
+		return prepare.Cards{}, meta, err
 	}
 	meta.Stats["career"] = career
 	meta.Stats["session"] = session
@@ -94,21 +98,35 @@ func (r *renderer) Session(ctx context.Context, accountId string, from time.Time
 		}
 	}
 
-	glossary, err := r.database.GetVehicles(ctx, vehicles)
+	glossary, err := c.database.GetVehicles(ctx, vehicles)
 	if err != nil {
-		return nil, meta, err
+		return prepare.Cards{}, meta, err
 	}
 	stop()
 
 	stop = meta.Timer("prepare#NewCards")
-	cards, err := prepare.NewCards(session, career, glossary, common.WithPrinter(printer, r.locale))
+	cards, err := prepare.NewCards(session, career, glossary, common.WithPrinter(printer, c.locale))
 	stop()
+	if err != nil {
+		return prepare.Cards{}, meta, err
+	}
+
+	return cards, meta, nil
+}
+
+func (c *client) SessionImage(ctx context.Context, accountId string, from time.Time, o ...RequestOption) (Image, Metadata, error) {
+	var opts = requestOptions{}
+	for _, apply := range o {
+		apply(&opts)
+	}
+
+	cards, meta, err := c.SessionCards(ctx, accountId, from, o...)
 	if err != nil {
 		return nil, meta, err
 	}
 
-	stop = meta.Timer("render#CardsToImage")
-	image, err := render.CardsToImage(session, career, cards, nil, opts...)
+	stop := meta.Timer("render#CardsToImage")
+	image, err := render.CardsToImage(meta.Stats["session"], meta.Stats["career"], cards, nil, opts.RenderOpts()...)
 	stop()
 	if err != nil {
 		return nil, meta, err
diff --git a/internal/stats/fetch/v1/client.go b/internal/stats/fetch/v1/client.go
index 8bcef83b..79a2ba70 100644
--- a/internal/stats/fetch/v1/client.go
+++ b/internal/stats/fetch/v1/client.go
@@ -58,7 +58,9 @@ type Client interface {
 }
 
 type statsOptions struct {
-	withWN8 bool
+	withWN8      bool
+	referenceID  string
+	snapshotType models.SnapshotType
 }
 
 type StatsOption func(*statsOptions)
@@ -68,3 +70,13 @@ func WithWN8() StatsOption {
 		so.withWN8 = true
 	}
 }
+func WithType(sType models.SnapshotType) StatsOption {
+	return func(so *statsOptions) {
+		so.snapshotType = sType
+	}
+}
+func WithReferenceID(reference string) StatsOption {
+	return func(so *statsOptions) {
+		so.referenceID = reference
+	}
+}
diff --git a/internal/stats/fetch/v1/multisource.go b/internal/stats/fetch/v1/multisource.go
index 060398e7..60e919a9 100644
--- a/internal/stats/fetch/v1/multisource.go
+++ b/internal/stats/fetch/v1/multisource.go
@@ -272,7 +272,7 @@ func (c *multiSourceClient) PeriodStats(ctx context.Context, id string, periodSt
 }
 
 func (c *multiSourceClient) SessionStats(ctx context.Context, id string, sessionStart time.Time, opts ...StatsOption) (AccountStatsOverPeriod, AccountStatsOverPeriod, error) {
-	var options statsOptions
+	var options = statsOptions{snapshotType: models.SnapshotTypeDaily, referenceID: id}
 	for _, apply := range opts {
 		apply(&options)
 	}
@@ -311,13 +311,13 @@ func (c *multiSourceClient) SessionStats(ctx context.Context, id string, session
 	group.Add(1)
 	go func() {
 		defer group.Done()
-		s, err := c.database.GetAccountSnapshot(ctx, id, id, models.SnapshotTypeDaily, database.WithCreatedBefore(sessionBefore))
+		s, err := c.database.GetAccountSnapshot(ctx, id, options.referenceID, options.snapshotType, database.WithCreatedBefore(sessionBefore))
 		accountSnapshot = retry.DataWithErr[models.AccountSnapshot]{Data: s, Err: err}
 		if err != nil {
 			return
 		}
 
-		v, err := c.database.GetVehicleSnapshots(ctx, id, id, models.SnapshotTypeDaily, database.WithCreatedBefore(sessionBefore))
+		v, err := c.database.GetVehicleSnapshots(ctx, id, options.referenceID, options.snapshotType, database.WithCreatedBefore(sessionBefore))
 		vehiclesSnapshots = retry.DataWithErr[[]models.VehicleSnapshot]{Data: v, Err: err}
 	}()
 
diff --git a/internal/stats/prepare/session/v1/constants.go b/internal/stats/prepare/session/v1/constants.go
index 6996f9bf..4d872179 100644
--- a/internal/stats/prepare/session/v1/constants.go
+++ b/internal/stats/prepare/session/v1/constants.go
@@ -12,7 +12,7 @@ type overviewColumnBlocks struct {
 
 var unratedOverviewBlocks = []overviewColumnBlocks{
 	{[]common.Tag{common.TagBattles, common.TagWinrate}, BlockFlavorDefault},
-	{[]common.Tag{common.TagWN8}, BlockFlavorRating},
+	{[]common.Tag{common.TagWN8}, BlockFlavorWN8},
 	{[]common.Tag{common.TagAvgDamage, common.TagDamageRatio}, BlockFlavorDefault},
 }
 
@@ -59,4 +59,5 @@ type blockFlavor string
 const (
 	BlockFlavorDefault blockFlavor = "default"
 	BlockFlavorRating  blockFlavor = "rating"
+	BlockFlavorWN8     blockFlavor = "wn8"
 )
diff --git a/internal/stats/render/common/v1/rating.go b/internal/stats/render/common/v1/rating.go
new file mode 100644
index 00000000..53f6c62b
--- /dev/null
+++ b/internal/stats/render/common/v1/rating.go
@@ -0,0 +1,45 @@
+package common
+
+import (
+	"github.com/cufee/aftermath/internal/stats/frame"
+	"github.com/cufee/aftermath/internal/stats/render/assets"
+)
+
+var iconsCache = make(map[string]Block, 6)
+
+func GetRatingIconName(rating float32) string {
+	switch {
+	case rating > 5000:
+		return "diamond"
+	case rating > 4000:
+		return "platinum"
+	case rating > 3000:
+		return "gold"
+	case rating > 2000:
+		return "silver"
+	case rating > 0:
+		return "bronze"
+	default:
+		return "calibration"
+	}
+}
+
+func GetRatingIcon(rating frame.Value, size float64) (Block, bool) {
+	style := Style{Width: size, Height: size}
+	if rating.Float() < 0 {
+		style.BackgroundColor = TextAlt
+	}
+	name := "rating-" + GetRatingIconName(rating.Float())
+
+	if b, ok := iconsCache[name]; ok {
+		return b, true
+	}
+
+	img, ok := assets.GetLoadedImage(name)
+	if !ok {
+		return Block{}, false
+	}
+
+	iconsCache[name] = NewImageContent(style, img)
+	return iconsCache[name], true
+}
diff --git a/internal/stats/render/session/v1/blocks.go b/internal/stats/render/session/v1/blocks.go
index 64220f45..64ff1315 100644
--- a/internal/stats/render/session/v1/blocks.go
+++ b/internal/stats/render/session/v1/blocks.go
@@ -41,7 +41,7 @@ func makeSpecialRatingColumn(block prepare.StatsBlock[session.BlockData], width
 
 	case prepare.TagRankedRating:
 		var column []common.Block
-		icon, ok := getRatingIcon(block.Value)
+		icon, ok := common.GetRatingIcon(block.Value, specialRatingIconSize)
 		if ok {
 			column = append(column, icon)
 		}
diff --git a/internal/stats/render/session/v1/icons.go b/internal/stats/render/session/v1/icons.go
deleted file mode 100644
index 1684fbaf..00000000
--- a/internal/stats/render/session/v1/icons.go
+++ /dev/null
@@ -1,40 +0,0 @@
-package session
-
-import (
-	"github.com/cufee/aftermath/internal/stats/frame"
-	"github.com/cufee/aftermath/internal/stats/render/assets"
-	"github.com/cufee/aftermath/internal/stats/render/common/v1"
-)
-
-var iconsCache = make(map[string]common.Block, 6)
-
-func getRatingIcon(rating frame.Value) (common.Block, bool) {
-	style := common.Style{Width: specialRatingIconSize, Height: specialRatingIconSize}
-	name := "rating-"
-	switch {
-	case rating.Float() > 5000:
-		name += "diamond"
-	case rating.Float() > 4000:
-		name += "platinum"
-	case rating.Float() > 3000:
-		name += "gold"
-	case rating.Float() > 2000:
-		name += "silver"
-	case rating.Float() > 0:
-		name += "bronze"
-	default:
-		name += "calibration"
-		style.BackgroundColor = common.TextAlt
-	}
-	if b, ok := iconsCache[name]; ok {
-		return b, true
-	}
-
-	img, ok := assets.GetLoadedImage(name)
-	if !ok {
-		return common.Block{}, false
-	}
-
-	iconsCache[name] = common.NewImageContent(style, img)
-	return iconsCache[name], true
-}
diff --git a/internal/stats/renderer/v1/renderer.go b/internal/stats/renderer/v1/renderer.go
deleted file mode 100644
index fab17367..00000000
--- a/internal/stats/renderer/v1/renderer.go
+++ /dev/null
@@ -1,32 +0,0 @@
-package renderer
-
-import (
-	"context"
-	"time"
-
-	"github.com/cufee/aftermath/internal/database"
-	"github.com/cufee/aftermath/internal/external/wargaming"
-	"github.com/cufee/aftermath/internal/stats/fetch/v1"
-	"github.com/cufee/aftermath/internal/stats/render/common/v1"
-	"golang.org/x/text/language"
-)
-
-var _ Renderer = &renderer{}
-
-type renderer struct {
-	fetchClient fetch.Client
-	wargaming   wargaming.Client
-	database    database.Client
-	locale      language.Tag
-}
-
-type Renderer interface {
-	Period(ctx context.Context, accountId string, from time.Time, opts ...common.Option) (Image, Metadata, error)
-	Session(ctx context.Context, accountId string, from time.Time, opts ...common.Option) (Image, Metadata, error)
-
-	// Replay(accountId string, from time.Time) (image.Image, error)
-}
-
-func NewRenderer(fetch fetch.Client, database database.Client, wargaming wargaming.Client, locale language.Tag) *renderer {
-	return &renderer{fetch, wargaming, database, locale}
-}
diff --git a/internal/stats/renderer/v1/replay.go b/internal/stats/renderer/v1/replay.go
deleted file mode 100644
index 35803f64..00000000
--- a/internal/stats/renderer/v1/replay.go
+++ /dev/null
@@ -1 +0,0 @@
-package renderer
diff --git a/main.go b/main.go
index 929ec2e9..aad48955 100644
--- a/main.go
+++ b/main.go
@@ -18,6 +18,7 @@ import (
 	"github.com/cufee/aftermath/cmd/core/scheduler"
 	"github.com/cufee/aftermath/cmd/core/tasks"
 	"github.com/cufee/aftermath/cmd/discord/commands"
+	"github.com/cufee/aftermath/cmd/frontend"
 
 	"github.com/cufee/aftermath/cmd/core/server"
 	"github.com/cufee/aftermath/cmd/core/server/handlers/private"
@@ -42,6 +43,7 @@ import (
 )
 
 //go:generate go generate ./internal/database/ent
+//go:generate go generate ./cmd/frontend/assets
 
 //go:embed static/*
 var static embed.FS
@@ -102,12 +104,23 @@ func main() {
 		go servePrivate()
 	}
 
+	// will handle all GET routes with a wildcard
+	frontendHandlers, err := frontend.Handlers(liveCoreClient)
+	if err != nil {
+		log.Fatal().Err(err).Msg("frontend#Handlers failed")
+	}
+
 	discordHandlers := discordHandlersFromEnv(liveCoreClient)
-	// /discord/public/callback
-	// /discord/internal/callback
+	// POST /discord/public/callback
+	// POST /discord/internal/callback
+
+	var handlers []server.Handler
+	handlers = append(handlers, discordHandlers...)
+	handlers = append(handlers, frontendHandlers...)
+	handlers = append(handlers, redirectHandlersFromEnv()...)
 
 	port := os.Getenv("PORT")
-	servePublic := server.NewServer(port, discordHandlers...)
+	servePublic := server.NewServer(port, handlers...)
 	log.Info().Str("port", port).Msg("starting a public server")
 	go servePublic()
 
@@ -261,3 +274,20 @@ func newDatabaseClientFromEnv() (database.Client, error) {
 
 	return client, nil
 }
+
+func redirectHandlersFromEnv() []server.Handler {
+	return []server.Handler{
+		{
+			Path: "GET /invite/{$}",
+			Func: func(w http.ResponseWriter, r *http.Request) {
+				http.Redirect(w, r, os.Getenv("BOT_INVITE_LINK"), http.StatusTemporaryRedirect)
+			},
+		},
+		{
+			Path: "GET /join/{$}",
+			Func: func(w http.ResponseWriter, r *http.Request) {
+				http.Redirect(w, r, os.Getenv("PRIMARY_GUILD_INVITE_LINK"), http.StatusTemporaryRedirect)
+			},
+		},
+	}
+}
diff --git a/render_test.go b/render_test.go
index e995f5f6..6a0e37aa 100644
--- a/render_test.go
+++ b/render_test.go
@@ -6,8 +6,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/cufee/aftermath/internal/stats/render/common/v1"
-	stats "github.com/cufee/aftermath/internal/stats/renderer/v1"
+	stats "github.com/cufee/aftermath/internal/stats/client/v1"
 	"github.com/cufee/aftermath/tests"
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/assert"
@@ -23,10 +22,10 @@ func TestRenderSession(t *testing.T) {
 
 	loadStaticAssets(static)
 
-	renderer := stats.NewRenderer(tests.StaticTestingFetch(), tests.StaticTestingDatabase(), nil, language.English)
+	stats := stats.NewClient(tests.StaticTestingFetch(), tests.StaticTestingDatabase(), nil, language.English)
 
 	{
-		image, _, err := renderer.Session(context.Background(), tests.DefaultAccountNAShort, time.Now(), common.WithBackground(""))
+		image, _, err := stats.SessionImage(context.Background(), tests.DefaultAccountNAShort, time.Now())
 		assert.NoError(t, err, "failed to render a session image")
 		assert.NotNil(t, image, "image is nil")
 
@@ -38,7 +37,7 @@ func TestRenderSession(t *testing.T) {
 		assert.NoError(t, err, "failed to encode a png image")
 	}
 	{
-		image, _, err := renderer.Session(context.Background(), tests.DefaultAccountNA, time.Now(), common.WithBackground(""))
+		image, _, err := stats.SessionImage(context.Background(), tests.DefaultAccountNA, time.Now())
 		assert.NoError(t, err, "failed to render a session image")
 		assert.NotNil(t, image, "image is nil")
 
diff --git a/tests/static_database.go b/tests/static_database.go
index 065c0c7a..6c2a4366 100644
--- a/tests/static_database.go
+++ b/tests/static_database.go
@@ -64,8 +64,11 @@ func (c *staticTestingDatabase) GetVehicles(ctx context.Context, ids []string) (
 	return vehicles, nil
 }
 func (c *staticTestingDatabase) GetVehicleAverages(ctx context.Context, ids []string) (map[string]frame.StatsFrame, error) {
-	// TODO: get some kind of data in
-	return map[string]frame.StatsFrame{}, nil
+	averages := make(map[string]frame.StatsFrame)
+	for _, id := range ids {
+		averages[id] = DefaultStatsFrameSmall2
+	}
+	return averages, nil
 }
 func (c *staticTestingDatabase) UpsertVehicles(ctx context.Context, vehicles map[string]models.Vehicle) (map[string]error, error) {
 	return nil, errors.New("UpsertVehicles not implemented")

From cbc7f51bd41cdb22ba606ccad4a95d126f2e7a94 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Tue, 2 Jul 2024 20:48:29 -0400
Subject: [PATCH 239/341] fixed blank renders

---
 cmd/frontend/components/widget/default.templ  |  7 ++++--
 .../components/widget/default_templ.go        | 25 +++++++++++--------
 2 files changed, 19 insertions(+), 13 deletions(-)

diff --git a/cmd/frontend/components/widget/default.templ b/cmd/frontend/components/widget/default.templ
index 07ad5388..cfa4a601 100644
--- a/cmd/frontend/components/widget/default.templ
+++ b/cmd/frontend/components/widget/default.templ
@@ -34,6 +34,9 @@ func (w widget) defaultWidget() templ.Component {
 		if i >= w.unratedVehiclesLimit {
 			break
 		}
+		if len(card.Blocks) < 1 {
+			continue
+		}
 		vehicles = append(vehicles, vehicleExtended{}.fromCard(card))
 	}
 
@@ -42,10 +45,10 @@ func (w widget) defaultWidget() templ.Component {
 
 templ (w defaultWidget) Render() {
 	<div class="flex flex-col w-full gap-2 widget">
-		if w.showRatingOverview {
+		if w.showRatingOverview && len(w.cards.Rating.Overview.Blocks) > 0 {
 			@w.overviewCard(w.cards.Rating.Overview)
 		}
-		if w.showUnratedOverview {
+		if w.showUnratedOverview && len(w.cards.Unrated.Overview.Blocks) > 0 {
 			@w.overviewCard(w.cards.Unrated.Overview)
 		}
 		for _, card := range w.vehicleCards {
diff --git a/cmd/frontend/components/widget/default_templ.go b/cmd/frontend/components/widget/default_templ.go
index 23a95c88..a90f5fdb 100644
--- a/cmd/frontend/components/widget/default_templ.go
+++ b/cmd/frontend/components/widget/default_templ.go
@@ -44,6 +44,9 @@ func (w widget) defaultWidget() templ.Component {
 		if i >= w.unratedVehiclesLimit {
 			break
 		}
+		if len(card.Blocks) < 1 {
+			continue
+		}
 		vehicles = append(vehicles, vehicleExtended{}.fromCard(card))
 	}
 
@@ -67,13 +70,13 @@ func (w defaultWidget) Render() templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		if w.showRatingOverview {
+		if w.showRatingOverview && len(w.cards.Rating.Overview.Blocks) > 0 {
 			templ_7745c5c3_Err = w.overviewCard(w.cards.Rating.Overview).Render(ctx, templ_7745c5c3_Buffer)
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 		}
-		if w.showUnratedOverview {
+		if w.showUnratedOverview && len(w.cards.Unrated.Overview.Blocks) > 0 {
 			templ_7745c5c3_Err = w.overviewCard(w.cards.Unrated.Overview).Render(ctx, templ_7745c5c3_Buffer)
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
@@ -127,7 +130,7 @@ func (w defaultWidget) overviewCard(card session.OverviewCard) templ.Component {
 			var templ_7745c5c3_Var3 string
 			templ_7745c5c3_Var3, templ_7745c5c3_Err = templ.JoinStringErrs(card.Title)
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 64, Col: 16}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 67, Col: 16}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var3))
 			if templ_7745c5c3_Err != nil {
@@ -202,7 +205,7 @@ func (w defaultWidget) vehicleCard(card vehicleExtended) templ.Component {
 			var templ_7745c5c3_Var7 string
 			templ_7745c5c3_Var7, templ_7745c5c3_Err = templ.JoinStringErrs(card.Title)
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 80, Col: 17}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 83, Col: 17}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var7))
 			if templ_7745c5c3_Err != nil {
@@ -215,7 +218,7 @@ func (w defaultWidget) vehicleCard(card vehicleExtended) templ.Component {
 			var templ_7745c5c3_Var8 string
 			templ_7745c5c3_Var8, templ_7745c5c3_Err = templ.JoinStringErrs(assets.WN8IconPathSmall(card.wn8.Float()))
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 82, Col: 56}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 85, Col: 56}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var8))
 			if templ_7745c5c3_Err != nil {
@@ -312,7 +315,7 @@ func (w defaultWidget) vehicleLegendCard(blocks []common.StatsBlock[session.Bloc
 			var templ_7745c5c3_Var14 string
 			templ_7745c5c3_Var14, templ_7745c5c3_Err = templ.JoinStringErrs(block.Label)
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 98, Col: 18}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 101, Col: 18}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var14))
 			if templ_7745c5c3_Err != nil {
@@ -401,7 +404,7 @@ func (w defaultWidget) specialOverviewColumn(column session.OverviewColumn) temp
 				var templ_7745c5c3_Var17 string
 				templ_7745c5c3_Var17, templ_7745c5c3_Err = templ.JoinStringErrs(assets.RatingIconPath(block.Value.Float()))
 				if templ_7745c5c3_Err != nil {
-					return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 121, Col: 57}
+					return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 124, Col: 57}
 				}
 				_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var17))
 				if templ_7745c5c3_Err != nil {
@@ -424,7 +427,7 @@ func (w defaultWidget) specialOverviewColumn(column session.OverviewColumn) temp
 				var templ_7745c5c3_Var18 string
 				templ_7745c5c3_Var18, templ_7745c5c3_Err = templ.JoinStringErrs(assets.WN8IconPath(block.Value.Float()))
 				if templ_7745c5c3_Err != nil {
-					return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 124, Col: 54}
+					return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 127, Col: 54}
 				}
 				_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var18))
 				if templ_7745c5c3_Err != nil {
@@ -475,7 +478,7 @@ func (w defaultWidget) block(block common.StatsBlock[session.BlockData], style s
 		var templ_7745c5c3_Var20 string
 		templ_7745c5c3_Var20, templ_7745c5c3_Err = templ.JoinStringErrs(block.Data.Session.String())
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 133, Col: 65}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 136, Col: 65}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var20))
 		if templ_7745c5c3_Err != nil {
@@ -493,7 +496,7 @@ func (w defaultWidget) block(block common.StatsBlock[session.BlockData], style s
 			var templ_7745c5c3_Var21 string
 			templ_7745c5c3_Var21, templ_7745c5c3_Err = templ.JoinStringErrs(block.Data.Career.String())
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 135, Col: 67}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 138, Col: 67}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var21))
 			if templ_7745c5c3_Err != nil {
@@ -512,7 +515,7 @@ func (w defaultWidget) block(block common.StatsBlock[session.BlockData], style s
 			var templ_7745c5c3_Var22 string
 			templ_7745c5c3_Var22, templ_7745c5c3_Err = templ.JoinStringErrs(block.Label)
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 138, Col: 52}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 141, Col: 52}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var22))
 			if templ_7745c5c3_Err != nil {

From 3b7a2a0e8033c880596ab83f0a19cad629859c16 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Tue, 2 Jul 2024 20:53:52 -0400
Subject: [PATCH 240/341] added generate

---
 Dockerfile | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Dockerfile b/Dockerfile
index 2816f085..9e23b37d 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -8,6 +8,7 @@ RUN --mount=type=cache,target=$GOPATH/pkg/mod go mod download
 COPY ./ ./
 
 # build a fully standalone binary with zero dependencies
+RUN --mount=type=cache,target=$GOPATH/pkg/mod go generate ./...
 RUN --mount=type=cache,target=$GOPATH/pkg/mod CGO_ENABLED=1 GOOS=linux go build -o /bin/aftermath .
 
 # Make a scratch container with required files and binary

From c0d6e93e7ccc5d5b1e2fd6d5ef78f1dd42712f00 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Tue, 2 Jul 2024 20:56:08 -0400
Subject: [PATCH 241/341] tidy, generate

---
 Dockerfile                                  |   2 +-
 internal/database/ent/db/account.go         |  36 ++--
 internal/database/ent/db/account/account.go |  72 +++----
 internal/database/ent/db/account/where.go   |  24 +--
 internal/database/ent/db/account_create.go  |  40 ++--
 internal/database/ent/db/account_query.go   |  88 ++++----
 internal/database/ent/db/account_update.go  | 216 ++++++++++----------
 internal/database/ent/db/client.go          |  20 +-
 internal/database/ent/db/mutation.go        | 188 ++++++++---------
 9 files changed, 343 insertions(+), 343 deletions(-)

diff --git a/Dockerfile b/Dockerfile
index 9e23b37d..0148d3d6 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -8,7 +8,7 @@ RUN --mount=type=cache,target=$GOPATH/pkg/mod go mod download
 COPY ./ ./
 
 # build a fully standalone binary with zero dependencies
-RUN --mount=type=cache,target=$GOPATH/pkg/mod go generate ./...
+RUN --mount=type=cache,target=$GOPATH/pkg/mod go generate main.go
 RUN --mount=type=cache,target=$GOPATH/pkg/mod CGO_ENABLED=1 GOOS=linux go build -o /bin/aftermath .
 
 # Make a scratch container with required files and binary
diff --git a/internal/database/ent/db/account.go b/internal/database/ent/db/account.go
index c2ac1943..4412ee60 100644
--- a/internal/database/ent/db/account.go
+++ b/internal/database/ent/db/account.go
@@ -44,12 +44,12 @@ type Account struct {
 type AccountEdges struct {
 	// Clan holds the value of the clan edge.
 	Clan *Clan `json:"clan,omitempty"`
-	// AccountSnapshots holds the value of the account_snapshots edge.
-	AccountSnapshots []*AccountSnapshot `json:"account_snapshots,omitempty"`
-	// VehicleSnapshots holds the value of the vehicle_snapshots edge.
-	VehicleSnapshots []*VehicleSnapshot `json:"vehicle_snapshots,omitempty"`
 	// AchievementSnapshots holds the value of the achievement_snapshots edge.
 	AchievementSnapshots []*AchievementsSnapshot `json:"achievement_snapshots,omitempty"`
+	// VehicleSnapshots holds the value of the vehicle_snapshots edge.
+	VehicleSnapshots []*VehicleSnapshot `json:"vehicle_snapshots,omitempty"`
+	// AccountSnapshots holds the value of the account_snapshots edge.
+	AccountSnapshots []*AccountSnapshot `json:"account_snapshots,omitempty"`
 	// loadedTypes holds the information for reporting if a
 	// type was loaded (or requested) in eager-loading or not.
 	loadedTypes [4]bool
@@ -66,13 +66,13 @@ func (e AccountEdges) ClanOrErr() (*Clan, error) {
 	return nil, &NotLoadedError{edge: "clan"}
 }
 
-// AccountSnapshotsOrErr returns the AccountSnapshots value or an error if the edge
+// AchievementSnapshotsOrErr returns the AchievementSnapshots value or an error if the edge
 // was not loaded in eager-loading.
-func (e AccountEdges) AccountSnapshotsOrErr() ([]*AccountSnapshot, error) {
+func (e AccountEdges) AchievementSnapshotsOrErr() ([]*AchievementsSnapshot, error) {
 	if e.loadedTypes[1] {
-		return e.AccountSnapshots, nil
+		return e.AchievementSnapshots, nil
 	}
-	return nil, &NotLoadedError{edge: "account_snapshots"}
+	return nil, &NotLoadedError{edge: "achievement_snapshots"}
 }
 
 // VehicleSnapshotsOrErr returns the VehicleSnapshots value or an error if the edge
@@ -84,13 +84,13 @@ func (e AccountEdges) VehicleSnapshotsOrErr() ([]*VehicleSnapshot, error) {
 	return nil, &NotLoadedError{edge: "vehicle_snapshots"}
 }
 
-// AchievementSnapshotsOrErr returns the AchievementSnapshots value or an error if the edge
+// AccountSnapshotsOrErr returns the AccountSnapshots value or an error if the edge
 // was not loaded in eager-loading.
-func (e AccountEdges) AchievementSnapshotsOrErr() ([]*AchievementsSnapshot, error) {
+func (e AccountEdges) AccountSnapshotsOrErr() ([]*AccountSnapshot, error) {
 	if e.loadedTypes[3] {
-		return e.AchievementSnapshots, nil
+		return e.AccountSnapshots, nil
 	}
-	return nil, &NotLoadedError{edge: "achievement_snapshots"}
+	return nil, &NotLoadedError{edge: "account_snapshots"}
 }
 
 // scanValues returns the types for scanning values from sql.Rows.
@@ -191,9 +191,9 @@ func (a *Account) QueryClan() *ClanQuery {
 	return NewAccountClient(a.config).QueryClan(a)
 }
 
-// QueryAccountSnapshots queries the "account_snapshots" edge of the Account entity.
-func (a *Account) QueryAccountSnapshots() *AccountSnapshotQuery {
-	return NewAccountClient(a.config).QueryAccountSnapshots(a)
+// QueryAchievementSnapshots queries the "achievement_snapshots" edge of the Account entity.
+func (a *Account) QueryAchievementSnapshots() *AchievementsSnapshotQuery {
+	return NewAccountClient(a.config).QueryAchievementSnapshots(a)
 }
 
 // QueryVehicleSnapshots queries the "vehicle_snapshots" edge of the Account entity.
@@ -201,9 +201,9 @@ func (a *Account) QueryVehicleSnapshots() *VehicleSnapshotQuery {
 	return NewAccountClient(a.config).QueryVehicleSnapshots(a)
 }
 
-// QueryAchievementSnapshots queries the "achievement_snapshots" edge of the Account entity.
-func (a *Account) QueryAchievementSnapshots() *AchievementsSnapshotQuery {
-	return NewAccountClient(a.config).QueryAchievementSnapshots(a)
+// QueryAccountSnapshots queries the "account_snapshots" edge of the Account entity.
+func (a *Account) QueryAccountSnapshots() *AccountSnapshotQuery {
+	return NewAccountClient(a.config).QueryAccountSnapshots(a)
 }
 
 // Update returns a builder for updating this Account.
diff --git a/internal/database/ent/db/account/account.go b/internal/database/ent/db/account/account.go
index adb50e4e..7be72dac 100644
--- a/internal/database/ent/db/account/account.go
+++ b/internal/database/ent/db/account/account.go
@@ -32,12 +32,12 @@ const (
 	FieldClanID = "clan_id"
 	// EdgeClan holds the string denoting the clan edge name in mutations.
 	EdgeClan = "clan"
-	// EdgeAccountSnapshots holds the string denoting the account_snapshots edge name in mutations.
-	EdgeAccountSnapshots = "account_snapshots"
-	// EdgeVehicleSnapshots holds the string denoting the vehicle_snapshots edge name in mutations.
-	EdgeVehicleSnapshots = "vehicle_snapshots"
 	// EdgeAchievementSnapshots holds the string denoting the achievement_snapshots edge name in mutations.
 	EdgeAchievementSnapshots = "achievement_snapshots"
+	// EdgeVehicleSnapshots holds the string denoting the vehicle_snapshots edge name in mutations.
+	EdgeVehicleSnapshots = "vehicle_snapshots"
+	// EdgeAccountSnapshots holds the string denoting the account_snapshots edge name in mutations.
+	EdgeAccountSnapshots = "account_snapshots"
 	// Table holds the table name of the account in the database.
 	Table = "accounts"
 	// ClanTable is the table that holds the clan relation/edge.
@@ -47,20 +47,6 @@ const (
 	ClanInverseTable = "clans"
 	// ClanColumn is the table column denoting the clan relation/edge.
 	ClanColumn = "clan_id"
-	// AccountSnapshotsTable is the table that holds the account_snapshots relation/edge.
-	AccountSnapshotsTable = "account_snapshots"
-	// AccountSnapshotsInverseTable is the table name for the AccountSnapshot entity.
-	// It exists in this package in order to avoid circular dependency with the "accountsnapshot" package.
-	AccountSnapshotsInverseTable = "account_snapshots"
-	// AccountSnapshotsColumn is the table column denoting the account_snapshots relation/edge.
-	AccountSnapshotsColumn = "account_id"
-	// VehicleSnapshotsTable is the table that holds the vehicle_snapshots relation/edge.
-	VehicleSnapshotsTable = "vehicle_snapshots"
-	// VehicleSnapshotsInverseTable is the table name for the VehicleSnapshot entity.
-	// It exists in this package in order to avoid circular dependency with the "vehiclesnapshot" package.
-	VehicleSnapshotsInverseTable = "vehicle_snapshots"
-	// VehicleSnapshotsColumn is the table column denoting the vehicle_snapshots relation/edge.
-	VehicleSnapshotsColumn = "account_id"
 	// AchievementSnapshotsTable is the table that holds the achievement_snapshots relation/edge.
 	AchievementSnapshotsTable = "achievements_snapshots"
 	// AchievementSnapshotsInverseTable is the table name for the AchievementsSnapshot entity.
@@ -68,6 +54,20 @@ const (
 	AchievementSnapshotsInverseTable = "achievements_snapshots"
 	// AchievementSnapshotsColumn is the table column denoting the achievement_snapshots relation/edge.
 	AchievementSnapshotsColumn = "account_id"
+	// VehicleSnapshotsTable is the table that holds the vehicle_snapshots relation/edge.
+	VehicleSnapshotsTable = "vehicle_snapshots"
+	// VehicleSnapshotsInverseTable is the table name for the VehicleSnapshot entity.
+	// It exists in this package in order to avoid circular dependency with the "vehiclesnapshot" package.
+	VehicleSnapshotsInverseTable = "vehicle_snapshots"
+	// VehicleSnapshotsColumn is the table column denoting the vehicle_snapshots relation/edge.
+	VehicleSnapshotsColumn = "account_id"
+	// AccountSnapshotsTable is the table that holds the account_snapshots relation/edge.
+	AccountSnapshotsTable = "account_snapshots"
+	// AccountSnapshotsInverseTable is the table name for the AccountSnapshot entity.
+	// It exists in this package in order to avoid circular dependency with the "accountsnapshot" package.
+	AccountSnapshotsInverseTable = "account_snapshots"
+	// AccountSnapshotsColumn is the table column denoting the account_snapshots relation/edge.
+	AccountSnapshotsColumn = "account_id"
 )
 
 // Columns holds all SQL columns for account fields.
@@ -163,17 +163,17 @@ func ByClanField(field string, opts ...sql.OrderTermOption) OrderOption {
 	}
 }
 
-// ByAccountSnapshotsCount orders the results by account_snapshots count.
-func ByAccountSnapshotsCount(opts ...sql.OrderTermOption) OrderOption {
+// ByAchievementSnapshotsCount orders the results by achievement_snapshots count.
+func ByAchievementSnapshotsCount(opts ...sql.OrderTermOption) OrderOption {
 	return func(s *sql.Selector) {
-		sqlgraph.OrderByNeighborsCount(s, newAccountSnapshotsStep(), opts...)
+		sqlgraph.OrderByNeighborsCount(s, newAchievementSnapshotsStep(), opts...)
 	}
 }
 
-// ByAccountSnapshots orders the results by account_snapshots terms.
-func ByAccountSnapshots(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+// ByAchievementSnapshots orders the results by achievement_snapshots terms.
+func ByAchievementSnapshots(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
 	return func(s *sql.Selector) {
-		sqlgraph.OrderByNeighborTerms(s, newAccountSnapshotsStep(), append([]sql.OrderTerm{term}, terms...)...)
+		sqlgraph.OrderByNeighborTerms(s, newAchievementSnapshotsStep(), append([]sql.OrderTerm{term}, terms...)...)
 	}
 }
 
@@ -191,17 +191,17 @@ func ByVehicleSnapshots(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption
 	}
 }
 
-// ByAchievementSnapshotsCount orders the results by achievement_snapshots count.
-func ByAchievementSnapshotsCount(opts ...sql.OrderTermOption) OrderOption {
+// ByAccountSnapshotsCount orders the results by account_snapshots count.
+func ByAccountSnapshotsCount(opts ...sql.OrderTermOption) OrderOption {
 	return func(s *sql.Selector) {
-		sqlgraph.OrderByNeighborsCount(s, newAchievementSnapshotsStep(), opts...)
+		sqlgraph.OrderByNeighborsCount(s, newAccountSnapshotsStep(), opts...)
 	}
 }
 
-// ByAchievementSnapshots orders the results by achievement_snapshots terms.
-func ByAchievementSnapshots(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+// ByAccountSnapshots orders the results by account_snapshots terms.
+func ByAccountSnapshots(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
 	return func(s *sql.Selector) {
-		sqlgraph.OrderByNeighborTerms(s, newAchievementSnapshotsStep(), append([]sql.OrderTerm{term}, terms...)...)
+		sqlgraph.OrderByNeighborTerms(s, newAccountSnapshotsStep(), append([]sql.OrderTerm{term}, terms...)...)
 	}
 }
 func newClanStep() *sqlgraph.Step {
@@ -211,11 +211,11 @@ func newClanStep() *sqlgraph.Step {
 		sqlgraph.Edge(sqlgraph.M2O, true, ClanTable, ClanColumn),
 	)
 }
-func newAccountSnapshotsStep() *sqlgraph.Step {
+func newAchievementSnapshotsStep() *sqlgraph.Step {
 	return sqlgraph.NewStep(
 		sqlgraph.From(Table, FieldID),
-		sqlgraph.To(AccountSnapshotsInverseTable, FieldID),
-		sqlgraph.Edge(sqlgraph.O2M, false, AccountSnapshotsTable, AccountSnapshotsColumn),
+		sqlgraph.To(AchievementSnapshotsInverseTable, FieldID),
+		sqlgraph.Edge(sqlgraph.O2M, false, AchievementSnapshotsTable, AchievementSnapshotsColumn),
 	)
 }
 func newVehicleSnapshotsStep() *sqlgraph.Step {
@@ -225,10 +225,10 @@ func newVehicleSnapshotsStep() *sqlgraph.Step {
 		sqlgraph.Edge(sqlgraph.O2M, false, VehicleSnapshotsTable, VehicleSnapshotsColumn),
 	)
 }
-func newAchievementSnapshotsStep() *sqlgraph.Step {
+func newAccountSnapshotsStep() *sqlgraph.Step {
 	return sqlgraph.NewStep(
 		sqlgraph.From(Table, FieldID),
-		sqlgraph.To(AchievementSnapshotsInverseTable, FieldID),
-		sqlgraph.Edge(sqlgraph.O2M, false, AchievementSnapshotsTable, AchievementSnapshotsColumn),
+		sqlgraph.To(AccountSnapshotsInverseTable, FieldID),
+		sqlgraph.Edge(sqlgraph.O2M, false, AccountSnapshotsTable, AccountSnapshotsColumn),
 	)
 }
diff --git a/internal/database/ent/db/account/where.go b/internal/database/ent/db/account/where.go
index 2b170a4f..0c513cd9 100644
--- a/internal/database/ent/db/account/where.go
+++ b/internal/database/ent/db/account/where.go
@@ -503,21 +503,21 @@ func HasClanWith(preds ...predicate.Clan) predicate.Account {
 	})
 }
 
-// HasAccountSnapshots applies the HasEdge predicate on the "account_snapshots" edge.
-func HasAccountSnapshots() predicate.Account {
+// HasAchievementSnapshots applies the HasEdge predicate on the "achievement_snapshots" edge.
+func HasAchievementSnapshots() predicate.Account {
 	return predicate.Account(func(s *sql.Selector) {
 		step := sqlgraph.NewStep(
 			sqlgraph.From(Table, FieldID),
-			sqlgraph.Edge(sqlgraph.O2M, false, AccountSnapshotsTable, AccountSnapshotsColumn),
+			sqlgraph.Edge(sqlgraph.O2M, false, AchievementSnapshotsTable, AchievementSnapshotsColumn),
 		)
 		sqlgraph.HasNeighbors(s, step)
 	})
 }
 
-// HasAccountSnapshotsWith applies the HasEdge predicate on the "account_snapshots" edge with a given conditions (other predicates).
-func HasAccountSnapshotsWith(preds ...predicate.AccountSnapshot) predicate.Account {
+// HasAchievementSnapshotsWith applies the HasEdge predicate on the "achievement_snapshots" edge with a given conditions (other predicates).
+func HasAchievementSnapshotsWith(preds ...predicate.AchievementsSnapshot) predicate.Account {
 	return predicate.Account(func(s *sql.Selector) {
-		step := newAccountSnapshotsStep()
+		step := newAchievementSnapshotsStep()
 		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
 			for _, p := range preds {
 				p(s)
@@ -549,21 +549,21 @@ func HasVehicleSnapshotsWith(preds ...predicate.VehicleSnapshot) predicate.Accou
 	})
 }
 
-// HasAchievementSnapshots applies the HasEdge predicate on the "achievement_snapshots" edge.
-func HasAchievementSnapshots() predicate.Account {
+// HasAccountSnapshots applies the HasEdge predicate on the "account_snapshots" edge.
+func HasAccountSnapshots() predicate.Account {
 	return predicate.Account(func(s *sql.Selector) {
 		step := sqlgraph.NewStep(
 			sqlgraph.From(Table, FieldID),
-			sqlgraph.Edge(sqlgraph.O2M, false, AchievementSnapshotsTable, AchievementSnapshotsColumn),
+			sqlgraph.Edge(sqlgraph.O2M, false, AccountSnapshotsTable, AccountSnapshotsColumn),
 		)
 		sqlgraph.HasNeighbors(s, step)
 	})
 }
 
-// HasAchievementSnapshotsWith applies the HasEdge predicate on the "achievement_snapshots" edge with a given conditions (other predicates).
-func HasAchievementSnapshotsWith(preds ...predicate.AchievementsSnapshot) predicate.Account {
+// HasAccountSnapshotsWith applies the HasEdge predicate on the "account_snapshots" edge with a given conditions (other predicates).
+func HasAccountSnapshotsWith(preds ...predicate.AccountSnapshot) predicate.Account {
 	return predicate.Account(func(s *sql.Selector) {
-		step := newAchievementSnapshotsStep()
+		step := newAccountSnapshotsStep()
 		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
 			for _, p := range preds {
 				p(s)
diff --git a/internal/database/ent/db/account_create.go b/internal/database/ent/db/account_create.go
index c54cc2b3..9ed86957 100644
--- a/internal/database/ent/db/account_create.go
+++ b/internal/database/ent/db/account_create.go
@@ -115,19 +115,19 @@ func (ac *AccountCreate) SetClan(c *Clan) *AccountCreate {
 	return ac.SetClanID(c.ID)
 }
 
-// AddAccountSnapshotIDs adds the "account_snapshots" edge to the AccountSnapshot entity by IDs.
-func (ac *AccountCreate) AddAccountSnapshotIDs(ids ...string) *AccountCreate {
-	ac.mutation.AddAccountSnapshotIDs(ids...)
+// AddAchievementSnapshotIDs adds the "achievement_snapshots" edge to the AchievementsSnapshot entity by IDs.
+func (ac *AccountCreate) AddAchievementSnapshotIDs(ids ...string) *AccountCreate {
+	ac.mutation.AddAchievementSnapshotIDs(ids...)
 	return ac
 }
 
-// AddAccountSnapshots adds the "account_snapshots" edges to the AccountSnapshot entity.
-func (ac *AccountCreate) AddAccountSnapshots(a ...*AccountSnapshot) *AccountCreate {
+// AddAchievementSnapshots adds the "achievement_snapshots" edges to the AchievementsSnapshot entity.
+func (ac *AccountCreate) AddAchievementSnapshots(a ...*AchievementsSnapshot) *AccountCreate {
 	ids := make([]string, len(a))
 	for i := range a {
 		ids[i] = a[i].ID
 	}
-	return ac.AddAccountSnapshotIDs(ids...)
+	return ac.AddAchievementSnapshotIDs(ids...)
 }
 
 // AddVehicleSnapshotIDs adds the "vehicle_snapshots" edge to the VehicleSnapshot entity by IDs.
@@ -145,19 +145,19 @@ func (ac *AccountCreate) AddVehicleSnapshots(v ...*VehicleSnapshot) *AccountCrea
 	return ac.AddVehicleSnapshotIDs(ids...)
 }
 
-// AddAchievementSnapshotIDs adds the "achievement_snapshots" edge to the AchievementsSnapshot entity by IDs.
-func (ac *AccountCreate) AddAchievementSnapshotIDs(ids ...string) *AccountCreate {
-	ac.mutation.AddAchievementSnapshotIDs(ids...)
+// AddAccountSnapshotIDs adds the "account_snapshots" edge to the AccountSnapshot entity by IDs.
+func (ac *AccountCreate) AddAccountSnapshotIDs(ids ...string) *AccountCreate {
+	ac.mutation.AddAccountSnapshotIDs(ids...)
 	return ac
 }
 
-// AddAchievementSnapshots adds the "achievement_snapshots" edges to the AchievementsSnapshot entity.
-func (ac *AccountCreate) AddAchievementSnapshots(a ...*AchievementsSnapshot) *AccountCreate {
+// AddAccountSnapshots adds the "account_snapshots" edges to the AccountSnapshot entity.
+func (ac *AccountCreate) AddAccountSnapshots(a ...*AccountSnapshot) *AccountCreate {
 	ids := make([]string, len(a))
 	for i := range a {
 		ids[i] = a[i].ID
 	}
-	return ac.AddAchievementSnapshotIDs(ids...)
+	return ac.AddAccountSnapshotIDs(ids...)
 }
 
 // Mutation returns the AccountMutation object of the builder.
@@ -322,15 +322,15 @@ func (ac *AccountCreate) createSpec() (*Account, *sqlgraph.CreateSpec) {
 		_node.ClanID = nodes[0]
 		_spec.Edges = append(_spec.Edges, edge)
 	}
-	if nodes := ac.mutation.AccountSnapshotsIDs(); len(nodes) > 0 {
+	if nodes := ac.mutation.AchievementSnapshotsIDs(); len(nodes) > 0 {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,
 			Inverse: false,
-			Table:   account.AccountSnapshotsTable,
-			Columns: []string{account.AccountSnapshotsColumn},
+			Table:   account.AchievementSnapshotsTable,
+			Columns: []string{account.AchievementSnapshotsColumn},
 			Bidi:    false,
 			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(accountsnapshot.FieldID, field.TypeString),
+				IDSpec: sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString),
 			},
 		}
 		for _, k := range nodes {
@@ -354,15 +354,15 @@ func (ac *AccountCreate) createSpec() (*Account, *sqlgraph.CreateSpec) {
 		}
 		_spec.Edges = append(_spec.Edges, edge)
 	}
-	if nodes := ac.mutation.AchievementSnapshotsIDs(); len(nodes) > 0 {
+	if nodes := ac.mutation.AccountSnapshotsIDs(); len(nodes) > 0 {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,
 			Inverse: false,
-			Table:   account.AchievementSnapshotsTable,
-			Columns: []string{account.AchievementSnapshotsColumn},
+			Table:   account.AccountSnapshotsTable,
+			Columns: []string{account.AccountSnapshotsColumn},
 			Bidi:    false,
 			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString),
+				IDSpec: sqlgraph.NewFieldSpec(accountsnapshot.FieldID, field.TypeString),
 			},
 		}
 		for _, k := range nodes {
diff --git a/internal/database/ent/db/account_query.go b/internal/database/ent/db/account_query.go
index d3dc8f75..38604e4f 100644
--- a/internal/database/ent/db/account_query.go
+++ b/internal/database/ent/db/account_query.go
@@ -27,9 +27,9 @@ type AccountQuery struct {
 	inters                   []Interceptor
 	predicates               []predicate.Account
 	withClan                 *ClanQuery
-	withAccountSnapshots     *AccountSnapshotQuery
-	withVehicleSnapshots     *VehicleSnapshotQuery
 	withAchievementSnapshots *AchievementsSnapshotQuery
+	withVehicleSnapshots     *VehicleSnapshotQuery
+	withAccountSnapshots     *AccountSnapshotQuery
 	modifiers                []func(*sql.Selector)
 	// intermediate query (i.e. traversal path).
 	sql  *sql.Selector
@@ -89,9 +89,9 @@ func (aq *AccountQuery) QueryClan() *ClanQuery {
 	return query
 }
 
-// QueryAccountSnapshots chains the current query on the "account_snapshots" edge.
-func (aq *AccountQuery) QueryAccountSnapshots() *AccountSnapshotQuery {
-	query := (&AccountSnapshotClient{config: aq.config}).Query()
+// QueryAchievementSnapshots chains the current query on the "achievement_snapshots" edge.
+func (aq *AccountQuery) QueryAchievementSnapshots() *AchievementsSnapshotQuery {
+	query := (&AchievementsSnapshotClient{config: aq.config}).Query()
 	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
 		if err := aq.prepareQuery(ctx); err != nil {
 			return nil, err
@@ -102,8 +102,8 @@ func (aq *AccountQuery) QueryAccountSnapshots() *AccountSnapshotQuery {
 		}
 		step := sqlgraph.NewStep(
 			sqlgraph.From(account.Table, account.FieldID, selector),
-			sqlgraph.To(accountsnapshot.Table, accountsnapshot.FieldID),
-			sqlgraph.Edge(sqlgraph.O2M, false, account.AccountSnapshotsTable, account.AccountSnapshotsColumn),
+			sqlgraph.To(achievementssnapshot.Table, achievementssnapshot.FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, account.AchievementSnapshotsTable, account.AchievementSnapshotsColumn),
 		)
 		fromU = sqlgraph.SetNeighbors(aq.driver.Dialect(), step)
 		return fromU, nil
@@ -133,9 +133,9 @@ func (aq *AccountQuery) QueryVehicleSnapshots() *VehicleSnapshotQuery {
 	return query
 }
 
-// QueryAchievementSnapshots chains the current query on the "achievement_snapshots" edge.
-func (aq *AccountQuery) QueryAchievementSnapshots() *AchievementsSnapshotQuery {
-	query := (&AchievementsSnapshotClient{config: aq.config}).Query()
+// QueryAccountSnapshots chains the current query on the "account_snapshots" edge.
+func (aq *AccountQuery) QueryAccountSnapshots() *AccountSnapshotQuery {
+	query := (&AccountSnapshotClient{config: aq.config}).Query()
 	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
 		if err := aq.prepareQuery(ctx); err != nil {
 			return nil, err
@@ -146,8 +146,8 @@ func (aq *AccountQuery) QueryAchievementSnapshots() *AchievementsSnapshotQuery {
 		}
 		step := sqlgraph.NewStep(
 			sqlgraph.From(account.Table, account.FieldID, selector),
-			sqlgraph.To(achievementssnapshot.Table, achievementssnapshot.FieldID),
-			sqlgraph.Edge(sqlgraph.O2M, false, account.AchievementSnapshotsTable, account.AchievementSnapshotsColumn),
+			sqlgraph.To(accountsnapshot.Table, accountsnapshot.FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, account.AccountSnapshotsTable, account.AccountSnapshotsColumn),
 		)
 		fromU = sqlgraph.SetNeighbors(aq.driver.Dialect(), step)
 		return fromU, nil
@@ -348,9 +348,9 @@ func (aq *AccountQuery) Clone() *AccountQuery {
 		inters:                   append([]Interceptor{}, aq.inters...),
 		predicates:               append([]predicate.Account{}, aq.predicates...),
 		withClan:                 aq.withClan.Clone(),
-		withAccountSnapshots:     aq.withAccountSnapshots.Clone(),
-		withVehicleSnapshots:     aq.withVehicleSnapshots.Clone(),
 		withAchievementSnapshots: aq.withAchievementSnapshots.Clone(),
+		withVehicleSnapshots:     aq.withVehicleSnapshots.Clone(),
+		withAccountSnapshots:     aq.withAccountSnapshots.Clone(),
 		// clone intermediate query.
 		sql:  aq.sql.Clone(),
 		path: aq.path,
@@ -368,14 +368,14 @@ func (aq *AccountQuery) WithClan(opts ...func(*ClanQuery)) *AccountQuery {
 	return aq
 }
 
-// WithAccountSnapshots tells the query-builder to eager-load the nodes that are connected to
-// the "account_snapshots" edge. The optional arguments are used to configure the query builder of the edge.
-func (aq *AccountQuery) WithAccountSnapshots(opts ...func(*AccountSnapshotQuery)) *AccountQuery {
-	query := (&AccountSnapshotClient{config: aq.config}).Query()
+// WithAchievementSnapshots tells the query-builder to eager-load the nodes that are connected to
+// the "achievement_snapshots" edge. The optional arguments are used to configure the query builder of the edge.
+func (aq *AccountQuery) WithAchievementSnapshots(opts ...func(*AchievementsSnapshotQuery)) *AccountQuery {
+	query := (&AchievementsSnapshotClient{config: aq.config}).Query()
 	for _, opt := range opts {
 		opt(query)
 	}
-	aq.withAccountSnapshots = query
+	aq.withAchievementSnapshots = query
 	return aq
 }
 
@@ -390,14 +390,14 @@ func (aq *AccountQuery) WithVehicleSnapshots(opts ...func(*VehicleSnapshotQuery)
 	return aq
 }
 
-// WithAchievementSnapshots tells the query-builder to eager-load the nodes that are connected to
-// the "achievement_snapshots" edge. The optional arguments are used to configure the query builder of the edge.
-func (aq *AccountQuery) WithAchievementSnapshots(opts ...func(*AchievementsSnapshotQuery)) *AccountQuery {
-	query := (&AchievementsSnapshotClient{config: aq.config}).Query()
+// WithAccountSnapshots tells the query-builder to eager-load the nodes that are connected to
+// the "account_snapshots" edge. The optional arguments are used to configure the query builder of the edge.
+func (aq *AccountQuery) WithAccountSnapshots(opts ...func(*AccountSnapshotQuery)) *AccountQuery {
+	query := (&AccountSnapshotClient{config: aq.config}).Query()
 	for _, opt := range opts {
 		opt(query)
 	}
-	aq.withAchievementSnapshots = query
+	aq.withAccountSnapshots = query
 	return aq
 }
 
@@ -481,9 +481,9 @@ func (aq *AccountQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Acco
 		_spec       = aq.querySpec()
 		loadedTypes = [4]bool{
 			aq.withClan != nil,
-			aq.withAccountSnapshots != nil,
-			aq.withVehicleSnapshots != nil,
 			aq.withAchievementSnapshots != nil,
+			aq.withVehicleSnapshots != nil,
+			aq.withAccountSnapshots != nil,
 		}
 	)
 	_spec.ScanValues = func(columns []string) ([]any, error) {
@@ -513,10 +513,12 @@ func (aq *AccountQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Acco
 			return nil, err
 		}
 	}
-	if query := aq.withAccountSnapshots; query != nil {
-		if err := aq.loadAccountSnapshots(ctx, query, nodes,
-			func(n *Account) { n.Edges.AccountSnapshots = []*AccountSnapshot{} },
-			func(n *Account, e *AccountSnapshot) { n.Edges.AccountSnapshots = append(n.Edges.AccountSnapshots, e) }); err != nil {
+	if query := aq.withAchievementSnapshots; query != nil {
+		if err := aq.loadAchievementSnapshots(ctx, query, nodes,
+			func(n *Account) { n.Edges.AchievementSnapshots = []*AchievementsSnapshot{} },
+			func(n *Account, e *AchievementsSnapshot) {
+				n.Edges.AchievementSnapshots = append(n.Edges.AchievementSnapshots, e)
+			}); err != nil {
 			return nil, err
 		}
 	}
@@ -527,12 +529,10 @@ func (aq *AccountQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Acco
 			return nil, err
 		}
 	}
-	if query := aq.withAchievementSnapshots; query != nil {
-		if err := aq.loadAchievementSnapshots(ctx, query, nodes,
-			func(n *Account) { n.Edges.AchievementSnapshots = []*AchievementsSnapshot{} },
-			func(n *Account, e *AchievementsSnapshot) {
-				n.Edges.AchievementSnapshots = append(n.Edges.AchievementSnapshots, e)
-			}); err != nil {
+	if query := aq.withAccountSnapshots; query != nil {
+		if err := aq.loadAccountSnapshots(ctx, query, nodes,
+			func(n *Account) { n.Edges.AccountSnapshots = []*AccountSnapshot{} },
+			func(n *Account, e *AccountSnapshot) { n.Edges.AccountSnapshots = append(n.Edges.AccountSnapshots, e) }); err != nil {
 			return nil, err
 		}
 	}
@@ -568,7 +568,7 @@ func (aq *AccountQuery) loadClan(ctx context.Context, query *ClanQuery, nodes []
 	}
 	return nil
 }
-func (aq *AccountQuery) loadAccountSnapshots(ctx context.Context, query *AccountSnapshotQuery, nodes []*Account, init func(*Account), assign func(*Account, *AccountSnapshot)) error {
+func (aq *AccountQuery) loadAchievementSnapshots(ctx context.Context, query *AchievementsSnapshotQuery, nodes []*Account, init func(*Account), assign func(*Account, *AchievementsSnapshot)) error {
 	fks := make([]driver.Value, 0, len(nodes))
 	nodeids := make(map[string]*Account)
 	for i := range nodes {
@@ -579,10 +579,10 @@ func (aq *AccountQuery) loadAccountSnapshots(ctx context.Context, query *Account
 		}
 	}
 	if len(query.ctx.Fields) > 0 {
-		query.ctx.AppendFieldOnce(accountsnapshot.FieldAccountID)
+		query.ctx.AppendFieldOnce(achievementssnapshot.FieldAccountID)
 	}
-	query.Where(predicate.AccountSnapshot(func(s *sql.Selector) {
-		s.Where(sql.InValues(s.C(account.AccountSnapshotsColumn), fks...))
+	query.Where(predicate.AchievementsSnapshot(func(s *sql.Selector) {
+		s.Where(sql.InValues(s.C(account.AchievementSnapshotsColumn), fks...))
 	}))
 	neighbors, err := query.All(ctx)
 	if err != nil {
@@ -628,7 +628,7 @@ func (aq *AccountQuery) loadVehicleSnapshots(ctx context.Context, query *Vehicle
 	}
 	return nil
 }
-func (aq *AccountQuery) loadAchievementSnapshots(ctx context.Context, query *AchievementsSnapshotQuery, nodes []*Account, init func(*Account), assign func(*Account, *AchievementsSnapshot)) error {
+func (aq *AccountQuery) loadAccountSnapshots(ctx context.Context, query *AccountSnapshotQuery, nodes []*Account, init func(*Account), assign func(*Account, *AccountSnapshot)) error {
 	fks := make([]driver.Value, 0, len(nodes))
 	nodeids := make(map[string]*Account)
 	for i := range nodes {
@@ -639,10 +639,10 @@ func (aq *AccountQuery) loadAchievementSnapshots(ctx context.Context, query *Ach
 		}
 	}
 	if len(query.ctx.Fields) > 0 {
-		query.ctx.AppendFieldOnce(achievementssnapshot.FieldAccountID)
+		query.ctx.AppendFieldOnce(accountsnapshot.FieldAccountID)
 	}
-	query.Where(predicate.AchievementsSnapshot(func(s *sql.Selector) {
-		s.Where(sql.InValues(s.C(account.AchievementSnapshotsColumn), fks...))
+	query.Where(predicate.AccountSnapshot(func(s *sql.Selector) {
+		s.Where(sql.InValues(s.C(account.AccountSnapshotsColumn), fks...))
 	}))
 	neighbors, err := query.All(ctx)
 	if err != nil {
diff --git a/internal/database/ent/db/account_update.go b/internal/database/ent/db/account_update.go
index 7aca76d5..af4a3d52 100644
--- a/internal/database/ent/db/account_update.go
+++ b/internal/database/ent/db/account_update.go
@@ -134,19 +134,19 @@ func (au *AccountUpdate) SetClan(c *Clan) *AccountUpdate {
 	return au.SetClanID(c.ID)
 }
 
-// AddAccountSnapshotIDs adds the "account_snapshots" edge to the AccountSnapshot entity by IDs.
-func (au *AccountUpdate) AddAccountSnapshotIDs(ids ...string) *AccountUpdate {
-	au.mutation.AddAccountSnapshotIDs(ids...)
+// AddAchievementSnapshotIDs adds the "achievement_snapshots" edge to the AchievementsSnapshot entity by IDs.
+func (au *AccountUpdate) AddAchievementSnapshotIDs(ids ...string) *AccountUpdate {
+	au.mutation.AddAchievementSnapshotIDs(ids...)
 	return au
 }
 
-// AddAccountSnapshots adds the "account_snapshots" edges to the AccountSnapshot entity.
-func (au *AccountUpdate) AddAccountSnapshots(a ...*AccountSnapshot) *AccountUpdate {
+// AddAchievementSnapshots adds the "achievement_snapshots" edges to the AchievementsSnapshot entity.
+func (au *AccountUpdate) AddAchievementSnapshots(a ...*AchievementsSnapshot) *AccountUpdate {
 	ids := make([]string, len(a))
 	for i := range a {
 		ids[i] = a[i].ID
 	}
-	return au.AddAccountSnapshotIDs(ids...)
+	return au.AddAchievementSnapshotIDs(ids...)
 }
 
 // AddVehicleSnapshotIDs adds the "vehicle_snapshots" edge to the VehicleSnapshot entity by IDs.
@@ -164,19 +164,19 @@ func (au *AccountUpdate) AddVehicleSnapshots(v ...*VehicleSnapshot) *AccountUpda
 	return au.AddVehicleSnapshotIDs(ids...)
 }
 
-// AddAchievementSnapshotIDs adds the "achievement_snapshots" edge to the AchievementsSnapshot entity by IDs.
-func (au *AccountUpdate) AddAchievementSnapshotIDs(ids ...string) *AccountUpdate {
-	au.mutation.AddAchievementSnapshotIDs(ids...)
+// AddAccountSnapshotIDs adds the "account_snapshots" edge to the AccountSnapshot entity by IDs.
+func (au *AccountUpdate) AddAccountSnapshotIDs(ids ...string) *AccountUpdate {
+	au.mutation.AddAccountSnapshotIDs(ids...)
 	return au
 }
 
-// AddAchievementSnapshots adds the "achievement_snapshots" edges to the AchievementsSnapshot entity.
-func (au *AccountUpdate) AddAchievementSnapshots(a ...*AchievementsSnapshot) *AccountUpdate {
+// AddAccountSnapshots adds the "account_snapshots" edges to the AccountSnapshot entity.
+func (au *AccountUpdate) AddAccountSnapshots(a ...*AccountSnapshot) *AccountUpdate {
 	ids := make([]string, len(a))
 	for i := range a {
 		ids[i] = a[i].ID
 	}
-	return au.AddAchievementSnapshotIDs(ids...)
+	return au.AddAccountSnapshotIDs(ids...)
 }
 
 // Mutation returns the AccountMutation object of the builder.
@@ -190,25 +190,25 @@ func (au *AccountUpdate) ClearClan() *AccountUpdate {
 	return au
 }
 
-// ClearAccountSnapshots clears all "account_snapshots" edges to the AccountSnapshot entity.
-func (au *AccountUpdate) ClearAccountSnapshots() *AccountUpdate {
-	au.mutation.ClearAccountSnapshots()
+// ClearAchievementSnapshots clears all "achievement_snapshots" edges to the AchievementsSnapshot entity.
+func (au *AccountUpdate) ClearAchievementSnapshots() *AccountUpdate {
+	au.mutation.ClearAchievementSnapshots()
 	return au
 }
 
-// RemoveAccountSnapshotIDs removes the "account_snapshots" edge to AccountSnapshot entities by IDs.
-func (au *AccountUpdate) RemoveAccountSnapshotIDs(ids ...string) *AccountUpdate {
-	au.mutation.RemoveAccountSnapshotIDs(ids...)
+// RemoveAchievementSnapshotIDs removes the "achievement_snapshots" edge to AchievementsSnapshot entities by IDs.
+func (au *AccountUpdate) RemoveAchievementSnapshotIDs(ids ...string) *AccountUpdate {
+	au.mutation.RemoveAchievementSnapshotIDs(ids...)
 	return au
 }
 
-// RemoveAccountSnapshots removes "account_snapshots" edges to AccountSnapshot entities.
-func (au *AccountUpdate) RemoveAccountSnapshots(a ...*AccountSnapshot) *AccountUpdate {
+// RemoveAchievementSnapshots removes "achievement_snapshots" edges to AchievementsSnapshot entities.
+func (au *AccountUpdate) RemoveAchievementSnapshots(a ...*AchievementsSnapshot) *AccountUpdate {
 	ids := make([]string, len(a))
 	for i := range a {
 		ids[i] = a[i].ID
 	}
-	return au.RemoveAccountSnapshotIDs(ids...)
+	return au.RemoveAchievementSnapshotIDs(ids...)
 }
 
 // ClearVehicleSnapshots clears all "vehicle_snapshots" edges to the VehicleSnapshot entity.
@@ -232,25 +232,25 @@ func (au *AccountUpdate) RemoveVehicleSnapshots(v ...*VehicleSnapshot) *AccountU
 	return au.RemoveVehicleSnapshotIDs(ids...)
 }
 
-// ClearAchievementSnapshots clears all "achievement_snapshots" edges to the AchievementsSnapshot entity.
-func (au *AccountUpdate) ClearAchievementSnapshots() *AccountUpdate {
-	au.mutation.ClearAchievementSnapshots()
+// ClearAccountSnapshots clears all "account_snapshots" edges to the AccountSnapshot entity.
+func (au *AccountUpdate) ClearAccountSnapshots() *AccountUpdate {
+	au.mutation.ClearAccountSnapshots()
 	return au
 }
 
-// RemoveAchievementSnapshotIDs removes the "achievement_snapshots" edge to AchievementsSnapshot entities by IDs.
-func (au *AccountUpdate) RemoveAchievementSnapshotIDs(ids ...string) *AccountUpdate {
-	au.mutation.RemoveAchievementSnapshotIDs(ids...)
+// RemoveAccountSnapshotIDs removes the "account_snapshots" edge to AccountSnapshot entities by IDs.
+func (au *AccountUpdate) RemoveAccountSnapshotIDs(ids ...string) *AccountUpdate {
+	au.mutation.RemoveAccountSnapshotIDs(ids...)
 	return au
 }
 
-// RemoveAchievementSnapshots removes "achievement_snapshots" edges to AchievementsSnapshot entities.
-func (au *AccountUpdate) RemoveAchievementSnapshots(a ...*AchievementsSnapshot) *AccountUpdate {
+// RemoveAccountSnapshots removes "account_snapshots" edges to AccountSnapshot entities.
+func (au *AccountUpdate) RemoveAccountSnapshots(a ...*AccountSnapshot) *AccountUpdate {
 	ids := make([]string, len(a))
 	for i := range a {
 		ids[i] = a[i].ID
 	}
-	return au.RemoveAchievementSnapshotIDs(ids...)
+	return au.RemoveAccountSnapshotIDs(ids...)
 }
 
 // Save executes the query and returns the number of nodes affected by the update operation.
@@ -369,28 +369,28 @@ func (au *AccountUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 		_spec.Edges.Add = append(_spec.Edges.Add, edge)
 	}
-	if au.mutation.AccountSnapshotsCleared() {
+	if au.mutation.AchievementSnapshotsCleared() {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,
 			Inverse: false,
-			Table:   account.AccountSnapshotsTable,
-			Columns: []string{account.AccountSnapshotsColumn},
+			Table:   account.AchievementSnapshotsTable,
+			Columns: []string{account.AchievementSnapshotsColumn},
 			Bidi:    false,
 			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(accountsnapshot.FieldID, field.TypeString),
+				IDSpec: sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString),
 			},
 		}
 		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
 	}
-	if nodes := au.mutation.RemovedAccountSnapshotsIDs(); len(nodes) > 0 && !au.mutation.AccountSnapshotsCleared() {
+	if nodes := au.mutation.RemovedAchievementSnapshotsIDs(); len(nodes) > 0 && !au.mutation.AchievementSnapshotsCleared() {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,
 			Inverse: false,
-			Table:   account.AccountSnapshotsTable,
-			Columns: []string{account.AccountSnapshotsColumn},
+			Table:   account.AchievementSnapshotsTable,
+			Columns: []string{account.AchievementSnapshotsColumn},
 			Bidi:    false,
 			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(accountsnapshot.FieldID, field.TypeString),
+				IDSpec: sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString),
 			},
 		}
 		for _, k := range nodes {
@@ -398,15 +398,15 @@ func (au *AccountUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
 	}
-	if nodes := au.mutation.AccountSnapshotsIDs(); len(nodes) > 0 {
+	if nodes := au.mutation.AchievementSnapshotsIDs(); len(nodes) > 0 {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,
 			Inverse: false,
-			Table:   account.AccountSnapshotsTable,
-			Columns: []string{account.AccountSnapshotsColumn},
+			Table:   account.AchievementSnapshotsTable,
+			Columns: []string{account.AchievementSnapshotsColumn},
 			Bidi:    false,
 			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(accountsnapshot.FieldID, field.TypeString),
+				IDSpec: sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString),
 			},
 		}
 		for _, k := range nodes {
@@ -459,28 +459,28 @@ func (au *AccountUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 		_spec.Edges.Add = append(_spec.Edges.Add, edge)
 	}
-	if au.mutation.AchievementSnapshotsCleared() {
+	if au.mutation.AccountSnapshotsCleared() {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,
 			Inverse: false,
-			Table:   account.AchievementSnapshotsTable,
-			Columns: []string{account.AchievementSnapshotsColumn},
+			Table:   account.AccountSnapshotsTable,
+			Columns: []string{account.AccountSnapshotsColumn},
 			Bidi:    false,
 			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString),
+				IDSpec: sqlgraph.NewFieldSpec(accountsnapshot.FieldID, field.TypeString),
 			},
 		}
 		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
 	}
-	if nodes := au.mutation.RemovedAchievementSnapshotsIDs(); len(nodes) > 0 && !au.mutation.AchievementSnapshotsCleared() {
+	if nodes := au.mutation.RemovedAccountSnapshotsIDs(); len(nodes) > 0 && !au.mutation.AccountSnapshotsCleared() {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,
 			Inverse: false,
-			Table:   account.AchievementSnapshotsTable,
-			Columns: []string{account.AchievementSnapshotsColumn},
+			Table:   account.AccountSnapshotsTable,
+			Columns: []string{account.AccountSnapshotsColumn},
 			Bidi:    false,
 			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString),
+				IDSpec: sqlgraph.NewFieldSpec(accountsnapshot.FieldID, field.TypeString),
 			},
 		}
 		for _, k := range nodes {
@@ -488,15 +488,15 @@ func (au *AccountUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
 	}
-	if nodes := au.mutation.AchievementSnapshotsIDs(); len(nodes) > 0 {
+	if nodes := au.mutation.AccountSnapshotsIDs(); len(nodes) > 0 {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,
 			Inverse: false,
-			Table:   account.AchievementSnapshotsTable,
-			Columns: []string{account.AchievementSnapshotsColumn},
+			Table:   account.AccountSnapshotsTable,
+			Columns: []string{account.AccountSnapshotsColumn},
 			Bidi:    false,
 			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString),
+				IDSpec: sqlgraph.NewFieldSpec(accountsnapshot.FieldID, field.TypeString),
 			},
 		}
 		for _, k := range nodes {
@@ -627,19 +627,19 @@ func (auo *AccountUpdateOne) SetClan(c *Clan) *AccountUpdateOne {
 	return auo.SetClanID(c.ID)
 }
 
-// AddAccountSnapshotIDs adds the "account_snapshots" edge to the AccountSnapshot entity by IDs.
-func (auo *AccountUpdateOne) AddAccountSnapshotIDs(ids ...string) *AccountUpdateOne {
-	auo.mutation.AddAccountSnapshotIDs(ids...)
+// AddAchievementSnapshotIDs adds the "achievement_snapshots" edge to the AchievementsSnapshot entity by IDs.
+func (auo *AccountUpdateOne) AddAchievementSnapshotIDs(ids ...string) *AccountUpdateOne {
+	auo.mutation.AddAchievementSnapshotIDs(ids...)
 	return auo
 }
 
-// AddAccountSnapshots adds the "account_snapshots" edges to the AccountSnapshot entity.
-func (auo *AccountUpdateOne) AddAccountSnapshots(a ...*AccountSnapshot) *AccountUpdateOne {
+// AddAchievementSnapshots adds the "achievement_snapshots" edges to the AchievementsSnapshot entity.
+func (auo *AccountUpdateOne) AddAchievementSnapshots(a ...*AchievementsSnapshot) *AccountUpdateOne {
 	ids := make([]string, len(a))
 	for i := range a {
 		ids[i] = a[i].ID
 	}
-	return auo.AddAccountSnapshotIDs(ids...)
+	return auo.AddAchievementSnapshotIDs(ids...)
 }
 
 // AddVehicleSnapshotIDs adds the "vehicle_snapshots" edge to the VehicleSnapshot entity by IDs.
@@ -657,19 +657,19 @@ func (auo *AccountUpdateOne) AddVehicleSnapshots(v ...*VehicleSnapshot) *Account
 	return auo.AddVehicleSnapshotIDs(ids...)
 }
 
-// AddAchievementSnapshotIDs adds the "achievement_snapshots" edge to the AchievementsSnapshot entity by IDs.
-func (auo *AccountUpdateOne) AddAchievementSnapshotIDs(ids ...string) *AccountUpdateOne {
-	auo.mutation.AddAchievementSnapshotIDs(ids...)
+// AddAccountSnapshotIDs adds the "account_snapshots" edge to the AccountSnapshot entity by IDs.
+func (auo *AccountUpdateOne) AddAccountSnapshotIDs(ids ...string) *AccountUpdateOne {
+	auo.mutation.AddAccountSnapshotIDs(ids...)
 	return auo
 }
 
-// AddAchievementSnapshots adds the "achievement_snapshots" edges to the AchievementsSnapshot entity.
-func (auo *AccountUpdateOne) AddAchievementSnapshots(a ...*AchievementsSnapshot) *AccountUpdateOne {
+// AddAccountSnapshots adds the "account_snapshots" edges to the AccountSnapshot entity.
+func (auo *AccountUpdateOne) AddAccountSnapshots(a ...*AccountSnapshot) *AccountUpdateOne {
 	ids := make([]string, len(a))
 	for i := range a {
 		ids[i] = a[i].ID
 	}
-	return auo.AddAchievementSnapshotIDs(ids...)
+	return auo.AddAccountSnapshotIDs(ids...)
 }
 
 // Mutation returns the AccountMutation object of the builder.
@@ -683,25 +683,25 @@ func (auo *AccountUpdateOne) ClearClan() *AccountUpdateOne {
 	return auo
 }
 
-// ClearAccountSnapshots clears all "account_snapshots" edges to the AccountSnapshot entity.
-func (auo *AccountUpdateOne) ClearAccountSnapshots() *AccountUpdateOne {
-	auo.mutation.ClearAccountSnapshots()
+// ClearAchievementSnapshots clears all "achievement_snapshots" edges to the AchievementsSnapshot entity.
+func (auo *AccountUpdateOne) ClearAchievementSnapshots() *AccountUpdateOne {
+	auo.mutation.ClearAchievementSnapshots()
 	return auo
 }
 
-// RemoveAccountSnapshotIDs removes the "account_snapshots" edge to AccountSnapshot entities by IDs.
-func (auo *AccountUpdateOne) RemoveAccountSnapshotIDs(ids ...string) *AccountUpdateOne {
-	auo.mutation.RemoveAccountSnapshotIDs(ids...)
+// RemoveAchievementSnapshotIDs removes the "achievement_snapshots" edge to AchievementsSnapshot entities by IDs.
+func (auo *AccountUpdateOne) RemoveAchievementSnapshotIDs(ids ...string) *AccountUpdateOne {
+	auo.mutation.RemoveAchievementSnapshotIDs(ids...)
 	return auo
 }
 
-// RemoveAccountSnapshots removes "account_snapshots" edges to AccountSnapshot entities.
-func (auo *AccountUpdateOne) RemoveAccountSnapshots(a ...*AccountSnapshot) *AccountUpdateOne {
+// RemoveAchievementSnapshots removes "achievement_snapshots" edges to AchievementsSnapshot entities.
+func (auo *AccountUpdateOne) RemoveAchievementSnapshots(a ...*AchievementsSnapshot) *AccountUpdateOne {
 	ids := make([]string, len(a))
 	for i := range a {
 		ids[i] = a[i].ID
 	}
-	return auo.RemoveAccountSnapshotIDs(ids...)
+	return auo.RemoveAchievementSnapshotIDs(ids...)
 }
 
 // ClearVehicleSnapshots clears all "vehicle_snapshots" edges to the VehicleSnapshot entity.
@@ -725,25 +725,25 @@ func (auo *AccountUpdateOne) RemoveVehicleSnapshots(v ...*VehicleSnapshot) *Acco
 	return auo.RemoveVehicleSnapshotIDs(ids...)
 }
 
-// ClearAchievementSnapshots clears all "achievement_snapshots" edges to the AchievementsSnapshot entity.
-func (auo *AccountUpdateOne) ClearAchievementSnapshots() *AccountUpdateOne {
-	auo.mutation.ClearAchievementSnapshots()
+// ClearAccountSnapshots clears all "account_snapshots" edges to the AccountSnapshot entity.
+func (auo *AccountUpdateOne) ClearAccountSnapshots() *AccountUpdateOne {
+	auo.mutation.ClearAccountSnapshots()
 	return auo
 }
 
-// RemoveAchievementSnapshotIDs removes the "achievement_snapshots" edge to AchievementsSnapshot entities by IDs.
-func (auo *AccountUpdateOne) RemoveAchievementSnapshotIDs(ids ...string) *AccountUpdateOne {
-	auo.mutation.RemoveAchievementSnapshotIDs(ids...)
+// RemoveAccountSnapshotIDs removes the "account_snapshots" edge to AccountSnapshot entities by IDs.
+func (auo *AccountUpdateOne) RemoveAccountSnapshotIDs(ids ...string) *AccountUpdateOne {
+	auo.mutation.RemoveAccountSnapshotIDs(ids...)
 	return auo
 }
 
-// RemoveAchievementSnapshots removes "achievement_snapshots" edges to AchievementsSnapshot entities.
-func (auo *AccountUpdateOne) RemoveAchievementSnapshots(a ...*AchievementsSnapshot) *AccountUpdateOne {
+// RemoveAccountSnapshots removes "account_snapshots" edges to AccountSnapshot entities.
+func (auo *AccountUpdateOne) RemoveAccountSnapshots(a ...*AccountSnapshot) *AccountUpdateOne {
 	ids := make([]string, len(a))
 	for i := range a {
 		ids[i] = a[i].ID
 	}
-	return auo.RemoveAchievementSnapshotIDs(ids...)
+	return auo.RemoveAccountSnapshotIDs(ids...)
 }
 
 // Where appends a list predicates to the AccountUpdate builder.
@@ -892,28 +892,28 @@ func (auo *AccountUpdateOne) sqlSave(ctx context.Context) (_node *Account, err e
 		}
 		_spec.Edges.Add = append(_spec.Edges.Add, edge)
 	}
-	if auo.mutation.AccountSnapshotsCleared() {
+	if auo.mutation.AchievementSnapshotsCleared() {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,
 			Inverse: false,
-			Table:   account.AccountSnapshotsTable,
-			Columns: []string{account.AccountSnapshotsColumn},
+			Table:   account.AchievementSnapshotsTable,
+			Columns: []string{account.AchievementSnapshotsColumn},
 			Bidi:    false,
 			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(accountsnapshot.FieldID, field.TypeString),
+				IDSpec: sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString),
 			},
 		}
 		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
 	}
-	if nodes := auo.mutation.RemovedAccountSnapshotsIDs(); len(nodes) > 0 && !auo.mutation.AccountSnapshotsCleared() {
+	if nodes := auo.mutation.RemovedAchievementSnapshotsIDs(); len(nodes) > 0 && !auo.mutation.AchievementSnapshotsCleared() {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,
 			Inverse: false,
-			Table:   account.AccountSnapshotsTable,
-			Columns: []string{account.AccountSnapshotsColumn},
+			Table:   account.AchievementSnapshotsTable,
+			Columns: []string{account.AchievementSnapshotsColumn},
 			Bidi:    false,
 			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(accountsnapshot.FieldID, field.TypeString),
+				IDSpec: sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString),
 			},
 		}
 		for _, k := range nodes {
@@ -921,15 +921,15 @@ func (auo *AccountUpdateOne) sqlSave(ctx context.Context) (_node *Account, err e
 		}
 		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
 	}
-	if nodes := auo.mutation.AccountSnapshotsIDs(); len(nodes) > 0 {
+	if nodes := auo.mutation.AchievementSnapshotsIDs(); len(nodes) > 0 {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,
 			Inverse: false,
-			Table:   account.AccountSnapshotsTable,
-			Columns: []string{account.AccountSnapshotsColumn},
+			Table:   account.AchievementSnapshotsTable,
+			Columns: []string{account.AchievementSnapshotsColumn},
 			Bidi:    false,
 			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(accountsnapshot.FieldID, field.TypeString),
+				IDSpec: sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString),
 			},
 		}
 		for _, k := range nodes {
@@ -982,28 +982,28 @@ func (auo *AccountUpdateOne) sqlSave(ctx context.Context) (_node *Account, err e
 		}
 		_spec.Edges.Add = append(_spec.Edges.Add, edge)
 	}
-	if auo.mutation.AchievementSnapshotsCleared() {
+	if auo.mutation.AccountSnapshotsCleared() {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,
 			Inverse: false,
-			Table:   account.AchievementSnapshotsTable,
-			Columns: []string{account.AchievementSnapshotsColumn},
+			Table:   account.AccountSnapshotsTable,
+			Columns: []string{account.AccountSnapshotsColumn},
 			Bidi:    false,
 			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString),
+				IDSpec: sqlgraph.NewFieldSpec(accountsnapshot.FieldID, field.TypeString),
 			},
 		}
 		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
 	}
-	if nodes := auo.mutation.RemovedAchievementSnapshotsIDs(); len(nodes) > 0 && !auo.mutation.AchievementSnapshotsCleared() {
+	if nodes := auo.mutation.RemovedAccountSnapshotsIDs(); len(nodes) > 0 && !auo.mutation.AccountSnapshotsCleared() {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,
 			Inverse: false,
-			Table:   account.AchievementSnapshotsTable,
-			Columns: []string{account.AchievementSnapshotsColumn},
+			Table:   account.AccountSnapshotsTable,
+			Columns: []string{account.AccountSnapshotsColumn},
 			Bidi:    false,
 			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString),
+				IDSpec: sqlgraph.NewFieldSpec(accountsnapshot.FieldID, field.TypeString),
 			},
 		}
 		for _, k := range nodes {
@@ -1011,15 +1011,15 @@ func (auo *AccountUpdateOne) sqlSave(ctx context.Context) (_node *Account, err e
 		}
 		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
 	}
-	if nodes := auo.mutation.AchievementSnapshotsIDs(); len(nodes) > 0 {
+	if nodes := auo.mutation.AccountSnapshotsIDs(); len(nodes) > 0 {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,
 			Inverse: false,
-			Table:   account.AchievementSnapshotsTable,
-			Columns: []string{account.AchievementSnapshotsColumn},
+			Table:   account.AccountSnapshotsTable,
+			Columns: []string{account.AccountSnapshotsColumn},
 			Bidi:    false,
 			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString),
+				IDSpec: sqlgraph.NewFieldSpec(accountsnapshot.FieldID, field.TypeString),
 			},
 		}
 		for _, k := range nodes {
diff --git a/internal/database/ent/db/client.go b/internal/database/ent/db/client.go
index e77ab304..2d0eb667 100644
--- a/internal/database/ent/db/client.go
+++ b/internal/database/ent/db/client.go
@@ -449,15 +449,15 @@ func (c *AccountClient) QueryClan(a *Account) *ClanQuery {
 	return query
 }
 
-// QueryAccountSnapshots queries the account_snapshots edge of a Account.
-func (c *AccountClient) QueryAccountSnapshots(a *Account) *AccountSnapshotQuery {
-	query := (&AccountSnapshotClient{config: c.config}).Query()
+// QueryAchievementSnapshots queries the achievement_snapshots edge of a Account.
+func (c *AccountClient) QueryAchievementSnapshots(a *Account) *AchievementsSnapshotQuery {
+	query := (&AchievementsSnapshotClient{config: c.config}).Query()
 	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
 		id := a.ID
 		step := sqlgraph.NewStep(
 			sqlgraph.From(account.Table, account.FieldID, id),
-			sqlgraph.To(accountsnapshot.Table, accountsnapshot.FieldID),
-			sqlgraph.Edge(sqlgraph.O2M, false, account.AccountSnapshotsTable, account.AccountSnapshotsColumn),
+			sqlgraph.To(achievementssnapshot.Table, achievementssnapshot.FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, account.AchievementSnapshotsTable, account.AchievementSnapshotsColumn),
 		)
 		fromV = sqlgraph.Neighbors(a.driver.Dialect(), step)
 		return fromV, nil
@@ -481,15 +481,15 @@ func (c *AccountClient) QueryVehicleSnapshots(a *Account) *VehicleSnapshotQuery
 	return query
 }
 
-// QueryAchievementSnapshots queries the achievement_snapshots edge of a Account.
-func (c *AccountClient) QueryAchievementSnapshots(a *Account) *AchievementsSnapshotQuery {
-	query := (&AchievementsSnapshotClient{config: c.config}).Query()
+// QueryAccountSnapshots queries the account_snapshots edge of a Account.
+func (c *AccountClient) QueryAccountSnapshots(a *Account) *AccountSnapshotQuery {
+	query := (&AccountSnapshotClient{config: c.config}).Query()
 	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
 		id := a.ID
 		step := sqlgraph.NewStep(
 			sqlgraph.From(account.Table, account.FieldID, id),
-			sqlgraph.To(achievementssnapshot.Table, achievementssnapshot.FieldID),
-			sqlgraph.Edge(sqlgraph.O2M, false, account.AchievementSnapshotsTable, account.AchievementSnapshotsColumn),
+			sqlgraph.To(accountsnapshot.Table, accountsnapshot.FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, account.AccountSnapshotsTable, account.AccountSnapshotsColumn),
 		)
 		fromV = sqlgraph.Neighbors(a.driver.Dialect(), step)
 		return fromV, nil
diff --git a/internal/database/ent/db/mutation.go b/internal/database/ent/db/mutation.go
index 23952010..15855c1d 100644
--- a/internal/database/ent/db/mutation.go
+++ b/internal/database/ent/db/mutation.go
@@ -74,15 +74,15 @@ type AccountMutation struct {
 	clearedFields                map[string]struct{}
 	clan                         *string
 	clearedclan                  bool
-	account_snapshots            map[string]struct{}
-	removedaccount_snapshots     map[string]struct{}
-	clearedaccount_snapshots     bool
-	vehicle_snapshots            map[string]struct{}
-	removedvehicle_snapshots     map[string]struct{}
-	clearedvehicle_snapshots     bool
 	achievement_snapshots        map[string]struct{}
 	removedachievement_snapshots map[string]struct{}
 	clearedachievement_snapshots bool
+	vehicle_snapshots            map[string]struct{}
+	removedvehicle_snapshots     map[string]struct{}
+	clearedvehicle_snapshots     bool
+	account_snapshots            map[string]struct{}
+	removedaccount_snapshots     map[string]struct{}
+	clearedaccount_snapshots     bool
 	done                         bool
 	oldValue                     func(context.Context) (*Account, error)
 	predicates                   []predicate.Account
@@ -520,58 +520,58 @@ func (m *AccountMutation) ResetClan() {
 	m.clearedclan = false
 }
 
-// AddAccountSnapshotIDs adds the "account_snapshots" edge to the AccountSnapshot entity by ids.
-func (m *AccountMutation) AddAccountSnapshotIDs(ids ...string) {
-	if m.account_snapshots == nil {
-		m.account_snapshots = make(map[string]struct{})
+// AddAchievementSnapshotIDs adds the "achievement_snapshots" edge to the AchievementsSnapshot entity by ids.
+func (m *AccountMutation) AddAchievementSnapshotIDs(ids ...string) {
+	if m.achievement_snapshots == nil {
+		m.achievement_snapshots = make(map[string]struct{})
 	}
 	for i := range ids {
-		m.account_snapshots[ids[i]] = struct{}{}
+		m.achievement_snapshots[ids[i]] = struct{}{}
 	}
 }
 
-// ClearAccountSnapshots clears the "account_snapshots" edge to the AccountSnapshot entity.
-func (m *AccountMutation) ClearAccountSnapshots() {
-	m.clearedaccount_snapshots = true
+// ClearAchievementSnapshots clears the "achievement_snapshots" edge to the AchievementsSnapshot entity.
+func (m *AccountMutation) ClearAchievementSnapshots() {
+	m.clearedachievement_snapshots = true
 }
 
-// AccountSnapshotsCleared reports if the "account_snapshots" edge to the AccountSnapshot entity was cleared.
-func (m *AccountMutation) AccountSnapshotsCleared() bool {
-	return m.clearedaccount_snapshots
+// AchievementSnapshotsCleared reports if the "achievement_snapshots" edge to the AchievementsSnapshot entity was cleared.
+func (m *AccountMutation) AchievementSnapshotsCleared() bool {
+	return m.clearedachievement_snapshots
 }
 
-// RemoveAccountSnapshotIDs removes the "account_snapshots" edge to the AccountSnapshot entity by IDs.
-func (m *AccountMutation) RemoveAccountSnapshotIDs(ids ...string) {
-	if m.removedaccount_snapshots == nil {
-		m.removedaccount_snapshots = make(map[string]struct{})
+// RemoveAchievementSnapshotIDs removes the "achievement_snapshots" edge to the AchievementsSnapshot entity by IDs.
+func (m *AccountMutation) RemoveAchievementSnapshotIDs(ids ...string) {
+	if m.removedachievement_snapshots == nil {
+		m.removedachievement_snapshots = make(map[string]struct{})
 	}
 	for i := range ids {
-		delete(m.account_snapshots, ids[i])
-		m.removedaccount_snapshots[ids[i]] = struct{}{}
+		delete(m.achievement_snapshots, ids[i])
+		m.removedachievement_snapshots[ids[i]] = struct{}{}
 	}
 }
 
-// RemovedAccountSnapshots returns the removed IDs of the "account_snapshots" edge to the AccountSnapshot entity.
-func (m *AccountMutation) RemovedAccountSnapshotsIDs() (ids []string) {
-	for id := range m.removedaccount_snapshots {
+// RemovedAchievementSnapshots returns the removed IDs of the "achievement_snapshots" edge to the AchievementsSnapshot entity.
+func (m *AccountMutation) RemovedAchievementSnapshotsIDs() (ids []string) {
+	for id := range m.removedachievement_snapshots {
 		ids = append(ids, id)
 	}
 	return
 }
 
-// AccountSnapshotsIDs returns the "account_snapshots" edge IDs in the mutation.
-func (m *AccountMutation) AccountSnapshotsIDs() (ids []string) {
-	for id := range m.account_snapshots {
+// AchievementSnapshotsIDs returns the "achievement_snapshots" edge IDs in the mutation.
+func (m *AccountMutation) AchievementSnapshotsIDs() (ids []string) {
+	for id := range m.achievement_snapshots {
 		ids = append(ids, id)
 	}
 	return
 }
 
-// ResetAccountSnapshots resets all changes to the "account_snapshots" edge.
-func (m *AccountMutation) ResetAccountSnapshots() {
-	m.account_snapshots = nil
-	m.clearedaccount_snapshots = false
-	m.removedaccount_snapshots = nil
+// ResetAchievementSnapshots resets all changes to the "achievement_snapshots" edge.
+func (m *AccountMutation) ResetAchievementSnapshots() {
+	m.achievement_snapshots = nil
+	m.clearedachievement_snapshots = false
+	m.removedachievement_snapshots = nil
 }
 
 // AddVehicleSnapshotIDs adds the "vehicle_snapshots" edge to the VehicleSnapshot entity by ids.
@@ -628,58 +628,58 @@ func (m *AccountMutation) ResetVehicleSnapshots() {
 	m.removedvehicle_snapshots = nil
 }
 
-// AddAchievementSnapshotIDs adds the "achievement_snapshots" edge to the AchievementsSnapshot entity by ids.
-func (m *AccountMutation) AddAchievementSnapshotIDs(ids ...string) {
-	if m.achievement_snapshots == nil {
-		m.achievement_snapshots = make(map[string]struct{})
+// AddAccountSnapshotIDs adds the "account_snapshots" edge to the AccountSnapshot entity by ids.
+func (m *AccountMutation) AddAccountSnapshotIDs(ids ...string) {
+	if m.account_snapshots == nil {
+		m.account_snapshots = make(map[string]struct{})
 	}
 	for i := range ids {
-		m.achievement_snapshots[ids[i]] = struct{}{}
+		m.account_snapshots[ids[i]] = struct{}{}
 	}
 }
 
-// ClearAchievementSnapshots clears the "achievement_snapshots" edge to the AchievementsSnapshot entity.
-func (m *AccountMutation) ClearAchievementSnapshots() {
-	m.clearedachievement_snapshots = true
+// ClearAccountSnapshots clears the "account_snapshots" edge to the AccountSnapshot entity.
+func (m *AccountMutation) ClearAccountSnapshots() {
+	m.clearedaccount_snapshots = true
 }
 
-// AchievementSnapshotsCleared reports if the "achievement_snapshots" edge to the AchievementsSnapshot entity was cleared.
-func (m *AccountMutation) AchievementSnapshotsCleared() bool {
-	return m.clearedachievement_snapshots
+// AccountSnapshotsCleared reports if the "account_snapshots" edge to the AccountSnapshot entity was cleared.
+func (m *AccountMutation) AccountSnapshotsCleared() bool {
+	return m.clearedaccount_snapshots
 }
 
-// RemoveAchievementSnapshotIDs removes the "achievement_snapshots" edge to the AchievementsSnapshot entity by IDs.
-func (m *AccountMutation) RemoveAchievementSnapshotIDs(ids ...string) {
-	if m.removedachievement_snapshots == nil {
-		m.removedachievement_snapshots = make(map[string]struct{})
+// RemoveAccountSnapshotIDs removes the "account_snapshots" edge to the AccountSnapshot entity by IDs.
+func (m *AccountMutation) RemoveAccountSnapshotIDs(ids ...string) {
+	if m.removedaccount_snapshots == nil {
+		m.removedaccount_snapshots = make(map[string]struct{})
 	}
 	for i := range ids {
-		delete(m.achievement_snapshots, ids[i])
-		m.removedachievement_snapshots[ids[i]] = struct{}{}
+		delete(m.account_snapshots, ids[i])
+		m.removedaccount_snapshots[ids[i]] = struct{}{}
 	}
 }
 
-// RemovedAchievementSnapshots returns the removed IDs of the "achievement_snapshots" edge to the AchievementsSnapshot entity.
-func (m *AccountMutation) RemovedAchievementSnapshotsIDs() (ids []string) {
-	for id := range m.removedachievement_snapshots {
+// RemovedAccountSnapshots returns the removed IDs of the "account_snapshots" edge to the AccountSnapshot entity.
+func (m *AccountMutation) RemovedAccountSnapshotsIDs() (ids []string) {
+	for id := range m.removedaccount_snapshots {
 		ids = append(ids, id)
 	}
 	return
 }
 
-// AchievementSnapshotsIDs returns the "achievement_snapshots" edge IDs in the mutation.
-func (m *AccountMutation) AchievementSnapshotsIDs() (ids []string) {
-	for id := range m.achievement_snapshots {
+// AccountSnapshotsIDs returns the "account_snapshots" edge IDs in the mutation.
+func (m *AccountMutation) AccountSnapshotsIDs() (ids []string) {
+	for id := range m.account_snapshots {
 		ids = append(ids, id)
 	}
 	return
 }
 
-// ResetAchievementSnapshots resets all changes to the "achievement_snapshots" edge.
-func (m *AccountMutation) ResetAchievementSnapshots() {
-	m.achievement_snapshots = nil
-	m.clearedachievement_snapshots = false
-	m.removedachievement_snapshots = nil
+// ResetAccountSnapshots resets all changes to the "account_snapshots" edge.
+func (m *AccountMutation) ResetAccountSnapshots() {
+	m.account_snapshots = nil
+	m.clearedaccount_snapshots = false
+	m.removedaccount_snapshots = nil
 }
 
 // Where appends a list predicates to the AccountMutation builder.
@@ -947,14 +947,14 @@ func (m *AccountMutation) AddedEdges() []string {
 	if m.clan != nil {
 		edges = append(edges, account.EdgeClan)
 	}
-	if m.account_snapshots != nil {
-		edges = append(edges, account.EdgeAccountSnapshots)
+	if m.achievement_snapshots != nil {
+		edges = append(edges, account.EdgeAchievementSnapshots)
 	}
 	if m.vehicle_snapshots != nil {
 		edges = append(edges, account.EdgeVehicleSnapshots)
 	}
-	if m.achievement_snapshots != nil {
-		edges = append(edges, account.EdgeAchievementSnapshots)
+	if m.account_snapshots != nil {
+		edges = append(edges, account.EdgeAccountSnapshots)
 	}
 	return edges
 }
@@ -967,9 +967,9 @@ func (m *AccountMutation) AddedIDs(name string) []ent.Value {
 		if id := m.clan; id != nil {
 			return []ent.Value{*id}
 		}
-	case account.EdgeAccountSnapshots:
-		ids := make([]ent.Value, 0, len(m.account_snapshots))
-		for id := range m.account_snapshots {
+	case account.EdgeAchievementSnapshots:
+		ids := make([]ent.Value, 0, len(m.achievement_snapshots))
+		for id := range m.achievement_snapshots {
 			ids = append(ids, id)
 		}
 		return ids
@@ -979,9 +979,9 @@ func (m *AccountMutation) AddedIDs(name string) []ent.Value {
 			ids = append(ids, id)
 		}
 		return ids
-	case account.EdgeAchievementSnapshots:
-		ids := make([]ent.Value, 0, len(m.achievement_snapshots))
-		for id := range m.achievement_snapshots {
+	case account.EdgeAccountSnapshots:
+		ids := make([]ent.Value, 0, len(m.account_snapshots))
+		for id := range m.account_snapshots {
 			ids = append(ids, id)
 		}
 		return ids
@@ -992,14 +992,14 @@ func (m *AccountMutation) AddedIDs(name string) []ent.Value {
 // RemovedEdges returns all edge names that were removed in this mutation.
 func (m *AccountMutation) RemovedEdges() []string {
 	edges := make([]string, 0, 4)
-	if m.removedaccount_snapshots != nil {
-		edges = append(edges, account.EdgeAccountSnapshots)
+	if m.removedachievement_snapshots != nil {
+		edges = append(edges, account.EdgeAchievementSnapshots)
 	}
 	if m.removedvehicle_snapshots != nil {
 		edges = append(edges, account.EdgeVehicleSnapshots)
 	}
-	if m.removedachievement_snapshots != nil {
-		edges = append(edges, account.EdgeAchievementSnapshots)
+	if m.removedaccount_snapshots != nil {
+		edges = append(edges, account.EdgeAccountSnapshots)
 	}
 	return edges
 }
@@ -1008,9 +1008,9 @@ func (m *AccountMutation) RemovedEdges() []string {
 // the given name in this mutation.
 func (m *AccountMutation) RemovedIDs(name string) []ent.Value {
 	switch name {
-	case account.EdgeAccountSnapshots:
-		ids := make([]ent.Value, 0, len(m.removedaccount_snapshots))
-		for id := range m.removedaccount_snapshots {
+	case account.EdgeAchievementSnapshots:
+		ids := make([]ent.Value, 0, len(m.removedachievement_snapshots))
+		for id := range m.removedachievement_snapshots {
 			ids = append(ids, id)
 		}
 		return ids
@@ -1020,9 +1020,9 @@ func (m *AccountMutation) RemovedIDs(name string) []ent.Value {
 			ids = append(ids, id)
 		}
 		return ids
-	case account.EdgeAchievementSnapshots:
-		ids := make([]ent.Value, 0, len(m.removedachievement_snapshots))
-		for id := range m.removedachievement_snapshots {
+	case account.EdgeAccountSnapshots:
+		ids := make([]ent.Value, 0, len(m.removedaccount_snapshots))
+		for id := range m.removedaccount_snapshots {
 			ids = append(ids, id)
 		}
 		return ids
@@ -1036,14 +1036,14 @@ func (m *AccountMutation) ClearedEdges() []string {
 	if m.clearedclan {
 		edges = append(edges, account.EdgeClan)
 	}
-	if m.clearedaccount_snapshots {
-		edges = append(edges, account.EdgeAccountSnapshots)
+	if m.clearedachievement_snapshots {
+		edges = append(edges, account.EdgeAchievementSnapshots)
 	}
 	if m.clearedvehicle_snapshots {
 		edges = append(edges, account.EdgeVehicleSnapshots)
 	}
-	if m.clearedachievement_snapshots {
-		edges = append(edges, account.EdgeAchievementSnapshots)
+	if m.clearedaccount_snapshots {
+		edges = append(edges, account.EdgeAccountSnapshots)
 	}
 	return edges
 }
@@ -1054,12 +1054,12 @@ func (m *AccountMutation) EdgeCleared(name string) bool {
 	switch name {
 	case account.EdgeClan:
 		return m.clearedclan
-	case account.EdgeAccountSnapshots:
-		return m.clearedaccount_snapshots
-	case account.EdgeVehicleSnapshots:
-		return m.clearedvehicle_snapshots
 	case account.EdgeAchievementSnapshots:
 		return m.clearedachievement_snapshots
+	case account.EdgeVehicleSnapshots:
+		return m.clearedvehicle_snapshots
+	case account.EdgeAccountSnapshots:
+		return m.clearedaccount_snapshots
 	}
 	return false
 }
@@ -1082,14 +1082,14 @@ func (m *AccountMutation) ResetEdge(name string) error {
 	case account.EdgeClan:
 		m.ResetClan()
 		return nil
-	case account.EdgeAccountSnapshots:
-		m.ResetAccountSnapshots()
+	case account.EdgeAchievementSnapshots:
+		m.ResetAchievementSnapshots()
 		return nil
 	case account.EdgeVehicleSnapshots:
 		m.ResetVehicleSnapshots()
 		return nil
-	case account.EdgeAchievementSnapshots:
-		m.ResetAchievementSnapshots()
+	case account.EdgeAccountSnapshots:
+		m.ResetAccountSnapshots()
 		return nil
 	}
 	return fmt.Errorf("unknown Account edge %s", name)

From d9beec8a72d58199dd6f2364caaff4cb43f17b65 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Tue, 2 Jul 2024 20:57:56 -0400
Subject: [PATCH 242/341] removed old comment

---
 main.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/main.go b/main.go
index aad48955..db951222 100644
--- a/main.go
+++ b/main.go
@@ -39,7 +39,6 @@ import (
 
 	"net/http"
 	"net/http/pprof"
-	//  "github.com/pkg/profile"
 )
 
 //go:generate go generate ./internal/database/ent

From 2f7eb20de129a497645780b51724b740626ba726 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Tue, 2 Jul 2024 21:00:15 -0400
Subject: [PATCH 243/341] always passing background

---
 internal/stats/client/v1/options.go | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/internal/stats/client/v1/options.go b/internal/stats/client/v1/options.go
index 26cdbb4f..363d2074 100644
--- a/internal/stats/client/v1/options.go
+++ b/internal/stats/client/v1/options.go
@@ -37,9 +37,7 @@ func (o requestOptions) RenderOpts() []common.Option {
 	if o.promoText != nil {
 		copts = append(copts, common.WithPromoText(o.promoText...))
 	}
-	if o.backgroundURL != "" {
-		copts = append(copts, common.WithBackground(o.backgroundURL))
-	}
+	copts = append(copts, common.WithBackground(o.backgroundURL))
 	return copts
 }
 

From c74c2e01d494d95ab71f2e12ef356bc9532e9b29 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Tue, 2 Jul 2024 21:03:27 -0400
Subject: [PATCH 244/341] added back WN8

---
 cmd/discord/commands/interactions.go          | 4 ++--
 cmd/discord/commands/session.go               | 2 +-
 cmd/discord/commands/stats.go                 | 2 +-
 cmd/frontend/routes/widget/configure.templ    | 3 ++-
 cmd/frontend/routes/widget/configure_templ.go | 5 +++--
 cmd/frontend/routes/widget/live.templ         | 2 +-
 cmd/frontend/routes/widget/live_templ.go      | 2 +-
 7 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/cmd/discord/commands/interactions.go b/cmd/discord/commands/interactions.go
index a06720ae..4c52ebca 100644
--- a/cmd/discord/commands/interactions.go
+++ b/cmd/discord/commands/interactions.go
@@ -57,7 +57,7 @@ func init() {
 				var meta stats.Metadata
 				switch interaction.Command {
 				case "stats":
-					img, mt, err := ctx.Core.Stats(ctx.Locale).PeriodImage(context.Background(), interaction.Options.AccountID, interaction.Options.PeriodStart, stats.WithBackgroundURL(interaction.Options.BackgroundImageURL))
+					img, mt, err := ctx.Core.Stats(ctx.Locale).PeriodImage(context.Background(), interaction.Options.AccountID, interaction.Options.PeriodStart, stats.WithBackgroundURL(interaction.Options.BackgroundImageURL), stats.WithWN8())
 					if err != nil {
 						return ctx.Err(err)
 					}
@@ -65,7 +65,7 @@ func init() {
 					meta = mt
 
 				case "session":
-					img, mt, err := ctx.Core.Stats(ctx.Locale).SessionImage(context.Background(), interaction.Options.AccountID, interaction.Options.PeriodStart, stats.WithBackgroundURL(interaction.Options.BackgroundImageURL))
+					img, mt, err := ctx.Core.Stats(ctx.Locale).SessionImage(context.Background(), interaction.Options.AccountID, interaction.Options.PeriodStart, stats.WithBackgroundURL(interaction.Options.BackgroundImageURL), stats.WithWN8())
 					if err != nil {
 						if errors.Is(err, fetch.ErrSessionNotFound) || errors.Is(err, stats.ErrAccountNotTracked) {
 							return ctx.Reply().Send("stats_refresh_interaction_error_expired")
diff --git a/cmd/discord/commands/session.go b/cmd/discord/commands/session.go
index 23a709db..3d04e0b7 100644
--- a/cmd/discord/commands/session.go
+++ b/cmd/discord/commands/session.go
@@ -69,7 +69,7 @@ func init() {
 					}
 				}
 
-				image, meta, err := ctx.Core.Stats(ctx.Locale).SessionImage(context.Background(), accountID, options.PeriodStart, stats.WithBackgroundURL(backgroundURL))
+				image, meta, err := ctx.Core.Stats(ctx.Locale).SessionImage(context.Background(), accountID, options.PeriodStart, stats.WithBackgroundURL(backgroundURL), stats.WithWN8())
 				if err != nil {
 					if errors.Is(err, stats.ErrAccountNotTracked) || (errors.Is(err, fetch.ErrSessionNotFound) && options.Days < 1) {
 						return ctx.Reply().Send("session_error_account_was_not_tracked")
diff --git a/cmd/discord/commands/stats.go b/cmd/discord/commands/stats.go
index 3483ea2c..b1a62021 100644
--- a/cmd/discord/commands/stats.go
+++ b/cmd/discord/commands/stats.go
@@ -61,7 +61,7 @@ func init() {
 					// TODO: Get user background
 				}
 
-				image, meta, err := ctx.Core.Stats(ctx.Locale).PeriodImage(context.Background(), accountID, options.PeriodStart, stats.WithBackgroundURL(backgroundURL))
+				image, meta, err := ctx.Core.Stats(ctx.Locale).PeriodImage(context.Background(), accountID, options.PeriodStart, stats.WithBackgroundURL(backgroundURL), stats.WithWN8())
 				if err != nil {
 					return ctx.Err(err)
 				}
diff --git a/cmd/frontend/routes/widget/configure.templ b/cmd/frontend/routes/widget/configure.templ
index 0019d498..9f88403b 100644
--- a/cmd/frontend/routes/widget/configure.templ
+++ b/cmd/frontend/routes/widget/configure.templ
@@ -3,6 +3,7 @@ package widget
 import "github.com/cufee/aftermath/cmd/frontend/handler"
 import "github.com/cufee/aftermath/cmd/frontend/layouts"
 import "github.com/cufee/aftermath/cmd/frontend/components/widget"
+import "github.com/cufee/aftermath/internal/stats/client/v1"
 import "golang.org/x/text/language"
 import "time"
 import "github.com/pkg/errors"
@@ -19,7 +20,7 @@ var ConfigureWidget handler.Page = func(ctx *handler.Context) (handler.Layout, t
 		return nil, nil, errors.New("invalid account id")
 	}
 
-	cards, _, err := ctx.Client.Stats(language.English).SessionCards(context.Background(), account.ID, time.Now())
+	cards, _, err := ctx.Client.Stats(language.English).SessionCards(context.Background(), account.ID, time.Now(), client.WithWN8())
 	if err != nil {
 		return nil, nil, err
 	}
diff --git a/cmd/frontend/routes/widget/configure_templ.go b/cmd/frontend/routes/widget/configure_templ.go
index 15b2e371..b353aef5 100644
--- a/cmd/frontend/routes/widget/configure_templ.go
+++ b/cmd/frontend/routes/widget/configure_templ.go
@@ -13,6 +13,7 @@ import "bytes"
 import "github.com/cufee/aftermath/cmd/frontend/handler"
 import "github.com/cufee/aftermath/cmd/frontend/layouts"
 import "github.com/cufee/aftermath/cmd/frontend/components/widget"
+import "github.com/cufee/aftermath/internal/stats/client/v1"
 import "golang.org/x/text/language"
 import "time"
 import "github.com/pkg/errors"
@@ -29,7 +30,7 @@ var ConfigureWidget handler.Page = func(ctx *handler.Context) (handler.Layout, t
 		return nil, nil, errors.New("invalid account id")
 	}
 
-	cards, _, err := ctx.Client.Stats(language.English).SessionCards(context.Background(), account.ID, time.Now())
+	cards, _, err := ctx.Client.Stats(language.English).SessionCards(context.Background(), account.ID, time.Now(), client.WithWN8())
 	if err != nil {
 		return nil, nil, err
 	}
@@ -62,7 +63,7 @@ func configureWidgetPage(widget templ.Component) templ.Component {
 			var templ_7745c5c3_Var2 string
 			templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprint(i))
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/widget/configure.templ`, Line: 47, Col: 31}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/widget/configure.templ`, Line: 48, Col: 31}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
 			if templ_7745c5c3_Err != nil {
diff --git a/cmd/frontend/routes/widget/live.templ b/cmd/frontend/routes/widget/live.templ
index 34e4f295..e8a3f723 100644
--- a/cmd/frontend/routes/widget/live.templ
+++ b/cmd/frontend/routes/widget/live.templ
@@ -21,7 +21,7 @@ var LiveWidget handler.Page = func(ctx *handler.Context) (handler.Layout, templ.
 		return nil, nil, errors.New("invalid account id")
 	}
 
-	var opts []client.RequestOption
+	var opts  = []client.RequestOption{client.WithWN8()}
 	if ref := ctx.Req().URL.Query().Get("ref"); ref != "" {
 		opts = append(opts, client.WithReferenceID(ref))
 	}
diff --git a/cmd/frontend/routes/widget/live_templ.go b/cmd/frontend/routes/widget/live_templ.go
index 1b66362b..994c9045 100644
--- a/cmd/frontend/routes/widget/live_templ.go
+++ b/cmd/frontend/routes/widget/live_templ.go
@@ -31,7 +31,7 @@ var LiveWidget handler.Page = func(ctx *handler.Context) (handler.Layout, templ.
 		return nil, nil, errors.New("invalid account id")
 	}
 
-	var opts []client.RequestOption
+	var opts = []client.RequestOption{client.WithWN8()}
 	if ref := ctx.Req().URL.Query().Get("ref"); ref != "" {
 		opts = append(opts, client.WithReferenceID(ref))
 	}

From 967a767017c0bae7eece12d7dba6f74d4a1aef27 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Tue, 2 Jul 2024 21:04:14 -0400
Subject: [PATCH 245/341] unused write

---
 internal/stats/render/session/v1/blocks.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/internal/stats/render/session/v1/blocks.go b/internal/stats/render/session/v1/blocks.go
index 64ff1315..0322c06c 100644
--- a/internal/stats/render/session/v1/blocks.go
+++ b/internal/stats/render/session/v1/blocks.go
@@ -65,7 +65,6 @@ func blankBlock(width, height float64) common.Block {
 func vehicleWN8Icon(wn8 frame.Value) common.Block {
 	ratingColors := common.GetWN8Colors(wn8.Float())
 	if wn8.Float() <= 0 {
-		ratingColors.Content = common.TextAlt
 		ratingColors.Background = common.TextAlt
 	}
 	iconTop := common.AftermathLogo(ratingColors.Background, common.SmallLogoOptions())

From ddeb4de4778f089cf6d41ff17c34a8923f33171a Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Wed, 3 Jul 2024 15:27:18 -0400
Subject: [PATCH 246/341] added discord auth

---
 .air.toml                                     |    4 +
 .air.web.toml                                 |    6 +-
 .env.example                                  |    5 +-
 cmd/frontend/handler/context.go               |  134 +-
 cmd/frontend/handler/errors.go                |    7 +
 cmd/frontend/handlers.go                      |   29 +-
 cmd/frontend/logic/auth/contants.go           |   20 +
 cmd/frontend/logic/auth/cookie.go             |   34 +
 cmd/frontend/logic/discord/oauth.go           |  107 +
 cmd/frontend/logic/discord/user.go            |   44 +
 cmd/frontend/middleware/auth.go               |   21 +
 cmd/frontend/routes/api/auth/discord.go       |   91 +
 cmd/frontend/routes/app/index.templ           |   21 +
 cmd/frontend/routes/app/index_templ.go        |   61 +
 cmd/frontend/routes/errors.templ              |    4 +-
 cmd/frontend/routes/errors_templ.go           |    4 +-
 cmd/frontend/routes/login.go                  |   36 +
 cmd/frontend/routes/widget/configure.templ    |    2 +-
 cmd/frontend/routes/widget/configure_templ.go |    2 +-
 cmd/frontend/routes/widget/live.templ         |    6 +-
 cmd/frontend/routes/widget/live_templ.go      |    6 +-
 go.sum                                        |   10 +
 internal/database/auth.go                     |  110 +
 internal/database/client.go                   |   12 +
 internal/database/ent/db/authnonce.go         |  177 +
 .../database/ent/db/authnonce/authnonce.go    |  107 +
 internal/database/ent/db/authnonce/where.go   |  370 ++
 internal/database/ent/db/authnonce_create.go  |  325 ++
 internal/database/ent/db/authnonce_delete.go  |   88 +
 internal/database/ent/db/authnonce_query.go   |  548 +++
 internal/database/ent/db/authnonce_update.go  |  280 ++
 internal/database/ent/db/client.go            |  334 +-
 internal/database/ent/db/ent.go               |    4 +
 internal/database/ent/db/expose.go            |   26 +
 internal/database/ent/db/hook/hook.go         |   24 +
 internal/database/ent/db/migrate/schema.go    |   78 +-
 internal/database/ent/db/mutation.go          | 3563 ++++++++++++-----
 .../database/ent/db/predicate/predicate.go    |    6 +
 internal/database/ent/db/runtime.go           |   52 +-
 internal/database/ent/db/session.go           |  193 +
 internal/database/ent/db/session/session.go   |  121 +
 internal/database/ent/db/session/where.go     |  379 ++
 internal/database/ent/db/session_create.go    |  329 ++
 internal/database/ent/db/session_delete.go    |   88 +
 internal/database/ent/db/session_query.go     |  627 +++
 internal/database/ent/db/session_update.go    |  302 ++
 internal/database/ent/db/tx.go                |    6 +
 internal/database/ent/db/user.go              |   31 +-
 internal/database/ent/db/user/user.go         |   40 +
 internal/database/ent/db/user/where.go        |   93 +
 internal/database/ent/db/user_create.go       |   57 +
 internal/database/ent/db/user_query.go        |   76 +-
 internal/database/ent/db/user_update.go       |  197 +
 .../ent/migrations/20240703151859.sql         |   22 +
 .../ent/migrations/20240703160454.sql         |    6 +
 .../ent/migrations/20240703160711.sql         |  142 +
 .../ent/migrations/20240703180358.sql         |    4 +
 internal/database/ent/migrations/atlas.sum    |    6 +-
 internal/database/ent/schema/account.go       |    7 +-
 internal/database/ent/schema/nonce.go         |   31 +
 internal/database/ent/schema/session.go       |   33 +
 internal/database/ent/schema/user.go          |   12 +-
 internal/database/models/nonce.go             |   34 +
 internal/database/models/session.go           |   35 +
 internal/logic/strings.go                     |   15 +
 tests/static_database.go                      |   23 +
 66 files changed, 8543 insertions(+), 1124 deletions(-)
 create mode 100644 cmd/frontend/handler/errors.go
 create mode 100644 cmd/frontend/logic/auth/contants.go
 create mode 100644 cmd/frontend/logic/auth/cookie.go
 create mode 100644 cmd/frontend/logic/discord/oauth.go
 create mode 100644 cmd/frontend/logic/discord/user.go
 create mode 100644 cmd/frontend/middleware/auth.go
 create mode 100644 cmd/frontend/routes/api/auth/discord.go
 create mode 100644 cmd/frontend/routes/app/index.templ
 create mode 100644 cmd/frontend/routes/app/index_templ.go
 create mode 100644 cmd/frontend/routes/login.go
 create mode 100644 internal/database/auth.go
 create mode 100644 internal/database/ent/db/authnonce.go
 create mode 100644 internal/database/ent/db/authnonce/authnonce.go
 create mode 100644 internal/database/ent/db/authnonce/where.go
 create mode 100644 internal/database/ent/db/authnonce_create.go
 create mode 100644 internal/database/ent/db/authnonce_delete.go
 create mode 100644 internal/database/ent/db/authnonce_query.go
 create mode 100644 internal/database/ent/db/authnonce_update.go
 create mode 100644 internal/database/ent/db/session.go
 create mode 100644 internal/database/ent/db/session/session.go
 create mode 100644 internal/database/ent/db/session/where.go
 create mode 100644 internal/database/ent/db/session_create.go
 create mode 100644 internal/database/ent/db/session_delete.go
 create mode 100644 internal/database/ent/db/session_query.go
 create mode 100644 internal/database/ent/db/session_update.go
 create mode 100644 internal/database/ent/migrations/20240703151859.sql
 create mode 100644 internal/database/ent/migrations/20240703160454.sql
 create mode 100644 internal/database/ent/migrations/20240703160711.sql
 create mode 100644 internal/database/ent/migrations/20240703180358.sql
 create mode 100644 internal/database/ent/schema/nonce.go
 create mode 100644 internal/database/ent/schema/session.go
 create mode 100644 internal/database/models/nonce.go
 create mode 100644 internal/database/models/session.go
 create mode 100644 internal/logic/strings.go

diff --git a/.air.toml b/.air.toml
index 9de18a51..86f040d7 100644
--- a/.air.toml
+++ b/.air.toml
@@ -9,3 +9,7 @@ stop_on_error = true
 enabled = true
 proxy_port = 8080
 app_port = 9092
+
+[log]
+# Only show main log (silences watcher, build, runner)
+main_only = false
diff --git a/.air.web.toml b/.air.web.toml
index 181cb47e..3b69524b 100644
--- a/.air.web.toml
+++ b/.air.web.toml
@@ -9,5 +9,9 @@ bin = "tmp/web"
 
 [proxy]
 enabled = true
-proxy_port = 8081
+proxy_port = 8080
 app_port = 9092
+
+[log]
+# Only show main log (silences watcher, build, runner)
+main_only = false
diff --git a/.env.example b/.env.example
index 79768cef..505e0f42 100644
--- a/.env.example
+++ b/.env.example
@@ -26,7 +26,10 @@ DISCORD_TOKEN=""
 DISCORD_PUBLIC_KEY=""
 DISCORD_PRIMARY_GUILD_ID="" # Discord ID of the primary guild, some features will be locked to this guild only
 DISCORD_ERROR_REPORT_WEBHOOK_URL="" # A Discord webhook URL for a channel where the bot should report errors
-
+DISCORD_AUTH_DEFAULT_SCOPES="guilds identify"
+DISCORD_AUTH_REDIRECT_URL=""
+DISCORD_AUTH_CLIENT_SECRET=""
+DISCORD_AUTH_CLIENT_ID=""
 # Optional components
 SCHEDULER_ENABLED="true" # Scheduler is responsible for refreshing glossary cache and recording sessions
 SCHEDULER_CONCURRENT_WORKERS="5" 
diff --git a/cmd/frontend/handler/context.go b/cmd/frontend/handler/context.go
index c6b39e94..956b2a9b 100644
--- a/cmd/frontend/handler/context.go
+++ b/cmd/frontend/handler/context.go
@@ -8,33 +8,112 @@ import (
 
 	"github.com/a-h/templ"
 	"github.com/cufee/aftermath/cmd/core"
+	"github.com/cufee/aftermath/cmd/frontend/logic/auth"
+	"github.com/pkg/errors"
+
+	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/logic"
 	"github.com/rs/zerolog/log"
 )
 
-type Renderable interface {
-	Render(ctx *Context) error
+type Servable interface {
+	Serve(ctx *Context) error
 }
 
+type Middleware func(ctx *Context, next func(ctx *Context) error) func(ctx *Context) error
+
 type Context struct {
 	core.Client
 	context.Context
 
+	user *models.User
+
 	w http.ResponseWriter
 	r *http.Request
 }
 
-func (ctx *Context) Req() *http.Request {
-	return ctx.r
+type Layout func(ctx *Context, children ...templ.Component) (templ.Component, error)
+type Page func(ctx *Context) (Layout, templ.Component, error)
+type Partial func(ctx *Context) (templ.Component, error)
+type Endpoint func(ctx *Context) error
+
+var (
+	_ Servable = new(Page)
+	_ Servable = new(Partial)
+	_ Servable = new(Endpoint)
+)
+
+func (ctx *Context) Cookie(key string) (*http.Cookie, error) {
+	return ctx.r.Cookie(key)
+}
+func (ctx *Context) SetCookie(cookie *http.Cookie) {
+	http.SetCookie(ctx.w, cookie)
+}
+func (ctx *Context) Query(key string) string {
+	return ctx.r.URL.Query().Get(key)
+}
+func (ctx *Context) Form(key string) string {
+	return ctx.r.Form.Get(key)
+}
+func (ctx *Context) Path(key string) string {
+	return ctx.r.PathValue(key)
+}
+func (ctx *Context) RealIP() (string, bool) {
+	if ip := ctx.r.Header.Get("X-Forwarded-For"); ip != "" {
+		return ip, true
+	}
+	if ip := ctx.r.RemoteAddr; ip != "" {
+		return ip, true
+	}
+	return "", false
+}
+
+/*
+Returns a stable identifier based on requestor ip address
+*/
+func (ctx *Context) Identifier() (string, error) {
+	if ip, ok := ctx.RealIP(); ok {
+		return logic.HashString(ip), nil
+	}
+	return "", errors.New("failed to extract ip address")
 }
 
-func (ctx *Context) Error(err error, context ...string) error {
+func (ctx *Context) SessionUser() (*models.User, error) {
+	if ctx.user != nil {
+		return ctx.user, nil
+	}
+
+	cookie, err := ctx.Cookie(auth.SessionCookieName)
+	if err != nil || cookie == nil {
+		return nil, ErrSessionNotFound
+	}
+	if cookie.Value == "" {
+		return nil, ErrSessionNotFound
+	}
 
+	user, err := ctx.Database().UserFromSession(ctx.Context, cookie.Value)
+	if err != nil {
+		if database.IsNotFound(err) {
+			return nil, ErrSessionNotFound
+		}
+		return nil, err
+	}
+
+	ctx.user = &user
+	return ctx.user, nil
+}
+
+/*
+Redirects a user to /error with an error message set as query param
+*/
+func (ctx *Context) Error(err error, context ...string) error {
 	query := make(url.Values)
 	if err != nil {
 		query.Set("message", err.Error())
 	}
 	if len(context) > 1 {
-		log.Err(err).Msg("error while rendering") // end user does not get any context, so we log the error instead
+		log.Err(err).Msg("error while serving") // end user does not get any context, so we log the error instead
 		query.Set("message", strings.Join(context, ", "))
 	}
 
@@ -42,19 +121,20 @@ func (ctx *Context) Error(err error, context ...string) error {
 	return nil // this would never cause an error
 }
 
+func (ctx *Context) Redirect(path string, code int) error {
+	http.Redirect(ctx.w, ctx.r, path, code)
+	return nil // this would never cause an error
+}
+
 func (ctx *Context) SetStatus(code int) {
 	ctx.w.WriteHeader(code)
 }
 
 func newContext(core core.Client, w http.ResponseWriter, r *http.Request) *Context {
-	return &Context{core, r.Context(), w, r}
+	return &Context{core, r.Context(), nil, w, r}
 }
 
-type Layout func(ctx *Context, children ...templ.Component) (templ.Component, error)
-
-type Partial func(ctx *Context) (templ.Component, error)
-
-func (partial Partial) Render(ctx *Context) error {
+func (partial Partial) Serve(ctx *Context) error {
 	content, err := partial(ctx)
 	if err != nil {
 		return ctx.Error(err)
@@ -68,13 +148,16 @@ func (partial Partial) Render(ctx *Context) error {
 	return nil
 }
 
-type Page func(ctx *Context) (Layout, templ.Component, error)
-
-func (page Page) Render(ctx *Context) error {
+func (page Page) Serve(ctx *Context) error {
 	layout, body, err := page(ctx)
 	if err != nil {
 		return ctx.Error(err, "failed to render the page")
 	}
+	if layout == nil && body == nil {
+		return nil
+	} else if layout == nil {
+		return body.Render(ctx.Context, ctx.w)
+	}
 
 	content, err := layout(ctx, body)
 	if err != nil {
@@ -89,12 +172,25 @@ func (page Page) Render(ctx *Context) error {
 	return nil
 }
 
-func Handler(core core.Client, content Renderable) http.HandlerFunc {
+func (endpoint Endpoint) Serve(ctx *Context) error {
+	err := endpoint(ctx)
+	if err != nil {
+		return ctx.Error(err, "internal server error")
+	}
+	return nil
+}
+
+func Chain(core core.Client, serve Servable, middleware ...Middleware) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		err := content.Render(newContext(core, w, r))
+		ctx := newContext(core, w, r)
+		chain := serve.Serve
+		for i := len(middleware) - 1; i >= 0; i-- {
+			chain = middleware[i](ctx, chain)
+		}
+		err := chain(ctx)
 		if err != nil {
-			// this should never be the case, we return an error to make early returns more convenient
-			log.Err(err).Msg("handler failed to render, this should never happen")
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			log.Err(err).Msg("unhandled error in handler chain, this should never happen")
 		}
 	}
 }
diff --git a/cmd/frontend/handler/errors.go b/cmd/frontend/handler/errors.go
new file mode 100644
index 00000000..7797aa50
--- /dev/null
+++ b/cmd/frontend/handler/errors.go
@@ -0,0 +1,7 @@
+package handler
+
+import "github.com/pkg/errors"
+
+var (
+	ErrSessionNotFound = errors.New("session not found")
+)
diff --git a/cmd/frontend/handlers.go b/cmd/frontend/handlers.go
index f0f3d89c..640d0341 100644
--- a/cmd/frontend/handlers.go
+++ b/cmd/frontend/handlers.go
@@ -9,7 +9,10 @@ import (
 	"github.com/cufee/aftermath/cmd/core"
 	"github.com/cufee/aftermath/cmd/core/server"
 	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/cmd/frontend/middleware"
 	"github.com/cufee/aftermath/cmd/frontend/routes"
+	"github.com/cufee/aftermath/cmd/frontend/routes/api/auth"
+	"github.com/cufee/aftermath/cmd/frontend/routes/app"
 	"github.com/cufee/aftermath/cmd/frontend/routes/widget"
 	"github.com/pkg/errors"
 )
@@ -30,7 +33,7 @@ func Handlers(core core.Client) ([]server.Handler, error) {
 	return []server.Handler{
 		// assets
 		{
-			Path: "GET /assets/{$}",
+			Path: get("/assets"),
 			Func: redirect("/"),
 		},
 		{
@@ -40,28 +43,40 @@ func Handlers(core core.Client) ([]server.Handler, error) {
 		// wildcard to catch all invalid requests
 		{
 			Path: "GET /{pathname...}",
-			Func: handler.Handler(core, routes.ErrorNotFound),
+			Func: handler.Chain(core, routes.ErrorNotFound),
 		},
 		// common routes
 		{
 			Path: get("/"),
-			Func: handler.Handler(core, routes.Index),
+			Func: handler.Chain(core, routes.Index),
 		},
 		{
 			Path: get("/error"),
-			Func: handler.Handler(core, routes.GenericError),
+			Func: handler.Chain(core, routes.GenericError),
+		},
+		{
+			Path: get("/login"),
+			Func: handler.Chain(core, routes.Login),
 		},
 		// widget
 		{
 			Path: get("/widget/{accountId}"),
-			Func: handler.Handler(core, widget.ConfigureWidget),
+			Func: handler.Chain(core, widget.ConfigureWidget),
 		},
 		{
 			Path: get("/widget/{accountId}/live"),
-			Func: handler.Handler(core, widget.LiveWidget),
+			Func: handler.Chain(core, widget.LiveWidget),
 		},
 		// app routes
-		//
+		{
+			Path: get("/app"),
+			Func: handler.Chain(core, app.Index, middleware.SessionCheck),
+		},
+		// api routes
+		{
+			Path: get("/api/auth/discord"),
+			Func: handler.Chain(core, auth.DiscordRedirect),
+		},
 	}, nil
 }
 
diff --git a/cmd/frontend/logic/auth/contants.go b/cmd/frontend/logic/auth/contants.go
new file mode 100644
index 00000000..af408da1
--- /dev/null
+++ b/cmd/frontend/logic/auth/contants.go
@@ -0,0 +1,20 @@
+package auth
+
+import "os"
+
+const SessionCookieName = "x-amth-session"
+const AuthNonceCookieName = "x-amth-auth-nonce"
+
+var (
+	DefaultCookiePath   = os.Getenv("AUTH_COOKIE_PATH")
+	DefaultCookieDomain = os.Getenv("AUTH_COOKIE_DOMAIN")
+)
+
+func init() {
+	if DefaultCookiePath == "" {
+		panic("AUTH_COOKIE_PATH cannot be left empty")
+	}
+	if DefaultCookieDomain == "" {
+		panic("AUTH_COOKIE_DOMAIN cannot be left empty")
+	}
+}
diff --git a/cmd/frontend/logic/auth/cookie.go b/cmd/frontend/logic/auth/cookie.go
new file mode 100644
index 00000000..59162b77
--- /dev/null
+++ b/cmd/frontend/logic/auth/cookie.go
@@ -0,0 +1,34 @@
+package auth
+
+import (
+	"net/http"
+	"time"
+)
+
+func NewSessionCookie(value string, expiresAt time.Time) *http.Cookie {
+	return &http.Cookie{
+		Name:   SessionCookieName,
+		Value:  value,
+		MaxAge: int(time.Until(expiresAt).Seconds()),
+
+		Secure:   true,
+		HttpOnly: true,
+		Path:     DefaultCookiePath,
+		Domain:   DefaultCookieDomain,
+		SameSite: http.SameSiteLaxMode,
+	}
+}
+
+func NewNonceCookie(value string, expiresAt time.Time) *http.Cookie {
+	return &http.Cookie{
+		Name:   AuthNonceCookieName,
+		Value:  value,
+		MaxAge: int(time.Until(expiresAt).Seconds()),
+
+		Secure:   true,
+		HttpOnly: true,
+		Path:     DefaultCookiePath,
+		Domain:   DefaultCookieDomain,
+		SameSite: http.SameSiteLaxMode,
+	}
+}
diff --git a/cmd/frontend/logic/discord/oauth.go b/cmd/frontend/logic/discord/oauth.go
new file mode 100644
index 00000000..6d0d9809
--- /dev/null
+++ b/cmd/frontend/logic/discord/oauth.go
@@ -0,0 +1,107 @@
+package discord
+
+import (
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/url"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/bwmarrin/discordgo"
+	"github.com/pkg/errors"
+	"github.com/rs/zerolog/log"
+)
+
+type authToken struct {
+	Scope string `json:"scope"`
+	Type  string `json:"token_type"`
+	Value string `json:"access_token"`
+
+	ExpiresAt    time.Time `json:"-"`
+	ExpiresIn    int       `json:"expires_in"`
+	RefreshToken string    `json:"refresh_token"`
+}
+
+var defaultClient = http.Client{
+	Timeout: time.Second * 5,
+}
+
+const baseURL = "https://discord.com/oauth2"
+
+var defaultClientID = os.Getenv("DISCORD_AUTH_CLIENT_ID")
+var defaultClientSecret = os.Getenv("DISCORD_AUTH_CLIENT_SECRET")
+
+var defaultScopes = os.Getenv("DISCORD_AUTH_DEFAULT_SCOPES")
+var defaultRedirectURL = os.Getenv("DISCORD_AUTH_REDIRECT_URL")
+
+type oAuthURL struct {
+	scope        string
+	state        string
+	prompt       string
+	clientID     string
+	redirectURL  string
+	responseType string
+}
+
+func NewOAuthURL(state string) oAuthURL {
+	url := oAuthURL{
+		prompt:       "none",
+		state:        state,
+		scope:        defaultScopes,
+		clientID:     defaultClientID,
+		redirectURL:  defaultRedirectURL,
+		responseType: "code",
+	}
+	return url
+}
+
+func (u oAuthURL) String() string {
+	// https://discord.com/developers/docs/topics/oauth2#authorization-code-grant
+	base := baseURL + "/authorize"
+	query := url.Values{}
+	query.Set("scope", u.scope)
+	query.Set("prompt", u.prompt)
+	query.Set("state", u.state)
+	query.Set("client_id", u.clientID)
+	query.Set("redirect_uri", u.redirectURL)
+	query.Set("response_type", u.responseType)
+	return base + "?" + query.Encode()
+}
+
+func ExchangeOAuthCode(code, redirectURL string) (authToken, error) {
+	base := discordgo.EndpointOAuth2 + "token"
+	query := url.Values{}
+	query.Set("code", code)
+	query.Set("redirect_uri", defaultRedirectURL)
+	query.Set("grant_type", "authorization_code")
+
+	req, err := http.NewRequest("POST", base, strings.NewReader(query.Encode()))
+	if err != nil {
+		return authToken{}, errors.Wrap(err, "failed to create an exchange request")
+	}
+
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	req.SetBasicAuth(defaultClientID, defaultClientSecret)
+
+	res, err := defaultClient.Do(req)
+	if err != nil {
+		return authToken{}, errors.Wrap(err, "failed to make a POST request")
+	}
+	defer res.Body.Close()
+	if res.StatusCode != 200 {
+		body, _ := io.ReadAll(res.Body)
+		log.Error().Str("body", string(body)).Msg("bad status code")
+		return authToken{}, errors.Errorf("received status code %d", res.StatusCode)
+	}
+
+	var data authToken
+	err = json.NewDecoder(res.Body).Decode(&data)
+	if err != nil {
+		return authToken{}, errors.Wrap(err, "failed to decode response")
+	}
+
+	data.ExpiresAt = time.Now().Add(time.Second * time.Duration(data.ExpiresIn))
+	return data, nil
+}
diff --git a/cmd/frontend/logic/discord/user.go b/cmd/frontend/logic/discord/user.go
new file mode 100644
index 00000000..4940bebc
--- /dev/null
+++ b/cmd/frontend/logic/discord/user.go
@@ -0,0 +1,44 @@
+package discord
+
+import (
+	"encoding/json"
+	"io"
+	"net/http"
+
+	"github.com/bwmarrin/discordgo"
+	"github.com/pkg/errors"
+	"github.com/rs/zerolog/log"
+)
+
+type userResponse struct {
+	User   discordgo.User `json:"user"`
+	Scopes []string       `json:"scopes"`
+}
+
+func GetUserFromToken(token authToken) (discordgo.User, error) {
+	url := discordgo.EndpointOAuth2 + "@me"
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return discordgo.User{}, errors.Wrap(err, "failed to create a GET request")
+	}
+	req.Header.Add("Authorization", "Bearer "+token.Value)
+
+	res, err := defaultClient.Do(req)
+	if err != nil {
+		return discordgo.User{}, errors.Wrap(err, "GET request failed")
+	}
+	defer res.Body.Close()
+	if res.StatusCode != 200 {
+		body, _ := io.ReadAll(res.Body)
+		log.Error().Str("body", string(body)).Msg("bad status code")
+		return discordgo.User{}, errors.Errorf("received status code %d", res.StatusCode)
+	}
+
+	var data userResponse
+	err = json.NewDecoder(res.Body).Decode(&data)
+	if err != nil {
+		return discordgo.User{}, errors.Wrap(err, "failed to decode user data")
+	}
+
+	return data.User, nil
+}
diff --git a/cmd/frontend/middleware/auth.go b/cmd/frontend/middleware/auth.go
new file mode 100644
index 00000000..396a3c96
--- /dev/null
+++ b/cmd/frontend/middleware/auth.go
@@ -0,0 +1,21 @@
+package middleware
+
+import (
+	"net/http"
+	"time"
+
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/cmd/frontend/logic/auth"
+)
+
+var SessionCheck handler.Middleware = func(ctx *handler.Context, next func(ctx *handler.Context) error) func(ctx *handler.Context) error {
+	user, err := ctx.SessionUser()
+	if err == nil && user.ID != "" {
+		return next
+	}
+
+	return func(ctx *handler.Context) error {
+		ctx.SetCookie(auth.NewSessionCookie("", time.Time{}))
+		return ctx.Redirect("/login", http.StatusTemporaryRedirect)
+	}
+}
diff --git a/cmd/frontend/routes/api/auth/discord.go b/cmd/frontend/routes/api/auth/discord.go
new file mode 100644
index 00000000..8059ad9d
--- /dev/null
+++ b/cmd/frontend/routes/api/auth/discord.go
@@ -0,0 +1,91 @@
+package auth
+
+import (
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/cmd/frontend/logic/auth"
+	"github.com/cufee/aftermath/cmd/frontend/logic/discord"
+	"github.com/cufee/aftermath/internal/logic"
+	"github.com/rs/zerolog/log"
+)
+
+var DiscordRedirect handler.Endpoint = func(ctx *handler.Context) error {
+	log.Debug().Msg("started handling a discord redirect")
+
+	code := ctx.Query("code")
+	state := ctx.Query("state")
+	if code == "" || state == "" {
+		log.Debug().Msg("discord redirect missing state or code")
+		return ctx.Redirect("/login?message=session not found", http.StatusTemporaryRedirect)
+	}
+
+	cookie, err := ctx.Cookie(auth.AuthNonceCookieName)
+	if err != nil || cookie == nil {
+		return ctx.Redirect("/login?message=session not found", http.StatusTemporaryRedirect)
+	}
+	if cookie.Value == "" {
+		return ctx.Redirect("/login?message=session not found", http.StatusTemporaryRedirect)
+	}
+	log.Debug().Str("identifier", cookie.Value).Msg("handling a discord redirect")
+
+	nonce, err := ctx.Database().FindAuthNonce(ctx.Context, state)
+	if err != nil || !nonce.Active || nonce.ExpiresAt.Before(time.Now()) {
+		log.Debug().Msg("discord redirect missing or invalid nonce")
+		return ctx.Redirect("/login?message=session expired", http.StatusTemporaryRedirect)
+	}
+	err = ctx.Database().SetAuthNonceActive(ctx, nonce.ID, false)
+	if err != nil {
+		log.Err(err).Msg("failed to update nonce active status")
+		return ctx.Redirect("/login?message=session expired", http.StatusTemporaryRedirect)
+	}
+
+	identifier, err := ctx.Identifier()
+	if err != nil {
+		log.Err(err).Msg("failed to extract an identifier from a request")
+		return ctx.Redirect("/login?message=session expired", http.StatusTemporaryRedirect)
+	}
+
+	if nonce.Identifier != identifier {
+		log.Debug().Msg("discord redirect invalid identifier")
+		return ctx.Redirect("/login?message=session expired", http.StatusTemporaryRedirect)
+	}
+
+	token, err := discord.ExchangeOAuthCode(code, nonce.Meta["redirectUrl"])
+	if err != nil {
+		log.Err(err).Msg("failed to exchange code for token")
+		return ctx.Redirect("/login?message=failed to create a session", http.StatusTemporaryRedirect)
+	}
+
+	user, err := discord.GetUserFromToken(token)
+	if err != nil {
+		log.Err(err).Msg("failed to get user from token")
+		return ctx.Redirect("/login?message=failed to create a session", http.StatusTemporaryRedirect)
+	}
+	if user.ID == "" { // just in case
+		log.Error().Msg("blank user id received from discord")
+		return ctx.Redirect("/login?message=failed to create a session", http.StatusTemporaryRedirect)
+	}
+
+	sessionID, err := logic.RandomString(32)
+	if err != nil {
+		log.Err(err).Msg("failed to generate a session id")
+		return ctx.Redirect("/login?message=failed to create a session", http.StatusTemporaryRedirect)
+	}
+
+	sess, err := ctx.Database().CreateSession(ctx.Context, sessionID, user.ID, time.Now().Add(time.Hour*24*7), nil)
+	if err != nil {
+		log.Err(err).Msg("failed to create a new user session")
+		return ctx.Redirect("/login?message=failed to create a session", http.StatusTemporaryRedirect)
+	}
+
+	ctx.SetCookie(auth.NewSessionCookie(sess.PublicID, sess.ExpiresAt))
+
+	defer log.Debug().Msg("finished handling a discord redirect")
+	if path, ok := nonce.Meta["redirect"]; ok && strings.HasPrefix(path, "/") {
+		return ctx.Redirect(path, http.StatusTemporaryRedirect)
+	}
+	return ctx.Redirect("/app", http.StatusTemporaryRedirect)
+}
diff --git a/cmd/frontend/routes/app/index.templ b/cmd/frontend/routes/app/index.templ
new file mode 100644
index 00000000..6eddfd42
--- /dev/null
+++ b/cmd/frontend/routes/app/index.templ
@@ -0,0 +1,21 @@
+package app
+
+import "net/http"
+import "github.com/cufee/aftermath/internal/database/models"
+import "github.com/cufee/aftermath/cmd/frontend/handler"
+import "github.com/cufee/aftermath/cmd/frontend/layouts"
+
+var Index handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
+  user, err := ctx.SessionUser()
+  if err != nil {
+    return nil, nil, ctx.Redirect("/login", http.StatusTemporaryRedirect)
+  }
+	return layouts.Main, index(user), nil
+}
+
+templ index(user *models.User) {
+	<div class="flex flex-col justify-center gap-8 m-auto" id="landing">
+		App page
+    {user.ID}
+	</div>
+}
diff --git a/cmd/frontend/routes/app/index_templ.go b/cmd/frontend/routes/app/index_templ.go
new file mode 100644
index 00000000..16e3e940
--- /dev/null
+++ b/cmd/frontend/routes/app/index_templ.go
@@ -0,0 +1,61 @@
+// Code generated by templ - DO NOT EDIT.
+
+// templ: version: v0.2.696
+package app
+
+//lint:file-ignore SA4006 This context is only used if a nested component is present.
+
+import "github.com/a-h/templ"
+import "context"
+import "io"
+import "bytes"
+
+import "net/http"
+import "github.com/cufee/aftermath/internal/database/models"
+import "github.com/cufee/aftermath/cmd/frontend/handler"
+import "github.com/cufee/aftermath/cmd/frontend/layouts"
+
+var Index handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
+	user, err := ctx.SessionUser()
+	if err != nil {
+		return nil, nil, ctx.Redirect("/login", http.StatusTemporaryRedirect)
+	}
+	return layouts.Main, index(user), nil
+}
+
+func index(user *models.User) templ.Component {
+	return templ.ComponentFunc(func(ctx context.Context, templ_7745c5c3_W io.Writer) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templ_7745c5c3_W.(*bytes.Buffer)
+		if !templ_7745c5c3_IsBuffer {
+			templ_7745c5c3_Buffer = templ.GetBuffer()
+			defer templ.ReleaseBuffer(templ_7745c5c3_Buffer)
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var1 == nil {
+			templ_7745c5c3_Var1 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-col justify-center gap-8 m-auto\" id=\"landing\">App page ")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var2 string
+		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(user.ID)
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/app/index.templ`, Line: 19, Col: 12}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		if !templ_7745c5c3_IsBuffer {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteTo(templ_7745c5c3_W)
+		}
+		return templ_7745c5c3_Err
+	})
+}
diff --git a/cmd/frontend/routes/errors.templ b/cmd/frontend/routes/errors.templ
index cbd34c87..c3d4db65 100644
--- a/cmd/frontend/routes/errors.templ
+++ b/cmd/frontend/routes/errors.templ
@@ -5,7 +5,7 @@ import "github.com/cufee/aftermath/cmd/frontend/layouts"
 import "net/http"
 
 var GenericError handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
-	message := ctx.Req().URL.Query().Get("message")
+	message := ctx.Query("message")
 
 	ctx.SetStatus(http.StatusInternalServerError)
 	return layouts.Main, errorPage(message), nil
@@ -19,7 +19,7 @@ templ errorPage(message string) {
 }
 
 var ErrorNotFound handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
-	path := ctx.Req().PathValue("pathname")
+	path := ctx.Path("pathname")
 
 	ctx.SetStatus(http.StatusNotFound)
 	return layouts.Main, notFoundPage(path), nil
diff --git a/cmd/frontend/routes/errors_templ.go b/cmd/frontend/routes/errors_templ.go
index bb761d1a..c457a73c 100644
--- a/cmd/frontend/routes/errors_templ.go
+++ b/cmd/frontend/routes/errors_templ.go
@@ -15,7 +15,7 @@ import "github.com/cufee/aftermath/cmd/frontend/layouts"
 import "net/http"
 
 var GenericError handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
-	message := ctx.Req().URL.Query().Get("message")
+	message := ctx.Query("message")
 
 	ctx.SetStatus(http.StatusInternalServerError)
 	return layouts.Main, errorPage(message), nil
@@ -59,7 +59,7 @@ func errorPage(message string) templ.Component {
 }
 
 var ErrorNotFound handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
-	path := ctx.Req().PathValue("pathname")
+	path := ctx.Path("pathname")
 
 	ctx.SetStatus(http.StatusNotFound)
 	return layouts.Main, notFoundPage(path), nil
diff --git a/cmd/frontend/routes/login.go b/cmd/frontend/routes/login.go
new file mode 100644
index 00000000..c47c41af
--- /dev/null
+++ b/cmd/frontend/routes/login.go
@@ -0,0 +1,36 @@
+package routes
+
+import (
+	"net/http"
+	"time"
+
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/cmd/frontend/logic/auth"
+	"github.com/cufee/aftermath/cmd/frontend/logic/discord"
+	"github.com/cufee/aftermath/internal/logic"
+	"github.com/rs/zerolog/log"
+)
+
+var Login handler.Endpoint = func(ctx *handler.Context) error {
+	nonceID, err := logic.RandomString(32)
+	if err != nil {
+		return ctx.Error(err, "failed to authenticate")
+	}
+
+	identifier, err := ctx.Identifier()
+	if err != nil {
+		return ctx.Error(err, "failed to extract an identifier")
+	}
+	log.Debug().Str("identifier", identifier).Msg("new login request")
+
+	redirectURL := discord.NewOAuthURL(nonceID)
+	meta := map[string]string{"from": ctx.Query("from"), "redirectUrl": redirectURL.String()}
+
+	nonce, err := ctx.Database().CreateAuthNonce(ctx.Context, nonceID, identifier, time.Now().Add(time.Minute*5), meta)
+	if err != nil {
+		return ctx.Error(err, "failed to authenticate")
+	}
+
+	ctx.SetCookie(auth.NewNonceCookie(nonce.PublicID, nonce.ExpiresAt))
+	return ctx.Redirect(redirectURL.String(), http.StatusTemporaryRedirect)
+}
diff --git a/cmd/frontend/routes/widget/configure.templ b/cmd/frontend/routes/widget/configure.templ
index 9f88403b..7cc17bf4 100644
--- a/cmd/frontend/routes/widget/configure.templ
+++ b/cmd/frontend/routes/widget/configure.templ
@@ -10,7 +10,7 @@ import "github.com/pkg/errors"
 import "fmt"
 
 var ConfigureWidget handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
-	accountID := ctx.Req().PathValue("accountId")
+	accountID := ctx.Path("accountId")
 	if accountID == "" {
 		return nil, nil, errors.New("invalid account id")
 	}
diff --git a/cmd/frontend/routes/widget/configure_templ.go b/cmd/frontend/routes/widget/configure_templ.go
index b353aef5..755037b9 100644
--- a/cmd/frontend/routes/widget/configure_templ.go
+++ b/cmd/frontend/routes/widget/configure_templ.go
@@ -20,7 +20,7 @@ import "github.com/pkg/errors"
 import "fmt"
 
 var ConfigureWidget handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
-	accountID := ctx.Req().PathValue("accountId")
+	accountID := ctx.Path("accountId")
 	if accountID == "" {
 		return nil, nil, errors.New("invalid account id")
 	}
diff --git a/cmd/frontend/routes/widget/live.templ b/cmd/frontend/routes/widget/live.templ
index e8a3f723..31f52f8a 100644
--- a/cmd/frontend/routes/widget/live.templ
+++ b/cmd/frontend/routes/widget/live.templ
@@ -11,7 +11,7 @@ import "github.com/cufee/aftermath/internal/stats/client/v1"
 import "slices"
 
 var LiveWidget handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
-	accountID := ctx.Req().PathValue("accountId")
+	accountID := ctx.Path("accountId")
 	if accountID == "" {
 		return nil, nil, errors.New("invalid account id")
 	}
@@ -22,10 +22,10 @@ var LiveWidget handler.Page = func(ctx *handler.Context) (handler.Layout, templ.
 	}
 
 	var opts  = []client.RequestOption{client.WithWN8()}
-	if ref := ctx.Req().URL.Query().Get("ref"); ref != "" {
+	if ref := ctx.Query("ref"); ref != "" {
 		opts = append(opts, client.WithReferenceID(ref))
 	}
-	if t := ctx.Req().URL.Query().Get("type"); t != "" && slices.Contains(models.SnapshotType("").Values(), t) {
+	if t := ctx.Query("type"); t != "" && slices.Contains(models.SnapshotType("").Values(), t) {
 		opts = append(opts, client.WithType(models.SnapshotType(t)))
 	}
 
diff --git a/cmd/frontend/routes/widget/live_templ.go b/cmd/frontend/routes/widget/live_templ.go
index 994c9045..b176d1c8 100644
--- a/cmd/frontend/routes/widget/live_templ.go
+++ b/cmd/frontend/routes/widget/live_templ.go
@@ -21,7 +21,7 @@ import "github.com/cufee/aftermath/internal/stats/client/v1"
 import "slices"
 
 var LiveWidget handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
-	accountID := ctx.Req().PathValue("accountId")
+	accountID := ctx.Path("accountId")
 	if accountID == "" {
 		return nil, nil, errors.New("invalid account id")
 	}
@@ -32,10 +32,10 @@ var LiveWidget handler.Page = func(ctx *handler.Context) (handler.Layout, templ.
 	}
 
 	var opts = []client.RequestOption{client.WithWN8()}
-	if ref := ctx.Req().URL.Query().Get("ref"); ref != "" {
+	if ref := ctx.Query("ref"); ref != "" {
 		opts = append(opts, client.WithReferenceID(ref))
 	}
-	if t := ctx.Req().URL.Query().Get("type"); t != "" && slices.Contains(models.SnapshotType("").Values(), t) {
+	if t := ctx.Query("type"); t != "" && slices.Contains(models.SnapshotType("").Values(), t) {
 		opts = append(opts, client.WithType(models.SnapshotType(t)))
 	}
 
diff --git a/go.sum b/go.sum
index 1b86d9e9..aa531aa1 100644
--- a/go.sum
+++ b/go.sum
@@ -60,12 +60,16 @@ github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/
 github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
+github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/mattn/go-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o4kU=
 github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
 github.com/mitchellh/go-wordwrap v1.0.1 h1:TLuKupo69TCn6TQSyGxwI1EblZZEsQ0vMlAFQflz0v0=
 github.com/mitchellh/go-wordwrap v1.0.1/go.mod h1:R62XHJLzvMFRBbcrT7m7WgmE1eOyTSsCt+hzestvNj0=
 github.com/nlpodyssey/gopickle v0.3.0 h1:BLUE5gxFLyyNOPzlXxt6GoHEMMxD0qhsE4p0CIQyoLw=
 github.com/nlpodyssey/gopickle v0.3.0/go.mod h1:f070HJ/yR+eLi5WmM1OXJEGaTpuJEUiib19olXgYha0=
+github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
+github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
 github.com/pierrec/lz4/v4 v4.1.21 h1:yOVMLb6qSIDP67pl/5F7RepeKYu/VmTyEXvuMI5d9mQ=
 github.com/pierrec/lz4/v4 v4.1.21/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
@@ -73,6 +77,8 @@ github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
+github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
 github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=
 github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
@@ -81,6 +87,10 @@ github.com/rogpeppe/go-internal v1.8.1/go.mod h1:JeRgkft04UBgHMgCIwADu4Pn6Mtm5d4
 github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
 github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8=
 github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
+github.com/spf13/cobra v1.7.0 h1:hyqWnYt1ZQShIddO5kBpj3vu05/++x6tJ6dg8EC572I=
+github.com/spf13/cobra v1.7.0/go.mod h1:uLxZILRyS/50WlhOIKD7W6V5bgeIt+4sICxh6uRMrb0=
+github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
diff --git a/internal/database/auth.go b/internal/database/auth.go
new file mode 100644
index 00000000..b874264a
--- /dev/null
+++ b/internal/database/auth.go
@@ -0,0 +1,110 @@
+package database
+
+import (
+	"context"
+	"time"
+
+	"github.com/cufee/aftermath/internal/database/ent/db"
+	"github.com/cufee/aftermath/internal/database/ent/db/authnonce"
+	"github.com/cufee/aftermath/internal/database/ent/db/session"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+func toAuthNonce(record *db.AuthNonce) models.AuthNonce {
+	return models.AuthNonce{
+		ID:         record.ID,
+		Active:     record.Active,
+		PublicID:   record.PublicID,
+		Identifier: record.Identifier,
+		Meta:       record.Metadata,
+
+		CreatedAt: record.CreatedAt,
+		UpdatedAt: record.UpdatedAt,
+		ExpiresAt: record.ExpiresAt,
+	}
+}
+
+func (c *client) CreateAuthNonce(ctx context.Context, publicID, identifier string, expiresAt time.Time, meta map[string]string) (models.AuthNonce, error) {
+	record, err := c.db.AuthNonce.Create().SetActive(true).SetExpiresAt(expiresAt).SetIdentifier(identifier).SetPublicID(publicID).SetMetadata(meta).Save(ctx)
+	if err != nil {
+		return models.AuthNonce{}, err
+	}
+
+	nonce := toAuthNonce(record)
+	return nonce, nonce.Valid()
+}
+
+func (c *client) FindAuthNonce(ctx context.Context, publicID string) (models.AuthNonce, error) {
+	record, err := c.db.AuthNonce.Query().Where(authnonce.PublicID(publicID), authnonce.Active(true), authnonce.ExpiresAtGT(time.Now())).First(ctx)
+	if err != nil {
+		return models.AuthNonce{}, err
+	}
+
+	nonce := toAuthNonce(record)
+	return nonce, nonce.Valid()
+}
+
+func (c *client) SetAuthNonceActive(ctx context.Context, nonceID string, active bool) error {
+	err := c.db.AuthNonce.UpdateOneID(nonceID).SetActive(active).Exec(ctx)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func toSession(record *db.Session) models.Session {
+	return models.Session{
+		ID:       record.ID,
+		UserID:   record.UserID,
+		PublicID: record.PublicID,
+		Meta:     record.Metadata,
+
+		CreatedAt: record.CreatedAt,
+		UpdatedAt: record.UpdatedAt,
+		ExpiresAt: record.ExpiresAt,
+	}
+}
+
+func (c *client) CreateSession(ctx context.Context, publicID, userID string, expiresAt time.Time, meta map[string]string) (models.Session, error) {
+	user, err := c.GetOrCreateUserByID(ctx, userID)
+	if err != nil {
+		return models.Session{}, err
+	}
+
+	record, err := c.db.Session.Create().SetPublicID(publicID).SetUser(c.db.User.GetX(ctx, user.ID)).SetExpiresAt(expiresAt).SetMetadata(meta).Save(ctx)
+	if err != nil {
+		return models.Session{}, err
+	}
+
+	nonce := toSession(record)
+	return nonce, nonce.Valid()
+}
+
+func (c *client) FindSession(ctx context.Context, publicID string) (models.Session, error) {
+	record, err := c.db.Session.Query().Where(session.PublicID(publicID), session.ExpiresAtGT(time.Now())).First(ctx)
+	if err != nil {
+		return models.Session{}, err
+	}
+
+	session := toSession(record)
+	return session, session.Valid()
+}
+
+func (c *client) UserFromSession(ctx context.Context, publicID string) (models.User, error) {
+	record, err := c.db.Session.Query().Where(session.PublicID(publicID), session.ExpiresAtGT(time.Now())).QueryUser().First(ctx)
+	if err != nil {
+		return models.User{}, err
+	}
+
+	return toUser(record, nil, nil, nil), nil
+}
+
+func (c *client) SetSessionExpiresAt(ctx context.Context, sessionID string, expiresAt time.Time) error {
+	err := c.db.Session.UpdateOneID(sessionID).SetExpiresAt(expiresAt).Exec(ctx)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
diff --git a/internal/database/client.go b/internal/database/client.go
index cdcb8670..da875773 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -18,6 +18,17 @@ import (
 
 var _ Client = &client{}
 
+type AuthClient interface {
+	CreateAuthNonce(ctx context.Context, publicID, identifier string, expiresAt time.Time, meta map[string]string) (models.AuthNonce, error)
+	FindAuthNonce(ctx context.Context, publicID string) (models.AuthNonce, error)
+	SetAuthNonceActive(ctx context.Context, nonceID string, active bool) error
+
+	CreateSession(ctx context.Context, publicID, userID string, expiresAt time.Time, meta map[string]string) (models.Session, error)
+	SetSessionExpiresAt(ctx context.Context, sessionID string, expiresAt time.Time) error
+	UserFromSession(ctx context.Context, publicID string) (models.User, error)
+	FindSession(ctx context.Context, publicID string) (models.Session, error)
+}
+
 type AccountsClient interface {
 	GetAccounts(ctx context.Context, ids []string) ([]models.Account, error)
 	GetAccountByID(ctx context.Context, id string) (models.Account, error)
@@ -83,6 +94,7 @@ type DiscordDataClient interface {
 }
 
 type Client interface {
+	AuthClient
 	UsersClient
 
 	GlossaryClient
diff --git a/internal/database/ent/db/authnonce.go b/internal/database/ent/db/authnonce.go
new file mode 100644
index 00000000..84f2ca12
--- /dev/null
+++ b/internal/database/ent/db/authnonce.go
@@ -0,0 +1,177 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+	"time"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+	"github.com/cufee/aftermath/internal/database/ent/db/authnonce"
+)
+
+// AuthNonce is the model entity for the AuthNonce schema.
+type AuthNonce struct {
+	config `json:"-"`
+	// ID of the ent.
+	ID string `json:"id,omitempty"`
+	// CreatedAt holds the value of the "created_at" field.
+	CreatedAt time.Time `json:"created_at,omitempty"`
+	// UpdatedAt holds the value of the "updated_at" field.
+	UpdatedAt time.Time `json:"updated_at,omitempty"`
+	// Active holds the value of the "active" field.
+	Active bool `json:"active,omitempty"`
+	// ExpiresAt holds the value of the "expires_at" field.
+	ExpiresAt time.Time `json:"expires_at,omitempty"`
+	// Identifier holds the value of the "identifier" field.
+	Identifier string `json:"identifier,omitempty"`
+	// PublicID holds the value of the "public_id" field.
+	PublicID string `json:"public_id,omitempty"`
+	// Metadata holds the value of the "metadata" field.
+	Metadata     map[string]string `json:"metadata,omitempty"`
+	selectValues sql.SelectValues
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*AuthNonce) scanValues(columns []string) ([]any, error) {
+	values := make([]any, len(columns))
+	for i := range columns {
+		switch columns[i] {
+		case authnonce.FieldMetadata:
+			values[i] = new([]byte)
+		case authnonce.FieldActive:
+			values[i] = new(sql.NullBool)
+		case authnonce.FieldID, authnonce.FieldIdentifier, authnonce.FieldPublicID:
+			values[i] = new(sql.NullString)
+		case authnonce.FieldCreatedAt, authnonce.FieldUpdatedAt, authnonce.FieldExpiresAt:
+			values[i] = new(sql.NullTime)
+		default:
+			values[i] = new(sql.UnknownType)
+		}
+	}
+	return values, nil
+}
+
+// assignValues assigns the values that were returned from sql.Rows (after scanning)
+// to the AuthNonce fields.
+func (an *AuthNonce) assignValues(columns []string, values []any) error {
+	if m, n := len(values), len(columns); m < n {
+		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
+	}
+	for i := range columns {
+		switch columns[i] {
+		case authnonce.FieldID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field id", values[i])
+			} else if value.Valid {
+				an.ID = value.String
+			}
+		case authnonce.FieldCreatedAt:
+			if value, ok := values[i].(*sql.NullTime); !ok {
+				return fmt.Errorf("unexpected type %T for field created_at", values[i])
+			} else if value.Valid {
+				an.CreatedAt = value.Time
+			}
+		case authnonce.FieldUpdatedAt:
+			if value, ok := values[i].(*sql.NullTime); !ok {
+				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
+			} else if value.Valid {
+				an.UpdatedAt = value.Time
+			}
+		case authnonce.FieldActive:
+			if value, ok := values[i].(*sql.NullBool); !ok {
+				return fmt.Errorf("unexpected type %T for field active", values[i])
+			} else if value.Valid {
+				an.Active = value.Bool
+			}
+		case authnonce.FieldExpiresAt:
+			if value, ok := values[i].(*sql.NullTime); !ok {
+				return fmt.Errorf("unexpected type %T for field expires_at", values[i])
+			} else if value.Valid {
+				an.ExpiresAt = value.Time
+			}
+		case authnonce.FieldIdentifier:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field identifier", values[i])
+			} else if value.Valid {
+				an.Identifier = value.String
+			}
+		case authnonce.FieldPublicID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field public_id", values[i])
+			} else if value.Valid {
+				an.PublicID = value.String
+			}
+		case authnonce.FieldMetadata:
+			if value, ok := values[i].(*[]byte); !ok {
+				return fmt.Errorf("unexpected type %T for field metadata", values[i])
+			} else if value != nil && len(*value) > 0 {
+				if err := json.Unmarshal(*value, &an.Metadata); err != nil {
+					return fmt.Errorf("unmarshal field metadata: %w", err)
+				}
+			}
+		default:
+			an.selectValues.Set(columns[i], values[i])
+		}
+	}
+	return nil
+}
+
+// Value returns the ent.Value that was dynamically selected and assigned to the AuthNonce.
+// This includes values selected through modifiers, order, etc.
+func (an *AuthNonce) Value(name string) (ent.Value, error) {
+	return an.selectValues.Get(name)
+}
+
+// Update returns a builder for updating this AuthNonce.
+// Note that you need to call AuthNonce.Unwrap() before calling this method if this AuthNonce
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (an *AuthNonce) Update() *AuthNonceUpdateOne {
+	return NewAuthNonceClient(an.config).UpdateOne(an)
+}
+
+// Unwrap unwraps the AuthNonce entity that was returned from a transaction after it was closed,
+// so that all future queries will be executed through the driver which created the transaction.
+func (an *AuthNonce) Unwrap() *AuthNonce {
+	_tx, ok := an.config.driver.(*txDriver)
+	if !ok {
+		panic("db: AuthNonce is not a transactional entity")
+	}
+	an.config.driver = _tx.drv
+	return an
+}
+
+// String implements the fmt.Stringer.
+func (an *AuthNonce) String() string {
+	var builder strings.Builder
+	builder.WriteString("AuthNonce(")
+	builder.WriteString(fmt.Sprintf("id=%v, ", an.ID))
+	builder.WriteString("created_at=")
+	builder.WriteString(an.CreatedAt.Format(time.ANSIC))
+	builder.WriteString(", ")
+	builder.WriteString("updated_at=")
+	builder.WriteString(an.UpdatedAt.Format(time.ANSIC))
+	builder.WriteString(", ")
+	builder.WriteString("active=")
+	builder.WriteString(fmt.Sprintf("%v", an.Active))
+	builder.WriteString(", ")
+	builder.WriteString("expires_at=")
+	builder.WriteString(an.ExpiresAt.Format(time.ANSIC))
+	builder.WriteString(", ")
+	builder.WriteString("identifier=")
+	builder.WriteString(an.Identifier)
+	builder.WriteString(", ")
+	builder.WriteString("public_id=")
+	builder.WriteString(an.PublicID)
+	builder.WriteString(", ")
+	builder.WriteString("metadata=")
+	builder.WriteString(fmt.Sprintf("%v", an.Metadata))
+	builder.WriteByte(')')
+	return builder.String()
+}
+
+// AuthNonces is a parsable slice of AuthNonce.
+type AuthNonces []*AuthNonce
diff --git a/internal/database/ent/db/authnonce/authnonce.go b/internal/database/ent/db/authnonce/authnonce.go
new file mode 100644
index 00000000..8a1741f0
--- /dev/null
+++ b/internal/database/ent/db/authnonce/authnonce.go
@@ -0,0 +1,107 @@
+// Code generated by ent, DO NOT EDIT.
+
+package authnonce
+
+import (
+	"time"
+
+	"entgo.io/ent/dialect/sql"
+)
+
+const (
+	// Label holds the string label denoting the authnonce type in the database.
+	Label = "auth_nonce"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// FieldActive holds the string denoting the active field in the database.
+	FieldActive = "active"
+	// FieldExpiresAt holds the string denoting the expires_at field in the database.
+	FieldExpiresAt = "expires_at"
+	// FieldIdentifier holds the string denoting the identifier field in the database.
+	FieldIdentifier = "identifier"
+	// FieldPublicID holds the string denoting the public_id field in the database.
+	FieldPublicID = "public_id"
+	// FieldMetadata holds the string denoting the metadata field in the database.
+	FieldMetadata = "metadata"
+	// Table holds the table name of the authnonce in the database.
+	Table = "auth_nonces"
+)
+
+// Columns holds all SQL columns for authnonce fields.
+var Columns = []string{
+	FieldID,
+	FieldCreatedAt,
+	FieldUpdatedAt,
+	FieldActive,
+	FieldExpiresAt,
+	FieldIdentifier,
+	FieldPublicID,
+	FieldMetadata,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() time.Time
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() time.Time
+	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
+	UpdateDefaultUpdatedAt func() time.Time
+	// IdentifierValidator is a validator for the "identifier" field. It is called by the builders before save.
+	IdentifierValidator func(string) error
+	// PublicIDValidator is a validator for the "public_id" field. It is called by the builders before save.
+	PublicIDValidator func(string) error
+	// DefaultID holds the default value on creation for the "id" field.
+	DefaultID func() string
+)
+
+// OrderOption defines the ordering options for the AuthNonce queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByActive orders the results by the active field.
+func ByActive(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldActive, opts...).ToFunc()
+}
+
+// ByExpiresAt orders the results by the expires_at field.
+func ByExpiresAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldExpiresAt, opts...).ToFunc()
+}
+
+// ByIdentifier orders the results by the identifier field.
+func ByIdentifier(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldIdentifier, opts...).ToFunc()
+}
+
+// ByPublicID orders the results by the public_id field.
+func ByPublicID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldPublicID, opts...).ToFunc()
+}
diff --git a/internal/database/ent/db/authnonce/where.go b/internal/database/ent/db/authnonce/where.go
new file mode 100644
index 00000000..b4fc1a68
--- /dev/null
+++ b/internal/database/ent/db/authnonce/where.go
@@ -0,0 +1,370 @@
+// Code generated by ent, DO NOT EDIT.
+
+package authnonce
+
+import (
+	"time"
+
+	"entgo.io/ent/dialect/sql"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldLTE(FieldID, id))
+}
+
+// IDEqualFold applies the EqualFold predicate on the ID field.
+func IDEqualFold(id string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldEqualFold(FieldID, id))
+}
+
+// IDContainsFold applies the ContainsFold predicate on the ID field.
+func IDContainsFold(id string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldContainsFold(FieldID, id))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v time.Time) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v time.Time) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// Active applies equality check predicate on the "active" field. It's identical to ActiveEQ.
+func Active(v bool) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldEQ(FieldActive, v))
+}
+
+// ExpiresAt applies equality check predicate on the "expires_at" field. It's identical to ExpiresAtEQ.
+func ExpiresAt(v time.Time) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldEQ(FieldExpiresAt, v))
+}
+
+// Identifier applies equality check predicate on the "identifier" field. It's identical to IdentifierEQ.
+func Identifier(v string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldEQ(FieldIdentifier, v))
+}
+
+// PublicID applies equality check predicate on the "public_id" field. It's identical to PublicIDEQ.
+func PublicID(v string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldEQ(FieldPublicID, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v time.Time) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v time.Time) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...time.Time) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...time.Time) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v time.Time) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v time.Time) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v time.Time) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v time.Time) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v time.Time) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v time.Time) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...time.Time) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...time.Time) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v time.Time) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v time.Time) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v time.Time) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v time.Time) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// ActiveEQ applies the EQ predicate on the "active" field.
+func ActiveEQ(v bool) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldEQ(FieldActive, v))
+}
+
+// ActiveNEQ applies the NEQ predicate on the "active" field.
+func ActiveNEQ(v bool) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldNEQ(FieldActive, v))
+}
+
+// ExpiresAtEQ applies the EQ predicate on the "expires_at" field.
+func ExpiresAtEQ(v time.Time) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldEQ(FieldExpiresAt, v))
+}
+
+// ExpiresAtNEQ applies the NEQ predicate on the "expires_at" field.
+func ExpiresAtNEQ(v time.Time) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldNEQ(FieldExpiresAt, v))
+}
+
+// ExpiresAtIn applies the In predicate on the "expires_at" field.
+func ExpiresAtIn(vs ...time.Time) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldIn(FieldExpiresAt, vs...))
+}
+
+// ExpiresAtNotIn applies the NotIn predicate on the "expires_at" field.
+func ExpiresAtNotIn(vs ...time.Time) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldNotIn(FieldExpiresAt, vs...))
+}
+
+// ExpiresAtGT applies the GT predicate on the "expires_at" field.
+func ExpiresAtGT(v time.Time) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldGT(FieldExpiresAt, v))
+}
+
+// ExpiresAtGTE applies the GTE predicate on the "expires_at" field.
+func ExpiresAtGTE(v time.Time) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldGTE(FieldExpiresAt, v))
+}
+
+// ExpiresAtLT applies the LT predicate on the "expires_at" field.
+func ExpiresAtLT(v time.Time) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldLT(FieldExpiresAt, v))
+}
+
+// ExpiresAtLTE applies the LTE predicate on the "expires_at" field.
+func ExpiresAtLTE(v time.Time) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldLTE(FieldExpiresAt, v))
+}
+
+// IdentifierEQ applies the EQ predicate on the "identifier" field.
+func IdentifierEQ(v string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldEQ(FieldIdentifier, v))
+}
+
+// IdentifierNEQ applies the NEQ predicate on the "identifier" field.
+func IdentifierNEQ(v string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldNEQ(FieldIdentifier, v))
+}
+
+// IdentifierIn applies the In predicate on the "identifier" field.
+func IdentifierIn(vs ...string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldIn(FieldIdentifier, vs...))
+}
+
+// IdentifierNotIn applies the NotIn predicate on the "identifier" field.
+func IdentifierNotIn(vs ...string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldNotIn(FieldIdentifier, vs...))
+}
+
+// IdentifierGT applies the GT predicate on the "identifier" field.
+func IdentifierGT(v string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldGT(FieldIdentifier, v))
+}
+
+// IdentifierGTE applies the GTE predicate on the "identifier" field.
+func IdentifierGTE(v string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldGTE(FieldIdentifier, v))
+}
+
+// IdentifierLT applies the LT predicate on the "identifier" field.
+func IdentifierLT(v string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldLT(FieldIdentifier, v))
+}
+
+// IdentifierLTE applies the LTE predicate on the "identifier" field.
+func IdentifierLTE(v string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldLTE(FieldIdentifier, v))
+}
+
+// IdentifierContains applies the Contains predicate on the "identifier" field.
+func IdentifierContains(v string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldContains(FieldIdentifier, v))
+}
+
+// IdentifierHasPrefix applies the HasPrefix predicate on the "identifier" field.
+func IdentifierHasPrefix(v string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldHasPrefix(FieldIdentifier, v))
+}
+
+// IdentifierHasSuffix applies the HasSuffix predicate on the "identifier" field.
+func IdentifierHasSuffix(v string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldHasSuffix(FieldIdentifier, v))
+}
+
+// IdentifierEqualFold applies the EqualFold predicate on the "identifier" field.
+func IdentifierEqualFold(v string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldEqualFold(FieldIdentifier, v))
+}
+
+// IdentifierContainsFold applies the ContainsFold predicate on the "identifier" field.
+func IdentifierContainsFold(v string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldContainsFold(FieldIdentifier, v))
+}
+
+// PublicIDEQ applies the EQ predicate on the "public_id" field.
+func PublicIDEQ(v string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldEQ(FieldPublicID, v))
+}
+
+// PublicIDNEQ applies the NEQ predicate on the "public_id" field.
+func PublicIDNEQ(v string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldNEQ(FieldPublicID, v))
+}
+
+// PublicIDIn applies the In predicate on the "public_id" field.
+func PublicIDIn(vs ...string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldIn(FieldPublicID, vs...))
+}
+
+// PublicIDNotIn applies the NotIn predicate on the "public_id" field.
+func PublicIDNotIn(vs ...string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldNotIn(FieldPublicID, vs...))
+}
+
+// PublicIDGT applies the GT predicate on the "public_id" field.
+func PublicIDGT(v string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldGT(FieldPublicID, v))
+}
+
+// PublicIDGTE applies the GTE predicate on the "public_id" field.
+func PublicIDGTE(v string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldGTE(FieldPublicID, v))
+}
+
+// PublicIDLT applies the LT predicate on the "public_id" field.
+func PublicIDLT(v string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldLT(FieldPublicID, v))
+}
+
+// PublicIDLTE applies the LTE predicate on the "public_id" field.
+func PublicIDLTE(v string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldLTE(FieldPublicID, v))
+}
+
+// PublicIDContains applies the Contains predicate on the "public_id" field.
+func PublicIDContains(v string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldContains(FieldPublicID, v))
+}
+
+// PublicIDHasPrefix applies the HasPrefix predicate on the "public_id" field.
+func PublicIDHasPrefix(v string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldHasPrefix(FieldPublicID, v))
+}
+
+// PublicIDHasSuffix applies the HasSuffix predicate on the "public_id" field.
+func PublicIDHasSuffix(v string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldHasSuffix(FieldPublicID, v))
+}
+
+// PublicIDEqualFold applies the EqualFold predicate on the "public_id" field.
+func PublicIDEqualFold(v string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldEqualFold(FieldPublicID, v))
+}
+
+// PublicIDContainsFold applies the ContainsFold predicate on the "public_id" field.
+func PublicIDContainsFold(v string) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.FieldContainsFold(FieldPublicID, v))
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.AuthNonce) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.AuthNonce) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.AuthNonce) predicate.AuthNonce {
+	return predicate.AuthNonce(sql.NotPredicates(p))
+}
diff --git a/internal/database/ent/db/authnonce_create.go b/internal/database/ent/db/authnonce_create.go
new file mode 100644
index 00000000..e1ed2e5c
--- /dev/null
+++ b/internal/database/ent/db/authnonce_create.go
@@ -0,0 +1,325 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/authnonce"
+)
+
+// AuthNonceCreate is the builder for creating a AuthNonce entity.
+type AuthNonceCreate struct {
+	config
+	mutation *AuthNonceMutation
+	hooks    []Hook
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (anc *AuthNonceCreate) SetCreatedAt(t time.Time) *AuthNonceCreate {
+	anc.mutation.SetCreatedAt(t)
+	return anc
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (anc *AuthNonceCreate) SetNillableCreatedAt(t *time.Time) *AuthNonceCreate {
+	if t != nil {
+		anc.SetCreatedAt(*t)
+	}
+	return anc
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (anc *AuthNonceCreate) SetUpdatedAt(t time.Time) *AuthNonceCreate {
+	anc.mutation.SetUpdatedAt(t)
+	return anc
+}
+
+// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
+func (anc *AuthNonceCreate) SetNillableUpdatedAt(t *time.Time) *AuthNonceCreate {
+	if t != nil {
+		anc.SetUpdatedAt(*t)
+	}
+	return anc
+}
+
+// SetActive sets the "active" field.
+func (anc *AuthNonceCreate) SetActive(b bool) *AuthNonceCreate {
+	anc.mutation.SetActive(b)
+	return anc
+}
+
+// SetExpiresAt sets the "expires_at" field.
+func (anc *AuthNonceCreate) SetExpiresAt(t time.Time) *AuthNonceCreate {
+	anc.mutation.SetExpiresAt(t)
+	return anc
+}
+
+// SetIdentifier sets the "identifier" field.
+func (anc *AuthNonceCreate) SetIdentifier(s string) *AuthNonceCreate {
+	anc.mutation.SetIdentifier(s)
+	return anc
+}
+
+// SetPublicID sets the "public_id" field.
+func (anc *AuthNonceCreate) SetPublicID(s string) *AuthNonceCreate {
+	anc.mutation.SetPublicID(s)
+	return anc
+}
+
+// SetMetadata sets the "metadata" field.
+func (anc *AuthNonceCreate) SetMetadata(m map[string]string) *AuthNonceCreate {
+	anc.mutation.SetMetadata(m)
+	return anc
+}
+
+// SetID sets the "id" field.
+func (anc *AuthNonceCreate) SetID(s string) *AuthNonceCreate {
+	anc.mutation.SetID(s)
+	return anc
+}
+
+// SetNillableID sets the "id" field if the given value is not nil.
+func (anc *AuthNonceCreate) SetNillableID(s *string) *AuthNonceCreate {
+	if s != nil {
+		anc.SetID(*s)
+	}
+	return anc
+}
+
+// Mutation returns the AuthNonceMutation object of the builder.
+func (anc *AuthNonceCreate) Mutation() *AuthNonceMutation {
+	return anc.mutation
+}
+
+// Save creates the AuthNonce in the database.
+func (anc *AuthNonceCreate) Save(ctx context.Context) (*AuthNonce, error) {
+	anc.defaults()
+	return withHooks(ctx, anc.sqlSave, anc.mutation, anc.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (anc *AuthNonceCreate) SaveX(ctx context.Context) *AuthNonce {
+	v, err := anc.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (anc *AuthNonceCreate) Exec(ctx context.Context) error {
+	_, err := anc.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (anc *AuthNonceCreate) ExecX(ctx context.Context) {
+	if err := anc.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (anc *AuthNonceCreate) defaults() {
+	if _, ok := anc.mutation.CreatedAt(); !ok {
+		v := authnonce.DefaultCreatedAt()
+		anc.mutation.SetCreatedAt(v)
+	}
+	if _, ok := anc.mutation.UpdatedAt(); !ok {
+		v := authnonce.DefaultUpdatedAt()
+		anc.mutation.SetUpdatedAt(v)
+	}
+	if _, ok := anc.mutation.ID(); !ok {
+		v := authnonce.DefaultID()
+		anc.mutation.SetID(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (anc *AuthNonceCreate) check() error {
+	if _, ok := anc.mutation.CreatedAt(); !ok {
+		return &ValidationError{Name: "created_at", err: errors.New(`db: missing required field "AuthNonce.created_at"`)}
+	}
+	if _, ok := anc.mutation.UpdatedAt(); !ok {
+		return &ValidationError{Name: "updated_at", err: errors.New(`db: missing required field "AuthNonce.updated_at"`)}
+	}
+	if _, ok := anc.mutation.Active(); !ok {
+		return &ValidationError{Name: "active", err: errors.New(`db: missing required field "AuthNonce.active"`)}
+	}
+	if _, ok := anc.mutation.ExpiresAt(); !ok {
+		return &ValidationError{Name: "expires_at", err: errors.New(`db: missing required field "AuthNonce.expires_at"`)}
+	}
+	if _, ok := anc.mutation.Identifier(); !ok {
+		return &ValidationError{Name: "identifier", err: errors.New(`db: missing required field "AuthNonce.identifier"`)}
+	}
+	if v, ok := anc.mutation.Identifier(); ok {
+		if err := authnonce.IdentifierValidator(v); err != nil {
+			return &ValidationError{Name: "identifier", err: fmt.Errorf(`db: validator failed for field "AuthNonce.identifier": %w`, err)}
+		}
+	}
+	if _, ok := anc.mutation.PublicID(); !ok {
+		return &ValidationError{Name: "public_id", err: errors.New(`db: missing required field "AuthNonce.public_id"`)}
+	}
+	if v, ok := anc.mutation.PublicID(); ok {
+		if err := authnonce.PublicIDValidator(v); err != nil {
+			return &ValidationError{Name: "public_id", err: fmt.Errorf(`db: validator failed for field "AuthNonce.public_id": %w`, err)}
+		}
+	}
+	if _, ok := anc.mutation.Metadata(); !ok {
+		return &ValidationError{Name: "metadata", err: errors.New(`db: missing required field "AuthNonce.metadata"`)}
+	}
+	return nil
+}
+
+func (anc *AuthNonceCreate) sqlSave(ctx context.Context) (*AuthNonce, error) {
+	if err := anc.check(); err != nil {
+		return nil, err
+	}
+	_node, _spec := anc.createSpec()
+	if err := sqlgraph.CreateNode(ctx, anc.driver, _spec); err != nil {
+		if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	if _spec.ID.Value != nil {
+		if id, ok := _spec.ID.Value.(string); ok {
+			_node.ID = id
+		} else {
+			return nil, fmt.Errorf("unexpected AuthNonce.ID type: %T", _spec.ID.Value)
+		}
+	}
+	anc.mutation.id = &_node.ID
+	anc.mutation.done = true
+	return _node, nil
+}
+
+func (anc *AuthNonceCreate) createSpec() (*AuthNonce, *sqlgraph.CreateSpec) {
+	var (
+		_node = &AuthNonce{config: anc.config}
+		_spec = sqlgraph.NewCreateSpec(authnonce.Table, sqlgraph.NewFieldSpec(authnonce.FieldID, field.TypeString))
+	)
+	if id, ok := anc.mutation.ID(); ok {
+		_node.ID = id
+		_spec.ID.Value = id
+	}
+	if value, ok := anc.mutation.CreatedAt(); ok {
+		_spec.SetField(authnonce.FieldCreatedAt, field.TypeTime, value)
+		_node.CreatedAt = value
+	}
+	if value, ok := anc.mutation.UpdatedAt(); ok {
+		_spec.SetField(authnonce.FieldUpdatedAt, field.TypeTime, value)
+		_node.UpdatedAt = value
+	}
+	if value, ok := anc.mutation.Active(); ok {
+		_spec.SetField(authnonce.FieldActive, field.TypeBool, value)
+		_node.Active = value
+	}
+	if value, ok := anc.mutation.ExpiresAt(); ok {
+		_spec.SetField(authnonce.FieldExpiresAt, field.TypeTime, value)
+		_node.ExpiresAt = value
+	}
+	if value, ok := anc.mutation.Identifier(); ok {
+		_spec.SetField(authnonce.FieldIdentifier, field.TypeString, value)
+		_node.Identifier = value
+	}
+	if value, ok := anc.mutation.PublicID(); ok {
+		_spec.SetField(authnonce.FieldPublicID, field.TypeString, value)
+		_node.PublicID = value
+	}
+	if value, ok := anc.mutation.Metadata(); ok {
+		_spec.SetField(authnonce.FieldMetadata, field.TypeJSON, value)
+		_node.Metadata = value
+	}
+	return _node, _spec
+}
+
+// AuthNonceCreateBulk is the builder for creating many AuthNonce entities in bulk.
+type AuthNonceCreateBulk struct {
+	config
+	err      error
+	builders []*AuthNonceCreate
+}
+
+// Save creates the AuthNonce entities in the database.
+func (ancb *AuthNonceCreateBulk) Save(ctx context.Context) ([]*AuthNonce, error) {
+	if ancb.err != nil {
+		return nil, ancb.err
+	}
+	specs := make([]*sqlgraph.CreateSpec, len(ancb.builders))
+	nodes := make([]*AuthNonce, len(ancb.builders))
+	mutators := make([]Mutator, len(ancb.builders))
+	for i := range ancb.builders {
+		func(i int, root context.Context) {
+			builder := ancb.builders[i]
+			builder.defaults()
+			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+				mutation, ok := m.(*AuthNonceMutation)
+				if !ok {
+					return nil, fmt.Errorf("unexpected mutation type %T", m)
+				}
+				if err := builder.check(); err != nil {
+					return nil, err
+				}
+				builder.mutation = mutation
+				var err error
+				nodes[i], specs[i] = builder.createSpec()
+				if i < len(mutators)-1 {
+					_, err = mutators[i+1].Mutate(root, ancb.builders[i+1].mutation)
+				} else {
+					spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
+					// Invoke the actual operation on the latest mutation in the chain.
+					if err = sqlgraph.BatchCreate(ctx, ancb.driver, spec); err != nil {
+						if sqlgraph.IsConstraintError(err) {
+							err = &ConstraintError{msg: err.Error(), wrap: err}
+						}
+					}
+				}
+				if err != nil {
+					return nil, err
+				}
+				mutation.id = &nodes[i].ID
+				mutation.done = true
+				return nodes[i], nil
+			})
+			for i := len(builder.hooks) - 1; i >= 0; i-- {
+				mut = builder.hooks[i](mut)
+			}
+			mutators[i] = mut
+		}(i, ctx)
+	}
+	if len(mutators) > 0 {
+		if _, err := mutators[0].Mutate(ctx, ancb.builders[0].mutation); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (ancb *AuthNonceCreateBulk) SaveX(ctx context.Context) []*AuthNonce {
+	v, err := ancb.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (ancb *AuthNonceCreateBulk) Exec(ctx context.Context) error {
+	_, err := ancb.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (ancb *AuthNonceCreateBulk) ExecX(ctx context.Context) {
+	if err := ancb.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/database/ent/db/authnonce_delete.go b/internal/database/ent/db/authnonce_delete.go
new file mode 100644
index 00000000..de530b90
--- /dev/null
+++ b/internal/database/ent/db/authnonce_delete.go
@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/authnonce"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+)
+
+// AuthNonceDelete is the builder for deleting a AuthNonce entity.
+type AuthNonceDelete struct {
+	config
+	hooks    []Hook
+	mutation *AuthNonceMutation
+}
+
+// Where appends a list predicates to the AuthNonceDelete builder.
+func (and *AuthNonceDelete) Where(ps ...predicate.AuthNonce) *AuthNonceDelete {
+	and.mutation.Where(ps...)
+	return and
+}
+
+// Exec executes the deletion query and returns how many vertices were deleted.
+func (and *AuthNonceDelete) Exec(ctx context.Context) (int, error) {
+	return withHooks(ctx, and.sqlExec, and.mutation, and.hooks)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (and *AuthNonceDelete) ExecX(ctx context.Context) int {
+	n, err := and.Exec(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return n
+}
+
+func (and *AuthNonceDelete) sqlExec(ctx context.Context) (int, error) {
+	_spec := sqlgraph.NewDeleteSpec(authnonce.Table, sqlgraph.NewFieldSpec(authnonce.FieldID, field.TypeString))
+	if ps := and.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	affected, err := sqlgraph.DeleteNodes(ctx, and.driver, _spec)
+	if err != nil && sqlgraph.IsConstraintError(err) {
+		err = &ConstraintError{msg: err.Error(), wrap: err}
+	}
+	and.mutation.done = true
+	return affected, err
+}
+
+// AuthNonceDeleteOne is the builder for deleting a single AuthNonce entity.
+type AuthNonceDeleteOne struct {
+	and *AuthNonceDelete
+}
+
+// Where appends a list predicates to the AuthNonceDelete builder.
+func (ando *AuthNonceDeleteOne) Where(ps ...predicate.AuthNonce) *AuthNonceDeleteOne {
+	ando.and.mutation.Where(ps...)
+	return ando
+}
+
+// Exec executes the deletion query.
+func (ando *AuthNonceDeleteOne) Exec(ctx context.Context) error {
+	n, err := ando.and.Exec(ctx)
+	switch {
+	case err != nil:
+		return err
+	case n == 0:
+		return &NotFoundError{authnonce.Label}
+	default:
+		return nil
+	}
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (ando *AuthNonceDeleteOne) ExecX(ctx context.Context) {
+	if err := ando.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/database/ent/db/authnonce_query.go b/internal/database/ent/db/authnonce_query.go
new file mode 100644
index 00000000..962ee2fb
--- /dev/null
+++ b/internal/database/ent/db/authnonce_query.go
@@ -0,0 +1,548 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"fmt"
+	"math"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/authnonce"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+)
+
+// AuthNonceQuery is the builder for querying AuthNonce entities.
+type AuthNonceQuery struct {
+	config
+	ctx        *QueryContext
+	order      []authnonce.OrderOption
+	inters     []Interceptor
+	predicates []predicate.AuthNonce
+	modifiers  []func(*sql.Selector)
+	// intermediate query (i.e. traversal path).
+	sql  *sql.Selector
+	path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the AuthNonceQuery builder.
+func (anq *AuthNonceQuery) Where(ps ...predicate.AuthNonce) *AuthNonceQuery {
+	anq.predicates = append(anq.predicates, ps...)
+	return anq
+}
+
+// Limit the number of records to be returned by this query.
+func (anq *AuthNonceQuery) Limit(limit int) *AuthNonceQuery {
+	anq.ctx.Limit = &limit
+	return anq
+}
+
+// Offset to start from.
+func (anq *AuthNonceQuery) Offset(offset int) *AuthNonceQuery {
+	anq.ctx.Offset = &offset
+	return anq
+}
+
+// Unique configures the query builder to filter duplicate records on query.
+// By default, unique is set to true, and can be disabled using this method.
+func (anq *AuthNonceQuery) Unique(unique bool) *AuthNonceQuery {
+	anq.ctx.Unique = &unique
+	return anq
+}
+
+// Order specifies how the records should be ordered.
+func (anq *AuthNonceQuery) Order(o ...authnonce.OrderOption) *AuthNonceQuery {
+	anq.order = append(anq.order, o...)
+	return anq
+}
+
+// First returns the first AuthNonce entity from the query.
+// Returns a *NotFoundError when no AuthNonce was found.
+func (anq *AuthNonceQuery) First(ctx context.Context) (*AuthNonce, error) {
+	nodes, err := anq.Limit(1).All(setContextOp(ctx, anq.ctx, "First"))
+	if err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nil, &NotFoundError{authnonce.Label}
+	}
+	return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (anq *AuthNonceQuery) FirstX(ctx context.Context) *AuthNonce {
+	node, err := anq.First(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return node
+}
+
+// FirstID returns the first AuthNonce ID from the query.
+// Returns a *NotFoundError when no AuthNonce ID was found.
+func (anq *AuthNonceQuery) FirstID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = anq.Limit(1).IDs(setContextOp(ctx, anq.ctx, "FirstID")); err != nil {
+		return
+	}
+	if len(ids) == 0 {
+		err = &NotFoundError{authnonce.Label}
+		return
+	}
+	return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (anq *AuthNonceQuery) FirstIDX(ctx context.Context) string {
+	id, err := anq.FirstID(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return id
+}
+
+// Only returns a single AuthNonce entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one AuthNonce entity is found.
+// Returns a *NotFoundError when no AuthNonce entities are found.
+func (anq *AuthNonceQuery) Only(ctx context.Context) (*AuthNonce, error) {
+	nodes, err := anq.Limit(2).All(setContextOp(ctx, anq.ctx, "Only"))
+	if err != nil {
+		return nil, err
+	}
+	switch len(nodes) {
+	case 1:
+		return nodes[0], nil
+	case 0:
+		return nil, &NotFoundError{authnonce.Label}
+	default:
+		return nil, &NotSingularError{authnonce.Label}
+	}
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (anq *AuthNonceQuery) OnlyX(ctx context.Context) *AuthNonce {
+	node, err := anq.Only(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// OnlyID is like Only, but returns the only AuthNonce ID in the query.
+// Returns a *NotSingularError when more than one AuthNonce ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (anq *AuthNonceQuery) OnlyID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = anq.Limit(2).IDs(setContextOp(ctx, anq.ctx, "OnlyID")); err != nil {
+		return
+	}
+	switch len(ids) {
+	case 1:
+		id = ids[0]
+	case 0:
+		err = &NotFoundError{authnonce.Label}
+	default:
+		err = &NotSingularError{authnonce.Label}
+	}
+	return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (anq *AuthNonceQuery) OnlyIDX(ctx context.Context) string {
+	id, err := anq.OnlyID(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return id
+}
+
+// All executes the query and returns a list of AuthNonces.
+func (anq *AuthNonceQuery) All(ctx context.Context) ([]*AuthNonce, error) {
+	ctx = setContextOp(ctx, anq.ctx, "All")
+	if err := anq.prepareQuery(ctx); err != nil {
+		return nil, err
+	}
+	qr := querierAll[[]*AuthNonce, *AuthNonceQuery]()
+	return withInterceptors[[]*AuthNonce](ctx, anq, qr, anq.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (anq *AuthNonceQuery) AllX(ctx context.Context) []*AuthNonce {
+	nodes, err := anq.All(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return nodes
+}
+
+// IDs executes the query and returns a list of AuthNonce IDs.
+func (anq *AuthNonceQuery) IDs(ctx context.Context) (ids []string, err error) {
+	if anq.ctx.Unique == nil && anq.path != nil {
+		anq.Unique(true)
+	}
+	ctx = setContextOp(ctx, anq.ctx, "IDs")
+	if err = anq.Select(authnonce.FieldID).Scan(ctx, &ids); err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (anq *AuthNonceQuery) IDsX(ctx context.Context) []string {
+	ids, err := anq.IDs(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return ids
+}
+
+// Count returns the count of the given query.
+func (anq *AuthNonceQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, anq.ctx, "Count")
+	if err := anq.prepareQuery(ctx); err != nil {
+		return 0, err
+	}
+	return withInterceptors[int](ctx, anq, querierCount[*AuthNonceQuery](), anq.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (anq *AuthNonceQuery) CountX(ctx context.Context) int {
+	count, err := anq.Count(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (anq *AuthNonceQuery) Exist(ctx context.Context) (bool, error) {
+	ctx = setContextOp(ctx, anq.ctx, "Exist")
+	switch _, err := anq.FirstID(ctx); {
+	case IsNotFound(err):
+		return false, nil
+	case err != nil:
+		return false, fmt.Errorf("db: check existence: %w", err)
+	default:
+		return true, nil
+	}
+}
+
+// ExistX is like Exist, but panics if an error occurs.
+func (anq *AuthNonceQuery) ExistX(ctx context.Context) bool {
+	exist, err := anq.Exist(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return exist
+}
+
+// Clone returns a duplicate of the AuthNonceQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (anq *AuthNonceQuery) Clone() *AuthNonceQuery {
+	if anq == nil {
+		return nil
+	}
+	return &AuthNonceQuery{
+		config:     anq.config,
+		ctx:        anq.ctx.Clone(),
+		order:      append([]authnonce.OrderOption{}, anq.order...),
+		inters:     append([]Interceptor{}, anq.inters...),
+		predicates: append([]predicate.AuthNonce{}, anq.predicates...),
+		// clone intermediate query.
+		sql:  anq.sql.Clone(),
+		path: anq.path,
+	}
+}
+
+// GroupBy is used to group vertices by one or more fields/columns.
+// It is often used with aggregate functions, like: count, max, mean, min, sum.
+//
+// Example:
+//
+//	var v []struct {
+//		CreatedAt time.Time `json:"created_at,omitempty"`
+//		Count int `json:"count,omitempty"`
+//	}
+//
+//	client.AuthNonce.Query().
+//		GroupBy(authnonce.FieldCreatedAt).
+//		Aggregate(db.Count()).
+//		Scan(ctx, &v)
+func (anq *AuthNonceQuery) GroupBy(field string, fields ...string) *AuthNonceGroupBy {
+	anq.ctx.Fields = append([]string{field}, fields...)
+	grbuild := &AuthNonceGroupBy{build: anq}
+	grbuild.flds = &anq.ctx.Fields
+	grbuild.label = authnonce.Label
+	grbuild.scan = grbuild.Scan
+	return grbuild
+}
+
+// Select allows the selection one or more fields/columns for the given query,
+// instead of selecting all fields in the entity.
+//
+// Example:
+//
+//	var v []struct {
+//		CreatedAt time.Time `json:"created_at,omitempty"`
+//	}
+//
+//	client.AuthNonce.Query().
+//		Select(authnonce.FieldCreatedAt).
+//		Scan(ctx, &v)
+func (anq *AuthNonceQuery) Select(fields ...string) *AuthNonceSelect {
+	anq.ctx.Fields = append(anq.ctx.Fields, fields...)
+	sbuild := &AuthNonceSelect{AuthNonceQuery: anq}
+	sbuild.label = authnonce.Label
+	sbuild.flds, sbuild.scan = &anq.ctx.Fields, sbuild.Scan
+	return sbuild
+}
+
+// Aggregate returns a AuthNonceSelect configured with the given aggregations.
+func (anq *AuthNonceQuery) Aggregate(fns ...AggregateFunc) *AuthNonceSelect {
+	return anq.Select().Aggregate(fns...)
+}
+
+func (anq *AuthNonceQuery) prepareQuery(ctx context.Context) error {
+	for _, inter := range anq.inters {
+		if inter == nil {
+			return fmt.Errorf("db: uninitialized interceptor (forgotten import db/runtime?)")
+		}
+		if trv, ok := inter.(Traverser); ok {
+			if err := trv.Traverse(ctx, anq); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range anq.ctx.Fields {
+		if !authnonce.ValidColumn(f) {
+			return &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+		}
+	}
+	if anq.path != nil {
+		prev, err := anq.path(ctx)
+		if err != nil {
+			return err
+		}
+		anq.sql = prev
+	}
+	return nil
+}
+
+func (anq *AuthNonceQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*AuthNonce, error) {
+	var (
+		nodes = []*AuthNonce{}
+		_spec = anq.querySpec()
+	)
+	_spec.ScanValues = func(columns []string) ([]any, error) {
+		return (*AuthNonce).scanValues(nil, columns)
+	}
+	_spec.Assign = func(columns []string, values []any) error {
+		node := &AuthNonce{config: anq.config}
+		nodes = append(nodes, node)
+		return node.assignValues(columns, values)
+	}
+	if len(anq.modifiers) > 0 {
+		_spec.Modifiers = anq.modifiers
+	}
+	for i := range hooks {
+		hooks[i](ctx, _spec)
+	}
+	if err := sqlgraph.QueryNodes(ctx, anq.driver, _spec); err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nodes, nil
+	}
+	return nodes, nil
+}
+
+func (anq *AuthNonceQuery) sqlCount(ctx context.Context) (int, error) {
+	_spec := anq.querySpec()
+	if len(anq.modifiers) > 0 {
+		_spec.Modifiers = anq.modifiers
+	}
+	_spec.Node.Columns = anq.ctx.Fields
+	if len(anq.ctx.Fields) > 0 {
+		_spec.Unique = anq.ctx.Unique != nil && *anq.ctx.Unique
+	}
+	return sqlgraph.CountNodes(ctx, anq.driver, _spec)
+}
+
+func (anq *AuthNonceQuery) querySpec() *sqlgraph.QuerySpec {
+	_spec := sqlgraph.NewQuerySpec(authnonce.Table, authnonce.Columns, sqlgraph.NewFieldSpec(authnonce.FieldID, field.TypeString))
+	_spec.From = anq.sql
+	if unique := anq.ctx.Unique; unique != nil {
+		_spec.Unique = *unique
+	} else if anq.path != nil {
+		_spec.Unique = true
+	}
+	if fields := anq.ctx.Fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, authnonce.FieldID)
+		for i := range fields {
+			if fields[i] != authnonce.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+			}
+		}
+	}
+	if ps := anq.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if limit := anq.ctx.Limit; limit != nil {
+		_spec.Limit = *limit
+	}
+	if offset := anq.ctx.Offset; offset != nil {
+		_spec.Offset = *offset
+	}
+	if ps := anq.order; len(ps) > 0 {
+		_spec.Order = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	return _spec
+}
+
+func (anq *AuthNonceQuery) sqlQuery(ctx context.Context) *sql.Selector {
+	builder := sql.Dialect(anq.driver.Dialect())
+	t1 := builder.Table(authnonce.Table)
+	columns := anq.ctx.Fields
+	if len(columns) == 0 {
+		columns = authnonce.Columns
+	}
+	selector := builder.Select(t1.Columns(columns...)...).From(t1)
+	if anq.sql != nil {
+		selector = anq.sql
+		selector.Select(selector.Columns(columns...)...)
+	}
+	if anq.ctx.Unique != nil && *anq.ctx.Unique {
+		selector.Distinct()
+	}
+	for _, m := range anq.modifiers {
+		m(selector)
+	}
+	for _, p := range anq.predicates {
+		p(selector)
+	}
+	for _, p := range anq.order {
+		p(selector)
+	}
+	if offset := anq.ctx.Offset; offset != nil {
+		// limit is mandatory for offset clause. We start
+		// with default value, and override it below if needed.
+		selector.Offset(*offset).Limit(math.MaxInt32)
+	}
+	if limit := anq.ctx.Limit; limit != nil {
+		selector.Limit(*limit)
+	}
+	return selector
+}
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (anq *AuthNonceQuery) Modify(modifiers ...func(s *sql.Selector)) *AuthNonceSelect {
+	anq.modifiers = append(anq.modifiers, modifiers...)
+	return anq.Select()
+}
+
+// AuthNonceGroupBy is the group-by builder for AuthNonce entities.
+type AuthNonceGroupBy struct {
+	selector
+	build *AuthNonceQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (angb *AuthNonceGroupBy) Aggregate(fns ...AggregateFunc) *AuthNonceGroupBy {
+	angb.fns = append(angb.fns, fns...)
+	return angb
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (angb *AuthNonceGroupBy) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, angb.build.ctx, "GroupBy")
+	if err := angb.build.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*AuthNonceQuery, *AuthNonceGroupBy](ctx, angb.build, angb, angb.build.inters, v)
+}
+
+func (angb *AuthNonceGroupBy) sqlScan(ctx context.Context, root *AuthNonceQuery, v any) error {
+	selector := root.sqlQuery(ctx).Select()
+	aggregation := make([]string, 0, len(angb.fns))
+	for _, fn := range angb.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*angb.flds)+len(angb.fns))
+		for _, f := range *angb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*angb.flds...)...)
+	if err := selector.Err(); err != nil {
+		return err
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := angb.build.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
+
+// AuthNonceSelect is the builder for selecting fields of AuthNonce entities.
+type AuthNonceSelect struct {
+	*AuthNonceQuery
+	selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (ans *AuthNonceSelect) Aggregate(fns ...AggregateFunc) *AuthNonceSelect {
+	ans.fns = append(ans.fns, fns...)
+	return ans
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (ans *AuthNonceSelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, ans.ctx, "Select")
+	if err := ans.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*AuthNonceQuery, *AuthNonceSelect](ctx, ans.AuthNonceQuery, ans, ans.inters, v)
+}
+
+func (ans *AuthNonceSelect) sqlScan(ctx context.Context, root *AuthNonceQuery, v any) error {
+	selector := root.sqlQuery(ctx)
+	aggregation := make([]string, 0, len(ans.fns))
+	for _, fn := range ans.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	switch n := len(*ans.selector.flds); {
+	case n == 0 && len(aggregation) > 0:
+		selector.Select(aggregation...)
+	case n != 0 && len(aggregation) > 0:
+		selector.AppendSelect(aggregation...)
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := ans.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (ans *AuthNonceSelect) Modify(modifiers ...func(s *sql.Selector)) *AuthNonceSelect {
+	ans.modifiers = append(ans.modifiers, modifiers...)
+	return ans
+}
diff --git a/internal/database/ent/db/authnonce_update.go b/internal/database/ent/db/authnonce_update.go
new file mode 100644
index 00000000..70f5b091
--- /dev/null
+++ b/internal/database/ent/db/authnonce_update.go
@@ -0,0 +1,280 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/authnonce"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+)
+
+// AuthNonceUpdate is the builder for updating AuthNonce entities.
+type AuthNonceUpdate struct {
+	config
+	hooks     []Hook
+	mutation  *AuthNonceMutation
+	modifiers []func(*sql.UpdateBuilder)
+}
+
+// Where appends a list predicates to the AuthNonceUpdate builder.
+func (anu *AuthNonceUpdate) Where(ps ...predicate.AuthNonce) *AuthNonceUpdate {
+	anu.mutation.Where(ps...)
+	return anu
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (anu *AuthNonceUpdate) SetUpdatedAt(t time.Time) *AuthNonceUpdate {
+	anu.mutation.SetUpdatedAt(t)
+	return anu
+}
+
+// SetActive sets the "active" field.
+func (anu *AuthNonceUpdate) SetActive(b bool) *AuthNonceUpdate {
+	anu.mutation.SetActive(b)
+	return anu
+}
+
+// SetNillableActive sets the "active" field if the given value is not nil.
+func (anu *AuthNonceUpdate) SetNillableActive(b *bool) *AuthNonceUpdate {
+	if b != nil {
+		anu.SetActive(*b)
+	}
+	return anu
+}
+
+// SetMetadata sets the "metadata" field.
+func (anu *AuthNonceUpdate) SetMetadata(m map[string]string) *AuthNonceUpdate {
+	anu.mutation.SetMetadata(m)
+	return anu
+}
+
+// Mutation returns the AuthNonceMutation object of the builder.
+func (anu *AuthNonceUpdate) Mutation() *AuthNonceMutation {
+	return anu.mutation
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (anu *AuthNonceUpdate) Save(ctx context.Context) (int, error) {
+	anu.defaults()
+	return withHooks(ctx, anu.sqlSave, anu.mutation, anu.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (anu *AuthNonceUpdate) SaveX(ctx context.Context) int {
+	affected, err := anu.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return affected
+}
+
+// Exec executes the query.
+func (anu *AuthNonceUpdate) Exec(ctx context.Context) error {
+	_, err := anu.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (anu *AuthNonceUpdate) ExecX(ctx context.Context) {
+	if err := anu.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (anu *AuthNonceUpdate) defaults() {
+	if _, ok := anu.mutation.UpdatedAt(); !ok {
+		v := authnonce.UpdateDefaultUpdatedAt()
+		anu.mutation.SetUpdatedAt(v)
+	}
+}
+
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (anu *AuthNonceUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *AuthNonceUpdate {
+	anu.modifiers = append(anu.modifiers, modifiers...)
+	return anu
+}
+
+func (anu *AuthNonceUpdate) sqlSave(ctx context.Context) (n int, err error) {
+	_spec := sqlgraph.NewUpdateSpec(authnonce.Table, authnonce.Columns, sqlgraph.NewFieldSpec(authnonce.FieldID, field.TypeString))
+	if ps := anu.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := anu.mutation.UpdatedAt(); ok {
+		_spec.SetField(authnonce.FieldUpdatedAt, field.TypeTime, value)
+	}
+	if value, ok := anu.mutation.Active(); ok {
+		_spec.SetField(authnonce.FieldActive, field.TypeBool, value)
+	}
+	if value, ok := anu.mutation.Metadata(); ok {
+		_spec.SetField(authnonce.FieldMetadata, field.TypeJSON, value)
+	}
+	_spec.AddModifiers(anu.modifiers...)
+	if n, err = sqlgraph.UpdateNodes(ctx, anu.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{authnonce.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return 0, err
+	}
+	anu.mutation.done = true
+	return n, nil
+}
+
+// AuthNonceUpdateOne is the builder for updating a single AuthNonce entity.
+type AuthNonceUpdateOne struct {
+	config
+	fields    []string
+	hooks     []Hook
+	mutation  *AuthNonceMutation
+	modifiers []func(*sql.UpdateBuilder)
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (anuo *AuthNonceUpdateOne) SetUpdatedAt(t time.Time) *AuthNonceUpdateOne {
+	anuo.mutation.SetUpdatedAt(t)
+	return anuo
+}
+
+// SetActive sets the "active" field.
+func (anuo *AuthNonceUpdateOne) SetActive(b bool) *AuthNonceUpdateOne {
+	anuo.mutation.SetActive(b)
+	return anuo
+}
+
+// SetNillableActive sets the "active" field if the given value is not nil.
+func (anuo *AuthNonceUpdateOne) SetNillableActive(b *bool) *AuthNonceUpdateOne {
+	if b != nil {
+		anuo.SetActive(*b)
+	}
+	return anuo
+}
+
+// SetMetadata sets the "metadata" field.
+func (anuo *AuthNonceUpdateOne) SetMetadata(m map[string]string) *AuthNonceUpdateOne {
+	anuo.mutation.SetMetadata(m)
+	return anuo
+}
+
+// Mutation returns the AuthNonceMutation object of the builder.
+func (anuo *AuthNonceUpdateOne) Mutation() *AuthNonceMutation {
+	return anuo.mutation
+}
+
+// Where appends a list predicates to the AuthNonceUpdate builder.
+func (anuo *AuthNonceUpdateOne) Where(ps ...predicate.AuthNonce) *AuthNonceUpdateOne {
+	anuo.mutation.Where(ps...)
+	return anuo
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (anuo *AuthNonceUpdateOne) Select(field string, fields ...string) *AuthNonceUpdateOne {
+	anuo.fields = append([]string{field}, fields...)
+	return anuo
+}
+
+// Save executes the query and returns the updated AuthNonce entity.
+func (anuo *AuthNonceUpdateOne) Save(ctx context.Context) (*AuthNonce, error) {
+	anuo.defaults()
+	return withHooks(ctx, anuo.sqlSave, anuo.mutation, anuo.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (anuo *AuthNonceUpdateOne) SaveX(ctx context.Context) *AuthNonce {
+	node, err := anuo.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// Exec executes the query on the entity.
+func (anuo *AuthNonceUpdateOne) Exec(ctx context.Context) error {
+	_, err := anuo.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (anuo *AuthNonceUpdateOne) ExecX(ctx context.Context) {
+	if err := anuo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (anuo *AuthNonceUpdateOne) defaults() {
+	if _, ok := anuo.mutation.UpdatedAt(); !ok {
+		v := authnonce.UpdateDefaultUpdatedAt()
+		anuo.mutation.SetUpdatedAt(v)
+	}
+}
+
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (anuo *AuthNonceUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *AuthNonceUpdateOne {
+	anuo.modifiers = append(anuo.modifiers, modifiers...)
+	return anuo
+}
+
+func (anuo *AuthNonceUpdateOne) sqlSave(ctx context.Context) (_node *AuthNonce, err error) {
+	_spec := sqlgraph.NewUpdateSpec(authnonce.Table, authnonce.Columns, sqlgraph.NewFieldSpec(authnonce.FieldID, field.TypeString))
+	id, ok := anuo.mutation.ID()
+	if !ok {
+		return nil, &ValidationError{Name: "id", err: errors.New(`db: missing "AuthNonce.id" for update`)}
+	}
+	_spec.Node.ID.Value = id
+	if fields := anuo.fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, authnonce.FieldID)
+		for _, f := range fields {
+			if !authnonce.ValidColumn(f) {
+				return nil, &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+			}
+			if f != authnonce.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, f)
+			}
+		}
+	}
+	if ps := anuo.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := anuo.mutation.UpdatedAt(); ok {
+		_spec.SetField(authnonce.FieldUpdatedAt, field.TypeTime, value)
+	}
+	if value, ok := anuo.mutation.Active(); ok {
+		_spec.SetField(authnonce.FieldActive, field.TypeBool, value)
+	}
+	if value, ok := anuo.mutation.Metadata(); ok {
+		_spec.SetField(authnonce.FieldMetadata, field.TypeJSON, value)
+	}
+	_spec.AddModifiers(anuo.modifiers...)
+	_node = &AuthNonce{config: anuo.config}
+	_spec.Assign = _node.assignValues
+	_spec.ScanValues = _node.scanValues
+	if err = sqlgraph.UpdateNode(ctx, anuo.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{authnonce.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	anuo.mutation.done = true
+	return _node, nil
+}
diff --git a/internal/database/ent/db/client.go b/internal/database/ent/db/client.go
index 2d0eb667..f179636d 100644
--- a/internal/database/ent/db/client.go
+++ b/internal/database/ent/db/client.go
@@ -20,9 +20,11 @@ import (
 	"github.com/cufee/aftermath/internal/database/ent/db/achievementssnapshot"
 	"github.com/cufee/aftermath/internal/database/ent/db/appconfiguration"
 	"github.com/cufee/aftermath/internal/database/ent/db/applicationcommand"
+	"github.com/cufee/aftermath/internal/database/ent/db/authnonce"
 	"github.com/cufee/aftermath/internal/database/ent/db/clan"
 	"github.com/cufee/aftermath/internal/database/ent/db/crontask"
 	"github.com/cufee/aftermath/internal/database/ent/db/discordinteraction"
+	"github.com/cufee/aftermath/internal/database/ent/db/session"
 	"github.com/cufee/aftermath/internal/database/ent/db/user"
 	"github.com/cufee/aftermath/internal/database/ent/db/userconnection"
 	"github.com/cufee/aftermath/internal/database/ent/db/usercontent"
@@ -49,12 +51,16 @@ type Client struct {
 	AppConfiguration *AppConfigurationClient
 	// ApplicationCommand is the client for interacting with the ApplicationCommand builders.
 	ApplicationCommand *ApplicationCommandClient
+	// AuthNonce is the client for interacting with the AuthNonce builders.
+	AuthNonce *AuthNonceClient
 	// Clan is the client for interacting with the Clan builders.
 	Clan *ClanClient
 	// CronTask is the client for interacting with the CronTask builders.
 	CronTask *CronTaskClient
 	// DiscordInteraction is the client for interacting with the DiscordInteraction builders.
 	DiscordInteraction *DiscordInteractionClient
+	// Session is the client for interacting with the Session builders.
+	Session *SessionClient
 	// User is the client for interacting with the User builders.
 	User *UserClient
 	// UserConnection is the client for interacting with the UserConnection builders.
@@ -85,9 +91,11 @@ func (c *Client) init() {
 	c.AchievementsSnapshot = NewAchievementsSnapshotClient(c.config)
 	c.AppConfiguration = NewAppConfigurationClient(c.config)
 	c.ApplicationCommand = NewApplicationCommandClient(c.config)
+	c.AuthNonce = NewAuthNonceClient(c.config)
 	c.Clan = NewClanClient(c.config)
 	c.CronTask = NewCronTaskClient(c.config)
 	c.DiscordInteraction = NewDiscordInteractionClient(c.config)
+	c.Session = NewSessionClient(c.config)
 	c.User = NewUserClient(c.config)
 	c.UserConnection = NewUserConnectionClient(c.config)
 	c.UserContent = NewUserContentClient(c.config)
@@ -192,9 +200,11 @@ func (c *Client) Tx(ctx context.Context) (*Tx, error) {
 		AchievementsSnapshot: NewAchievementsSnapshotClient(cfg),
 		AppConfiguration:     NewAppConfigurationClient(cfg),
 		ApplicationCommand:   NewApplicationCommandClient(cfg),
+		AuthNonce:            NewAuthNonceClient(cfg),
 		Clan:                 NewClanClient(cfg),
 		CronTask:             NewCronTaskClient(cfg),
 		DiscordInteraction:   NewDiscordInteractionClient(cfg),
+		Session:              NewSessionClient(cfg),
 		User:                 NewUserClient(cfg),
 		UserConnection:       NewUserConnectionClient(cfg),
 		UserContent:          NewUserContentClient(cfg),
@@ -226,9 +236,11 @@ func (c *Client) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error)
 		AchievementsSnapshot: NewAchievementsSnapshotClient(cfg),
 		AppConfiguration:     NewAppConfigurationClient(cfg),
 		ApplicationCommand:   NewApplicationCommandClient(cfg),
+		AuthNonce:            NewAuthNonceClient(cfg),
 		Clan:                 NewClanClient(cfg),
 		CronTask:             NewCronTaskClient(cfg),
 		DiscordInteraction:   NewDiscordInteractionClient(cfg),
+		Session:              NewSessionClient(cfg),
 		User:                 NewUserClient(cfg),
 		UserConnection:       NewUserConnectionClient(cfg),
 		UserContent:          NewUserContentClient(cfg),
@@ -266,9 +278,9 @@ func (c *Client) Close() error {
 func (c *Client) Use(hooks ...Hook) {
 	for _, n := range []interface{ Use(...Hook) }{
 		c.Account, c.AccountSnapshot, c.AchievementsSnapshot, c.AppConfiguration,
-		c.ApplicationCommand, c.Clan, c.CronTask, c.DiscordInteraction, c.User,
-		c.UserConnection, c.UserContent, c.UserSubscription, c.Vehicle,
-		c.VehicleAverage, c.VehicleSnapshot,
+		c.ApplicationCommand, c.AuthNonce, c.Clan, c.CronTask, c.DiscordInteraction,
+		c.Session, c.User, c.UserConnection, c.UserContent, c.UserSubscription,
+		c.Vehicle, c.VehicleAverage, c.VehicleSnapshot,
 	} {
 		n.Use(hooks...)
 	}
@@ -279,9 +291,9 @@ func (c *Client) Use(hooks ...Hook) {
 func (c *Client) Intercept(interceptors ...Interceptor) {
 	for _, n := range []interface{ Intercept(...Interceptor) }{
 		c.Account, c.AccountSnapshot, c.AchievementsSnapshot, c.AppConfiguration,
-		c.ApplicationCommand, c.Clan, c.CronTask, c.DiscordInteraction, c.User,
-		c.UserConnection, c.UserContent, c.UserSubscription, c.Vehicle,
-		c.VehicleAverage, c.VehicleSnapshot,
+		c.ApplicationCommand, c.AuthNonce, c.Clan, c.CronTask, c.DiscordInteraction,
+		c.Session, c.User, c.UserConnection, c.UserContent, c.UserSubscription,
+		c.Vehicle, c.VehicleAverage, c.VehicleSnapshot,
 	} {
 		n.Intercept(interceptors...)
 	}
@@ -300,12 +312,16 @@ func (c *Client) Mutate(ctx context.Context, m Mutation) (Value, error) {
 		return c.AppConfiguration.mutate(ctx, m)
 	case *ApplicationCommandMutation:
 		return c.ApplicationCommand.mutate(ctx, m)
+	case *AuthNonceMutation:
+		return c.AuthNonce.mutate(ctx, m)
 	case *ClanMutation:
 		return c.Clan.mutate(ctx, m)
 	case *CronTaskMutation:
 		return c.CronTask.mutate(ctx, m)
 	case *DiscordInteractionMutation:
 		return c.DiscordInteraction.mutate(ctx, m)
+	case *SessionMutation:
+		return c.Session.mutate(ctx, m)
 	case *UserMutation:
 		return c.User.mutate(ctx, m)
 	case *UserConnectionMutation:
@@ -1086,6 +1102,139 @@ func (c *ApplicationCommandClient) mutate(ctx context.Context, m *ApplicationCom
 	}
 }
 
+// AuthNonceClient is a client for the AuthNonce schema.
+type AuthNonceClient struct {
+	config
+}
+
+// NewAuthNonceClient returns a client for the AuthNonce from the given config.
+func NewAuthNonceClient(c config) *AuthNonceClient {
+	return &AuthNonceClient{config: c}
+}
+
+// Use adds a list of mutation hooks to the hooks stack.
+// A call to `Use(f, g, h)` equals to `authnonce.Hooks(f(g(h())))`.
+func (c *AuthNonceClient) Use(hooks ...Hook) {
+	c.hooks.AuthNonce = append(c.hooks.AuthNonce, hooks...)
+}
+
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `authnonce.Intercept(f(g(h())))`.
+func (c *AuthNonceClient) Intercept(interceptors ...Interceptor) {
+	c.inters.AuthNonce = append(c.inters.AuthNonce, interceptors...)
+}
+
+// Create returns a builder for creating a AuthNonce entity.
+func (c *AuthNonceClient) Create() *AuthNonceCreate {
+	mutation := newAuthNonceMutation(c.config, OpCreate)
+	return &AuthNonceCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// CreateBulk returns a builder for creating a bulk of AuthNonce entities.
+func (c *AuthNonceClient) CreateBulk(builders ...*AuthNonceCreate) *AuthNonceCreateBulk {
+	return &AuthNonceCreateBulk{config: c.config, builders: builders}
+}
+
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *AuthNonceClient) MapCreateBulk(slice any, setFunc func(*AuthNonceCreate, int)) *AuthNonceCreateBulk {
+	rv := reflect.ValueOf(slice)
+	if rv.Kind() != reflect.Slice {
+		return &AuthNonceCreateBulk{err: fmt.Errorf("calling to AuthNonceClient.MapCreateBulk with wrong type %T, need slice", slice)}
+	}
+	builders := make([]*AuthNonceCreate, rv.Len())
+	for i := 0; i < rv.Len(); i++ {
+		builders[i] = c.Create()
+		setFunc(builders[i], i)
+	}
+	return &AuthNonceCreateBulk{config: c.config, builders: builders}
+}
+
+// Update returns an update builder for AuthNonce.
+func (c *AuthNonceClient) Update() *AuthNonceUpdate {
+	mutation := newAuthNonceMutation(c.config, OpUpdate)
+	return &AuthNonceUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOne returns an update builder for the given entity.
+func (c *AuthNonceClient) UpdateOne(an *AuthNonce) *AuthNonceUpdateOne {
+	mutation := newAuthNonceMutation(c.config, OpUpdateOne, withAuthNonce(an))
+	return &AuthNonceUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOneID returns an update builder for the given id.
+func (c *AuthNonceClient) UpdateOneID(id string) *AuthNonceUpdateOne {
+	mutation := newAuthNonceMutation(c.config, OpUpdateOne, withAuthNonceID(id))
+	return &AuthNonceUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// Delete returns a delete builder for AuthNonce.
+func (c *AuthNonceClient) Delete() *AuthNonceDelete {
+	mutation := newAuthNonceMutation(c.config, OpDelete)
+	return &AuthNonceDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// DeleteOne returns a builder for deleting the given entity.
+func (c *AuthNonceClient) DeleteOne(an *AuthNonce) *AuthNonceDeleteOne {
+	return c.DeleteOneID(an.ID)
+}
+
+// DeleteOneID returns a builder for deleting the given entity by its id.
+func (c *AuthNonceClient) DeleteOneID(id string) *AuthNonceDeleteOne {
+	builder := c.Delete().Where(authnonce.ID(id))
+	builder.mutation.id = &id
+	builder.mutation.op = OpDeleteOne
+	return &AuthNonceDeleteOne{builder}
+}
+
+// Query returns a query builder for AuthNonce.
+func (c *AuthNonceClient) Query() *AuthNonceQuery {
+	return &AuthNonceQuery{
+		config: c.config,
+		ctx:    &QueryContext{Type: TypeAuthNonce},
+		inters: c.Interceptors(),
+	}
+}
+
+// Get returns a AuthNonce entity by its id.
+func (c *AuthNonceClient) Get(ctx context.Context, id string) (*AuthNonce, error) {
+	return c.Query().Where(authnonce.ID(id)).Only(ctx)
+}
+
+// GetX is like Get, but panics if an error occurs.
+func (c *AuthNonceClient) GetX(ctx context.Context, id string) *AuthNonce {
+	obj, err := c.Get(ctx, id)
+	if err != nil {
+		panic(err)
+	}
+	return obj
+}
+
+// Hooks returns the client hooks.
+func (c *AuthNonceClient) Hooks() []Hook {
+	return c.hooks.AuthNonce
+}
+
+// Interceptors returns the client interceptors.
+func (c *AuthNonceClient) Interceptors() []Interceptor {
+	return c.inters.AuthNonce
+}
+
+func (c *AuthNonceClient) mutate(ctx context.Context, m *AuthNonceMutation) (Value, error) {
+	switch m.Op() {
+	case OpCreate:
+		return (&AuthNonceCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdate:
+		return (&AuthNonceUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdateOne:
+		return (&AuthNonceUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpDelete, OpDeleteOne:
+		return (&AuthNonceDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+	default:
+		return nil, fmt.Errorf("db: unknown AuthNonce mutation op: %q", m.Op())
+	}
+}
+
 // ClanClient is a client for the Clan schema.
 type ClanClient struct {
 	config
@@ -1517,6 +1666,155 @@ func (c *DiscordInteractionClient) mutate(ctx context.Context, m *DiscordInterac
 	}
 }
 
+// SessionClient is a client for the Session schema.
+type SessionClient struct {
+	config
+}
+
+// NewSessionClient returns a client for the Session from the given config.
+func NewSessionClient(c config) *SessionClient {
+	return &SessionClient{config: c}
+}
+
+// Use adds a list of mutation hooks to the hooks stack.
+// A call to `Use(f, g, h)` equals to `session.Hooks(f(g(h())))`.
+func (c *SessionClient) Use(hooks ...Hook) {
+	c.hooks.Session = append(c.hooks.Session, hooks...)
+}
+
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `session.Intercept(f(g(h())))`.
+func (c *SessionClient) Intercept(interceptors ...Interceptor) {
+	c.inters.Session = append(c.inters.Session, interceptors...)
+}
+
+// Create returns a builder for creating a Session entity.
+func (c *SessionClient) Create() *SessionCreate {
+	mutation := newSessionMutation(c.config, OpCreate)
+	return &SessionCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// CreateBulk returns a builder for creating a bulk of Session entities.
+func (c *SessionClient) CreateBulk(builders ...*SessionCreate) *SessionCreateBulk {
+	return &SessionCreateBulk{config: c.config, builders: builders}
+}
+
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *SessionClient) MapCreateBulk(slice any, setFunc func(*SessionCreate, int)) *SessionCreateBulk {
+	rv := reflect.ValueOf(slice)
+	if rv.Kind() != reflect.Slice {
+		return &SessionCreateBulk{err: fmt.Errorf("calling to SessionClient.MapCreateBulk with wrong type %T, need slice", slice)}
+	}
+	builders := make([]*SessionCreate, rv.Len())
+	for i := 0; i < rv.Len(); i++ {
+		builders[i] = c.Create()
+		setFunc(builders[i], i)
+	}
+	return &SessionCreateBulk{config: c.config, builders: builders}
+}
+
+// Update returns an update builder for Session.
+func (c *SessionClient) Update() *SessionUpdate {
+	mutation := newSessionMutation(c.config, OpUpdate)
+	return &SessionUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOne returns an update builder for the given entity.
+func (c *SessionClient) UpdateOne(s *Session) *SessionUpdateOne {
+	mutation := newSessionMutation(c.config, OpUpdateOne, withSession(s))
+	return &SessionUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOneID returns an update builder for the given id.
+func (c *SessionClient) UpdateOneID(id string) *SessionUpdateOne {
+	mutation := newSessionMutation(c.config, OpUpdateOne, withSessionID(id))
+	return &SessionUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// Delete returns a delete builder for Session.
+func (c *SessionClient) Delete() *SessionDelete {
+	mutation := newSessionMutation(c.config, OpDelete)
+	return &SessionDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// DeleteOne returns a builder for deleting the given entity.
+func (c *SessionClient) DeleteOne(s *Session) *SessionDeleteOne {
+	return c.DeleteOneID(s.ID)
+}
+
+// DeleteOneID returns a builder for deleting the given entity by its id.
+func (c *SessionClient) DeleteOneID(id string) *SessionDeleteOne {
+	builder := c.Delete().Where(session.ID(id))
+	builder.mutation.id = &id
+	builder.mutation.op = OpDeleteOne
+	return &SessionDeleteOne{builder}
+}
+
+// Query returns a query builder for Session.
+func (c *SessionClient) Query() *SessionQuery {
+	return &SessionQuery{
+		config: c.config,
+		ctx:    &QueryContext{Type: TypeSession},
+		inters: c.Interceptors(),
+	}
+}
+
+// Get returns a Session entity by its id.
+func (c *SessionClient) Get(ctx context.Context, id string) (*Session, error) {
+	return c.Query().Where(session.ID(id)).Only(ctx)
+}
+
+// GetX is like Get, but panics if an error occurs.
+func (c *SessionClient) GetX(ctx context.Context, id string) *Session {
+	obj, err := c.Get(ctx, id)
+	if err != nil {
+		panic(err)
+	}
+	return obj
+}
+
+// QueryUser queries the user edge of a Session.
+func (c *SessionClient) QueryUser(s *Session) *UserQuery {
+	query := (&UserClient{config: c.config}).Query()
+	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+		id := s.ID
+		step := sqlgraph.NewStep(
+			sqlgraph.From(session.Table, session.FieldID, id),
+			sqlgraph.To(user.Table, user.FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, session.UserTable, session.UserColumn),
+		)
+		fromV = sqlgraph.Neighbors(s.driver.Dialect(), step)
+		return fromV, nil
+	}
+	return query
+}
+
+// Hooks returns the client hooks.
+func (c *SessionClient) Hooks() []Hook {
+	return c.hooks.Session
+}
+
+// Interceptors returns the client interceptors.
+func (c *SessionClient) Interceptors() []Interceptor {
+	return c.inters.Session
+}
+
+func (c *SessionClient) mutate(ctx context.Context, m *SessionMutation) (Value, error) {
+	switch m.Op() {
+	case OpCreate:
+		return (&SessionCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdate:
+		return (&SessionUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdateOne:
+		return (&SessionUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpDelete, OpDeleteOne:
+		return (&SessionDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+	default:
+		return nil, fmt.Errorf("db: unknown Session mutation op: %q", m.Op())
+	}
+}
+
 // UserClient is a client for the User schema.
 type UserClient struct {
 	config
@@ -1689,6 +1987,22 @@ func (c *UserClient) QueryContent(u *User) *UserContentQuery {
 	return query
 }
 
+// QuerySessions queries the sessions edge of a User.
+func (c *UserClient) QuerySessions(u *User) *SessionQuery {
+	query := (&SessionClient{config: c.config}).Query()
+	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+		id := u.ID
+		step := sqlgraph.NewStep(
+			sqlgraph.From(user.Table, user.FieldID, id),
+			sqlgraph.To(session.Table, session.FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, user.SessionsTable, user.SessionsColumn),
+		)
+		fromV = sqlgraph.Neighbors(u.driver.Dialect(), step)
+		return fromV, nil
+	}
+	return query
+}
+
 // Hooks returns the client hooks.
 func (c *UserClient) Hooks() []Hook {
 	return c.hooks.User
@@ -2580,14 +2894,14 @@ func (c *VehicleSnapshotClient) mutate(ctx context.Context, m *VehicleSnapshotMu
 type (
 	hooks struct {
 		Account, AccountSnapshot, AchievementsSnapshot, AppConfiguration,
-		ApplicationCommand, Clan, CronTask, DiscordInteraction, User, UserConnection,
-		UserContent, UserSubscription, Vehicle, VehicleAverage,
+		ApplicationCommand, AuthNonce, Clan, CronTask, DiscordInteraction, Session,
+		User, UserConnection, UserContent, UserSubscription, Vehicle, VehicleAverage,
 		VehicleSnapshot []ent.Hook
 	}
 	inters struct {
 		Account, AccountSnapshot, AchievementsSnapshot, AppConfiguration,
-		ApplicationCommand, Clan, CronTask, DiscordInteraction, User, UserConnection,
-		UserContent, UserSubscription, Vehicle, VehicleAverage,
+		ApplicationCommand, AuthNonce, Clan, CronTask, DiscordInteraction, Session,
+		User, UserConnection, UserContent, UserSubscription, Vehicle, VehicleAverage,
 		VehicleSnapshot []ent.Interceptor
 	}
 )
diff --git a/internal/database/ent/db/ent.go b/internal/database/ent/db/ent.go
index 22bd881e..8bae5108 100644
--- a/internal/database/ent/db/ent.go
+++ b/internal/database/ent/db/ent.go
@@ -17,9 +17,11 @@ import (
 	"github.com/cufee/aftermath/internal/database/ent/db/achievementssnapshot"
 	"github.com/cufee/aftermath/internal/database/ent/db/appconfiguration"
 	"github.com/cufee/aftermath/internal/database/ent/db/applicationcommand"
+	"github.com/cufee/aftermath/internal/database/ent/db/authnonce"
 	"github.com/cufee/aftermath/internal/database/ent/db/clan"
 	"github.com/cufee/aftermath/internal/database/ent/db/crontask"
 	"github.com/cufee/aftermath/internal/database/ent/db/discordinteraction"
+	"github.com/cufee/aftermath/internal/database/ent/db/session"
 	"github.com/cufee/aftermath/internal/database/ent/db/user"
 	"github.com/cufee/aftermath/internal/database/ent/db/userconnection"
 	"github.com/cufee/aftermath/internal/database/ent/db/usercontent"
@@ -92,9 +94,11 @@ func checkColumn(table, column string) error {
 			achievementssnapshot.Table: achievementssnapshot.ValidColumn,
 			appconfiguration.Table:     appconfiguration.ValidColumn,
 			applicationcommand.Table:   applicationcommand.ValidColumn,
+			authnonce.Table:            authnonce.ValidColumn,
 			clan.Table:                 clan.ValidColumn,
 			crontask.Table:             crontask.ValidColumn,
 			discordinteraction.Table:   discordinteraction.ValidColumn,
+			session.Table:              session.ValidColumn,
 			user.Table:                 user.ValidColumn,
 			userconnection.Table:       userconnection.ValidColumn,
 			usercontent.Table:          usercontent.ValidColumn,
diff --git a/internal/database/ent/db/expose.go b/internal/database/ent/db/expose.go
index 4cc0d120..cffec5a4 100644
--- a/internal/database/ent/db/expose.go
+++ b/internal/database/ent/db/expose.go
@@ -69,6 +69,19 @@ func (ac *ApplicationCommand) ScanValues(columns []string) ([]any, error) {
 	return ac.scanValues(columns)
 }
 
+func (an *AuthNonce) AssignValues(columns []string, values []any) error {
+	if an == nil {
+		return fmt.Errorf("AuthNonce(nil)")
+	}
+	return an.assignValues(columns, values)
+}
+func (an *AuthNonce) ScanValues(columns []string) ([]any, error) {
+	if an == nil {
+		return nil, fmt.Errorf("AuthNonce(nil)")
+	}
+	return an.scanValues(columns)
+}
+
 func (c *Clan) AssignValues(columns []string, values []any) error {
 	if c == nil {
 		return fmt.Errorf("Clan(nil)")
@@ -108,6 +121,19 @@ func (di *DiscordInteraction) ScanValues(columns []string) ([]any, error) {
 	return di.scanValues(columns)
 }
 
+func (s *Session) AssignValues(columns []string, values []any) error {
+	if s == nil {
+		return fmt.Errorf("Session(nil)")
+	}
+	return s.assignValues(columns, values)
+}
+func (s *Session) ScanValues(columns []string) ([]any, error) {
+	if s == nil {
+		return nil, fmt.Errorf("Session(nil)")
+	}
+	return s.scanValues(columns)
+}
+
 func (u *User) AssignValues(columns []string, values []any) error {
 	if u == nil {
 		return fmt.Errorf("User(nil)")
diff --git a/internal/database/ent/db/hook/hook.go b/internal/database/ent/db/hook/hook.go
index f3a9e239..ab57723e 100644
--- a/internal/database/ent/db/hook/hook.go
+++ b/internal/database/ent/db/hook/hook.go
@@ -69,6 +69,18 @@ func (f ApplicationCommandFunc) Mutate(ctx context.Context, m db.Mutation) (db.V
 	return nil, fmt.Errorf("unexpected mutation type %T. expect *db.ApplicationCommandMutation", m)
 }
 
+// The AuthNonceFunc type is an adapter to allow the use of ordinary
+// function as AuthNonce mutator.
+type AuthNonceFunc func(context.Context, *db.AuthNonceMutation) (db.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f AuthNonceFunc) Mutate(ctx context.Context, m db.Mutation) (db.Value, error) {
+	if mv, ok := m.(*db.AuthNonceMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *db.AuthNonceMutation", m)
+}
+
 // The ClanFunc type is an adapter to allow the use of ordinary
 // function as Clan mutator.
 type ClanFunc func(context.Context, *db.ClanMutation) (db.Value, error)
@@ -105,6 +117,18 @@ func (f DiscordInteractionFunc) Mutate(ctx context.Context, m db.Mutation) (db.V
 	return nil, fmt.Errorf("unexpected mutation type %T. expect *db.DiscordInteractionMutation", m)
 }
 
+// The SessionFunc type is an adapter to allow the use of ordinary
+// function as Session mutator.
+type SessionFunc func(context.Context, *db.SessionMutation) (db.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f SessionFunc) Mutate(ctx context.Context, m db.Mutation) (db.Value, error) {
+	if mv, ok := m.(*db.SessionMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *db.SessionMutation", m)
+}
+
 // The UserFunc type is an adapter to allow the use of ordinary
 // function as User mutator.
 type UserFunc func(context.Context, *db.UserMutation) (db.Value, error)
diff --git a/internal/database/ent/db/migrate/schema.go b/internal/database/ent/db/migrate/schema.go
index 8017db8f..095dfa27 100644
--- a/internal/database/ent/db/migrate/schema.go
+++ b/internal/database/ent/db/migrate/schema.go
@@ -85,7 +85,7 @@ var (
 				Symbol:     "account_snapshots_accounts_account_snapshots",
 				Columns:    []*schema.Column{AccountSnapshotsColumns[10]},
 				RefColumns: []*schema.Column{AccountsColumns[0]},
-				OnDelete:   schema.NoAction,
+				OnDelete:   schema.Cascade,
 			},
 		},
 		Indexes: []*schema.Index{
@@ -138,7 +138,7 @@ var (
 				Symbol:     "achievements_snapshots_accounts_achievement_snapshots",
 				Columns:    []*schema.Column{AchievementsSnapshotsColumns[8]},
 				RefColumns: []*schema.Column{AccountsColumns[0]},
-				OnDelete:   schema.NoAction,
+				OnDelete:   schema.Cascade,
 			},
 		},
 		Indexes: []*schema.Index{
@@ -218,6 +218,30 @@ var (
 			},
 		},
 	}
+	// AuthNoncesColumns holds the columns for the "auth_nonces" table.
+	AuthNoncesColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeString, Unique: true},
+		{Name: "created_at", Type: field.TypeTime},
+		{Name: "updated_at", Type: field.TypeTime},
+		{Name: "active", Type: field.TypeBool},
+		{Name: "expires_at", Type: field.TypeTime},
+		{Name: "identifier", Type: field.TypeString},
+		{Name: "public_id", Type: field.TypeString, Unique: true},
+		{Name: "metadata", Type: field.TypeJSON},
+	}
+	// AuthNoncesTable holds the schema information for the "auth_nonces" table.
+	AuthNoncesTable = &schema.Table{
+		Name:       "auth_nonces",
+		Columns:    AuthNoncesColumns,
+		PrimaryKey: []*schema.Column{AuthNoncesColumns[0]},
+		Indexes: []*schema.Index{
+			{
+				Name:    "authnonce_public_id_active_expires_at",
+				Unique:  false,
+				Columns: []*schema.Column{AuthNoncesColumns[6], AuthNoncesColumns[3], AuthNoncesColumns[4]},
+			},
+		},
+	}
 	// ClansColumns holds the columns for the "clans" table.
 	ClansColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeString, Unique: true},
@@ -321,7 +345,7 @@ var (
 				Symbol:     "discord_interactions_users_discord_interactions",
 				Columns:    []*schema.Column{DiscordInteractionsColumns[8]},
 				RefColumns: []*schema.Column{UsersColumns[0]},
-				OnDelete:   schema.NoAction,
+				OnDelete:   schema.Cascade,
 			},
 		},
 		Indexes: []*schema.Index{
@@ -352,11 +376,43 @@ var (
 			},
 		},
 	}
+	// SessionsColumns holds the columns for the "sessions" table.
+	SessionsColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeString, Unique: true},
+		{Name: "created_at", Type: field.TypeTime},
+		{Name: "updated_at", Type: field.TypeTime},
+		{Name: "expires_at", Type: field.TypeTime},
+		{Name: "public_id", Type: field.TypeString, Unique: true},
+		{Name: "metadata", Type: field.TypeJSON},
+		{Name: "user_id", Type: field.TypeString},
+	}
+	// SessionsTable holds the schema information for the "sessions" table.
+	SessionsTable = &schema.Table{
+		Name:       "sessions",
+		Columns:    SessionsColumns,
+		PrimaryKey: []*schema.Column{SessionsColumns[0]},
+		ForeignKeys: []*schema.ForeignKey{
+			{
+				Symbol:     "sessions_users_sessions",
+				Columns:    []*schema.Column{SessionsColumns[6]},
+				RefColumns: []*schema.Column{UsersColumns[0]},
+				OnDelete:   schema.Cascade,
+			},
+		},
+		Indexes: []*schema.Index{
+			{
+				Name:    "session_public_id_expires_at",
+				Unique:  false,
+				Columns: []*schema.Column{SessionsColumns[4], SessionsColumns[3]},
+			},
+		},
+	}
 	// UsersColumns holds the columns for the "users" table.
 	UsersColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeString, Unique: true},
 		{Name: "created_at", Type: field.TypeTime},
 		{Name: "updated_at", Type: field.TypeTime},
+		{Name: "username", Type: field.TypeString, Default: ""},
 		{Name: "permissions", Type: field.TypeString, Default: ""},
 		{Name: "feature_flags", Type: field.TypeJSON, Nullable: true},
 	}
@@ -371,6 +427,11 @@ var (
 				Unique:  false,
 				Columns: []*schema.Column{UsersColumns[0]},
 			},
+			{
+				Name:    "user_username",
+				Unique:  false,
+				Columns: []*schema.Column{UsersColumns[3]},
+			},
 		},
 	}
 	// UserConnectionsColumns holds the columns for the "user_connections" table.
@@ -394,7 +455,7 @@ var (
 				Symbol:     "user_connections_users_connections",
 				Columns:    []*schema.Column{UserConnectionsColumns[7]},
 				RefColumns: []*schema.Column{UsersColumns[0]},
-				OnDelete:   schema.NoAction,
+				OnDelete:   schema.Cascade,
 			},
 		},
 		Indexes: []*schema.Index{
@@ -451,7 +512,7 @@ var (
 				Symbol:     "user_contents_users_content",
 				Columns:    []*schema.Column{UserContentsColumns[7]},
 				RefColumns: []*schema.Column{UsersColumns[0]},
-				OnDelete:   schema.NoAction,
+				OnDelete:   schema.Cascade,
 			},
 		},
 		Indexes: []*schema.Index{
@@ -503,7 +564,7 @@ var (
 				Symbol:     "user_subscriptions_users_subscriptions",
 				Columns:    []*schema.Column{UserSubscriptionsColumns[7]},
 				RefColumns: []*schema.Column{UsersColumns[0]},
-				OnDelete:   schema.NoAction,
+				OnDelete:   schema.Cascade,
 			},
 		},
 		Indexes: []*schema.Index{
@@ -598,7 +659,7 @@ var (
 				Symbol:     "vehicle_snapshots_accounts_vehicle_snapshots",
 				Columns:    []*schema.Column{VehicleSnapshotsColumns[9]},
 				RefColumns: []*schema.Column{AccountsColumns[0]},
-				OnDelete:   schema.NoAction,
+				OnDelete:   schema.Cascade,
 			},
 		},
 		Indexes: []*schema.Index{
@@ -636,9 +697,11 @@ var (
 		AchievementsSnapshotsTable,
 		AppConfigurationsTable,
 		ApplicationCommandsTable,
+		AuthNoncesTable,
 		ClansTable,
 		CronTasksTable,
 		DiscordInteractionsTable,
+		SessionsTable,
 		UsersTable,
 		UserConnectionsTable,
 		UserContentsTable,
@@ -654,6 +717,7 @@ func init() {
 	AccountSnapshotsTable.ForeignKeys[0].RefTable = AccountsTable
 	AchievementsSnapshotsTable.ForeignKeys[0].RefTable = AccountsTable
 	DiscordInteractionsTable.ForeignKeys[0].RefTable = UsersTable
+	SessionsTable.ForeignKeys[0].RefTable = UsersTable
 	UserConnectionsTable.ForeignKeys[0].RefTable = UsersTable
 	UserContentsTable.ForeignKeys[0].RefTable = UsersTable
 	UserSubscriptionsTable.ForeignKeys[0].RefTable = UsersTable
diff --git a/internal/database/ent/db/mutation.go b/internal/database/ent/db/mutation.go
index 15855c1d..148fcef9 100644
--- a/internal/database/ent/db/mutation.go
+++ b/internal/database/ent/db/mutation.go
@@ -16,10 +16,12 @@ import (
 	"github.com/cufee/aftermath/internal/database/ent/db/achievementssnapshot"
 	"github.com/cufee/aftermath/internal/database/ent/db/appconfiguration"
 	"github.com/cufee/aftermath/internal/database/ent/db/applicationcommand"
+	"github.com/cufee/aftermath/internal/database/ent/db/authnonce"
 	"github.com/cufee/aftermath/internal/database/ent/db/clan"
 	"github.com/cufee/aftermath/internal/database/ent/db/crontask"
 	"github.com/cufee/aftermath/internal/database/ent/db/discordinteraction"
 	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/ent/db/session"
 	"github.com/cufee/aftermath/internal/database/ent/db/user"
 	"github.com/cufee/aftermath/internal/database/ent/db/userconnection"
 	"github.com/cufee/aftermath/internal/database/ent/db/usercontent"
@@ -46,9 +48,11 @@ const (
 	TypeAchievementsSnapshot = "AchievementsSnapshot"
 	TypeAppConfiguration     = "AppConfiguration"
 	TypeApplicationCommand   = "ApplicationCommand"
+	TypeAuthNonce            = "AuthNonce"
 	TypeClan                 = "Clan"
 	TypeCronTask             = "CronTask"
 	TypeDiscordInteraction   = "DiscordInteraction"
+	TypeSession              = "Session"
 	TypeUser                 = "User"
 	TypeUserConnection       = "UserConnection"
 	TypeUserContent          = "UserContent"
@@ -3954,39 +3958,36 @@ func (m *ApplicationCommandMutation) ResetEdge(name string) error {
 	return fmt.Errorf("unknown ApplicationCommand edge %s", name)
 }
 
-// ClanMutation represents an operation that mutates the Clan nodes in the graph.
-type ClanMutation struct {
+// AuthNonceMutation represents an operation that mutates the AuthNonce nodes in the graph.
+type AuthNonceMutation struct {
 	config
-	op              Op
-	typ             string
-	id              *string
-	created_at      *time.Time
-	updated_at      *time.Time
-	tag             *string
-	name            *string
-	emblem_id       *string
-	members         *[]string
-	appendmembers   []string
-	clearedFields   map[string]struct{}
-	accounts        map[string]struct{}
-	removedaccounts map[string]struct{}
-	clearedaccounts bool
-	done            bool
-	oldValue        func(context.Context) (*Clan, error)
-	predicates      []predicate.Clan
+	op            Op
+	typ           string
+	id            *string
+	created_at    *time.Time
+	updated_at    *time.Time
+	active        *bool
+	expires_at    *time.Time
+	identifier    *string
+	public_id     *string
+	metadata      *map[string]string
+	clearedFields map[string]struct{}
+	done          bool
+	oldValue      func(context.Context) (*AuthNonce, error)
+	predicates    []predicate.AuthNonce
 }
 
-var _ ent.Mutation = (*ClanMutation)(nil)
+var _ ent.Mutation = (*AuthNonceMutation)(nil)
 
-// clanOption allows management of the mutation configuration using functional options.
-type clanOption func(*ClanMutation)
+// authnonceOption allows management of the mutation configuration using functional options.
+type authnonceOption func(*AuthNonceMutation)
 
-// newClanMutation creates new mutation for the Clan entity.
-func newClanMutation(c config, op Op, opts ...clanOption) *ClanMutation {
-	m := &ClanMutation{
+// newAuthNonceMutation creates new mutation for the AuthNonce entity.
+func newAuthNonceMutation(c config, op Op, opts ...authnonceOption) *AuthNonceMutation {
+	m := &AuthNonceMutation{
 		config:        c,
 		op:            op,
-		typ:           TypeClan,
+		typ:           TypeAuthNonce,
 		clearedFields: make(map[string]struct{}),
 	}
 	for _, opt := range opts {
@@ -3995,20 +3996,20 @@ func newClanMutation(c config, op Op, opts ...clanOption) *ClanMutation {
 	return m
 }
 
-// withClanID sets the ID field of the mutation.
-func withClanID(id string) clanOption {
-	return func(m *ClanMutation) {
+// withAuthNonceID sets the ID field of the mutation.
+func withAuthNonceID(id string) authnonceOption {
+	return func(m *AuthNonceMutation) {
 		var (
 			err   error
 			once  sync.Once
-			value *Clan
+			value *AuthNonce
 		)
-		m.oldValue = func(ctx context.Context) (*Clan, error) {
+		m.oldValue = func(ctx context.Context) (*AuthNonce, error) {
 			once.Do(func() {
 				if m.done {
 					err = errors.New("querying old values post mutation is not allowed")
 				} else {
-					value, err = m.Client().Clan.Get(ctx, id)
+					value, err = m.Client().AuthNonce.Get(ctx, id)
 				}
 			})
 			return value, err
@@ -4017,10 +4018,10 @@ func withClanID(id string) clanOption {
 	}
 }
 
-// withClan sets the old Clan of the mutation.
-func withClan(node *Clan) clanOption {
-	return func(m *ClanMutation) {
-		m.oldValue = func(context.Context) (*Clan, error) {
+// withAuthNonce sets the old AuthNonce of the mutation.
+func withAuthNonce(node *AuthNonce) authnonceOption {
+	return func(m *AuthNonceMutation) {
+		m.oldValue = func(context.Context) (*AuthNonce, error) {
 			return node, nil
 		}
 		m.id = &node.ID
@@ -4029,7 +4030,7 @@ func withClan(node *Clan) clanOption {
 
 // Client returns a new `ent.Client` from the mutation. If the mutation was
 // executed in a transaction (ent.Tx), a transactional client is returned.
-func (m ClanMutation) Client() *Client {
+func (m AuthNonceMutation) Client() *Client {
 	client := &Client{config: m.config}
 	client.init()
 	return client
@@ -4037,7 +4038,7 @@ func (m ClanMutation) Client() *Client {
 
 // Tx returns an `ent.Tx` for mutations that were executed in transactions;
 // it returns an error otherwise.
-func (m ClanMutation) Tx() (*Tx, error) {
+func (m AuthNonceMutation) Tx() (*Tx, error) {
 	if _, ok := m.driver.(*txDriver); !ok {
 		return nil, errors.New("db: mutation is not running in a transaction")
 	}
@@ -4047,14 +4048,14 @@ func (m ClanMutation) Tx() (*Tx, error) {
 }
 
 // SetID sets the value of the id field. Note that this
-// operation is only accepted on creation of Clan entities.
-func (m *ClanMutation) SetID(id string) {
+// operation is only accepted on creation of AuthNonce entities.
+func (m *AuthNonceMutation) SetID(id string) {
 	m.id = &id
 }
 
 // ID returns the ID value in the mutation. Note that the ID is only available
 // if it was provided to the builder or after it was returned from the database.
-func (m *ClanMutation) ID() (id string, exists bool) {
+func (m *AuthNonceMutation) ID() (id string, exists bool) {
 	if m.id == nil {
 		return
 	}
@@ -4065,7 +4066,7 @@ func (m *ClanMutation) ID() (id string, exists bool) {
 // That means, if the mutation is applied within a transaction with an isolation level such
 // as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
 // or updated by the mutation.
-func (m *ClanMutation) IDs(ctx context.Context) ([]string, error) {
+func (m *AuthNonceMutation) IDs(ctx context.Context) ([]string, error) {
 	switch {
 	case m.op.Is(OpUpdateOne | OpDeleteOne):
 		id, exists := m.ID()
@@ -4074,19 +4075,19 @@ func (m *ClanMutation) IDs(ctx context.Context) ([]string, error) {
 		}
 		fallthrough
 	case m.op.Is(OpUpdate | OpDelete):
-		return m.Client().Clan.Query().Where(m.predicates...).IDs(ctx)
+		return m.Client().AuthNonce.Query().Where(m.predicates...).IDs(ctx)
 	default:
 		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
 	}
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (m *ClanMutation) SetCreatedAt(t time.Time) {
+func (m *AuthNonceMutation) SetCreatedAt(t time.Time) {
 	m.created_at = &t
 }
 
 // CreatedAt returns the value of the "created_at" field in the mutation.
-func (m *ClanMutation) CreatedAt() (r time.Time, exists bool) {
+func (m *AuthNonceMutation) CreatedAt() (r time.Time, exists bool) {
 	v := m.created_at
 	if v == nil {
 		return
@@ -4094,10 +4095,10 @@ func (m *ClanMutation) CreatedAt() (r time.Time, exists bool) {
 	return *v, true
 }
 
-// OldCreatedAt returns the old "created_at" field's value of the Clan entity.
-// If the Clan object wasn't provided to the builder, the object is fetched from the database.
+// OldCreatedAt returns the old "created_at" field's value of the AuthNonce entity.
+// If the AuthNonce object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *ClanMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
+func (m *AuthNonceMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
 	}
@@ -4112,17 +4113,17 @@ func (m *ClanMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error
 }
 
 // ResetCreatedAt resets all changes to the "created_at" field.
-func (m *ClanMutation) ResetCreatedAt() {
+func (m *AuthNonceMutation) ResetCreatedAt() {
 	m.created_at = nil
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (m *ClanMutation) SetUpdatedAt(t time.Time) {
+func (m *AuthNonceMutation) SetUpdatedAt(t time.Time) {
 	m.updated_at = &t
 }
 
 // UpdatedAt returns the value of the "updated_at" field in the mutation.
-func (m *ClanMutation) UpdatedAt() (r time.Time, exists bool) {
+func (m *AuthNonceMutation) UpdatedAt() (r time.Time, exists bool) {
 	v := m.updated_at
 	if v == nil {
 		return
@@ -4130,10 +4131,10 @@ func (m *ClanMutation) UpdatedAt() (r time.Time, exists bool) {
 	return *v, true
 }
 
-// OldUpdatedAt returns the old "updated_at" field's value of the Clan entity.
-// If the Clan object wasn't provided to the builder, the object is fetched from the database.
+// OldUpdatedAt returns the old "updated_at" field's value of the AuthNonce entity.
+// If the AuthNonce object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *ClanMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
+func (m *AuthNonceMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
 	}
@@ -4148,245 +4149,199 @@ func (m *ClanMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error
 }
 
 // ResetUpdatedAt resets all changes to the "updated_at" field.
-func (m *ClanMutation) ResetUpdatedAt() {
+func (m *AuthNonceMutation) ResetUpdatedAt() {
 	m.updated_at = nil
 }
 
-// SetTag sets the "tag" field.
-func (m *ClanMutation) SetTag(s string) {
-	m.tag = &s
+// SetActive sets the "active" field.
+func (m *AuthNonceMutation) SetActive(b bool) {
+	m.active = &b
 }
 
-// Tag returns the value of the "tag" field in the mutation.
-func (m *ClanMutation) Tag() (r string, exists bool) {
-	v := m.tag
+// Active returns the value of the "active" field in the mutation.
+func (m *AuthNonceMutation) Active() (r bool, exists bool) {
+	v := m.active
 	if v == nil {
 		return
 	}
 	return *v, true
 }
 
-// OldTag returns the old "tag" field's value of the Clan entity.
-// If the Clan object wasn't provided to the builder, the object is fetched from the database.
+// OldActive returns the old "active" field's value of the AuthNonce entity.
+// If the AuthNonce object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *ClanMutation) OldTag(ctx context.Context) (v string, err error) {
+func (m *AuthNonceMutation) OldActive(ctx context.Context) (v bool, err error) {
 	if !m.op.Is(OpUpdateOne) {
-		return v, errors.New("OldTag is only allowed on UpdateOne operations")
+		return v, errors.New("OldActive is only allowed on UpdateOne operations")
 	}
 	if m.id == nil || m.oldValue == nil {
-		return v, errors.New("OldTag requires an ID field in the mutation")
+		return v, errors.New("OldActive requires an ID field in the mutation")
 	}
 	oldValue, err := m.oldValue(ctx)
 	if err != nil {
-		return v, fmt.Errorf("querying old value for OldTag: %w", err)
+		return v, fmt.Errorf("querying old value for OldActive: %w", err)
 	}
-	return oldValue.Tag, nil
+	return oldValue.Active, nil
 }
 
-// ResetTag resets all changes to the "tag" field.
-func (m *ClanMutation) ResetTag() {
-	m.tag = nil
+// ResetActive resets all changes to the "active" field.
+func (m *AuthNonceMutation) ResetActive() {
+	m.active = nil
 }
 
-// SetName sets the "name" field.
-func (m *ClanMutation) SetName(s string) {
-	m.name = &s
+// SetExpiresAt sets the "expires_at" field.
+func (m *AuthNonceMutation) SetExpiresAt(t time.Time) {
+	m.expires_at = &t
 }
 
-// Name returns the value of the "name" field in the mutation.
-func (m *ClanMutation) Name() (r string, exists bool) {
-	v := m.name
+// ExpiresAt returns the value of the "expires_at" field in the mutation.
+func (m *AuthNonceMutation) ExpiresAt() (r time.Time, exists bool) {
+	v := m.expires_at
 	if v == nil {
 		return
 	}
 	return *v, true
 }
 
-// OldName returns the old "name" field's value of the Clan entity.
-// If the Clan object wasn't provided to the builder, the object is fetched from the database.
+// OldExpiresAt returns the old "expires_at" field's value of the AuthNonce entity.
+// If the AuthNonce object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *ClanMutation) OldName(ctx context.Context) (v string, err error) {
+func (m *AuthNonceMutation) OldExpiresAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
-		return v, errors.New("OldName is only allowed on UpdateOne operations")
+		return v, errors.New("OldExpiresAt is only allowed on UpdateOne operations")
 	}
 	if m.id == nil || m.oldValue == nil {
-		return v, errors.New("OldName requires an ID field in the mutation")
+		return v, errors.New("OldExpiresAt requires an ID field in the mutation")
 	}
 	oldValue, err := m.oldValue(ctx)
 	if err != nil {
-		return v, fmt.Errorf("querying old value for OldName: %w", err)
+		return v, fmt.Errorf("querying old value for OldExpiresAt: %w", err)
 	}
-	return oldValue.Name, nil
+	return oldValue.ExpiresAt, nil
 }
 
-// ResetName resets all changes to the "name" field.
-func (m *ClanMutation) ResetName() {
-	m.name = nil
+// ResetExpiresAt resets all changes to the "expires_at" field.
+func (m *AuthNonceMutation) ResetExpiresAt() {
+	m.expires_at = nil
 }
 
-// SetEmblemID sets the "emblem_id" field.
-func (m *ClanMutation) SetEmblemID(s string) {
-	m.emblem_id = &s
+// SetIdentifier sets the "identifier" field.
+func (m *AuthNonceMutation) SetIdentifier(s string) {
+	m.identifier = &s
 }
 
-// EmblemID returns the value of the "emblem_id" field in the mutation.
-func (m *ClanMutation) EmblemID() (r string, exists bool) {
-	v := m.emblem_id
+// Identifier returns the value of the "identifier" field in the mutation.
+func (m *AuthNonceMutation) Identifier() (r string, exists bool) {
+	v := m.identifier
 	if v == nil {
 		return
 	}
 	return *v, true
 }
 
-// OldEmblemID returns the old "emblem_id" field's value of the Clan entity.
-// If the Clan object wasn't provided to the builder, the object is fetched from the database.
+// OldIdentifier returns the old "identifier" field's value of the AuthNonce entity.
+// If the AuthNonce object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *ClanMutation) OldEmblemID(ctx context.Context) (v string, err error) {
+func (m *AuthNonceMutation) OldIdentifier(ctx context.Context) (v string, err error) {
 	if !m.op.Is(OpUpdateOne) {
-		return v, errors.New("OldEmblemID is only allowed on UpdateOne operations")
+		return v, errors.New("OldIdentifier is only allowed on UpdateOne operations")
 	}
 	if m.id == nil || m.oldValue == nil {
-		return v, errors.New("OldEmblemID requires an ID field in the mutation")
+		return v, errors.New("OldIdentifier requires an ID field in the mutation")
 	}
 	oldValue, err := m.oldValue(ctx)
 	if err != nil {
-		return v, fmt.Errorf("querying old value for OldEmblemID: %w", err)
+		return v, fmt.Errorf("querying old value for OldIdentifier: %w", err)
 	}
-	return oldValue.EmblemID, nil
-}
-
-// ClearEmblemID clears the value of the "emblem_id" field.
-func (m *ClanMutation) ClearEmblemID() {
-	m.emblem_id = nil
-	m.clearedFields[clan.FieldEmblemID] = struct{}{}
-}
-
-// EmblemIDCleared returns if the "emblem_id" field was cleared in this mutation.
-func (m *ClanMutation) EmblemIDCleared() bool {
-	_, ok := m.clearedFields[clan.FieldEmblemID]
-	return ok
+	return oldValue.Identifier, nil
 }
 
-// ResetEmblemID resets all changes to the "emblem_id" field.
-func (m *ClanMutation) ResetEmblemID() {
-	m.emblem_id = nil
-	delete(m.clearedFields, clan.FieldEmblemID)
+// ResetIdentifier resets all changes to the "identifier" field.
+func (m *AuthNonceMutation) ResetIdentifier() {
+	m.identifier = nil
 }
 
-// SetMembers sets the "members" field.
-func (m *ClanMutation) SetMembers(s []string) {
-	m.members = &s
-	m.appendmembers = nil
+// SetPublicID sets the "public_id" field.
+func (m *AuthNonceMutation) SetPublicID(s string) {
+	m.public_id = &s
 }
 
-// Members returns the value of the "members" field in the mutation.
-func (m *ClanMutation) Members() (r []string, exists bool) {
-	v := m.members
+// PublicID returns the value of the "public_id" field in the mutation.
+func (m *AuthNonceMutation) PublicID() (r string, exists bool) {
+	v := m.public_id
 	if v == nil {
 		return
 	}
 	return *v, true
 }
 
-// OldMembers returns the old "members" field's value of the Clan entity.
-// If the Clan object wasn't provided to the builder, the object is fetched from the database.
+// OldPublicID returns the old "public_id" field's value of the AuthNonce entity.
+// If the AuthNonce object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *ClanMutation) OldMembers(ctx context.Context) (v []string, err error) {
+func (m *AuthNonceMutation) OldPublicID(ctx context.Context) (v string, err error) {
 	if !m.op.Is(OpUpdateOne) {
-		return v, errors.New("OldMembers is only allowed on UpdateOne operations")
+		return v, errors.New("OldPublicID is only allowed on UpdateOne operations")
 	}
 	if m.id == nil || m.oldValue == nil {
-		return v, errors.New("OldMembers requires an ID field in the mutation")
+		return v, errors.New("OldPublicID requires an ID field in the mutation")
 	}
 	oldValue, err := m.oldValue(ctx)
 	if err != nil {
-		return v, fmt.Errorf("querying old value for OldMembers: %w", err)
+		return v, fmt.Errorf("querying old value for OldPublicID: %w", err)
 	}
-	return oldValue.Members, nil
-}
-
-// AppendMembers adds s to the "members" field.
-func (m *ClanMutation) AppendMembers(s []string) {
-	m.appendmembers = append(m.appendmembers, s...)
+	return oldValue.PublicID, nil
 }
 
-// AppendedMembers returns the list of values that were appended to the "members" field in this mutation.
-func (m *ClanMutation) AppendedMembers() ([]string, bool) {
-	if len(m.appendmembers) == 0 {
-		return nil, false
-	}
-	return m.appendmembers, true
+// ResetPublicID resets all changes to the "public_id" field.
+func (m *AuthNonceMutation) ResetPublicID() {
+	m.public_id = nil
 }
 
-// ResetMembers resets all changes to the "members" field.
-func (m *ClanMutation) ResetMembers() {
-	m.members = nil
-	m.appendmembers = nil
+// SetMetadata sets the "metadata" field.
+func (m *AuthNonceMutation) SetMetadata(value map[string]string) {
+	m.metadata = &value
 }
 
-// AddAccountIDs adds the "accounts" edge to the Account entity by ids.
-func (m *ClanMutation) AddAccountIDs(ids ...string) {
-	if m.accounts == nil {
-		m.accounts = make(map[string]struct{})
-	}
-	for i := range ids {
-		m.accounts[ids[i]] = struct{}{}
+// Metadata returns the value of the "metadata" field in the mutation.
+func (m *AuthNonceMutation) Metadata() (r map[string]string, exists bool) {
+	v := m.metadata
+	if v == nil {
+		return
 	}
+	return *v, true
 }
 
-// ClearAccounts clears the "accounts" edge to the Account entity.
-func (m *ClanMutation) ClearAccounts() {
-	m.clearedaccounts = true
-}
-
-// AccountsCleared reports if the "accounts" edge to the Account entity was cleared.
-func (m *ClanMutation) AccountsCleared() bool {
-	return m.clearedaccounts
-}
-
-// RemoveAccountIDs removes the "accounts" edge to the Account entity by IDs.
-func (m *ClanMutation) RemoveAccountIDs(ids ...string) {
-	if m.removedaccounts == nil {
-		m.removedaccounts = make(map[string]struct{})
-	}
-	for i := range ids {
-		delete(m.accounts, ids[i])
-		m.removedaccounts[ids[i]] = struct{}{}
+// OldMetadata returns the old "metadata" field's value of the AuthNonce entity.
+// If the AuthNonce object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *AuthNonceMutation) OldMetadata(ctx context.Context) (v map[string]string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldMetadata is only allowed on UpdateOne operations")
 	}
-}
-
-// RemovedAccounts returns the removed IDs of the "accounts" edge to the Account entity.
-func (m *ClanMutation) RemovedAccountsIDs() (ids []string) {
-	for id := range m.removedaccounts {
-		ids = append(ids, id)
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldMetadata requires an ID field in the mutation")
 	}
-	return
-}
-
-// AccountsIDs returns the "accounts" edge IDs in the mutation.
-func (m *ClanMutation) AccountsIDs() (ids []string) {
-	for id := range m.accounts {
-		ids = append(ids, id)
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldMetadata: %w", err)
 	}
-	return
+	return oldValue.Metadata, nil
 }
 
-// ResetAccounts resets all changes to the "accounts" edge.
-func (m *ClanMutation) ResetAccounts() {
-	m.accounts = nil
-	m.clearedaccounts = false
-	m.removedaccounts = nil
+// ResetMetadata resets all changes to the "metadata" field.
+func (m *AuthNonceMutation) ResetMetadata() {
+	m.metadata = nil
 }
 
-// Where appends a list predicates to the ClanMutation builder.
-func (m *ClanMutation) Where(ps ...predicate.Clan) {
+// Where appends a list predicates to the AuthNonceMutation builder.
+func (m *AuthNonceMutation) Where(ps ...predicate.AuthNonce) {
 	m.predicates = append(m.predicates, ps...)
 }
 
-// WhereP appends storage-level predicates to the ClanMutation builder. Using this method,
+// WhereP appends storage-level predicates to the AuthNonceMutation builder. Using this method,
 // users can use type-assertion to append predicates that do not depend on any generated package.
-func (m *ClanMutation) WhereP(ps ...func(*sql.Selector)) {
-	p := make([]predicate.Clan, len(ps))
+func (m *AuthNonceMutation) WhereP(ps ...func(*sql.Selector)) {
+	p := make([]predicate.AuthNonce, len(ps))
 	for i := range ps {
 		p[i] = ps[i]
 	}
@@ -4394,42 +4349,45 @@ func (m *ClanMutation) WhereP(ps ...func(*sql.Selector)) {
 }
 
 // Op returns the operation name.
-func (m *ClanMutation) Op() Op {
+func (m *AuthNonceMutation) Op() Op {
 	return m.op
 }
 
 // SetOp allows setting the mutation operation.
-func (m *ClanMutation) SetOp(op Op) {
+func (m *AuthNonceMutation) SetOp(op Op) {
 	m.op = op
 }
 
-// Type returns the node type of this mutation (Clan).
-func (m *ClanMutation) Type() string {
+// Type returns the node type of this mutation (AuthNonce).
+func (m *AuthNonceMutation) Type() string {
 	return m.typ
 }
 
 // Fields returns all fields that were changed during this mutation. Note that in
 // order to get all numeric fields that were incremented/decremented, call
 // AddedFields().
-func (m *ClanMutation) Fields() []string {
-	fields := make([]string, 0, 6)
+func (m *AuthNonceMutation) Fields() []string {
+	fields := make([]string, 0, 7)
 	if m.created_at != nil {
-		fields = append(fields, clan.FieldCreatedAt)
+		fields = append(fields, authnonce.FieldCreatedAt)
 	}
 	if m.updated_at != nil {
-		fields = append(fields, clan.FieldUpdatedAt)
+		fields = append(fields, authnonce.FieldUpdatedAt)
 	}
-	if m.tag != nil {
-		fields = append(fields, clan.FieldTag)
+	if m.active != nil {
+		fields = append(fields, authnonce.FieldActive)
 	}
-	if m.name != nil {
-		fields = append(fields, clan.FieldName)
+	if m.expires_at != nil {
+		fields = append(fields, authnonce.FieldExpiresAt)
 	}
-	if m.emblem_id != nil {
-		fields = append(fields, clan.FieldEmblemID)
+	if m.identifier != nil {
+		fields = append(fields, authnonce.FieldIdentifier)
 	}
-	if m.members != nil {
-		fields = append(fields, clan.FieldMembers)
+	if m.public_id != nil {
+		fields = append(fields, authnonce.FieldPublicID)
+	}
+	if m.metadata != nil {
+		fields = append(fields, authnonce.FieldMetadata)
 	}
 	return fields
 }
@@ -4437,20 +4395,22 @@ func (m *ClanMutation) Fields() []string {
 // Field returns the value of a field with the given name. The second boolean
 // return value indicates that this field was not set, or was not defined in the
 // schema.
-func (m *ClanMutation) Field(name string) (ent.Value, bool) {
+func (m *AuthNonceMutation) Field(name string) (ent.Value, bool) {
 	switch name {
-	case clan.FieldCreatedAt:
+	case authnonce.FieldCreatedAt:
 		return m.CreatedAt()
-	case clan.FieldUpdatedAt:
+	case authnonce.FieldUpdatedAt:
 		return m.UpdatedAt()
-	case clan.FieldTag:
-		return m.Tag()
-	case clan.FieldName:
-		return m.Name()
-	case clan.FieldEmblemID:
-		return m.EmblemID()
-	case clan.FieldMembers:
-		return m.Members()
+	case authnonce.FieldActive:
+		return m.Active()
+	case authnonce.FieldExpiresAt:
+		return m.ExpiresAt()
+	case authnonce.FieldIdentifier:
+		return m.Identifier()
+	case authnonce.FieldPublicID:
+		return m.PublicID()
+	case authnonce.FieldMetadata:
+		return m.Metadata()
 	}
 	return nil, false
 }
@@ -4458,272 +4418,235 @@ func (m *ClanMutation) Field(name string) (ent.Value, bool) {
 // OldField returns the old value of the field from the database. An error is
 // returned if the mutation operation is not UpdateOne, or the query to the
 // database failed.
-func (m *ClanMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
+func (m *AuthNonceMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
 	switch name {
-	case clan.FieldCreatedAt:
+	case authnonce.FieldCreatedAt:
 		return m.OldCreatedAt(ctx)
-	case clan.FieldUpdatedAt:
+	case authnonce.FieldUpdatedAt:
 		return m.OldUpdatedAt(ctx)
-	case clan.FieldTag:
-		return m.OldTag(ctx)
-	case clan.FieldName:
-		return m.OldName(ctx)
-	case clan.FieldEmblemID:
-		return m.OldEmblemID(ctx)
-	case clan.FieldMembers:
-		return m.OldMembers(ctx)
+	case authnonce.FieldActive:
+		return m.OldActive(ctx)
+	case authnonce.FieldExpiresAt:
+		return m.OldExpiresAt(ctx)
+	case authnonce.FieldIdentifier:
+		return m.OldIdentifier(ctx)
+	case authnonce.FieldPublicID:
+		return m.OldPublicID(ctx)
+	case authnonce.FieldMetadata:
+		return m.OldMetadata(ctx)
 	}
-	return nil, fmt.Errorf("unknown Clan field %s", name)
+	return nil, fmt.Errorf("unknown AuthNonce field %s", name)
 }
 
 // SetField sets the value of a field with the given name. It returns an error if
 // the field is not defined in the schema, or if the type mismatched the field
 // type.
-func (m *ClanMutation) SetField(name string, value ent.Value) error {
+func (m *AuthNonceMutation) SetField(name string, value ent.Value) error {
 	switch name {
-	case clan.FieldCreatedAt:
+	case authnonce.FieldCreatedAt:
 		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetCreatedAt(v)
 		return nil
-	case clan.FieldUpdatedAt:
+	case authnonce.FieldUpdatedAt:
 		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetUpdatedAt(v)
 		return nil
-	case clan.FieldTag:
-		v, ok := value.(string)
+	case authnonce.FieldActive:
+		v, ok := value.(bool)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
-		m.SetTag(v)
+		m.SetActive(v)
 		return nil
-	case clan.FieldName:
+	case authnonce.FieldExpiresAt:
+		v, ok := value.(time.Time)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetExpiresAt(v)
+		return nil
+	case authnonce.FieldIdentifier:
 		v, ok := value.(string)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
-		m.SetName(v)
+		m.SetIdentifier(v)
 		return nil
-	case clan.FieldEmblemID:
+	case authnonce.FieldPublicID:
 		v, ok := value.(string)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
-		m.SetEmblemID(v)
+		m.SetPublicID(v)
 		return nil
-	case clan.FieldMembers:
-		v, ok := value.([]string)
+	case authnonce.FieldMetadata:
+		v, ok := value.(map[string]string)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
-		m.SetMembers(v)
+		m.SetMetadata(v)
 		return nil
 	}
-	return fmt.Errorf("unknown Clan field %s", name)
+	return fmt.Errorf("unknown AuthNonce field %s", name)
 }
 
 // AddedFields returns all numeric fields that were incremented/decremented during
 // this mutation.
-func (m *ClanMutation) AddedFields() []string {
+func (m *AuthNonceMutation) AddedFields() []string {
 	return nil
 }
 
 // AddedField returns the numeric value that was incremented/decremented on a field
 // with the given name. The second boolean return value indicates that this field
 // was not set, or was not defined in the schema.
-func (m *ClanMutation) AddedField(name string) (ent.Value, bool) {
+func (m *AuthNonceMutation) AddedField(name string) (ent.Value, bool) {
 	return nil, false
 }
 
 // AddField adds the value to the field with the given name. It returns an error if
 // the field is not defined in the schema, or if the type mismatched the field
 // type.
-func (m *ClanMutation) AddField(name string, value ent.Value) error {
+func (m *AuthNonceMutation) AddField(name string, value ent.Value) error {
 	switch name {
 	}
-	return fmt.Errorf("unknown Clan numeric field %s", name)
+	return fmt.Errorf("unknown AuthNonce numeric field %s", name)
 }
 
 // ClearedFields returns all nullable fields that were cleared during this
 // mutation.
-func (m *ClanMutation) ClearedFields() []string {
-	var fields []string
-	if m.FieldCleared(clan.FieldEmblemID) {
-		fields = append(fields, clan.FieldEmblemID)
-	}
-	return fields
+func (m *AuthNonceMutation) ClearedFields() []string {
+	return nil
 }
 
 // FieldCleared returns a boolean indicating if a field with the given name was
 // cleared in this mutation.
-func (m *ClanMutation) FieldCleared(name string) bool {
+func (m *AuthNonceMutation) FieldCleared(name string) bool {
 	_, ok := m.clearedFields[name]
 	return ok
 }
 
 // ClearField clears the value of the field with the given name. It returns an
 // error if the field is not defined in the schema.
-func (m *ClanMutation) ClearField(name string) error {
-	switch name {
-	case clan.FieldEmblemID:
-		m.ClearEmblemID()
-		return nil
-	}
-	return fmt.Errorf("unknown Clan nullable field %s", name)
+func (m *AuthNonceMutation) ClearField(name string) error {
+	return fmt.Errorf("unknown AuthNonce nullable field %s", name)
 }
 
 // ResetField resets all changes in the mutation for the field with the given name.
 // It returns an error if the field is not defined in the schema.
-func (m *ClanMutation) ResetField(name string) error {
+func (m *AuthNonceMutation) ResetField(name string) error {
 	switch name {
-	case clan.FieldCreatedAt:
+	case authnonce.FieldCreatedAt:
 		m.ResetCreatedAt()
 		return nil
-	case clan.FieldUpdatedAt:
+	case authnonce.FieldUpdatedAt:
 		m.ResetUpdatedAt()
 		return nil
-	case clan.FieldTag:
-		m.ResetTag()
+	case authnonce.FieldActive:
+		m.ResetActive()
 		return nil
-	case clan.FieldName:
-		m.ResetName()
+	case authnonce.FieldExpiresAt:
+		m.ResetExpiresAt()
 		return nil
-	case clan.FieldEmblemID:
-		m.ResetEmblemID()
+	case authnonce.FieldIdentifier:
+		m.ResetIdentifier()
 		return nil
-	case clan.FieldMembers:
-		m.ResetMembers()
+	case authnonce.FieldPublicID:
+		m.ResetPublicID()
+		return nil
+	case authnonce.FieldMetadata:
+		m.ResetMetadata()
 		return nil
 	}
-	return fmt.Errorf("unknown Clan field %s", name)
+	return fmt.Errorf("unknown AuthNonce field %s", name)
 }
 
 // AddedEdges returns all edge names that were set/added in this mutation.
-func (m *ClanMutation) AddedEdges() []string {
-	edges := make([]string, 0, 1)
-	if m.accounts != nil {
-		edges = append(edges, clan.EdgeAccounts)
-	}
+func (m *AuthNonceMutation) AddedEdges() []string {
+	edges := make([]string, 0, 0)
 	return edges
 }
 
 // AddedIDs returns all IDs (to other nodes) that were added for the given edge
 // name in this mutation.
-func (m *ClanMutation) AddedIDs(name string) []ent.Value {
-	switch name {
-	case clan.EdgeAccounts:
-		ids := make([]ent.Value, 0, len(m.accounts))
-		for id := range m.accounts {
-			ids = append(ids, id)
-		}
-		return ids
-	}
+func (m *AuthNonceMutation) AddedIDs(name string) []ent.Value {
 	return nil
 }
 
 // RemovedEdges returns all edge names that were removed in this mutation.
-func (m *ClanMutation) RemovedEdges() []string {
-	edges := make([]string, 0, 1)
-	if m.removedaccounts != nil {
-		edges = append(edges, clan.EdgeAccounts)
-	}
+func (m *AuthNonceMutation) RemovedEdges() []string {
+	edges := make([]string, 0, 0)
 	return edges
 }
 
 // RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
 // the given name in this mutation.
-func (m *ClanMutation) RemovedIDs(name string) []ent.Value {
-	switch name {
-	case clan.EdgeAccounts:
-		ids := make([]ent.Value, 0, len(m.removedaccounts))
-		for id := range m.removedaccounts {
-			ids = append(ids, id)
-		}
-		return ids
-	}
+func (m *AuthNonceMutation) RemovedIDs(name string) []ent.Value {
 	return nil
 }
 
 // ClearedEdges returns all edge names that were cleared in this mutation.
-func (m *ClanMutation) ClearedEdges() []string {
-	edges := make([]string, 0, 1)
-	if m.clearedaccounts {
-		edges = append(edges, clan.EdgeAccounts)
-	}
+func (m *AuthNonceMutation) ClearedEdges() []string {
+	edges := make([]string, 0, 0)
 	return edges
 }
 
 // EdgeCleared returns a boolean which indicates if the edge with the given name
 // was cleared in this mutation.
-func (m *ClanMutation) EdgeCleared(name string) bool {
-	switch name {
-	case clan.EdgeAccounts:
-		return m.clearedaccounts
-	}
+func (m *AuthNonceMutation) EdgeCleared(name string) bool {
 	return false
 }
 
 // ClearEdge clears the value of the edge with the given name. It returns an error
 // if that edge is not defined in the schema.
-func (m *ClanMutation) ClearEdge(name string) error {
-	switch name {
-	}
-	return fmt.Errorf("unknown Clan unique edge %s", name)
+func (m *AuthNonceMutation) ClearEdge(name string) error {
+	return fmt.Errorf("unknown AuthNonce unique edge %s", name)
 }
 
 // ResetEdge resets all changes to the edge with the given name in this mutation.
 // It returns an error if the edge is not defined in the schema.
-func (m *ClanMutation) ResetEdge(name string) error {
-	switch name {
-	case clan.EdgeAccounts:
-		m.ResetAccounts()
-		return nil
-	}
-	return fmt.Errorf("unknown Clan edge %s", name)
+func (m *AuthNonceMutation) ResetEdge(name string) error {
+	return fmt.Errorf("unknown AuthNonce edge %s", name)
 }
 
-// CronTaskMutation represents an operation that mutates the CronTask nodes in the graph.
-type CronTaskMutation struct {
+// ClanMutation represents an operation that mutates the Clan nodes in the graph.
+type ClanMutation struct {
 	config
 	op              Op
 	typ             string
 	id              *string
 	created_at      *time.Time
 	updated_at      *time.Time
-	_type           *models.TaskType
-	reference_id    *string
-	targets         *[]string
-	appendtargets   []string
-	status          *models.TaskStatus
-	scheduled_after *time.Time
-	last_run        *time.Time
-	tries_left      *int
-	addtries_left   *int
-	logs            *[]models.TaskLog
-	appendlogs      []models.TaskLog
-	data            *map[string]string
+	tag             *string
+	name            *string
+	emblem_id       *string
+	members         *[]string
+	appendmembers   []string
 	clearedFields   map[string]struct{}
+	accounts        map[string]struct{}
+	removedaccounts map[string]struct{}
+	clearedaccounts bool
 	done            bool
-	oldValue        func(context.Context) (*CronTask, error)
-	predicates      []predicate.CronTask
+	oldValue        func(context.Context) (*Clan, error)
+	predicates      []predicate.Clan
 }
 
-var _ ent.Mutation = (*CronTaskMutation)(nil)
+var _ ent.Mutation = (*ClanMutation)(nil)
 
-// crontaskOption allows management of the mutation configuration using functional options.
-type crontaskOption func(*CronTaskMutation)
+// clanOption allows management of the mutation configuration using functional options.
+type clanOption func(*ClanMutation)
 
-// newCronTaskMutation creates new mutation for the CronTask entity.
-func newCronTaskMutation(c config, op Op, opts ...crontaskOption) *CronTaskMutation {
-	m := &CronTaskMutation{
+// newClanMutation creates new mutation for the Clan entity.
+func newClanMutation(c config, op Op, opts ...clanOption) *ClanMutation {
+	m := &ClanMutation{
 		config:        c,
 		op:            op,
-		typ:           TypeCronTask,
+		typ:           TypeClan,
 		clearedFields: make(map[string]struct{}),
 	}
 	for _, opt := range opts {
@@ -4732,20 +4655,20 @@ func newCronTaskMutation(c config, op Op, opts ...crontaskOption) *CronTaskMutat
 	return m
 }
 
-// withCronTaskID sets the ID field of the mutation.
-func withCronTaskID(id string) crontaskOption {
-	return func(m *CronTaskMutation) {
+// withClanID sets the ID field of the mutation.
+func withClanID(id string) clanOption {
+	return func(m *ClanMutation) {
 		var (
 			err   error
 			once  sync.Once
-			value *CronTask
+			value *Clan
 		)
-		m.oldValue = func(ctx context.Context) (*CronTask, error) {
+		m.oldValue = func(ctx context.Context) (*Clan, error) {
 			once.Do(func() {
 				if m.done {
 					err = errors.New("querying old values post mutation is not allowed")
 				} else {
-					value, err = m.Client().CronTask.Get(ctx, id)
+					value, err = m.Client().Clan.Get(ctx, id)
 				}
 			})
 			return value, err
@@ -4754,10 +4677,10 @@ func withCronTaskID(id string) crontaskOption {
 	}
 }
 
-// withCronTask sets the old CronTask of the mutation.
-func withCronTask(node *CronTask) crontaskOption {
-	return func(m *CronTaskMutation) {
-		m.oldValue = func(context.Context) (*CronTask, error) {
+// withClan sets the old Clan of the mutation.
+func withClan(node *Clan) clanOption {
+	return func(m *ClanMutation) {
+		m.oldValue = func(context.Context) (*Clan, error) {
 			return node, nil
 		}
 		m.id = &node.ID
@@ -4766,7 +4689,7 @@ func withCronTask(node *CronTask) crontaskOption {
 
 // Client returns a new `ent.Client` from the mutation. If the mutation was
 // executed in a transaction (ent.Tx), a transactional client is returned.
-func (m CronTaskMutation) Client() *Client {
+func (m ClanMutation) Client() *Client {
 	client := &Client{config: m.config}
 	client.init()
 	return client
@@ -4774,7 +4697,7 @@ func (m CronTaskMutation) Client() *Client {
 
 // Tx returns an `ent.Tx` for mutations that were executed in transactions;
 // it returns an error otherwise.
-func (m CronTaskMutation) Tx() (*Tx, error) {
+func (m ClanMutation) Tx() (*Tx, error) {
 	if _, ok := m.driver.(*txDriver); !ok {
 		return nil, errors.New("db: mutation is not running in a transaction")
 	}
@@ -4784,14 +4707,14 @@ func (m CronTaskMutation) Tx() (*Tx, error) {
 }
 
 // SetID sets the value of the id field. Note that this
-// operation is only accepted on creation of CronTask entities.
-func (m *CronTaskMutation) SetID(id string) {
+// operation is only accepted on creation of Clan entities.
+func (m *ClanMutation) SetID(id string) {
 	m.id = &id
 }
 
 // ID returns the ID value in the mutation. Note that the ID is only available
 // if it was provided to the builder or after it was returned from the database.
-func (m *CronTaskMutation) ID() (id string, exists bool) {
+func (m *ClanMutation) ID() (id string, exists bool) {
 	if m.id == nil {
 		return
 	}
@@ -4802,7 +4725,7 @@ func (m *CronTaskMutation) ID() (id string, exists bool) {
 // That means, if the mutation is applied within a transaction with an isolation level such
 // as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
 // or updated by the mutation.
-func (m *CronTaskMutation) IDs(ctx context.Context) ([]string, error) {
+func (m *ClanMutation) IDs(ctx context.Context) ([]string, error) {
 	switch {
 	case m.op.Is(OpUpdateOne | OpDeleteOne):
 		id, exists := m.ID()
@@ -4811,19 +4734,19 @@ func (m *CronTaskMutation) IDs(ctx context.Context) ([]string, error) {
 		}
 		fallthrough
 	case m.op.Is(OpUpdate | OpDelete):
-		return m.Client().CronTask.Query().Where(m.predicates...).IDs(ctx)
+		return m.Client().Clan.Query().Where(m.predicates...).IDs(ctx)
 	default:
 		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
 	}
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (m *CronTaskMutation) SetCreatedAt(t time.Time) {
+func (m *ClanMutation) SetCreatedAt(t time.Time) {
 	m.created_at = &t
 }
 
 // CreatedAt returns the value of the "created_at" field in the mutation.
-func (m *CronTaskMutation) CreatedAt() (r time.Time, exists bool) {
+func (m *ClanMutation) CreatedAt() (r time.Time, exists bool) {
 	v := m.created_at
 	if v == nil {
 		return
@@ -4831,10 +4754,10 @@ func (m *CronTaskMutation) CreatedAt() (r time.Time, exists bool) {
 	return *v, true
 }
 
-// OldCreatedAt returns the old "created_at" field's value of the CronTask entity.
-// If the CronTask object wasn't provided to the builder, the object is fetched from the database.
+// OldCreatedAt returns the old "created_at" field's value of the Clan entity.
+// If the Clan object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *CronTaskMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
+func (m *ClanMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
 	}
@@ -4849,17 +4772,17 @@ func (m *CronTaskMutation) OldCreatedAt(ctx context.Context) (v time.Time, err e
 }
 
 // ResetCreatedAt resets all changes to the "created_at" field.
-func (m *CronTaskMutation) ResetCreatedAt() {
+func (m *ClanMutation) ResetCreatedAt() {
 	m.created_at = nil
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (m *CronTaskMutation) SetUpdatedAt(t time.Time) {
+func (m *ClanMutation) SetUpdatedAt(t time.Time) {
 	m.updated_at = &t
 }
 
 // UpdatedAt returns the value of the "updated_at" field in the mutation.
-func (m *CronTaskMutation) UpdatedAt() (r time.Time, exists bool) {
+func (m *ClanMutation) UpdatedAt() (r time.Time, exists bool) {
 	v := m.updated_at
 	if v == nil {
 		return
@@ -4867,10 +4790,10 @@ func (m *CronTaskMutation) UpdatedAt() (r time.Time, exists bool) {
 	return *v, true
 }
 
-// OldUpdatedAt returns the old "updated_at" field's value of the CronTask entity.
-// If the CronTask object wasn't provided to the builder, the object is fetched from the database.
+// OldUpdatedAt returns the old "updated_at" field's value of the Clan entity.
+// If the Clan object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *CronTaskMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
+func (m *ClanMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
 	}
@@ -4885,39 +4808,776 @@ func (m *CronTaskMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err e
 }
 
 // ResetUpdatedAt resets all changes to the "updated_at" field.
-func (m *CronTaskMutation) ResetUpdatedAt() {
+func (m *ClanMutation) ResetUpdatedAt() {
 	m.updated_at = nil
 }
 
-// SetType sets the "type" field.
-func (m *CronTaskMutation) SetType(mt models.TaskType) {
-	m._type = &mt
+// SetTag sets the "tag" field.
+func (m *ClanMutation) SetTag(s string) {
+	m.tag = &s
 }
 
-// GetType returns the value of the "type" field in the mutation.
-func (m *CronTaskMutation) GetType() (r models.TaskType, exists bool) {
-	v := m._type
+// Tag returns the value of the "tag" field in the mutation.
+func (m *ClanMutation) Tag() (r string, exists bool) {
+	v := m.tag
 	if v == nil {
 		return
 	}
 	return *v, true
 }
 
-// OldType returns the old "type" field's value of the CronTask entity.
-// If the CronTask object wasn't provided to the builder, the object is fetched from the database.
+// OldTag returns the old "tag" field's value of the Clan entity.
+// If the Clan object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *CronTaskMutation) OldType(ctx context.Context) (v models.TaskType, err error) {
+func (m *ClanMutation) OldTag(ctx context.Context) (v string, err error) {
 	if !m.op.Is(OpUpdateOne) {
-		return v, errors.New("OldType is only allowed on UpdateOne operations")
+		return v, errors.New("OldTag is only allowed on UpdateOne operations")
 	}
 	if m.id == nil || m.oldValue == nil {
-		return v, errors.New("OldType requires an ID field in the mutation")
+		return v, errors.New("OldTag requires an ID field in the mutation")
 	}
 	oldValue, err := m.oldValue(ctx)
 	if err != nil {
-		return v, fmt.Errorf("querying old value for OldType: %w", err)
+		return v, fmt.Errorf("querying old value for OldTag: %w", err)
 	}
-	return oldValue.Type, nil
+	return oldValue.Tag, nil
+}
+
+// ResetTag resets all changes to the "tag" field.
+func (m *ClanMutation) ResetTag() {
+	m.tag = nil
+}
+
+// SetName sets the "name" field.
+func (m *ClanMutation) SetName(s string) {
+	m.name = &s
+}
+
+// Name returns the value of the "name" field in the mutation.
+func (m *ClanMutation) Name() (r string, exists bool) {
+	v := m.name
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldName returns the old "name" field's value of the Clan entity.
+// If the Clan object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *ClanMutation) OldName(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldName is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldName requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldName: %w", err)
+	}
+	return oldValue.Name, nil
+}
+
+// ResetName resets all changes to the "name" field.
+func (m *ClanMutation) ResetName() {
+	m.name = nil
+}
+
+// SetEmblemID sets the "emblem_id" field.
+func (m *ClanMutation) SetEmblemID(s string) {
+	m.emblem_id = &s
+}
+
+// EmblemID returns the value of the "emblem_id" field in the mutation.
+func (m *ClanMutation) EmblemID() (r string, exists bool) {
+	v := m.emblem_id
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldEmblemID returns the old "emblem_id" field's value of the Clan entity.
+// If the Clan object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *ClanMutation) OldEmblemID(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldEmblemID is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldEmblemID requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldEmblemID: %w", err)
+	}
+	return oldValue.EmblemID, nil
+}
+
+// ClearEmblemID clears the value of the "emblem_id" field.
+func (m *ClanMutation) ClearEmblemID() {
+	m.emblem_id = nil
+	m.clearedFields[clan.FieldEmblemID] = struct{}{}
+}
+
+// EmblemIDCleared returns if the "emblem_id" field was cleared in this mutation.
+func (m *ClanMutation) EmblemIDCleared() bool {
+	_, ok := m.clearedFields[clan.FieldEmblemID]
+	return ok
+}
+
+// ResetEmblemID resets all changes to the "emblem_id" field.
+func (m *ClanMutation) ResetEmblemID() {
+	m.emblem_id = nil
+	delete(m.clearedFields, clan.FieldEmblemID)
+}
+
+// SetMembers sets the "members" field.
+func (m *ClanMutation) SetMembers(s []string) {
+	m.members = &s
+	m.appendmembers = nil
+}
+
+// Members returns the value of the "members" field in the mutation.
+func (m *ClanMutation) Members() (r []string, exists bool) {
+	v := m.members
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldMembers returns the old "members" field's value of the Clan entity.
+// If the Clan object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *ClanMutation) OldMembers(ctx context.Context) (v []string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldMembers is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldMembers requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldMembers: %w", err)
+	}
+	return oldValue.Members, nil
+}
+
+// AppendMembers adds s to the "members" field.
+func (m *ClanMutation) AppendMembers(s []string) {
+	m.appendmembers = append(m.appendmembers, s...)
+}
+
+// AppendedMembers returns the list of values that were appended to the "members" field in this mutation.
+func (m *ClanMutation) AppendedMembers() ([]string, bool) {
+	if len(m.appendmembers) == 0 {
+		return nil, false
+	}
+	return m.appendmembers, true
+}
+
+// ResetMembers resets all changes to the "members" field.
+func (m *ClanMutation) ResetMembers() {
+	m.members = nil
+	m.appendmembers = nil
+}
+
+// AddAccountIDs adds the "accounts" edge to the Account entity by ids.
+func (m *ClanMutation) AddAccountIDs(ids ...string) {
+	if m.accounts == nil {
+		m.accounts = make(map[string]struct{})
+	}
+	for i := range ids {
+		m.accounts[ids[i]] = struct{}{}
+	}
+}
+
+// ClearAccounts clears the "accounts" edge to the Account entity.
+func (m *ClanMutation) ClearAccounts() {
+	m.clearedaccounts = true
+}
+
+// AccountsCleared reports if the "accounts" edge to the Account entity was cleared.
+func (m *ClanMutation) AccountsCleared() bool {
+	return m.clearedaccounts
+}
+
+// RemoveAccountIDs removes the "accounts" edge to the Account entity by IDs.
+func (m *ClanMutation) RemoveAccountIDs(ids ...string) {
+	if m.removedaccounts == nil {
+		m.removedaccounts = make(map[string]struct{})
+	}
+	for i := range ids {
+		delete(m.accounts, ids[i])
+		m.removedaccounts[ids[i]] = struct{}{}
+	}
+}
+
+// RemovedAccounts returns the removed IDs of the "accounts" edge to the Account entity.
+func (m *ClanMutation) RemovedAccountsIDs() (ids []string) {
+	for id := range m.removedaccounts {
+		ids = append(ids, id)
+	}
+	return
+}
+
+// AccountsIDs returns the "accounts" edge IDs in the mutation.
+func (m *ClanMutation) AccountsIDs() (ids []string) {
+	for id := range m.accounts {
+		ids = append(ids, id)
+	}
+	return
+}
+
+// ResetAccounts resets all changes to the "accounts" edge.
+func (m *ClanMutation) ResetAccounts() {
+	m.accounts = nil
+	m.clearedaccounts = false
+	m.removedaccounts = nil
+}
+
+// Where appends a list predicates to the ClanMutation builder.
+func (m *ClanMutation) Where(ps ...predicate.Clan) {
+	m.predicates = append(m.predicates, ps...)
+}
+
+// WhereP appends storage-level predicates to the ClanMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *ClanMutation) WhereP(ps ...func(*sql.Selector)) {
+	p := make([]predicate.Clan, len(ps))
+	for i := range ps {
+		p[i] = ps[i]
+	}
+	m.Where(p...)
+}
+
+// Op returns the operation name.
+func (m *ClanMutation) Op() Op {
+	return m.op
+}
+
+// SetOp allows setting the mutation operation.
+func (m *ClanMutation) SetOp(op Op) {
+	m.op = op
+}
+
+// Type returns the node type of this mutation (Clan).
+func (m *ClanMutation) Type() string {
+	return m.typ
+}
+
+// Fields returns all fields that were changed during this mutation. Note that in
+// order to get all numeric fields that were incremented/decremented, call
+// AddedFields().
+func (m *ClanMutation) Fields() []string {
+	fields := make([]string, 0, 6)
+	if m.created_at != nil {
+		fields = append(fields, clan.FieldCreatedAt)
+	}
+	if m.updated_at != nil {
+		fields = append(fields, clan.FieldUpdatedAt)
+	}
+	if m.tag != nil {
+		fields = append(fields, clan.FieldTag)
+	}
+	if m.name != nil {
+		fields = append(fields, clan.FieldName)
+	}
+	if m.emblem_id != nil {
+		fields = append(fields, clan.FieldEmblemID)
+	}
+	if m.members != nil {
+		fields = append(fields, clan.FieldMembers)
+	}
+	return fields
+}
+
+// Field returns the value of a field with the given name. The second boolean
+// return value indicates that this field was not set, or was not defined in the
+// schema.
+func (m *ClanMutation) Field(name string) (ent.Value, bool) {
+	switch name {
+	case clan.FieldCreatedAt:
+		return m.CreatedAt()
+	case clan.FieldUpdatedAt:
+		return m.UpdatedAt()
+	case clan.FieldTag:
+		return m.Tag()
+	case clan.FieldName:
+		return m.Name()
+	case clan.FieldEmblemID:
+		return m.EmblemID()
+	case clan.FieldMembers:
+		return m.Members()
+	}
+	return nil, false
+}
+
+// OldField returns the old value of the field from the database. An error is
+// returned if the mutation operation is not UpdateOne, or the query to the
+// database failed.
+func (m *ClanMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
+	switch name {
+	case clan.FieldCreatedAt:
+		return m.OldCreatedAt(ctx)
+	case clan.FieldUpdatedAt:
+		return m.OldUpdatedAt(ctx)
+	case clan.FieldTag:
+		return m.OldTag(ctx)
+	case clan.FieldName:
+		return m.OldName(ctx)
+	case clan.FieldEmblemID:
+		return m.OldEmblemID(ctx)
+	case clan.FieldMembers:
+		return m.OldMembers(ctx)
+	}
+	return nil, fmt.Errorf("unknown Clan field %s", name)
+}
+
+// SetField sets the value of a field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *ClanMutation) SetField(name string, value ent.Value) error {
+	switch name {
+	case clan.FieldCreatedAt:
+		v, ok := value.(time.Time)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetCreatedAt(v)
+		return nil
+	case clan.FieldUpdatedAt:
+		v, ok := value.(time.Time)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetUpdatedAt(v)
+		return nil
+	case clan.FieldTag:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetTag(v)
+		return nil
+	case clan.FieldName:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetName(v)
+		return nil
+	case clan.FieldEmblemID:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetEmblemID(v)
+		return nil
+	case clan.FieldMembers:
+		v, ok := value.([]string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetMembers(v)
+		return nil
+	}
+	return fmt.Errorf("unknown Clan field %s", name)
+}
+
+// AddedFields returns all numeric fields that were incremented/decremented during
+// this mutation.
+func (m *ClanMutation) AddedFields() []string {
+	return nil
+}
+
+// AddedField returns the numeric value that was incremented/decremented on a field
+// with the given name. The second boolean return value indicates that this field
+// was not set, or was not defined in the schema.
+func (m *ClanMutation) AddedField(name string) (ent.Value, bool) {
+	return nil, false
+}
+
+// AddField adds the value to the field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *ClanMutation) AddField(name string, value ent.Value) error {
+	switch name {
+	}
+	return fmt.Errorf("unknown Clan numeric field %s", name)
+}
+
+// ClearedFields returns all nullable fields that were cleared during this
+// mutation.
+func (m *ClanMutation) ClearedFields() []string {
+	var fields []string
+	if m.FieldCleared(clan.FieldEmblemID) {
+		fields = append(fields, clan.FieldEmblemID)
+	}
+	return fields
+}
+
+// FieldCleared returns a boolean indicating if a field with the given name was
+// cleared in this mutation.
+func (m *ClanMutation) FieldCleared(name string) bool {
+	_, ok := m.clearedFields[name]
+	return ok
+}
+
+// ClearField clears the value of the field with the given name. It returns an
+// error if the field is not defined in the schema.
+func (m *ClanMutation) ClearField(name string) error {
+	switch name {
+	case clan.FieldEmblemID:
+		m.ClearEmblemID()
+		return nil
+	}
+	return fmt.Errorf("unknown Clan nullable field %s", name)
+}
+
+// ResetField resets all changes in the mutation for the field with the given name.
+// It returns an error if the field is not defined in the schema.
+func (m *ClanMutation) ResetField(name string) error {
+	switch name {
+	case clan.FieldCreatedAt:
+		m.ResetCreatedAt()
+		return nil
+	case clan.FieldUpdatedAt:
+		m.ResetUpdatedAt()
+		return nil
+	case clan.FieldTag:
+		m.ResetTag()
+		return nil
+	case clan.FieldName:
+		m.ResetName()
+		return nil
+	case clan.FieldEmblemID:
+		m.ResetEmblemID()
+		return nil
+	case clan.FieldMembers:
+		m.ResetMembers()
+		return nil
+	}
+	return fmt.Errorf("unknown Clan field %s", name)
+}
+
+// AddedEdges returns all edge names that were set/added in this mutation.
+func (m *ClanMutation) AddedEdges() []string {
+	edges := make([]string, 0, 1)
+	if m.accounts != nil {
+		edges = append(edges, clan.EdgeAccounts)
+	}
+	return edges
+}
+
+// AddedIDs returns all IDs (to other nodes) that were added for the given edge
+// name in this mutation.
+func (m *ClanMutation) AddedIDs(name string) []ent.Value {
+	switch name {
+	case clan.EdgeAccounts:
+		ids := make([]ent.Value, 0, len(m.accounts))
+		for id := range m.accounts {
+			ids = append(ids, id)
+		}
+		return ids
+	}
+	return nil
+}
+
+// RemovedEdges returns all edge names that were removed in this mutation.
+func (m *ClanMutation) RemovedEdges() []string {
+	edges := make([]string, 0, 1)
+	if m.removedaccounts != nil {
+		edges = append(edges, clan.EdgeAccounts)
+	}
+	return edges
+}
+
+// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
+// the given name in this mutation.
+func (m *ClanMutation) RemovedIDs(name string) []ent.Value {
+	switch name {
+	case clan.EdgeAccounts:
+		ids := make([]ent.Value, 0, len(m.removedaccounts))
+		for id := range m.removedaccounts {
+			ids = append(ids, id)
+		}
+		return ids
+	}
+	return nil
+}
+
+// ClearedEdges returns all edge names that were cleared in this mutation.
+func (m *ClanMutation) ClearedEdges() []string {
+	edges := make([]string, 0, 1)
+	if m.clearedaccounts {
+		edges = append(edges, clan.EdgeAccounts)
+	}
+	return edges
+}
+
+// EdgeCleared returns a boolean which indicates if the edge with the given name
+// was cleared in this mutation.
+func (m *ClanMutation) EdgeCleared(name string) bool {
+	switch name {
+	case clan.EdgeAccounts:
+		return m.clearedaccounts
+	}
+	return false
+}
+
+// ClearEdge clears the value of the edge with the given name. It returns an error
+// if that edge is not defined in the schema.
+func (m *ClanMutation) ClearEdge(name string) error {
+	switch name {
+	}
+	return fmt.Errorf("unknown Clan unique edge %s", name)
+}
+
+// ResetEdge resets all changes to the edge with the given name in this mutation.
+// It returns an error if the edge is not defined in the schema.
+func (m *ClanMutation) ResetEdge(name string) error {
+	switch name {
+	case clan.EdgeAccounts:
+		m.ResetAccounts()
+		return nil
+	}
+	return fmt.Errorf("unknown Clan edge %s", name)
+}
+
+// CronTaskMutation represents an operation that mutates the CronTask nodes in the graph.
+type CronTaskMutation struct {
+	config
+	op              Op
+	typ             string
+	id              *string
+	created_at      *time.Time
+	updated_at      *time.Time
+	_type           *models.TaskType
+	reference_id    *string
+	targets         *[]string
+	appendtargets   []string
+	status          *models.TaskStatus
+	scheduled_after *time.Time
+	last_run        *time.Time
+	tries_left      *int
+	addtries_left   *int
+	logs            *[]models.TaskLog
+	appendlogs      []models.TaskLog
+	data            *map[string]string
+	clearedFields   map[string]struct{}
+	done            bool
+	oldValue        func(context.Context) (*CronTask, error)
+	predicates      []predicate.CronTask
+}
+
+var _ ent.Mutation = (*CronTaskMutation)(nil)
+
+// crontaskOption allows management of the mutation configuration using functional options.
+type crontaskOption func(*CronTaskMutation)
+
+// newCronTaskMutation creates new mutation for the CronTask entity.
+func newCronTaskMutation(c config, op Op, opts ...crontaskOption) *CronTaskMutation {
+	m := &CronTaskMutation{
+		config:        c,
+		op:            op,
+		typ:           TypeCronTask,
+		clearedFields: make(map[string]struct{}),
+	}
+	for _, opt := range opts {
+		opt(m)
+	}
+	return m
+}
+
+// withCronTaskID sets the ID field of the mutation.
+func withCronTaskID(id string) crontaskOption {
+	return func(m *CronTaskMutation) {
+		var (
+			err   error
+			once  sync.Once
+			value *CronTask
+		)
+		m.oldValue = func(ctx context.Context) (*CronTask, error) {
+			once.Do(func() {
+				if m.done {
+					err = errors.New("querying old values post mutation is not allowed")
+				} else {
+					value, err = m.Client().CronTask.Get(ctx, id)
+				}
+			})
+			return value, err
+		}
+		m.id = &id
+	}
+}
+
+// withCronTask sets the old CronTask of the mutation.
+func withCronTask(node *CronTask) crontaskOption {
+	return func(m *CronTaskMutation) {
+		m.oldValue = func(context.Context) (*CronTask, error) {
+			return node, nil
+		}
+		m.id = &node.ID
+	}
+}
+
+// Client returns a new `ent.Client` from the mutation. If the mutation was
+// executed in a transaction (ent.Tx), a transactional client is returned.
+func (m CronTaskMutation) Client() *Client {
+	client := &Client{config: m.config}
+	client.init()
+	return client
+}
+
+// Tx returns an `ent.Tx` for mutations that were executed in transactions;
+// it returns an error otherwise.
+func (m CronTaskMutation) Tx() (*Tx, error) {
+	if _, ok := m.driver.(*txDriver); !ok {
+		return nil, errors.New("db: mutation is not running in a transaction")
+	}
+	tx := &Tx{config: m.config}
+	tx.init()
+	return tx, nil
+}
+
+// SetID sets the value of the id field. Note that this
+// operation is only accepted on creation of CronTask entities.
+func (m *CronTaskMutation) SetID(id string) {
+	m.id = &id
+}
+
+// ID returns the ID value in the mutation. Note that the ID is only available
+// if it was provided to the builder or after it was returned from the database.
+func (m *CronTaskMutation) ID() (id string, exists bool) {
+	if m.id == nil {
+		return
+	}
+	return *m.id, true
+}
+
+// IDs queries the database and returns the entity ids that match the mutation's predicate.
+// That means, if the mutation is applied within a transaction with an isolation level such
+// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
+// or updated by the mutation.
+func (m *CronTaskMutation) IDs(ctx context.Context) ([]string, error) {
+	switch {
+	case m.op.Is(OpUpdateOne | OpDeleteOne):
+		id, exists := m.ID()
+		if exists {
+			return []string{id}, nil
+		}
+		fallthrough
+	case m.op.Is(OpUpdate | OpDelete):
+		return m.Client().CronTask.Query().Where(m.predicates...).IDs(ctx)
+	default:
+		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
+	}
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (m *CronTaskMutation) SetCreatedAt(t time.Time) {
+	m.created_at = &t
+}
+
+// CreatedAt returns the value of the "created_at" field in the mutation.
+func (m *CronTaskMutation) CreatedAt() (r time.Time, exists bool) {
+	v := m.created_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldCreatedAt returns the old "created_at" field's value of the CronTask entity.
+// If the CronTask object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *CronTaskMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldCreatedAt requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
+	}
+	return oldValue.CreatedAt, nil
+}
+
+// ResetCreatedAt resets all changes to the "created_at" field.
+func (m *CronTaskMutation) ResetCreatedAt() {
+	m.created_at = nil
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (m *CronTaskMutation) SetUpdatedAt(t time.Time) {
+	m.updated_at = &t
+}
+
+// UpdatedAt returns the value of the "updated_at" field in the mutation.
+func (m *CronTaskMutation) UpdatedAt() (r time.Time, exists bool) {
+	v := m.updated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldUpdatedAt returns the old "updated_at" field's value of the CronTask entity.
+// If the CronTask object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *CronTaskMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
+	}
+	return oldValue.UpdatedAt, nil
+}
+
+// ResetUpdatedAt resets all changes to the "updated_at" field.
+func (m *CronTaskMutation) ResetUpdatedAt() {
+	m.updated_at = nil
+}
+
+// SetType sets the "type" field.
+func (m *CronTaskMutation) SetType(mt models.TaskType) {
+	m._type = &mt
+}
+
+// GetType returns the value of the "type" field in the mutation.
+func (m *CronTaskMutation) GetType() (r models.TaskType, exists bool) {
+	v := m._type
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldType returns the old "type" field's value of the CronTask entity.
+// If the CronTask object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *CronTaskMutation) OldType(ctx context.Context) (v models.TaskType, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldType is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldType requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldType: %w", err)
+	}
+	return oldValue.Type, nil
 }
 
 // ResetType resets all changes to the "type" field.
@@ -4925,353 +5585,1157 @@ func (m *CronTaskMutation) ResetType() {
 	m._type = nil
 }
 
-// SetReferenceID sets the "reference_id" field.
-func (m *CronTaskMutation) SetReferenceID(s string) {
-	m.reference_id = &s
+// SetReferenceID sets the "reference_id" field.
+func (m *CronTaskMutation) SetReferenceID(s string) {
+	m.reference_id = &s
+}
+
+// ReferenceID returns the value of the "reference_id" field in the mutation.
+func (m *CronTaskMutation) ReferenceID() (r string, exists bool) {
+	v := m.reference_id
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldReferenceID returns the old "reference_id" field's value of the CronTask entity.
+// If the CronTask object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *CronTaskMutation) OldReferenceID(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldReferenceID is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldReferenceID requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldReferenceID: %w", err)
+	}
+	return oldValue.ReferenceID, nil
+}
+
+// ResetReferenceID resets all changes to the "reference_id" field.
+func (m *CronTaskMutation) ResetReferenceID() {
+	m.reference_id = nil
+}
+
+// SetTargets sets the "targets" field.
+func (m *CronTaskMutation) SetTargets(s []string) {
+	m.targets = &s
+	m.appendtargets = nil
+}
+
+// Targets returns the value of the "targets" field in the mutation.
+func (m *CronTaskMutation) Targets() (r []string, exists bool) {
+	v := m.targets
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldTargets returns the old "targets" field's value of the CronTask entity.
+// If the CronTask object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *CronTaskMutation) OldTargets(ctx context.Context) (v []string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldTargets is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldTargets requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldTargets: %w", err)
+	}
+	return oldValue.Targets, nil
+}
+
+// AppendTargets adds s to the "targets" field.
+func (m *CronTaskMutation) AppendTargets(s []string) {
+	m.appendtargets = append(m.appendtargets, s...)
+}
+
+// AppendedTargets returns the list of values that were appended to the "targets" field in this mutation.
+func (m *CronTaskMutation) AppendedTargets() ([]string, bool) {
+	if len(m.appendtargets) == 0 {
+		return nil, false
+	}
+	return m.appendtargets, true
+}
+
+// ResetTargets resets all changes to the "targets" field.
+func (m *CronTaskMutation) ResetTargets() {
+	m.targets = nil
+	m.appendtargets = nil
+}
+
+// SetStatus sets the "status" field.
+func (m *CronTaskMutation) SetStatus(ms models.TaskStatus) {
+	m.status = &ms
+}
+
+// Status returns the value of the "status" field in the mutation.
+func (m *CronTaskMutation) Status() (r models.TaskStatus, exists bool) {
+	v := m.status
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldStatus returns the old "status" field's value of the CronTask entity.
+// If the CronTask object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *CronTaskMutation) OldStatus(ctx context.Context) (v models.TaskStatus, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldStatus is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldStatus requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldStatus: %w", err)
+	}
+	return oldValue.Status, nil
+}
+
+// ResetStatus resets all changes to the "status" field.
+func (m *CronTaskMutation) ResetStatus() {
+	m.status = nil
+}
+
+// SetScheduledAfter sets the "scheduled_after" field.
+func (m *CronTaskMutation) SetScheduledAfter(t time.Time) {
+	m.scheduled_after = &t
+}
+
+// ScheduledAfter returns the value of the "scheduled_after" field in the mutation.
+func (m *CronTaskMutation) ScheduledAfter() (r time.Time, exists bool) {
+	v := m.scheduled_after
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldScheduledAfter returns the old "scheduled_after" field's value of the CronTask entity.
+// If the CronTask object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *CronTaskMutation) OldScheduledAfter(ctx context.Context) (v time.Time, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldScheduledAfter is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldScheduledAfter requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldScheduledAfter: %w", err)
+	}
+	return oldValue.ScheduledAfter, nil
+}
+
+// ResetScheduledAfter resets all changes to the "scheduled_after" field.
+func (m *CronTaskMutation) ResetScheduledAfter() {
+	m.scheduled_after = nil
+}
+
+// SetLastRun sets the "last_run" field.
+func (m *CronTaskMutation) SetLastRun(t time.Time) {
+	m.last_run = &t
+}
+
+// LastRun returns the value of the "last_run" field in the mutation.
+func (m *CronTaskMutation) LastRun() (r time.Time, exists bool) {
+	v := m.last_run
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldLastRun returns the old "last_run" field's value of the CronTask entity.
+// If the CronTask object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *CronTaskMutation) OldLastRun(ctx context.Context) (v time.Time, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldLastRun is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldLastRun requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldLastRun: %w", err)
+	}
+	return oldValue.LastRun, nil
+}
+
+// ResetLastRun resets all changes to the "last_run" field.
+func (m *CronTaskMutation) ResetLastRun() {
+	m.last_run = nil
+}
+
+// SetTriesLeft sets the "tries_left" field.
+func (m *CronTaskMutation) SetTriesLeft(i int) {
+	m.tries_left = &i
+	m.addtries_left = nil
+}
+
+// TriesLeft returns the value of the "tries_left" field in the mutation.
+func (m *CronTaskMutation) TriesLeft() (r int, exists bool) {
+	v := m.tries_left
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldTriesLeft returns the old "tries_left" field's value of the CronTask entity.
+// If the CronTask object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *CronTaskMutation) OldTriesLeft(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldTriesLeft is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldTriesLeft requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldTriesLeft: %w", err)
+	}
+	return oldValue.TriesLeft, nil
+}
+
+// AddTriesLeft adds i to the "tries_left" field.
+func (m *CronTaskMutation) AddTriesLeft(i int) {
+	if m.addtries_left != nil {
+		*m.addtries_left += i
+	} else {
+		m.addtries_left = &i
+	}
+}
+
+// AddedTriesLeft returns the value that was added to the "tries_left" field in this mutation.
+func (m *CronTaskMutation) AddedTriesLeft() (r int, exists bool) {
+	v := m.addtries_left
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetTriesLeft resets all changes to the "tries_left" field.
+func (m *CronTaskMutation) ResetTriesLeft() {
+	m.tries_left = nil
+	m.addtries_left = nil
+}
+
+// SetLogs sets the "logs" field.
+func (m *CronTaskMutation) SetLogs(ml []models.TaskLog) {
+	m.logs = &ml
+	m.appendlogs = nil
+}
+
+// Logs returns the value of the "logs" field in the mutation.
+func (m *CronTaskMutation) Logs() (r []models.TaskLog, exists bool) {
+	v := m.logs
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldLogs returns the old "logs" field's value of the CronTask entity.
+// If the CronTask object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *CronTaskMutation) OldLogs(ctx context.Context) (v []models.TaskLog, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldLogs is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldLogs requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldLogs: %w", err)
+	}
+	return oldValue.Logs, nil
+}
+
+// AppendLogs adds ml to the "logs" field.
+func (m *CronTaskMutation) AppendLogs(ml []models.TaskLog) {
+	m.appendlogs = append(m.appendlogs, ml...)
+}
+
+// AppendedLogs returns the list of values that were appended to the "logs" field in this mutation.
+func (m *CronTaskMutation) AppendedLogs() ([]models.TaskLog, bool) {
+	if len(m.appendlogs) == 0 {
+		return nil, false
+	}
+	return m.appendlogs, true
+}
+
+// ResetLogs resets all changes to the "logs" field.
+func (m *CronTaskMutation) ResetLogs() {
+	m.logs = nil
+	m.appendlogs = nil
+}
+
+// SetData sets the "data" field.
+func (m *CronTaskMutation) SetData(value map[string]string) {
+	m.data = &value
+}
+
+// Data returns the value of the "data" field in the mutation.
+func (m *CronTaskMutation) Data() (r map[string]string, exists bool) {
+	v := m.data
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldData returns the old "data" field's value of the CronTask entity.
+// If the CronTask object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *CronTaskMutation) OldData(ctx context.Context) (v map[string]string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldData is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldData requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldData: %w", err)
+	}
+	return oldValue.Data, nil
+}
+
+// ResetData resets all changes to the "data" field.
+func (m *CronTaskMutation) ResetData() {
+	m.data = nil
+}
+
+// Where appends a list predicates to the CronTaskMutation builder.
+func (m *CronTaskMutation) Where(ps ...predicate.CronTask) {
+	m.predicates = append(m.predicates, ps...)
+}
+
+// WhereP appends storage-level predicates to the CronTaskMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *CronTaskMutation) WhereP(ps ...func(*sql.Selector)) {
+	p := make([]predicate.CronTask, len(ps))
+	for i := range ps {
+		p[i] = ps[i]
+	}
+	m.Where(p...)
+}
+
+// Op returns the operation name.
+func (m *CronTaskMutation) Op() Op {
+	return m.op
+}
+
+// SetOp allows setting the mutation operation.
+func (m *CronTaskMutation) SetOp(op Op) {
+	m.op = op
+}
+
+// Type returns the node type of this mutation (CronTask).
+func (m *CronTaskMutation) Type() string {
+	return m.typ
+}
+
+// Fields returns all fields that were changed during this mutation. Note that in
+// order to get all numeric fields that were incremented/decremented, call
+// AddedFields().
+func (m *CronTaskMutation) Fields() []string {
+	fields := make([]string, 0, 11)
+	if m.created_at != nil {
+		fields = append(fields, crontask.FieldCreatedAt)
+	}
+	if m.updated_at != nil {
+		fields = append(fields, crontask.FieldUpdatedAt)
+	}
+	if m._type != nil {
+		fields = append(fields, crontask.FieldType)
+	}
+	if m.reference_id != nil {
+		fields = append(fields, crontask.FieldReferenceID)
+	}
+	if m.targets != nil {
+		fields = append(fields, crontask.FieldTargets)
+	}
+	if m.status != nil {
+		fields = append(fields, crontask.FieldStatus)
+	}
+	if m.scheduled_after != nil {
+		fields = append(fields, crontask.FieldScheduledAfter)
+	}
+	if m.last_run != nil {
+		fields = append(fields, crontask.FieldLastRun)
+	}
+	if m.tries_left != nil {
+		fields = append(fields, crontask.FieldTriesLeft)
+	}
+	if m.logs != nil {
+		fields = append(fields, crontask.FieldLogs)
+	}
+	if m.data != nil {
+		fields = append(fields, crontask.FieldData)
+	}
+	return fields
+}
+
+// Field returns the value of a field with the given name. The second boolean
+// return value indicates that this field was not set, or was not defined in the
+// schema.
+func (m *CronTaskMutation) Field(name string) (ent.Value, bool) {
+	switch name {
+	case crontask.FieldCreatedAt:
+		return m.CreatedAt()
+	case crontask.FieldUpdatedAt:
+		return m.UpdatedAt()
+	case crontask.FieldType:
+		return m.GetType()
+	case crontask.FieldReferenceID:
+		return m.ReferenceID()
+	case crontask.FieldTargets:
+		return m.Targets()
+	case crontask.FieldStatus:
+		return m.Status()
+	case crontask.FieldScheduledAfter:
+		return m.ScheduledAfter()
+	case crontask.FieldLastRun:
+		return m.LastRun()
+	case crontask.FieldTriesLeft:
+		return m.TriesLeft()
+	case crontask.FieldLogs:
+		return m.Logs()
+	case crontask.FieldData:
+		return m.Data()
+	}
+	return nil, false
+}
+
+// OldField returns the old value of the field from the database. An error is
+// returned if the mutation operation is not UpdateOne, or the query to the
+// database failed.
+func (m *CronTaskMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
+	switch name {
+	case crontask.FieldCreatedAt:
+		return m.OldCreatedAt(ctx)
+	case crontask.FieldUpdatedAt:
+		return m.OldUpdatedAt(ctx)
+	case crontask.FieldType:
+		return m.OldType(ctx)
+	case crontask.FieldReferenceID:
+		return m.OldReferenceID(ctx)
+	case crontask.FieldTargets:
+		return m.OldTargets(ctx)
+	case crontask.FieldStatus:
+		return m.OldStatus(ctx)
+	case crontask.FieldScheduledAfter:
+		return m.OldScheduledAfter(ctx)
+	case crontask.FieldLastRun:
+		return m.OldLastRun(ctx)
+	case crontask.FieldTriesLeft:
+		return m.OldTriesLeft(ctx)
+	case crontask.FieldLogs:
+		return m.OldLogs(ctx)
+	case crontask.FieldData:
+		return m.OldData(ctx)
+	}
+	return nil, fmt.Errorf("unknown CronTask field %s", name)
+}
+
+// SetField sets the value of a field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *CronTaskMutation) SetField(name string, value ent.Value) error {
+	switch name {
+	case crontask.FieldCreatedAt:
+		v, ok := value.(time.Time)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetCreatedAt(v)
+		return nil
+	case crontask.FieldUpdatedAt:
+		v, ok := value.(time.Time)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetUpdatedAt(v)
+		return nil
+	case crontask.FieldType:
+		v, ok := value.(models.TaskType)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetType(v)
+		return nil
+	case crontask.FieldReferenceID:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetReferenceID(v)
+		return nil
+	case crontask.FieldTargets:
+		v, ok := value.([]string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetTargets(v)
+		return nil
+	case crontask.FieldStatus:
+		v, ok := value.(models.TaskStatus)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetStatus(v)
+		return nil
+	case crontask.FieldScheduledAfter:
+		v, ok := value.(time.Time)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetScheduledAfter(v)
+		return nil
+	case crontask.FieldLastRun:
+		v, ok := value.(time.Time)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetLastRun(v)
+		return nil
+	case crontask.FieldTriesLeft:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetTriesLeft(v)
+		return nil
+	case crontask.FieldLogs:
+		v, ok := value.([]models.TaskLog)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetLogs(v)
+		return nil
+	case crontask.FieldData:
+		v, ok := value.(map[string]string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetData(v)
+		return nil
+	}
+	return fmt.Errorf("unknown CronTask field %s", name)
+}
+
+// AddedFields returns all numeric fields that were incremented/decremented during
+// this mutation.
+func (m *CronTaskMutation) AddedFields() []string {
+	var fields []string
+	if m.addtries_left != nil {
+		fields = append(fields, crontask.FieldTriesLeft)
+	}
+	return fields
+}
+
+// AddedField returns the numeric value that was incremented/decremented on a field
+// with the given name. The second boolean return value indicates that this field
+// was not set, or was not defined in the schema.
+func (m *CronTaskMutation) AddedField(name string) (ent.Value, bool) {
+	switch name {
+	case crontask.FieldTriesLeft:
+		return m.AddedTriesLeft()
+	}
+	return nil, false
+}
+
+// AddField adds the value to the field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *CronTaskMutation) AddField(name string, value ent.Value) error {
+	switch name {
+	case crontask.FieldTriesLeft:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddTriesLeft(v)
+		return nil
+	}
+	return fmt.Errorf("unknown CronTask numeric field %s", name)
+}
+
+// ClearedFields returns all nullable fields that were cleared during this
+// mutation.
+func (m *CronTaskMutation) ClearedFields() []string {
+	return nil
+}
+
+// FieldCleared returns a boolean indicating if a field with the given name was
+// cleared in this mutation.
+func (m *CronTaskMutation) FieldCleared(name string) bool {
+	_, ok := m.clearedFields[name]
+	return ok
+}
+
+// ClearField clears the value of the field with the given name. It returns an
+// error if the field is not defined in the schema.
+func (m *CronTaskMutation) ClearField(name string) error {
+	return fmt.Errorf("unknown CronTask nullable field %s", name)
+}
+
+// ResetField resets all changes in the mutation for the field with the given name.
+// It returns an error if the field is not defined in the schema.
+func (m *CronTaskMutation) ResetField(name string) error {
+	switch name {
+	case crontask.FieldCreatedAt:
+		m.ResetCreatedAt()
+		return nil
+	case crontask.FieldUpdatedAt:
+		m.ResetUpdatedAt()
+		return nil
+	case crontask.FieldType:
+		m.ResetType()
+		return nil
+	case crontask.FieldReferenceID:
+		m.ResetReferenceID()
+		return nil
+	case crontask.FieldTargets:
+		m.ResetTargets()
+		return nil
+	case crontask.FieldStatus:
+		m.ResetStatus()
+		return nil
+	case crontask.FieldScheduledAfter:
+		m.ResetScheduledAfter()
+		return nil
+	case crontask.FieldLastRun:
+		m.ResetLastRun()
+		return nil
+	case crontask.FieldTriesLeft:
+		m.ResetTriesLeft()
+		return nil
+	case crontask.FieldLogs:
+		m.ResetLogs()
+		return nil
+	case crontask.FieldData:
+		m.ResetData()
+		return nil
+	}
+	return fmt.Errorf("unknown CronTask field %s", name)
 }
 
-// ReferenceID returns the value of the "reference_id" field in the mutation.
-func (m *CronTaskMutation) ReferenceID() (r string, exists bool) {
-	v := m.reference_id
+// AddedEdges returns all edge names that were set/added in this mutation.
+func (m *CronTaskMutation) AddedEdges() []string {
+	edges := make([]string, 0, 0)
+	return edges
+}
+
+// AddedIDs returns all IDs (to other nodes) that were added for the given edge
+// name in this mutation.
+func (m *CronTaskMutation) AddedIDs(name string) []ent.Value {
+	return nil
+}
+
+// RemovedEdges returns all edge names that were removed in this mutation.
+func (m *CronTaskMutation) RemovedEdges() []string {
+	edges := make([]string, 0, 0)
+	return edges
+}
+
+// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
+// the given name in this mutation.
+func (m *CronTaskMutation) RemovedIDs(name string) []ent.Value {
+	return nil
+}
+
+// ClearedEdges returns all edge names that were cleared in this mutation.
+func (m *CronTaskMutation) ClearedEdges() []string {
+	edges := make([]string, 0, 0)
+	return edges
+}
+
+// EdgeCleared returns a boolean which indicates if the edge with the given name
+// was cleared in this mutation.
+func (m *CronTaskMutation) EdgeCleared(name string) bool {
+	return false
+}
+
+// ClearEdge clears the value of the edge with the given name. It returns an error
+// if that edge is not defined in the schema.
+func (m *CronTaskMutation) ClearEdge(name string) error {
+	return fmt.Errorf("unknown CronTask unique edge %s", name)
+}
+
+// ResetEdge resets all changes to the edge with the given name in this mutation.
+// It returns an error if the edge is not defined in the schema.
+func (m *CronTaskMutation) ResetEdge(name string) error {
+	return fmt.Errorf("unknown CronTask edge %s", name)
+}
+
+// DiscordInteractionMutation represents an operation that mutates the DiscordInteraction nodes in the graph.
+type DiscordInteractionMutation struct {
+	config
+	op            Op
+	typ           string
+	id            *string
+	created_at    *time.Time
+	updated_at    *time.Time
+	command       *string
+	reference_id  *string
+	_type         *models.DiscordInteractionType
+	locale        *string
+	options       *models.DiscordInteractionOptions
+	clearedFields map[string]struct{}
+	user          *string
+	cleareduser   bool
+	done          bool
+	oldValue      func(context.Context) (*DiscordInteraction, error)
+	predicates    []predicate.DiscordInteraction
+}
+
+var _ ent.Mutation = (*DiscordInteractionMutation)(nil)
+
+// discordinteractionOption allows management of the mutation configuration using functional options.
+type discordinteractionOption func(*DiscordInteractionMutation)
+
+// newDiscordInteractionMutation creates new mutation for the DiscordInteraction entity.
+func newDiscordInteractionMutation(c config, op Op, opts ...discordinteractionOption) *DiscordInteractionMutation {
+	m := &DiscordInteractionMutation{
+		config:        c,
+		op:            op,
+		typ:           TypeDiscordInteraction,
+		clearedFields: make(map[string]struct{}),
+	}
+	for _, opt := range opts {
+		opt(m)
+	}
+	return m
+}
+
+// withDiscordInteractionID sets the ID field of the mutation.
+func withDiscordInteractionID(id string) discordinteractionOption {
+	return func(m *DiscordInteractionMutation) {
+		var (
+			err   error
+			once  sync.Once
+			value *DiscordInteraction
+		)
+		m.oldValue = func(ctx context.Context) (*DiscordInteraction, error) {
+			once.Do(func() {
+				if m.done {
+					err = errors.New("querying old values post mutation is not allowed")
+				} else {
+					value, err = m.Client().DiscordInteraction.Get(ctx, id)
+				}
+			})
+			return value, err
+		}
+		m.id = &id
+	}
+}
+
+// withDiscordInteraction sets the old DiscordInteraction of the mutation.
+func withDiscordInteraction(node *DiscordInteraction) discordinteractionOption {
+	return func(m *DiscordInteractionMutation) {
+		m.oldValue = func(context.Context) (*DiscordInteraction, error) {
+			return node, nil
+		}
+		m.id = &node.ID
+	}
+}
+
+// Client returns a new `ent.Client` from the mutation. If the mutation was
+// executed in a transaction (ent.Tx), a transactional client is returned.
+func (m DiscordInteractionMutation) Client() *Client {
+	client := &Client{config: m.config}
+	client.init()
+	return client
+}
+
+// Tx returns an `ent.Tx` for mutations that were executed in transactions;
+// it returns an error otherwise.
+func (m DiscordInteractionMutation) Tx() (*Tx, error) {
+	if _, ok := m.driver.(*txDriver); !ok {
+		return nil, errors.New("db: mutation is not running in a transaction")
+	}
+	tx := &Tx{config: m.config}
+	tx.init()
+	return tx, nil
+}
+
+// SetID sets the value of the id field. Note that this
+// operation is only accepted on creation of DiscordInteraction entities.
+func (m *DiscordInteractionMutation) SetID(id string) {
+	m.id = &id
+}
+
+// ID returns the ID value in the mutation. Note that the ID is only available
+// if it was provided to the builder or after it was returned from the database.
+func (m *DiscordInteractionMutation) ID() (id string, exists bool) {
+	if m.id == nil {
+		return
+	}
+	return *m.id, true
+}
+
+// IDs queries the database and returns the entity ids that match the mutation's predicate.
+// That means, if the mutation is applied within a transaction with an isolation level such
+// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
+// or updated by the mutation.
+func (m *DiscordInteractionMutation) IDs(ctx context.Context) ([]string, error) {
+	switch {
+	case m.op.Is(OpUpdateOne | OpDeleteOne):
+		id, exists := m.ID()
+		if exists {
+			return []string{id}, nil
+		}
+		fallthrough
+	case m.op.Is(OpUpdate | OpDelete):
+		return m.Client().DiscordInteraction.Query().Where(m.predicates...).IDs(ctx)
+	default:
+		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
+	}
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (m *DiscordInteractionMutation) SetCreatedAt(t time.Time) {
+	m.created_at = &t
+}
+
+// CreatedAt returns the value of the "created_at" field in the mutation.
+func (m *DiscordInteractionMutation) CreatedAt() (r time.Time, exists bool) {
+	v := m.created_at
 	if v == nil {
 		return
 	}
 	return *v, true
 }
 
-// OldReferenceID returns the old "reference_id" field's value of the CronTask entity.
-// If the CronTask object wasn't provided to the builder, the object is fetched from the database.
+// OldCreatedAt returns the old "created_at" field's value of the DiscordInteraction entity.
+// If the DiscordInteraction object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *CronTaskMutation) OldReferenceID(ctx context.Context) (v string, err error) {
+func (m *DiscordInteractionMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
-		return v, errors.New("OldReferenceID is only allowed on UpdateOne operations")
+		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
 	}
 	if m.id == nil || m.oldValue == nil {
-		return v, errors.New("OldReferenceID requires an ID field in the mutation")
+		return v, errors.New("OldCreatedAt requires an ID field in the mutation")
 	}
 	oldValue, err := m.oldValue(ctx)
 	if err != nil {
-		return v, fmt.Errorf("querying old value for OldReferenceID: %w", err)
+		return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
 	}
-	return oldValue.ReferenceID, nil
+	return oldValue.CreatedAt, nil
 }
 
-// ResetReferenceID resets all changes to the "reference_id" field.
-func (m *CronTaskMutation) ResetReferenceID() {
-	m.reference_id = nil
+// ResetCreatedAt resets all changes to the "created_at" field.
+func (m *DiscordInteractionMutation) ResetCreatedAt() {
+	m.created_at = nil
 }
 
-// SetTargets sets the "targets" field.
-func (m *CronTaskMutation) SetTargets(s []string) {
-	m.targets = &s
-	m.appendtargets = nil
+// SetUpdatedAt sets the "updated_at" field.
+func (m *DiscordInteractionMutation) SetUpdatedAt(t time.Time) {
+	m.updated_at = &t
 }
 
-// Targets returns the value of the "targets" field in the mutation.
-func (m *CronTaskMutation) Targets() (r []string, exists bool) {
-	v := m.targets
+// UpdatedAt returns the value of the "updated_at" field in the mutation.
+func (m *DiscordInteractionMutation) UpdatedAt() (r time.Time, exists bool) {
+	v := m.updated_at
 	if v == nil {
 		return
 	}
 	return *v, true
 }
 
-// OldTargets returns the old "targets" field's value of the CronTask entity.
-// If the CronTask object wasn't provided to the builder, the object is fetched from the database.
+// OldUpdatedAt returns the old "updated_at" field's value of the DiscordInteraction entity.
+// If the DiscordInteraction object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *CronTaskMutation) OldTargets(ctx context.Context) (v []string, err error) {
+func (m *DiscordInteractionMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
-		return v, errors.New("OldTargets is only allowed on UpdateOne operations")
+		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
 	}
 	if m.id == nil || m.oldValue == nil {
-		return v, errors.New("OldTargets requires an ID field in the mutation")
+		return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
 	}
 	oldValue, err := m.oldValue(ctx)
 	if err != nil {
-		return v, fmt.Errorf("querying old value for OldTargets: %w", err)
-	}
-	return oldValue.Targets, nil
-}
-
-// AppendTargets adds s to the "targets" field.
-func (m *CronTaskMutation) AppendTargets(s []string) {
-	m.appendtargets = append(m.appendtargets, s...)
-}
-
-// AppendedTargets returns the list of values that were appended to the "targets" field in this mutation.
-func (m *CronTaskMutation) AppendedTargets() ([]string, bool) {
-	if len(m.appendtargets) == 0 {
-		return nil, false
+		return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
 	}
-	return m.appendtargets, true
+	return oldValue.UpdatedAt, nil
 }
 
-// ResetTargets resets all changes to the "targets" field.
-func (m *CronTaskMutation) ResetTargets() {
-	m.targets = nil
-	m.appendtargets = nil
+// ResetUpdatedAt resets all changes to the "updated_at" field.
+func (m *DiscordInteractionMutation) ResetUpdatedAt() {
+	m.updated_at = nil
 }
 
-// SetStatus sets the "status" field.
-func (m *CronTaskMutation) SetStatus(ms models.TaskStatus) {
-	m.status = &ms
+// SetCommand sets the "command" field.
+func (m *DiscordInteractionMutation) SetCommand(s string) {
+	m.command = &s
 }
 
-// Status returns the value of the "status" field in the mutation.
-func (m *CronTaskMutation) Status() (r models.TaskStatus, exists bool) {
-	v := m.status
+// Command returns the value of the "command" field in the mutation.
+func (m *DiscordInteractionMutation) Command() (r string, exists bool) {
+	v := m.command
 	if v == nil {
 		return
 	}
 	return *v, true
 }
 
-// OldStatus returns the old "status" field's value of the CronTask entity.
-// If the CronTask object wasn't provided to the builder, the object is fetched from the database.
+// OldCommand returns the old "command" field's value of the DiscordInteraction entity.
+// If the DiscordInteraction object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *CronTaskMutation) OldStatus(ctx context.Context) (v models.TaskStatus, err error) {
+func (m *DiscordInteractionMutation) OldCommand(ctx context.Context) (v string, err error) {
 	if !m.op.Is(OpUpdateOne) {
-		return v, errors.New("OldStatus is only allowed on UpdateOne operations")
+		return v, errors.New("OldCommand is only allowed on UpdateOne operations")
 	}
 	if m.id == nil || m.oldValue == nil {
-		return v, errors.New("OldStatus requires an ID field in the mutation")
+		return v, errors.New("OldCommand requires an ID field in the mutation")
 	}
 	oldValue, err := m.oldValue(ctx)
 	if err != nil {
-		return v, fmt.Errorf("querying old value for OldStatus: %w", err)
+		return v, fmt.Errorf("querying old value for OldCommand: %w", err)
 	}
-	return oldValue.Status, nil
+	return oldValue.Command, nil
 }
 
-// ResetStatus resets all changes to the "status" field.
-func (m *CronTaskMutation) ResetStatus() {
-	m.status = nil
+// ResetCommand resets all changes to the "command" field.
+func (m *DiscordInteractionMutation) ResetCommand() {
+	m.command = nil
 }
 
-// SetScheduledAfter sets the "scheduled_after" field.
-func (m *CronTaskMutation) SetScheduledAfter(t time.Time) {
-	m.scheduled_after = &t
+// SetUserID sets the "user_id" field.
+func (m *DiscordInteractionMutation) SetUserID(s string) {
+	m.user = &s
 }
 
-// ScheduledAfter returns the value of the "scheduled_after" field in the mutation.
-func (m *CronTaskMutation) ScheduledAfter() (r time.Time, exists bool) {
-	v := m.scheduled_after
+// UserID returns the value of the "user_id" field in the mutation.
+func (m *DiscordInteractionMutation) UserID() (r string, exists bool) {
+	v := m.user
 	if v == nil {
 		return
 	}
 	return *v, true
 }
 
-// OldScheduledAfter returns the old "scheduled_after" field's value of the CronTask entity.
-// If the CronTask object wasn't provided to the builder, the object is fetched from the database.
+// OldUserID returns the old "user_id" field's value of the DiscordInteraction entity.
+// If the DiscordInteraction object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *CronTaskMutation) OldScheduledAfter(ctx context.Context) (v time.Time, err error) {
+func (m *DiscordInteractionMutation) OldUserID(ctx context.Context) (v string, err error) {
 	if !m.op.Is(OpUpdateOne) {
-		return v, errors.New("OldScheduledAfter is only allowed on UpdateOne operations")
+		return v, errors.New("OldUserID is only allowed on UpdateOne operations")
 	}
 	if m.id == nil || m.oldValue == nil {
-		return v, errors.New("OldScheduledAfter requires an ID field in the mutation")
+		return v, errors.New("OldUserID requires an ID field in the mutation")
 	}
 	oldValue, err := m.oldValue(ctx)
 	if err != nil {
-		return v, fmt.Errorf("querying old value for OldScheduledAfter: %w", err)
+		return v, fmt.Errorf("querying old value for OldUserID: %w", err)
 	}
-	return oldValue.ScheduledAfter, nil
+	return oldValue.UserID, nil
 }
 
-// ResetScheduledAfter resets all changes to the "scheduled_after" field.
-func (m *CronTaskMutation) ResetScheduledAfter() {
-	m.scheduled_after = nil
+// ResetUserID resets all changes to the "user_id" field.
+func (m *DiscordInteractionMutation) ResetUserID() {
+	m.user = nil
 }
 
-// SetLastRun sets the "last_run" field.
-func (m *CronTaskMutation) SetLastRun(t time.Time) {
-	m.last_run = &t
+// SetReferenceID sets the "reference_id" field.
+func (m *DiscordInteractionMutation) SetReferenceID(s string) {
+	m.reference_id = &s
 }
 
-// LastRun returns the value of the "last_run" field in the mutation.
-func (m *CronTaskMutation) LastRun() (r time.Time, exists bool) {
-	v := m.last_run
+// ReferenceID returns the value of the "reference_id" field in the mutation.
+func (m *DiscordInteractionMutation) ReferenceID() (r string, exists bool) {
+	v := m.reference_id
 	if v == nil {
 		return
 	}
 	return *v, true
 }
 
-// OldLastRun returns the old "last_run" field's value of the CronTask entity.
-// If the CronTask object wasn't provided to the builder, the object is fetched from the database.
+// OldReferenceID returns the old "reference_id" field's value of the DiscordInteraction entity.
+// If the DiscordInteraction object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *CronTaskMutation) OldLastRun(ctx context.Context) (v time.Time, err error) {
+func (m *DiscordInteractionMutation) OldReferenceID(ctx context.Context) (v string, err error) {
 	if !m.op.Is(OpUpdateOne) {
-		return v, errors.New("OldLastRun is only allowed on UpdateOne operations")
+		return v, errors.New("OldReferenceID is only allowed on UpdateOne operations")
 	}
 	if m.id == nil || m.oldValue == nil {
-		return v, errors.New("OldLastRun requires an ID field in the mutation")
+		return v, errors.New("OldReferenceID requires an ID field in the mutation")
 	}
 	oldValue, err := m.oldValue(ctx)
 	if err != nil {
-		return v, fmt.Errorf("querying old value for OldLastRun: %w", err)
+		return v, fmt.Errorf("querying old value for OldReferenceID: %w", err)
 	}
-	return oldValue.LastRun, nil
+	return oldValue.ReferenceID, nil
 }
 
-// ResetLastRun resets all changes to the "last_run" field.
-func (m *CronTaskMutation) ResetLastRun() {
-	m.last_run = nil
+// ResetReferenceID resets all changes to the "reference_id" field.
+func (m *DiscordInteractionMutation) ResetReferenceID() {
+	m.reference_id = nil
 }
 
-// SetTriesLeft sets the "tries_left" field.
-func (m *CronTaskMutation) SetTriesLeft(i int) {
-	m.tries_left = &i
-	m.addtries_left = nil
+// SetType sets the "type" field.
+func (m *DiscordInteractionMutation) SetType(mit models.DiscordInteractionType) {
+	m._type = &mit
 }
 
-// TriesLeft returns the value of the "tries_left" field in the mutation.
-func (m *CronTaskMutation) TriesLeft() (r int, exists bool) {
-	v := m.tries_left
+// GetType returns the value of the "type" field in the mutation.
+func (m *DiscordInteractionMutation) GetType() (r models.DiscordInteractionType, exists bool) {
+	v := m._type
 	if v == nil {
 		return
 	}
 	return *v, true
 }
 
-// OldTriesLeft returns the old "tries_left" field's value of the CronTask entity.
-// If the CronTask object wasn't provided to the builder, the object is fetched from the database.
+// OldType returns the old "type" field's value of the DiscordInteraction entity.
+// If the DiscordInteraction object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *CronTaskMutation) OldTriesLeft(ctx context.Context) (v int, err error) {
+func (m *DiscordInteractionMutation) OldType(ctx context.Context) (v models.DiscordInteractionType, err error) {
 	if !m.op.Is(OpUpdateOne) {
-		return v, errors.New("OldTriesLeft is only allowed on UpdateOne operations")
+		return v, errors.New("OldType is only allowed on UpdateOne operations")
 	}
 	if m.id == nil || m.oldValue == nil {
-		return v, errors.New("OldTriesLeft requires an ID field in the mutation")
+		return v, errors.New("OldType requires an ID field in the mutation")
 	}
 	oldValue, err := m.oldValue(ctx)
 	if err != nil {
-		return v, fmt.Errorf("querying old value for OldTriesLeft: %w", err)
-	}
-	return oldValue.TriesLeft, nil
-}
-
-// AddTriesLeft adds i to the "tries_left" field.
-func (m *CronTaskMutation) AddTriesLeft(i int) {
-	if m.addtries_left != nil {
-		*m.addtries_left += i
-	} else {
-		m.addtries_left = &i
-	}
-}
-
-// AddedTriesLeft returns the value that was added to the "tries_left" field in this mutation.
-func (m *CronTaskMutation) AddedTriesLeft() (r int, exists bool) {
-	v := m.addtries_left
-	if v == nil {
-		return
+		return v, fmt.Errorf("querying old value for OldType: %w", err)
 	}
-	return *v, true
+	return oldValue.Type, nil
 }
 
-// ResetTriesLeft resets all changes to the "tries_left" field.
-func (m *CronTaskMutation) ResetTriesLeft() {
-	m.tries_left = nil
-	m.addtries_left = nil
+// ResetType resets all changes to the "type" field.
+func (m *DiscordInteractionMutation) ResetType() {
+	m._type = nil
 }
 
-// SetLogs sets the "logs" field.
-func (m *CronTaskMutation) SetLogs(ml []models.TaskLog) {
-	m.logs = &ml
-	m.appendlogs = nil
+// SetLocale sets the "locale" field.
+func (m *DiscordInteractionMutation) SetLocale(s string) {
+	m.locale = &s
 }
 
-// Logs returns the value of the "logs" field in the mutation.
-func (m *CronTaskMutation) Logs() (r []models.TaskLog, exists bool) {
-	v := m.logs
+// Locale returns the value of the "locale" field in the mutation.
+func (m *DiscordInteractionMutation) Locale() (r string, exists bool) {
+	v := m.locale
 	if v == nil {
 		return
 	}
 	return *v, true
 }
 
-// OldLogs returns the old "logs" field's value of the CronTask entity.
-// If the CronTask object wasn't provided to the builder, the object is fetched from the database.
+// OldLocale returns the old "locale" field's value of the DiscordInteraction entity.
+// If the DiscordInteraction object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *CronTaskMutation) OldLogs(ctx context.Context) (v []models.TaskLog, err error) {
+func (m *DiscordInteractionMutation) OldLocale(ctx context.Context) (v string, err error) {
 	if !m.op.Is(OpUpdateOne) {
-		return v, errors.New("OldLogs is only allowed on UpdateOne operations")
+		return v, errors.New("OldLocale is only allowed on UpdateOne operations")
 	}
 	if m.id == nil || m.oldValue == nil {
-		return v, errors.New("OldLogs requires an ID field in the mutation")
+		return v, errors.New("OldLocale requires an ID field in the mutation")
 	}
 	oldValue, err := m.oldValue(ctx)
 	if err != nil {
-		return v, fmt.Errorf("querying old value for OldLogs: %w", err)
-	}
-	return oldValue.Logs, nil
-}
-
-// AppendLogs adds ml to the "logs" field.
-func (m *CronTaskMutation) AppendLogs(ml []models.TaskLog) {
-	m.appendlogs = append(m.appendlogs, ml...)
-}
-
-// AppendedLogs returns the list of values that were appended to the "logs" field in this mutation.
-func (m *CronTaskMutation) AppendedLogs() ([]models.TaskLog, bool) {
-	if len(m.appendlogs) == 0 {
-		return nil, false
+		return v, fmt.Errorf("querying old value for OldLocale: %w", err)
 	}
-	return m.appendlogs, true
+	return oldValue.Locale, nil
 }
 
-// ResetLogs resets all changes to the "logs" field.
-func (m *CronTaskMutation) ResetLogs() {
-	m.logs = nil
-	m.appendlogs = nil
+// ResetLocale resets all changes to the "locale" field.
+func (m *DiscordInteractionMutation) ResetLocale() {
+	m.locale = nil
 }
 
-// SetData sets the "data" field.
-func (m *CronTaskMutation) SetData(value map[string]string) {
-	m.data = &value
+// SetOptions sets the "options" field.
+func (m *DiscordInteractionMutation) SetOptions(mio models.DiscordInteractionOptions) {
+	m.options = &mio
 }
 
-// Data returns the value of the "data" field in the mutation.
-func (m *CronTaskMutation) Data() (r map[string]string, exists bool) {
-	v := m.data
+// Options returns the value of the "options" field in the mutation.
+func (m *DiscordInteractionMutation) Options() (r models.DiscordInteractionOptions, exists bool) {
+	v := m.options
 	if v == nil {
 		return
 	}
 	return *v, true
 }
 
-// OldData returns the old "data" field's value of the CronTask entity.
-// If the CronTask object wasn't provided to the builder, the object is fetched from the database.
+// OldOptions returns the old "options" field's value of the DiscordInteraction entity.
+// If the DiscordInteraction object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *CronTaskMutation) OldData(ctx context.Context) (v map[string]string, err error) {
+func (m *DiscordInteractionMutation) OldOptions(ctx context.Context) (v models.DiscordInteractionOptions, err error) {
 	if !m.op.Is(OpUpdateOne) {
-		return v, errors.New("OldData is only allowed on UpdateOne operations")
+		return v, errors.New("OldOptions is only allowed on UpdateOne operations")
 	}
 	if m.id == nil || m.oldValue == nil {
-		return v, errors.New("OldData requires an ID field in the mutation")
+		return v, errors.New("OldOptions requires an ID field in the mutation")
 	}
 	oldValue, err := m.oldValue(ctx)
 	if err != nil {
-		return v, fmt.Errorf("querying old value for OldData: %w", err)
+		return v, fmt.Errorf("querying old value for OldOptions: %w", err)
 	}
-	return oldValue.Data, nil
+	return oldValue.Options, nil
 }
 
-// ResetData resets all changes to the "data" field.
-func (m *CronTaskMutation) ResetData() {
-	m.data = nil
+// ResetOptions resets all changes to the "options" field.
+func (m *DiscordInteractionMutation) ResetOptions() {
+	m.options = nil
 }
 
-// Where appends a list predicates to the CronTaskMutation builder.
-func (m *CronTaskMutation) Where(ps ...predicate.CronTask) {
+// ClearUser clears the "user" edge to the User entity.
+func (m *DiscordInteractionMutation) ClearUser() {
+	m.cleareduser = true
+	m.clearedFields[discordinteraction.FieldUserID] = struct{}{}
+}
+
+// UserCleared reports if the "user" edge to the User entity was cleared.
+func (m *DiscordInteractionMutation) UserCleared() bool {
+	return m.cleareduser
+}
+
+// UserIDs returns the "user" edge IDs in the mutation.
+// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
+// UserID instead. It exists only for internal usage by the builders.
+func (m *DiscordInteractionMutation) UserIDs() (ids []string) {
+	if id := m.user; id != nil {
+		ids = append(ids, *id)
+	}
+	return
+}
+
+// ResetUser resets all changes to the "user" edge.
+func (m *DiscordInteractionMutation) ResetUser() {
+	m.user = nil
+	m.cleareduser = false
+}
+
+// Where appends a list predicates to the DiscordInteractionMutation builder.
+func (m *DiscordInteractionMutation) Where(ps ...predicate.DiscordInteraction) {
 	m.predicates = append(m.predicates, ps...)
 }
 
-// WhereP appends storage-level predicates to the CronTaskMutation builder. Using this method,
+// WhereP appends storage-level predicates to the DiscordInteractionMutation builder. Using this method,
 // users can use type-assertion to append predicates that do not depend on any generated package.
-func (m *CronTaskMutation) WhereP(ps ...func(*sql.Selector)) {
-	p := make([]predicate.CronTask, len(ps))
+func (m *DiscordInteractionMutation) WhereP(ps ...func(*sql.Selector)) {
+	p := make([]predicate.DiscordInteraction, len(ps))
 	for i := range ps {
 		p[i] = ps[i]
 	}
@@ -5279,57 +6743,48 @@ func (m *CronTaskMutation) WhereP(ps ...func(*sql.Selector)) {
 }
 
 // Op returns the operation name.
-func (m *CronTaskMutation) Op() Op {
+func (m *DiscordInteractionMutation) Op() Op {
 	return m.op
 }
 
 // SetOp allows setting the mutation operation.
-func (m *CronTaskMutation) SetOp(op Op) {
+func (m *DiscordInteractionMutation) SetOp(op Op) {
 	m.op = op
 }
 
-// Type returns the node type of this mutation (CronTask).
-func (m *CronTaskMutation) Type() string {
+// Type returns the node type of this mutation (DiscordInteraction).
+func (m *DiscordInteractionMutation) Type() string {
 	return m.typ
 }
 
 // Fields returns all fields that were changed during this mutation. Note that in
 // order to get all numeric fields that were incremented/decremented, call
 // AddedFields().
-func (m *CronTaskMutation) Fields() []string {
-	fields := make([]string, 0, 11)
+func (m *DiscordInteractionMutation) Fields() []string {
+	fields := make([]string, 0, 8)
 	if m.created_at != nil {
-		fields = append(fields, crontask.FieldCreatedAt)
+		fields = append(fields, discordinteraction.FieldCreatedAt)
 	}
 	if m.updated_at != nil {
-		fields = append(fields, crontask.FieldUpdatedAt)
-	}
-	if m._type != nil {
-		fields = append(fields, crontask.FieldType)
-	}
-	if m.reference_id != nil {
-		fields = append(fields, crontask.FieldReferenceID)
-	}
-	if m.targets != nil {
-		fields = append(fields, crontask.FieldTargets)
+		fields = append(fields, discordinteraction.FieldUpdatedAt)
 	}
-	if m.status != nil {
-		fields = append(fields, crontask.FieldStatus)
+	if m.command != nil {
+		fields = append(fields, discordinteraction.FieldCommand)
 	}
-	if m.scheduled_after != nil {
-		fields = append(fields, crontask.FieldScheduledAfter)
+	if m.user != nil {
+		fields = append(fields, discordinteraction.FieldUserID)
 	}
-	if m.last_run != nil {
-		fields = append(fields, crontask.FieldLastRun)
+	if m.reference_id != nil {
+		fields = append(fields, discordinteraction.FieldReferenceID)
 	}
-	if m.tries_left != nil {
-		fields = append(fields, crontask.FieldTriesLeft)
+	if m._type != nil {
+		fields = append(fields, discordinteraction.FieldType)
 	}
-	if m.logs != nil {
-		fields = append(fields, crontask.FieldLogs)
+	if m.locale != nil {
+		fields = append(fields, discordinteraction.FieldLocale)
 	}
-	if m.data != nil {
-		fields = append(fields, crontask.FieldData)
+	if m.options != nil {
+		fields = append(fields, discordinteraction.FieldOptions)
 	}
 	return fields
 }
@@ -5337,30 +6792,24 @@ func (m *CronTaskMutation) Fields() []string {
 // Field returns the value of a field with the given name. The second boolean
 // return value indicates that this field was not set, or was not defined in the
 // schema.
-func (m *CronTaskMutation) Field(name string) (ent.Value, bool) {
+func (m *DiscordInteractionMutation) Field(name string) (ent.Value, bool) {
 	switch name {
-	case crontask.FieldCreatedAt:
+	case discordinteraction.FieldCreatedAt:
 		return m.CreatedAt()
-	case crontask.FieldUpdatedAt:
+	case discordinteraction.FieldUpdatedAt:
 		return m.UpdatedAt()
-	case crontask.FieldType:
-		return m.GetType()
-	case crontask.FieldReferenceID:
+	case discordinteraction.FieldCommand:
+		return m.Command()
+	case discordinteraction.FieldUserID:
+		return m.UserID()
+	case discordinteraction.FieldReferenceID:
 		return m.ReferenceID()
-	case crontask.FieldTargets:
-		return m.Targets()
-	case crontask.FieldStatus:
-		return m.Status()
-	case crontask.FieldScheduledAfter:
-		return m.ScheduledAfter()
-	case crontask.FieldLastRun:
-		return m.LastRun()
-	case crontask.FieldTriesLeft:
-		return m.TriesLeft()
-	case crontask.FieldLogs:
-		return m.Logs()
-	case crontask.FieldData:
-		return m.Data()
+	case discordinteraction.FieldType:
+		return m.GetType()
+	case discordinteraction.FieldLocale:
+		return m.Locale()
+	case discordinteraction.FieldOptions:
+		return m.Options()
 	}
 	return nil, false
 }
@@ -5368,297 +6817,270 @@ func (m *CronTaskMutation) Field(name string) (ent.Value, bool) {
 // OldField returns the old value of the field from the database. An error is
 // returned if the mutation operation is not UpdateOne, or the query to the
 // database failed.
-func (m *CronTaskMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
+func (m *DiscordInteractionMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
 	switch name {
-	case crontask.FieldCreatedAt:
+	case discordinteraction.FieldCreatedAt:
 		return m.OldCreatedAt(ctx)
-	case crontask.FieldUpdatedAt:
+	case discordinteraction.FieldUpdatedAt:
 		return m.OldUpdatedAt(ctx)
-	case crontask.FieldType:
-		return m.OldType(ctx)
-	case crontask.FieldReferenceID:
+	case discordinteraction.FieldCommand:
+		return m.OldCommand(ctx)
+	case discordinteraction.FieldUserID:
+		return m.OldUserID(ctx)
+	case discordinteraction.FieldReferenceID:
 		return m.OldReferenceID(ctx)
-	case crontask.FieldTargets:
-		return m.OldTargets(ctx)
-	case crontask.FieldStatus:
-		return m.OldStatus(ctx)
-	case crontask.FieldScheduledAfter:
-		return m.OldScheduledAfter(ctx)
-	case crontask.FieldLastRun:
-		return m.OldLastRun(ctx)
-	case crontask.FieldTriesLeft:
-		return m.OldTriesLeft(ctx)
-	case crontask.FieldLogs:
-		return m.OldLogs(ctx)
-	case crontask.FieldData:
-		return m.OldData(ctx)
+	case discordinteraction.FieldType:
+		return m.OldType(ctx)
+	case discordinteraction.FieldLocale:
+		return m.OldLocale(ctx)
+	case discordinteraction.FieldOptions:
+		return m.OldOptions(ctx)
 	}
-	return nil, fmt.Errorf("unknown CronTask field %s", name)
+	return nil, fmt.Errorf("unknown DiscordInteraction field %s", name)
 }
 
 // SetField sets the value of a field with the given name. It returns an error if
 // the field is not defined in the schema, or if the type mismatched the field
 // type.
-func (m *CronTaskMutation) SetField(name string, value ent.Value) error {
+func (m *DiscordInteractionMutation) SetField(name string, value ent.Value) error {
 	switch name {
-	case crontask.FieldCreatedAt:
+	case discordinteraction.FieldCreatedAt:
 		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetCreatedAt(v)
 		return nil
-	case crontask.FieldUpdatedAt:
+	case discordinteraction.FieldUpdatedAt:
 		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetUpdatedAt(v)
 		return nil
-	case crontask.FieldType:
-		v, ok := value.(models.TaskType)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.SetType(v)
-		return nil
-	case crontask.FieldReferenceID:
+	case discordinteraction.FieldCommand:
 		v, ok := value.(string)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
-		m.SetReferenceID(v)
-		return nil
-	case crontask.FieldTargets:
-		v, ok := value.([]string)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.SetTargets(v)
-		return nil
-	case crontask.FieldStatus:
-		v, ok := value.(models.TaskStatus)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.SetStatus(v)
+		m.SetCommand(v)
 		return nil
-	case crontask.FieldScheduledAfter:
-		v, ok := value.(time.Time)
+	case discordinteraction.FieldUserID:
+		v, ok := value.(string)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
-		m.SetScheduledAfter(v)
+		m.SetUserID(v)
 		return nil
-	case crontask.FieldLastRun:
-		v, ok := value.(time.Time)
+	case discordinteraction.FieldReferenceID:
+		v, ok := value.(string)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
-		m.SetLastRun(v)
+		m.SetReferenceID(v)
 		return nil
-	case crontask.FieldTriesLeft:
-		v, ok := value.(int)
+	case discordinteraction.FieldType:
+		v, ok := value.(models.DiscordInteractionType)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
-		m.SetTriesLeft(v)
+		m.SetType(v)
 		return nil
-	case crontask.FieldLogs:
-		v, ok := value.([]models.TaskLog)
+	case discordinteraction.FieldLocale:
+		v, ok := value.(string)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
-		m.SetLogs(v)
+		m.SetLocale(v)
 		return nil
-	case crontask.FieldData:
-		v, ok := value.(map[string]string)
+	case discordinteraction.FieldOptions:
+		v, ok := value.(models.DiscordInteractionOptions)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
-		m.SetData(v)
+		m.SetOptions(v)
 		return nil
 	}
-	return fmt.Errorf("unknown CronTask field %s", name)
+	return fmt.Errorf("unknown DiscordInteraction field %s", name)
 }
 
 // AddedFields returns all numeric fields that were incremented/decremented during
 // this mutation.
-func (m *CronTaskMutation) AddedFields() []string {
-	var fields []string
-	if m.addtries_left != nil {
-		fields = append(fields, crontask.FieldTriesLeft)
-	}
-	return fields
+func (m *DiscordInteractionMutation) AddedFields() []string {
+	return nil
 }
 
 // AddedField returns the numeric value that was incremented/decremented on a field
 // with the given name. The second boolean return value indicates that this field
 // was not set, or was not defined in the schema.
-func (m *CronTaskMutation) AddedField(name string) (ent.Value, bool) {
-	switch name {
-	case crontask.FieldTriesLeft:
-		return m.AddedTriesLeft()
-	}
+func (m *DiscordInteractionMutation) AddedField(name string) (ent.Value, bool) {
 	return nil, false
 }
 
 // AddField adds the value to the field with the given name. It returns an error if
 // the field is not defined in the schema, or if the type mismatched the field
 // type.
-func (m *CronTaskMutation) AddField(name string, value ent.Value) error {
+func (m *DiscordInteractionMutation) AddField(name string, value ent.Value) error {
 	switch name {
-	case crontask.FieldTriesLeft:
-		v, ok := value.(int)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddTriesLeft(v)
-		return nil
 	}
-	return fmt.Errorf("unknown CronTask numeric field %s", name)
+	return fmt.Errorf("unknown DiscordInteraction numeric field %s", name)
 }
 
 // ClearedFields returns all nullable fields that were cleared during this
 // mutation.
-func (m *CronTaskMutation) ClearedFields() []string {
+func (m *DiscordInteractionMutation) ClearedFields() []string {
 	return nil
 }
 
 // FieldCleared returns a boolean indicating if a field with the given name was
 // cleared in this mutation.
-func (m *CronTaskMutation) FieldCleared(name string) bool {
+func (m *DiscordInteractionMutation) FieldCleared(name string) bool {
 	_, ok := m.clearedFields[name]
 	return ok
 }
 
 // ClearField clears the value of the field with the given name. It returns an
 // error if the field is not defined in the schema.
-func (m *CronTaskMutation) ClearField(name string) error {
-	return fmt.Errorf("unknown CronTask nullable field %s", name)
+func (m *DiscordInteractionMutation) ClearField(name string) error {
+	return fmt.Errorf("unknown DiscordInteraction nullable field %s", name)
 }
 
 // ResetField resets all changes in the mutation for the field with the given name.
 // It returns an error if the field is not defined in the schema.
-func (m *CronTaskMutation) ResetField(name string) error {
+func (m *DiscordInteractionMutation) ResetField(name string) error {
 	switch name {
-	case crontask.FieldCreatedAt:
+	case discordinteraction.FieldCreatedAt:
 		m.ResetCreatedAt()
 		return nil
-	case crontask.FieldUpdatedAt:
+	case discordinteraction.FieldUpdatedAt:
 		m.ResetUpdatedAt()
 		return nil
-	case crontask.FieldType:
-		m.ResetType()
-		return nil
-	case crontask.FieldReferenceID:
-		m.ResetReferenceID()
-		return nil
-	case crontask.FieldTargets:
-		m.ResetTargets()
-		return nil
-	case crontask.FieldStatus:
-		m.ResetStatus()
+	case discordinteraction.FieldCommand:
+		m.ResetCommand()
 		return nil
-	case crontask.FieldScheduledAfter:
-		m.ResetScheduledAfter()
+	case discordinteraction.FieldUserID:
+		m.ResetUserID()
 		return nil
-	case crontask.FieldLastRun:
-		m.ResetLastRun()
+	case discordinteraction.FieldReferenceID:
+		m.ResetReferenceID()
 		return nil
-	case crontask.FieldTriesLeft:
-		m.ResetTriesLeft()
+	case discordinteraction.FieldType:
+		m.ResetType()
 		return nil
-	case crontask.FieldLogs:
-		m.ResetLogs()
+	case discordinteraction.FieldLocale:
+		m.ResetLocale()
 		return nil
-	case crontask.FieldData:
-		m.ResetData()
+	case discordinteraction.FieldOptions:
+		m.ResetOptions()
 		return nil
 	}
-	return fmt.Errorf("unknown CronTask field %s", name)
+	return fmt.Errorf("unknown DiscordInteraction field %s", name)
 }
 
 // AddedEdges returns all edge names that were set/added in this mutation.
-func (m *CronTaskMutation) AddedEdges() []string {
-	edges := make([]string, 0, 0)
+func (m *DiscordInteractionMutation) AddedEdges() []string {
+	edges := make([]string, 0, 1)
+	if m.user != nil {
+		edges = append(edges, discordinteraction.EdgeUser)
+	}
 	return edges
 }
 
 // AddedIDs returns all IDs (to other nodes) that were added for the given edge
 // name in this mutation.
-func (m *CronTaskMutation) AddedIDs(name string) []ent.Value {
+func (m *DiscordInteractionMutation) AddedIDs(name string) []ent.Value {
+	switch name {
+	case discordinteraction.EdgeUser:
+		if id := m.user; id != nil {
+			return []ent.Value{*id}
+		}
+	}
 	return nil
 }
 
 // RemovedEdges returns all edge names that were removed in this mutation.
-func (m *CronTaskMutation) RemovedEdges() []string {
-	edges := make([]string, 0, 0)
+func (m *DiscordInteractionMutation) RemovedEdges() []string {
+	edges := make([]string, 0, 1)
 	return edges
 }
 
 // RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
 // the given name in this mutation.
-func (m *CronTaskMutation) RemovedIDs(name string) []ent.Value {
+func (m *DiscordInteractionMutation) RemovedIDs(name string) []ent.Value {
 	return nil
 }
 
 // ClearedEdges returns all edge names that were cleared in this mutation.
-func (m *CronTaskMutation) ClearedEdges() []string {
-	edges := make([]string, 0, 0)
+func (m *DiscordInteractionMutation) ClearedEdges() []string {
+	edges := make([]string, 0, 1)
+	if m.cleareduser {
+		edges = append(edges, discordinteraction.EdgeUser)
+	}
 	return edges
 }
 
 // EdgeCleared returns a boolean which indicates if the edge with the given name
 // was cleared in this mutation.
-func (m *CronTaskMutation) EdgeCleared(name string) bool {
+func (m *DiscordInteractionMutation) EdgeCleared(name string) bool {
+	switch name {
+	case discordinteraction.EdgeUser:
+		return m.cleareduser
+	}
 	return false
 }
 
 // ClearEdge clears the value of the edge with the given name. It returns an error
 // if that edge is not defined in the schema.
-func (m *CronTaskMutation) ClearEdge(name string) error {
-	return fmt.Errorf("unknown CronTask unique edge %s", name)
+func (m *DiscordInteractionMutation) ClearEdge(name string) error {
+	switch name {
+	case discordinteraction.EdgeUser:
+		m.ClearUser()
+		return nil
+	}
+	return fmt.Errorf("unknown DiscordInteraction unique edge %s", name)
 }
 
 // ResetEdge resets all changes to the edge with the given name in this mutation.
 // It returns an error if the edge is not defined in the schema.
-func (m *CronTaskMutation) ResetEdge(name string) error {
-	return fmt.Errorf("unknown CronTask edge %s", name)
+func (m *DiscordInteractionMutation) ResetEdge(name string) error {
+	switch name {
+	case discordinteraction.EdgeUser:
+		m.ResetUser()
+		return nil
+	}
+	return fmt.Errorf("unknown DiscordInteraction edge %s", name)
 }
 
-// DiscordInteractionMutation represents an operation that mutates the DiscordInteraction nodes in the graph.
-type DiscordInteractionMutation struct {
+// SessionMutation represents an operation that mutates the Session nodes in the graph.
+type SessionMutation struct {
 	config
 	op            Op
 	typ           string
 	id            *string
 	created_at    *time.Time
 	updated_at    *time.Time
-	command       *string
-	reference_id  *string
-	_type         *models.DiscordInteractionType
-	locale        *string
-	options       *models.DiscordInteractionOptions
+	expires_at    *time.Time
+	public_id     *string
+	metadata      *map[string]string
 	clearedFields map[string]struct{}
 	user          *string
 	cleareduser   bool
 	done          bool
-	oldValue      func(context.Context) (*DiscordInteraction, error)
-	predicates    []predicate.DiscordInteraction
+	oldValue      func(context.Context) (*Session, error)
+	predicates    []predicate.Session
 }
 
-var _ ent.Mutation = (*DiscordInteractionMutation)(nil)
+var _ ent.Mutation = (*SessionMutation)(nil)
 
-// discordinteractionOption allows management of the mutation configuration using functional options.
-type discordinteractionOption func(*DiscordInteractionMutation)
+// sessionOption allows management of the mutation configuration using functional options.
+type sessionOption func(*SessionMutation)
 
-// newDiscordInteractionMutation creates new mutation for the DiscordInteraction entity.
-func newDiscordInteractionMutation(c config, op Op, opts ...discordinteractionOption) *DiscordInteractionMutation {
-	m := &DiscordInteractionMutation{
+// newSessionMutation creates new mutation for the Session entity.
+func newSessionMutation(c config, op Op, opts ...sessionOption) *SessionMutation {
+	m := &SessionMutation{
 		config:        c,
 		op:            op,
-		typ:           TypeDiscordInteraction,
+		typ:           TypeSession,
 		clearedFields: make(map[string]struct{}),
 	}
 	for _, opt := range opts {
@@ -5667,20 +7089,20 @@ func newDiscordInteractionMutation(c config, op Op, opts ...discordinteractionOp
 	return m
 }
 
-// withDiscordInteractionID sets the ID field of the mutation.
-func withDiscordInteractionID(id string) discordinteractionOption {
-	return func(m *DiscordInteractionMutation) {
+// withSessionID sets the ID field of the mutation.
+func withSessionID(id string) sessionOption {
+	return func(m *SessionMutation) {
 		var (
 			err   error
 			once  sync.Once
-			value *DiscordInteraction
+			value *Session
 		)
-		m.oldValue = func(ctx context.Context) (*DiscordInteraction, error) {
+		m.oldValue = func(ctx context.Context) (*Session, error) {
 			once.Do(func() {
 				if m.done {
 					err = errors.New("querying old values post mutation is not allowed")
 				} else {
-					value, err = m.Client().DiscordInteraction.Get(ctx, id)
+					value, err = m.Client().Session.Get(ctx, id)
 				}
 			})
 			return value, err
@@ -5689,10 +7111,10 @@ func withDiscordInteractionID(id string) discordinteractionOption {
 	}
 }
 
-// withDiscordInteraction sets the old DiscordInteraction of the mutation.
-func withDiscordInteraction(node *DiscordInteraction) discordinteractionOption {
-	return func(m *DiscordInteractionMutation) {
-		m.oldValue = func(context.Context) (*DiscordInteraction, error) {
+// withSession sets the old Session of the mutation.
+func withSession(node *Session) sessionOption {
+	return func(m *SessionMutation) {
+		m.oldValue = func(context.Context) (*Session, error) {
 			return node, nil
 		}
 		m.id = &node.ID
@@ -5701,7 +7123,7 @@ func withDiscordInteraction(node *DiscordInteraction) discordinteractionOption {
 
 // Client returns a new `ent.Client` from the mutation. If the mutation was
 // executed in a transaction (ent.Tx), a transactional client is returned.
-func (m DiscordInteractionMutation) Client() *Client {
+func (m SessionMutation) Client() *Client {
 	client := &Client{config: m.config}
 	client.init()
 	return client
@@ -5709,7 +7131,7 @@ func (m DiscordInteractionMutation) Client() *Client {
 
 // Tx returns an `ent.Tx` for mutations that were executed in transactions;
 // it returns an error otherwise.
-func (m DiscordInteractionMutation) Tx() (*Tx, error) {
+func (m SessionMutation) Tx() (*Tx, error) {
 	if _, ok := m.driver.(*txDriver); !ok {
 		return nil, errors.New("db: mutation is not running in a transaction")
 	}
@@ -5719,14 +7141,14 @@ func (m DiscordInteractionMutation) Tx() (*Tx, error) {
 }
 
 // SetID sets the value of the id field. Note that this
-// operation is only accepted on creation of DiscordInteraction entities.
-func (m *DiscordInteractionMutation) SetID(id string) {
+// operation is only accepted on creation of Session entities.
+func (m *SessionMutation) SetID(id string) {
 	m.id = &id
 }
 
 // ID returns the ID value in the mutation. Note that the ID is only available
 // if it was provided to the builder or after it was returned from the database.
-func (m *DiscordInteractionMutation) ID() (id string, exists bool) {
+func (m *SessionMutation) ID() (id string, exists bool) {
 	if m.id == nil {
 		return
 	}
@@ -5737,7 +7159,7 @@ func (m *DiscordInteractionMutation) ID() (id string, exists bool) {
 // That means, if the mutation is applied within a transaction with an isolation level such
 // as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
 // or updated by the mutation.
-func (m *DiscordInteractionMutation) IDs(ctx context.Context) ([]string, error) {
+func (m *SessionMutation) IDs(ctx context.Context) ([]string, error) {
 	switch {
 	case m.op.Is(OpUpdateOne | OpDeleteOne):
 		id, exists := m.ID()
@@ -5746,19 +7168,19 @@ func (m *DiscordInteractionMutation) IDs(ctx context.Context) ([]string, error)
 		}
 		fallthrough
 	case m.op.Is(OpUpdate | OpDelete):
-		return m.Client().DiscordInteraction.Query().Where(m.predicates...).IDs(ctx)
+		return m.Client().Session.Query().Where(m.predicates...).IDs(ctx)
 	default:
 		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
 	}
 }
 
 // SetCreatedAt sets the "created_at" field.
-func (m *DiscordInteractionMutation) SetCreatedAt(t time.Time) {
+func (m *SessionMutation) SetCreatedAt(t time.Time) {
 	m.created_at = &t
 }
 
 // CreatedAt returns the value of the "created_at" field in the mutation.
-func (m *DiscordInteractionMutation) CreatedAt() (r time.Time, exists bool) {
+func (m *SessionMutation) CreatedAt() (r time.Time, exists bool) {
 	v := m.created_at
 	if v == nil {
 		return
@@ -5766,10 +7188,10 @@ func (m *DiscordInteractionMutation) CreatedAt() (r time.Time, exists bool) {
 	return *v, true
 }
 
-// OldCreatedAt returns the old "created_at" field's value of the DiscordInteraction entity.
-// If the DiscordInteraction object wasn't provided to the builder, the object is fetched from the database.
+// OldCreatedAt returns the old "created_at" field's value of the Session entity.
+// If the Session object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *DiscordInteractionMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
+func (m *SessionMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
 	}
@@ -5784,17 +7206,17 @@ func (m *DiscordInteractionMutation) OldCreatedAt(ctx context.Context) (v time.T
 }
 
 // ResetCreatedAt resets all changes to the "created_at" field.
-func (m *DiscordInteractionMutation) ResetCreatedAt() {
+func (m *SessionMutation) ResetCreatedAt() {
 	m.created_at = nil
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (m *DiscordInteractionMutation) SetUpdatedAt(t time.Time) {
+func (m *SessionMutation) SetUpdatedAt(t time.Time) {
 	m.updated_at = &t
 }
 
 // UpdatedAt returns the value of the "updated_at" field in the mutation.
-func (m *DiscordInteractionMutation) UpdatedAt() (r time.Time, exists bool) {
+func (m *SessionMutation) UpdatedAt() (r time.Time, exists bool) {
 	v := m.updated_at
 	if v == nil {
 		return
@@ -5802,10 +7224,10 @@ func (m *DiscordInteractionMutation) UpdatedAt() (r time.Time, exists bool) {
 	return *v, true
 }
 
-// OldUpdatedAt returns the old "updated_at" field's value of the DiscordInteraction entity.
-// If the DiscordInteraction object wasn't provided to the builder, the object is fetched from the database.
+// OldUpdatedAt returns the old "updated_at" field's value of the Session entity.
+// If the Session object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *DiscordInteractionMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
+func (m *SessionMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
 	}
@@ -5820,53 +7242,53 @@ func (m *DiscordInteractionMutation) OldUpdatedAt(ctx context.Context) (v time.T
 }
 
 // ResetUpdatedAt resets all changes to the "updated_at" field.
-func (m *DiscordInteractionMutation) ResetUpdatedAt() {
+func (m *SessionMutation) ResetUpdatedAt() {
 	m.updated_at = nil
 }
 
-// SetCommand sets the "command" field.
-func (m *DiscordInteractionMutation) SetCommand(s string) {
-	m.command = &s
+// SetExpiresAt sets the "expires_at" field.
+func (m *SessionMutation) SetExpiresAt(t time.Time) {
+	m.expires_at = &t
 }
 
-// Command returns the value of the "command" field in the mutation.
-func (m *DiscordInteractionMutation) Command() (r string, exists bool) {
-	v := m.command
+// ExpiresAt returns the value of the "expires_at" field in the mutation.
+func (m *SessionMutation) ExpiresAt() (r time.Time, exists bool) {
+	v := m.expires_at
 	if v == nil {
 		return
 	}
 	return *v, true
 }
 
-// OldCommand returns the old "command" field's value of the DiscordInteraction entity.
-// If the DiscordInteraction object wasn't provided to the builder, the object is fetched from the database.
+// OldExpiresAt returns the old "expires_at" field's value of the Session entity.
+// If the Session object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *DiscordInteractionMutation) OldCommand(ctx context.Context) (v string, err error) {
+func (m *SessionMutation) OldExpiresAt(ctx context.Context) (v time.Time, err error) {
 	if !m.op.Is(OpUpdateOne) {
-		return v, errors.New("OldCommand is only allowed on UpdateOne operations")
+		return v, errors.New("OldExpiresAt is only allowed on UpdateOne operations")
 	}
 	if m.id == nil || m.oldValue == nil {
-		return v, errors.New("OldCommand requires an ID field in the mutation")
+		return v, errors.New("OldExpiresAt requires an ID field in the mutation")
 	}
 	oldValue, err := m.oldValue(ctx)
 	if err != nil {
-		return v, fmt.Errorf("querying old value for OldCommand: %w", err)
+		return v, fmt.Errorf("querying old value for OldExpiresAt: %w", err)
 	}
-	return oldValue.Command, nil
+	return oldValue.ExpiresAt, nil
 }
 
-// ResetCommand resets all changes to the "command" field.
-func (m *DiscordInteractionMutation) ResetCommand() {
-	m.command = nil
+// ResetExpiresAt resets all changes to the "expires_at" field.
+func (m *SessionMutation) ResetExpiresAt() {
+	m.expires_at = nil
 }
 
 // SetUserID sets the "user_id" field.
-func (m *DiscordInteractionMutation) SetUserID(s string) {
+func (m *SessionMutation) SetUserID(s string) {
 	m.user = &s
 }
 
 // UserID returns the value of the "user_id" field in the mutation.
-func (m *DiscordInteractionMutation) UserID() (r string, exists bool) {
+func (m *SessionMutation) UserID() (r string, exists bool) {
 	v := m.user
 	if v == nil {
 		return
@@ -5874,10 +7296,10 @@ func (m *DiscordInteractionMutation) UserID() (r string, exists bool) {
 	return *v, true
 }
 
-// OldUserID returns the old "user_id" field's value of the DiscordInteraction entity.
-// If the DiscordInteraction object wasn't provided to the builder, the object is fetched from the database.
+// OldUserID returns the old "user_id" field's value of the Session entity.
+// If the Session object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *DiscordInteractionMutation) OldUserID(ctx context.Context) (v string, err error) {
+func (m *SessionMutation) OldUserID(ctx context.Context) (v string, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldUserID is only allowed on UpdateOne operations")
 	}
@@ -5891,170 +7313,98 @@ func (m *DiscordInteractionMutation) OldUserID(ctx context.Context) (v string, e
 	return oldValue.UserID, nil
 }
 
-// ResetUserID resets all changes to the "user_id" field.
-func (m *DiscordInteractionMutation) ResetUserID() {
-	m.user = nil
-}
-
-// SetReferenceID sets the "reference_id" field.
-func (m *DiscordInteractionMutation) SetReferenceID(s string) {
-	m.reference_id = &s
-}
-
-// ReferenceID returns the value of the "reference_id" field in the mutation.
-func (m *DiscordInteractionMutation) ReferenceID() (r string, exists bool) {
-	v := m.reference_id
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
-// OldReferenceID returns the old "reference_id" field's value of the DiscordInteraction entity.
-// If the DiscordInteraction object wasn't provided to the builder, the object is fetched from the database.
-// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *DiscordInteractionMutation) OldReferenceID(ctx context.Context) (v string, err error) {
-	if !m.op.Is(OpUpdateOne) {
-		return v, errors.New("OldReferenceID is only allowed on UpdateOne operations")
-	}
-	if m.id == nil || m.oldValue == nil {
-		return v, errors.New("OldReferenceID requires an ID field in the mutation")
-	}
-	oldValue, err := m.oldValue(ctx)
-	if err != nil {
-		return v, fmt.Errorf("querying old value for OldReferenceID: %w", err)
-	}
-	return oldValue.ReferenceID, nil
-}
-
-// ResetReferenceID resets all changes to the "reference_id" field.
-func (m *DiscordInteractionMutation) ResetReferenceID() {
-	m.reference_id = nil
-}
-
-// SetType sets the "type" field.
-func (m *DiscordInteractionMutation) SetType(mit models.DiscordInteractionType) {
-	m._type = &mit
-}
-
-// GetType returns the value of the "type" field in the mutation.
-func (m *DiscordInteractionMutation) GetType() (r models.DiscordInteractionType, exists bool) {
-	v := m._type
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
-// OldType returns the old "type" field's value of the DiscordInteraction entity.
-// If the DiscordInteraction object wasn't provided to the builder, the object is fetched from the database.
-// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *DiscordInteractionMutation) OldType(ctx context.Context) (v models.DiscordInteractionType, err error) {
-	if !m.op.Is(OpUpdateOne) {
-		return v, errors.New("OldType is only allowed on UpdateOne operations")
-	}
-	if m.id == nil || m.oldValue == nil {
-		return v, errors.New("OldType requires an ID field in the mutation")
-	}
-	oldValue, err := m.oldValue(ctx)
-	if err != nil {
-		return v, fmt.Errorf("querying old value for OldType: %w", err)
-	}
-	return oldValue.Type, nil
-}
-
-// ResetType resets all changes to the "type" field.
-func (m *DiscordInteractionMutation) ResetType() {
-	m._type = nil
-}
-
-// SetLocale sets the "locale" field.
-func (m *DiscordInteractionMutation) SetLocale(s string) {
-	m.locale = &s
+// ResetUserID resets all changes to the "user_id" field.
+func (m *SessionMutation) ResetUserID() {
+	m.user = nil
 }
 
-// Locale returns the value of the "locale" field in the mutation.
-func (m *DiscordInteractionMutation) Locale() (r string, exists bool) {
-	v := m.locale
+// SetPublicID sets the "public_id" field.
+func (m *SessionMutation) SetPublicID(s string) {
+	m.public_id = &s
+}
+
+// PublicID returns the value of the "public_id" field in the mutation.
+func (m *SessionMutation) PublicID() (r string, exists bool) {
+	v := m.public_id
 	if v == nil {
 		return
 	}
 	return *v, true
 }
 
-// OldLocale returns the old "locale" field's value of the DiscordInteraction entity.
-// If the DiscordInteraction object wasn't provided to the builder, the object is fetched from the database.
+// OldPublicID returns the old "public_id" field's value of the Session entity.
+// If the Session object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *DiscordInteractionMutation) OldLocale(ctx context.Context) (v string, err error) {
+func (m *SessionMutation) OldPublicID(ctx context.Context) (v string, err error) {
 	if !m.op.Is(OpUpdateOne) {
-		return v, errors.New("OldLocale is only allowed on UpdateOne operations")
+		return v, errors.New("OldPublicID is only allowed on UpdateOne operations")
 	}
 	if m.id == nil || m.oldValue == nil {
-		return v, errors.New("OldLocale requires an ID field in the mutation")
+		return v, errors.New("OldPublicID requires an ID field in the mutation")
 	}
 	oldValue, err := m.oldValue(ctx)
 	if err != nil {
-		return v, fmt.Errorf("querying old value for OldLocale: %w", err)
+		return v, fmt.Errorf("querying old value for OldPublicID: %w", err)
 	}
-	return oldValue.Locale, nil
+	return oldValue.PublicID, nil
 }
 
-// ResetLocale resets all changes to the "locale" field.
-func (m *DiscordInteractionMutation) ResetLocale() {
-	m.locale = nil
+// ResetPublicID resets all changes to the "public_id" field.
+func (m *SessionMutation) ResetPublicID() {
+	m.public_id = nil
 }
 
-// SetOptions sets the "options" field.
-func (m *DiscordInteractionMutation) SetOptions(mio models.DiscordInteractionOptions) {
-	m.options = &mio
+// SetMetadata sets the "metadata" field.
+func (m *SessionMutation) SetMetadata(value map[string]string) {
+	m.metadata = &value
 }
 
-// Options returns the value of the "options" field in the mutation.
-func (m *DiscordInteractionMutation) Options() (r models.DiscordInteractionOptions, exists bool) {
-	v := m.options
+// Metadata returns the value of the "metadata" field in the mutation.
+func (m *SessionMutation) Metadata() (r map[string]string, exists bool) {
+	v := m.metadata
 	if v == nil {
 		return
 	}
 	return *v, true
 }
 
-// OldOptions returns the old "options" field's value of the DiscordInteraction entity.
-// If the DiscordInteraction object wasn't provided to the builder, the object is fetched from the database.
+// OldMetadata returns the old "metadata" field's value of the Session entity.
+// If the Session object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *DiscordInteractionMutation) OldOptions(ctx context.Context) (v models.DiscordInteractionOptions, err error) {
+func (m *SessionMutation) OldMetadata(ctx context.Context) (v map[string]string, err error) {
 	if !m.op.Is(OpUpdateOne) {
-		return v, errors.New("OldOptions is only allowed on UpdateOne operations")
+		return v, errors.New("OldMetadata is only allowed on UpdateOne operations")
 	}
 	if m.id == nil || m.oldValue == nil {
-		return v, errors.New("OldOptions requires an ID field in the mutation")
+		return v, errors.New("OldMetadata requires an ID field in the mutation")
 	}
 	oldValue, err := m.oldValue(ctx)
 	if err != nil {
-		return v, fmt.Errorf("querying old value for OldOptions: %w", err)
+		return v, fmt.Errorf("querying old value for OldMetadata: %w", err)
 	}
-	return oldValue.Options, nil
+	return oldValue.Metadata, nil
 }
 
-// ResetOptions resets all changes to the "options" field.
-func (m *DiscordInteractionMutation) ResetOptions() {
-	m.options = nil
+// ResetMetadata resets all changes to the "metadata" field.
+func (m *SessionMutation) ResetMetadata() {
+	m.metadata = nil
 }
 
 // ClearUser clears the "user" edge to the User entity.
-func (m *DiscordInteractionMutation) ClearUser() {
+func (m *SessionMutation) ClearUser() {
 	m.cleareduser = true
-	m.clearedFields[discordinteraction.FieldUserID] = struct{}{}
+	m.clearedFields[session.FieldUserID] = struct{}{}
 }
 
 // UserCleared reports if the "user" edge to the User entity was cleared.
-func (m *DiscordInteractionMutation) UserCleared() bool {
+func (m *SessionMutation) UserCleared() bool {
 	return m.cleareduser
 }
 
 // UserIDs returns the "user" edge IDs in the mutation.
 // Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
 // UserID instead. It exists only for internal usage by the builders.
-func (m *DiscordInteractionMutation) UserIDs() (ids []string) {
+func (m *SessionMutation) UserIDs() (ids []string) {
 	if id := m.user; id != nil {
 		ids = append(ids, *id)
 	}
@@ -6062,20 +7412,20 @@ func (m *DiscordInteractionMutation) UserIDs() (ids []string) {
 }
 
 // ResetUser resets all changes to the "user" edge.
-func (m *DiscordInteractionMutation) ResetUser() {
+func (m *SessionMutation) ResetUser() {
 	m.user = nil
 	m.cleareduser = false
 }
 
-// Where appends a list predicates to the DiscordInteractionMutation builder.
-func (m *DiscordInteractionMutation) Where(ps ...predicate.DiscordInteraction) {
+// Where appends a list predicates to the SessionMutation builder.
+func (m *SessionMutation) Where(ps ...predicate.Session) {
 	m.predicates = append(m.predicates, ps...)
 }
 
-// WhereP appends storage-level predicates to the DiscordInteractionMutation builder. Using this method,
+// WhereP appends storage-level predicates to the SessionMutation builder. Using this method,
 // users can use type-assertion to append predicates that do not depend on any generated package.
-func (m *DiscordInteractionMutation) WhereP(ps ...func(*sql.Selector)) {
-	p := make([]predicate.DiscordInteraction, len(ps))
+func (m *SessionMutation) WhereP(ps ...func(*sql.Selector)) {
+	p := make([]predicate.Session, len(ps))
 	for i := range ps {
 		p[i] = ps[i]
 	}
@@ -6083,48 +7433,42 @@ func (m *DiscordInteractionMutation) WhereP(ps ...func(*sql.Selector)) {
 }
 
 // Op returns the operation name.
-func (m *DiscordInteractionMutation) Op() Op {
+func (m *SessionMutation) Op() Op {
 	return m.op
 }
 
 // SetOp allows setting the mutation operation.
-func (m *DiscordInteractionMutation) SetOp(op Op) {
+func (m *SessionMutation) SetOp(op Op) {
 	m.op = op
 }
 
-// Type returns the node type of this mutation (DiscordInteraction).
-func (m *DiscordInteractionMutation) Type() string {
+// Type returns the node type of this mutation (Session).
+func (m *SessionMutation) Type() string {
 	return m.typ
 }
 
 // Fields returns all fields that were changed during this mutation. Note that in
 // order to get all numeric fields that were incremented/decremented, call
 // AddedFields().
-func (m *DiscordInteractionMutation) Fields() []string {
-	fields := make([]string, 0, 8)
+func (m *SessionMutation) Fields() []string {
+	fields := make([]string, 0, 6)
 	if m.created_at != nil {
-		fields = append(fields, discordinteraction.FieldCreatedAt)
+		fields = append(fields, session.FieldCreatedAt)
 	}
 	if m.updated_at != nil {
-		fields = append(fields, discordinteraction.FieldUpdatedAt)
+		fields = append(fields, session.FieldUpdatedAt)
 	}
-	if m.command != nil {
-		fields = append(fields, discordinteraction.FieldCommand)
+	if m.expires_at != nil {
+		fields = append(fields, session.FieldExpiresAt)
 	}
 	if m.user != nil {
-		fields = append(fields, discordinteraction.FieldUserID)
-	}
-	if m.reference_id != nil {
-		fields = append(fields, discordinteraction.FieldReferenceID)
+		fields = append(fields, session.FieldUserID)
 	}
-	if m._type != nil {
-		fields = append(fields, discordinteraction.FieldType)
-	}
-	if m.locale != nil {
-		fields = append(fields, discordinteraction.FieldLocale)
+	if m.public_id != nil {
+		fields = append(fields, session.FieldPublicID)
 	}
-	if m.options != nil {
-		fields = append(fields, discordinteraction.FieldOptions)
+	if m.metadata != nil {
+		fields = append(fields, session.FieldMetadata)
 	}
 	return fields
 }
@@ -6132,24 +7476,20 @@ func (m *DiscordInteractionMutation) Fields() []string {
 // Field returns the value of a field with the given name. The second boolean
 // return value indicates that this field was not set, or was not defined in the
 // schema.
-func (m *DiscordInteractionMutation) Field(name string) (ent.Value, bool) {
+func (m *SessionMutation) Field(name string) (ent.Value, bool) {
 	switch name {
-	case discordinteraction.FieldCreatedAt:
+	case session.FieldCreatedAt:
 		return m.CreatedAt()
-	case discordinteraction.FieldUpdatedAt:
+	case session.FieldUpdatedAt:
 		return m.UpdatedAt()
-	case discordinteraction.FieldCommand:
-		return m.Command()
-	case discordinteraction.FieldUserID:
+	case session.FieldExpiresAt:
+		return m.ExpiresAt()
+	case session.FieldUserID:
 		return m.UserID()
-	case discordinteraction.FieldReferenceID:
-		return m.ReferenceID()
-	case discordinteraction.FieldType:
-		return m.GetType()
-	case discordinteraction.FieldLocale:
-		return m.Locale()
-	case discordinteraction.FieldOptions:
-		return m.Options()
+	case session.FieldPublicID:
+		return m.PublicID()
+	case session.FieldMetadata:
+		return m.Metadata()
 	}
 	return nil, false
 }
@@ -6157,180 +7497,156 @@ func (m *DiscordInteractionMutation) Field(name string) (ent.Value, bool) {
 // OldField returns the old value of the field from the database. An error is
 // returned if the mutation operation is not UpdateOne, or the query to the
 // database failed.
-func (m *DiscordInteractionMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
+func (m *SessionMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
 	switch name {
-	case discordinteraction.FieldCreatedAt:
+	case session.FieldCreatedAt:
 		return m.OldCreatedAt(ctx)
-	case discordinteraction.FieldUpdatedAt:
+	case session.FieldUpdatedAt:
 		return m.OldUpdatedAt(ctx)
-	case discordinteraction.FieldCommand:
-		return m.OldCommand(ctx)
-	case discordinteraction.FieldUserID:
+	case session.FieldExpiresAt:
+		return m.OldExpiresAt(ctx)
+	case session.FieldUserID:
 		return m.OldUserID(ctx)
-	case discordinteraction.FieldReferenceID:
-		return m.OldReferenceID(ctx)
-	case discordinteraction.FieldType:
-		return m.OldType(ctx)
-	case discordinteraction.FieldLocale:
-		return m.OldLocale(ctx)
-	case discordinteraction.FieldOptions:
-		return m.OldOptions(ctx)
+	case session.FieldPublicID:
+		return m.OldPublicID(ctx)
+	case session.FieldMetadata:
+		return m.OldMetadata(ctx)
 	}
-	return nil, fmt.Errorf("unknown DiscordInteraction field %s", name)
+	return nil, fmt.Errorf("unknown Session field %s", name)
 }
 
 // SetField sets the value of a field with the given name. It returns an error if
 // the field is not defined in the schema, or if the type mismatched the field
 // type.
-func (m *DiscordInteractionMutation) SetField(name string, value ent.Value) error {
+func (m *SessionMutation) SetField(name string, value ent.Value) error {
 	switch name {
-	case discordinteraction.FieldCreatedAt:
+	case session.FieldCreatedAt:
 		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetCreatedAt(v)
 		return nil
-	case discordinteraction.FieldUpdatedAt:
+	case session.FieldUpdatedAt:
 		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetUpdatedAt(v)
 		return nil
-	case discordinteraction.FieldCommand:
-		v, ok := value.(string)
+	case session.FieldExpiresAt:
+		v, ok := value.(time.Time)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
-		m.SetCommand(v)
+		m.SetExpiresAt(v)
 		return nil
-	case discordinteraction.FieldUserID:
+	case session.FieldUserID:
 		v, ok := value.(string)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
 		m.SetUserID(v)
 		return nil
-	case discordinteraction.FieldReferenceID:
-		v, ok := value.(string)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.SetReferenceID(v)
-		return nil
-	case discordinteraction.FieldType:
-		v, ok := value.(models.DiscordInteractionType)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.SetType(v)
-		return nil
-	case discordinteraction.FieldLocale:
+	case session.FieldPublicID:
 		v, ok := value.(string)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
-		m.SetLocale(v)
+		m.SetPublicID(v)
 		return nil
-	case discordinteraction.FieldOptions:
-		v, ok := value.(models.DiscordInteractionOptions)
+	case session.FieldMetadata:
+		v, ok := value.(map[string]string)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
-		m.SetOptions(v)
+		m.SetMetadata(v)
 		return nil
 	}
-	return fmt.Errorf("unknown DiscordInteraction field %s", name)
+	return fmt.Errorf("unknown Session field %s", name)
 }
 
 // AddedFields returns all numeric fields that were incremented/decremented during
 // this mutation.
-func (m *DiscordInteractionMutation) AddedFields() []string {
+func (m *SessionMutation) AddedFields() []string {
 	return nil
 }
 
 // AddedField returns the numeric value that was incremented/decremented on a field
 // with the given name. The second boolean return value indicates that this field
 // was not set, or was not defined in the schema.
-func (m *DiscordInteractionMutation) AddedField(name string) (ent.Value, bool) {
+func (m *SessionMutation) AddedField(name string) (ent.Value, bool) {
 	return nil, false
 }
 
 // AddField adds the value to the field with the given name. It returns an error if
 // the field is not defined in the schema, or if the type mismatched the field
 // type.
-func (m *DiscordInteractionMutation) AddField(name string, value ent.Value) error {
+func (m *SessionMutation) AddField(name string, value ent.Value) error {
 	switch name {
 	}
-	return fmt.Errorf("unknown DiscordInteraction numeric field %s", name)
+	return fmt.Errorf("unknown Session numeric field %s", name)
 }
 
 // ClearedFields returns all nullable fields that were cleared during this
 // mutation.
-func (m *DiscordInteractionMutation) ClearedFields() []string {
+func (m *SessionMutation) ClearedFields() []string {
 	return nil
 }
 
 // FieldCleared returns a boolean indicating if a field with the given name was
 // cleared in this mutation.
-func (m *DiscordInteractionMutation) FieldCleared(name string) bool {
+func (m *SessionMutation) FieldCleared(name string) bool {
 	_, ok := m.clearedFields[name]
 	return ok
 }
 
 // ClearField clears the value of the field with the given name. It returns an
 // error if the field is not defined in the schema.
-func (m *DiscordInteractionMutation) ClearField(name string) error {
-	return fmt.Errorf("unknown DiscordInteraction nullable field %s", name)
+func (m *SessionMutation) ClearField(name string) error {
+	return fmt.Errorf("unknown Session nullable field %s", name)
 }
 
 // ResetField resets all changes in the mutation for the field with the given name.
 // It returns an error if the field is not defined in the schema.
-func (m *DiscordInteractionMutation) ResetField(name string) error {
+func (m *SessionMutation) ResetField(name string) error {
 	switch name {
-	case discordinteraction.FieldCreatedAt:
+	case session.FieldCreatedAt:
 		m.ResetCreatedAt()
 		return nil
-	case discordinteraction.FieldUpdatedAt:
+	case session.FieldUpdatedAt:
 		m.ResetUpdatedAt()
 		return nil
-	case discordinteraction.FieldCommand:
-		m.ResetCommand()
+	case session.FieldExpiresAt:
+		m.ResetExpiresAt()
 		return nil
-	case discordinteraction.FieldUserID:
+	case session.FieldUserID:
 		m.ResetUserID()
 		return nil
-	case discordinteraction.FieldReferenceID:
-		m.ResetReferenceID()
-		return nil
-	case discordinteraction.FieldType:
-		m.ResetType()
-		return nil
-	case discordinteraction.FieldLocale:
-		m.ResetLocale()
+	case session.FieldPublicID:
+		m.ResetPublicID()
 		return nil
-	case discordinteraction.FieldOptions:
-		m.ResetOptions()
+	case session.FieldMetadata:
+		m.ResetMetadata()
 		return nil
 	}
-	return fmt.Errorf("unknown DiscordInteraction field %s", name)
+	return fmt.Errorf("unknown Session field %s", name)
 }
 
 // AddedEdges returns all edge names that were set/added in this mutation.
-func (m *DiscordInteractionMutation) AddedEdges() []string {
+func (m *SessionMutation) AddedEdges() []string {
 	edges := make([]string, 0, 1)
 	if m.user != nil {
-		edges = append(edges, discordinteraction.EdgeUser)
+		edges = append(edges, session.EdgeUser)
 	}
 	return edges
 }
 
 // AddedIDs returns all IDs (to other nodes) that were added for the given edge
 // name in this mutation.
-func (m *DiscordInteractionMutation) AddedIDs(name string) []ent.Value {
+func (m *SessionMutation) AddedIDs(name string) []ent.Value {
 	switch name {
-	case discordinteraction.EdgeUser:
+	case session.EdgeUser:
 		if id := m.user; id != nil {
 			return []ent.Value{*id}
 		}
@@ -6339,31 +7655,31 @@ func (m *DiscordInteractionMutation) AddedIDs(name string) []ent.Value {
 }
 
 // RemovedEdges returns all edge names that were removed in this mutation.
-func (m *DiscordInteractionMutation) RemovedEdges() []string {
+func (m *SessionMutation) RemovedEdges() []string {
 	edges := make([]string, 0, 1)
 	return edges
 }
 
 // RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
 // the given name in this mutation.
-func (m *DiscordInteractionMutation) RemovedIDs(name string) []ent.Value {
+func (m *SessionMutation) RemovedIDs(name string) []ent.Value {
 	return nil
 }
 
 // ClearedEdges returns all edge names that were cleared in this mutation.
-func (m *DiscordInteractionMutation) ClearedEdges() []string {
+func (m *SessionMutation) ClearedEdges() []string {
 	edges := make([]string, 0, 1)
 	if m.cleareduser {
-		edges = append(edges, discordinteraction.EdgeUser)
+		edges = append(edges, session.EdgeUser)
 	}
 	return edges
 }
 
 // EdgeCleared returns a boolean which indicates if the edge with the given name
 // was cleared in this mutation.
-func (m *DiscordInteractionMutation) EdgeCleared(name string) bool {
+func (m *SessionMutation) EdgeCleared(name string) bool {
 	switch name {
-	case discordinteraction.EdgeUser:
+	case session.EdgeUser:
 		return m.cleareduser
 	}
 	return false
@@ -6371,24 +7687,24 @@ func (m *DiscordInteractionMutation) EdgeCleared(name string) bool {
 
 // ClearEdge clears the value of the edge with the given name. It returns an error
 // if that edge is not defined in the schema.
-func (m *DiscordInteractionMutation) ClearEdge(name string) error {
+func (m *SessionMutation) ClearEdge(name string) error {
 	switch name {
-	case discordinteraction.EdgeUser:
+	case session.EdgeUser:
 		m.ClearUser()
 		return nil
 	}
-	return fmt.Errorf("unknown DiscordInteraction unique edge %s", name)
+	return fmt.Errorf("unknown Session unique edge %s", name)
 }
 
 // ResetEdge resets all changes to the edge with the given name in this mutation.
 // It returns an error if the edge is not defined in the schema.
-func (m *DiscordInteractionMutation) ResetEdge(name string) error {
+func (m *SessionMutation) ResetEdge(name string) error {
 	switch name {
-	case discordinteraction.EdgeUser:
+	case session.EdgeUser:
 		m.ResetUser()
 		return nil
 	}
-	return fmt.Errorf("unknown DiscordInteraction edge %s", name)
+	return fmt.Errorf("unknown Session edge %s", name)
 }
 
 // UserMutation represents an operation that mutates the User nodes in the graph.
@@ -6399,6 +7715,7 @@ type UserMutation struct {
 	id                          *string
 	created_at                  *time.Time
 	updated_at                  *time.Time
+	username                    *string
 	permissions                 *string
 	feature_flags               *[]string
 	appendfeature_flags         []string
@@ -6415,6 +7732,9 @@ type UserMutation struct {
 	content                     map[string]struct{}
 	removedcontent              map[string]struct{}
 	clearedcontent              bool
+	sessions                    map[string]struct{}
+	removedsessions             map[string]struct{}
+	clearedsessions             bool
 	done                        bool
 	oldValue                    func(context.Context) (*User, error)
 	predicates                  []predicate.User
@@ -6596,6 +7916,42 @@ func (m *UserMutation) ResetUpdatedAt() {
 	m.updated_at = nil
 }
 
+// SetUsername sets the "username" field.
+func (m *UserMutation) SetUsername(s string) {
+	m.username = &s
+}
+
+// Username returns the value of the "username" field in the mutation.
+func (m *UserMutation) Username() (r string, exists bool) {
+	v := m.username
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldUsername returns the old "username" field's value of the User entity.
+// If the User object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserMutation) OldUsername(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldUsername is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldUsername requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldUsername: %w", err)
+	}
+	return oldValue.Username, nil
+}
+
+// ResetUsername resets all changes to the "username" field.
+func (m *UserMutation) ResetUsername() {
+	m.username = nil
+}
+
 // SetPermissions sets the "permissions" field.
 func (m *UserMutation) SetPermissions(s string) {
 	m.permissions = &s
@@ -6913,6 +8269,60 @@ func (m *UserMutation) ResetContent() {
 	m.removedcontent = nil
 }
 
+// AddSessionIDs adds the "sessions" edge to the Session entity by ids.
+func (m *UserMutation) AddSessionIDs(ids ...string) {
+	if m.sessions == nil {
+		m.sessions = make(map[string]struct{})
+	}
+	for i := range ids {
+		m.sessions[ids[i]] = struct{}{}
+	}
+}
+
+// ClearSessions clears the "sessions" edge to the Session entity.
+func (m *UserMutation) ClearSessions() {
+	m.clearedsessions = true
+}
+
+// SessionsCleared reports if the "sessions" edge to the Session entity was cleared.
+func (m *UserMutation) SessionsCleared() bool {
+	return m.clearedsessions
+}
+
+// RemoveSessionIDs removes the "sessions" edge to the Session entity by IDs.
+func (m *UserMutation) RemoveSessionIDs(ids ...string) {
+	if m.removedsessions == nil {
+		m.removedsessions = make(map[string]struct{})
+	}
+	for i := range ids {
+		delete(m.sessions, ids[i])
+		m.removedsessions[ids[i]] = struct{}{}
+	}
+}
+
+// RemovedSessions returns the removed IDs of the "sessions" edge to the Session entity.
+func (m *UserMutation) RemovedSessionsIDs() (ids []string) {
+	for id := range m.removedsessions {
+		ids = append(ids, id)
+	}
+	return
+}
+
+// SessionsIDs returns the "sessions" edge IDs in the mutation.
+func (m *UserMutation) SessionsIDs() (ids []string) {
+	for id := range m.sessions {
+		ids = append(ids, id)
+	}
+	return
+}
+
+// ResetSessions resets all changes to the "sessions" edge.
+func (m *UserMutation) ResetSessions() {
+	m.sessions = nil
+	m.clearedsessions = false
+	m.removedsessions = nil
+}
+
 // Where appends a list predicates to the UserMutation builder.
 func (m *UserMutation) Where(ps ...predicate.User) {
 	m.predicates = append(m.predicates, ps...)
@@ -6947,13 +8357,16 @@ func (m *UserMutation) Type() string {
 // order to get all numeric fields that were incremented/decremented, call
 // AddedFields().
 func (m *UserMutation) Fields() []string {
-	fields := make([]string, 0, 4)
+	fields := make([]string, 0, 5)
 	if m.created_at != nil {
 		fields = append(fields, user.FieldCreatedAt)
 	}
 	if m.updated_at != nil {
 		fields = append(fields, user.FieldUpdatedAt)
 	}
+	if m.username != nil {
+		fields = append(fields, user.FieldUsername)
+	}
 	if m.permissions != nil {
 		fields = append(fields, user.FieldPermissions)
 	}
@@ -6972,6 +8385,8 @@ func (m *UserMutation) Field(name string) (ent.Value, bool) {
 		return m.CreatedAt()
 	case user.FieldUpdatedAt:
 		return m.UpdatedAt()
+	case user.FieldUsername:
+		return m.Username()
 	case user.FieldPermissions:
 		return m.Permissions()
 	case user.FieldFeatureFlags:
@@ -6989,6 +8404,8 @@ func (m *UserMutation) OldField(ctx context.Context, name string) (ent.Value, er
 		return m.OldCreatedAt(ctx)
 	case user.FieldUpdatedAt:
 		return m.OldUpdatedAt(ctx)
+	case user.FieldUsername:
+		return m.OldUsername(ctx)
 	case user.FieldPermissions:
 		return m.OldPermissions(ctx)
 	case user.FieldFeatureFlags:
@@ -7016,6 +8433,13 @@ func (m *UserMutation) SetField(name string, value ent.Value) error {
 		}
 		m.SetUpdatedAt(v)
 		return nil
+	case user.FieldUsername:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetUsername(v)
+		return nil
 	case user.FieldPermissions:
 		v, ok := value.(string)
 		if !ok {
@@ -7094,6 +8518,9 @@ func (m *UserMutation) ResetField(name string) error {
 	case user.FieldUpdatedAt:
 		m.ResetUpdatedAt()
 		return nil
+	case user.FieldUsername:
+		m.ResetUsername()
+		return nil
 	case user.FieldPermissions:
 		m.ResetPermissions()
 		return nil
@@ -7106,7 +8533,7 @@ func (m *UserMutation) ResetField(name string) error {
 
 // AddedEdges returns all edge names that were set/added in this mutation.
 func (m *UserMutation) AddedEdges() []string {
-	edges := make([]string, 0, 4)
+	edges := make([]string, 0, 5)
 	if m.discord_interactions != nil {
 		edges = append(edges, user.EdgeDiscordInteractions)
 	}
@@ -7119,6 +8546,9 @@ func (m *UserMutation) AddedEdges() []string {
 	if m.content != nil {
 		edges = append(edges, user.EdgeContent)
 	}
+	if m.sessions != nil {
+		edges = append(edges, user.EdgeSessions)
+	}
 	return edges
 }
 
@@ -7150,13 +8580,19 @@ func (m *UserMutation) AddedIDs(name string) []ent.Value {
 			ids = append(ids, id)
 		}
 		return ids
+	case user.EdgeSessions:
+		ids := make([]ent.Value, 0, len(m.sessions))
+		for id := range m.sessions {
+			ids = append(ids, id)
+		}
+		return ids
 	}
 	return nil
 }
 
 // RemovedEdges returns all edge names that were removed in this mutation.
 func (m *UserMutation) RemovedEdges() []string {
-	edges := make([]string, 0, 4)
+	edges := make([]string, 0, 5)
 	if m.removeddiscord_interactions != nil {
 		edges = append(edges, user.EdgeDiscordInteractions)
 	}
@@ -7169,6 +8605,9 @@ func (m *UserMutation) RemovedEdges() []string {
 	if m.removedcontent != nil {
 		edges = append(edges, user.EdgeContent)
 	}
+	if m.removedsessions != nil {
+		edges = append(edges, user.EdgeSessions)
+	}
 	return edges
 }
 
@@ -7200,13 +8639,19 @@ func (m *UserMutation) RemovedIDs(name string) []ent.Value {
 			ids = append(ids, id)
 		}
 		return ids
+	case user.EdgeSessions:
+		ids := make([]ent.Value, 0, len(m.removedsessions))
+		for id := range m.removedsessions {
+			ids = append(ids, id)
+		}
+		return ids
 	}
 	return nil
 }
 
 // ClearedEdges returns all edge names that were cleared in this mutation.
 func (m *UserMutation) ClearedEdges() []string {
-	edges := make([]string, 0, 4)
+	edges := make([]string, 0, 5)
 	if m.cleareddiscord_interactions {
 		edges = append(edges, user.EdgeDiscordInteractions)
 	}
@@ -7219,6 +8664,9 @@ func (m *UserMutation) ClearedEdges() []string {
 	if m.clearedcontent {
 		edges = append(edges, user.EdgeContent)
 	}
+	if m.clearedsessions {
+		edges = append(edges, user.EdgeSessions)
+	}
 	return edges
 }
 
@@ -7234,6 +8682,8 @@ func (m *UserMutation) EdgeCleared(name string) bool {
 		return m.clearedconnections
 	case user.EdgeContent:
 		return m.clearedcontent
+	case user.EdgeSessions:
+		return m.clearedsessions
 	}
 	return false
 }
@@ -7262,6 +8712,9 @@ func (m *UserMutation) ResetEdge(name string) error {
 	case user.EdgeContent:
 		m.ResetContent()
 		return nil
+	case user.EdgeSessions:
+		m.ResetSessions()
+		return nil
 	}
 	return fmt.Errorf("unknown User edge %s", name)
 }
diff --git a/internal/database/ent/db/predicate/predicate.go b/internal/database/ent/db/predicate/predicate.go
index 9814087f..5f57ffbb 100644
--- a/internal/database/ent/db/predicate/predicate.go
+++ b/internal/database/ent/db/predicate/predicate.go
@@ -21,6 +21,9 @@ type AppConfiguration func(*sql.Selector)
 // ApplicationCommand is the predicate function for applicationcommand builders.
 type ApplicationCommand func(*sql.Selector)
 
+// AuthNonce is the predicate function for authnonce builders.
+type AuthNonce func(*sql.Selector)
+
 // Clan is the predicate function for clan builders.
 type Clan func(*sql.Selector)
 
@@ -30,6 +33,9 @@ type CronTask func(*sql.Selector)
 // DiscordInteraction is the predicate function for discordinteraction builders.
 type DiscordInteraction func(*sql.Selector)
 
+// Session is the predicate function for session builders.
+type Session func(*sql.Selector)
+
 // User is the predicate function for user builders.
 type User func(*sql.Selector)
 
diff --git a/internal/database/ent/db/runtime.go b/internal/database/ent/db/runtime.go
index 7e0f56ad..34a91098 100644
--- a/internal/database/ent/db/runtime.go
+++ b/internal/database/ent/db/runtime.go
@@ -10,9 +10,11 @@ import (
 	"github.com/cufee/aftermath/internal/database/ent/db/achievementssnapshot"
 	"github.com/cufee/aftermath/internal/database/ent/db/appconfiguration"
 	"github.com/cufee/aftermath/internal/database/ent/db/applicationcommand"
+	"github.com/cufee/aftermath/internal/database/ent/db/authnonce"
 	"github.com/cufee/aftermath/internal/database/ent/db/clan"
 	"github.com/cufee/aftermath/internal/database/ent/db/crontask"
 	"github.com/cufee/aftermath/internal/database/ent/db/discordinteraction"
+	"github.com/cufee/aftermath/internal/database/ent/db/session"
 	"github.com/cufee/aftermath/internal/database/ent/db/user"
 	"github.com/cufee/aftermath/internal/database/ent/db/userconnection"
 	"github.com/cufee/aftermath/internal/database/ent/db/usercontent"
@@ -161,6 +163,30 @@ func init() {
 	applicationcommandDescID := applicationcommandFields[0].Descriptor()
 	// applicationcommand.DefaultID holds the default value on creation for the id field.
 	applicationcommand.DefaultID = applicationcommandDescID.Default.(func() string)
+	authnonceFields := schema.AuthNonce{}.Fields()
+	_ = authnonceFields
+	// authnonceDescCreatedAt is the schema descriptor for created_at field.
+	authnonceDescCreatedAt := authnonceFields[1].Descriptor()
+	// authnonce.DefaultCreatedAt holds the default value on creation for the created_at field.
+	authnonce.DefaultCreatedAt = authnonceDescCreatedAt.Default.(func() time.Time)
+	// authnonceDescUpdatedAt is the schema descriptor for updated_at field.
+	authnonceDescUpdatedAt := authnonceFields[2].Descriptor()
+	// authnonce.DefaultUpdatedAt holds the default value on creation for the updated_at field.
+	authnonce.DefaultUpdatedAt = authnonceDescUpdatedAt.Default.(func() time.Time)
+	// authnonce.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
+	authnonce.UpdateDefaultUpdatedAt = authnonceDescUpdatedAt.UpdateDefault.(func() time.Time)
+	// authnonceDescIdentifier is the schema descriptor for identifier field.
+	authnonceDescIdentifier := authnonceFields[5].Descriptor()
+	// authnonce.IdentifierValidator is a validator for the "identifier" field. It is called by the builders before save.
+	authnonce.IdentifierValidator = authnonceDescIdentifier.Validators[0].(func(string) error)
+	// authnonceDescPublicID is the schema descriptor for public_id field.
+	authnonceDescPublicID := authnonceFields[6].Descriptor()
+	// authnonce.PublicIDValidator is a validator for the "public_id" field. It is called by the builders before save.
+	authnonce.PublicIDValidator = authnonceDescPublicID.Validators[0].(func(string) error)
+	// authnonceDescID is the schema descriptor for id field.
+	authnonceDescID := authnonceFields[0].Descriptor()
+	// authnonce.DefaultID holds the default value on creation for the id field.
+	authnonce.DefaultID = authnonceDescID.Default.(func() string)
 	clanFields := schema.Clan{}.Fields()
 	_ = clanFields
 	// clanDescCreatedAt is the schema descriptor for created_at field.
@@ -237,6 +263,26 @@ func init() {
 	discordinteractionDescID := discordinteractionFields[0].Descriptor()
 	// discordinteraction.DefaultID holds the default value on creation for the id field.
 	discordinteraction.DefaultID = discordinteractionDescID.Default.(func() string)
+	sessionFields := schema.Session{}.Fields()
+	_ = sessionFields
+	// sessionDescCreatedAt is the schema descriptor for created_at field.
+	sessionDescCreatedAt := sessionFields[1].Descriptor()
+	// session.DefaultCreatedAt holds the default value on creation for the created_at field.
+	session.DefaultCreatedAt = sessionDescCreatedAt.Default.(func() time.Time)
+	// sessionDescUpdatedAt is the schema descriptor for updated_at field.
+	sessionDescUpdatedAt := sessionFields[2].Descriptor()
+	// session.DefaultUpdatedAt holds the default value on creation for the updated_at field.
+	session.DefaultUpdatedAt = sessionDescUpdatedAt.Default.(func() time.Time)
+	// session.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
+	session.UpdateDefaultUpdatedAt = sessionDescUpdatedAt.UpdateDefault.(func() time.Time)
+	// sessionDescPublicID is the schema descriptor for public_id field.
+	sessionDescPublicID := sessionFields[5].Descriptor()
+	// session.PublicIDValidator is a validator for the "public_id" field. It is called by the builders before save.
+	session.PublicIDValidator = sessionDescPublicID.Validators[0].(func(string) error)
+	// sessionDescID is the schema descriptor for id field.
+	sessionDescID := sessionFields[0].Descriptor()
+	// session.DefaultID holds the default value on creation for the id field.
+	session.DefaultID = sessionDescID.Default.(func() string)
 	userFields := schema.User{}.Fields()
 	_ = userFields
 	// userDescCreatedAt is the schema descriptor for created_at field.
@@ -249,8 +295,12 @@ func init() {
 	user.DefaultUpdatedAt = userDescUpdatedAt.Default.(func() time.Time)
 	// user.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
 	user.UpdateDefaultUpdatedAt = userDescUpdatedAt.UpdateDefault.(func() time.Time)
+	// userDescUsername is the schema descriptor for username field.
+	userDescUsername := userFields[3].Descriptor()
+	// user.DefaultUsername holds the default value on creation for the username field.
+	user.DefaultUsername = userDescUsername.Default.(string)
 	// userDescPermissions is the schema descriptor for permissions field.
-	userDescPermissions := userFields[3].Descriptor()
+	userDescPermissions := userFields[4].Descriptor()
 	// user.DefaultPermissions holds the default value on creation for the permissions field.
 	user.DefaultPermissions = userDescPermissions.Default.(string)
 	userconnectionFields := schema.UserConnection{}.Fields()
diff --git a/internal/database/ent/db/session.go b/internal/database/ent/db/session.go
new file mode 100644
index 00000000..34f65e03
--- /dev/null
+++ b/internal/database/ent/db/session.go
@@ -0,0 +1,193 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+	"time"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+	"github.com/cufee/aftermath/internal/database/ent/db/session"
+	"github.com/cufee/aftermath/internal/database/ent/db/user"
+)
+
+// Session is the model entity for the Session schema.
+type Session struct {
+	config `json:"-"`
+	// ID of the ent.
+	ID string `json:"id,omitempty"`
+	// CreatedAt holds the value of the "created_at" field.
+	CreatedAt time.Time `json:"created_at,omitempty"`
+	// UpdatedAt holds the value of the "updated_at" field.
+	UpdatedAt time.Time `json:"updated_at,omitempty"`
+	// ExpiresAt holds the value of the "expires_at" field.
+	ExpiresAt time.Time `json:"expires_at,omitempty"`
+	// UserID holds the value of the "user_id" field.
+	UserID string `json:"user_id,omitempty"`
+	// PublicID holds the value of the "public_id" field.
+	PublicID string `json:"public_id,omitempty"`
+	// Metadata holds the value of the "metadata" field.
+	Metadata map[string]string `json:"metadata,omitempty"`
+	// Edges holds the relations/edges for other nodes in the graph.
+	// The values are being populated by the SessionQuery when eager-loading is set.
+	Edges        SessionEdges `json:"edges"`
+	selectValues sql.SelectValues
+}
+
+// SessionEdges holds the relations/edges for other nodes in the graph.
+type SessionEdges struct {
+	// User holds the value of the user edge.
+	User *User `json:"user,omitempty"`
+	// loadedTypes holds the information for reporting if a
+	// type was loaded (or requested) in eager-loading or not.
+	loadedTypes [1]bool
+}
+
+// UserOrErr returns the User value or an error if the edge
+// was not loaded in eager-loading, or loaded but was not found.
+func (e SessionEdges) UserOrErr() (*User, error) {
+	if e.User != nil {
+		return e.User, nil
+	} else if e.loadedTypes[0] {
+		return nil, &NotFoundError{label: user.Label}
+	}
+	return nil, &NotLoadedError{edge: "user"}
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*Session) scanValues(columns []string) ([]any, error) {
+	values := make([]any, len(columns))
+	for i := range columns {
+		switch columns[i] {
+		case session.FieldMetadata:
+			values[i] = new([]byte)
+		case session.FieldID, session.FieldUserID, session.FieldPublicID:
+			values[i] = new(sql.NullString)
+		case session.FieldCreatedAt, session.FieldUpdatedAt, session.FieldExpiresAt:
+			values[i] = new(sql.NullTime)
+		default:
+			values[i] = new(sql.UnknownType)
+		}
+	}
+	return values, nil
+}
+
+// assignValues assigns the values that were returned from sql.Rows (after scanning)
+// to the Session fields.
+func (s *Session) assignValues(columns []string, values []any) error {
+	if m, n := len(values), len(columns); m < n {
+		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
+	}
+	for i := range columns {
+		switch columns[i] {
+		case session.FieldID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field id", values[i])
+			} else if value.Valid {
+				s.ID = value.String
+			}
+		case session.FieldCreatedAt:
+			if value, ok := values[i].(*sql.NullTime); !ok {
+				return fmt.Errorf("unexpected type %T for field created_at", values[i])
+			} else if value.Valid {
+				s.CreatedAt = value.Time
+			}
+		case session.FieldUpdatedAt:
+			if value, ok := values[i].(*sql.NullTime); !ok {
+				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
+			} else if value.Valid {
+				s.UpdatedAt = value.Time
+			}
+		case session.FieldExpiresAt:
+			if value, ok := values[i].(*sql.NullTime); !ok {
+				return fmt.Errorf("unexpected type %T for field expires_at", values[i])
+			} else if value.Valid {
+				s.ExpiresAt = value.Time
+			}
+		case session.FieldUserID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field user_id", values[i])
+			} else if value.Valid {
+				s.UserID = value.String
+			}
+		case session.FieldPublicID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field public_id", values[i])
+			} else if value.Valid {
+				s.PublicID = value.String
+			}
+		case session.FieldMetadata:
+			if value, ok := values[i].(*[]byte); !ok {
+				return fmt.Errorf("unexpected type %T for field metadata", values[i])
+			} else if value != nil && len(*value) > 0 {
+				if err := json.Unmarshal(*value, &s.Metadata); err != nil {
+					return fmt.Errorf("unmarshal field metadata: %w", err)
+				}
+			}
+		default:
+			s.selectValues.Set(columns[i], values[i])
+		}
+	}
+	return nil
+}
+
+// Value returns the ent.Value that was dynamically selected and assigned to the Session.
+// This includes values selected through modifiers, order, etc.
+func (s *Session) Value(name string) (ent.Value, error) {
+	return s.selectValues.Get(name)
+}
+
+// QueryUser queries the "user" edge of the Session entity.
+func (s *Session) QueryUser() *UserQuery {
+	return NewSessionClient(s.config).QueryUser(s)
+}
+
+// Update returns a builder for updating this Session.
+// Note that you need to call Session.Unwrap() before calling this method if this Session
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (s *Session) Update() *SessionUpdateOne {
+	return NewSessionClient(s.config).UpdateOne(s)
+}
+
+// Unwrap unwraps the Session entity that was returned from a transaction after it was closed,
+// so that all future queries will be executed through the driver which created the transaction.
+func (s *Session) Unwrap() *Session {
+	_tx, ok := s.config.driver.(*txDriver)
+	if !ok {
+		panic("db: Session is not a transactional entity")
+	}
+	s.config.driver = _tx.drv
+	return s
+}
+
+// String implements the fmt.Stringer.
+func (s *Session) String() string {
+	var builder strings.Builder
+	builder.WriteString("Session(")
+	builder.WriteString(fmt.Sprintf("id=%v, ", s.ID))
+	builder.WriteString("created_at=")
+	builder.WriteString(s.CreatedAt.Format(time.ANSIC))
+	builder.WriteString(", ")
+	builder.WriteString("updated_at=")
+	builder.WriteString(s.UpdatedAt.Format(time.ANSIC))
+	builder.WriteString(", ")
+	builder.WriteString("expires_at=")
+	builder.WriteString(s.ExpiresAt.Format(time.ANSIC))
+	builder.WriteString(", ")
+	builder.WriteString("user_id=")
+	builder.WriteString(s.UserID)
+	builder.WriteString(", ")
+	builder.WriteString("public_id=")
+	builder.WriteString(s.PublicID)
+	builder.WriteString(", ")
+	builder.WriteString("metadata=")
+	builder.WriteString(fmt.Sprintf("%v", s.Metadata))
+	builder.WriteByte(')')
+	return builder.String()
+}
+
+// Sessions is a parsable slice of Session.
+type Sessions []*Session
diff --git a/internal/database/ent/db/session/session.go b/internal/database/ent/db/session/session.go
new file mode 100644
index 00000000..52bb3557
--- /dev/null
+++ b/internal/database/ent/db/session/session.go
@@ -0,0 +1,121 @@
+// Code generated by ent, DO NOT EDIT.
+
+package session
+
+import (
+	"time"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+)
+
+const (
+	// Label holds the string label denoting the session type in the database.
+	Label = "session"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// FieldExpiresAt holds the string denoting the expires_at field in the database.
+	FieldExpiresAt = "expires_at"
+	// FieldUserID holds the string denoting the user_id field in the database.
+	FieldUserID = "user_id"
+	// FieldPublicID holds the string denoting the public_id field in the database.
+	FieldPublicID = "public_id"
+	// FieldMetadata holds the string denoting the metadata field in the database.
+	FieldMetadata = "metadata"
+	// EdgeUser holds the string denoting the user edge name in mutations.
+	EdgeUser = "user"
+	// Table holds the table name of the session in the database.
+	Table = "sessions"
+	// UserTable is the table that holds the user relation/edge.
+	UserTable = "sessions"
+	// UserInverseTable is the table name for the User entity.
+	// It exists in this package in order to avoid circular dependency with the "user" package.
+	UserInverseTable = "users"
+	// UserColumn is the table column denoting the user relation/edge.
+	UserColumn = "user_id"
+)
+
+// Columns holds all SQL columns for session fields.
+var Columns = []string{
+	FieldID,
+	FieldCreatedAt,
+	FieldUpdatedAt,
+	FieldExpiresAt,
+	FieldUserID,
+	FieldPublicID,
+	FieldMetadata,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() time.Time
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() time.Time
+	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
+	UpdateDefaultUpdatedAt func() time.Time
+	// PublicIDValidator is a validator for the "public_id" field. It is called by the builders before save.
+	PublicIDValidator func(string) error
+	// DefaultID holds the default value on creation for the "id" field.
+	DefaultID func() string
+)
+
+// OrderOption defines the ordering options for the Session queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByExpiresAt orders the results by the expires_at field.
+func ByExpiresAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldExpiresAt, opts...).ToFunc()
+}
+
+// ByUserID orders the results by the user_id field.
+func ByUserID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUserID, opts...).ToFunc()
+}
+
+// ByPublicID orders the results by the public_id field.
+func ByPublicID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldPublicID, opts...).ToFunc()
+}
+
+// ByUserField orders the results by user field.
+func ByUserField(field string, opts ...sql.OrderTermOption) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborTerms(s, newUserStep(), sql.OrderByField(field, opts...))
+	}
+}
+func newUserStep() *sqlgraph.Step {
+	return sqlgraph.NewStep(
+		sqlgraph.From(Table, FieldID),
+		sqlgraph.To(UserInverseTable, FieldID),
+		sqlgraph.Edge(sqlgraph.M2O, true, UserTable, UserColumn),
+	)
+}
diff --git a/internal/database/ent/db/session/where.go b/internal/database/ent/db/session/where.go
new file mode 100644
index 00000000..6409fe74
--- /dev/null
+++ b/internal/database/ent/db/session/where.go
@@ -0,0 +1,379 @@
+// Code generated by ent, DO NOT EDIT.
+
+package session
+
+import (
+	"time"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id string) predicate.Session {
+	return predicate.Session(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id string) predicate.Session {
+	return predicate.Session(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id string) predicate.Session {
+	return predicate.Session(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...string) predicate.Session {
+	return predicate.Session(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...string) predicate.Session {
+	return predicate.Session(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id string) predicate.Session {
+	return predicate.Session(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id string) predicate.Session {
+	return predicate.Session(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id string) predicate.Session {
+	return predicate.Session(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id string) predicate.Session {
+	return predicate.Session(sql.FieldLTE(FieldID, id))
+}
+
+// IDEqualFold applies the EqualFold predicate on the ID field.
+func IDEqualFold(id string) predicate.Session {
+	return predicate.Session(sql.FieldEqualFold(FieldID, id))
+}
+
+// IDContainsFold applies the ContainsFold predicate on the ID field.
+func IDContainsFold(id string) predicate.Session {
+	return predicate.Session(sql.FieldContainsFold(FieldID, id))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v time.Time) predicate.Session {
+	return predicate.Session(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v time.Time) predicate.Session {
+	return predicate.Session(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// ExpiresAt applies equality check predicate on the "expires_at" field. It's identical to ExpiresAtEQ.
+func ExpiresAt(v time.Time) predicate.Session {
+	return predicate.Session(sql.FieldEQ(FieldExpiresAt, v))
+}
+
+// UserID applies equality check predicate on the "user_id" field. It's identical to UserIDEQ.
+func UserID(v string) predicate.Session {
+	return predicate.Session(sql.FieldEQ(FieldUserID, v))
+}
+
+// PublicID applies equality check predicate on the "public_id" field. It's identical to PublicIDEQ.
+func PublicID(v string) predicate.Session {
+	return predicate.Session(sql.FieldEQ(FieldPublicID, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v time.Time) predicate.Session {
+	return predicate.Session(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v time.Time) predicate.Session {
+	return predicate.Session(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...time.Time) predicate.Session {
+	return predicate.Session(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...time.Time) predicate.Session {
+	return predicate.Session(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v time.Time) predicate.Session {
+	return predicate.Session(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v time.Time) predicate.Session {
+	return predicate.Session(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v time.Time) predicate.Session {
+	return predicate.Session(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v time.Time) predicate.Session {
+	return predicate.Session(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v time.Time) predicate.Session {
+	return predicate.Session(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v time.Time) predicate.Session {
+	return predicate.Session(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...time.Time) predicate.Session {
+	return predicate.Session(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...time.Time) predicate.Session {
+	return predicate.Session(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v time.Time) predicate.Session {
+	return predicate.Session(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v time.Time) predicate.Session {
+	return predicate.Session(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v time.Time) predicate.Session {
+	return predicate.Session(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v time.Time) predicate.Session {
+	return predicate.Session(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// ExpiresAtEQ applies the EQ predicate on the "expires_at" field.
+func ExpiresAtEQ(v time.Time) predicate.Session {
+	return predicate.Session(sql.FieldEQ(FieldExpiresAt, v))
+}
+
+// ExpiresAtNEQ applies the NEQ predicate on the "expires_at" field.
+func ExpiresAtNEQ(v time.Time) predicate.Session {
+	return predicate.Session(sql.FieldNEQ(FieldExpiresAt, v))
+}
+
+// ExpiresAtIn applies the In predicate on the "expires_at" field.
+func ExpiresAtIn(vs ...time.Time) predicate.Session {
+	return predicate.Session(sql.FieldIn(FieldExpiresAt, vs...))
+}
+
+// ExpiresAtNotIn applies the NotIn predicate on the "expires_at" field.
+func ExpiresAtNotIn(vs ...time.Time) predicate.Session {
+	return predicate.Session(sql.FieldNotIn(FieldExpiresAt, vs...))
+}
+
+// ExpiresAtGT applies the GT predicate on the "expires_at" field.
+func ExpiresAtGT(v time.Time) predicate.Session {
+	return predicate.Session(sql.FieldGT(FieldExpiresAt, v))
+}
+
+// ExpiresAtGTE applies the GTE predicate on the "expires_at" field.
+func ExpiresAtGTE(v time.Time) predicate.Session {
+	return predicate.Session(sql.FieldGTE(FieldExpiresAt, v))
+}
+
+// ExpiresAtLT applies the LT predicate on the "expires_at" field.
+func ExpiresAtLT(v time.Time) predicate.Session {
+	return predicate.Session(sql.FieldLT(FieldExpiresAt, v))
+}
+
+// ExpiresAtLTE applies the LTE predicate on the "expires_at" field.
+func ExpiresAtLTE(v time.Time) predicate.Session {
+	return predicate.Session(sql.FieldLTE(FieldExpiresAt, v))
+}
+
+// UserIDEQ applies the EQ predicate on the "user_id" field.
+func UserIDEQ(v string) predicate.Session {
+	return predicate.Session(sql.FieldEQ(FieldUserID, v))
+}
+
+// UserIDNEQ applies the NEQ predicate on the "user_id" field.
+func UserIDNEQ(v string) predicate.Session {
+	return predicate.Session(sql.FieldNEQ(FieldUserID, v))
+}
+
+// UserIDIn applies the In predicate on the "user_id" field.
+func UserIDIn(vs ...string) predicate.Session {
+	return predicate.Session(sql.FieldIn(FieldUserID, vs...))
+}
+
+// UserIDNotIn applies the NotIn predicate on the "user_id" field.
+func UserIDNotIn(vs ...string) predicate.Session {
+	return predicate.Session(sql.FieldNotIn(FieldUserID, vs...))
+}
+
+// UserIDGT applies the GT predicate on the "user_id" field.
+func UserIDGT(v string) predicate.Session {
+	return predicate.Session(sql.FieldGT(FieldUserID, v))
+}
+
+// UserIDGTE applies the GTE predicate on the "user_id" field.
+func UserIDGTE(v string) predicate.Session {
+	return predicate.Session(sql.FieldGTE(FieldUserID, v))
+}
+
+// UserIDLT applies the LT predicate on the "user_id" field.
+func UserIDLT(v string) predicate.Session {
+	return predicate.Session(sql.FieldLT(FieldUserID, v))
+}
+
+// UserIDLTE applies the LTE predicate on the "user_id" field.
+func UserIDLTE(v string) predicate.Session {
+	return predicate.Session(sql.FieldLTE(FieldUserID, v))
+}
+
+// UserIDContains applies the Contains predicate on the "user_id" field.
+func UserIDContains(v string) predicate.Session {
+	return predicate.Session(sql.FieldContains(FieldUserID, v))
+}
+
+// UserIDHasPrefix applies the HasPrefix predicate on the "user_id" field.
+func UserIDHasPrefix(v string) predicate.Session {
+	return predicate.Session(sql.FieldHasPrefix(FieldUserID, v))
+}
+
+// UserIDHasSuffix applies the HasSuffix predicate on the "user_id" field.
+func UserIDHasSuffix(v string) predicate.Session {
+	return predicate.Session(sql.FieldHasSuffix(FieldUserID, v))
+}
+
+// UserIDEqualFold applies the EqualFold predicate on the "user_id" field.
+func UserIDEqualFold(v string) predicate.Session {
+	return predicate.Session(sql.FieldEqualFold(FieldUserID, v))
+}
+
+// UserIDContainsFold applies the ContainsFold predicate on the "user_id" field.
+func UserIDContainsFold(v string) predicate.Session {
+	return predicate.Session(sql.FieldContainsFold(FieldUserID, v))
+}
+
+// PublicIDEQ applies the EQ predicate on the "public_id" field.
+func PublicIDEQ(v string) predicate.Session {
+	return predicate.Session(sql.FieldEQ(FieldPublicID, v))
+}
+
+// PublicIDNEQ applies the NEQ predicate on the "public_id" field.
+func PublicIDNEQ(v string) predicate.Session {
+	return predicate.Session(sql.FieldNEQ(FieldPublicID, v))
+}
+
+// PublicIDIn applies the In predicate on the "public_id" field.
+func PublicIDIn(vs ...string) predicate.Session {
+	return predicate.Session(sql.FieldIn(FieldPublicID, vs...))
+}
+
+// PublicIDNotIn applies the NotIn predicate on the "public_id" field.
+func PublicIDNotIn(vs ...string) predicate.Session {
+	return predicate.Session(sql.FieldNotIn(FieldPublicID, vs...))
+}
+
+// PublicIDGT applies the GT predicate on the "public_id" field.
+func PublicIDGT(v string) predicate.Session {
+	return predicate.Session(sql.FieldGT(FieldPublicID, v))
+}
+
+// PublicIDGTE applies the GTE predicate on the "public_id" field.
+func PublicIDGTE(v string) predicate.Session {
+	return predicate.Session(sql.FieldGTE(FieldPublicID, v))
+}
+
+// PublicIDLT applies the LT predicate on the "public_id" field.
+func PublicIDLT(v string) predicate.Session {
+	return predicate.Session(sql.FieldLT(FieldPublicID, v))
+}
+
+// PublicIDLTE applies the LTE predicate on the "public_id" field.
+func PublicIDLTE(v string) predicate.Session {
+	return predicate.Session(sql.FieldLTE(FieldPublicID, v))
+}
+
+// PublicIDContains applies the Contains predicate on the "public_id" field.
+func PublicIDContains(v string) predicate.Session {
+	return predicate.Session(sql.FieldContains(FieldPublicID, v))
+}
+
+// PublicIDHasPrefix applies the HasPrefix predicate on the "public_id" field.
+func PublicIDHasPrefix(v string) predicate.Session {
+	return predicate.Session(sql.FieldHasPrefix(FieldPublicID, v))
+}
+
+// PublicIDHasSuffix applies the HasSuffix predicate on the "public_id" field.
+func PublicIDHasSuffix(v string) predicate.Session {
+	return predicate.Session(sql.FieldHasSuffix(FieldPublicID, v))
+}
+
+// PublicIDEqualFold applies the EqualFold predicate on the "public_id" field.
+func PublicIDEqualFold(v string) predicate.Session {
+	return predicate.Session(sql.FieldEqualFold(FieldPublicID, v))
+}
+
+// PublicIDContainsFold applies the ContainsFold predicate on the "public_id" field.
+func PublicIDContainsFold(v string) predicate.Session {
+	return predicate.Session(sql.FieldContainsFold(FieldPublicID, v))
+}
+
+// HasUser applies the HasEdge predicate on the "user" edge.
+func HasUser() predicate.Session {
+	return predicate.Session(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, UserTable, UserColumn),
+		)
+		sqlgraph.HasNeighbors(s, step)
+	})
+}
+
+// HasUserWith applies the HasEdge predicate on the "user" edge with a given conditions (other predicates).
+func HasUserWith(preds ...predicate.User) predicate.Session {
+	return predicate.Session(func(s *sql.Selector) {
+		step := newUserStep()
+		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+			for _, p := range preds {
+				p(s)
+			}
+		})
+	})
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.Session) predicate.Session {
+	return predicate.Session(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.Session) predicate.Session {
+	return predicate.Session(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.Session) predicate.Session {
+	return predicate.Session(sql.NotPredicates(p))
+}
diff --git a/internal/database/ent/db/session_create.go b/internal/database/ent/db/session_create.go
new file mode 100644
index 00000000..38e5c37f
--- /dev/null
+++ b/internal/database/ent/db/session_create.go
@@ -0,0 +1,329 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/session"
+	"github.com/cufee/aftermath/internal/database/ent/db/user"
+)
+
+// SessionCreate is the builder for creating a Session entity.
+type SessionCreate struct {
+	config
+	mutation *SessionMutation
+	hooks    []Hook
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (sc *SessionCreate) SetCreatedAt(t time.Time) *SessionCreate {
+	sc.mutation.SetCreatedAt(t)
+	return sc
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (sc *SessionCreate) SetNillableCreatedAt(t *time.Time) *SessionCreate {
+	if t != nil {
+		sc.SetCreatedAt(*t)
+	}
+	return sc
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (sc *SessionCreate) SetUpdatedAt(t time.Time) *SessionCreate {
+	sc.mutation.SetUpdatedAt(t)
+	return sc
+}
+
+// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
+func (sc *SessionCreate) SetNillableUpdatedAt(t *time.Time) *SessionCreate {
+	if t != nil {
+		sc.SetUpdatedAt(*t)
+	}
+	return sc
+}
+
+// SetExpiresAt sets the "expires_at" field.
+func (sc *SessionCreate) SetExpiresAt(t time.Time) *SessionCreate {
+	sc.mutation.SetExpiresAt(t)
+	return sc
+}
+
+// SetUserID sets the "user_id" field.
+func (sc *SessionCreate) SetUserID(s string) *SessionCreate {
+	sc.mutation.SetUserID(s)
+	return sc
+}
+
+// SetPublicID sets the "public_id" field.
+func (sc *SessionCreate) SetPublicID(s string) *SessionCreate {
+	sc.mutation.SetPublicID(s)
+	return sc
+}
+
+// SetMetadata sets the "metadata" field.
+func (sc *SessionCreate) SetMetadata(m map[string]string) *SessionCreate {
+	sc.mutation.SetMetadata(m)
+	return sc
+}
+
+// SetID sets the "id" field.
+func (sc *SessionCreate) SetID(s string) *SessionCreate {
+	sc.mutation.SetID(s)
+	return sc
+}
+
+// SetNillableID sets the "id" field if the given value is not nil.
+func (sc *SessionCreate) SetNillableID(s *string) *SessionCreate {
+	if s != nil {
+		sc.SetID(*s)
+	}
+	return sc
+}
+
+// SetUser sets the "user" edge to the User entity.
+func (sc *SessionCreate) SetUser(u *User) *SessionCreate {
+	return sc.SetUserID(u.ID)
+}
+
+// Mutation returns the SessionMutation object of the builder.
+func (sc *SessionCreate) Mutation() *SessionMutation {
+	return sc.mutation
+}
+
+// Save creates the Session in the database.
+func (sc *SessionCreate) Save(ctx context.Context) (*Session, error) {
+	sc.defaults()
+	return withHooks(ctx, sc.sqlSave, sc.mutation, sc.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (sc *SessionCreate) SaveX(ctx context.Context) *Session {
+	v, err := sc.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (sc *SessionCreate) Exec(ctx context.Context) error {
+	_, err := sc.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (sc *SessionCreate) ExecX(ctx context.Context) {
+	if err := sc.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (sc *SessionCreate) defaults() {
+	if _, ok := sc.mutation.CreatedAt(); !ok {
+		v := session.DefaultCreatedAt()
+		sc.mutation.SetCreatedAt(v)
+	}
+	if _, ok := sc.mutation.UpdatedAt(); !ok {
+		v := session.DefaultUpdatedAt()
+		sc.mutation.SetUpdatedAt(v)
+	}
+	if _, ok := sc.mutation.ID(); !ok {
+		v := session.DefaultID()
+		sc.mutation.SetID(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (sc *SessionCreate) check() error {
+	if _, ok := sc.mutation.CreatedAt(); !ok {
+		return &ValidationError{Name: "created_at", err: errors.New(`db: missing required field "Session.created_at"`)}
+	}
+	if _, ok := sc.mutation.UpdatedAt(); !ok {
+		return &ValidationError{Name: "updated_at", err: errors.New(`db: missing required field "Session.updated_at"`)}
+	}
+	if _, ok := sc.mutation.ExpiresAt(); !ok {
+		return &ValidationError{Name: "expires_at", err: errors.New(`db: missing required field "Session.expires_at"`)}
+	}
+	if _, ok := sc.mutation.UserID(); !ok {
+		return &ValidationError{Name: "user_id", err: errors.New(`db: missing required field "Session.user_id"`)}
+	}
+	if _, ok := sc.mutation.PublicID(); !ok {
+		return &ValidationError{Name: "public_id", err: errors.New(`db: missing required field "Session.public_id"`)}
+	}
+	if v, ok := sc.mutation.PublicID(); ok {
+		if err := session.PublicIDValidator(v); err != nil {
+			return &ValidationError{Name: "public_id", err: fmt.Errorf(`db: validator failed for field "Session.public_id": %w`, err)}
+		}
+	}
+	if _, ok := sc.mutation.Metadata(); !ok {
+		return &ValidationError{Name: "metadata", err: errors.New(`db: missing required field "Session.metadata"`)}
+	}
+	if _, ok := sc.mutation.UserID(); !ok {
+		return &ValidationError{Name: "user", err: errors.New(`db: missing required edge "Session.user"`)}
+	}
+	return nil
+}
+
+func (sc *SessionCreate) sqlSave(ctx context.Context) (*Session, error) {
+	if err := sc.check(); err != nil {
+		return nil, err
+	}
+	_node, _spec := sc.createSpec()
+	if err := sqlgraph.CreateNode(ctx, sc.driver, _spec); err != nil {
+		if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	if _spec.ID.Value != nil {
+		if id, ok := _spec.ID.Value.(string); ok {
+			_node.ID = id
+		} else {
+			return nil, fmt.Errorf("unexpected Session.ID type: %T", _spec.ID.Value)
+		}
+	}
+	sc.mutation.id = &_node.ID
+	sc.mutation.done = true
+	return _node, nil
+}
+
+func (sc *SessionCreate) createSpec() (*Session, *sqlgraph.CreateSpec) {
+	var (
+		_node = &Session{config: sc.config}
+		_spec = sqlgraph.NewCreateSpec(session.Table, sqlgraph.NewFieldSpec(session.FieldID, field.TypeString))
+	)
+	if id, ok := sc.mutation.ID(); ok {
+		_node.ID = id
+		_spec.ID.Value = id
+	}
+	if value, ok := sc.mutation.CreatedAt(); ok {
+		_spec.SetField(session.FieldCreatedAt, field.TypeTime, value)
+		_node.CreatedAt = value
+	}
+	if value, ok := sc.mutation.UpdatedAt(); ok {
+		_spec.SetField(session.FieldUpdatedAt, field.TypeTime, value)
+		_node.UpdatedAt = value
+	}
+	if value, ok := sc.mutation.ExpiresAt(); ok {
+		_spec.SetField(session.FieldExpiresAt, field.TypeTime, value)
+		_node.ExpiresAt = value
+	}
+	if value, ok := sc.mutation.PublicID(); ok {
+		_spec.SetField(session.FieldPublicID, field.TypeString, value)
+		_node.PublicID = value
+	}
+	if value, ok := sc.mutation.Metadata(); ok {
+		_spec.SetField(session.FieldMetadata, field.TypeJSON, value)
+		_node.Metadata = value
+	}
+	if nodes := sc.mutation.UserIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   session.UserTable,
+			Columns: []string{session.UserColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_node.UserID = nodes[0]
+		_spec.Edges = append(_spec.Edges, edge)
+	}
+	return _node, _spec
+}
+
+// SessionCreateBulk is the builder for creating many Session entities in bulk.
+type SessionCreateBulk struct {
+	config
+	err      error
+	builders []*SessionCreate
+}
+
+// Save creates the Session entities in the database.
+func (scb *SessionCreateBulk) Save(ctx context.Context) ([]*Session, error) {
+	if scb.err != nil {
+		return nil, scb.err
+	}
+	specs := make([]*sqlgraph.CreateSpec, len(scb.builders))
+	nodes := make([]*Session, len(scb.builders))
+	mutators := make([]Mutator, len(scb.builders))
+	for i := range scb.builders {
+		func(i int, root context.Context) {
+			builder := scb.builders[i]
+			builder.defaults()
+			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+				mutation, ok := m.(*SessionMutation)
+				if !ok {
+					return nil, fmt.Errorf("unexpected mutation type %T", m)
+				}
+				if err := builder.check(); err != nil {
+					return nil, err
+				}
+				builder.mutation = mutation
+				var err error
+				nodes[i], specs[i] = builder.createSpec()
+				if i < len(mutators)-1 {
+					_, err = mutators[i+1].Mutate(root, scb.builders[i+1].mutation)
+				} else {
+					spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
+					// Invoke the actual operation on the latest mutation in the chain.
+					if err = sqlgraph.BatchCreate(ctx, scb.driver, spec); err != nil {
+						if sqlgraph.IsConstraintError(err) {
+							err = &ConstraintError{msg: err.Error(), wrap: err}
+						}
+					}
+				}
+				if err != nil {
+					return nil, err
+				}
+				mutation.id = &nodes[i].ID
+				mutation.done = true
+				return nodes[i], nil
+			})
+			for i := len(builder.hooks) - 1; i >= 0; i-- {
+				mut = builder.hooks[i](mut)
+			}
+			mutators[i] = mut
+		}(i, ctx)
+	}
+	if len(mutators) > 0 {
+		if _, err := mutators[0].Mutate(ctx, scb.builders[0].mutation); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (scb *SessionCreateBulk) SaveX(ctx context.Context) []*Session {
+	v, err := scb.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (scb *SessionCreateBulk) Exec(ctx context.Context) error {
+	_, err := scb.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (scb *SessionCreateBulk) ExecX(ctx context.Context) {
+	if err := scb.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/database/ent/db/session_delete.go b/internal/database/ent/db/session_delete.go
new file mode 100644
index 00000000..19677342
--- /dev/null
+++ b/internal/database/ent/db/session_delete.go
@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/ent/db/session"
+)
+
+// SessionDelete is the builder for deleting a Session entity.
+type SessionDelete struct {
+	config
+	hooks    []Hook
+	mutation *SessionMutation
+}
+
+// Where appends a list predicates to the SessionDelete builder.
+func (sd *SessionDelete) Where(ps ...predicate.Session) *SessionDelete {
+	sd.mutation.Where(ps...)
+	return sd
+}
+
+// Exec executes the deletion query and returns how many vertices were deleted.
+func (sd *SessionDelete) Exec(ctx context.Context) (int, error) {
+	return withHooks(ctx, sd.sqlExec, sd.mutation, sd.hooks)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (sd *SessionDelete) ExecX(ctx context.Context) int {
+	n, err := sd.Exec(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return n
+}
+
+func (sd *SessionDelete) sqlExec(ctx context.Context) (int, error) {
+	_spec := sqlgraph.NewDeleteSpec(session.Table, sqlgraph.NewFieldSpec(session.FieldID, field.TypeString))
+	if ps := sd.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	affected, err := sqlgraph.DeleteNodes(ctx, sd.driver, _spec)
+	if err != nil && sqlgraph.IsConstraintError(err) {
+		err = &ConstraintError{msg: err.Error(), wrap: err}
+	}
+	sd.mutation.done = true
+	return affected, err
+}
+
+// SessionDeleteOne is the builder for deleting a single Session entity.
+type SessionDeleteOne struct {
+	sd *SessionDelete
+}
+
+// Where appends a list predicates to the SessionDelete builder.
+func (sdo *SessionDeleteOne) Where(ps ...predicate.Session) *SessionDeleteOne {
+	sdo.sd.mutation.Where(ps...)
+	return sdo
+}
+
+// Exec executes the deletion query.
+func (sdo *SessionDeleteOne) Exec(ctx context.Context) error {
+	n, err := sdo.sd.Exec(ctx)
+	switch {
+	case err != nil:
+		return err
+	case n == 0:
+		return &NotFoundError{session.Label}
+	default:
+		return nil
+	}
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (sdo *SessionDeleteOne) ExecX(ctx context.Context) {
+	if err := sdo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/database/ent/db/session_query.go b/internal/database/ent/db/session_query.go
new file mode 100644
index 00000000..06db7534
--- /dev/null
+++ b/internal/database/ent/db/session_query.go
@@ -0,0 +1,627 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"fmt"
+	"math"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/ent/db/session"
+	"github.com/cufee/aftermath/internal/database/ent/db/user"
+)
+
+// SessionQuery is the builder for querying Session entities.
+type SessionQuery struct {
+	config
+	ctx        *QueryContext
+	order      []session.OrderOption
+	inters     []Interceptor
+	predicates []predicate.Session
+	withUser   *UserQuery
+	modifiers  []func(*sql.Selector)
+	// intermediate query (i.e. traversal path).
+	sql  *sql.Selector
+	path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the SessionQuery builder.
+func (sq *SessionQuery) Where(ps ...predicate.Session) *SessionQuery {
+	sq.predicates = append(sq.predicates, ps...)
+	return sq
+}
+
+// Limit the number of records to be returned by this query.
+func (sq *SessionQuery) Limit(limit int) *SessionQuery {
+	sq.ctx.Limit = &limit
+	return sq
+}
+
+// Offset to start from.
+func (sq *SessionQuery) Offset(offset int) *SessionQuery {
+	sq.ctx.Offset = &offset
+	return sq
+}
+
+// Unique configures the query builder to filter duplicate records on query.
+// By default, unique is set to true, and can be disabled using this method.
+func (sq *SessionQuery) Unique(unique bool) *SessionQuery {
+	sq.ctx.Unique = &unique
+	return sq
+}
+
+// Order specifies how the records should be ordered.
+func (sq *SessionQuery) Order(o ...session.OrderOption) *SessionQuery {
+	sq.order = append(sq.order, o...)
+	return sq
+}
+
+// QueryUser chains the current query on the "user" edge.
+func (sq *SessionQuery) QueryUser() *UserQuery {
+	query := (&UserClient{config: sq.config}).Query()
+	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+		if err := sq.prepareQuery(ctx); err != nil {
+			return nil, err
+		}
+		selector := sq.sqlQuery(ctx)
+		if err := selector.Err(); err != nil {
+			return nil, err
+		}
+		step := sqlgraph.NewStep(
+			sqlgraph.From(session.Table, session.FieldID, selector),
+			sqlgraph.To(user.Table, user.FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, session.UserTable, session.UserColumn),
+		)
+		fromU = sqlgraph.SetNeighbors(sq.driver.Dialect(), step)
+		return fromU, nil
+	}
+	return query
+}
+
+// First returns the first Session entity from the query.
+// Returns a *NotFoundError when no Session was found.
+func (sq *SessionQuery) First(ctx context.Context) (*Session, error) {
+	nodes, err := sq.Limit(1).All(setContextOp(ctx, sq.ctx, "First"))
+	if err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nil, &NotFoundError{session.Label}
+	}
+	return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (sq *SessionQuery) FirstX(ctx context.Context) *Session {
+	node, err := sq.First(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return node
+}
+
+// FirstID returns the first Session ID from the query.
+// Returns a *NotFoundError when no Session ID was found.
+func (sq *SessionQuery) FirstID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = sq.Limit(1).IDs(setContextOp(ctx, sq.ctx, "FirstID")); err != nil {
+		return
+	}
+	if len(ids) == 0 {
+		err = &NotFoundError{session.Label}
+		return
+	}
+	return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (sq *SessionQuery) FirstIDX(ctx context.Context) string {
+	id, err := sq.FirstID(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return id
+}
+
+// Only returns a single Session entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one Session entity is found.
+// Returns a *NotFoundError when no Session entities are found.
+func (sq *SessionQuery) Only(ctx context.Context) (*Session, error) {
+	nodes, err := sq.Limit(2).All(setContextOp(ctx, sq.ctx, "Only"))
+	if err != nil {
+		return nil, err
+	}
+	switch len(nodes) {
+	case 1:
+		return nodes[0], nil
+	case 0:
+		return nil, &NotFoundError{session.Label}
+	default:
+		return nil, &NotSingularError{session.Label}
+	}
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (sq *SessionQuery) OnlyX(ctx context.Context) *Session {
+	node, err := sq.Only(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// OnlyID is like Only, but returns the only Session ID in the query.
+// Returns a *NotSingularError when more than one Session ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (sq *SessionQuery) OnlyID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = sq.Limit(2).IDs(setContextOp(ctx, sq.ctx, "OnlyID")); err != nil {
+		return
+	}
+	switch len(ids) {
+	case 1:
+		id = ids[0]
+	case 0:
+		err = &NotFoundError{session.Label}
+	default:
+		err = &NotSingularError{session.Label}
+	}
+	return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (sq *SessionQuery) OnlyIDX(ctx context.Context) string {
+	id, err := sq.OnlyID(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return id
+}
+
+// All executes the query and returns a list of Sessions.
+func (sq *SessionQuery) All(ctx context.Context) ([]*Session, error) {
+	ctx = setContextOp(ctx, sq.ctx, "All")
+	if err := sq.prepareQuery(ctx); err != nil {
+		return nil, err
+	}
+	qr := querierAll[[]*Session, *SessionQuery]()
+	return withInterceptors[[]*Session](ctx, sq, qr, sq.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (sq *SessionQuery) AllX(ctx context.Context) []*Session {
+	nodes, err := sq.All(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return nodes
+}
+
+// IDs executes the query and returns a list of Session IDs.
+func (sq *SessionQuery) IDs(ctx context.Context) (ids []string, err error) {
+	if sq.ctx.Unique == nil && sq.path != nil {
+		sq.Unique(true)
+	}
+	ctx = setContextOp(ctx, sq.ctx, "IDs")
+	if err = sq.Select(session.FieldID).Scan(ctx, &ids); err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (sq *SessionQuery) IDsX(ctx context.Context) []string {
+	ids, err := sq.IDs(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return ids
+}
+
+// Count returns the count of the given query.
+func (sq *SessionQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, sq.ctx, "Count")
+	if err := sq.prepareQuery(ctx); err != nil {
+		return 0, err
+	}
+	return withInterceptors[int](ctx, sq, querierCount[*SessionQuery](), sq.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (sq *SessionQuery) CountX(ctx context.Context) int {
+	count, err := sq.Count(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (sq *SessionQuery) Exist(ctx context.Context) (bool, error) {
+	ctx = setContextOp(ctx, sq.ctx, "Exist")
+	switch _, err := sq.FirstID(ctx); {
+	case IsNotFound(err):
+		return false, nil
+	case err != nil:
+		return false, fmt.Errorf("db: check existence: %w", err)
+	default:
+		return true, nil
+	}
+}
+
+// ExistX is like Exist, but panics if an error occurs.
+func (sq *SessionQuery) ExistX(ctx context.Context) bool {
+	exist, err := sq.Exist(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return exist
+}
+
+// Clone returns a duplicate of the SessionQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (sq *SessionQuery) Clone() *SessionQuery {
+	if sq == nil {
+		return nil
+	}
+	return &SessionQuery{
+		config:     sq.config,
+		ctx:        sq.ctx.Clone(),
+		order:      append([]session.OrderOption{}, sq.order...),
+		inters:     append([]Interceptor{}, sq.inters...),
+		predicates: append([]predicate.Session{}, sq.predicates...),
+		withUser:   sq.withUser.Clone(),
+		// clone intermediate query.
+		sql:  sq.sql.Clone(),
+		path: sq.path,
+	}
+}
+
+// WithUser tells the query-builder to eager-load the nodes that are connected to
+// the "user" edge. The optional arguments are used to configure the query builder of the edge.
+func (sq *SessionQuery) WithUser(opts ...func(*UserQuery)) *SessionQuery {
+	query := (&UserClient{config: sq.config}).Query()
+	for _, opt := range opts {
+		opt(query)
+	}
+	sq.withUser = query
+	return sq
+}
+
+// GroupBy is used to group vertices by one or more fields/columns.
+// It is often used with aggregate functions, like: count, max, mean, min, sum.
+//
+// Example:
+//
+//	var v []struct {
+//		CreatedAt time.Time `json:"created_at,omitempty"`
+//		Count int `json:"count,omitempty"`
+//	}
+//
+//	client.Session.Query().
+//		GroupBy(session.FieldCreatedAt).
+//		Aggregate(db.Count()).
+//		Scan(ctx, &v)
+func (sq *SessionQuery) GroupBy(field string, fields ...string) *SessionGroupBy {
+	sq.ctx.Fields = append([]string{field}, fields...)
+	grbuild := &SessionGroupBy{build: sq}
+	grbuild.flds = &sq.ctx.Fields
+	grbuild.label = session.Label
+	grbuild.scan = grbuild.Scan
+	return grbuild
+}
+
+// Select allows the selection one or more fields/columns for the given query,
+// instead of selecting all fields in the entity.
+//
+// Example:
+//
+//	var v []struct {
+//		CreatedAt time.Time `json:"created_at,omitempty"`
+//	}
+//
+//	client.Session.Query().
+//		Select(session.FieldCreatedAt).
+//		Scan(ctx, &v)
+func (sq *SessionQuery) Select(fields ...string) *SessionSelect {
+	sq.ctx.Fields = append(sq.ctx.Fields, fields...)
+	sbuild := &SessionSelect{SessionQuery: sq}
+	sbuild.label = session.Label
+	sbuild.flds, sbuild.scan = &sq.ctx.Fields, sbuild.Scan
+	return sbuild
+}
+
+// Aggregate returns a SessionSelect configured with the given aggregations.
+func (sq *SessionQuery) Aggregate(fns ...AggregateFunc) *SessionSelect {
+	return sq.Select().Aggregate(fns...)
+}
+
+func (sq *SessionQuery) prepareQuery(ctx context.Context) error {
+	for _, inter := range sq.inters {
+		if inter == nil {
+			return fmt.Errorf("db: uninitialized interceptor (forgotten import db/runtime?)")
+		}
+		if trv, ok := inter.(Traverser); ok {
+			if err := trv.Traverse(ctx, sq); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range sq.ctx.Fields {
+		if !session.ValidColumn(f) {
+			return &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+		}
+	}
+	if sq.path != nil {
+		prev, err := sq.path(ctx)
+		if err != nil {
+			return err
+		}
+		sq.sql = prev
+	}
+	return nil
+}
+
+func (sq *SessionQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Session, error) {
+	var (
+		nodes       = []*Session{}
+		_spec       = sq.querySpec()
+		loadedTypes = [1]bool{
+			sq.withUser != nil,
+		}
+	)
+	_spec.ScanValues = func(columns []string) ([]any, error) {
+		return (*Session).scanValues(nil, columns)
+	}
+	_spec.Assign = func(columns []string, values []any) error {
+		node := &Session{config: sq.config}
+		nodes = append(nodes, node)
+		node.Edges.loadedTypes = loadedTypes
+		return node.assignValues(columns, values)
+	}
+	if len(sq.modifiers) > 0 {
+		_spec.Modifiers = sq.modifiers
+	}
+	for i := range hooks {
+		hooks[i](ctx, _spec)
+	}
+	if err := sqlgraph.QueryNodes(ctx, sq.driver, _spec); err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nodes, nil
+	}
+	if query := sq.withUser; query != nil {
+		if err := sq.loadUser(ctx, query, nodes, nil,
+			func(n *Session, e *User) { n.Edges.User = e }); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+func (sq *SessionQuery) loadUser(ctx context.Context, query *UserQuery, nodes []*Session, init func(*Session), assign func(*Session, *User)) error {
+	ids := make([]string, 0, len(nodes))
+	nodeids := make(map[string][]*Session)
+	for i := range nodes {
+		fk := nodes[i].UserID
+		if _, ok := nodeids[fk]; !ok {
+			ids = append(ids, fk)
+		}
+		nodeids[fk] = append(nodeids[fk], nodes[i])
+	}
+	if len(ids) == 0 {
+		return nil
+	}
+	query.Where(user.IDIn(ids...))
+	neighbors, err := query.All(ctx)
+	if err != nil {
+		return err
+	}
+	for _, n := range neighbors {
+		nodes, ok := nodeids[n.ID]
+		if !ok {
+			return fmt.Errorf(`unexpected foreign-key "user_id" returned %v`, n.ID)
+		}
+		for i := range nodes {
+			assign(nodes[i], n)
+		}
+	}
+	return nil
+}
+
+func (sq *SessionQuery) sqlCount(ctx context.Context) (int, error) {
+	_spec := sq.querySpec()
+	if len(sq.modifiers) > 0 {
+		_spec.Modifiers = sq.modifiers
+	}
+	_spec.Node.Columns = sq.ctx.Fields
+	if len(sq.ctx.Fields) > 0 {
+		_spec.Unique = sq.ctx.Unique != nil && *sq.ctx.Unique
+	}
+	return sqlgraph.CountNodes(ctx, sq.driver, _spec)
+}
+
+func (sq *SessionQuery) querySpec() *sqlgraph.QuerySpec {
+	_spec := sqlgraph.NewQuerySpec(session.Table, session.Columns, sqlgraph.NewFieldSpec(session.FieldID, field.TypeString))
+	_spec.From = sq.sql
+	if unique := sq.ctx.Unique; unique != nil {
+		_spec.Unique = *unique
+	} else if sq.path != nil {
+		_spec.Unique = true
+	}
+	if fields := sq.ctx.Fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, session.FieldID)
+		for i := range fields {
+			if fields[i] != session.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+			}
+		}
+		if sq.withUser != nil {
+			_spec.Node.AddColumnOnce(session.FieldUserID)
+		}
+	}
+	if ps := sq.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if limit := sq.ctx.Limit; limit != nil {
+		_spec.Limit = *limit
+	}
+	if offset := sq.ctx.Offset; offset != nil {
+		_spec.Offset = *offset
+	}
+	if ps := sq.order; len(ps) > 0 {
+		_spec.Order = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	return _spec
+}
+
+func (sq *SessionQuery) sqlQuery(ctx context.Context) *sql.Selector {
+	builder := sql.Dialect(sq.driver.Dialect())
+	t1 := builder.Table(session.Table)
+	columns := sq.ctx.Fields
+	if len(columns) == 0 {
+		columns = session.Columns
+	}
+	selector := builder.Select(t1.Columns(columns...)...).From(t1)
+	if sq.sql != nil {
+		selector = sq.sql
+		selector.Select(selector.Columns(columns...)...)
+	}
+	if sq.ctx.Unique != nil && *sq.ctx.Unique {
+		selector.Distinct()
+	}
+	for _, m := range sq.modifiers {
+		m(selector)
+	}
+	for _, p := range sq.predicates {
+		p(selector)
+	}
+	for _, p := range sq.order {
+		p(selector)
+	}
+	if offset := sq.ctx.Offset; offset != nil {
+		// limit is mandatory for offset clause. We start
+		// with default value, and override it below if needed.
+		selector.Offset(*offset).Limit(math.MaxInt32)
+	}
+	if limit := sq.ctx.Limit; limit != nil {
+		selector.Limit(*limit)
+	}
+	return selector
+}
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (sq *SessionQuery) Modify(modifiers ...func(s *sql.Selector)) *SessionSelect {
+	sq.modifiers = append(sq.modifiers, modifiers...)
+	return sq.Select()
+}
+
+// SessionGroupBy is the group-by builder for Session entities.
+type SessionGroupBy struct {
+	selector
+	build *SessionQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (sgb *SessionGroupBy) Aggregate(fns ...AggregateFunc) *SessionGroupBy {
+	sgb.fns = append(sgb.fns, fns...)
+	return sgb
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (sgb *SessionGroupBy) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, sgb.build.ctx, "GroupBy")
+	if err := sgb.build.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*SessionQuery, *SessionGroupBy](ctx, sgb.build, sgb, sgb.build.inters, v)
+}
+
+func (sgb *SessionGroupBy) sqlScan(ctx context.Context, root *SessionQuery, v any) error {
+	selector := root.sqlQuery(ctx).Select()
+	aggregation := make([]string, 0, len(sgb.fns))
+	for _, fn := range sgb.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*sgb.flds)+len(sgb.fns))
+		for _, f := range *sgb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*sgb.flds...)...)
+	if err := selector.Err(); err != nil {
+		return err
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := sgb.build.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
+
+// SessionSelect is the builder for selecting fields of Session entities.
+type SessionSelect struct {
+	*SessionQuery
+	selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (ss *SessionSelect) Aggregate(fns ...AggregateFunc) *SessionSelect {
+	ss.fns = append(ss.fns, fns...)
+	return ss
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (ss *SessionSelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, ss.ctx, "Select")
+	if err := ss.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*SessionQuery, *SessionSelect](ctx, ss.SessionQuery, ss, ss.inters, v)
+}
+
+func (ss *SessionSelect) sqlScan(ctx context.Context, root *SessionQuery, v any) error {
+	selector := root.sqlQuery(ctx)
+	aggregation := make([]string, 0, len(ss.fns))
+	for _, fn := range ss.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	switch n := len(*ss.selector.flds); {
+	case n == 0 && len(aggregation) > 0:
+		selector.Select(aggregation...)
+	case n != 0 && len(aggregation) > 0:
+		selector.AppendSelect(aggregation...)
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := ss.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (ss *SessionSelect) Modify(modifiers ...func(s *sql.Selector)) *SessionSelect {
+	ss.modifiers = append(ss.modifiers, modifiers...)
+	return ss
+}
diff --git a/internal/database/ent/db/session_update.go b/internal/database/ent/db/session_update.go
new file mode 100644
index 00000000..b3c596d8
--- /dev/null
+++ b/internal/database/ent/db/session_update.go
@@ -0,0 +1,302 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/ent/db/session"
+)
+
+// SessionUpdate is the builder for updating Session entities.
+type SessionUpdate struct {
+	config
+	hooks     []Hook
+	mutation  *SessionMutation
+	modifiers []func(*sql.UpdateBuilder)
+}
+
+// Where appends a list predicates to the SessionUpdate builder.
+func (su *SessionUpdate) Where(ps ...predicate.Session) *SessionUpdate {
+	su.mutation.Where(ps...)
+	return su
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (su *SessionUpdate) SetUpdatedAt(t time.Time) *SessionUpdate {
+	su.mutation.SetUpdatedAt(t)
+	return su
+}
+
+// SetExpiresAt sets the "expires_at" field.
+func (su *SessionUpdate) SetExpiresAt(t time.Time) *SessionUpdate {
+	su.mutation.SetExpiresAt(t)
+	return su
+}
+
+// SetNillableExpiresAt sets the "expires_at" field if the given value is not nil.
+func (su *SessionUpdate) SetNillableExpiresAt(t *time.Time) *SessionUpdate {
+	if t != nil {
+		su.SetExpiresAt(*t)
+	}
+	return su
+}
+
+// SetMetadata sets the "metadata" field.
+func (su *SessionUpdate) SetMetadata(m map[string]string) *SessionUpdate {
+	su.mutation.SetMetadata(m)
+	return su
+}
+
+// Mutation returns the SessionMutation object of the builder.
+func (su *SessionUpdate) Mutation() *SessionMutation {
+	return su.mutation
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (su *SessionUpdate) Save(ctx context.Context) (int, error) {
+	su.defaults()
+	return withHooks(ctx, su.sqlSave, su.mutation, su.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (su *SessionUpdate) SaveX(ctx context.Context) int {
+	affected, err := su.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return affected
+}
+
+// Exec executes the query.
+func (su *SessionUpdate) Exec(ctx context.Context) error {
+	_, err := su.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (su *SessionUpdate) ExecX(ctx context.Context) {
+	if err := su.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (su *SessionUpdate) defaults() {
+	if _, ok := su.mutation.UpdatedAt(); !ok {
+		v := session.UpdateDefaultUpdatedAt()
+		su.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (su *SessionUpdate) check() error {
+	if _, ok := su.mutation.UserID(); su.mutation.UserCleared() && !ok {
+		return errors.New(`db: clearing a required unique edge "Session.user"`)
+	}
+	return nil
+}
+
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (su *SessionUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *SessionUpdate {
+	su.modifiers = append(su.modifiers, modifiers...)
+	return su
+}
+
+func (su *SessionUpdate) sqlSave(ctx context.Context) (n int, err error) {
+	if err := su.check(); err != nil {
+		return n, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(session.Table, session.Columns, sqlgraph.NewFieldSpec(session.FieldID, field.TypeString))
+	if ps := su.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := su.mutation.UpdatedAt(); ok {
+		_spec.SetField(session.FieldUpdatedAt, field.TypeTime, value)
+	}
+	if value, ok := su.mutation.ExpiresAt(); ok {
+		_spec.SetField(session.FieldExpiresAt, field.TypeTime, value)
+	}
+	if value, ok := su.mutation.Metadata(); ok {
+		_spec.SetField(session.FieldMetadata, field.TypeJSON, value)
+	}
+	_spec.AddModifiers(su.modifiers...)
+	if n, err = sqlgraph.UpdateNodes(ctx, su.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{session.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return 0, err
+	}
+	su.mutation.done = true
+	return n, nil
+}
+
+// SessionUpdateOne is the builder for updating a single Session entity.
+type SessionUpdateOne struct {
+	config
+	fields    []string
+	hooks     []Hook
+	mutation  *SessionMutation
+	modifiers []func(*sql.UpdateBuilder)
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (suo *SessionUpdateOne) SetUpdatedAt(t time.Time) *SessionUpdateOne {
+	suo.mutation.SetUpdatedAt(t)
+	return suo
+}
+
+// SetExpiresAt sets the "expires_at" field.
+func (suo *SessionUpdateOne) SetExpiresAt(t time.Time) *SessionUpdateOne {
+	suo.mutation.SetExpiresAt(t)
+	return suo
+}
+
+// SetNillableExpiresAt sets the "expires_at" field if the given value is not nil.
+func (suo *SessionUpdateOne) SetNillableExpiresAt(t *time.Time) *SessionUpdateOne {
+	if t != nil {
+		suo.SetExpiresAt(*t)
+	}
+	return suo
+}
+
+// SetMetadata sets the "metadata" field.
+func (suo *SessionUpdateOne) SetMetadata(m map[string]string) *SessionUpdateOne {
+	suo.mutation.SetMetadata(m)
+	return suo
+}
+
+// Mutation returns the SessionMutation object of the builder.
+func (suo *SessionUpdateOne) Mutation() *SessionMutation {
+	return suo.mutation
+}
+
+// Where appends a list predicates to the SessionUpdate builder.
+func (suo *SessionUpdateOne) Where(ps ...predicate.Session) *SessionUpdateOne {
+	suo.mutation.Where(ps...)
+	return suo
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (suo *SessionUpdateOne) Select(field string, fields ...string) *SessionUpdateOne {
+	suo.fields = append([]string{field}, fields...)
+	return suo
+}
+
+// Save executes the query and returns the updated Session entity.
+func (suo *SessionUpdateOne) Save(ctx context.Context) (*Session, error) {
+	suo.defaults()
+	return withHooks(ctx, suo.sqlSave, suo.mutation, suo.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (suo *SessionUpdateOne) SaveX(ctx context.Context) *Session {
+	node, err := suo.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// Exec executes the query on the entity.
+func (suo *SessionUpdateOne) Exec(ctx context.Context) error {
+	_, err := suo.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (suo *SessionUpdateOne) ExecX(ctx context.Context) {
+	if err := suo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (suo *SessionUpdateOne) defaults() {
+	if _, ok := suo.mutation.UpdatedAt(); !ok {
+		v := session.UpdateDefaultUpdatedAt()
+		suo.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (suo *SessionUpdateOne) check() error {
+	if _, ok := suo.mutation.UserID(); suo.mutation.UserCleared() && !ok {
+		return errors.New(`db: clearing a required unique edge "Session.user"`)
+	}
+	return nil
+}
+
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (suo *SessionUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *SessionUpdateOne {
+	suo.modifiers = append(suo.modifiers, modifiers...)
+	return suo
+}
+
+func (suo *SessionUpdateOne) sqlSave(ctx context.Context) (_node *Session, err error) {
+	if err := suo.check(); err != nil {
+		return _node, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(session.Table, session.Columns, sqlgraph.NewFieldSpec(session.FieldID, field.TypeString))
+	id, ok := suo.mutation.ID()
+	if !ok {
+		return nil, &ValidationError{Name: "id", err: errors.New(`db: missing "Session.id" for update`)}
+	}
+	_spec.Node.ID.Value = id
+	if fields := suo.fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, session.FieldID)
+		for _, f := range fields {
+			if !session.ValidColumn(f) {
+				return nil, &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+			}
+			if f != session.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, f)
+			}
+		}
+	}
+	if ps := suo.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := suo.mutation.UpdatedAt(); ok {
+		_spec.SetField(session.FieldUpdatedAt, field.TypeTime, value)
+	}
+	if value, ok := suo.mutation.ExpiresAt(); ok {
+		_spec.SetField(session.FieldExpiresAt, field.TypeTime, value)
+	}
+	if value, ok := suo.mutation.Metadata(); ok {
+		_spec.SetField(session.FieldMetadata, field.TypeJSON, value)
+	}
+	_spec.AddModifiers(suo.modifiers...)
+	_node = &Session{config: suo.config}
+	_spec.Assign = _node.assignValues
+	_spec.ScanValues = _node.scanValues
+	if err = sqlgraph.UpdateNode(ctx, suo.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{session.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	suo.mutation.done = true
+	return _node, nil
+}
diff --git a/internal/database/ent/db/tx.go b/internal/database/ent/db/tx.go
index 9852c615..72a6edce 100644
--- a/internal/database/ent/db/tx.go
+++ b/internal/database/ent/db/tx.go
@@ -24,12 +24,16 @@ type Tx struct {
 	AppConfiguration *AppConfigurationClient
 	// ApplicationCommand is the client for interacting with the ApplicationCommand builders.
 	ApplicationCommand *ApplicationCommandClient
+	// AuthNonce is the client for interacting with the AuthNonce builders.
+	AuthNonce *AuthNonceClient
 	// Clan is the client for interacting with the Clan builders.
 	Clan *ClanClient
 	// CronTask is the client for interacting with the CronTask builders.
 	CronTask *CronTaskClient
 	// DiscordInteraction is the client for interacting with the DiscordInteraction builders.
 	DiscordInteraction *DiscordInteractionClient
+	// Session is the client for interacting with the Session builders.
+	Session *SessionClient
 	// User is the client for interacting with the User builders.
 	User *UserClient
 	// UserConnection is the client for interacting with the UserConnection builders.
@@ -180,9 +184,11 @@ func (tx *Tx) init() {
 	tx.AchievementsSnapshot = NewAchievementsSnapshotClient(tx.config)
 	tx.AppConfiguration = NewAppConfigurationClient(tx.config)
 	tx.ApplicationCommand = NewApplicationCommandClient(tx.config)
+	tx.AuthNonce = NewAuthNonceClient(tx.config)
 	tx.Clan = NewClanClient(tx.config)
 	tx.CronTask = NewCronTaskClient(tx.config)
 	tx.DiscordInteraction = NewDiscordInteractionClient(tx.config)
+	tx.Session = NewSessionClient(tx.config)
 	tx.User = NewUserClient(tx.config)
 	tx.UserConnection = NewUserConnectionClient(tx.config)
 	tx.UserContent = NewUserContentClient(tx.config)
diff --git a/internal/database/ent/db/user.go b/internal/database/ent/db/user.go
index f94bd4f6..a4d68628 100644
--- a/internal/database/ent/db/user.go
+++ b/internal/database/ent/db/user.go
@@ -22,6 +22,8 @@ type User struct {
 	CreatedAt time.Time `json:"created_at,omitempty"`
 	// UpdatedAt holds the value of the "updated_at" field.
 	UpdatedAt time.Time `json:"updated_at,omitempty"`
+	// Username holds the value of the "username" field.
+	Username string `json:"username,omitempty"`
 	// Permissions holds the value of the "permissions" field.
 	Permissions string `json:"permissions,omitempty"`
 	// FeatureFlags holds the value of the "feature_flags" field.
@@ -42,9 +44,11 @@ type UserEdges struct {
 	Connections []*UserConnection `json:"connections,omitempty"`
 	// Content holds the value of the content edge.
 	Content []*UserContent `json:"content,omitempty"`
+	// Sessions holds the value of the sessions edge.
+	Sessions []*Session `json:"sessions,omitempty"`
 	// loadedTypes holds the information for reporting if a
 	// type was loaded (or requested) in eager-loading or not.
-	loadedTypes [4]bool
+	loadedTypes [5]bool
 }
 
 // DiscordInteractionsOrErr returns the DiscordInteractions value or an error if the edge
@@ -83,6 +87,15 @@ func (e UserEdges) ContentOrErr() ([]*UserContent, error) {
 	return nil, &NotLoadedError{edge: "content"}
 }
 
+// SessionsOrErr returns the Sessions value or an error if the edge
+// was not loaded in eager-loading.
+func (e UserEdges) SessionsOrErr() ([]*Session, error) {
+	if e.loadedTypes[4] {
+		return e.Sessions, nil
+	}
+	return nil, &NotLoadedError{edge: "sessions"}
+}
+
 // scanValues returns the types for scanning values from sql.Rows.
 func (*User) scanValues(columns []string) ([]any, error) {
 	values := make([]any, len(columns))
@@ -90,7 +103,7 @@ func (*User) scanValues(columns []string) ([]any, error) {
 		switch columns[i] {
 		case user.FieldFeatureFlags:
 			values[i] = new([]byte)
-		case user.FieldID, user.FieldPermissions:
+		case user.FieldID, user.FieldUsername, user.FieldPermissions:
 			values[i] = new(sql.NullString)
 		case user.FieldCreatedAt, user.FieldUpdatedAt:
 			values[i] = new(sql.NullTime)
@@ -127,6 +140,12 @@ func (u *User) assignValues(columns []string, values []any) error {
 			} else if value.Valid {
 				u.UpdatedAt = value.Time
 			}
+		case user.FieldUsername:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field username", values[i])
+			} else if value.Valid {
+				u.Username = value.String
+			}
 		case user.FieldPermissions:
 			if value, ok := values[i].(*sql.NullString); !ok {
 				return fmt.Errorf("unexpected type %T for field permissions", values[i])
@@ -174,6 +193,11 @@ func (u *User) QueryContent() *UserContentQuery {
 	return NewUserClient(u.config).QueryContent(u)
 }
 
+// QuerySessions queries the "sessions" edge of the User entity.
+func (u *User) QuerySessions() *SessionQuery {
+	return NewUserClient(u.config).QuerySessions(u)
+}
+
 // Update returns a builder for updating this User.
 // Note that you need to call User.Unwrap() before calling this method if this User
 // was returned from a transaction, and the transaction was committed or rolled back.
@@ -203,6 +227,9 @@ func (u *User) String() string {
 	builder.WriteString("updated_at=")
 	builder.WriteString(u.UpdatedAt.Format(time.ANSIC))
 	builder.WriteString(", ")
+	builder.WriteString("username=")
+	builder.WriteString(u.Username)
+	builder.WriteString(", ")
 	builder.WriteString("permissions=")
 	builder.WriteString(u.Permissions)
 	builder.WriteString(", ")
diff --git a/internal/database/ent/db/user/user.go b/internal/database/ent/db/user/user.go
index e4787254..4e21b04c 100644
--- a/internal/database/ent/db/user/user.go
+++ b/internal/database/ent/db/user/user.go
@@ -18,6 +18,8 @@ const (
 	FieldCreatedAt = "created_at"
 	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
 	FieldUpdatedAt = "updated_at"
+	// FieldUsername holds the string denoting the username field in the database.
+	FieldUsername = "username"
 	// FieldPermissions holds the string denoting the permissions field in the database.
 	FieldPermissions = "permissions"
 	// FieldFeatureFlags holds the string denoting the feature_flags field in the database.
@@ -30,6 +32,8 @@ const (
 	EdgeConnections = "connections"
 	// EdgeContent holds the string denoting the content edge name in mutations.
 	EdgeContent = "content"
+	// EdgeSessions holds the string denoting the sessions edge name in mutations.
+	EdgeSessions = "sessions"
 	// Table holds the table name of the user in the database.
 	Table = "users"
 	// DiscordInteractionsTable is the table that holds the discord_interactions relation/edge.
@@ -60,6 +64,13 @@ const (
 	ContentInverseTable = "user_contents"
 	// ContentColumn is the table column denoting the content relation/edge.
 	ContentColumn = "user_id"
+	// SessionsTable is the table that holds the sessions relation/edge.
+	SessionsTable = "sessions"
+	// SessionsInverseTable is the table name for the Session entity.
+	// It exists in this package in order to avoid circular dependency with the "session" package.
+	SessionsInverseTable = "sessions"
+	// SessionsColumn is the table column denoting the sessions relation/edge.
+	SessionsColumn = "user_id"
 )
 
 // Columns holds all SQL columns for user fields.
@@ -67,6 +78,7 @@ var Columns = []string{
 	FieldID,
 	FieldCreatedAt,
 	FieldUpdatedAt,
+	FieldUsername,
 	FieldPermissions,
 	FieldFeatureFlags,
 }
@@ -88,6 +100,8 @@ var (
 	DefaultUpdatedAt func() time.Time
 	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
 	UpdateDefaultUpdatedAt func() time.Time
+	// DefaultUsername holds the default value on creation for the "username" field.
+	DefaultUsername string
 	// DefaultPermissions holds the default value on creation for the "permissions" field.
 	DefaultPermissions string
 )
@@ -110,6 +124,11 @@ func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
 }
 
+// ByUsername orders the results by the username field.
+func ByUsername(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUsername, opts...).ToFunc()
+}
+
 // ByPermissions orders the results by the permissions field.
 func ByPermissions(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldPermissions, opts...).ToFunc()
@@ -170,6 +189,20 @@ func ByContent(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
 		sqlgraph.OrderByNeighborTerms(s, newContentStep(), append([]sql.OrderTerm{term}, terms...)...)
 	}
 }
+
+// BySessionsCount orders the results by sessions count.
+func BySessionsCount(opts ...sql.OrderTermOption) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborsCount(s, newSessionsStep(), opts...)
+	}
+}
+
+// BySessions orders the results by sessions terms.
+func BySessions(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborTerms(s, newSessionsStep(), append([]sql.OrderTerm{term}, terms...)...)
+	}
+}
 func newDiscordInteractionsStep() *sqlgraph.Step {
 	return sqlgraph.NewStep(
 		sqlgraph.From(Table, FieldID),
@@ -198,3 +231,10 @@ func newContentStep() *sqlgraph.Step {
 		sqlgraph.Edge(sqlgraph.O2M, false, ContentTable, ContentColumn),
 	)
 }
+func newSessionsStep() *sqlgraph.Step {
+	return sqlgraph.NewStep(
+		sqlgraph.From(Table, FieldID),
+		sqlgraph.To(SessionsInverseTable, FieldID),
+		sqlgraph.Edge(sqlgraph.O2M, false, SessionsTable, SessionsColumn),
+	)
+}
diff --git a/internal/database/ent/db/user/where.go b/internal/database/ent/db/user/where.go
index 989d46ba..4a8bebd1 100644
--- a/internal/database/ent/db/user/where.go
+++ b/internal/database/ent/db/user/where.go
@@ -75,6 +75,11 @@ func UpdatedAt(v time.Time) predicate.User {
 	return predicate.User(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
+// Username applies equality check predicate on the "username" field. It's identical to UsernameEQ.
+func Username(v string) predicate.User {
+	return predicate.User(sql.FieldEQ(FieldUsername, v))
+}
+
 // Permissions applies equality check predicate on the "permissions" field. It's identical to PermissionsEQ.
 func Permissions(v string) predicate.User {
 	return predicate.User(sql.FieldEQ(FieldPermissions, v))
@@ -160,6 +165,71 @@ func UpdatedAtLTE(v time.Time) predicate.User {
 	return predicate.User(sql.FieldLTE(FieldUpdatedAt, v))
 }
 
+// UsernameEQ applies the EQ predicate on the "username" field.
+func UsernameEQ(v string) predicate.User {
+	return predicate.User(sql.FieldEQ(FieldUsername, v))
+}
+
+// UsernameNEQ applies the NEQ predicate on the "username" field.
+func UsernameNEQ(v string) predicate.User {
+	return predicate.User(sql.FieldNEQ(FieldUsername, v))
+}
+
+// UsernameIn applies the In predicate on the "username" field.
+func UsernameIn(vs ...string) predicate.User {
+	return predicate.User(sql.FieldIn(FieldUsername, vs...))
+}
+
+// UsernameNotIn applies the NotIn predicate on the "username" field.
+func UsernameNotIn(vs ...string) predicate.User {
+	return predicate.User(sql.FieldNotIn(FieldUsername, vs...))
+}
+
+// UsernameGT applies the GT predicate on the "username" field.
+func UsernameGT(v string) predicate.User {
+	return predicate.User(sql.FieldGT(FieldUsername, v))
+}
+
+// UsernameGTE applies the GTE predicate on the "username" field.
+func UsernameGTE(v string) predicate.User {
+	return predicate.User(sql.FieldGTE(FieldUsername, v))
+}
+
+// UsernameLT applies the LT predicate on the "username" field.
+func UsernameLT(v string) predicate.User {
+	return predicate.User(sql.FieldLT(FieldUsername, v))
+}
+
+// UsernameLTE applies the LTE predicate on the "username" field.
+func UsernameLTE(v string) predicate.User {
+	return predicate.User(sql.FieldLTE(FieldUsername, v))
+}
+
+// UsernameContains applies the Contains predicate on the "username" field.
+func UsernameContains(v string) predicate.User {
+	return predicate.User(sql.FieldContains(FieldUsername, v))
+}
+
+// UsernameHasPrefix applies the HasPrefix predicate on the "username" field.
+func UsernameHasPrefix(v string) predicate.User {
+	return predicate.User(sql.FieldHasPrefix(FieldUsername, v))
+}
+
+// UsernameHasSuffix applies the HasSuffix predicate on the "username" field.
+func UsernameHasSuffix(v string) predicate.User {
+	return predicate.User(sql.FieldHasSuffix(FieldUsername, v))
+}
+
+// UsernameEqualFold applies the EqualFold predicate on the "username" field.
+func UsernameEqualFold(v string) predicate.User {
+	return predicate.User(sql.FieldEqualFold(FieldUsername, v))
+}
+
+// UsernameContainsFold applies the ContainsFold predicate on the "username" field.
+func UsernameContainsFold(v string) predicate.User {
+	return predicate.User(sql.FieldContainsFold(FieldUsername, v))
+}
+
 // PermissionsEQ applies the EQ predicate on the "permissions" field.
 func PermissionsEQ(v string) predicate.User {
 	return predicate.User(sql.FieldEQ(FieldPermissions, v))
@@ -327,6 +397,29 @@ func HasContentWith(preds ...predicate.UserContent) predicate.User {
 	})
 }
 
+// HasSessions applies the HasEdge predicate on the "sessions" edge.
+func HasSessions() predicate.User {
+	return predicate.User(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, SessionsTable, SessionsColumn),
+		)
+		sqlgraph.HasNeighbors(s, step)
+	})
+}
+
+// HasSessionsWith applies the HasEdge predicate on the "sessions" edge with a given conditions (other predicates).
+func HasSessionsWith(preds ...predicate.Session) predicate.User {
+	return predicate.User(func(s *sql.Selector) {
+		step := newSessionsStep()
+		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+			for _, p := range preds {
+				p(s)
+			}
+		})
+	})
+}
+
 // And groups predicates with the AND operator between them.
 func And(predicates ...predicate.User) predicate.User {
 	return predicate.User(sql.AndPredicates(predicates...))
diff --git a/internal/database/ent/db/user_create.go b/internal/database/ent/db/user_create.go
index 8cf24699..0f2d6dc1 100644
--- a/internal/database/ent/db/user_create.go
+++ b/internal/database/ent/db/user_create.go
@@ -11,6 +11,7 @@ import (
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"entgo.io/ent/schema/field"
 	"github.com/cufee/aftermath/internal/database/ent/db/discordinteraction"
+	"github.com/cufee/aftermath/internal/database/ent/db/session"
 	"github.com/cufee/aftermath/internal/database/ent/db/user"
 	"github.com/cufee/aftermath/internal/database/ent/db/userconnection"
 	"github.com/cufee/aftermath/internal/database/ent/db/usercontent"
@@ -52,6 +53,20 @@ func (uc *UserCreate) SetNillableUpdatedAt(t *time.Time) *UserCreate {
 	return uc
 }
 
+// SetUsername sets the "username" field.
+func (uc *UserCreate) SetUsername(s string) *UserCreate {
+	uc.mutation.SetUsername(s)
+	return uc
+}
+
+// SetNillableUsername sets the "username" field if the given value is not nil.
+func (uc *UserCreate) SetNillableUsername(s *string) *UserCreate {
+	if s != nil {
+		uc.SetUsername(*s)
+	}
+	return uc
+}
+
 // SetPermissions sets the "permissions" field.
 func (uc *UserCreate) SetPermissions(s string) *UserCreate {
 	uc.mutation.SetPermissions(s)
@@ -138,6 +153,21 @@ func (uc *UserCreate) AddContent(u ...*UserContent) *UserCreate {
 	return uc.AddContentIDs(ids...)
 }
 
+// AddSessionIDs adds the "sessions" edge to the Session entity by IDs.
+func (uc *UserCreate) AddSessionIDs(ids ...string) *UserCreate {
+	uc.mutation.AddSessionIDs(ids...)
+	return uc
+}
+
+// AddSessions adds the "sessions" edges to the Session entity.
+func (uc *UserCreate) AddSessions(s ...*Session) *UserCreate {
+	ids := make([]string, len(s))
+	for i := range s {
+		ids[i] = s[i].ID
+	}
+	return uc.AddSessionIDs(ids...)
+}
+
 // Mutation returns the UserMutation object of the builder.
 func (uc *UserCreate) Mutation() *UserMutation {
 	return uc.mutation
@@ -181,6 +211,10 @@ func (uc *UserCreate) defaults() {
 		v := user.DefaultUpdatedAt()
 		uc.mutation.SetUpdatedAt(v)
 	}
+	if _, ok := uc.mutation.Username(); !ok {
+		v := user.DefaultUsername
+		uc.mutation.SetUsername(v)
+	}
 	if _, ok := uc.mutation.Permissions(); !ok {
 		v := user.DefaultPermissions
 		uc.mutation.SetPermissions(v)
@@ -195,6 +229,9 @@ func (uc *UserCreate) check() error {
 	if _, ok := uc.mutation.UpdatedAt(); !ok {
 		return &ValidationError{Name: "updated_at", err: errors.New(`db: missing required field "User.updated_at"`)}
 	}
+	if _, ok := uc.mutation.Username(); !ok {
+		return &ValidationError{Name: "username", err: errors.New(`db: missing required field "User.username"`)}
+	}
 	if _, ok := uc.mutation.Permissions(); !ok {
 		return &ValidationError{Name: "permissions", err: errors.New(`db: missing required field "User.permissions"`)}
 	}
@@ -241,6 +278,10 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) {
 		_spec.SetField(user.FieldUpdatedAt, field.TypeTime, value)
 		_node.UpdatedAt = value
 	}
+	if value, ok := uc.mutation.Username(); ok {
+		_spec.SetField(user.FieldUsername, field.TypeString, value)
+		_node.Username = value
+	}
 	if value, ok := uc.mutation.Permissions(); ok {
 		_spec.SetField(user.FieldPermissions, field.TypeString, value)
 		_node.Permissions = value
@@ -313,6 +354,22 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) {
 		}
 		_spec.Edges = append(_spec.Edges, edge)
 	}
+	if nodes := uc.mutation.SessionsIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.SessionsTable,
+			Columns: []string{user.SessionsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(session.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges = append(_spec.Edges, edge)
+	}
 	return _node, _spec
 }
 
diff --git a/internal/database/ent/db/user_query.go b/internal/database/ent/db/user_query.go
index 2e37a52c..ef3b78e1 100644
--- a/internal/database/ent/db/user_query.go
+++ b/internal/database/ent/db/user_query.go
@@ -13,6 +13,7 @@ import (
 	"entgo.io/ent/schema/field"
 	"github.com/cufee/aftermath/internal/database/ent/db/discordinteraction"
 	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/ent/db/session"
 	"github.com/cufee/aftermath/internal/database/ent/db/user"
 	"github.com/cufee/aftermath/internal/database/ent/db/userconnection"
 	"github.com/cufee/aftermath/internal/database/ent/db/usercontent"
@@ -30,6 +31,7 @@ type UserQuery struct {
 	withSubscriptions       *UserSubscriptionQuery
 	withConnections         *UserConnectionQuery
 	withContent             *UserContentQuery
+	withSessions            *SessionQuery
 	modifiers               []func(*sql.Selector)
 	// intermediate query (i.e. traversal path).
 	sql  *sql.Selector
@@ -155,6 +157,28 @@ func (uq *UserQuery) QueryContent() *UserContentQuery {
 	return query
 }
 
+// QuerySessions chains the current query on the "sessions" edge.
+func (uq *UserQuery) QuerySessions() *SessionQuery {
+	query := (&SessionClient{config: uq.config}).Query()
+	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+		if err := uq.prepareQuery(ctx); err != nil {
+			return nil, err
+		}
+		selector := uq.sqlQuery(ctx)
+		if err := selector.Err(); err != nil {
+			return nil, err
+		}
+		step := sqlgraph.NewStep(
+			sqlgraph.From(user.Table, user.FieldID, selector),
+			sqlgraph.To(session.Table, session.FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, user.SessionsTable, user.SessionsColumn),
+		)
+		fromU = sqlgraph.SetNeighbors(uq.driver.Dialect(), step)
+		return fromU, nil
+	}
+	return query
+}
+
 // First returns the first User entity from the query.
 // Returns a *NotFoundError when no User was found.
 func (uq *UserQuery) First(ctx context.Context) (*User, error) {
@@ -351,6 +375,7 @@ func (uq *UserQuery) Clone() *UserQuery {
 		withSubscriptions:       uq.withSubscriptions.Clone(),
 		withConnections:         uq.withConnections.Clone(),
 		withContent:             uq.withContent.Clone(),
+		withSessions:            uq.withSessions.Clone(),
 		// clone intermediate query.
 		sql:  uq.sql.Clone(),
 		path: uq.path,
@@ -401,6 +426,17 @@ func (uq *UserQuery) WithContent(opts ...func(*UserContentQuery)) *UserQuery {
 	return uq
 }
 
+// WithSessions tells the query-builder to eager-load the nodes that are connected to
+// the "sessions" edge. The optional arguments are used to configure the query builder of the edge.
+func (uq *UserQuery) WithSessions(opts ...func(*SessionQuery)) *UserQuery {
+	query := (&SessionClient{config: uq.config}).Query()
+	for _, opt := range opts {
+		opt(query)
+	}
+	uq.withSessions = query
+	return uq
+}
+
 // GroupBy is used to group vertices by one or more fields/columns.
 // It is often used with aggregate functions, like: count, max, mean, min, sum.
 //
@@ -479,11 +515,12 @@ func (uq *UserQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*User, e
 	var (
 		nodes       = []*User{}
 		_spec       = uq.querySpec()
-		loadedTypes = [4]bool{
+		loadedTypes = [5]bool{
 			uq.withDiscordInteractions != nil,
 			uq.withSubscriptions != nil,
 			uq.withConnections != nil,
 			uq.withContent != nil,
+			uq.withSessions != nil,
 		}
 	)
 	_spec.ScanValues = func(columns []string) ([]any, error) {
@@ -537,6 +574,13 @@ func (uq *UserQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*User, e
 			return nil, err
 		}
 	}
+	if query := uq.withSessions; query != nil {
+		if err := uq.loadSessions(ctx, query, nodes,
+			func(n *User) { n.Edges.Sessions = []*Session{} },
+			func(n *User, e *Session) { n.Edges.Sessions = append(n.Edges.Sessions, e) }); err != nil {
+			return nil, err
+		}
+	}
 	return nodes, nil
 }
 
@@ -660,6 +704,36 @@ func (uq *UserQuery) loadContent(ctx context.Context, query *UserContentQuery, n
 	}
 	return nil
 }
+func (uq *UserQuery) loadSessions(ctx context.Context, query *SessionQuery, nodes []*User, init func(*User), assign func(*User, *Session)) error {
+	fks := make([]driver.Value, 0, len(nodes))
+	nodeids := make(map[string]*User)
+	for i := range nodes {
+		fks = append(fks, nodes[i].ID)
+		nodeids[nodes[i].ID] = nodes[i]
+		if init != nil {
+			init(nodes[i])
+		}
+	}
+	if len(query.ctx.Fields) > 0 {
+		query.ctx.AppendFieldOnce(session.FieldUserID)
+	}
+	query.Where(predicate.Session(func(s *sql.Selector) {
+		s.Where(sql.InValues(s.C(user.SessionsColumn), fks...))
+	}))
+	neighbors, err := query.All(ctx)
+	if err != nil {
+		return err
+	}
+	for _, n := range neighbors {
+		fk := n.UserID
+		node, ok := nodeids[fk]
+		if !ok {
+			return fmt.Errorf(`unexpected referenced foreign-key "user_id" returned %v for node %v`, fk, n.ID)
+		}
+		assign(node, n)
+	}
+	return nil
+}
 
 func (uq *UserQuery) sqlCount(ctx context.Context) (int, error) {
 	_spec := uq.querySpec()
diff --git a/internal/database/ent/db/user_update.go b/internal/database/ent/db/user_update.go
index 57c92a14..1b4b1997 100644
--- a/internal/database/ent/db/user_update.go
+++ b/internal/database/ent/db/user_update.go
@@ -14,6 +14,7 @@ import (
 	"entgo.io/ent/schema/field"
 	"github.com/cufee/aftermath/internal/database/ent/db/discordinteraction"
 	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/ent/db/session"
 	"github.com/cufee/aftermath/internal/database/ent/db/user"
 	"github.com/cufee/aftermath/internal/database/ent/db/userconnection"
 	"github.com/cufee/aftermath/internal/database/ent/db/usercontent"
@@ -40,6 +41,20 @@ func (uu *UserUpdate) SetUpdatedAt(t time.Time) *UserUpdate {
 	return uu
 }
 
+// SetUsername sets the "username" field.
+func (uu *UserUpdate) SetUsername(s string) *UserUpdate {
+	uu.mutation.SetUsername(s)
+	return uu
+}
+
+// SetNillableUsername sets the "username" field if the given value is not nil.
+func (uu *UserUpdate) SetNillableUsername(s *string) *UserUpdate {
+	if s != nil {
+		uu.SetUsername(*s)
+	}
+	return uu
+}
+
 // SetPermissions sets the "permissions" field.
 func (uu *UserUpdate) SetPermissions(s string) *UserUpdate {
 	uu.mutation.SetPermissions(s)
@@ -132,6 +147,21 @@ func (uu *UserUpdate) AddContent(u ...*UserContent) *UserUpdate {
 	return uu.AddContentIDs(ids...)
 }
 
+// AddSessionIDs adds the "sessions" edge to the Session entity by IDs.
+func (uu *UserUpdate) AddSessionIDs(ids ...string) *UserUpdate {
+	uu.mutation.AddSessionIDs(ids...)
+	return uu
+}
+
+// AddSessions adds the "sessions" edges to the Session entity.
+func (uu *UserUpdate) AddSessions(s ...*Session) *UserUpdate {
+	ids := make([]string, len(s))
+	for i := range s {
+		ids[i] = s[i].ID
+	}
+	return uu.AddSessionIDs(ids...)
+}
+
 // Mutation returns the UserMutation object of the builder.
 func (uu *UserUpdate) Mutation() *UserMutation {
 	return uu.mutation
@@ -221,6 +251,27 @@ func (uu *UserUpdate) RemoveContent(u ...*UserContent) *UserUpdate {
 	return uu.RemoveContentIDs(ids...)
 }
 
+// ClearSessions clears all "sessions" edges to the Session entity.
+func (uu *UserUpdate) ClearSessions() *UserUpdate {
+	uu.mutation.ClearSessions()
+	return uu
+}
+
+// RemoveSessionIDs removes the "sessions" edge to Session entities by IDs.
+func (uu *UserUpdate) RemoveSessionIDs(ids ...string) *UserUpdate {
+	uu.mutation.RemoveSessionIDs(ids...)
+	return uu
+}
+
+// RemoveSessions removes "sessions" edges to Session entities.
+func (uu *UserUpdate) RemoveSessions(s ...*Session) *UserUpdate {
+	ids := make([]string, len(s))
+	for i := range s {
+		ids[i] = s[i].ID
+	}
+	return uu.RemoveSessionIDs(ids...)
+}
+
 // Save executes the query and returns the number of nodes affected by the update operation.
 func (uu *UserUpdate) Save(ctx context.Context) (int, error) {
 	uu.defaults()
@@ -275,6 +326,9 @@ func (uu *UserUpdate) sqlSave(ctx context.Context) (n int, err error) {
 	if value, ok := uu.mutation.UpdatedAt(); ok {
 		_spec.SetField(user.FieldUpdatedAt, field.TypeTime, value)
 	}
+	if value, ok := uu.mutation.Username(); ok {
+		_spec.SetField(user.FieldUsername, field.TypeString, value)
+	}
 	if value, ok := uu.mutation.Permissions(); ok {
 		_spec.SetField(user.FieldPermissions, field.TypeString, value)
 	}
@@ -469,6 +523,51 @@ func (uu *UserUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 		_spec.Edges.Add = append(_spec.Edges.Add, edge)
 	}
+	if uu.mutation.SessionsCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.SessionsTable,
+			Columns: []string{user.SessionsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(session.FieldID, field.TypeString),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := uu.mutation.RemovedSessionsIDs(); len(nodes) > 0 && !uu.mutation.SessionsCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.SessionsTable,
+			Columns: []string{user.SessionsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(session.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := uu.mutation.SessionsIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.SessionsTable,
+			Columns: []string{user.SessionsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(session.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
 	_spec.AddModifiers(uu.modifiers...)
 	if n, err = sqlgraph.UpdateNodes(ctx, uu.driver, _spec); err != nil {
 		if _, ok := err.(*sqlgraph.NotFoundError); ok {
@@ -497,6 +596,20 @@ func (uuo *UserUpdateOne) SetUpdatedAt(t time.Time) *UserUpdateOne {
 	return uuo
 }
 
+// SetUsername sets the "username" field.
+func (uuo *UserUpdateOne) SetUsername(s string) *UserUpdateOne {
+	uuo.mutation.SetUsername(s)
+	return uuo
+}
+
+// SetNillableUsername sets the "username" field if the given value is not nil.
+func (uuo *UserUpdateOne) SetNillableUsername(s *string) *UserUpdateOne {
+	if s != nil {
+		uuo.SetUsername(*s)
+	}
+	return uuo
+}
+
 // SetPermissions sets the "permissions" field.
 func (uuo *UserUpdateOne) SetPermissions(s string) *UserUpdateOne {
 	uuo.mutation.SetPermissions(s)
@@ -589,6 +702,21 @@ func (uuo *UserUpdateOne) AddContent(u ...*UserContent) *UserUpdateOne {
 	return uuo.AddContentIDs(ids...)
 }
 
+// AddSessionIDs adds the "sessions" edge to the Session entity by IDs.
+func (uuo *UserUpdateOne) AddSessionIDs(ids ...string) *UserUpdateOne {
+	uuo.mutation.AddSessionIDs(ids...)
+	return uuo
+}
+
+// AddSessions adds the "sessions" edges to the Session entity.
+func (uuo *UserUpdateOne) AddSessions(s ...*Session) *UserUpdateOne {
+	ids := make([]string, len(s))
+	for i := range s {
+		ids[i] = s[i].ID
+	}
+	return uuo.AddSessionIDs(ids...)
+}
+
 // Mutation returns the UserMutation object of the builder.
 func (uuo *UserUpdateOne) Mutation() *UserMutation {
 	return uuo.mutation
@@ -678,6 +806,27 @@ func (uuo *UserUpdateOne) RemoveContent(u ...*UserContent) *UserUpdateOne {
 	return uuo.RemoveContentIDs(ids...)
 }
 
+// ClearSessions clears all "sessions" edges to the Session entity.
+func (uuo *UserUpdateOne) ClearSessions() *UserUpdateOne {
+	uuo.mutation.ClearSessions()
+	return uuo
+}
+
+// RemoveSessionIDs removes the "sessions" edge to Session entities by IDs.
+func (uuo *UserUpdateOne) RemoveSessionIDs(ids ...string) *UserUpdateOne {
+	uuo.mutation.RemoveSessionIDs(ids...)
+	return uuo
+}
+
+// RemoveSessions removes "sessions" edges to Session entities.
+func (uuo *UserUpdateOne) RemoveSessions(s ...*Session) *UserUpdateOne {
+	ids := make([]string, len(s))
+	for i := range s {
+		ids[i] = s[i].ID
+	}
+	return uuo.RemoveSessionIDs(ids...)
+}
+
 // Where appends a list predicates to the UserUpdate builder.
 func (uuo *UserUpdateOne) Where(ps ...predicate.User) *UserUpdateOne {
 	uuo.mutation.Where(ps...)
@@ -762,6 +911,9 @@ func (uuo *UserUpdateOne) sqlSave(ctx context.Context) (_node *User, err error)
 	if value, ok := uuo.mutation.UpdatedAt(); ok {
 		_spec.SetField(user.FieldUpdatedAt, field.TypeTime, value)
 	}
+	if value, ok := uuo.mutation.Username(); ok {
+		_spec.SetField(user.FieldUsername, field.TypeString, value)
+	}
 	if value, ok := uuo.mutation.Permissions(); ok {
 		_spec.SetField(user.FieldPermissions, field.TypeString, value)
 	}
@@ -956,6 +1108,51 @@ func (uuo *UserUpdateOne) sqlSave(ctx context.Context) (_node *User, err error)
 		}
 		_spec.Edges.Add = append(_spec.Edges.Add, edge)
 	}
+	if uuo.mutation.SessionsCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.SessionsTable,
+			Columns: []string{user.SessionsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(session.FieldID, field.TypeString),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := uuo.mutation.RemovedSessionsIDs(); len(nodes) > 0 && !uuo.mutation.SessionsCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.SessionsTable,
+			Columns: []string{user.SessionsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(session.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := uuo.mutation.SessionsIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.SessionsTable,
+			Columns: []string{user.SessionsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(session.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
 	_spec.AddModifiers(uuo.modifiers...)
 	_node = &User{config: uuo.config}
 	_spec.Assign = _node.assignValues
diff --git a/internal/database/ent/migrations/20240703151859.sql b/internal/database/ent/migrations/20240703151859.sql
new file mode 100644
index 00000000..b2ceca0a
--- /dev/null
+++ b/internal/database/ent/migrations/20240703151859.sql
@@ -0,0 +1,22 @@
+-- Disable the enforcement of foreign-keys constraints
+PRAGMA foreign_keys = off;
+-- Create "new_users" table
+CREATE TABLE `new_users` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `username` text NOT NULL DEFAULT (''), `permissions` text NOT NULL DEFAULT (''), `feature_flags` json NULL, PRIMARY KEY (`id`));
+-- Copy rows from old table "users" to new temporary table "new_users"
+INSERT INTO `new_users` (`id`, `created_at`, `updated_at`, `permissions`, `feature_flags`) SELECT `id`, `created_at`, `updated_at`, `permissions`, `feature_flags` FROM `users`;
+-- Drop "users" table after copying rows
+DROP TABLE `users`;
+-- Rename temporary table "new_users" to "users"
+ALTER TABLE `new_users` RENAME TO `users`;
+-- Create index "user_id" to table: "users"
+CREATE INDEX `user_id` ON `users` (`id`);
+-- Create index "user_username" to table: "users"
+CREATE INDEX `user_username` ON `users` (`username`);
+-- Create "auth_nonces" table
+CREATE TABLE `auth_nonces` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `active` bool NOT NULL, `expires_at` datetime NOT NULL, `identifier` text NOT NULL, `public_id` text NOT NULL, PRIMARY KEY (`id`));
+-- Create index "auth_nonces_public_id_key" to table: "auth_nonces"
+CREATE UNIQUE INDEX `auth_nonces_public_id_key` ON `auth_nonces` (`public_id`);
+-- Create index "authnonce_public_id_active_expires_at" to table: "auth_nonces"
+CREATE INDEX `authnonce_public_id_active_expires_at` ON `auth_nonces` (`public_id`, `active`, `expires_at`);
+-- Enable back the enforcement of foreign-keys constraints
+PRAGMA foreign_keys = on;
diff --git a/internal/database/ent/migrations/20240703160454.sql b/internal/database/ent/migrations/20240703160454.sql
new file mode 100644
index 00000000..dd5c1c46
--- /dev/null
+++ b/internal/database/ent/migrations/20240703160454.sql
@@ -0,0 +1,6 @@
+-- Create "sessions" table
+CREATE TABLE `sessions` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `expires_at` datetime NOT NULL, `public_id` text NOT NULL, `user_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `sessions_users_sessions` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE NO ACTION);
+-- Create index "sessions_public_id_key" to table: "sessions"
+CREATE UNIQUE INDEX `sessions_public_id_key` ON `sessions` (`public_id`);
+-- Create index "session_public_id_expires_at" to table: "sessions"
+CREATE INDEX `session_public_id_expires_at` ON `sessions` (`public_id`, `expires_at`);
diff --git a/internal/database/ent/migrations/20240703160711.sql b/internal/database/ent/migrations/20240703160711.sql
new file mode 100644
index 00000000..3e23cb09
--- /dev/null
+++ b/internal/database/ent/migrations/20240703160711.sql
@@ -0,0 +1,142 @@
+-- Disable the enforcement of foreign-keys constraints
+PRAGMA foreign_keys = off;
+-- Create "new_account_snapshots" table
+CREATE TABLE `new_account_snapshots` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `last_battle_time` datetime NOT NULL, `reference_id` text NOT NULL, `rating_battles` integer NOT NULL, `rating_frame` json NOT NULL, `regular_battles` integer NOT NULL, `regular_frame` json NOT NULL, `account_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `account_snapshots_accounts_account_snapshots` FOREIGN KEY (`account_id`) REFERENCES `accounts` (`id`) ON DELETE CASCADE);
+-- Copy rows from old table "account_snapshots" to new temporary table "new_account_snapshots"
+INSERT INTO `new_account_snapshots` (`id`, `created_at`, `updated_at`, `type`, `last_battle_time`, `reference_id`, `rating_battles`, `rating_frame`, `regular_battles`, `regular_frame`, `account_id`) SELECT `id`, `created_at`, `updated_at`, `type`, `last_battle_time`, `reference_id`, `rating_battles`, `rating_frame`, `regular_battles`, `regular_frame`, `account_id` FROM `account_snapshots`;
+-- Drop "account_snapshots" table after copying rows
+DROP TABLE `account_snapshots`;
+-- Rename temporary table "new_account_snapshots" to "account_snapshots"
+ALTER TABLE `new_account_snapshots` RENAME TO `account_snapshots`;
+-- Create index "accountsnapshot_id" to table: "account_snapshots"
+CREATE INDEX `accountsnapshot_id` ON `account_snapshots` (`id`);
+-- Create index "accountsnapshot_created_at" to table: "account_snapshots"
+CREATE INDEX `accountsnapshot_created_at` ON `account_snapshots` (`created_at`);
+-- Create index "accountsnapshot_type_account_id_created_at" to table: "account_snapshots"
+CREATE INDEX `accountsnapshot_type_account_id_created_at` ON `account_snapshots` (`type`, `account_id`, `created_at`);
+-- Create index "accountsnapshot_type_account_id_reference_id" to table: "account_snapshots"
+CREATE INDEX `accountsnapshot_type_account_id_reference_id` ON `account_snapshots` (`type`, `account_id`, `reference_id`);
+-- Create index "accountsnapshot_type_account_id_reference_id_created_at" to table: "account_snapshots"
+CREATE INDEX `accountsnapshot_type_account_id_reference_id_created_at` ON `account_snapshots` (`type`, `account_id`, `reference_id`, `created_at`);
+-- Create "new_achievements_snapshots" table
+CREATE TABLE `new_achievements_snapshots` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `reference_id` text NOT NULL, `battles` integer NOT NULL, `last_battle_time` datetime NOT NULL, `data` json NOT NULL, `account_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `achievements_snapshots_accounts_achievement_snapshots` FOREIGN KEY (`account_id`) REFERENCES `accounts` (`id`) ON DELETE CASCADE);
+-- Copy rows from old table "achievements_snapshots" to new temporary table "new_achievements_snapshots"
+INSERT INTO `new_achievements_snapshots` (`id`, `created_at`, `updated_at`, `type`, `reference_id`, `battles`, `last_battle_time`, `data`, `account_id`) SELECT `id`, `created_at`, `updated_at`, `type`, `reference_id`, `battles`, `last_battle_time`, `data`, `account_id` FROM `achievements_snapshots`;
+-- Drop "achievements_snapshots" table after copying rows
+DROP TABLE `achievements_snapshots`;
+-- Rename temporary table "new_achievements_snapshots" to "achievements_snapshots"
+ALTER TABLE `new_achievements_snapshots` RENAME TO `achievements_snapshots`;
+-- Create index "achievementssnapshot_id" to table: "achievements_snapshots"
+CREATE INDEX `achievementssnapshot_id` ON `achievements_snapshots` (`id`);
+-- Create index "achievementssnapshot_created_at" to table: "achievements_snapshots"
+CREATE INDEX `achievementssnapshot_created_at` ON `achievements_snapshots` (`created_at`);
+-- Create index "achievementssnapshot_account_id_reference_id" to table: "achievements_snapshots"
+CREATE INDEX `achievementssnapshot_account_id_reference_id` ON `achievements_snapshots` (`account_id`, `reference_id`);
+-- Create index "achievementssnapshot_account_id_reference_id_created_at" to table: "achievements_snapshots"
+CREATE INDEX `achievementssnapshot_account_id_reference_id_created_at` ON `achievements_snapshots` (`account_id`, `reference_id`, `created_at`);
+-- Create "new_discord_interactions" table
+CREATE TABLE `new_discord_interactions` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `command` text NOT NULL, `reference_id` text NOT NULL, `type` text NOT NULL, `locale` text NOT NULL, `options` json NOT NULL, `user_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `discord_interactions_users_discord_interactions` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE CASCADE);
+-- Copy rows from old table "discord_interactions" to new temporary table "new_discord_interactions"
+INSERT INTO `new_discord_interactions` (`id`, `created_at`, `updated_at`, `command`, `reference_id`, `type`, `locale`, `options`, `user_id`) SELECT `id`, `created_at`, `updated_at`, `command`, `reference_id`, `type`, `locale`, `options`, `user_id` FROM `discord_interactions`;
+-- Drop "discord_interactions" table after copying rows
+DROP TABLE `discord_interactions`;
+-- Rename temporary table "new_discord_interactions" to "discord_interactions"
+ALTER TABLE `new_discord_interactions` RENAME TO `discord_interactions`;
+-- Create index "discordinteraction_id" to table: "discord_interactions"
+CREATE INDEX `discordinteraction_id` ON `discord_interactions` (`id`);
+-- Create index "discordinteraction_command" to table: "discord_interactions"
+CREATE INDEX `discordinteraction_command` ON `discord_interactions` (`command`);
+-- Create index "discordinteraction_user_id" to table: "discord_interactions"
+CREATE INDEX `discordinteraction_user_id` ON `discord_interactions` (`user_id`);
+-- Create index "discordinteraction_user_id_type" to table: "discord_interactions"
+CREATE INDEX `discordinteraction_user_id_type` ON `discord_interactions` (`user_id`, `type`);
+-- Create index "discordinteraction_reference_id" to table: "discord_interactions"
+CREATE INDEX `discordinteraction_reference_id` ON `discord_interactions` (`reference_id`);
+-- Create "new_user_connections" table
+CREATE TABLE `new_user_connections` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `reference_id` text NOT NULL, `permissions` text NULL DEFAULT (''), `metadata` json NULL, `user_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `user_connections_users_connections` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE CASCADE);
+-- Copy rows from old table "user_connections" to new temporary table "new_user_connections"
+INSERT INTO `new_user_connections` (`id`, `created_at`, `updated_at`, `type`, `reference_id`, `permissions`, `metadata`, `user_id`) SELECT `id`, `created_at`, `updated_at`, `type`, `reference_id`, `permissions`, `metadata`, `user_id` FROM `user_connections`;
+-- Drop "user_connections" table after copying rows
+DROP TABLE `user_connections`;
+-- Rename temporary table "new_user_connections" to "user_connections"
+ALTER TABLE `new_user_connections` RENAME TO `user_connections`;
+-- Create index "userconnection_id" to table: "user_connections"
+CREATE INDEX `userconnection_id` ON `user_connections` (`id`);
+-- Create index "userconnection_user_id" to table: "user_connections"
+CREATE INDEX `userconnection_user_id` ON `user_connections` (`user_id`);
+-- Create index "userconnection_type_user_id" to table: "user_connections"
+CREATE INDEX `userconnection_type_user_id` ON `user_connections` (`type`, `user_id`);
+-- Create index "userconnection_reference_id" to table: "user_connections"
+CREATE INDEX `userconnection_reference_id` ON `user_connections` (`reference_id`);
+-- Create index "userconnection_type_reference_id" to table: "user_connections"
+CREATE INDEX `userconnection_type_reference_id` ON `user_connections` (`type`, `reference_id`);
+-- Create index "userconnection_reference_id_user_id_type" to table: "user_connections"
+CREATE UNIQUE INDEX `userconnection_reference_id_user_id_type` ON `user_connections` (`reference_id`, `user_id`, `type`);
+-- Create "new_user_contents" table
+CREATE TABLE `new_user_contents` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `reference_id` text NOT NULL, `value` text NOT NULL, `metadata` json NOT NULL, `user_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `user_contents_users_content` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE CASCADE);
+-- Copy rows from old table "user_contents" to new temporary table "new_user_contents"
+INSERT INTO `new_user_contents` (`id`, `created_at`, `updated_at`, `type`, `reference_id`, `value`, `metadata`, `user_id`) SELECT `id`, `created_at`, `updated_at`, `type`, `reference_id`, `value`, `metadata`, `user_id` FROM `user_contents`;
+-- Drop "user_contents" table after copying rows
+DROP TABLE `user_contents`;
+-- Rename temporary table "new_user_contents" to "user_contents"
+ALTER TABLE `new_user_contents` RENAME TO `user_contents`;
+-- Create index "usercontent_id" to table: "user_contents"
+CREATE INDEX `usercontent_id` ON `user_contents` (`id`);
+-- Create index "usercontent_user_id" to table: "user_contents"
+CREATE INDEX `usercontent_user_id` ON `user_contents` (`user_id`);
+-- Create index "usercontent_type_user_id" to table: "user_contents"
+CREATE INDEX `usercontent_type_user_id` ON `user_contents` (`type`, `user_id`);
+-- Create index "usercontent_reference_id" to table: "user_contents"
+CREATE INDEX `usercontent_reference_id` ON `user_contents` (`reference_id`);
+-- Create index "usercontent_type_reference_id" to table: "user_contents"
+CREATE INDEX `usercontent_type_reference_id` ON `user_contents` (`type`, `reference_id`);
+-- Create "new_user_subscriptions" table
+CREATE TABLE `new_user_subscriptions` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `expires_at` datetime NOT NULL, `permissions` text NOT NULL, `reference_id` text NOT NULL, `user_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `user_subscriptions_users_subscriptions` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE CASCADE);
+-- Copy rows from old table "user_subscriptions" to new temporary table "new_user_subscriptions"
+INSERT INTO `new_user_subscriptions` (`id`, `created_at`, `updated_at`, `type`, `expires_at`, `permissions`, `reference_id`, `user_id`) SELECT `id`, `created_at`, `updated_at`, `type`, `expires_at`, `permissions`, `reference_id`, `user_id` FROM `user_subscriptions`;
+-- Drop "user_subscriptions" table after copying rows
+DROP TABLE `user_subscriptions`;
+-- Rename temporary table "new_user_subscriptions" to "user_subscriptions"
+ALTER TABLE `new_user_subscriptions` RENAME TO `user_subscriptions`;
+-- Create index "usersubscription_id" to table: "user_subscriptions"
+CREATE INDEX `usersubscription_id` ON `user_subscriptions` (`id`);
+-- Create index "usersubscription_user_id" to table: "user_subscriptions"
+CREATE INDEX `usersubscription_user_id` ON `user_subscriptions` (`user_id`);
+-- Create index "usersubscription_type_user_id" to table: "user_subscriptions"
+CREATE INDEX `usersubscription_type_user_id` ON `user_subscriptions` (`type`, `user_id`);
+-- Create index "usersubscription_expires_at" to table: "user_subscriptions"
+CREATE INDEX `usersubscription_expires_at` ON `user_subscriptions` (`expires_at`);
+-- Create index "usersubscription_expires_at_user_id" to table: "user_subscriptions"
+CREATE INDEX `usersubscription_expires_at_user_id` ON `user_subscriptions` (`expires_at`, `user_id`);
+-- Create "new_vehicle_snapshots" table
+CREATE TABLE `new_vehicle_snapshots` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `vehicle_id` text NOT NULL, `reference_id` text NOT NULL, `battles` integer NOT NULL, `last_battle_time` datetime NOT NULL, `frame` json NOT NULL, `account_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `vehicle_snapshots_accounts_vehicle_snapshots` FOREIGN KEY (`account_id`) REFERENCES `accounts` (`id`) ON DELETE CASCADE);
+-- Copy rows from old table "vehicle_snapshots" to new temporary table "new_vehicle_snapshots"
+INSERT INTO `new_vehicle_snapshots` (`id`, `created_at`, `updated_at`, `type`, `vehicle_id`, `reference_id`, `battles`, `last_battle_time`, `frame`, `account_id`) SELECT `id`, `created_at`, `updated_at`, `type`, `vehicle_id`, `reference_id`, `battles`, `last_battle_time`, `frame`, `account_id` FROM `vehicle_snapshots`;
+-- Drop "vehicle_snapshots" table after copying rows
+DROP TABLE `vehicle_snapshots`;
+-- Rename temporary table "new_vehicle_snapshots" to "vehicle_snapshots"
+ALTER TABLE `new_vehicle_snapshots` RENAME TO `vehicle_snapshots`;
+-- Create index "vehiclesnapshot_id" to table: "vehicle_snapshots"
+CREATE INDEX `vehiclesnapshot_id` ON `vehicle_snapshots` (`id`);
+-- Create index "vehiclesnapshot_created_at" to table: "vehicle_snapshots"
+CREATE INDEX `vehiclesnapshot_created_at` ON `vehicle_snapshots` (`created_at`);
+-- Create index "vehiclesnapshot_vehicle_id_created_at" to table: "vehicle_snapshots"
+CREATE INDEX `vehiclesnapshot_vehicle_id_created_at` ON `vehicle_snapshots` (`vehicle_id`, `created_at`);
+-- Create index "vehiclesnapshot_account_id_created_at" to table: "vehicle_snapshots"
+CREATE INDEX `vehiclesnapshot_account_id_created_at` ON `vehicle_snapshots` (`account_id`, `created_at`);
+-- Create index "vehiclesnapshot_account_id_type_created_at" to table: "vehicle_snapshots"
+CREATE INDEX `vehiclesnapshot_account_id_type_created_at` ON `vehicle_snapshots` (`account_id`, `type`, `created_at`);
+-- Create "new_sessions" table
+CREATE TABLE `new_sessions` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `expires_at` datetime NOT NULL, `public_id` text NOT NULL, `user_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `sessions_users_sessions` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE CASCADE);
+-- Copy rows from old table "sessions" to new temporary table "new_sessions"
+INSERT INTO `new_sessions` (`id`, `created_at`, `updated_at`, `expires_at`, `public_id`, `user_id`) SELECT `id`, `created_at`, `updated_at`, `expires_at`, `public_id`, `user_id` FROM `sessions`;
+-- Drop "sessions" table after copying rows
+DROP TABLE `sessions`;
+-- Rename temporary table "new_sessions" to "sessions"
+ALTER TABLE `new_sessions` RENAME TO `sessions`;
+-- Create index "sessions_public_id_key" to table: "sessions"
+CREATE UNIQUE INDEX `sessions_public_id_key` ON `sessions` (`public_id`);
+-- Create index "session_public_id_expires_at" to table: "sessions"
+CREATE INDEX `session_public_id_expires_at` ON `sessions` (`public_id`, `expires_at`);
+-- Enable back the enforcement of foreign-keys constraints
+PRAGMA foreign_keys = on;
diff --git a/internal/database/ent/migrations/20240703180358.sql b/internal/database/ent/migrations/20240703180358.sql
new file mode 100644
index 00000000..4162fa2b
--- /dev/null
+++ b/internal/database/ent/migrations/20240703180358.sql
@@ -0,0 +1,4 @@
+-- Add column "metadata" to table: "auth_nonces"
+ALTER TABLE `auth_nonces` ADD COLUMN `metadata` json NOT NULL;
+-- Add column "metadata" to table: "sessions"
+ALTER TABLE `sessions` ADD COLUMN `metadata` json NOT NULL;
diff --git a/internal/database/ent/migrations/atlas.sum b/internal/database/ent/migrations/atlas.sum
index 2251e9e6..e7b6993f 100644
--- a/internal/database/ent/migrations/atlas.sum
+++ b/internal/database/ent/migrations/atlas.sum
@@ -1,3 +1,7 @@
-h1:ZYxvqqhpfA/QIZSU/etxpGhuHYFfgwF3/i9HL04YT0E=
+h1:FmVqQkU1ia4ydQNcB3kqRiXuPqjEdvnRb+sVMIJRRPA=
 20240627171532.sql h1:480JhjRCpyyix192z/L92yEI7LSsgJhuiK0ljat55TI=
 20240627200953.sql h1:VUQZd1HQrxITMUtNO9HRtnDE8wgtWgRyzduACb3D3u4=
+20240703151859.sql h1:1QQD7uLkRsLESNATRcGMg7k1C+sxYFQh/wI7BXrsKUA=
+20240703160454.sql h1:8KsIVNWGQGGSkh/cvdYdg1SLIRG0BqY262QOu0Icqu4=
+20240703160711.sql h1:26t/4QYITq6eAo2hif8sCLRpuHsCHXt6nyvDnX+Y1oQ=
+20240703180358.sql h1:gxgh1nrquDAOFGT7yGzgqpy5EfQ4Dvgd6c2NMPM3iIs=
diff --git a/internal/database/ent/schema/account.go b/internal/database/ent/schema/account.go
index c27e22df..ce4ca153 100644
--- a/internal/database/ent/schema/account.go
+++ b/internal/database/ent/schema/account.go
@@ -2,6 +2,7 @@ package schema
 
 import (
 	"entgo.io/ent"
+	"entgo.io/ent/dialect/entsql"
 	"entgo.io/ent/schema/edge"
 	"entgo.io/ent/schema/field"
 	"entgo.io/ent/schema/index"
@@ -41,9 +42,9 @@ func (Account) Fields() []ent.Field {
 func (Account) Edges() []ent.Edge {
 	return []ent.Edge{
 		edge.From("clan", Clan.Type).Ref("accounts").Field("clan_id").Unique(),
-		edge.To("achievement_snapshots", AchievementsSnapshot.Type),
-		edge.To("vehicle_snapshots", VehicleSnapshot.Type),
-		edge.To("account_snapshots", AccountSnapshot.Type),
+		edge.To("achievement_snapshots", AchievementsSnapshot.Type).Annotations(entsql.OnDelete(entsql.Cascade)),
+		edge.To("vehicle_snapshots", VehicleSnapshot.Type).Annotations(entsql.OnDelete(entsql.Cascade)),
+		edge.To("account_snapshots", AccountSnapshot.Type).Annotations(entsql.OnDelete(entsql.Cascade)),
 	}
 }
 
diff --git a/internal/database/ent/schema/nonce.go b/internal/database/ent/schema/nonce.go
new file mode 100644
index 00000000..86baceaa
--- /dev/null
+++ b/internal/database/ent/schema/nonce.go
@@ -0,0 +1,31 @@
+package schema
+
+import (
+	"entgo.io/ent"
+	"entgo.io/ent/schema/field"
+	"entgo.io/ent/schema/index"
+)
+
+type AuthNonce struct {
+	ent.Schema
+}
+
+func (AuthNonce) Fields() []ent.Field {
+	return append(defaultFields,
+		field.Bool("active"),
+		field.Time("expires_at").Immutable(),
+		field.String("identifier").NotEmpty().Immutable(),
+		field.String("public_id").NotEmpty().Immutable().Unique(),
+		field.JSON("metadata", map[string]string{}),
+	)
+}
+
+func (AuthNonce) Edges() []ent.Edge {
+	return nil
+}
+
+func (AuthNonce) Indexes() []ent.Index {
+	return []ent.Index{
+		index.Fields("public_id", "active", "expires_at"),
+	}
+}
diff --git a/internal/database/ent/schema/session.go b/internal/database/ent/schema/session.go
new file mode 100644
index 00000000..d9c20e7d
--- /dev/null
+++ b/internal/database/ent/schema/session.go
@@ -0,0 +1,33 @@
+package schema
+
+import (
+	"entgo.io/ent"
+	"entgo.io/ent/schema/edge"
+	"entgo.io/ent/schema/field"
+	"entgo.io/ent/schema/index"
+)
+
+type Session struct {
+	ent.Schema
+}
+
+func (Session) Fields() []ent.Field {
+	return append(defaultFields,
+		field.Time("expires_at"),
+		field.String("user_id").Immutable(),
+		field.String("public_id").NotEmpty().Immutable().Unique(),
+		field.JSON("metadata", map[string]string{}),
+	)
+}
+
+func (Session) Edges() []ent.Edge {
+	return []ent.Edge{
+		edge.From("user", User.Type).Ref("sessions").Field("user_id").Required().Immutable().Unique(),
+	}
+}
+
+func (Session) Indexes() []ent.Index {
+	return []ent.Index{
+		index.Fields("public_id", "expires_at"),
+	}
+}
diff --git a/internal/database/ent/schema/user.go b/internal/database/ent/schema/user.go
index aec9bc0f..338c0e79 100644
--- a/internal/database/ent/schema/user.go
+++ b/internal/database/ent/schema/user.go
@@ -2,6 +2,7 @@ package schema
 
 import (
 	"entgo.io/ent"
+	"entgo.io/ent/dialect/entsql"
 	"entgo.io/ent/schema/edge"
 	"entgo.io/ent/schema/field"
 	"entgo.io/ent/schema/index"
@@ -25,6 +26,7 @@ func (User) Fields() []ent.Field {
 			Default(timeNow).
 			UpdateDefault(timeNow),
 		//
+		field.String("username").Default(""),
 		field.String("permissions").Default(""),
 		field.Strings("feature_flags").Optional(),
 	}
@@ -33,15 +35,17 @@ func (User) Fields() []ent.Field {
 // Edges of the User.
 func (User) Edges() []ent.Edge {
 	return []ent.Edge{
-		edge.To("discord_interactions", DiscordInteraction.Type),
-		edge.To("subscriptions", UserSubscription.Type),
-		edge.To("connections", UserConnection.Type),
-		edge.To("content", UserContent.Type),
+		edge.To("discord_interactions", DiscordInteraction.Type).Annotations(entsql.OnDelete(entsql.Cascade)),
+		edge.To("subscriptions", UserSubscription.Type).Annotations(entsql.OnDelete(entsql.Cascade)),
+		edge.To("connections", UserConnection.Type).Annotations(entsql.OnDelete(entsql.Cascade)),
+		edge.To("content", UserContent.Type).Annotations(entsql.OnDelete(entsql.Cascade)),
+		edge.To("sessions", Session.Type).Annotations(entsql.OnDelete(entsql.Cascade)),
 	}
 }
 
 func (User) Indexes() []ent.Index {
 	return []ent.Index{
 		index.Fields("id"),
+		index.Fields("username"),
 	}
 }
diff --git a/internal/database/models/nonce.go b/internal/database/models/nonce.go
new file mode 100644
index 00000000..deb191c7
--- /dev/null
+++ b/internal/database/models/nonce.go
@@ -0,0 +1,34 @@
+package models
+
+import (
+	"time"
+
+	"github.com/pkg/errors"
+)
+
+var ErrInvalidNonce = errors.New("invalid nonce")
+var ErrNonceExpired = errors.New("nonce expired")
+
+type AuthNonce struct {
+	ID string
+
+	Active     bool
+	PublicID   string
+	Identifier string
+
+	CreatedAt time.Time
+	UpdatedAt time.Time
+	ExpiresAt time.Time
+
+	Meta map[string]string
+}
+
+func (n AuthNonce) Valid() error {
+	if n.ExpiresAt.Before(time.Now()) {
+		return ErrNonceExpired
+	}
+	if n.Active && n.PublicID != "" && n.Identifier != "" {
+		return nil
+	}
+	return ErrInvalidNonce
+}
diff --git a/internal/database/models/session.go b/internal/database/models/session.go
new file mode 100644
index 00000000..fa93af6a
--- /dev/null
+++ b/internal/database/models/session.go
@@ -0,0 +1,35 @@
+package models
+
+import (
+	"time"
+
+	"github.com/pkg/errors"
+)
+
+var (
+	ErrSessionExpired = errors.New("session expired")
+	ErrSessionInvalid = errors.New("session invalid")
+)
+
+type Session struct {
+	ID string
+
+	UserID   string
+	PublicID string
+
+	CreatedAt time.Time
+	UpdatedAt time.Time
+	ExpiresAt time.Time
+
+	Meta map[string]string
+}
+
+func (n Session) Valid() error {
+	if n.ExpiresAt.Before(time.Now()) {
+		return ErrSessionExpired
+	}
+	if n.UserID != "" && n.PublicID != "" {
+		return nil
+	}
+	return ErrSessionInvalid
+}
diff --git a/internal/logic/strings.go b/internal/logic/strings.go
new file mode 100644
index 00000000..8d139873
--- /dev/null
+++ b/internal/logic/strings.go
@@ -0,0 +1,15 @@
+package logic
+
+import (
+	"crypto/rand"
+	"fmt"
+)
+
+func RandomString(length int) (string, error) {
+	data := make([]byte, length)
+	_, err := rand.Read(data)
+	if err != nil {
+		return "", err
+	}
+	return fmt.Sprintf("%x", data), nil
+}
diff --git a/tests/static_database.go b/tests/static_database.go
index 6c2a4366..d2abba2c 100644
--- a/tests/static_database.go
+++ b/tests/static_database.go
@@ -169,3 +169,26 @@ func (c *staticTestingDatabase) GetDiscordInteraction(ctx context.Context, refer
 func (c *staticTestingDatabase) DeleteExpiredInteractions(ctx context.Context, expiration time.Time) error {
 	return errors.New("DeleteExpiredInteractions not implemented")
 }
+
+func (c *staticTestingDatabase) CreateAuthNonce(ctx context.Context, publicID, identifier string, expiresAt time.Time, meta map[string]string) (models.AuthNonce, error) {
+	return models.AuthNonce{}, errors.New("CreateAuthNonce not implemented")
+}
+func (c *staticTestingDatabase) FindAuthNonce(ctx context.Context, publicID string) (models.AuthNonce, error) {
+	return models.AuthNonce{}, errors.New("FindAuthNonce not implemented")
+}
+func (c *staticTestingDatabase) SetAuthNonceActive(ctx context.Context, nonceID string, active bool) error {
+	return errors.New("SetAuthNonceActive not implemented")
+}
+
+func (c *staticTestingDatabase) CreateSession(ctx context.Context, publicID, userID string, expiresAt time.Time, meta map[string]string) (models.Session, error) {
+	return models.Session{}, errors.New("CreateSession not implementer")
+}
+func (c *staticTestingDatabase) SetSessionExpiresAt(ctx context.Context, sessionID string, expiresAt time.Time) error {
+	return errors.New("SetSessionExpiresAt not implementer")
+}
+func (c *staticTestingDatabase) FindSession(ctx context.Context, publicID string) (models.Session, error) {
+	return models.Session{}, errors.New("FindSession not implementer")
+}
+func (c *staticTestingDatabase) UserFromSession(ctx context.Context, publicID string) (models.User, error) {
+	return models.User{}, errors.New("UserFromSession not implementer")
+}

From 4e60c16b55c44a6a8264a7a5906026a83f360f32 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 4 Jul 2024 10:47:50 -0400
Subject: [PATCH 247/341] mostly formatting and ui

---
 cmd/frontend/components/logo_templ.go         |  22 +-
 cmd/frontend/components/navbar.templ          |  67 +++++
 cmd/frontend/components/navbar_templ.go       | 193 +++++++++++++++
 .../components/widget/default_templ.go        | 118 +++++----
 .../components/widget/widget_templ.go         |  22 +-
 cmd/frontend/handler/context.go               |  10 +
 cmd/frontend/handlers.go                      |  12 +
 cmd/frontend/layouts/main.templ               |  42 ++--
 cmd/frontend/layouts/main_templ.go            |  69 ++++--
 cmd/frontend/logic/strings.go                 |   8 +
 cmd/frontend/routes/app/index_templ.go        |  22 +-
 cmd/frontend/routes/app/widgets.templ         | 102 ++++++++
 cmd/frontend/routes/app/widgets_templ.go      | 233 ++++++++++++++++++
 cmd/frontend/routes/errors.templ              |  11 +-
 cmd/frontend/routes/errors_templ.go           |  53 ++--
 cmd/frontend/routes/index.templ               |  54 ++--
 cmd/frontend/routes/index_templ.go            | 224 +++++++++++++++--
 cmd/frontend/routes/widget/configure.templ    |  19 +-
 cmd/frontend/routes/widget/configure_templ.go |  43 ++--
 cmd/frontend/routes/widget/live.templ         |  50 +++-
 cmd/frontend/routes/widget/live_templ.go      |  70 ++++--
 cmd/frontend/routes/widget/personal.templ     |  76 ++++++
 cmd/frontend/routes/widget/personal_templ.go  |  97 ++++++++
 internal/database/models/user.go              |  40 ++-
 internal/database/models/widget_options.go    |  28 +++
 tests/static_data.go                          |  13 +
 tests/static_database.go                      |  25 +-
 27 files changed, 1467 insertions(+), 256 deletions(-)
 create mode 100644 cmd/frontend/components/navbar.templ
 create mode 100644 cmd/frontend/components/navbar_templ.go
 create mode 100644 cmd/frontend/logic/strings.go
 create mode 100644 cmd/frontend/routes/app/widgets.templ
 create mode 100644 cmd/frontend/routes/app/widgets_templ.go
 create mode 100644 cmd/frontend/routes/widget/personal.templ
 create mode 100644 cmd/frontend/routes/widget/personal_templ.go
 create mode 100644 internal/database/models/widget_options.go

diff --git a/cmd/frontend/components/logo_templ.go b/cmd/frontend/components/logo_templ.go
index fe08297b..7e4f5f4d 100644
--- a/cmd/frontend/components/logo_templ.go
+++ b/cmd/frontend/components/logo_templ.go
@@ -1,23 +1,26 @@
 // Code generated by templ - DO NOT EDIT.
 
-// templ: version: v0.2.696
+// templ: version: v0.2.731
 package components
 
 //lint:file-ignore SA4006 This context is only used if a nested component is present.
 
 import "github.com/a-h/templ"
-import "context"
-import "io"
-import "bytes"
+import templruntime "github.com/a-h/templ/runtime"
 
 import "fmt"
 
 func Logo(size string) templ.Component {
-	return templ.ComponentFunc(func(ctx context.Context, templ_7745c5c3_W io.Writer) (templ_7745c5c3_Err error) {
-		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templ_7745c5c3_W.(*bytes.Buffer)
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
-			templ_7745c5c3_Buffer = templ.GetBuffer()
-			defer templ.ReleaseBuffer(templ_7745c5c3_Buffer)
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
@@ -42,9 +45,6 @@ func Logo(size string) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		if !templ_7745c5c3_IsBuffer {
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteTo(templ_7745c5c3_W)
-		}
 		return templ_7745c5c3_Err
 	})
 }
diff --git a/cmd/frontend/components/navbar.templ b/cmd/frontend/components/navbar.templ
new file mode 100644
index 00000000..09b4fa99
--- /dev/null
+++ b/cmd/frontend/components/navbar.templ
@@ -0,0 +1,67 @@
+package components
+
+import (
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/cmd/frontend/logic"
+	"os"
+	"strings"
+)
+
+var appName = os.Getenv("WEBAPP_NAME")
+
+type navbarProps struct {
+	authenticated bool
+	path          string
+}
+
+var Navbar handler.Partial = func(ctx *handler.Context) (templ.Component, error) {
+	var props navbarProps
+	props.path = ctx.URL().Path
+
+	user, err := ctx.SessionUser()
+	if err == nil {
+		// props.authenticated = user.ID != ""
+		_ = user
+	}
+
+	return navbar(props), nil
+}
+
+templ navbar(props navbarProps) {
+	<div class="no-animation" hx-boost="true">
+		<div class="navbar bg-base-100 gap-1">
+			<div class="navbar-start gap-1">
+				@Logo("32")
+				<div class="flex-1">
+					<a class="btn btn-ghost text-xl" href="/">Aftermath</a>
+				</div>
+			</div>
+			<div class="navbar-center">
+				<div class="form-control">
+					<input type="text" placeholder="Search Players" class="input input-bordered w-24 md:w-auto"/>
+				</div>
+			</div>
+			<ul class="navbar-end menu menu-horizontal px-1 gap-1">
+				<li><a href="/widget" class={ logic.StringIfElse("active", "", props.path == "/widget") }>Widget</a></li>
+				<li><a href="/login" class={ logic.StringIfElse("btn active", "btn", props.path == "/login") }>Login</a></li>
+			</ul>
+		</div>
+	</div>
+}
+
+templ navMenuLink(label, href, currentPath string) {
+	<a href={ templ.URL(href) } class={ navLinkClass(href, currentPath) }>{ label }</a>
+}
+
+func navLinkClass(path, requiredPath string) string {
+	base := "underline-offset-4 link"
+
+	if !strings.HasSuffix(path, "/") {
+		path += "/"
+	}
+	if path == requiredPath {
+		return base
+	}
+
+	return base + " " + "link-hover"
+}
diff --git a/cmd/frontend/components/navbar_templ.go b/cmd/frontend/components/navbar_templ.go
new file mode 100644
index 00000000..2d384ef6
--- /dev/null
+++ b/cmd/frontend/components/navbar_templ.go
@@ -0,0 +1,193 @@
+// Code generated by templ - DO NOT EDIT.
+
+// templ: version: v0.2.731
+package components
+
+//lint:file-ignore SA4006 This context is only used if a nested component is present.
+
+import "github.com/a-h/templ"
+import templruntime "github.com/a-h/templ/runtime"
+
+import (
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/cmd/frontend/logic"
+	"os"
+	"strings"
+)
+
+var appName = os.Getenv("WEBAPP_NAME")
+
+type navbarProps struct {
+	authenticated bool
+	path          string
+}
+
+var Navbar handler.Partial = func(ctx *handler.Context) (templ.Component, error) {
+	var props navbarProps
+	props.path = ctx.URL().Path
+
+	user, err := ctx.SessionUser()
+	if err == nil {
+		// props.authenticated = user.ID != ""
+		_ = user
+	}
+
+	return navbar(props), nil
+}
+
+func navbar(props navbarProps) templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var1 == nil {
+			templ_7745c5c3_Var1 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"no-animation\" hx-boost=\"true\"><div class=\"navbar bg-base-100 gap-1\"><div class=\"navbar-start gap-1\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = Logo("32").Render(ctx, templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex-1\"><a class=\"btn btn-ghost text-xl\" href=\"/\">Aftermath</a></div></div><div class=\"navbar-center\"><div class=\"form-control\"><input type=\"text\" placeholder=\"Search Players\" class=\"input input-bordered w-24 md:w-auto\"></div></div><ul class=\"navbar-end menu menu-horizontal px-1 gap-1\"><li>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var2 = []any{logic.StringIfElse("active", "", props.path == "/widget")}
+		templ_7745c5c3_Err = templ.RenderCSSItems(ctx, templ_7745c5c3_Buffer, templ_7745c5c3_Var2...)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<a href=\"/widget\" class=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var3 string
+		templ_7745c5c3_Var3, templ_7745c5c3_Err = templ.JoinStringErrs(templ.CSSClasses(templ_7745c5c3_Var2).String())
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/navbar.templ`, Line: 1, Col: 0}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var3))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\">Widget</a></li><li>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var4 = []any{logic.StringIfElse("btn active", "btn", props.path == "/login")}
+		templ_7745c5c3_Err = templ.RenderCSSItems(ctx, templ_7745c5c3_Buffer, templ_7745c5c3_Var4...)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<a href=\"/login\" class=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var5 string
+		templ_7745c5c3_Var5, templ_7745c5c3_Err = templ.JoinStringErrs(templ.CSSClasses(templ_7745c5c3_Var4).String())
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/navbar.templ`, Line: 1, Col: 0}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var5))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\">Login</a></li></ul></div></div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return templ_7745c5c3_Err
+	})
+}
+
+func navMenuLink(label, href, currentPath string) templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var6 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var6 == nil {
+			templ_7745c5c3_Var6 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		var templ_7745c5c3_Var7 = []any{navLinkClass(href, currentPath)}
+		templ_7745c5c3_Err = templ.RenderCSSItems(ctx, templ_7745c5c3_Buffer, templ_7745c5c3_Var7...)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<a href=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var8 templ.SafeURL = templ.URL(href)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(string(templ_7745c5c3_Var8)))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\" class=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var9 string
+		templ_7745c5c3_Var9, templ_7745c5c3_Err = templ.JoinStringErrs(templ.CSSClasses(templ_7745c5c3_Var7).String())
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/navbar.templ`, Line: 1, Col: 0}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var9))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var10 string
+		templ_7745c5c3_Var10, templ_7745c5c3_Err = templ.JoinStringErrs(label)
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/navbar.templ`, Line: 53, Col: 78}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var10))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</a>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return templ_7745c5c3_Err
+	})
+}
+
+func navLinkClass(path, requiredPath string) string {
+	base := "underline-offset-4 link"
+
+	if !strings.HasSuffix(path, "/") {
+		path += "/"
+	}
+	if path == requiredPath {
+		return base
+	}
+
+	return base + " " + "link-hover"
+}
diff --git a/cmd/frontend/components/widget/default_templ.go b/cmd/frontend/components/widget/default_templ.go
index a90f5fdb..fc252866 100644
--- a/cmd/frontend/components/widget/default_templ.go
+++ b/cmd/frontend/components/widget/default_templ.go
@@ -1,14 +1,12 @@
 // Code generated by templ - DO NOT EDIT.
 
-// templ: version: v0.2.696
+// templ: version: v0.2.731
 package widget
 
 //lint:file-ignore SA4006 This context is only used if a nested component is present.
 
 import "github.com/a-h/templ"
-import "context"
-import "io"
-import "bytes"
+import templruntime "github.com/a-h/templ/runtime"
 
 import "fmt"
 import "github.com/cufee/aftermath/internal/stats/prepare/session/v1"
@@ -54,11 +52,16 @@ func (w widget) defaultWidget() templ.Component {
 }
 
 func (w defaultWidget) Render() templ.Component {
-	return templ.ComponentFunc(func(ctx context.Context, templ_7745c5c3_W io.Writer) (templ_7745c5c3_Err error) {
-		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templ_7745c5c3_W.(*bytes.Buffer)
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
-			templ_7745c5c3_Buffer = templ.GetBuffer()
-			defer templ.ReleaseBuffer(templ_7745c5c3_Buffer)
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
@@ -98,19 +101,21 @@ func (w defaultWidget) Render() templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		if !templ_7745c5c3_IsBuffer {
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteTo(templ_7745c5c3_W)
-		}
 		return templ_7745c5c3_Err
 	})
 }
 
 func (w defaultWidget) overviewCard(card session.OverviewCard) templ.Component {
-	return templ.ComponentFunc(func(ctx context.Context, templ_7745c5c3_W io.Writer) (templ_7745c5c3_Err error) {
-		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templ_7745c5c3_W.(*bytes.Buffer)
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
-			templ_7745c5c3_Buffer = templ.GetBuffer()
-			defer templ.ReleaseBuffer(templ_7745c5c3_Buffer)
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var2 := templ.GetChildren(ctx)
@@ -173,19 +178,21 @@ func (w defaultWidget) overviewCard(card session.OverviewCard) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		if !templ_7745c5c3_IsBuffer {
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteTo(templ_7745c5c3_W)
-		}
 		return templ_7745c5c3_Err
 	})
 }
 
 func (w defaultWidget) vehicleCard(card vehicleExtended) templ.Component {
-	return templ.ComponentFunc(func(ctx context.Context, templ_7745c5c3_W io.Writer) (templ_7745c5c3_Err error) {
-		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templ_7745c5c3_W.(*bytes.Buffer)
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
-			templ_7745c5c3_Buffer = templ.GetBuffer()
-			defer templ.ReleaseBuffer(templ_7745c5c3_Buffer)
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var6 := templ.GetChildren(ctx)
@@ -261,19 +268,21 @@ func (w defaultWidget) vehicleCard(card vehicleExtended) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		if !templ_7745c5c3_IsBuffer {
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteTo(templ_7745c5c3_W)
-		}
 		return templ_7745c5c3_Err
 	})
 }
 
 func (w defaultWidget) vehicleLegendCard(blocks []common.StatsBlock[session.BlockData]) templ.Component {
-	return templ.ComponentFunc(func(ctx context.Context, templ_7745c5c3_W io.Writer) (templ_7745c5c3_Err error) {
-		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templ_7745c5c3_W.(*bytes.Buffer)
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
-			templ_7745c5c3_Buffer = templ.GetBuffer()
-			defer templ.ReleaseBuffer(templ_7745c5c3_Buffer)
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var11 := templ.GetChildren(ctx)
@@ -330,19 +339,21 @@ func (w defaultWidget) vehicleLegendCard(blocks []common.StatsBlock[session.Bloc
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		if !templ_7745c5c3_IsBuffer {
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteTo(templ_7745c5c3_W)
-		}
 		return templ_7745c5c3_Err
 	})
 }
 
 func (w defaultWidget) overviewColumn(column session.OverviewColumn) templ.Component {
-	return templ.ComponentFunc(func(ctx context.Context, templ_7745c5c3_W io.Writer) (templ_7745c5c3_Err error) {
-		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templ_7745c5c3_W.(*bytes.Buffer)
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
-			templ_7745c5c3_Buffer = templ.GetBuffer()
-			defer templ.ReleaseBuffer(templ_7745c5c3_Buffer)
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var15 := templ.GetChildren(ctx)
@@ -371,19 +382,21 @@ func (w defaultWidget) overviewColumn(column session.OverviewColumn) templ.Compo
 				return templ_7745c5c3_Err
 			}
 		}
-		if !templ_7745c5c3_IsBuffer {
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteTo(templ_7745c5c3_W)
-		}
 		return templ_7745c5c3_Err
 	})
 }
 
 func (w defaultWidget) specialOverviewColumn(column session.OverviewColumn) templ.Component {
-	return templ.ComponentFunc(func(ctx context.Context, templ_7745c5c3_W io.Writer) (templ_7745c5c3_Err error) {
-		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templ_7745c5c3_W.(*bytes.Buffer)
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
-			templ_7745c5c3_Buffer = templ.GetBuffer()
-			defer templ.ReleaseBuffer(templ_7745c5c3_Buffer)
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var16 := templ.GetChildren(ctx)
@@ -451,19 +464,21 @@ func (w defaultWidget) specialOverviewColumn(column session.OverviewColumn) temp
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		if !templ_7745c5c3_IsBuffer {
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteTo(templ_7745c5c3_W)
-		}
 		return templ_7745c5c3_Err
 	})
 }
 
 func (w defaultWidget) block(block common.StatsBlock[session.BlockData], style styleOptions) templ.Component {
-	return templ.ComponentFunc(func(ctx context.Context, templ_7745c5c3_W io.Writer) (templ_7745c5c3_Err error) {
-		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templ_7745c5c3_W.(*bytes.Buffer)
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
-			templ_7745c5c3_Buffer = templ.GetBuffer()
-			defer templ.ReleaseBuffer(templ_7745c5c3_Buffer)
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var19 := templ.GetChildren(ctx)
@@ -530,9 +545,6 @@ func (w defaultWidget) block(block common.StatsBlock[session.BlockData], style s
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		if !templ_7745c5c3_IsBuffer {
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteTo(templ_7745c5c3_W)
-		}
 		return templ_7745c5c3_Err
 	})
 }
diff --git a/cmd/frontend/components/widget/widget_templ.go b/cmd/frontend/components/widget/widget_templ.go
index 33366abe..f4802841 100644
--- a/cmd/frontend/components/widget/widget_templ.go
+++ b/cmd/frontend/components/widget/widget_templ.go
@@ -1,14 +1,12 @@
 // Code generated by templ - DO NOT EDIT.
 
-// templ: version: v0.2.696
+// templ: version: v0.2.731
 package widget
 
 //lint:file-ignore SA4006 This context is only used if a nested component is present.
 
 import "github.com/a-h/templ"
-import "context"
-import "io"
-import "bytes"
+import templruntime "github.com/a-h/templ/runtime"
 
 import "github.com/cufee/aftermath/cmd/frontend/logic"
 import "fmt"
@@ -82,11 +80,16 @@ type widget struct {
 }
 
 func (w widget) Render() templ.Component {
-	return templ.ComponentFunc(func(ctx context.Context, templ_7745c5c3_W io.Writer) (templ_7745c5c3_Err error) {
-		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templ_7745c5c3_W.(*bytes.Buffer)
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
-			templ_7745c5c3_Buffer = templ.GetBuffer()
-			defer templ.ReleaseBuffer(templ_7745c5c3_Buffer)
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
@@ -154,9 +157,6 @@ func (w widget) Render() templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		if !templ_7745c5c3_IsBuffer {
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteTo(templ_7745c5c3_W)
-		}
 		return templ_7745c5c3_Err
 	})
 }
diff --git a/cmd/frontend/handler/context.go b/cmd/frontend/handler/context.go
index 956b2a9b..e8d02055 100644
--- a/cmd/frontend/handler/context.go
+++ b/cmd/frontend/handler/context.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"net/http"
 	"net/url"
+	"os"
 	"strings"
 
 	"github.com/a-h/templ"
@@ -17,6 +18,8 @@ import (
 	"github.com/rs/zerolog/log"
 )
 
+var devMode = os.Getenv("AUTH_DEV_MODE") == "true"
+
 type Servable interface {
 	Serve(ctx *Context) error
 }
@@ -59,6 +62,9 @@ func (ctx *Context) Form(key string) string {
 func (ctx *Context) Path(key string) string {
 	return ctx.r.PathValue(key)
 }
+func (ctx *Context) URL() *url.URL {
+	return ctx.r.URL
+}
 func (ctx *Context) RealIP() (string, bool) {
 	if ip := ctx.r.Header.Get("X-Forwarded-For"); ip != "" {
 		return ip, true
@@ -83,6 +89,10 @@ func (ctx *Context) SessionUser() (*models.User, error) {
 	if ctx.user != nil {
 		return ctx.user, nil
 	}
+	if devMode {
+		user, _ := ctx.Database().UserFromSession(ctx.Context, "dev-user")
+		return &user, nil
+	}
 
 	cookie, err := ctx.Cookie(auth.SessionCookieName)
 	if err != nil || cookie == nil {
diff --git a/cmd/frontend/handlers.go b/cmd/frontend/handlers.go
index 640d0341..62dfec16 100644
--- a/cmd/frontend/handlers.go
+++ b/cmd/frontend/handlers.go
@@ -67,11 +67,23 @@ func Handlers(core core.Client) ([]server.Handler, error) {
 			Path: get("/widget/{accountId}/live"),
 			Func: handler.Chain(core, widget.LiveWidget),
 		},
+		{
+			Path: get("/widget/personal"),
+			Func: redirect("/app/widget"),
+		},
+		{
+			Path: get("/widget/personal/{widgetId}/live"),
+			Func: handler.Chain(core, widget.PersonalLiveWidget),
+		},
 		// app routes
 		{
 			Path: get("/app"),
 			Func: handler.Chain(core, app.Index, middleware.SessionCheck),
 		},
+		{
+			Path: get("/app/widgets"),
+			Func: handler.Chain(core, app.Widgets, middleware.SessionCheck),
+		},
 		// api routes
 		{
 			Path: get("/api/auth/discord"),
diff --git a/cmd/frontend/layouts/main.templ b/cmd/frontend/layouts/main.templ
index 6a10ee55..252ea782 100644
--- a/cmd/frontend/layouts/main.templ
+++ b/cmd/frontend/layouts/main.templ
@@ -1,17 +1,24 @@
 package layouts
 
 import (
-	"os"
+	"github.com/cufee/aftermath/cmd/frontend/components"
 	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/cmd/frontend/logic"
+	"os"
 )
 
 var appName = os.Getenv("WEBAPP_NAME")
 
 var Main handler.Layout = func(ctx *handler.Context, children ...templ.Component) (templ.Component, error) {
-	return main(children...), nil
+	navbar, err := components.Navbar(ctx)
+	if err != nil {
+		return nil, ctx.Error(err, "failed to render a page")
+	}
+
+	return main(navbar, children...), nil
 }
 
-templ main(children ...templ.Component) {
+templ main(navbar templ.Component, children ...templ.Component) {
 	<!DOCTYPE html>
 	<html lang="en" data-theme="dark">
 		<head>
@@ -23,23 +30,12 @@ templ main(children ...templ.Component) {
 			<script src="https://unpkg.com/htmx.org/dist/ext/head-support.js"></script>
 			<script src="https://unpkg.com/htmx.org@1.9.12/dist/ext/multi-swap.js"></script>
 			<script src="https://cdn.tailwindcss.com"></script>
-			<script>
-				tailwind.config = {
-					theme: {
-						borderRadius: {
-							"sm": "10px",
-							"md": "15px",
-							"lg": "20px",
-							"xl": "25px",
-							'full': '9999px',
-						}
-					}
-				}
-			</script>
+			@logic.EmbedMinifiedScript(tailwindConfig())
 			<title>{ appName }</title>
 		</head>
 		<body hx-ext="multi-swap,head-support">
 			<main class="mx-auto min-h-screen max-w-7xl p-2 flex flex-col gap-2 underline-offset-4">
+				@navbar
 				for _, render := range children {
 					@render
 				}
@@ -56,3 +52,17 @@ templ main(children ...templ.Component) {
 		</body>
 	</html>
 }
+
+script tailwindConfig() {
+	tailwind.config = {
+		theme: {
+			borderRadius: {
+				"sm": "10px",
+				"md": "15px",
+				"lg": "20px",
+				"xl": "25px",
+				'full': '9999px',
+			}
+		}
+	}
+}
diff --git a/cmd/frontend/layouts/main_templ.go b/cmd/frontend/layouts/main_templ.go
index 3b602fb6..f38cdafb 100644
--- a/cmd/frontend/layouts/main_templ.go
+++ b/cmd/frontend/layouts/main_templ.go
@@ -1,32 +1,42 @@
 // Code generated by templ - DO NOT EDIT.
 
-// templ: version: v0.2.696
+// templ: version: v0.2.731
 package layouts
 
 //lint:file-ignore SA4006 This context is only used if a nested component is present.
 
 import "github.com/a-h/templ"
-import "context"
-import "io"
-import "bytes"
+import templruntime "github.com/a-h/templ/runtime"
 
 import (
+	"github.com/cufee/aftermath/cmd/frontend/components"
 	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/cmd/frontend/logic"
 	"os"
 )
 
 var appName = os.Getenv("WEBAPP_NAME")
 
 var Main handler.Layout = func(ctx *handler.Context, children ...templ.Component) (templ.Component, error) {
-	return main(children...), nil
+	navbar, err := components.Navbar(ctx)
+	if err != nil {
+		return nil, ctx.Error(err, "failed to render a page")
+	}
+
+	return main(navbar, children...), nil
 }
 
-func main(children ...templ.Component) templ.Component {
-	return templ.ComponentFunc(func(ctx context.Context, templ_7745c5c3_W io.Writer) (templ_7745c5c3_Err error) {
-		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templ_7745c5c3_W.(*bytes.Buffer)
+func main(navbar templ.Component, children ...templ.Component) templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
-			templ_7745c5c3_Buffer = templ.GetBuffer()
-			defer templ.ReleaseBuffer(templ_7745c5c3_Buffer)
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
@@ -34,14 +44,22 @@ func main(children ...templ.Component) templ.Component {
 			templ_7745c5c3_Var1 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<!doctype html><html lang=\"en\" data-theme=\"dark\"><head><meta charset=\"utf-8\"><meta name=\"color-scheme\" content=\"light\"><meta name=\"viewport\" content=\"width=device-width, initial-scale=1\"><link href=\"https://cdn.jsdelivr.net/npm/daisyui@4.11.1/dist/full.min.css\" rel=\"stylesheet\" type=\"text/css\"><script src=\"https://unpkg.com/htmx.org@1.9.12\"></script><script src=\"https://unpkg.com/htmx.org/dist/ext/head-support.js\"></script><script src=\"https://unpkg.com/htmx.org@1.9.12/dist/ext/multi-swap.js\"></script><script src=\"https://cdn.tailwindcss.com\"></script><script>\n\t\t\t\ttailwind.config = {\n\t\t\t\t\ttheme: {\n\t\t\t\t\t\tborderRadius: {\n\t\t\t\t\t\t\t\"sm\": \"10px\",\n\t\t\t\t\t\t\t\"md\": \"15px\",\n\t\t\t\t\t\t\t\"lg\": \"20px\",\n\t\t\t\t\t\t\t\"xl\": \"25px\",\n\t\t\t\t\t\t\t'full': '9999px',\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t</script><title>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<!doctype html><html lang=\"en\" data-theme=\"dark\"><head><meta charset=\"utf-8\"><meta name=\"color-scheme\" content=\"light\"><meta name=\"viewport\" content=\"width=device-width, initial-scale=1\"><link href=\"https://cdn.jsdelivr.net/npm/daisyui@4.11.1/dist/full.min.css\" rel=\"stylesheet\" type=\"text/css\"><script src=\"https://unpkg.com/htmx.org@1.9.12\"></script><script src=\"https://unpkg.com/htmx.org/dist/ext/head-support.js\"></script><script src=\"https://unpkg.com/htmx.org@1.9.12/dist/ext/multi-swap.js\"></script><script src=\"https://cdn.tailwindcss.com\"></script>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = logic.EmbedMinifiedScript(tailwindConfig()).Render(ctx, templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<title>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var2 string
 		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(appName)
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/layouts/main.templ`, Line: 39, Col: 19}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/layouts/main.templ`, Line: 34, Col: 19}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
 		if templ_7745c5c3_Err != nil {
@@ -51,6 +69,10 @@ func main(children ...templ.Component) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
+		templ_7745c5c3_Err = navbar.Render(ctx, templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
 		for _, render := range children {
 			templ_7745c5c3_Err = render.Render(ctx, templ_7745c5c3_Buffer)
 			if templ_7745c5c3_Err != nil {
@@ -61,9 +83,26 @@ func main(children ...templ.Component) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		if !templ_7745c5c3_IsBuffer {
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteTo(templ_7745c5c3_W)
-		}
 		return templ_7745c5c3_Err
 	})
 }
+
+func tailwindConfig() templ.ComponentScript {
+	return templ.ComponentScript{
+		Name: `__templ_tailwindConfig_0472`,
+		Function: `function __templ_tailwindConfig_0472(){tailwind.config = {
+		theme: {
+			borderRadius: {
+				"sm": "10px",
+				"md": "15px",
+				"lg": "20px",
+				"xl": "25px",
+				'full': '9999px',
+			}
+		}
+	}
+}`,
+		Call:       templ.SafeScript(`__templ_tailwindConfig_0472`),
+		CallInline: templ.SafeScriptInline(`__templ_tailwindConfig_0472`),
+	}
+}
diff --git a/cmd/frontend/logic/strings.go b/cmd/frontend/logic/strings.go
new file mode 100644
index 00000000..4fba48cd
--- /dev/null
+++ b/cmd/frontend/logic/strings.go
@@ -0,0 +1,8 @@
+package logic
+
+func StringIfElse(onTrue, onFalse string, condition bool) string {
+	if condition {
+		return onTrue
+	}
+	return onFalse
+}
diff --git a/cmd/frontend/routes/app/index_templ.go b/cmd/frontend/routes/app/index_templ.go
index 16e3e940..4cc53393 100644
--- a/cmd/frontend/routes/app/index_templ.go
+++ b/cmd/frontend/routes/app/index_templ.go
@@ -1,14 +1,12 @@
 // Code generated by templ - DO NOT EDIT.
 
-// templ: version: v0.2.696
+// templ: version: v0.2.731
 package app
 
 //lint:file-ignore SA4006 This context is only used if a nested component is present.
 
 import "github.com/a-h/templ"
-import "context"
-import "io"
-import "bytes"
+import templruntime "github.com/a-h/templ/runtime"
 
 import "net/http"
 import "github.com/cufee/aftermath/internal/database/models"
@@ -24,11 +22,16 @@ var Index handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Compo
 }
 
 func index(user *models.User) templ.Component {
-	return templ.ComponentFunc(func(ctx context.Context, templ_7745c5c3_W io.Writer) (templ_7745c5c3_Err error) {
-		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templ_7745c5c3_W.(*bytes.Buffer)
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
-			templ_7745c5c3_Buffer = templ.GetBuffer()
-			defer templ.ReleaseBuffer(templ_7745c5c3_Buffer)
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
@@ -53,9 +56,6 @@ func index(user *models.User) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		if !templ_7745c5c3_IsBuffer {
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteTo(templ_7745c5c3_W)
-		}
 		return templ_7745c5c3_Err
 	})
 }
diff --git a/cmd/frontend/routes/app/widgets.templ b/cmd/frontend/routes/app/widgets.templ
new file mode 100644
index 00000000..00b35f75
--- /dev/null
+++ b/cmd/frontend/routes/app/widgets.templ
@@ -0,0 +1,102 @@
+package app 
+
+import (
+	"fmt"
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/cmd/frontend/layouts"
+	"github.com/cufee/aftermath/cmd/frontend/logic"
+	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/pkg/errors"
+	"net/http"
+)
+
+var Widgets handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
+	user, err := ctx.SessionUser()
+	if err != nil {
+		return nil, nil, ctx.Redirect("/login", http.StatusTemporaryRedirect)
+	}
+
+	extendedUser, err := ctx.Database().GetUserByID(ctx, user.ID, database.WithConnections())
+	if err != nil {
+		return nil, nil, ctx.Redirect("/login", http.StatusTemporaryRedirect)
+	}
+
+	var accountIDs []string
+	connections, _ := extendedUser.FilterConnections(models.ConnectionTypeWargaming, nil)
+	for _, conn := range connections {
+		accountIDs = append(accountIDs, conn.ReferenceID)
+	}
+
+	var accounts []models.Account
+	if len(accountIDs) > 0 {
+		accounts, err = ctx.Database().GetAccounts(ctx.Context, accountIDs)
+		if err != nil {
+			return nil, nil, errors.New("invalid account id")
+		}
+	}
+
+	return layouts.Main, widgetConfiguratorPage(accounts, "account1"), nil
+}
+
+templ widgetConfiguratorPage(accounts []models.Account, selectedId string) {
+	<div class="flex flex-row justify-center gap-4 flex-wrap min-w-max">
+		<div class="flex flex-col gap-2">
+			<ul class="menu bg-base-200 rounded-box min-w-max gap-1">
+				for _, account := range accounts {
+					<li class="group">
+						<a class={ "flex flex-row gap-2 justify-between" + logic.StringIfElse(" active", "", account.ID == selectedId) }>
+							<span>{ account.Nickname }</span>
+							<span class={ "badge group-hover:bg-gray-900 " + logic.StringIfElse("bg-gray-900", "badge-neutral", account.ID == selectedId) }>{ account.Realm }</span>
+						</a>
+					</li>
+				}
+				<li>
+					<a class={ "flex flex-row gap-1 justify-between" + logic.StringIfElse(" active", "", selectedId == "") }>
+						<span>Link</span>
+						<span>+</span>
+					</a>
+				</li>
+			</ul>
+		</div>
+		<div class="grow flex flex-col max-w-xl gap-2">
+			@widgetOptions()
+			// @widget.Widget()
+		</div>
+	</div>
+}
+
+templ widgetOptions() {
+	<div class="flex flex-col items-center justify-center gap-4">
+		<div class="form-control w-full flex gap-2">
+			<div class="flex flex-col bg-base-200 rounded-lg p-4">
+				<span class="text-lg">Regular Battles</span>
+				<label class="label cursor-pointer">
+					<span class="label-text">Show Overview Card</span>
+					<input type="checkbox" class="toggle toggle-secondary" checked="checked"/>
+				</label>
+				<label class="label cursor-pointer flex flex-col items-start gap-1">
+					<span class="label-text">Vehicle Cards</span>
+					<input type="range" min="0" max="10" value="3" class="range" step="1"/>
+					<div class="flex w-full justify-between px-2 text-xs">
+						for i := range 11 {
+							<div class="flex flex-col items-center">
+								<span>{ fmt.Sprint(i) }</span>
+							</div>
+						}
+					</div>
+				</label>
+			</div>
+			<div class="flex flex-col bg-base-200 rounded-lg p-4">
+				<span class="text-lg">Rating Battles</span>
+				<label class="label cursor-pointer">
+					<span class="label-text">Show Overview Card</span>
+					<input type="checkbox" class="toggle toggle-secondary" checked="checked"/>
+				</label>
+			</div>
+		</div>
+		<button class="btn btn-primary">
+			copy link
+		</button>
+	</div>
+}
diff --git a/cmd/frontend/routes/app/widgets_templ.go b/cmd/frontend/routes/app/widgets_templ.go
new file mode 100644
index 00000000..3a049f64
--- /dev/null
+++ b/cmd/frontend/routes/app/widgets_templ.go
@@ -0,0 +1,233 @@
+// Code generated by templ - DO NOT EDIT.
+
+// templ: version: v0.2.731
+package app
+
+//lint:file-ignore SA4006 This context is only used if a nested component is present.
+
+import "github.com/a-h/templ"
+import templruntime "github.com/a-h/templ/runtime"
+
+import (
+	"fmt"
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/cmd/frontend/layouts"
+	"github.com/cufee/aftermath/cmd/frontend/logic"
+	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/pkg/errors"
+	"net/http"
+)
+
+var Widgets handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
+	user, err := ctx.SessionUser()
+	if err != nil {
+		return nil, nil, ctx.Redirect("/login", http.StatusTemporaryRedirect)
+	}
+
+	extendedUser, err := ctx.Database().GetUserByID(ctx, user.ID, database.WithConnections())
+	if err != nil {
+		return nil, nil, ctx.Redirect("/login", http.StatusTemporaryRedirect)
+	}
+
+	var accountIDs []string
+	connections, _ := extendedUser.FilterConnections(models.ConnectionTypeWargaming, nil)
+	for _, conn := range connections {
+		accountIDs = append(accountIDs, conn.ReferenceID)
+	}
+
+	var accounts []models.Account
+	if len(accountIDs) > 0 {
+		accounts, err = ctx.Database().GetAccounts(ctx.Context, accountIDs)
+		if err != nil {
+			return nil, nil, errors.New("invalid account id")
+		}
+	}
+
+	return layouts.Main, widgetConfiguratorPage(accounts, "account1"), nil
+}
+
+func widgetConfiguratorPage(accounts []models.Account, selectedId string) templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var1 == nil {
+			templ_7745c5c3_Var1 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-row justify-center gap-4 flex-wrap min-w-max\"><div class=\"flex flex-col gap-2\"><ul class=\"menu bg-base-200 rounded-box min-w-max gap-1\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		for _, account := range accounts {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<li class=\"group\">")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			var templ_7745c5c3_Var2 = []any{"flex flex-row gap-2 justify-between" + logic.StringIfElse(" active", "", account.ID == selectedId)}
+			templ_7745c5c3_Err = templ.RenderCSSItems(ctx, templ_7745c5c3_Buffer, templ_7745c5c3_Var2...)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<a class=\"")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			var templ_7745c5c3_Var3 string
+			templ_7745c5c3_Var3, templ_7745c5c3_Err = templ.JoinStringErrs(templ.CSSClasses(templ_7745c5c3_Var2).String())
+			if templ_7745c5c3_Err != nil {
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/app/widgets.templ`, Line: 1, Col: 0}
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var3))
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><span>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			var templ_7745c5c3_Var4 string
+			templ_7745c5c3_Var4, templ_7745c5c3_Err = templ.JoinStringErrs(account.Nickname)
+			if templ_7745c5c3_Err != nil {
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/app/widgets.templ`, Line: 49, Col: 31}
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var4))
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</span> ")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			var templ_7745c5c3_Var5 = []any{"badge group-hover:bg-gray-900 " + logic.StringIfElse("bg-gray-900", "badge-neutral", account.ID == selectedId)}
+			templ_7745c5c3_Err = templ.RenderCSSItems(ctx, templ_7745c5c3_Buffer, templ_7745c5c3_Var5...)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<span class=\"")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			var templ_7745c5c3_Var6 string
+			templ_7745c5c3_Var6, templ_7745c5c3_Err = templ.JoinStringErrs(templ.CSSClasses(templ_7745c5c3_Var5).String())
+			if templ_7745c5c3_Err != nil {
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/app/widgets.templ`, Line: 1, Col: 0}
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var6))
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\">")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			var templ_7745c5c3_Var7 string
+			templ_7745c5c3_Var7, templ_7745c5c3_Err = templ.JoinStringErrs(account.Realm)
+			if templ_7745c5c3_Err != nil {
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/app/widgets.templ`, Line: 50, Col: 150}
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var7))
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</span></a></li>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<li>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var8 = []any{"flex flex-row gap-1 justify-between" + logic.StringIfElse(" active", "", selectedId == "")}
+		templ_7745c5c3_Err = templ.RenderCSSItems(ctx, templ_7745c5c3_Buffer, templ_7745c5c3_Var8...)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<a class=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var9 string
+		templ_7745c5c3_Var9, templ_7745c5c3_Err = templ.JoinStringErrs(templ.CSSClasses(templ_7745c5c3_Var8).String())
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/app/widgets.templ`, Line: 1, Col: 0}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var9))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><span>Link</span> <span>+</span></a></li></ul></div><div class=\"grow flex flex-col max-w-xl gap-2\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = widgetOptions().Render(ctx, templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return templ_7745c5c3_Err
+	})
+}
+
+func widgetOptions() templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var10 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var10 == nil {
+			templ_7745c5c3_Var10 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-col items-center justify-center gap-4\"><div class=\"form-control w-full flex gap-2\"><div class=\"flex flex-col bg-base-200 rounded-lg p-4\"><span class=\"text-lg\">Regular Battles</span> <label class=\"label cursor-pointer\"><span class=\"label-text\">Show Overview Card</span> <input type=\"checkbox\" class=\"toggle toggle-secondary\" checked=\"checked\"></label> <label class=\"label cursor-pointer flex flex-col items-start gap-1\"><span class=\"label-text\">Vehicle Cards</span> <input type=\"range\" min=\"0\" max=\"10\" value=\"3\" class=\"range\" step=\"1\"><div class=\"flex w-full justify-between px-2 text-xs\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		for i := range 11 {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-col items-center\"><span>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			var templ_7745c5c3_Var11 string
+			templ_7745c5c3_Var11, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprint(i))
+			if templ_7745c5c3_Err != nil {
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/app/widgets.templ`, Line: 84, Col: 29}
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var11))
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</span></div>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></label></div><div class=\"flex flex-col bg-base-200 rounded-lg p-4\"><span class=\"text-lg\">Rating Battles</span> <label class=\"label cursor-pointer\"><span class=\"label-text\">Show Overview Card</span> <input type=\"checkbox\" class=\"toggle toggle-secondary\" checked=\"checked\"></label></div></div><button class=\"btn btn-primary\">copy link</button></div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return templ_7745c5c3_Err
+	})
+}
diff --git a/cmd/frontend/routes/errors.templ b/cmd/frontend/routes/errors.templ
index c3d4db65..f299728e 100644
--- a/cmd/frontend/routes/errors.templ
+++ b/cmd/frontend/routes/errors.templ
@@ -1,13 +1,14 @@
 package routes
 
-import "github.com/cufee/aftermath/cmd/frontend/handler"
-import "github.com/cufee/aftermath/cmd/frontend/layouts"
-import "net/http"
+import (
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/cmd/frontend/layouts"
+)
 
 var GenericError handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
 	message := ctx.Query("message")
 
-	ctx.SetStatus(http.StatusInternalServerError)
+	// ctx.SetStatus(http.StatusInternalServerError)
 	return layouts.Main, errorPage(message), nil
 }
 
@@ -21,7 +22,7 @@ templ errorPage(message string) {
 var ErrorNotFound handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
 	path := ctx.Path("pathname")
 
-	ctx.SetStatus(http.StatusNotFound)
+	// ctx.SetStatus(http.StatusNotFound)
 	return layouts.Main, notFoundPage(path), nil
 }
 
diff --git a/cmd/frontend/routes/errors_templ.go b/cmd/frontend/routes/errors_templ.go
index c457a73c..e6a3617b 100644
--- a/cmd/frontend/routes/errors_templ.go
+++ b/cmd/frontend/routes/errors_templ.go
@@ -1,32 +1,36 @@
 // Code generated by templ - DO NOT EDIT.
 
-// templ: version: v0.2.696
+// templ: version: v0.2.731
 package routes
 
 //lint:file-ignore SA4006 This context is only used if a nested component is present.
 
 import "github.com/a-h/templ"
-import "context"
-import "io"
-import "bytes"
+import templruntime "github.com/a-h/templ/runtime"
 
-import "github.com/cufee/aftermath/cmd/frontend/handler"
-import "github.com/cufee/aftermath/cmd/frontend/layouts"
-import "net/http"
+import (
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/cmd/frontend/layouts"
+)
 
 var GenericError handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
 	message := ctx.Query("message")
 
-	ctx.SetStatus(http.StatusInternalServerError)
+	// ctx.SetStatus(http.StatusInternalServerError)
 	return layouts.Main, errorPage(message), nil
 }
 
 func errorPage(message string) templ.Component {
-	return templ.ComponentFunc(func(ctx context.Context, templ_7745c5c3_W io.Writer) (templ_7745c5c3_Err error) {
-		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templ_7745c5c3_W.(*bytes.Buffer)
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
-			templ_7745c5c3_Buffer = templ.GetBuffer()
-			defer templ.ReleaseBuffer(templ_7745c5c3_Buffer)
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
@@ -41,7 +45,7 @@ func errorPage(message string) templ.Component {
 		var templ_7745c5c3_Var2 string
 		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(message)
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/errors.templ`, Line: 17, Col: 17}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/errors.templ`, Line: 18, Col: 17}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
 		if templ_7745c5c3_Err != nil {
@@ -51,9 +55,6 @@ func errorPage(message string) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		if !templ_7745c5c3_IsBuffer {
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteTo(templ_7745c5c3_W)
-		}
 		return templ_7745c5c3_Err
 	})
 }
@@ -61,16 +62,21 @@ func errorPage(message string) templ.Component {
 var ErrorNotFound handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
 	path := ctx.Path("pathname")
 
-	ctx.SetStatus(http.StatusNotFound)
+	// ctx.SetStatus(http.StatusNotFound)
 	return layouts.Main, notFoundPage(path), nil
 }
 
 func notFoundPage(path string) templ.Component {
-	return templ.ComponentFunc(func(ctx context.Context, templ_7745c5c3_W io.Writer) (templ_7745c5c3_Err error) {
-		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templ_7745c5c3_W.(*bytes.Buffer)
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
-			templ_7745c5c3_Buffer = templ.GetBuffer()
-			defer templ.ReleaseBuffer(templ_7745c5c3_Buffer)
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var3 := templ.GetChildren(ctx)
@@ -85,7 +91,7 @@ func notFoundPage(path string) templ.Component {
 		var templ_7745c5c3_Var4 string
 		templ_7745c5c3_Var4, templ_7745c5c3_Err = templ.JoinStringErrs(path)
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/errors.templ`, Line: 31, Col: 15}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/errors.templ`, Line: 32, Col: 15}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var4))
 		if templ_7745c5c3_Err != nil {
@@ -95,9 +101,6 @@ func notFoundPage(path string) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		if !templ_7745c5c3_IsBuffer {
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteTo(templ_7745c5c3_W)
-		}
 		return templ_7745c5c3_Err
 	})
 }
diff --git a/cmd/frontend/routes/index.templ b/cmd/frontend/routes/index.templ
index 581aaa5b..b3822a69 100644
--- a/cmd/frontend/routes/index.templ
+++ b/cmd/frontend/routes/index.templ
@@ -1,8 +1,9 @@
 package routes
 
-import "github.com/cufee/aftermath/cmd/frontend/handler"
-import "github.com/cufee/aftermath/cmd/frontend/layouts"
-import "github.com/cufee/aftermath/cmd/frontend/components"
+import (
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/cmd/frontend/layouts"
+)
 
 var Index handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
 	return layouts.Main, index(), nil
@@ -10,27 +11,40 @@ var Index handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Compo
 
 templ index() {
 	<div class="flex flex-col justify-center gap-8 m-auto" id="landing">
-		<div class="flex items-center justify-center">
-			@components.Logo("128")
+		<div class="flex flex-row flex-wrap">
+			@card(cardImage("/assets/promo-join.jpg"), cardActionButton("Join Aftermath Official", "/join")) {
+				<p>Aftermath is making a comeback! We've revamped everything to be faster and more beautiful. Join our community server for the latest features and updates.</p>
+			}
+			@card(cardImage("/assets/promo-invite.jpg"), cardActionButton("Add Aftermath on Discord", "/invite")) {
+				<p>The new bot is here! Add it to your server for an easier time tracking sessions. It's that simple – give Aftermath a try on your favorite server!</p>
+			}
 		</div>
-		<div class="grid gap-4 p-4 md:grid-cols-2">
-			<div class="shadow-xl card bg-base-300">
-				<figure><img src="/assets/promo-join.jpg" alt="Join Aftermath Official"/></figure>
-				<div class="card-body">
-					<p>Aftermath is making a comeback! We've revamped everything to be faster and more beautiful. Join our community server for the latest features and updates.</p>
-					<div class="justify-center card-actions">
-						<a href="/join" class="btn btn-primary">Join Aftermath Official</a>
-					</div>
+	</div>
+}
+
+templ cardImage(path string) {
+	<img src={ path } class="max-h-24 md:max-h-48 object-cover w-full" alt="Join Aftermath Official"/>
+}
+
+templ cardActionButton(label, path string) {
+	<a href={ templ.URL(path) } class="btn btn-primary">{ label }</a>
+}
+
+templ card(image templ.Component, button templ.Component) {
+	<div class="grow md:basis-1/2 p-2">
+		<div class="shadow-xl card bg-base-300 overflow-hidden h-full">
+			if image != nil {
+				<div class="overflow-hidden">
+					@image
 				</div>
-			</div>
-			<div class="shadow-xl card bg-base-300">
-				<figure><img src="/assets/promo-invite.jpg" alt="Invite Aftermath"/></figure>
-				<div class="card-body">
-					<p>The new bot is here! Add it to your server for an easier time tracking sessions. It's that simple – give Aftermath a try on your favorite server!</p>
+			}
+			<div class="card-body gap-4">
+				{ children... }
+				if button != nil {
 					<div class="justify-center card-actions">
-						<a href="/invite" class="btn btn-primary">Invite Aftermath</a>
+						@button
 					</div>
-				</div>
+				}
 			</div>
 		</div>
 	</div>
diff --git a/cmd/frontend/routes/index_templ.go b/cmd/frontend/routes/index_templ.go
index 279553da..98fa1ccb 100644
--- a/cmd/frontend/routes/index_templ.go
+++ b/cmd/frontend/routes/index_templ.go
@@ -1,29 +1,33 @@
 // Code generated by templ - DO NOT EDIT.
 
-// templ: version: v0.2.696
+// templ: version: v0.2.731
 package routes
 
 //lint:file-ignore SA4006 This context is only used if a nested component is present.
 
 import "github.com/a-h/templ"
-import "context"
-import "io"
-import "bytes"
+import templruntime "github.com/a-h/templ/runtime"
 
-import "github.com/cufee/aftermath/cmd/frontend/handler"
-import "github.com/cufee/aftermath/cmd/frontend/layouts"
-import "github.com/cufee/aftermath/cmd/frontend/components"
+import (
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/cmd/frontend/layouts"
+)
 
 var Index handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
 	return layouts.Main, index(), nil
 }
 
 func index() templ.Component {
-	return templ.ComponentFunc(func(ctx context.Context, templ_7745c5c3_W io.Writer) (templ_7745c5c3_Err error) {
-		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templ_7745c5c3_W.(*bytes.Buffer)
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
-			templ_7745c5c3_Buffer = templ.GetBuffer()
-			defer templ.ReleaseBuffer(templ_7745c5c3_Buffer)
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
@@ -31,20 +35,210 @@ func index() templ.Component {
 			templ_7745c5c3_Var1 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-col justify-center gap-8 m-auto\" id=\"landing\"><div class=\"flex items-center justify-center\">")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-col justify-center gap-8 m-auto\" id=\"landing\"><div class=\"flex flex-row flex-wrap\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		templ_7745c5c3_Err = components.Logo("128").Render(ctx, templ_7745c5c3_Buffer)
+		templ_7745c5c3_Var2 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+			templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+			templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+			if !templ_7745c5c3_IsBuffer {
+				defer func() {
+					templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+					if templ_7745c5c3_Err == nil {
+						templ_7745c5c3_Err = templ_7745c5c3_BufErr
+					}
+				}()
+			}
+			ctx = templ.InitializeContext(ctx)
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<p>Aftermath is making a comeback! We've revamped everything to be faster and more beautiful. Join our community server for the latest features and updates.</p>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			return templ_7745c5c3_Err
+		})
+		templ_7745c5c3_Err = card(cardImage("/assets/promo-join.jpg"), cardActionButton("Join Aftermath Official", "/join")).Render(templ.WithChildren(ctx, templ_7745c5c3_Var2), templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Var3 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+			templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+			templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+			if !templ_7745c5c3_IsBuffer {
+				defer func() {
+					templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+					if templ_7745c5c3_Err == nil {
+						templ_7745c5c3_Err = templ_7745c5c3_BufErr
+					}
+				}()
+			}
+			ctx = templ.InitializeContext(ctx)
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<p>The new bot is here! Add it to your server for an easier time tracking sessions. It's that simple – give Aftermath a try on your favorite server!</p>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			return templ_7745c5c3_Err
+		})
+		templ_7745c5c3_Err = card(cardImage("/assets/promo-invite.jpg"), cardActionButton("Add Aftermath on Discord", "/invite")).Render(templ.WithChildren(ctx, templ_7745c5c3_Var3), templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return templ_7745c5c3_Err
+	})
+}
+
+func cardImage(path string) templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var4 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var4 == nil {
+			templ_7745c5c3_Var4 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<img src=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var5 string
+		templ_7745c5c3_Var5, templ_7745c5c3_Err = templ.JoinStringErrs(path)
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/index.templ`, Line: 26, Col: 16}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var5))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\" class=\"max-h-24 md:max-h-48 object-cover w-full\" alt=\"Join Aftermath Official\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return templ_7745c5c3_Err
+	})
+}
+
+func cardActionButton(label, path string) templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var6 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var6 == nil {
+			templ_7745c5c3_Var6 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<a href=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var7 templ.SafeURL = templ.URL(path)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(string(templ_7745c5c3_Var7)))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\" class=\"btn btn-primary\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div><div class=\"grid gap-4 p-4 md:grid-cols-2\"><div class=\"shadow-xl card bg-base-300\"><figure><img src=\"/assets/promo-join.jpg\" alt=\"Join Aftermath Official\"></figure><div class=\"card-body\"><p>Aftermath is making a comeback! We've revamped everything to be faster and more beautiful. Join our community server for the latest features and updates.</p><div class=\"justify-center card-actions\"><a href=\"/join\" class=\"btn btn-primary\">Join Aftermath Official</a></div></div></div><div class=\"shadow-xl card bg-base-300\"><figure><img src=\"/assets/promo-invite.jpg\" alt=\"Invite Aftermath\"></figure><div class=\"card-body\"><p>The new bot is here! Add it to your server for an easier time tracking sessions. It's that simple – give Aftermath a try on your favorite server!</p><div class=\"justify-center card-actions\"><a href=\"/invite\" class=\"btn btn-primary\">Invite Aftermath</a></div></div></div></div></div>")
+		var templ_7745c5c3_Var8 string
+		templ_7745c5c3_Var8, templ_7745c5c3_Err = templ.JoinStringErrs(label)
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/index.templ`, Line: 30, Col: 60}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var8))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</a>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return templ_7745c5c3_Err
+	})
+}
+
+func card(image templ.Component, button templ.Component) templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteTo(templ_7745c5c3_W)
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var9 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var9 == nil {
+			templ_7745c5c3_Var9 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"grow md:basis-1/2 p-2\"><div class=\"shadow-xl card bg-base-300 overflow-hidden h-full\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		if image != nil {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"overflow-hidden\">")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			templ_7745c5c3_Err = image.Render(ctx, templ_7745c5c3_Buffer)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"card-body gap-4\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = templ_7745c5c3_Var9.Render(ctx, templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		if button != nil {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"justify-center card-actions\">")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			templ_7745c5c3_Err = button.Render(ctx, templ_7745c5c3_Buffer)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></div></div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
 		}
 		return templ_7745c5c3_Err
 	})
diff --git a/cmd/frontend/routes/widget/configure.templ b/cmd/frontend/routes/widget/configure.templ
index 7cc17bf4..d3b012c5 100644
--- a/cmd/frontend/routes/widget/configure.templ
+++ b/cmd/frontend/routes/widget/configure.templ
@@ -1,13 +1,16 @@
 package widget 
 
-import "github.com/cufee/aftermath/cmd/frontend/handler"
-import "github.com/cufee/aftermath/cmd/frontend/layouts"
-import "github.com/cufee/aftermath/cmd/frontend/components/widget"
-import "github.com/cufee/aftermath/internal/stats/client/v1"
-import "golang.org/x/text/language"
-import "time"
-import "github.com/pkg/errors"
-import "fmt"
+import (
+	"context"
+	"fmt"
+	"github.com/cufee/aftermath/cmd/frontend/components/widget"
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/cmd/frontend/layouts"
+	"github.com/cufee/aftermath/internal/stats/client/v1"
+	"github.com/pkg/errors"
+	"golang.org/x/text/language"
+	"time"
+)
 
 var ConfigureWidget handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
 	accountID := ctx.Path("accountId")
diff --git a/cmd/frontend/routes/widget/configure_templ.go b/cmd/frontend/routes/widget/configure_templ.go
index 755037b9..6331a92e 100644
--- a/cmd/frontend/routes/widget/configure_templ.go
+++ b/cmd/frontend/routes/widget/configure_templ.go
@@ -1,23 +1,24 @@
 // Code generated by templ - DO NOT EDIT.
 
-// templ: version: v0.2.696
+// templ: version: v0.2.731
 package widget
 
 //lint:file-ignore SA4006 This context is only used if a nested component is present.
 
 import "github.com/a-h/templ"
-import "context"
-import "io"
-import "bytes"
+import templruntime "github.com/a-h/templ/runtime"
 
-import "github.com/cufee/aftermath/cmd/frontend/handler"
-import "github.com/cufee/aftermath/cmd/frontend/layouts"
-import "github.com/cufee/aftermath/cmd/frontend/components/widget"
-import "github.com/cufee/aftermath/internal/stats/client/v1"
-import "golang.org/x/text/language"
-import "time"
-import "github.com/pkg/errors"
-import "fmt"
+import (
+	"context"
+	"fmt"
+	"github.com/cufee/aftermath/cmd/frontend/components/widget"
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/cmd/frontend/layouts"
+	"github.com/cufee/aftermath/internal/stats/client/v1"
+	"github.com/pkg/errors"
+	"golang.org/x/text/language"
+	"time"
+)
 
 var ConfigureWidget handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
 	accountID := ctx.Path("accountId")
@@ -39,11 +40,16 @@ var ConfigureWidget handler.Page = func(ctx *handler.Context) (handler.Layout, t
 }
 
 func configureWidgetPage(widget templ.Component) templ.Component {
-	return templ.ComponentFunc(func(ctx context.Context, templ_7745c5c3_W io.Writer) (templ_7745c5c3_Err error) {
-		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templ_7745c5c3_W.(*bytes.Buffer)
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
-			templ_7745c5c3_Buffer = templ.GetBuffer()
-			defer templ.ReleaseBuffer(templ_7745c5c3_Buffer)
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
@@ -63,7 +69,7 @@ func configureWidgetPage(widget templ.Component) templ.Component {
 			var templ_7745c5c3_Var2 string
 			templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprint(i))
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/widget/configure.templ`, Line: 48, Col: 31}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/widget/configure.templ`, Line: 51, Col: 31}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
 			if templ_7745c5c3_Err != nil {
@@ -86,9 +92,6 @@ func configureWidgetPage(widget templ.Component) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		if !templ_7745c5c3_IsBuffer {
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteTo(templ_7745c5c3_W)
-		}
 		return templ_7745c5c3_Err
 	})
 }
diff --git a/cmd/frontend/routes/widget/live.templ b/cmd/frontend/routes/widget/live.templ
index 31f52f8a..ef76ce7b 100644
--- a/cmd/frontend/routes/widget/live.templ
+++ b/cmd/frontend/routes/widget/live.templ
@@ -1,14 +1,44 @@
 package widget
 
-import "github.com/cufee/aftermath/cmd/frontend/handler"
-import "github.com/pkg/errors"
-import "golang.org/x/text/language"
-import "time"
-import "github.com/cufee/aftermath/cmd/frontend/layouts"
-import "github.com/cufee/aftermath/cmd/frontend/components/widget"
-import "github.com/cufee/aftermath/internal/database/models"
-import "github.com/cufee/aftermath/internal/stats/client/v1"
-import "slices"
+import (
+	"context"
+	"github.com/cufee/aftermath/cmd/frontend/components/widget"
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/cmd/frontend/layouts"
+	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/stats/client/v1"
+	"github.com/pkg/errors"
+	"golang.org/x/text/language"
+	"slices"
+	"time"
+)
+
+var PersonalLiveWidget handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
+	userID := ctx.Path("userId")
+	if userID == "" {
+		return nil, nil, errors.New("invalid account id")
+	}
+
+	account, err := ctx.Fetch().Account(ctx.Context, userID)
+	if err != nil {
+		return nil, nil, errors.New("invalid account id")
+	}
+
+	var opts = []client.RequestOption{client.WithWN8()}
+	if ref := ctx.Query("ref"); ref != "" {
+		opts = append(opts, client.WithReferenceID(ref))
+	}
+	if t := ctx.Query("type"); t != "" && slices.Contains(models.SnapshotType("").Values(), t) {
+		opts = append(opts, client.WithType(models.SnapshotType(t)))
+	}
+
+	cards, _, err := ctx.Client.Stats(language.English).SessionCards(context.Background(), account.ID, time.Now(), opts...)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return layouts.Main, liveWidget(widget.Widget(account, cards, widget.WithAutoReload())), nil
+}
 
 var LiveWidget handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
 	accountID := ctx.Path("accountId")
@@ -21,7 +51,7 @@ var LiveWidget handler.Page = func(ctx *handler.Context) (handler.Layout, templ.
 		return nil, nil, errors.New("invalid account id")
 	}
 
-	var opts  = []client.RequestOption{client.WithWN8()}
+	var opts = []client.RequestOption{client.WithWN8()}
 	if ref := ctx.Query("ref"); ref != "" {
 		opts = append(opts, client.WithReferenceID(ref))
 	}
diff --git a/cmd/frontend/routes/widget/live_templ.go b/cmd/frontend/routes/widget/live_templ.go
index b176d1c8..0e1ebfb9 100644
--- a/cmd/frontend/routes/widget/live_templ.go
+++ b/cmd/frontend/routes/widget/live_templ.go
@@ -1,24 +1,52 @@
 // Code generated by templ - DO NOT EDIT.
 
-// templ: version: v0.2.696
+// templ: version: v0.2.731
 package widget
 
 //lint:file-ignore SA4006 This context is only used if a nested component is present.
 
 import "github.com/a-h/templ"
-import "context"
-import "io"
-import "bytes"
+import templruntime "github.com/a-h/templ/runtime"
 
-import "github.com/cufee/aftermath/cmd/frontend/handler"
-import "github.com/pkg/errors"
-import "golang.org/x/text/language"
-import "time"
-import "github.com/cufee/aftermath/cmd/frontend/layouts"
-import "github.com/cufee/aftermath/cmd/frontend/components/widget"
-import "github.com/cufee/aftermath/internal/database/models"
-import "github.com/cufee/aftermath/internal/stats/client/v1"
-import "slices"
+import (
+	"context"
+	"github.com/cufee/aftermath/cmd/frontend/components/widget"
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/cmd/frontend/layouts"
+	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/stats/client/v1"
+	"github.com/pkg/errors"
+	"golang.org/x/text/language"
+	"slices"
+	"time"
+)
+
+var PersonalLiveWidget handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
+	userID := ctx.Path("userId")
+	if userID == "" {
+		return nil, nil, errors.New("invalid account id")
+	}
+
+	account, err := ctx.Fetch().Account(ctx.Context, userID)
+	if err != nil {
+		return nil, nil, errors.New("invalid account id")
+	}
+
+	var opts = []client.RequestOption{client.WithWN8()}
+	if ref := ctx.Query("ref"); ref != "" {
+		opts = append(opts, client.WithReferenceID(ref))
+	}
+	if t := ctx.Query("type"); t != "" && slices.Contains(models.SnapshotType("").Values(), t) {
+		opts = append(opts, client.WithType(models.SnapshotType(t)))
+	}
+
+	cards, _, err := ctx.Client.Stats(language.English).SessionCards(context.Background(), account.ID, time.Now(), opts...)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return layouts.Main, liveWidget(widget.Widget(account, cards, widget.WithAutoReload())), nil
+}
 
 var LiveWidget handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
 	accountID := ctx.Path("accountId")
@@ -48,11 +76,16 @@ var LiveWidget handler.Page = func(ctx *handler.Context) (handler.Layout, templ.
 }
 
 func liveWidget(widget templ.Component) templ.Component {
-	return templ.ComponentFunc(func(ctx context.Context, templ_7745c5c3_W io.Writer) (templ_7745c5c3_Err error) {
-		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templ_7745c5c3_W.(*bytes.Buffer)
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 		if !templ_7745c5c3_IsBuffer {
-			templ_7745c5c3_Buffer = templ.GetBuffer()
-			defer templ.ReleaseBuffer(templ_7745c5c3_Buffer)
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
 		}
 		ctx = templ.InitializeContext(ctx)
 		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
@@ -68,9 +101,6 @@ func liveWidget(widget templ.Component) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		if !templ_7745c5c3_IsBuffer {
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteTo(templ_7745c5c3_W)
-		}
 		return templ_7745c5c3_Err
 	})
 }
diff --git a/cmd/frontend/routes/widget/personal.templ b/cmd/frontend/routes/widget/personal.templ
new file mode 100644
index 00000000..7817451a
--- /dev/null
+++ b/cmd/frontend/routes/widget/personal.templ
@@ -0,0 +1,76 @@
+package widget 
+
+import (
+	"context"
+	"fmt"
+	"github.com/cufee/aftermath/cmd/frontend/components/widget"
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/cmd/frontend/layouts"
+	"github.com/cufee/aftermath/internal/stats/client/v1"
+	"github.com/pkg/errors"
+	"golang.org/x/text/language"
+	"time"
+)
+
+var PersonalWidget handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
+	userID := ctx.Path("userId")
+	if userID == "" {
+		return nil, nil, errors.New("invalid user id id")
+	}
+
+	account, err := ctx.Fetch().Account(ctx.Context, userID)
+	if err != nil {
+		return nil, nil, errors.New("invalid account id")
+	}
+
+	cards, _, err := ctx.Client.Stats(language.English).SessionCards(context.Background(), account.ID, time.Now(), client.WithWN8())
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return layouts.Main, personalWidgetPage(widget.Widget(account, cards)), nil
+}
+
+templ personalWidgetPage(widget templ.Component) {
+	<div class="flex flex-row justify-center gap-4 flex-wrap min-w-max">
+		<div class="grow flex flex-col max-w-xl gap-2">
+			<div class="flex flex-col items-center justify-center gap-4">
+				<div class="form-control w-full flex gap-2">
+					<div class="flex flex-col bg-base-200 rounded-lg p-4">
+						<span class="text-lg">Regular Battles</span>
+						<label class="label cursor-pointer">
+							<span class="label-text">Show Overview Card</span>
+							<input type="checkbox" class="toggle toggle-secondary" checked="checked" disabled/>
+						</label>
+						<label class="label cursor-pointer flex flex-col items-start gap-1">
+							<span class="label-text">Vehicle Cards</span>
+							<input type="range" min="0" max="10" value="3" class="range" step="1" disabled/>
+							<div class="flex w-full justify-between px-2 text-xs">
+								for i := range 11 {
+									<div class="flex flex-col items-center">
+										<span>{ fmt.Sprint(i) }</span>
+									</div>
+								}
+							</div>
+						</label>
+					</div>
+					<div class="flex flex-col bg-base-200 rounded-lg p-4">
+						<span class="text-lg">Rating Battles</span>
+						<label class="label cursor-pointer">
+							<span class="label-text">Show Overview Card</span>
+							<input type="checkbox" class="toggle toggle-secondary" checked="checked" disabled/>
+						</label>
+					</div>
+				</div>
+				<button class="btn btn-primary">
+					copy link
+				</button>
+			</div>
+		</div>
+		<div class="flex flex-col gap-2">
+			<div class="max-m-max">
+				@widget
+			</div>
+		</div>
+	</div>
+}
diff --git a/cmd/frontend/routes/widget/personal_templ.go b/cmd/frontend/routes/widget/personal_templ.go
new file mode 100644
index 00000000..935f05ed
--- /dev/null
+++ b/cmd/frontend/routes/widget/personal_templ.go
@@ -0,0 +1,97 @@
+// Code generated by templ - DO NOT EDIT.
+
+// templ: version: v0.2.731
+package widget
+
+//lint:file-ignore SA4006 This context is only used if a nested component is present.
+
+import "github.com/a-h/templ"
+import templruntime "github.com/a-h/templ/runtime"
+
+import (
+	"context"
+	"fmt"
+	"github.com/cufee/aftermath/cmd/frontend/components/widget"
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/cmd/frontend/layouts"
+	"github.com/cufee/aftermath/internal/stats/client/v1"
+	"github.com/pkg/errors"
+	"golang.org/x/text/language"
+	"time"
+)
+
+var PersonalWidget handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
+	userID := ctx.Path("userId")
+	if userID == "" {
+		return nil, nil, errors.New("invalid user id id")
+	}
+
+	account, err := ctx.Fetch().Account(ctx.Context, userID)
+	if err != nil {
+		return nil, nil, errors.New("invalid account id")
+	}
+
+	cards, _, err := ctx.Client.Stats(language.English).SessionCards(context.Background(), account.ID, time.Now(), client.WithWN8())
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return layouts.Main, personalWidgetPage(widget.Widget(account, cards)), nil
+}
+
+func personalWidgetPage(widget templ.Component) templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var1 == nil {
+			templ_7745c5c3_Var1 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-row justify-center gap-4 flex-wrap min-w-max\"><div class=\"grow flex flex-col max-w-xl gap-2\"><div class=\"flex flex-col items-center justify-center gap-4\"><div class=\"form-control w-full flex gap-2\"><div class=\"flex flex-col bg-base-200 rounded-lg p-4\"><span class=\"text-lg\">Regular Battles</span> <label class=\"label cursor-pointer\"><span class=\"label-text\">Show Overview Card</span> <input type=\"checkbox\" class=\"toggle toggle-secondary\" checked=\"checked\" disabled></label> <label class=\"label cursor-pointer flex flex-col items-start gap-1\"><span class=\"label-text\">Vehicle Cards</span> <input type=\"range\" min=\"0\" max=\"10\" value=\"3\" class=\"range\" step=\"1\" disabled><div class=\"flex w-full justify-between px-2 text-xs\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		for i := range 11 {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-col items-center\"><span>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			var templ_7745c5c3_Var2 string
+			templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprint(i))
+			if templ_7745c5c3_Err != nil {
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/widget/personal.templ`, Line: 51, Col: 31}
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</span></div>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></label></div><div class=\"flex flex-col bg-base-200 rounded-lg p-4\"><span class=\"text-lg\">Rating Battles</span> <label class=\"label cursor-pointer\"><span class=\"label-text\">Show Overview Card</span> <input type=\"checkbox\" class=\"toggle toggle-secondary\" checked=\"checked\" disabled></label></div></div><button class=\"btn btn-primary\">copy link</button></div></div><div class=\"flex flex-col gap-2\"><div class=\"max-m-max\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = widget.Render(ctx, templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></div></div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return templ_7745c5c3_Err
+	})
+}
diff --git a/internal/database/models/user.go b/internal/database/models/user.go
index e0c8b1fc..4e271ee2 100644
--- a/internal/database/models/user.go
+++ b/internal/database/models/user.go
@@ -35,6 +35,16 @@ func (u User) HasPermission(value permissions.Permissions) bool {
 }
 
 func (u User) Connection(kind ConnectionType, conditions map[string]any) (UserConnection, bool) {
+	valid, ok := u.FilterConnections(kind, conditions)
+	if !ok {
+		return UserConnection{}, false
+	}
+	return valid[0], true
+}
+
+func (u User) FilterConnections(kind ConnectionType, conditions map[string]any) ([]UserConnection, bool) {
+	var valid []UserConnection
+
 outerLoop:
 	for _, connection := range u.Connections {
 		if connection.Type == kind {
@@ -43,26 +53,44 @@ outerLoop:
 					continue outerLoop
 				}
 			}
-			return connection, true
+			valid = append(valid, connection)
 		}
 	}
-	return UserConnection{}, false
+
+	return valid, len(valid) > 0
 }
 
 func (u User) Subscription(kind SubscriptionType) (UserSubscription, bool) {
+	valid, ok := u.FilterSubscriptions(kind)
+	if !ok {
+		return UserSubscription{}, false
+	}
+	return valid[0], true
+}
+
+func (u User) FilterSubscriptions(kind SubscriptionType) ([]UserSubscription, bool) {
+	var valid []UserSubscription
 	for _, subscription := range u.Subscriptions {
 		if subscription.Type == kind {
-			return subscription, true
+			valid = append(valid, subscription)
 		}
 	}
-	return UserSubscription{}, false
+	return valid, len(valid) > 0
 }
 
 func (u User) Content(kind UserContentType) (UserContent, bool) {
+	valid, ok := u.FilterContent(kind)
+	if !ok {
+		return UserContent{}, false
+	}
+	return valid[0], true
+}
+func (u User) FilterContent(kind UserContentType) ([]UserContent, bool) {
+	var valid []UserContent
 	for _, content := range u.Uploads {
 		if content.Type == kind {
-			return content, true
+			valid = append(valid, content)
 		}
 	}
-	return UserContent{}, false
+	return valid, len(valid) > 0
 }
diff --git a/internal/database/models/widget_options.go b/internal/database/models/widget_options.go
new file mode 100644
index 00000000..be34cb8d
--- /dev/null
+++ b/internal/database/models/widget_options.go
@@ -0,0 +1,28 @@
+package models
+
+import "time"
+
+type WidgetOptions struct {
+	ID        string
+	CreatedAt time.Time
+	UpdatedAt time.Time
+
+	UserID    string
+	AccountID string
+
+	Style WidgetStyling
+}
+
+type WidgetStyling struct {
+	Flavor          string
+	UnratedOverview WidgetCardStyle
+	RatingOverview  WidgetCardStyle
+	Vehicles        WidgetCardStyle
+}
+
+type WidgetCardStyle struct {
+	ShowTitle  bool
+	ShowCareer bool
+	ShowLabel  bool
+	Blocks     []string
+}
diff --git a/tests/static_data.go b/tests/static_data.go
index 93dcc80c..1ac8f29a 100644
--- a/tests/static_data.go
+++ b/tests/static_data.go
@@ -1,6 +1,7 @@
 package tests
 
 import (
+	"fmt"
 	"time"
 
 	"github.com/cufee/aftermath/internal/database/models"
@@ -113,3 +114,15 @@ func DefaultVehicleStatsFrameSmall2(id string) frame.VehicleStatsFrame {
 		StatsFrame: &f,
 	}
 }
+
+var (
+	DefaultUserWithEdges = models.User{ID: "user1", Connections: []models.UserConnection{Connection(models.ConnectionTypeWargaming)}}
+)
+
+func Connection(kind models.ConnectionType) models.UserConnection {
+	return models.UserConnection{
+		ID:          fmt.Sprint(time.Now().Nanosecond()),
+		ReferenceID: DefaultAccountNA,
+		Type:        kind,
+	}
+}
diff --git a/tests/static_database.go b/tests/static_database.go
index d2abba2c..44689e87 100644
--- a/tests/static_database.go
+++ b/tests/static_database.go
@@ -78,13 +78,18 @@ func (c *staticTestingDatabase) UpsertVehicleAverages(ctx context.Context, avera
 }
 
 func (c *staticTestingDatabase) GetUserByID(ctx context.Context, id string, opts ...database.UserGetOption) (models.User, error) {
-	return models.User{}, errors.New("GetUserByID not implemented")
+	return DefaultUserWithEdges, nil
 }
 func (c *staticTestingDatabase) GetOrCreateUserByID(ctx context.Context, id string, opts ...database.UserGetOption) (models.User, error) {
-	return models.User{}, errors.New("GetOrCreateUserByID not implemented")
+	return c.GetUserByID(ctx, id)
 }
 func (c *staticTestingDatabase) UpsertUserWithPermissions(ctx context.Context, userID string, perms permissions.Permissions) (models.User, error) {
-	return models.User{}, errors.New("UpsertUserWithPermissions not implemented")
+	u, err := c.GetUserByID(ctx, userID)
+	if err != nil {
+		return u, err
+	}
+	u.Permissions = perms
+	return u, nil
 }
 func (c *staticTestingDatabase) UpdateConnection(ctx context.Context, connection models.UserConnection) (models.UserConnection, error) {
 	return models.UserConnection{}, errors.New("UpdateConnection not implemented")
@@ -171,24 +176,24 @@ func (c *staticTestingDatabase) DeleteExpiredInteractions(ctx context.Context, e
 }
 
 func (c *staticTestingDatabase) CreateAuthNonce(ctx context.Context, publicID, identifier string, expiresAt time.Time, meta map[string]string) (models.AuthNonce, error) {
-	return models.AuthNonce{}, errors.New("CreateAuthNonce not implemented")
+	return models.AuthNonce{ID: "nonce1", Active: true, PublicID: "nonce1", Identifier: "ident1", ExpiresAt: time.Date(9999, 0, 0, 0, 0, 0, 0, time.UTC)}, nil
 }
 func (c *staticTestingDatabase) FindAuthNonce(ctx context.Context, publicID string) (models.AuthNonce, error) {
-	return models.AuthNonce{}, errors.New("FindAuthNonce not implemented")
+	return models.AuthNonce{ID: "nonce1", Active: true, PublicID: "nonce1", Identifier: "ident1", ExpiresAt: time.Date(9999, 0, 0, 0, 0, 0, 0, time.UTC)}, nil
 }
 func (c *staticTestingDatabase) SetAuthNonceActive(ctx context.Context, nonceID string, active bool) error {
-	return errors.New("SetAuthNonceActive not implemented")
+	return nil
 }
 
 func (c *staticTestingDatabase) CreateSession(ctx context.Context, publicID, userID string, expiresAt time.Time, meta map[string]string) (models.Session, error) {
-	return models.Session{}, errors.New("CreateSession not implementer")
+	return models.Session{ID: "session1", UserID: "user1", PublicID: "cookie1", ExpiresAt: time.Date(9999, 0, 0, 0, 0, 0, 0, time.UTC)}, nil
 }
 func (c *staticTestingDatabase) SetSessionExpiresAt(ctx context.Context, sessionID string, expiresAt time.Time) error {
-	return errors.New("SetSessionExpiresAt not implementer")
+	return nil
 }
 func (c *staticTestingDatabase) FindSession(ctx context.Context, publicID string) (models.Session, error) {
-	return models.Session{}, errors.New("FindSession not implementer")
+	return models.Session{ID: "session1", UserID: "user1", PublicID: "cookie1", ExpiresAt: time.Date(9999, 0, 0, 0, 0, 0, 0, time.UTC)}, nil
 }
 func (c *staticTestingDatabase) UserFromSession(ctx context.Context, publicID string) (models.User, error) {
-	return models.User{}, errors.New("UserFromSession not implementer")
+	return models.User{ID: "user1"}, nil
 }

From 1aec05e211036afc213f6c13ac56c50cc58942de Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 4 Jul 2024 14:18:39 -0400
Subject: [PATCH 248/341] added gomemlimit, ui work

---
 .air.toml                                 |   1 +
 Dockerfile                                |   4 +-
 cmd/core/queue/queue.go                   | 186 +++++++++++-----------
 cmd/frontend/components/navbar.templ      |  28 +++-
 cmd/frontend/components/navbar_templ.go   |   8 +-
 cmd/frontend/components/obs.templ         |  71 +++++++++
 cmd/frontend/components/obs_templ.go      | 133 ++++++++++++++++
 cmd/frontend/handlers.go                  |   4 +
 cmd/frontend/layouts/main.templ           |   6 +-
 cmd/frontend/layouts/main_templ.go        |   6 +-
 cmd/frontend/public/widget-background.jpg | Bin 0 -> 8506 bytes
 cmd/frontend/routes/api/widget/mock.go    |  11 ++
 cmd/frontend/routes/errors.templ          |  38 +++--
 cmd/frontend/routes/errors_templ.go       | 120 ++++++++++----
 cmd/frontend/routes/widget/index.templ    |  35 ++++
 cmd/frontend/routes/widget/index_templ.go |  72 +++++++++
 docker-compose.yaml                       |   2 +
 17 files changed, 577 insertions(+), 148 deletions(-)
 create mode 100644 cmd/frontend/components/obs.templ
 create mode 100644 cmd/frontend/components/obs_templ.go
 create mode 100644 cmd/frontend/public/widget-background.jpg
 create mode 100644 cmd/frontend/routes/api/widget/mock.go
 create mode 100644 cmd/frontend/routes/widget/index.templ
 create mode 100644 cmd/frontend/routes/widget/index_templ.go

diff --git a/.air.toml b/.air.toml
index 86f040d7..57af028c 100644
--- a/.air.toml
+++ b/.air.toml
@@ -2,6 +2,7 @@
 include_ext = ["go", "tmpl", "templ", "html"]
 exclude_regex = [".*_templ.go"]
 pre_cmd = ["templ generate"]
+cmd = "GODEBUG=gctrace=1 go build -o ./tmp/main ."
 send_interrupt = true
 stop_on_error = true
 
diff --git a/Dockerfile b/Dockerfile
index 0148d3d6..9b53de01 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,5 +1,7 @@
 FROM golang:1.22.3-bookworm as builder
 
+ARG GO_MEM_LIMIT=122MiB
+
 WORKDIR /workspace
 
 COPY go.mod go.sum ./
@@ -9,7 +11,7 @@ COPY ./ ./
 
 # build a fully standalone binary with zero dependencies
 RUN --mount=type=cache,target=$GOPATH/pkg/mod go generate main.go
-RUN --mount=type=cache,target=$GOPATH/pkg/mod CGO_ENABLED=1 GOOS=linux go build -o /bin/aftermath .
+RUN --mount=type=cache,target=$GOPATH/pkg/mod CGO_ENABLED=1 GOOS=linux GOMEMLIMIT=$GO_MEM_LIMIT go build -o /bin/aftermath .
 
 # Make a scratch container with required files and binary
 FROM debian:stable-slim
diff --git a/cmd/core/queue/queue.go b/cmd/core/queue/queue.go
index 499a4e34..ebbbc6e2 100644
--- a/cmd/core/queue/queue.go
+++ b/cmd/core/queue/queue.go
@@ -151,107 +151,109 @@ func (q *queue) startWorkers(ctx context.Context, onComplete func(id string)) {
 	for {
 		select {
 		case task := <-q.queued:
-			go func() {
-				q.workerLimiter <- struct{}{}
+			q.workerLimiter <- struct{}{}
+			q.activeTasksMx.Lock()
+			q.activeTasks[task.ID] = &struct{}{}
+			q.activeTasksMx.Unlock()
+			defer func() {
+				<-q.workerLimiter
 				q.activeTasksMx.Lock()
-				q.activeTasks[task.ID] = &struct{}{}
+				delete(q.activeTasks, task.ID)
 				q.activeTasksMx.Unlock()
-				defer func() {
-					<-q.workerLimiter
-					q.activeTasksMx.Lock()
-					delete(q.activeTasks, task.ID)
-					q.activeTasksMx.Unlock()
-					if onComplete != nil {
-						onComplete(task.ID)
-					}
-				}()
-
-				log.Debug().Str("taskId", task.ID).Msg("worker started processing a task")
-				defer log.Debug().Str("taskId", task.ID).Msg("worker finished processing a task")
-
-				defer func() {
-					if r := recover(); r != nil {
-						event := log.Error().Str("stack", string(debug.Stack())).Str("taskId", task.ID)
-						defer event.Msg("panic in queue worker")
-
-						coreClient, err := q.newCoreClient()
-						if err != nil {
-							event.AnErr("core", err).Str("additional", "failed to create a core client")
-							return
-						}
-						task.Status = models.TaskStatusFailed
-						task.LogAttempt(models.TaskLog{
-							Timestamp: time.Now(),
-							Comment:   "task caused a panic in worker handler",
-						})
-
-						uctx, cancel := context.WithTimeout(ctx, q.workerTimeout)
-						defer cancel()
-
-						err = coreClient.Database().UpdateTasks(uctx, task)
-						if err != nil {
-							event.AnErr("updateTasks", err).Str("additional", "failed to update a task")
-						}
-					}
-				}()
-
-				coreClient, err := q.newCoreClient()
-				if err != nil {
-					log.Err(err).Msg("failed to create a new core client for a task worker")
-					return
+				if onComplete != nil {
+					onComplete(task.ID)
 				}
+			}()
 
-				task.TriesLeft -= 1
-				handler, ok := q.handlers[task.Type]
-				if !ok {
-					task.Status = models.TaskStatusFailed
-					task.LogAttempt(models.TaskLog{
-						Error:     "task missing a handler",
-						Comment:   "task missing a handler",
-						Timestamp: time.Now(),
-					})
-
-					uctx, cancel := context.WithTimeout(ctx, q.workerTimeout)
-					defer cancel()
-
-					err := coreClient.Database().UpdateTasks(uctx, task)
-					if err != nil {
-						log.Err(err).Msg("failed to update a task")
-					}
-					return
-				}
+			coreClient, err := q.newCoreClient()
+			if err != nil {
+				log.Err(err).Msg("failed to create a new core client for a task worker")
+				return
+			}
+			go q.processTask(coreClient, task)
 
-				wctx, cancel := context.WithTimeout(ctx, q.workerTimeout)
-				defer cancel()
+		case <-ctx.Done():
+			return
+		}
+	}
+}
 
-				err = handler.Process(wctx, coreClient, &task)
-				task.Status = models.TaskStatusComplete
-				l := models.TaskLog{
-					Timestamp: time.Now(),
-					Comment:   "task handler finished",
-				}
-				if err != nil {
-					l.Error = err.Error()
-					if task.TriesLeft > 0 {
-						task.Status = models.TaskStatusScheduled
-						task.ScheduledAfter = time.Now().Add(time.Minute * 5)
-					} else {
-						task.Status = models.TaskStatusFailed
-					}
-				}
-				task.LogAttempt(l)
+func (q *queue) processTask(coreClient core.Client, task models.Task) {
+	log.Debug().Str("taskId", task.ID).Msg("worker started processing a task")
+	defer log.Debug().Str("taskId", task.ID).Msg("worker finished processing a task")
 
-				uctx, cancel := context.WithTimeout(ctx, q.workerTimeout)
-				defer cancel()
+	defer func() {
+		if r := recover(); r != nil {
+			event := log.Error().Str("stack", string(debug.Stack())).Str("taskId", task.ID)
+			defer event.Msg("panic in queue worker")
 
-				err = coreClient.Database().UpdateTasks(uctx, task)
-				if err != nil {
-					log.Err(err).Msg("failed to update a task")
-				}
-			}()
+			coreClient, err := q.newCoreClient()
+			if err != nil {
+				event.AnErr("core", err).Str("additional", "failed to create a core client")
+				return
+			}
+			task.Status = models.TaskStatusFailed
+			task.LogAttempt(models.TaskLog{
+				Timestamp: time.Now(),
+				Comment:   "task caused a panic in worker handler",
+			})
+
+			uctx, cancel := context.WithTimeout(context.Background(), time.Second*15)
+			defer cancel()
+
+			err = coreClient.Database().UpdateTasks(uctx, task)
+			if err != nil {
+				event.AnErr("updateTasks", err).Str("additional", "failed to update a task")
+			}
+		}
+	}()
+
+	task.TriesLeft -= 1
+	handler, ok := q.handlers[task.Type]
+	if !ok {
+		task.Status = models.TaskStatusFailed
+		task.LogAttempt(models.TaskLog{
+			Error:     "task missing a handler",
+			Comment:   "task missing a handler",
+			Timestamp: time.Now(),
+		})
+
+		uctx, cancel := context.WithTimeout(context.Background(), time.Second*15)
+		defer cancel()
 
-		case <-ctx.Done():
-			return
+		err := coreClient.Database().UpdateTasks(uctx, task)
+		if err != nil {
+			log.Err(err).Msg("failed to update a task")
 		}
+		return
 	}
+
+	wctx, cancel := context.WithTimeout(context.Background(), q.workerTimeout)
+	defer cancel()
+
+	err := handler.Process(wctx, coreClient, &task)
+	task.Status = models.TaskStatusComplete
+	l := models.TaskLog{
+		Timestamp: time.Now(),
+		Comment:   "task handler finished",
+	}
+	if err != nil {
+		l.Error = err.Error()
+		if task.TriesLeft > 0 {
+			task.Status = models.TaskStatusScheduled
+			task.ScheduledAfter = time.Now().Add(time.Minute * 5)
+		} else {
+			task.Status = models.TaskStatusFailed
+		}
+	}
+	task.LogAttempt(l)
+
+	uctx, cancel := context.WithTimeout(context.Background(), time.Second*15)
+	defer cancel()
+
+	err = coreClient.Database().UpdateTasks(uctx, task)
+	if err != nil {
+		log.Err(err).Msg("failed to update a task")
+	}
+
 }
diff --git a/cmd/frontend/components/navbar.templ b/cmd/frontend/components/navbar.templ
index 09b4fa99..b3145190 100644
--- a/cmd/frontend/components/navbar.templ
+++ b/cmd/frontend/components/navbar.templ
@@ -31,20 +31,36 @@ templ navbar(props navbarProps) {
 	<div class="no-animation" hx-boost="true">
 		<div class="navbar bg-base-100 gap-1">
 			<div class="navbar-start gap-1">
-				@Logo("32")
-				<div class="flex-1">
-					<a class="btn btn-ghost text-xl" href="/">Aftermath</a>
-				</div>
+				<a href="/" class="px-2">
+					@Logo("32")
+				</a>
 			</div>
 			<div class="navbar-center">
 				<div class="form-control">
-					<input type="text" placeholder="Search Players" class="input input-bordered w-24 md:w-auto"/>
+					<input type="text" placeholder="Search Players" class="input input-bordered w-48 md:w-auto placeholder:text-center"/>
 				</div>
 			</div>
-			<ul class="navbar-end menu menu-horizontal px-1 gap-1">
+			<ul class="navbar-end menu menu-horizontal px-1 gap-1 hidden md:flex">
 				<li><a href="/widget" class={ logic.StringIfElse("active", "", props.path == "/widget") }>Widget</a></li>
 				<li><a href="/login" class={ logic.StringIfElse("btn active", "btn", props.path == "/login") }>Login</a></li>
 			</ul>
+			<ul class="navbar-end menu menu-horizontal px-1 gap-1 md:hidden">
+				<button class="btn btn-square btn-ghost">
+					<svg
+						xmlns="http://www.w3.org/2000/svg"
+						fill="none"
+						viewBox="0 0 24 24"
+						class="inline-block h-5 w-5 stroke-current"
+					>
+						<path
+							stroke-linecap="round"
+							stroke-linejoin="round"
+							stroke-width="2"
+							d="M4 6h16M4 12h16M4 18h16"
+						></path>
+					</svg>
+				</button>
+			</ul>
 		</div>
 	</div>
 }
diff --git a/cmd/frontend/components/navbar_templ.go b/cmd/frontend/components/navbar_templ.go
index 2d384ef6..66d0cbd5 100644
--- a/cmd/frontend/components/navbar_templ.go
+++ b/cmd/frontend/components/navbar_templ.go
@@ -53,7 +53,7 @@ func navbar(props navbarProps) templ.Component {
 			templ_7745c5c3_Var1 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"no-animation\" hx-boost=\"true\"><div class=\"navbar bg-base-100 gap-1\"><div class=\"navbar-start gap-1\">")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"no-animation\" hx-boost=\"true\"><div class=\"navbar bg-base-100 gap-1\"><div class=\"navbar-start gap-1\"><a href=\"/\" class=\"px-2\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -61,7 +61,7 @@ func navbar(props navbarProps) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex-1\"><a class=\"btn btn-ghost text-xl\" href=\"/\">Aftermath</a></div></div><div class=\"navbar-center\"><div class=\"form-control\"><input type=\"text\" placeholder=\"Search Players\" class=\"input input-bordered w-24 md:w-auto\"></div></div><ul class=\"navbar-end menu menu-horizontal px-1 gap-1\"><li>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</a></div><div class=\"navbar-center\"><div class=\"form-control\"><input type=\"text\" placeholder=\"Search Players\" class=\"input input-bordered w-48 md:w-auto placeholder:text-center\"></div></div><ul class=\"navbar-end menu menu-horizontal px-1 gap-1 hidden md:flex\"><li>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -105,7 +105,7 @@ func navbar(props navbarProps) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\">Login</a></li></ul></div></div>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\">Login</a></li></ul><ul class=\"navbar-end menu menu-horizontal px-1 gap-1 md:hidden\"><button class=\"btn btn-square btn-ghost\"><svg xmlns=\"http://www.w3.org/2000/svg\" fill=\"none\" viewBox=\"0 0 24 24\" class=\"inline-block h-5 w-5 stroke-current\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M4 6h16M4 12h16M4 18h16\"></path></svg></button></ul></div></div>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -165,7 +165,7 @@ func navMenuLink(label, href, currentPath string) templ.Component {
 		var templ_7745c5c3_Var10 string
 		templ_7745c5c3_Var10, templ_7745c5c3_Err = templ.JoinStringErrs(label)
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/navbar.templ`, Line: 53, Col: 78}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/navbar.templ`, Line: 69, Col: 78}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var10))
 		if templ_7745c5c3_Err != nil {
diff --git a/cmd/frontend/components/obs.templ b/cmd/frontend/components/obs.templ
new file mode 100644
index 00000000..b124f529
--- /dev/null
+++ b/cmd/frontend/components/obs.templ
@@ -0,0 +1,71 @@
+package components
+
+templ OBSMockup(backgroundURL string) {
+	<div class="mockup-window bg-base-300 rounded-xl overflow-hidden w-full">
+		<div class="flex flex-col p-4 pt-0 gap-2">
+			<div class="grow relative aspect-video rounded-md overflow-hidden">
+				if backgroundURL == "" {
+					<div class="absolute w-1/2 h-full bg-gray-300 left-0 top-0 z-10"></div>
+					<div class="absolute w-1/2 h-full bg-gray-600 right-0 top-0 z-0"></div>
+				} else {
+					<img src={ backgroundURL } class="object-cover absolute laft-0 top-0 z-0 w-full h-full"/>
+				}
+				<div class="relative z-10 p-2 flex items-center justify-center h-full">
+					{ children... }
+				</div>
+			</div>
+			<div class="grow flex flex-row gap-1 text-xs">
+				<div class="grow flex flex-col gap-1 bg-base-200 p-2 rounded-md">
+					<div class="bg-gray-700 rounded-full px-2 py-1 whitespace-nowrap">
+						❤︎ Aftermath
+					</div>
+					@buttonMockup()
+					@buttonMockup()
+				</div>
+				<div class="grow flex flex-col gap-1 bg-base-200 p-2 rounded-md">
+					<div class="bg-gray-800 rounded-full px-2 py-1">
+						<span class="line-clamp-1 break-all whitespace-normal">
+							amth.one/widget
+						</span>
+					</div>
+					@buttonMockup()
+					@buttonMockup()
+				</div>
+				<div class="grow flex flex-col gap-2 bg-base-200 p-2 rounded-md">
+					<div class="flex flex-col gap-1">
+						<div class="h-1 min-w-12 w-full bg-gray-700 rounded-full">
+							<div class="w-2/3 h-1 rounded-full bg-green-600"></div>
+						</div>
+						<div class="h-1 flex flex-row gap-1">
+							<div class="grow rounded-full bg-blue-600"></div>
+							<div class="w-1 h-1 rounded-full bg-red-600"></div>
+						</div>
+					</div>
+					<div class="flex flex-col gap-1">
+						<div class="h-1 min-w-12 w-full bg-gray-700 rounded-full">
+							<div class="w-1/4 h-1 rounded-full bg-green-600"></div>
+						</div>
+						<div class="h-1 flex flex-row gap-1">
+							<div class="grow rounded-full bg-blue-600"></div>
+							<div class="w-1 h-1 rounded-full bg-red-600"></div>
+						</div>
+					</div>
+				</div>
+				<div class="grow hidden sm:flex flex-col gap-1 bg-base-200 p-2 rounded-md text-center max-w-24">
+					<div class="h-4 min-w-12 w-full bg-gray-800 rounded-full flex flex-row gap-1 items-center px-1">
+						<div class="h-2 w-2 rounded-full bg-red-500"></div>
+						<div class="h-1 min-w-8 grow bg-gray-500 rounded-full"></div>
+					</div>
+					@buttonMockup()
+					@buttonMockup()
+				</div>
+			</div>
+		</div>
+	</div>
+}
+
+templ buttonMockup() {
+	<div class="min-w-12 w-full bg-gray-800 rounded-full flex items-center p-1">
+		<div class="h-1 min-w-8 grow bg-gray-500 rounded-full"></div>
+	</div>
+}
diff --git a/cmd/frontend/components/obs_templ.go b/cmd/frontend/components/obs_templ.go
new file mode 100644
index 00000000..d3ee9522
--- /dev/null
+++ b/cmd/frontend/components/obs_templ.go
@@ -0,0 +1,133 @@
+// Code generated by templ - DO NOT EDIT.
+
+// templ: version: v0.2.731
+package components
+
+//lint:file-ignore SA4006 This context is only used if a nested component is present.
+
+import "github.com/a-h/templ"
+import templruntime "github.com/a-h/templ/runtime"
+
+func OBSMockup(backgroundURL string) templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var1 == nil {
+			templ_7745c5c3_Var1 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"mockup-window bg-base-300 rounded-xl overflow-hidden w-full\"><div class=\"flex flex-col p-4 pt-0 gap-2\"><div class=\"grow relative aspect-video rounded-md overflow-hidden\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		if backgroundURL == "" {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"absolute w-1/2 h-full bg-gray-300 left-0 top-0 z-10\"></div><div class=\"absolute w-1/2 h-full bg-gray-600 right-0 top-0 z-0\"></div>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		} else {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<img src=\"")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			var templ_7745c5c3_Var2 string
+			templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(backgroundURL)
+			if templ_7745c5c3_Err != nil {
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/obs.templ`, Line: 11, Col: 29}
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\" class=\"object-cover absolute laft-0 top-0 z-0 w-full h-full\">")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"relative z-10 p-2 flex items-center justify-center h-full\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = templ_7745c5c3_Var1.Render(ctx, templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></div><div class=\"grow flex flex-row gap-1 text-xs\"><div class=\"grow flex flex-col gap-1 bg-base-200 p-2 rounded-md\"><div class=\"bg-gray-700 rounded-full px-2 py-1 whitespace-nowrap\">❤︎ Aftermath</div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = buttonMockup().Render(ctx, templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = buttonMockup().Render(ctx, templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div><div class=\"grow flex flex-col gap-1 bg-base-200 p-2 rounded-md\"><div class=\"bg-gray-800 rounded-full px-2 py-1\"><span class=\"line-clamp-1 break-all whitespace-normal\">amth.one/widget</span></div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = buttonMockup().Render(ctx, templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = buttonMockup().Render(ctx, templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div><div class=\"grow flex flex-col gap-2 bg-base-200 p-2 rounded-md\"><div class=\"flex flex-col gap-1\"><div class=\"h-1 min-w-12 w-full bg-gray-700 rounded-full\"><div class=\"w-2/3 h-1 rounded-full bg-green-600\"></div></div><div class=\"h-1 flex flex-row gap-1\"><div class=\"grow rounded-full bg-blue-600\"></div><div class=\"w-1 h-1 rounded-full bg-red-600\"></div></div></div><div class=\"flex flex-col gap-1\"><div class=\"h-1 min-w-12 w-full bg-gray-700 rounded-full\"><div class=\"w-1/4 h-1 rounded-full bg-green-600\"></div></div><div class=\"h-1 flex flex-row gap-1\"><div class=\"grow rounded-full bg-blue-600\"></div><div class=\"w-1 h-1 rounded-full bg-red-600\"></div></div></div></div><div class=\"grow hidden sm:flex flex-col gap-1 bg-base-200 p-2 rounded-md text-center max-w-24\"><div class=\"h-4 min-w-12 w-full bg-gray-800 rounded-full flex flex-row gap-1 items-center px-1\"><div class=\"h-2 w-2 rounded-full bg-red-500\"></div><div class=\"h-1 min-w-8 grow bg-gray-500 rounded-full\"></div></div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = buttonMockup().Render(ctx, templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = buttonMockup().Render(ctx, templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></div></div></div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return templ_7745c5c3_Err
+	})
+}
+
+func buttonMockup() templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var3 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var3 == nil {
+			templ_7745c5c3_Var3 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"min-w-12 w-full bg-gray-800 rounded-full flex items-center p-1\"><div class=\"h-1 min-w-8 grow bg-gray-500 rounded-full\"></div></div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return templ_7745c5c3_Err
+	})
+}
diff --git a/cmd/frontend/handlers.go b/cmd/frontend/handlers.go
index 62dfec16..eb3c3d09 100644
--- a/cmd/frontend/handlers.go
+++ b/cmd/frontend/handlers.go
@@ -59,6 +59,10 @@ func Handlers(core core.Client) ([]server.Handler, error) {
 			Func: handler.Chain(core, routes.Login),
 		},
 		// widget
+		{
+			Path: get("/widget"),
+			Func: handler.Chain(core, widget.WidgetHome),
+		},
 		{
 			Path: get("/widget/{accountId}"),
 			Func: handler.Chain(core, widget.ConfigureWidget),
diff --git a/cmd/frontend/layouts/main.templ b/cmd/frontend/layouts/main.templ
index 252ea782..dc9b6a2f 100644
--- a/cmd/frontend/layouts/main.templ
+++ b/cmd/frontend/layouts/main.templ
@@ -33,9 +33,11 @@ templ main(navbar templ.Component, children ...templ.Component) {
 			@logic.EmbedMinifiedScript(tailwindConfig())
 			<title>{ appName }</title>
 		</head>
-		<body hx-ext="multi-swap,head-support">
-			<main class="mx-auto min-h-screen max-w-7xl p-2 flex flex-col gap-2 underline-offset-4">
+		<body hx-ext="multi-swap,head-support" class="min-h-screen flex flex-col">
+			<div class="max-w-7xl w-full mx-auto">
 				@navbar
+			</div>
+			<main class="mx-auto max-w-7xl w-full grow flex flex-col gap-2 underline-offset-4 p-4">
 				for _, render := range children {
 					@render
 				}
diff --git a/cmd/frontend/layouts/main_templ.go b/cmd/frontend/layouts/main_templ.go
index f38cdafb..ec95d7dc 100644
--- a/cmd/frontend/layouts/main_templ.go
+++ b/cmd/frontend/layouts/main_templ.go
@@ -65,7 +65,7 @@ func main(navbar templ.Component, children ...templ.Component) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</title></head><body hx-ext=\"multi-swap,head-support\"><main class=\"mx-auto min-h-screen max-w-7xl p-2 flex flex-col gap-2 underline-offset-4\">")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</title></head><body hx-ext=\"multi-swap,head-support\" class=\"min-h-screen flex flex-col\"><div class=\"max-w-7xl w-full mx-auto\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -73,6 +73,10 @@ func main(navbar templ.Component, children ...templ.Component) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div><main class=\"mx-auto max-w-7xl w-full grow flex flex-col gap-2 underline-offset-4 p-4\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
 		for _, render := range children {
 			templ_7745c5c3_Err = render.Render(ctx, templ_7745c5c3_Buffer)
 			if templ_7745c5c3_Err != nil {
diff --git a/cmd/frontend/public/widget-background.jpg b/cmd/frontend/public/widget-background.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..3c9324e1140516813d8db897e3d44121c31bdd4d
GIT binary patch
literal 8506
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
EKf0)3FaQ7m

literal 0
HcmV?d00001

diff --git a/cmd/frontend/routes/api/widget/mock.go b/cmd/frontend/routes/api/widget/mock.go
new file mode 100644
index 00000000..57c413e2
--- /dev/null
+++ b/cmd/frontend/routes/api/widget/mock.go
@@ -0,0 +1,11 @@
+package widget
+
+import (
+	"github.com/a-h/templ"
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+)
+
+var MockWidget handler.Partial = func(ctx *handler.Context) (templ.Component, error) {
+
+	return nil, nil
+}
diff --git a/cmd/frontend/routes/errors.templ b/cmd/frontend/routes/errors.templ
index f299728e..178c3269 100644
--- a/cmd/frontend/routes/errors.templ
+++ b/cmd/frontend/routes/errors.templ
@@ -7,28 +7,36 @@ import (
 
 var GenericError handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
 	message := ctx.Query("message")
-
-	// ctx.SetStatus(http.StatusInternalServerError)
-	return layouts.Main, errorPage(message), nil
+	return layouts.Main, genericErrorPage(message), nil
 }
 
-templ errorPage(message string) {
-	<div class="flex flex-col gap-2">
-		<span>Something did not work</span>
-		<span>{ message }</span>
-	</div>
+templ genericErrorPage(message string) {
+	@errorPage("500", message) {
+		Something unexpected happened while working on your request. You can reach out to our team on <a href="/join" class="link">Aftermath Official</a> to report this issue.
+	}
 }
 
 var ErrorNotFound handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
-	path := ctx.Path("pathname")
+	message := "/" + ctx.Path("pathname") + " does not exist"
+	return layouts.Main, notFoundPage(message), nil
+}
 
-	// ctx.SetStatus(http.StatusNotFound)
-	return layouts.Main, notFoundPage(path), nil
+templ notFoundPage(message string) {
+	@errorPage("404", message) {
+		Sorry, we couldn't find this page. But don't worry, you can find plenty of other things on our <a href="/" class="link">homepage</a>.
+	}
 }
 
-templ notFoundPage(path string) {
-	<div class="flex flex-col gap-2">
-		<span>404 - Not Found</span>
-		<span>/{ path }</span>
+templ errorPage(title string, context string) {
+	<div class="flex flex-col gap-8 items-center justify-center p-8">
+		<div class="flex flex-col items-center gap-2">
+			<span class="font-bold text-7xl">{ title }</span>
+			<span class="text-xl max-w-2xl text-center">
+				{ children... }
+			</span>
+		</div>
+		<span class="text-sm text-dark">
+			{ context }
+		</span>
 	</div>
 }
diff --git a/cmd/frontend/routes/errors_templ.go b/cmd/frontend/routes/errors_templ.go
index e6a3617b..e2c174e5 100644
--- a/cmd/frontend/routes/errors_templ.go
+++ b/cmd/frontend/routes/errors_templ.go
@@ -15,12 +15,10 @@ import (
 
 var GenericError handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
 	message := ctx.Query("message")
-
-	// ctx.SetStatus(http.StatusInternalServerError)
-	return layouts.Main, errorPage(message), nil
+	return layouts.Main, genericErrorPage(message), nil
 }
 
-func errorPage(message string) templ.Component {
+func genericErrorPage(message string) templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
@@ -38,20 +36,25 @@ func errorPage(message string) templ.Component {
 			templ_7745c5c3_Var1 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-col gap-2\"><span>Something did not work</span> <span>")
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		var templ_7745c5c3_Var2 string
-		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(message)
-		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/errors.templ`, Line: 18, Col: 17}
-		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
-		if templ_7745c5c3_Err != nil {
+		templ_7745c5c3_Var2 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+			templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+			templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+			if !templ_7745c5c3_IsBuffer {
+				defer func() {
+					templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+					if templ_7745c5c3_Err == nil {
+						templ_7745c5c3_Err = templ_7745c5c3_BufErr
+					}
+				}()
+			}
+			ctx = templ.InitializeContext(ctx)
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("Something unexpected happened while working on your request. You can reach out to our team on <a href=\"/join\" class=\"link\">Aftermath Official</a> to report this issue.")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
 			return templ_7745c5c3_Err
-		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</span></div>")
+		})
+		templ_7745c5c3_Err = errorPage("500", message).Render(templ.WithChildren(ctx, templ_7745c5c3_Var2), templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -60,13 +63,11 @@ func errorPage(message string) templ.Component {
 }
 
 var ErrorNotFound handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
-	path := ctx.Path("pathname")
-
-	// ctx.SetStatus(http.StatusNotFound)
-	return layouts.Main, notFoundPage(path), nil
+	message := "/" + ctx.Path("pathname") + " does not exist"
+	return layouts.Main, notFoundPage(message), nil
 }
 
-func notFoundPage(path string) templ.Component {
+func notFoundPage(message string) templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
@@ -84,16 +85,81 @@ func notFoundPage(path string) templ.Component {
 			templ_7745c5c3_Var3 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-col gap-2\"><span>404 - Not Found</span> <span>/")
+		templ_7745c5c3_Var4 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+			templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+			templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+			if !templ_7745c5c3_IsBuffer {
+				defer func() {
+					templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+					if templ_7745c5c3_Err == nil {
+						templ_7745c5c3_Err = templ_7745c5c3_BufErr
+					}
+				}()
+			}
+			ctx = templ.InitializeContext(ctx)
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("Sorry, we couldn't find this page. But don't worry, you can find plenty of other things on our <a href=\"/\" class=\"link\">homepage</a>.")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			return templ_7745c5c3_Err
+		})
+		templ_7745c5c3_Err = errorPage("404", message).Render(templ.WithChildren(ctx, templ_7745c5c3_Var4), templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return templ_7745c5c3_Err
+	})
+}
+
+func errorPage(title string, context string) templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var5 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var5 == nil {
+			templ_7745c5c3_Var5 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-col gap-8 items-center justify-center p-8\"><div class=\"flex flex-col items-center gap-2\"><span class=\"font-bold text-7xl\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var6 string
+		templ_7745c5c3_Var6, templ_7745c5c3_Err = templ.JoinStringErrs(title)
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/errors.templ`, Line: 33, Col: 43}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var6))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</span> <span class=\"text-xl max-w-2xl text-center\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = templ_7745c5c3_Var5.Render(ctx, templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</span></div><span class=\"text-sm text-dark\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var4 string
-		templ_7745c5c3_Var4, templ_7745c5c3_Err = templ.JoinStringErrs(path)
+		var templ_7745c5c3_Var7 string
+		templ_7745c5c3_Var7, templ_7745c5c3_Err = templ.JoinStringErrs(context)
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/errors.templ`, Line: 32, Col: 15}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/errors.templ`, Line: 39, Col: 12}
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var4))
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var7))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
diff --git a/cmd/frontend/routes/widget/index.templ b/cmd/frontend/routes/widget/index.templ
new file mode 100644
index 00000000..2180b095
--- /dev/null
+++ b/cmd/frontend/routes/widget/index.templ
@@ -0,0 +1,35 @@
+package widget
+
+import (
+	"github.com/cufee/aftermath/cmd/frontend/components"
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/cmd/frontend/layouts"
+)
+
+var WidgetHome handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
+
+	return layouts.Main, widgetHome(), nil
+}
+
+templ widgetHome() {
+	<div class="flex flex-row justify-center gap-4 flex-wrap">
+		<div class="flex flex-row flex-wrap md:flex-nowrap gap-4">
+			<div class="grow">
+				Amet cillum fugiat ut eu enim dolor nulla minim. Officia veniam esse exercitation elit consequat voluptate cillum ex. Ut aute nulla ipsum in sint enim et amet nisi irure. Nulla tempor enim ut reprehenderit excepteur ad aute eu fugiat cupidatat et eu magna officia. Aute aute quis ea anim. Ipsum aliqua officia qui id dolore ullamco ipsum ipsum esse laborum. Minim Lorem ex cupidatat elit Lorem consequat deserunt cillum.
+				Laboris esse do non dolor reprehenderit excepteur ea eiusmod incididunt sit eu tempor consectetur reprehenderit. Dolore est exercitation ullamco magna adipisicing dolor ea esse sit fugiat sint enim in irure. Aliquip ea ea magna irure amet dolore. Lorem anim ad enim reprehenderit officia et magna pariatur dolore ex quis sint. Quis duis aliqua do ipsum enim cillum.
+			</div>
+			<div class="flex items-center justify-center grow">
+				<div>
+					@components.OBSMockup("/assets/widget-background.jpg") {
+						<div>
+							<span class="text-white">content</span>
+						</div>
+					}
+				</div>
+			</div>
+		</div>
+		<div class="flex">
+			// account input
+		</div>
+	</div>
+}
diff --git a/cmd/frontend/routes/widget/index_templ.go b/cmd/frontend/routes/widget/index_templ.go
new file mode 100644
index 00000000..d0ccd481
--- /dev/null
+++ b/cmd/frontend/routes/widget/index_templ.go
@@ -0,0 +1,72 @@
+// Code generated by templ - DO NOT EDIT.
+
+// templ: version: v0.2.731
+package widget
+
+//lint:file-ignore SA4006 This context is only used if a nested component is present.
+
+import "github.com/a-h/templ"
+import templruntime "github.com/a-h/templ/runtime"
+
+import (
+	"github.com/cufee/aftermath/cmd/frontend/components"
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/cmd/frontend/layouts"
+)
+
+var WidgetHome handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
+
+	return layouts.Main, widgetHome(), nil
+}
+
+func widgetHome() templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var1 == nil {
+			templ_7745c5c3_Var1 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-row justify-center gap-4 flex-wrap\"><div class=\"flex flex-row flex-wrap md:flex-nowrap gap-4\"><div class=\"grow\">Amet cillum fugiat ut eu enim dolor nulla minim. Officia veniam esse exercitation elit consequat voluptate cillum ex. Ut aute nulla ipsum in sint enim et amet nisi irure. Nulla tempor enim ut reprehenderit excepteur ad aute eu fugiat cupidatat et eu magna officia. Aute aute quis ea anim. Ipsum aliqua officia qui id dolore ullamco ipsum ipsum esse laborum. Minim Lorem ex cupidatat elit Lorem consequat deserunt cillum. Laboris esse do non dolor reprehenderit excepteur ea eiusmod incididunt sit eu tempor consectetur reprehenderit. Dolore est exercitation ullamco magna adipisicing dolor ea esse sit fugiat sint enim in irure. Aliquip ea ea magna irure amet dolore. Lorem anim ad enim reprehenderit officia et magna pariatur dolore ex quis sint. Quis duis aliqua do ipsum enim cillum.</div><div class=\"flex items-center justify-center grow\"><div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Var2 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+			templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+			templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+			if !templ_7745c5c3_IsBuffer {
+				defer func() {
+					templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+					if templ_7745c5c3_Err == nil {
+						templ_7745c5c3_Err = templ_7745c5c3_BufErr
+					}
+				}()
+			}
+			ctx = templ.InitializeContext(ctx)
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div><span class=\"text-white\">content</span></div>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			return templ_7745c5c3_Err
+		})
+		templ_7745c5c3_Err = components.OBSMockup("/assets/widget-background.jpg").Render(templ.WithChildren(ctx, templ_7745c5c3_Var2), templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></div></div><div class=\"flex\"></div></div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return templ_7745c5c3_Err
+	})
+}
diff --git a/docker-compose.yaml b/docker-compose.yaml
index ca895eef..6caba5f0 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -24,6 +24,8 @@ services:
     image: aftermath-service
     build:
       dockerfile: Dockerfile
+      args:
+        - GO_MEM_LIMIT=122MiB
     restart: always
     deploy:
       resources:

From 1711b91f3db8a9c62d3895dc4b75cd884f987f28 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 4 Jul 2024 14:29:27 -0400
Subject: [PATCH 249/341] adding map length

---
 .air.toml                                    | 2 +-
 .air.web.toml                                | 2 +-
 cmd/core/queue/queue.go                      | 2 +-
 cmd/core/server/handlers/private/accounts.go | 4 ++--
 internal/external/blitzstars/account.go      | 4 ++--
 internal/external/blitzstars/averages.go     | 4 ++--
 internal/external/blitzstars/client.go       | 4 ++--
 7 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/.air.toml b/.air.toml
index 57af028c..327c2ea5 100644
--- a/.air.toml
+++ b/.air.toml
@@ -2,7 +2,7 @@
 include_ext = ["go", "tmpl", "templ", "html"]
 exclude_regex = [".*_templ.go"]
 pre_cmd = ["templ generate"]
-cmd = "GODEBUG=gctrace=1 go build -o ./tmp/main ."
+cmd = "go build -gcflags '-m' -o ./tmp/main ."
 send_interrupt = true
 stop_on_error = true
 
diff --git a/.air.web.toml b/.air.web.toml
index 3b69524b..c61c6803 100644
--- a/.air.web.toml
+++ b/.air.web.toml
@@ -4,7 +4,7 @@ exclude_regex = [".*_templ.go"]
 pre_cmd = ["templ generate"]
 send_interrupt = true
 stop_on_error = true
-cmd = "go build -o ./tmp/web dev_web.go"
+cmd = "go build -gcflags '-m' -o ./tmp/main ."
 bin = "tmp/web"
 
 [proxy]
diff --git a/cmd/core/queue/queue.go b/cmd/core/queue/queue.go
index ebbbc6e2..7c23ca99 100644
--- a/cmd/core/queue/queue.go
+++ b/cmd/core/queue/queue.go
@@ -33,7 +33,7 @@ type queue struct {
 func New(workerLimit int, newCoreClient func() (core.Client, error)) *queue {
 	return &queue{
 		newCoreClient: newCoreClient,
-		handlers:      make(map[models.TaskType]tasks.TaskHandler),
+		handlers:      make(map[models.TaskType]tasks.TaskHandler, 10),
 
 		workerLimit:   workerLimit,
 		workerTimeout: time.Second * 60, // a single cron scheduler cycle
diff --git a/cmd/core/server/handlers/private/accounts.go b/cmd/core/server/handlers/private/accounts.go
index d42b260b..9bfb47f1 100644
--- a/cmd/core/server/handlers/private/accounts.go
+++ b/cmd/core/server/handlers/private/accounts.go
@@ -44,7 +44,7 @@ func LoadAccountsHandler(client core.Client) http.HandlerFunc {
 				existingMap[a.ID] = struct{}{}
 			}
 
-			accountsByRealm := make(map[string][]string)
+			accountsByRealm := make(map[string][]string, len(accounts))
 			for _, a := range accounts {
 				if _, ok := existingMap[a]; ok {
 					continue
@@ -57,7 +57,7 @@ func LoadAccountsHandler(client core.Client) http.HandlerFunc {
 			batchSize := 50
 			var wg sync.WaitGroup
 			sem := semaphore.NewWeighted(5)
-			errors := make(map[string]error)
+			errors := make(map[string]error, len(accountsByRealm))
 			var errorsMx sync.Mutex
 
 			for realm, accounts := range accountsByRealm {
diff --git a/internal/external/blitzstars/account.go b/internal/external/blitzstars/account.go
index 6c63ecb2..3c20d585 100644
--- a/internal/external/blitzstars/account.go
+++ b/internal/external/blitzstars/account.go
@@ -17,7 +17,7 @@ type TankHistoryEntry struct {
 	Stats           types.StatsFrame `json:"all"`
 }
 
-func (c *client) AccountTankHistories(ctx context.Context, accountId string) (map[int][]TankHistoryEntry, error) {
+func (c client) AccountTankHistories(ctx context.Context, accountId string) (map[int][]TankHistoryEntry, error) {
 	req, err := http.NewRequest("GET", fmt.Sprintf("%s/tankhistories/for/%s", c.apiURL, accountId), nil)
 	if err != nil {
 		return nil, err
@@ -38,7 +38,7 @@ func (c *client) AccountTankHistories(ctx context.Context, accountId string) (ma
 		return nil, err
 	}
 
-	var historiesMap = make(map[int][]TankHistoryEntry)
+	var historiesMap = make(map[int][]TankHistoryEntry, len(histories))
 	for _, entry := range histories {
 		historiesMap[entry.TankID] = append(historiesMap[entry.TankID], entry)
 	}
diff --git a/internal/external/blitzstars/averages.go b/internal/external/blitzstars/averages.go
index b7ddddb4..d206b4d4 100644
--- a/internal/external/blitzstars/averages.go
+++ b/internal/external/blitzstars/averages.go
@@ -33,7 +33,7 @@ type VehicleAverages struct {
 	} `json:"special,omitempty"`
 }
 
-func (c *client) CurrentTankAverages(ctx context.Context) (map[string]frame.StatsFrame, error) {
+func (c client) CurrentTankAverages(ctx context.Context) (map[string]frame.StatsFrame, error) {
 	req, err := http.NewRequest("GET", c.apiURL+"/tankaverages.json", nil)
 	if err != nil {
 		return nil, err
@@ -55,7 +55,7 @@ func (c *client) CurrentTankAverages(ctx context.Context) (map[string]frame.Stat
 		return nil, err
 	}
 
-	averagesMap := make(map[string]frame.StatsFrame)
+	averagesMap := make(map[string]frame.StatsFrame, len(averages))
 	for _, average := range averages {
 		battles := average.All.AvgBattles * float32(average.Players)
 
diff --git a/internal/external/blitzstars/client.go b/internal/external/blitzstars/client.go
index 2015050e..1b5a69c4 100644
--- a/internal/external/blitzstars/client.go
+++ b/internal/external/blitzstars/client.go
@@ -21,8 +21,8 @@ type client struct {
 	requestTimeout time.Duration
 }
 
-func NewClient(apiURL string, requestTimeout time.Duration) (*client, error) {
-	return &client{
+func NewClient(apiURL string, requestTimeout time.Duration) (client, error) {
+	return client{
 		apiURL:         apiURL,
 		requestTimeout: requestTimeout,
 		http:           http.Client{Timeout: requestTimeout},

From 8680f1893b50ca15c6803ab66c414a61bacac09c Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 4 Jul 2024 14:29:34 -0400
Subject: [PATCH 250/341] added missing length

---
 cmd/core/server/handlers/private/accounts.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cmd/core/server/handlers/private/accounts.go b/cmd/core/server/handlers/private/accounts.go
index 9bfb47f1..2281ae22 100644
--- a/cmd/core/server/handlers/private/accounts.go
+++ b/cmd/core/server/handlers/private/accounts.go
@@ -39,7 +39,7 @@ func LoadAccountsHandler(client core.Client) http.HandlerFunc {
 		log.Info().Int("count", len(accounts)-len(existing)).Msg("importing accounts")
 
 		go func(accounts []string, existing []models.Account) {
-			existingMap := make(map[string]struct{})
+			existingMap := make(map[string]struct{}, len(existing))
 			for _, a := range existing {
 				existingMap[a.ID] = struct{}{}
 			}

From b87e7275218708994a4bcac1e51071264bf3c4a2 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 4 Jul 2024 14:45:29 -0400
Subject: [PATCH 251/341] added hard mem limit

---
 docker-compose.yaml                       | 4 +++-
 internal/stats/render/common/v1/images.go | 4 ++++
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/docker-compose.yaml b/docker-compose.yaml
index 6caba5f0..9d7bcfce 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -30,7 +30,9 @@ services:
     deploy:
       resources:
         reservations:
-          memory: 128m
+          memory: 64m
+        limits:
+          memory: 156m
     networks:
       - dokploy-network
     labels:
diff --git a/internal/stats/render/common/v1/images.go b/internal/stats/render/common/v1/images.go
index c28f1ef7..8e5d9a01 100644
--- a/internal/stats/render/common/v1/images.go
+++ b/internal/stats/render/common/v1/images.go
@@ -157,6 +157,10 @@ func getDetailedSize(images []image.Image, style Style) imageSize {
 	var totalHeight float64
 	maxWidth, maxHeight := 0.0, 0.0
 	for _, img := range images {
+		if img == nil {
+			continue
+		}
+
 		imgX := float64(img.Bounds().Dx())
 		maxWidth = max(maxWidth, imgX)
 

From 4de2407fac84790edc98da51c2fa1768b3f51ed0 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 4 Jul 2024 14:45:57 -0400
Subject: [PATCH 252/341] added error on invalid font

---
 internal/stats/render/common/v1/block.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/internal/stats/render/common/v1/block.go b/internal/stats/render/common/v1/block.go
index 86d07cb9..3b2013b8 100644
--- a/internal/stats/render/common/v1/block.go
+++ b/internal/stats/render/common/v1/block.go
@@ -62,7 +62,7 @@ func NewTextContent(style Style, value string) Block {
 
 func (content contentText) Render(style Style) (image.Image, error) {
 	if !style.Font.Valid() {
-		// return nil, errors.New("font not valid")
+		return nil, errors.New("font not valid")
 	}
 
 	size := MeasureString(content.value, style.Font)

From f68c154bfe367caf6b98f5f69a509a6d62eb8dcb Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 4 Jul 2024 14:51:42 -0400
Subject: [PATCH 253/341] fixed queue deadlock

---
 cmd/core/queue/queue.go | 35 +++++++++++++++++++----------------
 1 file changed, 19 insertions(+), 16 deletions(-)

diff --git a/cmd/core/queue/queue.go b/cmd/core/queue/queue.go
index 7c23ca99..b45853cb 100644
--- a/cmd/core/queue/queue.go
+++ b/cmd/core/queue/queue.go
@@ -151,26 +151,23 @@ func (q *queue) startWorkers(ctx context.Context, onComplete func(id string)) {
 	for {
 		select {
 		case task := <-q.queued:
-			q.workerLimiter <- struct{}{}
-			q.activeTasksMx.Lock()
-			q.activeTasks[task.ID] = &struct{}{}
-			q.activeTasksMx.Unlock()
-			defer func() {
+			go func(task models.Task) {
+				// send to limiter channel
+				q.workerLimiter <- struct{}{}
+				q.activeTasksMx.Lock()
+				q.activeTasks[task.ID] = &struct{}{}
+				q.activeTasksMx.Unlock()
+				// run task handler
+				q.processTask(task)
+				// free limiter channel
 				<-q.workerLimiter
 				q.activeTasksMx.Lock()
 				delete(q.activeTasks, task.ID)
 				q.activeTasksMx.Unlock()
 				if onComplete != nil {
-					onComplete(task.ID)
+					go onComplete(task.ID)
 				}
-			}()
-
-			coreClient, err := q.newCoreClient()
-			if err != nil {
-				log.Err(err).Msg("failed to create a new core client for a task worker")
-				return
-			}
-			go q.processTask(coreClient, task)
+			}(task)
 
 		case <-ctx.Done():
 			return
@@ -178,10 +175,16 @@ func (q *queue) startWorkers(ctx context.Context, onComplete func(id string)) {
 	}
 }
 
-func (q *queue) processTask(coreClient core.Client, task models.Task) {
+func (q *queue) processTask(task models.Task) {
 	log.Debug().Str("taskId", task.ID).Msg("worker started processing a task")
 	defer log.Debug().Str("taskId", task.ID).Msg("worker finished processing a task")
 
+	coreClient, err := q.newCoreClient()
+	if err != nil {
+		log.Err(err).Msg("failed to create a new core client for a task worker")
+		return
+	}
+
 	defer func() {
 		if r := recover(); r != nil {
 			event := log.Error().Str("stack", string(debug.Stack())).Str("taskId", task.ID)
@@ -231,7 +234,7 @@ func (q *queue) processTask(coreClient core.Client, task models.Task) {
 	wctx, cancel := context.WithTimeout(context.Background(), q.workerTimeout)
 	defer cancel()
 
-	err := handler.Process(wctx, coreClient, &task)
+	err = handler.Process(wctx, coreClient, &task)
 	task.Status = models.TaskStatusComplete
 	l := models.TaskLog{
 		Timestamp: time.Now(),

From 1bbd147965324c46aa11278689c5a10e8a703799 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 4 Jul 2024 14:59:58 -0400
Subject: [PATCH 254/341] capturing body vars

---
 cmd/core/queue/queue.go | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/cmd/core/queue/queue.go b/cmd/core/queue/queue.go
index b45853cb..b8d311de 100644
--- a/cmd/core/queue/queue.go
+++ b/cmd/core/queue/queue.go
@@ -190,11 +190,6 @@ func (q *queue) processTask(task models.Task) {
 			event := log.Error().Str("stack", string(debug.Stack())).Str("taskId", task.ID)
 			defer event.Msg("panic in queue worker")
 
-			coreClient, err := q.newCoreClient()
-			if err != nil {
-				event.AnErr("core", err).Str("additional", "failed to create a core client")
-				return
-			}
 			task.Status = models.TaskStatusFailed
 			task.LogAttempt(models.TaskLog{
 				Timestamp: time.Now(),

From b226f6a73ddf050944ca9f1dc04ba6f1e3ee44ac Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 4 Jul 2024 15:01:36 -0400
Subject: [PATCH 255/341] removed boost from login

---
 cmd/frontend/components/navbar.templ    | 2 +-
 cmd/frontend/components/navbar_templ.go | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/cmd/frontend/components/navbar.templ b/cmd/frontend/components/navbar.templ
index b3145190..d96c1db4 100644
--- a/cmd/frontend/components/navbar.templ
+++ b/cmd/frontend/components/navbar.templ
@@ -42,7 +42,7 @@ templ navbar(props navbarProps) {
 			</div>
 			<ul class="navbar-end menu menu-horizontal px-1 gap-1 hidden md:flex">
 				<li><a href="/widget" class={ logic.StringIfElse("active", "", props.path == "/widget") }>Widget</a></li>
-				<li><a href="/login" class={ logic.StringIfElse("btn active", "btn", props.path == "/login") }>Login</a></li>
+				<li><a href="/login" hx-boost="false" class={ logic.StringIfElse("btn active", "btn", props.path == "/login") }>Login</a></li>
 			</ul>
 			<ul class="navbar-end menu menu-horizontal px-1 gap-1 md:hidden">
 				<button class="btn btn-square btn-ghost">
diff --git a/cmd/frontend/components/navbar_templ.go b/cmd/frontend/components/navbar_templ.go
index 66d0cbd5..fc1f0cda 100644
--- a/cmd/frontend/components/navbar_templ.go
+++ b/cmd/frontend/components/navbar_templ.go
@@ -92,7 +92,7 @@ func navbar(props navbarProps) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<a href=\"/login\" class=\"")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<a href=\"/login\" hx-boost=\"false\" class=\"")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}

From 1fff025c7d3bbea2ebb034d8c68542e79ac30611 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 4 Jul 2024 18:48:06 -0400
Subject: [PATCH 256/341] basic widget preview

---
 .air.web.toml                                 |   2 +-
 cmd/frontend/assets/widget.go                 |  51 +++++++
 cmd/frontend/components/obs.templ             |  18 +--
 cmd/frontend/components/obs_templ.go          |  18 ++-
 cmd/frontend/components/widget/default.templ  |  30 +++--
 .../components/widget/default_templ.go        |  48 ++++---
 cmd/frontend/components/widget/widget.templ   |  14 +-
 .../components/widget/widget_templ.go         |  20 +--
 cmd/frontend/handlers.go                      |   5 +
 cmd/frontend/routes/api/widget/mock.go        |  11 --
 cmd/frontend/routes/api/widget/mock.templ     |  28 ++++
 cmd/frontend/routes/api/widget/mock_templ.go  |  64 +++++++++
 cmd/frontend/routes/app/index.templ           |  33 +++--
 cmd/frontend/routes/app/index_templ.go        |  16 ++-
 cmd/frontend/routes/index.templ               |   6 +-
 cmd/frontend/routes/index_templ.go            |   6 +-
 cmd/frontend/routes/login.go                  |   5 +
 cmd/frontend/routes/widget/index.templ        |  83 +++++++++---
 cmd/frontend/routes/widget/index_templ.go     | 125 +++++++++++++++++-
 cmd/frontend/routes/widget/live.templ         |  14 +-
 cmd/frontend/routes/widget/live_templ.go      |  14 +-
 internal/database/models/account.go           |  16 +--
 internal/stats/frame/value.go                 |  10 ++
 .../stats/prepare/session/v1/constants.go     |  18 +--
 24 files changed, 520 insertions(+), 135 deletions(-)
 create mode 100644 cmd/frontend/assets/widget.go
 delete mode 100644 cmd/frontend/routes/api/widget/mock.go
 create mode 100644 cmd/frontend/routes/api/widget/mock.templ
 create mode 100644 cmd/frontend/routes/api/widget/mock_templ.go

diff --git a/.air.web.toml b/.air.web.toml
index c61c6803..3b69524b 100644
--- a/.air.web.toml
+++ b/.air.web.toml
@@ -4,7 +4,7 @@ exclude_regex = [".*_templ.go"]
 pre_cmd = ["templ generate"]
 send_interrupt = true
 stop_on_error = true
-cmd = "go build -gcflags '-m' -o ./tmp/main ."
+cmd = "go build -o ./tmp/web dev_web.go"
 bin = "tmp/web"
 
 [proxy]
diff --git a/cmd/frontend/assets/widget.go b/cmd/frontend/assets/widget.go
new file mode 100644
index 00000000..c2d0a8c4
--- /dev/null
+++ b/cmd/frontend/assets/widget.go
@@ -0,0 +1,51 @@
+package assets
+
+import (
+	"context"
+	"time"
+
+	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/localization"
+	"github.com/cufee/aftermath/internal/stats/fetch/v1"
+	"github.com/cufee/aftermath/internal/stats/prepare/common/v1"
+	"github.com/cufee/aftermath/internal/stats/prepare/session/v1"
+	"github.com/cufee/aftermath/tests"
+	"golang.org/x/text/language"
+)
+
+type mockWidget struct {
+	Account models.Account
+	Cards   session.Cards
+}
+
+var mockWidgetData *mockWidget
+
+func MockWidgetData() mockWidget {
+	if mockWidgetData == nil {
+		loadWidgetData()
+	}
+	return *mockWidgetData
+}
+
+func loadWidgetData() {
+	// TODO: need a better way to do this
+
+	mockWidgetData = &mockWidget{}
+	mockWidgetData.Account = models.Account{ID: "mock-account-id", Realm: "NA", Nickname: "@your_name", CreatedAt: time.Now(), LastBattleTime: time.Now(), ClanID: "mock-clan", ClanTag: "AMTH"}
+
+	sess, career, err := tests.StaticTestingFetch().SessionStats(context.Background(), tests.DefaultAccountNA, time.Time{}, fetch.WithWN8())
+	if err != nil {
+		panic(err)
+	}
+
+	printer, err := localization.NewPrinter("stats", language.English)
+	if err != nil {
+		panic(err)
+	}
+
+	cards, err := session.NewCards(sess, career, nil, common.WithPrinter(printer, language.English))
+	if err != nil {
+		panic(err)
+	}
+	mockWidgetData.Cards = cards
+}
diff --git a/cmd/frontend/components/obs.templ b/cmd/frontend/components/obs.templ
index b124f529..35bc4c8b 100644
--- a/cmd/frontend/components/obs.templ
+++ b/cmd/frontend/components/obs.templ
@@ -1,9 +1,12 @@
 package components
 
 templ OBSMockup(backgroundURL string) {
-	<div class="mockup-window bg-base-300 rounded-xl overflow-hidden w-full">
+	<div class="mockup-browser bg-base-300 rounded-xl overflow-hidden w-full h-full">
+		<div class="mockup-browser-toolbar">
+			<div class="w-full text-center mr-14">OBS Studio</div>
+		</div>
 		<div class="flex flex-col p-4 pt-0 gap-2">
-			<div class="grow relative aspect-video rounded-md overflow-hidden">
+			<div class="grow relative rounded-md overflow-hidden">
 				if backgroundURL == "" {
 					<div class="absolute w-1/2 h-full bg-gray-300 left-0 top-0 z-10"></div>
 					<div class="absolute w-1/2 h-full bg-gray-600 right-0 top-0 z-0"></div>
@@ -16,18 +19,15 @@ templ OBSMockup(backgroundURL string) {
 			</div>
 			<div class="grow flex flex-row gap-1 text-xs">
 				<div class="grow flex flex-col gap-1 bg-base-200 p-2 rounded-md">
-					<div class="bg-gray-700 rounded-full px-2 py-1 whitespace-nowrap">
+					<div class="bg-gray-700 rounded-full px-2 py-1 whitespace-nowrap text-center">
 						❤︎ Aftermath
 					</div>
 					@buttonMockup()
 					@buttonMockup()
 				</div>
 				<div class="grow flex flex-col gap-1 bg-base-200 p-2 rounded-md">
-					<div class="bg-gray-800 rounded-full px-2 py-1">
-						<span class="line-clamp-1 break-all whitespace-normal">
-							amth.one/widget
-						</span>
-					</div>
+					@buttonMockup()
+					@buttonMockup()
 					@buttonMockup()
 					@buttonMockup()
 				</div>
@@ -51,7 +51,7 @@ templ OBSMockup(backgroundURL string) {
 						</div>
 					</div>
 				</div>
-				<div class="grow hidden sm:flex flex-col gap-1 bg-base-200 p-2 rounded-md text-center max-w-24">
+				<div class="grow hidden sm:flex flex-col gap-1 bg-base-200 p-2 rounded-md text-center">
 					<div class="h-4 min-w-12 w-full bg-gray-800 rounded-full flex flex-row gap-1 items-center px-1">
 						<div class="h-2 w-2 rounded-full bg-red-500"></div>
 						<div class="h-1 min-w-8 grow bg-gray-500 rounded-full"></div>
diff --git a/cmd/frontend/components/obs_templ.go b/cmd/frontend/components/obs_templ.go
index d3ee9522..b47aab36 100644
--- a/cmd/frontend/components/obs_templ.go
+++ b/cmd/frontend/components/obs_templ.go
@@ -26,7 +26,7 @@ func OBSMockup(backgroundURL string) templ.Component {
 			templ_7745c5c3_Var1 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"mockup-window bg-base-300 rounded-xl overflow-hidden w-full\"><div class=\"flex flex-col p-4 pt-0 gap-2\"><div class=\"grow relative aspect-video rounded-md overflow-hidden\">")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"mockup-browser bg-base-300 rounded-xl overflow-hidden w-full h-full\"><div class=\"mockup-browser-toolbar\"><div class=\"w-full text-center mr-14\">OBS Studio</div></div><div class=\"flex flex-col p-4 pt-0 gap-2\"><div class=\"grow relative rounded-md overflow-hidden\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -43,7 +43,7 @@ func OBSMockup(backgroundURL string) templ.Component {
 			var templ_7745c5c3_Var2 string
 			templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(backgroundURL)
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/obs.templ`, Line: 11, Col: 29}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/obs.templ`, Line: 14, Col: 29}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
 			if templ_7745c5c3_Err != nil {
@@ -62,7 +62,7 @@ func OBSMockup(backgroundURL string) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></div><div class=\"grow flex flex-row gap-1 text-xs\"><div class=\"grow flex flex-col gap-1 bg-base-200 p-2 rounded-md\"><div class=\"bg-gray-700 rounded-full px-2 py-1 whitespace-nowrap\">❤︎ Aftermath</div>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></div><div class=\"grow flex flex-row gap-1 text-xs\"><div class=\"grow flex flex-col gap-1 bg-base-200 p-2 rounded-md\"><div class=\"bg-gray-700 rounded-full px-2 py-1 whitespace-nowrap text-center\">❤︎ Aftermath</div>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -74,7 +74,7 @@ func OBSMockup(backgroundURL string) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div><div class=\"grow flex flex-col gap-1 bg-base-200 p-2 rounded-md\"><div class=\"bg-gray-800 rounded-full px-2 py-1\"><span class=\"line-clamp-1 break-all whitespace-normal\">amth.one/widget</span></div>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div><div class=\"grow flex flex-col gap-1 bg-base-200 p-2 rounded-md\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -86,7 +86,15 @@ func OBSMockup(backgroundURL string) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div><div class=\"grow flex flex-col gap-2 bg-base-200 p-2 rounded-md\"><div class=\"flex flex-col gap-1\"><div class=\"h-1 min-w-12 w-full bg-gray-700 rounded-full\"><div class=\"w-2/3 h-1 rounded-full bg-green-600\"></div></div><div class=\"h-1 flex flex-row gap-1\"><div class=\"grow rounded-full bg-blue-600\"></div><div class=\"w-1 h-1 rounded-full bg-red-600\"></div></div></div><div class=\"flex flex-col gap-1\"><div class=\"h-1 min-w-12 w-full bg-gray-700 rounded-full\"><div class=\"w-1/4 h-1 rounded-full bg-green-600\"></div></div><div class=\"h-1 flex flex-row gap-1\"><div class=\"grow rounded-full bg-blue-600\"></div><div class=\"w-1 h-1 rounded-full bg-red-600\"></div></div></div></div><div class=\"grow hidden sm:flex flex-col gap-1 bg-base-200 p-2 rounded-md text-center max-w-24\"><div class=\"h-4 min-w-12 w-full bg-gray-800 rounded-full flex flex-row gap-1 items-center px-1\"><div class=\"h-2 w-2 rounded-full bg-red-500\"></div><div class=\"h-1 min-w-8 grow bg-gray-500 rounded-full\"></div></div>")
+		templ_7745c5c3_Err = buttonMockup().Render(ctx, templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = buttonMockup().Render(ctx, templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div><div class=\"grow flex flex-col gap-2 bg-base-200 p-2 rounded-md\"><div class=\"flex flex-col gap-1\"><div class=\"h-1 min-w-12 w-full bg-gray-700 rounded-full\"><div class=\"w-2/3 h-1 rounded-full bg-green-600\"></div></div><div class=\"h-1 flex flex-row gap-1\"><div class=\"grow rounded-full bg-blue-600\"></div><div class=\"w-1 h-1 rounded-full bg-red-600\"></div></div></div><div class=\"flex flex-col gap-1\"><div class=\"h-1 min-w-12 w-full bg-gray-700 rounded-full\"><div class=\"w-1/4 h-1 rounded-full bg-green-600\"></div></div><div class=\"h-1 flex flex-row gap-1\"><div class=\"grow rounded-full bg-blue-600\"></div><div class=\"w-1 h-1 rounded-full bg-red-600\"></div></div></div></div><div class=\"grow hidden sm:flex flex-col gap-1 bg-base-200 p-2 rounded-md text-center\"><div class=\"h-4 min-w-12 w-full bg-gray-800 rounded-full flex flex-row gap-1 items-center px-1\"><div class=\"h-2 w-2 rounded-full bg-red-500\"></div><div class=\"h-1 min-w-8 grow bg-gray-500 rounded-full\"></div></div>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
diff --git a/cmd/frontend/components/widget/default.templ b/cmd/frontend/components/widget/default.templ
index cfa4a601..4df1f90f 100644
--- a/cmd/frontend/components/widget/default.templ
+++ b/cmd/frontend/components/widget/default.templ
@@ -1,13 +1,16 @@
 package widget
 
-import "fmt"
-import "github.com/cufee/aftermath/internal/stats/prepare/session/v1"
-import "github.com/cufee/aftermath/internal/stats/prepare/common/v1"
-import "github.com/cufee/aftermath/cmd/frontend/assets"
-import "github.com/cufee/aftermath/internal/stats/frame"
+import (
+	"fmt"
+	"github.com/cufee/aftermath/cmd/frontend/assets"
+	"github.com/cufee/aftermath/internal/stats/frame"
+	"github.com/cufee/aftermath/internal/stats/prepare/common/v1"
+	"github.com/cufee/aftermath/internal/stats/prepare/session/v1"
+)
 
 type defaultWidget struct {
 	widget
+	showLegend   bool
 	vehicleCards []vehicleExtended
 }
 
@@ -29,6 +32,7 @@ func (v vehicleExtended) fromCard(card session.VehicleCard) vehicleExtended {
 }
 
 func (w widget) defaultWidget() templ.Component {
+
 	var vehicles []vehicleExtended
 	for i, card := range w.cards.Unrated.Vehicles {
 		if i >= w.unratedVehiclesLimit {
@@ -40,7 +44,13 @@ func (w widget) defaultWidget() templ.Component {
 		vehicles = append(vehicles, vehicleExtended{}.fromCard(card))
 	}
 
-	return defaultWidget{w, vehicles}.Render()
+	widget := defaultWidget{w, false, vehicles}
+	if w.vehicleStyle.showLabel {
+		widget.showLegend = true
+		widget.vehicleStyle.showLabel = false
+	}
+
+	return widget.Render()
 }
 
 templ (w defaultWidget) Render() {
@@ -54,7 +64,7 @@ templ (w defaultWidget) Render() {
 		for _, card := range w.vehicleCards {
 			@w.vehicleCard(card)
 		}
-		if len(w.vehicleCards) > 0 {
+		if len(w.vehicleCards) > 0 && w.showLegend {
 			@w.vehicleLegendCard(w.vehicleCards[0].Blocks)
 		}
 	</div>
@@ -67,7 +77,7 @@ templ (w defaultWidget) overviewCard(card session.OverviewCard) {
 				{ card.Title }
 			</span>
 		}
-		<div class={ fmt.Sprintf("columns overview-columns grid grid-cols-%d gap-1 items-center bg-black rounded-xl bg-opacity-95 p-4", len(card.Blocks)) }>
+		<div class={ fmt.Sprintf("columns overview-columns grid grid-cols-%d gap-1 items-center bg-black rounded-xl bg-opacity-75 p-4", len(card.Blocks)) }>
 			for _, column := range card.Blocks {
 				@w.overviewColumn(column)
 			}
@@ -76,7 +86,7 @@ templ (w defaultWidget) overviewCard(card session.OverviewCard) {
 }
 
 templ (w defaultWidget) vehicleCard(card vehicleExtended) {
-	<div class="flex flex-col gap-1 card vehicle-card grow bg-black rounded-lg bg-opacity-95 p-4">
+	<div class="flex flex-col gap-1 card vehicle-card grow bg-black rounded-lg bg-opacity-75 p-4">
 		if w.vehicleStyle.showTitle {
 			<div class="flex flex-row gap-2 justify-between">
 				<span class="text-gray-300 title">
@@ -97,7 +107,7 @@ templ (w defaultWidget) vehicleLegendCard(blocks []common.StatsBlock[session.Blo
 	<div class="flex flex-col gap-1 card legend-card grow">
 		<div class={ fmt.Sprintf("blocks legend-blocks grid grid-cols-%d gap-1 items-center justify-center px-4", len(blocks)) }>
 			for _, block := range blocks {
-				<div class="bg-black rounded-full bg-opacity-95 m-auto px-3 py-1">
+				<div class="bg-black rounded-full bg-opacity-75 m-auto px-3 py-1">
 					{ block.Label }
 				</div>
 			}
diff --git a/cmd/frontend/components/widget/default_templ.go b/cmd/frontend/components/widget/default_templ.go
index fc252866..bcc967e9 100644
--- a/cmd/frontend/components/widget/default_templ.go
+++ b/cmd/frontend/components/widget/default_templ.go
@@ -8,14 +8,17 @@ package widget
 import "github.com/a-h/templ"
 import templruntime "github.com/a-h/templ/runtime"
 
-import "fmt"
-import "github.com/cufee/aftermath/internal/stats/prepare/session/v1"
-import "github.com/cufee/aftermath/internal/stats/prepare/common/v1"
-import "github.com/cufee/aftermath/cmd/frontend/assets"
-import "github.com/cufee/aftermath/internal/stats/frame"
+import (
+	"fmt"
+	"github.com/cufee/aftermath/cmd/frontend/assets"
+	"github.com/cufee/aftermath/internal/stats/frame"
+	"github.com/cufee/aftermath/internal/stats/prepare/common/v1"
+	"github.com/cufee/aftermath/internal/stats/prepare/session/v1"
+)
 
 type defaultWidget struct {
 	widget
+	showLegend   bool
 	vehicleCards []vehicleExtended
 }
 
@@ -37,6 +40,7 @@ func (v vehicleExtended) fromCard(card session.VehicleCard) vehicleExtended {
 }
 
 func (w widget) defaultWidget() templ.Component {
+
 	var vehicles []vehicleExtended
 	for i, card := range w.cards.Unrated.Vehicles {
 		if i >= w.unratedVehiclesLimit {
@@ -48,7 +52,13 @@ func (w widget) defaultWidget() templ.Component {
 		vehicles = append(vehicles, vehicleExtended{}.fromCard(card))
 	}
 
-	return defaultWidget{w, vehicles}.Render()
+	widget := defaultWidget{w, false, vehicles}
+	if w.vehicleStyle.showLabel {
+		widget.showLegend = true
+		widget.vehicleStyle.showLabel = false
+	}
+
+	return widget.Render()
 }
 
 func (w defaultWidget) Render() templ.Component {
@@ -91,7 +101,7 @@ func (w defaultWidget) Render() templ.Component {
 				return templ_7745c5c3_Err
 			}
 		}
-		if len(w.vehicleCards) > 0 {
+		if len(w.vehicleCards) > 0 && w.showLegend {
 			templ_7745c5c3_Err = w.vehicleLegendCard(w.vehicleCards[0].Blocks).Render(ctx, templ_7745c5c3_Buffer)
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
@@ -135,7 +145,7 @@ func (w defaultWidget) overviewCard(card session.OverviewCard) templ.Component {
 			var templ_7745c5c3_Var3 string
 			templ_7745c5c3_Var3, templ_7745c5c3_Err = templ.JoinStringErrs(card.Title)
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 67, Col: 16}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 77, Col: 16}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var3))
 			if templ_7745c5c3_Err != nil {
@@ -146,7 +156,7 @@ func (w defaultWidget) overviewCard(card session.OverviewCard) templ.Component {
 				return templ_7745c5c3_Err
 			}
 		}
-		var templ_7745c5c3_Var4 = []any{fmt.Sprintf("columns overview-columns grid grid-cols-%d gap-1 items-center bg-black rounded-xl bg-opacity-95 p-4", len(card.Blocks))}
+		var templ_7745c5c3_Var4 = []any{fmt.Sprintf("columns overview-columns grid grid-cols-%d gap-1 items-center bg-black rounded-xl bg-opacity-75 p-4", len(card.Blocks))}
 		templ_7745c5c3_Err = templ.RenderCSSItems(ctx, templ_7745c5c3_Buffer, templ_7745c5c3_Var4...)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
@@ -200,7 +210,7 @@ func (w defaultWidget) vehicleCard(card vehicleExtended) templ.Component {
 			templ_7745c5c3_Var6 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-col gap-1 card vehicle-card grow bg-black rounded-lg bg-opacity-95 p-4\">")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-col gap-1 card vehicle-card grow bg-black rounded-lg bg-opacity-75 p-4\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -212,7 +222,7 @@ func (w defaultWidget) vehicleCard(card vehicleExtended) templ.Component {
 			var templ_7745c5c3_Var7 string
 			templ_7745c5c3_Var7, templ_7745c5c3_Err = templ.JoinStringErrs(card.Title)
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 83, Col: 17}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 93, Col: 17}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var7))
 			if templ_7745c5c3_Err != nil {
@@ -225,7 +235,7 @@ func (w defaultWidget) vehicleCard(card vehicleExtended) templ.Component {
 			var templ_7745c5c3_Var8 string
 			templ_7745c5c3_Var8, templ_7745c5c3_Err = templ.JoinStringErrs(assets.WN8IconPathSmall(card.wn8.Float()))
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 85, Col: 56}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 95, Col: 56}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var8))
 			if templ_7745c5c3_Err != nil {
@@ -317,14 +327,14 @@ func (w defaultWidget) vehicleLegendCard(blocks []common.StatsBlock[session.Bloc
 			return templ_7745c5c3_Err
 		}
 		for _, block := range blocks {
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"bg-black rounded-full bg-opacity-95 m-auto px-3 py-1\">")
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"bg-black rounded-full bg-opacity-75 m-auto px-3 py-1\">")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			var templ_7745c5c3_Var14 string
 			templ_7745c5c3_Var14, templ_7745c5c3_Err = templ.JoinStringErrs(block.Label)
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 101, Col: 18}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 111, Col: 18}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var14))
 			if templ_7745c5c3_Err != nil {
@@ -417,7 +427,7 @@ func (w defaultWidget) specialOverviewColumn(column session.OverviewColumn) temp
 				var templ_7745c5c3_Var17 string
 				templ_7745c5c3_Var17, templ_7745c5c3_Err = templ.JoinStringErrs(assets.RatingIconPath(block.Value.Float()))
 				if templ_7745c5c3_Err != nil {
-					return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 124, Col: 57}
+					return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 134, Col: 57}
 				}
 				_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var17))
 				if templ_7745c5c3_Err != nil {
@@ -440,7 +450,7 @@ func (w defaultWidget) specialOverviewColumn(column session.OverviewColumn) temp
 				var templ_7745c5c3_Var18 string
 				templ_7745c5c3_Var18, templ_7745c5c3_Err = templ.JoinStringErrs(assets.WN8IconPath(block.Value.Float()))
 				if templ_7745c5c3_Err != nil {
-					return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 127, Col: 54}
+					return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 137, Col: 54}
 				}
 				_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var18))
 				if templ_7745c5c3_Err != nil {
@@ -493,7 +503,7 @@ func (w defaultWidget) block(block common.StatsBlock[session.BlockData], style s
 		var templ_7745c5c3_Var20 string
 		templ_7745c5c3_Var20, templ_7745c5c3_Err = templ.JoinStringErrs(block.Data.Session.String())
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 136, Col: 65}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 146, Col: 65}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var20))
 		if templ_7745c5c3_Err != nil {
@@ -511,7 +521,7 @@ func (w defaultWidget) block(block common.StatsBlock[session.BlockData], style s
 			var templ_7745c5c3_Var21 string
 			templ_7745c5c3_Var21, templ_7745c5c3_Err = templ.JoinStringErrs(block.Data.Career.String())
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 138, Col: 67}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 148, Col: 67}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var21))
 			if templ_7745c5c3_Err != nil {
@@ -530,7 +540,7 @@ func (w defaultWidget) block(block common.StatsBlock[session.BlockData], style s
 			var templ_7745c5c3_Var22 string
 			templ_7745c5c3_Var22, templ_7745c5c3_Err = templ.JoinStringErrs(block.Label)
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 141, Col: 52}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/default.templ`, Line: 151, Col: 52}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var22))
 			if templ_7745c5c3_Err != nil {
diff --git a/cmd/frontend/components/widget/widget.templ b/cmd/frontend/components/widget/widget.templ
index ac781198..be9ce894 100644
--- a/cmd/frontend/components/widget/widget.templ
+++ b/cmd/frontend/components/widget/widget.templ
@@ -1,9 +1,11 @@
 package widget
 
-import "github.com/cufee/aftermath/cmd/frontend/logic"
-import "fmt"
-import "github.com/cufee/aftermath/internal/database/models"
-import prepare "github.com/cufee/aftermath/internal/stats/prepare/session/v1"
+import (
+	"fmt"
+	"github.com/cufee/aftermath/cmd/frontend/logic"
+	"github.com/cufee/aftermath/internal/database/models"
+	prepare "github.com/cufee/aftermath/internal/stats/prepare/session/v1"
+)
 
 type WidgetFlavor string
 
@@ -36,7 +38,7 @@ func Widget(account models.Account, cards prepare.Cards, options ...WidgetOption
 		account:       account,
 		flavor:        WidgetFlavorDefault,
 		autoReload:    false,
-		vehicleStyle:  styleOptions{showTitle: true},
+		vehicleStyle:  styleOptions{showTitle: true, showLabel: true},
 		overviewStyle: styleOptions{showLabel: true},
 
 		showRatingOverview:   true,
@@ -84,7 +86,7 @@ templ (w widget) Render() {
 		<meta name="twitter:image" content="https://amth.one/assets/og-widget.jpg"/>
 		<meta name="twitter:description" content={ fmt.Sprintf("Aftermath streaming widget for %s [%s]", w.account.Nickname, w.account.Realm) }/>
 	</head>
-	<div class="text-nowrap whitespace-nowrap min-w-max" id="widget-container">
+	<div class="text-nowrap whitespace-nowrap" id="widget-container">
 		switch w.flavor {
 			default:
 				@w.defaultWidget()
diff --git a/cmd/frontend/components/widget/widget_templ.go b/cmd/frontend/components/widget/widget_templ.go
index f4802841..d0e9334f 100644
--- a/cmd/frontend/components/widget/widget_templ.go
+++ b/cmd/frontend/components/widget/widget_templ.go
@@ -8,10 +8,12 @@ package widget
 import "github.com/a-h/templ"
 import templruntime "github.com/a-h/templ/runtime"
 
-import "github.com/cufee/aftermath/cmd/frontend/logic"
-import "fmt"
-import "github.com/cufee/aftermath/internal/database/models"
-import prepare "github.com/cufee/aftermath/internal/stats/prepare/session/v1"
+import (
+	"fmt"
+	"github.com/cufee/aftermath/cmd/frontend/logic"
+	"github.com/cufee/aftermath/internal/database/models"
+	prepare "github.com/cufee/aftermath/internal/stats/prepare/session/v1"
+)
 
 type WidgetFlavor string
 
@@ -44,7 +46,7 @@ func Widget(account models.Account, cards prepare.Cards, options ...WidgetOption
 		account:       account,
 		flavor:        WidgetFlavorDefault,
 		autoReload:    false,
-		vehicleStyle:  styleOptions{showTitle: true},
+		vehicleStyle:  styleOptions{showTitle: true, showLabel: true},
 		overviewStyle: styleOptions{showLabel: true},
 
 		showRatingOverview:   true,
@@ -104,7 +106,7 @@ func (w widget) Render() templ.Component {
 		var templ_7745c5c3_Var2 string
 		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(w.account.Nickname)
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/widget.templ`, Line: 76, Col: 41}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/widget.templ`, Line: 78, Col: 41}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
 		if templ_7745c5c3_Err != nil {
@@ -117,7 +119,7 @@ func (w widget) Render() templ.Component {
 		var templ_7745c5c3_Var3 string
 		templ_7745c5c3_Var3, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprintf("Aftermath streaming widget for %s [%s]", w.account.Nickname, w.account.Realm))
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/widget.templ`, Line: 80, Col: 134}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/widget.templ`, Line: 82, Col: 134}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var3))
 		if templ_7745c5c3_Err != nil {
@@ -130,13 +132,13 @@ func (w widget) Render() templ.Component {
 		var templ_7745c5c3_Var4 string
 		templ_7745c5c3_Var4, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprintf("Aftermath streaming widget for %s [%s]", w.account.Nickname, w.account.Realm))
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/widget.templ`, Line: 85, Col: 135}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/widget.templ`, Line: 87, Col: 135}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var4))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"></head><div class=\"text-nowrap whitespace-nowrap min-w-max\" id=\"widget-container\">")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"></head><div class=\"text-nowrap whitespace-nowrap\" id=\"widget-container\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
diff --git a/cmd/frontend/handlers.go b/cmd/frontend/handlers.go
index eb3c3d09..484db49e 100644
--- a/cmd/frontend/handlers.go
+++ b/cmd/frontend/handlers.go
@@ -12,6 +12,7 @@ import (
 	"github.com/cufee/aftermath/cmd/frontend/middleware"
 	"github.com/cufee/aftermath/cmd/frontend/routes"
 	"github.com/cufee/aftermath/cmd/frontend/routes/api/auth"
+	aWidget "github.com/cufee/aftermath/cmd/frontend/routes/api/widget"
 	"github.com/cufee/aftermath/cmd/frontend/routes/app"
 	"github.com/cufee/aftermath/cmd/frontend/routes/widget"
 	"github.com/pkg/errors"
@@ -93,6 +94,10 @@ func Handlers(core core.Client) ([]server.Handler, error) {
 			Path: get("/api/auth/discord"),
 			Func: handler.Chain(core, auth.DiscordRedirect),
 		},
+		{
+			Path: get("/api/widget/mock"),
+			Func: handler.Chain(core, aWidget.MockWidget),
+		},
 	}, nil
 }
 
diff --git a/cmd/frontend/routes/api/widget/mock.go b/cmd/frontend/routes/api/widget/mock.go
deleted file mode 100644
index 57c413e2..00000000
--- a/cmd/frontend/routes/api/widget/mock.go
+++ /dev/null
@@ -1,11 +0,0 @@
-package widget
-
-import (
-	"github.com/a-h/templ"
-	"github.com/cufee/aftermath/cmd/frontend/handler"
-)
-
-var MockWidget handler.Partial = func(ctx *handler.Context) (templ.Component, error) {
-
-	return nil, nil
-}
diff --git a/cmd/frontend/routes/api/widget/mock.templ b/cmd/frontend/routes/api/widget/mock.templ
new file mode 100644
index 00000000..6a93e6bc
--- /dev/null
+++ b/cmd/frontend/routes/api/widget/mock.templ
@@ -0,0 +1,28 @@
+package widget
+
+import (
+	"github.com/cufee/aftermath/cmd/frontend/assets"
+	"github.com/cufee/aftermath/cmd/frontend/components/widget"
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"strconv"
+)
+
+var MockWidget handler.Partial = func(ctx *handler.Context) (templ.Component, error) {
+	var opts []widget.WidgetOption
+	if v, err := strconv.Atoi(ctx.Query("vl")); err == nil && v >= 0 && v <= 10 {
+		opts = append(opts, widget.WithVehicleLimit(int(v)))
+	}
+	if v := ctx.Query("or"); v != "" {
+		opts = append(opts, widget.WithRatingOverview(v == "1"))
+	}
+	if v := ctx.Query("ou"); v != "" {
+		opts = append(opts, widget.WithUnratedOverview(v == "1"))
+	}
+	return mockWidget(widget.Widget(assets.MockWidgetData().Account, assets.MockWidgetData().Cards, opts...)), nil
+}
+
+templ mockWidget(widget templ.Component) {
+	<div id="mock-widget">
+		@widget
+	</div>
+}
diff --git a/cmd/frontend/routes/api/widget/mock_templ.go b/cmd/frontend/routes/api/widget/mock_templ.go
new file mode 100644
index 00000000..6bfbf0a3
--- /dev/null
+++ b/cmd/frontend/routes/api/widget/mock_templ.go
@@ -0,0 +1,64 @@
+// Code generated by templ - DO NOT EDIT.
+
+// templ: version: v0.2.731
+package widget
+
+//lint:file-ignore SA4006 This context is only used if a nested component is present.
+
+import "github.com/a-h/templ"
+import templruntime "github.com/a-h/templ/runtime"
+
+import (
+	"github.com/cufee/aftermath/cmd/frontend/assets"
+	"github.com/cufee/aftermath/cmd/frontend/components/widget"
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"strconv"
+)
+
+var MockWidget handler.Partial = func(ctx *handler.Context) (templ.Component, error) {
+	var opts []widget.WidgetOption
+	if v, err := strconv.Atoi(ctx.Query("vl")); err == nil && v >= 0 && v <= 10 {
+		opts = append(opts, widget.WithVehicleLimit(int(v)))
+	}
+	if v := ctx.Query("or"); v != "" {
+		opts = append(opts, widget.WithRatingOverview(v == "1"))
+	}
+	if v := ctx.Query("ou"); v != "" {
+		opts = append(opts, widget.WithUnratedOverview(v == "1"))
+	}
+	return mockWidget(widget.Widget(assets.MockWidgetData().Account, assets.MockWidgetData().Cards, opts...)), nil
+}
+
+func mockWidget(widget templ.Component) templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var1 == nil {
+			templ_7745c5c3_Var1 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div id=\"mock-widget\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = widget.Render(ctx, templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return templ_7745c5c3_Err
+	})
+}
diff --git a/cmd/frontend/routes/app/index.templ b/cmd/frontend/routes/app/index.templ
index 6eddfd42..558d5835 100644
--- a/cmd/frontend/routes/app/index.templ
+++ b/cmd/frontend/routes/app/index.templ
@@ -1,21 +1,32 @@
 package app
 
-import "net/http"
-import "github.com/cufee/aftermath/internal/database/models"
-import "github.com/cufee/aftermath/cmd/frontend/handler"
-import "github.com/cufee/aftermath/cmd/frontend/layouts"
+import (
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/cmd/frontend/layouts"
+	"github.com/cufee/aftermath/internal/database/models"
+	"net/http"
+)
 
 var Index handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
-  user, err := ctx.SessionUser()
-  if err != nil {
-    return nil, nil, ctx.Redirect("/login", http.StatusTemporaryRedirect)
-  }
+	user, err := ctx.SessionUser()
+	if err != nil {
+		return nil, nil, ctx.Redirect("/login", http.StatusTemporaryRedirect)
+	}
 	return layouts.Main, index(user), nil
 }
 
 templ index(user *models.User) {
-	<div class="flex flex-col justify-center gap-8 m-auto" id="landing">
-		App page
-    {user.ID}
+	<div class="flex flex-col items-center gap-4">
+		<div class="text-3xl font-bold">
+			🎉 You are logged in! 🎉
+		</div>
+		<div class="flex flex-col items-center">
+			<span class="text-xl">
+				But we did not add any features here just yet.
+			</span>
+			<span>
+				Here is your user id instead - { user.ID }
+			</span>
+		</div>
 	</div>
 }
diff --git a/cmd/frontend/routes/app/index_templ.go b/cmd/frontend/routes/app/index_templ.go
index 4cc53393..e8a19c4d 100644
--- a/cmd/frontend/routes/app/index_templ.go
+++ b/cmd/frontend/routes/app/index_templ.go
@@ -8,10 +8,12 @@ package app
 import "github.com/a-h/templ"
 import templruntime "github.com/a-h/templ/runtime"
 
-import "net/http"
-import "github.com/cufee/aftermath/internal/database/models"
-import "github.com/cufee/aftermath/cmd/frontend/handler"
-import "github.com/cufee/aftermath/cmd/frontend/layouts"
+import (
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/cmd/frontend/layouts"
+	"github.com/cufee/aftermath/internal/database/models"
+	"net/http"
+)
 
 var Index handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
 	user, err := ctx.SessionUser()
@@ -39,20 +41,20 @@ func index(user *models.User) templ.Component {
 			templ_7745c5c3_Var1 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-col justify-center gap-8 m-auto\" id=\"landing\">App page ")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-col items-center gap-4\"><div class=\"text-3xl font-bold\">🎉 You are logged in! 🎉</div><div class=\"flex flex-col items-center\"><span class=\"text-xl\">But we did not add any features here just yet.</span> <span>Here is your user id instead - ")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var2 string
 		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(user.ID)
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/app/index.templ`, Line: 19, Col: 12}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/app/index.templ`, Line: 28, Col: 44}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</span></div></div>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
diff --git a/cmd/frontend/routes/index.templ b/cmd/frontend/routes/index.templ
index b3822a69..652a8782 100644
--- a/cmd/frontend/routes/index.templ
+++ b/cmd/frontend/routes/index.templ
@@ -10,7 +10,7 @@ var Index handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Compo
 }
 
 templ index() {
-	<div class="flex flex-col justify-center gap-8 m-auto" id="landing">
+	<div class="flex flex-col justify-center" id="landing">
 		<div class="flex flex-row flex-wrap">
 			@card(cardImage("/assets/promo-join.jpg"), cardActionButton("Join Aftermath Official", "/join")) {
 				<p>Aftermath is making a comeback! We've revamped everything to be faster and more beautiful. Join our community server for the latest features and updates.</p>
@@ -23,7 +23,7 @@ templ index() {
 }
 
 templ cardImage(path string) {
-	<img src={ path } class="max-h-24 md:max-h-48 object-cover w-full" alt="Join Aftermath Official"/>
+	<img src={ path } class="object-cover w-full h-full" alt="Join Aftermath Official"/>
 }
 
 templ cardActionButton(label, path string) {
@@ -34,7 +34,7 @@ templ card(image templ.Component, button templ.Component) {
 	<div class="grow md:basis-1/2 p-2">
 		<div class="shadow-xl card bg-base-300 overflow-hidden h-full">
 			if image != nil {
-				<div class="overflow-hidden">
+				<div class="overflow-hidden h-24 sm:h-48">
 					@image
 				</div>
 			}
diff --git a/cmd/frontend/routes/index_templ.go b/cmd/frontend/routes/index_templ.go
index 98fa1ccb..83153c9e 100644
--- a/cmd/frontend/routes/index_templ.go
+++ b/cmd/frontend/routes/index_templ.go
@@ -35,7 +35,7 @@ func index() templ.Component {
 			templ_7745c5c3_Var1 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-col justify-center gap-8 m-auto\" id=\"landing\"><div class=\"flex flex-row flex-wrap\">")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-col justify-center\" id=\"landing\"><div class=\"flex flex-row flex-wrap\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -122,7 +122,7 @@ func cardImage(path string) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\" class=\"max-h-24 md:max-h-48 object-cover w-full\" alt=\"Join Aftermath Official\">")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\" class=\"object-cover w-full h-full\" alt=\"Join Aftermath Official\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -201,7 +201,7 @@ func card(image templ.Component, button templ.Component) templ.Component {
 			return templ_7745c5c3_Err
 		}
 		if image != nil {
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"overflow-hidden\">")
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"overflow-hidden h-24 sm:h-48\">")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
diff --git a/cmd/frontend/routes/login.go b/cmd/frontend/routes/login.go
index c47c41af..1001f650 100644
--- a/cmd/frontend/routes/login.go
+++ b/cmd/frontend/routes/login.go
@@ -12,6 +12,11 @@ import (
 )
 
 var Login handler.Endpoint = func(ctx *handler.Context) error {
+	user, err := ctx.SessionUser()
+	if err == nil && user.ID != "" {
+		return ctx.Redirect("/app", http.StatusTemporaryRedirect)
+	}
+
 	nonceID, err := logic.RandomString(32)
 	if err != nil {
 		return ctx.Error(err, "failed to authenticate")
diff --git a/cmd/frontend/routes/widget/index.templ b/cmd/frontend/routes/widget/index.templ
index 2180b095..3119cab4 100644
--- a/cmd/frontend/routes/widget/index.templ
+++ b/cmd/frontend/routes/widget/index.templ
@@ -1,35 +1,88 @@
 package widget
 
 import (
+	"fmt"
 	"github.com/cufee/aftermath/cmd/frontend/components"
 	"github.com/cufee/aftermath/cmd/frontend/handler"
 	"github.com/cufee/aftermath/cmd/frontend/layouts"
+	"github.com/cufee/aftermath/cmd/frontend/routes/api/widget"
+	"strconv"
 )
 
 var WidgetHome handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
+	widget, err := widget.MockWidget(ctx)
+	if err != nil {
+		return layouts.Main, nil, ctx.Error(err, "failed to generate a widget preview")
+	}
 
-	return layouts.Main, widgetHome(), nil
+	var withUnrated = ctx.Query("ou") != "0"
+	var withRating = ctx.Query("or") != "0"
+	var vehicles int = 3
+	if v, err := strconv.Atoi(ctx.Query("vl")); err == nil && v >= 0 && v <= 10 {
+		vehicles = v
+	}
+
+	return layouts.Main, widgetHome(widget, withRating, withUnrated, vehicles), nil
 }
 
-templ widgetHome() {
-	<div class="flex flex-row justify-center gap-4 flex-wrap">
-		<div class="flex flex-row flex-wrap md:flex-nowrap gap-4">
-			<div class="grow">
-				Amet cillum fugiat ut eu enim dolor nulla minim. Officia veniam esse exercitation elit consequat voluptate cillum ex. Ut aute nulla ipsum in sint enim et amet nisi irure. Nulla tempor enim ut reprehenderit excepteur ad aute eu fugiat cupidatat et eu magna officia. Aute aute quis ea anim. Ipsum aliqua officia qui id dolore ullamco ipsum ipsum esse laborum. Minim Lorem ex cupidatat elit Lorem consequat deserunt cillum.
-				Laboris esse do non dolor reprehenderit excepteur ea eiusmod incididunt sit eu tempor consectetur reprehenderit. Dolore est exercitation ullamco magna adipisicing dolor ea esse sit fugiat sint enim in irure. Aliquip ea ea magna irure amet dolore. Lorem anim ad enim reprehenderit officia et magna pariatur dolore ex quis sint. Quis duis aliqua do ipsum enim cillum.
+templ widgetHome(widget templ.Component, or, ou bool, vl int) {
+	<div class="flex flex-row flex-wrap gap-4">
+		<div class="flex flex-col gap-4 basis-1/2 grow">
+			<div class="flex flex-col gap-2 items-center">
+				<div class="text-3xl font-bold">
+					Aftermath Streaming Widget
+				</div>
+				<p>
+					Level up your stream with a real-time stats widget!
+				</p>
 			</div>
-			<div class="flex items-center justify-center grow">
-				<div>
-					@components.OBSMockup("/assets/widget-background.jpg") {
-						<div>
-							<span class="text-white">content</span>
+			<div class="form-control flex gap-2 grow">
+				<div class="flex flex-col bg-base-200 rounded-lg p-4">
+					<span class="text-lg">Rating Battles</span>
+					<label class="label cursor-pointer">
+						<span class="label-text">Show Overview Card</span>
+						<input id="widget-or" type="checkbox" class="toggle toggle-secondary" checked?={ or }/>
+					</label>
+				</div>
+				<div class="flex flex-col bg-base-200 rounded-lg p-4">
+					<span class="text-lg">Regular Battles</span>
+					<label class="label cursor-pointer">
+						<span class="label-text">Show Overview Card</span>
+						<input id="widget-ou" type="checkbox" class="toggle toggle-secondary" checked?={ ou }/>
+					</label>
+					<label class="label cursor-pointer flex flex-col items-start gap-1">
+						<span class="label-text">Vehicle Cards</span>
+						<input id="widget-vl" type="range" min="0" max="10" value={ fmt.Sprint(vl) } class="range" step="1"/>
+						<div class="flex w-full justify-between px-2 text-xs">
+							for i := range 11 {
+								<div class="flex flex-col items-center">
+									<span>{ fmt.Sprint(i) }</span>
+								</div>
+							}
 						</div>
-					}
+					</label>
 				</div>
+				<button onclick={ handlePreview() } type="button" id="preview-widget" class="btn btn-primary w-full">Preview</button>
 			</div>
 		</div>
-		<div class="flex">
-			// account input
+		<div class="flex items-center justify-center grow">
+			<div class="max-w-4xl w-full">
+				@components.OBSMockup("/assets/widget-background.jpg") {
+					<div class="w-max p-8 min-h-96" style="zoom: 0.5;">
+						@widget
+					</div>
+				}
+			</div>
 		</div>
 	</div>
 }
+
+script handlePreview() {
+	const ou = document.getElementById("widget-ou").checked ? "1" : "0"
+	const or = document.getElementById("widget-or").checked ? "1" : "0"
+	const vl = document.getElementById("widget-vl").value
+	const newQuery = `?or=${or}&ou=${ou}&vl=${vl}`
+	if (newQuery != window.location.search) {
+		window.location.search = newQuery
+	}
+}
diff --git a/cmd/frontend/routes/widget/index_templ.go b/cmd/frontend/routes/widget/index_templ.go
index d0ccd481..cc797c88 100644
--- a/cmd/frontend/routes/widget/index_templ.go
+++ b/cmd/frontend/routes/widget/index_templ.go
@@ -9,17 +9,31 @@ import "github.com/a-h/templ"
 import templruntime "github.com/a-h/templ/runtime"
 
 import (
+	"fmt"
 	"github.com/cufee/aftermath/cmd/frontend/components"
 	"github.com/cufee/aftermath/cmd/frontend/handler"
 	"github.com/cufee/aftermath/cmd/frontend/layouts"
+	"github.com/cufee/aftermath/cmd/frontend/routes/api/widget"
+	"strconv"
 )
 
 var WidgetHome handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
+	widget, err := widget.MockWidget(ctx)
+	if err != nil {
+		return layouts.Main, nil, ctx.Error(err, "failed to generate a widget preview")
+	}
 
-	return layouts.Main, widgetHome(), nil
+	var withUnrated = ctx.Query("ou") != "0"
+	var withRating = ctx.Query("or") != "0"
+	var vehicles int = 3
+	if v, err := strconv.Atoi(ctx.Query("vl")); err == nil && v >= 0 && v <= 10 {
+		vehicles = v
+	}
+
+	return layouts.Main, widgetHome(widget, withRating, withUnrated, vehicles), nil
 }
 
-func widgetHome() templ.Component {
+func widgetHome(widget templ.Component, or, ou bool, vl int) templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
@@ -37,11 +51,84 @@ func widgetHome() templ.Component {
 			templ_7745c5c3_Var1 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-row justify-center gap-4 flex-wrap\"><div class=\"flex flex-row flex-wrap md:flex-nowrap gap-4\"><div class=\"grow\">Amet cillum fugiat ut eu enim dolor nulla minim. Officia veniam esse exercitation elit consequat voluptate cillum ex. Ut aute nulla ipsum in sint enim et amet nisi irure. Nulla tempor enim ut reprehenderit excepteur ad aute eu fugiat cupidatat et eu magna officia. Aute aute quis ea anim. Ipsum aliqua officia qui id dolore ullamco ipsum ipsum esse laborum. Minim Lorem ex cupidatat elit Lorem consequat deserunt cillum. Laboris esse do non dolor reprehenderit excepteur ea eiusmod incididunt sit eu tempor consectetur reprehenderit. Dolore est exercitation ullamco magna adipisicing dolor ea esse sit fugiat sint enim in irure. Aliquip ea ea magna irure amet dolore. Lorem anim ad enim reprehenderit officia et magna pariatur dolore ex quis sint. Quis duis aliqua do ipsum enim cillum.</div><div class=\"flex items-center justify-center grow\"><div>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-row flex-wrap gap-4\"><div class=\"flex flex-col gap-4 basis-1/2 grow\"><div class=\"flex flex-col gap-2 items-center\"><div class=\"text-3xl font-bold\">Aftermath Streaming Widget</div><p>Level up your stream with a real-time stats widget!</p></div><div class=\"form-control flex gap-2 grow\"><div class=\"flex flex-col bg-base-200 rounded-lg p-4\"><span class=\"text-lg\">Rating Battles</span> <label class=\"label cursor-pointer\"><span class=\"label-text\">Show Overview Card</span> <input id=\"widget-or\" type=\"checkbox\" class=\"toggle toggle-secondary\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		if or {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" checked")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("></label></div><div class=\"flex flex-col bg-base-200 rounded-lg p-4\"><span class=\"text-lg\">Regular Battles</span> <label class=\"label cursor-pointer\"><span class=\"label-text\">Show Overview Card</span> <input id=\"widget-ou\" type=\"checkbox\" class=\"toggle toggle-secondary\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		if ou {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" checked")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("></label> <label class=\"label cursor-pointer flex flex-col items-start gap-1\"><span class=\"label-text\">Vehicle Cards</span> <input id=\"widget-vl\" type=\"range\" min=\"0\" max=\"10\" value=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var2 string
+		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprint(vl))
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/widget/index.templ`, Line: 55, Col: 80}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\" class=\"range\" step=\"1\"><div class=\"flex w-full justify-between px-2 text-xs\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		for i := range 11 {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-col items-center\"><span>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			var templ_7745c5c3_Var3 string
+			templ_7745c5c3_Var3, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprint(i))
+			if templ_7745c5c3_Err != nil {
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/widget/index.templ`, Line: 59, Col: 30}
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var3))
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</span></div>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></label></div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = templ.RenderScriptItems(ctx, templ_7745c5c3_Buffer, handlePreview())
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<button onclick=\"")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		templ_7745c5c3_Var2 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		var templ_7745c5c3_Var4 templ.ComponentScript = handlePreview()
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ_7745c5c3_Var4.Call)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\" type=\"button\" id=\"preview-widget\" class=\"btn btn-primary w-full\">Preview</button></div></div><div class=\"flex items-center justify-center grow\"><div class=\"max-w-4xl w-full\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Var5 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 			templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 			templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 			if !templ_7745c5c3_IsBuffer {
@@ -53,20 +140,44 @@ func widgetHome() templ.Component {
 				}()
 			}
 			ctx = templ.InitializeContext(ctx)
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div><span class=\"text-white\">content</span></div>")
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"w-max p-8 min-h-96\" style=\"zoom: 0.5;\">")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			templ_7745c5c3_Err = widget.Render(ctx, templ_7745c5c3_Buffer)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div>")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			return templ_7745c5c3_Err
 		})
-		templ_7745c5c3_Err = components.OBSMockup("/assets/widget-background.jpg").Render(templ.WithChildren(ctx, templ_7745c5c3_Var2), templ_7745c5c3_Buffer)
+		templ_7745c5c3_Err = components.OBSMockup("/assets/widget-background.jpg").Render(templ.WithChildren(ctx, templ_7745c5c3_Var5), templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></div></div><div class=\"flex\"></div></div>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></div></div>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		return templ_7745c5c3_Err
 	})
 }
+
+func handlePreview() templ.ComponentScript {
+	return templ.ComponentScript{
+		Name: `__templ_handlePreview_9417`,
+		Function: `function __templ_handlePreview_9417(){const ou = document.getElementById("widget-ou").checked ? "1" : "0"
+	const or = document.getElementById("widget-or").checked ? "1" : "0"
+	const vl = document.getElementById("widget-vl").value
+	const newQuery = ` + "`" + `?or=${or}&ou=${ou}&vl=${vl}` + "`" + `
+	if (newQuery != window.location.search) {
+		window.location.search = newQuery
+	}
+}`,
+		Call:       templ.SafeScript(`__templ_handlePreview_9417`),
+		CallInline: templ.SafeScriptInline(`__templ_handlePreview_9417`),
+	}
+}
diff --git a/cmd/frontend/routes/widget/live.templ b/cmd/frontend/routes/widget/live.templ
index ef76ce7b..e5829ae9 100644
--- a/cmd/frontend/routes/widget/live.templ
+++ b/cmd/frontend/routes/widget/live.templ
@@ -10,6 +10,7 @@ import (
 	"github.com/pkg/errors"
 	"golang.org/x/text/language"
 	"slices"
+	"strconv"
 	"time"
 )
 
@@ -37,7 +38,18 @@ var PersonalLiveWidget handler.Page = func(ctx *handler.Context) (handler.Layout
 		return nil, nil, err
 	}
 
-	return layouts.Main, liveWidget(widget.Widget(account, cards, widget.WithAutoReload())), nil
+	var wopts = []widget.WidgetOption{widget.WithAutoReload()}
+	if v, err := strconv.Atoi(ctx.Query("vl")); err == nil && v >= 0 && v <= 10 {
+		wopts = append(wopts, widget.WithVehicleLimit(int(v)))
+	}
+	if v := ctx.Query("or"); v != "" {
+		wopts = append(wopts, widget.WithRatingOverview(v == "1"))
+	}
+	if v := ctx.Query("ou"); v != "" {
+		wopts = append(wopts, widget.WithUnratedOverview(v == "1"))
+	}
+
+	return layouts.Main, liveWidget(widget.Widget(account, cards, wopts...)), nil
 }
 
 var LiveWidget handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
diff --git a/cmd/frontend/routes/widget/live_templ.go b/cmd/frontend/routes/widget/live_templ.go
index 0e1ebfb9..028ae140 100644
--- a/cmd/frontend/routes/widget/live_templ.go
+++ b/cmd/frontend/routes/widget/live_templ.go
@@ -18,6 +18,7 @@ import (
 	"github.com/pkg/errors"
 	"golang.org/x/text/language"
 	"slices"
+	"strconv"
 	"time"
 )
 
@@ -45,7 +46,18 @@ var PersonalLiveWidget handler.Page = func(ctx *handler.Context) (handler.Layout
 		return nil, nil, err
 	}
 
-	return layouts.Main, liveWidget(widget.Widget(account, cards, widget.WithAutoReload())), nil
+	var wopts = []widget.WidgetOption{widget.WithAutoReload()}
+	if v, err := strconv.Atoi(ctx.Query("vl")); err == nil && v >= 0 && v <= 10 {
+		wopts = append(wopts, widget.WithVehicleLimit(int(v)))
+	}
+	if v := ctx.Query("or"); v != "" {
+		wopts = append(wopts, widget.WithRatingOverview(v == "1"))
+	}
+	if v := ctx.Query("ou"); v != "" {
+		wopts = append(wopts, widget.WithUnratedOverview(v == "1"))
+	}
+
+	return layouts.Main, liveWidget(widget.Widget(account, cards, wopts...)), nil
 }
 
 var LiveWidget handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
diff --git a/internal/database/models/account.go b/internal/database/models/account.go
index 773bfdca..221e284b 100644
--- a/internal/database/models/account.go
+++ b/internal/database/models/account.go
@@ -3,14 +3,14 @@ package models
 import "time"
 
 type Account struct {
-	ID       string
-	Realm    string
-	Nickname string
+	ID       string `json:"id"`
+	Realm    string `json:"realm"`
+	Nickname string `json:"nickname"`
 
-	Private        bool
-	CreatedAt      time.Time
-	LastBattleTime time.Time
+	Private        bool      `json:"private"`
+	CreatedAt      time.Time `json:"createdAt"`
+	LastBattleTime time.Time `json:"lastBattleTime"`
 
-	ClanID  string
-	ClanTag string
+	ClanID  string `json:"clanId"`
+	ClanTag string `json:"clanTag"`
 }
diff --git a/internal/stats/frame/value.go b/internal/stats/frame/value.go
index b14a2148..5c5075dd 100644
--- a/internal/stats/frame/value.go
+++ b/internal/stats/frame/value.go
@@ -4,6 +4,8 @@ import "fmt"
 
 type ValueInt int
 
+var _ Value = ValueInt(0)
+
 func (value ValueInt) String() string {
 	return fmt.Sprintf("%d", value)
 }
@@ -14,6 +16,8 @@ func (value ValueInt) Float() float32 {
 
 type ValueFloatDecimal float32
 
+var _ Value = ValueFloatDecimal(0)
+
 func (value ValueFloatDecimal) String() string {
 	return fmt.Sprintf("%.2f", value)
 }
@@ -24,6 +28,8 @@ func (value ValueFloatDecimal) Float() float32 {
 
 type ValueFloatPercent float32
 
+var _ Value = ValueFloatPercent(0)
+
 func (value ValueFloatPercent) String() string {
 	return fmt.Sprintf("%.2f%%", value)
 }
@@ -34,6 +40,8 @@ func (value ValueFloatPercent) Float() float32 {
 
 type valueInvalid struct{}
 
+var _ Value = InvalidValue
+
 func (value valueInvalid) String() string {
 	return "-"
 }
@@ -54,6 +62,8 @@ var InvalidValue = valueInvalid{}
 
 type ValueSpecialRating float32
 
+var _ Value = ValueSpecialRating(0)
+
 func (value ValueSpecialRating) int() int {
 	if value > 0 {
 		return int((value * 10) + 3000)
diff --git a/internal/stats/prepare/session/v1/constants.go b/internal/stats/prepare/session/v1/constants.go
index 4d872179..c64e8a86 100644
--- a/internal/stats/prepare/session/v1/constants.go
+++ b/internal/stats/prepare/session/v1/constants.go
@@ -31,27 +31,27 @@ type Cards struct {
 }
 
 type UnratedCards struct {
-	Overview   OverviewCard
-	Vehicles   []VehicleCard
-	Highlights []VehicleCard
+	Overview   OverviewCard  `json:"overview"`
+	Vehicles   []VehicleCard `json:"vehicles"`
+	Highlights []VehicleCard `json:"highlights"`
 }
 
 type RatingCards struct {
-	Overview OverviewCard
-	Vehicles []VehicleCard
+	Overview OverviewCard  `json:"overview"`
+	Vehicles []VehicleCard `json:"vehicles"`
 }
 
 type OverviewColumn struct {
-	Blocks []common.StatsBlock[BlockData]
-	Flavor blockFlavor
+	Blocks []common.StatsBlock[BlockData] `json:"blocks"`
+	Flavor blockFlavor                    `json:"flavor"`
 }
 
 type OverviewCard common.StatsCard[OverviewColumn, string]
 type VehicleCard common.StatsCard[common.StatsBlock[BlockData], string]
 
 type BlockData struct {
-	Session frame.Value
-	Career  frame.Value
+	Session frame.Value `json:"session"`
+	Career  frame.Value `json:"career"`
 }
 
 type blockFlavor string

From 03a604b2af817545e7dd21047d3d27a20763f617 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 4 Jul 2024 19:05:02 -0400
Subject: [PATCH 257/341] widget preview without refresh

---
 cmd/frontend/routes/api/widget/mock.templ    |  3 +++
 cmd/frontend/routes/api/widget/mock_templ.go |  3 +++
 cmd/frontend/routes/widget/index.templ       |  6 +++++-
 cmd/frontend/routes/widget/index_templ.go    | 14 +++++++++-----
 4 files changed, 20 insertions(+), 6 deletions(-)

diff --git a/cmd/frontend/routes/api/widget/mock.templ b/cmd/frontend/routes/api/widget/mock.templ
index 6a93e6bc..7d81c897 100644
--- a/cmd/frontend/routes/api/widget/mock.templ
+++ b/cmd/frontend/routes/api/widget/mock.templ
@@ -4,6 +4,7 @@ import (
 	"github.com/cufee/aftermath/cmd/frontend/assets"
 	"github.com/cufee/aftermath/cmd/frontend/components/widget"
 	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"net/http"
 	"strconv"
 )
 
@@ -18,6 +19,8 @@ var MockWidget handler.Partial = func(ctx *handler.Context) (templ.Component, er
 	if v := ctx.Query("ou"); v != "" {
 		opts = append(opts, widget.WithUnratedOverview(v == "1"))
 	}
+
+	ctx.SetStatus(http.StatusBadRequest)
 	return mockWidget(widget.Widget(assets.MockWidgetData().Account, assets.MockWidgetData().Cards, opts...)), nil
 }
 
diff --git a/cmd/frontend/routes/api/widget/mock_templ.go b/cmd/frontend/routes/api/widget/mock_templ.go
index 6bfbf0a3..0694da22 100644
--- a/cmd/frontend/routes/api/widget/mock_templ.go
+++ b/cmd/frontend/routes/api/widget/mock_templ.go
@@ -12,6 +12,7 @@ import (
 	"github.com/cufee/aftermath/cmd/frontend/assets"
 	"github.com/cufee/aftermath/cmd/frontend/components/widget"
 	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"net/http"
 	"strconv"
 )
 
@@ -26,6 +27,8 @@ var MockWidget handler.Partial = func(ctx *handler.Context) (templ.Component, er
 	if v := ctx.Query("ou"); v != "" {
 		opts = append(opts, widget.WithUnratedOverview(v == "1"))
 	}
+
+	ctx.SetStatus(http.StatusBadRequest)
 	return mockWidget(widget.Widget(assets.MockWidgetData().Account, assets.MockWidgetData().Cards, opts...)), nil
 }
 
diff --git a/cmd/frontend/routes/widget/index.templ b/cmd/frontend/routes/widget/index.templ
index 3119cab4..2bcc14b4 100644
--- a/cmd/frontend/routes/widget/index.templ
+++ b/cmd/frontend/routes/widget/index.templ
@@ -83,6 +83,10 @@ script handlePreview() {
 	const vl = document.getElementById("widget-vl").value
 	const newQuery = `?or=${or}&ou=${ou}&vl=${vl}`
 	if (newQuery != window.location.search) {
-		window.location.search = newQuery
+		fetch("/api/widget/mock"+newQuery).then((r) => r.text()).then((html) => {
+			document.getElementById("mock-widget").outerHTML = html
+			const url = window.location.protocol + "//" + window.location.host + window.location.pathname + newQuery;
+			window.history?.pushState({path:url},'',url);
+		}).catch(e => console.log(e))
 	}
 }
diff --git a/cmd/frontend/routes/widget/index_templ.go b/cmd/frontend/routes/widget/index_templ.go
index cc797c88..59f4f47a 100644
--- a/cmd/frontend/routes/widget/index_templ.go
+++ b/cmd/frontend/routes/widget/index_templ.go
@@ -168,16 +168,20 @@ func widgetHome(widget templ.Component, or, ou bool, vl int) templ.Component {
 
 func handlePreview() templ.ComponentScript {
 	return templ.ComponentScript{
-		Name: `__templ_handlePreview_9417`,
-		Function: `function __templ_handlePreview_9417(){const ou = document.getElementById("widget-ou").checked ? "1" : "0"
+		Name: `__templ_handlePreview_f919`,
+		Function: `function __templ_handlePreview_f919(){const ou = document.getElementById("widget-ou").checked ? "1" : "0"
 	const or = document.getElementById("widget-or").checked ? "1" : "0"
 	const vl = document.getElementById("widget-vl").value
 	const newQuery = ` + "`" + `?or=${or}&ou=${ou}&vl=${vl}` + "`" + `
 	if (newQuery != window.location.search) {
-		window.location.search = newQuery
+		fetch("/api/widget/mock"+newQuery).then((r) => r.text()).then((html) => {
+			document.getElementById("mock-widget").outerHTML = html
+			const url = window.location.protocol + "//" + window.location.host + window.location.pathname + newQuery;
+			window.history?.pushState({path:url},'',url);
+		}).catch(e => console.log(e))
 	}
 }`,
-		Call:       templ.SafeScript(`__templ_handlePreview_9417`),
-		CallInline: templ.SafeScriptInline(`__templ_handlePreview_9417`),
+		Call:       templ.SafeScript(`__templ_handlePreview_f919`),
+		CallInline: templ.SafeScriptInline(`__templ_handlePreview_f919`),
 	}
 }

From ee7cf4f57c76a0c806170eeaeb618c74ae095ae3 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 4 Jul 2024 19:05:58 -0400
Subject: [PATCH 258/341] fixed response status

---
 cmd/frontend/routes/api/widget/mock.templ    | 2 --
 cmd/frontend/routes/api/widget/mock_templ.go | 2 --
 2 files changed, 4 deletions(-)

diff --git a/cmd/frontend/routes/api/widget/mock.templ b/cmd/frontend/routes/api/widget/mock.templ
index 7d81c897..24ba8cd6 100644
--- a/cmd/frontend/routes/api/widget/mock.templ
+++ b/cmd/frontend/routes/api/widget/mock.templ
@@ -4,7 +4,6 @@ import (
 	"github.com/cufee/aftermath/cmd/frontend/assets"
 	"github.com/cufee/aftermath/cmd/frontend/components/widget"
 	"github.com/cufee/aftermath/cmd/frontend/handler"
-	"net/http"
 	"strconv"
 )
 
@@ -20,7 +19,6 @@ var MockWidget handler.Partial = func(ctx *handler.Context) (templ.Component, er
 		opts = append(opts, widget.WithUnratedOverview(v == "1"))
 	}
 
-	ctx.SetStatus(http.StatusBadRequest)
 	return mockWidget(widget.Widget(assets.MockWidgetData().Account, assets.MockWidgetData().Cards, opts...)), nil
 }
 
diff --git a/cmd/frontend/routes/api/widget/mock_templ.go b/cmd/frontend/routes/api/widget/mock_templ.go
index 0694da22..033591f5 100644
--- a/cmd/frontend/routes/api/widget/mock_templ.go
+++ b/cmd/frontend/routes/api/widget/mock_templ.go
@@ -12,7 +12,6 @@ import (
 	"github.com/cufee/aftermath/cmd/frontend/assets"
 	"github.com/cufee/aftermath/cmd/frontend/components/widget"
 	"github.com/cufee/aftermath/cmd/frontend/handler"
-	"net/http"
 	"strconv"
 )
 
@@ -28,7 +27,6 @@ var MockWidget handler.Partial = func(ctx *handler.Context) (templ.Component, er
 		opts = append(opts, widget.WithUnratedOverview(v == "1"))
 	}
 
-	ctx.SetStatus(http.StatusBadRequest)
 	return mockWidget(widget.Widget(assets.MockWidgetData().Account, assets.MockWidgetData().Cards, opts...)), nil
 }
 

From ad2adb45f56657a5f5e79bdbc436336dfba26db9 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 4 Jul 2024 19:52:20 -0400
Subject: [PATCH 259/341] better widget preview experience

---
 cmd/frontend/components/head.templ            |  32 ++++
 cmd/frontend/components/head_templ.go         |  78 +++++++++
 cmd/frontend/components/widget/settings.templ |  33 ++++
 .../components/widget/settings_templ.go       | 144 +++++++++++++++
 cmd/frontend/handlers.go                      |   6 +-
 cmd/frontend/layouts/main.templ               |  31 +---
 cmd/frontend/layouts/main_templ.go            |  43 +----
 cmd/frontend/layouts/style_only.templ         |  31 ++++
 cmd/frontend/layouts/style_only_templ.go      |  62 +++++++
 cmd/frontend/routes/api/widget/account.templ  |  58 +++++++
 .../routes/api/widget/account_templ.go        |  94 ++++++++++
 cmd/frontend/routes/widget/configure.templ    |  76 --------
 cmd/frontend/routes/widget/configure_templ.go |  97 -----------
 cmd/frontend/routes/widget/index.templ        |  59 +++----
 cmd/frontend/routes/widget/index_templ.go     | 108 +++---------
 cmd/frontend/routes/widget/live.templ         |  17 +-
 cmd/frontend/routes/widget/live_templ.go      |  19 +-
 cmd/frontend/routes/widget/preview.templ      |  89 ++++++++++
 cmd/frontend/routes/widget/preview_templ.go   | 164 ++++++++++++++++++
 19 files changed, 877 insertions(+), 364 deletions(-)
 create mode 100644 cmd/frontend/components/head.templ
 create mode 100644 cmd/frontend/components/head_templ.go
 create mode 100644 cmd/frontend/components/widget/settings.templ
 create mode 100644 cmd/frontend/components/widget/settings_templ.go
 create mode 100644 cmd/frontend/layouts/style_only.templ
 create mode 100644 cmd/frontend/layouts/style_only_templ.go
 create mode 100644 cmd/frontend/routes/api/widget/account.templ
 create mode 100644 cmd/frontend/routes/api/widget/account_templ.go
 delete mode 100644 cmd/frontend/routes/widget/configure.templ
 delete mode 100644 cmd/frontend/routes/widget/configure_templ.go
 create mode 100644 cmd/frontend/routes/widget/preview.templ
 create mode 100644 cmd/frontend/routes/widget/preview_templ.go

diff --git a/cmd/frontend/components/head.templ b/cmd/frontend/components/head.templ
new file mode 100644
index 00000000..8ecca509
--- /dev/null
+++ b/cmd/frontend/components/head.templ
@@ -0,0 +1,32 @@
+package components
+
+import "github.com/cufee/aftermath/cmd/frontend/logic"
+
+templ Head() {
+	<head>
+		<meta charset="utf-8"/>
+		<meta name="color-scheme" content="light"/>
+		<meta name="viewport" content="width=device-width, initial-scale=1"/>
+		<link href="https://cdn.jsdelivr.net/npm/daisyui@4.11.1/dist/full.min.css" rel="stylesheet" type="text/css"/>
+		<script src="https://unpkg.com/htmx.org@1.9.12"></script>
+		<script src="https://unpkg.com/htmx.org/dist/ext/head-support.js"></script>
+		<script src="https://unpkg.com/htmx.org@1.9.12/dist/ext/multi-swap.js"></script>
+		<script src="https://cdn.tailwindcss.com"></script>
+		@logic.EmbedMinifiedScript(tailwindConfig())
+		<title>{ appName }</title>
+	</head>
+}
+
+script tailwindConfig() {
+	tailwind.config = {
+		theme: {
+			borderRadius: {
+				"sm": "10px",
+				"md": "15px",
+				"lg": "20px",
+				"xl": "25px",
+				'full': '9999px',
+			}
+		}
+	}
+}
diff --git a/cmd/frontend/components/head_templ.go b/cmd/frontend/components/head_templ.go
new file mode 100644
index 00000000..a78d7c78
--- /dev/null
+++ b/cmd/frontend/components/head_templ.go
@@ -0,0 +1,78 @@
+// Code generated by templ - DO NOT EDIT.
+
+// templ: version: v0.2.731
+package components
+
+//lint:file-ignore SA4006 This context is only used if a nested component is present.
+
+import "github.com/a-h/templ"
+import templruntime "github.com/a-h/templ/runtime"
+
+import "github.com/cufee/aftermath/cmd/frontend/logic"
+
+func Head() templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var1 == nil {
+			templ_7745c5c3_Var1 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<head><meta charset=\"utf-8\"><meta name=\"color-scheme\" content=\"light\"><meta name=\"viewport\" content=\"width=device-width, initial-scale=1\"><link href=\"https://cdn.jsdelivr.net/npm/daisyui@4.11.1/dist/full.min.css\" rel=\"stylesheet\" type=\"text/css\"><script src=\"https://unpkg.com/htmx.org@1.9.12\"></script><script src=\"https://unpkg.com/htmx.org/dist/ext/head-support.js\"></script><script src=\"https://unpkg.com/htmx.org@1.9.12/dist/ext/multi-swap.js\"></script><script src=\"https://cdn.tailwindcss.com\"></script>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = logic.EmbedMinifiedScript(tailwindConfig()).Render(ctx, templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<title>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var2 string
+		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(appName)
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/head.templ`, Line: 16, Col: 18}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</title></head>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return templ_7745c5c3_Err
+	})
+}
+
+func tailwindConfig() templ.ComponentScript {
+	return templ.ComponentScript{
+		Name: `__templ_tailwindConfig_0472`,
+		Function: `function __templ_tailwindConfig_0472(){tailwind.config = {
+		theme: {
+			borderRadius: {
+				"sm": "10px",
+				"md": "15px",
+				"lg": "20px",
+				"xl": "25px",
+				'full': '9999px',
+			}
+		}
+	}
+}`,
+		Call:       templ.SafeScript(`__templ_tailwindConfig_0472`),
+		CallInline: templ.SafeScriptInline(`__templ_tailwindConfig_0472`),
+	}
+}
diff --git a/cmd/frontend/components/widget/settings.templ b/cmd/frontend/components/widget/settings.templ
new file mode 100644
index 00000000..c19bcbc9
--- /dev/null
+++ b/cmd/frontend/components/widget/settings.templ
@@ -0,0 +1,33 @@
+package widget
+
+import "fmt"
+
+templ Settings(onChange templ.ComponentScript, or, ou bool, vl int) {
+	<div class="form-control flex gap-2">
+		<div class="flex flex-col bg-base-200 rounded-lg p-4">
+			<span class="text-lg">Rating Battles</span>
+			<label class="label cursor-pointer">
+				<span class="label-text">Show Overview Card</span>
+				<input id="widget-settings-or" type="checkbox" class="toggle toggle-secondary" checked?={ or } onchange={ onChange }/>
+			</label>
+		</div>
+		<div class="flex flex-col bg-base-200 rounded-lg p-4">
+			<span class="text-lg">Regular Battles</span>
+			<label class="label cursor-pointer">
+				<span class="label-text">Show Overview Card</span>
+				<input id="widget-settings-ou" type="checkbox" class="toggle toggle-secondary" checked?={ ou } onchange={ onChange }/>
+			</label>
+			<label class="label cursor-pointer flex flex-col items-start gap-1">
+				<span class="label-text">Vehicle Cards</span>
+				<input id="widget-settings-vl" type="range" min="0" max="10" value={ fmt.Sprint(vl) } class="range" step="1" onchange={ onChange }/>
+				<div class="flex w-full justify-between px-2 text-xs">
+					for i := range 11 {
+						<div class="flex flex-col items-center">
+							<span>{ fmt.Sprint(i) }</span>
+						</div>
+					}
+				</div>
+			</label>
+		</div>
+	</div>
+}
diff --git a/cmd/frontend/components/widget/settings_templ.go b/cmd/frontend/components/widget/settings_templ.go
new file mode 100644
index 00000000..5e02fe40
--- /dev/null
+++ b/cmd/frontend/components/widget/settings_templ.go
@@ -0,0 +1,144 @@
+// Code generated by templ - DO NOT EDIT.
+
+// templ: version: v0.2.731
+package widget
+
+//lint:file-ignore SA4006 This context is only used if a nested component is present.
+
+import "github.com/a-h/templ"
+import templruntime "github.com/a-h/templ/runtime"
+
+import "fmt"
+
+func Settings(onChange templ.ComponentScript, or, ou bool, vl int) templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var1 == nil {
+			templ_7745c5c3_Var1 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"form-control flex gap-2\"><div class=\"flex flex-col bg-base-200 rounded-lg p-4\"><span class=\"text-lg\">Rating Battles</span> <label class=\"label cursor-pointer\"><span class=\"label-text\">Show Overview Card</span> ")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = templ.RenderScriptItems(ctx, templ_7745c5c3_Buffer, onChange)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<input id=\"widget-settings-or\" type=\"checkbox\" class=\"toggle toggle-secondary\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		if or {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" checked")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" onchange=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var2 templ.ComponentScript = onChange
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ_7745c5c3_Var2.Call)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"></label></div><div class=\"flex flex-col bg-base-200 rounded-lg p-4\"><span class=\"text-lg\">Regular Battles</span> <label class=\"label cursor-pointer\"><span class=\"label-text\">Show Overview Card</span> ")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = templ.RenderScriptItems(ctx, templ_7745c5c3_Buffer, onChange)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<input id=\"widget-settings-ou\" type=\"checkbox\" class=\"toggle toggle-secondary\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		if ou {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" checked")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" onchange=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var3 templ.ComponentScript = onChange
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ_7745c5c3_Var3.Call)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"></label> <label class=\"label cursor-pointer flex flex-col items-start gap-1\"><span class=\"label-text\">Vehicle Cards</span> ")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = templ.RenderScriptItems(ctx, templ_7745c5c3_Buffer, onChange)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<input id=\"widget-settings-vl\" type=\"range\" min=\"0\" max=\"10\" value=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var4 string
+		templ_7745c5c3_Var4, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprint(vl))
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/settings.templ`, Line: 22, Col: 87}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var4))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\" class=\"range\" step=\"1\" onchange=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var5 templ.ComponentScript = onChange
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ_7745c5c3_Var5.Call)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><div class=\"flex w-full justify-between px-2 text-xs\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		for i := range 11 {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-col items-center\"><span>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			var templ_7745c5c3_Var6 string
+			templ_7745c5c3_Var6, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprint(i))
+			if templ_7745c5c3_Err != nil {
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/settings.templ`, Line: 26, Col: 28}
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var6))
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</span></div>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></label></div></div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return templ_7745c5c3_Err
+	})
+}
diff --git a/cmd/frontend/handlers.go b/cmd/frontend/handlers.go
index 484db49e..503c1c71 100644
--- a/cmd/frontend/handlers.go
+++ b/cmd/frontend/handlers.go
@@ -66,7 +66,7 @@ func Handlers(core core.Client) ([]server.Handler, error) {
 		},
 		{
 			Path: get("/widget/{accountId}"),
-			Func: handler.Chain(core, widget.ConfigureWidget),
+			Func: handler.Chain(core, widget.WidgetPreview),
 		},
 		{
 			Path: get("/widget/{accountId}/live"),
@@ -98,6 +98,10 @@ func Handlers(core core.Client) ([]server.Handler, error) {
 			Path: get("/api/widget/mock"),
 			Func: handler.Chain(core, aWidget.MockWidget),
 		},
+		{
+			Path: get("/api/widget/{accountId}"),
+			Func: handler.Chain(core, aWidget.AccountWidget),
+		},
 	}, nil
 }
 
diff --git a/cmd/frontend/layouts/main.templ b/cmd/frontend/layouts/main.templ
index dc9b6a2f..cf4276c8 100644
--- a/cmd/frontend/layouts/main.templ
+++ b/cmd/frontend/layouts/main.templ
@@ -3,12 +3,8 @@ package layouts
 import (
 	"github.com/cufee/aftermath/cmd/frontend/components"
 	"github.com/cufee/aftermath/cmd/frontend/handler"
-	"github.com/cufee/aftermath/cmd/frontend/logic"
-	"os"
 )
 
-var appName = os.Getenv("WEBAPP_NAME")
-
 var Main handler.Layout = func(ctx *handler.Context, children ...templ.Component) (templ.Component, error) {
 	navbar, err := components.Navbar(ctx)
 	if err != nil {
@@ -21,18 +17,7 @@ var Main handler.Layout = func(ctx *handler.Context, children ...templ.Component
 templ main(navbar templ.Component, children ...templ.Component) {
 	<!DOCTYPE html>
 	<html lang="en" data-theme="dark">
-		<head>
-			<meta charset="utf-8"/>
-			<meta name="color-scheme" content="light"/>
-			<meta name="viewport" content="width=device-width, initial-scale=1"/>
-			<link href="https://cdn.jsdelivr.net/npm/daisyui@4.11.1/dist/full.min.css" rel="stylesheet" type="text/css"/>
-			<script src="https://unpkg.com/htmx.org@1.9.12"></script>
-			<script src="https://unpkg.com/htmx.org/dist/ext/head-support.js"></script>
-			<script src="https://unpkg.com/htmx.org@1.9.12/dist/ext/multi-swap.js"></script>
-			<script src="https://cdn.tailwindcss.com"></script>
-			@logic.EmbedMinifiedScript(tailwindConfig())
-			<title>{ appName }</title>
-		</head>
+		@components.Head()
 		<body hx-ext="multi-swap,head-support" class="min-h-screen flex flex-col">
 			<div class="max-w-7xl w-full mx-auto">
 				@navbar
@@ -54,17 +39,3 @@ templ main(navbar templ.Component, children ...templ.Component) {
 		</body>
 	</html>
 }
-
-script tailwindConfig() {
-	tailwind.config = {
-		theme: {
-			borderRadius: {
-				"sm": "10px",
-				"md": "15px",
-				"lg": "20px",
-				"xl": "25px",
-				'full': '9999px',
-			}
-		}
-	}
-}
diff --git a/cmd/frontend/layouts/main_templ.go b/cmd/frontend/layouts/main_templ.go
index ec95d7dc..01543a48 100644
--- a/cmd/frontend/layouts/main_templ.go
+++ b/cmd/frontend/layouts/main_templ.go
@@ -11,12 +11,8 @@ import templruntime "github.com/a-h/templ/runtime"
 import (
 	"github.com/cufee/aftermath/cmd/frontend/components"
 	"github.com/cufee/aftermath/cmd/frontend/handler"
-	"github.com/cufee/aftermath/cmd/frontend/logic"
-	"os"
 )
 
-var appName = os.Getenv("WEBAPP_NAME")
-
 var Main handler.Layout = func(ctx *handler.Context, children ...templ.Component) (templ.Component, error) {
 	navbar, err := components.Navbar(ctx)
 	if err != nil {
@@ -44,28 +40,15 @@ func main(navbar templ.Component, children ...templ.Component) templ.Component {
 			templ_7745c5c3_Var1 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<!doctype html><html lang=\"en\" data-theme=\"dark\"><head><meta charset=\"utf-8\"><meta name=\"color-scheme\" content=\"light\"><meta name=\"viewport\" content=\"width=device-width, initial-scale=1\"><link href=\"https://cdn.jsdelivr.net/npm/daisyui@4.11.1/dist/full.min.css\" rel=\"stylesheet\" type=\"text/css\"><script src=\"https://unpkg.com/htmx.org@1.9.12\"></script><script src=\"https://unpkg.com/htmx.org/dist/ext/head-support.js\"></script><script src=\"https://unpkg.com/htmx.org@1.9.12/dist/ext/multi-swap.js\"></script><script src=\"https://cdn.tailwindcss.com\"></script>")
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		templ_7745c5c3_Err = logic.EmbedMinifiedScript(tailwindConfig()).Render(ctx, templ_7745c5c3_Buffer)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<!doctype html><html lang=\"en\" data-theme=\"dark\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<title>")
+		templ_7745c5c3_Err = components.Head().Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var2 string
-		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(appName)
-		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/layouts/main.templ`, Line: 34, Col: 19}
-		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</title></head><body hx-ext=\"multi-swap,head-support\" class=\"min-h-screen flex flex-col\"><div class=\"max-w-7xl w-full mx-auto\">")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<body hx-ext=\"multi-swap,head-support\" class=\"min-h-screen flex flex-col\"><div class=\"max-w-7xl w-full mx-auto\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -90,23 +73,3 @@ func main(navbar templ.Component, children ...templ.Component) templ.Component {
 		return templ_7745c5c3_Err
 	})
 }
-
-func tailwindConfig() templ.ComponentScript {
-	return templ.ComponentScript{
-		Name: `__templ_tailwindConfig_0472`,
-		Function: `function __templ_tailwindConfig_0472(){tailwind.config = {
-		theme: {
-			borderRadius: {
-				"sm": "10px",
-				"md": "15px",
-				"lg": "20px",
-				"xl": "25px",
-				'full': '9999px',
-			}
-		}
-	}
-}`,
-		Call:       templ.SafeScript(`__templ_tailwindConfig_0472`),
-		CallInline: templ.SafeScriptInline(`__templ_tailwindConfig_0472`),
-	}
-}
diff --git a/cmd/frontend/layouts/style_only.templ b/cmd/frontend/layouts/style_only.templ
new file mode 100644
index 00000000..d3f19c4d
--- /dev/null
+++ b/cmd/frontend/layouts/style_only.templ
@@ -0,0 +1,31 @@
+package layouts
+
+import (
+	"github.com/cufee/aftermath/cmd/frontend/components"
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+)
+
+var StyleOnly handler.Layout = func(ctx *handler.Context, children ...templ.Component) (templ.Component, error) {
+	return styleOnly(children...), nil
+}
+
+templ styleOnly(children ...templ.Component) {
+	<!DOCTYPE html>
+	<html lang="en" data-theme="dark">
+		@components.Head()
+		<body hx-ext="multi-swap,head-support" class="flex flex-col">
+			for _, render := range children {
+				@render
+			}
+			<script>
+				// enable swap on 422, this status code is used for validation errors and returns error messages bound to elements
+				document.body.addEventListener('htmx:beforeOnLoad', function (evt) {
+						if (evt.detail.xhr.status === 422) {
+								evt.detail.shouldSwap = true;
+								evt.detail.isError = false;
+						}
+				});
+			</script>
+		</body>
+	</html>
+}
diff --git a/cmd/frontend/layouts/style_only_templ.go b/cmd/frontend/layouts/style_only_templ.go
new file mode 100644
index 00000000..c41d6a1c
--- /dev/null
+++ b/cmd/frontend/layouts/style_only_templ.go
@@ -0,0 +1,62 @@
+// Code generated by templ - DO NOT EDIT.
+
+// templ: version: v0.2.731
+package layouts
+
+//lint:file-ignore SA4006 This context is only used if a nested component is present.
+
+import "github.com/a-h/templ"
+import templruntime "github.com/a-h/templ/runtime"
+
+import (
+	"github.com/cufee/aftermath/cmd/frontend/components"
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+)
+
+var StyleOnly handler.Layout = func(ctx *handler.Context, children ...templ.Component) (templ.Component, error) {
+	return styleOnly(children...), nil
+}
+
+func styleOnly(children ...templ.Component) templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var1 == nil {
+			templ_7745c5c3_Var1 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<!doctype html><html lang=\"en\" data-theme=\"dark\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = components.Head().Render(ctx, templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<body hx-ext=\"multi-swap,head-support\" class=\"flex flex-col\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		for _, render := range children {
+			templ_7745c5c3_Err = render.Render(ctx, templ_7745c5c3_Buffer)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<script>\n\t\t\t\t// enable swap on 422, this status code is used for validation errors and returns error messages bound to elements\n\t\t\t\tdocument.body.addEventListener('htmx:beforeOnLoad', function (evt) {\n\t\t\t\t\t\tif (evt.detail.xhr.status === 422) {\n\t\t\t\t\t\t\t\tevt.detail.shouldSwap = true;\n\t\t\t\t\t\t\t\tevt.detail.isError = false;\n\t\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t</script></body></html>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return templ_7745c5c3_Err
+	})
+}
diff --git a/cmd/frontend/routes/api/widget/account.templ b/cmd/frontend/routes/api/widget/account.templ
new file mode 100644
index 00000000..a41df837
--- /dev/null
+++ b/cmd/frontend/routes/api/widget/account.templ
@@ -0,0 +1,58 @@
+package widget
+
+import (
+	"context"
+	"github.com/cufee/aftermath/cmd/frontend/components/widget"
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/stats/client/v1"
+	"golang.org/x/text/language"
+	"net/http"
+	"slices"
+	"strconv"
+	"time"
+)
+
+var AccountWidget handler.Partial = func(ctx *handler.Context) (templ.Component, error) {
+	accountID := ctx.Path("accountId")
+	if accountID == "" {
+		return nil, ctx.Redirect("/widget", http.StatusTemporaryRedirect)
+	}
+
+	account, err := ctx.Fetch().Account(ctx.Context, accountID)
+	if err != nil {
+		return nil, ctx.Redirect("/widget", http.StatusTemporaryRedirect)
+	}
+
+	var opts = []client.RequestOption{client.WithWN8()}
+	if ref := ctx.Query("ref"); ref != "" {
+		opts = append(opts, client.WithReferenceID(ref))
+	}
+	if t := ctx.Query("type"); t != "" && slices.Contains(models.SnapshotType("").Values(), t) {
+		opts = append(opts, client.WithType(models.SnapshotType(t)))
+	}
+
+	cards, _, err := ctx.Client.Stats(language.English).SessionCards(context.Background(), account.ID, time.Now(), opts...)
+	if err != nil {
+		return nil, err
+	}
+
+	var wopts []widget.WidgetOption
+	if v, err := strconv.Atoi(ctx.Query("vl")); err == nil && v >= 0 && v <= 10 {
+		wopts = append(wopts, widget.WithVehicleLimit(int(v)))
+	}
+	if v := ctx.Query("or"); v != "" {
+		wopts = append(wopts, widget.WithRatingOverview(v == "1"))
+	}
+	if v := ctx.Query("ou"); v != "" {
+		wopts = append(wopts, widget.WithUnratedOverview(v == "1"))
+	}
+
+	return accountWidget(widget.Widget(account, cards, wopts...)), nil
+}
+
+templ accountWidget(widget templ.Component) {
+	<div id="account-widget">
+		@widget
+	</div>
+}
diff --git a/cmd/frontend/routes/api/widget/account_templ.go b/cmd/frontend/routes/api/widget/account_templ.go
new file mode 100644
index 00000000..1648bee9
--- /dev/null
+++ b/cmd/frontend/routes/api/widget/account_templ.go
@@ -0,0 +1,94 @@
+// Code generated by templ - DO NOT EDIT.
+
+// templ: version: v0.2.731
+package widget
+
+//lint:file-ignore SA4006 This context is only used if a nested component is present.
+
+import "github.com/a-h/templ"
+import templruntime "github.com/a-h/templ/runtime"
+
+import (
+	"context"
+	"github.com/cufee/aftermath/cmd/frontend/components/widget"
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/stats/client/v1"
+	"golang.org/x/text/language"
+	"net/http"
+	"slices"
+	"strconv"
+	"time"
+)
+
+var AccountWidget handler.Partial = func(ctx *handler.Context) (templ.Component, error) {
+	accountID := ctx.Path("accountId")
+	if accountID == "" {
+		return nil, ctx.Redirect("/widget", http.StatusTemporaryRedirect)
+	}
+
+	account, err := ctx.Fetch().Account(ctx.Context, accountID)
+	if err != nil {
+		return nil, ctx.Redirect("/widget", http.StatusTemporaryRedirect)
+	}
+
+	var opts = []client.RequestOption{client.WithWN8()}
+	if ref := ctx.Query("ref"); ref != "" {
+		opts = append(opts, client.WithReferenceID(ref))
+	}
+	if t := ctx.Query("type"); t != "" && slices.Contains(models.SnapshotType("").Values(), t) {
+		opts = append(opts, client.WithType(models.SnapshotType(t)))
+	}
+
+	cards, _, err := ctx.Client.Stats(language.English).SessionCards(context.Background(), account.ID, time.Now(), opts...)
+	if err != nil {
+		return nil, err
+	}
+
+	var wopts []widget.WidgetOption
+	if v, err := strconv.Atoi(ctx.Query("vl")); err == nil && v >= 0 && v <= 10 {
+		wopts = append(wopts, widget.WithVehicleLimit(int(v)))
+	}
+	if v := ctx.Query("or"); v != "" {
+		wopts = append(wopts, widget.WithRatingOverview(v == "1"))
+	}
+	if v := ctx.Query("ou"); v != "" {
+		wopts = append(wopts, widget.WithUnratedOverview(v == "1"))
+	}
+
+	return accountWidget(widget.Widget(account, cards, wopts...)), nil
+}
+
+func accountWidget(widget templ.Component) templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var1 == nil {
+			templ_7745c5c3_Var1 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div id=\"account-widget\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = widget.Render(ctx, templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return templ_7745c5c3_Err
+	})
+}
diff --git a/cmd/frontend/routes/widget/configure.templ b/cmd/frontend/routes/widget/configure.templ
deleted file mode 100644
index d3b012c5..00000000
--- a/cmd/frontend/routes/widget/configure.templ
+++ /dev/null
@@ -1,76 +0,0 @@
-package widget 
-
-import (
-	"context"
-	"fmt"
-	"github.com/cufee/aftermath/cmd/frontend/components/widget"
-	"github.com/cufee/aftermath/cmd/frontend/handler"
-	"github.com/cufee/aftermath/cmd/frontend/layouts"
-	"github.com/cufee/aftermath/internal/stats/client/v1"
-	"github.com/pkg/errors"
-	"golang.org/x/text/language"
-	"time"
-)
-
-var ConfigureWidget handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
-	accountID := ctx.Path("accountId")
-	if accountID == "" {
-		return nil, nil, errors.New("invalid account id")
-	}
-
-	account, err := ctx.Fetch().Account(ctx.Context, accountID)
-	if err != nil {
-		return nil, nil, errors.New("invalid account id")
-	}
-
-	cards, _, err := ctx.Client.Stats(language.English).SessionCards(context.Background(), account.ID, time.Now(), client.WithWN8())
-	if err != nil {
-		return nil, nil, err
-	}
-
-	return layouts.Main, configureWidgetPage(widget.Widget(account, cards)), nil
-}
-
-templ configureWidgetPage(widget templ.Component) {
-	<div class="flex flex-row justify-center gap-4 flex-wrap min-w-max">
-		<div class="grow flex flex-col max-w-xl gap-2">
-			<div class="flex flex-col items-center justify-center gap-4">
-				<div class="form-control w-full flex gap-2">
-					<div class="flex flex-col bg-base-200 rounded-lg p-4">
-						<span class="text-lg">Regular Battles</span>
-						<label class="label cursor-pointer">
-							<span class="label-text">Show Overview Card</span>
-							<input type="checkbox" class="toggle toggle-secondary" checked="checked" disabled/>
-						</label>
-						<label class="label cursor-pointer flex flex-col items-start gap-1">
-							<span class="label-text">Vehicle Cards</span>
-							<input type="range" min="0" max="10" value="3" class="range" step="1" disabled/>
-							<div class="flex w-full justify-between px-2 text-xs">
-								for i := range 11 {
-									<div class="flex flex-col items-center">
-										<span>{ fmt.Sprint(i) }</span>
-									</div>
-								}
-							</div>
-						</label>
-					</div>
-					<div class="flex flex-col bg-base-200 rounded-lg p-4">
-						<span class="text-lg">Rating Battles</span>
-						<label class="label cursor-pointer">
-							<span class="label-text">Show Overview Card</span>
-							<input type="checkbox" class="toggle toggle-secondary" checked="checked" disabled/>
-						</label>
-					</div>
-				</div>
-				<button class="btn btn-primary">
-					copy link
-				</button>
-			</div>
-		</div>
-		<div class="flex flex-col gap-2">
-			<div class="max-m-max">
-				@widget
-			</div>
-		</div>
-	</div>
-}
diff --git a/cmd/frontend/routes/widget/configure_templ.go b/cmd/frontend/routes/widget/configure_templ.go
deleted file mode 100644
index 6331a92e..00000000
--- a/cmd/frontend/routes/widget/configure_templ.go
+++ /dev/null
@@ -1,97 +0,0 @@
-// Code generated by templ - DO NOT EDIT.
-
-// templ: version: v0.2.731
-package widget
-
-//lint:file-ignore SA4006 This context is only used if a nested component is present.
-
-import "github.com/a-h/templ"
-import templruntime "github.com/a-h/templ/runtime"
-
-import (
-	"context"
-	"fmt"
-	"github.com/cufee/aftermath/cmd/frontend/components/widget"
-	"github.com/cufee/aftermath/cmd/frontend/handler"
-	"github.com/cufee/aftermath/cmd/frontend/layouts"
-	"github.com/cufee/aftermath/internal/stats/client/v1"
-	"github.com/pkg/errors"
-	"golang.org/x/text/language"
-	"time"
-)
-
-var ConfigureWidget handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
-	accountID := ctx.Path("accountId")
-	if accountID == "" {
-		return nil, nil, errors.New("invalid account id")
-	}
-
-	account, err := ctx.Fetch().Account(ctx.Context, accountID)
-	if err != nil {
-		return nil, nil, errors.New("invalid account id")
-	}
-
-	cards, _, err := ctx.Client.Stats(language.English).SessionCards(context.Background(), account.ID, time.Now(), client.WithWN8())
-	if err != nil {
-		return nil, nil, err
-	}
-
-	return layouts.Main, configureWidgetPage(widget.Widget(account, cards)), nil
-}
-
-func configureWidgetPage(widget templ.Component) templ.Component {
-	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
-		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
-		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
-		if !templ_7745c5c3_IsBuffer {
-			defer func() {
-				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
-				if templ_7745c5c3_Err == nil {
-					templ_7745c5c3_Err = templ_7745c5c3_BufErr
-				}
-			}()
-		}
-		ctx = templ.InitializeContext(ctx)
-		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
-		if templ_7745c5c3_Var1 == nil {
-			templ_7745c5c3_Var1 = templ.NopComponent
-		}
-		ctx = templ.ClearChildren(ctx)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-row justify-center gap-4 flex-wrap min-w-max\"><div class=\"grow flex flex-col max-w-xl gap-2\"><div class=\"flex flex-col items-center justify-center gap-4\"><div class=\"form-control w-full flex gap-2\"><div class=\"flex flex-col bg-base-200 rounded-lg p-4\"><span class=\"text-lg\">Regular Battles</span> <label class=\"label cursor-pointer\"><span class=\"label-text\">Show Overview Card</span> <input type=\"checkbox\" class=\"toggle toggle-secondary\" checked=\"checked\" disabled></label> <label class=\"label cursor-pointer flex flex-col items-start gap-1\"><span class=\"label-text\">Vehicle Cards</span> <input type=\"range\" min=\"0\" max=\"10\" value=\"3\" class=\"range\" step=\"1\" disabled><div class=\"flex w-full justify-between px-2 text-xs\">")
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		for i := range 11 {
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-col items-center\"><span>")
-			if templ_7745c5c3_Err != nil {
-				return templ_7745c5c3_Err
-			}
-			var templ_7745c5c3_Var2 string
-			templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprint(i))
-			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/widget/configure.templ`, Line: 51, Col: 31}
-			}
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
-			if templ_7745c5c3_Err != nil {
-				return templ_7745c5c3_Err
-			}
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</span></div>")
-			if templ_7745c5c3_Err != nil {
-				return templ_7745c5c3_Err
-			}
-		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></label></div><div class=\"flex flex-col bg-base-200 rounded-lg p-4\"><span class=\"text-lg\">Rating Battles</span> <label class=\"label cursor-pointer\"><span class=\"label-text\">Show Overview Card</span> <input type=\"checkbox\" class=\"toggle toggle-secondary\" checked=\"checked\" disabled></label></div></div><button class=\"btn btn-primary\">copy link</button></div></div><div class=\"flex flex-col gap-2\"><div class=\"max-m-max\">")
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		templ_7745c5c3_Err = widget.Render(ctx, templ_7745c5c3_Buffer)
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></div></div>")
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		return templ_7745c5c3_Err
-	})
-}
diff --git a/cmd/frontend/routes/widget/index.templ b/cmd/frontend/routes/widget/index.templ
index 2bcc14b4..666f5d68 100644
--- a/cmd/frontend/routes/widget/index.templ
+++ b/cmd/frontend/routes/widget/index.templ
@@ -1,8 +1,8 @@
 package widget
 
 import (
-	"fmt"
 	"github.com/cufee/aftermath/cmd/frontend/components"
+	cwidget "github.com/cufee/aftermath/cmd/frontend/components/widget"
 	"github.com/cufee/aftermath/cmd/frontend/handler"
 	"github.com/cufee/aftermath/cmd/frontend/layouts"
 	"github.com/cufee/aftermath/cmd/frontend/routes/api/widget"
@@ -28,7 +28,7 @@ var WidgetHome handler.Page = func(ctx *handler.Context) (handler.Layout, templ.
 templ widgetHome(widget templ.Component, or, ou bool, vl int) {
 	<div class="flex flex-row flex-wrap gap-4">
 		<div class="flex flex-col gap-4 basis-1/2 grow">
-			<div class="flex flex-col gap-2 items-center">
+			<div class="flex flex-col gap-2 text-center">
 				<div class="text-3xl font-bold">
 					Aftermath Streaming Widget
 				</div>
@@ -36,39 +36,13 @@ templ widgetHome(widget templ.Component, or, ou bool, vl int) {
 					Level up your stream with a real-time stats widget!
 				</p>
 			</div>
-			<div class="form-control flex gap-2 grow">
-				<div class="flex flex-col bg-base-200 rounded-lg p-4">
-					<span class="text-lg">Rating Battles</span>
-					<label class="label cursor-pointer">
-						<span class="label-text">Show Overview Card</span>
-						<input id="widget-or" type="checkbox" class="toggle toggle-secondary" checked?={ or }/>
-					</label>
-				</div>
-				<div class="flex flex-col bg-base-200 rounded-lg p-4">
-					<span class="text-lg">Regular Battles</span>
-					<label class="label cursor-pointer">
-						<span class="label-text">Show Overview Card</span>
-						<input id="widget-ou" type="checkbox" class="toggle toggle-secondary" checked?={ ou }/>
-					</label>
-					<label class="label cursor-pointer flex flex-col items-start gap-1">
-						<span class="label-text">Vehicle Cards</span>
-						<input id="widget-vl" type="range" min="0" max="10" value={ fmt.Sprint(vl) } class="range" step="1"/>
-						<div class="flex w-full justify-between px-2 text-xs">
-							for i := range 11 {
-								<div class="flex flex-col items-center">
-									<span>{ fmt.Sprint(i) }</span>
-								</div>
-							}
-						</div>
-					</label>
-				</div>
-				<button onclick={ handlePreview() } type="button" id="preview-widget" class="btn btn-primary w-full">Preview</button>
-			</div>
+			@cwidget.Settings(handlePreviewOnHome(), or, ou, vl)
+			<button disabled type="button" id="preview-widget" class="btn btn-primary w-full">Create Your Widget</button>
 		</div>
 		<div class="flex items-center justify-center grow">
 			<div class="max-w-4xl w-full">
 				@components.OBSMockup("/assets/widget-background.jpg") {
-					<div class="w-max p-8 min-h-96" style="zoom: 0.5;">
+					<div class="w-max p-8 min-w-[500px] min-h-[100vh]" style="zoom: 0.5;">
 						@widget
 					</div>
 				}
@@ -77,16 +51,29 @@ templ widgetHome(widget templ.Component, or, ou bool, vl int) {
 	</div>
 }
 
-script handlePreview() {
-	const ou = document.getElementById("widget-ou").checked ? "1" : "0"
-	const or = document.getElementById("widget-or").checked ? "1" : "0"
-	const vl = document.getElementById("widget-vl").value
+script handlePreviewOnHome() {
+	const ouEl = document.getElementById("widget-settings-ou")
+	const orEl = document.getElementById("widget-settings-or")
+	const vlEl = document.getElementById("widget-settings-vl")
+
+	const ou = ouEl.checked ? "1" : "0"
+	const or = orEl.checked ? "1" : "0"
+	const vl = vlEl.value
 	const newQuery = `?or=${or}&ou=${ou}&vl=${vl}`
 	if (newQuery != window.location.search) {
+		ouEl.disabled = true
+		orEl.disabled = true
+		vlEl.disabled = true
 		fetch("/api/widget/mock"+newQuery).then((r) => r.text()).then((html) => {
 			document.getElementById("mock-widget").outerHTML = html
 			const url = window.location.protocol + "//" + window.location.host + window.location.pathname + newQuery;
 			window.history?.pushState({path:url},'',url);
-		}).catch(e => console.log(e))
+		}).catch(e => console.log(e)).finally(() => {
+			setTimeout(() => {
+				ouEl.disabled = false
+				orEl.disabled = false
+				vlEl.disabled = false
+			}, 250)
+		})
 	}
 }
diff --git a/cmd/frontend/routes/widget/index_templ.go b/cmd/frontend/routes/widget/index_templ.go
index 59f4f47a..1db963b6 100644
--- a/cmd/frontend/routes/widget/index_templ.go
+++ b/cmd/frontend/routes/widget/index_templ.go
@@ -9,8 +9,8 @@ import "github.com/a-h/templ"
 import templruntime "github.com/a-h/templ/runtime"
 
 import (
-	"fmt"
 	"github.com/cufee/aftermath/cmd/frontend/components"
+	cwidget "github.com/cufee/aftermath/cmd/frontend/components/widget"
 	"github.com/cufee/aftermath/cmd/frontend/handler"
 	"github.com/cufee/aftermath/cmd/frontend/layouts"
 	"github.com/cufee/aftermath/cmd/frontend/routes/api/widget"
@@ -51,84 +51,19 @@ func widgetHome(widget templ.Component, or, ou bool, vl int) templ.Component {
 			templ_7745c5c3_Var1 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-row flex-wrap gap-4\"><div class=\"flex flex-col gap-4 basis-1/2 grow\"><div class=\"flex flex-col gap-2 items-center\"><div class=\"text-3xl font-bold\">Aftermath Streaming Widget</div><p>Level up your stream with a real-time stats widget!</p></div><div class=\"form-control flex gap-2 grow\"><div class=\"flex flex-col bg-base-200 rounded-lg p-4\"><span class=\"text-lg\">Rating Battles</span> <label class=\"label cursor-pointer\"><span class=\"label-text\">Show Overview Card</span> <input id=\"widget-or\" type=\"checkbox\" class=\"toggle toggle-secondary\"")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-row flex-wrap gap-4\"><div class=\"flex flex-col gap-4 basis-1/2 grow\"><div class=\"flex flex-col gap-2 text-center\"><div class=\"text-3xl font-bold\">Aftermath Streaming Widget</div><p>Level up your stream with a real-time stats widget!</p></div>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		if or {
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" checked")
-			if templ_7745c5c3_Err != nil {
-				return templ_7745c5c3_Err
-			}
-		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("></label></div><div class=\"flex flex-col bg-base-200 rounded-lg p-4\"><span class=\"text-lg\">Regular Battles</span> <label class=\"label cursor-pointer\"><span class=\"label-text\">Show Overview Card</span> <input id=\"widget-ou\" type=\"checkbox\" class=\"toggle toggle-secondary\"")
+		templ_7745c5c3_Err = cwidget.Settings(handlePreviewOnHome(), or, ou, vl).Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		if ou {
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" checked")
-			if templ_7745c5c3_Err != nil {
-				return templ_7745c5c3_Err
-			}
-		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("></label> <label class=\"label cursor-pointer flex flex-col items-start gap-1\"><span class=\"label-text\">Vehicle Cards</span> <input id=\"widget-vl\" type=\"range\" min=\"0\" max=\"10\" value=\"")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<button disabled type=\"button\" id=\"preview-widget\" class=\"btn btn-primary w-full\">Create Your Widget</button></div><div class=\"flex items-center justify-center grow\"><div class=\"max-w-4xl w-full\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var2 string
-		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprint(vl))
-		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/widget/index.templ`, Line: 55, Col: 80}
-		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\" class=\"range\" step=\"1\"><div class=\"flex w-full justify-between px-2 text-xs\">")
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		for i := range 11 {
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-col items-center\"><span>")
-			if templ_7745c5c3_Err != nil {
-				return templ_7745c5c3_Err
-			}
-			var templ_7745c5c3_Var3 string
-			templ_7745c5c3_Var3, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprint(i))
-			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/widget/index.templ`, Line: 59, Col: 30}
-			}
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var3))
-			if templ_7745c5c3_Err != nil {
-				return templ_7745c5c3_Err
-			}
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</span></div>")
-			if templ_7745c5c3_Err != nil {
-				return templ_7745c5c3_Err
-			}
-		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></label></div>")
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		templ_7745c5c3_Err = templ.RenderScriptItems(ctx, templ_7745c5c3_Buffer, handlePreview())
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<button onclick=\"")
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		var templ_7745c5c3_Var4 templ.ComponentScript = handlePreview()
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ_7745c5c3_Var4.Call)
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\" type=\"button\" id=\"preview-widget\" class=\"btn btn-primary w-full\">Preview</button></div></div><div class=\"flex items-center justify-center grow\"><div class=\"max-w-4xl w-full\">")
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		templ_7745c5c3_Var5 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_Var2 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 			templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 			templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 			if !templ_7745c5c3_IsBuffer {
@@ -140,7 +75,7 @@ func widgetHome(widget templ.Component, or, ou bool, vl int) templ.Component {
 				}()
 			}
 			ctx = templ.InitializeContext(ctx)
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"w-max p-8 min-h-96\" style=\"zoom: 0.5;\">")
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"w-max p-8 min-w-[500px] min-h-[100vh]\" style=\"zoom: 0.5;\">")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
@@ -154,7 +89,7 @@ func widgetHome(widget templ.Component, or, ou bool, vl int) templ.Component {
 			}
 			return templ_7745c5c3_Err
 		})
-		templ_7745c5c3_Err = components.OBSMockup("/assets/widget-background.jpg").Render(templ.WithChildren(ctx, templ_7745c5c3_Var5), templ_7745c5c3_Buffer)
+		templ_7745c5c3_Err = components.OBSMockup("/assets/widget-background.jpg").Render(templ.WithChildren(ctx, templ_7745c5c3_Var2), templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -166,22 +101,35 @@ func widgetHome(widget templ.Component, or, ou bool, vl int) templ.Component {
 	})
 }
 
-func handlePreview() templ.ComponentScript {
+func handlePreviewOnHome() templ.ComponentScript {
 	return templ.ComponentScript{
-		Name: `__templ_handlePreview_f919`,
-		Function: `function __templ_handlePreview_f919(){const ou = document.getElementById("widget-ou").checked ? "1" : "0"
-	const or = document.getElementById("widget-or").checked ? "1" : "0"
-	const vl = document.getElementById("widget-vl").value
+		Name: `__templ_handlePreviewOnHome_85e3`,
+		Function: `function __templ_handlePreviewOnHome_85e3(){const ouEl = document.getElementById("widget-settings-ou")
+	const orEl = document.getElementById("widget-settings-or")
+	const vlEl = document.getElementById("widget-settings-vl")
+
+	const ou = ouEl.checked ? "1" : "0"
+	const or = orEl.checked ? "1" : "0"
+	const vl = vlEl.value
 	const newQuery = ` + "`" + `?or=${or}&ou=${ou}&vl=${vl}` + "`" + `
 	if (newQuery != window.location.search) {
+		ouEl.disabled = true
+		orEl.disabled = true
+		vlEl.disabled = true
 		fetch("/api/widget/mock"+newQuery).then((r) => r.text()).then((html) => {
 			document.getElementById("mock-widget").outerHTML = html
 			const url = window.location.protocol + "//" + window.location.host + window.location.pathname + newQuery;
 			window.history?.pushState({path:url},'',url);
-		}).catch(e => console.log(e))
+		}).catch(e => console.log(e)).finally(() => {
+			setTimeout(() => {
+				ouEl.disabled = false
+				orEl.disabled = false
+				vlEl.disabled = false
+			}, 250)
+		})
 	}
 }`,
-		Call:       templ.SafeScript(`__templ_handlePreview_f919`),
-		CallInline: templ.SafeScriptInline(`__templ_handlePreview_f919`),
+		Call:       templ.SafeScript(`__templ_handlePreviewOnHome_85e3`),
+		CallInline: templ.SafeScriptInline(`__templ_handlePreviewOnHome_85e3`),
 	}
 }
diff --git a/cmd/frontend/routes/widget/live.templ b/cmd/frontend/routes/widget/live.templ
index e5829ae9..3defc533 100644
--- a/cmd/frontend/routes/widget/live.templ
+++ b/cmd/frontend/routes/widget/live.templ
@@ -76,11 +76,24 @@ var LiveWidget handler.Page = func(ctx *handler.Context) (handler.Layout, templ.
 		return nil, nil, err
 	}
 
-	return layouts.Main, liveWidget(widget.Widget(account, cards, widget.WithAutoReload())), nil
+	var wopts = []widget.WidgetOption{widget.WithAutoReload()}
+	if v, err := strconv.Atoi(ctx.Query("vl")); err == nil && v >= 0 && v <= 10 {
+		wopts = append(wopts, widget.WithVehicleLimit(int(v)))
+	}
+	if v := ctx.Query("or"); v != "" {
+		wopts = append(wopts, widget.WithRatingOverview(v == "1"))
+	}
+	if v := ctx.Query("ou"); v != "" {
+		wopts = append(wopts, widget.WithUnratedOverview(v == "1"))
+	}
+
+	return layouts.StyleOnly, liveWidget(widget.Widget(account, cards, wopts...)), nil
 }
 
 templ liveWidget(widget templ.Component) {
-	@widget
+	<div class="min-w-max">
+		@widget
+	</div>
 	<style>
     :root { background-color: rgba(0, 0, 0, 0); white-space: nowrap; }
   </style>
diff --git a/cmd/frontend/routes/widget/live_templ.go b/cmd/frontend/routes/widget/live_templ.go
index 028ae140..85bfe6c1 100644
--- a/cmd/frontend/routes/widget/live_templ.go
+++ b/cmd/frontend/routes/widget/live_templ.go
@@ -84,7 +84,18 @@ var LiveWidget handler.Page = func(ctx *handler.Context) (handler.Layout, templ.
 		return nil, nil, err
 	}
 
-	return layouts.Main, liveWidget(widget.Widget(account, cards, widget.WithAutoReload())), nil
+	var wopts = []widget.WidgetOption{widget.WithAutoReload()}
+	if v, err := strconv.Atoi(ctx.Query("vl")); err == nil && v >= 0 && v <= 10 {
+		wopts = append(wopts, widget.WithVehicleLimit(int(v)))
+	}
+	if v := ctx.Query("or"); v != "" {
+		wopts = append(wopts, widget.WithRatingOverview(v == "1"))
+	}
+	if v := ctx.Query("ou"); v != "" {
+		wopts = append(wopts, widget.WithUnratedOverview(v == "1"))
+	}
+
+	return layouts.StyleOnly, liveWidget(widget.Widget(account, cards, wopts...)), nil
 }
 
 func liveWidget(widget templ.Component) templ.Component {
@@ -105,11 +116,15 @@ func liveWidget(widget templ.Component) templ.Component {
 			templ_7745c5c3_Var1 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"min-w-max\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
 		templ_7745c5c3_Err = widget.Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<style>\n    :root { background-color: rgba(0, 0, 0, 0); white-space: nowrap; }\n  </style>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div><style>\n    :root { background-color: rgba(0, 0, 0, 0); white-space: nowrap; }\n  </style>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
diff --git a/cmd/frontend/routes/widget/preview.templ b/cmd/frontend/routes/widget/preview.templ
new file mode 100644
index 00000000..382e2d26
--- /dev/null
+++ b/cmd/frontend/routes/widget/preview.templ
@@ -0,0 +1,89 @@
+package widget
+
+import (
+	"github.com/cufee/aftermath/cmd/frontend/components"
+	cwidget "github.com/cufee/aftermath/cmd/frontend/components/widget"
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/cmd/frontend/layouts"
+	"github.com/cufee/aftermath/cmd/frontend/routes/api/widget"
+	"strconv"
+)
+
+var WidgetPreview handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
+	widget, err := widget.AccountWidget(ctx)
+	if err != nil {
+		return layouts.Main, nil, ctx.Error(err, "failed to generate a widget preview")
+	}
+	if widget == nil {
+		return nil, nil, nil
+	}
+
+	var withUnrated = ctx.Query("ou") != "0"
+	var withRating = ctx.Query("or") != "0"
+	var vehicles int = 3
+	if v, err := strconv.Atoi(ctx.Query("vl")); err == nil && v >= 0 && v <= 10 {
+		vehicles = v
+	}
+
+	return layouts.Main, widgetPreview(ctx.Path("accountId"), widget, withRating, withUnrated, vehicles), nil
+}
+
+templ widgetPreview(accountID string, widget templ.Component, or, ou bool, vl int) {
+	<div class="flex flex-row flex-wrap gap-4">
+		<div class="flex flex-col gap-4 basis-1/2 grow">
+			<div class="flex flex-col gap-2 text-center">
+				<div class="text-3xl font-bold">
+					Aftermath Streaming Widget
+				</div>
+				<p>
+					Level up your stream with a real-time stats widget!
+				</p>
+			</div>
+			@cwidget.Settings(handlePreview(accountID), or, ou, vl)
+			<button type="button" id="copy-widget-link" class="btn btn-primary w-full" onclick={ copyButtonAction() }>Copy Link</button>
+		</div>
+		<div class="flex items-center justify-center grow">
+			<div class="max-w-4xl w-full">
+				@components.OBSMockup("/assets/widget-background.jpg") {
+					<div class="w-max p-8 min-w-[500px] min-h-[100vh]" style="zoom: 0.5;">
+						@widget
+					</div>
+				}
+			</div>
+		</div>
+	</div>
+}
+
+script copyButtonAction() {
+	const url = window.location.protocol + "//" + window.location.host + window.location.pathname + "/live" + window.location.search
+	navigator.clipboard.writeText(url);
+}
+
+script handlePreview(id string) {
+	const ouEl = document.getElementById("widget-settings-ou")
+	const orEl = document.getElementById("widget-settings-or")
+	const vlEl = document.getElementById("widget-settings-vl")
+	const button = document.getElementById("copy-widget-link")
+	
+	const ou = ouEl.checked ? "1" : "0"
+	const or = orEl.checked ? "1" : "0"
+	const vl = vlEl.value
+	const newQuery = `?or=${or}&ou=${ou}&vl=${vl}`
+	if (newQuery != window.location.search) {
+		ouEl.disabled = true
+		orEl.disabled = true
+		vlEl.disabled = true
+		button.disabled = true
+
+		fetch("/api/widget/"+id+newQuery).then((r) => r.text()).then((html) => {
+			document.getElementById("account-widget").outerHTML = html
+			const url = window.location.protocol + "//" + window.location.host + window.location.pathname + newQuery;
+			window.history?.pushState({path:url},'',url);
+		}).catch(e => console.log(e)).finally(() => {
+			ouEl.disabled = false
+			orEl.disabled = false
+			vlEl.disabled = false
+			button.disabled = false
+		})
+	}
+}
diff --git a/cmd/frontend/routes/widget/preview_templ.go b/cmd/frontend/routes/widget/preview_templ.go
new file mode 100644
index 00000000..7bebfffb
--- /dev/null
+++ b/cmd/frontend/routes/widget/preview_templ.go
@@ -0,0 +1,164 @@
+// Code generated by templ - DO NOT EDIT.
+
+// templ: version: v0.2.731
+package widget
+
+//lint:file-ignore SA4006 This context is only used if a nested component is present.
+
+import "github.com/a-h/templ"
+import templruntime "github.com/a-h/templ/runtime"
+
+import (
+	"github.com/cufee/aftermath/cmd/frontend/components"
+	cwidget "github.com/cufee/aftermath/cmd/frontend/components/widget"
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/cmd/frontend/layouts"
+	"github.com/cufee/aftermath/cmd/frontend/routes/api/widget"
+	"strconv"
+)
+
+var WidgetPreview handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
+	widget, err := widget.AccountWidget(ctx)
+	if err != nil {
+		return layouts.Main, nil, ctx.Error(err, "failed to generate a widget preview")
+	}
+	if widget == nil {
+		return nil, nil, nil
+	}
+
+	var withUnrated = ctx.Query("ou") != "0"
+	var withRating = ctx.Query("or") != "0"
+	var vehicles int = 3
+	if v, err := strconv.Atoi(ctx.Query("vl")); err == nil && v >= 0 && v <= 10 {
+		vehicles = v
+	}
+
+	return layouts.Main, widgetPreview(ctx.Path("accountId"), widget, withRating, withUnrated, vehicles), nil
+}
+
+func widgetPreview(accountID string, widget templ.Component, or, ou bool, vl int) templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var1 == nil {
+			templ_7745c5c3_Var1 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-row flex-wrap gap-4\"><div class=\"flex flex-col gap-4 basis-1/2 grow\"><div class=\"flex flex-col gap-2 text-center\"><div class=\"text-3xl font-bold\">Aftermath Streaming Widget</div><p>Level up your stream with a real-time stats widget!</p></div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = cwidget.Settings(handlePreview(accountID), or, ou, vl).Render(ctx, templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = templ.RenderScriptItems(ctx, templ_7745c5c3_Buffer, copyButtonAction())
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<button type=\"button\" id=\"copy-widget-link\" class=\"btn btn-primary w-full\" onclick=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var2 templ.ComponentScript = copyButtonAction()
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ_7745c5c3_Var2.Call)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\">Copy Link</button></div><div class=\"flex items-center justify-center grow\"><div class=\"max-w-4xl w-full\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Var3 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+			templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+			templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+			if !templ_7745c5c3_IsBuffer {
+				defer func() {
+					templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+					if templ_7745c5c3_Err == nil {
+						templ_7745c5c3_Err = templ_7745c5c3_BufErr
+					}
+				}()
+			}
+			ctx = templ.InitializeContext(ctx)
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"w-max p-8 min-w-[500px] min-h-[100vh]\" style=\"zoom: 0.5;\">")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			templ_7745c5c3_Err = widget.Render(ctx, templ_7745c5c3_Buffer)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			return templ_7745c5c3_Err
+		})
+		templ_7745c5c3_Err = components.OBSMockup("/assets/widget-background.jpg").Render(templ.WithChildren(ctx, templ_7745c5c3_Var3), templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></div></div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return templ_7745c5c3_Err
+	})
+}
+
+func copyButtonAction() templ.ComponentScript {
+	return templ.ComponentScript{
+		Name: `__templ_copyButtonAction_1df6`,
+		Function: `function __templ_copyButtonAction_1df6(){const url = window.location.protocol + "//" + window.location.host + window.location.pathname + "/live" + window.location.search
+	navigator.clipboard.writeText(url);
+}`,
+		Call:       templ.SafeScript(`__templ_copyButtonAction_1df6`),
+		CallInline: templ.SafeScriptInline(`__templ_copyButtonAction_1df6`),
+	}
+}
+
+func handlePreview(id string) templ.ComponentScript {
+	return templ.ComponentScript{
+		Name: `__templ_handlePreview_7995`,
+		Function: `function __templ_handlePreview_7995(id){const ouEl = document.getElementById("widget-settings-ou")
+	const orEl = document.getElementById("widget-settings-or")
+	const vlEl = document.getElementById("widget-settings-vl")
+	const button = document.getElementById("copy-widget-link")
+	
+	const ou = ouEl.checked ? "1" : "0"
+	const or = orEl.checked ? "1" : "0"
+	const vl = vlEl.value
+	const newQuery = ` + "`" + `?or=${or}&ou=${ou}&vl=${vl}` + "`" + `
+	if (newQuery != window.location.search) {
+		ouEl.disabled = true
+		orEl.disabled = true
+		vlEl.disabled = true
+		button.disabled = true
+
+		fetch("/api/widget/"+id+newQuery).then((r) => r.text()).then((html) => {
+			document.getElementById("account-widget").outerHTML = html
+			const url = window.location.protocol + "//" + window.location.host + window.location.pathname + newQuery;
+			window.history?.pushState({path:url},'',url);
+		}).catch(e => console.log(e)).finally(() => {
+			ouEl.disabled = false
+			orEl.disabled = false
+			vlEl.disabled = false
+			button.disabled = false
+		})
+	}
+}`,
+		Call:       templ.SafeScript(`__templ_handlePreview_7995`, id),
+		CallInline: templ.SafeScriptInline(`__templ_handlePreview_7995`, id),
+	}
+}

From e4dc803a120b9d838773fa9f767f4cbcc5839cdb Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 4 Jul 2024 19:53:21 -0400
Subject: [PATCH 260/341] slightly longer timeout

---
 cmd/frontend/routes/widget/index.templ    |  2 +-
 cmd/frontend/routes/widget/index_templ.go | 10 +++++-----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/cmd/frontend/routes/widget/index.templ b/cmd/frontend/routes/widget/index.templ
index 666f5d68..d79ed062 100644
--- a/cmd/frontend/routes/widget/index.templ
+++ b/cmd/frontend/routes/widget/index.templ
@@ -73,7 +73,7 @@ script handlePreviewOnHome() {
 				ouEl.disabled = false
 				orEl.disabled = false
 				vlEl.disabled = false
-			}, 250)
+			}, 500)
 		})
 	}
 }
diff --git a/cmd/frontend/routes/widget/index_templ.go b/cmd/frontend/routes/widget/index_templ.go
index 1db963b6..c1c65f9c 100644
--- a/cmd/frontend/routes/widget/index_templ.go
+++ b/cmd/frontend/routes/widget/index_templ.go
@@ -103,8 +103,8 @@ func widgetHome(widget templ.Component, or, ou bool, vl int) templ.Component {
 
 func handlePreviewOnHome() templ.ComponentScript {
 	return templ.ComponentScript{
-		Name: `__templ_handlePreviewOnHome_85e3`,
-		Function: `function __templ_handlePreviewOnHome_85e3(){const ouEl = document.getElementById("widget-settings-ou")
+		Name: `__templ_handlePreviewOnHome_66f0`,
+		Function: `function __templ_handlePreviewOnHome_66f0(){const ouEl = document.getElementById("widget-settings-ou")
 	const orEl = document.getElementById("widget-settings-or")
 	const vlEl = document.getElementById("widget-settings-vl")
 
@@ -125,11 +125,11 @@ func handlePreviewOnHome() templ.ComponentScript {
 				ouEl.disabled = false
 				orEl.disabled = false
 				vlEl.disabled = false
-			}, 250)
+			}, 500)
 		})
 	}
 }`,
-		Call:       templ.SafeScript(`__templ_handlePreviewOnHome_85e3`),
-		CallInline: templ.SafeScriptInline(`__templ_handlePreviewOnHome_85e3`),
+		Call:       templ.SafeScript(`__templ_handlePreviewOnHome_66f0`),
+		CallInline: templ.SafeScriptInline(`__templ_handlePreviewOnHome_66f0`),
 	}
 }

From 150cf4fc93a942facd35807f630db6dd7409e7ec Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 5 Jul 2024 11:09:04 -0400
Subject: [PATCH 261/341] generating website logos

---
 cmd/frontend/assets/gen.go              |  28 ++++++++++++++++++++++++
 cmd/frontend/public/icon-128.png        | Bin 2378 -> 2261 bytes
 cmd/frontend/public/icon-16.png         | Bin 0 -> 349 bytes
 cmd/frontend/public/icon-256.png        | Bin 4905 -> 4671 bytes
 cmd/frontend/public/icon-32.png         | Bin 692 -> 583 bytes
 cmd/frontend/public/icon-512.png        | Bin 10321 -> 10453 bytes
 cmd/frontend/public/icon-64.png         | Bin 1235 -> 1146 bytes
 internal/stats/render/common/v1/logo.go |   2 +-
 8 files changed, 29 insertions(+), 1 deletion(-)
 create mode 100644 cmd/frontend/public/icon-16.png

diff --git a/cmd/frontend/assets/gen.go b/cmd/frontend/assets/gen.go
index 5b233b97..f69bcc74 100644
--- a/cmd/frontend/assets/gen.go
+++ b/cmd/frontend/assets/gen.go
@@ -3,17 +3,20 @@
 package main
 
 import (
+	"fmt"
 	"image/png"
 	"os"
 	"path/filepath"
 
 	"github.com/cufee/aftermath/cmd/frontend/assets"
 	"github.com/cufee/aftermath/internal/stats/render/common/v1"
+	"github.com/disintegration/imaging"
 	"github.com/rs/zerolog/log"
 )
 
 func main() {
 	generateWN8Icons()
+	generateLogoOptions()
 }
 
 var wn8Tiers = []int{0, 1, 301, 451, 651, 901, 1201, 1601, 2001, 2451, 2901}
@@ -54,3 +57,28 @@ func generateWN8Icons() {
 		}
 	}
 }
+
+func generateLogoOptions() {
+	log.Debug().Msg("generating logo options")
+
+	for _, size := range []int{16, 32, 64, 128, 256, 512} {
+		filename := fmt.Sprintf("icon-%d.png", size)
+
+		opts := common.DefaultLogoOptions()
+		opts.Gap *= 10
+		opts.Jump *= 10
+		opts.LineStep *= 10
+		opts.LineWidth *= 10
+
+		img := common.AftermathLogo(common.ColorAftermathRed, opts)
+		f, err := os.Create(filepath.Join("../public", filename))
+		if err != nil {
+			panic(err)
+		}
+		err = png.Encode(f, imaging.Fit(img, size, size, imaging.Linear))
+		if err != nil {
+			panic(err)
+		}
+		f.Close()
+	}
+}
diff --git a/cmd/frontend/public/icon-128.png b/cmd/frontend/public/icon-128.png
index 7c8566d8f547ac7ce318a8c074353e01ea63e21e..0ead61004b181ab32db55bac4aeb02fa428137bb 100644
GIT binary patch
literal 2261
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

literal 2378
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

diff --git a/cmd/frontend/public/icon-16.png b/cmd/frontend/public/icon-16.png
new file mode 100644
index 0000000000000000000000000000000000000000..296978bdb2807bc89e036ca461d5ec676867a013
GIT binary patch
literal 349
zcmV-j0iyniP)<h;3K|Lk000e1NJLTq000mG000jN1^@s6?Q>5r0003bNkl<Zc$}2d
zze*fY7zOa(WH&{^5*E@dsX`VO(xpn3YP&${ZBryo-rzpMKuQrC8=HLsD{Bj}v+@B1
zv5^&vwb1p-mFsd{Xa9I$m^+8_ojKo`X<LFQw6K#O|5fT)lWwU2Ds+o;Bi^hq*a$BY
zL?PYY;l7|-QFx1+O1(BgioK0t!3{IlT@*JNbnpZHg6n6lvx&j0Fz+A=sp;0bfheSz
zS*4DP2?qF&-irBN)(oDA(%=h5g+Y45ZN6e*Fv{BJD>NYed0YAXZJDT@zk7)(PH<MK
zkMiChGdC@|m?!v&Pq@GxF7dY%;{b>FoHc3nKRB<Vu#2zwjqlj6)YnaMqwoR0aEv{i
vrUVmQJ-VsKD>{*l$5D8nXC@B;00960_gg=A=>A>U00000NkvXXu0mjf8}gje

literal 0
HcmV?d00001

diff --git a/cmd/frontend/public/icon-256.png b/cmd/frontend/public/icon-256.png
index ac3ed4fa79383f352d421b8423dcbd720ac0154b..60feffa2fbf05f6fca3bf1438e00f164c38b836f 100644
GIT binary patch
literal 4671
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
IX>9y|0yKa%4FCWD

literal 4905
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
AdH?_b

diff --git a/cmd/frontend/public/icon-32.png b/cmd/frontend/public/icon-32.png
index 09440087a38dd5fa71c6c56c6fca09dee349acc6..cf84b0338966cc7934059b46e4efe500588eafbd 100644
GIT binary patch
delta 571
zcmV-B0>u5a1;+%C7k?iJ1^@s6hE~sv0006GNkl<Zc%1CkziU%b90l;t3vHkd77C)M
z2r3R03cA#_AUHVbAoxcJE<!UpMhBhRp}6U!4ldo4>L>_SP#3|eV^u2RkGAQP+k6Ah
zHlg9BZaEP0Zti*Ko_Fr|d-FzQqSQEtCo#NMXfEgI)N&1A3V$c#GnFfnoj}}M45~9o
z0{eoYfuVuEs<+fg)t>tP0$$)#7f$**gNt~L<wCREOS|6$#&HjGxQ%)jPCe%4f;--i
zaK8q|a3uK0G1`SQ8gsSaj_s#`|AwJ~p@FXFK=l1VY~W|Ec$^IfqC>uSI~RH-FpXze
zz~Nj2aqmKCO@DVI^fGV>Gq{4u0Srur#!P7TZJ=J6AM~ZAwnK9lAs1iqr*fTzK@7aa
zt;%&4vfHrGT%(-FeET{N{U%Ut#~*05P28z+S}`ZM8~bVC8}8yV9#;0giuBuktYR_l
z+1o&=k+$JHPGO01btkFNY?T_1@iaYYp}9*a9Wtfa=YJGS*lLd(|8PpPiFqj6@-yD1
z1Ww=q&XSai^iuJAo8OLgy|X|k`d)}Fsd6@AT(&ifbi&?X+u284O$H`#H2U;(6y{>Q
zey!j`KT-C;dpyFi(5%H8^;mPFR}H+wb!>JL$ix@ij9UBEt?Nc2qOBOG1v_zP{|R*v
zwX)uMh%~5)&6rMWwrUac8>C)-wbwomhO!lFti_rue**vj|Njrxe<%CCg+>4X002ov
JPDHLkV1m0;6*K?<

delta 681
zcmV;a0#^OU1hfT^7k?cH1^@s6%bsqB0007eNkl<Zc%1B)KWG$D5XOJAyZPgZ(J0a4
z{DY=Rqh&CHSOp}75hRU`joJk(lO`zyn~;E}Fol(sAT|axjaVs&TG@$`M8P1YkRxak
zLvBZA-^SdUyG?dU6d@lh_wLQSZ@!zEz4u-~PAJz7z>abEZGWL#82y@uC$|6ynt>w~
z<6Hu~`~rNbKK^S0HV6Ng00mKc>g_X&ZPNrme;2gghyIQ#wvO1=wIu@7`E~;rKs&2=
zbUGW|nt?ZC2E>n-`BkX=q|cTJ*nDgYNc}5T`gVbL33L{w9&MbqCs2-^2iXsE_k^+U
zxdedM26_Wz27ijrH!h&K4`cwe2u-hmH#H-q6P4>h>VO8Q&(PhGZ-ZNF9JTS!dth6@
znkH1Px4Pz=&(L(~P<or7a2mpQ!ti9J%}Y97tpk4m<N*}UrqeE$txMe#jZ<J;#_12Z
z7_0ar0}Upq1+)OzF>9tasW$_9H`;}xaVnY}r?kW|YJUk>4_bEHeOMMoekk0uS%FaL
zE4zg1I@w4fi+~WYQ}AAprz?S1&C%TP*eBd5={j$LhVCd}&yvE>1WaCpp_glYZ7#A+
zINz0Znkptx&IHhY6c$UsT++P!5&Xx%XONOagb$ah5mnk0DS?iI6l0DPiJwJp3pDP5
z*V7)HJbwk=6DSNrp)po&lq%f*0!x=+YEZbfke;ndG3Glp2tThl4$<GSqZk&;Vzze#
zpohS-3&uBBlJFULyJ7k5Dp__&B2&f{yokB2>}~E+BZs}DI;+?87%ZHFk(xVLb{Lm&
zmhM#aRg~ob!cXAO0`FmdF;-r+&UxY9mQm|5t0Mm*?EC;6wAjA_00960E_lS=Dp@Wy
P00000NkvXXu0mjffrdN^

diff --git a/cmd/frontend/public/icon-512.png b/cmd/frontend/public/icon-512.png
index d09fa52fbf5bde2e762c895d9747b700ed7e730e..39d71f287f3f54302b70ec0a6ab7f93821a4d5ff 100644
GIT binary patch
literal 10453
zcmeI2XIE2O*Y|e_A+(SP3QA3+d6XtdlM)CPBK4?<f;4H;L69y9AP^5CF(@5DMWl;T
zr6mYb4vI*xAqJEp9YQC$<2A<f4W4n2`^EJtb7alc_Fj9<`Two;$kO~Wj8~Kw000=)
z_`+2H;9#4e9d0i6kM7@ALI7|o8+*a<dT93IBu|~I>x0?-6<ls6DEjmzS7FfS6G`9s
z<^C}$@pzpxl3D1X^FB~0_R`M*?Vn~HCMDNfoCrTMmu1SRh1<dBJe<Wv|F*@PANvP<
z>Q(1seCKt34)yG@eO#`c*IJPJ%fi;tR-66Csc#$E142cW!>nu@uO>3X-0K7>HGf6|
zbZy^g_BahosYJct3_I5rP4rqI?*VN-#9<H`-*}u3?QIYao;a4B1!J8eT|#Cm8T75n
zR{lmha5i$%M=3)1V|)i&OB5@j15^o5O^f;XRa)s*U-}6kU-o3iJOJfTjtvE`9(9}q
zhQr`>LUsJ>(v(@Jg)Q19m1vSS0D$pToHA->P*IYhe7(5!DKEls2*>tt6G#ew;HgsU
zW1Op4gyI4`Vr0eeyU$e^a)b~d8G2s&{B8KUCrx24iZj)RPa|p0l62`SfHW(d8Ne6C
z;;$j8{Nm>djHY;ZXNgky<)xNUbHQhF#1bI?QS~CSvmZ(2E|r{)hR16i(*jbP#Oj<M
zcch+^dA)G@**Q$trf6raVPn*nBv$OuK+AMlSCN^xLm!?W=zEBDyJ0vBLy+w(w!HqO
z4)(SV_}xfB$eIa)@#hSS-$bo>6KazKzObH(U$xMWyrH^ucp(#MU(x4s3mV4jf4e_!
zkseB@r3{P}@I9^aXHV?I0Utr6)*E8+wm30O!;X+2rv?}cy&9ux+Vd^;2Pwj*&r-Zn
zJR(5(JWc>n&OlX&sLW~ZIe&lr-TW;CIoq_hC<N2zTeWuS<a}<|gJ_ZAh{M`J!@<=H
zx&`wXnWYSnf#*jTVS*7Vs>aos1wV%P7T5E#E2zKPcnl224}>?FS9joQJbtm3#o^)*
zi511G-C<9!ENMb?CGLdv$0<;FJKqkfn|Pl6<DBD)=+LzL{Mx^9<;2smZve8|-rP{~
zd(g4uPd})(`CDplOv*$K+k;|;hC4t4Amb%>fM}!qI(*t8O9WUvJ$%kCI$w`H!Lr)Q
zAGvu-jGUBX^0H;dpEL8a{*l3o3WM=7ScocMOuCNzule8S@V~GK@?6bCkg$^(knj@x
zA!-Y<6?2nE+luu(j8I10Hl)HfLZGwDck8^XEmbS|@1f@wp&u<CNGiT#dId%M5Vwt}
z;K{EQ&bF(}g6>q|uRz|TXN}Ih1y3GE3bd)=r%_M11h^!@r4zfu1VxG)!4~i3^!aDk
z7unv!^Fb@zJwAJv|BfYv06Ac%1#OBN@&%_jcx~kL^$+z^d)7(lZOjDkZD@Bn-Zf3G
z-yuOllXEsWi+L;m@)`C<Y*Xl>u^?Y5gmM5MoNPNn8M}NoTOB^Z6(+l?-N_mvzl6H`
zN(AgCrhZxGyUig!8KlS;WJf*=)0pfJLN%m(DUa9X4TY?#5~lIs=%0KC1p8wO8<!~;
ziMfDMLZfne_mMPZSRBYe2$eBEm7WV*^TXpn;+&<&=cJv^%rGdI@fMT;M$3E?Dpl_&
z7ybv<tpNWTX%F7LM39cQ0#o^F!L>t9>+c*FvRdXhj1+7|dE`OG3{pll!Y_Wug!Yx<
z1lC{<XdVnAEFSKVkxZe*&|9i{bF;;7NEycv$_YDxv`K{gV&7*pfvFv+)wY5;fCS-m
zGN?FXR}*PxINs*WXm9i~4?+wX1sMs+Ply#mvBcNWhO_04*Ur@6TLK+7{ea4A5TI`(
znG&mYN2vRIvtRUxx$zU+IZ`!0bxD%{N&?ka?|DMQ<qabNdbPCgL6O))>Eep-VN#ot
zS&e~h2?K?)Z#gDg^D2+rDOlDM{TXY)s@#s<fz2IE5x<#I=O5fCn|V|;gmpWw!Z=6J
zCge(Ocs_56o{9+-QLs(RR&6)(N+;EBTjYRIObZ%gQ1JWv`P|BH?|Oc?T40C9$BT!~
z0)=twHywpkmfKl|C8#}Ed-%;J2XM!*rGf*Wwyj>$O7@(lZ+G$Y)7b*L&C$~)$(=yn
z4Xm30-keo%XhOLj`$m_G9+J0V+hr=0l)z<qn024ZxhChB%Vm-gqjloETGy9)uHQuF
z2{7J9I^))@<Zadh!fhAcYD4p(^p{9L)p<xKkmfNt)0#f%NmJ-F2iRJs%LB0<FAsTk
zm6x85A<Lh(po$+o&~v8<wV1`pAe2oZlWf&omN_sgx^F!jJo~6CzQF5guqsd}dyjWr
zvqbTMtt?)|@WsR**T}PNd^R;-K0277Y0P$|l_H|3D`08T_6WiHFn>DOS#h=AWsg?C
z_g&h=4IUS2*B$;enDMWtA74=z7oc7q#W!B^TYb!DAo}1U!CkiBC%kw-iIjnlyrH+z
zT((^!jkJGmx_?qby}V51(Lbc**qx8zwnM4^7$KuTcg*^q-wnBEHn}4;5G0%Is2&t0
zN$+I`Uw**zIwPJOs=E5Dz-zQJ6csc!R;_SHQH3W^{RMB1P|AG4Z_6KSubX~hlRLG$
zMN5YARo-qNnVMneRv#9W+{7E<g<e+nTEk7GodC<$JMY4Gr(_<NDaS_M>%Vw6g#H&I
zMWu#G`v)K3Yo>6h#-50ey1#e-MTOp@>^$J&-P$L9q1&C8oo0iF6<=(;5;Vow4E5D;
zq(9^NTY^wie%+FhImHuJ_^6}CrPkz_H%3WV(N3qq`|@G&l+*k`1V`cXJ7k{vw@b6&
z^h}MvL=sa=7Y)k2>;Hl98aMdZdfn-fF5WoR#47$<&Qe_=oydc)UM-lkIqNa|opZ3{
zO=nide<SUG(~ST9bjxNa2sGB@qLEiCOg}{npqwW(q0)>tk+lXBkT9{$@&tC~xia-V
zXp)p#;1YadQy^ALREzr#+ELvFdPj0ypJq;To3n>+WW{c~_uv2h;{;$MmtiN+bQt~C
zu$hxSkASk{<~~q@EC^;=-O=%vYSUA>f2Oov?iTA<r?Sz+1f07iTO>FCVv!`~-u=lr
zGO!-jt6k%HFt5ps0G&Z{%wfDC%Mgv$0Sm{4K9@rgq;g!Hj#gmvd@h!i2+ET!jz{lX
z>?z0Z3?nQ`#SWe~?4}leqV&82<2#IWp>%5$jz1f|R^+lra$KgKWoeP*ZmTvZ&-6!I
z8_m8!Byf1)izXvY$a<p<%y5OalxPS1jwUe;oNMgX3^a+wXvZ4x9S3ZX8KY7krsl{;
zw0Q1(K8f}$=7k05_OkZW=MH>S_nqc$OJ-9g?#+`@(_IR1QenKSas-?e9IZ6;@4}fE
za9xodxgh50(bY$e)06DTo9GDKwNz~qKmYCFPU}KfZncqqn-hWz-^I)^v8o%Is}zga
zjrhpp*c7EOor(jt;#i326DnRld^wLB+CZA)sT(N_9LMd23WLDgkY1uoP3}Jqut>xX
z<H$KC+y=CEl%R%Ua^H}$Px_6$Dm#j(pc@l#@Bl7<I#G;eS5_9Uts@l^>Z+<!Jbf3=
z55SDg?F4qcdPlhf=+cjiVEyN5iio#{E4^pME&AH#^o2v=ZMK(oR6dk2^;WtNVkn24
z#=za<Pl^&$fXBB~D@6;a*K>Bn)ql0FK-SI^%(}jyy8d$3Z_L-gQYE_<oqtPya(I`z
znKU@Pzb$=ptKH?W_^ebzC>MS$BJ6pUcH@gKv~Ni<--B6y3J50daMi1HZVF8Oqv>9O
zmZ!kUr4ds0W0bW-H{f`RiySFK9@8j9r^I*9JIs-Ja)xEp3Ve$U2CJpsL6{6_1x?8m
zEzUdVGqm+Hd~2S?90%In?er?QGGKbU=z%E8IP%5!AQVY7KyXnUI#D~1S%{!lBB@+C
z0bdM>AV=NeCAH~`3~!dk*HAsKP?HZYVVVHene=5Dx(20uHyi$tc#I*~CL$|#`;|Ty
z7yf-G7{yYo!1X`Zy}&vd0h;OR3K9#Kl}Wm(Iv%}<CLUbn+m5+q?PD+y7}a;2J(y_-
z0^J{Uq#?k#TITGKI$L4}bb=R7u%McDUA_kjGs^0A7kKyq=^GXwBCMLw!D5Wu1B-aA
z9(%yU!^G{?*bilg5z<FvxVs<0TDBi%VS0Oy?VV<k5bD{08x8<gF>_UAI+lHwt}Id9
zkqcS!V`hfBu=5r^^~5*jpOgA#O4`Th+TdnWXH)u2{1C`QH0!1vW2c(xbQtlriS*hP
zI9{|&WxN>k$}D#QJ&8%j=biLeTQ??1XO`aqZE?KdycVHu*LjuwGKzX^2-EC;qqkyo
z-_M_vN$Tqf*|fOwdXKYH18!xi3#Qy%vh~~5;khxm&tYs+|0E;tWpk_T2kdteyO%O`
z=kUrQ6@`Smzds<ctpS$z%Pbz=XJkW?2q4G&JG-3sYZcXeOib(+`#*if1-s{_E@jux
z90x9ys2O@R^dImU$|Q}f3%_IG3XcgLy&*>e88l=*6N}A%^KJh-;RGOqJxv4|kn%bH
zFPVK6uKf_>F*UY&k2>VKf4TpnF7G%DbakJNXok8UHrCFcmW+$w2d?fbdesBi2thsC
z5Iei6YlO^c*u~{vc7wBJ|7cue^B+GkynX*g<8T))pokH!gYW+HDg@~fh?H~ghNsz&
z!?S5=@;ornA0!)*8Ujvhy^;Xrr?Ta~qDUhe<rmYKKW`&U8}DuSOY18Zf3=%Egh#zi
zkadisEqgV`MEQt(dcu=gaq4+D8|C0>i%XO=yp+0Kw{#t7-K0f(JWJ_9--|z$o=(La
zsH#i_$--Yd^oyXBed-ZdK4&%_xu8-DTQ_2;Hq?BSq_<ink>sL52AQXFx{>Ii5BB&a
zA`UXSqWS+Q%bQBbx->D@r)wXyryeOvckUhU3pz^@?kU5+;StQHvZm`@wwfqMC~6_h
zZ(ogRf}PtC_o{%Km_F$Ws6nRj_O=+61%%ldDO2aAHbiM?O7Y4$|41yDt=xr9X(^+W
z@!4g;RI%UPAqzP?A(H!vzI)PUa%@!eGDfY|a5jaA<BoKGoWQiX|HTR?;(c$3eC{Qi
zGI8>0+;?JPXxq^&krCZjsA#4;l_&D(I^1#eVv9%fnnk7~n;d<D%x)ILLf6YE;j|Kp
ziu(*2I1rjC>WvU<3yIkt-7yjBu>$%85!v5yn5k^<9hDhtyhHSXH3f@EZ0re?q-RlZ
z5PiO!l9(iogFZnvT}ma^M>n6$XcndmA->@wkF4G%fTPtZryU_GRyf<*u`dZ_gZ)ud
z`|XpFpmm+z2HEsL9M0p>S-{xDlH6im;8$obc{DeEnW}Q1!=K+@tL=QJI%8^Cb1wul
z!5yY(dI;2STTe4{_<Qc|bv!-C!Jfn;-d~0CD-7~7M5&xC(}l&8WS(~dNbJ>Uet;x%
z?Ei?VcYZVoWFx4XJfH=}i>C67`qcju*S%YCrgzzNEbLiRL5bxkTPoPF3LfCt8NMZ)
z-dvE_>pO|owipUPw{b#*6)&;{fWj}7uOB-@ztU-&rG#k^s<lG-2+sIy$rXA0DXlf6
z4g?+J8;GlGo<CWo6V^JziLX0y$F|?9(ECrh6cE+>ryQc>SI@m<9t9s^gEzh)$f`mA
z#s7GCH{*m31S;OlU)fU76a#FQRB6ivi8t{~ZI<0leb8)Usw#W<$Fj%4QQW4O;XTdY
zh`byB=pdCn*n_GQUQcL=kaMZSm^=p=DE1!e&uH4{M>W89bQkO1&SR={CL2)Spf&8M
zAw7q&=ijhCXGd@WET>~Cmmy5ayBqzC5Il~zC-_&e3B>)Y(Sftx(cT+}fd?zGfl*`Z
z0LX6idjsM_ndWjC1=8D4%x+S?=?sc&xjj<#{Y~$FM?oS{1t`>``_j<0LD%xmp!9{m
zR9FA~w_^G@@9y7uNlr`63*rvHR7f^0Yyr&OW17dB*~&=$3Q12mFv(@gV{e0YTT&Hy
z7IXV^V-8kY+IdFHEKPFQ{i@!V-|Q*r7$5gfnfUvg*^Z0<C9#F?90RNyIPmUh>O*{#
zUK${U_syF9Sg67URA2HB$3#hJLF+#LxVLBF?GURgL{E+P`u=)o|7@FF9<0Q~H%7O?
z!Nfn+@M;-b{grSA+RZVoJK=y?&$DLHQ03A+w~DT;t%p3n1eeLj*YyVL_uD7<vY|N^
zkgUkvWSh@Go^a+E2b)eG%GcR;=!*B2)ylny?@5d8_dbxn?r+bUS~lsmb@0<r@8PP$
zE#?}$5IBI8`VXV4pMVU?gf_<ym+cU<0~Y?8kLP<2x#(vowvG#d6@%(5A-@jYHh1LI
zRoMJvMb6vMFi{1T&`6Yp|5&=f8O4bY1$;zFbN^sga#`0N+;D=oQAmsDrhZJT>!DJN
zg|%~aN%PMXR-a|=WgXJBX8wr7D*a@8P$_jcH^HwtGlb}Fm@U;f{N}Z%VgxYY*^*(4
zL_>DtJr$ly!NS}^$Uj&bGvg>0;!``0r#K$`VM>Jz)2e>)oP3{<kp3>bc-^8nP+ech
zTlCkgiIF=S;V5gpo}xMAc#i<P9<*VU1IOA9=movT3Wm;2*imkg8{Sn8V60Pe0oK{k
zRoBj8!{(#(6O?~0MtKhjUHS%P3ZHl2(>NcL|Hu*OZR6JPg(_VsP>$X?z8XmBqFh65
zl_x;=W;X|vTJo%u_m>Mr4|DuB8tOcE_HkR~feGYwPBC1%so%pLtyOWFEc+N_XwZq)
zvN6|U-#777H#4E}9rYdEWU%ombvssjdwcl8S>P_6GjN-Y<KEQ=Ot%sf0C|oMP=Zlu
z+-<wbs%ibsailL$j^6>z*bSz(=18=hFk@+X8l!h)`_Y9puqWhLDzi82q(6thOq(Gw
z!rDo-=K7Dbz7HD(>GwKwuaEBs|C&5?C54T69$hcnppGVy%c5GxwzJByDe~#Bql(FI
znf1-fJ!z@B@}MjKKQMXTdooNV>@wxUUj!>+f}!q-P+fmSTQl(t@)run8z45rAWoGq
zA1hWkU-p0Uj`~cd`qE^LV(d*=*!9U830MHK0zPw(uteMjYC*#WE2=a%LYc}GtVhCY
zT%!gce&MPR4!6MXxYAta#Q7E>rCh1jj0*!R0V^EiB@U(&@Gzm(DW_2p62lrpmHfhJ
zw<616;m^MWBjGW+0`$)mzLy(y2~|GV8mfGB@L`U8ri}5Ll4#{m>wGB;YeT9Pc{y^X
zT@WCRb{ObO(bapyc>F0n)&VQ_1Jw-j(DfFS0Q3dlns6r$zccQ#ci^~O9&o@<l36;P
zF)6j~iXaQDMLLr8B25OO9m6JT%3`%Rc3cVLC^URcvupEW%Y?;cJC-rnK((KR%H?V-
zi&{Vjac>B0CG1$yW*rxvcP-)`Hfm{2N28uAV*7k$)ehVD-J_>U#F%<|1IyTfR@ytL
zJ#fvz+-(Xz*&Xw77nRB+pTGjfR4QD{E7}^9%`2`s<2*=Ku!rq>)4q{1l0SiKA+y?O
z1Jb#mu5oax6#ts7)$}(ft8Hd)(89M!i5YCKw%RS$iIIEO{!|2fgDjxIab_R;%MRfV
zvJiE$XjLV=Mlp}mn<{>-hL=anV2x6|xo-x@1Zi;KIK{PR+Huz1DD#I}&^ug1;wt~d
z@~Z=zIK!?zBh(ah4R_sn+xb0wm5b&*C*jOZl!2KH?t~;mdO%U&kqFZSd+6FeB_f59
zz~A5_W&;$~A2uWy%<3V?x4z-U-#$mM1n&sVoc)g)lkq4jsy~eAz-05R-E;h$ZZZO;
z!+OIsHw7f!#x>d`@yEQ7QMIBCBOf<k@|-Eg<)z1~PcJ+m$|&ACGlcnqX{?H76Hzbx
zu+f1)=?R<t^Uv7J$rME9U0YeeWL4Em3WPpT)hk{*f$bBtuJ!RNmGZV$zuiMckf8@x
zRP~<KMBLN^*l5{^MnpZJ<_#G%9xM2d6w80aP#~c1R#@-96o?Cjn&zlHhKp$dGL;e5
z(?YuUDffx3!JMnVTw;wtr2NaW8F~Qy>wVik;lEePHuhXvDI1Giya3~IoBYtE^ckq4
zTW2bm%&{BTx}fw_M)3h-tN9z){(GBF;FhCRwIC`t-4wprtLNC7evSB!LqKXV@X{~K
zPHQ9f=^l!dkA0d9ih^m?&0h(gHtw{>@SpqU(<?vCRG$3_j%qJ#;?^o)3mvS`^x7cb
zZ=0oKj3;%88h7E84U~Y`qS__JA;ZRs3}<(Y`M+X(`_)gpzj<JNRL*X{ZkB)z?Vlv1
zev?XUMMXssEp7$@#%^hbx*{VXM2>dHi>$O~rkZD;^q1MY>mJ#w-owaxc#L1Q`z_>T
za=0+@{)$_gwQ`o1_g5BXiEpjZFtq{R3+~l9N`H7{IZjvMFn8^4x~HR@`=)YDLkDi+
z;{4ksc7BfOJM~#&uv-7fa?FG(vvuo9yjHPm$(W=$>*W?_y3M9;9EgL`Q_kv8WbSu(
z;yRr>a3hWII@f~^yJtQKv}Zjx_VqK(8^e1S>L7P!R@zvz^pWDP>D<Y2w}W(aJH_$$
ziNCpam;qxAHb+!^!!&1L)9B?_n<-m^W+Et$XY0j#Ho2UK5wm(Q@$L7{k)z-8h6WuH
zRgK{keMHK-iH)5Zmw2s2R&=-g>u$vreBG=0(=tg{w^lBPoU{APv4}s=H=R^x8g(!g
z$9DZJB*E|J!a`#=fl|*FYA0WHV|1;MV73}OQY`)9dj^ZADdImfzP}uQaH-!)f#O4{
zjoDUTTdlI5bTf^K9{XX)Vc=fpCnR1}^eZ@UAxdJs-ZR6_%O{}`s8<3%ORZw6znHC!
z?DAvThrxoBedl&^c+!ELydpz6y2TZ+K0oX*HkgfFde<LmPQ}!5)>!n3I$@J-YN2aO
z3*mlcKE&LFrIg;lv8v<wK4<;{&YjfKM4<=ig8(}!!<w>U&_4CTSm~qLe4D<d<zZv>
zm%Gd;Z)4Fuf$!!?j==Hc5)_)Ns%*Rr7j4I}*5&9M(f`?4w8^oY_3#i&>k}3*+gdS_
zimPKEBwt~>Cq@E0%9LT7;Fd|)ZW_Y+KPchfGf4DEuWG~O{FE5`BUlR;Qcp?;Ir7J7
zJ1(4_JG`aWPz~D?8Fxpa#k{?*oqBriPRngpCTrgl<LD)MWpBG39lJc((q7>8R}9F}
zG^RgfAP}TK5R;@;PeB{L;LFhwE5CSEIy}T68x~m&S%HS;EhNoUw%jrszRC}#9ESwj
zz6?>Ckr&OzrwsnOu&Z?QzDGro;=DuOajPa^8`n@TvU<oB!LbLwfP<|u9k1ES%PC>m
z6y^5>Xjih6Ty%BiCIc^pVV*7B^YqV5B44kdH9p+oooV>(6VuUjbSH{7O^I-N)AZDt
z%^xZk9yLTLs_^X|alGBI^3}TGa7}=)5!-)zL%9fNv4Dvxuh(2<ob|Pfg3qwPYf2+g
zO>mj%;ojv?SH7O*+&Q$l8?!L#$LAGLLb8A5tEg!fwzJ=9(AEAfDfn3SM?LMI<Q98P
z@Ct{$`lqdzIM(iwRS*HrC8n7?r!@wS07Q>w2guLlVwkoxH3li$Nk796q6BushhQRy
z+a3B^i{ioSS35%hu?3L~SfFXMwXz=b=uFlg2sz?1J%wa9Ae_Bs@PUaTL>V34qp1_W
z#b`O=lP7JG7=fU+%P+T$=6ay+u=n?{CT9LzU7Kbqj3@#ha*Dh0xRx(It;gk%>yzL0
z>B9j1pcVdK;_=?;pgc&7S_DIM1TNq2@Nfr0+eMK1cR2}h{IJdbeLIARQPh!jDI|GT
z07sHc@|+^&w8p2&_TxC$h6kHYna3ZTARG#7+|JM=l%UA`w>fvwF=~F2t;u=pTL4w2
zDk0ZY4+Cg{2q*_Tx<j-i=_-zjGp7l@>d`8Gpz?$rrM7L9U+jo@_V*f}1X;6m&vD1*
z=cYK3^HOoT+;l9_0`eqAt14Xnfw`eKL<6jevA;E$vR=RN;@tgQu_x8ZpuD(+^7j!b
z*Ouc3hYcbF;Ex)bD{cs8Ym}?X9y^)-8*Mp}nSJj}>Bmz0`r3qutDzR2+F*l3$n4S{
zEAxe{`o9r<ee}}+mc;7<5M_!Cxc;x0=L~?(MOLnpuo~u%TII%G9sikM<@I3FaI6Nz
zVekdKk;r1c&rBE@3pzr|uSxWwJYiFxyd}iA$o|(@e$a$9&Md}<7@}$SP^O5nTt4>r
zkw1Fo)%Xv?ct8Uj@@M;A&?netDq%<i!C_v573L4WBC`I}<-{|U=Z8MyST`s6!i?Cs
zh%~134!ZnDV%8s9mrp$W#qNLm5^anpojaY#z6zsmCUO$%*|2Oyc_lV@cEQk|@0zCa
z7MP10&{<A6Xy^O_PKPSR|MYoxjWkdvu|4EtJ1+lmiXHH6h4(>;0zk|DK4?Y?Ij#?P
zJTsFP)1O&xL>jnfHJ<7a<Gugy`>(wXcZoGVy-E0TPG$h*+wu1YqN|eyB}5ss$0pH!
z=j_^~yA$!z@ikBwFpg)v``ij_gQebCD;SfifH3IlFa>O8{XvY~?}|b9F(@z4avKxH
zw;tn(!Ia3XS`l#EzsB@arLmrmiobU9MYBdfJz74j+1fy)UH4g~!+zKSIw^fPu5z)1
z%J>D1PBPwqH&<r<?|*+I_kG5f%&gZD!`JVB&WVlcrGSv>zgq^<*qgFKxCWj3Kq3e&
z<h>~Y{7FL6e}5Wyi$t?e@f$*col`-|ycz-%zxAKhg1FxLLG`(_r(*P;?ZcSX_>GuK
zIai&_*sI-~Z~fwOx;dI})GC^dfp)cNtu40_sVtneQKW?bwp-`+K$71zRG#%$>KAnU
zj+2qPF)8&i6^>**Xv!=t`sjP8!N3_b!q1~6hY|!70Zw-YvYGGWOMA@sHsyuWv}C8j
zi@}E`BrYo$q%CeR_NQa_vT)H<YE*-#t+l;ywtiKOdOX7reuX+3?TQ9x3#{on{;Wt|
zQ~C8fXiI6%?s)cmDGuA$E7RZoGElWGBKj@R-QhptLu7HXw@&6)TJ}r*oA3bcJi+YA
z*xh$vGGAn2R5ksS9&n&I<JUSM;#8ePmhtE;_~o<@A(F3|sY>lif(~molu=P4sSlh-
zlF+Z`KqFSFl>+o?ifyzr-qq+}N6Fu)Nu2K7QXrPFGfI-tD|Pv0Oc(}}VdCE{pzLyq
zLH}UpUv2U+X42!GzWE^hf=IO>os)K-a%KTp5spuu;GN)%1nsD7DkV@;X{D$e?7Y9#
zq#(M-lOR8gqPfs2Knaafg;N##8J;4asK;6|j53zUI?`|eex*Q%l9IQfN)thua|qZw
z!gwYiyFRp6p0h2D0}@ObtXc6dt~NE4J;z!iMJ@VJ<X~yAB!LXsO&(MwH@+HkaNlef
z1|*-EvTxOi2R(_?eZTkl=h`5v-KNtDF<!Ek-1u>U_mK&b3=NYtJv=pXw^bSInG{Z<
zJtcM+&UO(kpf4<IefAB@@gp`(pZ(mGx1Qf`Wj*LDaa`zVX@9TulEnf80E^}Gv@nIw
TGhu{%T@k=uG`~=eag6yNxa&`e

literal 10321
zcmeI2`8U-6+xTB&m>I@0vdcEvvMbplGf0vwS)vd^iWrh5+srVQHxVk7Y$Z!}vXsFX
z+hncm`&f!(O?Ja~-k<w?@4w*w<v!>BX`VCZn&)zzb6wBZ<1zD(xv3!=iy#XC0BlBA
zFIxZr1APdZf<fpnp2{t$0C1My=(4U=(3_Ph=8q0;VV$(~>i$o!4AHSY%xB}owy2Dz
z)|{QS--a(X3&JS~7{1Q>+ig2AXb|?X(qpJ;TyXpcAwuPvfw`->z!}E#h<h+2%H#F1
z{)WCOXuK<NH_LBFb8$a>__N~38F$o4$ePaK{-xIGg1Eda9%SUFd8CeL6(7hD9VAjA
z-Nu}Nt%Z<TV(S>x(Z|gjZM{CfxSTf-DZw|+HULJYoSN?EH}qoH?>{~sz}=X5GA2b0
zr(oGPQBJK&4Dg$EMXp9(u0T@ob=RAs*EQLz25@N%&!e9d4k56tn<^E{uSw)%sWjQ5
z%MhR_=CWxf<NP#qwxlB#b$S-*=Onqn$B@nOra9l}{WaNFAoMb4a&-W{>p@Z&B7J<J
z6$RNZnEj_8qWC25OJ}MT0~j|5j!Qln^*fz;(#EU0rLm9=QuL8RFNcd~ioCF@y4#DL
zgd(-xM`dEC7VbLgY82hKv`|+8t~y}4d=aLiE%%yp(^+S)r~jE#`zToy#R^#P$$4*g
zFK3>Vc|8nJhZU%LtGpO|PyakkR^$)YGtA`j$i3MgNzD?$Y{{QfMeh`OW?m2=YuORk
znpL02)tWuxMK4>>kLH=6#Yl#Cd7?s)*EI@>JCX?m`f2pq2Sc{+JEfiK4uV)E1_+>+
zO~ZZOmpxu)jD@a}s%dsb(>uEDX>3NzYV<ke5;7Ubj@@iPD^S{MJ<Z(Wxd4z?#@(s+
zaIq9?SL`Ba)%n69Dlhln^T=2sACm?{8lxu*7_K=`05Sjfx0jOoF*W+jNf$1M`$!sH
zO9G)&@)!jGiT@k^@6LmDw<22Bk^mH}F}!m}YvgTK^C>gmg*YozF#ORHn`ETbwYKjv
zQM$_<PNdIQGlZB%HZ7t9&Mx%hE1+%6tjDEf4<~_zIy6y0O%cz;5z}IczV;l1Hj3*J
zVp7Rs+P_{%6x66#`kO7Q{o}-D`J|fj$_&U4i(sC?sj4$6I!yfhzRjKdT$;4kDn=Bj
zvSEM%?~XB#RJ2!lBC(xA=8Zf*?+6qrM7RY)c)dKZ+ZLa)j(;Tu-xgXC=o^QBz(j4Z
zQ*V)$kRth_bJwU^B)5u%9n#y|@z<u`Qf@)@X3TI76Ju+<+Ax|D+&;)t>$Jj^qeE@J
z57N5Yoa8n141%MY)0Q=qX%5>$<mp>EE4c<TKOfh3@`g`u<~>4(LFmHMzU;T}m=Do=
zz=lEk=4(n(t7c+!Zcw>9kyqA{@g5I09vOIi;dloMUev8;?9)^WHnGyv9(zfkY+9#p
zU7^k(vw)`<vU4#aF=9iL-|vy@TAP%R<%Bu0)5R>Z0zpnTx!oZ&lWwqgswd3Bx9n<T
zKai7UQ?e_1m}X9sC(y($g#7yb%Dm{=nZ+wVFNoXThsSM)A3IWX7_WP-eS`M@Lqj$&
zCepSjC9^$euR65TzkT!iuf8BA!ZW?ld+?0cth3yO#75ifn<_l(zX*YP0e^mGsAi0R
z7eVwz$|wbDq8t0T>@TfNhT*H@d&5mc_fb<;RQb{MuS<}Le3|L)UopBG)v(*87lIPC
zq2w`T_w3<X$(P;qb*!(?|HQ&)qr9|7c4LC1da}mzcTV|qnUaK@u4D-Ih!Oc^tL<6L
zl~jPj7!ys#sz6r1f)nK-!=%~EOIj^53(0cRt()ahD+IM3s`k)**g7FIYo<f(eeEBH
z_gPje3+$MvdOPM`vuI_mpDPx66PNOjMebo9tbRTjZgbbu8Mq|8Yz+an3tjScL#;Cm
z6U_V{&ufAOUmd`XD34x?Xb0Y58|a25TXYKmgMM))E}Q0*@tS)?CTI6TVoxuw)rJ^2
z){W2XDn2t&u922E?E;u{T=chc8Pv#aJF~1R1S&Z2$#Kq5WhT!i>{iKhA+?A>sf0m0
zR$y6o%(hU-Hh>4Q6J65w&9m-wo!|VqX15T<9)7z3PK#>#ijjYGoSsz`0|EG^^X|yc
z_WpXCBB|aS{2Kx2Z6Po&_-p#L-=h50`ci1M{FO7GZTufUZ>n}CkgX_3;lO_)%(47G
z>snRqL>H#@)E<Jzo;y+<tG*@pU0arc07m0#TG(v~FiygV`8;qn<%QV)4gVMC;X|qe
z?xGC=sP071^d+HAS1keqVi}B2n5wpuP>jwptVisSo8&H4yg^NsXIij{>piA`Y}n9L
zZZM)kiQph63ctnnX9%$tIWC-}5PfV&onv#}cqi}G2jui}3!fBmIrmf|?l6z}CYeAx
zK<|(@k#ICyRk+h7E77Q~?TU2{arYx`Z+qVQ;GC5igXMta`C^~HI*2<gL<aIXL_UKH
zUWX!!5O>|~pSV(}1Da%e7Y^~m^54P=%iFpjz77Zgf2Gf;7`8NZqIYy*O5lL$(4w>2
z`&ik8>~rl*GAmFbr)(gp(($R#zH0pjr;_&fuc{GyippzVh-oIFudrD=gdQgZf|UXq
zbTtIY4bCfO)HnTCQtd@;KNd|j$6QPUp|RYWo}x=y%t3*^Ac52are$RqRCjw@Iq;6_
zP(K6wFvGrVusTkxso&RJlaK71kQi3D+!AI(nPw5<7-;6#Ty$jEO0CIp^+&3MJbdyv
zHMf)tkL7$iU>8pcJ~&p;v!j=O&_pRIeQGap$$InFD;>Bj9G}Kfy@mb!ASsi1wu+(|
z(^hbOUd91}YvbXIsLq0i@$vnpJ@uacrjOGQCL20+HN@XY$Sal65x1O%kHwtMIC?#H
zV+1u(&Y&1w&92Ny0g{L+yM!*3evpyNrRFaXC8vQn`1s$EEB%@e;^Q2S51X34?XQn7
z^qm-4!#ef1xs*e8d4(Ju+Twl5X9~>lH~f$xUZ?w_f?<1%J(s>G$NVjb>u>w}F6YlP
zgT)yO0m4Y@(x+rUsk(Xve`PTGZCvtRAu49CR?Qm{W?IRvxhUY}VYYm#V8rmqT~|BD
zglz|e1#g=4b-nLKg;w=Vf@Rks`L&hbSm&~Jf2j5`T#cHmR$eCDZFMxxr_~MrF-1&+
z{Tx`Xz5t2cdWixj-d|^O|7r!p;Kx>3MJ%9NZqkLsnqFsOB}!W8hPM4xne%|e*++jE
zDaR~xqdRpvLGGmZob}k9ItBl?n}!TZ^2nzn<&b%Nb6k(W%yF%?8W^3@Ap*>PeWa-2
z?|jBp`ZH_JpsEhIytn}ONVd=sT-BO$u<~f!<`paOkBr)pRrW|w8|Id5`vAkD>Dfw1
z5%|r;$|angFMN$X1hN1Xqzt$KSNlp>2#aYab<aZ3Sd}b|v;LJ$4-nncgf!g%Wg*9V
zup7**z!!l`-O1(^**JmNYp<#i7SN>$COv2<`&{@&C>VX09#C|zJuo&+;b}~dBp|8y
zR1QNsF<Tzxx!J&&#1BTlzDRv_RJmMt<62}ko}K?m=edgKAhC0IaMmd;AxVwYtHLe)
zcjMlGk|bnw>HRz96di8<Z}`794?|V(r2t>$%bCZlg=@@XeF!OZ3A&bf&ZF=Wz@Zpb
zUILFiu}}G^%E{0p0QD7x4dk5X{Br~0ff!-n(6<L|iLxi9Ibi4r$*NCp=J!@WH7>{y
zuxkv^0C3^Yp_!IqDnzQRD-KyS7WtBcBun;9s8yX^$HEdt&o7(4W|@D6>ng_c>5X!w
zGdzvDCTb2=13cpp%DX?W9!a^5w4{W9<2~F?*rz%GWybdV*d5lT5NU$C?)ImNAdW*p
z)N`?wDUDpS2&3kwZ?-UqvIw)XM>o+HAL70puN0Ywsaj1#g}_f|x=`g8j_qjfg04^y
z2IL(nFcbTR=2lPjc4rEB19E~I{Cpa-(l3?)7h-=Z(&4-;z1EEsV%fA)-u+IQQh#kP
z`CjT#C{LoM5cvz~H_|i;5gn9%AohD7!H(;aqrQQksS$<zM16Z(6%v;L1ftKWT5IxD
zF_GZWWBcl?SyV0kASj{Rslzi)lF8_rzHhJA&zg2s<s&viX7smxlr`=3(HU5F)bf|)
zfr1N_lUZ)SXyV(g?7zM+EXT@No4yTRJdT6(SDo*HZA!2mT_p7E!6}MSK0(jj-~Jw1
z;%HfVCcseJ4^*(Ve>}<C5+jPHe?8)baIN1-a$xNw_94WI(s)MdzhH1aoE3)guU|2a
zL7jSH#H%}M3KO!NfYCTg&y6G+4<Qiz?)K!kNKzOqQIj~zEpF8KzP?u2pWEtKWNuBt
z+xx=Co%Dm$yB)fAcY)CljaksKU!;ZMI#mrWADF8s!7sBmWiaxdSyUGkA8A-W-5g2g
zhPjgl!FDq@1J45wbzRpk^Ka|qWJ;Uz1cBSQ#z*rdYK&(7L6|<=nsSHg201P)@XF5y
zpui+vw@v`_a58ZGitj09x$_|fJGF8~rCgeB?v&|~`i>e)n&7b%f8gVciB%Q|u0Uq^
zcuO7JP}97P5EB9oiBG}Biukxks(cMq*Meo|KdZ4-sW<RB`9W~KE41q{CHYOH5my|P
zU3k43B(aS<sF5cIpEld`tnu(Q$yP4S+tEq|IjOv)A+?Jq1<CQV<|8HaFtD^5#9ET2
zKe~z5RhqlS52$e^@{c_~etkEPzXtO~^{NHe(+p7VP#w*ypP#}Z_bEEj1sJ^^dUMmi
z>HTZgF%{!7-IUi(8@Gp}CyMGE7+od%R{})9q<dBFFC26?x6@h{L06YS&X49jzZ-Mw
zYo2b<%Ajw<*WO6WI{UW1=wR2K=%fIGqkHM9z|h`s(<!z)1Ks0<(MnbzL#AO1TNNFL
zJ?&-8{x{8mv4UAPJhP@2`5Wiy;czzOLEZf5m#Yp%wam5-0X!sGiuy|j!hflfB8;$)
z<Cry?D0(pR^1uB_8UCoRsu<_PSK??Hz>^Z)_pd_P|1CBRywE%dXYf#G<h=+M^GDK^
zQxuuHc6cNhYium<^58~fo;UqU_<YlrWfO`puIIs2^cFkyR?)A@A_2NL8WFUI)C-aI
zS20@JwjUdP!VV`=2U+QM$C#%Z*tLi5k4$L6%`tMv(%L)4)JR-jnHzmJTc>YQ6eR}l
z`(`lyhx0ZSvzGX%%nh+KMy>y@HGLF<!^(Sq@pOanYwu(l*kvpFZRO@kDbqzzS$ec%
zpya{{qq70r?l$`om;9%$B5ctiT^)%aY%4g2u{<8`y2N58lS$_Nhqix)?vCkN)D_bo
zWb=L&#^7LSt#91SX;5lAsh(3LKzKui(jU1s^;dcu;ZC2y;_=t5@|cA6sJ+>{e$<LA
z-ukl9mChKk6YR>-`{{XB+@MQb;=x>qxC#nBP>$QXNHN9vC@TvTqDziuY#cjbxsbs)
z%<g=h`Jv)q8Sclf#t)@!DSA%d2@3BDbMm$pIYw6=qBRh6c*IUbsKvZvS#&*XJsWvF
z7b|1G7b_lKRQK;mY#uMbMHrS*&58{oMwu;_fD{Qyy7V%#h+zGn8&2@jMT-X$o%+lj
zX%SP70Xzn5w@Uw|K2_+&S=z*?MnPWIT{?b_o3CHE`O<-@g7*)b8{fA^h#K#@^VpnA
z5(nMS4L+pPZcd5lTqE7&X|uj$Um|@TLem;U@>XPVA-UtsD%UJ5|3jYJNi#R;aGKWg
z*|59pZAfVd<J@;Tih4&%{_a-P^HBR2KO;;?<;Gb$Wg|Xdd0Wf7Y!2SD9<j|2h-q%O
z*!D3D@m(dl9?bMWQ~t@COFrUl4cFw~=>*e!eW3dls?!akAh*7^lT5!cvXx;)ZgeER
zA-4uCi?G#$+GAAiK!0OLj%!0qj_oMrN(HM2Gv}I5i3H`m*?B*F9w?M%;vI6L{zj}R
z<?eSPLxp)ClOeT=>L<>y__(6I0QjzMZQ=h1ayvhGTRHcxZ(TR_X=@-(4!p4HS*Omk
zKAXR;7jBT@?x&`A6j;Ag=k?IiLyo@Pn@-NC!DFU9$MF$?8D<(^i?r6PCgY{Kxz3yb
zBq3n+S7EjsDuyi^Zof)9S-wTjX#Ku15+z#yj!m4>DVELAjq%-b+~QvUQI&y%$M4p^
zg!Cs*<OG01gKv3Gq;$Cf=4NvFNj5b8IYZ>fjajrWPaD(59=878WN5-AVMlzBQDx^_
zH-%E5FR~LmcPcSB6NJ80Zp*Uw;{+Yf(uVrzB$Xo~ufyW02$Q!TS#T*vDxWaNF6ytk
zkh*?~gl)XBWvzKWTZZ9Yd^$M63S85xObs~>#0Bctzcu1u{t$R-L^l*A|4H7b=o!tc
zlC<yX)cW2$1l9H%f3M_QdDMn5Wrm3_bVNYtJsHSx<+l9170$fL9lL#FL7|nX@5I&C
zfbSN=a>(yDnZ<c#lOhs)`mL2WM5vCqkm&u@XQy!)$Si1vDSoRwaNJR*h+fWvrU{4&
z`SV*U$}|?33X%xXK%^5h(=fOotu|5g9)xw${<?ATl;FF+cH(}0Q5)HaY1T10{37tK
zj<#ISLN0CB5BG?7>UA*PmotC>l11n4HY<=jXG@InzrF@4w=L?Ao}S~56>u#^I<h<a
zHnzre-PJe=H;l{7<s==elWUX%1qZX(hV*e@u@&Zh3796qnpAan*qvHOn(~<ypDxXP
zAppGi_!eBhF*{crvTr@MeLpA;9dO*$@spID>hNrkZ4&%HT+;vDACmI%Rq*?RUzz={
zN`Cl(zC*twq=GJ_IuORYfuuJFG1^!ny*#(g?HuW1=*x08o?h4>ZOC&vzMKOj+#SL`
zR=%YNbRzAn=>ebS=G)zKANp!eVt}hpL1LFwsXwdYaY3k(Mmn10J@O)Q%!Sd*f0oyF
zA;q2!CI2wXf6ygXF5ED@Lr5|fQTUgD<bxRJFx^v7gpF>v<<iqen1?u>s?_A8gA89W
zp^qa0Q%%_i38uSHQpc&{dbX@R{U@u%@(`SaLJ<F)^^aBZv%1#&-(3&vmM>(KG4ZAi
z2B8*gG*72Vfzc6h$$`iIPDaeV<xt+1t{;*g75sBT()5VLyav!(#P}Ka`R}g4)!}k)
zXcM6Qtx3&=um|VgyIskrYq5E&kcLH+E9i)ORrAg*&W^bC>J+*{aF?0NL~whm)R@%?
z9QRtx-Ywf<<~rmxVb@<(bJd(8_bnq68lkikYkT;MGhp=hpQShr(fUTV1TWl?V|*_*
z@%Vj#tPa<{HED7DBXUEn&;iCbH4$Aqn9B+<%LRxjed3+7cX|RZ5LMSZIz=#J`dR1u
zMR!@G-Q9&|kc537bO9sBs@SR!6{I$~WsIR2XMn_f+bJ&7yEy^p2{Uz0n$&aD>WW|M
z3|kke|F~N$vV;cnX!|NIq^ap>^}f*G6ZSdP)6n%wgWh`6nd=ur5M~TbQ+WyanvU<}
z7@QfS;*Og511O{76UGA+`=&NEQ7Y<B4M{yW;1s<G#j!*GTKLRd9l_WQxW<+h|F#;n
zk@VF0jkspp5F#AdwDdW_FgPv~l(dpRU%8}gIK8cz9w6>>apM~7dGxvazm>dq6C81S
z*7Z*BGn=zqfv=)Ge9`f#hKbFHL>l`7y<l0$e#q-%ecgx1X|O%qo_*8Zbl<pj1lBil
z+4MyCsSbNOvk=(XF$XhIo>(k44Vk^hUoRBiI68G4{5chZ(-<wFBg~kU(-~Kn98_cp
zWFJyk5)BpcCyd^TgSQVgKl71$Qw4PBoc<7_8?Njc!eEKKd3u*~hGW(=wi$2I9O>T;
zh97nx3+LUru>z;sCEuEf{1T!cfbijOqam+@rO^CmcUaqgv|q%oUa@WFS9~%UbM!c$
z($GQj*3$K|_@@4oXQ?~BDOoiM1=$*@`LjOq7chT(;3thPoqj+!RI`Wz{U9l2<^$RG
z`{(S~oF%Ux>btJ7Df_6p27Wds`f*E7OFkPk+)jQq0_GX5W-wz+=gvuOMYEswv(=zR
zUGd1gQqd&GZu+bLK=EM-$rL0jP?D&uLyi+P_ltCNr>hB${bTb>A{wWvf@3EdZKsR=
z@`Myrb;jeZ-I(9_xwujd&2O<TmV51}))s-p=(>YHP@d3CSS}X)^?1d}rs|b4&nQ%b
zx2hS}^b%1X+e1@YYS#4GJh(TUpZvhyoLG2OQtl$YMVWftE-ki41pZP#_uyu%G%t8g
zqioO5dl+RJU7_CgPK?O;K@_(amLBrNb=4nlJfc=ymOsUW&<w<;2kBTfGtSZw`Fxot
zJA?xaN`zc3ro~3KaUPs8Fr8?)Rb!N56-~KyNLu31-!3K<A$Bl-pV$cspxUX}a*iB#
zv>LohskP1QN?-c7lJP4-0Nv*q^o6r+_){_XDMO#h5*YieJ^yYEWlSk<`omeH<@3p}
zUQ%v#>duVds_|il!|LoirP8hG<%WIX){X1J4-&+e?c+^Y51WK#({!~TAO3SM#v0iK
z$euvlo2AZsYH8h(G+Jgg$X1=N`MRqa+o^{6)HvPQ(HgH4c;Ltvwz0vc1q=?bT|YD~
z4CSBGF<Ch}4Z(f`=ltnc-goO`yqa>+;hVZ?I1>RIu~)*ooiKnrgsmL>eA_rHpj&W}
z27@iu<ZofWQ++uix}Ny-`PmIbOBnT@pC`TTkL&mJnz7{oy?jRg+ZrA6!kGz2S;-VT
z0#{&vhqs`*1UZ`b4k?rWD0myE<T*e1dqb2V(Iad|Bk0Iof2WdSWEtZ}KtgeMy<7$z
z^@D!-2nyx1Y+Qj!cPPwQo;9*~AQ(1qT8!BA&Aq0(+xd@OOtp<SzY3tW$~3!5TFPw>
zxZI%|#PLSwQ}61vl#jxTruda9t$@Q2%LLFg==qM&GCYPGh)W3C?~e1|Ki~Gw`R@(7
zic7g@@J;%MA)n>Rdky}oH1-;d&>SmiMFwGdHtUi@v^nPFa{AC3LDJ~^O?tr+%Yxz@
zWuzFSNk$Wg-)m9l+5lw_C77G!n`j@Q>!Y701tpAvE!^B;N-}lPD}}j=U{-$)($=->
z8fN2cvL+$iZzYVxEhj|D-am#Bzu%o8rxa0xKn2#NRri$?y4H+NZ7G9@9R<vTqi3p5
z@%1z2cm7>s?`4x4Dm75P!t*}?Nvq?a$ax(~fM^#ynjiSH*?R<Onf=F_Vr+UlC2#Fi
z#(~3unM&=LV>ybIhZ6I*f`|<Gc?+uj48=&fy_Xafn&aO&y?I6~Ku<X3f?f@=KL4e{
zLyy@OtsG2AcQm)&#k?icQ#b20WY%I65F;<`BPCRIZ#JjaRBcUxwmpMGiIajCpMjkG
z<iuWN-W<^jEnE<kC}N%yCvp84HgC?4`SD};>k~Q!{!{mu^ms@dk@jCx5DVxFeSqv^
zjLUN8|Hakc(qG>F7*0}(j#-ndgBW>4<6k09%pY++L+?3!QGF~#XVGB=uO5aM5?5d-
zg3?RkJt?DJpUo>2tkv}Nhn4_L^ibaiodi0RrVSdN*bF~MYp%xdm>(LQ#R}-9Tq&tf
zZ5P$Gy=B4lTkH;VTB&RSt<Mbzdab<IZo03IKR+A~5etWh`-d=l8C%4cG_n1`@Qu{h
zHZYOv;yoL(x_}CU5v8bczGZi>jMK;91xJ|ustO>n{ggxwr*4rPyu1&5DJYJSi?n7Y
z2u|VbMXJe+e15`st#^&!93NFg{lnE|-M|?O`}uLTiZ1-R-mw?d+U_3RRhXe*`zZbU
zosUCl3q&CgM|Sx~TiJP8mi7~Bq0D>PY6?t~5MPm=-B+@9&U7Dgw{a;VBR2rj)^J;c
z%RF+AjnWVA!B!Y}UA6edkR1-Fh2@R@wrbv~AyaD(OsTBtf$^RvcJ9Dv^jzDgMZ=_Q
z$mG`uu7FEz24AsKZ?Kr>&lHS=m)`PJga^1tIfXsvxD&bINkPG~k18`yY6XB=@rpvo
z2v+ou3Qq2|ADLZh@DO<iLh}RjDePW;`6A+=Mseen8)6ZCWJASE^;Qf+t!AR}1GAq+
zpU7?R2mk@-O8i2EBRc%l!j_n#aLateA@WG*kEQce=W-_YdH2h_M85Po*5OR(<^|XY
z_eh6xkz@S2%+5nEZGoRB-%YSu`77&6Yl7`C+R@A8c@)TyrfxOONMtAb;l4~fc~YAE
z2ot@hYKxVW4;sDEocDr>w<NIw_Vb9lic9QBl@N)aid(OnNv&t87v59bFsVP>x!ZA5
zs|!%RY*0l!2;>ass8)*V$~C{lI_HOP#5suFMA~s|w#+q+1aYxWGI*}T<o|kxOBUtw
z!`QrW#}=-`XVQHDD|VT(QeOzc0VxW12FR_5H2r$EIgC@UiO-lU)UwqD;Lo2UH0<4=
zb|&9K#Vp^C4O1>-$Y5B|wDPP7=aQeK2EUN-vU9;bb`c5<I4LP_9lfD!j+c+T!Fk|O
zkuM5SQxj3l<5UJN=+0mM>-r*3>MZ1Xq%%oifcFts&j0jpl7e@ESk>4{>-LqL$@S?p
z3I9YQ_@E>B(072|bLc&ZS5K$y!)q^q%q2NOf6mvhWhbLQsS*SUs`^jb5nyzE9r()3
zZ)9^bz4+-puhDGW{1F=su`c|dp5#%dD}R_~&o*iOh%H4zbs<poApg7<F6hwwj&d82
zG{rvKg5(`?_0@cM`?fbd;*!iHTgll^u~3{=^q&YM1ZORWY<7+{P`!0TCzBt;Vn*Me
zABf7)Cuw(V{eV<>#&Hgiw`a2lY3sCgz5d}0n_;sjHs$R|8Xa&MWM42}KP@U#5K+(a
zXI<@JNmwlpK#1ubakl-Aws*8_6K&0Rd^u1nVPseRGdLC{Q?%*nJn$@DC%BVsUKhQq
z%^2E5VB_G>KT@x+UonZL@2;1;Z6L}c>gCt^On*<iBs8c{N$3#(qhrF6$ij^0d?d#K
zzB~8ib*_|<QOfPorHq?2p}8Nc4G!TOvnU(Va&cVKll#%zXQ_0y6blt1V<r#`%guvk
zIJo^GJ@p?*WdE;NkdOa-QH{cd(cNiQa5l{TbAW~+e@h^!r-27@Prv?s6jCf^Po*%E
zYi}Wiw+3lsVacf2#HH376=d>TkMukfRSo8wzBu`gRSV!A5N`eu*yo3|pNVjM4D87)
z_)#P5UWY!U@6Po}m{Tb4Ms<gLfXa~A(JAuSMz`mcM>)#hubt_%nWePmtc&7ofH3h(
zQWflbB5hkv)1_sH#wnkTgjO8;HDTmVoDF#Xwa=&ti35q^C~J`M*^X_(I<<kQM#(B!
z%<oVDQJDPKxleKM`S*3?iFV1!ZKoFf-VbIec>(b~V?0%Lx;uBM=$!LUTNe=P498%#
zaK(+H!`C<L1{i?I=A|B%l`z0+8aCUH)P~PVz$QGTp(2r?=jagJ#I%(fm5Rwpk|^4q
zqvC@4bdrV+JL(wvqm|tzz(4qrCDHZ#b6D_9L<1j(d)>+K1yw*>=6o@S)EfIx8ej;9
zf>gv-SSmTlS7JFB0vXix!Y>g#XFo#?FTSTIR9ZH*hhv8A;0`eM4Z*=gf0#>nhy1I4
w&>@-7uu=vt!*{O1<sTlDMx9{k{|-Dk`D_ONRSFw9Lw^Gp8JJ!!({qaWe=85hp8x;=

diff --git a/cmd/frontend/public/icon-64.png b/cmd/frontend/public/icon-64.png
index 87796e6a2fb35983a6c048aa874988ce4d900fc2..91576276a6666fed7ffdc5709e5a784063ca5cda 100644
GIT binary patch
delta 1138
zcmV-&1daRC3Hk_-7k@tp1^@s6P#w<7000C*Nkl<Zc%1B;&5ImG7{-4!iOFh=ta}mh
zummJ={Xj*JLRfD($a+yUnp5%*h>)3sdJ%NSFYu6q2Zhy>k{Ct7lj}i`!T60)bQOYN
zVn!1;o7H5tq^6%9n@LBzdTP6}Oh2&9c6ImrKJU}j^;W%8vwx8Yu(YOtr-42FLwEyt
z%Fyms&81PbLrc>Dj{tjtt-v+FK47=bRf@_50CNQ}3vA9by8rLhxk?d10Nhia$Z4O@
zxk?d3fXfQC0I><gMlC>W0<lpG5Su`3)B?mN5F51su?fV+*bA^G^#Dr~iEF`H!*eC=
z?04%UlPr?#YJXWf|ApW^z|z_bW)92&Fdb;zWodc)N$zRfo!D@;8gq&5un5`%RM6NB
zyaY_D+H;@Uj(VEAU6rC8S|&dPJZ5Rm8#*===fFL{Yylos@QAnzU{0?^A?VusGr=R9
zd*mY+Lcap8i%t!-xd5)yyIc@P_gqvUnHs7jjf|?YK!4?xo}w80G*}A|n?P*T0>mZ|
z8?^wj3B*P%Kx_iBQ40{8Kx~Y?0ABR~6*jg3HvwJXb68zoi%Lx~KKtD>yh^nLw^IBT
zSTwX(i`ppM11v4KqT2<$2OI+42cCh(*3uD-jK1$@#pRH=?Go2w7CgL7LcdZmlUeug
z19p}pAAbZpwbdrA6U>O?WKjb?0$dAB54CLpwtLtJjqT!)#k9B<f{y@=OI*Lf!$xT2
z`Mwm-T#S7ds0E1N)1|0CbK1}7T&0L0fISbqtAJCSN!t47Dn;d6WepuSr+6FK1U#tb
zw}8X$T-AuOSJ=>Au{7twyqUDvm5|@|_#lb^B!4}@1$-`+{}go=2yD+i)m~2fg%Y;%
z?&*cj6rlxJ0=|+EDgFjN1?%yS_pd#wdk2lOeKsWFzyerD_(kAD;52XocolfZXN1?a
zhk@5*<FstPARoaHbP!aE`x1B<xDi+Zz5|y1t=TS^$AMS0mHvC+ROnPW5Wv!MA6M!Z
z9DirQE|qa+XuFT!^j8}4?S%Vm6g&JI+tpe*x=GhL@l0L;U2rEb4=f}T6Ej<8Ys=*Z
z#W1VM)`DWZLop9}z!dO&^0SrxclkF1H)xl};{W=Hha$eGftP{XbUdSY-7K`5KH+WZ
z0ohX04&au|u^Zw47&7is)vqH4F$zxPq<_ob#WlsPLq!{-SY6D6EU+nOK-{1)L9i!*
z*E7alKK=ywC}2RoSP+MFZm^_{RVOpoOym?!HY(=gS-{ZgSy~75O56kd0vrU62MMJV
z>~S!Afd_!=fscU?4DGzhST4NMprO5NX&y`}u*Rk%X)GvH{Ag)*w6V&YllMG8PHSTh
zd>3I9PU}9+jfzx&^Er!{o@R3E9e?G-b|GD7qyqc|d@*#<55PCoa9mS-tyr>f)AgUp
z2yhB`5;&sXa13~&z$9orU{SFhQ*1|c>|*Ah00030|GiD~3O#<Nj{pDw07*qoM6N<$
Eg6iHEfdBvi

delta 1228
zcmV;-1T*{k2-69W7k@hl1^@s6%Z!ZN000D<Nkl<Zc%1B;OK2Tc7{`C#+#8cL_NB!%
zXe(8GfScmRn+g`8;G<AM$wCq0s!&4gCPu_AT-ZfRN|BJJxX^YfNyIMdrVq@@6j7u_
zTa^%-6pN37ZPQ1Rn|yNSoU8YSBs0m}$q6_=xG;Az-#7p7KYw$+J2PjJ#{<gtJT$k1
z?z3y;L-@K|7%VQgmSDMeXldRI+6Ho;{g`F5Zu#+K0PAhxCBo(PK7{x(V8xIb;9G!i
zG6Q@I@J(ibZvno^4Dc<$H>utWD0>^Bt^j%)7!nTNj2G9r8YqCQg1bY)N57|~F|{*5
zX}cflj)Hs!!GGrvysxy}6CG!^k$pDC#MbxPT<MVF5V-d#kR3p+`2xHKn;N6z%r^3>
zi!re~Y_4=j(EzQVHN<Km7kLJ_ZEDL_)VN%!@V{?@nE}29_$D*Jw*cQ{2KW}>o6LY}
zBvH2Kbs5bx`?7Nj$w`#NiYV*^X@Tb7lwz;YHBt>>^MCKNV+-W>08L7vABIjQnNUgS
z;xk)8dVmLk8OS#(?Yo8UiDY@_Mro~s{0G3B_Ux7Cq4^37e!JA12~S&j9B3@dwG~*C
zEayV3S?%^w(%lI9M3RgN4bYr%p)y~sB+I!FVeWFx;xsIo>{r0I0N-Q=_!i)s%mCj4
ze3KdATYrFWVqFR=9Sx9gf~mjZ&@~C~M^+vhUKq7+fQGeDyef3vii(Lm1MKWh{s?du
zYEHmA+p4Cx>b(0bG<;#T=6bC5g^4i)YF`9i2Q~rQAb2~@49{}oG__leMytF5buUE4
z#V{b)XeTF1$VPa$CYjusabUb`#W+mHnm3#uqkqY0`xo=QDJsfS6C4=<JqnE3k69l3
z)rS%<Z;A?ilS)e$Y#Fd?Mn=p!A6mQ^fHML3$=Ci%q&NiR4p9E6Y67NX9OZDE@+V4D
zE>|j~Xu$Xnz$sUZX?O!L7UM;SaGL=aV`5LcT&a-S5D<E<DSP)+z9AAl&TW6_+z*@q
z>VIM4oXM4z&QyDVd$r}n;^V?sX-=i1s*<D+MW?8^EY>3EOk!2@VsdMFUs0!F$t3Lo
z7l2{6Y?{>|+`OJJ=K`4AW*?M_9){xiBpJgYptR)R(WgPT!ptSOJ|uh`!`TBDq4O<}
zogi1?R$sihrD1X_?faqOXV50llW^!#oPStlcMYs9K=35U_b~jO&^PURz?SELV;~Pf
z?k`x^2J}Y@Vg?QlnFg1<ym$!Re*#AqAGz)o2zr1Gz!i9;75FN!w~%6Pcs9Es@c;z7
z>{$^qdrYS|#uGEAR$EK3%hndwXli}Q)b4tKtg4LDdicXla7<qWZj>cF58tFR^?#KN
zqe(B6nQ#O2N4schnf<1jtvSZeVDSv(-UD6+{RKGe<G;J2Fq)J?7w9y|W5Aa%c{VC8
z(g5M`9fe+K{RD1LnZ{8y)m26~Fsih4z^WQJJ`v~1l`}xKa*9v1GO<Z?{BHFnS08tP
z<~T?)%M1;_2evr5{9jP`hfx?@$wkd>k%YC3mWsBu%4Ji#Yl2h#?%I0-<Q(Xyva-AV
qqOi3TkJ;Kxje6SE%s&AD0RR8M^hTymKz^nG0000<MNUMnLSTXgVNqlN

diff --git a/internal/stats/render/common/v1/logo.go b/internal/stats/render/common/v1/logo.go
index 5f25f173..370e88a9 100644
--- a/internal/stats/render/common/v1/logo.go
+++ b/internal/stats/render/common/v1/logo.go
@@ -54,7 +54,7 @@ func AftermathLogo(fillColor color.Color, opts LogoSizingOptions) image.Image {
 			offset = float64(opts.Height() - height - ((opts.Lines - line - 1) * int(opts.Jump)))
 		}
 
-		ctx.DrawRoundedRectangle((opts.Gap/2)+float64(line*(int(opts.LineWidth+opts.Gap))), offset, opts.LineWidth, float64(height), opts.Jump/2)
+		ctx.DrawRoundedRectangle((opts.Gap/2)+float64(line*(int(opts.LineWidth+opts.Gap))), offset, opts.LineWidth, float64(height), opts.LineWidth/2)
 		ctx.SetColor(fillColor)
 		ctx.Fill()
 		ctx.ClearPath()

From c0eea0275b73277554cd122e4c7c8dcc4a956dfa Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 5 Jul 2024 11:36:18 -0400
Subject: [PATCH 262/341] generating og images

---
 cmd/frontend/assets/bg-default.jpg      | Bin 0 -> 36041 bytes
 cmd/frontend/assets/gen.go              |  81 ++++++++++++++++++++++++
 cmd/frontend/components/navbar.templ    |   2 +-
 cmd/frontend/components/navbar_templ.go |   2 +-
 cmd/frontend/public/og-widget.jpg       | Bin 40334 -> 16098 bytes
 cmd/frontend/public/og.jpg              | Bin 40334 -> 16098 bytes
 cmd/frontend/public/og.png              | Bin 14493 -> 0 bytes
 7 files changed, 83 insertions(+), 2 deletions(-)
 create mode 100644 cmd/frontend/assets/bg-default.jpg
 delete mode 100644 cmd/frontend/public/og.png

diff --git a/cmd/frontend/assets/bg-default.jpg b/cmd/frontend/assets/bg-default.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..d752d09c77a0818bb8bd2f54bb9fe3233942504a
GIT binary patch
literal 36041
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

literal 0
HcmV?d00001

diff --git a/cmd/frontend/assets/gen.go b/cmd/frontend/assets/gen.go
index f69bcc74..53476f65 100644
--- a/cmd/frontend/assets/gen.go
+++ b/cmd/frontend/assets/gen.go
@@ -11,12 +11,14 @@ import (
 	"github.com/cufee/aftermath/cmd/frontend/assets"
 	"github.com/cufee/aftermath/internal/stats/render/common/v1"
 	"github.com/disintegration/imaging"
+	"github.com/fogleman/gg"
 	"github.com/rs/zerolog/log"
 )
 
 func main() {
 	generateWN8Icons()
 	generateLogoOptions()
+	generateOGImages()
 }
 
 var wn8Tiers = []int{0, 1, 301, 451, 651, 901, 1201, 1601, 2001, 2451, 2901}
@@ -82,3 +84,82 @@ func generateLogoOptions() {
 		f.Close()
 	}
 }
+
+func generateOGImages() {
+	log.Debug().Msg("generating og images")
+
+	imageWidth := 512
+	imageHeight := imageWidth * 2 / 3
+	logoSize := imageHeight * 2 / 3
+	borderWidth := 2
+
+	{
+		filename := "og-widget.jpg"
+		opts := common.DefaultLogoOptions()
+		opts.Gap *= 10
+		opts.Jump *= 10
+		opts.LineStep *= 10
+		opts.LineWidth *= 10
+
+		logo := common.AftermathLogo(common.ColorAftermathRed, opts)
+		ctx := gg.NewContext(imageWidth, imageHeight)
+
+		bg, err := imaging.Open("./bg-default.jpg")
+		if err != nil {
+			panic(err)
+		}
+
+		ctx.DrawImage(imaging.Blur(imaging.Fill(bg, imageWidth, imageHeight, imaging.Center, imaging.Lanczos), 30), 0, 0)
+		ctx.DrawRoundedRectangle(float64(borderWidth), float64(borderWidth), float64(imageWidth-borderWidth*2), float64(imageHeight-borderWidth*2), 20)
+		ctx.SetColor(common.DefaultCardColorNoAlpha)
+		ctx.Fill()
+
+		ctx.DrawImageAnchored(imaging.Fit(logo, logoSize, logoSize, imaging.Linear), imageWidth/2, imageHeight/2, 0.5, 0.5)
+
+		f, err := os.Create(filepath.Join("../public", filename))
+		if err != nil {
+			panic(err)
+		}
+
+		err = imaging.Encode(f, ctx.Image(), imaging.JPEG)
+		if err != nil {
+			panic(err)
+		}
+		f.Close()
+	}
+
+	{
+		filename := "og.jpg"
+		opts := common.DefaultLogoOptions()
+		opts.Gap *= 10
+		opts.Jump *= 10
+		opts.LineStep *= 10
+		opts.LineWidth *= 10
+
+		logo := common.AftermathLogo(common.ColorAftermathRed, opts)
+		ctx := gg.NewContext(imageWidth, imageHeight)
+
+		bg, err := imaging.Open("./bg-default.jpg")
+		if err != nil {
+			panic(err)
+		}
+
+		ctx.DrawImage(imaging.Blur(imaging.Fill(bg, imageWidth, imageHeight, imaging.Center, imaging.Lanczos), 30), 0, 0)
+		ctx.DrawRoundedRectangle(float64(borderWidth), float64(borderWidth), float64(imageWidth-borderWidth*2), float64(imageHeight-borderWidth*2), 20)
+		ctx.SetColor(common.DefaultCardColorNoAlpha)
+		ctx.Fill()
+
+		ctx.DrawImageAnchored(imaging.Fit(logo, logoSize, logoSize, imaging.Linear), imageWidth/2, imageHeight/2, 0.5, 0.5)
+
+		f, err := os.Create(filepath.Join("../public", filename))
+		if err != nil {
+			panic(err)
+		}
+
+		err = imaging.Encode(f, ctx.Image(), imaging.JPEG)
+		if err != nil {
+			panic(err)
+		}
+		f.Close()
+	}
+}
diff --git a/cmd/frontend/components/navbar.templ b/cmd/frontend/components/navbar.templ
index d96c1db4..a2502d76 100644
--- a/cmd/frontend/components/navbar.templ
+++ b/cmd/frontend/components/navbar.templ
@@ -31,7 +31,7 @@ templ navbar(props navbarProps) {
 	<div class="no-animation" hx-boost="true">
 		<div class="navbar bg-base-100 gap-1">
 			<div class="navbar-start gap-1">
-				<a href="/" class="px-2">
+				<a href="/" class="p-2 aspect-square">
 					@Logo("32")
 				</a>
 			</div>
diff --git a/cmd/frontend/components/navbar_templ.go b/cmd/frontend/components/navbar_templ.go
index fc1f0cda..5e433b20 100644
--- a/cmd/frontend/components/navbar_templ.go
+++ b/cmd/frontend/components/navbar_templ.go
@@ -53,7 +53,7 @@ func navbar(props navbarProps) templ.Component {
 			templ_7745c5c3_Var1 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"no-animation\" hx-boost=\"true\"><div class=\"navbar bg-base-100 gap-1\"><div class=\"navbar-start gap-1\"><a href=\"/\" class=\"px-2\">")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"no-animation\" hx-boost=\"true\"><div class=\"navbar bg-base-100 gap-1\"><div class=\"navbar-start gap-1\"><a href=\"/\" class=\"p-2 aspect-square\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
diff --git a/cmd/frontend/public/og-widget.jpg b/cmd/frontend/public/og-widget.jpg
index a1c8eb84a7fb5615033062be6668c5ca368a6e90..1aca9a7be0ff7892940833c0d4b6780950903d53 100644
GIT binary patch
literal 16098
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
IyrAQM0c-XhrT_o{

literal 40334
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
Bll1@q

diff --git a/cmd/frontend/public/og.jpg b/cmd/frontend/public/og.jpg
index a1c8eb84a7fb5615033062be6668c5ca368a6e90..1aca9a7be0ff7892940833c0d4b6780950903d53 100644
GIT binary patch
literal 16098
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
IyrAQM0c-XhrT_o{

literal 40334
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
Bll1@q

diff --git a/cmd/frontend/public/og.png b/cmd/frontend/public/og.png
deleted file mode 100644
index df904fb569107ec0fdbf3795f2eab2e1ba1e627e..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 14493
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
UAA4yCpbkXup7Gtv+mD|A52cumk^lez


From 2023e89fe9b7876beebbfe9d365d06d286dfa7a9 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 5 Jul 2024 13:49:57 -0400
Subject: [PATCH 263/341] added accounts search

---
 cmd/frontend/components/navbar.templ      |   8 +-
 cmd/frontend/components/navbar_templ.go   |  14 +-
 cmd/frontend/routes/widget/index.templ    | 162 ++++++++++++++--
 cmd/frontend/routes/widget/index_templ.go | 216 +++++++++++++++++++---
 4 files changed, 355 insertions(+), 45 deletions(-)

diff --git a/cmd/frontend/components/navbar.templ b/cmd/frontend/components/navbar.templ
index a2502d76..c57557de 100644
--- a/cmd/frontend/components/navbar.templ
+++ b/cmd/frontend/components/navbar.templ
@@ -36,9 +36,11 @@ templ navbar(props navbarProps) {
 				</a>
 			</div>
 			<div class="navbar-center">
-				<div class="form-control">
-					<input type="text" placeholder="Search Players" class="input input-bordered w-48 md:w-auto placeholder:text-center"/>
-				</div>
+				if props.path == "/" {
+					<div class="form-control">
+						<input type="text" placeholder="Search Players" class="input input-bordered w-48 md:w-auto placeholder:text-center" disabled/>
+					</div>
+				}
 			</div>
 			<ul class="navbar-end menu menu-horizontal px-1 gap-1 hidden md:flex">
 				<li><a href="/widget" class={ logic.StringIfElse("active", "", props.path == "/widget") }>Widget</a></li>
diff --git a/cmd/frontend/components/navbar_templ.go b/cmd/frontend/components/navbar_templ.go
index 5e433b20..288dd95d 100644
--- a/cmd/frontend/components/navbar_templ.go
+++ b/cmd/frontend/components/navbar_templ.go
@@ -61,7 +61,17 @@ func navbar(props navbarProps) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</a></div><div class=\"navbar-center\"><div class=\"form-control\"><input type=\"text\" placeholder=\"Search Players\" class=\"input input-bordered w-48 md:w-auto placeholder:text-center\"></div></div><ul class=\"navbar-end menu menu-horizontal px-1 gap-1 hidden md:flex\"><li>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</a></div><div class=\"navbar-center\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		if props.path == "/" {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"form-control\"><input type=\"text\" placeholder=\"Search Players\" class=\"input input-bordered w-48 md:w-auto placeholder:text-center\" disabled></div>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div><ul class=\"navbar-end menu menu-horizontal px-1 gap-1 hidden md:flex\"><li>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -165,7 +175,7 @@ func navMenuLink(label, href, currentPath string) templ.Component {
 		var templ_7745c5c3_Var10 string
 		templ_7745c5c3_Var10, templ_7745c5c3_Err = templ.JoinStringErrs(label)
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/navbar.templ`, Line: 69, Col: 78}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/navbar.templ`, Line: 71, Col: 78}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var10))
 		if templ_7745c5c3_Err != nil {
diff --git a/cmd/frontend/routes/widget/index.templ b/cmd/frontend/routes/widget/index.templ
index d79ed062..ffec0d0d 100644
--- a/cmd/frontend/routes/widget/index.templ
+++ b/cmd/frontend/routes/widget/index.templ
@@ -5,10 +5,14 @@ import (
 	cwidget "github.com/cufee/aftermath/cmd/frontend/components/widget"
 	"github.com/cufee/aftermath/cmd/frontend/handler"
 	"github.com/cufee/aftermath/cmd/frontend/layouts"
+	"github.com/cufee/aftermath/cmd/frontend/logic"
 	"github.com/cufee/aftermath/cmd/frontend/routes/api/widget"
+	"os"
 	"strconv"
 )
 
+var publicWgAppID = os.Getenv("WG_AUTH_APP_ID")
+
 var WidgetHome handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
 	widget, err := widget.MockWidget(ctx)
 	if err != nil {
@@ -37,7 +41,20 @@ templ widgetHome(widget templ.Component, or, ou bool, vl int) {
 				</p>
 			</div>
 			@cwidget.Settings(handlePreviewOnHome(), or, ou, vl)
-			<button disabled type="button" id="preview-widget" class="btn btn-primary w-full">Create Your Widget</button>
+			<div class="flex flex-row flex-wrap gap-2">
+				<select id="player-search-realm" class="select select-bordered" onchange={ onRealmSelect() }>
+					<option disabled selected class="text-center">Pick a Server</option>
+					<option value="NA">North America</option>
+					<option value="EU">Europe</option>
+					<option value="AS">Asia</option>
+				</select>
+				<div class="dropdown dropdown-top grow">
+					<input id="player-search-nickname" type="text" placeholder="Nickname" class="join-item input input-bordered placeholder:text-center w-full" disabled oninput={ onNicknameInput() }/>
+					<ul id="player-search-results" tabindex="0" class="dropdown-content z-[1] menu p-2 shadow bg-base-300 rounded-t-box flex-nowrap overflow-auto w-full">
+						<span class="text-xs text-center cursor-default">Start typing to search</span>
+					</ul>
+				</div>
+			</div>
 		</div>
 		<div class="flex items-center justify-center grow">
 			<div class="max-w-4xl w-full">
@@ -49,31 +66,142 @@ templ widgetHome(widget templ.Component, or, ou bool, vl int) {
 			</div>
 		</div>
 	</div>
+	@logic.EmbedMinifiedScript(searchEventHandler(publicWgAppID), publicWgAppID)
+}
+
+script onRealmSelect() {
+	const results = document.getElementById("player-search-results");
+	const select = document.getElementById("player-search-realm");
+	const realm = select.value;
+	// enable/disable field
+	const nickname = document.getElementById("player-search-nickname");
+	if (realm) {
+		if (nickname.value.length >= 5) {
+			// if the input already exists - send a request
+			results.innerHTML = '<li><span class="loading loading-dots loading-xs m-auto"></span></li>';
+			const event = new CustomEvent("player-search", { detail: {query: nickname.value, realm} });
+			document.dispatchEvent(event);
+			return
+		}
+		nickname.disabled = false;
+	} else {
+		nickname.disabled = true;
+	}
+	// clear results
+	results.innerHTML = '<span class="text-xs text-center cursor-default">Start typing to search</span>';
+}
+
+script onNicknameInput() {
+	const nickname = document.getElementById("player-search-nickname");
+	const results = document.getElementById("player-search-results");
+	const select = document.getElementById("player-search-realm");
+	const realm = select.value;
+	if (!realm) {
+		results.innerHTML = '<span class="text-xs text-center cursor-default">Start typing to search</span>';
+		nickname.disabled = true;
+		nickname.value = '';
+		return;
+	}
+	if (!nickname.value) {
+		results.innerHTML = '<span class="text-xs text-center cursor-default">Start typing to search</span>';
+		return;
+	}
+	if (nickname.value.length < 5) {
+		results.innerHTML = '<span class="text-xs text-center cursor-default">Continue typing to search</span>';
+		return;
+	}
+	const event = new CustomEvent("player-search", { detail: {query: nickname.value, realm} });
+	document.dispatchEvent(event);
+}
+
+script searchEventHandler(appId string) {
+	const results = document.getElementById("player-search-results");
+	const nickname = document.getElementById("player-search-nickname");
+
+	const getApiUrl = (realm, query) => {
+		let baseUrl = "";
+		switch (realm) {
+			case "NA":
+				baseUrl = "https://api.wotblitz.com/wotb";
+				break;
+			case "EU":
+				baseUrl = "https://api.wotblitz.eu/wotb";
+				break;
+			case "AS":
+				baseUrl = "https://api.wotblitz.asia/wotb";
+				break;
+			default:
+				return "";
+		}
+		return baseUrl + "/account/list/" + "?application_id=" + appId + "&limit=5" + "&search=" + query;
+	}
+
+	let debounceTimeout;
+	const debounceDelay = 500;
+
+	document.addEventListener(
+		"player-search",
+		(evt) => {
+			clearTimeout(debounceTimeout);
+			debounceTimeout = setTimeout(() => {
+				results.innerHTML = '<li><span class="loading loading-dots loading-xs m-auto"></span></li>';
+				
+				const { query, realm } = evt.detail;
+				const url = getApiUrl(realm, query);
+				if (!url) return;
+
+				fetch(url).then(res => res.json()).then(data => {
+					if (data.status != "ok") {
+						results.innerHTML = `<span class="text-xs text-center cursor-default">${data?.error?.message.toLocaleLowerCase().replaceAll("_", " ") || "Failed to get accounts"}</span>`;
+						nickname.disabled = false;
+						return;
+					}
+					const elements = []
+					for (const account of data.data || []) {
+						if (!account.account_id || !account.nickname) continue;
+						elements.push(`<li><a href="/widget/${account.account_id}">${account.nickname}</a></li>`);
+					}
+					if (elements.length == 0) {
+						results.innerHTML = '<span class="text-xs text-center cursor-default">No players found</span>';
+						nickname.disabled = false;
+						return;
+					}
+					results.innerHTML = elements.join("");
+					return;
+				}).catch(e => {
+					console.log("failed to search for accounts",e);
+					results.innerHTML = '<span class="text-xs text-center cursor-default">No players found</span>';
+					nickname.disabled = false;
+				});
+			}, debounceDelay);
+		},
+		false,
+	);
 }
 
 script handlePreviewOnHome() {
-	const ouEl = document.getElementById("widget-settings-ou")
-	const orEl = document.getElementById("widget-settings-or")
-	const vlEl = document.getElementById("widget-settings-vl")
+	const ouEl = document.getElementById("widget-settings-ou");
+	const orEl = document.getElementById("widget-settings-or");
+	const vlEl = document.getElementById("widget-settings-vl");
 
-	const ou = ouEl.checked ? "1" : "0"
-	const or = orEl.checked ? "1" : "0"
-	const vl = vlEl.value
-	const newQuery = `?or=${or}&ou=${ou}&vl=${vl}`
+	const ou = ouEl.checked ? "1" : "0";
+	const or = orEl.checked ? "1" : "0";
+	const vl = vlEl.value;
+	const newQuery = `?or=${or}&ou=${ou}&vl=${vl}`;
 	if (newQuery != window.location.search) {
-		ouEl.disabled = true
-		orEl.disabled = true
-		vlEl.disabled = true
+		ouEl.disabled = true;
+		orEl.disabled = true;
+		vlEl.disabled = true;
 		fetch("/api/widget/mock"+newQuery).then((r) => r.text()).then((html) => {
-			document.getElementById("mock-widget").outerHTML = html
+			document.getElementById("mock-widget").outerHTML = html;
 			const url = window.location.protocol + "//" + window.location.host + window.location.pathname + newQuery;
 			window.history?.pushState({path:url},'',url);
 		}).catch(e => console.log(e)).finally(() => {
 			setTimeout(() => {
-				ouEl.disabled = false
-				orEl.disabled = false
-				vlEl.disabled = false
-			}, 500)
-		})
+				ouEl.disabled = false;
+				orEl.disabled = false;
+				vlEl.disabled = false;
+			}, 500);
+		});
 	}
 }
diff --git a/cmd/frontend/routes/widget/index_templ.go b/cmd/frontend/routes/widget/index_templ.go
index c1c65f9c..7427e0b3 100644
--- a/cmd/frontend/routes/widget/index_templ.go
+++ b/cmd/frontend/routes/widget/index_templ.go
@@ -13,10 +13,14 @@ import (
 	cwidget "github.com/cufee/aftermath/cmd/frontend/components/widget"
 	"github.com/cufee/aftermath/cmd/frontend/handler"
 	"github.com/cufee/aftermath/cmd/frontend/layouts"
+	"github.com/cufee/aftermath/cmd/frontend/logic"
 	"github.com/cufee/aftermath/cmd/frontend/routes/api/widget"
+	"os"
 	"strconv"
 )
 
+var publicWgAppID = os.Getenv("WG_AUTH_APP_ID")
+
 var WidgetHome handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
 	widget, err := widget.MockWidget(ctx)
 	if err != nil {
@@ -59,11 +63,45 @@ func widgetHome(widget templ.Component, or, ou bool, vl int) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<button disabled type=\"button\" id=\"preview-widget\" class=\"btn btn-primary w-full\">Create Your Widget</button></div><div class=\"flex items-center justify-center grow\"><div class=\"max-w-4xl w-full\">")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-row flex-wrap gap-2\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = templ.RenderScriptItems(ctx, templ_7745c5c3_Buffer, onRealmSelect())
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<select id=\"player-search-realm\" class=\"select select-bordered\" onchange=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var2 templ.ComponentScript = onRealmSelect()
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ_7745c5c3_Var2.Call)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><option disabled selected class=\"text-center\">Pick a Server</option> <option value=\"NA\">North America</option> <option value=\"EU\">Europe</option> <option value=\"AS\">Asia</option></select><div class=\"dropdown dropdown-top grow\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = templ.RenderScriptItems(ctx, templ_7745c5c3_Buffer, onNicknameInput())
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<input id=\"player-search-nickname\" type=\"text\" placeholder=\"Nickname\" class=\"join-item input input-bordered placeholder:text-center w-full\" disabled oninput=\"")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		templ_7745c5c3_Var2 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		var templ_7745c5c3_Var3 templ.ComponentScript = onNicknameInput()
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ_7745c5c3_Var3.Call)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><ul id=\"player-search-results\" tabindex=\"0\" class=\"dropdown-content z-[1] menu p-2 shadow bg-base-300 rounded-t-box flex-nowrap overflow-auto w-full\"><span class=\"text-xs text-center cursor-default\">Start typing to search</span></ul></div></div></div><div class=\"flex items-center justify-center grow\"><div class=\"max-w-4xl w-full\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Var4 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 			templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 			templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 			if !templ_7745c5c3_IsBuffer {
@@ -89,7 +127,7 @@ func widgetHome(widget templ.Component, or, ou bool, vl int) templ.Component {
 			}
 			return templ_7745c5c3_Err
 		})
-		templ_7745c5c3_Err = components.OBSMockup("/assets/widget-background.jpg").Render(templ.WithChildren(ctx, templ_7745c5c3_Var2), templ_7745c5c3_Buffer)
+		templ_7745c5c3_Err = components.OBSMockup("/assets/widget-background.jpg").Render(templ.WithChildren(ctx, templ_7745c5c3_Var4), templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -97,39 +135,171 @@ func widgetHome(widget templ.Component, or, ou bool, vl int) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
+		templ_7745c5c3_Err = logic.EmbedMinifiedScript(searchEventHandler(publicWgAppID), publicWgAppID).Render(ctx, templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
 		return templ_7745c5c3_Err
 	})
 }
 
+func onRealmSelect() templ.ComponentScript {
+	return templ.ComponentScript{
+		Name: `__templ_onRealmSelect_da95`,
+		Function: `function __templ_onRealmSelect_da95(){const results = document.getElementById("player-search-results");
+	const select = document.getElementById("player-search-realm");
+	const realm = select.value;
+	// enable/disable field
+	const nickname = document.getElementById("player-search-nickname");
+	if (realm) {
+		if (nickname.value.length >= 5) {
+			// if the input already exists - send a request
+			results.innerHTML = '<li><span class="loading loading-dots loading-xs m-auto"></span></li>';
+			const event = new CustomEvent("player-search", { detail: {query: nickname.value, realm} });
+			document.dispatchEvent(event);
+			return
+		}
+		nickname.disabled = false;
+	} else {
+		nickname.disabled = true;
+	}
+	// clear results
+	results.innerHTML = '<span class="text-xs text-center cursor-default">Start typing to search</span>';
+}`,
+		Call:       templ.SafeScript(`__templ_onRealmSelect_da95`),
+		CallInline: templ.SafeScriptInline(`__templ_onRealmSelect_da95`),
+	}
+}
+
+func onNicknameInput() templ.ComponentScript {
+	return templ.ComponentScript{
+		Name: `__templ_onNicknameInput_042c`,
+		Function: `function __templ_onNicknameInput_042c(){const nickname = document.getElementById("player-search-nickname");
+	const results = document.getElementById("player-search-results");
+	const select = document.getElementById("player-search-realm");
+	const realm = select.value;
+	if (!realm) {
+		results.innerHTML = '<span class="text-xs text-center cursor-default">Start typing to search</span>';
+		nickname.disabled = true;
+		nickname.value = '';
+		return;
+	}
+	if (!nickname.value) {
+		results.innerHTML = '<span class="text-xs text-center cursor-default">Start typing to search</span>';
+		return;
+	}
+	if (nickname.value.length < 5) {
+		results.innerHTML = '<span class="text-xs text-center cursor-default">Continue typing to search</span>';
+		return;
+	}
+	const event = new CustomEvent("player-search", { detail: {query: nickname.value, realm} });
+	document.dispatchEvent(event);
+}`,
+		Call:       templ.SafeScript(`__templ_onNicknameInput_042c`),
+		CallInline: templ.SafeScriptInline(`__templ_onNicknameInput_042c`),
+	}
+}
+
+func searchEventHandler(appId string) templ.ComponentScript {
+	return templ.ComponentScript{
+		Name: `__templ_searchEventHandler_f59f`,
+		Function: `function __templ_searchEventHandler_f59f(appId){const results = document.getElementById("player-search-results");
+	const nickname = document.getElementById("player-search-nickname");
+
+	const getApiUrl = (realm, query) => {
+		let baseUrl = "";
+		switch (realm) {
+			case "NA":
+				baseUrl = "https://api.wotblitz.com/wotb";
+				break;
+			case "EU":
+				baseUrl = "https://api.wotblitz.eu/wotb";
+				break;
+			case "AS":
+				baseUrl = "https://api.wotblitz.asia/wotb";
+				break;
+			default:
+				return "";
+		}
+		return baseUrl + "/account/list/" + "?application_id=" + appId + "&limit=5" + "&search=" + query;
+	}
+
+	let debounceTimeout;
+	const debounceDelay = 500;
+
+	document.addEventListener(
+		"player-search",
+		(evt) => {
+			clearTimeout(debounceTimeout);
+			debounceTimeout = setTimeout(() => {
+				results.innerHTML = '<li><span class="loading loading-dots loading-xs m-auto"></span></li>';
+				
+				const { query, realm } = evt.detail;
+				const url = getApiUrl(realm, query);
+				if (!url) return;
+
+				fetch(url).then(res => res.json()).then(data => {
+					if (data.status != "ok") {
+						results.innerHTML = ` + "`" + `<span class="text-xs text-center cursor-default">${data?.error?.message.toLocaleLowerCase().replaceAll("_", " ") || "Failed to get accounts"}</span>` + "`" + `;
+						nickname.disabled = false;
+						return;
+					}
+					const elements = []
+					for (const account of data.data || []) {
+						if (!account.account_id || !account.nickname) continue;
+						elements.push(` + "`" + `<li><a href="/widget/${account.account_id}">${account.nickname}</a></li>` + "`" + `);
+					}
+					if (elements.length == 0) {
+						results.innerHTML = '<span class="text-xs text-center cursor-default">No players found</span>';
+						nickname.disabled = false;
+						return;
+					}
+					results.innerHTML = elements.join("");
+					return;
+				}).catch(e => {
+					console.log("failed to search for accounts",e);
+					results.innerHTML = '<span class="text-xs text-center cursor-default">No players found</span>';
+					nickname.disabled = false;
+				});
+			}, debounceDelay);
+		},
+		false,
+	);
+}`,
+		Call:       templ.SafeScript(`__templ_searchEventHandler_f59f`, appId),
+		CallInline: templ.SafeScriptInline(`__templ_searchEventHandler_f59f`, appId),
+	}
+}
+
 func handlePreviewOnHome() templ.ComponentScript {
 	return templ.ComponentScript{
-		Name: `__templ_handlePreviewOnHome_66f0`,
-		Function: `function __templ_handlePreviewOnHome_66f0(){const ouEl = document.getElementById("widget-settings-ou")
-	const orEl = document.getElementById("widget-settings-or")
-	const vlEl = document.getElementById("widget-settings-vl")
-
-	const ou = ouEl.checked ? "1" : "0"
-	const or = orEl.checked ? "1" : "0"
-	const vl = vlEl.value
-	const newQuery = ` + "`" + `?or=${or}&ou=${ou}&vl=${vl}` + "`" + `
+		Name: `__templ_handlePreviewOnHome_2c46`,
+		Function: `function __templ_handlePreviewOnHome_2c46(){const ouEl = document.getElementById("widget-settings-ou");
+	const orEl = document.getElementById("widget-settings-or");
+	const vlEl = document.getElementById("widget-settings-vl");
+
+	const ou = ouEl.checked ? "1" : "0";
+	const or = orEl.checked ? "1" : "0";
+	const vl = vlEl.value;
+	const newQuery = ` + "`" + `?or=${or}&ou=${ou}&vl=${vl}` + "`" + `;
 	if (newQuery != window.location.search) {
-		ouEl.disabled = true
-		orEl.disabled = true
-		vlEl.disabled = true
+		ouEl.disabled = true;
+		orEl.disabled = true;
+		vlEl.disabled = true;
 		fetch("/api/widget/mock"+newQuery).then((r) => r.text()).then((html) => {
-			document.getElementById("mock-widget").outerHTML = html
+			document.getElementById("mock-widget").outerHTML = html;
 			const url = window.location.protocol + "//" + window.location.host + window.location.pathname + newQuery;
 			window.history?.pushState({path:url},'',url);
 		}).catch(e => console.log(e)).finally(() => {
 			setTimeout(() => {
-				ouEl.disabled = false
-				orEl.disabled = false
-				vlEl.disabled = false
-			}, 500)
-		})
+				ouEl.disabled = false;
+				orEl.disabled = false;
+				vlEl.disabled = false;
+			}, 500);
+		});
 	}
 }`,
-		Call:       templ.SafeScript(`__templ_handlePreviewOnHome_66f0`),
-		CallInline: templ.SafeScriptInline(`__templ_handlePreviewOnHome_66f0`),
+		Call:       templ.SafeScript(`__templ_handlePreviewOnHome_2c46`),
+		CallInline: templ.SafeScriptInline(`__templ_handlePreviewOnHome_2c46`),
 	}
 }

From d06974c46e675886eff29b5d49569e8b902e212b Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 5 Jul 2024 13:55:18 -0400
Subject: [PATCH 264/341] added loading state on navigation

---
 cmd/frontend/routes/widget/index.templ    |  9 +++++++--
 cmd/frontend/routes/widget/index_templ.go | 17 +++++++++++------
 2 files changed, 18 insertions(+), 8 deletions(-)

diff --git a/cmd/frontend/routes/widget/index.templ b/cmd/frontend/routes/widget/index.templ
index ffec0d0d..9f9be33d 100644
--- a/cmd/frontend/routes/widget/index.templ
+++ b/cmd/frontend/routes/widget/index.templ
@@ -118,6 +118,11 @@ script searchEventHandler(appId string) {
 	const results = document.getElementById("player-search-results");
 	const nickname = document.getElementById("player-search-nickname");
 
+	const setResultsLoading = () => {
+		results.innerHTML = '<li><span class="loading loading-dots loading-xs m-auto"></span></li>';
+	}
+	window.setResultsLoading = setResultsLoading
+
 	const getApiUrl = (realm, query) => {
 		let baseUrl = "";
 		switch (realm) {
@@ -144,7 +149,7 @@ script searchEventHandler(appId string) {
 		(evt) => {
 			clearTimeout(debounceTimeout);
 			debounceTimeout = setTimeout(() => {
-				results.innerHTML = '<li><span class="loading loading-dots loading-xs m-auto"></span></li>';
+				setResultsLoading()
 				
 				const { query, realm } = evt.detail;
 				const url = getApiUrl(realm, query);
@@ -159,7 +164,7 @@ script searchEventHandler(appId string) {
 					const elements = []
 					for (const account of data.data || []) {
 						if (!account.account_id || !account.nickname) continue;
-						elements.push(`<li><a href="/widget/${account.account_id}">${account.nickname}</a></li>`);
+						elements.push(`<li><a onclick="window.setResultsLoading()" href="/widget/${account.account_id}">${account.nickname}</a></li>`);
 					}
 					if (elements.length == 0) {
 						results.innerHTML = '<span class="text-xs text-center cursor-default">No players found</span>';
diff --git a/cmd/frontend/routes/widget/index_templ.go b/cmd/frontend/routes/widget/index_templ.go
index 7427e0b3..64e48378 100644
--- a/cmd/frontend/routes/widget/index_templ.go
+++ b/cmd/frontend/routes/widget/index_templ.go
@@ -202,10 +202,15 @@ func onNicknameInput() templ.ComponentScript {
 
 func searchEventHandler(appId string) templ.ComponentScript {
 	return templ.ComponentScript{
-		Name: `__templ_searchEventHandler_f59f`,
-		Function: `function __templ_searchEventHandler_f59f(appId){const results = document.getElementById("player-search-results");
+		Name: `__templ_searchEventHandler_c17b`,
+		Function: `function __templ_searchEventHandler_c17b(appId){const results = document.getElementById("player-search-results");
 	const nickname = document.getElementById("player-search-nickname");
 
+	const setResultsLoading = () => {
+		results.innerHTML = '<li><span class="loading loading-dots loading-xs m-auto"></span></li>';
+	}
+	window.setResultsLoading = setResultsLoading
+
 	const getApiUrl = (realm, query) => {
 		let baseUrl = "";
 		switch (realm) {
@@ -232,7 +237,7 @@ func searchEventHandler(appId string) templ.ComponentScript {
 		(evt) => {
 			clearTimeout(debounceTimeout);
 			debounceTimeout = setTimeout(() => {
-				results.innerHTML = '<li><span class="loading loading-dots loading-xs m-auto"></span></li>';
+				setResultsLoading()
 				
 				const { query, realm } = evt.detail;
 				const url = getApiUrl(realm, query);
@@ -247,7 +252,7 @@ func searchEventHandler(appId string) templ.ComponentScript {
 					const elements = []
 					for (const account of data.data || []) {
 						if (!account.account_id || !account.nickname) continue;
-						elements.push(` + "`" + `<li><a href="/widget/${account.account_id}">${account.nickname}</a></li>` + "`" + `);
+						elements.push(` + "`" + `<li><a onclick="window.setResultsLoading()" href="/widget/${account.account_id}">${account.nickname}</a></li>` + "`" + `);
 					}
 					if (elements.length == 0) {
 						results.innerHTML = '<span class="text-xs text-center cursor-default">No players found</span>';
@@ -266,8 +271,8 @@ func searchEventHandler(appId string) templ.ComponentScript {
 		false,
 	);
 }`,
-		Call:       templ.SafeScript(`__templ_searchEventHandler_f59f`, appId),
-		CallInline: templ.SafeScriptInline(`__templ_searchEventHandler_f59f`, appId),
+		Call:       templ.SafeScript(`__templ_searchEventHandler_c17b`, appId),
+		CallInline: templ.SafeScriptInline(`__templ_searchEventHandler_c17b`, appId),
 	}
 }
 

From b752cab3b9f7929f6c3de49cc749e144c0c53665 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 5 Jul 2024 13:56:36 -0400
Subject: [PATCH 265/341] removed extra generate

---
 main.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/main.go b/main.go
index db951222..4d887007 100644
--- a/main.go
+++ b/main.go
@@ -41,7 +41,6 @@ import (
 	"net/http/pprof"
 )
 
-//go:generate go generate ./internal/database/ent
 //go:generate go generate ./cmd/frontend/assets
 
 //go:embed static/*

From 64dba914c91f0367119f9619ddf923877194e6c5 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 5 Jul 2024 13:59:39 -0400
Subject: [PATCH 266/341] always generating cards

---
 internal/stats/prepare/session/v1/card.go | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/internal/stats/prepare/session/v1/card.go b/internal/stats/prepare/session/v1/card.go
index d9a1a6bb..e7160723 100644
--- a/internal/stats/prepare/session/v1/card.go
+++ b/internal/stats/prepare/session/v1/card.go
@@ -22,8 +22,7 @@ func NewCards(session, career fetch.AccountStatsOverPeriod, glossary map[string]
 
 	var cards Cards
 
-	// Rating battles overview
-	if session.RatingBattles.Battles > 0 {
+	{ // Rating battles overview
 		card, err := makeOverviewCard(
 			ratingOverviewBlocks,
 			session.RatingBattles.StatsFrame,
@@ -42,8 +41,7 @@ func NewCards(session, career fetch.AccountStatsOverPeriod, glossary map[string]
 		}
 		cards.Rating.Overview = card
 	}
-	// Regular battles overview
-	if session.RegularBattles.Battles > 0 || session.RatingBattles.Battles == 0 {
+	{ // Regular battles overview
 		card, err := makeOverviewCard(
 			unratedOverviewBlocks,
 			session.RegularBattles.StatsFrame,

From 0ab7b4880a2b4d9050170847d0b86d211095bcd2 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 5 Jul 2024 14:00:40 -0400
Subject: [PATCH 267/341] changed highlights order

---
 internal/stats/prepare/session/v1/card.go      | 2 +-
 internal/stats/prepare/session/v1/constants.go | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/internal/stats/prepare/session/v1/card.go b/internal/stats/prepare/session/v1/card.go
index e7160723..55b8db9a 100644
--- a/internal/stats/prepare/session/v1/card.go
+++ b/internal/stats/prepare/session/v1/card.go
@@ -122,11 +122,11 @@ func NewCards(session, career fetch.AccountStatsOverPeriod, glossary map[string]
 	}
 
 	// Vehicle Highlights
-	var minimumBattles float64 = 5
 	periodDays := session.PeriodEnd.Sub(session.PeriodStart).Hours() / 24
 	withFallback := func(battles float64) float64 {
 		return math.Min(battles, float64(session.RegularBattles.Battles.Float())/float64(len(highlights)))
 	}
+	var minimumBattles float64 = withFallback(5)
 	if periodDays > 90 {
 		minimumBattles = withFallback(100)
 	} else if periodDays > 60 {
diff --git a/internal/stats/prepare/session/v1/constants.go b/internal/stats/prepare/session/v1/constants.go
index c64e8a86..f4f1a925 100644
--- a/internal/stats/prepare/session/v1/constants.go
+++ b/internal/stats/prepare/session/v1/constants.go
@@ -23,7 +23,7 @@ var ratingOverviewBlocks = []overviewColumnBlocks{
 }
 
 var vehicleBlocks = []common.Tag{common.TagBattles, common.TagWinrate, common.TagAvgDamage, common.TagWN8}
-var highlights = []common.Highlight{common.HighlightBattles, common.HighlightWN8, common.HighlightAvgDamage}
+var highlights = []common.Highlight{common.HighlightWN8, common.HighlightAvgDamage, common.HighlightBattles}
 
 type Cards struct {
 	Unrated UnratedCards `json:"unrated"`

From 938b9fbc265ce5335b01c5a5bcce35d8595a3631 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 5 Jul 2024 14:05:44 -0400
Subject: [PATCH 268/341] added progress bar on requests

---
 cmd/frontend/components/navbar.templ    |  67 ++++++++++++++++
 cmd/frontend/components/navbar_templ.go | 101 +++++++++++++++++++++++-
 2 files changed, 167 insertions(+), 1 deletion(-)

diff --git a/cmd/frontend/components/navbar.templ b/cmd/frontend/components/navbar.templ
index c57557de..30c0c8d8 100644
--- a/cmd/frontend/components/navbar.templ
+++ b/cmd/frontend/components/navbar.templ
@@ -28,6 +28,7 @@ var Navbar handler.Partial = func(ctx *handler.Context) (templ.Component, error)
 }
 
 templ navbar(props navbarProps) {
+	@navProgressAnimated()
 	<div class="no-animation" hx-boost="true">
 		<div class="navbar bg-base-100 gap-1">
 			<div class="navbar-start gap-1">
@@ -83,3 +84,69 @@ func navLinkClass(path, requiredPath string) string {
 
 	return base + " " + "link-hover"
 }
+
+templ navProgressAnimated(...templ.Component) {
+	<div class="w-full h-fit sticky top-0 rounded-b-box overflow-hidden">
+		<div id="nav-progress" class="invisible h-1 transition-all bg-primary rounded-r-full duration-[50ms] ease-in" style="width: 0%"></div>
+	</div>
+	@logic.EmbedMinifiedScript(animateNavProgress())
+}
+
+script animateNavProgress() {
+	const progressBar = document.getElementById('nav-progress');
+	const progressBaseStep = 5;
+
+	const progressRandomStep = () => {
+		return Math.floor(progressBaseStep * Math.random()) + progressBaseStep;
+	}
+	const progressSlowStep = () => {
+		return Math.floor(Math.random() * 2);
+	}
+	
+	document.body.addEventListener('load', () => {
+		progressBar.value = 0;
+		progressBar.style.width = progressBar.value + "%"
+		progressBar.classList.add('invisible');
+		document.querySelectorAll('.nav-btn').forEach((btn) => {
+			btn.removeAttribute('disabled');
+		});
+		if (stopAnimation) {
+			clearInterval(stopAnimation);
+			stopAnimation = null;
+		}
+	});
+	
+	document.body.addEventListener('htmx:afterRequest', () => {
+		setTimeout(() => {
+			progressBar.classList.add('invisible');
+			progressBar.value = 0;
+			progressBar.style.width = progressBar.value + "%"
+		}, 250);
+		progressBar.value = 100;
+		progressBar.style.width = progressBar.value + "%"
+		if (stopAnimation) {
+			clearInterval(stopAnimation);
+			stopAnimation = null;
+		}
+	});
+
+	let stopAnimation;
+	document.body.addEventListener('htmx:beforeSend', () => {
+		progressBar.value = progressRandomStep()
+		progressBar.style.width = progressBar.value + "%"
+		progressBar.classList.remove('invisible');
+
+		stopAnimation = setInterval(() => {
+			if (progressBar.value <= 65) {
+				progressBar.value += progressRandomStep()
+				progressBar.style.width = progressBar.value + "%"
+			} else if (progressBar.value <= 85) {
+				progressBar.value += progressSlowStep()
+				progressBar.style.width = progressBar.value + "%"
+			} else if (progressBar.value <= 95){
+				progressBar.value += 1
+				progressBar.style.width = progressBar.value + "%"
+			}
+		}, 50);
+	});
+}
diff --git a/cmd/frontend/components/navbar_templ.go b/cmd/frontend/components/navbar_templ.go
index 288dd95d..88d0bf78 100644
--- a/cmd/frontend/components/navbar_templ.go
+++ b/cmd/frontend/components/navbar_templ.go
@@ -53,6 +53,10 @@ func navbar(props navbarProps) templ.Component {
 			templ_7745c5c3_Var1 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
+		templ_7745c5c3_Err = navProgressAnimated().Render(ctx, templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"no-animation\" hx-boost=\"true\"><div class=\"navbar bg-base-100 gap-1\"><div class=\"navbar-start gap-1\"><a href=\"/\" class=\"p-2 aspect-square\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
@@ -175,7 +179,7 @@ func navMenuLink(label, href, currentPath string) templ.Component {
 		var templ_7745c5c3_Var10 string
 		templ_7745c5c3_Var10, templ_7745c5c3_Err = templ.JoinStringErrs(label)
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/navbar.templ`, Line: 71, Col: 78}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/navbar.templ`, Line: 72, Col: 78}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var10))
 		if templ_7745c5c3_Err != nil {
@@ -201,3 +205,98 @@ func navLinkClass(path, requiredPath string) string {
 
 	return base + " " + "link-hover"
 }
+
+func navProgressAnimated(...templ.Component) templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var11 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var11 == nil {
+			templ_7745c5c3_Var11 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"w-full h-fit sticky top-0 rounded-b-box overflow-hidden\"><div id=\"nav-progress\" class=\"invisible h-1 transition-all bg-primary rounded-r-full duration-[50ms] ease-in\" style=\"width: 0%\"></div></div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = logic.EmbedMinifiedScript(animateNavProgress()).Render(ctx, templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return templ_7745c5c3_Err
+	})
+}
+
+func animateNavProgress() templ.ComponentScript {
+	return templ.ComponentScript{
+		Name: `__templ_animateNavProgress_cbe4`,
+		Function: `function __templ_animateNavProgress_cbe4(){const progressBar = document.getElementById('nav-progress');
+	const progressBaseStep = 5;
+
+	const progressRandomStep = () => {
+		return Math.floor(progressBaseStep * Math.random()) + progressBaseStep;
+	}
+	const progressSlowStep = () => {
+		return Math.floor(Math.random() * 2);
+	}
+	
+	document.body.addEventListener('load', () => {
+		progressBar.value = 0;
+		progressBar.style.width = progressBar.value + "%"
+		progressBar.classList.add('invisible');
+		document.querySelectorAll('.nav-btn').forEach((btn) => {
+			btn.removeAttribute('disabled');
+		});
+		if (stopAnimation) {
+			clearInterval(stopAnimation);
+			stopAnimation = null;
+		}
+	});
+	
+	document.body.addEventListener('htmx:afterRequest', () => {
+		setTimeout(() => {
+			progressBar.classList.add('invisible');
+			progressBar.value = 0;
+			progressBar.style.width = progressBar.value + "%"
+		}, 250);
+		progressBar.value = 100;
+		progressBar.style.width = progressBar.value + "%"
+		if (stopAnimation) {
+			clearInterval(stopAnimation);
+			stopAnimation = null;
+		}
+	});
+
+	let stopAnimation;
+	document.body.addEventListener('htmx:beforeSend', () => {
+		progressBar.value = progressRandomStep()
+		progressBar.style.width = progressBar.value + "%"
+		progressBar.classList.remove('invisible');
+
+		stopAnimation = setInterval(() => {
+			if (progressBar.value <= 65) {
+				progressBar.value += progressRandomStep()
+				progressBar.style.width = progressBar.value + "%"
+			} else if (progressBar.value <= 85) {
+				progressBar.value += progressSlowStep()
+				progressBar.style.width = progressBar.value + "%"
+			} else if (progressBar.value <= 95){
+				progressBar.value += 1
+				progressBar.style.width = progressBar.value + "%"
+			}
+		}, 50);
+	});
+}`,
+		Call:       templ.SafeScript(`__templ_animateNavProgress_cbe4`),
+		CallInline: templ.SafeScriptInline(`__templ_animateNavProgress_cbe4`),
+	}
+}

From ed7e8b87e9e117f28226360a21325f1a1a6dd24e Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 5 Jul 2024 14:08:04 -0400
Subject: [PATCH 269/341] set position to fixed

---
 cmd/frontend/components/navbar.templ    | 2 +-
 cmd/frontend/components/navbar_templ.go | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/cmd/frontend/components/navbar.templ b/cmd/frontend/components/navbar.templ
index 30c0c8d8..2c5f5c63 100644
--- a/cmd/frontend/components/navbar.templ
+++ b/cmd/frontend/components/navbar.templ
@@ -86,7 +86,7 @@ func navLinkClass(path, requiredPath string) string {
 }
 
 templ navProgressAnimated(...templ.Component) {
-	<div class="w-full h-fit sticky top-0 rounded-b-box overflow-hidden">
+	<div class="w-full h-fit fixed top-0 rounded-b-box overflow-hidden">
 		<div id="nav-progress" class="invisible h-1 transition-all bg-primary rounded-r-full duration-[50ms] ease-in" style="width: 0%"></div>
 	</div>
 	@logic.EmbedMinifiedScript(animateNavProgress())
diff --git a/cmd/frontend/components/navbar_templ.go b/cmd/frontend/components/navbar_templ.go
index 88d0bf78..f51a745c 100644
--- a/cmd/frontend/components/navbar_templ.go
+++ b/cmd/frontend/components/navbar_templ.go
@@ -224,7 +224,7 @@ func navProgressAnimated(...templ.Component) templ.Component {
 			templ_7745c5c3_Var11 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"w-full h-fit sticky top-0 rounded-b-box overflow-hidden\"><div id=\"nav-progress\" class=\"invisible h-1 transition-all bg-primary rounded-r-full duration-[50ms] ease-in\" style=\"width: 0%\"></div></div>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"w-full h-fit fixed top-0 rounded-b-box overflow-hidden\"><div id=\"nav-progress\" class=\"invisible h-1 transition-all bg-primary rounded-r-full duration-[50ms] ease-in\" style=\"width: 0%\"></div></div>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}

From f3e2bbda4d46e5a2ac656fdba6233f3a1281ad4e Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 5 Jul 2024 14:09:10 -0400
Subject: [PATCH 270/341] updated memory limit and reservation

---
 docker-compose.yaml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docker-compose.yaml b/docker-compose.yaml
index 9d7bcfce..5b54b8dc 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -30,9 +30,9 @@ services:
     deploy:
       resources:
         reservations:
-          memory: 64m
+          memory: 128m
         limits:
-          memory: 156m
+          memory: 256m
     networks:
       - dokploy-network
     labels:

From 5b12cce850a0d5c7c49594048c78ed01def39fa1 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 5 Jul 2024 14:21:04 -0400
Subject: [PATCH 271/341] more consistent progress bar

---
 cmd/frontend/components/navbar.templ      | 11 ++++++++---
 cmd/frontend/components/navbar_templ.go   | 19 ++++++++++++-------
 cmd/frontend/routes/widget/index.templ    |  4 ++--
 cmd/frontend/routes/widget/index_templ.go | 12 ++++++------
 4 files changed, 28 insertions(+), 18 deletions(-)

diff --git a/cmd/frontend/components/navbar.templ b/cmd/frontend/components/navbar.templ
index 2c5f5c63..e60fdc99 100644
--- a/cmd/frontend/components/navbar.templ
+++ b/cmd/frontend/components/navbar.templ
@@ -102,8 +102,8 @@ script animateNavProgress() {
 	const progressSlowStep = () => {
 		return Math.floor(Math.random() * 2);
 	}
-	
-	document.body.addEventListener('load', () => {
+
+	const resetProgress = () => {
 		progressBar.value = 0;
 		progressBar.style.width = progressBar.value + "%"
 		progressBar.classList.add('invisible');
@@ -114,7 +114,12 @@ script animateNavProgress() {
 			clearInterval(stopAnimation);
 			stopAnimation = null;
 		}
-	});
+	}
+
+	document.body.addEventListener('load', resetProgress);
+	document.body.addEventListener('popstate', resetProgress);
+	document.body.addEventListener('hashchange', resetProgress);
+	document.body.addEventListener('beforeunload', resetProgress);
 	
 	document.body.addEventListener('htmx:afterRequest', () => {
 		setTimeout(() => {
diff --git a/cmd/frontend/components/navbar_templ.go b/cmd/frontend/components/navbar_templ.go
index f51a745c..b0dae156 100644
--- a/cmd/frontend/components/navbar_templ.go
+++ b/cmd/frontend/components/navbar_templ.go
@@ -238,8 +238,8 @@ func navProgressAnimated(...templ.Component) templ.Component {
 
 func animateNavProgress() templ.ComponentScript {
 	return templ.ComponentScript{
-		Name: `__templ_animateNavProgress_cbe4`,
-		Function: `function __templ_animateNavProgress_cbe4(){const progressBar = document.getElementById('nav-progress');
+		Name: `__templ_animateNavProgress_7b6b`,
+		Function: `function __templ_animateNavProgress_7b6b(){const progressBar = document.getElementById('nav-progress');
 	const progressBaseStep = 5;
 
 	const progressRandomStep = () => {
@@ -248,8 +248,8 @@ func animateNavProgress() templ.ComponentScript {
 	const progressSlowStep = () => {
 		return Math.floor(Math.random() * 2);
 	}
-	
-	document.body.addEventListener('load', () => {
+
+	const resetProgress = () => {
 		progressBar.value = 0;
 		progressBar.style.width = progressBar.value + "%"
 		progressBar.classList.add('invisible');
@@ -260,7 +260,12 @@ func animateNavProgress() templ.ComponentScript {
 			clearInterval(stopAnimation);
 			stopAnimation = null;
 		}
-	});
+	}
+
+	document.body.addEventListener('load', resetProgress);
+	document.body.addEventListener('popstate', resetProgress);
+	document.body.addEventListener('hashchange', resetProgress);
+	document.body.addEventListener('beforeunload', resetProgress);
 	
 	document.body.addEventListener('htmx:afterRequest', () => {
 		setTimeout(() => {
@@ -296,7 +301,7 @@ func animateNavProgress() templ.ComponentScript {
 		}, 50);
 	});
 }`,
-		Call:       templ.SafeScript(`__templ_animateNavProgress_cbe4`),
-		CallInline: templ.SafeScriptInline(`__templ_animateNavProgress_cbe4`),
+		Call:       templ.SafeScript(`__templ_animateNavProgress_7b6b`),
+		CallInline: templ.SafeScriptInline(`__templ_animateNavProgress_7b6b`),
 	}
 }
diff --git a/cmd/frontend/routes/widget/index.templ b/cmd/frontend/routes/widget/index.templ
index 9f9be33d..4d5bcb63 100644
--- a/cmd/frontend/routes/widget/index.templ
+++ b/cmd/frontend/routes/widget/index.templ
@@ -50,7 +50,7 @@ templ widgetHome(widget templ.Component, or, ou bool, vl int) {
 				</select>
 				<div class="dropdown dropdown-top grow">
 					<input id="player-search-nickname" type="text" placeholder="Nickname" class="join-item input input-bordered placeholder:text-center w-full" disabled oninput={ onNicknameInput() }/>
-					<ul id="player-search-results" tabindex="0" class="dropdown-content z-[1] menu p-2 shadow bg-base-300 rounded-t-box flex-nowrap overflow-auto w-full">
+					<ul hx-boost="true" id="player-search-results" tabindex="0" class="dropdown-content z-[1] menu p-2 shadow bg-base-300 rounded-t-box flex-nowrap overflow-auto w-full">
 						<span class="text-xs text-center cursor-default">Start typing to search</span>
 					</ul>
 				</div>
@@ -164,7 +164,7 @@ script searchEventHandler(appId string) {
 					const elements = []
 					for (const account of data.data || []) {
 						if (!account.account_id || !account.nickname) continue;
-						elements.push(`<li><a onclick="window.setResultsLoading()" href="/widget/${account.account_id}">${account.nickname}</a></li>`);
+						elements.push(`<li><a onclick="window.setResultsLoading();htmx.trigger('body','htmx:beforeSend');" href="/widget/${account.account_id}">${account.nickname}</a></li>`);
 					}
 					if (elements.length == 0) {
 						results.innerHTML = '<span class="text-xs text-center cursor-default">No players found</span>';
diff --git a/cmd/frontend/routes/widget/index_templ.go b/cmd/frontend/routes/widget/index_templ.go
index 64e48378..a544c53d 100644
--- a/cmd/frontend/routes/widget/index_templ.go
+++ b/cmd/frontend/routes/widget/index_templ.go
@@ -97,7 +97,7 @@ func widgetHome(widget templ.Component, or, ou bool, vl int) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><ul id=\"player-search-results\" tabindex=\"0\" class=\"dropdown-content z-[1] menu p-2 shadow bg-base-300 rounded-t-box flex-nowrap overflow-auto w-full\"><span class=\"text-xs text-center cursor-default\">Start typing to search</span></ul></div></div></div><div class=\"flex items-center justify-center grow\"><div class=\"max-w-4xl w-full\">")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><ul hx-boost=\"true\" id=\"player-search-results\" tabindex=\"0\" class=\"dropdown-content z-[1] menu p-2 shadow bg-base-300 rounded-t-box flex-nowrap overflow-auto w-full\"><span class=\"text-xs text-center cursor-default\">Start typing to search</span></ul></div></div></div><div class=\"flex items-center justify-center grow\"><div class=\"max-w-4xl w-full\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -202,8 +202,8 @@ func onNicknameInput() templ.ComponentScript {
 
 func searchEventHandler(appId string) templ.ComponentScript {
 	return templ.ComponentScript{
-		Name: `__templ_searchEventHandler_c17b`,
-		Function: `function __templ_searchEventHandler_c17b(appId){const results = document.getElementById("player-search-results");
+		Name: `__templ_searchEventHandler_0220`,
+		Function: `function __templ_searchEventHandler_0220(appId){const results = document.getElementById("player-search-results");
 	const nickname = document.getElementById("player-search-nickname");
 
 	const setResultsLoading = () => {
@@ -252,7 +252,7 @@ func searchEventHandler(appId string) templ.ComponentScript {
 					const elements = []
 					for (const account of data.data || []) {
 						if (!account.account_id || !account.nickname) continue;
-						elements.push(` + "`" + `<li><a onclick="window.setResultsLoading()" href="/widget/${account.account_id}">${account.nickname}</a></li>` + "`" + `);
+						elements.push(` + "`" + `<li><a onclick="window.setResultsLoading();htmx.trigger('body','htmx:beforeSend');" href="/widget/${account.account_id}">${account.nickname}</a></li>` + "`" + `);
 					}
 					if (elements.length == 0) {
 						results.innerHTML = '<span class="text-xs text-center cursor-default">No players found</span>';
@@ -271,8 +271,8 @@ func searchEventHandler(appId string) templ.ComponentScript {
 		false,
 	);
 }`,
-		Call:       templ.SafeScript(`__templ_searchEventHandler_c17b`, appId),
-		CallInline: templ.SafeScriptInline(`__templ_searchEventHandler_c17b`, appId),
+		Call:       templ.SafeScript(`__templ_searchEventHandler_0220`, appId),
+		CallInline: templ.SafeScriptInline(`__templ_searchEventHandler_0220`, appId),
 	}
 }
 

From fbde58db2312afbd46d196d1d76c4d8bf1f9a050 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 5 Jul 2024 14:37:00 -0400
Subject: [PATCH 272/341] mobile bav

---
 cmd/frontend/components/navbar.templ      | 42 +++++++-----
 cmd/frontend/components/navbar_templ.go   | 80 ++++++++++++++++++-----
 cmd/frontend/routes/index.templ           |  6 +-
 cmd/frontend/routes/index_templ.go        |  8 +--
 cmd/frontend/routes/widget/index.templ    |  2 +-
 cmd/frontend/routes/widget/index_templ.go |  2 +-
 6 files changed, 98 insertions(+), 42 deletions(-)

diff --git a/cmd/frontend/components/navbar.templ b/cmd/frontend/components/navbar.templ
index e60fdc99..a56cc678 100644
--- a/cmd/frontend/components/navbar.templ
+++ b/cmd/frontend/components/navbar.templ
@@ -48,21 +48,33 @@ templ navbar(props navbarProps) {
 				<li><a href="/login" hx-boost="false" class={ logic.StringIfElse("btn active", "btn", props.path == "/login") }>Login</a></li>
 			</ul>
 			<ul class="navbar-end menu menu-horizontal px-1 gap-1 md:hidden">
-				<button class="btn btn-square btn-ghost">
-					<svg
-						xmlns="http://www.w3.org/2000/svg"
-						fill="none"
-						viewBox="0 0 24 24"
-						class="inline-block h-5 w-5 stroke-current"
-					>
-						<path
-							stroke-linecap="round"
-							stroke-linejoin="round"
-							stroke-width="2"
-							d="M4 6h16M4 12h16M4 18h16"
-						></path>
-					</svg>
-				</button>
+				<div class="drawer drawer-end">
+					<input id="menu-drawer" type="checkbox" class="drawer-toggle"/>
+					<div class="drawer-content flex justify-end items-center">
+						<label for="menu-drawer" class="btn drawer-button">
+							<svg
+								xmlns="http://www.w3.org/2000/svg"
+								fill="none"
+								viewBox="0 0 24 24"
+								class="inline-block h-5 w-5 stroke-current"
+							>
+								<path
+									stroke-linecap="round"
+									stroke-linejoin="round"
+									stroke-width="2"
+									d="M4 6h16M4 12h16M4 18h16"
+								></path>
+							</svg>
+						</label>
+					</div>
+					<div class="drawer-side z-20">
+						<label for="menu-drawer" aria-label="close sidebar" class="drawer-overlay"></label>
+						<ul class="menu bg-base-300 min-h-full min-w-64 p-4 gap-2">
+							<li><a href="/widget" class={ "btn btn-neutral" + logic.StringIfElse(" active", "", props.path == "/widget") }>Widget</a></li>
+							<li><a href="/login" hx-boost="false" class={ "btn btn-primary" + logic.StringIfElse(" active", "", props.path == "/login") }>Login</a></li>
+						</ul>
+					</div>
+				</div>
 			</ul>
 		</div>
 	</div>
diff --git a/cmd/frontend/components/navbar_templ.go b/cmd/frontend/components/navbar_templ.go
index b0dae156..1559bcf8 100644
--- a/cmd/frontend/components/navbar_templ.go
+++ b/cmd/frontend/components/navbar_templ.go
@@ -119,7 +119,51 @@ func navbar(props navbarProps) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\">Login</a></li></ul><ul class=\"navbar-end menu menu-horizontal px-1 gap-1 md:hidden\"><button class=\"btn btn-square btn-ghost\"><svg xmlns=\"http://www.w3.org/2000/svg\" fill=\"none\" viewBox=\"0 0 24 24\" class=\"inline-block h-5 w-5 stroke-current\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M4 6h16M4 12h16M4 18h16\"></path></svg></button></ul></div></div>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\">Login</a></li></ul><ul class=\"navbar-end menu menu-horizontal px-1 gap-1 md:hidden\"><div class=\"drawer drawer-end\"><input id=\"menu-drawer\" type=\"checkbox\" class=\"drawer-toggle\"><div class=\"drawer-content flex justify-end items-center\"><label for=\"menu-drawer\" class=\"btn drawer-button\"><svg xmlns=\"http://www.w3.org/2000/svg\" fill=\"none\" viewBox=\"0 0 24 24\" class=\"inline-block h-5 w-5 stroke-current\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M4 6h16M4 12h16M4 18h16\"></path></svg></label></div><div class=\"drawer-side z-20\"><label for=\"menu-drawer\" aria-label=\"close sidebar\" class=\"drawer-overlay\"></label><ul class=\"menu bg-base-300 min-h-full min-w-64 p-4 gap-2\"><li>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var6 = []any{"btn btn-neutral" + logic.StringIfElse(" active", "", props.path == "/widget")}
+		templ_7745c5c3_Err = templ.RenderCSSItems(ctx, templ_7745c5c3_Buffer, templ_7745c5c3_Var6...)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<a href=\"/widget\" class=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var7 string
+		templ_7745c5c3_Var7, templ_7745c5c3_Err = templ.JoinStringErrs(templ.CSSClasses(templ_7745c5c3_Var6).String())
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/navbar.templ`, Line: 1, Col: 0}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var7))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\">Widget</a></li><li>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var8 = []any{"btn btn-primary" + logic.StringIfElse(" active", "", props.path == "/login")}
+		templ_7745c5c3_Err = templ.RenderCSSItems(ctx, templ_7745c5c3_Buffer, templ_7745c5c3_Var8...)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<a href=\"/login\" hx-boost=\"false\" class=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var9 string
+		templ_7745c5c3_Var9, templ_7745c5c3_Err = templ.JoinStringErrs(templ.CSSClasses(templ_7745c5c3_Var8).String())
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/navbar.templ`, Line: 1, Col: 0}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var9))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\">Login</a></li></ul></div></div></ul></div></div>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -140,13 +184,13 @@ func navMenuLink(label, href, currentPath string) templ.Component {
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
-		templ_7745c5c3_Var6 := templ.GetChildren(ctx)
-		if templ_7745c5c3_Var6 == nil {
-			templ_7745c5c3_Var6 = templ.NopComponent
+		templ_7745c5c3_Var10 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var10 == nil {
+			templ_7745c5c3_Var10 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		var templ_7745c5c3_Var7 = []any{navLinkClass(href, currentPath)}
-		templ_7745c5c3_Err = templ.RenderCSSItems(ctx, templ_7745c5c3_Buffer, templ_7745c5c3_Var7...)
+		var templ_7745c5c3_Var11 = []any{navLinkClass(href, currentPath)}
+		templ_7745c5c3_Err = templ.RenderCSSItems(ctx, templ_7745c5c3_Buffer, templ_7745c5c3_Var11...)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -154,8 +198,8 @@ func navMenuLink(label, href, currentPath string) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var8 templ.SafeURL = templ.URL(href)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(string(templ_7745c5c3_Var8)))
+		var templ_7745c5c3_Var12 templ.SafeURL = templ.URL(href)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(string(templ_7745c5c3_Var12)))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -163,12 +207,12 @@ func navMenuLink(label, href, currentPath string) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var9 string
-		templ_7745c5c3_Var9, templ_7745c5c3_Err = templ.JoinStringErrs(templ.CSSClasses(templ_7745c5c3_Var7).String())
+		var templ_7745c5c3_Var13 string
+		templ_7745c5c3_Var13, templ_7745c5c3_Err = templ.JoinStringErrs(templ.CSSClasses(templ_7745c5c3_Var11).String())
 		if templ_7745c5c3_Err != nil {
 			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/navbar.templ`, Line: 1, Col: 0}
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var9))
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var13))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -176,12 +220,12 @@ func navMenuLink(label, href, currentPath string) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var10 string
-		templ_7745c5c3_Var10, templ_7745c5c3_Err = templ.JoinStringErrs(label)
+		var templ_7745c5c3_Var14 string
+		templ_7745c5c3_Var14, templ_7745c5c3_Err = templ.JoinStringErrs(label)
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/navbar.templ`, Line: 72, Col: 78}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/navbar.templ`, Line: 84, Col: 78}
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var10))
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var14))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -219,9 +263,9 @@ func navProgressAnimated(...templ.Component) templ.Component {
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
-		templ_7745c5c3_Var11 := templ.GetChildren(ctx)
-		if templ_7745c5c3_Var11 == nil {
-			templ_7745c5c3_Var11 = templ.NopComponent
+		templ_7745c5c3_Var15 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var15 == nil {
+			templ_7745c5c3_Var15 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"w-full h-fit fixed top-0 rounded-b-box overflow-hidden\"><div id=\"nav-progress\" class=\"invisible h-1 transition-all bg-primary rounded-r-full duration-[50ms] ease-in\" style=\"width: 0%\"></div></div>")
diff --git a/cmd/frontend/routes/index.templ b/cmd/frontend/routes/index.templ
index 652a8782..514d507e 100644
--- a/cmd/frontend/routes/index.templ
+++ b/cmd/frontend/routes/index.templ
@@ -12,12 +12,12 @@ var Index handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Compo
 templ index() {
 	<div class="flex flex-col justify-center" id="landing">
 		<div class="flex flex-row flex-wrap">
+			@card(cardImage("/assets/promo-invite.jpg"), cardActionButton("Add Aftermath on Discord", "/invite")) {
+				<p>Add Aftermath to your favorite server for an easier time tracking sessions!</p>
+			}
 			@card(cardImage("/assets/promo-join.jpg"), cardActionButton("Join Aftermath Official", "/join")) {
 				<p>Aftermath is making a comeback! We've revamped everything to be faster and more beautiful. Join our community server for the latest features and updates.</p>
 			}
-			@card(cardImage("/assets/promo-invite.jpg"), cardActionButton("Add Aftermath on Discord", "/invite")) {
-				<p>The new bot is here! Add it to your server for an easier time tracking sessions. It's that simple – give Aftermath a try on your favorite server!</p>
-			}
 		</div>
 	</div>
 }
diff --git a/cmd/frontend/routes/index_templ.go b/cmd/frontend/routes/index_templ.go
index 83153c9e..c671d99a 100644
--- a/cmd/frontend/routes/index_templ.go
+++ b/cmd/frontend/routes/index_templ.go
@@ -51,13 +51,13 @@ func index() templ.Component {
 				}()
 			}
 			ctx = templ.InitializeContext(ctx)
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<p>Aftermath is making a comeback! We've revamped everything to be faster and more beautiful. Join our community server for the latest features and updates.</p>")
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<p>Add Aftermath to your favorite server for an easier time tracking sessions!</p>")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			return templ_7745c5c3_Err
 		})
-		templ_7745c5c3_Err = card(cardImage("/assets/promo-join.jpg"), cardActionButton("Join Aftermath Official", "/join")).Render(templ.WithChildren(ctx, templ_7745c5c3_Var2), templ_7745c5c3_Buffer)
+		templ_7745c5c3_Err = card(cardImage("/assets/promo-invite.jpg"), cardActionButton("Add Aftermath on Discord", "/invite")).Render(templ.WithChildren(ctx, templ_7745c5c3_Var2), templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -73,13 +73,13 @@ func index() templ.Component {
 				}()
 			}
 			ctx = templ.InitializeContext(ctx)
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<p>The new bot is here! Add it to your server for an easier time tracking sessions. It's that simple – give Aftermath a try on your favorite server!</p>")
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<p>Aftermath is making a comeback! We've revamped everything to be faster and more beautiful. Join our community server for the latest features and updates.</p>")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			return templ_7745c5c3_Err
 		})
-		templ_7745c5c3_Err = card(cardImage("/assets/promo-invite.jpg"), cardActionButton("Add Aftermath on Discord", "/invite")).Render(templ.WithChildren(ctx, templ_7745c5c3_Var3), templ_7745c5c3_Buffer)
+		templ_7745c5c3_Err = card(cardImage("/assets/promo-join.jpg"), cardActionButton("Join Aftermath Official", "/join")).Render(templ.WithChildren(ctx, templ_7745c5c3_Var3), templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
diff --git a/cmd/frontend/routes/widget/index.templ b/cmd/frontend/routes/widget/index.templ
index 4d5bcb63..8a4984d1 100644
--- a/cmd/frontend/routes/widget/index.templ
+++ b/cmd/frontend/routes/widget/index.templ
@@ -42,7 +42,7 @@ templ widgetHome(widget templ.Component, or, ou bool, vl int) {
 			</div>
 			@cwidget.Settings(handlePreviewOnHome(), or, ou, vl)
 			<div class="flex flex-row flex-wrap gap-2">
-				<select id="player-search-realm" class="select select-bordered" onchange={ onRealmSelect() }>
+				<select id="player-search-realm" class="select select-bordered grow" onchange={ onRealmSelect() }>
 					<option disabled selected class="text-center">Pick a Server</option>
 					<option value="NA">North America</option>
 					<option value="EU">Europe</option>
diff --git a/cmd/frontend/routes/widget/index_templ.go b/cmd/frontend/routes/widget/index_templ.go
index a544c53d..1b7b4a8b 100644
--- a/cmd/frontend/routes/widget/index_templ.go
+++ b/cmd/frontend/routes/widget/index_templ.go
@@ -71,7 +71,7 @@ func widgetHome(widget templ.Component, or, ou bool, vl int) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<select id=\"player-search-realm\" class=\"select select-bordered\" onchange=\"")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<select id=\"player-search-realm\" class=\"select select-bordered grow\" onchange=\"")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}

From b46a38d9743cb0f91fd51d2bd7c50df5fe01debd Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 5 Jul 2024 15:26:26 -0400
Subject: [PATCH 273/341] fixed overflows

---
 cmd/frontend/components/obs.templ         |  4 ++--
 cmd/frontend/components/obs_templ.go      |  4 ++--
 cmd/frontend/handler/context.go           | 10 ++++++++--
 cmd/frontend/routes/widget/index.templ    | 12 ++++++------
 cmd/frontend/routes/widget/index_templ.go |  8 ++++----
 5 files changed, 22 insertions(+), 16 deletions(-)

diff --git a/cmd/frontend/components/obs.templ b/cmd/frontend/components/obs.templ
index 35bc4c8b..2d523773 100644
--- a/cmd/frontend/components/obs.templ
+++ b/cmd/frontend/components/obs.templ
@@ -1,7 +1,7 @@
 package components
 
 templ OBSMockup(backgroundURL string) {
-	<div class="mockup-browser bg-base-300 rounded-xl overflow-hidden w-full h-full">
+	<div class="mockup-browser bg-base-300 rounded-xl overflow-hidden w-full">
 		<div class="mockup-browser-toolbar">
 			<div class="w-full text-center mr-14">OBS Studio</div>
 		</div>
@@ -13,7 +13,7 @@ templ OBSMockup(backgroundURL string) {
 				} else {
 					<img src={ backgroundURL } class="object-cover absolute laft-0 top-0 z-0 w-full h-full"/>
 				}
-				<div class="relative z-10 p-2 flex items-center justify-center h-full">
+				<div class="relative z-10 flex items-center justify-center h-full">
 					{ children... }
 				</div>
 			</div>
diff --git a/cmd/frontend/components/obs_templ.go b/cmd/frontend/components/obs_templ.go
index b47aab36..67f8f5fe 100644
--- a/cmd/frontend/components/obs_templ.go
+++ b/cmd/frontend/components/obs_templ.go
@@ -26,7 +26,7 @@ func OBSMockup(backgroundURL string) templ.Component {
 			templ_7745c5c3_Var1 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"mockup-browser bg-base-300 rounded-xl overflow-hidden w-full h-full\"><div class=\"mockup-browser-toolbar\"><div class=\"w-full text-center mr-14\">OBS Studio</div></div><div class=\"flex flex-col p-4 pt-0 gap-2\"><div class=\"grow relative rounded-md overflow-hidden\">")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"mockup-browser bg-base-300 rounded-xl overflow-hidden w-full\"><div class=\"mockup-browser-toolbar\"><div class=\"w-full text-center mr-14\">OBS Studio</div></div><div class=\"flex flex-col p-4 pt-0 gap-2\"><div class=\"grow relative rounded-md overflow-hidden\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -54,7 +54,7 @@ func OBSMockup(backgroundURL string) templ.Component {
 				return templ_7745c5c3_Err
 			}
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"relative z-10 p-2 flex items-center justify-center h-full\">")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"relative z-10 flex items-center justify-center h-full\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
diff --git a/cmd/frontend/handler/context.go b/cmd/frontend/handler/context.go
index e8d02055..0ba5f763 100644
--- a/cmd/frontend/handler/context.go
+++ b/cmd/frontend/handler/context.go
@@ -149,6 +149,9 @@ func (partial Partial) Serve(ctx *Context) error {
 	if err != nil {
 		return ctx.Error(err)
 	}
+	if content == nil {
+		return nil
+	}
 
 	err = content.Render(ctx.Context, ctx.w)
 	if err != nil {
@@ -169,12 +172,15 @@ func (page Page) Serve(ctx *Context) error {
 		return body.Render(ctx.Context, ctx.w)
 	}
 
-	content, err := layout(ctx, body)
+	withLayout, err := layout(ctx, body)
 	if err != nil {
 		return ctx.Error(err, "failed to render the layout")
 	}
+	if withLayout == nil {
+		return nil
+	}
 
-	err = content.Render(ctx.Context, ctx.w)
+	err = withLayout.Render(ctx.Context, ctx.w)
 	if err != nil {
 		return ctx.Error(err, "failed to render content")
 	}
diff --git a/cmd/frontend/routes/widget/index.templ b/cmd/frontend/routes/widget/index.templ
index 8a4984d1..8ac29699 100644
--- a/cmd/frontend/routes/widget/index.templ
+++ b/cmd/frontend/routes/widget/index.templ
@@ -56,14 +56,14 @@ templ widgetHome(widget templ.Component, or, ou bool, vl int) {
 				</div>
 			</div>
 		</div>
-		<div class="flex items-center justify-center grow">
-			<div class="max-w-4xl w-full">
-				@components.OBSMockup("/assets/widget-background.jpg") {
-					<div class="w-max p-8 min-w-[500px] min-h-[100vh]" style="zoom: 0.5;">
+		<div class="flex flex-col items-center justify-center grow overflow-auto">
+			@components.OBSMockup("/assets/widget-background.jpg") {
+				<div class="h-96 w-full overflow-auto p-2 relative">
+					<div class="w-max mx-auto h-1/2">
 						@widget
 					</div>
-				}
-			</div>
+				</div>
+			}
 		</div>
 	</div>
 	@logic.EmbedMinifiedScript(searchEventHandler(publicWgAppID), publicWgAppID)
diff --git a/cmd/frontend/routes/widget/index_templ.go b/cmd/frontend/routes/widget/index_templ.go
index 1b7b4a8b..7a3e9682 100644
--- a/cmd/frontend/routes/widget/index_templ.go
+++ b/cmd/frontend/routes/widget/index_templ.go
@@ -97,7 +97,7 @@ func widgetHome(widget templ.Component, or, ou bool, vl int) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><ul hx-boost=\"true\" id=\"player-search-results\" tabindex=\"0\" class=\"dropdown-content z-[1] menu p-2 shadow bg-base-300 rounded-t-box flex-nowrap overflow-auto w-full\"><span class=\"text-xs text-center cursor-default\">Start typing to search</span></ul></div></div></div><div class=\"flex items-center justify-center grow\"><div class=\"max-w-4xl w-full\">")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><ul hx-boost=\"true\" id=\"player-search-results\" tabindex=\"0\" class=\"dropdown-content z-[1] menu p-2 shadow bg-base-300 rounded-t-box flex-nowrap overflow-auto w-full\"><span class=\"text-xs text-center cursor-default\">Start typing to search</span></ul></div></div></div><div class=\"flex flex-col items-center justify-center grow overflow-auto\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -113,7 +113,7 @@ func widgetHome(widget templ.Component, or, ou bool, vl int) templ.Component {
 				}()
 			}
 			ctx = templ.InitializeContext(ctx)
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"w-max p-8 min-w-[500px] min-h-[100vh]\" style=\"zoom: 0.5;\">")
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"h-96 w-full overflow-auto p-2 relative\"><div class=\"w-max mx-auto h-1/2\">")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
@@ -121,7 +121,7 @@ func widgetHome(widget templ.Component, or, ou bool, vl int) templ.Component {
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div>")
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></div>")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
@@ -131,7 +131,7 @@ func widgetHome(widget templ.Component, or, ou bool, vl int) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></div></div>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></div>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}

From dc693a1bc92bc0589184e14421a425045f025b2d Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 5 Jul 2024 15:53:22 -0400
Subject: [PATCH 274/341] tweaking overflow/height

---
 cmd/frontend/routes/widget/index.templ      |  4 ++--
 cmd/frontend/routes/widget/index_templ.go   |  2 +-
 cmd/frontend/routes/widget/preview.templ    | 12 ++++++------
 cmd/frontend/routes/widget/preview_templ.go |  8 ++++----
 4 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/cmd/frontend/routes/widget/index.templ b/cmd/frontend/routes/widget/index.templ
index 8ac29699..51745064 100644
--- a/cmd/frontend/routes/widget/index.templ
+++ b/cmd/frontend/routes/widget/index.templ
@@ -58,8 +58,8 @@ templ widgetHome(widget templ.Component, or, ou bool, vl int) {
 		</div>
 		<div class="flex flex-col items-center justify-center grow overflow-auto">
 			@components.OBSMockup("/assets/widget-background.jpg") {
-				<div class="h-96 w-full overflow-auto p-2 relative">
-					<div class="w-max mx-auto h-1/2">
+				<div class="min-h-96 w-full overflow-auto p-2 relative">
+					<div class="min-w-[400px] w-max mx-auto h-1/2">
 						@widget
 					</div>
 				</div>
diff --git a/cmd/frontend/routes/widget/index_templ.go b/cmd/frontend/routes/widget/index_templ.go
index 7a3e9682..4cb8c780 100644
--- a/cmd/frontend/routes/widget/index_templ.go
+++ b/cmd/frontend/routes/widget/index_templ.go
@@ -113,7 +113,7 @@ func widgetHome(widget templ.Component, or, ou bool, vl int) templ.Component {
 				}()
 			}
 			ctx = templ.InitializeContext(ctx)
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"h-96 w-full overflow-auto p-2 relative\"><div class=\"w-max mx-auto h-1/2\">")
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"min-h-96 w-full overflow-auto p-2 relative\"><div class=\"min-w-[400px] w-max mx-auto h-1/2\">")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
diff --git a/cmd/frontend/routes/widget/preview.templ b/cmd/frontend/routes/widget/preview.templ
index 382e2d26..e3e16b08 100644
--- a/cmd/frontend/routes/widget/preview.templ
+++ b/cmd/frontend/routes/widget/preview.templ
@@ -42,14 +42,14 @@ templ widgetPreview(accountID string, widget templ.Component, or, ou bool, vl in
 			@cwidget.Settings(handlePreview(accountID), or, ou, vl)
 			<button type="button" id="copy-widget-link" class="btn btn-primary w-full" onclick={ copyButtonAction() }>Copy Link</button>
 		</div>
-		<div class="flex items-center justify-center grow">
-			<div class="max-w-4xl w-full">
-				@components.OBSMockup("/assets/widget-background.jpg") {
-					<div class="w-max p-8 min-w-[500px] min-h-[100vh]" style="zoom: 0.5;">
+		<div class="flex flex-col items-center justify-center grow overflow-auto">
+			@components.OBSMockup("/assets/widget-background.jpg") {
+				<div class="min-h-96 w-full overflow-auto p-2 relative">
+					<div class="min-w-[400px] w-max mx-auto h-1/2">
 						@widget
 					</div>
-				}
-			</div>
+				</div>
+			}
 		</div>
 	</div>
 }
diff --git a/cmd/frontend/routes/widget/preview_templ.go b/cmd/frontend/routes/widget/preview_templ.go
index 7bebfffb..4194d4c0 100644
--- a/cmd/frontend/routes/widget/preview_templ.go
+++ b/cmd/frontend/routes/widget/preview_templ.go
@@ -75,7 +75,7 @@ func widgetPreview(accountID string, widget templ.Component, or, ou bool, vl int
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\">Copy Link</button></div><div class=\"flex items-center justify-center grow\"><div class=\"max-w-4xl w-full\">")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\">Copy Link</button></div><div class=\"flex flex-col items-center justify-center grow overflow-auto\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -91,7 +91,7 @@ func widgetPreview(accountID string, widget templ.Component, or, ou bool, vl int
 				}()
 			}
 			ctx = templ.InitializeContext(ctx)
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"w-max p-8 min-w-[500px] min-h-[100vh]\" style=\"zoom: 0.5;\">")
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"min-h-96 w-full overflow-auto p-2 relative\"><div class=\"min-w-[400px] w-max mx-auto h-1/2\">")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
@@ -99,7 +99,7 @@ func widgetPreview(accountID string, widget templ.Component, or, ou bool, vl int
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div>")
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></div>")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
@@ -109,7 +109,7 @@ func widgetPreview(accountID string, widget templ.Component, or, ou bool, vl int
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></div></div>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></div>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}

From 9ab39312ede1137d9d6e8440d0a4cbfb8408d400 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 5 Jul 2024 15:58:33 -0400
Subject: [PATCH 275/341] added missing search string

---
 cmd/frontend/routes/widget/index.templ    |  2 +-
 cmd/frontend/routes/widget/index_templ.go | 10 +++++-----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/cmd/frontend/routes/widget/index.templ b/cmd/frontend/routes/widget/index.templ
index 51745064..a462acec 100644
--- a/cmd/frontend/routes/widget/index.templ
+++ b/cmd/frontend/routes/widget/index.templ
@@ -164,7 +164,7 @@ script searchEventHandler(appId string) {
 					const elements = []
 					for (const account of data.data || []) {
 						if (!account.account_id || !account.nickname) continue;
-						elements.push(`<li><a onclick="window.setResultsLoading();htmx.trigger('body','htmx:beforeSend');" href="/widget/${account.account_id}">${account.nickname}</a></li>`);
+						elements.push(`<li><a onclick="window.setResultsLoading();htmx.trigger('body','htmx:beforeSend');" href="/widget/${account.account_id}${window.location.search}">${account.nickname}</a></li>`);
 					}
 					if (elements.length == 0) {
 						results.innerHTML = '<span class="text-xs text-center cursor-default">No players found</span>';
diff --git a/cmd/frontend/routes/widget/index_templ.go b/cmd/frontend/routes/widget/index_templ.go
index 4cb8c780..812b5bab 100644
--- a/cmd/frontend/routes/widget/index_templ.go
+++ b/cmd/frontend/routes/widget/index_templ.go
@@ -202,8 +202,8 @@ func onNicknameInput() templ.ComponentScript {
 
 func searchEventHandler(appId string) templ.ComponentScript {
 	return templ.ComponentScript{
-		Name: `__templ_searchEventHandler_0220`,
-		Function: `function __templ_searchEventHandler_0220(appId){const results = document.getElementById("player-search-results");
+		Name: `__templ_searchEventHandler_0d98`,
+		Function: `function __templ_searchEventHandler_0d98(appId){const results = document.getElementById("player-search-results");
 	const nickname = document.getElementById("player-search-nickname");
 
 	const setResultsLoading = () => {
@@ -252,7 +252,7 @@ func searchEventHandler(appId string) templ.ComponentScript {
 					const elements = []
 					for (const account of data.data || []) {
 						if (!account.account_id || !account.nickname) continue;
-						elements.push(` + "`" + `<li><a onclick="window.setResultsLoading();htmx.trigger('body','htmx:beforeSend');" href="/widget/${account.account_id}">${account.nickname}</a></li>` + "`" + `);
+						elements.push(` + "`" + `<li><a onclick="window.setResultsLoading();htmx.trigger('body','htmx:beforeSend');" href="/widget/${account.account_id}${window.location.search}">${account.nickname}</a></li>` + "`" + `);
 					}
 					if (elements.length == 0) {
 						results.innerHTML = '<span class="text-xs text-center cursor-default">No players found</span>';
@@ -271,8 +271,8 @@ func searchEventHandler(appId string) templ.ComponentScript {
 		false,
 	);
 }`,
-		Call:       templ.SafeScript(`__templ_searchEventHandler_0220`, appId),
-		CallInline: templ.SafeScriptInline(`__templ_searchEventHandler_0220`, appId),
+		Call:       templ.SafeScript(`__templ_searchEventHandler_0d98`, appId),
+		CallInline: templ.SafeScriptInline(`__templ_searchEventHandler_0d98`, appId),
 	}
 }
 

From 7f61bc8b465104825e1f7ec374f410baf54d91b5 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 5 Jul 2024 16:03:46 -0400
Subject: [PATCH 276/341] added auth state checks

---
 cmd/frontend/components/navbar.templ    |  17 +-
 cmd/frontend/components/navbar_templ.go | 199 ++++++++++++++++--------
 2 files changed, 148 insertions(+), 68 deletions(-)

diff --git a/cmd/frontend/components/navbar.templ b/cmd/frontend/components/navbar.templ
index a56cc678..26dadaeb 100644
--- a/cmd/frontend/components/navbar.templ
+++ b/cmd/frontend/components/navbar.templ
@@ -20,8 +20,7 @@ var Navbar handler.Partial = func(ctx *handler.Context) (templ.Component, error)
 
 	user, err := ctx.SessionUser()
 	if err == nil {
-		// props.authenticated = user.ID != ""
-		_ = user
+		props.authenticated = user.ID != ""
 	}
 
 	return navbar(props), nil
@@ -30,7 +29,7 @@ var Navbar handler.Partial = func(ctx *handler.Context) (templ.Component, error)
 templ navbar(props navbarProps) {
 	@navProgressAnimated()
 	<div class="no-animation" hx-boost="true">
-		<div class="navbar bg-base-100 gap-1">
+		<div class="navbar bg-base-100 gap-1 h-6">
 			<div class="navbar-start gap-1">
 				<a href="/" class="p-2 aspect-square">
 					@Logo("32")
@@ -45,7 +44,11 @@ templ navbar(props navbarProps) {
 			</div>
 			<ul class="navbar-end menu menu-horizontal px-1 gap-1 hidden md:flex">
 				<li><a href="/widget" class={ logic.StringIfElse("active", "", props.path == "/widget") }>Widget</a></li>
-				<li><a href="/login" hx-boost="false" class={ logic.StringIfElse("btn active", "btn", props.path == "/login") }>Login</a></li>
+				if !props.authenticated {
+					<li><a href="/login" hx-boost="false" class={ logic.StringIfElse("btn active", "btn", props.path == "/login") }>Login</a></li>
+				} else {
+					<li><a href="/app" class={ logic.StringIfElse("btn active", "btn", props.path == "/app") }>Profile</a></li>
+				}
 			</ul>
 			<ul class="navbar-end menu menu-horizontal px-1 gap-1 md:hidden">
 				<div class="drawer drawer-end">
@@ -71,7 +74,11 @@ templ navbar(props navbarProps) {
 						<label for="menu-drawer" aria-label="close sidebar" class="drawer-overlay"></label>
 						<ul class="menu bg-base-300 min-h-full min-w-64 p-4 gap-2">
 							<li><a href="/widget" class={ "btn btn-neutral" + logic.StringIfElse(" active", "", props.path == "/widget") }>Widget</a></li>
-							<li><a href="/login" hx-boost="false" class={ "btn btn-primary" + logic.StringIfElse(" active", "", props.path == "/login") }>Login</a></li>
+							if !props.authenticated {
+								<li><a href="/login" hx-boost="false" onclick="htmx.trigger('body','htmx:beforeSend');" class={ "btn btn-primary" + logic.StringIfElse(" active", "", props.path == "/login") }>Login</a></li>
+							} else {
+								<li><a href="/app" class={ logic.StringIfElse("btn active", "btn", props.path == "/app") }>Profile</a></li>
+							}
 						</ul>
 					</div>
 				</div>
diff --git a/cmd/frontend/components/navbar_templ.go b/cmd/frontend/components/navbar_templ.go
index 1559bcf8..d71a7792 100644
--- a/cmd/frontend/components/navbar_templ.go
+++ b/cmd/frontend/components/navbar_templ.go
@@ -28,8 +28,7 @@ var Navbar handler.Partial = func(ctx *handler.Context) (templ.Component, error)
 
 	user, err := ctx.SessionUser()
 	if err == nil {
-		// props.authenticated = user.ID != ""
-		_ = user
+		props.authenticated = user.ID != ""
 	}
 
 	return navbar(props), nil
@@ -57,7 +56,7 @@ func navbar(props navbarProps) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"no-animation\" hx-boost=\"true\"><div class=\"navbar bg-base-100 gap-1\"><div class=\"navbar-start gap-1\"><a href=\"/\" class=\"p-2 aspect-square\">")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"no-animation\" hx-boost=\"true\"><div class=\"navbar bg-base-100 gap-1 h-6\"><div class=\"navbar-start gap-1\"><a href=\"/\" class=\"p-2 aspect-square\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -97,34 +96,71 @@ func navbar(props navbarProps) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\">Widget</a></li><li>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\">Widget</a></li>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var4 = []any{logic.StringIfElse("btn active", "btn", props.path == "/login")}
-		templ_7745c5c3_Err = templ.RenderCSSItems(ctx, templ_7745c5c3_Buffer, templ_7745c5c3_Var4...)
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<a href=\"/login\" hx-boost=\"false\" class=\"")
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		var templ_7745c5c3_Var5 string
-		templ_7745c5c3_Var5, templ_7745c5c3_Err = templ.JoinStringErrs(templ.CSSClasses(templ_7745c5c3_Var4).String())
-		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/navbar.templ`, Line: 1, Col: 0}
-		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var5))
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
+		if !props.authenticated {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<li>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			var templ_7745c5c3_Var4 = []any{logic.StringIfElse("btn active", "btn", props.path == "/login")}
+			templ_7745c5c3_Err = templ.RenderCSSItems(ctx, templ_7745c5c3_Buffer, templ_7745c5c3_Var4...)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<a href=\"/login\" hx-boost=\"false\" class=\"")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			var templ_7745c5c3_Var5 string
+			templ_7745c5c3_Var5, templ_7745c5c3_Err = templ.JoinStringErrs(templ.CSSClasses(templ_7745c5c3_Var4).String())
+			if templ_7745c5c3_Err != nil {
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/navbar.templ`, Line: 1, Col: 0}
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var5))
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\">Login</a></li>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		} else {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<li>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			var templ_7745c5c3_Var6 = []any{logic.StringIfElse("btn active", "btn", props.path == "/app")}
+			templ_7745c5c3_Err = templ.RenderCSSItems(ctx, templ_7745c5c3_Buffer, templ_7745c5c3_Var6...)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<a href=\"/app\" class=\"")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			var templ_7745c5c3_Var7 string
+			templ_7745c5c3_Var7, templ_7745c5c3_Err = templ.JoinStringErrs(templ.CSSClasses(templ_7745c5c3_Var6).String())
+			if templ_7745c5c3_Err != nil {
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/navbar.templ`, Line: 1, Col: 0}
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var7))
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\">Profile</a></li>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\">Login</a></li></ul><ul class=\"navbar-end menu menu-horizontal px-1 gap-1 md:hidden\"><div class=\"drawer drawer-end\"><input id=\"menu-drawer\" type=\"checkbox\" class=\"drawer-toggle\"><div class=\"drawer-content flex justify-end items-center\"><label for=\"menu-drawer\" class=\"btn drawer-button\"><svg xmlns=\"http://www.w3.org/2000/svg\" fill=\"none\" viewBox=\"0 0 24 24\" class=\"inline-block h-5 w-5 stroke-current\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M4 6h16M4 12h16M4 18h16\"></path></svg></label></div><div class=\"drawer-side z-20\"><label for=\"menu-drawer\" aria-label=\"close sidebar\" class=\"drawer-overlay\"></label><ul class=\"menu bg-base-300 min-h-full min-w-64 p-4 gap-2\"><li>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</ul><ul class=\"navbar-end menu menu-horizontal px-1 gap-1 md:hidden\"><div class=\"drawer drawer-end\"><input id=\"menu-drawer\" type=\"checkbox\" class=\"drawer-toggle\"><div class=\"drawer-content flex justify-end items-center\"><label for=\"menu-drawer\" class=\"btn drawer-button\"><svg xmlns=\"http://www.w3.org/2000/svg\" fill=\"none\" viewBox=\"0 0 24 24\" class=\"inline-block h-5 w-5 stroke-current\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M4 6h16M4 12h16M4 18h16\"></path></svg></label></div><div class=\"drawer-side z-20\"><label for=\"menu-drawer\" aria-label=\"close sidebar\" class=\"drawer-overlay\"></label><ul class=\"menu bg-base-300 min-h-full min-w-64 p-4 gap-2\"><li>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var6 = []any{"btn btn-neutral" + logic.StringIfElse(" active", "", props.path == "/widget")}
-		templ_7745c5c3_Err = templ.RenderCSSItems(ctx, templ_7745c5c3_Buffer, templ_7745c5c3_Var6...)
+		var templ_7745c5c3_Var8 = []any{"btn btn-neutral" + logic.StringIfElse(" active", "", props.path == "/widget")}
+		templ_7745c5c3_Err = templ.RenderCSSItems(ctx, templ_7745c5c3_Buffer, templ_7745c5c3_Var8...)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -132,38 +168,75 @@ func navbar(props navbarProps) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var7 string
-		templ_7745c5c3_Var7, templ_7745c5c3_Err = templ.JoinStringErrs(templ.CSSClasses(templ_7745c5c3_Var6).String())
+		var templ_7745c5c3_Var9 string
+		templ_7745c5c3_Var9, templ_7745c5c3_Err = templ.JoinStringErrs(templ.CSSClasses(templ_7745c5c3_Var8).String())
 		if templ_7745c5c3_Err != nil {
 			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/navbar.templ`, Line: 1, Col: 0}
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var7))
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\">Widget</a></li><li>")
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		var templ_7745c5c3_Var8 = []any{"btn btn-primary" + logic.StringIfElse(" active", "", props.path == "/login")}
-		templ_7745c5c3_Err = templ.RenderCSSItems(ctx, templ_7745c5c3_Buffer, templ_7745c5c3_Var8...)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var9))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<a href=\"/login\" hx-boost=\"false\" class=\"")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\">Widget</a></li>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var9 string
-		templ_7745c5c3_Var9, templ_7745c5c3_Err = templ.JoinStringErrs(templ.CSSClasses(templ_7745c5c3_Var8).String())
-		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/navbar.templ`, Line: 1, Col: 0}
-		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var9))
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
+		if !props.authenticated {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<li>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			var templ_7745c5c3_Var10 = []any{"btn btn-primary" + logic.StringIfElse(" active", "", props.path == "/login")}
+			templ_7745c5c3_Err = templ.RenderCSSItems(ctx, templ_7745c5c3_Buffer, templ_7745c5c3_Var10...)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<a href=\"/login\" hx-boost=\"false\" onclick=\"htmx.trigger(&#39;body&#39;,&#39;htmx:beforeSend&#39;);\" class=\"")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			var templ_7745c5c3_Var11 string
+			templ_7745c5c3_Var11, templ_7745c5c3_Err = templ.JoinStringErrs(templ.CSSClasses(templ_7745c5c3_Var10).String())
+			if templ_7745c5c3_Err != nil {
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/navbar.templ`, Line: 1, Col: 0}
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var11))
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\">Login</a></li>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		} else {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<li>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			var templ_7745c5c3_Var12 = []any{logic.StringIfElse("btn active", "btn", props.path == "/app")}
+			templ_7745c5c3_Err = templ.RenderCSSItems(ctx, templ_7745c5c3_Buffer, templ_7745c5c3_Var12...)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<a href=\"/app\" class=\"")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			var templ_7745c5c3_Var13 string
+			templ_7745c5c3_Var13, templ_7745c5c3_Err = templ.JoinStringErrs(templ.CSSClasses(templ_7745c5c3_Var12).String())
+			if templ_7745c5c3_Err != nil {
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/navbar.templ`, Line: 1, Col: 0}
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var13))
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\">Profile</a></li>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\">Login</a></li></ul></div></div></ul></div></div>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</ul></div></div></ul></div></div>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -184,13 +257,13 @@ func navMenuLink(label, href, currentPath string) templ.Component {
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
-		templ_7745c5c3_Var10 := templ.GetChildren(ctx)
-		if templ_7745c5c3_Var10 == nil {
-			templ_7745c5c3_Var10 = templ.NopComponent
+		templ_7745c5c3_Var14 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var14 == nil {
+			templ_7745c5c3_Var14 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		var templ_7745c5c3_Var11 = []any{navLinkClass(href, currentPath)}
-		templ_7745c5c3_Err = templ.RenderCSSItems(ctx, templ_7745c5c3_Buffer, templ_7745c5c3_Var11...)
+		var templ_7745c5c3_Var15 = []any{navLinkClass(href, currentPath)}
+		templ_7745c5c3_Err = templ.RenderCSSItems(ctx, templ_7745c5c3_Buffer, templ_7745c5c3_Var15...)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -198,8 +271,8 @@ func navMenuLink(label, href, currentPath string) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var12 templ.SafeURL = templ.URL(href)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(string(templ_7745c5c3_Var12)))
+		var templ_7745c5c3_Var16 templ.SafeURL = templ.URL(href)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(string(templ_7745c5c3_Var16)))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -207,12 +280,12 @@ func navMenuLink(label, href, currentPath string) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var13 string
-		templ_7745c5c3_Var13, templ_7745c5c3_Err = templ.JoinStringErrs(templ.CSSClasses(templ_7745c5c3_Var11).String())
+		var templ_7745c5c3_Var17 string
+		templ_7745c5c3_Var17, templ_7745c5c3_Err = templ.JoinStringErrs(templ.CSSClasses(templ_7745c5c3_Var15).String())
 		if templ_7745c5c3_Err != nil {
 			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/navbar.templ`, Line: 1, Col: 0}
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var13))
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var17))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -220,12 +293,12 @@ func navMenuLink(label, href, currentPath string) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var14 string
-		templ_7745c5c3_Var14, templ_7745c5c3_Err = templ.JoinStringErrs(label)
+		var templ_7745c5c3_Var18 string
+		templ_7745c5c3_Var18, templ_7745c5c3_Err = templ.JoinStringErrs(label)
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/navbar.templ`, Line: 84, Col: 78}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/navbar.templ`, Line: 91, Col: 78}
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var14))
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var18))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -263,9 +336,9 @@ func navProgressAnimated(...templ.Component) templ.Component {
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
-		templ_7745c5c3_Var15 := templ.GetChildren(ctx)
-		if templ_7745c5c3_Var15 == nil {
-			templ_7745c5c3_Var15 = templ.NopComponent
+		templ_7745c5c3_Var19 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var19 == nil {
+			templ_7745c5c3_Var19 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"w-full h-fit fixed top-0 rounded-b-box overflow-hidden\"><div id=\"nav-progress\" class=\"invisible h-1 transition-all bg-primary rounded-r-full duration-[50ms] ease-in\" style=\"width: 0%\"></div></div>")

From ca9cdf11e212a7a51dfdcb21c14e0a4cef943929 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 5 Jul 2024 16:08:44 -0400
Subject: [PATCH 277/341] better path checks

---
 cmd/frontend/components/navbar.templ    | 4 ++--
 cmd/frontend/components/navbar_templ.go | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/cmd/frontend/components/navbar.templ b/cmd/frontend/components/navbar.templ
index 26dadaeb..f437f5f2 100644
--- a/cmd/frontend/components/navbar.templ
+++ b/cmd/frontend/components/navbar.templ
@@ -36,14 +36,14 @@ templ navbar(props navbarProps) {
 				</a>
 			</div>
 			<div class="navbar-center">
-				if props.path == "/" {
+				if !strings.HasPrefix(props.path, "/widget") {
 					<div class="form-control">
 						<input type="text" placeholder="Search Players" class="input input-bordered w-48 md:w-auto placeholder:text-center" disabled/>
 					</div>
 				}
 			</div>
 			<ul class="navbar-end menu menu-horizontal px-1 gap-1 hidden md:flex">
-				<li><a href="/widget" class={ logic.StringIfElse("active", "", props.path == "/widget") }>Widget</a></li>
+				<li><a href="/widget" class={ logic.StringIfElse("active", "", strings.HasPrefix(props.path, "/widget")) }>Widget</a></li>
 				if !props.authenticated {
 					<li><a href="/login" hx-boost="false" class={ logic.StringIfElse("btn active", "btn", props.path == "/login") }>Login</a></li>
 				} else {
diff --git a/cmd/frontend/components/navbar_templ.go b/cmd/frontend/components/navbar_templ.go
index d71a7792..17e5f998 100644
--- a/cmd/frontend/components/navbar_templ.go
+++ b/cmd/frontend/components/navbar_templ.go
@@ -68,7 +68,7 @@ func navbar(props navbarProps) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		if props.path == "/" {
+		if !strings.HasPrefix(props.path, "/widget") {
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"form-control\"><input type=\"text\" placeholder=\"Search Players\" class=\"input input-bordered w-48 md:w-auto placeholder:text-center\" disabled></div>")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
@@ -78,7 +78,7 @@ func navbar(props navbarProps) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var2 = []any{logic.StringIfElse("active", "", props.path == "/widget")}
+		var templ_7745c5c3_Var2 = []any{logic.StringIfElse("active", "", strings.HasPrefix(props.path, "/widget"))}
 		templ_7745c5c3_Err = templ.RenderCSSItems(ctx, templ_7745c5c3_Buffer, templ_7745c5c3_Var2...)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err

From e99bdbddce0ae7950dbe752bb5d828cdbc2fdb7e Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 5 Jul 2024 20:37:38 -0400
Subject: [PATCH 278/341] account verification

---
 cmd/frontend/components/head.templ        |   1 +
 cmd/frontend/components/head_templ.go     |   9 +-
 cmd/frontend/handler/context.go           |  23 ++-
 cmd/frontend/handlers.go                  |   8 +
 cmd/frontend/logic/auth/wargaming.go      |  15 ++
 cmd/frontend/middleware/auth.go           |   2 +-
 cmd/frontend/routes/api/auth/wargaming.go | 107 +++++++++++++
 cmd/frontend/routes/app/index.templ       | 132 ++++++++++++++--
 cmd/frontend/routes/app/index_templ.go    | 183 +++++++++++++++++++++-
 cmd/frontend/routes/widget/index.templ    |   4 +-
 cmd/frontend/routes/widget/index_templ.go |  12 +-
 internal/database/auth.go                 |  20 ++-
 internal/database/client.go               |   2 +-
 internal/database/users.go                |  10 ++
 internal/external/wargaming/client.go     |   3 +
 tests/static_data.go                      |  10 +-
 tests/static_database.go                  |   4 +-
 17 files changed, 498 insertions(+), 47 deletions(-)
 create mode 100644 cmd/frontend/logic/auth/wargaming.go
 create mode 100644 cmd/frontend/routes/api/auth/wargaming.go

diff --git a/cmd/frontend/components/head.templ b/cmd/frontend/components/head.templ
index 8ecca509..caa5473b 100644
--- a/cmd/frontend/components/head.templ
+++ b/cmd/frontend/components/head.templ
@@ -21,6 +21,7 @@ script tailwindConfig() {
 	tailwind.config = {
 		theme: {
 			borderRadius: {
+				"none": "0px",
 				"sm": "10px",
 				"md": "15px",
 				"lg": "20px",
diff --git a/cmd/frontend/components/head_templ.go b/cmd/frontend/components/head_templ.go
index a78d7c78..2ea807a1 100644
--- a/cmd/frontend/components/head_templ.go
+++ b/cmd/frontend/components/head_templ.go
@@ -59,10 +59,11 @@ func Head() templ.Component {
 
 func tailwindConfig() templ.ComponentScript {
 	return templ.ComponentScript{
-		Name: `__templ_tailwindConfig_0472`,
-		Function: `function __templ_tailwindConfig_0472(){tailwind.config = {
+		Name: `__templ_tailwindConfig_bf3d`,
+		Function: `function __templ_tailwindConfig_bf3d(){tailwind.config = {
 		theme: {
 			borderRadius: {
+				"none": "0px",
 				"sm": "10px",
 				"md": "15px",
 				"lg": "20px",
@@ -72,7 +73,7 @@ func tailwindConfig() templ.ComponentScript {
 		}
 	}
 }`,
-		Call:       templ.SafeScript(`__templ_tailwindConfig_0472`),
-		CallInline: templ.SafeScriptInline(`__templ_tailwindConfig_0472`),
+		Call:       templ.SafeScript(`__templ_tailwindConfig_bf3d`),
+		CallInline: templ.SafeScriptInline(`__templ_tailwindConfig_bf3d`),
 	}
 }
diff --git a/cmd/frontend/handler/context.go b/cmd/frontend/handler/context.go
index 0ba5f763..c4db18ac 100644
--- a/cmd/frontend/handler/context.go
+++ b/cmd/frontend/handler/context.go
@@ -30,7 +30,8 @@ type Context struct {
 	core.Client
 	context.Context
 
-	user *models.User
+	user        *models.User
+	userOptions database.UserGetOptions
 
 	w http.ResponseWriter
 	r *http.Request
@@ -85,15 +86,20 @@ func (ctx *Context) Identifier() (string, error) {
 	return "", errors.New("failed to extract ip address")
 }
 
-func (ctx *Context) SessionUser() (*models.User, error) {
-	if ctx.user != nil {
-		return ctx.user, nil
-	}
+func (ctx *Context) SessionUser(o ...database.UserGetOption) (*models.User, error) {
+	var opts database.UserGetOptions = o
+
+	// if dev mode is on, we just grab a pre-defined user from the database, expecting it to exist
 	if devMode {
-		user, _ := ctx.Database().UserFromSession(ctx.Context, "dev-user")
+		user, _ := ctx.Database().UserFromSession(ctx.Context, "dev-user", opts...)
 		return &user, nil
 	}
 
+	// if the user already exists and options are equal, return cached user
+	if ctx.user != nil && ctx.userOptions.ToOptions() == opts.ToOptions() {
+		return ctx.user, nil
+	}
+
 	cookie, err := ctx.Cookie(auth.SessionCookieName)
 	if err != nil || cookie == nil {
 		return nil, ErrSessionNotFound
@@ -102,7 +108,7 @@ func (ctx *Context) SessionUser() (*models.User, error) {
 		return nil, ErrSessionNotFound
 	}
 
-	user, err := ctx.Database().UserFromSession(ctx.Context, cookie.Value)
+	user, err := ctx.Database().UserFromSession(ctx.Context, cookie.Value, opts...)
 	if err != nil {
 		if database.IsNotFound(err) {
 			return nil, ErrSessionNotFound
@@ -111,6 +117,7 @@ func (ctx *Context) SessionUser() (*models.User, error) {
 	}
 
 	ctx.user = &user
+	ctx.userOptions = opts
 	return ctx.user, nil
 }
 
@@ -141,7 +148,7 @@ func (ctx *Context) SetStatus(code int) {
 }
 
 func newContext(core core.Client, w http.ResponseWriter, r *http.Request) *Context {
-	return &Context{core, r.Context(), nil, w, r}
+	return &Context{w: w, r: r, Client: core, Context: r.Context()}
 }
 
 func (partial Partial) Serve(ctx *Context) error {
diff --git a/cmd/frontend/handlers.go b/cmd/frontend/handlers.go
index 503c1c71..21ed5c83 100644
--- a/cmd/frontend/handlers.go
+++ b/cmd/frontend/handlers.go
@@ -94,6 +94,14 @@ func Handlers(core core.Client) ([]server.Handler, error) {
 			Path: get("/api/auth/discord"),
 			Func: handler.Chain(core, auth.DiscordRedirect),
 		},
+		{
+			Path: get("/api/auth/wargaming/{realm}"),
+			Func: handler.Chain(core, auth.WargamingBegin),
+		},
+		{
+			Path: get("/api/auth/wargaming/redirect/{token}"),
+			Func: handler.Chain(core, auth.WargamingRedirect),
+		},
 		{
 			Path: get("/api/widget/mock"),
 			Func: handler.Chain(core, aWidget.MockWidget),
diff --git a/cmd/frontend/logic/auth/wargaming.go b/cmd/frontend/logic/auth/wargaming.go
new file mode 100644
index 00000000..a4eb77e7
--- /dev/null
+++ b/cmd/frontend/logic/auth/wargaming.go
@@ -0,0 +1,15 @@
+package auth
+
+import "os"
+
+var baseRedirectURL = os.Getenv("WG_AUTH_REDIRECT_URI")
+
+func init() {
+	if baseRedirectURL == "" {
+		panic("WG_AUTH_REDIRECT_URI missing")
+	}
+}
+
+func NewWargamingAuthRedirectURL(token string) string {
+	return baseRedirectURL + "/" + token
+}
diff --git a/cmd/frontend/middleware/auth.go b/cmd/frontend/middleware/auth.go
index 396a3c96..9e9e0505 100644
--- a/cmd/frontend/middleware/auth.go
+++ b/cmd/frontend/middleware/auth.go
@@ -16,6 +16,6 @@ var SessionCheck handler.Middleware = func(ctx *handler.Context, next func(ctx *
 
 	return func(ctx *handler.Context) error {
 		ctx.SetCookie(auth.NewSessionCookie("", time.Time{}))
-		return ctx.Redirect("/login", http.StatusTemporaryRedirect)
+		return ctx.Redirect("/login?from="+ctx.URL().Path, http.StatusTemporaryRedirect)
 	}
 }
diff --git a/cmd/frontend/routes/api/auth/wargaming.go b/cmd/frontend/routes/api/auth/wargaming.go
new file mode 100644
index 00000000..114d7d95
--- /dev/null
+++ b/cmd/frontend/routes/api/auth/wargaming.go
@@ -0,0 +1,107 @@
+package auth
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/cmd/frontend/logic/auth"
+	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/external/wargaming"
+	"github.com/cufee/aftermath/internal/logic"
+	"github.com/pkg/errors"
+	"github.com/rs/zerolog/log"
+)
+
+var WargamingRedirect handler.Endpoint = func(ctx *handler.Context) error {
+	accountID := ctx.Query("account_id")
+	if accountID == "" {
+		return ctx.Redirect("/error?message=invalid response received from wargaming", http.StatusTemporaryRedirect)
+	}
+	if ctx.Query("status") == "error" {
+		return ctx.Redirect("/error?message="+ctx.Query("message"), http.StatusTemporaryRedirect)
+	}
+
+	token := ctx.Path("token")
+	if token == "" {
+		return ctx.Redirect("/error?message=this verification link has expired", http.StatusTemporaryRedirect)
+	}
+
+	user, err := ctx.Database().UserFromSession(ctx.Context, token, database.WithConnections())
+	if err != nil {
+		return ctx.Redirect("/error?message=this verification link has expired", http.StatusTemporaryRedirect)
+	}
+
+	err = ctx.Database().SetSessionExpiresAt(ctx.Context, token, time.Time{})
+	if err != nil {
+		log.Err(err).Msg("failed to set session expiration")
+		return ctx.Redirect("/error?message=this verification link has expired", http.StatusTemporaryRedirect)
+	}
+
+	connections, _ := user.FilterConnections(models.ConnectionTypeWargaming, nil)
+	for _, conn := range connections {
+		if conn.ReferenceID == accountID {
+			conn.Metadata["default"] = true
+			conn.Metadata["verified"] = true
+			_, err := ctx.Database().UpdateConnection(ctx.Context, conn)
+			if err != nil {
+				return ctx.Error(err, "failed to update user connection")
+			}
+			return ctx.Redirect("/app#links", http.StatusTemporaryRedirect)
+		}
+	}
+
+	conn := models.UserConnection{
+		Type:        models.ConnectionTypeWargaming,
+		UserID:      user.ID,
+		ReferenceID: accountID,
+		Metadata:    map[string]any{"verified": true, "default": true},
+	}
+	_, err = ctx.Database().UpsertConnection(ctx.Context, conn)
+	if err != nil {
+		return ctx.Error(err, "failed to update user connection")
+	}
+	return ctx.Redirect("/app#links", http.StatusTemporaryRedirect)
+}
+
+var WargamingBegin handler.Endpoint = func(ctx *handler.Context) error {
+	user, err := ctx.SessionUser()
+	if err != nil {
+		return ctx.Redirect("/login", http.StatusTemporaryRedirect)
+	}
+
+	baseWgURL, err := authURLFromRealm(ctx.Path("realm"))
+	if err != nil {
+		return ctx.Redirect("/app", http.StatusTemporaryRedirect)
+	}
+
+	verifySessionID, err := logic.RandomString(32)
+	if err != nil {
+		return ctx.Redirect("/error?message=failed to start a new session", http.StatusTemporaryRedirect)
+	}
+
+	verifySession, err := ctx.Database().CreateSession(ctx.Context, verifySessionID, user.ID, time.Now().Add(time.Minute), map[string]string{"flow": "wargaming-redirect"})
+	if err != nil {
+		log.Err(err).Str("userId", user.ID).Msg("failed to create a new user session for wargaming auth flow")
+		return ctx.Redirect("/error?message=failed to start a new session", http.StatusTemporaryRedirect)
+	}
+
+	redirectURL := fmt.Sprintf("%s?application_id=%s&redirect_uri=%s", baseWgURL, wargaming.PublicAppID, auth.NewWargamingAuthRedirectURL(verifySession.ID))
+	return ctx.Redirect(redirectURL, http.StatusTemporaryRedirect)
+}
+
+func authURLFromRealm(realm string) (string, error) {
+	switch strings.ToUpper(realm) {
+	case "EU":
+		return "https://api.worldoftanks.eu/wot/auth/login/", nil
+	case "NA":
+		return "https://api.worldoftanks.com/wot/auth/login/", nil
+	case "AS":
+		return "https://api.worldoftanks.asia/wot/auth/login/", nil
+	default:
+		return "", errors.New("unknown realm")
+	}
+}
diff --git a/cmd/frontend/routes/app/index.templ b/cmd/frontend/routes/app/index.templ
index 558d5835..cc7511e4 100644
--- a/cmd/frontend/routes/app/index.templ
+++ b/cmd/frontend/routes/app/index.templ
@@ -1,32 +1,142 @@
 package app
 
 import (
+	"fmt"
 	"github.com/cufee/aftermath/cmd/frontend/handler"
 	"github.com/cufee/aftermath/cmd/frontend/layouts"
+	"github.com/cufee/aftermath/cmd/frontend/logic"
+	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
 	"net/http"
+	"time"
 )
 
+type connectionWithAccount struct {
+	models.UserConnection
+	Account models.Account
+}
+
 var Index handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
-	user, err := ctx.SessionUser()
+	user, err := ctx.SessionUser(database.WithConnections())
 	if err != nil {
 		return nil, nil, ctx.Redirect("/login", http.StatusTemporaryRedirect)
 	}
-	return layouts.Main, index(user), nil
+
+	var ids []string
+	var connections []connectionWithAccount
+	var accountToConnection = make(map[string]models.UserConnection)
+	accountConnection, _ := user.FilterConnections(models.ConnectionTypeWargaming, nil)
+	for _, conn := range accountConnection {
+		accountToConnection[conn.ReferenceID] = conn
+		ids = append(ids, conn.ReferenceID)
+	}
+	if len(ids) > 0 {
+		accounts, _ := ctx.Database().GetAccounts(ctx.Context, ids)
+		for _, acc := range accounts {
+			connections = append(connections, connectionWithAccount{
+				UserConnection: accountToConnection[acc.ID],
+				Account:        acc,
+			})
+		}
+	}
+
+	return layouts.Main, index(connections, 3), nil
 }
 
-templ index(user *models.User) {
+templ index(connections []connectionWithAccount, linkLimit int) {
 	<div class="flex flex-col items-center gap-4">
-		<div class="text-3xl font-bold">
-			🎉 You are logged in! 🎉
+		<div class="text-2xl font-bold">
+			Linked Accounts { fmt.Sprintf("%d/%d", len(connections),linkLimit) }
 		</div>
-		<div class="flex flex-col items-center">
-			<span class="text-xl">
-				But we did not add any features here just yet.
-			</span>
-			<span>
-				Here is your user id instead - { user.ID }
+		<div class="flex flex-row flex-wrap gap-2">
+			for _, connection:= range connections {
+				@connectionCard(connection)
+			}
+			if len(connections) < linkLimit {
+				<div class="grow dropdown dropdown-hover">
+					<button tabindex="0" class="verify-button verify-button-large no-animation btn h-full rounded-md w-full">Link a new account</button>
+					<ul hx-boost="false" tabindex="0" class="dropdown-content menu bg-base-100 rounded-box z-[1] p-2 shadow w-full gap-1">
+						<li>
+							<a class="verify-button bg-base-200 flex flex-row align-center justify-between gap-1" href="/api/auth/wargaming/na">
+								<span>North America</span>
+								<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="1.5" stroke="currentColor" class="size-3">
+									<path stroke-linecap="round" stroke-linejoin="round" d="M13.5 6H5.25A2.25 2.25 0 0 0 3 8.25v10.5A2.25 2.25 0 0 0 5.25 21h10.5A2.25 2.25 0 0 0 18 18.75V10.5m-10.5 6L21 3m0 0h-5.25M21 3v5.25"></path>
+								</svg>
+							</a>
+						</li>
+						<li>
+							<a class="verify-button bg-base-200 flex flex-row align-center justify-between gap-1" href="/api/auth/wargaming/eu">
+								<span>Europe</span>
+								<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="1.5" stroke="currentColor" class="size-3">
+									<path stroke-linecap="round" stroke-linejoin="round" d="M13.5 6H5.25A2.25 2.25 0 0 0 3 8.25v10.5A2.25 2.25 0 0 0 5.25 21h10.5A2.25 2.25 0 0 0 18 18.75V10.5m-10.5 6L21 3m0 0h-5.25M21 3v5.25"></path>
+								</svg>
+							</a>
+						</li>
+						<li>
+							<a class="verify-button bg-base-200 flex flex-row align-center justify-between gap-1" href="/api/auth/wargaming/as">
+								<span>Asia</span>
+								<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="1.5" stroke="currentColor" class="size-3">
+									<path stroke-linecap="round" stroke-linejoin="round" d="M13.5 6H5.25A2.25 2.25 0 0 0 3 8.25v10.5A2.25 2.25 0 0 0 5.25 21h10.5A2.25 2.25 0 0 0 18 18.75V10.5m-10.5 6L21 3m0 0h-5.25M21 3v5.25"></path>
+								</svg>
+							</a>
+						</li>
+					</ul>
+				</div>
+			}
+		</div>
+	</div>
+	@logic.EmbedMinifiedScript(verifyButtonExpiration(int(time.Minute*5)), int(time.Minute*5))
+}
+
+templ connectionCard(connection connectionWithAccount) {
+	<div class="rounded-md bg-base-300 flex flex-row grow overflow-hidden">
+		<div class="p-1 bg-base-200 flex justify-center items-center h-full aspect-square">
+			<span class="font-bold">
+				{ connection.Account.Realm }
 			</span>
 		</div>
+		<div class="grow p-3 pr-0 flex flex-row gap-2 items-center justify-between">
+			<div class="grow flex flex-row gap-2 items-center">
+				<div class="flex flex-row gap-1 items-center">
+					<div class="text-lg line-clamp-1 break-all overflow-hidden">
+						{ connection.Account.Nickname }
+					</div>
+					<button class={ logic.StringIfElse("text-yellow-500", "", connection.Metadata["default"] == true) } disabled?={ connection.Metadata["default"] == true }>
+						<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="1.5" stroke="currentColor" class="size-4">
+							<path stroke-linecap="round" stroke-linejoin="round" d="M11.48 3.499a.562.562 0 0 1 1.04 0l2.125 5.111a.563.563 0 0 0 .475.345l5.518.442c.499.04.701.663.321.988l-4.204 3.602a.563.563 0 0 0-.182.557l1.285 5.385a.562.562 0 0 1-.84.61l-4.725-2.885a.562.562 0 0 0-.586 0L6.982 20.54a.562.562 0 0 1-.84-.61l1.285-5.386a.562.562 0 0 0-.182-.557l-4.204-3.602a.562.562 0 0 1 .321-.988l5.518-.442a.563.563 0 0 0 .475-.345L11.48 3.5Z"></path>
+						</svg>
+						<span class="hidden loading loading-xs text-base-content"></span>
+					</button>
+				</div>
+			</div>
+			if connection.Metadata["verified"] != true {
+				<form action={ templ.URL("/api/auth/wargaming/" + connection.Account.Realm) }>
+					<button type="submit" class="verify-button btn btn-sm btn-info flex flex-row flex-nowrap items-center justify-between gap-1 font-normal">
+						<span>Verify</span>
+						<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="1.5" stroke="currentColor" class="size-3">
+							<path stroke-linecap="round" stroke-linejoin="round" d="M13.5 6H5.25A2.25 2.25 0 0 0 3 8.25v10.5A2.25 2.25 0 0 0 5.25 21h10.5A2.25 2.25 0 0 0 18 18.75V10.5m-10.5 6L21 3m0 0h-5.25M21 3v5.25"></path>
+						</svg>
+					</button>
+				</form>
+			}
+		</div>
+		<button class="btn btn-sm rounded-none h-full btn-ghost">
+			<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="1.5" stroke="currentColor" class="size-6">
+				<path stroke-linecap="round" stroke-linejoin="round" d="M9.594 3.94c.09-.542.56-.94 1.11-.94h2.593c.55 0 1.02.398 1.11.94l.213 1.281c.063.374.313.686.645.87.074.04.147.083.22.127.325.196.72.257 1.075.124l1.217-.456a1.125 1.125 0 0 1 1.37.49l1.296 2.247a1.125 1.125 0 0 1-.26 1.431l-1.003.827c-.293.241-.438.613-.43.992a7.723 7.723 0 0 1 0 .255c-.008.378.137.75.43.991l1.004.827c.424.35.534.955.26 1.43l-1.298 2.247a1.125 1.125 0 0 1-1.369.491l-1.217-.456c-.355-.133-.75-.072-1.076.124a6.47 6.47 0 0 1-.22.128c-.331.183-.581.495-.644.869l-.213 1.281c-.09.543-.56.94-1.11.94h-2.594c-.55 0-1.019-.398-1.11-.94l-.213-1.281c-.062-.374-.312-.686-.644-.87a6.52 6.52 0 0 1-.22-.127c-.325-.196-.72-.257-1.076-.124l-1.217.456a1.125 1.125 0 0 1-1.369-.49l-1.297-2.247a1.125 1.125 0 0 1 .26-1.431l1.004-.827c.292-.24.437-.613.43-.991a6.932 6.932 0 0 1 0-.255c.007-.38-.138-.751-.43-.992l-1.004-.827a1.125 1.125 0 0 1-.26-1.43l1.297-2.247a1.125 1.125 0 0 1 1.37-.491l1.216.456c.356.133.751.072 1.076-.124.072-.044.146-.086.22-.128.332-.183.582-.495.644-.869l.214-1.28Z"></path>
+				<path stroke-linecap="round" stroke-linejoin="round" d="M15 12a3 3 0 1 1-6 0 3 3 0 0 1 6 0Z"></path>
+			</svg>
+		</button>
 	</div>
 }
+
+script verifyButtonExpiration(expirationSec int) {
+	setTimeout(() => {
+		const elements = document.querySelectorAll(".verify-button");
+		for (const el of elements) {
+			el.disabled = true;
+			if (el.classList.contains("verify-button-large")) {
+				el.innerText = "Page refresh required";
+			}
+		}
+	}, expirationSec * 1000);
+}
diff --git a/cmd/frontend/routes/app/index_templ.go b/cmd/frontend/routes/app/index_templ.go
index e8a19c4d..719278dd 100644
--- a/cmd/frontend/routes/app/index_templ.go
+++ b/cmd/frontend/routes/app/index_templ.go
@@ -9,21 +9,49 @@ import "github.com/a-h/templ"
 import templruntime "github.com/a-h/templ/runtime"
 
 import (
+	"fmt"
 	"github.com/cufee/aftermath/cmd/frontend/handler"
 	"github.com/cufee/aftermath/cmd/frontend/layouts"
+	"github.com/cufee/aftermath/cmd/frontend/logic"
+	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
 	"net/http"
+	"time"
 )
 
+type connectionWithAccount struct {
+	models.UserConnection
+	Account models.Account
+}
+
 var Index handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
-	user, err := ctx.SessionUser()
+	user, err := ctx.SessionUser(database.WithConnections())
 	if err != nil {
 		return nil, nil, ctx.Redirect("/login", http.StatusTemporaryRedirect)
 	}
-	return layouts.Main, index(user), nil
+
+	var ids []string
+	var connections []connectionWithAccount
+	var accountToConnection = make(map[string]models.UserConnection)
+	accountConnection, _ := user.FilterConnections(models.ConnectionTypeWargaming, nil)
+	for _, conn := range accountConnection {
+		accountToConnection[conn.ReferenceID] = conn
+		ids = append(ids, conn.ReferenceID)
+	}
+	if len(ids) > 0 {
+		accounts, _ := ctx.Database().GetAccounts(ctx.Context, ids)
+		for _, acc := range accounts {
+			connections = append(connections, connectionWithAccount{
+				UserConnection: accountToConnection[acc.ID],
+				Account:        acc,
+			})
+		}
+	}
+
+	return layouts.Main, index(connections, 3), nil
 }
 
-func index(user *models.User) templ.Component {
+func index(connections []connectionWithAccount, linkLimit int) templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
@@ -41,23 +69,164 @@ func index(user *models.User) templ.Component {
 			templ_7745c5c3_Var1 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-col items-center gap-4\"><div class=\"text-3xl font-bold\">🎉 You are logged in! 🎉</div><div class=\"flex flex-col items-center\"><span class=\"text-xl\">But we did not add any features here just yet.</span> <span>Here is your user id instead - ")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex flex-col items-center gap-4\"><div class=\"text-2xl font-bold\">Linked Accounts ")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var2 string
-		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(user.ID)
+		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprintf("%d/%d", len(connections), linkLimit))
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/app/index.templ`, Line: 28, Col: 44}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/app/index.templ`, Line: 49, Col: 69}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</span></div></div>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div><div class=\"flex flex-row flex-wrap gap-2\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		for _, connection := range connections {
+			templ_7745c5c3_Err = connectionCard(connection).Render(ctx, templ_7745c5c3_Buffer)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		if len(connections) < linkLimit {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"grow dropdown dropdown-hover\"><button tabindex=\"0\" class=\"verify-button verify-button-large no-animation btn h-full rounded-md w-full\">Link a new account</button><ul hx-boost=\"false\" tabindex=\"0\" class=\"dropdown-content menu bg-base-100 rounded-box z-[1] p-2 shadow w-full gap-1\"><li><a class=\"verify-button bg-base-200 flex flex-row align-center justify-between gap-1\" href=\"/api/auth/wargaming/na\"><span>North America</span> <svg xmlns=\"http://www.w3.org/2000/svg\" fill=\"none\" viewBox=\"0 0 24 24\" stroke-width=\"1.5\" stroke=\"currentColor\" class=\"size-3\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"M13.5 6H5.25A2.25 2.25 0 0 0 3 8.25v10.5A2.25 2.25 0 0 0 5.25 21h10.5A2.25 2.25 0 0 0 18 18.75V10.5m-10.5 6L21 3m0 0h-5.25M21 3v5.25\"></path></svg></a></li><li><a class=\"verify-button bg-base-200 flex flex-row align-center justify-between gap-1\" href=\"/api/auth/wargaming/eu\"><span>Europe</span> <svg xmlns=\"http://www.w3.org/2000/svg\" fill=\"none\" viewBox=\"0 0 24 24\" stroke-width=\"1.5\" stroke=\"currentColor\" class=\"size-3\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"M13.5 6H5.25A2.25 2.25 0 0 0 3 8.25v10.5A2.25 2.25 0 0 0 5.25 21h10.5A2.25 2.25 0 0 0 18 18.75V10.5m-10.5 6L21 3m0 0h-5.25M21 3v5.25\"></path></svg></a></li><li><a class=\"verify-button bg-base-200 flex flex-row align-center justify-between gap-1\" href=\"/api/auth/wargaming/as\"><span>Asia</span> <svg xmlns=\"http://www.w3.org/2000/svg\" fill=\"none\" viewBox=\"0 0 24 24\" stroke-width=\"1.5\" stroke=\"currentColor\" class=\"size-3\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"M13.5 6H5.25A2.25 2.25 0 0 0 3 8.25v10.5A2.25 2.25 0 0 0 5.25 21h10.5A2.25 2.25 0 0 0 18 18.75V10.5m-10.5 6L21 3m0 0h-5.25M21 3v5.25\"></path></svg></a></li></ul></div>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = logic.EmbedMinifiedScript(verifyButtonExpiration(int(time.Minute*5)), int(time.Minute*5)).Render(ctx, templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return templ_7745c5c3_Err
+	})
+}
+
+func connectionCard(connection connectionWithAccount) templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var3 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var3 == nil {
+			templ_7745c5c3_Var3 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"rounded-md bg-base-300 flex flex-row grow overflow-hidden\"><div class=\"p-1 bg-base-200 flex justify-center items-center h-full aspect-square\"><span class=\"font-bold\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var4 string
+		templ_7745c5c3_Var4, templ_7745c5c3_Err = templ.JoinStringErrs(connection.Account.Realm)
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/app/index.templ`, Line: 95, Col: 30}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var4))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</span></div><div class=\"grow p-3 pr-0 flex flex-row gap-2 items-center justify-between\"><div class=\"grow flex flex-row gap-2 items-center\"><div class=\"flex flex-row gap-1 items-center\"><div class=\"text-lg line-clamp-1 break-all overflow-hidden\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var5 string
+		templ_7745c5c3_Var5, templ_7745c5c3_Err = templ.JoinStringErrs(connection.Account.Nickname)
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/app/index.templ`, Line: 102, Col: 35}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var5))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var6 = []any{logic.StringIfElse("text-yellow-500", "", connection.Metadata["default"] == true)}
+		templ_7745c5c3_Err = templ.RenderCSSItems(ctx, templ_7745c5c3_Buffer, templ_7745c5c3_Var6...)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<button class=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var7 string
+		templ_7745c5c3_Var7, templ_7745c5c3_Err = templ.JoinStringErrs(templ.CSSClasses(templ_7745c5c3_Var6).String())
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/app/index.templ`, Line: 1, Col: 0}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var7))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		if connection.Metadata["default"] == true {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" disabled")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("><svg xmlns=\"http://www.w3.org/2000/svg\" fill=\"none\" viewBox=\"0 0 24 24\" stroke-width=\"1.5\" stroke=\"currentColor\" class=\"size-4\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"M11.48 3.499a.562.562 0 0 1 1.04 0l2.125 5.111a.563.563 0 0 0 .475.345l5.518.442c.499.04.701.663.321.988l-4.204 3.602a.563.563 0 0 0-.182.557l1.285 5.385a.562.562 0 0 1-.84.61l-4.725-2.885a.562.562 0 0 0-.586 0L6.982 20.54a.562.562 0 0 1-.84-.61l1.285-5.386a.562.562 0 0 0-.182-.557l-4.204-3.602a.562.562 0 0 1 .321-.988l5.518-.442a.563.563 0 0 0 .475-.345L11.48 3.5Z\"></path></svg> <span class=\"hidden loading loading-xs text-base-content\"></span></button></div></div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		if connection.Metadata["verified"] != true {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<form action=\"")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			var templ_7745c5c3_Var8 templ.SafeURL = templ.URL("/api/auth/wargaming/" + connection.Account.Realm)
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(string(templ_7745c5c3_Var8)))
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><button type=\"submit\" class=\"verify-button btn btn-sm btn-info flex flex-row flex-nowrap items-center justify-between gap-1 font-normal\"><span>Verify</span> <svg xmlns=\"http://www.w3.org/2000/svg\" fill=\"none\" viewBox=\"0 0 24 24\" stroke-width=\"1.5\" stroke=\"currentColor\" class=\"size-3\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"M13.5 6H5.25A2.25 2.25 0 0 0 3 8.25v10.5A2.25 2.25 0 0 0 5.25 21h10.5A2.25 2.25 0 0 0 18 18.75V10.5m-10.5 6L21 3m0 0h-5.25M21 3v5.25\"></path></svg></button></form>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div><button class=\"btn btn-sm rounded-none h-full btn-ghost\"><svg xmlns=\"http://www.w3.org/2000/svg\" fill=\"none\" viewBox=\"0 0 24 24\" stroke-width=\"1.5\" stroke=\"currentColor\" class=\"size-6\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"M9.594 3.94c.09-.542.56-.94 1.11-.94h2.593c.55 0 1.02.398 1.11.94l.213 1.281c.063.374.313.686.645.87.074.04.147.083.22.127.325.196.72.257 1.075.124l1.217-.456a1.125 1.125 0 0 1 1.37.49l1.296 2.247a1.125 1.125 0 0 1-.26 1.431l-1.003.827c-.293.241-.438.613-.43.992a7.723 7.723 0 0 1 0 .255c-.008.378.137.75.43.991l1.004.827c.424.35.534.955.26 1.43l-1.298 2.247a1.125 1.125 0 0 1-1.369.491l-1.217-.456c-.355-.133-.75-.072-1.076.124a6.47 6.47 0 0 1-.22.128c-.331.183-.581.495-.644.869l-.213 1.281c-.09.543-.56.94-1.11.94h-2.594c-.55 0-1.019-.398-1.11-.94l-.213-1.281c-.062-.374-.312-.686-.644-.87a6.52 6.52 0 0 1-.22-.127c-.325-.196-.72-.257-1.076-.124l-1.217.456a1.125 1.125 0 0 1-1.369-.49l-1.297-2.247a1.125 1.125 0 0 1 .26-1.431l1.004-.827c.292-.24.437-.613.43-.991a6.932 6.932 0 0 1 0-.255c.007-.38-.138-.751-.43-.992l-1.004-.827a1.125 1.125 0 0 1-.26-1.43l1.297-2.247a1.125 1.125 0 0 1 1.37-.491l1.216.456c.356.133.751.072 1.076-.124.072-.044.146-.086.22-.128.332-.183.582-.495.644-.869l.214-1.28Z\"></path> <path stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"M15 12a3 3 0 1 1-6 0 3 3 0 0 1 6 0Z\"></path></svg></button></div>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		return templ_7745c5c3_Err
 	})
 }
+
+func verifyButtonExpiration(expirationSec int) templ.ComponentScript {
+	return templ.ComponentScript{
+		Name: `__templ_verifyButtonExpiration_775b`,
+		Function: `function __templ_verifyButtonExpiration_775b(expirationSec){setTimeout(() => {
+		const elements = document.querySelectorAll(".verify-button");
+		for (const el of elements) {
+			el.disabled = true;
+			if (el.classList.contains("verify-button-large")) {
+				el.innerText = "Page refresh required";
+			}
+		}
+	}, expirationSec * 1000);
+}`,
+		Call:       templ.SafeScript(`__templ_verifyButtonExpiration_775b`, expirationSec),
+		CallInline: templ.SafeScriptInline(`__templ_verifyButtonExpiration_775b`, expirationSec),
+	}
+}
diff --git a/cmd/frontend/routes/widget/index.templ b/cmd/frontend/routes/widget/index.templ
index a462acec..c8a93c2d 100644
--- a/cmd/frontend/routes/widget/index.templ
+++ b/cmd/frontend/routes/widget/index.templ
@@ -43,7 +43,7 @@ templ widgetHome(widget templ.Component, or, ou bool, vl int) {
 			@cwidget.Settings(handlePreviewOnHome(), or, ou, vl)
 			<div class="flex flex-row flex-wrap gap-2">
 				<select id="player-search-realm" class="select select-bordered grow" onchange={ onRealmSelect() }>
-					<option disabled selected class="text-center">Pick a Server</option>
+					<option disabled selected class="text-center">Select a Server</option>
 					<option value="NA">North America</option>
 					<option value="EU">Europe</option>
 					<option value="AS">Asia</option>
@@ -162,7 +162,7 @@ script searchEventHandler(appId string) {
 						return;
 					}
 					const elements = []
-					for (const account of data.data || []) {
+					for (const account of data.data?.reverse() || []) {
 						if (!account.account_id || !account.nickname) continue;
 						elements.push(`<li><a onclick="window.setResultsLoading();htmx.trigger('body','htmx:beforeSend');" href="/widget/${account.account_id}${window.location.search}">${account.nickname}</a></li>`);
 					}
diff --git a/cmd/frontend/routes/widget/index_templ.go b/cmd/frontend/routes/widget/index_templ.go
index 812b5bab..a3a243b2 100644
--- a/cmd/frontend/routes/widget/index_templ.go
+++ b/cmd/frontend/routes/widget/index_templ.go
@@ -80,7 +80,7 @@ func widgetHome(widget templ.Component, or, ou bool, vl int) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><option disabled selected class=\"text-center\">Pick a Server</option> <option value=\"NA\">North America</option> <option value=\"EU\">Europe</option> <option value=\"AS\">Asia</option></select><div class=\"dropdown dropdown-top grow\">")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><option disabled selected class=\"text-center\">Select a Server</option> <option value=\"NA\">North America</option> <option value=\"EU\">Europe</option> <option value=\"AS\">Asia</option></select><div class=\"dropdown dropdown-top grow\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -202,8 +202,8 @@ func onNicknameInput() templ.ComponentScript {
 
 func searchEventHandler(appId string) templ.ComponentScript {
 	return templ.ComponentScript{
-		Name: `__templ_searchEventHandler_0d98`,
-		Function: `function __templ_searchEventHandler_0d98(appId){const results = document.getElementById("player-search-results");
+		Name: `__templ_searchEventHandler_3147`,
+		Function: `function __templ_searchEventHandler_3147(appId){const results = document.getElementById("player-search-results");
 	const nickname = document.getElementById("player-search-nickname");
 
 	const setResultsLoading = () => {
@@ -250,7 +250,7 @@ func searchEventHandler(appId string) templ.ComponentScript {
 						return;
 					}
 					const elements = []
-					for (const account of data.data || []) {
+					for (const account of data.data?.reverse() || []) {
 						if (!account.account_id || !account.nickname) continue;
 						elements.push(` + "`" + `<li><a onclick="window.setResultsLoading();htmx.trigger('body','htmx:beforeSend');" href="/widget/${account.account_id}${window.location.search}">${account.nickname}</a></li>` + "`" + `);
 					}
@@ -271,8 +271,8 @@ func searchEventHandler(appId string) templ.ComponentScript {
 		false,
 	);
 }`,
-		Call:       templ.SafeScript(`__templ_searchEventHandler_0d98`, appId),
-		CallInline: templ.SafeScriptInline(`__templ_searchEventHandler_0d98`, appId),
+		Call:       templ.SafeScript(`__templ_searchEventHandler_3147`, appId),
+		CallInline: templ.SafeScriptInline(`__templ_searchEventHandler_3147`, appId),
 	}
 }
 
diff --git a/internal/database/auth.go b/internal/database/auth.go
index b874264a..f860fba3 100644
--- a/internal/database/auth.go
+++ b/internal/database/auth.go
@@ -91,8 +91,24 @@ func (c *client) FindSession(ctx context.Context, publicID string) (models.Sessi
 	return session, session.Valid()
 }
 
-func (c *client) UserFromSession(ctx context.Context, publicID string) (models.User, error) {
-	record, err := c.db.Session.Query().Where(session.PublicID(publicID), session.ExpiresAtGT(time.Now())).QueryUser().First(ctx)
+func (c *client) UserFromSession(ctx context.Context, publicID string, opts ...UserGetOption) (models.User, error) {
+	var options userGetOpts
+	for _, apply := range opts {
+		apply(&options)
+	}
+
+	query := c.db.Session.Query().Where(session.PublicID(publicID), session.ExpiresAtGT(time.Now())).QueryUser()
+	if options.subscriptions {
+		query = query.WithSubscriptions()
+	}
+	if options.connections {
+		query = query.WithConnections()
+	}
+	if options.content {
+		query.WithContent()
+	}
+
+	record, err := query.First(ctx)
 	if err != nil {
 		return models.User{}, err
 	}
diff --git a/internal/database/client.go b/internal/database/client.go
index da875773..bb4053f2 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -23,9 +23,9 @@ type AuthClient interface {
 	FindAuthNonce(ctx context.Context, publicID string) (models.AuthNonce, error)
 	SetAuthNonceActive(ctx context.Context, nonceID string, active bool) error
 
+	UserFromSession(ctx context.Context, publicID string, opts ...UserGetOption) (models.User, error)
 	CreateSession(ctx context.Context, publicID, userID string, expiresAt time.Time, meta map[string]string) (models.Session, error)
 	SetSessionExpiresAt(ctx context.Context, sessionID string, expiresAt time.Time) error
-	UserFromSession(ctx context.Context, publicID string) (models.User, error)
 	FindSession(ctx context.Context, publicID string) (models.Session, error)
 }
 
diff --git a/internal/database/users.go b/internal/database/users.go
index 27d8fed7..506adacc 100644
--- a/internal/database/users.go
+++ b/internal/database/users.go
@@ -69,6 +69,16 @@ type userGetOpts struct {
 	subscriptions bool
 }
 
+type UserGetOptions []UserGetOption
+
+func (o UserGetOptions) ToOptions() userGetOpts {
+	var opts userGetOpts
+	for _, apply := range o {
+		apply(&opts)
+	}
+	return opts
+}
+
 type UserGetOption func(*userGetOpts)
 
 func WithConnections() UserGetOption {
diff --git a/internal/external/wargaming/client.go b/internal/external/wargaming/client.go
index 738c4cac..42d4a5fe 100644
--- a/internal/external/wargaming/client.go
+++ b/internal/external/wargaming/client.go
@@ -2,6 +2,7 @@ package wargaming
 
 import (
 	"fmt"
+	"os"
 	"strconv"
 	"time"
 
@@ -28,3 +29,5 @@ func NewClientFromEnv(primaryAppId, primaryAppRps, requestTimeout, proxyHostList
 
 	return client.NewEmbeddedClient(primaryAppId, primaryRps, proxyHostList, timeout, client.WithLogLevel(zerolog.WarnLevel))
 }
+
+var PublicAppID = os.Getenv("WG_AUTH_APP_ID")
diff --git a/tests/static_data.go b/tests/static_data.go
index 1ac8f29a..f5b5e501 100644
--- a/tests/static_data.go
+++ b/tests/static_data.go
@@ -116,13 +116,17 @@ func DefaultVehicleStatsFrameSmall2(id string) frame.VehicleStatsFrame {
 }
 
 var (
-	DefaultUserWithEdges = models.User{ID: "user1", Connections: []models.UserConnection{Connection(models.ConnectionTypeWargaming)}}
+	DefaultUserWithEdges = models.User{ID: "user1", Connections: []models.UserConnection{
+		Connection(DefaultAccountNA, models.ConnectionTypeWargaming, map[string]any{"verified": false}),
+		Connection(DefaultAccountEU, models.ConnectionTypeWargaming, map[string]any{"default": true}),
+	}}
 )
 
-func Connection(kind models.ConnectionType) models.UserConnection {
+func Connection(id string, kind models.ConnectionType, meta map[string]any) models.UserConnection {
 	return models.UserConnection{
 		ID:          fmt.Sprint(time.Now().Nanosecond()),
-		ReferenceID: DefaultAccountNA,
+		ReferenceID: id,
 		Type:        kind,
+		Metadata:    meta,
 	}
 }
diff --git a/tests/static_database.go b/tests/static_database.go
index 44689e87..add0488a 100644
--- a/tests/static_database.go
+++ b/tests/static_database.go
@@ -194,6 +194,6 @@ func (c *staticTestingDatabase) SetSessionExpiresAt(ctx context.Context, session
 func (c *staticTestingDatabase) FindSession(ctx context.Context, publicID string) (models.Session, error) {
 	return models.Session{ID: "session1", UserID: "user1", PublicID: "cookie1", ExpiresAt: time.Date(9999, 0, 0, 0, 0, 0, 0, time.UTC)}, nil
 }
-func (c *staticTestingDatabase) UserFromSession(ctx context.Context, publicID string) (models.User, error) {
-	return models.User{ID: "user1"}, nil
+func (c *staticTestingDatabase) UserFromSession(ctx context.Context, publicID string, opts ...database.UserGetOption) (models.User, error) {
+	return DefaultUserWithEdges, nil
 }

From 9ceb9ab94c2e4a6878e7af61eed264fc1e5c565e Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 5 Jul 2024 20:38:13 -0400
Subject: [PATCH 279/341] disabled a button that does nothing

---
 cmd/frontend/routes/app/index.templ    | 2 +-
 cmd/frontend/routes/app/index_templ.go | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/cmd/frontend/routes/app/index.templ b/cmd/frontend/routes/app/index.templ
index cc7511e4..234ce29f 100644
--- a/cmd/frontend/routes/app/index.templ
+++ b/cmd/frontend/routes/app/index.templ
@@ -120,7 +120,7 @@ templ connectionCard(connection connectionWithAccount) {
 				</form>
 			}
 		</div>
-		<button class="btn btn-sm rounded-none h-full btn-ghost">
+		<button class="btn btn-sm rounded-none h-full btn-ghost" disabled>
 			<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="1.5" stroke="currentColor" class="size-6">
 				<path stroke-linecap="round" stroke-linejoin="round" d="M9.594 3.94c.09-.542.56-.94 1.11-.94h2.593c.55 0 1.02.398 1.11.94l.213 1.281c.063.374.313.686.645.87.074.04.147.083.22.127.325.196.72.257 1.075.124l1.217-.456a1.125 1.125 0 0 1 1.37.49l1.296 2.247a1.125 1.125 0 0 1-.26 1.431l-1.003.827c-.293.241-.438.613-.43.992a7.723 7.723 0 0 1 0 .255c-.008.378.137.75.43.991l1.004.827c.424.35.534.955.26 1.43l-1.298 2.247a1.125 1.125 0 0 1-1.369.491l-1.217-.456c-.355-.133-.75-.072-1.076.124a6.47 6.47 0 0 1-.22.128c-.331.183-.581.495-.644.869l-.213 1.281c-.09.543-.56.94-1.11.94h-2.594c-.55 0-1.019-.398-1.11-.94l-.213-1.281c-.062-.374-.312-.686-.644-.87a6.52 6.52 0 0 1-.22-.127c-.325-.196-.72-.257-1.076-.124l-1.217.456a1.125 1.125 0 0 1-1.369-.49l-1.297-2.247a1.125 1.125 0 0 1 .26-1.431l1.004-.827c.292-.24.437-.613.43-.991a6.932 6.932 0 0 1 0-.255c.007-.38-.138-.751-.43-.992l-1.004-.827a1.125 1.125 0 0 1-.26-1.43l1.297-2.247a1.125 1.125 0 0 1 1.37-.491l1.216.456c.356.133.751.072 1.076-.124.072-.044.146-.086.22-.128.332-.183.582-.495.644-.869l.214-1.28Z"></path>
 				<path stroke-linecap="round" stroke-linejoin="round" d="M15 12a3 3 0 1 1-6 0 3 3 0 0 1 6 0Z"></path>
diff --git a/cmd/frontend/routes/app/index_templ.go b/cmd/frontend/routes/app/index_templ.go
index 719278dd..fadab3aa 100644
--- a/cmd/frontend/routes/app/index_templ.go
+++ b/cmd/frontend/routes/app/index_templ.go
@@ -205,7 +205,7 @@ func connectionCard(connection connectionWithAccount) templ.Component {
 				return templ_7745c5c3_Err
 			}
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div><button class=\"btn btn-sm rounded-none h-full btn-ghost\"><svg xmlns=\"http://www.w3.org/2000/svg\" fill=\"none\" viewBox=\"0 0 24 24\" stroke-width=\"1.5\" stroke=\"currentColor\" class=\"size-6\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"M9.594 3.94c.09-.542.56-.94 1.11-.94h2.593c.55 0 1.02.398 1.11.94l.213 1.281c.063.374.313.686.645.87.074.04.147.083.22.127.325.196.72.257 1.075.124l1.217-.456a1.125 1.125 0 0 1 1.37.49l1.296 2.247a1.125 1.125 0 0 1-.26 1.431l-1.003.827c-.293.241-.438.613-.43.992a7.723 7.723 0 0 1 0 .255c-.008.378.137.75.43.991l1.004.827c.424.35.534.955.26 1.43l-1.298 2.247a1.125 1.125 0 0 1-1.369.491l-1.217-.456c-.355-.133-.75-.072-1.076.124a6.47 6.47 0 0 1-.22.128c-.331.183-.581.495-.644.869l-.213 1.281c-.09.543-.56.94-1.11.94h-2.594c-.55 0-1.019-.398-1.11-.94l-.213-1.281c-.062-.374-.312-.686-.644-.87a6.52 6.52 0 0 1-.22-.127c-.325-.196-.72-.257-1.076-.124l-1.217.456a1.125 1.125 0 0 1-1.369-.49l-1.297-2.247a1.125 1.125 0 0 1 .26-1.431l1.004-.827c.292-.24.437-.613.43-.991a6.932 6.932 0 0 1 0-.255c.007-.38-.138-.751-.43-.992l-1.004-.827a1.125 1.125 0 0 1-.26-1.43l1.297-2.247a1.125 1.125 0 0 1 1.37-.491l1.216.456c.356.133.751.072 1.076-.124.072-.044.146-.086.22-.128.332-.183.582-.495.644-.869l.214-1.28Z\"></path> <path stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"M15 12a3 3 0 1 1-6 0 3 3 0 0 1 6 0Z\"></path></svg></button></div>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div><button class=\"btn btn-sm rounded-none h-full btn-ghost\" disabled><svg xmlns=\"http://www.w3.org/2000/svg\" fill=\"none\" viewBox=\"0 0 24 24\" stroke-width=\"1.5\" stroke=\"currentColor\" class=\"size-6\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"M9.594 3.94c.09-.542.56-.94 1.11-.94h2.593c.55 0 1.02.398 1.11.94l.213 1.281c.063.374.313.686.645.87.074.04.147.083.22.127.325.196.72.257 1.075.124l1.217-.456a1.125 1.125 0 0 1 1.37.49l1.296 2.247a1.125 1.125 0 0 1-.26 1.431l-1.003.827c-.293.241-.438.613-.43.992a7.723 7.723 0 0 1 0 .255c-.008.378.137.75.43.991l1.004.827c.424.35.534.955.26 1.43l-1.298 2.247a1.125 1.125 0 0 1-1.369.491l-1.217-.456c-.355-.133-.75-.072-1.076.124a6.47 6.47 0 0 1-.22.128c-.331.183-.581.495-.644.869l-.213 1.281c-.09.543-.56.94-1.11.94h-2.594c-.55 0-1.019-.398-1.11-.94l-.213-1.281c-.062-.374-.312-.686-.644-.87a6.52 6.52 0 0 1-.22-.127c-.325-.196-.72-.257-1.076-.124l-1.217.456a1.125 1.125 0 0 1-1.369-.49l-1.297-2.247a1.125 1.125 0 0 1 .26-1.431l1.004-.827c.292-.24.437-.613.43-.991a6.932 6.932 0 0 1 0-.255c.007-.38-.138-.751-.43-.992l-1.004-.827a1.125 1.125 0 0 1-.26-1.43l1.297-2.247a1.125 1.125 0 0 1 1.37-.491l1.216.456c.356.133.751.072 1.076-.124.072-.044.146-.086.22-.128.332-.183.582-.495.644-.869l.214-1.28Z\"></path> <path stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"M15 12a3 3 0 1 1-6 0 3 3 0 0 1 6 0Z\"></path></svg></button></div>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}

From 739dc1abede5a8d9aad86c6578e27f7269517271 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 5 Jul 2024 20:51:53 -0400
Subject: [PATCH 280/341] correctly expiring the old session

---
 cmd/frontend/routes/api/auth/wargaming.go | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/cmd/frontend/routes/api/auth/wargaming.go b/cmd/frontend/routes/api/auth/wargaming.go
index 114d7d95..99f917dd 100644
--- a/cmd/frontend/routes/api/auth/wargaming.go
+++ b/cmd/frontend/routes/api/auth/wargaming.go
@@ -30,12 +30,20 @@ var WargamingRedirect handler.Endpoint = func(ctx *handler.Context) error {
 		return ctx.Redirect("/error?message=this verification link has expired", http.StatusTemporaryRedirect)
 	}
 
-	user, err := ctx.Database().UserFromSession(ctx.Context, token, database.WithConnections())
+	session, err := ctx.Database().FindSession(ctx.Context, token)
+	if err != nil {
+		return ctx.Redirect("/error?message=this verification link has expired", http.StatusTemporaryRedirect)
+	}
+	if session.Meta["flow"] != "wargaming-redirect" {
+		return ctx.Redirect("/error?message=this verification link has expired", http.StatusTemporaryRedirect)
+	}
+
+	user, err := ctx.Database().GetUserByID(ctx.Context, session.UserID, database.WithConnections())
 	if err != nil {
 		return ctx.Redirect("/error?message=this verification link has expired", http.StatusTemporaryRedirect)
 	}
 
-	err = ctx.Database().SetSessionExpiresAt(ctx.Context, token, time.Time{})
+	err = ctx.Database().SetSessionExpiresAt(ctx.Context, session.ID, time.Time{})
 	if err != nil {
 		log.Err(err).Msg("failed to set session expiration")
 		return ctx.Redirect("/error?message=this verification link has expired", http.StatusTemporaryRedirect)
@@ -46,11 +54,11 @@ var WargamingRedirect handler.Endpoint = func(ctx *handler.Context) error {
 		if conn.ReferenceID == accountID {
 			conn.Metadata["default"] = true
 			conn.Metadata["verified"] = true
-			_, err := ctx.Database().UpdateConnection(ctx.Context, conn)
+			_, err := ctx.Database().UpsertConnection(ctx.Context, conn)
 			if err != nil {
 				return ctx.Error(err, "failed to update user connection")
 			}
-			return ctx.Redirect("/app#links", http.StatusTemporaryRedirect)
+			return ctx.Redirect("/app?linked="+ctx.Query("nickname"), http.StatusTemporaryRedirect)
 		}
 	}
 
@@ -64,7 +72,7 @@ var WargamingRedirect handler.Endpoint = func(ctx *handler.Context) error {
 	if err != nil {
 		return ctx.Error(err, "failed to update user connection")
 	}
-	return ctx.Redirect("/app#links", http.StatusTemporaryRedirect)
+	return ctx.Redirect("/app?linked="+ctx.Query("nickname"), http.StatusTemporaryRedirect)
 }
 
 var WargamingBegin handler.Endpoint = func(ctx *handler.Context) error {

From ab5a899f7972978e36f068f02c5faa4ae0b94530 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 5 Jul 2024 20:54:29 -0400
Subject: [PATCH 281/341] added error

---
 cmd/frontend/routes/app/index.templ    |  5 ++++-
 cmd/frontend/routes/app/index_templ.go | 11 +++++++----
 2 files changed, 11 insertions(+), 5 deletions(-)

diff --git a/cmd/frontend/routes/app/index.templ b/cmd/frontend/routes/app/index.templ
index 234ce29f..d496a523 100644
--- a/cmd/frontend/routes/app/index.templ
+++ b/cmd/frontend/routes/app/index.templ
@@ -31,7 +31,10 @@ var Index handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Compo
 		ids = append(ids, conn.ReferenceID)
 	}
 	if len(ids) > 0 {
-		accounts, _ := ctx.Database().GetAccounts(ctx.Context, ids)
+		accounts, err := ctx.Database().GetAccounts(ctx.Context, ids)
+		if err != nil {
+			return nil, nil, ctx.Error(err, "failed to get account information")
+		}
 		for _, acc := range accounts {
 			connections = append(connections, connectionWithAccount{
 				UserConnection: accountToConnection[acc.ID],
diff --git a/cmd/frontend/routes/app/index_templ.go b/cmd/frontend/routes/app/index_templ.go
index fadab3aa..da4447d4 100644
--- a/cmd/frontend/routes/app/index_templ.go
+++ b/cmd/frontend/routes/app/index_templ.go
@@ -39,7 +39,10 @@ var Index handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Compo
 		ids = append(ids, conn.ReferenceID)
 	}
 	if len(ids) > 0 {
-		accounts, _ := ctx.Database().GetAccounts(ctx.Context, ids)
+		accounts, err := ctx.Database().GetAccounts(ctx.Context, ids)
+		if err != nil {
+			return nil, nil, ctx.Error(err, "failed to get account information")
+		}
 		for _, acc := range accounts {
 			connections = append(connections, connectionWithAccount{
 				UserConnection: accountToConnection[acc.ID],
@@ -76,7 +79,7 @@ func index(connections []connectionWithAccount, linkLimit int) templ.Component {
 		var templ_7745c5c3_Var2 string
 		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprintf("%d/%d", len(connections), linkLimit))
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/app/index.templ`, Line: 49, Col: 69}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/app/index.templ`, Line: 52, Col: 69}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
 		if templ_7745c5c3_Err != nil {
@@ -135,7 +138,7 @@ func connectionCard(connection connectionWithAccount) templ.Component {
 		var templ_7745c5c3_Var4 string
 		templ_7745c5c3_Var4, templ_7745c5c3_Err = templ.JoinStringErrs(connection.Account.Realm)
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/app/index.templ`, Line: 95, Col: 30}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/app/index.templ`, Line: 98, Col: 30}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var4))
 		if templ_7745c5c3_Err != nil {
@@ -148,7 +151,7 @@ func connectionCard(connection connectionWithAccount) templ.Component {
 		var templ_7745c5c3_Var5 string
 		templ_7745c5c3_Var5, templ_7745c5c3_Err = templ.JoinStringErrs(connection.Account.Nickname)
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/app/index.templ`, Line: 102, Col: 35}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/app/index.templ`, Line: 105, Col: 35}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var5))
 		if templ_7745c5c3_Err != nil {

From 686a1f12981ce5bb3dc0f1f41618a0210b4d79ba Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 5 Jul 2024 20:55:44 -0400
Subject: [PATCH 282/341] disabled user cache on ctx

---
 cmd/frontend/handler/context.go | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/cmd/frontend/handler/context.go b/cmd/frontend/handler/context.go
index c4db18ac..0fd75913 100644
--- a/cmd/frontend/handler/context.go
+++ b/cmd/frontend/handler/context.go
@@ -95,10 +95,10 @@ func (ctx *Context) SessionUser(o ...database.UserGetOption) (*models.User, erro
 		return &user, nil
 	}
 
-	// if the user already exists and options are equal, return cached user
-	if ctx.user != nil && ctx.userOptions.ToOptions() == opts.ToOptions() {
-		return ctx.user, nil
-	}
+	// // if the user already exists and options are equal, return cached user
+	// if ctx.user != nil && ctx.userOptions.ToOptions() == opts.ToOptions() {
+	// 	return ctx.user, nil
+	// }
 
 	cookie, err := ctx.Cookie(auth.SessionCookieName)
 	if err != nil || cookie == nil {
@@ -108,7 +108,7 @@ func (ctx *Context) SessionUser(o ...database.UserGetOption) (*models.User, erro
 		return nil, ErrSessionNotFound
 	}
 
-	user, err := ctx.Database().UserFromSession(ctx.Context, cookie.Value, opts...)
+	user, err := ctx.Database().UserFromSession(ctx.Context, cookie.Value, o...)
 	if err != nil {
 		if database.IsNotFound(err) {
 			return nil, ErrSessionNotFound

From 6223464510591f97f5603dfe442d15e5155f85ae Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 5 Jul 2024 20:57:51 -0400
Subject: [PATCH 283/341] re-enabled cache

---
 cmd/frontend/handler/context.go        | 18 +++++++-----------
 cmd/frontend/routes/app/index.templ    |  3 +--
 cmd/frontend/routes/app/index_templ.go |  9 ++++-----
 3 files changed, 12 insertions(+), 18 deletions(-)

diff --git a/cmd/frontend/handler/context.go b/cmd/frontend/handler/context.go
index 0fd75913..a57e4f7d 100644
--- a/cmd/frontend/handler/context.go
+++ b/cmd/frontend/handler/context.go
@@ -30,8 +30,7 @@ type Context struct {
 	core.Client
 	context.Context
 
-	user        *models.User
-	userOptions database.UserGetOptions
+	user *models.User
 
 	w http.ResponseWriter
 	r *http.Request
@@ -86,19 +85,17 @@ func (ctx *Context) Identifier() (string, error) {
 	return "", errors.New("failed to extract ip address")
 }
 
-func (ctx *Context) SessionUser(o ...database.UserGetOption) (*models.User, error) {
-	var opts database.UserGetOptions = o
-
+func (ctx *Context) SessionUser() (*models.User, error) {
 	// if dev mode is on, we just grab a pre-defined user from the database, expecting it to exist
 	if devMode {
-		user, _ := ctx.Database().UserFromSession(ctx.Context, "dev-user", opts...)
+		user, _ := ctx.Database().UserFromSession(ctx.Context, "dev-user")
 		return &user, nil
 	}
 
 	// // if the user already exists and options are equal, return cached user
-	// if ctx.user != nil && ctx.userOptions.ToOptions() == opts.ToOptions() {
-	// 	return ctx.user, nil
-	// }
+	if ctx.user != nil {
+		return ctx.user, nil
+	}
 
 	cookie, err := ctx.Cookie(auth.SessionCookieName)
 	if err != nil || cookie == nil {
@@ -108,7 +105,7 @@ func (ctx *Context) SessionUser(o ...database.UserGetOption) (*models.User, erro
 		return nil, ErrSessionNotFound
 	}
 
-	user, err := ctx.Database().UserFromSession(ctx.Context, cookie.Value, o...)
+	user, err := ctx.Database().UserFromSession(ctx.Context, cookie.Value, database.WithConnections(), database.WithContent(), database.WithSubscriptions())
 	if err != nil {
 		if database.IsNotFound(err) {
 			return nil, ErrSessionNotFound
@@ -117,7 +114,6 @@ func (ctx *Context) SessionUser(o ...database.UserGetOption) (*models.User, erro
 	}
 
 	ctx.user = &user
-	ctx.userOptions = opts
 	return ctx.user, nil
 }
 
diff --git a/cmd/frontend/routes/app/index.templ b/cmd/frontend/routes/app/index.templ
index d496a523..f5f5fa7d 100644
--- a/cmd/frontend/routes/app/index.templ
+++ b/cmd/frontend/routes/app/index.templ
@@ -5,7 +5,6 @@ import (
 	"github.com/cufee/aftermath/cmd/frontend/handler"
 	"github.com/cufee/aftermath/cmd/frontend/layouts"
 	"github.com/cufee/aftermath/cmd/frontend/logic"
-	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
 	"net/http"
 	"time"
@@ -17,7 +16,7 @@ type connectionWithAccount struct {
 }
 
 var Index handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
-	user, err := ctx.SessionUser(database.WithConnections())
+	user, err := ctx.SessionUser()
 	if err != nil {
 		return nil, nil, ctx.Redirect("/login", http.StatusTemporaryRedirect)
 	}
diff --git a/cmd/frontend/routes/app/index_templ.go b/cmd/frontend/routes/app/index_templ.go
index da4447d4..35ff1a61 100644
--- a/cmd/frontend/routes/app/index_templ.go
+++ b/cmd/frontend/routes/app/index_templ.go
@@ -13,7 +13,6 @@ import (
 	"github.com/cufee/aftermath/cmd/frontend/handler"
 	"github.com/cufee/aftermath/cmd/frontend/layouts"
 	"github.com/cufee/aftermath/cmd/frontend/logic"
-	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
 	"net/http"
 	"time"
@@ -25,7 +24,7 @@ type connectionWithAccount struct {
 }
 
 var Index handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
-	user, err := ctx.SessionUser(database.WithConnections())
+	user, err := ctx.SessionUser()
 	if err != nil {
 		return nil, nil, ctx.Redirect("/login", http.StatusTemporaryRedirect)
 	}
@@ -79,7 +78,7 @@ func index(connections []connectionWithAccount, linkLimit int) templ.Component {
 		var templ_7745c5c3_Var2 string
 		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprintf("%d/%d", len(connections), linkLimit))
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/app/index.templ`, Line: 52, Col: 69}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/app/index.templ`, Line: 51, Col: 69}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
 		if templ_7745c5c3_Err != nil {
@@ -138,7 +137,7 @@ func connectionCard(connection connectionWithAccount) templ.Component {
 		var templ_7745c5c3_Var4 string
 		templ_7745c5c3_Var4, templ_7745c5c3_Err = templ.JoinStringErrs(connection.Account.Realm)
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/app/index.templ`, Line: 98, Col: 30}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/app/index.templ`, Line: 97, Col: 30}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var4))
 		if templ_7745c5c3_Err != nil {
@@ -151,7 +150,7 @@ func connectionCard(connection connectionWithAccount) templ.Component {
 		var templ_7745c5c3_Var5 string
 		templ_7745c5c3_Var5, templ_7745c5c3_Err = templ.JoinStringErrs(connection.Account.Nickname)
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/app/index.templ`, Line: 105, Col: 35}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/app/index.templ`, Line: 104, Col: 35}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var5))
 		if templ_7745c5c3_Err != nil {

From 36efcb5b568bba45f1d77bfaede1f9b75a711ed3 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 5 Jul 2024 21:01:54 -0400
Subject: [PATCH 284/341] removed indirect user get call

---
 cmd/frontend/handler/context.go | 31 +++++++++++++++++++++++++------
 internal/database/auth.go       | 25 -------------------------
 internal/database/client.go     |  1 -
 3 files changed, 25 insertions(+), 32 deletions(-)

diff --git a/cmd/frontend/handler/context.go b/cmd/frontend/handler/context.go
index a57e4f7d..e3fdfe95 100644
--- a/cmd/frontend/handler/context.go
+++ b/cmd/frontend/handler/context.go
@@ -6,6 +6,7 @@ import (
 	"net/url"
 	"os"
 	"strings"
+	"time"
 
 	"github.com/a-h/templ"
 	"github.com/cufee/aftermath/cmd/core"
@@ -30,7 +31,8 @@ type Context struct {
 	core.Client
 	context.Context
 
-	user *models.User
+	user        *models.User
+	userOptions database.UserGetOptions
 
 	w http.ResponseWriter
 	r *http.Request
@@ -85,15 +87,20 @@ func (ctx *Context) Identifier() (string, error) {
 	return "", errors.New("failed to extract ip address")
 }
 
-func (ctx *Context) SessionUser() (*models.User, error) {
+func (ctx *Context) SessionUser(o ...database.UserGetOption) (*models.User, error) {
+	var opts database.UserGetOptions = o
+
 	// if dev mode is on, we just grab a pre-defined user from the database, expecting it to exist
 	if devMode {
-		user, _ := ctx.Database().UserFromSession(ctx.Context, "dev-user")
+		user, err := ctx.Database().GetUserByID(ctx.Context, "dev-user", opts...)
+		if err != nil {
+			panic(err)
+		}
 		return &user, nil
 	}
 
-	// // if the user already exists and options are equal, return cached user
-	if ctx.user != nil {
+	// if the user already exists and options are equal, return cached user
+	if ctx.user != nil && ctx.userOptions.ToOptions() == opts.ToOptions() {
 		return ctx.user, nil
 	}
 
@@ -105,7 +112,18 @@ func (ctx *Context) SessionUser() (*models.User, error) {
 		return nil, ErrSessionNotFound
 	}
 
-	user, err := ctx.Database().UserFromSession(ctx.Context, cookie.Value, database.WithConnections(), database.WithContent(), database.WithSubscriptions())
+	session, err := ctx.Database().FindSession(ctx.Context, cookie.Value)
+	if err != nil {
+		if database.IsNotFound(err) {
+			return nil, ErrSessionNotFound
+		}
+		return nil, err
+	}
+	if session.ExpiresAt.Before(time.Now()) {
+		return nil, ErrSessionNotFound
+	}
+
+	user, err := ctx.Database().GetUserByID(ctx.Context, session.UserID, opts...)
 	if err != nil {
 		if database.IsNotFound(err) {
 			return nil, ErrSessionNotFound
@@ -114,6 +132,7 @@ func (ctx *Context) SessionUser() (*models.User, error) {
 	}
 
 	ctx.user = &user
+	ctx.userOptions = opts
 	return ctx.user, nil
 }
 
diff --git a/internal/database/auth.go b/internal/database/auth.go
index f860fba3..071137aa 100644
--- a/internal/database/auth.go
+++ b/internal/database/auth.go
@@ -91,31 +91,6 @@ func (c *client) FindSession(ctx context.Context, publicID string) (models.Sessi
 	return session, session.Valid()
 }
 
-func (c *client) UserFromSession(ctx context.Context, publicID string, opts ...UserGetOption) (models.User, error) {
-	var options userGetOpts
-	for _, apply := range opts {
-		apply(&options)
-	}
-
-	query := c.db.Session.Query().Where(session.PublicID(publicID), session.ExpiresAtGT(time.Now())).QueryUser()
-	if options.subscriptions {
-		query = query.WithSubscriptions()
-	}
-	if options.connections {
-		query = query.WithConnections()
-	}
-	if options.content {
-		query.WithContent()
-	}
-
-	record, err := query.First(ctx)
-	if err != nil {
-		return models.User{}, err
-	}
-
-	return toUser(record, nil, nil, nil), nil
-}
-
 func (c *client) SetSessionExpiresAt(ctx context.Context, sessionID string, expiresAt time.Time) error {
 	err := c.db.Session.UpdateOneID(sessionID).SetExpiresAt(expiresAt).Exec(ctx)
 	if err != nil {
diff --git a/internal/database/client.go b/internal/database/client.go
index bb4053f2..8f014b01 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -23,7 +23,6 @@ type AuthClient interface {
 	FindAuthNonce(ctx context.Context, publicID string) (models.AuthNonce, error)
 	SetAuthNonceActive(ctx context.Context, nonceID string, active bool) error
 
-	UserFromSession(ctx context.Context, publicID string, opts ...UserGetOption) (models.User, error)
 	CreateSession(ctx context.Context, publicID, userID string, expiresAt time.Time, meta map[string]string) (models.Session, error)
 	SetSessionExpiresAt(ctx context.Context, sessionID string, expiresAt time.Time) error
 	FindSession(ctx context.Context, publicID string) (models.Session, error)

From 387f84d48d76d180143f25da9595a529cc18eb53 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 5 Jul 2024 21:05:27 -0400
Subject: [PATCH 285/341] changed handler url

---
 cmd/frontend/handlers.go               | 2 +-
 cmd/frontend/routes/app/index.templ    | 8 ++++----
 cmd/frontend/routes/app/index_templ.go | 4 ++--
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/cmd/frontend/handlers.go b/cmd/frontend/handlers.go
index 21ed5c83..7d4af1e4 100644
--- a/cmd/frontend/handlers.go
+++ b/cmd/frontend/handlers.go
@@ -95,7 +95,7 @@ func Handlers(core core.Client) ([]server.Handler, error) {
 			Func: handler.Chain(core, auth.DiscordRedirect),
 		},
 		{
-			Path: get("/api/auth/wargaming/{realm}"),
+			Path: get("/api/auth/wargaming/login/{realm}"),
 			Func: handler.Chain(core, auth.WargamingBegin),
 		},
 		{
diff --git a/cmd/frontend/routes/app/index.templ b/cmd/frontend/routes/app/index.templ
index f5f5fa7d..b1a41531 100644
--- a/cmd/frontend/routes/app/index.templ
+++ b/cmd/frontend/routes/app/index.templ
@@ -59,7 +59,7 @@ templ index(connections []connectionWithAccount, linkLimit int) {
 					<button tabindex="0" class="verify-button verify-button-large no-animation btn h-full rounded-md w-full">Link a new account</button>
 					<ul hx-boost="false" tabindex="0" class="dropdown-content menu bg-base-100 rounded-box z-[1] p-2 shadow w-full gap-1">
 						<li>
-							<a class="verify-button bg-base-200 flex flex-row align-center justify-between gap-1" href="/api/auth/wargaming/na">
+							<a class="verify-button bg-base-200 flex flex-row align-center justify-between gap-1" href="/api/auth/wargaming/login/na">
 								<span>North America</span>
 								<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="1.5" stroke="currentColor" class="size-3">
 									<path stroke-linecap="round" stroke-linejoin="round" d="M13.5 6H5.25A2.25 2.25 0 0 0 3 8.25v10.5A2.25 2.25 0 0 0 5.25 21h10.5A2.25 2.25 0 0 0 18 18.75V10.5m-10.5 6L21 3m0 0h-5.25M21 3v5.25"></path>
@@ -67,7 +67,7 @@ templ index(connections []connectionWithAccount, linkLimit int) {
 							</a>
 						</li>
 						<li>
-							<a class="verify-button bg-base-200 flex flex-row align-center justify-between gap-1" href="/api/auth/wargaming/eu">
+							<a class="verify-button bg-base-200 flex flex-row align-center justify-between gap-1" href="/api/auth/wargaming/login/eu">
 								<span>Europe</span>
 								<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="1.5" stroke="currentColor" class="size-3">
 									<path stroke-linecap="round" stroke-linejoin="round" d="M13.5 6H5.25A2.25 2.25 0 0 0 3 8.25v10.5A2.25 2.25 0 0 0 5.25 21h10.5A2.25 2.25 0 0 0 18 18.75V10.5m-10.5 6L21 3m0 0h-5.25M21 3v5.25"></path>
@@ -75,7 +75,7 @@ templ index(connections []connectionWithAccount, linkLimit int) {
 							</a>
 						</li>
 						<li>
-							<a class="verify-button bg-base-200 flex flex-row align-center justify-between gap-1" href="/api/auth/wargaming/as">
+							<a class="verify-button bg-base-200 flex flex-row align-center justify-between gap-1" href="/api/auth/wargaming/login/as">
 								<span>Asia</span>
 								<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="1.5" stroke="currentColor" class="size-3">
 									<path stroke-linecap="round" stroke-linejoin="round" d="M13.5 6H5.25A2.25 2.25 0 0 0 3 8.25v10.5A2.25 2.25 0 0 0 5.25 21h10.5A2.25 2.25 0 0 0 18 18.75V10.5m-10.5 6L21 3m0 0h-5.25M21 3v5.25"></path>
@@ -112,7 +112,7 @@ templ connectionCard(connection connectionWithAccount) {
 				</div>
 			</div>
 			if connection.Metadata["verified"] != true {
-				<form action={ templ.URL("/api/auth/wargaming/" + connection.Account.Realm) }>
+				<form action={ templ.URL("/api/auth/wargaming/login/" + connection.Account.Realm) }>
 					<button type="submit" class="verify-button btn btn-sm btn-info flex flex-row flex-nowrap items-center justify-between gap-1 font-normal">
 						<span>Verify</span>
 						<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="1.5" stroke="currentColor" class="size-3">
diff --git a/cmd/frontend/routes/app/index_templ.go b/cmd/frontend/routes/app/index_templ.go
index 35ff1a61..61702a47 100644
--- a/cmd/frontend/routes/app/index_templ.go
+++ b/cmd/frontend/routes/app/index_templ.go
@@ -95,7 +95,7 @@ func index(connections []connectionWithAccount, linkLimit int) templ.Component {
 			}
 		}
 		if len(connections) < linkLimit {
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"grow dropdown dropdown-hover\"><button tabindex=\"0\" class=\"verify-button verify-button-large no-animation btn h-full rounded-md w-full\">Link a new account</button><ul hx-boost=\"false\" tabindex=\"0\" class=\"dropdown-content menu bg-base-100 rounded-box z-[1] p-2 shadow w-full gap-1\"><li><a class=\"verify-button bg-base-200 flex flex-row align-center justify-between gap-1\" href=\"/api/auth/wargaming/na\"><span>North America</span> <svg xmlns=\"http://www.w3.org/2000/svg\" fill=\"none\" viewBox=\"0 0 24 24\" stroke-width=\"1.5\" stroke=\"currentColor\" class=\"size-3\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"M13.5 6H5.25A2.25 2.25 0 0 0 3 8.25v10.5A2.25 2.25 0 0 0 5.25 21h10.5A2.25 2.25 0 0 0 18 18.75V10.5m-10.5 6L21 3m0 0h-5.25M21 3v5.25\"></path></svg></a></li><li><a class=\"verify-button bg-base-200 flex flex-row align-center justify-between gap-1\" href=\"/api/auth/wargaming/eu\"><span>Europe</span> <svg xmlns=\"http://www.w3.org/2000/svg\" fill=\"none\" viewBox=\"0 0 24 24\" stroke-width=\"1.5\" stroke=\"currentColor\" class=\"size-3\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"M13.5 6H5.25A2.25 2.25 0 0 0 3 8.25v10.5A2.25 2.25 0 0 0 5.25 21h10.5A2.25 2.25 0 0 0 18 18.75V10.5m-10.5 6L21 3m0 0h-5.25M21 3v5.25\"></path></svg></a></li><li><a class=\"verify-button bg-base-200 flex flex-row align-center justify-between gap-1\" href=\"/api/auth/wargaming/as\"><span>Asia</span> <svg xmlns=\"http://www.w3.org/2000/svg\" fill=\"none\" viewBox=\"0 0 24 24\" stroke-width=\"1.5\" stroke=\"currentColor\" class=\"size-3\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"M13.5 6H5.25A2.25 2.25 0 0 0 3 8.25v10.5A2.25 2.25 0 0 0 5.25 21h10.5A2.25 2.25 0 0 0 18 18.75V10.5m-10.5 6L21 3m0 0h-5.25M21 3v5.25\"></path></svg></a></li></ul></div>")
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"grow dropdown dropdown-hover\"><button tabindex=\"0\" class=\"verify-button verify-button-large no-animation btn h-full rounded-md w-full\">Link a new account</button><ul hx-boost=\"false\" tabindex=\"0\" class=\"dropdown-content menu bg-base-100 rounded-box z-[1] p-2 shadow w-full gap-1\"><li><a class=\"verify-button bg-base-200 flex flex-row align-center justify-between gap-1\" href=\"/api/auth/wargaming/login/na\"><span>North America</span> <svg xmlns=\"http://www.w3.org/2000/svg\" fill=\"none\" viewBox=\"0 0 24 24\" stroke-width=\"1.5\" stroke=\"currentColor\" class=\"size-3\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"M13.5 6H5.25A2.25 2.25 0 0 0 3 8.25v10.5A2.25 2.25 0 0 0 5.25 21h10.5A2.25 2.25 0 0 0 18 18.75V10.5m-10.5 6L21 3m0 0h-5.25M21 3v5.25\"></path></svg></a></li><li><a class=\"verify-button bg-base-200 flex flex-row align-center justify-between gap-1\" href=\"/api/auth/wargaming/login/eu\"><span>Europe</span> <svg xmlns=\"http://www.w3.org/2000/svg\" fill=\"none\" viewBox=\"0 0 24 24\" stroke-width=\"1.5\" stroke=\"currentColor\" class=\"size-3\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"M13.5 6H5.25A2.25 2.25 0 0 0 3 8.25v10.5A2.25 2.25 0 0 0 5.25 21h10.5A2.25 2.25 0 0 0 18 18.75V10.5m-10.5 6L21 3m0 0h-5.25M21 3v5.25\"></path></svg></a></li><li><a class=\"verify-button bg-base-200 flex flex-row align-center justify-between gap-1\" href=\"/api/auth/wargaming/login/as\"><span>Asia</span> <svg xmlns=\"http://www.w3.org/2000/svg\" fill=\"none\" viewBox=\"0 0 24 24\" stroke-width=\"1.5\" stroke=\"currentColor\" class=\"size-3\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"M13.5 6H5.25A2.25 2.25 0 0 0 3 8.25v10.5A2.25 2.25 0 0 0 5.25 21h10.5A2.25 2.25 0 0 0 18 18.75V10.5m-10.5 6L21 3m0 0h-5.25M21 3v5.25\"></path></svg></a></li></ul></div>")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
@@ -197,7 +197,7 @@ func connectionCard(connection connectionWithAccount) templ.Component {
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
-			var templ_7745c5c3_Var8 templ.SafeURL = templ.URL("/api/auth/wargaming/" + connection.Account.Realm)
+			var templ_7745c5c3_Var8 templ.SafeURL = templ.URL("/api/auth/wargaming/login/" + connection.Account.Realm)
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(string(templ_7745c5c3_Var8)))
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err

From 2e9f674b193436a2c70cb38f6b2174ad66d69d53 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 5 Jul 2024 21:26:27 -0400
Subject: [PATCH 286/341] fixed linking

---
 cmd/frontend/routes/api/auth/wargaming.go |  7 ++-
 cmd/frontend/routes/app/index.templ       | 40 ++++++------
 cmd/frontend/routes/app/index_templ.go    | 74 +++++++++++++++--------
 3 files changed, 75 insertions(+), 46 deletions(-)

diff --git a/cmd/frontend/routes/api/auth/wargaming.go b/cmd/frontend/routes/api/auth/wargaming.go
index 99f917dd..e0072209 100644
--- a/cmd/frontend/routes/api/auth/wargaming.go
+++ b/cmd/frontend/routes/api/auth/wargaming.go
@@ -27,11 +27,13 @@ var WargamingRedirect handler.Endpoint = func(ctx *handler.Context) error {
 
 	token := ctx.Path("token")
 	if token == "" {
+		log.Debug().Msg("missing token")
 		return ctx.Redirect("/error?message=this verification link has expired", http.StatusTemporaryRedirect)
 	}
 
 	session, err := ctx.Database().FindSession(ctx.Context, token)
 	if err != nil {
+		log.Debug().Err(err).Msg("failed to find session")
 		return ctx.Redirect("/error?message=this verification link has expired", http.StatusTemporaryRedirect)
 	}
 	if session.Meta["flow"] != "wargaming-redirect" {
@@ -40,6 +42,7 @@ var WargamingRedirect handler.Endpoint = func(ctx *handler.Context) error {
 
 	user, err := ctx.Database().GetUserByID(ctx.Context, session.UserID, database.WithConnections())
 	if err != nil {
+		log.Debug().Err(err).Msg("failed to find user")
 		return ctx.Redirect("/error?message=this verification link has expired", http.StatusTemporaryRedirect)
 	}
 
@@ -91,13 +94,13 @@ var WargamingBegin handler.Endpoint = func(ctx *handler.Context) error {
 		return ctx.Redirect("/error?message=failed to start a new session", http.StatusTemporaryRedirect)
 	}
 
-	verifySession, err := ctx.Database().CreateSession(ctx.Context, verifySessionID, user.ID, time.Now().Add(time.Minute), map[string]string{"flow": "wargaming-redirect"})
+	verifySession, err := ctx.Database().CreateSession(ctx.Context, verifySessionID, user.ID, time.Now().Add(time.Minute*5), map[string]string{"flow": "wargaming-redirect"})
 	if err != nil {
 		log.Err(err).Str("userId", user.ID).Msg("failed to create a new user session for wargaming auth flow")
 		return ctx.Redirect("/error?message=failed to start a new session", http.StatusTemporaryRedirect)
 	}
 
-	redirectURL := fmt.Sprintf("%s?application_id=%s&redirect_uri=%s", baseWgURL, wargaming.PublicAppID, auth.NewWargamingAuthRedirectURL(verifySession.ID))
+	redirectURL := fmt.Sprintf("%s?application_id=%s&redirect_uri=%s", baseWgURL, wargaming.PublicAppID, auth.NewWargamingAuthRedirectURL(verifySession.PublicID))
 	return ctx.Redirect(redirectURL, http.StatusTemporaryRedirect)
 }
 
diff --git a/cmd/frontend/routes/app/index.templ b/cmd/frontend/routes/app/index.templ
index b1a41531..a4cff945 100644
--- a/cmd/frontend/routes/app/index.templ
+++ b/cmd/frontend/routes/app/index.templ
@@ -5,6 +5,7 @@ import (
 	"github.com/cufee/aftermath/cmd/frontend/handler"
 	"github.com/cufee/aftermath/cmd/frontend/layouts"
 	"github.com/cufee/aftermath/cmd/frontend/logic"
+	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
 	"net/http"
 	"time"
@@ -16,7 +17,7 @@ type connectionWithAccount struct {
 }
 
 var Index handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
-	user, err := ctx.SessionUser()
+	user, err := ctx.SessionUser(database.WithConnections())
 	if err != nil {
 		return nil, nil, ctx.Redirect("/login", http.StatusTemporaryRedirect)
 	}
@@ -42,17 +43,19 @@ var Index handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Compo
 		}
 	}
 
-	return layouts.Main, index(connections, 3), nil
+	return layouts.Main, index(user, connections, 3), nil
 }
 
-templ index(connections []connectionWithAccount, linkLimit int) {
+templ index(user *models.User, connections []connectionWithAccount, linkLimit int) {
 	<div class="flex flex-col items-center gap-4">
 		<div class="text-2xl font-bold">
 			Linked Accounts { fmt.Sprintf("%d/%d", len(connections),linkLimit) }
 		</div>
-		<div class="flex flex-row flex-wrap gap-2">
+		<div class="flex flex-col sm:flex-row sm:flex-wrap gap-2 w-full">
 			for _, connection:= range connections {
-				@connectionCard(connection)
+				<div class="flex grow">
+					@connectionCard(connection)
+				</div>
 			}
 			if len(connections) < linkLimit {
 				<div class="grow dropdown dropdown-hover">
@@ -86,30 +89,31 @@ templ index(connections []connectionWithAccount, linkLimit int) {
 				</div>
 			}
 		</div>
+		<div class="text-center">
+			{ user.ID }
+		</div>
 	</div>
 	@logic.EmbedMinifiedScript(verifyButtonExpiration(int(time.Minute*5)), int(time.Minute*5))
 }
 
 templ connectionCard(connection connectionWithAccount) {
-	<div class="rounded-md bg-base-300 flex flex-row grow overflow-hidden">
+	<div class="rounded-md bg-base-300 flex flex-row overflow-hidden grow">
 		<div class="p-1 bg-base-200 flex justify-center items-center h-full aspect-square">
 			<span class="font-bold">
 				{ connection.Account.Realm }
 			</span>
 		</div>
-		<div class="grow p-3 pr-0 flex flex-row gap-2 items-center justify-between">
-			<div class="grow flex flex-row gap-2 items-center">
-				<div class="flex flex-row gap-1 items-center">
-					<div class="text-lg line-clamp-1 break-all overflow-hidden">
-						{ connection.Account.Nickname }
-					</div>
-					<button class={ logic.StringIfElse("text-yellow-500", "", connection.Metadata["default"] == true) } disabled?={ connection.Metadata["default"] == true }>
-						<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="1.5" stroke="currentColor" class="size-4">
-							<path stroke-linecap="round" stroke-linejoin="round" d="M11.48 3.499a.562.562 0 0 1 1.04 0l2.125 5.111a.563.563 0 0 0 .475.345l5.518.442c.499.04.701.663.321.988l-4.204 3.602a.563.563 0 0 0-.182.557l1.285 5.385a.562.562 0 0 1-.84.61l-4.725-2.885a.562.562 0 0 0-.586 0L6.982 20.54a.562.562 0 0 1-.84-.61l1.285-5.386a.562.562 0 0 0-.182-.557l-4.204-3.602a.562.562 0 0 1 .321-.988l5.518-.442a.563.563 0 0 0 .475-.345L11.48 3.5Z"></path>
-						</svg>
-						<span class="hidden loading loading-xs text-base-content"></span>
-					</button>
+		<div class="p-3 pr-0 flex flex-row gap-2 items-center justify-between grow">
+			<div class="flex flex-row gap-1 items-center w-full">
+				<div class="text-lg break-all overflow-hidden line-clamp-1">
+					{ connection.Account.Nickname }
 				</div>
+				<button class={ logic.StringIfElse("text-yellow-500", "", connection.Metadata["default"] == true) } disabled?={ connection.Metadata["default"] == true }>
+					<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="1.5" stroke="currentColor" class="size-4">
+						<path stroke-linecap="round" stroke-linejoin="round" d="M11.48 3.499a.562.562 0 0 1 1.04 0l2.125 5.111a.563.563 0 0 0 .475.345l5.518.442c.499.04.701.663.321.988l-4.204 3.602a.563.563 0 0 0-.182.557l1.285 5.385a.562.562 0 0 1-.84.61l-4.725-2.885a.562.562 0 0 0-.586 0L6.982 20.54a.562.562 0 0 1-.84-.61l1.285-5.386a.562.562 0 0 0-.182-.557l-4.204-3.602a.562.562 0 0 1 .321-.988l5.518-.442a.563.563 0 0 0 .475-.345L11.48 3.5Z"></path>
+					</svg>
+					<span class="hidden loading loading-xs text-base-content"></span>
+				</button>
 			</div>
 			if connection.Metadata["verified"] != true {
 				<form action={ templ.URL("/api/auth/wargaming/login/" + connection.Account.Realm) }>
diff --git a/cmd/frontend/routes/app/index_templ.go b/cmd/frontend/routes/app/index_templ.go
index 61702a47..01596849 100644
--- a/cmd/frontend/routes/app/index_templ.go
+++ b/cmd/frontend/routes/app/index_templ.go
@@ -13,6 +13,7 @@ import (
 	"github.com/cufee/aftermath/cmd/frontend/handler"
 	"github.com/cufee/aftermath/cmd/frontend/layouts"
 	"github.com/cufee/aftermath/cmd/frontend/logic"
+	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
 	"net/http"
 	"time"
@@ -24,7 +25,7 @@ type connectionWithAccount struct {
 }
 
 var Index handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
-	user, err := ctx.SessionUser()
+	user, err := ctx.SessionUser(database.WithConnections())
 	if err != nil {
 		return nil, nil, ctx.Redirect("/login", http.StatusTemporaryRedirect)
 	}
@@ -50,10 +51,10 @@ var Index handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Compo
 		}
 	}
 
-	return layouts.Main, index(connections, 3), nil
+	return layouts.Main, index(user, connections, 3), nil
 }
 
-func index(connections []connectionWithAccount, linkLimit int) templ.Component {
+func index(user *models.User, connections []connectionWithAccount, linkLimit int) templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
@@ -78,21 +79,29 @@ func index(connections []connectionWithAccount, linkLimit int) templ.Component {
 		var templ_7745c5c3_Var2 string
 		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprintf("%d/%d", len(connections), linkLimit))
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/app/index.templ`, Line: 51, Col: 69}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/app/index.templ`, Line: 52, Col: 69}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div><div class=\"flex flex-row flex-wrap gap-2\">")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div><div class=\"flex flex-col sm:flex-row sm:flex-wrap gap-2 w-full\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		for _, connection := range connections {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"flex grow\">")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
 			templ_7745c5c3_Err = connectionCard(connection).Render(ctx, templ_7745c5c3_Buffer)
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
 		}
 		if len(connections) < linkLimit {
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"grow dropdown dropdown-hover\"><button tabindex=\"0\" class=\"verify-button verify-button-large no-animation btn h-full rounded-md w-full\">Link a new account</button><ul hx-boost=\"false\" tabindex=\"0\" class=\"dropdown-content menu bg-base-100 rounded-box z-[1] p-2 shadow w-full gap-1\"><li><a class=\"verify-button bg-base-200 flex flex-row align-center justify-between gap-1\" href=\"/api/auth/wargaming/login/na\"><span>North America</span> <svg xmlns=\"http://www.w3.org/2000/svg\" fill=\"none\" viewBox=\"0 0 24 24\" stroke-width=\"1.5\" stroke=\"currentColor\" class=\"size-3\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"M13.5 6H5.25A2.25 2.25 0 0 0 3 8.25v10.5A2.25 2.25 0 0 0 5.25 21h10.5A2.25 2.25 0 0 0 18 18.75V10.5m-10.5 6L21 3m0 0h-5.25M21 3v5.25\"></path></svg></a></li><li><a class=\"verify-button bg-base-200 flex flex-row align-center justify-between gap-1\" href=\"/api/auth/wargaming/login/eu\"><span>Europe</span> <svg xmlns=\"http://www.w3.org/2000/svg\" fill=\"none\" viewBox=\"0 0 24 24\" stroke-width=\"1.5\" stroke=\"currentColor\" class=\"size-3\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"M13.5 6H5.25A2.25 2.25 0 0 0 3 8.25v10.5A2.25 2.25 0 0 0 5.25 21h10.5A2.25 2.25 0 0 0 18 18.75V10.5m-10.5 6L21 3m0 0h-5.25M21 3v5.25\"></path></svg></a></li><li><a class=\"verify-button bg-base-200 flex flex-row align-center justify-between gap-1\" href=\"/api/auth/wargaming/login/as\"><span>Asia</span> <svg xmlns=\"http://www.w3.org/2000/svg\" fill=\"none\" viewBox=\"0 0 24 24\" stroke-width=\"1.5\" stroke=\"currentColor\" class=\"size-3\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"M13.5 6H5.25A2.25 2.25 0 0 0 3 8.25v10.5A2.25 2.25 0 0 0 5.25 21h10.5A2.25 2.25 0 0 0 18 18.75V10.5m-10.5 6L21 3m0 0h-5.25M21 3v5.25\"></path></svg></a></li></ul></div>")
@@ -100,6 +109,19 @@ func index(connections []connectionWithAccount, linkLimit int) templ.Component {
 				return templ_7745c5c3_Err
 			}
 		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div><div class=\"text-center\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var3 string
+		templ_7745c5c3_Var3, templ_7745c5c3_Err = templ.JoinStringErrs(user.ID)
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/app/index.templ`, Line: 93, Col: 12}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var3))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div></div>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
@@ -125,34 +147,34 @@ func connectionCard(connection connectionWithAccount) templ.Component {
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
-		templ_7745c5c3_Var3 := templ.GetChildren(ctx)
-		if templ_7745c5c3_Var3 == nil {
-			templ_7745c5c3_Var3 = templ.NopComponent
+		templ_7745c5c3_Var4 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var4 == nil {
+			templ_7745c5c3_Var4 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"rounded-md bg-base-300 flex flex-row grow overflow-hidden\"><div class=\"p-1 bg-base-200 flex justify-center items-center h-full aspect-square\"><span class=\"font-bold\">")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"rounded-md bg-base-300 flex flex-row overflow-hidden grow\"><div class=\"p-1 bg-base-200 flex justify-center items-center h-full aspect-square\"><span class=\"font-bold\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var4 string
-		templ_7745c5c3_Var4, templ_7745c5c3_Err = templ.JoinStringErrs(connection.Account.Realm)
+		var templ_7745c5c3_Var5 string
+		templ_7745c5c3_Var5, templ_7745c5c3_Err = templ.JoinStringErrs(connection.Account.Realm)
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/app/index.templ`, Line: 97, Col: 30}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/app/index.templ`, Line: 103, Col: 30}
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var4))
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var5))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</span></div><div class=\"grow p-3 pr-0 flex flex-row gap-2 items-center justify-between\"><div class=\"grow flex flex-row gap-2 items-center\"><div class=\"flex flex-row gap-1 items-center\"><div class=\"text-lg line-clamp-1 break-all overflow-hidden\">")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</span></div><div class=\"p-3 pr-0 flex flex-row gap-2 items-center justify-between grow\"><div class=\"flex flex-row gap-1 items-center w-full\"><div class=\"text-lg break-all overflow-hidden line-clamp-1\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var5 string
-		templ_7745c5c3_Var5, templ_7745c5c3_Err = templ.JoinStringErrs(connection.Account.Nickname)
+		var templ_7745c5c3_Var6 string
+		templ_7745c5c3_Var6, templ_7745c5c3_Err = templ.JoinStringErrs(connection.Account.Nickname)
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/app/index.templ`, Line: 104, Col: 35}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/app/index.templ`, Line: 109, Col: 34}
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var5))
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var6))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -160,8 +182,8 @@ func connectionCard(connection connectionWithAccount) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var6 = []any{logic.StringIfElse("text-yellow-500", "", connection.Metadata["default"] == true)}
-		templ_7745c5c3_Err = templ.RenderCSSItems(ctx, templ_7745c5c3_Buffer, templ_7745c5c3_Var6...)
+		var templ_7745c5c3_Var7 = []any{logic.StringIfElse("text-yellow-500", "", connection.Metadata["default"] == true)}
+		templ_7745c5c3_Err = templ.RenderCSSItems(ctx, templ_7745c5c3_Buffer, templ_7745c5c3_Var7...)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -169,12 +191,12 @@ func connectionCard(connection connectionWithAccount) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var7 string
-		templ_7745c5c3_Var7, templ_7745c5c3_Err = templ.JoinStringErrs(templ.CSSClasses(templ_7745c5c3_Var6).String())
+		var templ_7745c5c3_Var8 string
+		templ_7745c5c3_Var8, templ_7745c5c3_Err = templ.JoinStringErrs(templ.CSSClasses(templ_7745c5c3_Var7).String())
 		if templ_7745c5c3_Err != nil {
 			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/app/index.templ`, Line: 1, Col: 0}
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var7))
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var8))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -188,7 +210,7 @@ func connectionCard(connection connectionWithAccount) templ.Component {
 				return templ_7745c5c3_Err
 			}
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("><svg xmlns=\"http://www.w3.org/2000/svg\" fill=\"none\" viewBox=\"0 0 24 24\" stroke-width=\"1.5\" stroke=\"currentColor\" class=\"size-4\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"M11.48 3.499a.562.562 0 0 1 1.04 0l2.125 5.111a.563.563 0 0 0 .475.345l5.518.442c.499.04.701.663.321.988l-4.204 3.602a.563.563 0 0 0-.182.557l1.285 5.385a.562.562 0 0 1-.84.61l-4.725-2.885a.562.562 0 0 0-.586 0L6.982 20.54a.562.562 0 0 1-.84-.61l1.285-5.386a.562.562 0 0 0-.182-.557l-4.204-3.602a.562.562 0 0 1 .321-.988l5.518-.442a.563.563 0 0 0 .475-.345L11.48 3.5Z\"></path></svg> <span class=\"hidden loading loading-xs text-base-content\"></span></button></div></div>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("><svg xmlns=\"http://www.w3.org/2000/svg\" fill=\"none\" viewBox=\"0 0 24 24\" stroke-width=\"1.5\" stroke=\"currentColor\" class=\"size-4\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"M11.48 3.499a.562.562 0 0 1 1.04 0l2.125 5.111a.563.563 0 0 0 .475.345l5.518.442c.499.04.701.663.321.988l-4.204 3.602a.563.563 0 0 0-.182.557l1.285 5.385a.562.562 0 0 1-.84.61l-4.725-2.885a.562.562 0 0 0-.586 0L6.982 20.54a.562.562 0 0 1-.84-.61l1.285-5.386a.562.562 0 0 0-.182-.557l-4.204-3.602a.562.562 0 0 1 .321-.988l5.518-.442a.563.563 0 0 0 .475-.345L11.48 3.5Z\"></path></svg> <span class=\"hidden loading loading-xs text-base-content\"></span></button></div>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -197,8 +219,8 @@ func connectionCard(connection connectionWithAccount) templ.Component {
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
-			var templ_7745c5c3_Var8 templ.SafeURL = templ.URL("/api/auth/wargaming/login/" + connection.Account.Realm)
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(string(templ_7745c5c3_Var8)))
+			var templ_7745c5c3_Var9 templ.SafeURL = templ.URL("/api/auth/wargaming/login/" + connection.Account.Realm)
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(string(templ_7745c5c3_Var9)))
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}

From 41c0e0b6e4bf058762aa5d321db9f22b43028f7e Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Fri, 5 Jul 2024 21:35:04 -0400
Subject: [PATCH 287/341] updating all connections on verify

---
 cmd/frontend/routes/api/auth/wargaming.go | 34 +++++++++++++----------
 1 file changed, 19 insertions(+), 15 deletions(-)

diff --git a/cmd/frontend/routes/api/auth/wargaming.go b/cmd/frontend/routes/api/auth/wargaming.go
index e0072209..18bbb655 100644
--- a/cmd/frontend/routes/api/auth/wargaming.go
+++ b/cmd/frontend/routes/api/auth/wargaming.go
@@ -53,28 +53,32 @@ var WargamingRedirect handler.Endpoint = func(ctx *handler.Context) error {
 	}
 
 	connections, _ := user.FilterConnections(models.ConnectionTypeWargaming, nil)
+	var found bool
 	for _, conn := range connections {
+		conn.Metadata["default"] = conn.ReferenceID == accountID
 		if conn.ReferenceID == accountID {
-			conn.Metadata["default"] = true
 			conn.Metadata["verified"] = true
-			_, err := ctx.Database().UpsertConnection(ctx.Context, conn)
-			if err != nil {
-				return ctx.Error(err, "failed to update user connection")
-			}
-			return ctx.Redirect("/app?linked="+ctx.Query("nickname"), http.StatusTemporaryRedirect)
+			found = true
 		}
-	}
 
-	conn := models.UserConnection{
-		Type:        models.ConnectionTypeWargaming,
-		UserID:      user.ID,
-		ReferenceID: accountID,
-		Metadata:    map[string]any{"verified": true, "default": true},
+		_, err := ctx.Database().UpdateConnection(ctx.Context, conn)
+		if err != nil {
+			return ctx.Error(err, "failed to update user connection")
+		}
 	}
-	_, err = ctx.Database().UpsertConnection(ctx.Context, conn)
-	if err != nil {
-		return ctx.Error(err, "failed to update user connection")
+	if !found {
+		conn := models.UserConnection{
+			Type:        models.ConnectionTypeWargaming,
+			UserID:      user.ID,
+			ReferenceID: accountID,
+			Metadata:    map[string]any{"verified": true, "default": true},
+		}
+		_, err := ctx.Database().UpsertConnection(ctx.Context, conn)
+		if err != nil {
+			return ctx.Error(err, "failed to update user connection")
+		}
 	}
+
 	return ctx.Redirect("/app?linked="+ctx.Query("nickname"), http.StatusTemporaryRedirect)
 }
 

From 6ff53e22dc7eae1defa81ae457f33c9b2863f77b Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sat, 6 Jul 2024 19:34:12 -0400
Subject: [PATCH 288/341] improved linking flow, added a new command

---
 cmd/discord/commands/links.go                 |  22 +++
 cmd/frontend/assets/assets.go                 |   3 -
 .../assets/{ => generate}/bg-default.jpg      | Bin
 cmd/frontend/assets/generate/blitz-logo.png   | Bin 0 -> 169063 bytes
 cmd/frontend/assets/generate/gen.go           |   3 +
 .../assets/{gen.go => generate/generate.go}   |  77 ++++++++--
 cmd/frontend/assets/generate/link.png         | Bin 0 -> 7344 bytes
 cmd/frontend/components/head.templ            |  12 +-
 cmd/frontend/components/head_templ.go         |  23 ++-
 cmd/frontend/components/navbar.templ          |   3 -
 cmd/frontend/components/navbar_templ.go       |   5 +-
 cmd/frontend/components/widget/widget.templ   |   5 +-
 .../components/widget/widget_templ.go         |  39 +++++-
 cmd/frontend/handler/context.go               |  49 ++++---
 cmd/frontend/handler/head.go                  |  58 ++++++++
 cmd/frontend/handlers.go                      |  10 ++
 cmd/frontend/layouts/main.templ               |   6 +-
 cmd/frontend/layouts/main_templ.go            |   6 +-
 cmd/frontend/logic/discord/oauth.go           |  18 +--
 cmd/frontend/middleware/auth.go               |  27 ++++
 cmd/frontend/public/og-verify.jpg             | Bin 0 -> 13625 bytes
 cmd/frontend/public/og-widget.jpg             | Bin 16098 -> 11274 bytes
 cmd/frontend/public/og.jpg                    | Bin 16098 -> 11274 bytes
 cmd/frontend/routes/api/auth/discord.go       |   2 +-
 cmd/frontend/routes/api/auth/wargaming.go     |   6 +-
 cmd/frontend/routes/linked.templ              |  30 ++++
 cmd/frontend/routes/linked_templ.go           |  72 ++++++++++
 cmd/frontend/routes/login.go                  |   9 +-
 .../routes/redirect/discord_verify.templ      |  38 +++++
 .../routes/redirect/discord_verify_templ.go   | 131 ++++++++++++++++++
 cmd/frontend/routes/widget/index.templ        |   6 +-
 cmd/frontend/routes/widget/index_templ.go     |   6 +-
 dev_web.go                                    |   5 +-
 go.mod                                        |   3 +
 go.sum                                        |  40 ++++--
 internal/constants/core.go                    |  15 ++
 internal/constants/database.go                |   6 +
 internal/constants/discord.go                 |  24 ++++
 internal/constants/env.go                     |  19 +++
 internal/constants/external.go                |  40 ++++++
 internal/constants/web.go                     |  13 ++
 internal/external/wargaming/client.go         |  21 +--
 main.go                                       |  51 +++----
 static/localization/en/discord.yaml           |   6 +
 44 files changed, 758 insertions(+), 151 deletions(-)
 delete mode 100644 cmd/frontend/assets/assets.go
 rename cmd/frontend/assets/{ => generate}/bg-default.jpg (100%)
 create mode 100644 cmd/frontend/assets/generate/blitz-logo.png
 create mode 100644 cmd/frontend/assets/generate/gen.go
 rename cmd/frontend/assets/{gen.go => generate/generate.go} (58%)
 create mode 100644 cmd/frontend/assets/generate/link.png
 create mode 100644 cmd/frontend/handler/head.go
 create mode 100644 cmd/frontend/public/og-verify.jpg
 create mode 100644 cmd/frontend/routes/linked.templ
 create mode 100644 cmd/frontend/routes/linked_templ.go
 create mode 100644 cmd/frontend/routes/redirect/discord_verify.templ
 create mode 100644 cmd/frontend/routes/redirect/discord_verify_templ.go
 create mode 100644 internal/constants/core.go
 create mode 100644 internal/constants/database.go
 create mode 100644 internal/constants/discord.go
 create mode 100644 internal/constants/env.go
 create mode 100644 internal/constants/external.go
 create mode 100644 internal/constants/web.go

diff --git a/cmd/discord/commands/links.go b/cmd/discord/commands/links.go
index 506d2a3d..691e5a9f 100644
--- a/cmd/discord/commands/links.go
+++ b/cmd/discord/commands/links.go
@@ -10,6 +10,7 @@ import (
 	"github.com/bwmarrin/discordgo"
 	"github.com/cufee/aftermath/cmd/discord/commands/builder"
 	"github.com/cufee/aftermath/cmd/discord/common"
+	"github.com/cufee/aftermath/internal/constants"
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
 )
@@ -49,6 +50,21 @@ func init() {
 							Autocomplete().
 							Required(),
 					),
+				builder.NewOption("verify", discordgo.ApplicationCommandOptionSubCommand).
+					Params(builder.SetNameKey("command_option_links_verify_name"), builder.SetDescKey("command_option_links_verify_desc")).
+					Options(
+						builder.NewOption("server", discordgo.ApplicationCommandOptionString).
+							Required().
+							Params(
+								builder.SetNameKey("common_option_stats_realm_name"),
+								builder.SetDescKey("common_option_stats_realm_description"),
+							).
+							Choices(
+								builder.NewChoice("realm_na", "NA").Params(builder.SetNameKey("common_label_realm_na")),
+								builder.NewChoice("realm_eu", "EU").Params(builder.SetNameKey("common_label_realm_eu")),
+								builder.NewChoice("realm_as", "AS").Params(builder.SetNameKey("common_label_realm_as")),
+							),
+					),
 
 				builder.NewOption("view", discordgo.ApplicationCommandOptionSubCommand).
 					Params(builder.SetNameKey("command_option_links_view_name"), builder.SetDescKey("command_option_links_view_desc")),
@@ -67,6 +83,12 @@ func init() {
 				default:
 					return ctx.Error("received an unexpected subcommand: " + subcommand)
 
+				case "verify":
+					options := getDefaultStatsOptions(subOptions)
+					realm := strings.ToLower(options.Server)
+					loginURL := fmt.Sprintf("%s/r/verify/%s", constants.FrontendURL, realm)
+					return ctx.Reply().Format("command_links_verify_response_fmt", ctx.Localize("common_label_realm_"+realm), loginURL).Send()
+
 				case "favorite":
 					value, _ := subOptions.Value("selected").(string)
 					parts := strings.Split(value, "#")
diff --git a/cmd/frontend/assets/assets.go b/cmd/frontend/assets/assets.go
deleted file mode 100644
index 85f48bc9..00000000
--- a/cmd/frontend/assets/assets.go
+++ /dev/null
@@ -1,3 +0,0 @@
-package assets
-
-//go:generate go run gen.go
diff --git a/cmd/frontend/assets/bg-default.jpg b/cmd/frontend/assets/generate/bg-default.jpg
similarity index 100%
rename from cmd/frontend/assets/bg-default.jpg
rename to cmd/frontend/assets/generate/bg-default.jpg
diff --git a/cmd/frontend/assets/generate/blitz-logo.png b/cmd/frontend/assets/generate/blitz-logo.png
new file mode 100644
index 0000000000000000000000000000000000000000..9e97666ab7edfe2c71d515b7abda3124afeeba9b
GIT binary patch
literal 169063
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%0DMiiVjPirsfos&ggdRK%AfT
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

literal 0
HcmV?d00001

diff --git a/cmd/frontend/assets/generate/gen.go b/cmd/frontend/assets/generate/gen.go
new file mode 100644
index 00000000..0cb8d24e
--- /dev/null
+++ b/cmd/frontend/assets/generate/gen.go
@@ -0,0 +1,3 @@
+package generate
+
+//go:generate go run ./generate.go
diff --git a/cmd/frontend/assets/gen.go b/cmd/frontend/assets/generate/generate.go
similarity index 58%
rename from cmd/frontend/assets/gen.go
rename to cmd/frontend/assets/generate/generate.go
index 53476f65..0d5acd21 100644
--- a/cmd/frontend/assets/gen.go
+++ b/cmd/frontend/assets/generate/generate.go
@@ -4,6 +4,7 @@ package main
 
 import (
 	"fmt"
+	"image/color"
 	"image/png"
 	"os"
 	"path/filepath"
@@ -15,6 +16,10 @@ import (
 	"github.com/rs/zerolog/log"
 )
 
+var outDirPath = "../../public"
+
+var cardColor = color.RGBA{17, 17, 17, 255}
+
 func main() {
 	generateWN8Icons()
 	generateLogoOptions()
@@ -34,7 +39,7 @@ func generateWN8Icons() {
 		{
 			filename := assets.WN8IconFilename(float32(tier))
 			img := common.AftermathLogo(color, common.DefaultLogoOptions())
-			f, err := os.Create(filepath.Join("../public", "wn8", filename))
+			f, err := os.Create(filepath.Join(outDirPath, "wn8", filename))
 			if err != nil {
 				panic(err)
 			}
@@ -47,7 +52,7 @@ func generateWN8Icons() {
 		{
 			filename := "small_" + assets.WN8IconFilename(float32(tier))
 			img := common.AftermathLogo(color, common.SmallLogoOptions())
-			f, err := os.Create(filepath.Join("../public", "wn8", filename))
+			f, err := os.Create(filepath.Join(outDirPath, "wn8", filename))
 			if err != nil {
 				panic(err)
 			}
@@ -73,7 +78,7 @@ func generateLogoOptions() {
 		opts.LineWidth *= 10
 
 		img := common.AftermathLogo(common.ColorAftermathRed, opts)
-		f, err := os.Create(filepath.Join("../public", filename))
+		f, err := os.Create(filepath.Join(outDirPath, filename))
 		if err != nil {
 			panic(err)
 		}
@@ -89,10 +94,15 @@ func generateOGImages() {
 	log.Debug().Msg("generating og images")
 
 	imageWidth := 512
-	imageHeight := imageWidth * 2 / 3
-	logoSize := imageHeight * 2 / 3
+	imageHeight := imageWidth * 2 / 4
+	logoSize := imageHeight * 1 / 2
 	borderWidth := 2
 
+	bg, err := imaging.Open("./bg-default.jpg")
+	if err != nil {
+		panic(err)
+	}
+
 	{
 		filename := "og-widget.jpg"
 		opts := common.DefaultLogoOptions()
@@ -104,19 +114,44 @@ func generateOGImages() {
 		logo := common.AftermathLogo(common.ColorAftermathRed, opts)
 		ctx := gg.NewContext(imageWidth, imageHeight)
 
-		bg, err := imaging.Open("./bg-default.jpg")
+		ctx.DrawImage(imaging.Blur(imaging.Fill(bg, imageWidth, imageHeight, imaging.Center, imaging.Lanczos), 30), 0, 0)
+		ctx.DrawRoundedRectangle(float64(borderWidth), float64(borderWidth), float64(imageWidth-borderWidth*2), float64(imageHeight-borderWidth*2), 20)
+		ctx.SetColor(cardColor)
+		ctx.Fill()
+
+		ctx.DrawImageAnchored(imaging.Fit(logo, logoSize, logoSize, imaging.Linear), imageWidth/2, imageHeight/2, 0.5, 0.5)
+
+		f, err := os.Create(filepath.Join(outDirPath, filename))
+		if err != nil {
+			panic(err)
+		}
+
+		err = imaging.Encode(f, ctx.Image(), imaging.JPEG)
 		if err != nil {
 			panic(err)
 		}
+		f.Close()
+	}
+
+	{
+		filename := "og.jpg"
+		opts := common.DefaultLogoOptions()
+		opts.Gap *= 10
+		opts.Jump *= 10
+		opts.LineStep *= 10
+		opts.LineWidth *= 10
+
+		logo := common.AftermathLogo(common.ColorAftermathRed, opts)
+		ctx := gg.NewContext(imageWidth, imageHeight)
 
 		ctx.DrawImage(imaging.Blur(imaging.Fill(bg, imageWidth, imageHeight, imaging.Center, imaging.Lanczos), 30), 0, 0)
 		ctx.DrawRoundedRectangle(float64(borderWidth), float64(borderWidth), float64(imageWidth-borderWidth*2), float64(imageHeight-borderWidth*2), 20)
-		ctx.SetColor(common.DefaultCardColorNoAlpha)
+		ctx.SetColor(cardColor)
 		ctx.Fill()
 
 		ctx.DrawImageAnchored(imaging.Fit(logo, logoSize, logoSize, imaging.Linear), imageWidth/2, imageHeight/2, 0.5, 0.5)
 
-		f, err := os.Create(filepath.Join("../public", filename))
+		f, err := os.Create(filepath.Join(outDirPath, filename))
 		if err != nil {
 			panic(err)
 		}
@@ -129,7 +164,7 @@ func generateOGImages() {
 	}
 
 	{
-		filename := "og.jpg"
+		filename := "og-verify.jpg"
 		opts := common.DefaultLogoOptions()
 		opts.Gap *= 10
 		opts.Jump *= 10
@@ -139,19 +174,35 @@ func generateOGImages() {
 		logo := common.AftermathLogo(common.ColorAftermathRed, opts)
 		ctx := gg.NewContext(imageWidth, imageHeight)
 
-		bg, err := imaging.Open("./bg-default.jpg")
+		linkIcon, err := imaging.Open("./link.png")
+		if err != nil {
+			panic(err)
+		}
+		blitzLogo, err := imaging.Open("./blitz-logo.png")
 		if err != nil {
 			panic(err)
 		}
 
+		// each logo should take 1/3 of the total height available
+		heightAvailable := imageHeight - borderWidth*2
+		widthAvailable := imageWidth - borderWidth*2
+		singleLogoSize := heightAvailable / 3
+		// link icon should be centered, other icons should be moved a specific distance away from it
+		linkIconSize := 32 // px
+		imageGap := 32     // px
+		padding := (widthAvailable-linkIconSize-singleLogoSize*2-imageGap*2)/2 + borderWidth*2
+		// we can now draw padding - logo - gap - link - gap - logo
+
 		ctx.DrawImage(imaging.Blur(imaging.Fill(bg, imageWidth, imageHeight, imaging.Center, imaging.Lanczos), 30), 0, 0)
 		ctx.DrawRoundedRectangle(float64(borderWidth), float64(borderWidth), float64(imageWidth-borderWidth*2), float64(imageHeight-borderWidth*2), 20)
-		ctx.SetColor(common.DefaultCardColorNoAlpha)
+		ctx.SetColor(cardColor)
 		ctx.Fill()
 
-		ctx.DrawImageAnchored(imaging.Fit(logo, logoSize, logoSize, imaging.Linear), imageWidth/2, imageHeight/2, 0.5, 0.5)
+		ctx.DrawImage(imaging.Fill(logo, singleLogoSize, singleLogoSize, imaging.Center, imaging.Lanczos), padding, imageHeight/2-singleLogoSize/2)
+		ctx.DrawImage(imaging.Fill(linkIcon, linkIconSize, linkIconSize, imaging.Center, imaging.Lanczos), padding+singleLogoSize+imageGap, imageHeight/2-linkIconSize/2)
+		ctx.DrawImage(imaging.Fill(blitzLogo, singleLogoSize, singleLogoSize, imaging.Center, imaging.Lanczos), padding+singleLogoSize+imageGap+linkIconSize+imageGap, imageHeight/2-singleLogoSize/2)
 
-		f, err := os.Create(filepath.Join("../public", filename))
+		f, err := os.Create(filepath.Join(outDirPath, filename))
 		if err != nil {
 			panic(err)
 		}
diff --git a/cmd/frontend/assets/generate/link.png b/cmd/frontend/assets/generate/link.png
new file mode 100644
index 0000000000000000000000000000000000000000..ac13c193cf68d0146fb11cbb9fd7a6f7510755dc
GIT binary patch
literal 7344
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
WIxsNX!ogqw0000<MNUMnLSTZCg*5*F

literal 0
HcmV?d00001

diff --git a/cmd/frontend/components/head.templ b/cmd/frontend/components/head.templ
index caa5473b..469aef89 100644
--- a/cmd/frontend/components/head.templ
+++ b/cmd/frontend/components/head.templ
@@ -1,8 +1,11 @@
 package components
 
-import "github.com/cufee/aftermath/cmd/frontend/logic"
+import (
+	"github.com/cufee/aftermath/cmd/frontend/logic"
+	"github.com/cufee/aftermath/internal/constants"
+)
 
-templ Head() {
+templ Head(additional ...templ.Component) {
 	<head>
 		<meta charset="utf-8"/>
 		<meta name="color-scheme" content="light"/>
@@ -13,7 +16,10 @@ templ Head() {
 		<script src="https://unpkg.com/htmx.org@1.9.12/dist/ext/multi-swap.js"></script>
 		<script src="https://cdn.tailwindcss.com"></script>
 		@logic.EmbedMinifiedScript(tailwindConfig())
-		<title>{ appName }</title>
+		<title>{ constants.FrontendAppName }</title>
+		for _, component := range additional {
+			@component
+		}
 	</head>
 }
 
diff --git a/cmd/frontend/components/head_templ.go b/cmd/frontend/components/head_templ.go
index 2ea807a1..ca4a3a6e 100644
--- a/cmd/frontend/components/head_templ.go
+++ b/cmd/frontend/components/head_templ.go
@@ -8,9 +8,12 @@ package components
 import "github.com/a-h/templ"
 import templruntime "github.com/a-h/templ/runtime"
 
-import "github.com/cufee/aftermath/cmd/frontend/logic"
+import (
+	"github.com/cufee/aftermath/cmd/frontend/logic"
+	"github.com/cufee/aftermath/internal/constants"
+)
 
-func Head() templ.Component {
+func Head(additional ...templ.Component) templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
@@ -41,15 +44,25 @@ func Head() templ.Component {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var2 string
-		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(appName)
+		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(constants.FrontendAppName)
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/head.templ`, Line: 16, Col: 18}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/head.templ`, Line: 19, Col: 36}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</title></head>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</title>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		for _, component := range additional {
+			templ_7745c5c3_Err = component.Render(ctx, templ_7745c5c3_Buffer)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</head>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
diff --git a/cmd/frontend/components/navbar.templ b/cmd/frontend/components/navbar.templ
index f437f5f2..40594695 100644
--- a/cmd/frontend/components/navbar.templ
+++ b/cmd/frontend/components/navbar.templ
@@ -3,12 +3,9 @@ package components
 import (
 	"github.com/cufee/aftermath/cmd/frontend/handler"
 	"github.com/cufee/aftermath/cmd/frontend/logic"
-	"os"
 	"strings"
 )
 
-var appName = os.Getenv("WEBAPP_NAME")
-
 type navbarProps struct {
 	authenticated bool
 	path          string
diff --git a/cmd/frontend/components/navbar_templ.go b/cmd/frontend/components/navbar_templ.go
index 17e5f998..75e62056 100644
--- a/cmd/frontend/components/navbar_templ.go
+++ b/cmd/frontend/components/navbar_templ.go
@@ -11,12 +11,9 @@ import templruntime "github.com/a-h/templ/runtime"
 import (
 	"github.com/cufee/aftermath/cmd/frontend/handler"
 	"github.com/cufee/aftermath/cmd/frontend/logic"
-	"os"
 	"strings"
 )
 
-var appName = os.Getenv("WEBAPP_NAME")
-
 type navbarProps struct {
 	authenticated bool
 	path          string
@@ -296,7 +293,7 @@ func navMenuLink(label, href, currentPath string) templ.Component {
 		var templ_7745c5c3_Var18 string
 		templ_7745c5c3_Var18, templ_7745c5c3_Err = templ.JoinStringErrs(label)
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/navbar.templ`, Line: 91, Col: 78}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/navbar.templ`, Line: 88, Col: 78}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var18))
 		if templ_7745c5c3_Err != nil {
diff --git a/cmd/frontend/components/widget/widget.templ b/cmd/frontend/components/widget/widget.templ
index be9ce894..e3be364d 100644
--- a/cmd/frontend/components/widget/widget.templ
+++ b/cmd/frontend/components/widget/widget.templ
@@ -3,6 +3,7 @@ package widget
 import (
 	"fmt"
 	"github.com/cufee/aftermath/cmd/frontend/logic"
+	"github.com/cufee/aftermath/internal/constants"
 	"github.com/cufee/aftermath/internal/database/models"
 	prepare "github.com/cufee/aftermath/internal/stats/prepare/session/v1"
 )
@@ -78,12 +79,12 @@ templ (w widget) Render() {
 		<title>Aftermath - { w.account.Nickname }</title>
 		<meta property="og:type" content="website"/>
 		<meta property="og:title" content="Aftermath - Streaming Widget"/>
-		<meta property="og:image" content="https://amth.one/assets/og-widget.jpg"/>
+		<meta property="og:image" content={ constants.FrontendURL + "/assets/og-widget.jpg" }/>
 		<meta property="og:description" content={ fmt.Sprintf("Aftermath streaming widget for %s [%s]", w.account.Nickname, w.account.Realm) }/>
 		<meta name="twitter:card" content="summary_large_image"/>
 		<meta name="twitter:title" content="Aftermath - Streaming Widget"/>
 		<meta name="twitter:image:alt" content="Aftermath Streaming Widget"/>
-		<meta name="twitter:image" content="https://amth.one/assets/og-widget.jpg"/>
+		<meta name="twitter:image" content={ constants.FrontendURL + "/assets/og-widget.jpg" }/>
 		<meta name="twitter:description" content={ fmt.Sprintf("Aftermath streaming widget for %s [%s]", w.account.Nickname, w.account.Realm) }/>
 	</head>
 	<div class="text-nowrap whitespace-nowrap" id="widget-container">
diff --git a/cmd/frontend/components/widget/widget_templ.go b/cmd/frontend/components/widget/widget_templ.go
index d0e9334f..1428a829 100644
--- a/cmd/frontend/components/widget/widget_templ.go
+++ b/cmd/frontend/components/widget/widget_templ.go
@@ -11,6 +11,7 @@ import templruntime "github.com/a-h/templ/runtime"
 import (
 	"fmt"
 	"github.com/cufee/aftermath/cmd/frontend/logic"
+	"github.com/cufee/aftermath/internal/constants"
 	"github.com/cufee/aftermath/internal/database/models"
 	prepare "github.com/cufee/aftermath/internal/stats/prepare/session/v1"
 )
@@ -106,38 +107,64 @@ func (w widget) Render() templ.Component {
 		var templ_7745c5c3_Var2 string
 		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(w.account.Nickname)
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/widget.templ`, Line: 78, Col: 41}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/widget.templ`, Line: 79, Col: 41}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</title><meta property=\"og:type\" content=\"website\"><meta property=\"og:title\" content=\"Aftermath - Streaming Widget\"><meta property=\"og:image\" content=\"https://amth.one/assets/og-widget.jpg\"><meta property=\"og:description\" content=\"")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</title><meta property=\"og:type\" content=\"website\"><meta property=\"og:title\" content=\"Aftermath - Streaming Widget\"><meta property=\"og:image\" content=\"")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var3 string
-		templ_7745c5c3_Var3, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprintf("Aftermath streaming widget for %s [%s]", w.account.Nickname, w.account.Realm))
+		templ_7745c5c3_Var3, templ_7745c5c3_Err = templ.JoinStringErrs(constants.FrontendURL + "/assets/og-widget.jpg")
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/widget.templ`, Line: 82, Col: 134}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/widget.templ`, Line: 82, Col: 85}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var3))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><meta name=\"twitter:card\" content=\"summary_large_image\"><meta name=\"twitter:title\" content=\"Aftermath - Streaming Widget\"><meta name=\"twitter:image:alt\" content=\"Aftermath Streaming Widget\"><meta name=\"twitter:image\" content=\"https://amth.one/assets/og-widget.jpg\"><meta name=\"twitter:description\" content=\"")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><meta property=\"og:description\" content=\"")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var4 string
 		templ_7745c5c3_Var4, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprintf("Aftermath streaming widget for %s [%s]", w.account.Nickname, w.account.Realm))
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/widget.templ`, Line: 87, Col: 135}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/widget.templ`, Line: 83, Col: 134}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var4))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><meta name=\"twitter:card\" content=\"summary_large_image\"><meta name=\"twitter:title\" content=\"Aftermath - Streaming Widget\"><meta name=\"twitter:image:alt\" content=\"Aftermath Streaming Widget\"><meta name=\"twitter:image\" content=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var5 string
+		templ_7745c5c3_Var5, templ_7745c5c3_Err = templ.JoinStringErrs(constants.FrontendURL + "/assets/og-widget.jpg")
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/widget.templ`, Line: 87, Col: 86}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var5))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><meta name=\"twitter:description\" content=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var6 string
+		templ_7745c5c3_Var6, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprintf("Aftermath streaming widget for %s [%s]", w.account.Nickname, w.account.Realm))
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/widget.templ`, Line: 88, Col: 135}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var6))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"></head><div class=\"text-nowrap whitespace-nowrap\" id=\"widget-container\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
diff --git a/cmd/frontend/handler/context.go b/cmd/frontend/handler/context.go
index e3fdfe95..d4c233ce 100644
--- a/cmd/frontend/handler/context.go
+++ b/cmd/frontend/handler/context.go
@@ -33,6 +33,7 @@ type Context struct {
 
 	user        *models.User
 	userOptions database.UserGetOptions
+	session     *models.Session
 
 	w http.ResponseWriter
 	r *http.Request
@@ -87,21 +88,9 @@ func (ctx *Context) Identifier() (string, error) {
 	return "", errors.New("failed to extract ip address")
 }
 
-func (ctx *Context) SessionUser(o ...database.UserGetOption) (*models.User, error) {
-	var opts database.UserGetOptions = o
-
-	// if dev mode is on, we just grab a pre-defined user from the database, expecting it to exist
-	if devMode {
-		user, err := ctx.Database().GetUserByID(ctx.Context, "dev-user", opts...)
-		if err != nil {
-			panic(err)
-		}
-		return &user, nil
-	}
-
-	// if the user already exists and options are equal, return cached user
-	if ctx.user != nil && ctx.userOptions.ToOptions() == opts.ToOptions() {
-		return ctx.user, nil
+func (ctx *Context) Session() (*models.Session, error) {
+	if ctx.session != nil {
+		return ctx.session, nil
 	}
 
 	cookie, err := ctx.Cookie(auth.SessionCookieName)
@@ -122,6 +111,30 @@ func (ctx *Context) SessionUser(o ...database.UserGetOption) (*models.User, erro
 	if session.ExpiresAt.Before(time.Now()) {
 		return nil, ErrSessionNotFound
 	}
+	return &session, nil
+}
+
+func (ctx *Context) SessionUser(o ...database.UserGetOption) (*models.User, error) {
+	var opts database.UserGetOptions = o
+
+	// if dev mode is on, we just grab a pre-defined user from the database, expecting it to exist
+	if devMode {
+		user, err := ctx.Database().GetUserByID(ctx.Context, "dev-user", opts...)
+		if err != nil {
+			panic(err)
+		}
+		return &user, nil
+	}
+
+	// if the user already exists and options are equal, return cached user
+	if ctx.user != nil && ctx.userOptions.ToOptions() == opts.ToOptions() {
+		return ctx.user, nil
+	}
+
+	session, err := ctx.Session()
+	if err != nil {
+		return nil, err
+	}
 
 	user, err := ctx.Database().GetUserByID(ctx.Context, session.UserID, opts...)
 	if err != nil {
@@ -202,12 +215,14 @@ func (page Page) Serve(ctx *Context) error {
 		return nil
 	}
 
-	err = withLayout.Render(ctx.Context, ctx.w)
+	buf := templ.GetBuffer()
+	err = withLayout.Render(ctx.Context, buf)
 	if err != nil {
 		return ctx.Error(err, "failed to render content")
 	}
 
-	return nil
+	// find head tags that were included in the body and merge them into layout head
+	return mergeBodyHeadTags(buf, ctx.w)
 }
 
 func (endpoint Endpoint) Serve(ctx *Context) error {
diff --git a/cmd/frontend/handler/head.go b/cmd/frontend/handler/head.go
new file mode 100644
index 00000000..71f3492d
--- /dev/null
+++ b/cmd/frontend/handler/head.go
@@ -0,0 +1,58 @@
+package handler
+
+import (
+	"errors"
+	"io"
+
+	"github.com/PuerkitoBio/goquery"
+)
+
+/*
+Merges the <head> found inside <body> into document <head>.
+  - document is parsed from r using goquery and the result is written to w
+*/
+func mergeBodyHeadTags(r io.Reader, w io.Writer) error {
+	headTags := []string{"meta", "link", "title", "style"}
+
+	doc, err := goquery.NewDocumentFromReader(r)
+	if err != nil {
+		return errors.Join(errors.New("goquery.NewDocumentFromReader"), err)
+	}
+
+	var headTagNodes []*goquery.Selection
+	for _, tag := range headTags {
+		doc.Find("body").Find(tag).Each(func(i int, s *goquery.Selection) {
+			headTagNodes = append(headTagNodes, s.Remove())
+		})
+	}
+
+	for _, bodyNode := range headTagNodes {
+		name := bodyNode.Get(0).Data
+		head := doc.Find("head")
+		if head.Length() == 0 {
+			doc.Add("head").AppendSelection(bodyNode)
+			continue
+		}
+
+		currentHeadTags := head.Find(name)
+		currentHeadTags.Each(func(i int, s *goquery.Selection) {
+			if shouldMergeTags(s, bodyNode) {
+				s.Remove()
+				return
+			}
+		})
+		doc.Find("head").AppendSelection(bodyNode)
+	}
+
+	rendered, err := doc.Html()
+	if err != nil {
+		return err
+	}
+
+	_, err = w.Write([]byte(rendered))
+	return err
+}
+
+func shouldMergeTags(head, body *goquery.Selection) bool {
+	return body.Get(0).Data == "title" || (body.Get(0).Data == "meta" && (head.AttrOr("property", "#h") == body.AttrOr("property", "#b") || head.AttrOr("name", "#h") == body.AttrOr("name", "#b")))
+}
diff --git a/cmd/frontend/handlers.go b/cmd/frontend/handlers.go
index 7d4af1e4..af59ee6d 100644
--- a/cmd/frontend/handlers.go
+++ b/cmd/frontend/handlers.go
@@ -14,6 +14,7 @@ import (
 	"github.com/cufee/aftermath/cmd/frontend/routes/api/auth"
 	aWidget "github.com/cufee/aftermath/cmd/frontend/routes/api/widget"
 	"github.com/cufee/aftermath/cmd/frontend/routes/app"
+	r "github.com/cufee/aftermath/cmd/frontend/routes/redirect"
 	"github.com/cufee/aftermath/cmd/frontend/routes/widget"
 	"github.com/pkg/errors"
 )
@@ -59,6 +60,10 @@ func Handlers(core core.Client) ([]server.Handler, error) {
 			Path: get("/login"),
 			Func: handler.Chain(core, routes.Login),
 		},
+		{
+			Path: get("/linked"),
+			Func: handler.Chain(core, routes.AccountLinked),
+		},
 		// widget
 		{
 			Path: get("/widget"),
@@ -110,6 +115,11 @@ func Handlers(core core.Client) ([]server.Handler, error) {
 			Path: get("/api/widget/{accountId}"),
 			Func: handler.Chain(core, aWidget.AccountWidget),
 		},
+		// redirects
+		{
+			Path: get("/r/verify/{realm}"),
+			Func: handler.Chain(core, r.VerifyFromDiscord),
+		},
 	}, nil
 }
 
diff --git a/cmd/frontend/layouts/main.templ b/cmd/frontend/layouts/main.templ
index cf4276c8..d39ee89a 100644
--- a/cmd/frontend/layouts/main.templ
+++ b/cmd/frontend/layouts/main.templ
@@ -11,13 +11,13 @@ var Main handler.Layout = func(ctx *handler.Context, children ...templ.Component
 		return nil, ctx.Error(err, "failed to render a page")
 	}
 
-	return main(navbar, children...), nil
+	return main(components.Head(), navbar, children...), nil
 }
 
-templ main(navbar templ.Component, children ...templ.Component) {
+templ main(head templ.Component, navbar templ.Component, children ...templ.Component) {
 	<!DOCTYPE html>
 	<html lang="en" data-theme="dark">
-		@components.Head()
+		@head
 		<body hx-ext="multi-swap,head-support" class="min-h-screen flex flex-col">
 			<div class="max-w-7xl w-full mx-auto">
 				@navbar
diff --git a/cmd/frontend/layouts/main_templ.go b/cmd/frontend/layouts/main_templ.go
index 01543a48..07ffeebf 100644
--- a/cmd/frontend/layouts/main_templ.go
+++ b/cmd/frontend/layouts/main_templ.go
@@ -19,10 +19,10 @@ var Main handler.Layout = func(ctx *handler.Context, children ...templ.Component
 		return nil, ctx.Error(err, "failed to render a page")
 	}
 
-	return main(navbar, children...), nil
+	return main(components.Head(), navbar, children...), nil
 }
 
-func main(navbar templ.Component, children ...templ.Component) templ.Component {
+func main(head templ.Component, navbar templ.Component, children ...templ.Component) templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
@@ -44,7 +44,7 @@ func main(navbar templ.Component, children ...templ.Component) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		templ_7745c5c3_Err = components.Head().Render(ctx, templ_7745c5c3_Buffer)
+		templ_7745c5c3_Err = head.Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
diff --git a/cmd/frontend/logic/discord/oauth.go b/cmd/frontend/logic/discord/oauth.go
index 6d0d9809..d4aadd73 100644
--- a/cmd/frontend/logic/discord/oauth.go
+++ b/cmd/frontend/logic/discord/oauth.go
@@ -5,11 +5,11 @@ import (
 	"io"
 	"net/http"
 	"net/url"
-	"os"
 	"strings"
 	"time"
 
 	"github.com/bwmarrin/discordgo"
+	"github.com/cufee/aftermath/internal/constants"
 	"github.com/pkg/errors"
 	"github.com/rs/zerolog/log"
 )
@@ -30,12 +30,6 @@ var defaultClient = http.Client{
 
 const baseURL = "https://discord.com/oauth2"
 
-var defaultClientID = os.Getenv("DISCORD_AUTH_CLIENT_ID")
-var defaultClientSecret = os.Getenv("DISCORD_AUTH_CLIENT_SECRET")
-
-var defaultScopes = os.Getenv("DISCORD_AUTH_DEFAULT_SCOPES")
-var defaultRedirectURL = os.Getenv("DISCORD_AUTH_REDIRECT_URL")
-
 type oAuthURL struct {
 	scope        string
 	state        string
@@ -49,9 +43,9 @@ func NewOAuthURL(state string) oAuthURL {
 	url := oAuthURL{
 		prompt:       "none",
 		state:        state,
-		scope:        defaultScopes,
-		clientID:     defaultClientID,
-		redirectURL:  defaultRedirectURL,
+		scope:        constants.DiscordAuthDefaultScopes,
+		clientID:     constants.DiscordAuthClientID,
+		redirectURL:  constants.DiscordAuthRedirectURL,
 		responseType: "code",
 	}
 	return url
@@ -74,7 +68,7 @@ func ExchangeOAuthCode(code, redirectURL string) (authToken, error) {
 	base := discordgo.EndpointOAuth2 + "token"
 	query := url.Values{}
 	query.Set("code", code)
-	query.Set("redirect_uri", defaultRedirectURL)
+	query.Set("redirect_uri", constants.DiscordAuthRedirectURL)
 	query.Set("grant_type", "authorization_code")
 
 	req, err := http.NewRequest("POST", base, strings.NewReader(query.Encode()))
@@ -83,7 +77,7 @@ func ExchangeOAuthCode(code, redirectURL string) (authToken, error) {
 	}
 
 	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	req.SetBasicAuth(defaultClientID, defaultClientSecret)
+	req.SetBasicAuth(constants.DiscordAuthClientID, constants.DiscordAuthClientSecret)
 
 	res, err := defaultClient.Do(req)
 	if err != nil {
diff --git a/cmd/frontend/middleware/auth.go b/cmd/frontend/middleware/auth.go
index 9e9e0505..723e2c1c 100644
--- a/cmd/frontend/middleware/auth.go
+++ b/cmd/frontend/middleware/auth.go
@@ -1,16 +1,43 @@
 package middleware
 
 import (
+	"context"
 	"net/http"
+	"slices"
 	"time"
 
 	"github.com/cufee/aftermath/cmd/frontend/handler"
 	"github.com/cufee/aftermath/cmd/frontend/logic/auth"
+	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/rs/zerolog/log"
 )
 
 var SessionCheck handler.Middleware = func(ctx *handler.Context, next func(ctx *handler.Context) error) func(ctx *handler.Context) error {
 	user, err := ctx.SessionUser()
 	if err == nil && user.ID != "" {
+		go func(session *models.Session, err error) {
+			if err != nil {
+				log.Err(err).Msg("failed to retrieve a session after retrieving the user from it")
+				return
+			}
+			if session.ExpiresAt.After(time.Now().Add(time.Hour * 24)) {
+				// we only update the session once it is about to expire
+				return
+			}
+			if slices.Contains([]string{"wargaming-redirect"}, session.Meta["flow"]) {
+				// some session types should not be refreshed, even though this handler should never check them in the first place
+				return
+			}
+
+			c, cancel := context.WithTimeout(context.Background(), time.Second*5)
+			defer cancel()
+			err = ctx.Database().SetSessionExpiresAt(c, session.ID, time.Now().Add(time.Hour*24*7))
+			if err != nil {
+				log.Err(err).Msg("failed to set session expiration")
+				return
+			}
+		}(ctx.Session())
+
 		return next
 	}
 
diff --git a/cmd/frontend/public/og-verify.jpg b/cmd/frontend/public/og-verify.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..c518dde586be856124eb7891c7796f847e9e877d
GIT binary patch
literal 13625
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
B_qzZ9

literal 0
HcmV?d00001

diff --git a/cmd/frontend/public/og-widget.jpg b/cmd/frontend/public/og-widget.jpg
index 1aca9a7be0ff7892940833c0d4b6780950903d53..ffe14d66a975906ac1009f22446b219d4a567424 100644
GIT binary patch
literal 11274
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
WeNgLB-+XZ65p(B`8uSL%_J076D<i1@

literal 16098
zcmch83p`X?`~Q|oNlB4NrpPUoBcu!Vkt0b6NfC2O2+1vxnBC1Kl_{5$+nh+0%Otl*
zrd&fcxlTyaxXW#ZF=ochp8ulW^LyXU`+5JT|K**}XYZPA?Y-8s*7x~7-{;wD1Rn)m
z&^2g*(A;P4ykPFLP<ZaVXyHQPg^L$0UOaz@EM2l#WU0vF#Y>hgSt>gB0sj+QCMq`f
z<=brw76}V45*1l2GXLkFItgAu5=(?^7eK;73eW-xAz=w2LA6jC1PLvgADR&K{UfwM
zc;TYOB47y1R)S#*3xmNf0wV=2L&4vmg%XQaZPYYeyxQu7h=Q-=_RDu3EK%H>|60nr
ziM~neq~DdLqHCnr%E&4ytEj4N*4EjfyK~oWqu-48nd~<`U~|~^h~3d+_RgnVT-{E)
zd-$IVI3E~vA^7UGu<(e;>rpYWaq)K(?%hvJOMjU0C^PHvlV=5mMa3o0OUo*&s%vWN
z-qbfVx3spkQ$BWd(t3LP`UeJwhQBf<r<l{M88(M21nm3A=bJ(QWRC=}XTjW@i_F<0
zv>*^1!V(J?ZPZ-6%Fs&WgzsvF?U$EG?!EIM|MgNuEo-{eNxvr1HJh|)N{l&^<}Lbr
z23`3-vgl8P{<KHX35f{{fdvzmfMAHn^Tj8X1WyvL!-el}(7GOLBO=EhW%$deE47fu
zS8~Pt1kh#SPpzaP@#>3&<)=TewM?FCc6*$*AO1j#5$hFh@qI&1dpd#Dw;TRsRXzRG
z_OtksF(roCMQj@X7{_v{Plnj}_0GOg3`Few%d(0Wqa>r}FZpQ|TO1osML30boA&HH
zb8-Vh^{AW960e)M;YFz-a5j1ipxTk>w2BqSYQ0nfBMImtjVahD+AOx_*a?~dx@5wO
zF6Uif=UG@r382Y+;;2F*b-jUF306`7_1(nqjQtKD7C@e^B&Gz+TY(+0V;NYJ2IMj9
zg~*$)<l2d-<&<gx#8DCvKoaJ#EKVu4LP-GC??l*9{aG3O>_mjj5kOz81(2oyI@Rxq
z9yby|LU_)4O?C}KZki#DnpO#*Y8%TMa-<if8pBZ&2TwZQElDcUg2A0IPjs$RS9?-_
zHB4VCfbKM5qCOiq#}bjg94yaVvqCkfzk*dNfMS{uhR$VUjWNAO6tNUQ3lMPMc_&i;
zTZAr!?i&d?z{n10Cr#SJsB$7sfn8HJg5hXj1kmcEan@+lTX>L3qN||J-0($6V-^^*
zI`39&uK<#kFDpTR#S5V8j|l67vZmYM$pxUNJI0t!FdPnFgSS)w-N#zLCUOEXrO2Hp
zA)Y<1BagxKfhp{9&#X02JX?lG4K3+84Qj|~X8|-g`mLi!Qb^--{+niltqh@&ETnIf
z01|a)Sd@2rlO|UQpfI;46AFVm#lo^z3!v>4xe=)Gi~@tPtvL8IcsiJ7QKO!%r;?M%
zyl@ija8~*VdxA4NKb(8~uthBCPd6g4ZArOQ)Cfy|h<<8=2S)^u9G3nh&T5($$m1uV
z3kA?yTy4y(`uJAF%fk(ILKrpRv2byb1_w-joiuNAu4E{(9;|~4fG<3SDR@+-KxWmZ
zA^l)#<S;Z7Rz*7aD~A0A+?Q*N!PX(<4&;j^udaSY&DCrVk=#0TCtR5@>u{*nph*Bl
zi_@R9{&V*s`J+eCHWFr%I{!Q~J`v14dH$wsD-%{YjN%&S7jupAog5EELLt(7m8WJ=
z@L0YCp6@jK`$BxTyb;@FpTOe@pxzs(<Z^GD_1nJLlx+-;i6K1no6&(T`FUT{GbnRY
zlYvs(NP`msXd{tryIU3gPzMGuJZD2yqGMxvwf&o2(ge<Oq%tlj!CpjR=37Hq)qldw
zAi<B#*jKh2i_9;JRZnivIg$W+V~R=<!0>iO{G(r7bLM$>@ipvg=UU;(RY;gBBO<a+
z*a|dNL#6KjOH=(^>;Q5hOV7Q>cK9(e2PRP;1}RF!9AJBc3V`h~Z7co*fJ?$N0rZN%
z!FL@&-DVPd>r&O75{cgsn<<WAKR?$-nsfr7&j<eaFYPIyeZiR!V@4FS9iDFz7h=lD
z8qP)f3K5?9iGPNlCf`|tH!<Nl$+KWo^1HnSkW$(lysLT$coFkJ@bx74>PbjTpyZRj
zLspaTwi?{y_M3q^n;+~+<)}*o-?qR=<2Dj4R{{t>gn7pP=d8KoS}4wJ0vUjFdq{(Q
z6|8erz0%dbE!9|#ia5B#5+iG%l=X_C@{KF(wi;{Xf!^j?!g<c{+`j=vz24P~mTKxZ
zCbGcD;nY^7ssbibh1pSkL+K+&i5!l`OZ>=3>USTxPZ5t6KvEIHHCT?~9DP|}<k2nB
zsp{aSwJ^KemwA})wi4}{{fLr4!|$`463G@oj5FsLZs>jo@V~OuMphJ?=&l;$6}&D?
z<laDjq_6-A*-U7E9<0i(K?aeFvTuEdsh!_Id{F>ZA)OAtF{E09b#HE6ZC-jiEV>`_
z%P!`wepn9g>qL~j={8A>@*J}4i0IL$TrV^&Uzhz!W?NzPaxcZ?f>##5gq}|p<8J5L
z;Z{p+j_FI~%S<1W542ltdxEiIY;=~R^&WB0uFu11dhD3YSNB?8?mMe?9m^@rTl|99
zdC0l<NFhAZC4fxR^48ov-}T;C7rh{Wh7a;u6iiRu^F+wckzrNUw5Un)VQ_~2+lP7u
z|Gu|N5&Ly!SM5iKtZfRngD<a!rworT4}=R&lWS8X5egZNHFG#2fbinBoRkh{PtA1i
z0sKG&uDJ@cE+Ah3IZ?UhQa<sYaV^dmIh{W*1azeUHyZ?0iUr=2p*6T2!;zpNBcEVq
zoTQcUg@`BM4E?tcsczgmMR=X|A$WKYtV%}Sniu4b`+*_eO(OgdurS(173=r|^4U{+
zo{>2+fGFe;?LDkN*0P85#JMa1)O<AiGVxb_RxLHUb4UOYv3#Yda`c7&JFRj%eh2}L
zBPYGldGnMsJ&xfX5LHbpFK7qnOFw@=v6s|`$XBRO11LAN*Xo%wjE<MJIG5ct_0Bx{
z<a(vN;d!6EF>u5}Zg0l96ZE!xoBl_6p_vPVLThjeu70ojf)IDr?E2#LwcDbt&mZ8g
znQ%~X4H+~JHDu_bOBrr1X^mMtb%ya+O{?nBqaL-}UF%%V*+Se?&Y$ew2Hp*{5B*du
z-991t;f?jthsU@7vU5XpwQNwbQplE=tX%)hXr6X2W;r8n$n81K@^sR*SnF%KFCP|`
zm6e_M818&0(PS+3He{uhu_W}fhuy{5UvBdJKGc0*j@Nd`?6$m#=rUOW1fUqx=(yH6
z#1Up_yd7@<l;&o{^98GNTL5)toaY5oBKW~z6}RXN77Y=KeCq1PLY&c1gn3tXs%)HG
zNY=zoPa<3!1J4L>uhBKIfIw|Aug&36CGY<PivgI0%xr!Co|*8%l)W41mbnf&Steo?
zzki_&y@JGqF6|cO(fO&Mv*$r}Xw_W-#9d4Lz~zQq*KpPy<YI=rKQzSaRNl|{?d718
zT1D~U7PJ1qnWx07q%&R$jVAmDI&X4LEGgh<m1Vv9%usV?ClhKb7{qYci^$m->VUq?
zMVJTL@AqI2TfV~`oWb4Ge%x5KMZ2@@<O8=(=2z;3USgCgF%EurC@o4A`q_hM$iKS}
zw`a%*tspV)dQ5#~YIGcO>-~HM9s$b6)HN?>&GSxd4}Kt;myPa=gX=JSwN<!wXH21Z
z<YIV`0@`dO?jr8z=PjmoN>>Y`FJWek>{Rerk2nVdBFe~^C4VbHvx+onNrOk)VE)EM
zl2%TJqu~7O&mQaXqd+MrRaKH$awP)jLk%v1G8pmKYptiSuL#5;Bn>u#If_#-7bP)2
z?X6hLFDCWTroFkWA_3H-j`gQhVTvidWP@BlaP1_nlIOt*{<~meed<JuFlrtuJ}a6j
zfF6y=n;T2o)e{CHe-`I+?d{TV4T>=49E1$d&nIyYaUVZ+F>-o6gy8}lH=AY?H7FP}
zo)xcY$OWF%d4TQ&=-wa8s#u4dCalDBnV`{r&v%|J@R^MzteXrF<%yPj#qjd?FM@7Z
zYyjet(n;Vt7&t`0eW|a(w<id9?;I`pcl<mhrCr*C>6k#xBEpc-T|kjMh~kSA$>M*x
zl=X&m8ODAPK)>O_kx7#QWSWl*KMxDhob^KLtG-gF$2<j4+L4OEzu=fUn>dY))u%oZ
z;U#i0EGbI?WZpgx;aK?H%AbYrTzjGkKjso#h=~BkXOj4v63csDDzZ!jP;3}o0P$af
z>D<)TbvJuJ8>z#*lMe@suXr40gH$a;0o%3KnT2Ppg_$5!JoK@<Z<mR7c$TnY7#qMe
z!+gan<&`gjVl5PEk#DnX7Y-af<)5e7rt_z!dGkzoi2mcClIkM{Ynytg0m!-Azh*uf
z*dR9Rj|~jj#J`VQ8=~H{u^3;~UKXAHG&I|$;_|6L+^o?l1+EZ#;KkFUqR-nojxk?x
zbu^7DJma2r<$}t?x8(HKskOy;`Rk{z&GtXg`O?}f@QLM@-Rctp=mw_1vT`CScuRYU
zyj;=KRx!8HvXr=Ga(60rZY^9s@>P5oyM$d*wVQBN&m5tdyZ%yQAKLQzm-S0+ZsMI=
zLr>R!+59DOAkZ?4XHU0_ELW<wy1VV6CvC)WZ;p-AWLvFOV1Im(ePP?^c%q}oU%m0)
zd1%ocWC4!!fbYQ60$C;uPDJ1x=GE#ne3vI`fjI&$cw+ghie~hGgjC^s0rZLTgm-_O
z{|nql0T6r&0Dm^WuhnKOH?zDny18@v<N=zZVcWfAAr9peA|!xZG@uY|`dHCmBvakd
z#__Jw#TVIcuH9HBk#Z;72O3U&R4yhjnzzHt<hK$xhDn%#gs=DwnT+EG3w$#UL|J4U
z>&}|O#&0T$OG$}ue&$t_fy$(jj4C$p7O-s@D*Iy(QbIPm$=$qWe9?VDjkZeukwdWJ
z9qdxx5q99?kj)HM`WG*2OU=<o)iy$xx114HL^qrCCYGOdv|AXLR2FLKRzqI!{6=N)
zIp2U06N&IA9NYbw>nz?)Hf(+2sNB<<c>bbRN?MdU85aL3pfL#@l5VVUIvr*L)_fRi
zmt^-4ed7!lnnYas?kF!NU;6LH^y1Mtyom~^0~BL;K7eiRz+=gpvj>81W4Qj{>rVB?
zkyetI24@!@q|jXi^p2sEgJZH;rbI9DjowwNu#*<Qlm4XljbmXyLGSWcXE#3~jV-15
zG%T6DC?A>@Jd0Kc@#BD_(LywUwtNSuB((x1K7K>$&KTh;^4D|MfsBGwCxAZM2%wh3
zS1K0sbK`AT5e!vZVO`BwJXT44B9Xn0^&F5u1Ve)#0$4K5IWrY0tD`Vo2?x)Sde(m-
zjc$gy9{I7e`ru(cbRs`uD-a5r*ay=b+F!5jlBTPSaOIH?WOP4|jFO0a-IYI(8|Bk9
zy>1Ky7Zvergi=IAuiLlm5kUS<*^_QBn6JQCutsPlC}Rwl)h(kxwnbHf0@f~AQF?j_
zJl)~R3@7PUNFw!z=!5(SFPP~^8D8#u8>FbXEDrWT1TRtx;m!iK+<)7y22=86Gw*`Z
z;RT&K`QH8snC1!!F$(ea2E~_|MJ1@W!ytAXs~uX>OhwK20uPD8#*w7}hWhYRl0TDw
zs5g^Nt+X6lP5S~5112$5Ch8E)_;|1~Jv?BUH^Md136`-a&HE0Vp*~RY(yanD2@KbI
z3$C-udrYV21PHHKuJNJ^F2R{&Pc>&Pg6<)dggF%1IVJ;xl(y-jB%sln`$7m}U@3N8
z0p35S*&+dooMe6uOJTEW;1QK<EJ{ieK*su^d@O`EAd@~7(%`8BAn;pa5xdqt?0EAu
zUjmKhF9*g@LE&W-+&BEh5G#zMU?zP~CD8gFiFq(!=3U70+2bInu@le=AZVI2TgY&?
z^9WZ9`$(6Ulq1a#1EI$J$achy#Mve<1!lXSgodj#4M=+MkC!qP(1m=&=si~k3=(r6
z1nX&_FnXkZgw1T~k7~u<4H@@ro7aDsNzWnVqb<zWJxas<02rKi2*}W59?;0MD>{*(
zeqyt1-9}WBZ#79W66dUR6+qK0;J_RH1ua-lyBfHpgqMJyz0xIsbn|YG@EZs4C0qxj
zJ`>B5Fq^#JQ)p!zaveSSQ<5zhI~t-jYs@}}P^jpgcTVn3_h;o9v-^SqQBZATMtd-y
zh5CoU{E&!$5KzT;9J#SNfw!bEbor&ou%uMK?N@5?P~Dhe4@d;QVafcwuO%;zJ;CMM
z2_UmOlOZ66Y#LaGz66BOtN>(wkV^5-i2Y#c(M;gD%V-D}_2x@X&rF91{}oC$caRrm
z6s8Gx4^tNm5CNX>6x{ac@uD9=LZRx=b;rPPRm6L+T+R)kl<F+?1W*8;IP?y8k2-nw
zDV8OL;p-f&|7-5>@A8S{8|>B7eDOU)Zop6+IAJMhQl#CF5_UY8?L0qu5pATAP73HY
z*BvD3r9@kfRyX%|q@MUd0G*igu5RZrHjqL}MpXpX`a%HgM(jf!&P#eadLSYK9^K<E
zfYR@h_It`jux+MI8u(&xpCNE5N+-ho?Mj6j|0Suf9Qm|{%6S=@i<Lw_Q$e|Fe3>`z
zbD0)#MkCRHI_xEYlv9w8#u^Q7Q6O8KRN+Ma%#uhA6Y?i`$!-zI7~r1$14J$2K|bCB
zK22T$!q7aTQcd&xfgmFSnryx^eCj*-P~ITJ`%7lMfscJ)6VOj2W|Zh;)HKp{$(i+l
z0pvANgRgL<JgtnKZJ}C+P`;A5$MG>V0!QT+?DSXQ9zcewzt(^Hcf@F3BMoo|s9FW~
z1Z1)juJYFT>ObBo?Z3Tdb*Rjn<!sj^y7;Rjgw+PyPFJjG^=CQUh?)6S-d@{!loWX!
zr^A)X9A@pdy=i|o$z5&@ec!6JCl5V|S`0zwq()py&-q?|f40f~G;%O#>6dNNH3xSn
zYQIx&xVt9qW#Zv6@~#fk5hbOyH3wjq;?H;UIaJ27FN7NLuqOpU)JokQxA%CNJ-Du*
z(h|H%h^5m&874&X_M`_D7?sioBey7)7QBe8)7!qyNSKFzFosR0uF?Y(xI_bAgcrGP
zmY0;(xM0`UhMc{z6E_bJ91DJ}qxzyI*-1ZWy-8)%^E0kkCtIKRuBgEhJ>~e(PuAAf
zcJ2?0-E)(^!Y(jpCw3V?$`mq`NhD=|!E{)n7Sfe~dw5i?+Q`J$X+Mn__h2*<jrli$
zJP+=p@yr0eHIbovBmW_clMZ@wbdPGxisI44oKq+nnLMti4#3@r@Wt$gLUBR3A1_%L
z^Okbah?M_#s<V>!Bi-^o|JAFajd*I@^nP48W^w}%Gb3X#U%~KSe5RuPUl`d@hBBM*
z4&%)%1}tMi8dXT>*Q)VEUSXGoAdKD9IU&nw7n4|c`7?L2B<j$qVo98G{u!@Lq?h5f
z7?O6jtXpfc_#if&Acm74f|v26oWJlFG&x6iN=+qeywiTpNx}PBAn`%R&I^weguJiE
z)TJ(DYnR)<%f~q64WIC7*micuU|c5dXzh&I{`ykwu~Rt{0d&eO*cE%LLa1e(JwyC*
z=9)Ws!)`@)lqK*-KAH+sGkgNLxS^Ph(Z*sqzclPKl%f;HuF@%{Y)?jX59QaAqi2fL
zU0#MSTzmA!8nHjluZz3A$F)pL?%B@$o8!7E_gT0-e0d*v*;B1k<w+8|?*-~Ct<6+V
zJ|5d26L;9=hQ~X<M@jaD%*h6j*gA6#{T&gb-U2(5IXkI;vW1&d!YsxOmDQ*Mx^O;I
ze0lsjb`JpNJYz8Z5Y9T_&2{2@HEHCm24^=ciFC~i6-%f5Szn~SiJktPO@c>y$ehi9
z-lw@lG(oYC?TMPcmF5S7VDNAQV2?ranZGl{Y4~FmYN28zfcyplRqKa#VVB}+F_XT#
zF|!FUcjL%-C-*I$4={5b-7kO+R78*_&*X!^0iv9_l_-zJe+XEZO+>4<3!vTnr9`rK
zrx|KS1}`2*wKS%3rl>PP0Pyk5Mj#5*w}EIC0ixA_!@m*NmyjR)_VIU()b#&1)Qz&2
z2QI?b;+Hu(?q8)t*;=BhC;nLon-(DRO>nz?cyAS=c)ylA8w3Pe5qj|7<%nvt?v7pE
z=m##Pqi=bCjrY1Q%oC!gj+FjcY!FK;|E22DbkKaNSp73ji~e6ZZT%c0DH?#diKPpm
zp_8P8o>O}&Nt0T`B%u7n=X7FisUIdhvvC^U!(D?sA4GZ{aBM}{Bd92ll1koy2%m}~
zLmi%@_J6%ruuA~>;<ETg!^c3V4KLw`rh}q}{8CV_sw4Ej`aAV1y9~4rgiT-EdI3~2
zUp#4kslobnCqJ!xH!=d^F3|kg4R++GggN2(L!KDO>H++e&M^5V)B2`IFeTEw6igI6
z1^~DJ528w5-nNz~25=LUh$i2eOa`iH)42FIl?H0ZQd4z>e@7Ao6GlN6p|Toimr{R_
z%E?!Z5wDS)#W_1u#QBW`{>teYuTWPL6zKbE&;yczHKKBM93{?*J_dNt3d3E*HDf28
zLV#90aUV&+U84+^i~)(SG+2YMWD+>-7ba%QLlL6}t_u(iQVGaM;F2x=TmPClyn>$*
zc*z=JfW<i^rVWMKI{7V@4gEh0Wfxkt%)B>~7ly50yM1@El;UmUP*1u8Ym^>3e$_iY
z#NIt8U|mq<j&w=o{dvD=J`bxuqR&?3*wstgk!im1PyPKK%?y7)73d>1@>}Sn?Wr2d
z$zE1UyZw)UNOW*iPHF2-bk8ojxC38cpp5G#EaSoHW|%6DQhSlg-mL=2r>Sb)dDksM
z8-j(%MIoWYk+RI|(=UiCM*_|DyGO@#s&m^?qD`N~*`8#yF>d*fmMIde3DQATHG0Ns
zu2VPNn@LK$-D@ShFB~h?RVnIMaY-xco<aZjX$tEZhGyA@X(#+&<tcrsz-#Uh%z?&Z
zBOsT5q{B&}VL38PDpvpj?lY3&Iv+0;ud?aq5>oif;7|S}#v$I5u#f-&v`7??WJv}n
zDlCGTXNp)`|INjYWC8S?bQt%5nFEk-<bYN*0qKcf2q?doJo)ACaQ<9Qjp6Jhh$BG5
z#+W;KI>pW^%;lFC|52#PuX@5WoO^KrR5`OSc$W$9)>H8E9b`#2fRp~KgAtGNpOgBA
zctFXYolmm$1AKAG$3TY7C2{>s8hi$Mu^(aXv?cIIL%<8~Q$PF-S`hk*<VWz5Eh5l<
zG8!2?TU@b<e-rNOIS0>dLzqUC?xN}Ym|4JTt9f_O_)u}Auj3>rr(~juX;PfASyQC`
z0t3qrcR>TVtFfun!USFd0W8c%SM1=iLDDz_Br@v53BXg2I0BCp2f^$u>^kOARV9Gd
z>uEmm@Lxi6G`H%GUNEsp$e`l{_JI!PQqG&#O_3Y=RtDQO!AoK9TMkvSn+!1QSXxJb
z)!EAmtzIt6v{b)%AEDtZjD1~pe%*PxA;sj>bScNADYn*P&6h388k@*ZF3JYDKB>$|
zPRnRWS8a^nk(Vwl?dg5-bf_1WfE2QdP7rw)7~9exz1<WshFX^;U$K%}0ZZw8h1bB|
zFKw#rw{%KZVV5^%BwbTePQRe)Ze{5hRjxL(si(p}@Pb^u;$7EWuFf%*xq4j~6A3Ac
zq%w=K1ZEN=A?*2taM+tk+0@RI&8h7HTYBYPq}SH!)$2Zd*f-{t^SSr{5H?zD_8fvJ
z^u>=o(}E_9+r1sm>`2TlZ!Ss8i8AGd;bN<_?N(+~uM#mi^rpdYiQZN0J)Lm@B#d}b
zSMqc}e4*oSowIA-vh|QsMzz0Js^t2WgAu~TJ|?*rWh{2wU1J?)zWOU-8!A)oNF#}B
z9(`M)ADd~iil*9H5OXsvu`tf&d`z%*N+QK1fMp({KkMsxWOrR%*P9$yan`yeTOV!q
zzYc9Np*<I!z=87k>%H#=?kGi6AtL6U0h^_yJL954a%K)6zk<t@Z=146&%%08raTf;
zTFAb>>ZW?lJC1!yj<I~KQ{i>*5Yg27;Y4ni0dZKP*KLV!f_M{+cZFEu)O7f<m6~dv
z?WS~junWiUh5Ioj&*JVJwjH`J6jX_TIs<Qg?okE;!;n6=7Gwm)0IffK%kwr*#{m17
ziQP+{k(=NhhBrUJu18+)CH3VFBP=0H{<^K9H-5Zw-VGktXv1WMs>6LB+UML2VWz(Z
z3&5V@J^x#!RwlkfvKN$CL4YI9$Ij0$F|7SN`499AO!%Ox2;Mu4`E-&be*dQVxBkn!
z2Sp<m*q;;ofB}Cma!7p@KtS)qMdH^5(DwkUnwP5Ca-#qP*vmlxS?uTF*0)5^33FNM
z?JMB5U$XwC|B$6Fa9FnPoi%H{u0`>M%v9s(wa&*2@^?bw)}F)O5eVJVwW6t~)j%nz
z%+u`tA<d^P&ekW%uIJyVP=w_N%4b>1O*sMhPGNITw$Tl<W8(^9+l8O}j;Y$kQy=%3
znM__J%Ivm};&v#`S`LxF5SK7gjj)kgT&M2M(eb;z>W%$sw^=8sTbP#~Qy$IfPV%6x
z5Ao(l1W+S7CDE;P<r3w5H;=IKT-R$`7=QFV?W(%8n+e;~5Afj_?RZ(WmD`_gjEi2v
zB)%hGPc(mYm9fsL>CEagYZ7bT9wMgY<UqV^xvoWKV!gYARX%Wt4=LC5bZKKD@@{tw
zo6{rxZa(g=-)Ci-DXrZ7FsaO|BUk&pBk8Xqf=ud2sNuR@uFxIYjTUUL^VnuDli^%_
z^0!l;LNA}d{^8NkAaiu(K0}e*;9YXDmGuFnA^aya;%K>!rMU0C)AbkkpL9_!%h-Ib
z6`SrG<8;&hM@hb@tgJY{IEFQOE^6)V@@IQa*#26-iM5va9($ugwU9xq=3lI_M|R9~
zK5Tv!dMLjWk+^D=T7PlvwvsuDynmz0B<$H+^%z!6uA1s}|4mu%rd>)?yE;|VDgdbT
zDx*~YSn$KK4E;+8yp{1eWsgls>w@t~6;sWTqRVJJ*M?@fYS>AW-klJo?U0e!&h1dX
z{$cQn7Cvhzv?g?ok<x4p#j+J0=dS6YH^{V0)nD8<WNMNf#d=)Smt@K+8$WGVhov7P
za@2#d{7WDo+1H3YNvXz`U~ZlxN%78H)K?CO*G^h8I&f!&VVu?;@v8F%e^6WlHa$HO
zY7Zac9y>{I)l-R=jX7YeZf)i0U|!$Vq}<UPKT0S7$qUlsebe5aU2wc@#hvs$65bl|
z6%NUAtD^P``PcTcg`M_@E>%8SPrE0K%|NA^&lF<BhPm64MC-iWT_g{sMK5@ANxiPY
z=Nuzo)7LX)!3404U>{M`53|bulViy6E*d@mD$D)(R6}}#hSrgg$9v5mws_@wokPzv
zym_lj_RHEdenI3NLyK0ct;rC**JqG)djaXVEQe5IAWhMe=~+e;3yQV8=+L$6pnoMF
zpEbSEPu$0oSy}O`0J;)BRJ;Sb>RhPn=amIc!<&x(f(dzeZ9ypAmu=_jnLryp#42pd
z!98Z;>AF|g&Q}Fc`<5&Cw*CV?H@_q&tH@LwZjL=46YHRz__A%3Ovp-$;<T{;<HjNN
zCekSqXQu`Tqu&&TztfFb6{P;vX$)(6{>@Kml_<~j3YN(wpb4u#G$4KM-?miTNuNEN
zjJBXEDroY2kqo?=oqPWlSWRX1gF6q|#oL+4AobXLAVua<fu4BlgWg}U`k(Z>+kf0r
zaZzPd38-u?6@6_7bC(cH)O+BMAVHlb@vr0|ObP5+yY@c9I98X7874KYL(LC@wO1yh
zu?N+sVtZj;Jasit4LFd7nCRecQ3h3N5srF=3do80R5aS7$^ezrKQ@UuIKfeVM&$Cr
z?gF{C;K3?P7u+*gbxT1*yn$6#le}b2w~o?DM%K`S)+@ixyt}YoYN|E6?ZGw=zXCWs
z$n(bYgsb^vnV6ozh^)4xt3?#|tq;o+JqEKv?D@GB>LK<mn5vnQHQcjF8mo^Dzp;BS
zAN|%;vFoxE)>!gMd$!Z@w)GtZ315?yjI+NpI%<^zzIJ|U34Atsx5>$L6Uc5{gEksV
z9uoTTaJo#t%8F;F&`&D2@N^NW_o)-5g(H0$E6?`(7+Qx$>t~aPvNMll$V?e_q}Cc&
z%TUDzH0%10UjLB0K4Wo9LASy1w8ikWNfDdM8e_lid8x)sQSPkTckED3?8kH&pWrb!
z74KHDS;`HwEwOJ}%oX>%SQF?RQ$4+D=24TKgM`D%32Qt36{@{X>b=Jgst?|)?@?NG
zdP-j*m6v}cisYb#OCLje2Vm|HoPtXlrcR1qMV}KVr8svy1rSCPAi|J0!lYUVpxYss
z=^ErV(I1F{1cF8@TE&&(9UJ6>9B}-k2S)=H)c{E_0TgOSrFGGpQqvhBK>IC{21=b=
zg|L<Z9l1|*0u(tuDNXXoowzvcq-#F47v!>;zk~fuAeqJVAN^0Nb#9Y|2nNFx25B~y
zYo>FdI~X&X<;$2dgs0~`pup~BWdqOhG6>VHB<AxJjveooDiRHIt+f%atAtMf>N>Q1
z-T}&{ExV2mvXU6UzHe3Hypmq?opqqRLYyWs`|ycxY@g|A@GnN7F>~=ZQUCY<5PyZs
z`H86F$B?b;s*Ip?JFjBn#LtrlL*MkRGsB693@yi9I`-NA>zaJ((N7OQyuI9WcZXQs
z!&56wtg!b2KC-2I!A5h9@ODgxlNh7BEjMenxY<Omi8!0R`6;$aYNWp-=5<Y_$4IF7
zFja_$R0TO)%8eU%exa@MJ+65hK|@cu+4}f1U+bH3cAe(hGZlmo_F!!VhJBHCk+g<=
zm$RX$F!IG3z0%RBJ^6Y<*yL0-iYvq9dVu(<<BvKtCS0BetiMru23M5POTK}Tz^NQp
zs*C111Z1rhKy7s!m&sxdMJ~8HzR17ruJgUn^QOl3>Jxez>&wsJZyX)fms`Kos`3OU
z8I-Bj4p8Ds9S+oQN=quvExD)wrcE0~{*J(sI+`wG^JbS67em+T!ChxyY3~U=`rC$O
z14{N6E%TvjuikvA!Q|`(`9COwp=W}$>QF8A1(5Nd2~w|4un%~>)~y657rZ?=T)tYC
zxt-_#`mk4aX6bC;WmJP)d7M?`(du|+hl1v<{WTezdb)0=hpw}W>Gx7j{rZNl;%aOC
z_E+dsY-hy=evyIdX|S6WRnN_g$cwqCzlJiJ?JLtzuiW$Aa9rpWIX};>hEP~nXSr_J
zGA#(-qtsgbOw3erWewyzRJ+OABtLIWnZI1~&NAHlME8JFu6Q)E|E>7-U1ENE3CpeT
zu5ZwKyt({|Uw^x%)wM@)Hibz8UWM^@OMnz*;QRmMmM-F6e*Aj_y&;wF+qXKI;vJ`Z
zdn>L1{fP{3DVm_CmfKwV2ktwtyqiPca4&$oj0l}>)tP8HNHW3uk%noFuHOb(2@Ewd
zj{~GDc<WZwRNLu$*9Bx~QghHxdBd#tq5fmnW5w^&KPr#^%J&xns3Yhyqs2%CO$D3&
z?7x8ht@kVpcAa)ZD-dR)Jy(7eC5n!j2D{ReuXo=?-ZVt8fg@!oTCzR>xqTPx1}FvQ
z$w~FMeZ>@e^O7^KYXM~q-efPj5b9kEYGL-S2utFd+8#|ne`9-dXT<qR;LRs?Tkwe=
zS^U58-EnaAjW46>H+XsqkXbWD#F0As-k0&>&kIdH5xn^O2p<8(i%f;{{iI3FbaW?r
zdX(f1FL69gkV&XntjG%Wwv75MR!&A?figDB_9ocj9u^djyTrq>H6Mj|(>JBcr5?V5
zc9)NBV?=Nt|603FZuG=!p7<ek8Z5(BslkYs8|sGZVbdF3E(mebZ~Iggs0}q-lz2`2
zz&rh=9A{V~RiOI1+(6mF!^~xu=g!80mwhiXGdj<+ajV~*?%n?JL|5T(wnLeN&SVpZ
zck_vA8cEh5XD;9UZy)Ndq*KHd<j1@Np+WmXQntP8Ajo;&K4Z%>^anqrA?nk~Vbc?9
zJs78*<XRq<md4Q|cUpDdV;<5s4|SwR(DDfM7nSa5zm07D^lpIq=`#B4;5p3b<ySmz
zEH;~MSsC<pB=WIy|KhAeA@3dK+Vi8vCtPQha`T8xIsJsz>R#t#M86d?Qw~a;)aj$C
zy6n&|gvhc$mdUMhEzhjV(vHEpseP8#(Z9S2ZH?-B1b^1ycSlyz^5c~DmP^vM%AJZe
zKkq(-x=l{+dLP&NN2lkLrc|}Z=xf44jd8K|lEkr?*y<xCjCjn<q%NEb-t<Nwymj3r
z=ql`L<ckaV3B_7sz#{?Fc!1r(#?q!u{q>6DsV*)v%6CRh4Bj6}{fxapL+GzCBJhw4
z*hst>cmgBJ6ZZ-c5qibYxK5&P2Wjg~yD}ThglrKF8*vM40WT(e0zZ5Cyo=={fclyE
z<pL;tA$t!fxBc1P#&T4G9wa7!DouN^Jh2i`&ypGsSbYvY&=zDvqwtrx^U1vTk%RXO
zfQEQWAK+g>R|*l>`+26|M>2N>5btCn@;mjKBI*jS`iB|bNSS*Ck!D|4iC=*XIarP(
z1Lur(y_26l*0XhX2~R;r07c=elaZGGIjbMRqw4fq79x@5CKMDmCV<#A7d>aP`e&)P
z&Xz0Fd(p7Cib2%vxYn7PmmUSxT`U>)fyE|~Atqn|J_sYq8COMGO3922G5&TTk(D|7
zC@r?g3$s*jhc{|Gf48Gvqx?)3S=#$!1nt-19`TjnM^DEwJlA{Fe3i;SeDn-^FuY|~
z!TeDQbZw@ys6?8BNu|beWXR48j6T4ou2+7_?UwGS4L!$ARscor1P+}Av)}Eb<_A``
z4HJR%VoQk#AQ|E*+_YFq_EEMWEeZTq%25N5+I@<ct6Hur8RPx2j^-nSex?W@`et!d
z%Zl)^ix$Bb37FuC&UgM4wyb@iFVbA>B+hp6=14Wq5;!SV)fD9Pq%uDmCnMJDNO?Zj
zHNt+UNphYD|J`lYAC&4|-2)ebduOt+nY|7gA|bz&@S+}vf`uy!c%qxFcb{}hBRsq1
zI0dFFV^AG)?~c{9r!r{Q_wP<b6%S{Ai@nKfvKTyMJ8$t`zl#M84y^rbpT+x1a=~mJ
zgn1tKsL$N0;)ioR5%y}3)yNVL;|RA*R6Lr3bZ7x!zs~%v=W@wgygOi8Gqb&j$Xg1E
zySHo{Sk~;ImpUn6nigyX5VQTd{d`v6n4JJx=~+3!m9n0*Q}Y_u=<Pa|EjxHIQXD|w
zEt$U+p~a&Z<b(4uU}YqU-4^W0<hd7_y(TR45<m)xSU?S0LDr9EOzxMA7SP#ZxBhIY
zi^_O|!W4h84tUlLFbum#V0x1*(G7KBB&J%%3_P{lIU)_MAGpeLqzj#di*@kd8d@V&
z8bQM76>c565TL3yyE$PZ(M$X_ei<@kGdDfna@*GP<1UbR+h;DpLmD~Am*22Fk3_^3
z16{?Bg*pQ>6@Zxm!?x=JVEcqG<gj|+jZYHhys>kqp4P1D6rSy>A%uLu9{pxlH-`S!
zX@LOxqaq)`SOQ^`F@rZ_uR2L1AHLnz@w?Amw#49Hn!&Vt<%<N6;s10x#605tnzW3<
zYnX$;JLgNUNl)<ru;C}^()>l!-)(FXKw>ptG`Pz~Fl-4R`PUIm(()6oR;<<F#Lq3q
z-Df;0bm4_Mo|g0_(mzZ*8&7f-{}&T&hgyjgdQQfdnQ$}I<s9%-S8B&|42Ol^4SIB<
zi~LWIhhUcpX!So$kL|FehShYA5=|uB^V_{HTMC2_TKap0b{EAAV!C9>-xeSXJj;QN
z05fm7eV<#~VNl2uwI3v0!^!48YnaD@<!Ctx4NZS9GMZ0kgFt%56P~wCHUry%r48@g
zT?<%jZgQV6<A)65`erLjGikaJ%g#KTUzwu#egQN!CJ#_5mQA19iFULHBjjoTd_3F5
zGJ?RAX(!PYfCD+*=OJNR{m7Ms6?Z$l;5ipJ+uTSR?9^+;HNY$0kXi4GKu5m-hJNCQ
zf~8*(NoKYGd5KvBI%f{EDO-43=!~t~I}rfl?WAXZ6C5U96Z0&vDou-Dl#9&!Trvsx
z+})A?@i}wLGBw6bo_(q`8&}-;7|?U$F$)K8n&MlS7E>YT40qX6(S=n2wvVe=ChW8O
zkm70bH$Sw?WbxcbK7^{r;ADJ6yEHO^3#iX3ZlTQVpQN%+As`cEuKP|3mSD<_*ucjO
zUxLvsI5F?FQcC`oRZa`dP-7-Kh&rQnjqqTzUOoco<>8l+;K6VGKDnsTp-T%$?lHS@
z>&UR-z^?HR!r+Hu3WWBTI=fLx5IONYqdbvJC8bN5nE}Y_q2qox^F2rJ7*!dppp&ki
zAr<g69&~m5=3Bm(phY<1+=%frcegSQ)sfQ|+q&q$P017MSD9{lxvEM2rlPE`Rn#*_
IyrAQM0c-XhrT_o{

diff --git a/cmd/frontend/public/og.jpg b/cmd/frontend/public/og.jpg
index 1aca9a7be0ff7892940833c0d4b6780950903d53..ffe14d66a975906ac1009f22446b219d4a567424 100644
GIT binary patch
literal 11274
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
WeNgLB-+XZ65p(B`8uSL%_J076D<i1@

literal 16098
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
IyrAQM0c-XhrT_o{

diff --git a/cmd/frontend/routes/api/auth/discord.go b/cmd/frontend/routes/api/auth/discord.go
index 8059ad9d..8fae1c84 100644
--- a/cmd/frontend/routes/api/auth/discord.go
+++ b/cmd/frontend/routes/api/auth/discord.go
@@ -84,7 +84,7 @@ var DiscordRedirect handler.Endpoint = func(ctx *handler.Context) error {
 	ctx.SetCookie(auth.NewSessionCookie(sess.PublicID, sess.ExpiresAt))
 
 	defer log.Debug().Msg("finished handling a discord redirect")
-	if path, ok := nonce.Meta["redirect"]; ok && strings.HasPrefix(path, "/") {
+	if path, ok := nonce.Meta["from"]; ok && !strings.HasPrefix(path, "http://") && !strings.HasPrefix(path, "https://") {
 		return ctx.Redirect(path, http.StatusTemporaryRedirect)
 	}
 	return ctx.Redirect("/app", http.StatusTemporaryRedirect)
diff --git a/cmd/frontend/routes/api/auth/wargaming.go b/cmd/frontend/routes/api/auth/wargaming.go
index 18bbb655..116cb5b5 100644
--- a/cmd/frontend/routes/api/auth/wargaming.go
+++ b/cmd/frontend/routes/api/auth/wargaming.go
@@ -8,9 +8,9 @@ import (
 
 	"github.com/cufee/aftermath/cmd/frontend/handler"
 	"github.com/cufee/aftermath/cmd/frontend/logic/auth"
+	"github.com/cufee/aftermath/internal/constants"
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
-	"github.com/cufee/aftermath/internal/external/wargaming"
 	"github.com/cufee/aftermath/internal/logic"
 	"github.com/pkg/errors"
 	"github.com/rs/zerolog/log"
@@ -79,7 +79,7 @@ var WargamingRedirect handler.Endpoint = func(ctx *handler.Context) error {
 		}
 	}
 
-	return ctx.Redirect("/app?linked="+ctx.Query("nickname"), http.StatusTemporaryRedirect)
+	return ctx.Redirect("/linked?nickname="+ctx.Query("nickname"), http.StatusTemporaryRedirect)
 }
 
 var WargamingBegin handler.Endpoint = func(ctx *handler.Context) error {
@@ -104,7 +104,7 @@ var WargamingBegin handler.Endpoint = func(ctx *handler.Context) error {
 		return ctx.Redirect("/error?message=failed to start a new session", http.StatusTemporaryRedirect)
 	}
 
-	redirectURL := fmt.Sprintf("%s?application_id=%s&redirect_uri=%s", baseWgURL, wargaming.PublicAppID, auth.NewWargamingAuthRedirectURL(verifySession.PublicID))
+	redirectURL := fmt.Sprintf("%s?application_id=%s&redirect_uri=%s", baseWgURL, constants.WargamingPublicAppID, auth.NewWargamingAuthRedirectURL(verifySession.PublicID))
 	return ctx.Redirect(redirectURL, http.StatusTemporaryRedirect)
 }
 
diff --git a/cmd/frontend/routes/linked.templ b/cmd/frontend/routes/linked.templ
new file mode 100644
index 00000000..c54eb74a
--- /dev/null
+++ b/cmd/frontend/routes/linked.templ
@@ -0,0 +1,30 @@
+package routes
+
+import (
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/cmd/frontend/layouts"
+)
+
+var AccountLinked handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
+	return layouts.Main, accountLinkedPage(ctx.Query("nickname")), nil
+}
+
+templ accountLinkedPage(nickname string) {
+	<head>
+		<title>Aftermath 🔗 Wargaming</title>
+	</head>
+	<div class="flex flex-col items-center self-center justify-center h-full gap-1">
+		<span class="text-7xl p-2">🎉</span>
+		if nickname != "" {
+			<span class="text-2xl font-bold">Your { nickname } account is linked!</span>
+		} else {
+			<span class="text-2xl font-bold">Your account is linked!</span>
+		}
+		<span>This page will be closed automatically in a few seconds.</span>
+	</div>
+	<script>
+    setTimeout(() => {
+      window.location.href = "/app"
+    }, 5000)
+  </script>
+}
diff --git a/cmd/frontend/routes/linked_templ.go b/cmd/frontend/routes/linked_templ.go
new file mode 100644
index 00000000..15c3cd14
--- /dev/null
+++ b/cmd/frontend/routes/linked_templ.go
@@ -0,0 +1,72 @@
+// Code generated by templ - DO NOT EDIT.
+
+// templ: version: v0.2.731
+package routes
+
+//lint:file-ignore SA4006 This context is only used if a nested component is present.
+
+import "github.com/a-h/templ"
+import templruntime "github.com/a-h/templ/runtime"
+
+import (
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/cmd/frontend/layouts"
+)
+
+var AccountLinked handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
+	return layouts.Main, accountLinkedPage(ctx.Query("nickname")), nil
+}
+
+func accountLinkedPage(nickname string) templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var1 == nil {
+			templ_7745c5c3_Var1 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<head><title>Aftermath 🔗 Wargaming</title></head><div class=\"flex flex-col items-center self-center justify-center h-full gap-1\"><span class=\"text-7xl p-2\">🎉</span> ")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		if nickname != "" {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<span class=\"text-2xl font-bold\">Your ")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			var templ_7745c5c3_Var2 string
+			templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(nickname)
+			if templ_7745c5c3_Err != nil {
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/linked.templ`, Line: 19, Col: 51}
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" account is linked!</span> ")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		} else {
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<span class=\"text-2xl font-bold\">Your account is linked!</span> ")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<span>This page will be closed automatically in a few seconds.</span></div><script>\n    setTimeout(() => {\n      window.location.href = \"/app\"\n    }, 5000)\n  </script>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return templ_7745c5c3_Err
+	})
+}
diff --git a/cmd/frontend/routes/login.go b/cmd/frontend/routes/login.go
index 1001f650..1377d157 100644
--- a/cmd/frontend/routes/login.go
+++ b/cmd/frontend/routes/login.go
@@ -2,6 +2,7 @@ package routes
 
 import (
 	"net/http"
+	"strings"
 	"time"
 
 	"github.com/cufee/aftermath/cmd/frontend/handler"
@@ -14,6 +15,9 @@ import (
 var Login handler.Endpoint = func(ctx *handler.Context) error {
 	user, err := ctx.SessionUser()
 	if err == nil && user.ID != "" {
+		if from := strings.ToLower(ctx.Query("from")); from != "" && !strings.HasPrefix(from, "http://") && !strings.HasPrefix(from, "https://") {
+			return ctx.Redirect(from, http.StatusTemporaryRedirect)
+		}
 		return ctx.Redirect("/app", http.StatusTemporaryRedirect)
 	}
 
@@ -29,7 +33,10 @@ var Login handler.Endpoint = func(ctx *handler.Context) error {
 	log.Debug().Str("identifier", identifier).Msg("new login request")
 
 	redirectURL := discord.NewOAuthURL(nonceID)
-	meta := map[string]string{"from": ctx.Query("from"), "redirectUrl": redirectURL.String()}
+	meta := map[string]string{"redirectUrl": redirectURL.String()}
+	if path := ctx.Query("from"); path != "" && !strings.HasPrefix(path, "http://") && !strings.HasPrefix(path, "https://") {
+		meta["from"] = path
+	}
 
 	nonce, err := ctx.Database().CreateAuthNonce(ctx.Context, nonceID, identifier, time.Now().Add(time.Minute*5), meta)
 	if err != nil {
diff --git a/cmd/frontend/routes/redirect/discord_verify.templ b/cmd/frontend/routes/redirect/discord_verify.templ
new file mode 100644
index 00000000..ee386978
--- /dev/null
+++ b/cmd/frontend/routes/redirect/discord_verify.templ
@@ -0,0 +1,38 @@
+package redirect
+
+import (
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/cmd/frontend/logic"
+	"github.com/cufee/aftermath/internal/constants"
+	"net/http"
+	"slices"
+	"strings"
+)
+
+var VerifyFromDiscord handler.Partial = func(ctx *handler.Context) (templ.Component, error) {
+	realm := strings.ToLower(ctx.Path("realm"))
+	if !slices.Contains([]string{"na", "eu", "as"}, realm) {
+		return nil, ctx.Redirect("/", http.StatusMovedPermanently)
+	}
+	return discordVerifyRedirect(realm), nil
+}
+
+templ discordVerifyRedirect(realm string) {
+	<head>
+		<title>Aftermath 🔗 Wargaming - { strings.ToUpper(realm) }</title>
+		<meta property="og:type" content="website"/>
+		<meta property="og:title" content={ "Aftermath 🔗 Wargaming -" + strings.ToUpper(realm) }/>
+		<meta property="og:image" content={ constants.FrontendURL + "/assets/og-verify.jpg" }/>
+		<meta property="og:description" content="Link your Blitz account to Aftermath!"/>
+		<meta name="twitter:card" content="summary_large_image"/>
+		<meta name="twitter:title" content={ "Aftermath 🔗 Wargaming -" + strings.ToUpper(realm) }/>
+		<meta name="twitter:image:alt" content="Link your Blitz account to Aftermath"/>
+		<meta name="twitter:image" content={ constants.FrontendURL + "/assets/og-verify.jpg" }/>
+		<meta name="twitter:description" content="Link your Blitz account to Aftermath!"/>
+	</head>
+	@logic.EmbedScript(discordVerifyRedirectScript(realm))
+}
+
+script discordVerifyRedirectScript(realm string) {
+	window.location.href="/login?from=/api/auth/wargaming/login/"+realm;
+}
diff --git a/cmd/frontend/routes/redirect/discord_verify_templ.go b/cmd/frontend/routes/redirect/discord_verify_templ.go
new file mode 100644
index 00000000..f63369ee
--- /dev/null
+++ b/cmd/frontend/routes/redirect/discord_verify_templ.go
@@ -0,0 +1,131 @@
+// Code generated by templ - DO NOT EDIT.
+
+// templ: version: v0.2.731
+package redirect
+
+//lint:file-ignore SA4006 This context is only used if a nested component is present.
+
+import "github.com/a-h/templ"
+import templruntime "github.com/a-h/templ/runtime"
+
+import (
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/cmd/frontend/logic"
+	"github.com/cufee/aftermath/internal/constants"
+	"net/http"
+	"slices"
+	"strings"
+)
+
+var VerifyFromDiscord handler.Partial = func(ctx *handler.Context) (templ.Component, error) {
+	realm := strings.ToLower(ctx.Path("realm"))
+	if !slices.Contains([]string{"na", "eu", "as"}, realm) {
+		return nil, ctx.Redirect("/", http.StatusMovedPermanently)
+	}
+	return discordVerifyRedirect(realm), nil
+}
+
+func discordVerifyRedirect(realm string) templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var1 == nil {
+			templ_7745c5c3_Var1 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<head><title>Aftermath 🔗 Wargaming - ")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var2 string
+		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(strings.ToUpper(realm))
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/redirect/discord_verify.templ`, Line: 22, Col: 60}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</title><meta property=\"og:type\" content=\"website\"><meta property=\"og:title\" content=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var3 string
+		templ_7745c5c3_Var3, templ_7745c5c3_Err = templ.JoinStringErrs("Aftermath 🔗 Wargaming -" + strings.ToUpper(realm))
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/redirect/discord_verify.templ`, Line: 24, Col: 91}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var3))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><meta property=\"og:image\" content=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var4 string
+		templ_7745c5c3_Var4, templ_7745c5c3_Err = templ.JoinStringErrs(constants.FrontendURL + "/assets/og-verify.jpg")
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/redirect/discord_verify.templ`, Line: 25, Col: 85}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var4))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><meta property=\"og:description\" content=\"Link your Blitz account to Aftermath!\"><meta name=\"twitter:card\" content=\"summary_large_image\"><meta name=\"twitter:title\" content=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var5 string
+		templ_7745c5c3_Var5, templ_7745c5c3_Err = templ.JoinStringErrs("Aftermath 🔗 Wargaming -" + strings.ToUpper(realm))
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/redirect/discord_verify.templ`, Line: 28, Col: 92}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var5))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><meta name=\"twitter:image:alt\" content=\"Link your Blitz account to Aftermath\"><meta name=\"twitter:image\" content=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var6 string
+		templ_7745c5c3_Var6, templ_7745c5c3_Err = templ.JoinStringErrs(constants.FrontendURL + "/assets/og-verify.jpg")
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/redirect/discord_verify.templ`, Line: 30, Col: 86}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var6))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><meta name=\"twitter:description\" content=\"Link your Blitz account to Aftermath!\"></head>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = logic.EmbedScript(discordVerifyRedirectScript(realm)).Render(ctx, templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return templ_7745c5c3_Err
+	})
+}
+
+func discordVerifyRedirectScript(realm string) templ.ComponentScript {
+	return templ.ComponentScript{
+		Name: `__templ_discordVerifyRedirectScript_fac0`,
+		Function: `function __templ_discordVerifyRedirectScript_fac0(realm){window.location.href="/login?from=/api/auth/wargaming/login/"+realm;
+}`,
+		Call:       templ.SafeScript(`__templ_discordVerifyRedirectScript_fac0`, realm),
+		CallInline: templ.SafeScriptInline(`__templ_discordVerifyRedirectScript_fac0`, realm),
+	}
+}
diff --git a/cmd/frontend/routes/widget/index.templ b/cmd/frontend/routes/widget/index.templ
index c8a93c2d..6a88e68d 100644
--- a/cmd/frontend/routes/widget/index.templ
+++ b/cmd/frontend/routes/widget/index.templ
@@ -7,12 +7,10 @@ import (
 	"github.com/cufee/aftermath/cmd/frontend/layouts"
 	"github.com/cufee/aftermath/cmd/frontend/logic"
 	"github.com/cufee/aftermath/cmd/frontend/routes/api/widget"
-	"os"
+	"github.com/cufee/aftermath/internal/constants"
 	"strconv"
 )
 
-var publicWgAppID = os.Getenv("WG_AUTH_APP_ID")
-
 var WidgetHome handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
 	widget, err := widget.MockWidget(ctx)
 	if err != nil {
@@ -66,7 +64,7 @@ templ widgetHome(widget templ.Component, or, ou bool, vl int) {
 			}
 		</div>
 	</div>
-	@logic.EmbedMinifiedScript(searchEventHandler(publicWgAppID), publicWgAppID)
+	@logic.EmbedMinifiedScript(searchEventHandler(constants.WargamingPublicAppID), constants.WargamingPublicAppID)
 }
 
 script onRealmSelect() {
diff --git a/cmd/frontend/routes/widget/index_templ.go b/cmd/frontend/routes/widget/index_templ.go
index a3a243b2..8b115b3d 100644
--- a/cmd/frontend/routes/widget/index_templ.go
+++ b/cmd/frontend/routes/widget/index_templ.go
@@ -15,12 +15,10 @@ import (
 	"github.com/cufee/aftermath/cmd/frontend/layouts"
 	"github.com/cufee/aftermath/cmd/frontend/logic"
 	"github.com/cufee/aftermath/cmd/frontend/routes/api/widget"
-	"os"
+	"github.com/cufee/aftermath/internal/constants"
 	"strconv"
 )
 
-var publicWgAppID = os.Getenv("WG_AUTH_APP_ID")
-
 var WidgetHome handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
 	widget, err := widget.MockWidget(ctx)
 	if err != nil {
@@ -135,7 +133,7 @@ func widgetHome(widget templ.Component, or, ou bool, vl int) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		templ_7745c5c3_Err = logic.EmbedMinifiedScript(searchEventHandler(publicWgAppID), publicWgAppID).Render(ctx, templ_7745c5c3_Buffer)
+		templ_7745c5c3_Err = logic.EmbedMinifiedScript(searchEventHandler(constants.WargamingPublicAppID), constants.WargamingPublicAppID).Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
diff --git a/dev_web.go b/dev_web.go
index c358a669..bf9d10bf 100644
--- a/dev_web.go
+++ b/dev_web.go
@@ -10,6 +10,7 @@ import (
 	"github.com/cufee/aftermath/cmd/core"
 	"github.com/cufee/aftermath/cmd/core/server"
 	"github.com/cufee/aftermath/cmd/frontend"
+	"github.com/cufee/aftermath/internal/constants"
 	"github.com/cufee/aftermath/internal/localization"
 	"github.com/cufee/aftermath/internal/stats/render/assets"
 	render "github.com/cufee/aftermath/internal/stats/render/common/v1"
@@ -60,13 +61,13 @@ func redirectHandlersFromEnv() []server.Handler {
 		{
 			Path: "GET /invite/{$}",
 			Func: func(w http.ResponseWriter, r *http.Request) {
-				http.Redirect(w, r, os.Getenv("BOT_INVITE_LINK"), http.StatusTemporaryRedirect)
+				http.Redirect(w, r, constants.DiscordBotInviteURL, http.StatusTemporaryRedirect)
 			},
 		},
 		{
 			Path: "GET /join/{$}",
 			Func: func(w http.ResponseWriter, r *http.Request) {
-				http.Redirect(w, r, os.Getenv("PRIMARY_GUILD_INVITE_LINK"), http.StatusTemporaryRedirect)
+				http.Redirect(w, r, constants.DiscordPrimaryGuildInviteURL, http.StatusTemporaryRedirect)
 			},
 		},
 	}
diff --git a/go.mod b/go.mod
index 224245ef..43127461 100644
--- a/go.mod
+++ b/go.mod
@@ -4,6 +4,7 @@ go 1.22.3
 
 require (
 	entgo.io/ent v0.13.1
+	github.com/PuerkitoBio/goquery v1.8.1
 	github.com/a-h/templ v0.2.731
 	github.com/bwmarrin/discordgo v0.28.1
 	github.com/cufee/am-wg-proxy-next/v2 v2.1.7
@@ -31,6 +32,7 @@ require (
 require (
 	ariga.io/atlas v0.24.0 // indirect
 	github.com/agext/levenshtein v1.2.3 // indirect
+	github.com/andybalholm/cascadia v1.3.1 // indirect
 	github.com/apparentlymart/go-textseg/v15 v15.0.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/go-openapi/inflect v0.21.0 // indirect
@@ -48,6 +50,7 @@ require (
 	go.uber.org/atomic v1.11.0 // indirect
 	golang.org/x/crypto v0.24.0 // indirect
 	golang.org/x/mod v0.18.0 // indirect
+	golang.org/x/net v0.26.0 // indirect
 	golang.org/x/sys v0.21.0 // indirect
 	golang.org/x/tools v0.22.0 // indirect
 )
diff --git a/go.sum b/go.sum
index aa531aa1..c67354f4 100644
--- a/go.sum
+++ b/go.sum
@@ -4,10 +4,14 @@ entgo.io/ent v0.13.1 h1:uD8QwN1h6SNphdCCzmkMN3feSUzNnVvV/WIkHKMbzOE=
 entgo.io/ent v0.13.1/go.mod h1:qCEmo+biw3ccBn9OyL4ZK5dfpwg++l1Gxwac5B1206A=
 github.com/DATA-DOG/go-sqlmock v1.5.0 h1:Shsta01QNfFxHCfpW6YH2STWB0MudeXXEWMr20OEh60=
 github.com/DATA-DOG/go-sqlmock v1.5.0/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM=
+github.com/PuerkitoBio/goquery v1.8.1 h1:uQxhNlArOIdbrH1tr0UXwdVFgDcZDrZVdcpygAcwmWM=
+github.com/PuerkitoBio/goquery v1.8.1/go.mod h1:Q8ICL1kNUJ2sXGoAhPGUdYDJvgQgHzJsnnd3H7Ho5jQ=
 github.com/a-h/templ v0.2.731 h1:yiv4C7whSUsa36y65O06DPr/U/j3+WGB0RmvLOoVFXc=
 github.com/a-h/templ v0.2.731/go.mod h1:IejA/ecDD0ul0dCvgCwp9t7bUZXVpGClEAdsqZQigi8=
 github.com/agext/levenshtein v1.2.3 h1:YB2fHEn0UJagG8T1rrWknE3ZQzWM06O8AMAatNn7lmo=
 github.com/agext/levenshtein v1.2.3/go.mod h1:JEDfjyjHDjOF/1e4FlBE/PkbqA9OfWu2ki2W0IB5558=
+github.com/andybalholm/cascadia v1.3.1 h1:nhxRkql1kdYCc8Snf7D5/D3spOX+dBgjA6u8x004T2c=
+github.com/andybalholm/cascadia v1.3.1/go.mod h1:R4bJ1UQfqADjvDa4P6HZHLh/3OxWWEqc0Sk8XGwHqvA=
 github.com/apparentlymart/go-textseg/v15 v15.0.0 h1:uYvfpb3DyLSCGWnctWKGj857c6ew1u1fNQOlOtuGxQY=
 github.com/apparentlymart/go-textseg/v15 v15.0.0/go.mod h1:K8XmNZdhEBkdlyDdvbmmsvpAG721bKi0joRfFdHIWJ4=
 github.com/bwmarrin/discordgo v0.28.1 h1:gXsuo2GBO7NbR6uqmrrBDplPUx2T3nzu775q/Rd1aG4=
@@ -60,16 +64,12 @@ github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/
 github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
-github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/mattn/go-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o4kU=
 github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
 github.com/mitchellh/go-wordwrap v1.0.1 h1:TLuKupo69TCn6TQSyGxwI1EblZZEsQ0vMlAFQflz0v0=
 github.com/mitchellh/go-wordwrap v1.0.1/go.mod h1:R62XHJLzvMFRBbcrT7m7WgmE1eOyTSsCt+hzestvNj0=
 github.com/nlpodyssey/gopickle v0.3.0 h1:BLUE5gxFLyyNOPzlXxt6GoHEMMxD0qhsE4p0CIQyoLw=
 github.com/nlpodyssey/gopickle v0.3.0/go.mod h1:f070HJ/yR+eLi5WmM1OXJEGaTpuJEUiib19olXgYha0=
-github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
-github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
 github.com/pierrec/lz4/v4 v4.1.21 h1:yOVMLb6qSIDP67pl/5F7RepeKYu/VmTyEXvuMI5d9mQ=
 github.com/pierrec/lz4/v4 v4.1.21/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
@@ -77,8 +77,6 @@ github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
-github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
 github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=
 github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
@@ -87,10 +85,6 @@ github.com/rogpeppe/go-internal v1.8.1/go.mod h1:JeRgkft04UBgHMgCIwADu4Pn6Mtm5d4
 github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
 github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8=
 github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
-github.com/spf13/cobra v1.7.0 h1:hyqWnYt1ZQShIddO5kBpj3vu05/++x6tJ6dg8EC572I=
-github.com/spf13/cobra v1.7.0/go.mod h1:uLxZILRyS/50WlhOIKD7W6V5bgeIt+4sICxh6uRMrb0=
-github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
-github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
@@ -107,6 +101,7 @@ github.com/tdewolff/parse/v2 v2.7.15/go.mod h1:3FbJWZp3XT9OWVN3Hmfp0p/a08v4h8J9W
 github.com/tdewolff/test v1.0.11-0.20231101010635-f1265d231d52/go.mod h1:6DAvZliBAAnD7rhVgwaM7DE5/d9NMOAJ09SqYqeK4QE=
 github.com/tdewolff/test v1.0.11-0.20240106005702-7de5f7df4739 h1:IkjBCtQOOjIn03u/dMQK9g+Iw9ewps4mCl1nB8Sscbo=
 github.com/tdewolff/test v1.0.11-0.20240106005702-7de5f7df4739/go.mod h1:XPuWBzvdUzhCuxWO1ojpXsyzsA5bFoS3tO/Q3kFuTG8=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 github.com/zclconf/go-cty v1.14.4 h1:uXXczd9QDGsgu0i/QFR/hzI5NYCHLf6NQw/atrbnhq8=
 github.com/zclconf/go-cty v1.14.4/go.mod h1:VvMs5i0vgZdhYawQNq5kePSpLAoz8u1xvZgrPIxfnZE=
 github.com/zclconf/go-cty-debug v0.0.0-20240509010212-0d6042c53940 h1:4r45xpDWB6ZMSMNJFMOjqrGHynW3DIBuR2H9j0ug+Mo=
@@ -124,7 +119,9 @@ go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
 go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE=
 go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0=
 golang.org/x/crypto v0.0.0-20190123085648-057139ce5d2b/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.24.0 h1:mnl8DM0o513X8fdIkmyFE/5hTYxbwYOjDS/+rK6qpRI=
 golang.org/x/crypto v0.24.0/go.mod h1:Z1PMYSOR5nyMcyAVAIQSKCDwalqy85Aqn1x3Ws4L5DM=
 golang.org/x/exp v0.0.0-20240613232115-7f521ea00fb8 h1:yixxcjnhBmY0nkL253HFVIm0JsFHwrHdT3Yh6szTnfY=
@@ -132,26 +129,49 @@ golang.org/x/exp v0.0.0-20240613232115-7f521ea00fb8/go.mod h1:jj3sYF3dwk5D+ghuXy
 golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
 golang.org/x/image v0.17.0 h1:nTRVVdajgB8zCMZVsViyzhnMKPwYeroEERRC64JuLco=
 golang.org/x/image v0.17.0/go.mod h1:4yyo5vMFQjVjUcVk4jEQcU9MGy/rulF5WvUILseCM2E=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
 golang.org/x/mod v0.18.0 h1:5+9lSbEzPSdWkH32vYPBwEpX8KwDbM52Ud9xBUvNlb0=
 golang.org/x/mod v0.18.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20210916014120-12bc252f5db8/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
+golang.org/x/net v0.26.0 h1:soB7SVo0PWrY4vPW/+ay0jKDNScG2X9wFeYlXIvJsOQ=
+golang.org/x/net v0.26.0/go.mod h1:5YKkiSynbBIh3p6iOc/vibscux0x38BZDkn8sCUPxHE=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
 golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20190124100055-b90733256f2e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.21.0 h1:rF+pYz3DAGSQAxAu1CbC7catZg4ebC4UIeIhKxBZvws=
 golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
 golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
 golang.org/x/tools v0.22.0 h1:gqSGLZqv+AI9lIQzniJ0nZDRG5GBPsSi+DRNHWNz6yA=
 golang.org/x/tools v0.22.0/go.mod h1:aCwcsjqvq7Yqt6TNyX7QMU2enbQ/Gt0bo6krSeEri+c=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
diff --git a/internal/constants/core.go b/internal/constants/core.go
new file mode 100644
index 00000000..35a6c59e
--- /dev/null
+++ b/internal/constants/core.go
@@ -0,0 +1,15 @@
+package constants
+
+import (
+	"os"
+	"strconv"
+)
+
+var (
+	SchedulerEnabled           = os.Getenv("SCHEDULER_ENABLED") == "true"
+	SchedulerConcurrentWorkers int
+)
+
+func init() {
+	SchedulerConcurrentWorkers, _ = strconv.Atoi(mustGetEnv("SCHEDULER_CONCURRENT_WORKERS", func() bool { return !SchedulerEnabled }))
+}
diff --git a/internal/constants/database.go b/internal/constants/database.go
new file mode 100644
index 00000000..3570af51
--- /dev/null
+++ b/internal/constants/database.go
@@ -0,0 +1,6 @@
+package constants
+
+var (
+	DatabasePath = mustGetEnv("DATABASE_PATH")
+	DatabaseName = mustGetEnv("DATABASE_NAME")
+)
diff --git a/internal/constants/discord.go b/internal/constants/discord.go
new file mode 100644
index 00000000..8d300bba
--- /dev/null
+++ b/internal/constants/discord.go
@@ -0,0 +1,24 @@
+package constants
+
+import "os"
+
+var (
+	DiscordBotInviteURL          = mustGetEnv("BOT_INVITE_LINK")
+	DiscordPrimaryGuildInviteURL = mustGetEnv("PRIMARY_GUILD_INVITE_LINK")
+)
+
+var (
+	DiscordPrimaryToken     = mustGetEnv("DISCORD_TOKEN")
+	DiscordPrimaryPublicKey = mustGetEnv("DISCORD_PUBLIC_KEY")
+
+	DiscordPrivateBotEnabled = os.Getenv("INTERNAL_DISCORD_TOKEN") != ""
+	DiscordPrivateToken      = mustGetEnv("INTERNAL_DISCORD_TOKEN", func() bool { return !DiscordPrivateBotEnabled })
+	DiscordPrivatePublicKey  = mustGetEnv("INTERNAL_DISCORD_PUBLIC_KEY", func() bool { return !DiscordPrivateBotEnabled })
+)
+
+var (
+	DiscordAuthClientID      = mustGetEnv("DISCORD_AUTH_CLIENT_ID")
+	DiscordAuthClientSecret  = mustGetEnv("DISCORD_AUTH_CLIENT_SECRET")
+	DiscordAuthRedirectURL   = mustGetEnv("DISCORD_AUTH_REDIRECT_URL")
+	DiscordAuthDefaultScopes = mustGetEnv("DISCORD_AUTH_DEFAULT_SCOPES")
+)
diff --git a/internal/constants/env.go b/internal/constants/env.go
new file mode 100644
index 00000000..005f0cba
--- /dev/null
+++ b/internal/constants/env.go
@@ -0,0 +1,19 @@
+package constants
+
+import (
+	"os"
+
+	_ "github.com/joho/godotenv/autoload"
+)
+
+func mustGetEnv(key string, ignoreIf ...func() bool) string {
+	if v := os.Getenv(key); v != "" {
+		return v
+	}
+	for _, ignore := range ignoreIf {
+		if ignore() {
+			return "@ignored"
+		}
+	}
+	panic(key + " environment variable must be set")
+}
diff --git a/internal/constants/external.go b/internal/constants/external.go
new file mode 100644
index 00000000..cb78dce6
--- /dev/null
+++ b/internal/constants/external.go
@@ -0,0 +1,40 @@
+package constants
+
+import (
+	"os"
+	"strconv"
+	"time"
+)
+
+var (
+	BlitzStarsApiURL = mustGetEnv("BLITZ_STARS_API_URL")
+)
+
+var (
+	WargamingPrimaryAppID             = mustGetEnv("WG_PRIMARY_APP_ID")
+	WargamingPrimaryAppRPS            int
+	WargamingPrimaryAppRequestTimeout time.Duration
+	WargamingPrimaryAppProxyHostList  = os.Getenv("WG_PROXY_HOST_LIST")
+	WargamingCacheAppID               = mustGetEnv("WG_CACHE_APP_ID")
+	WargamingCacheAppRPS              int
+	WargamingCacheAppRequestTimeout   time.Duration
+	WargamingCacheAppProxyHostList    = os.Getenv("WG_CACHE_PROXY_HOST_LIST")
+
+	WargamingPublicAppID = mustGetEnv("WG_AUTH_APP_ID")
+)
+
+func init() {
+	{
+		WargamingPrimaryAppRPS, _ = strconv.Atoi(mustGetEnv("WG_PRIMARY_APP_RPS"))
+		timeoutSec, _ := strconv.Atoi(mustGetEnv("WG_PRIMARY_REQUEST_TIMEOUT_SEC"))
+		WargamingPrimaryAppRequestTimeout = time.Duration(timeoutSec) * time.Second
+	}
+
+	{
+
+		WargamingCacheAppRPS, _ = strconv.Atoi(mustGetEnv("WG_CACHE_APP_RPS"))
+		timeoutSec, _ := strconv.Atoi(mustGetEnv("WG_CACHE_REQUEST_TIMEOUT_SEC"))
+		WargamingCacheAppRequestTimeout = time.Duration(timeoutSec) * time.Second
+	}
+
+}
diff --git a/internal/constants/web.go b/internal/constants/web.go
new file mode 100644
index 00000000..0ee38d55
--- /dev/null
+++ b/internal/constants/web.go
@@ -0,0 +1,13 @@
+package constants
+
+import "os"
+
+var (
+	FrontendURL     = mustGetEnv("FRONTEND_URL")
+	FrontendAppName = mustGetEnv("WEBAPP_NAME")
+)
+
+var (
+	ServePrivateEndpointsEnabled = os.Getenv("PRIVATE_SERVER_ENABLED") == "true"
+	ServePrivateEndpointsPort    = os.Getenv("PRIVATE_SERVER_PORT")
+)
diff --git a/internal/external/wargaming/client.go b/internal/external/wargaming/client.go
index 42d4a5fe..75766449 100644
--- a/internal/external/wargaming/client.go
+++ b/internal/external/wargaming/client.go
@@ -1,9 +1,6 @@
 package wargaming
 
 import (
-	"fmt"
-	"os"
-	"strconv"
 	"time"
 
 	"github.com/cufee/am-wg-proxy-next/v2/client"
@@ -14,20 +11,6 @@ type Client interface {
 	client.Client
 }
 
-func NewClientFromEnv(primaryAppId, primaryAppRps, requestTimeout, proxyHostList string) (Client, error) {
-	primaryRps, err := strconv.Atoi(primaryAppRps)
-	if err != nil {
-		return nil, fmt.Errorf("primaryAppRps invalid: %w", err)
-
-	}
-
-	timeoutInt, err := strconv.Atoi(requestTimeout)
-	if err != nil {
-		return nil, fmt.Errorf("requestTimeout invalid: %w", err)
-	}
-	timeout := time.Second * time.Duration(timeoutInt)
-
-	return client.NewEmbeddedClient(primaryAppId, primaryRps, proxyHostList, timeout, client.WithLogLevel(zerolog.WarnLevel))
+func NewClientFromEnv(primaryAppId string, primaryAppRps int, requestTimeout time.Duration, proxyHostList string) (Client, error) {
+	return client.NewEmbeddedClient(primaryAppId, primaryAppRps, proxyHostList, requestTimeout, client.WithLogLevel(zerolog.WarnLevel))
 }
-
-var PublicAppID = os.Getenv("WG_AUTH_APP_ID")
diff --git a/main.go b/main.go
index 4d887007..010fae72 100644
--- a/main.go
+++ b/main.go
@@ -7,7 +7,6 @@ import (
 	"io/fs"
 	"os/signal"
 	"path/filepath"
-	"strconv"
 	"syscall"
 
 	"os"
@@ -23,6 +22,7 @@ import (
 	"github.com/cufee/aftermath/cmd/core/server"
 	"github.com/cufee/aftermath/cmd/core/server/handlers/private"
 	"github.com/cufee/aftermath/cmd/discord"
+	"github.com/cufee/aftermath/internal/constants"
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/external/blitzstars"
 	"github.com/cufee/aftermath/internal/external/wargaming"
@@ -41,7 +41,7 @@ import (
 	"net/http/pprof"
 )
 
-//go:generate go generate ./cmd/frontend/assets
+//go:generate go generate ./cmd/frontend/assets/generate
 
 //go:embed static/*
 var static embed.FS
@@ -76,9 +76,8 @@ func main() {
 	// Load some init options to registered admin accounts and etc
 	logic.ApplyInitOptions(liveCoreClient.Database())
 
-	if e := os.Getenv("PRIVATE_SERVER_ENABLED"); e == "true" {
-		port := os.Getenv("PRIVATE_SERVER_PORT")
-		servePrivate := server.NewServer(port, []server.Handler{
+	if constants.ServePrivateEndpointsEnabled {
+		servePrivate := server.NewServer(constants.ServePrivateEndpointsPort, []server.Handler{
 			{
 				Path: "GET /debug/profile/{name}",
 				Func: func(w http.ResponseWriter, r *http.Request) {
@@ -98,7 +97,7 @@ func main() {
 				Func: private.SaveRealmSnapshots(cacheCoreClient),
 			},
 		}...)
-		log.Info().Str("port", port).Msg("starting a private server")
+		log.Info().Str("port", constants.ServePrivateEndpointsPort).Msg("starting a private server")
 		go servePrivate()
 	}
 
@@ -135,11 +134,7 @@ func discordHandlersFromEnv(coreClient core.Client) []server.Handler {
 
 	// main Discord with all the user-facing command
 	{
-		if os.Getenv("DISCORD_TOKEN") == "" || os.Getenv("DISCORD_PUBLIC_KEY") == "" {
-			log.Fatal().Msg("DISCORD_TOKEN and DISCORD_PUBLIC_KEY are required")
-
-		}
-		mainDiscordHandler, err := discord.NewRouterHandler(coreClient, os.Getenv("DISCORD_TOKEN"), os.Getenv("DISCORD_PUBLIC_KEY"), commands.LoadedPublic.Compose()...)
+		mainDiscordHandler, err := discord.NewRouterHandler(coreClient, constants.DiscordPrimaryToken, constants.DiscordPrimaryPublicKey, commands.LoadedPublic.Compose()...)
 		if err != nil {
 			log.Fatal().Msgf("discord#NewRouterHandler failed %s", err)
 		}
@@ -150,13 +145,8 @@ func discordHandlersFromEnv(coreClient core.Client) []server.Handler {
 	}
 
 	// secondary Discord bot with mod/admin commands - permissions are still checked
-	if token := os.Getenv("INTERNAL_DISCORD_TOKEN"); token != "" {
-		publicKey := os.Getenv("INTERNAL_DISCORD_PUBLIC_KEY")
-		if publicKey == "" {
-			log.Fatal().Msg("discordHandlersFromEnv failed missing INTERNAL_DISCORD_PUBLIC_KEY")
-		}
-
-		internalDiscordHandler, err := discord.NewRouterHandler(coreClient, token, publicKey, commands.LoadedInternal.Compose()...)
+	if constants.DiscordPrivateBotEnabled {
+		internalDiscordHandler, err := discord.NewRouterHandler(coreClient, constants.DiscordPrivateToken, constants.DiscordPrivatePublicKey, commands.LoadedInternal.Compose()...)
 		if err != nil {
 			log.Fatal().Msgf("discord#NewRouterHandler failed %s", err)
 		}
@@ -170,7 +160,7 @@ func discordHandlersFromEnv(coreClient core.Client) []server.Handler {
 }
 
 func startSchedulerFromEnv(ctx context.Context, coreClient core.Client) (func(), error) {
-	if os.Getenv("SCHEDULER_ENABLED") != "true" {
+	if !constants.SchedulerEnabled {
 		return func() {}, nil
 	}
 	s := scheduler.New()
@@ -179,7 +169,7 @@ func startSchedulerFromEnv(ctx context.Context, coreClient core.Client) (func(),
 }
 
 func startQueueFromEnv(ctx context.Context, db database.Client, wgClient wargaming.Client) (func(), error) {
-	bsClient, err := blitzstars.NewClient(os.Getenv("BLITZ_STARS_API_URL"), time.Second*10)
+	bsClient, err := blitzstars.NewClient(constants.BlitzStarsApiURL, time.Second*10)
 	if err != nil {
 		log.Fatal().Msgf("failed to init a blitzstars client %s", err)
 	}
@@ -191,13 +181,8 @@ func startQueueFromEnv(ctx context.Context, db database.Client, wgClient wargami
 	}
 
 	// Queue - pulls tasks from database and runs the logic
-	queueWorkerLimit := 10
-	if v, err := strconv.Atoi(os.Getenv("SCHEDULER_CONCURRENT_WORKERS")); err == nil {
-		queueWorkerLimit = v
-	}
-
 	coreClient := core.NewClient(client, wgClient, db)
-	q := queue.New(queueWorkerLimit, func() (core.Client, error) {
+	q := queue.New(constants.SchedulerConcurrentWorkers, func() (core.Client, error) {
 		return coreClient, nil
 	})
 
@@ -206,7 +191,7 @@ func startQueueFromEnv(ctx context.Context, db database.Client, wgClient wargami
 }
 
 func coreClientsFromEnv(db database.Client) (core.Client, core.Client) {
-	bsClient, err := blitzstars.NewClient(os.Getenv("BLITZ_STARS_API_URL"), time.Second*10)
+	bsClient, err := blitzstars.NewClient(constants.BlitzStarsApiURL, time.Second*10)
 	if err != nil {
 		log.Fatal().Msgf("failed to init a blitzstars client %s", err)
 	}
@@ -244,13 +229,13 @@ func loadStaticAssets(static fs.FS) {
 }
 
 func wargamingClientsFromEnv() (wargaming.Client, wargaming.Client) {
-	liveClient, err := wargaming.NewClientFromEnv(os.Getenv("WG_PRIMARY_APP_ID"), os.Getenv("WG_PRIMARY_APP_RPS"), os.Getenv("WG_PRIMARY_REQUEST_TIMEOUT_SEC"), os.Getenv("WG_PROXY_HOST_LIST"))
+	liveClient, err := wargaming.NewClientFromEnv(constants.WargamingPrimaryAppID, constants.WargamingPrimaryAppRPS, constants.WargamingPrimaryAppRequestTimeout, constants.WargamingPrimaryAppProxyHostList)
 	if err != nil {
 		log.Fatal().Msgf("wargamingClientsFromEnv#NewClientFromEnv failed %s", err)
 	}
 
 	// This wargaming client is using a different proxy as it needs a lot higher rps, but can be slow
-	cacheClient, err := wargaming.NewClientFromEnv(os.Getenv("WG_CACHE_APP_ID"), os.Getenv("WG_CACHE_APP_RPS"), os.Getenv("WG_CACHE_REQUEST_TIMEOUT_SEC"), os.Getenv("WG_CACHE_PROXY_HOST_LIST"))
+	cacheClient, err := wargaming.NewClientFromEnv(constants.WargamingCacheAppID, constants.WargamingCacheAppRPS, constants.WargamingCacheAppRequestTimeout, constants.WargamingCacheAppProxyHostList)
 	if err != nil {
 		log.Fatal().Msgf("wargamingClientsFromEnv#NewClientFromEnv failed %s", err)
 	}
@@ -259,12 +244,12 @@ func wargamingClientsFromEnv() (wargaming.Client, wargaming.Client) {
 }
 
 func newDatabaseClientFromEnv() (database.Client, error) {
-	err := os.MkdirAll(os.Getenv("DATABASE_PATH"), os.ModePerm)
+	err := os.MkdirAll(constants.DatabasePath, os.ModePerm)
 	if err != nil {
 		return nil, fmt.Errorf("os#MkdirAll failed %w", err)
 	}
 
-	client, err := database.NewSQLiteClient(filepath.Join(os.Getenv("DATABASE_PATH"), os.Getenv("DATABASE_NAME")))
+	client, err := database.NewSQLiteClient(filepath.Join(constants.DatabasePath, constants.DatabaseName))
 	if err != nil {
 
 		return nil, fmt.Errorf("database#NewClient failed %w", err)
@@ -278,13 +263,13 @@ func redirectHandlersFromEnv() []server.Handler {
 		{
 			Path: "GET /invite/{$}",
 			Func: func(w http.ResponseWriter, r *http.Request) {
-				http.Redirect(w, r, os.Getenv("BOT_INVITE_LINK"), http.StatusTemporaryRedirect)
+				http.Redirect(w, r, constants.DiscordBotInviteURL, http.StatusTemporaryRedirect)
 			},
 		},
 		{
 			Path: "GET /join/{$}",
 			Func: func(w http.ResponseWriter, r *http.Request) {
-				http.Redirect(w, r, os.Getenv("PRIMARY_GUILD_INVITE_LINK"), http.StatusTemporaryRedirect)
+				http.Redirect(w, r, constants.DiscordPrimaryGuildInviteURL, http.StatusTemporaryRedirect)
 			},
 		},
 	}
diff --git a/static/localization/en/discord.yaml b/static/localization/en/discord.yaml
index 0db84573..6dad1136 100755
--- a/static/localization/en/discord.yaml
+++ b/static/localization/en/discord.yaml
@@ -36,6 +36,12 @@
   value: View your linked Blitz accounts
 - key: command_links_linked_successfully_fmt
   value: "Your account has been linked! Aftermath will now default to **%s** on **%s** when checking stats.\nYou can also verify your account with `/verify`"
+- key: command_option_links_verify_name
+  value: "verify"
+- key: command_option_links_verify_desc
+  value: "Link and verify your Blitz account to unlock more features!"
+- key: command_links_verify_response_fmt
+  value: "## Here is your verification link!\n### You will need to log in using the Discord account you are currently using in order to link your Blitz account.\n_This link is specific to %s. It does not contain any personal information._\n:link: %s"
 
 - key: command_links_set_default_successfully_fmt
   value: "Your default account has been updated! Aftermath will now default to **%s** on **%s** when checking stats."

From 9e2be034d841b0d9dc1d2d867f93744fcb460084 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sat, 6 Jul 2024 19:42:44 -0400
Subject: [PATCH 289/341] added favicon

---
 cmd/frontend/assets/generate/generate.go |  14 ++++++++++++++
 cmd/frontend/components/head.templ       |   1 +
 cmd/frontend/components/head_templ.go    |   2 +-
 cmd/frontend/public/favicon.ico          | Bin 3890 -> 397 bytes
 4 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/cmd/frontend/assets/generate/generate.go b/cmd/frontend/assets/generate/generate.go
index 0d5acd21..16e1a8d3 100644
--- a/cmd/frontend/assets/generate/generate.go
+++ b/cmd/frontend/assets/generate/generate.go
@@ -14,6 +14,8 @@ import (
 	"github.com/disintegration/imaging"
 	"github.com/fogleman/gg"
 	"github.com/rs/zerolog/log"
+
+	ico "github.com/Kodeworks/golang-image-ico"
 )
 
 var outDirPath = "../../public"
@@ -87,6 +89,18 @@ func generateLogoOptions() {
 			panic(err)
 		}
 		f.Close()
+
+		if size == 16 {
+			f, err := os.Create(filepath.Join(outDirPath, "favicon.ico"))
+			if err != nil {
+				panic(err)
+			}
+			err = ico.Encode(f, imaging.Fit(img, size, size, imaging.Linear))
+			if err != nil {
+				panic(err)
+			}
+			f.Close()
+		}
 	}
 }
 
diff --git a/cmd/frontend/components/head.templ b/cmd/frontend/components/head.templ
index 469aef89..49b76ae0 100644
--- a/cmd/frontend/components/head.templ
+++ b/cmd/frontend/components/head.templ
@@ -17,6 +17,7 @@ templ Head(additional ...templ.Component) {
 		<script src="https://cdn.tailwindcss.com"></script>
 		@logic.EmbedMinifiedScript(tailwindConfig())
 		<title>{ constants.FrontendAppName }</title>
+		<link rel="icon" type="image/x-icon" href="/assets/favicon.ico"/>
 		for _, component := range additional {
 			@component
 		}
diff --git a/cmd/frontend/components/head_templ.go b/cmd/frontend/components/head_templ.go
index ca4a3a6e..1bc54385 100644
--- a/cmd/frontend/components/head_templ.go
+++ b/cmd/frontend/components/head_templ.go
@@ -52,7 +52,7 @@ func Head(additional ...templ.Component) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</title>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</title><link rel=\"icon\" type=\"image/x-icon\" href=\"/assets/favicon.ico\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
diff --git a/cmd/frontend/public/favicon.ico b/cmd/frontend/public/favicon.ico
index c3e53a365e285c5778cde17f07f767a785254e2b..3a98784e58c51ba68a31ed8c1e35c0631b7ea526 100644
GIT binary patch
literal 397
zcmV;80doET0096201yuV0096X0CxcZ02TlM0EtjeM-2)Z3IG5A4M|8uQUCw|5C8xG
z4+sVT008ZCPcHxf0X|7YK~#90l#ww@!%!53zuT0GL8R&uoTP%_Qk=x0P;e7mb#+h#
z2N9R%Kj>JBATBOlT%DX9#I2K?i%>++6o)RhUU_+eh`yxlfd@C|o_BKYyG1gf?08VQ
zuwTzd!p+d7D`XkKn}C$<F|`{x2IIkLpqx%a)k~SGXSp#9l#?=)THtS{tf@;a+Z&l+
zY6hr*ET>#t*OK1o5hg()jgBbw%(bSvdeLYd2^uS~aSjAI_XDdj+J6R80oesj3{*kC
zlA{S1SdGzI<V2Psd^eN-ti?k*;4tv|pdHW`;q1ZA9WDSJ+xugngj=ACz$-8SeFqL8
z`X!F;VD27t31na*DUE%Qt|;LZ$SSZ0x(@wYq50{Gs~pdQzYX#TT!TKD5h9=mA6?<H
ro&6?ecd>C>IrL$^XYT$400960+0<5-i7-)B00000NkvXXu0mjf-U*`0

literal 3890
zcmeH~O=}ZT6oyYyHHg~Sg^CifAWHoKMN~BIvu+l;Z$T96w;OG6=U)&?Rdnah{($1f
zuDjB%0t&8#T3lEtJw9)8JMB#Ll1UR>*n~It+`0F>&&>UpnV1#$j-E9ATBU4u)Xc`v
zD7uJrT%X2pt4RGkFu(NJ{0n+@%e<6o96&`3Sg*wt`;qxI;x+V<xIAIL@3#42GcWcJ
z??rh|n(q}uEHTA?XnsBL7b!=mPg8!lZ+^aCe0j+;c#jZ^wI(*_a0M-+mq_RKo^pe7
zQv5sS`!yzc&qX=PRi3<pr@YHZtYyaka@Bkf<r(JXNSK>>^+i+D=Eo`DqUW1l-JFN|
zDhKYH;4wvA*EBDNSYnF3-7m{$+%Ayw1AUSYYoeg*Qn@{^9dEU%uX2<t57;SwXKwpQ
zmd`nAZ>*xv%+(2eYQ*m-wXISg9SdzW^;Hg9l}DfW6?|Uc>G;pI;o2kZeWGJ(Qy=2W
zAozIBih-Unt_NT}C4Qn<$3oj|uYB!KJm%0(yz80q*EJ>lyXI%9f0aTU<JaYh=EO)%
zT&4o^H0&B{VK~O;8qeYPO$zZ}`SOydyfe6HwO{-wB+|IcPwoHI`pYx_ks*#Yv9`up
zH{U6j!aXfn|1o~(yA*QAqmW1=j6<+*;!~gCzDwK{UwxIM+#BWxBZwSLUhI~?c~8t?
z-bL44{=Xi7)>QKR%dUUw$@6b8^KS+}dH!elv?b5~E*4XdUAEqFvV6T0Y2T^r(L7gL
zCqGyEjywPF{CnnO?8nyohvFR%XifwEPaT7=|1pb-bEYTV%kC=$_eM+A^@g4LWzC_5
fQcK0FrKVX+D`w>lvzb517lyn;&62ycUhU9tq7ivL


From 17a4af78848bf6c30c33c466e4e0909287e1ec79 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sat, 6 Jul 2024 19:57:03 -0400
Subject: [PATCH 290/341] removed generated assets

---
 cmd/frontend/assets/generate/gen.go           |   4 +++
 cmd/frontend/assets/generate/generate.go      |  27 ++++++++++++------
 cmd/frontend/components/head.templ            |   9 ++++++
 cmd/frontend/components/logo.templ            |   2 +-
 cmd/frontend/components/widget/widget.templ   |   4 +--
 cmd/frontend/public/.gitignore                |   1 +
 cmd/frontend/public/favicon.ico               | Bin 397 -> 0 bytes
 cmd/frontend/public/favicon.png               | Bin 692 -> 0 bytes
 cmd/frontend/public/icon-128.png              | Bin 2261 -> 0 bytes
 cmd/frontend/public/icon-16.png               | Bin 349 -> 0 bytes
 cmd/frontend/public/icon-256.png              | Bin 4671 -> 0 bytes
 cmd/frontend/public/icon-32.png               | Bin 583 -> 0 bytes
 cmd/frontend/public/icon-512.png              | Bin 10453 -> 0 bytes
 cmd/frontend/public/icon-64.png               | Bin 1146 -> 0 bytes
 cmd/frontend/public/og-verify.jpg             | Bin 13625 -> 0 bytes
 cmd/frontend/public/og-widget.jpg             | Bin 11274 -> 0 bytes
 cmd/frontend/public/og.jpg                    | Bin 11274 -> 0 bytes
 .../routes/redirect/discord_verify.templ      |   4 +--
 go.mod                                        |   1 +
 go.sum                                        |   2 ++
 20 files changed, 41 insertions(+), 13 deletions(-)
 create mode 100644 cmd/frontend/public/.gitignore
 delete mode 100644 cmd/frontend/public/favicon.ico
 delete mode 100644 cmd/frontend/public/favicon.png
 delete mode 100644 cmd/frontend/public/icon-128.png
 delete mode 100644 cmd/frontend/public/icon-16.png
 delete mode 100644 cmd/frontend/public/icon-256.png
 delete mode 100644 cmd/frontend/public/icon-32.png
 delete mode 100644 cmd/frontend/public/icon-512.png
 delete mode 100644 cmd/frontend/public/icon-64.png
 delete mode 100644 cmd/frontend/public/og-verify.jpg
 delete mode 100644 cmd/frontend/public/og-widget.jpg
 delete mode 100644 cmd/frontend/public/og.jpg

diff --git a/cmd/frontend/assets/generate/gen.go b/cmd/frontend/assets/generate/gen.go
index 0cb8d24e..acbf99d0 100644
--- a/cmd/frontend/assets/generate/gen.go
+++ b/cmd/frontend/assets/generate/gen.go
@@ -1,3 +1,7 @@
 package generate
 
+import (
+	_ "github.com/Kodeworks/golang-image-ico"
+)
+
 //go:generate go run ./generate.go
diff --git a/cmd/frontend/assets/generate/generate.go b/cmd/frontend/assets/generate/generate.go
index 16e1a8d3..6803d299 100644
--- a/cmd/frontend/assets/generate/generate.go
+++ b/cmd/frontend/assets/generate/generate.go
@@ -16,13 +16,24 @@ import (
 	"github.com/rs/zerolog/log"
 
 	ico "github.com/Kodeworks/golang-image-ico"
+	"github.com/joho/godotenv"
 )
 
 var outDirPath = "../../public"
+var brandColor color.RGBA
 
 var cardColor = color.RGBA{17, 17, 17, 255}
 
 func main() {
+	godotenv.Load("../../../../.env")
+
+	switch os.Getenv("BRAND_FLAVOR") {
+	default:
+		brandColor = common.ColorAftermathRed
+	case "blue":
+		brandColor = common.ColorAftermathBlue
+	}
+
 	generateWN8Icons()
 	generateLogoOptions()
 	generateOGImages()
@@ -71,7 +82,7 @@ func generateLogoOptions() {
 	log.Debug().Msg("generating logo options")
 
 	for _, size := range []int{16, 32, 64, 128, 256, 512} {
-		filename := fmt.Sprintf("icon-%d.png", size)
+		filename := fmt.Sprintf("icon/%d.png", size)
 
 		opts := common.DefaultLogoOptions()
 		opts.Gap *= 10
@@ -79,7 +90,7 @@ func generateLogoOptions() {
 		opts.LineStep *= 10
 		opts.LineWidth *= 10
 
-		img := common.AftermathLogo(common.ColorAftermathRed, opts)
+		img := common.AftermathLogo(brandColor, opts)
 		f, err := os.Create(filepath.Join(outDirPath, filename))
 		if err != nil {
 			panic(err)
@@ -118,14 +129,14 @@ func generateOGImages() {
 	}
 
 	{
-		filename := "og-widget.jpg"
+		filename := "og/widget.jpg"
 		opts := common.DefaultLogoOptions()
 		opts.Gap *= 10
 		opts.Jump *= 10
 		opts.LineStep *= 10
 		opts.LineWidth *= 10
 
-		logo := common.AftermathLogo(common.ColorAftermathRed, opts)
+		logo := common.AftermathLogo(brandColor, opts)
 		ctx := gg.NewContext(imageWidth, imageHeight)
 
 		ctx.DrawImage(imaging.Blur(imaging.Fill(bg, imageWidth, imageHeight, imaging.Center, imaging.Lanczos), 30), 0, 0)
@@ -148,14 +159,14 @@ func generateOGImages() {
 	}
 
 	{
-		filename := "og.jpg"
+		filename := "og/default.jpg"
 		opts := common.DefaultLogoOptions()
 		opts.Gap *= 10
 		opts.Jump *= 10
 		opts.LineStep *= 10
 		opts.LineWidth *= 10
 
-		logo := common.AftermathLogo(common.ColorAftermathRed, opts)
+		logo := common.AftermathLogo(brandColor, opts)
 		ctx := gg.NewContext(imageWidth, imageHeight)
 
 		ctx.DrawImage(imaging.Blur(imaging.Fill(bg, imageWidth, imageHeight, imaging.Center, imaging.Lanczos), 30), 0, 0)
@@ -178,14 +189,14 @@ func generateOGImages() {
 	}
 
 	{
-		filename := "og-verify.jpg"
+		filename := "og/verify.jpg"
 		opts := common.DefaultLogoOptions()
 		opts.Gap *= 10
 		opts.Jump *= 10
 		opts.LineStep *= 10
 		opts.LineWidth *= 10
 
-		logo := common.AftermathLogo(common.ColorAftermathRed, opts)
+		logo := common.AftermathLogo(brandColor, opts)
 		ctx := gg.NewContext(imageWidth, imageHeight)
 
 		linkIcon, err := imaging.Open("./link.png")
diff --git a/cmd/frontend/components/head.templ b/cmd/frontend/components/head.templ
index 49b76ae0..91ce6c7e 100644
--- a/cmd/frontend/components/head.templ
+++ b/cmd/frontend/components/head.templ
@@ -10,6 +10,15 @@ templ Head(additional ...templ.Component) {
 		<meta charset="utf-8"/>
 		<meta name="color-scheme" content="light"/>
 		<meta name="viewport" content="width=device-width, initial-scale=1"/>
+		<meta property="og:type" content="website"/>
+		<meta property="og:title" content={ constants.FrontendAppName }/>
+		<meta property="og:image" content={ constants.FrontendURL + "/assets/og/dafeult.jpg" }/>
+		<meta property="og:description" content="Fastest and most beautiful way to view Blitz stats!"/>
+		<meta name="twitter:card" content="summary_large_image"/>
+		<meta name="twitter:title" content={ constants.FrontendAppName }/>
+		<meta name="twitter:image:alt" content={ constants.FrontendAppName + " Logo" }/>
+		<meta name="twitter:image" content={ constants.FrontendURL + "/assets/og/dafeult.jpg" }/>
+		<meta name="twitter:description" content="Fastest and most beautiful way to view Blitz stats!"/>
 		<link href="https://cdn.jsdelivr.net/npm/daisyui@4.11.1/dist/full.min.css" rel="stylesheet" type="text/css"/>
 		<script src="https://unpkg.com/htmx.org@1.9.12"></script>
 		<script src="https://unpkg.com/htmx.org/dist/ext/head-support.js"></script>
diff --git a/cmd/frontend/components/logo.templ b/cmd/frontend/components/logo.templ
index c4b602e8..56a25f79 100644
--- a/cmd/frontend/components/logo.templ
+++ b/cmd/frontend/components/logo.templ
@@ -3,5 +3,5 @@ package components
 import "fmt"
 
 templ Logo(size string) {
-	<div class="flex flex-row items-center pointer-events-none select-none cursor-inherit"><img draggable="false" src={ fmt.Sprintf("/assets/icon-%s.png", size) } alt="Aftermath"/></div>
+	<div class="flex flex-row items-center pointer-events-none select-none cursor-inherit"><img draggable="false" src={ fmt.Sprintf("/assets/icon/%s.png", size) } alt="Aftermath"/></div>
 }
diff --git a/cmd/frontend/components/widget/widget.templ b/cmd/frontend/components/widget/widget.templ
index e3be364d..3d77f460 100644
--- a/cmd/frontend/components/widget/widget.templ
+++ b/cmd/frontend/components/widget/widget.templ
@@ -79,12 +79,12 @@ templ (w widget) Render() {
 		<title>Aftermath - { w.account.Nickname }</title>
 		<meta property="og:type" content="website"/>
 		<meta property="og:title" content="Aftermath - Streaming Widget"/>
-		<meta property="og:image" content={ constants.FrontendURL + "/assets/og-widget.jpg" }/>
+		<meta property="og:image" content={ constants.FrontendURL + "/assets/og/widget.jpg" }/>
 		<meta property="og:description" content={ fmt.Sprintf("Aftermath streaming widget for %s [%s]", w.account.Nickname, w.account.Realm) }/>
 		<meta name="twitter:card" content="summary_large_image"/>
 		<meta name="twitter:title" content="Aftermath - Streaming Widget"/>
 		<meta name="twitter:image:alt" content="Aftermath Streaming Widget"/>
-		<meta name="twitter:image" content={ constants.FrontendURL + "/assets/og-widget.jpg" }/>
+		<meta name="twitter:image" content={ constants.FrontendURL + "/assets/og/widget.jpg" }/>
 		<meta name="twitter:description" content={ fmt.Sprintf("Aftermath streaming widget for %s [%s]", w.account.Nickname, w.account.Realm) }/>
 	</head>
 	<div class="text-nowrap whitespace-nowrap" id="widget-container">
diff --git a/cmd/frontend/public/.gitignore b/cmd/frontend/public/.gitignore
new file mode 100644
index 00000000..dc4f0b78
--- /dev/null
+++ b/cmd/frontend/public/.gitignore
@@ -0,0 +1 @@
+favicon.ico
\ No newline at end of file
diff --git a/cmd/frontend/public/favicon.ico b/cmd/frontend/public/favicon.ico
deleted file mode 100644
index 3a98784e58c51ba68a31ed8c1e35c0631b7ea526..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 397
zcmV;80doET0096201yuV0096X0CxcZ02TlM0EtjeM-2)Z3IG5A4M|8uQUCw|5C8xG
z4+sVT008ZCPcHxf0X|7YK~#90l#ww@!%!53zuT0GL8R&uoTP%_Qk=x0P;e7mb#+h#
z2N9R%Kj>JBATBOlT%DX9#I2K?i%>++6o)RhUU_+eh`yxlfd@C|o_BKYyG1gf?08VQ
zuwTzd!p+d7D`XkKn}C$<F|`{x2IIkLpqx%a)k~SGXSp#9l#?=)THtS{tf@;a+Z&l+
zY6hr*ET>#t*OK1o5hg()jgBbw%(bSvdeLYd2^uS~aSjAI_XDdj+J6R80oesj3{*kC
zlA{S1SdGzI<V2Psd^eN-ti?k*;4tv|pdHW`;q1ZA9WDSJ+xugngj=ACz$-8SeFqL8
z`X!F;VD27t31na*DUE%Qt|;LZ$SSZ0x(@wYq50{Gs~pdQzYX#TT!TKD5h9=mA6?<H
ro&6?ecd>C>IrL$^XYT$400960+0<5-i7-)B00000NkvXXu0mjf-U*`0

diff --git a/cmd/frontend/public/favicon.png b/cmd/frontend/public/favicon.png
deleted file mode 100644
index 09440087a38dd5fa71c6c56c6fca09dee349acc6..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 692
zcmV;l0!#ggP)<h;3K|Lk000e1NJLTq001BW0012b1^@s6%bsqB0007eNkl<Zc%1B)
zKWG$D5XOJAyZPgZ(J0a4{DY=Rqh&CHSOp}75hRU`joJk(lO`zyn~;E}Fol(sAT|ax
zjaVs&TG@$`M8P1YkRxakLvBZA-^SdUyG?dU6d@lh_wLQSZ@!zEz4u-~PAJz7z>abE
zZJ}Ej{hEg-w*Uy5fg=^;TmroO0(_}H{%Zm@2mhA<1yOqH?K6vQ(*!_&7qs4o{*EfP
zj@Z_<B?8p>b^{kcJF9qfIvd@Zfj46Y#E+NxRjB-=&z1<-d~6Fy{VP`bc7b;ZbQY!_
zZJf3zP>!7k*$;E~gt70r1c28DdIMwziqAJLptuiY0JI2AuYfl-Bcv0R>p|*(2B^=_
z-H~sDTWcJ(@y~l;TfmwoRIazW=9|yZbm>rfo1kzS!gs>(WTnkZI$o^<e*okG6wap8
zE|;xK-4l&dU|h!O54aes_#*=iCa49p0N62WrZ%ZJ19~^wg`;sQnjNRK#4&0KSPxou
z+kIFTMt&&Vv{`{r=_|X0>N?p-B8z|!uv73}kf$qwSIyDf@z^KaDCs(HfrjoVV9%1m
z&;(3ggrS#feQhqXO*r3`b($(BP|gI<eiRl<z+BS2{1N=ez-N$>M1&8Qsu5M%6e)p@
zgA`+q6N#TiZwoZ;f!EU>oIC~I6DSNrp)po&lq%f*0!x=+YEZbfke;ndG3Glp2tThl
z4$<GSqZk&;Vzze#pohS-3&uBBlJFULyJ7k5Dp__&B2&f{yokB2>}~E+BZs}DI;+?8
z7%ZHFk(xVLb{Lm&mhM#aRg~ob!cXAO0`FmdF;-r+&UxY9mQm|5tN$YG`~V!Z*uMe*
a0RR6kc*Nc+SuQmI0000<MNUMnLSTYD-8w%2

diff --git a/cmd/frontend/public/icon-128.png b/cmd/frontend/public/icon-128.png
deleted file mode 100644
index 0ead61004b181ab32db55bac4aeb02fa428137bb..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2261
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

diff --git a/cmd/frontend/public/icon-16.png b/cmd/frontend/public/icon-16.png
deleted file mode 100644
index 296978bdb2807bc89e036ca461d5ec676867a013..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 349
zcmV-j0iyniP)<h;3K|Lk000e1NJLTq000mG000jN1^@s6?Q>5r0003bNkl<Zc$}2d
zze*fY7zOa(WH&{^5*E@dsX`VO(xpn3YP&${ZBryo-rzpMKuQrC8=HLsD{Bj}v+@B1
zv5^&vwb1p-mFsd{Xa9I$m^+8_ojKo`X<LFQw6K#O|5fT)lWwU2Ds+o;Bi^hq*a$BY
zL?PYY;l7|-QFx1+O1(BgioK0t!3{IlT@*JNbnpZHg6n6lvx&j0Fz+A=sp;0bfheSz
zS*4DP2?qF&-irBN)(oDA(%=h5g+Y45ZN6e*Fv{BJD>NYed0YAXZJDT@zk7)(PH<MK
zkMiChGdC@|m?!v&Pq@GxF7dY%;{b>FoHc3nKRB<Vu#2zwjqlj6)YnaMqwoR0aEv{i
vrUVmQJ-VsKD>{*l$5D8nXC@B;00960_gg=A=>A>U00000NkvXXu0mjf8}gje

diff --git a/cmd/frontend/public/icon-256.png b/cmd/frontend/public/icon-256.png
deleted file mode 100644
index 60feffa2fbf05f6fca3bf1438e00f164c38b836f..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 4671
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
IX>9y|0yKa%4FCWD

diff --git a/cmd/frontend/public/icon-32.png b/cmd/frontend/public/icon-32.png
deleted file mode 100644
index cf84b0338966cc7934059b46e4efe500588eafbd..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 583
zcmV-N0=WH&P)<h;3K|Lk000e1NJLTq001BW0018d1^@s6hE~sv0006GNkl<Zc%1Ck
zziU%b90l;t3vHkd77C)M2r3R03cA#_AUHVbAoxcJE<!UpMhBhRp}6U!4ldo4>L>_S
zP#3|eV^u2RkGAQP+k6AhHlg9BZaEP0Zti*Ko_Fr|d-FzQqSQEtCo#NMXfEgI)N&1A
z3Mb<;l`E2+K-^mlsxwFe`+}i?p@F`tx70}0p8Ea*Uf@#~PWn27i+GLYLbKdUyWa%H
zaSwC2jd~YOJ?7?uJKm3QzXrx|B>2ZM+J!S3bG6`(?WckNhM|F>fv)F3^!-6>;AgIQ
zoDBz}L%w%A7kVWyjb~WE;amf8??PxzcO&#Na0xTGg2@34OoqlxX!dQOUYQ^CrKPq*
za~B~OU-74MorOURyu_`_br!PQu+UtioX33oIuHFOP;JK_Xthn;sd8E|C%7B?Y2X{~
z;xZmq_P&br+kLEJG49#hK&g?o;XF=ZiE?!(snBed8jtZbJ!zr2ODG*OrP=2cOW10U
z8~<=hvx#{q+VV5rrUXvl0nU<?i}X_Qdz;^mb-lAdC;DE9Eva%gVqCU0i*&-?VB6V8
zTulZha5Vb#bQI=dyne0VLqAdWz<WHxvCyo=8ueInqE`*P!*y(S63E0C+>BcL)vfDB
zBBHGrrv*E4Xa5Ox5Vf-2d5EZq&6rMWwrUac8>C)-wbwomhO!lFti_rue**vj|Njrx
Ve<%CCg+>4X002ovPDHLkV1iL%6V?C#

diff --git a/cmd/frontend/public/icon-512.png b/cmd/frontend/public/icon-512.png
deleted file mode 100644
index 39d71f287f3f54302b70ec0a6ab7f93821a4d5ff..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 10453
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
TGhu{%T@k=uG`~=eag6yNxa&`e

diff --git a/cmd/frontend/public/icon-64.png b/cmd/frontend/public/icon-64.png
deleted file mode 100644
index 91576276a6666fed7ffdc5709e5a784063ca5cda..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1146
zcmV-=1cm#FP)<h;3K|Lk000e1NJLTq002M$002J-1^@s6P#w<7000C*Nkl<Zc%1B;
z&5ImG7{-4!iOFh=ta}mhummJ={Xj*JLRfD($a+yUnp5%*h>)3sdJ%NSFYu6q2Zhy>
zk{Ct7lj}i`!T60)bQOYNVn!1;o7H5tq^6%9n@LBzdTP6}Oh2&9c6ImrKJU}j^;W%8
zvylj}w5EWkfj#|0cmsIK(C${vrBSs*OVa?40DFP0z%{@=V7Jayipm85a|JL9Y|b>g
z|L@hgN)bT-+*6*&X`j%!N)bbV%L=ssu?fUREkJAnu~7>Un?P*T0>mZ|8?^wj3B<<O
z3$P~j080~zYr$H>b0zKUck3gQERyVMSv&uQ;61?7+6-n6%mFYRXxwFKdHYH3Y22OI
zaJCwAiS4im+5=S3*bTe{Osd**pW2Rkn!8<<q8(Z$KLk8xY0euuHWcT;J-}=M9#!y&
zxC>xTuSFr~+WRxXBb$5VBN#%z0<Mcr4Yj!duG70*5JvZ0R3Moesw9n!s<J@km7by)
z`!rY!5Su`3)B?mN5F51su?fUREkJAnu~7>Un?P)gy#QYI02Ma20XG3%;B#1AUW-ai
zF+Tg<GrUT*1GiHA7Faa2SBu&x+yg8vx1!qxyayZt-Upt6#@5mijEuhTXT{}^xa|_x
zVir8SO+vp?F_T&M?*n$0BOe4iwbdrA6U>O?WKjb?0$dAB54CLpwtLtJjqT!)#k9B<
zf{y@=OI*Lf!$xT2`Mwm-T#S7ds0E1N)1|0CbK1}7T&0L0fISbqtAJCSN!t47Dn;d6
zWepuSr+6FK1U#tbw}8X$T-AuOSJ=>Au{7twyqUDvm5|@|_#lb^Bt5|ed@h#%6m=E|
zY|lN_UQYXk61MX0>4nY|p#@k1zLF3r{suk;>+z2FuRW@J2aU3QHYDM|0$4}*Mc_l=
zG;jiV6?n&Igx9r)f!Ac?v~0d0AHfiG5LAl$5_lN65m*7f1D5@**)EvJfmgJZ{(In5
z=u|lnz|wLbSLzoWXTdI&ab{?{kKgoH8uIOg`)m|D{2SZVS~<E&*E#V_UIATjCom5z
zBoh-eTV`v^<p#wttI5`aV!T5!4|>29@O<*KmHv16Hv>0lm&W4%`iO@jzNdkgf!lOE
zqj=pcw3|NRZR!EpQqm6Kmdvpm;r|#i?o!pSBL*=FPUNJ^-^De>twTi{qgY+cgDkKq
zXF%MbF+s2=f!8y}T|WK<_$XjNzE}{4bZ)Suja4Tz*G%LTPBtp$;#t7Z=~-F_^h(?V
z`~n;Vjt2>)6zp*@dw~al>w%Af4-D<R$yhGD(x9QeY-t`$DzL_;BWWxsQ~YRYcC@j|
zo0IoEKu%*0d>3I9PU}9+jfzx&^Er!{o@R3E9e?G-b|GD7qyqc|d@*#<55PCoa9mS-
ztyr>f)AgUp2yhB`5;&sXa13~&z$9orU{SFhQ*1|c>|*Ah00030|GiD~3O#<Nj{pDw
M07*qoM6N<$f^1n6wg3PC

diff --git a/cmd/frontend/public/og-verify.jpg b/cmd/frontend/public/og-verify.jpg
deleted file mode 100644
index c518dde586be856124eb7891c7796f847e9e877d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 13625
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
B_qzZ9

diff --git a/cmd/frontend/public/og-widget.jpg b/cmd/frontend/public/og-widget.jpg
deleted file mode 100644
index ffe14d66a975906ac1009f22446b219d4a567424..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 11274
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
WeNgLB-+XZ65p(B`8uSL%_J076D<i1@

diff --git a/cmd/frontend/public/og.jpg b/cmd/frontend/public/og.jpg
deleted file mode 100644
index ffe14d66a975906ac1009f22446b219d4a567424..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 11274
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
WeNgLB-+XZ65p(B`8uSL%_J076D<i1@

diff --git a/cmd/frontend/routes/redirect/discord_verify.templ b/cmd/frontend/routes/redirect/discord_verify.templ
index ee386978..baff2fd6 100644
--- a/cmd/frontend/routes/redirect/discord_verify.templ
+++ b/cmd/frontend/routes/redirect/discord_verify.templ
@@ -22,12 +22,12 @@ templ discordVerifyRedirect(realm string) {
 		<title>Aftermath 🔗 Wargaming - { strings.ToUpper(realm) }</title>
 		<meta property="og:type" content="website"/>
 		<meta property="og:title" content={ "Aftermath 🔗 Wargaming -" + strings.ToUpper(realm) }/>
-		<meta property="og:image" content={ constants.FrontendURL + "/assets/og-verify.jpg" }/>
+		<meta property="og:image" content={ constants.FrontendURL + "/assets/og/verify.jpg" }/>
 		<meta property="og:description" content="Link your Blitz account to Aftermath!"/>
 		<meta name="twitter:card" content="summary_large_image"/>
 		<meta name="twitter:title" content={ "Aftermath 🔗 Wargaming -" + strings.ToUpper(realm) }/>
 		<meta name="twitter:image:alt" content="Link your Blitz account to Aftermath"/>
-		<meta name="twitter:image" content={ constants.FrontendURL + "/assets/og-verify.jpg" }/>
+		<meta name="twitter:image" content={ constants.FrontendURL + "/assets/og/verify.jpg" }/>
 		<meta name="twitter:description" content="Link your Blitz account to Aftermath!"/>
 	</head>
 	@logic.EmbedScript(discordVerifyRedirectScript(realm))
diff --git a/go.mod b/go.mod
index 43127461..02914176 100644
--- a/go.mod
+++ b/go.mod
@@ -4,6 +4,7 @@ go 1.22.3
 
 require (
 	entgo.io/ent v0.13.1
+	github.com/Kodeworks/golang-image-ico v0.0.0-20141118225523-73f0f4cfade9
 	github.com/PuerkitoBio/goquery v1.8.1
 	github.com/a-h/templ v0.2.731
 	github.com/bwmarrin/discordgo v0.28.1
diff --git a/go.sum b/go.sum
index c67354f4..5ad9e250 100644
--- a/go.sum
+++ b/go.sum
@@ -4,6 +4,8 @@ entgo.io/ent v0.13.1 h1:uD8QwN1h6SNphdCCzmkMN3feSUzNnVvV/WIkHKMbzOE=
 entgo.io/ent v0.13.1/go.mod h1:qCEmo+biw3ccBn9OyL4ZK5dfpwg++l1Gxwac5B1206A=
 github.com/DATA-DOG/go-sqlmock v1.5.0 h1:Shsta01QNfFxHCfpW6YH2STWB0MudeXXEWMr20OEh60=
 github.com/DATA-DOG/go-sqlmock v1.5.0/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM=
+github.com/Kodeworks/golang-image-ico v0.0.0-20141118225523-73f0f4cfade9 h1:1ltqoej5GtaWF8jaiA49HwsZD459jqm9YFz9ZtMFpQA=
+github.com/Kodeworks/golang-image-ico v0.0.0-20141118225523-73f0f4cfade9/go.mod h1:7uhhqiBaR4CpN0k9rMjOtjpcfGd6DG2m04zQxKnWQ0I=
 github.com/PuerkitoBio/goquery v1.8.1 h1:uQxhNlArOIdbrH1tr0UXwdVFgDcZDrZVdcpygAcwmWM=
 github.com/PuerkitoBio/goquery v1.8.1/go.mod h1:Q8ICL1kNUJ2sXGoAhPGUdYDJvgQgHzJsnnd3H7Ho5jQ=
 github.com/a-h/templ v0.2.731 h1:yiv4C7whSUsa36y65O06DPr/U/j3+WGB0RmvLOoVFXc=

From fa098128711d8ab3d31c549bab68c7996e57b0f1 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sat, 6 Jul 2024 20:23:34 -0400
Subject: [PATCH 291/341] new widget splash

---
 cmd/frontend/assets/generate/generate.go      |  11 +-
 cmd/frontend/assets/generate/obs-splash.png   | Bin 0 -> 298265 bytes
 cmd/frontend/components/head.templ            |   4 +-
 cmd/frontend/components/head_templ.go         |  75 +++++++++++++-
 cmd/frontend/components/logo_templ.go         |   2 +-
 cmd/frontend/components/widget/widget.templ   |  33 +++---
 .../components/widget/widget_templ.go         |  95 ++++++++++++------
 cmd/frontend/routes/api/widget/mock.templ     |  18 +++-
 cmd/frontend/routes/api/widget/mock_templ.go  |  55 +++++++++-
 .../routes/redirect/discord_verify_templ.go   |   4 +-
 10 files changed, 240 insertions(+), 57 deletions(-)
 create mode 100644 cmd/frontend/assets/generate/obs-splash.png

diff --git a/cmd/frontend/assets/generate/generate.go b/cmd/frontend/assets/generate/generate.go
index 6803d299..281e5633 100644
--- a/cmd/frontend/assets/generate/generate.go
+++ b/cmd/frontend/assets/generate/generate.go
@@ -139,9 +139,14 @@ func generateOGImages() {
 		logo := common.AftermathLogo(brandColor, opts)
 		ctx := gg.NewContext(imageWidth, imageHeight)
 
-		ctx.DrawImage(imaging.Blur(imaging.Fill(bg, imageWidth, imageHeight, imaging.Center, imaging.Lanczos), 30), 0, 0)
-		ctx.DrawRoundedRectangle(float64(borderWidth), float64(borderWidth), float64(imageWidth-borderWidth*2), float64(imageHeight-borderWidth*2), 20)
-		ctx.SetColor(cardColor)
+		obsBg, err := imaging.Open("./obs-splash.png")
+		if err != nil {
+			panic(err)
+		}
+
+		ctx.DrawImage(imaging.Fill(obsBg, imageWidth, imageHeight, imaging.Center, imaging.Lanczos), 0, 0)
+		ctx.DrawRectangle(0, 0, float64(imageWidth), float64(imageHeight))
+		ctx.SetColor(color.RGBA{7, 7, 7, 200})
 		ctx.Fill()
 
 		ctx.DrawImageAnchored(imaging.Fit(logo, logoSize, logoSize, imaging.Linear), imageWidth/2, imageHeight/2, 0.5, 0.5)
diff --git a/cmd/frontend/assets/generate/obs-splash.png b/cmd/frontend/assets/generate/obs-splash.png
new file mode 100644
index 0000000000000000000000000000000000000000..3a8c155501ecf391245f092380d3c799f05a2dc5
GIT binary patch
literal 298265
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

literal 0
HcmV?d00001

diff --git a/cmd/frontend/components/head.templ b/cmd/frontend/components/head.templ
index 91ce6c7e..e4c22a17 100644
--- a/cmd/frontend/components/head.templ
+++ b/cmd/frontend/components/head.templ
@@ -12,12 +12,12 @@ templ Head(additional ...templ.Component) {
 		<meta name="viewport" content="width=device-width, initial-scale=1"/>
 		<meta property="og:type" content="website"/>
 		<meta property="og:title" content={ constants.FrontendAppName }/>
-		<meta property="og:image" content={ constants.FrontendURL + "/assets/og/dafeult.jpg" }/>
+		<meta property="og:image" content={ constants.FrontendURL + "/assets/og/default.jpg" }/>
 		<meta property="og:description" content="Fastest and most beautiful way to view Blitz stats!"/>
 		<meta name="twitter:card" content="summary_large_image"/>
 		<meta name="twitter:title" content={ constants.FrontendAppName }/>
 		<meta name="twitter:image:alt" content={ constants.FrontendAppName + " Logo" }/>
-		<meta name="twitter:image" content={ constants.FrontendURL + "/assets/og/dafeult.jpg" }/>
+		<meta name="twitter:image" content={ constants.FrontendURL + "/assets/og/default.jpg" }/>
 		<meta name="twitter:description" content="Fastest and most beautiful way to view Blitz stats!"/>
 		<link href="https://cdn.jsdelivr.net/npm/daisyui@4.11.1/dist/full.min.css" rel="stylesheet" type="text/css"/>
 		<script src="https://unpkg.com/htmx.org@1.9.12"></script>
diff --git a/cmd/frontend/components/head_templ.go b/cmd/frontend/components/head_templ.go
index 1bc54385..479def88 100644
--- a/cmd/frontend/components/head_templ.go
+++ b/cmd/frontend/components/head_templ.go
@@ -31,7 +31,72 @@ func Head(additional ...templ.Component) templ.Component {
 			templ_7745c5c3_Var1 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<head><meta charset=\"utf-8\"><meta name=\"color-scheme\" content=\"light\"><meta name=\"viewport\" content=\"width=device-width, initial-scale=1\"><link href=\"https://cdn.jsdelivr.net/npm/daisyui@4.11.1/dist/full.min.css\" rel=\"stylesheet\" type=\"text/css\"><script src=\"https://unpkg.com/htmx.org@1.9.12\"></script><script src=\"https://unpkg.com/htmx.org/dist/ext/head-support.js\"></script><script src=\"https://unpkg.com/htmx.org@1.9.12/dist/ext/multi-swap.js\"></script><script src=\"https://cdn.tailwindcss.com\"></script>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<head><meta charset=\"utf-8\"><meta name=\"color-scheme\" content=\"light\"><meta name=\"viewport\" content=\"width=device-width, initial-scale=1\"><meta property=\"og:type\" content=\"website\"><meta property=\"og:title\" content=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var2 string
+		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(constants.FrontendAppName)
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/head.templ`, Line: 14, Col: 63}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><meta property=\"og:image\" content=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var3 string
+		templ_7745c5c3_Var3, templ_7745c5c3_Err = templ.JoinStringErrs(constants.FrontendURL + "/assets/og/default.jpg")
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/head.templ`, Line: 15, Col: 86}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var3))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><meta property=\"og:description\" content=\"Fastest and most beautiful way to view Blitz stats!\"><meta name=\"twitter:card\" content=\"summary_large_image\"><meta name=\"twitter:title\" content=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var4 string
+		templ_7745c5c3_Var4, templ_7745c5c3_Err = templ.JoinStringErrs(constants.FrontendAppName)
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/head.templ`, Line: 18, Col: 64}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var4))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><meta name=\"twitter:image:alt\" content=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var5 string
+		templ_7745c5c3_Var5, templ_7745c5c3_Err = templ.JoinStringErrs(constants.FrontendAppName + " Logo")
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/head.templ`, Line: 19, Col: 78}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var5))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><meta name=\"twitter:image\" content=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var6 string
+		templ_7745c5c3_Var6, templ_7745c5c3_Err = templ.JoinStringErrs(constants.FrontendURL + "/assets/og/default.jpg")
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/head.templ`, Line: 20, Col: 87}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var6))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><meta name=\"twitter:description\" content=\"Fastest and most beautiful way to view Blitz stats!\"><link href=\"https://cdn.jsdelivr.net/npm/daisyui@4.11.1/dist/full.min.css\" rel=\"stylesheet\" type=\"text/css\"><script src=\"https://unpkg.com/htmx.org@1.9.12\"></script><script src=\"https://unpkg.com/htmx.org/dist/ext/head-support.js\"></script><script src=\"https://unpkg.com/htmx.org@1.9.12/dist/ext/multi-swap.js\"></script><script src=\"https://cdn.tailwindcss.com\"></script>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -43,12 +108,12 @@ func Head(additional ...templ.Component) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var2 string
-		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(constants.FrontendAppName)
+		var templ_7745c5c3_Var7 string
+		templ_7745c5c3_Var7, templ_7745c5c3_Err = templ.JoinStringErrs(constants.FrontendAppName)
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/head.templ`, Line: 19, Col: 36}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/head.templ`, Line: 28, Col: 36}
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var7))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
diff --git a/cmd/frontend/components/logo_templ.go b/cmd/frontend/components/logo_templ.go
index 7e4f5f4d..dd5f605a 100644
--- a/cmd/frontend/components/logo_templ.go
+++ b/cmd/frontend/components/logo_templ.go
@@ -33,7 +33,7 @@ func Logo(size string) templ.Component {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var2 string
-		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprintf("/assets/icon-%s.png", size))
+		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprintf("/assets/icon/%s.png", size))
 		if templ_7745c5c3_Err != nil {
 			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/logo.templ`, Line: 6, Col: 157}
 		}
diff --git a/cmd/frontend/components/widget/widget.templ b/cmd/frontend/components/widget/widget.templ
index 3d77f460..9eb72b2f 100644
--- a/cmd/frontend/components/widget/widget.templ
+++ b/cmd/frontend/components/widget/widget.templ
@@ -32,9 +32,13 @@ func WithUnratedOverview(shown bool) WidgetOption {
 func WithFlavor(flavor WidgetFlavor) WidgetOption {
 	return func(w *widget) { w.flavor = flavor }
 }
+func WithHead(componeent templ.Component) WidgetOption {
+	return func(w *widget) { w.head = componeent }
+}
 
 func Widget(account models.Account, cards prepare.Cards, options ...WidgetOption) templ.Component {
 	widget := widget{
+		head:          widgetHead(account.Nickname, account.Realm),
 		cards:         cards,
 		account:       account,
 		flavor:        WidgetFlavorDefault,
@@ -70,23 +74,13 @@ type widget struct {
 	showUnratedOverview  bool
 	unratedVehiclesLimit int
 
+	head       templ.Component
 	flavor     WidgetFlavor
 	autoReload bool
 }
 
 templ (w widget) Render() {
-	<head>
-		<title>Aftermath - { w.account.Nickname }</title>
-		<meta property="og:type" content="website"/>
-		<meta property="og:title" content="Aftermath - Streaming Widget"/>
-		<meta property="og:image" content={ constants.FrontendURL + "/assets/og/widget.jpg" }/>
-		<meta property="og:description" content={ fmt.Sprintf("Aftermath streaming widget for %s [%s]", w.account.Nickname, w.account.Realm) }/>
-		<meta name="twitter:card" content="summary_large_image"/>
-		<meta name="twitter:title" content="Aftermath - Streaming Widget"/>
-		<meta name="twitter:image:alt" content="Aftermath Streaming Widget"/>
-		<meta name="twitter:image" content={ constants.FrontendURL + "/assets/og/widget.jpg" }/>
-		<meta name="twitter:description" content={ fmt.Sprintf("Aftermath streaming widget for %s [%s]", w.account.Nickname, w.account.Realm) }/>
-	</head>
+	@w.head
 	<div class="text-nowrap whitespace-nowrap" id="widget-container">
 		switch w.flavor {
 			default:
@@ -98,6 +92,21 @@ templ (w widget) Render() {
 	</div>
 }
 
+templ widgetHead(nickname, realm string) {
+	<head>
+		<title>Aftermath - { nickname }</title>
+		<meta property="og:type" content="website"/>
+		<meta property="og:title" content="Aftermath - Streaming Widget"/>
+		<meta property="og:image" content={ constants.FrontendURL + "/assets/og/widget.jpg" }/>
+		<meta property="og:description" content={ fmt.Sprintf("Aftermath streaming widget for %s [%s]", nickname, realm) }/>
+		<meta name="twitter:card" content="summary_large_image"/>
+		<meta name="twitter:title" content="Aftermath - Streaming Widget"/>
+		<meta name="twitter:image:alt" content="Aftermath Streaming Widget"/>
+		<meta name="twitter:image" content={ constants.FrontendURL + "/assets/og/widget.jpg" }/>
+		<meta name="twitter:description" content={ fmt.Sprintf("Aftermath streaming widget for %s [%s]", nickname, realm) }/>
+	</head>
+}
+
 script widgetRefresh(realm string, accountID string, lastBattle int64) {
   let apiHost = ""
   switch (realm.toLowerCase()) {
diff --git a/cmd/frontend/components/widget/widget_templ.go b/cmd/frontend/components/widget/widget_templ.go
index 1428a829..59626304 100644
--- a/cmd/frontend/components/widget/widget_templ.go
+++ b/cmd/frontend/components/widget/widget_templ.go
@@ -40,9 +40,13 @@ func WithUnratedOverview(shown bool) WidgetOption {
 func WithFlavor(flavor WidgetFlavor) WidgetOption {
 	return func(w *widget) { w.flavor = flavor }
 }
+func WithHead(componeent templ.Component) WidgetOption {
+	return func(w *widget) { w.head = componeent }
+}
 
 func Widget(account models.Account, cards prepare.Cards, options ...WidgetOption) templ.Component {
 	widget := widget{
+		head:          widgetHead(account.Nickname, account.Realm),
 		cards:         cards,
 		account:       account,
 		flavor:        WidgetFlavorDefault,
@@ -78,6 +82,7 @@ type widget struct {
 	showUnratedOverview  bool
 	unratedVehiclesLimit int
 
+	head       templ.Component
 	flavor     WidgetFlavor
 	autoReload bool
 }
@@ -100,89 +105,119 @@ func (w widget) Render() templ.Component {
 			templ_7745c5c3_Var1 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<head><title>Aftermath - ")
+		templ_7745c5c3_Err = w.head.Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var2 string
-		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(w.account.Nickname)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div class=\"text-nowrap whitespace-nowrap\" id=\"widget-container\">")
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/widget.templ`, Line: 79, Col: 41}
+			return templ_7745c5c3_Err
+		}
+		switch w.flavor {
+		default:
+			templ_7745c5c3_Err = w.defaultWidget().Render(ctx, templ_7745c5c3_Buffer)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		if w.autoReload {
+			templ_7745c5c3_Err = logic.EmbedMinifiedScript(widgetRefresh(w.account.Realm, w.account.ID, w.account.LastBattleTime.Unix()), w.account.Realm, w.account.ID, w.account.LastBattleTime.Unix()).Render(ctx, templ_7745c5c3_Buffer)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</title><meta property=\"og:type\" content=\"website\"><meta property=\"og:title\" content=\"Aftermath - Streaming Widget\"><meta property=\"og:image\" content=\"")
+		return templ_7745c5c3_Err
+	})
+}
+
+func widgetHead(nickname, realm string) templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var2 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var2 == nil {
+			templ_7745c5c3_Var2 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<head><title>Aftermath - ")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var3 string
-		templ_7745c5c3_Var3, templ_7745c5c3_Err = templ.JoinStringErrs(constants.FrontendURL + "/assets/og-widget.jpg")
+		templ_7745c5c3_Var3, templ_7745c5c3_Err = templ.JoinStringErrs(nickname)
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/widget.templ`, Line: 82, Col: 85}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/widget.templ`, Line: 97, Col: 31}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var3))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><meta property=\"og:description\" content=\"")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</title><meta property=\"og:type\" content=\"website\"><meta property=\"og:title\" content=\"Aftermath - Streaming Widget\"><meta property=\"og:image\" content=\"")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var4 string
-		templ_7745c5c3_Var4, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprintf("Aftermath streaming widget for %s [%s]", w.account.Nickname, w.account.Realm))
+		templ_7745c5c3_Var4, templ_7745c5c3_Err = templ.JoinStringErrs(constants.FrontendURL + "/assets/og/widget.jpg")
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/widget.templ`, Line: 83, Col: 134}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/widget.templ`, Line: 100, Col: 85}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var4))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><meta name=\"twitter:card\" content=\"summary_large_image\"><meta name=\"twitter:title\" content=\"Aftermath - Streaming Widget\"><meta name=\"twitter:image:alt\" content=\"Aftermath Streaming Widget\"><meta name=\"twitter:image\" content=\"")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><meta property=\"og:description\" content=\"")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var5 string
-		templ_7745c5c3_Var5, templ_7745c5c3_Err = templ.JoinStringErrs(constants.FrontendURL + "/assets/og-widget.jpg")
+		templ_7745c5c3_Var5, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprintf("Aftermath streaming widget for %s [%s]", nickname, realm))
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/widget.templ`, Line: 87, Col: 86}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/widget.templ`, Line: 101, Col: 114}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var5))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><meta name=\"twitter:description\" content=\"")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><meta name=\"twitter:card\" content=\"summary_large_image\"><meta name=\"twitter:title\" content=\"Aftermath - Streaming Widget\"><meta name=\"twitter:image:alt\" content=\"Aftermath Streaming Widget\"><meta name=\"twitter:image\" content=\"")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var6 string
-		templ_7745c5c3_Var6, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprintf("Aftermath streaming widget for %s [%s]", w.account.Nickname, w.account.Realm))
+		templ_7745c5c3_Var6, templ_7745c5c3_Err = templ.JoinStringErrs(constants.FrontendURL + "/assets/og/widget.jpg")
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/widget.templ`, Line: 88, Col: 135}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/widget.templ`, Line: 105, Col: 86}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var6))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"></head><div class=\"text-nowrap whitespace-nowrap\" id=\"widget-container\">")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><meta name=\"twitter:description\" content=\"")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		switch w.flavor {
-		default:
-			templ_7745c5c3_Err = w.defaultWidget().Render(ctx, templ_7745c5c3_Buffer)
-			if templ_7745c5c3_Err != nil {
-				return templ_7745c5c3_Err
-			}
+		var templ_7745c5c3_Var7 string
+		templ_7745c5c3_Var7, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprintf("Aftermath streaming widget for %s [%s]", nickname, realm))
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/components/widget/widget.templ`, Line: 106, Col: 115}
 		}
-		if w.autoReload {
-			templ_7745c5c3_Err = logic.EmbedMinifiedScript(widgetRefresh(w.account.Realm, w.account.ID, w.account.LastBattleTime.Unix()), w.account.Realm, w.account.ID, w.account.LastBattleTime.Unix()).Render(ctx, templ_7745c5c3_Buffer)
-			if templ_7745c5c3_Err != nil {
-				return templ_7745c5c3_Err
-			}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var7))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</div>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"></head>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
diff --git a/cmd/frontend/routes/api/widget/mock.templ b/cmd/frontend/routes/api/widget/mock.templ
index 24ba8cd6..26971864 100644
--- a/cmd/frontend/routes/api/widget/mock.templ
+++ b/cmd/frontend/routes/api/widget/mock.templ
@@ -4,11 +4,12 @@ import (
 	"github.com/cufee/aftermath/cmd/frontend/assets"
 	"github.com/cufee/aftermath/cmd/frontend/components/widget"
 	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/internal/constants"
 	"strconv"
 )
 
 var MockWidget handler.Partial = func(ctx *handler.Context) (templ.Component, error) {
-	var opts []widget.WidgetOption
+	var opts = []widget.WidgetOption{widget.WithHead(mockWidgetHead())}
 	if v, err := strconv.Atoi(ctx.Query("vl")); err == nil && v >= 0 && v <= 10 {
 		opts = append(opts, widget.WithVehicleLimit(int(v)))
 	}
@@ -27,3 +28,18 @@ templ mockWidget(widget templ.Component) {
 		@widget
 	</div>
 }
+
+templ mockWidgetHead() {
+	<head>
+		<title>Aftermath - Create your widget</title>
+		<meta property="og:type" content="website"/>
+		<meta property="og:title" content="Aftermath - Create Your Streaming Widget"/>
+		<meta property="og:image" content={ constants.FrontendURL + "/assets/og/widget.jpg" }/>
+		<meta property="og:description" content="Create a unique streaming widget just for you!"/>
+		<meta name="twitter:card" content="summary_large_image"/>
+		<meta name="twitter:title" content="Aftermath - Create Your Streaming Widget"/>
+		<meta name="twitter:image:alt" content="Aftermath Streaming Widget"/>
+		<meta name="twitter:image" content={ constants.FrontendURL + "/assets/og/widget.jpg" }/>
+		<meta name="twitter:description" content="Create a unique streaming widget just for you!"/>
+	</head>
+}
diff --git a/cmd/frontend/routes/api/widget/mock_templ.go b/cmd/frontend/routes/api/widget/mock_templ.go
index 033591f5..836d77fd 100644
--- a/cmd/frontend/routes/api/widget/mock_templ.go
+++ b/cmd/frontend/routes/api/widget/mock_templ.go
@@ -12,11 +12,12 @@ import (
 	"github.com/cufee/aftermath/cmd/frontend/assets"
 	"github.com/cufee/aftermath/cmd/frontend/components/widget"
 	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/internal/constants"
 	"strconv"
 )
 
 var MockWidget handler.Partial = func(ctx *handler.Context) (templ.Component, error) {
-	var opts []widget.WidgetOption
+	var opts = []widget.WidgetOption{widget.WithHead(mockWidgetHead())}
 	if v, err := strconv.Atoi(ctx.Query("vl")); err == nil && v >= 0 && v <= 10 {
 		opts = append(opts, widget.WithVehicleLimit(int(v)))
 	}
@@ -63,3 +64,55 @@ func mockWidget(widget templ.Component) templ.Component {
 		return templ_7745c5c3_Err
 	})
 }
+
+func mockWidgetHead() templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var2 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var2 == nil {
+			templ_7745c5c3_Var2 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<head><title>Aftermath - Create your widget</title><meta property=\"og:type\" content=\"website\"><meta property=\"og:title\" content=\"Aftermath - Create Your Streaming Widget\"><meta property=\"og:image\" content=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var3 string
+		templ_7745c5c3_Var3, templ_7745c5c3_Err = templ.JoinStringErrs(constants.FrontendURL + "/assets/og/widget.jpg")
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/api/widget/mock.templ`, Line: 37, Col: 85}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var3))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><meta property=\"og:description\" content=\"Create a unique streaming widget just for you!\"><meta name=\"twitter:card\" content=\"summary_large_image\"><meta name=\"twitter:title\" content=\"Aftermath - Create Your Streaming Widget\"><meta name=\"twitter:image:alt\" content=\"Aftermath Streaming Widget\"><meta name=\"twitter:image\" content=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var4 string
+		templ_7745c5c3_Var4, templ_7745c5c3_Err = templ.JoinStringErrs(constants.FrontendURL + "/assets/og/widget.jpg")
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/api/widget/mock.templ`, Line: 42, Col: 86}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var4))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><meta name=\"twitter:description\" content=\"Create a unique streaming widget just for you!\"></head>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return templ_7745c5c3_Err
+	})
+}
diff --git a/cmd/frontend/routes/redirect/discord_verify_templ.go b/cmd/frontend/routes/redirect/discord_verify_templ.go
index f63369ee..c68ec440 100644
--- a/cmd/frontend/routes/redirect/discord_verify_templ.go
+++ b/cmd/frontend/routes/redirect/discord_verify_templ.go
@@ -74,7 +74,7 @@ func discordVerifyRedirect(realm string) templ.Component {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var4 string
-		templ_7745c5c3_Var4, templ_7745c5c3_Err = templ.JoinStringErrs(constants.FrontendURL + "/assets/og-verify.jpg")
+		templ_7745c5c3_Var4, templ_7745c5c3_Err = templ.JoinStringErrs(constants.FrontendURL + "/assets/og/verify.jpg")
 		if templ_7745c5c3_Err != nil {
 			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/redirect/discord_verify.templ`, Line: 25, Col: 85}
 		}
@@ -100,7 +100,7 @@ func discordVerifyRedirect(realm string) templ.Component {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var6 string
-		templ_7745c5c3_Var6, templ_7745c5c3_Err = templ.JoinStringErrs(constants.FrontendURL + "/assets/og-verify.jpg")
+		templ_7745c5c3_Var6, templ_7745c5c3_Err = templ.JoinStringErrs(constants.FrontendURL + "/assets/og/verify.jpg")
 		if templ_7745c5c3_Err != nil {
 			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/redirect/discord_verify.templ`, Line: 30, Col: 86}
 		}

From 89e2eaf114e938a67c5f458767d466b5abe1f915 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sat, 6 Jul 2024 20:27:34 -0400
Subject: [PATCH 292/341] added missing dir

---
 cmd/frontend/public/icon/.gitignore | 1 +
 dev_web.go                          | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)
 create mode 100644 cmd/frontend/public/icon/.gitignore

diff --git a/cmd/frontend/public/icon/.gitignore b/cmd/frontend/public/icon/.gitignore
new file mode 100644
index 00000000..3f644593
--- /dev/null
+++ b/cmd/frontend/public/icon/.gitignore
@@ -0,0 +1 @@
+**.*
\ No newline at end of file
diff --git a/dev_web.go b/dev_web.go
index bf9d10bf..7112ac62 100644
--- a/dev_web.go
+++ b/dev_web.go
@@ -19,7 +19,7 @@ import (
 	"github.com/rs/zerolog/log"
 )
 
-//go:generate go generate ./cmd/frontend/assets
+//go:generate go generate ./cmd/frontend/assets/generate
 
 //go:embed static/*
 var static embed.FS

From b919a7ebdd385d8e5f9a7fa2bf73ecf590a10338 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sat, 6 Jul 2024 20:28:04 -0400
Subject: [PATCH 293/341] another missing dir

---
 cmd/frontend/public/og/.gitignore | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 cmd/frontend/public/og/.gitignore

diff --git a/cmd/frontend/public/og/.gitignore b/cmd/frontend/public/og/.gitignore
new file mode 100644
index 00000000..3f644593
--- /dev/null
+++ b/cmd/frontend/public/og/.gitignore
@@ -0,0 +1 @@
+**.*
\ No newline at end of file

From b43fe96a91c184ecf37c940c77bb5efc787d593d Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sat, 6 Jul 2024 20:31:54 -0400
Subject: [PATCH 294/341] passing BRAND_FLAVOR

---
 Dockerfile          | 2 ++
 docker-compose.yaml | 1 +
 2 files changed, 3 insertions(+)

diff --git a/Dockerfile b/Dockerfile
index 9b53de01..dd693ab1 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,6 +1,8 @@
 FROM golang:1.22.3-bookworm as builder
 
 ARG GO_MEM_LIMIT=122MiB
+ARG BRAND_FLAVOR=red
+ENV BRAND_FLAVOR $BRAND_FLAVOR
 
 WORKDIR /workspace
 
diff --git a/docker-compose.yaml b/docker-compose.yaml
index 5b54b8dc..a55eaf89 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -26,6 +26,7 @@ services:
       dockerfile: Dockerfile
       args:
         - GO_MEM_LIMIT=122MiB
+        - BRAND_FLAVOR=${BRAND_FLAVOR}
     restart: always
     deploy:
       resources:

From 1c09b9adfb5fbd58e64a716680197cba247df9f8 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sat, 6 Jul 2024 20:35:20 -0400
Subject: [PATCH 295/341] added missing arg

---
 cmd/frontend/routes/redirect/discord_verify.templ    | 2 +-
 cmd/frontend/routes/redirect/discord_verify_templ.go | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/cmd/frontend/routes/redirect/discord_verify.templ b/cmd/frontend/routes/redirect/discord_verify.templ
index baff2fd6..096978a5 100644
--- a/cmd/frontend/routes/redirect/discord_verify.templ
+++ b/cmd/frontend/routes/redirect/discord_verify.templ
@@ -30,7 +30,7 @@ templ discordVerifyRedirect(realm string) {
 		<meta name="twitter:image" content={ constants.FrontendURL + "/assets/og/verify.jpg" }/>
 		<meta name="twitter:description" content="Link your Blitz account to Aftermath!"/>
 	</head>
-	@logic.EmbedScript(discordVerifyRedirectScript(realm))
+	@logic.EmbedScript(discordVerifyRedirectScript(realm), realm)
 }
 
 script discordVerifyRedirectScript(realm string) {
diff --git a/cmd/frontend/routes/redirect/discord_verify_templ.go b/cmd/frontend/routes/redirect/discord_verify_templ.go
index c68ec440..459c3ed8 100644
--- a/cmd/frontend/routes/redirect/discord_verify_templ.go
+++ b/cmd/frontend/routes/redirect/discord_verify_templ.go
@@ -112,7 +112,7 @@ func discordVerifyRedirect(realm string) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		templ_7745c5c3_Err = logic.EmbedScript(discordVerifyRedirectScript(realm)).Render(ctx, templ_7745c5c3_Buffer)
+		templ_7745c5c3_Err = logic.EmbedScript(discordVerifyRedirectScript(realm), realm).Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}

From 9c2f93490cfde4cfc10223c1d0382a4aee6a6b97 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sat, 6 Jul 2024 20:45:16 -0400
Subject: [PATCH 296/341] updated og images

---
 cmd/frontend/assets/generate/generate.go      | 31 +++++++++++--------
 .../routes/redirect/discord_verify.templ      |  4 +--
 .../routes/redirect/discord_verify_templ.go   |  8 ++---
 3 files changed, 24 insertions(+), 19 deletions(-)

diff --git a/cmd/frontend/assets/generate/generate.go b/cmd/frontend/assets/generate/generate.go
index 281e5633..e0632dd3 100644
--- a/cmd/frontend/assets/generate/generate.go
+++ b/cmd/frontend/assets/generate/generate.go
@@ -22,7 +22,7 @@ import (
 var outDirPath = "../../public"
 var brandColor color.RGBA
 
-var cardColor = color.RGBA{17, 17, 17, 255}
+var cardColor = color.RGBA{7, 7, 7, 200}
 
 func main() {
 	godotenv.Load("../../../../.env")
@@ -175,7 +175,7 @@ func generateOGImages() {
 		ctx := gg.NewContext(imageWidth, imageHeight)
 
 		ctx.DrawImage(imaging.Blur(imaging.Fill(bg, imageWidth, imageHeight, imaging.Center, imaging.Lanczos), 30), 0, 0)
-		ctx.DrawRoundedRectangle(float64(borderWidth), float64(borderWidth), float64(imageWidth-borderWidth*2), float64(imageHeight-borderWidth*2), 20)
+		ctx.DrawRectangle(0, 0, float64(imageWidth), float64(imageHeight))
 		ctx.SetColor(cardColor)
 		ctx.Fill()
 
@@ -204,15 +204,6 @@ func generateOGImages() {
 		logo := common.AftermathLogo(brandColor, opts)
 		ctx := gg.NewContext(imageWidth, imageHeight)
 
-		linkIcon, err := imaging.Open("./link.png")
-		if err != nil {
-			panic(err)
-		}
-		blitzLogo, err := imaging.Open("./blitz-logo.png")
-		if err != nil {
-			panic(err)
-		}
-
 		// each logo should take 1/3 of the total height available
 		heightAvailable := imageHeight - borderWidth*2
 		widthAvailable := imageWidth - borderWidth*2
@@ -223,13 +214,27 @@ func generateOGImages() {
 		padding := (widthAvailable-linkIconSize-singleLogoSize*2-imageGap*2)/2 + borderWidth*2
 		// we can now draw padding - logo - gap - link - gap - logo
 
+		linkIcon, err := imaging.Open("./link.png")
+		if err != nil {
+			panic(err)
+		}
+		blitzLogo, err := imaging.Open("./blitz-logo.png")
+		if err != nil {
+			panic(err)
+		}
+		linkBlock := common.NewImageContent(common.Style{Width: float64(linkIconSize), Height: float64(linkIconSize), BackgroundColor: common.TextAlt}, linkIcon)
+		linkColored, err := linkBlock.Render()
+		if err != nil {
+			panic(err)
+		}
+
 		ctx.DrawImage(imaging.Blur(imaging.Fill(bg, imageWidth, imageHeight, imaging.Center, imaging.Lanczos), 30), 0, 0)
-		ctx.DrawRoundedRectangle(float64(borderWidth), float64(borderWidth), float64(imageWidth-borderWidth*2), float64(imageHeight-borderWidth*2), 20)
+		ctx.DrawRectangle(0, 0, float64(imageWidth), float64(imageHeight))
 		ctx.SetColor(cardColor)
 		ctx.Fill()
 
 		ctx.DrawImage(imaging.Fill(logo, singleLogoSize, singleLogoSize, imaging.Center, imaging.Lanczos), padding, imageHeight/2-singleLogoSize/2)
-		ctx.DrawImage(imaging.Fill(linkIcon, linkIconSize, linkIconSize, imaging.Center, imaging.Lanczos), padding+singleLogoSize+imageGap, imageHeight/2-linkIconSize/2)
+		ctx.DrawImage(imaging.Fill(linkColored, linkIconSize, linkIconSize, imaging.Center, imaging.Lanczos), padding+singleLogoSize+imageGap, imageHeight/2-linkIconSize/2)
 		ctx.DrawImage(imaging.Fill(blitzLogo, singleLogoSize, singleLogoSize, imaging.Center, imaging.Lanczos), padding+singleLogoSize+imageGap+linkIconSize+imageGap, imageHeight/2-singleLogoSize/2)
 
 		f, err := os.Create(filepath.Join(outDirPath, filename))
diff --git a/cmd/frontend/routes/redirect/discord_verify.templ b/cmd/frontend/routes/redirect/discord_verify.templ
index 096978a5..29073093 100644
--- a/cmd/frontend/routes/redirect/discord_verify.templ
+++ b/cmd/frontend/routes/redirect/discord_verify.templ
@@ -21,11 +21,11 @@ templ discordVerifyRedirect(realm string) {
 	<head>
 		<title>Aftermath 🔗 Wargaming - { strings.ToUpper(realm) }</title>
 		<meta property="og:type" content="website"/>
-		<meta property="og:title" content={ "Aftermath 🔗 Wargaming -" + strings.ToUpper(realm) }/>
+		<meta property="og:title" content={ "Aftermath 🔗 Wargaming - " + strings.ToUpper(realm) }/>
 		<meta property="og:image" content={ constants.FrontendURL + "/assets/og/verify.jpg" }/>
 		<meta property="og:description" content="Link your Blitz account to Aftermath!"/>
 		<meta name="twitter:card" content="summary_large_image"/>
-		<meta name="twitter:title" content={ "Aftermath 🔗 Wargaming -" + strings.ToUpper(realm) }/>
+		<meta name="twitter:title" content={ "Aftermath 🔗 Wargaming - " + strings.ToUpper(realm) }/>
 		<meta name="twitter:image:alt" content="Link your Blitz account to Aftermath"/>
 		<meta name="twitter:image" content={ constants.FrontendURL + "/assets/og/verify.jpg" }/>
 		<meta name="twitter:description" content="Link your Blitz account to Aftermath!"/>
diff --git a/cmd/frontend/routes/redirect/discord_verify_templ.go b/cmd/frontend/routes/redirect/discord_verify_templ.go
index 459c3ed8..84f1b951 100644
--- a/cmd/frontend/routes/redirect/discord_verify_templ.go
+++ b/cmd/frontend/routes/redirect/discord_verify_templ.go
@@ -61,9 +61,9 @@ func discordVerifyRedirect(realm string) templ.Component {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var3 string
-		templ_7745c5c3_Var3, templ_7745c5c3_Err = templ.JoinStringErrs("Aftermath 🔗 Wargaming -" + strings.ToUpper(realm))
+		templ_7745c5c3_Var3, templ_7745c5c3_Err = templ.JoinStringErrs("Aftermath 🔗 Wargaming - " + strings.ToUpper(realm))
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/redirect/discord_verify.templ`, Line: 24, Col: 91}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/redirect/discord_verify.templ`, Line: 24, Col: 92}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var3))
 		if templ_7745c5c3_Err != nil {
@@ -87,9 +87,9 @@ func discordVerifyRedirect(realm string) templ.Component {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var5 string
-		templ_7745c5c3_Var5, templ_7745c5c3_Err = templ.JoinStringErrs("Aftermath 🔗 Wargaming -" + strings.ToUpper(realm))
+		templ_7745c5c3_Var5, templ_7745c5c3_Err = templ.JoinStringErrs("Aftermath 🔗 Wargaming - " + strings.ToUpper(realm))
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/redirect/discord_verify.templ`, Line: 28, Col: 92}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/redirect/discord_verify.templ`, Line: 28, Col: 93}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var5))
 		if templ_7745c5c3_Err != nil {

From ad8eb9fc7e64e8b74a80198185e64575f3ba52dd Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 7 Jul 2024 11:11:32 -0400
Subject: [PATCH 297/341] added meta tags to login page, added plug to static
 redirect pages

---
 cmd/frontend/assets/generate/generate.go      |   2 +
 cmd/frontend/components/doctype_html.templ    |  16 +++
 cmd/frontend/components/doctype_html_templ.go |  51 +++++++
 cmd/frontend/components/head.templ            |   4 +-
 cmd/frontend/components/head_templ.go         |   4 +-
 cmd/frontend/components/manual_redirect.templ |   9 ++
 .../components/manual_redirect_templ.go       |  44 ++++++
 cmd/frontend/handlers.go                      |   7 +-
 cmd/frontend/routes/{ => api}/login.go        |   2 +-
 cmd/frontend/routes/login.templ               |  38 +++++
 cmd/frontend/routes/login_templ.go            | 134 ++++++++++++++++++
 .../routes/redirect/discord_verify.templ      |  17 ++-
 .../routes/redirect/discord_verify_templ.go   | 111 +++++++++++----
 13 files changed, 397 insertions(+), 42 deletions(-)
 create mode 100644 cmd/frontend/components/doctype_html.templ
 create mode 100644 cmd/frontend/components/doctype_html_templ.go
 create mode 100644 cmd/frontend/components/manual_redirect.templ
 create mode 100644 cmd/frontend/components/manual_redirect_templ.go
 rename cmd/frontend/routes/{ => api}/login.go (99%)
 create mode 100644 cmd/frontend/routes/login.templ
 create mode 100644 cmd/frontend/routes/login_templ.go

diff --git a/cmd/frontend/assets/generate/generate.go b/cmd/frontend/assets/generate/generate.go
index e0632dd3..0ef79294 100644
--- a/cmd/frontend/assets/generate/generate.go
+++ b/cmd/frontend/assets/generate/generate.go
@@ -32,6 +32,8 @@ func main() {
 		brandColor = common.ColorAftermathRed
 	case "blue":
 		brandColor = common.ColorAftermathBlue
+	case "gold":
+		brandColor = common.TextSubscriptionPremium
 	}
 
 	generateWN8Icons()
diff --git a/cmd/frontend/components/doctype_html.templ b/cmd/frontend/components/doctype_html.templ
new file mode 100644
index 00000000..99ac98cf
--- /dev/null
+++ b/cmd/frontend/components/doctype_html.templ
@@ -0,0 +1,16 @@
+package components
+
+templ DoctypeHTML(head templ.Component) {
+	<!DOCTYPE html>
+	<html lang="en" data-theme="dark">
+		@head
+		<body>
+			<style>
+				:root {
+					background-color: black
+				}
+			</style>
+			{ children... }
+		</body>
+	</html>
+}
diff --git a/cmd/frontend/components/doctype_html_templ.go b/cmd/frontend/components/doctype_html_templ.go
new file mode 100644
index 00000000..d223a477
--- /dev/null
+++ b/cmd/frontend/components/doctype_html_templ.go
@@ -0,0 +1,51 @@
+// Code generated by templ - DO NOT EDIT.
+
+// templ: version: v0.2.731
+package components
+
+//lint:file-ignore SA4006 This context is only used if a nested component is present.
+
+import "github.com/a-h/templ"
+import templruntime "github.com/a-h/templ/runtime"
+
+func DoctypeHTML(head templ.Component) templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var1 == nil {
+			templ_7745c5c3_Var1 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<!doctype html><html lang=\"en\" data-theme=\"dark\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = head.Render(ctx, templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<body><style>\n\t\t\t\t:root {\n\t\t\t\t\tbackground-color: black\n\t\t\t\t}\n\t\t\t</style>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = templ_7745c5c3_Var1.Render(ctx, templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</body></html>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return templ_7745c5c3_Err
+	})
+}
diff --git a/cmd/frontend/components/head.templ b/cmd/frontend/components/head.templ
index e4c22a17..cda76701 100644
--- a/cmd/frontend/components/head.templ
+++ b/cmd/frontend/components/head.templ
@@ -13,12 +13,12 @@ templ Head(additional ...templ.Component) {
 		<meta property="og:type" content="website"/>
 		<meta property="og:title" content={ constants.FrontendAppName }/>
 		<meta property="og:image" content={ constants.FrontendURL + "/assets/og/default.jpg" }/>
-		<meta property="og:description" content="Fastest and most beautiful way to view Blitz stats!"/>
+		<meta property="og:description" content="The Fastest and Most Beautifudl way to view Blitz stats!"/>
 		<meta name="twitter:card" content="summary_large_image"/>
 		<meta name="twitter:title" content={ constants.FrontendAppName }/>
 		<meta name="twitter:image:alt" content={ constants.FrontendAppName + " Logo" }/>
 		<meta name="twitter:image" content={ constants.FrontendURL + "/assets/og/default.jpg" }/>
-		<meta name="twitter:description" content="Fastest and most beautiful way to view Blitz stats!"/>
+		<meta name="twitter:description" content="The Fastest and Most Beautifudl way to view Blitz stats!"/>
 		<link href="https://cdn.jsdelivr.net/npm/daisyui@4.11.1/dist/full.min.css" rel="stylesheet" type="text/css"/>
 		<script src="https://unpkg.com/htmx.org@1.9.12"></script>
 		<script src="https://unpkg.com/htmx.org/dist/ext/head-support.js"></script>
diff --git a/cmd/frontend/components/head_templ.go b/cmd/frontend/components/head_templ.go
index 479def88..9025e7c9 100644
--- a/cmd/frontend/components/head_templ.go
+++ b/cmd/frontend/components/head_templ.go
@@ -57,7 +57,7 @@ func Head(additional ...templ.Component) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><meta property=\"og:description\" content=\"Fastest and most beautiful way to view Blitz stats!\"><meta name=\"twitter:card\" content=\"summary_large_image\"><meta name=\"twitter:title\" content=\"")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><meta property=\"og:description\" content=\"The Fastest and Most Beautifudl way to view Blitz stats!\"><meta name=\"twitter:card\" content=\"summary_large_image\"><meta name=\"twitter:title\" content=\"")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -96,7 +96,7 @@ func Head(additional ...templ.Component) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><meta name=\"twitter:description\" content=\"Fastest and most beautiful way to view Blitz stats!\"><link href=\"https://cdn.jsdelivr.net/npm/daisyui@4.11.1/dist/full.min.css\" rel=\"stylesheet\" type=\"text/css\"><script src=\"https://unpkg.com/htmx.org@1.9.12\"></script><script src=\"https://unpkg.com/htmx.org/dist/ext/head-support.js\"></script><script src=\"https://unpkg.com/htmx.org@1.9.12/dist/ext/multi-swap.js\"></script><script src=\"https://cdn.tailwindcss.com\"></script>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><meta name=\"twitter:description\" content=\"The Fastest and Most Beautifudl way to view Blitz stats!\"><link href=\"https://cdn.jsdelivr.net/npm/daisyui@4.11.1/dist/full.min.css\" rel=\"stylesheet\" type=\"text/css\"><script src=\"https://unpkg.com/htmx.org@1.9.12\"></script><script src=\"https://unpkg.com/htmx.org/dist/ext/head-support.js\"></script><script src=\"https://unpkg.com/htmx.org@1.9.12/dist/ext/multi-swap.js\"></script><script src=\"https://cdn.tailwindcss.com\"></script>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
diff --git a/cmd/frontend/components/manual_redirect.templ b/cmd/frontend/components/manual_redirect.templ
new file mode 100644
index 00000000..a138bb8c
--- /dev/null
+++ b/cmd/frontend/components/manual_redirect.templ
@@ -0,0 +1,9 @@
+package components
+
+templ ManualRedirect(target string) {
+	<div style="height: 50vh; display: flex; align-items: center; justify-content: center;">
+		<div style="color: gray; text-align: center; font-weight: bold;">
+			Page not redirecting? <a style="color: white;" href={ templ.URL(target) }>Click here</a> to open the next page manually.
+		</div>
+	</div>
+}
diff --git a/cmd/frontend/components/manual_redirect_templ.go b/cmd/frontend/components/manual_redirect_templ.go
new file mode 100644
index 00000000..7b4a2b6d
--- /dev/null
+++ b/cmd/frontend/components/manual_redirect_templ.go
@@ -0,0 +1,44 @@
+// Code generated by templ - DO NOT EDIT.
+
+// templ: version: v0.2.731
+package components
+
+//lint:file-ignore SA4006 This context is only used if a nested component is present.
+
+import "github.com/a-h/templ"
+import templruntime "github.com/a-h/templ/runtime"
+
+func ManualRedirect(target string) templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var1 == nil {
+			templ_7745c5c3_Var1 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div style=\"height: 50vh; display: flex; align-items: center; justify-content: center;\"><div style=\"color: gray; text-align: center; font-weight: bold;\">Page not redirecting? <a style=\"color: white;\" href=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var2 templ.SafeURL = templ.URL(target)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(string(templ_7745c5c3_Var2)))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\">Click here</a> to open the next page manually.</div></div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return templ_7745c5c3_Err
+	})
+}
diff --git a/cmd/frontend/handlers.go b/cmd/frontend/handlers.go
index af59ee6d..336ee72c 100644
--- a/cmd/frontend/handlers.go
+++ b/cmd/frontend/handlers.go
@@ -11,6 +11,7 @@ import (
 	"github.com/cufee/aftermath/cmd/frontend/handler"
 	"github.com/cufee/aftermath/cmd/frontend/middleware"
 	"github.com/cufee/aftermath/cmd/frontend/routes"
+	"github.com/cufee/aftermath/cmd/frontend/routes/api"
 	"github.com/cufee/aftermath/cmd/frontend/routes/api/auth"
 	aWidget "github.com/cufee/aftermath/cmd/frontend/routes/api/widget"
 	"github.com/cufee/aftermath/cmd/frontend/routes/app"
@@ -58,7 +59,7 @@ func Handlers(core core.Client) ([]server.Handler, error) {
 		},
 		{
 			Path: get("/login"),
-			Func: handler.Chain(core, routes.Login),
+			Func: handler.Chain(core, routes.LoginStatic),
 		},
 		{
 			Path: get("/linked"),
@@ -95,6 +96,10 @@ func Handlers(core core.Client) ([]server.Handler, error) {
 			Func: handler.Chain(core, app.Widgets, middleware.SessionCheck),
 		},
 		// api routes
+		{
+			Path: get("/api/login"),
+			Func: handler.Chain(core, api.Login),
+		},
 		{
 			Path: get("/api/auth/discord"),
 			Func: handler.Chain(core, auth.DiscordRedirect),
diff --git a/cmd/frontend/routes/login.go b/cmd/frontend/routes/api/login.go
similarity index 99%
rename from cmd/frontend/routes/login.go
rename to cmd/frontend/routes/api/login.go
index 1377d157..27caed8f 100644
--- a/cmd/frontend/routes/login.go
+++ b/cmd/frontend/routes/api/login.go
@@ -1,4 +1,4 @@
-package routes
+package api
 
 import (
 	"net/http"
diff --git a/cmd/frontend/routes/login.templ b/cmd/frontend/routes/login.templ
new file mode 100644
index 00000000..6bdb6a82
--- /dev/null
+++ b/cmd/frontend/routes/login.templ
@@ -0,0 +1,38 @@
+package routes
+
+import (
+	"github.com/cufee/aftermath/cmd/frontend/components"
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/cmd/frontend/logic"
+	"github.com/cufee/aftermath/internal/constants"
+)
+
+var LoginStatic handler.Partial = func(ctx *handler.Context) (templ.Component, error) {
+	return loginStaticPage(ctx.URL().RawQuery), nil
+}
+
+templ loginStaticPage(query string) {
+	@components.DoctypeHTML(loginStaticHead()) {
+		@logic.EmbedScript(loginPageRedirectScript(query))
+		@components.ManualRedirect("/api/login?" + query)
+	}
+}
+
+templ loginStaticHead() {
+	<head>
+		<title>Aftermath - Login</title>
+		<meta property="og:type" content="website"/>
+		<meta property="og:title" content="Aftermath - Login"/>
+		<meta property="og:image" content={ constants.FrontendURL + "/assets/og/default.jpg" }/>
+		<meta property="og:description" content="The Fastest and Most Beautifudl way to view Blitz stats!"/>
+		<meta name="twitter:card" content="summary_large_image"/>
+		<meta name="twitter:title" content="Aftermath - Login"/>
+		<meta name="twitter:image:alt" content="Link your Blitz account to Aftermath"/>
+		<meta name="twitter:image" content={ constants.FrontendURL + "/assets/og/default.jpg" }/>
+		<meta name="twitter:description" content="The Fastest and Most Beautifudl way to view Blitz stats!"/>
+	</head>
+}
+
+script loginPageRedirectScript(query string) {
+	window.location.href="/api/login?"+query;
+}
diff --git a/cmd/frontend/routes/login_templ.go b/cmd/frontend/routes/login_templ.go
new file mode 100644
index 00000000..85d262c5
--- /dev/null
+++ b/cmd/frontend/routes/login_templ.go
@@ -0,0 +1,134 @@
+// Code generated by templ - DO NOT EDIT.
+
+// templ: version: v0.2.731
+package routes
+
+//lint:file-ignore SA4006 This context is only used if a nested component is present.
+
+import "github.com/a-h/templ"
+import templruntime "github.com/a-h/templ/runtime"
+
+import (
+	"github.com/cufee/aftermath/cmd/frontend/components"
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/cmd/frontend/logic"
+	"github.com/cufee/aftermath/internal/constants"
+)
+
+var LoginStatic handler.Partial = func(ctx *handler.Context) (templ.Component, error) {
+	return loginStaticPage(ctx.URL().RawQuery), nil
+}
+
+func loginStaticPage(query string) templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var1 == nil {
+			templ_7745c5c3_Var1 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		templ_7745c5c3_Var2 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+			templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+			templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+			if !templ_7745c5c3_IsBuffer {
+				defer func() {
+					templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+					if templ_7745c5c3_Err == nil {
+						templ_7745c5c3_Err = templ_7745c5c3_BufErr
+					}
+				}()
+			}
+			ctx = templ.InitializeContext(ctx)
+			templ_7745c5c3_Err = logic.EmbedScript(loginPageRedirectScript(query)).Render(ctx, templ_7745c5c3_Buffer)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" ")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			templ_7745c5c3_Err = components.ManualRedirect("/api/login?"+query).Render(ctx, templ_7745c5c3_Buffer)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			return templ_7745c5c3_Err
+		})
+		templ_7745c5c3_Err = components.DoctypeHTML(loginStaticHead()).Render(templ.WithChildren(ctx, templ_7745c5c3_Var2), templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return templ_7745c5c3_Err
+	})
+}
+
+func loginStaticHead() templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var3 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var3 == nil {
+			templ_7745c5c3_Var3 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<head><title>Aftermath - Login</title><meta property=\"og:type\" content=\"website\"><meta property=\"og:title\" content=\"Aftermath - Login\"><meta property=\"og:image\" content=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var4 string
+		templ_7745c5c3_Var4, templ_7745c5c3_Err = templ.JoinStringErrs(constants.FrontendURL + "/assets/og/default.jpg")
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/login.templ`, Line: 26, Col: 86}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var4))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><meta property=\"og:description\" content=\"The Fastest and Most Beautifudl way to view Blitz stats!\"><meta name=\"twitter:card\" content=\"summary_large_image\"><meta name=\"twitter:title\" content=\"Aftermath - Login\"><meta name=\"twitter:image:alt\" content=\"Link your Blitz account to Aftermath\"><meta name=\"twitter:image\" content=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var5 string
+		templ_7745c5c3_Var5, templ_7745c5c3_Err = templ.JoinStringErrs(constants.FrontendURL + "/assets/og/default.jpg")
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/login.templ`, Line: 31, Col: 87}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var5))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><meta name=\"twitter:description\" content=\"The Fastest and Most Beautifudl way to view Blitz stats!\"></head>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return templ_7745c5c3_Err
+	})
+}
+
+func loginPageRedirectScript(query string) templ.ComponentScript {
+	return templ.ComponentScript{
+		Name: `__templ_loginPageRedirectScript_45dd`,
+		Function: `function __templ_loginPageRedirectScript_45dd(query){window.location.href="/api/login?"+query;
+}`,
+		Call:       templ.SafeScript(`__templ_loginPageRedirectScript_45dd`, query),
+		CallInline: templ.SafeScriptInline(`__templ_loginPageRedirectScript_45dd`, query),
+	}
+}
diff --git a/cmd/frontend/routes/redirect/discord_verify.templ b/cmd/frontend/routes/redirect/discord_verify.templ
index 29073093..87ebd370 100644
--- a/cmd/frontend/routes/redirect/discord_verify.templ
+++ b/cmd/frontend/routes/redirect/discord_verify.templ
@@ -1,6 +1,7 @@
 package redirect
 
 import (
+	"github.com/cufee/aftermath/cmd/frontend/components"
 	"github.com/cufee/aftermath/cmd/frontend/handler"
 	"github.com/cufee/aftermath/cmd/frontend/logic"
 	"github.com/cufee/aftermath/internal/constants"
@@ -18,21 +19,27 @@ var VerifyFromDiscord handler.Partial = func(ctx *handler.Context) (templ.Compon
 }
 
 templ discordVerifyRedirect(realm string) {
+	@components.DoctypeHTML(discordVerifyHead(realm)) {
+		@logic.EmbedScript(discordVerifyRedirectScript(realm), realm)
+		@components.ManualRedirect("/api/login?from=/api/auth/wargaming/login/" + realm)
+	}
+}
+
+templ discordVerifyHead(realm string) {
 	<head>
 		<title>Aftermath 🔗 Wargaming - { strings.ToUpper(realm) }</title>
 		<meta property="og:type" content="website"/>
 		<meta property="og:title" content={ "Aftermath 🔗 Wargaming - " + strings.ToUpper(realm) }/>
 		<meta property="og:image" content={ constants.FrontendURL + "/assets/og/verify.jpg" }/>
-		<meta property="og:description" content="Link your Blitz account to Aftermath!"/>
+		<meta property="og:description" content="Link your Blitz account to Aftermath and unlock even more features!"/>
 		<meta name="twitter:card" content="summary_large_image"/>
 		<meta name="twitter:title" content={ "Aftermath 🔗 Wargaming - " + strings.ToUpper(realm) }/>
-		<meta name="twitter:image:alt" content="Link your Blitz account to Aftermath"/>
+		<meta name="twitter:image:alt" content="Link your Blitz account to Aftermath and unlock even more features"/>
 		<meta name="twitter:image" content={ constants.FrontendURL + "/assets/og/verify.jpg" }/>
-		<meta name="twitter:description" content="Link your Blitz account to Aftermath!"/>
+		<meta name="twitter:description" content="Link your Blitz account to Aftermath and unlock even more features!"/>
 	</head>
-	@logic.EmbedScript(discordVerifyRedirectScript(realm), realm)
 }
 
 script discordVerifyRedirectScript(realm string) {
-	window.location.href="/login?from=/api/auth/wargaming/login/"+realm;
+	window.location.href="/api/login?from=/api/auth/wargaming/login/"+realm;
 }
diff --git a/cmd/frontend/routes/redirect/discord_verify_templ.go b/cmd/frontend/routes/redirect/discord_verify_templ.go
index 84f1b951..397dadcf 100644
--- a/cmd/frontend/routes/redirect/discord_verify_templ.go
+++ b/cmd/frontend/routes/redirect/discord_verify_templ.go
@@ -9,6 +9,7 @@ import "github.com/a-h/templ"
 import templruntime "github.com/a-h/templ/runtime"
 
 import (
+	"github.com/cufee/aftermath/cmd/frontend/components"
 	"github.com/cufee/aftermath/cmd/frontend/handler"
 	"github.com/cufee/aftermath/cmd/frontend/logic"
 	"github.com/cufee/aftermath/internal/constants"
@@ -43,16 +44,68 @@ func discordVerifyRedirect(realm string) templ.Component {
 			templ_7745c5c3_Var1 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
+		templ_7745c5c3_Var2 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+			templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+			templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+			if !templ_7745c5c3_IsBuffer {
+				defer func() {
+					templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+					if templ_7745c5c3_Err == nil {
+						templ_7745c5c3_Err = templ_7745c5c3_BufErr
+					}
+				}()
+			}
+			ctx = templ.InitializeContext(ctx)
+			templ_7745c5c3_Err = logic.EmbedScript(discordVerifyRedirectScript(realm), realm).Render(ctx, templ_7745c5c3_Buffer)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" ")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			templ_7745c5c3_Err = components.ManualRedirect("/api/login?from=/api/auth/wargaming/login/"+realm).Render(ctx, templ_7745c5c3_Buffer)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			return templ_7745c5c3_Err
+		})
+		templ_7745c5c3_Err = components.DoctypeHTML(discordVerifyHead(realm)).Render(templ.WithChildren(ctx, templ_7745c5c3_Var2), templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return templ_7745c5c3_Err
+	})
+}
+
+func discordVerifyHead(realm string) templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var3 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var3 == nil {
+			templ_7745c5c3_Var3 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<head><title>Aftermath 🔗 Wargaming - ")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var2 string
-		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(strings.ToUpper(realm))
+		var templ_7745c5c3_Var4 string
+		templ_7745c5c3_Var4, templ_7745c5c3_Err = templ.JoinStringErrs(strings.ToUpper(realm))
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/redirect/discord_verify.templ`, Line: 22, Col: 60}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/redirect/discord_verify.templ`, Line: 30, Col: 60}
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var4))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -60,12 +113,12 @@ func discordVerifyRedirect(realm string) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var3 string
-		templ_7745c5c3_Var3, templ_7745c5c3_Err = templ.JoinStringErrs("Aftermath 🔗 Wargaming - " + strings.ToUpper(realm))
+		var templ_7745c5c3_Var5 string
+		templ_7745c5c3_Var5, templ_7745c5c3_Err = templ.JoinStringErrs("Aftermath 🔗 Wargaming - " + strings.ToUpper(realm))
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/redirect/discord_verify.templ`, Line: 24, Col: 92}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/redirect/discord_verify.templ`, Line: 32, Col: 92}
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var3))
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var5))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -73,46 +126,42 @@ func discordVerifyRedirect(realm string) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var4 string
-		templ_7745c5c3_Var4, templ_7745c5c3_Err = templ.JoinStringErrs(constants.FrontendURL + "/assets/og/verify.jpg")
+		var templ_7745c5c3_Var6 string
+		templ_7745c5c3_Var6, templ_7745c5c3_Err = templ.JoinStringErrs(constants.FrontendURL + "/assets/og/verify.jpg")
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/redirect/discord_verify.templ`, Line: 25, Col: 85}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/redirect/discord_verify.templ`, Line: 33, Col: 85}
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var4))
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var6))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><meta property=\"og:description\" content=\"Link your Blitz account to Aftermath!\"><meta name=\"twitter:card\" content=\"summary_large_image\"><meta name=\"twitter:title\" content=\"")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><meta property=\"og:description\" content=\"Link your Blitz account to Aftermath and unlock even more features!\"><meta name=\"twitter:card\" content=\"summary_large_image\"><meta name=\"twitter:title\" content=\"")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var5 string
-		templ_7745c5c3_Var5, templ_7745c5c3_Err = templ.JoinStringErrs("Aftermath 🔗 Wargaming - " + strings.ToUpper(realm))
+		var templ_7745c5c3_Var7 string
+		templ_7745c5c3_Var7, templ_7745c5c3_Err = templ.JoinStringErrs("Aftermath 🔗 Wargaming - " + strings.ToUpper(realm))
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/redirect/discord_verify.templ`, Line: 28, Col: 93}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/redirect/discord_verify.templ`, Line: 36, Col: 93}
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var5))
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var7))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><meta name=\"twitter:image:alt\" content=\"Link your Blitz account to Aftermath\"><meta name=\"twitter:image\" content=\"")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><meta name=\"twitter:image:alt\" content=\"Link your Blitz account to Aftermath and unlock even more features\"><meta name=\"twitter:image\" content=\"")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var6 string
-		templ_7745c5c3_Var6, templ_7745c5c3_Err = templ.JoinStringErrs(constants.FrontendURL + "/assets/og/verify.jpg")
-		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/redirect/discord_verify.templ`, Line: 30, Col: 86}
-		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var6))
+		var templ_7745c5c3_Var8 string
+		templ_7745c5c3_Var8, templ_7745c5c3_Err = templ.JoinStringErrs(constants.FrontendURL + "/assets/og/verify.jpg")
 		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `cmd/frontend/routes/redirect/discord_verify.templ`, Line: 38, Col: 86}
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><meta name=\"twitter:description\" content=\"Link your Blitz account to Aftermath!\"></head>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var8))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		templ_7745c5c3_Err = logic.EmbedScript(discordVerifyRedirectScript(realm), realm).Render(ctx, templ_7745c5c3_Buffer)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><meta name=\"twitter:description\" content=\"Link your Blitz account to Aftermath and unlock even more features!\"></head>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -122,10 +171,10 @@ func discordVerifyRedirect(realm string) templ.Component {
 
 func discordVerifyRedirectScript(realm string) templ.ComponentScript {
 	return templ.ComponentScript{
-		Name: `__templ_discordVerifyRedirectScript_fac0`,
-		Function: `function __templ_discordVerifyRedirectScript_fac0(realm){window.location.href="/login?from=/api/auth/wargaming/login/"+realm;
+		Name: `__templ_discordVerifyRedirectScript_4e71`,
+		Function: `function __templ_discordVerifyRedirectScript_4e71(realm){window.location.href="/api/login?from=/api/auth/wargaming/login/"+realm;
 }`,
-		Call:       templ.SafeScript(`__templ_discordVerifyRedirectScript_fac0`, realm),
-		CallInline: templ.SafeScriptInline(`__templ_discordVerifyRedirectScript_fac0`, realm),
+		Call:       templ.SafeScript(`__templ_discordVerifyRedirectScript_4e71`, realm),
+		CallInline: templ.SafeScriptInline(`__templ_discordVerifyRedirectScript_4e71`, realm),
 	}
 }

From 2948a73f17ba03cfe7add765429299f29c3e525c Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 7 Jul 2024 14:33:24 -0400
Subject: [PATCH 298/341] added footer and legal pages

---
 cmd/frontend/components/footer.templ    | 13 +++++++
 cmd/frontend/components/footer_templ.go | 35 +++++++++++++++++
 cmd/frontend/components/remote.templ    | 14 +++++++
 cmd/frontend/components/remote_templ.go | 51 +++++++++++++++++++++++++
 cmd/frontend/handlers.go                |  9 +++++
 cmd/frontend/layouts/main.templ         |  1 +
 cmd/frontend/layouts/main_templ.go      | 10 ++++-
 cmd/frontend/routes/legal.go            | 16 ++++++++
 8 files changed, 148 insertions(+), 1 deletion(-)
 create mode 100644 cmd/frontend/components/footer.templ
 create mode 100644 cmd/frontend/components/footer_templ.go
 create mode 100644 cmd/frontend/components/remote.templ
 create mode 100644 cmd/frontend/components/remote_templ.go
 create mode 100644 cmd/frontend/routes/legal.go

diff --git a/cmd/frontend/components/footer.templ b/cmd/frontend/components/footer.templ
new file mode 100644
index 00000000..944fc144
--- /dev/null
+++ b/cmd/frontend/components/footer.templ
@@ -0,0 +1,13 @@
+package components
+
+templ Footer() {
+	<footer class="footer bg-base-300 text-base-content p-4 flex flex-row flex-wrap justify-between gap-4">
+		<aside class="flex flex-row flex-wrap">
+			Aftermath - <span class="italic">Blazingly</span> fast stats since 2020
+		</aside>
+		<aside class="flex flex-row flex-wrap gap-4">
+			<a href="/legal/terms-of-service" class="link link-hover">Terms of Service</a>
+			<a href="/legal/privacy-policy" class="link link-hover">Privacy Policy</a>
+		</aside>
+	</footer>
+}
diff --git a/cmd/frontend/components/footer_templ.go b/cmd/frontend/components/footer_templ.go
new file mode 100644
index 00000000..f2838ba1
--- /dev/null
+++ b/cmd/frontend/components/footer_templ.go
@@ -0,0 +1,35 @@
+// Code generated by templ - DO NOT EDIT.
+
+// templ: version: v0.2.731
+package components
+
+//lint:file-ignore SA4006 This context is only used if a nested component is present.
+
+import "github.com/a-h/templ"
+import templruntime "github.com/a-h/templ/runtime"
+
+func Footer() templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var1 == nil {
+			templ_7745c5c3_Var1 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<footer class=\"footer bg-base-300 text-base-content p-4 flex flex-row flex-wrap justify-between gap-4\"><aside class=\"flex flex-row flex-wrap\">Aftermath - <span class=\"italic\">Blazingly</span> fast stats since 2020</aside><aside class=\"flex flex-row flex-wrap gap-4\"><a href=\"/legal/terms-of-service\" class=\"link link-hover\">Terms of Service</a> <a href=\"/legal/privacy-policy\" class=\"link link-hover\">Privacy Policy</a></aside></footer>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return templ_7745c5c3_Err
+	})
+}
diff --git a/cmd/frontend/components/remote.templ b/cmd/frontend/components/remote.templ
new file mode 100644
index 00000000..717dc959
--- /dev/null
+++ b/cmd/frontend/components/remote.templ
@@ -0,0 +1,14 @@
+package components
+
+import "github.com/cufee/aftermath/cmd/frontend/logic"
+
+templ RemoteContentPage(url string) {
+	<div id="page-content" class="px-4">
+		JavaScript is required to load this page.
+	</div>
+	@logic.EmbedScript(loadContent(url), url)
+}
+
+script loadContent(url string) {
+	fetch(url).then(res=>res.text()).then(html=>document.getElementById('page-content').innerHTML=html);
+}
diff --git a/cmd/frontend/components/remote_templ.go b/cmd/frontend/components/remote_templ.go
new file mode 100644
index 00000000..10e9495a
--- /dev/null
+++ b/cmd/frontend/components/remote_templ.go
@@ -0,0 +1,51 @@
+// Code generated by templ - DO NOT EDIT.
+
+// templ: version: v0.2.731
+package components
+
+//lint:file-ignore SA4006 This context is only used if a nested component is present.
+
+import "github.com/a-h/templ"
+import templruntime "github.com/a-h/templ/runtime"
+
+import "github.com/cufee/aftermath/cmd/frontend/logic"
+
+func RemoteContentPage(url string) templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var1 == nil {
+			templ_7745c5c3_Var1 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div id=\"page-content\" class=\"px-4\">JavaScript is required to load this page.</div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = logic.EmbedScript(loadContent(url), url).Render(ctx, templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return templ_7745c5c3_Err
+	})
+}
+
+func loadContent(url string) templ.ComponentScript {
+	return templ.ComponentScript{
+		Name: `__templ_loadContent_9132`,
+		Function: `function __templ_loadContent_9132(url){fetch(url).then(res=>res.text()).then(html=>document.getElementById('page-content').innerHTML=html);
+}`,
+		Call:       templ.SafeScript(`__templ_loadContent_9132`, url),
+		CallInline: templ.SafeScriptInline(`__templ_loadContent_9132`, url),
+	}
+}
diff --git a/cmd/frontend/handlers.go b/cmd/frontend/handlers.go
index 336ee72c..659bc062 100644
--- a/cmd/frontend/handlers.go
+++ b/cmd/frontend/handlers.go
@@ -48,6 +48,15 @@ func Handlers(core core.Client) ([]server.Handler, error) {
 			Path: "GET /{pathname...}",
 			Func: handler.Chain(core, routes.ErrorNotFound),
 		},
+		// legal
+		{
+			Path: get("/legal/terms-of-service"),
+			Func: handler.Chain(core, routes.TermsOfService),
+		},
+		{
+			Path: get("/legal/privacy-policy"),
+			Func: handler.Chain(core, routes.PrivacyPolicy),
+		},
 		// common routes
 		{
 			Path: get("/"),
diff --git a/cmd/frontend/layouts/main.templ b/cmd/frontend/layouts/main.templ
index d39ee89a..f86369a6 100644
--- a/cmd/frontend/layouts/main.templ
+++ b/cmd/frontend/layouts/main.templ
@@ -27,6 +27,7 @@ templ main(head templ.Component, navbar templ.Component, children ...templ.Compo
 					@render
 				}
 			</main>
+			@components.Footer()
 			<script>
 				// enable swap on 422, this status code is used for validation errors and returns error messages bound to elements
 				document.body.addEventListener('htmx:beforeOnLoad', function (evt) {
diff --git a/cmd/frontend/layouts/main_templ.go b/cmd/frontend/layouts/main_templ.go
index 07ffeebf..dc4aa73c 100644
--- a/cmd/frontend/layouts/main_templ.go
+++ b/cmd/frontend/layouts/main_templ.go
@@ -66,7 +66,15 @@ func main(head templ.Component, navbar templ.Component, children ...templ.Compon
 				return templ_7745c5c3_Err
 			}
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</main><script>\n\t\t\t\t// enable swap on 422, this status code is used for validation errors and returns error messages bound to elements\n\t\t\t\tdocument.body.addEventListener('htmx:beforeOnLoad', function (evt) {\n\t\t\t\t\t\tif (evt.detail.xhr.status === 422) {\n\t\t\t\t\t\t\t\tevt.detail.shouldSwap = true;\n\t\t\t\t\t\t\t\tevt.detail.isError = false;\n\t\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t</script></body></html>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("</main>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = components.Footer().Render(ctx, templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<script>\n\t\t\t\t// enable swap on 422, this status code is used for validation errors and returns error messages bound to elements\n\t\t\t\tdocument.body.addEventListener('htmx:beforeOnLoad', function (evt) {\n\t\t\t\t\t\tif (evt.detail.xhr.status === 422) {\n\t\t\t\t\t\t\t\tevt.detail.shouldSwap = true;\n\t\t\t\t\t\t\t\tevt.detail.isError = false;\n\t\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t</script></body></html>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
diff --git a/cmd/frontend/routes/legal.go b/cmd/frontend/routes/legal.go
new file mode 100644
index 00000000..91cdbdd4
--- /dev/null
+++ b/cmd/frontend/routes/legal.go
@@ -0,0 +1,16 @@
+package routes
+
+import (
+	"github.com/a-h/templ"
+	"github.com/cufee/aftermath/cmd/frontend/components"
+	"github.com/cufee/aftermath/cmd/frontend/handler"
+	"github.com/cufee/aftermath/cmd/frontend/layouts"
+)
+
+var TermsOfService handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
+	return layouts.Main, components.RemoteContentPage("https://byvko-dev.github.io/legal/terms-of-service-partial"), nil
+}
+
+var PrivacyPolicy handler.Page = func(ctx *handler.Context) (handler.Layout, templ.Component, error) {
+	return layouts.Main, components.RemoteContentPage("https://byvko-dev.github.io/legal/privacy-policy"), nil
+}

From d35b2215e916ddab5d2f6f62137f56c92b52de55 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 7 Jul 2024 17:47:06 -0400
Subject: [PATCH 299/341] tweaked footed, added clarification to readme

---
 README.md                               | 3 +++
 cmd/frontend/components/footer.templ    | 7 ++++---
 cmd/frontend/components/footer_templ.go | 2 +-
 3 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index bbff7d4b..5f3f39e2 100644
--- a/README.md
+++ b/README.md
@@ -22,3 +22,6 @@ Deploying Aftermath is relatively simple. You can build the binary manually, use
 - Head over to General and click on Deploy.
 - Once the app is deployed and everything looks good in Logs, set the INTERACTIONS ENDPOINT URL under General Information in Discord Application settings to `https://yourdomain/discord/callback`. For example, `https://amth.one/discord/callback`.
 - You can start using Discord commands now!
+
+## On Source Code and Licensing
+Aftermath is a **source-available** project, **not** open source. Please note that this means you are not permitted to freely modify and redistribute any part of this codebase. For more information, refer to the specific licensing terms provided in the LICENSE file.
\ No newline at end of file
diff --git a/cmd/frontend/components/footer.templ b/cmd/frontend/components/footer.templ
index 944fc144..eba68408 100644
--- a/cmd/frontend/components/footer.templ
+++ b/cmd/frontend/components/footer.templ
@@ -1,11 +1,12 @@
 package components
 
 templ Footer() {
-	<footer class="footer bg-base-300 text-base-content p-4 flex flex-row flex-wrap justify-between gap-4">
-		<aside class="flex flex-row flex-wrap">
+	<footer class="footer bg-base-300 text-base-content p-4 flex flex-row flex-wrap justify-between gap-2">
+		<aside class="flex flex-row flex-wrap justify-center sm:justify-start grow">
 			Aftermath - <span class="italic">Blazingly</span> fast stats since 2020
 		</aside>
-		<aside class="flex flex-row flex-wrap gap-4">
+		<aside class="flex flex-row flex-wrap gap-4 justify-center sm:justify-end grow">
+			<a href="https://github.com/Cufee/aftermath" class="link link-hover">GitHub Repository</a>
 			<a href="/legal/terms-of-service" class="link link-hover">Terms of Service</a>
 			<a href="/legal/privacy-policy" class="link link-hover">Privacy Policy</a>
 		</aside>
diff --git a/cmd/frontend/components/footer_templ.go b/cmd/frontend/components/footer_templ.go
index f2838ba1..59cd99ac 100644
--- a/cmd/frontend/components/footer_templ.go
+++ b/cmd/frontend/components/footer_templ.go
@@ -26,7 +26,7 @@ func Footer() templ.Component {
 			templ_7745c5c3_Var1 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<footer class=\"footer bg-base-300 text-base-content p-4 flex flex-row flex-wrap justify-between gap-4\"><aside class=\"flex flex-row flex-wrap\">Aftermath - <span class=\"italic\">Blazingly</span> fast stats since 2020</aside><aside class=\"flex flex-row flex-wrap gap-4\"><a href=\"/legal/terms-of-service\" class=\"link link-hover\">Terms of Service</a> <a href=\"/legal/privacy-policy\" class=\"link link-hover\">Privacy Policy</a></aside></footer>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<footer class=\"footer bg-base-300 text-base-content p-4 flex flex-row flex-wrap justify-between gap-2\"><aside class=\"flex flex-row flex-wrap justify-center sm:justify-start grow\">Aftermath - <span class=\"italic\">Blazingly</span> fast stats since 2020</aside><aside class=\"flex flex-row flex-wrap gap-4 justify-center sm:justify-end grow\"><a href=\"https://github.com/Cufee/aftermath\" class=\"link link-hover\">GitHub Repository</a> <a href=\"/legal/terms-of-service\" class=\"link link-hover\">Terms of Service</a> <a href=\"/legal/privacy-policy\" class=\"link link-hover\">Privacy Policy</a></aside></footer>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}

From 0f0dfde750040d532e2d89c09a755f1c21c7f813 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 7 Jul 2024 18:13:36 -0400
Subject: [PATCH 300/341] added docker image build action

---
 .github/workflows/build-packages.yml | 84 ++++++++++++++++++++++++++++
 1 file changed, 84 insertions(+)
 create mode 100644 .github/workflows/build-packages.yml

diff --git a/.github/workflows/build-packages.yml b/.github/workflows/build-packages.yml
new file mode 100644
index 00000000..28d5e20a
--- /dev/null
+++ b/.github/workflows/build-packages.yml
@@ -0,0 +1,84 @@
+name: Create and publish Docker images
+
+# Configures this workflow to run every time a change is pushed to the branch called `release`.
+on:
+  push:
+    branches: ['release', 'canary']
+
+# Defines two custom environment variables for the workflow. These are used for the Container registry domain, and a name for the Docker image that this workflow builds.
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: ${{ github.repository }}-${{ github.ref_name }}
+
+# There is a single job in this workflow. It's configured to run on the latest available version of Ubuntu.
+jobs:
+  build-and-push-image:
+    environment: dokploy-${{ github.ref_name }}
+    runs-on: ubuntu-latest
+    # Sets the permissions granted to the `GITHUB_TOKEN` for the actions in this job.
+    permissions:
+      contents: read
+      packages: write
+      attestations: write
+      id-token: write
+      # 
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      # Uses the `docker/login-action` action to log in to the Container registry registry using the account and password that will publish the packages. Once published, the packages are scoped to the account defined here.
+      - name: Log in to the Container registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      # This step uses [docker/metadata-action](https://github.com/docker/metadata-action#about) to extract tags and labels that will be applied to the specified image. The `id` "meta" allows the output of this step to be referenced in a subsequent step. The `images` value provides the base name for the tags and labels.
+      - name: Extract migrations metadata (tags, labels) for Docker
+        id: meta-migrations
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}-migrations
+      - name: Extract service metadata (tags, labels) for Docker
+        id: meta-service
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+
+      # This step uses the `docker/build-push-action` action to build the image, based on your repository's `Dockerfile`. If the build succeeds, it pushes the image to GitHub Packages.
+      # It uses the `context` parameter to define the build's context as the set of files located in the specified path. For more information, see "[Usage](https://github.com/docker/build-push-action#usage)" in the README of the `docker/build-push-action` repository.
+      # It uses the `tags` and `labels` parameters to tag and label the image with the output from the "meta" step.
+      - name: Build and push migrations Docker image
+        id: push
+        uses: docker/build-push-action@@v6
+        with:
+          context: .
+          push: true
+          tags: ${{ steps.meta-migrations.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          file: Dockerfile.migrate
+
+      - name: Build and push service Docker image
+        id: push
+        uses: docker/build-push-action@@v6
+        with:
+          context: .
+          push: true
+          tags: ${{ steps.meta-service.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          file: Dockerfile
+      
+      # This step generates an artifact attestation for the image, which is an unforgeable statement about where and how it was built. It increases supply chain security for people who consume the image. For more information, see "[AUTOTITLE](/actions/security-guides/using-artifact-attestations-to-establish-provenance-for-builds)." 
+      - name: Generate artifact attestation
+        uses: actions/attest-build-provenance@v1
+        with:
+          platforms: linux/amd64,linux/arm64
+          subject-name: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME}}
+          subject-digest: ${{ steps.push.outputs.digest }}
+          push-to-registry: true
+
+      - name: Redeploy the application using the latest image
+        uses: distributhor/workflow-webhook@v3
+        with:
+          webhook_url: ${{ secrets.DOKPLOY_WEBHOOK_URL }}
+            
+        

From 92c8de79bd18dc378747134472adceb9d7352786 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 7 Jul 2024 18:15:05 -0400
Subject: [PATCH 301/341] typo

---
 .github/workflows/build-packages.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/build-packages.yml b/.github/workflows/build-packages.yml
index 28d5e20a..bdb9e8c6 100644
--- a/.github/workflows/build-packages.yml
+++ b/.github/workflows/build-packages.yml
@@ -49,7 +49,7 @@ jobs:
       # It uses the `tags` and `labels` parameters to tag and label the image with the output from the "meta" step.
       - name: Build and push migrations Docker image
         id: push
-        uses: docker/build-push-action@@v6
+        uses: docker/build-push-action@v6
         with:
           context: .
           push: true
@@ -59,7 +59,7 @@ jobs:
 
       - name: Build and push service Docker image
         id: push
-        uses: docker/build-push-action@@v6
+        uses: docker/build-push-action@v6
         with:
           context: .
           push: true

From afd7cb4761546faae4416cffec2a0942fd5ce371 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 7 Jul 2024 18:16:57 -0400
Subject: [PATCH 302/341] fixed incorrect IDs

---
 .github/workflows/build-packages.yml | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/build-packages.yml b/.github/workflows/build-packages.yml
index bdb9e8c6..486c7cb2 100644
--- a/.github/workflows/build-packages.yml
+++ b/.github/workflows/build-packages.yml
@@ -48,32 +48,39 @@ jobs:
       # It uses the `context` parameter to define the build's context as the set of files located in the specified path. For more information, see "[Usage](https://github.com/docker/build-push-action#usage)" in the README of the `docker/build-push-action` repository.
       # It uses the `tags` and `labels` parameters to tag and label the image with the output from the "meta" step.
       - name: Build and push migrations Docker image
-        id: push
+        id: push-migrations
         uses: docker/build-push-action@v6
         with:
           context: .
           push: true
           tags: ${{ steps.meta-migrations.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
+          labels: ${{ steps.meta-migrations.outputs.labels }}
           file: Dockerfile.migrate
 
       - name: Build and push service Docker image
-        id: push
+        id: push-service
         uses: docker/build-push-action@v6
         with:
           context: .
           push: true
           tags: ${{ steps.meta-service.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
+          labels: ${{ steps.meta-service.outputs.labels }}
           file: Dockerfile
       
       # This step generates an artifact attestation for the image, which is an unforgeable statement about where and how it was built. It increases supply chain security for people who consume the image. For more information, see "[AUTOTITLE](/actions/security-guides/using-artifact-attestations-to-establish-provenance-for-builds)." 
-      - name: Generate artifact attestation
+      - name: Generate migrations artifact attestation
+        uses: actions/attest-build-provenance@v1
+        with:
+          platforms: linux/amd64,linux/arm64
+          subject-name: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME}}-migrations
+          subject-digest: ${{ steps.push-migrations.outputs.digest }}
+          push-to-registry: true
+      - name: Generate service artifact attestation
         uses: actions/attest-build-provenance@v1
         with:
           platforms: linux/amd64,linux/arm64
           subject-name: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME}}
-          subject-digest: ${{ steps.push.outputs.digest }}
+          subject-digest: ${{ steps.push-service.outputs.digest }}
           push-to-registry: true
 
       - name: Redeploy the application using the latest image

From 74ef06140d198ee78ba7a54896554f8d715ec43d Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 7 Jul 2024 18:20:01 -0400
Subject: [PATCH 303/341] added platform targets correctly

---
 .github/workflows/build-packages.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/build-packages.yml b/.github/workflows/build-packages.yml
index 486c7cb2..7a3cb906 100644
--- a/.github/workflows/build-packages.yml
+++ b/.github/workflows/build-packages.yml
@@ -53,6 +53,7 @@ jobs:
         with:
           context: .
           push: true
+          platforms: linux/amd64,linux/arm64
           tags: ${{ steps.meta-migrations.outputs.tags }}
           labels: ${{ steps.meta-migrations.outputs.labels }}
           file: Dockerfile.migrate
@@ -63,6 +64,7 @@ jobs:
         with:
           context: .
           push: true
+          platforms: linux/amd64,linux/arm64
           tags: ${{ steps.meta-service.outputs.tags }}
           labels: ${{ steps.meta-service.outputs.labels }}
           file: Dockerfile
@@ -71,14 +73,12 @@ jobs:
       - name: Generate migrations artifact attestation
         uses: actions/attest-build-provenance@v1
         with:
-          platforms: linux/amd64,linux/arm64
           subject-name: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME}}-migrations
           subject-digest: ${{ steps.push-migrations.outputs.digest }}
           push-to-registry: true
       - name: Generate service artifact attestation
         uses: actions/attest-build-provenance@v1
         with:
-          platforms: linux/amd64,linux/arm64
           subject-name: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME}}
           subject-digest: ${{ steps.push-service.outputs.digest }}
           push-to-registry: true

From 48b697efd68c3be1dc6eb5486cb2d6a8768f5917 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 7 Jul 2024 18:28:05 -0400
Subject: [PATCH 304/341] added more tags

---
 .github/workflows/build-packages.yml | 24 ++++++++++++++++++++----
 docker-compose.yaml                  | 13 ++++---------
 2 files changed, 24 insertions(+), 13 deletions(-)

diff --git a/.github/workflows/build-packages.yml b/.github/workflows/build-packages.yml
index 7a3cb906..7ae5d722 100644
--- a/.github/workflows/build-packages.yml
+++ b/.github/workflows/build-packages.yml
@@ -38,11 +38,27 @@ jobs:
         uses: docker/metadata-action@v5
         with:
           images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}-migrations
+          tags: |
+            type=schedule
+            type=ref,event=branch
+            type=ref,event=pr
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+            type=semver,pattern={{major}}
+            type=sha   
       - name: Extract service metadata (tags, labels) for Docker
         id: meta-service
         uses: docker/metadata-action@v5
         with:
           images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+          tags: |
+            type=schedule
+            type=ref,event=branch
+            type=ref,event=pr
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+            type=semver,pattern={{major}}
+            type=sha   
 
       # This step uses the `docker/build-push-action` action to build the image, based on your repository's `Dockerfile`. If the build succeeds, it pushes the image to GitHub Packages.
       # It uses the `context` parameter to define the build's context as the set of files located in the specified path. For more information, see "[Usage](https://github.com/docker/build-push-action#usage)" in the README of the `docker/build-push-action` repository.
@@ -83,9 +99,9 @@ jobs:
           subject-digest: ${{ steps.push-service.outputs.digest }}
           push-to-registry: true
 
-      - name: Redeploy the application using the latest image
-        uses: distributhor/workflow-webhook@v3
-        with:
-          webhook_url: ${{ secrets.DOKPLOY_WEBHOOK_URL }}
+      # - name: Redeploy the application using the latest image
+      #   uses: distributhor/workflow-webhook@v3
+      #   with:
+      #     webhook_url: ${{ secrets.DOKPLOY_WEBHOOK_URL }}
             
         
diff --git a/docker-compose.yaml b/docker-compose.yaml
index a55eaf89..81d62a2d 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -1,8 +1,7 @@
 services:
   aftermath-migrate:
-    image: aftermath-migrate
-    build:
-      dockerfile: Dockerfile.migrate
+    pull_policy: always
+    image: ghcr.io/cufee/aftermath-canary-migrate:latest
     command: migrate apply --allow-dirty --dir "file:///migrations" --tx-mode all --url "sqlite:///data/${DATABASE_NAME}?_fk=1"
     volumes:
       - ${DATABASE_PATH}:/data
@@ -21,12 +20,8 @@ services:
     volumes:
       - ${DATABASE_PATH}:/data
 
-    image: aftermath-service
-    build:
-      dockerfile: Dockerfile
-      args:
-        - GO_MEM_LIMIT=122MiB
-        - BRAND_FLAVOR=${BRAND_FLAVOR}
+    pull_policy: always
+    image: ghcr.io/cufee/aftermath-canary:latest
     restart: always
     deploy:
       resources:

From 588939b31b9a157825cca1e4d23a533080d49b50 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 7 Jul 2024 18:33:48 -0400
Subject: [PATCH 305/341] added latest tags

---
 .github/workflows/build-packages.yml | 18 +++++++++++-------
 1 file changed, 11 insertions(+), 7 deletions(-)

diff --git a/.github/workflows/build-packages.yml b/.github/workflows/build-packages.yml
index 7ae5d722..627cb788 100644
--- a/.github/workflows/build-packages.yml
+++ b/.github/workflows/build-packages.yml
@@ -8,7 +8,7 @@ on:
 # Defines two custom environment variables for the workflow. These are used for the Container registry domain, and a name for the Docker image that this workflow builds.
 env:
   REGISTRY: ghcr.io
-  IMAGE_NAME: ${{ github.repository }}-${{ github.ref_name }}
+  IMAGE_NAME: ${{ github.repository }}
 
 # There is a single job in this workflow. It's configured to run on the latest available version of Ubuntu.
 jobs:
@@ -40,12 +40,14 @@ jobs:
           images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}-migrations
           tags: |
             type=schedule
-            type=ref,event=branch
             type=ref,event=pr
+            type=ref,event=branch
             type=semver,pattern={{version}}
             type=semver,pattern={{major}}.{{minor}}
             type=semver,pattern={{major}}
-            type=sha   
+            type=raw,latest-${{ github.ref_name }}
+            type=raw,latest
+            type=sha
       - name: Extract service metadata (tags, labels) for Docker
         id: meta-service
         uses: docker/metadata-action@v5
@@ -53,12 +55,14 @@ jobs:
           images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
           tags: |
             type=schedule
-            type=ref,event=branch
             type=ref,event=pr
+            type=ref,event=branch
             type=semver,pattern={{version}}
             type=semver,pattern={{major}}.{{minor}}
             type=semver,pattern={{major}}
-            type=sha   
+            type=raw,latest-${{ github.ref_name }}
+            type=raw,latest
+            type=sha
 
       # This step uses the `docker/build-push-action` action to build the image, based on your repository's `Dockerfile`. If the build succeeds, it pushes the image to GitHub Packages.
       # It uses the `context` parameter to define the build's context as the set of files located in the specified path. For more information, see "[Usage](https://github.com/docker/build-push-action#usage)" in the README of the `docker/build-push-action` repository.
@@ -69,7 +73,7 @@ jobs:
         with:
           context: .
           push: true
-          platforms: linux/amd64,linux/arm64
+          # platforms: linux/amd64,linux/arm64
           tags: ${{ steps.meta-migrations.outputs.tags }}
           labels: ${{ steps.meta-migrations.outputs.labels }}
           file: Dockerfile.migrate
@@ -80,7 +84,7 @@ jobs:
         with:
           context: .
           push: true
-          platforms: linux/amd64,linux/arm64
+          # platforms: linux/amd64,linux/arm64
           tags: ${{ steps.meta-service.outputs.tags }}
           labels: ${{ steps.meta-service.outputs.labels }}
           file: Dockerfile

From 551561444b3cc9bc7172951fa97201a1bc95515f Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 7 Jul 2024 18:41:57 -0400
Subject: [PATCH 306/341] added dynamic image names, re-enabled webhooks

---
 .env.example                         | 1 +
 .github/workflows/build-packages.yml | 8 ++++----
 docker-compose.yaml                  | 4 ++--
 3 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/.env.example b/.env.example
index 505e0f42..f4196fac 100644
--- a/.env.example
+++ b/.env.example
@@ -43,6 +43,7 @@ BOT_INVITE_LINK="https://discord.com/application-directory/1196247108215386142"
 # Misc configuration
 # This is not required for local deployment using compose. When deploying with Dokploy, this is the domain aftermath service will be available on.
 TRAEFIK_HOST="local.amth.one"
+ENVIRONMENT="canary" # this is used to pull the correct image, needs to march a github branch
 LOG_LEVEL="debug"
 NETWORK="tcp"
 PORT="9092"
diff --git a/.github/workflows/build-packages.yml b/.github/workflows/build-packages.yml
index 627cb788..f9871d87 100644
--- a/.github/workflows/build-packages.yml
+++ b/.github/workflows/build-packages.yml
@@ -103,9 +103,9 @@ jobs:
           subject-digest: ${{ steps.push-service.outputs.digest }}
           push-to-registry: true
 
-      # - name: Redeploy the application using the latest image
-      #   uses: distributhor/workflow-webhook@v3
-      #   with:
-      #     webhook_url: ${{ secrets.DOKPLOY_WEBHOOK_URL }}
+      - name: Redeploy the application using the latest image
+        uses: distributhor/workflow-webhook@v3
+        with:
+          webhook_url: ${{ secrets.DOKPLOY_WEBHOOK_URL }}
             
         
diff --git a/docker-compose.yaml b/docker-compose.yaml
index 81d62a2d..49f3e4d1 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -1,7 +1,7 @@
 services:
   aftermath-migrate:
     pull_policy: always
-    image: ghcr.io/cufee/aftermath-canary-migrate:latest
+    image: ghcr.io/cufee/aftermath-migrate:latest-${ENVIRONMENT}
     command: migrate apply --allow-dirty --dir "file:///migrations" --tx-mode all --url "sqlite:///data/${DATABASE_NAME}?_fk=1"
     volumes:
       - ${DATABASE_PATH}:/data
@@ -21,7 +21,7 @@ services:
       - ${DATABASE_PATH}:/data
 
     pull_policy: always
-    image: ghcr.io/cufee/aftermath-canary:latest
+    image: ghcr.io/cufee/aftermath-canary:latest-${ENVIRONMENT}
     restart: always
     deploy:
       resources:

From 95b7a648e6f7552cba74695751a24de5a4ffdbcb Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 7 Jul 2024 18:53:24 -0400
Subject: [PATCH 307/341] fixed typo

---
 docker-compose.yaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docker-compose.yaml b/docker-compose.yaml
index 49f3e4d1..884a8303 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -1,7 +1,7 @@
 services:
   aftermath-migrate:
     pull_policy: always
-    image: ghcr.io/cufee/aftermath-migrate:latest-${ENVIRONMENT}
+    image: ghcr.io/cufee/aftermath-migrations:latest-${ENVIRONMENT}
     command: migrate apply --allow-dirty --dir "file:///migrations" --tx-mode all --url "sqlite:///data/${DATABASE_NAME}?_fk=1"
     volumes:
       - ${DATABASE_PATH}:/data

From 85e63adb1e9f0ecaad883f78cd2c44af5bbbf305 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 7 Jul 2024 18:53:38 -0400
Subject: [PATCH 308/341] fixed another typo

---
 docker-compose.yaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docker-compose.yaml b/docker-compose.yaml
index 884a8303..c12fb73a 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -21,7 +21,7 @@ services:
       - ${DATABASE_PATH}:/data
 
     pull_policy: always
-    image: ghcr.io/cufee/aftermath-canary:latest-${ENVIRONMENT}
+    image: ghcr.io/cufee/aftermath:latest-${ENVIRONMENT}
     restart: always
     deploy:
       resources:

From d41d13b29a1c9bc9f56c1a9f7646afb39f375948 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 7 Jul 2024 19:00:16 -0400
Subject: [PATCH 309/341] removed old info from readme

---
 .env.example | 21 +++++++++++++++------
 README.md    |  1 -
 2 files changed, 15 insertions(+), 7 deletions(-)

diff --git a/.env.example b/.env.example
index f4196fac..e09a958d 100644
--- a/.env.example
+++ b/.env.example
@@ -6,7 +6,7 @@ INIT_GLOBAL_ADMIN_USER="" # Discord user ID for a user who will be assigned perm
 
 # Wargaming API
 WG_AUTH_APP_ID="" # Used to verify WG accounts, this app id will be exposed to the end user
-
+WG_AUTH_REDIRECT_URI="yourdomain.com/api/auth/wargaming/redirect"
 # Requests initiated by a user will always go through the "primary" wg app id and proxy
 WG_PRIMARY_APP_ID=""
 WG_PRIMARY_APP_RPS="10"
@@ -23,6 +23,7 @@ WG_CACHE_PROXY_HOST_LIST=""
 
 # Discord
 DISCORD_TOKEN=""
+DISCORD_CLIENT_ID=""
 DISCORD_PUBLIC_KEY=""
 DISCORD_PRIMARY_GUILD_ID="" # Discord ID of the primary guild, some features will be locked to this guild only
 DISCORD_ERROR_REPORT_WEBHOOK_URL="" # A Discord webhook URL for a channel where the bot should report errors
@@ -30,6 +31,12 @@ DISCORD_AUTH_DEFAULT_SCOPES="guilds identify"
 DISCORD_AUTH_REDIRECT_URL=""
 DISCORD_AUTH_CLIENT_SECRET=""
 DISCORD_AUTH_CLIENT_ID=""
+
+# Authentication
+AUTH_DEV_MODE="false"
+AUTH_COOKIE_PATH="/"
+AUTH_COOKIE_DOMAIN="yourdomain.com"
+
 # Optional components
 SCHEDULER_ENABLED="true" # Scheduler is responsible for refreshing glossary cache and recording sessions
 SCHEDULER_CONCURRENT_WORKERS="5" 
@@ -37,13 +44,15 @@ PRIVATE_SERVER_ENABLED="true" # A private server can be used to access some mana
 PRIVATE_SERVER_PORT="9093"
 
 # Discord Invites
-PRIMARY_GUILD_INVITE_LINK="https://discord.gg/8PVq2qvafw"
-BOT_INVITE_LINK="https://discord.com/application-directory/1196247108215386142"
+PRIMARY_GUILD_INVITE_LINK="https://discord.gg/..."
+BOT_INVITE_LINK="https://discord.com/application-directory/..."
 
 # Misc configuration
 # This is not required for local deployment using compose. When deploying with Dokploy, this is the domain aftermath service will be available on.
 TRAEFIK_HOST="local.amth.one"
-ENVIRONMENT="canary" # this is used to pull the correct image, needs to march a github branch
-LOG_LEVEL="debug"
+FRONTEND_URL="https://yourdomain.com"
+WEBAPP_NAME="Aftermath"
+ENVIRONMENT="release" # this is used to pull the correct image, needs to march a github branch
+LOG_LEVEL="info"
 NETWORK="tcp"
-PORT="9092"
+PORT="9092"
\ No newline at end of file
diff --git a/README.md b/README.md
index 5f3f39e2..cdc78f0e 100644
--- a/README.md
+++ b/README.md
@@ -11,7 +11,6 @@ Deploying Aftermath is relatively simple. You can build the binary manually, use
 - Create a new Project and add a new Compose service.
 - In Service settings > General > Provider, select your forked repository or Git > `git@github.com:Cufee/aftermath.git`. The branch should be `master`, but you can pick something different.
 - Change the Compose Path to `./docker-compose.yaml`.
-- If you are using your own repository, [setup a webhook under Deployments](https://docs.dokploy.com/application/overview#github).
 - Add your environment configuration under Environment, you can start by copying `.env.example`.
   - Set `TRAEFIK_HOST` to your domain. For example, `amth.one`.
   - Add a Discord Bot token and public key

From 6f7f54a81f381a0158392b1e91c1d07224762257 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 7 Jul 2024 19:02:35 -0400
Subject: [PATCH 310/341] added some files to Dockerignore

---
 .dockerignore   | 10 +++++++++-
 fly.canary.toml | 45 ---------------------------------------------
 2 files changed, 9 insertions(+), 46 deletions(-)
 delete mode 100644 fly.canary.toml

diff --git a/.dockerignore b/.dockerignore
index 5957f913..7bce32f2 100644
--- a/.dockerignore
+++ b/.dockerignore
@@ -1,7 +1,15 @@
 tmp
 .git
+.github
 .task
 .vscode
 **/.DS_Store
 
-.env
+.env*
+
+.air.*
+dev_web.go
+
+README.md
+Taskfile.yaml
+docker-compose.yaml
\ No newline at end of file
diff --git a/fly.canary.toml b/fly.canary.toml
deleted file mode 100644
index 12b4efb0..00000000
--- a/fly.canary.toml
+++ /dev/null
@@ -1,45 +0,0 @@
-app = 'aftermath-canary'
-primary_region = 'lhr'
-kill_signal = 'SIGINT'
-kill_timeout = '5s'
-
-
-[http_service]
-internal_port = 8080
-force_https = true
-auto_stop_machines = false
-auto_start_machines = false
-processes = ['app']
-
-[env]
-# Database configuration
-DATABASE_URL = "file:/data/db/canary.db"
-# Wargaming API
-WG_PRIMARY_APP_RPS = "10"
-WG_REQUEST_TIMEOUT_SEC = "5"
-WG_CACHE_APP_RPS = "10"
-WG_CACHE_REQUEST_TIMEOUT_SEC = "15"
-# External services
-BLITZ_STARS_API_URL = "https://www.blitzstars.com/api"
-WOT_BLITZ_PUBLIC_API_URL_FMT = "https://%s.wotblitz.com/en/api"
-WOT_INSPECTOR_REPLAYS_URL = 'https://api.wotinspector.com/v2/blitz/replays/'
-WOT_INSPECTOR_TANK_DB_URL = "https://armor.wotinspector.com/static/armorinspector/tank_db_blitz.js"
-# Discord
-DISCORD_PRIMARY_GUILD_ID = "1090331056449781793"
-# Misc configuration
-SCHEDULER_CONCURRENT_WORKERS = 10
-SCHEDULER_ENABLED = "true"
-LOG_LEVEL = "info"
-NETWORK = "tcp"
-PORT = "8080"
-
-[[mounts]]
-source = 'aftermath_canary_data'
-destination = '/data/db'
-initial_size = '1GB'
-auto_extend_size_threshold = 80
-auto_extend_size_increment = '1GB'
-auto_extend_size_limit = '100GB'
-
-[[vm]]
-size = 'shared-cpu-2x'

From 8df1dfcb8880f7255de067f4295a3a89b61f30ce Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 7 Jul 2024 19:06:06 -0400
Subject: [PATCH 311/341] cleaned up ignore files

---
 .dockerignore | 5 +++--
 .gitignore    | 3 +--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/.dockerignore b/.dockerignore
index 7bce32f2..94af9c6e 100644
--- a/.dockerignore
+++ b/.dockerignore
@@ -1,13 +1,14 @@
 tmp
 .git
 .github
+*/**.gitignore
 .task
 .vscode
 **/.DS_Store
 
-.env*
+**/.env*
 
-.air.*
+**/.air.*
 dev_web.go
 
 README.md
diff --git a/.gitignore b/.gitignore
index ee8990c0..3bec02dd 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,5 +4,4 @@ tmp
 .vscode
 **/.DS_Store
 
-**/.env
-**/.env.test
+**/.env*

From 7da69f2e8391600c2e8975202f26cb8b12427532 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 7 Jul 2024 20:14:24 -0400
Subject: [PATCH 312/341] split up docker compose files

---
 .dockerignore               |  2 +-
 .env.example                |  3 ++-
 README.md                   | 15 ++++++++++++-
 docker-compose.base.yaml    | 25 +++++++++++++++++++++
 docker-compose.dokploy.yaml | 27 +++++++++++++++++++++++
 docker-compose.yaml         | 44 +++++++------------------------------
 6 files changed, 77 insertions(+), 39 deletions(-)
 create mode 100644 docker-compose.base.yaml
 create mode 100644 docker-compose.dokploy.yaml

diff --git a/.dockerignore b/.dockerignore
index 94af9c6e..ed303011 100644
--- a/.dockerignore
+++ b/.dockerignore
@@ -13,4 +13,4 @@ dev_web.go
 
 README.md
 Taskfile.yaml
-docker-compose.yaml
\ No newline at end of file
+docker-compose.*
\ No newline at end of file
diff --git a/.env.example b/.env.example
index e09a958d..1c41218c 100644
--- a/.env.example
+++ b/.env.example
@@ -47,9 +47,10 @@ PRIVATE_SERVER_PORT="9093"
 PRIMARY_GUILD_INVITE_LINK="https://discord.gg/..."
 BOT_INVITE_LINK="https://discord.com/application-directory/..."
 
-# Misc configuration
 # This is not required for local deployment using compose. When deploying with Dokploy, this is the domain aftermath service will be available on.
 TRAEFIK_HOST="local.amth.one"
+
+# Misc configuration
 FRONTEND_URL="https://yourdomain.com"
 WEBAPP_NAME="Aftermath"
 ENVIRONMENT="release" # this is used to pull the correct image, needs to march a github branch
diff --git a/README.md b/README.md
index cdc78f0e..45b47f97 100644
--- a/README.md
+++ b/README.md
@@ -10,7 +10,7 @@ Deploying Aftermath is relatively simple. You can build the binary manually, use
 - [Install Dokploy and Docker](https://docs.dokploy.com/get-started/installation).
 - Create a new Project and add a new Compose service.
 - In Service settings > General > Provider, select your forked repository or Git > `git@github.com:Cufee/aftermath.git`. The branch should be `master`, but you can pick something different.
-- Change the Compose Path to `./docker-compose.yaml`.
+- Change the Compose Path to `./docker-compose.dokploy.yaml`.
 - Add your environment configuration under Environment, you can start by copying `.env.example`.
   - Set `TRAEFIK_HOST` to your domain. For example, `amth.one`.
   - Add a Discord Bot token and public key
@@ -22,5 +22,18 @@ Deploying Aftermath is relatively simple. You can build the binary manually, use
 - Once the app is deployed and everything looks good in Logs, set the INTERACTIONS ENDPOINT URL under General Information in Discord Application settings to `https://yourdomain/discord/callback`. For example, `https://amth.one/discord/callback`.
 - You can start using Discord commands now!
 
+### Locally with Docker Compose
+- Create a new Bot Application in Discord
+- [Install Docker](https://docs.docker.com/engine/install/).
+- Add your environment configuration under Environment, you can start by copying `.env.example`.
+  - Set `TRAEFIK_HOST` to your domain. For example, `amth.one`.
+  - Add a Discord Bot token and public key
+  - Ensure the `DATABASE_DIR` and `DATABASE_NAME` are set correctly, this will be the path **on your host**. If this is misconfigured, you will lose data on restart.
+  - Add Wargaming App IDs, not that one of them will be public.
+  - If you are planning to track a lot of users, add proxies for Wargaming API in the following format: `user:password@host:port?wgAppId=your_app_id&maxRps=20`
+  - Read through all variables prefixed with `INIT_`. Those will allow you to create admin user accounts and etc.
+- Start all services with `docker compose up -d`
+- You can start using Discord commands now!
+
 ## On Source Code and Licensing
 Aftermath is a **source-available** project, **not** open source. Please note that this means you are not permitted to freely modify and redistribute any part of this codebase. For more information, refer to the specific licensing terms provided in the LICENSE file.
\ No newline at end of file
diff --git a/docker-compose.base.yaml b/docker-compose.base.yaml
new file mode 100644
index 00000000..37cc5d75
--- /dev/null
+++ b/docker-compose.base.yaml
@@ -0,0 +1,25 @@
+services:
+  aftermath-migrate-base:
+    pull_policy: always
+    image: ghcr.io/cufee/aftermath-migrations:latest-${ENVIRONMENT}
+    command: migrate apply --allow-dirty --dir "file:///migrations" --tx-mode all --url "sqlite:///data/${DATABASE_NAME}?_fk=1"
+    volumes:
+      - ${DATABASE_PATH}:/data
+
+  aftermath-service-base:
+    pull_policy: always
+    image: ghcr.io/cufee/aftermath:latest-${ENVIRONMENT}
+    restart: always
+    volumes:
+      - ${DATABASE_PATH}:/data
+    env_file:
+      - .env
+    depends_on:
+      aftermath-migrate:
+        condition: service_completed_successfully
+    deploy:
+      resources:
+        reservations:
+          memory: 128m
+        limits:
+          memory: 256m
diff --git a/docker-compose.dokploy.yaml b/docker-compose.dokploy.yaml
new file mode 100644
index 00000000..f3371d32
--- /dev/null
+++ b/docker-compose.dokploy.yaml
@@ -0,0 +1,27 @@
+services:
+  aftermath-migrate:
+    extends:
+      file: docker-compose.base.yaml
+      service: aftermath-migrate-base
+    networks:
+      - dokploy-network
+
+  aftermath-service:
+    extends:
+      file: docker-compose.base.yaml
+      service: aftermath-service-base
+    environment:
+      - PORT=3000
+      - DATABASE_PATH=/data
+    networks:
+      - dokploy-network
+    labels:
+      - "traefik.enable=true"
+      - "traefik.http.routers.aftermath-monorepo-compose.rule=Host(`${TRAEFIK_HOST}`)"
+      - "traefik.http.routers.aftermath-monorepo-compose.entrypoints=websecure"
+      - "traefik.http.routers.aftermath-monorepo-compose.tls.certResolver=letsencrypt"
+      - "traefik.http.services.aftermath-monorepo-compose.loadbalancer.server.port=3000"
+
+networks:
+  dokploy-network:
+    external: true
diff --git a/docker-compose.yaml b/docker-compose.yaml
index c12fb73a..c69375e3 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -1,43 +1,15 @@
 services:
   aftermath-migrate:
-    pull_policy: always
-    image: ghcr.io/cufee/aftermath-migrations:latest-${ENVIRONMENT}
-    command: migrate apply --allow-dirty --dir "file:///migrations" --tx-mode all --url "sqlite:///data/${DATABASE_NAME}?_fk=1"
-    volumes:
-      - ${DATABASE_PATH}:/data
-    networks:
-      - dokploy-network
+    extends:
+      file: docker-compose.base.yaml
+      service: aftermath-migrate-base
+    network_mode: "host"
 
   aftermath-service:
-    env_file:
-      - .env
+    extends:
+      file: docker-compose.base.yaml
+      service: aftermath-service-base
     environment:
       - PORT=3000
       - DATABASE_PATH=/data
-    depends_on:
-      aftermath-migrate:
-        condition: service_completed_successfully
-    volumes:
-      - ${DATABASE_PATH}:/data
-
-    pull_policy: always
-    image: ghcr.io/cufee/aftermath:latest-${ENVIRONMENT}
-    restart: always
-    deploy:
-      resources:
-        reservations:
-          memory: 128m
-        limits:
-          memory: 256m
-    networks:
-      - dokploy-network
-    labels:
-      - "traefik.enable=true"
-      - "traefik.http.routers.aftermath-monorepo-compose.rule=Host(`${TRAEFIK_HOST}`)"
-      - "traefik.http.routers.aftermath-monorepo-compose.entrypoints=websecure"
-      - "traefik.http.routers.aftermath-monorepo-compose.tls.certResolver=letsencrypt"
-      - "traefik.http.services.aftermath-monorepo-compose.loadbalancer.server.port=3000"
-
-networks:
-  dokploy-network:
-    external: true
+    network_mode: "host"

From f5565514e4d01497d21cfcee250d7042691e852b Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 7 Jul 2024 20:24:31 -0400
Subject: [PATCH 313/341] added some comments

---
 docker-compose.base.yaml    | 3 +++
 docker-compose.dokploy.yaml | 5 +++--
 docker-compose.yaml         | 4 ++--
 3 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/docker-compose.base.yaml b/docker-compose.base.yaml
index 37cc5d75..34b6bc5b 100644
--- a/docker-compose.base.yaml
+++ b/docker-compose.base.yaml
@@ -1,3 +1,5 @@
+# This file defines the base services that will be extended from in order for us to support multiple platforms/deployment options
+# While it is fine to import .env files through `env_file` option here, `environment` should never be defined in this file - it will be overwritten
 services:
   aftermath-migrate-base:
     pull_policy: always
@@ -18,6 +20,7 @@ services:
       aftermath-migrate:
         condition: service_completed_successfully
     deploy:
+      # the resource limits are setup during build step and should generally not be adjusted here without changing the build pipeline first
       resources:
         reservations:
           memory: 128m
diff --git a/docker-compose.dokploy.yaml b/docker-compose.dokploy.yaml
index f3371d32..5e1036f9 100644
--- a/docker-compose.dokploy.yaml
+++ b/docker-compose.dokploy.yaml
@@ -11,8 +11,9 @@ services:
       file: docker-compose.base.yaml
       service: aftermath-service-base
     environment:
-      - PORT=3000
-      - DATABASE_PATH=/data
+      # the rest is imported from .env, which is going to be created by Dokploy automatically
+      - PORT=3000 # the port does not matter, but it needs to match Traefik labels. we set it here explicitly in order to avoid any issues
+      - DATABASE_PATH=/data # this is the path inside a contianer and needs to match the volume mount
     networks:
       - dokploy-network
     labels:
diff --git a/docker-compose.yaml b/docker-compose.yaml
index c69375e3..794cd86e 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -10,6 +10,6 @@ services:
       file: docker-compose.base.yaml
       service: aftermath-service-base
     environment:
-      - PORT=3000
-      - DATABASE_PATH=/data
+      # use the default port from .env
+      - DATABASE_PATH=/data # this is the path inside a contianer and needs to match the volume mount
     network_mode: "host"

From e71eff81c94aa6a83a3808fa53ef9e0dce6330f5 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 7 Jul 2024 20:26:52 -0400
Subject: [PATCH 314/341] minor working/typos fixes

---
 README.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 45b47f97..01f01056 100644
--- a/README.md
+++ b/README.md
@@ -15,7 +15,7 @@ Deploying Aftermath is relatively simple. You can build the binary manually, use
   - Set `TRAEFIK_HOST` to your domain. For example, `amth.one`.
   - Add a Discord Bot token and public key
   - Ensure the `DATABASE_DIR` and `DATABASE_NAME` are set correctly, this will be the path **on your host**. If this is misconfigured, you will lose data on restart.
-  - Add Wargaming App IDs, not that one of them will be public.
+  - Add Wargaming App IDs, note that one of them will be public.
   - If you are planning to track a lot of users, add proxies for Wargaming API in the following format: `user:password@host:port?wgAppId=your_app_id&maxRps=20`
   - Read through all variables prefixed with `INIT_`. Those will allow you to create admin user accounts and etc.
 - Head over to General and click on Deploy.
@@ -23,13 +23,13 @@ Deploying Aftermath is relatively simple. You can build the binary manually, use
 - You can start using Discord commands now!
 
 ### Locally with Docker Compose
+- Setup a reverse proxy for your machine, or use something like [ngrok](https://ngrok.com/docs/getting-started/)
 - Create a new Bot Application in Discord
-- [Install Docker](https://docs.docker.com/engine/install/).
+- [Install Docker](https://docs.docker.com/engine/install/)
 - Add your environment configuration under Environment, you can start by copying `.env.example`.
-  - Set `TRAEFIK_HOST` to your domain. For example, `amth.one`.
   - Add a Discord Bot token and public key
   - Ensure the `DATABASE_DIR` and `DATABASE_NAME` are set correctly, this will be the path **on your host**. If this is misconfigured, you will lose data on restart.
-  - Add Wargaming App IDs, not that one of them will be public.
+  - Add Wargaming App IDs, note that one of them will be public.
   - If you are planning to track a lot of users, add proxies for Wargaming API in the following format: `user:password@host:port?wgAppId=your_app_id&maxRps=20`
   - Read through all variables prefixed with `INIT_`. Those will allow you to create admin user accounts and etc.
 - Start all services with `docker compose up -d`

From c35b31ece57e6b68af6bcc8c555b81948ab7daa1 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 7 Jul 2024 20:27:21 -0400
Subject: [PATCH 315/341] ignoring all MD files

---
 .dockerignore | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.dockerignore b/.dockerignore
index ed303011..a38f17a1 100644
--- a/.dockerignore
+++ b/.dockerignore
@@ -11,6 +11,6 @@ tmp
 **/.air.*
 dev_web.go
 
-README.md
+**/*.md
 Taskfile.yaml
 docker-compose.*
\ No newline at end of file

From 5a5f7b910083261557439c7a0f740dae7249464e Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Sun, 7 Jul 2024 22:16:59 -0400
Subject: [PATCH 316/341] in progress achievements

---
 cmd/core/scheduler/scheduler.go           | 19 ++++++------
 cmd/core/scheduler/workers.go             | 11 ++++++-
 cmd/core/tasks/leaderboards.go            | 36 +++++++++++++++++++++++
 internal/database/models/task.go          |  6 ++--
 internal/stats/fetch/v1/multisource.go    | 16 ++++++++++
 internal/stats/render/common/v1/images.go | 33 ++++++++++++++++-----
 render_test.go                            |  6 ++--
 7 files changed, 105 insertions(+), 22 deletions(-)
 create mode 100644 cmd/core/tasks/leaderboards.go

diff --git a/cmd/core/scheduler/scheduler.go b/cmd/core/scheduler/scheduler.go
index bcadb57e..d4c3ebe5 100644
--- a/cmd/core/scheduler/scheduler.go
+++ b/cmd/core/scheduler/scheduler.go
@@ -43,15 +43,16 @@ func RegisterDefaultTasks(s *scheduler, coreClient core.Client) {
 	// Averages - Update averages once daily
 	s.Add("0 0 * * *", UpdateAveragesWorker(coreClient))
 
-	// Sessions
-	s.Add("0 9 * * *", CreateSessionTasksWorker(coreClient, "NA"))  // NA
-	s.Add("0 1 * * *", CreateSessionTasksWorker(coreClient, "EU"))  // EU
-	s.Add("0 18 * * *", CreateSessionTasksWorker(coreClient, "AS")) // Asia
-
-	// Refresh WN8
-	// "45 9 * * *" 	// NA
-	// "45 1 * * *" 	// EU
-	// "45 18 * * *" 	// Asia
+	// Snapshots
+	s.Add("0 9 * * *", CreateSnapshotTasksWorker(coreClient, "NA"))  // NA
+	s.Add("0 1 * * *", CreateSnapshotTasksWorker(coreClient, "EU"))  // EU
+	s.Add("0 18 * * *", CreateSnapshotTasksWorker(coreClient, "AS")) // Asia
+
+	// Achievement leaderboards
+	// ideally, this should not delay snapshots
+	s.Add("25 * * * *", CreateSnapshotTasksWorker(coreClient, "NA")) // NA
+	s.Add("30 * * * *", CreateSnapshotTasksWorker(coreClient, "EU")) // EU
+	s.Add("35 * * * *", CreateSnapshotTasksWorker(coreClient, "AS")) // Asia
 
 	// Configurations
 	s.Add("0 0 */7 * *", RotateBackgroundPresetsWorker(coreClient))
diff --git a/cmd/core/scheduler/workers.go b/cmd/core/scheduler/workers.go
index b6697880..6405abfc 100644
--- a/cmd/core/scheduler/workers.go
+++ b/cmd/core/scheduler/workers.go
@@ -38,7 +38,7 @@ func RotateBackgroundPresetsWorker(client core.Client) func() {
 	}
 }
 
-func CreateSessionTasksWorker(client core.Client, realm string) func() {
+func CreateSnapshotTasksWorker(client core.Client, realm string) func() {
 	return func() {
 		err := tasks.CreateRecordSnapshotsTasks(client, realm)
 		if err != nil {
@@ -156,3 +156,12 @@ func UpdateGlossaryWorker(client core.Client) func() {
 		log.Info().Msg("glossary cache updated")
 	}
 }
+
+func CreateAchievementLeaderboardTasksWorker(client core.Client, realm string) func() {
+	return func() {
+		err := tasks.CreateRecordSnapshotsTasks(client, realm)
+		if err != nil {
+			log.Err(err).Str("realm", realm).Msg("failed to schedule session update tasks")
+		}
+	}
+}
diff --git a/cmd/core/tasks/leaderboards.go b/cmd/core/tasks/leaderboards.go
new file mode 100644
index 00000000..12c8e387
--- /dev/null
+++ b/cmd/core/tasks/leaderboards.go
@@ -0,0 +1,36 @@
+package tasks
+
+import (
+	"github.com/cufee/aftermath/cmd/core"
+)
+
+// func init() {
+// 	defaultHandlers[models.TaskTypeAchievementsLeaderboardUpdate] = TaskHandler{
+// 		Process: func(ctx context.Context, client core.Client, task *models.Task) error {
+// 			forceUpdate := task.Data["force"] == "true"
+// 			realm, ok := task.Data["realm"]
+// 			if !ok {
+// 				return errors.New("invalid realm")
+// 			}
+// 			if len(task.Targets) > 100 {
+// 				return errors.New("invalid targets length")
+// 			}
+// 			if len(task.Targets) < 1 {
+// 				return errors.New("invalid targets length")
+// 			}
+
+// 			log.Debug().Str("taskId", task.ID).Any("targets", task.Targets).Msg("started working on a session refresh task")
+// 			accountErrors, err := logic.RecordAccountSnapshots(ctx, client.Wargaming(), client.Database(), realm, forceUpdate, task.Targets...)
+// 			if err != nil {
+// 				return err
+// 			}
+
+// 			return nil
+// 		},
+// 	}
+// }
+
+func CreateUpdateLeaderboardsTasks(client core.Client, realm string) error {
+	//
+	return nil
+}
diff --git a/internal/database/models/task.go b/internal/database/models/task.go
index 9ea7ed03..a0f557cb 100644
--- a/internal/database/models/task.go
+++ b/internal/database/models/task.go
@@ -7,8 +7,9 @@ import (
 type TaskType string
 
 const (
-	TaskTypeUpdateClans     TaskType = "UPDATE_CLANS"
-	TaskTypeRecordSnapshots TaskType = "RECORD_SNAPSHOTS"
+	TaskTypeUpdateClans                   TaskType = "UPDATE_CLANS"
+	TaskTypeRecordSnapshots               TaskType = "RECORD_SNAPSHOTS"
+	TaskTypeAchievementsLeaderboardUpdate TaskType = "ACHIEVEMENT_LEADERBOARDS"
 
 	TaskTypeDatabaseCleanup TaskType = "CLEANUP_DATABASE"
 )
@@ -19,6 +20,7 @@ func (TaskType) Values() []string {
 	for _, s := range []TaskType{
 		TaskTypeUpdateClans,
 		TaskTypeRecordSnapshots,
+		TaskTypeAchievementsLeaderboardUpdate,
 		TaskTypeDatabaseCleanup,
 	} {
 		kinds = append(kinds, string(s))
diff --git a/internal/stats/fetch/v1/multisource.go b/internal/stats/fetch/v1/multisource.go
index 60e919a9..3ae56c51 100644
--- a/internal/stats/fetch/v1/multisource.go
+++ b/internal/stats/fetch/v1/multisource.go
@@ -397,3 +397,19 @@ func (c *multiSourceClient) SessionStats(ctx context.Context, id string, session
 func (c *multiSourceClient) CurrentTankAverages(ctx context.Context) (map[string]frame.StatsFrame, error) {
 	return c.blitzstars.CurrentTankAverages(ctx)
 }
+
+func (c *multiSourceClient) PlayersAchievementsLeaderboard(ctx context.Context, playerID string, from time.Time, opts ...StatsOption) (any, error) {
+	// achievement snapshots are stored for overall stats and per vehicle
+	// for overall snapshot, reference ID should be accountID. for vehicles, reference should be vehicleID
+
+	var options = statsOptions{snapshotType: models.SnapshotTypeDaily}
+	for _, apply := range opts {
+		apply(&options)
+	}
+
+	if days := time.Since(from).Hours() / 24; from.IsZero() || days > 90 {
+		return nil, ErrInvalidSessionStart
+	}
+
+	return nil, nil
+}
diff --git a/internal/stats/render/common/v1/images.go b/internal/stats/render/common/v1/images.go
index 8e5d9a01..a85c20b7 100644
--- a/internal/stats/render/common/v1/images.go
+++ b/internal/stats/render/common/v1/images.go
@@ -16,13 +16,13 @@ func AddBackground(content, background image.Image, style Style) image.Image {
 	}
 
 	// Fill background with black and round the corners
-	frameCtx := gg.NewContextForImage(content)
+	frameCtx := gg.NewContext(content.Bounds().Dx(), content.Bounds().Dy())
 	if style.BackgroundColor != nil {
 		frameCtx.SetColor(style.BackgroundColor)
 		frameCtx.Clear()
 	}
-	frameCtx.DrawRoundedRectangle(0, 0, float64(frameCtx.Width()), float64(frameCtx.Height()), style.BorderRadius)
-	frameCtx.Clip()
+
+	clipRoundedRect(frameCtx, style.BorderRadius)
 
 	// Resize the background image to fit the cards
 	bgImage := imaging.Fill(background, frameCtx.Width(), frameCtx.Height(), imaging.Center, imaging.NearestNeighbor)
@@ -74,10 +74,8 @@ func renderImages(images []image.Image, style Style) (image.Image, error) {
 
 	ctx := gg.NewContext(int(math.Ceil(imageSize.width)), int(math.Ceil(imageSize.height)))
 
-	if style.BorderRadius > 0 {
-		ctx.DrawRoundedRectangle(0, 0, float64(ctx.Width()), float64(ctx.Height()), style.BorderRadius)
-		ctx.Clip()
-	}
+	clipRoundedRect(ctx, style.BorderRadius)
+
 	if style.BackgroundColor != nil {
 		ctx.DrawRectangle(0, 0, imageSize.width, imageSize.height)
 		ctx.SetColor(style.BackgroundColor)
@@ -214,3 +212,24 @@ func max(a, b float64) float64 {
 	}
 	return b
 }
+
+func clipRoundedRect(ctx *gg.Context, borderRadius float64) {
+	if borderRadius <= 0 {
+		return
+	}
+
+	width, height := float64(ctx.Width()), float64(ctx.Height())
+	// top left
+	ctx.DrawEllipticalArc(borderRadius, borderRadius, borderRadius, borderRadius, gg.Radians(270), gg.Radians(180))
+	// bottom left
+	ctx.LineTo(0, height-borderRadius)
+	ctx.DrawEllipticalArc(borderRadius, height-borderRadius, borderRadius, borderRadius, gg.Radians(180), gg.Radians(90))
+	// bottom right
+	ctx.LineTo(width-borderRadius, height)
+	ctx.DrawEllipticalArc(width-borderRadius, height-borderRadius, borderRadius, borderRadius, gg.Radians(90), gg.Radians(0))
+	// top right
+	ctx.LineTo(width, borderRadius)
+	ctx.DrawEllipticalArc(width-borderRadius, borderRadius, borderRadius, borderRadius, gg.Radians(0), gg.Radians(-90))
+	// clip final path
+	ctx.Clip()
+}
diff --git a/render_test.go b/render_test.go
index 6a0e37aa..8fdde513 100644
--- a/render_test.go
+++ b/render_test.go
@@ -6,7 +6,7 @@ import (
 	"testing"
 	"time"
 
-	stats "github.com/cufee/aftermath/internal/stats/client/v1"
+	client "github.com/cufee/aftermath/internal/stats/client/v1"
 	"github.com/cufee/aftermath/tests"
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/assert"
@@ -22,7 +22,7 @@ func TestRenderSession(t *testing.T) {
 
 	loadStaticAssets(static)
 
-	stats := stats.NewClient(tests.StaticTestingFetch(), tests.StaticTestingDatabase(), nil, language.English)
+	stats := client.NewClient(tests.StaticTestingFetch(), tests.StaticTestingDatabase(), nil, language.English)
 
 	{
 		image, _, err := stats.SessionImage(context.Background(), tests.DefaultAccountNAShort, time.Now())
@@ -37,7 +37,7 @@ func TestRenderSession(t *testing.T) {
 		assert.NoError(t, err, "failed to encode a png image")
 	}
 	{
-		image, _, err := stats.SessionImage(context.Background(), tests.DefaultAccountNA, time.Now())
+		image, _, err := stats.SessionImage(context.Background(), tests.DefaultAccountNA, time.Now(), client.WithBackgroundURL("static://bg-default"))
 		assert.NoError(t, err, "failed to render a session image")
 		assert.NotNil(t, image, "image is nil")
 

From 09c9b1a290a9a095b83291778f3dabb97124bde3 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Mon, 8 Jul 2024 11:44:33 -0400
Subject: [PATCH 317/341] added new leaderboard_scores table

---
 .../ent/migrations/20240708154415.sql         | 18 ++++++
 internal/database/ent/migrations/atlas.sum    |  3 +-
 .../database/ent/schema/leaderboard_score.go  | 42 ++++++++++++++
 internal/database/models/leaderboard_score.go | 56 +++++++++++++++++++
 4 files changed, 118 insertions(+), 1 deletion(-)
 create mode 100644 internal/database/ent/migrations/20240708154415.sql
 create mode 100644 internal/database/ent/schema/leaderboard_score.go
 create mode 100644 internal/database/models/leaderboard_score.go

diff --git a/internal/database/ent/migrations/20240708154415.sql b/internal/database/ent/migrations/20240708154415.sql
new file mode 100644
index 00000000..b3346bf7
--- /dev/null
+++ b/internal/database/ent/migrations/20240708154415.sql
@@ -0,0 +1,18 @@
+-- Create "leaderboard_scores" table
+CREATE TABLE `leaderboard_scores` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `score` real NOT NULL, `reference_id` text NOT NULL, `leaderboard_id` text NOT NULL, `meta` json NOT NULL, PRIMARY KEY (`id`));
+-- Create index "leaderboardscore_id" to table: "leaderboard_scores"
+CREATE INDEX `leaderboardscore_id` ON `leaderboard_scores` (`id`);
+-- Create index "leaderboardscore_created_at" to table: "leaderboard_scores"
+CREATE INDEX `leaderboardscore_created_at` ON `leaderboard_scores` (`created_at`);
+-- Create index "leaderboardscore_created_at_type" to table: "leaderboard_scores"
+CREATE INDEX `leaderboardscore_created_at_type` ON `leaderboard_scores` (`created_at`, `type`);
+-- Create index "leaderboardscore_score_type" to table: "leaderboard_scores"
+CREATE INDEX `leaderboardscore_score_type` ON `leaderboard_scores` (`score`, `type`);
+-- Create index "leaderboardscore_leaderboard_id_type" to table: "leaderboard_scores"
+CREATE INDEX `leaderboardscore_leaderboard_id_type` ON `leaderboard_scores` (`leaderboard_id`, `type`);
+-- Create index "leaderboardscore_leaderboard_id_score_type" to table: "leaderboard_scores"
+CREATE INDEX `leaderboardscore_leaderboard_id_score_type` ON `leaderboard_scores` (`leaderboard_id`, `score`, `type`);
+-- Create index "leaderboardscore_leaderboard_id_reference_id_type" to table: "leaderboard_scores"
+CREATE INDEX `leaderboardscore_leaderboard_id_reference_id_type` ON `leaderboard_scores` (`leaderboard_id`, `reference_id`, `type`);
+-- Create index "leaderboardscore_leaderboard_id_reference_id_score_type" to table: "leaderboard_scores"
+CREATE INDEX `leaderboardscore_leaderboard_id_reference_id_score_type` ON `leaderboard_scores` (`leaderboard_id`, `reference_id`, `score`, `type`);
diff --git a/internal/database/ent/migrations/atlas.sum b/internal/database/ent/migrations/atlas.sum
index e7b6993f..32cd7d8d 100644
--- a/internal/database/ent/migrations/atlas.sum
+++ b/internal/database/ent/migrations/atlas.sum
@@ -1,7 +1,8 @@
-h1:FmVqQkU1ia4ydQNcB3kqRiXuPqjEdvnRb+sVMIJRRPA=
+h1:RbUSxWnhyo1kiQgt6Y9HLURMb2YJ/BYgcdibq+u4MIU=
 20240627171532.sql h1:480JhjRCpyyix192z/L92yEI7LSsgJhuiK0ljat55TI=
 20240627200953.sql h1:VUQZd1HQrxITMUtNO9HRtnDE8wgtWgRyzduACb3D3u4=
 20240703151859.sql h1:1QQD7uLkRsLESNATRcGMg7k1C+sxYFQh/wI7BXrsKUA=
 20240703160454.sql h1:8KsIVNWGQGGSkh/cvdYdg1SLIRG0BqY262QOu0Icqu4=
 20240703160711.sql h1:26t/4QYITq6eAo2hif8sCLRpuHsCHXt6nyvDnX+Y1oQ=
 20240703180358.sql h1:gxgh1nrquDAOFGT7yGzgqpy5EfQ4Dvgd6c2NMPM3iIs=
+20240708154415.sql h1:csEqKf/8D88IvC1u0lgdHZDavyrlPUS8PMI8+74jIw8=
diff --git a/internal/database/ent/schema/leaderboard_score.go b/internal/database/ent/schema/leaderboard_score.go
new file mode 100644
index 00000000..58fa326d
--- /dev/null
+++ b/internal/database/ent/schema/leaderboard_score.go
@@ -0,0 +1,42 @@
+package schema
+
+import (
+	"entgo.io/ent"
+	"entgo.io/ent/schema/field"
+	"entgo.io/ent/schema/index"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+type LeaderboardScore struct {
+	ent.Schema
+}
+
+func (LeaderboardScore) Fields() []ent.Field {
+	return append(
+		defaultFields,
+		field.Enum("type").
+			GoType(models.ScoreType("")),
+		field.Float32("score"),
+		field.String("reference_id"),
+		field.Enum("leaderboard_id").
+			GoType(models.LeaderboardID("")),
+		field.JSON("meta", map[string]any{}),
+	)
+}
+
+func (LeaderboardScore) Edges() []ent.Edge {
+	return nil
+}
+
+func (LeaderboardScore) Indexes() []ent.Index {
+	return []ent.Index{
+		index.Fields("id"),
+		index.Fields("created_at"),
+		index.Fields("created_at", "type"),
+		index.Fields("score", "type"),
+		index.Fields("leaderboard_id", "type"),
+		index.Fields("leaderboard_id", "score", "type"),
+		index.Fields("leaderboard_id", "reference_id", "type"),
+		index.Fields("leaderboard_id", "reference_id", "score", "type"),
+	}
+}
diff --git a/internal/database/models/leaderboard_score.go b/internal/database/models/leaderboard_score.go
new file mode 100644
index 00000000..f99a0e67
--- /dev/null
+++ b/internal/database/models/leaderboard_score.go
@@ -0,0 +1,56 @@
+package models
+
+import (
+	"time"
+)
+
+type LeaderboardID string
+
+// Values provides list valid values for Enum.
+func (LeaderboardID) Values() []string {
+	var kinds []string
+	for _, s := range []LeaderboardID{
+		LeaderboardsMasteryWeightedPlayers,
+		LeaderboardsMasteryWeightedClans,
+	} {
+		kinds = append(kinds, string(s))
+	}
+	return kinds
+}
+
+type ScoreType string
+
+// Values provides list valid values for Enum.
+func (ScoreType) Values() []string {
+	var kinds []string
+	for _, s := range []ScoreType{
+		LeaderboardScoreCustom,
+		LeaderboardScoreHourly,
+		LeaderboardScoreDaily,
+	} {
+		kinds = append(kinds, string(s))
+	}
+	return kinds
+}
+
+const (
+	LeaderboardsMasteryWeightedPlayers LeaderboardID = "mastery-weighted-players"
+	LeaderboardsMasteryWeightedClans   LeaderboardID = "mastery-weighted-clans"
+
+	LeaderboardScoreCustom ScoreType = "custom"
+	LeaderboardScoreHourly ScoreType = "hourly"
+	LeaderboardScoreDaily  ScoreType = "daily"
+)
+
+type LeaderboardScore struct {
+	ID        string
+	CreatedAt time.Time
+	UpdatedAt time.Time
+
+	Type          ScoreType
+	ReferenceID   string
+	LeaderboardID LeaderboardID
+
+	Score float32
+	Meta  map[string]any
+}

From 89a69c20ca3b2f4444bc5c748e819570ae72e2da Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Mon, 8 Jul 2024 18:18:13 -0400
Subject: [PATCH 318/341] added leaderboards, simplified snapshot queries all
 around

---
 .github/workflows/build-packages.yml          |   3 +
 Taskfile.yaml                                 |  19 +-
 cmd/core/tasks/leaderboards.go                |  57 +-
 cmd/discord/commands/manage.go                |  34 -
 go.sum                                        |  10 +
 internal/database/client.go                   |  23 +-
 internal/database/ent/db/client.go            | 161 +++-
 internal/database/ent/db/crontask/crontask.go |   2 +-
 internal/database/ent/db/ent.go               |   2 +
 internal/database/ent/db/expose.go            |  13 +
 internal/database/ent/db/hook/hook.go         |  12 +
 internal/database/ent/db/leaderboardscore.go  | 178 +++++
 .../db/leaderboardscore/leaderboardscore.go   | 125 ++++
 .../database/ent/db/leaderboardscore/where.go | 346 +++++++++
 .../ent/db/leaderboardscore_create.go         | 326 ++++++++
 .../ent/db/leaderboardscore_delete.go         |  88 +++
 .../database/ent/db/leaderboardscore_query.go | 548 ++++++++++++++
 .../ent/db/leaderboardscore_update.go         | 439 +++++++++++
 internal/database/ent/db/migrate/schema.go    |  62 +-
 internal/database/ent/db/mutation.go          | 694 ++++++++++++++++++
 .../database/ent/db/predicate/predicate.go    |   3 +
 internal/database/ent/db/runtime.go           |  17 +
 internal/database/ent/db/tx.go                |   3 +
 internal/database/snapshots.go                | 520 +++++++++----
 internal/database/snapshots_test.go           |  10 +-
 internal/logic/snapshots.go                   |  29 +-
 internal/stats/fetch/v1/multisource.go        |  17 +-
 main.go                                       |   1 -
 tests/static_database.go                      |  18 +-
 29 files changed, 3485 insertions(+), 275 deletions(-)
 create mode 100644 internal/database/ent/db/leaderboardscore.go
 create mode 100644 internal/database/ent/db/leaderboardscore/leaderboardscore.go
 create mode 100644 internal/database/ent/db/leaderboardscore/where.go
 create mode 100644 internal/database/ent/db/leaderboardscore_create.go
 create mode 100644 internal/database/ent/db/leaderboardscore_delete.go
 create mode 100644 internal/database/ent/db/leaderboardscore_query.go
 create mode 100644 internal/database/ent/db/leaderboardscore_update.go

diff --git a/.github/workflows/build-packages.yml b/.github/workflows/build-packages.yml
index f9871d87..730ee1b3 100644
--- a/.github/workflows/build-packages.yml
+++ b/.github/workflows/build-packages.yml
@@ -88,6 +88,9 @@ jobs:
           tags: ${{ steps.meta-service.outputs.tags }}
           labels: ${{ steps.meta-service.outputs.labels }}
           file: Dockerfile
+          build-args: |
+            BRAND_FLAVOR=${{ env.BRAND_FLAVOR }}
+            GO_MEM_LIMIT=${{ env.GO_MEM_LIMIT }}
       
       # This step generates an artifact attestation for the image, which is an unforgeable statement about where and how it was built. It increases supply chain security for people who consume the image. For more information, see "[AUTOTITLE](/actions/security-guides/using-artifact-attestations-to-establish-provenance-for-builds)." 
       - name: Generate migrations artifact attestation
diff --git a/Taskfile.yaml b/Taskfile.yaml
index 394154d4..5200e7d2 100644
--- a/Taskfile.yaml
+++ b/Taskfile.yaml
@@ -3,11 +3,17 @@ version: "3"
 dotenv:
   - ".env"
 
+vars:
+  DATABASE_PATH: $DATABASE_PATH
+  DATABASE_NAME: $DATABASE_NAME
+
 tasks:
   test:
+    dotenv:
+      - ".env.test"
     desc: runs tests
     cmds:
-      - go run {{ .PRISMA_CLIENT }} db push {{ .PRISMA_SCHEMA }}
+      - task: db-migrate-apply-test
       - |
         if [ -z "{{ .CLI_ARGS }}" ]; then
           go test -timeout 30s --count=1 -v ./...
@@ -24,10 +30,17 @@ tasks:
     cmd: atlas migrate hash --dir "file://internal/database/ent/migrations" && atlas migrate diff {{.CLI_ARGS}} --dir "file://internal/database/ent/migrations" --to "ent://internal/database/ent/schema" --dev-url "sqlite://file?mode=memory&_fk=1"
   db-migrate-apply:
     desc: apply migrations using atlas
-    cmd: atlas migrate apply --allow-dirty --dir "file://internal/database/ent/migrations" --tx-mode all --url "sqlite://${DATABASE_PATH}/${DATABASE_NAME}?_fk=1"
+    cmds: 
+      # variables will be pulled from global vars declaration unless overwritten in the task call
+      - echo "Applying migrations to {{.DATABASE_PATH}}/{{.DATABASE_NAME}}"
+      - atlas migrate apply --allow-dirty --dir "file://internal/database/ent/migrations" --tx-mode all --url "sqlite://{{.DATABASE_PATH}}/{{.DATABASE_NAME}}?_fk=1"
   db-migrate-apply-test:
     desc: apply migrations to the tests database using atlas
-    cmd: atlas migrate apply --allow-dirty --dir "file://internal/database/ent/migrations" --tx-mode all --url "sqlite://${DATABASE_PATH}/tests.db?_fk=1"
+    cmds:
+      - task: db-migrate-apply
+        vars:
+          DATABASE_PATH: $DATABASE_PATH
+          DATABASE_NAME: tests.db
 
   dev:
     desc: Start a local dev server
diff --git a/cmd/core/tasks/leaderboards.go b/cmd/core/tasks/leaderboards.go
index 12c8e387..e320e5d3 100644
--- a/cmd/core/tasks/leaderboards.go
+++ b/cmd/core/tasks/leaderboards.go
@@ -4,31 +4,38 @@ import (
 	"github.com/cufee/aftermath/cmd/core"
 )
 
-// func init() {
-// 	defaultHandlers[models.TaskTypeAchievementsLeaderboardUpdate] = TaskHandler{
-// 		Process: func(ctx context.Context, client core.Client, task *models.Task) error {
-// 			forceUpdate := task.Data["force"] == "true"
-// 			realm, ok := task.Data["realm"]
-// 			if !ok {
-// 				return errors.New("invalid realm")
-// 			}
-// 			if len(task.Targets) > 100 {
-// 				return errors.New("invalid targets length")
-// 			}
-// 			if len(task.Targets) < 1 {
-// 				return errors.New("invalid targets length")
-// 			}
-
-// 			log.Debug().Str("taskId", task.ID).Any("targets", task.Targets).Msg("started working on a session refresh task")
-// 			accountErrors, err := logic.RecordAccountSnapshots(ctx, client.Wargaming(), client.Database(), realm, forceUpdate, task.Targets...)
-// 			if err != nil {
-// 				return err
-// 			}
-
-// 			return nil
-// 		},
-// 	}
-// }
+func init() {
+	// defaultHandlers[models.TaskTypeAchievementsLeaderboardUpdate] = TaskHandler{
+	// 	Process: func(ctx context.Context, client core.Client, task *models.Task) error {
+	// 		realm, ok := task.Data["realm"]
+	// 		if !ok {
+	// 			return errors.New("invalid realm")
+	// 		}
+	// 		if len(task.Targets) > 100 {
+	// 			return errors.New("invalid targets length")
+	// 		}
+	// 		if len(task.Targets) < 1 {
+	// 			return errors.New("invalid targets length")
+	// 		}
+
+	// 		ctx, cancel := context.WithCancel(ctx)
+	// 		defer cancel()
+
+	// 		lastBattles, err := client.Wargaming().BatchAccountByID(ctx, realm, task.Targets, "account_id", "last_battle_time")
+	// 		if err != nil {
+	// 			return errors.Wrap(err, "failed to get account data from wargaming")
+	// 		}
+
+	// 		client.Database().GetAchievementsSnapshots(ctx, )
+
+	// 		// calculate the current score for each player
+
+	// 		// save scores to database
+
+	// 		return nil
+	// 	},
+	// }
+}
 
 func CreateUpdateLeaderboardsTasks(client core.Client, realm string) error {
 	//
diff --git a/cmd/discord/commands/manage.go b/cmd/discord/commands/manage.go
index dff707d1..a66acf71 100644
--- a/cmd/discord/commands/manage.go
+++ b/cmd/discord/commands/manage.go
@@ -43,11 +43,6 @@ func init() {
 						builder.NewOption("id", discordgo.ApplicationCommandOptionString).Required(),
 					),
 				),
-				builder.NewOption("snapshots", discordgo.ApplicationCommandOptionSubCommandGroup).Options(
-					builder.NewOption("view", discordgo.ApplicationCommandOptionSubCommand).Options(
-						builder.NewOption("account_id", discordgo.ApplicationCommandOptionString).Required(),
-					),
-				),
 			).
 			Handler(func(ctx *common.Context) error {
 				command, opts, _ := ctx.Options().Subcommand()
@@ -79,35 +74,6 @@ func init() {
 					}
 					return ctx.Reply().Send("```" + string(data) + "```")
 
-				case "snapshots_view":
-					accountId, ok := opts.Value("account_id").(string)
-					if !ok {
-						return ctx.Reply().Send("invalid accountId, failed to cast to string")
-					}
-					snapshots, err := ctx.Core.Database().GetLastAccountSnapshots(ctx.Context, accountId, 3)
-					if err != nil {
-						return ctx.Reply().Send("GetLastAccountSnapshots: " + err.Error())
-					}
-
-					var data []map[string]string
-					for _, snapshot := range snapshots {
-						data = append(data, map[string]string{
-							"id":             snapshot.ID,
-							"type":           string(snapshot.Type),
-							"referenceId":    snapshot.ReferenceID,
-							"createdAt":      snapshot.CreatedAt.String(),
-							"lastBattleTime": snapshot.LastBattleTime.String(),
-							"battlesRating":  snapshot.RatingBattles.Battles.String(),
-							"battlesRegular": snapshot.RegularBattles.Battles.String(),
-						})
-					}
-
-					bytes, err := json.MarshalIndent(data, "", "  ")
-					if err != nil {
-						return ctx.Reply().Send("json.Marshal: " + err.Error())
-					}
-					return ctx.Reply().Send("```" + string(bytes) + "```")
-
 				case "tasks_view":
 					if !ctx.User.HasPermission(permissions.ViewTaskLogs) {
 						ctx.Reply().Send("You do not have access to this sub-command.")
diff --git a/go.sum b/go.sum
index 5ad9e250..959271d5 100644
--- a/go.sum
+++ b/go.sum
@@ -66,12 +66,16 @@ github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/
 github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
+github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/mattn/go-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o4kU=
 github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
 github.com/mitchellh/go-wordwrap v1.0.1 h1:TLuKupo69TCn6TQSyGxwI1EblZZEsQ0vMlAFQflz0v0=
 github.com/mitchellh/go-wordwrap v1.0.1/go.mod h1:R62XHJLzvMFRBbcrT7m7WgmE1eOyTSsCt+hzestvNj0=
 github.com/nlpodyssey/gopickle v0.3.0 h1:BLUE5gxFLyyNOPzlXxt6GoHEMMxD0qhsE4p0CIQyoLw=
 github.com/nlpodyssey/gopickle v0.3.0/go.mod h1:f070HJ/yR+eLi5WmM1OXJEGaTpuJEUiib19olXgYha0=
+github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
+github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
 github.com/pierrec/lz4/v4 v4.1.21 h1:yOVMLb6qSIDP67pl/5F7RepeKYu/VmTyEXvuMI5d9mQ=
 github.com/pierrec/lz4/v4 v4.1.21/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
@@ -79,6 +83,8 @@ github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
+github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
 github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=
 github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
@@ -87,6 +93,10 @@ github.com/rogpeppe/go-internal v1.8.1/go.mod h1:JeRgkft04UBgHMgCIwADu4Pn6Mtm5d4
 github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
 github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8=
 github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
+github.com/spf13/cobra v1.7.0 h1:hyqWnYt1ZQShIddO5kBpj3vu05/++x6tJ6dg8EC572I=
+github.com/spf13/cobra v1.7.0/go.mod h1:uLxZILRyS/50WlhOIKD7W6V5bgeIt+4sICxh6uRMrb0=
+github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
diff --git a/internal/database/client.go b/internal/database/client.go
index 8f014b01..25440d87 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -55,16 +55,17 @@ type UsersClient interface {
 }
 
 type SnapshotsClient interface {
-	GetAccountSnapshot(ctx context.Context, accountID, referenceID string, kind models.SnapshotType, options ...SnapshotQuery) (models.AccountSnapshot, error)
-	CreateAccountSnapshots(ctx context.Context, snapshots ...models.AccountSnapshot) (map[string]error, error)
-	GetLastAccountSnapshots(ctx context.Context, accountID string, limit int) ([]models.AccountSnapshot, error)
-	GetManyAccountSnapshots(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.AccountSnapshot, error)
+	GetAccountSnapshots(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.AccountSnapshot, error)
+	GetAchievementSnapshots(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.AchievementsSnapshot, error)
+	GetVehicleSnapshots(ctx context.Context, accountID string, vehicleIDs []string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.VehicleSnapshot, error)
 
-	GetVehicleSnapshots(ctx context.Context, accountID, referenceID string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.VehicleSnapshot, error)
-	CreateAccountVehicleSnapshots(ctx context.Context, accountID string, snapshots ...models.VehicleSnapshot) (map[string]error, error)
+	GetAccountLastBattleTimes(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...SnapshotQuery) (map[string]time.Time, error)
+	GetVehicleLastBattleTimes(ctx context.Context, accountID string, vehicleIDs []string, kind models.SnapshotType, options ...SnapshotQuery) (map[string]time.Time, error)
+	// last battle times for achievements would be equivalent to account/vehicle ones
 
+	CreateAccountSnapshots(ctx context.Context, snapshots ...models.AccountSnapshot) (map[string]error, error)
+	CreateAccountVehicleSnapshots(ctx context.Context, accountID string, snapshots ...models.VehicleSnapshot) (map[string]error, error)
 	CreateAccountAchievementSnapshots(ctx context.Context, accountID string, snapshots ...models.AchievementsSnapshot) (map[string]error, error)
-	GetAchievementsSnapshots(ctx context.Context, accountID string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.AchievementsSnapshot, error)
 
 	DeleteExpiredSnapshots(ctx context.Context, expiration time.Time) error
 }
@@ -191,3 +192,11 @@ func NewSQLiteClient(filePath string, options ...ClientOption) (*client, error)
 		db:        c,
 	}, nil
 }
+
+func toAnySlice[T any](s ...T) []any {
+	var a []any
+	for _, i := range s {
+		a = append(a, i)
+	}
+	return a
+}
diff --git a/internal/database/ent/db/client.go b/internal/database/ent/db/client.go
index f179636d..67301ef3 100644
--- a/internal/database/ent/db/client.go
+++ b/internal/database/ent/db/client.go
@@ -24,6 +24,7 @@ import (
 	"github.com/cufee/aftermath/internal/database/ent/db/clan"
 	"github.com/cufee/aftermath/internal/database/ent/db/crontask"
 	"github.com/cufee/aftermath/internal/database/ent/db/discordinteraction"
+	"github.com/cufee/aftermath/internal/database/ent/db/leaderboardscore"
 	"github.com/cufee/aftermath/internal/database/ent/db/session"
 	"github.com/cufee/aftermath/internal/database/ent/db/user"
 	"github.com/cufee/aftermath/internal/database/ent/db/userconnection"
@@ -59,6 +60,8 @@ type Client struct {
 	CronTask *CronTaskClient
 	// DiscordInteraction is the client for interacting with the DiscordInteraction builders.
 	DiscordInteraction *DiscordInteractionClient
+	// LeaderboardScore is the client for interacting with the LeaderboardScore builders.
+	LeaderboardScore *LeaderboardScoreClient
 	// Session is the client for interacting with the Session builders.
 	Session *SessionClient
 	// User is the client for interacting with the User builders.
@@ -95,6 +98,7 @@ func (c *Client) init() {
 	c.Clan = NewClanClient(c.config)
 	c.CronTask = NewCronTaskClient(c.config)
 	c.DiscordInteraction = NewDiscordInteractionClient(c.config)
+	c.LeaderboardScore = NewLeaderboardScoreClient(c.config)
 	c.Session = NewSessionClient(c.config)
 	c.User = NewUserClient(c.config)
 	c.UserConnection = NewUserConnectionClient(c.config)
@@ -204,6 +208,7 @@ func (c *Client) Tx(ctx context.Context) (*Tx, error) {
 		Clan:                 NewClanClient(cfg),
 		CronTask:             NewCronTaskClient(cfg),
 		DiscordInteraction:   NewDiscordInteractionClient(cfg),
+		LeaderboardScore:     NewLeaderboardScoreClient(cfg),
 		Session:              NewSessionClient(cfg),
 		User:                 NewUserClient(cfg),
 		UserConnection:       NewUserConnectionClient(cfg),
@@ -240,6 +245,7 @@ func (c *Client) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error)
 		Clan:                 NewClanClient(cfg),
 		CronTask:             NewCronTaskClient(cfg),
 		DiscordInteraction:   NewDiscordInteractionClient(cfg),
+		LeaderboardScore:     NewLeaderboardScoreClient(cfg),
 		Session:              NewSessionClient(cfg),
 		User:                 NewUserClient(cfg),
 		UserConnection:       NewUserConnectionClient(cfg),
@@ -279,8 +285,8 @@ func (c *Client) Use(hooks ...Hook) {
 	for _, n := range []interface{ Use(...Hook) }{
 		c.Account, c.AccountSnapshot, c.AchievementsSnapshot, c.AppConfiguration,
 		c.ApplicationCommand, c.AuthNonce, c.Clan, c.CronTask, c.DiscordInteraction,
-		c.Session, c.User, c.UserConnection, c.UserContent, c.UserSubscription,
-		c.Vehicle, c.VehicleAverage, c.VehicleSnapshot,
+		c.LeaderboardScore, c.Session, c.User, c.UserConnection, c.UserContent,
+		c.UserSubscription, c.Vehicle, c.VehicleAverage, c.VehicleSnapshot,
 	} {
 		n.Use(hooks...)
 	}
@@ -292,8 +298,8 @@ func (c *Client) Intercept(interceptors ...Interceptor) {
 	for _, n := range []interface{ Intercept(...Interceptor) }{
 		c.Account, c.AccountSnapshot, c.AchievementsSnapshot, c.AppConfiguration,
 		c.ApplicationCommand, c.AuthNonce, c.Clan, c.CronTask, c.DiscordInteraction,
-		c.Session, c.User, c.UserConnection, c.UserContent, c.UserSubscription,
-		c.Vehicle, c.VehicleAverage, c.VehicleSnapshot,
+		c.LeaderboardScore, c.Session, c.User, c.UserConnection, c.UserContent,
+		c.UserSubscription, c.Vehicle, c.VehicleAverage, c.VehicleSnapshot,
 	} {
 		n.Intercept(interceptors...)
 	}
@@ -320,6 +326,8 @@ func (c *Client) Mutate(ctx context.Context, m Mutation) (Value, error) {
 		return c.CronTask.mutate(ctx, m)
 	case *DiscordInteractionMutation:
 		return c.DiscordInteraction.mutate(ctx, m)
+	case *LeaderboardScoreMutation:
+		return c.LeaderboardScore.mutate(ctx, m)
 	case *SessionMutation:
 		return c.Session.mutate(ctx, m)
 	case *UserMutation:
@@ -1666,6 +1674,139 @@ func (c *DiscordInteractionClient) mutate(ctx context.Context, m *DiscordInterac
 	}
 }
 
+// LeaderboardScoreClient is a client for the LeaderboardScore schema.
+type LeaderboardScoreClient struct {
+	config
+}
+
+// NewLeaderboardScoreClient returns a client for the LeaderboardScore from the given config.
+func NewLeaderboardScoreClient(c config) *LeaderboardScoreClient {
+	return &LeaderboardScoreClient{config: c}
+}
+
+// Use adds a list of mutation hooks to the hooks stack.
+// A call to `Use(f, g, h)` equals to `leaderboardscore.Hooks(f(g(h())))`.
+func (c *LeaderboardScoreClient) Use(hooks ...Hook) {
+	c.hooks.LeaderboardScore = append(c.hooks.LeaderboardScore, hooks...)
+}
+
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `leaderboardscore.Intercept(f(g(h())))`.
+func (c *LeaderboardScoreClient) Intercept(interceptors ...Interceptor) {
+	c.inters.LeaderboardScore = append(c.inters.LeaderboardScore, interceptors...)
+}
+
+// Create returns a builder for creating a LeaderboardScore entity.
+func (c *LeaderboardScoreClient) Create() *LeaderboardScoreCreate {
+	mutation := newLeaderboardScoreMutation(c.config, OpCreate)
+	return &LeaderboardScoreCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// CreateBulk returns a builder for creating a bulk of LeaderboardScore entities.
+func (c *LeaderboardScoreClient) CreateBulk(builders ...*LeaderboardScoreCreate) *LeaderboardScoreCreateBulk {
+	return &LeaderboardScoreCreateBulk{config: c.config, builders: builders}
+}
+
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *LeaderboardScoreClient) MapCreateBulk(slice any, setFunc func(*LeaderboardScoreCreate, int)) *LeaderboardScoreCreateBulk {
+	rv := reflect.ValueOf(slice)
+	if rv.Kind() != reflect.Slice {
+		return &LeaderboardScoreCreateBulk{err: fmt.Errorf("calling to LeaderboardScoreClient.MapCreateBulk with wrong type %T, need slice", slice)}
+	}
+	builders := make([]*LeaderboardScoreCreate, rv.Len())
+	for i := 0; i < rv.Len(); i++ {
+		builders[i] = c.Create()
+		setFunc(builders[i], i)
+	}
+	return &LeaderboardScoreCreateBulk{config: c.config, builders: builders}
+}
+
+// Update returns an update builder for LeaderboardScore.
+func (c *LeaderboardScoreClient) Update() *LeaderboardScoreUpdate {
+	mutation := newLeaderboardScoreMutation(c.config, OpUpdate)
+	return &LeaderboardScoreUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOne returns an update builder for the given entity.
+func (c *LeaderboardScoreClient) UpdateOne(ls *LeaderboardScore) *LeaderboardScoreUpdateOne {
+	mutation := newLeaderboardScoreMutation(c.config, OpUpdateOne, withLeaderboardScore(ls))
+	return &LeaderboardScoreUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOneID returns an update builder for the given id.
+func (c *LeaderboardScoreClient) UpdateOneID(id string) *LeaderboardScoreUpdateOne {
+	mutation := newLeaderboardScoreMutation(c.config, OpUpdateOne, withLeaderboardScoreID(id))
+	return &LeaderboardScoreUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// Delete returns a delete builder for LeaderboardScore.
+func (c *LeaderboardScoreClient) Delete() *LeaderboardScoreDelete {
+	mutation := newLeaderboardScoreMutation(c.config, OpDelete)
+	return &LeaderboardScoreDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// DeleteOne returns a builder for deleting the given entity.
+func (c *LeaderboardScoreClient) DeleteOne(ls *LeaderboardScore) *LeaderboardScoreDeleteOne {
+	return c.DeleteOneID(ls.ID)
+}
+
+// DeleteOneID returns a builder for deleting the given entity by its id.
+func (c *LeaderboardScoreClient) DeleteOneID(id string) *LeaderboardScoreDeleteOne {
+	builder := c.Delete().Where(leaderboardscore.ID(id))
+	builder.mutation.id = &id
+	builder.mutation.op = OpDeleteOne
+	return &LeaderboardScoreDeleteOne{builder}
+}
+
+// Query returns a query builder for LeaderboardScore.
+func (c *LeaderboardScoreClient) Query() *LeaderboardScoreQuery {
+	return &LeaderboardScoreQuery{
+		config: c.config,
+		ctx:    &QueryContext{Type: TypeLeaderboardScore},
+		inters: c.Interceptors(),
+	}
+}
+
+// Get returns a LeaderboardScore entity by its id.
+func (c *LeaderboardScoreClient) Get(ctx context.Context, id string) (*LeaderboardScore, error) {
+	return c.Query().Where(leaderboardscore.ID(id)).Only(ctx)
+}
+
+// GetX is like Get, but panics if an error occurs.
+func (c *LeaderboardScoreClient) GetX(ctx context.Context, id string) *LeaderboardScore {
+	obj, err := c.Get(ctx, id)
+	if err != nil {
+		panic(err)
+	}
+	return obj
+}
+
+// Hooks returns the client hooks.
+func (c *LeaderboardScoreClient) Hooks() []Hook {
+	return c.hooks.LeaderboardScore
+}
+
+// Interceptors returns the client interceptors.
+func (c *LeaderboardScoreClient) Interceptors() []Interceptor {
+	return c.inters.LeaderboardScore
+}
+
+func (c *LeaderboardScoreClient) mutate(ctx context.Context, m *LeaderboardScoreMutation) (Value, error) {
+	switch m.Op() {
+	case OpCreate:
+		return (&LeaderboardScoreCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdate:
+		return (&LeaderboardScoreUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdateOne:
+		return (&LeaderboardScoreUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpDelete, OpDeleteOne:
+		return (&LeaderboardScoreDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+	default:
+		return nil, fmt.Errorf("db: unknown LeaderboardScore mutation op: %q", m.Op())
+	}
+}
+
 // SessionClient is a client for the Session schema.
 type SessionClient struct {
 	config
@@ -2894,15 +3035,15 @@ func (c *VehicleSnapshotClient) mutate(ctx context.Context, m *VehicleSnapshotMu
 type (
 	hooks struct {
 		Account, AccountSnapshot, AchievementsSnapshot, AppConfiguration,
-		ApplicationCommand, AuthNonce, Clan, CronTask, DiscordInteraction, Session,
-		User, UserConnection, UserContent, UserSubscription, Vehicle, VehicleAverage,
-		VehicleSnapshot []ent.Hook
+		ApplicationCommand, AuthNonce, Clan, CronTask, DiscordInteraction,
+		LeaderboardScore, Session, User, UserConnection, UserContent, UserSubscription,
+		Vehicle, VehicleAverage, VehicleSnapshot []ent.Hook
 	}
 	inters struct {
 		Account, AccountSnapshot, AchievementsSnapshot, AppConfiguration,
-		ApplicationCommand, AuthNonce, Clan, CronTask, DiscordInteraction, Session,
-		User, UserConnection, UserContent, UserSubscription, Vehicle, VehicleAverage,
-		VehicleSnapshot []ent.Interceptor
+		ApplicationCommand, AuthNonce, Clan, CronTask, DiscordInteraction,
+		LeaderboardScore, Session, User, UserConnection, UserContent, UserSubscription,
+		Vehicle, VehicleAverage, VehicleSnapshot []ent.Interceptor
 	}
 )
 
diff --git a/internal/database/ent/db/crontask/crontask.go b/internal/database/ent/db/crontask/crontask.go
index 7c6b7ab4..c15458d3 100644
--- a/internal/database/ent/db/crontask/crontask.go
+++ b/internal/database/ent/db/crontask/crontask.go
@@ -85,7 +85,7 @@ var (
 // TypeValidator is a validator for the "type" field enum values. It is called by the builders before save.
 func TypeValidator(_type models.TaskType) error {
 	switch _type {
-	case "UPDATE_CLANS", "RECORD_SNAPSHOTS", "CLEANUP_DATABASE":
+	case "UPDATE_CLANS", "RECORD_SNAPSHOTS", "ACHIEVEMENT_LEADERBOARDS", "CLEANUP_DATABASE":
 		return nil
 	default:
 		return fmt.Errorf("crontask: invalid enum value for type field: %q", _type)
diff --git a/internal/database/ent/db/ent.go b/internal/database/ent/db/ent.go
index 8bae5108..3701a22a 100644
--- a/internal/database/ent/db/ent.go
+++ b/internal/database/ent/db/ent.go
@@ -21,6 +21,7 @@ import (
 	"github.com/cufee/aftermath/internal/database/ent/db/clan"
 	"github.com/cufee/aftermath/internal/database/ent/db/crontask"
 	"github.com/cufee/aftermath/internal/database/ent/db/discordinteraction"
+	"github.com/cufee/aftermath/internal/database/ent/db/leaderboardscore"
 	"github.com/cufee/aftermath/internal/database/ent/db/session"
 	"github.com/cufee/aftermath/internal/database/ent/db/user"
 	"github.com/cufee/aftermath/internal/database/ent/db/userconnection"
@@ -98,6 +99,7 @@ func checkColumn(table, column string) error {
 			clan.Table:                 clan.ValidColumn,
 			crontask.Table:             crontask.ValidColumn,
 			discordinteraction.Table:   discordinteraction.ValidColumn,
+			leaderboardscore.Table:     leaderboardscore.ValidColumn,
 			session.Table:              session.ValidColumn,
 			user.Table:                 user.ValidColumn,
 			userconnection.Table:       userconnection.ValidColumn,
diff --git a/internal/database/ent/db/expose.go b/internal/database/ent/db/expose.go
index cffec5a4..a0d836f3 100644
--- a/internal/database/ent/db/expose.go
+++ b/internal/database/ent/db/expose.go
@@ -121,6 +121,19 @@ func (di *DiscordInteraction) ScanValues(columns []string) ([]any, error) {
 	return di.scanValues(columns)
 }
 
+func (ls *LeaderboardScore) AssignValues(columns []string, values []any) error {
+	if ls == nil {
+		return fmt.Errorf("LeaderboardScore(nil)")
+	}
+	return ls.assignValues(columns, values)
+}
+func (ls *LeaderboardScore) ScanValues(columns []string) ([]any, error) {
+	if ls == nil {
+		return nil, fmt.Errorf("LeaderboardScore(nil)")
+	}
+	return ls.scanValues(columns)
+}
+
 func (s *Session) AssignValues(columns []string, values []any) error {
 	if s == nil {
 		return fmt.Errorf("Session(nil)")
diff --git a/internal/database/ent/db/hook/hook.go b/internal/database/ent/db/hook/hook.go
index ab57723e..baaa0ac8 100644
--- a/internal/database/ent/db/hook/hook.go
+++ b/internal/database/ent/db/hook/hook.go
@@ -117,6 +117,18 @@ func (f DiscordInteractionFunc) Mutate(ctx context.Context, m db.Mutation) (db.V
 	return nil, fmt.Errorf("unexpected mutation type %T. expect *db.DiscordInteractionMutation", m)
 }
 
+// The LeaderboardScoreFunc type is an adapter to allow the use of ordinary
+// function as LeaderboardScore mutator.
+type LeaderboardScoreFunc func(context.Context, *db.LeaderboardScoreMutation) (db.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f LeaderboardScoreFunc) Mutate(ctx context.Context, m db.Mutation) (db.Value, error) {
+	if mv, ok := m.(*db.LeaderboardScoreMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *db.LeaderboardScoreMutation", m)
+}
+
 // The SessionFunc type is an adapter to allow the use of ordinary
 // function as Session mutator.
 type SessionFunc func(context.Context, *db.SessionMutation) (db.Value, error)
diff --git a/internal/database/ent/db/leaderboardscore.go b/internal/database/ent/db/leaderboardscore.go
new file mode 100644
index 00000000..93fab4ec
--- /dev/null
+++ b/internal/database/ent/db/leaderboardscore.go
@@ -0,0 +1,178 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+	"time"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+	"github.com/cufee/aftermath/internal/database/ent/db/leaderboardscore"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+// LeaderboardScore is the model entity for the LeaderboardScore schema.
+type LeaderboardScore struct {
+	config `json:"-"`
+	// ID of the ent.
+	ID string `json:"id,omitempty"`
+	// CreatedAt holds the value of the "created_at" field.
+	CreatedAt time.Time `json:"created_at,omitempty"`
+	// UpdatedAt holds the value of the "updated_at" field.
+	UpdatedAt time.Time `json:"updated_at,omitempty"`
+	// Type holds the value of the "type" field.
+	Type models.ScoreType `json:"type,omitempty"`
+	// Score holds the value of the "score" field.
+	Score float32 `json:"score,omitempty"`
+	// ReferenceID holds the value of the "reference_id" field.
+	ReferenceID string `json:"reference_id,omitempty"`
+	// LeaderboardID holds the value of the "leaderboard_id" field.
+	LeaderboardID models.LeaderboardID `json:"leaderboard_id,omitempty"`
+	// Meta holds the value of the "meta" field.
+	Meta         map[string]interface{} `json:"meta,omitempty"`
+	selectValues sql.SelectValues
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*LeaderboardScore) scanValues(columns []string) ([]any, error) {
+	values := make([]any, len(columns))
+	for i := range columns {
+		switch columns[i] {
+		case leaderboardscore.FieldMeta:
+			values[i] = new([]byte)
+		case leaderboardscore.FieldScore:
+			values[i] = new(sql.NullFloat64)
+		case leaderboardscore.FieldID, leaderboardscore.FieldType, leaderboardscore.FieldReferenceID, leaderboardscore.FieldLeaderboardID:
+			values[i] = new(sql.NullString)
+		case leaderboardscore.FieldCreatedAt, leaderboardscore.FieldUpdatedAt:
+			values[i] = new(sql.NullTime)
+		default:
+			values[i] = new(sql.UnknownType)
+		}
+	}
+	return values, nil
+}
+
+// assignValues assigns the values that were returned from sql.Rows (after scanning)
+// to the LeaderboardScore fields.
+func (ls *LeaderboardScore) assignValues(columns []string, values []any) error {
+	if m, n := len(values), len(columns); m < n {
+		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
+	}
+	for i := range columns {
+		switch columns[i] {
+		case leaderboardscore.FieldID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field id", values[i])
+			} else if value.Valid {
+				ls.ID = value.String
+			}
+		case leaderboardscore.FieldCreatedAt:
+			if value, ok := values[i].(*sql.NullTime); !ok {
+				return fmt.Errorf("unexpected type %T for field created_at", values[i])
+			} else if value.Valid {
+				ls.CreatedAt = value.Time
+			}
+		case leaderboardscore.FieldUpdatedAt:
+			if value, ok := values[i].(*sql.NullTime); !ok {
+				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
+			} else if value.Valid {
+				ls.UpdatedAt = value.Time
+			}
+		case leaderboardscore.FieldType:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field type", values[i])
+			} else if value.Valid {
+				ls.Type = models.ScoreType(value.String)
+			}
+		case leaderboardscore.FieldScore:
+			if value, ok := values[i].(*sql.NullFloat64); !ok {
+				return fmt.Errorf("unexpected type %T for field score", values[i])
+			} else if value.Valid {
+				ls.Score = float32(value.Float64)
+			}
+		case leaderboardscore.FieldReferenceID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field reference_id", values[i])
+			} else if value.Valid {
+				ls.ReferenceID = value.String
+			}
+		case leaderboardscore.FieldLeaderboardID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field leaderboard_id", values[i])
+			} else if value.Valid {
+				ls.LeaderboardID = models.LeaderboardID(value.String)
+			}
+		case leaderboardscore.FieldMeta:
+			if value, ok := values[i].(*[]byte); !ok {
+				return fmt.Errorf("unexpected type %T for field meta", values[i])
+			} else if value != nil && len(*value) > 0 {
+				if err := json.Unmarshal(*value, &ls.Meta); err != nil {
+					return fmt.Errorf("unmarshal field meta: %w", err)
+				}
+			}
+		default:
+			ls.selectValues.Set(columns[i], values[i])
+		}
+	}
+	return nil
+}
+
+// Value returns the ent.Value that was dynamically selected and assigned to the LeaderboardScore.
+// This includes values selected through modifiers, order, etc.
+func (ls *LeaderboardScore) Value(name string) (ent.Value, error) {
+	return ls.selectValues.Get(name)
+}
+
+// Update returns a builder for updating this LeaderboardScore.
+// Note that you need to call LeaderboardScore.Unwrap() before calling this method if this LeaderboardScore
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (ls *LeaderboardScore) Update() *LeaderboardScoreUpdateOne {
+	return NewLeaderboardScoreClient(ls.config).UpdateOne(ls)
+}
+
+// Unwrap unwraps the LeaderboardScore entity that was returned from a transaction after it was closed,
+// so that all future queries will be executed through the driver which created the transaction.
+func (ls *LeaderboardScore) Unwrap() *LeaderboardScore {
+	_tx, ok := ls.config.driver.(*txDriver)
+	if !ok {
+		panic("db: LeaderboardScore is not a transactional entity")
+	}
+	ls.config.driver = _tx.drv
+	return ls
+}
+
+// String implements the fmt.Stringer.
+func (ls *LeaderboardScore) String() string {
+	var builder strings.Builder
+	builder.WriteString("LeaderboardScore(")
+	builder.WriteString(fmt.Sprintf("id=%v, ", ls.ID))
+	builder.WriteString("created_at=")
+	builder.WriteString(ls.CreatedAt.Format(time.ANSIC))
+	builder.WriteString(", ")
+	builder.WriteString("updated_at=")
+	builder.WriteString(ls.UpdatedAt.Format(time.ANSIC))
+	builder.WriteString(", ")
+	builder.WriteString("type=")
+	builder.WriteString(fmt.Sprintf("%v", ls.Type))
+	builder.WriteString(", ")
+	builder.WriteString("score=")
+	builder.WriteString(fmt.Sprintf("%v", ls.Score))
+	builder.WriteString(", ")
+	builder.WriteString("reference_id=")
+	builder.WriteString(ls.ReferenceID)
+	builder.WriteString(", ")
+	builder.WriteString("leaderboard_id=")
+	builder.WriteString(fmt.Sprintf("%v", ls.LeaderboardID))
+	builder.WriteString(", ")
+	builder.WriteString("meta=")
+	builder.WriteString(fmt.Sprintf("%v", ls.Meta))
+	builder.WriteByte(')')
+	return builder.String()
+}
+
+// LeaderboardScores is a parsable slice of LeaderboardScore.
+type LeaderboardScores []*LeaderboardScore
diff --git a/internal/database/ent/db/leaderboardscore/leaderboardscore.go b/internal/database/ent/db/leaderboardscore/leaderboardscore.go
new file mode 100644
index 00000000..7ed97521
--- /dev/null
+++ b/internal/database/ent/db/leaderboardscore/leaderboardscore.go
@@ -0,0 +1,125 @@
+// Code generated by ent, DO NOT EDIT.
+
+package leaderboardscore
+
+import (
+	"fmt"
+	"time"
+
+	"entgo.io/ent/dialect/sql"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+const (
+	// Label holds the string label denoting the leaderboardscore type in the database.
+	Label = "leaderboard_score"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// FieldType holds the string denoting the type field in the database.
+	FieldType = "type"
+	// FieldScore holds the string denoting the score field in the database.
+	FieldScore = "score"
+	// FieldReferenceID holds the string denoting the reference_id field in the database.
+	FieldReferenceID = "reference_id"
+	// FieldLeaderboardID holds the string denoting the leaderboard_id field in the database.
+	FieldLeaderboardID = "leaderboard_id"
+	// FieldMeta holds the string denoting the meta field in the database.
+	FieldMeta = "meta"
+	// Table holds the table name of the leaderboardscore in the database.
+	Table = "leaderboard_scores"
+)
+
+// Columns holds all SQL columns for leaderboardscore fields.
+var Columns = []string{
+	FieldID,
+	FieldCreatedAt,
+	FieldUpdatedAt,
+	FieldType,
+	FieldScore,
+	FieldReferenceID,
+	FieldLeaderboardID,
+	FieldMeta,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() time.Time
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() time.Time
+	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
+	UpdateDefaultUpdatedAt func() time.Time
+	// DefaultID holds the default value on creation for the "id" field.
+	DefaultID func() string
+)
+
+// TypeValidator is a validator for the "type" field enum values. It is called by the builders before save.
+func TypeValidator(_type models.ScoreType) error {
+	switch _type {
+	case "custom", "hourly", "daily":
+		return nil
+	default:
+		return fmt.Errorf("leaderboardscore: invalid enum value for type field: %q", _type)
+	}
+}
+
+// LeaderboardIDValidator is a validator for the "leaderboard_id" field enum values. It is called by the builders before save.
+func LeaderboardIDValidator(li models.LeaderboardID) error {
+	switch li {
+	case "mastery-weighted-players", "mastery-weighted-clans":
+		return nil
+	default:
+		return fmt.Errorf("leaderboardscore: invalid enum value for leaderboard_id field: %q", li)
+	}
+}
+
+// OrderOption defines the ordering options for the LeaderboardScore queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByType orders the results by the type field.
+func ByType(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldType, opts...).ToFunc()
+}
+
+// ByScore orders the results by the score field.
+func ByScore(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldScore, opts...).ToFunc()
+}
+
+// ByReferenceID orders the results by the reference_id field.
+func ByReferenceID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldReferenceID, opts...).ToFunc()
+}
+
+// ByLeaderboardID orders the results by the leaderboard_id field.
+func ByLeaderboardID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldLeaderboardID, opts...).ToFunc()
+}
diff --git a/internal/database/ent/db/leaderboardscore/where.go b/internal/database/ent/db/leaderboardscore/where.go
new file mode 100644
index 00000000..25877ee2
--- /dev/null
+++ b/internal/database/ent/db/leaderboardscore/where.go
@@ -0,0 +1,346 @@
+// Code generated by ent, DO NOT EDIT.
+
+package leaderboardscore
+
+import (
+	"time"
+
+	"entgo.io/ent/dialect/sql"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldLTE(FieldID, id))
+}
+
+// IDEqualFold applies the EqualFold predicate on the ID field.
+func IDEqualFold(id string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldEqualFold(FieldID, id))
+}
+
+// IDContainsFold applies the ContainsFold predicate on the ID field.
+func IDContainsFold(id string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldContainsFold(FieldID, id))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v time.Time) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v time.Time) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// Score applies equality check predicate on the "score" field. It's identical to ScoreEQ.
+func Score(v float32) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldEQ(FieldScore, v))
+}
+
+// ReferenceID applies equality check predicate on the "reference_id" field. It's identical to ReferenceIDEQ.
+func ReferenceID(v string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldEQ(FieldReferenceID, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v time.Time) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v time.Time) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...time.Time) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...time.Time) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v time.Time) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v time.Time) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v time.Time) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v time.Time) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v time.Time) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v time.Time) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...time.Time) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...time.Time) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v time.Time) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v time.Time) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v time.Time) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v time.Time) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// TypeEQ applies the EQ predicate on the "type" field.
+func TypeEQ(v models.ScoreType) predicate.LeaderboardScore {
+	vc := v
+	return predicate.LeaderboardScore(sql.FieldEQ(FieldType, vc))
+}
+
+// TypeNEQ applies the NEQ predicate on the "type" field.
+func TypeNEQ(v models.ScoreType) predicate.LeaderboardScore {
+	vc := v
+	return predicate.LeaderboardScore(sql.FieldNEQ(FieldType, vc))
+}
+
+// TypeIn applies the In predicate on the "type" field.
+func TypeIn(vs ...models.ScoreType) predicate.LeaderboardScore {
+	v := make([]any, len(vs))
+	for i := range v {
+		v[i] = vs[i]
+	}
+	return predicate.LeaderboardScore(sql.FieldIn(FieldType, v...))
+}
+
+// TypeNotIn applies the NotIn predicate on the "type" field.
+func TypeNotIn(vs ...models.ScoreType) predicate.LeaderboardScore {
+	v := make([]any, len(vs))
+	for i := range v {
+		v[i] = vs[i]
+	}
+	return predicate.LeaderboardScore(sql.FieldNotIn(FieldType, v...))
+}
+
+// ScoreEQ applies the EQ predicate on the "score" field.
+func ScoreEQ(v float32) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldEQ(FieldScore, v))
+}
+
+// ScoreNEQ applies the NEQ predicate on the "score" field.
+func ScoreNEQ(v float32) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldNEQ(FieldScore, v))
+}
+
+// ScoreIn applies the In predicate on the "score" field.
+func ScoreIn(vs ...float32) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldIn(FieldScore, vs...))
+}
+
+// ScoreNotIn applies the NotIn predicate on the "score" field.
+func ScoreNotIn(vs ...float32) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldNotIn(FieldScore, vs...))
+}
+
+// ScoreGT applies the GT predicate on the "score" field.
+func ScoreGT(v float32) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldGT(FieldScore, v))
+}
+
+// ScoreGTE applies the GTE predicate on the "score" field.
+func ScoreGTE(v float32) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldGTE(FieldScore, v))
+}
+
+// ScoreLT applies the LT predicate on the "score" field.
+func ScoreLT(v float32) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldLT(FieldScore, v))
+}
+
+// ScoreLTE applies the LTE predicate on the "score" field.
+func ScoreLTE(v float32) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldLTE(FieldScore, v))
+}
+
+// ReferenceIDEQ applies the EQ predicate on the "reference_id" field.
+func ReferenceIDEQ(v string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldEQ(FieldReferenceID, v))
+}
+
+// ReferenceIDNEQ applies the NEQ predicate on the "reference_id" field.
+func ReferenceIDNEQ(v string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldNEQ(FieldReferenceID, v))
+}
+
+// ReferenceIDIn applies the In predicate on the "reference_id" field.
+func ReferenceIDIn(vs ...string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldIn(FieldReferenceID, vs...))
+}
+
+// ReferenceIDNotIn applies the NotIn predicate on the "reference_id" field.
+func ReferenceIDNotIn(vs ...string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldNotIn(FieldReferenceID, vs...))
+}
+
+// ReferenceIDGT applies the GT predicate on the "reference_id" field.
+func ReferenceIDGT(v string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldGT(FieldReferenceID, v))
+}
+
+// ReferenceIDGTE applies the GTE predicate on the "reference_id" field.
+func ReferenceIDGTE(v string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldGTE(FieldReferenceID, v))
+}
+
+// ReferenceIDLT applies the LT predicate on the "reference_id" field.
+func ReferenceIDLT(v string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldLT(FieldReferenceID, v))
+}
+
+// ReferenceIDLTE applies the LTE predicate on the "reference_id" field.
+func ReferenceIDLTE(v string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldLTE(FieldReferenceID, v))
+}
+
+// ReferenceIDContains applies the Contains predicate on the "reference_id" field.
+func ReferenceIDContains(v string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldContains(FieldReferenceID, v))
+}
+
+// ReferenceIDHasPrefix applies the HasPrefix predicate on the "reference_id" field.
+func ReferenceIDHasPrefix(v string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldHasPrefix(FieldReferenceID, v))
+}
+
+// ReferenceIDHasSuffix applies the HasSuffix predicate on the "reference_id" field.
+func ReferenceIDHasSuffix(v string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldHasSuffix(FieldReferenceID, v))
+}
+
+// ReferenceIDEqualFold applies the EqualFold predicate on the "reference_id" field.
+func ReferenceIDEqualFold(v string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldEqualFold(FieldReferenceID, v))
+}
+
+// ReferenceIDContainsFold applies the ContainsFold predicate on the "reference_id" field.
+func ReferenceIDContainsFold(v string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldContainsFold(FieldReferenceID, v))
+}
+
+// LeaderboardIDEQ applies the EQ predicate on the "leaderboard_id" field.
+func LeaderboardIDEQ(v models.LeaderboardID) predicate.LeaderboardScore {
+	vc := v
+	return predicate.LeaderboardScore(sql.FieldEQ(FieldLeaderboardID, vc))
+}
+
+// LeaderboardIDNEQ applies the NEQ predicate on the "leaderboard_id" field.
+func LeaderboardIDNEQ(v models.LeaderboardID) predicate.LeaderboardScore {
+	vc := v
+	return predicate.LeaderboardScore(sql.FieldNEQ(FieldLeaderboardID, vc))
+}
+
+// LeaderboardIDIn applies the In predicate on the "leaderboard_id" field.
+func LeaderboardIDIn(vs ...models.LeaderboardID) predicate.LeaderboardScore {
+	v := make([]any, len(vs))
+	for i := range v {
+		v[i] = vs[i]
+	}
+	return predicate.LeaderboardScore(sql.FieldIn(FieldLeaderboardID, v...))
+}
+
+// LeaderboardIDNotIn applies the NotIn predicate on the "leaderboard_id" field.
+func LeaderboardIDNotIn(vs ...models.LeaderboardID) predicate.LeaderboardScore {
+	v := make([]any, len(vs))
+	for i := range v {
+		v[i] = vs[i]
+	}
+	return predicate.LeaderboardScore(sql.FieldNotIn(FieldLeaderboardID, v...))
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.LeaderboardScore) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.LeaderboardScore) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.LeaderboardScore) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.NotPredicates(p))
+}
diff --git a/internal/database/ent/db/leaderboardscore_create.go b/internal/database/ent/db/leaderboardscore_create.go
new file mode 100644
index 00000000..276e3572
--- /dev/null
+++ b/internal/database/ent/db/leaderboardscore_create.go
@@ -0,0 +1,326 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/leaderboardscore"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+// LeaderboardScoreCreate is the builder for creating a LeaderboardScore entity.
+type LeaderboardScoreCreate struct {
+	config
+	mutation *LeaderboardScoreMutation
+	hooks    []Hook
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (lsc *LeaderboardScoreCreate) SetCreatedAt(t time.Time) *LeaderboardScoreCreate {
+	lsc.mutation.SetCreatedAt(t)
+	return lsc
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (lsc *LeaderboardScoreCreate) SetNillableCreatedAt(t *time.Time) *LeaderboardScoreCreate {
+	if t != nil {
+		lsc.SetCreatedAt(*t)
+	}
+	return lsc
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (lsc *LeaderboardScoreCreate) SetUpdatedAt(t time.Time) *LeaderboardScoreCreate {
+	lsc.mutation.SetUpdatedAt(t)
+	return lsc
+}
+
+// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
+func (lsc *LeaderboardScoreCreate) SetNillableUpdatedAt(t *time.Time) *LeaderboardScoreCreate {
+	if t != nil {
+		lsc.SetUpdatedAt(*t)
+	}
+	return lsc
+}
+
+// SetType sets the "type" field.
+func (lsc *LeaderboardScoreCreate) SetType(mt models.ScoreType) *LeaderboardScoreCreate {
+	lsc.mutation.SetType(mt)
+	return lsc
+}
+
+// SetScore sets the "score" field.
+func (lsc *LeaderboardScoreCreate) SetScore(f float32) *LeaderboardScoreCreate {
+	lsc.mutation.SetScore(f)
+	return lsc
+}
+
+// SetReferenceID sets the "reference_id" field.
+func (lsc *LeaderboardScoreCreate) SetReferenceID(s string) *LeaderboardScoreCreate {
+	lsc.mutation.SetReferenceID(s)
+	return lsc
+}
+
+// SetLeaderboardID sets the "leaderboard_id" field.
+func (lsc *LeaderboardScoreCreate) SetLeaderboardID(mi models.LeaderboardID) *LeaderboardScoreCreate {
+	lsc.mutation.SetLeaderboardID(mi)
+	return lsc
+}
+
+// SetMeta sets the "meta" field.
+func (lsc *LeaderboardScoreCreate) SetMeta(m map[string]interface{}) *LeaderboardScoreCreate {
+	lsc.mutation.SetMeta(m)
+	return lsc
+}
+
+// SetID sets the "id" field.
+func (lsc *LeaderboardScoreCreate) SetID(s string) *LeaderboardScoreCreate {
+	lsc.mutation.SetID(s)
+	return lsc
+}
+
+// SetNillableID sets the "id" field if the given value is not nil.
+func (lsc *LeaderboardScoreCreate) SetNillableID(s *string) *LeaderboardScoreCreate {
+	if s != nil {
+		lsc.SetID(*s)
+	}
+	return lsc
+}
+
+// Mutation returns the LeaderboardScoreMutation object of the builder.
+func (lsc *LeaderboardScoreCreate) Mutation() *LeaderboardScoreMutation {
+	return lsc.mutation
+}
+
+// Save creates the LeaderboardScore in the database.
+func (lsc *LeaderboardScoreCreate) Save(ctx context.Context) (*LeaderboardScore, error) {
+	lsc.defaults()
+	return withHooks(ctx, lsc.sqlSave, lsc.mutation, lsc.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (lsc *LeaderboardScoreCreate) SaveX(ctx context.Context) *LeaderboardScore {
+	v, err := lsc.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (lsc *LeaderboardScoreCreate) Exec(ctx context.Context) error {
+	_, err := lsc.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (lsc *LeaderboardScoreCreate) ExecX(ctx context.Context) {
+	if err := lsc.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (lsc *LeaderboardScoreCreate) defaults() {
+	if _, ok := lsc.mutation.CreatedAt(); !ok {
+		v := leaderboardscore.DefaultCreatedAt()
+		lsc.mutation.SetCreatedAt(v)
+	}
+	if _, ok := lsc.mutation.UpdatedAt(); !ok {
+		v := leaderboardscore.DefaultUpdatedAt()
+		lsc.mutation.SetUpdatedAt(v)
+	}
+	if _, ok := lsc.mutation.ID(); !ok {
+		v := leaderboardscore.DefaultID()
+		lsc.mutation.SetID(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (lsc *LeaderboardScoreCreate) check() error {
+	if _, ok := lsc.mutation.CreatedAt(); !ok {
+		return &ValidationError{Name: "created_at", err: errors.New(`db: missing required field "LeaderboardScore.created_at"`)}
+	}
+	if _, ok := lsc.mutation.UpdatedAt(); !ok {
+		return &ValidationError{Name: "updated_at", err: errors.New(`db: missing required field "LeaderboardScore.updated_at"`)}
+	}
+	if _, ok := lsc.mutation.GetType(); !ok {
+		return &ValidationError{Name: "type", err: errors.New(`db: missing required field "LeaderboardScore.type"`)}
+	}
+	if v, ok := lsc.mutation.GetType(); ok {
+		if err := leaderboardscore.TypeValidator(v); err != nil {
+			return &ValidationError{Name: "type", err: fmt.Errorf(`db: validator failed for field "LeaderboardScore.type": %w`, err)}
+		}
+	}
+	if _, ok := lsc.mutation.Score(); !ok {
+		return &ValidationError{Name: "score", err: errors.New(`db: missing required field "LeaderboardScore.score"`)}
+	}
+	if _, ok := lsc.mutation.ReferenceID(); !ok {
+		return &ValidationError{Name: "reference_id", err: errors.New(`db: missing required field "LeaderboardScore.reference_id"`)}
+	}
+	if _, ok := lsc.mutation.LeaderboardID(); !ok {
+		return &ValidationError{Name: "leaderboard_id", err: errors.New(`db: missing required field "LeaderboardScore.leaderboard_id"`)}
+	}
+	if v, ok := lsc.mutation.LeaderboardID(); ok {
+		if err := leaderboardscore.LeaderboardIDValidator(v); err != nil {
+			return &ValidationError{Name: "leaderboard_id", err: fmt.Errorf(`db: validator failed for field "LeaderboardScore.leaderboard_id": %w`, err)}
+		}
+	}
+	if _, ok := lsc.mutation.Meta(); !ok {
+		return &ValidationError{Name: "meta", err: errors.New(`db: missing required field "LeaderboardScore.meta"`)}
+	}
+	return nil
+}
+
+func (lsc *LeaderboardScoreCreate) sqlSave(ctx context.Context) (*LeaderboardScore, error) {
+	if err := lsc.check(); err != nil {
+		return nil, err
+	}
+	_node, _spec := lsc.createSpec()
+	if err := sqlgraph.CreateNode(ctx, lsc.driver, _spec); err != nil {
+		if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	if _spec.ID.Value != nil {
+		if id, ok := _spec.ID.Value.(string); ok {
+			_node.ID = id
+		} else {
+			return nil, fmt.Errorf("unexpected LeaderboardScore.ID type: %T", _spec.ID.Value)
+		}
+	}
+	lsc.mutation.id = &_node.ID
+	lsc.mutation.done = true
+	return _node, nil
+}
+
+func (lsc *LeaderboardScoreCreate) createSpec() (*LeaderboardScore, *sqlgraph.CreateSpec) {
+	var (
+		_node = &LeaderboardScore{config: lsc.config}
+		_spec = sqlgraph.NewCreateSpec(leaderboardscore.Table, sqlgraph.NewFieldSpec(leaderboardscore.FieldID, field.TypeString))
+	)
+	if id, ok := lsc.mutation.ID(); ok {
+		_node.ID = id
+		_spec.ID.Value = id
+	}
+	if value, ok := lsc.mutation.CreatedAt(); ok {
+		_spec.SetField(leaderboardscore.FieldCreatedAt, field.TypeTime, value)
+		_node.CreatedAt = value
+	}
+	if value, ok := lsc.mutation.UpdatedAt(); ok {
+		_spec.SetField(leaderboardscore.FieldUpdatedAt, field.TypeTime, value)
+		_node.UpdatedAt = value
+	}
+	if value, ok := lsc.mutation.GetType(); ok {
+		_spec.SetField(leaderboardscore.FieldType, field.TypeEnum, value)
+		_node.Type = value
+	}
+	if value, ok := lsc.mutation.Score(); ok {
+		_spec.SetField(leaderboardscore.FieldScore, field.TypeFloat32, value)
+		_node.Score = value
+	}
+	if value, ok := lsc.mutation.ReferenceID(); ok {
+		_spec.SetField(leaderboardscore.FieldReferenceID, field.TypeString, value)
+		_node.ReferenceID = value
+	}
+	if value, ok := lsc.mutation.LeaderboardID(); ok {
+		_spec.SetField(leaderboardscore.FieldLeaderboardID, field.TypeEnum, value)
+		_node.LeaderboardID = value
+	}
+	if value, ok := lsc.mutation.Meta(); ok {
+		_spec.SetField(leaderboardscore.FieldMeta, field.TypeJSON, value)
+		_node.Meta = value
+	}
+	return _node, _spec
+}
+
+// LeaderboardScoreCreateBulk is the builder for creating many LeaderboardScore entities in bulk.
+type LeaderboardScoreCreateBulk struct {
+	config
+	err      error
+	builders []*LeaderboardScoreCreate
+}
+
+// Save creates the LeaderboardScore entities in the database.
+func (lscb *LeaderboardScoreCreateBulk) Save(ctx context.Context) ([]*LeaderboardScore, error) {
+	if lscb.err != nil {
+		return nil, lscb.err
+	}
+	specs := make([]*sqlgraph.CreateSpec, len(lscb.builders))
+	nodes := make([]*LeaderboardScore, len(lscb.builders))
+	mutators := make([]Mutator, len(lscb.builders))
+	for i := range lscb.builders {
+		func(i int, root context.Context) {
+			builder := lscb.builders[i]
+			builder.defaults()
+			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+				mutation, ok := m.(*LeaderboardScoreMutation)
+				if !ok {
+					return nil, fmt.Errorf("unexpected mutation type %T", m)
+				}
+				if err := builder.check(); err != nil {
+					return nil, err
+				}
+				builder.mutation = mutation
+				var err error
+				nodes[i], specs[i] = builder.createSpec()
+				if i < len(mutators)-1 {
+					_, err = mutators[i+1].Mutate(root, lscb.builders[i+1].mutation)
+				} else {
+					spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
+					// Invoke the actual operation on the latest mutation in the chain.
+					if err = sqlgraph.BatchCreate(ctx, lscb.driver, spec); err != nil {
+						if sqlgraph.IsConstraintError(err) {
+							err = &ConstraintError{msg: err.Error(), wrap: err}
+						}
+					}
+				}
+				if err != nil {
+					return nil, err
+				}
+				mutation.id = &nodes[i].ID
+				mutation.done = true
+				return nodes[i], nil
+			})
+			for i := len(builder.hooks) - 1; i >= 0; i-- {
+				mut = builder.hooks[i](mut)
+			}
+			mutators[i] = mut
+		}(i, ctx)
+	}
+	if len(mutators) > 0 {
+		if _, err := mutators[0].Mutate(ctx, lscb.builders[0].mutation); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (lscb *LeaderboardScoreCreateBulk) SaveX(ctx context.Context) []*LeaderboardScore {
+	v, err := lscb.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (lscb *LeaderboardScoreCreateBulk) Exec(ctx context.Context) error {
+	_, err := lscb.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (lscb *LeaderboardScoreCreateBulk) ExecX(ctx context.Context) {
+	if err := lscb.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/database/ent/db/leaderboardscore_delete.go b/internal/database/ent/db/leaderboardscore_delete.go
new file mode 100644
index 00000000..0229dd09
--- /dev/null
+++ b/internal/database/ent/db/leaderboardscore_delete.go
@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/leaderboardscore"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+)
+
+// LeaderboardScoreDelete is the builder for deleting a LeaderboardScore entity.
+type LeaderboardScoreDelete struct {
+	config
+	hooks    []Hook
+	mutation *LeaderboardScoreMutation
+}
+
+// Where appends a list predicates to the LeaderboardScoreDelete builder.
+func (lsd *LeaderboardScoreDelete) Where(ps ...predicate.LeaderboardScore) *LeaderboardScoreDelete {
+	lsd.mutation.Where(ps...)
+	return lsd
+}
+
+// Exec executes the deletion query and returns how many vertices were deleted.
+func (lsd *LeaderboardScoreDelete) Exec(ctx context.Context) (int, error) {
+	return withHooks(ctx, lsd.sqlExec, lsd.mutation, lsd.hooks)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (lsd *LeaderboardScoreDelete) ExecX(ctx context.Context) int {
+	n, err := lsd.Exec(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return n
+}
+
+func (lsd *LeaderboardScoreDelete) sqlExec(ctx context.Context) (int, error) {
+	_spec := sqlgraph.NewDeleteSpec(leaderboardscore.Table, sqlgraph.NewFieldSpec(leaderboardscore.FieldID, field.TypeString))
+	if ps := lsd.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	affected, err := sqlgraph.DeleteNodes(ctx, lsd.driver, _spec)
+	if err != nil && sqlgraph.IsConstraintError(err) {
+		err = &ConstraintError{msg: err.Error(), wrap: err}
+	}
+	lsd.mutation.done = true
+	return affected, err
+}
+
+// LeaderboardScoreDeleteOne is the builder for deleting a single LeaderboardScore entity.
+type LeaderboardScoreDeleteOne struct {
+	lsd *LeaderboardScoreDelete
+}
+
+// Where appends a list predicates to the LeaderboardScoreDelete builder.
+func (lsdo *LeaderboardScoreDeleteOne) Where(ps ...predicate.LeaderboardScore) *LeaderboardScoreDeleteOne {
+	lsdo.lsd.mutation.Where(ps...)
+	return lsdo
+}
+
+// Exec executes the deletion query.
+func (lsdo *LeaderboardScoreDeleteOne) Exec(ctx context.Context) error {
+	n, err := lsdo.lsd.Exec(ctx)
+	switch {
+	case err != nil:
+		return err
+	case n == 0:
+		return &NotFoundError{leaderboardscore.Label}
+	default:
+		return nil
+	}
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (lsdo *LeaderboardScoreDeleteOne) ExecX(ctx context.Context) {
+	if err := lsdo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/database/ent/db/leaderboardscore_query.go b/internal/database/ent/db/leaderboardscore_query.go
new file mode 100644
index 00000000..69915de8
--- /dev/null
+++ b/internal/database/ent/db/leaderboardscore_query.go
@@ -0,0 +1,548 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"fmt"
+	"math"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/leaderboardscore"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+)
+
+// LeaderboardScoreQuery is the builder for querying LeaderboardScore entities.
+type LeaderboardScoreQuery struct {
+	config
+	ctx        *QueryContext
+	order      []leaderboardscore.OrderOption
+	inters     []Interceptor
+	predicates []predicate.LeaderboardScore
+	modifiers  []func(*sql.Selector)
+	// intermediate query (i.e. traversal path).
+	sql  *sql.Selector
+	path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the LeaderboardScoreQuery builder.
+func (lsq *LeaderboardScoreQuery) Where(ps ...predicate.LeaderboardScore) *LeaderboardScoreQuery {
+	lsq.predicates = append(lsq.predicates, ps...)
+	return lsq
+}
+
+// Limit the number of records to be returned by this query.
+func (lsq *LeaderboardScoreQuery) Limit(limit int) *LeaderboardScoreQuery {
+	lsq.ctx.Limit = &limit
+	return lsq
+}
+
+// Offset to start from.
+func (lsq *LeaderboardScoreQuery) Offset(offset int) *LeaderboardScoreQuery {
+	lsq.ctx.Offset = &offset
+	return lsq
+}
+
+// Unique configures the query builder to filter duplicate records on query.
+// By default, unique is set to true, and can be disabled using this method.
+func (lsq *LeaderboardScoreQuery) Unique(unique bool) *LeaderboardScoreQuery {
+	lsq.ctx.Unique = &unique
+	return lsq
+}
+
+// Order specifies how the records should be ordered.
+func (lsq *LeaderboardScoreQuery) Order(o ...leaderboardscore.OrderOption) *LeaderboardScoreQuery {
+	lsq.order = append(lsq.order, o...)
+	return lsq
+}
+
+// First returns the first LeaderboardScore entity from the query.
+// Returns a *NotFoundError when no LeaderboardScore was found.
+func (lsq *LeaderboardScoreQuery) First(ctx context.Context) (*LeaderboardScore, error) {
+	nodes, err := lsq.Limit(1).All(setContextOp(ctx, lsq.ctx, "First"))
+	if err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nil, &NotFoundError{leaderboardscore.Label}
+	}
+	return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (lsq *LeaderboardScoreQuery) FirstX(ctx context.Context) *LeaderboardScore {
+	node, err := lsq.First(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return node
+}
+
+// FirstID returns the first LeaderboardScore ID from the query.
+// Returns a *NotFoundError when no LeaderboardScore ID was found.
+func (lsq *LeaderboardScoreQuery) FirstID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = lsq.Limit(1).IDs(setContextOp(ctx, lsq.ctx, "FirstID")); err != nil {
+		return
+	}
+	if len(ids) == 0 {
+		err = &NotFoundError{leaderboardscore.Label}
+		return
+	}
+	return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (lsq *LeaderboardScoreQuery) FirstIDX(ctx context.Context) string {
+	id, err := lsq.FirstID(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return id
+}
+
+// Only returns a single LeaderboardScore entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one LeaderboardScore entity is found.
+// Returns a *NotFoundError when no LeaderboardScore entities are found.
+func (lsq *LeaderboardScoreQuery) Only(ctx context.Context) (*LeaderboardScore, error) {
+	nodes, err := lsq.Limit(2).All(setContextOp(ctx, lsq.ctx, "Only"))
+	if err != nil {
+		return nil, err
+	}
+	switch len(nodes) {
+	case 1:
+		return nodes[0], nil
+	case 0:
+		return nil, &NotFoundError{leaderboardscore.Label}
+	default:
+		return nil, &NotSingularError{leaderboardscore.Label}
+	}
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (lsq *LeaderboardScoreQuery) OnlyX(ctx context.Context) *LeaderboardScore {
+	node, err := lsq.Only(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// OnlyID is like Only, but returns the only LeaderboardScore ID in the query.
+// Returns a *NotSingularError when more than one LeaderboardScore ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (lsq *LeaderboardScoreQuery) OnlyID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = lsq.Limit(2).IDs(setContextOp(ctx, lsq.ctx, "OnlyID")); err != nil {
+		return
+	}
+	switch len(ids) {
+	case 1:
+		id = ids[0]
+	case 0:
+		err = &NotFoundError{leaderboardscore.Label}
+	default:
+		err = &NotSingularError{leaderboardscore.Label}
+	}
+	return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (lsq *LeaderboardScoreQuery) OnlyIDX(ctx context.Context) string {
+	id, err := lsq.OnlyID(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return id
+}
+
+// All executes the query and returns a list of LeaderboardScores.
+func (lsq *LeaderboardScoreQuery) All(ctx context.Context) ([]*LeaderboardScore, error) {
+	ctx = setContextOp(ctx, lsq.ctx, "All")
+	if err := lsq.prepareQuery(ctx); err != nil {
+		return nil, err
+	}
+	qr := querierAll[[]*LeaderboardScore, *LeaderboardScoreQuery]()
+	return withInterceptors[[]*LeaderboardScore](ctx, lsq, qr, lsq.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (lsq *LeaderboardScoreQuery) AllX(ctx context.Context) []*LeaderboardScore {
+	nodes, err := lsq.All(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return nodes
+}
+
+// IDs executes the query and returns a list of LeaderboardScore IDs.
+func (lsq *LeaderboardScoreQuery) IDs(ctx context.Context) (ids []string, err error) {
+	if lsq.ctx.Unique == nil && lsq.path != nil {
+		lsq.Unique(true)
+	}
+	ctx = setContextOp(ctx, lsq.ctx, "IDs")
+	if err = lsq.Select(leaderboardscore.FieldID).Scan(ctx, &ids); err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (lsq *LeaderboardScoreQuery) IDsX(ctx context.Context) []string {
+	ids, err := lsq.IDs(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return ids
+}
+
+// Count returns the count of the given query.
+func (lsq *LeaderboardScoreQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, lsq.ctx, "Count")
+	if err := lsq.prepareQuery(ctx); err != nil {
+		return 0, err
+	}
+	return withInterceptors[int](ctx, lsq, querierCount[*LeaderboardScoreQuery](), lsq.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (lsq *LeaderboardScoreQuery) CountX(ctx context.Context) int {
+	count, err := lsq.Count(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (lsq *LeaderboardScoreQuery) Exist(ctx context.Context) (bool, error) {
+	ctx = setContextOp(ctx, lsq.ctx, "Exist")
+	switch _, err := lsq.FirstID(ctx); {
+	case IsNotFound(err):
+		return false, nil
+	case err != nil:
+		return false, fmt.Errorf("db: check existence: %w", err)
+	default:
+		return true, nil
+	}
+}
+
+// ExistX is like Exist, but panics if an error occurs.
+func (lsq *LeaderboardScoreQuery) ExistX(ctx context.Context) bool {
+	exist, err := lsq.Exist(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return exist
+}
+
+// Clone returns a duplicate of the LeaderboardScoreQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (lsq *LeaderboardScoreQuery) Clone() *LeaderboardScoreQuery {
+	if lsq == nil {
+		return nil
+	}
+	return &LeaderboardScoreQuery{
+		config:     lsq.config,
+		ctx:        lsq.ctx.Clone(),
+		order:      append([]leaderboardscore.OrderOption{}, lsq.order...),
+		inters:     append([]Interceptor{}, lsq.inters...),
+		predicates: append([]predicate.LeaderboardScore{}, lsq.predicates...),
+		// clone intermediate query.
+		sql:  lsq.sql.Clone(),
+		path: lsq.path,
+	}
+}
+
+// GroupBy is used to group vertices by one or more fields/columns.
+// It is often used with aggregate functions, like: count, max, mean, min, sum.
+//
+// Example:
+//
+//	var v []struct {
+//		CreatedAt time.Time `json:"created_at,omitempty"`
+//		Count int `json:"count,omitempty"`
+//	}
+//
+//	client.LeaderboardScore.Query().
+//		GroupBy(leaderboardscore.FieldCreatedAt).
+//		Aggregate(db.Count()).
+//		Scan(ctx, &v)
+func (lsq *LeaderboardScoreQuery) GroupBy(field string, fields ...string) *LeaderboardScoreGroupBy {
+	lsq.ctx.Fields = append([]string{field}, fields...)
+	grbuild := &LeaderboardScoreGroupBy{build: lsq}
+	grbuild.flds = &lsq.ctx.Fields
+	grbuild.label = leaderboardscore.Label
+	grbuild.scan = grbuild.Scan
+	return grbuild
+}
+
+// Select allows the selection one or more fields/columns for the given query,
+// instead of selecting all fields in the entity.
+//
+// Example:
+//
+//	var v []struct {
+//		CreatedAt time.Time `json:"created_at,omitempty"`
+//	}
+//
+//	client.LeaderboardScore.Query().
+//		Select(leaderboardscore.FieldCreatedAt).
+//		Scan(ctx, &v)
+func (lsq *LeaderboardScoreQuery) Select(fields ...string) *LeaderboardScoreSelect {
+	lsq.ctx.Fields = append(lsq.ctx.Fields, fields...)
+	sbuild := &LeaderboardScoreSelect{LeaderboardScoreQuery: lsq}
+	sbuild.label = leaderboardscore.Label
+	sbuild.flds, sbuild.scan = &lsq.ctx.Fields, sbuild.Scan
+	return sbuild
+}
+
+// Aggregate returns a LeaderboardScoreSelect configured with the given aggregations.
+func (lsq *LeaderboardScoreQuery) Aggregate(fns ...AggregateFunc) *LeaderboardScoreSelect {
+	return lsq.Select().Aggregate(fns...)
+}
+
+func (lsq *LeaderboardScoreQuery) prepareQuery(ctx context.Context) error {
+	for _, inter := range lsq.inters {
+		if inter == nil {
+			return fmt.Errorf("db: uninitialized interceptor (forgotten import db/runtime?)")
+		}
+		if trv, ok := inter.(Traverser); ok {
+			if err := trv.Traverse(ctx, lsq); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range lsq.ctx.Fields {
+		if !leaderboardscore.ValidColumn(f) {
+			return &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+		}
+	}
+	if lsq.path != nil {
+		prev, err := lsq.path(ctx)
+		if err != nil {
+			return err
+		}
+		lsq.sql = prev
+	}
+	return nil
+}
+
+func (lsq *LeaderboardScoreQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*LeaderboardScore, error) {
+	var (
+		nodes = []*LeaderboardScore{}
+		_spec = lsq.querySpec()
+	)
+	_spec.ScanValues = func(columns []string) ([]any, error) {
+		return (*LeaderboardScore).scanValues(nil, columns)
+	}
+	_spec.Assign = func(columns []string, values []any) error {
+		node := &LeaderboardScore{config: lsq.config}
+		nodes = append(nodes, node)
+		return node.assignValues(columns, values)
+	}
+	if len(lsq.modifiers) > 0 {
+		_spec.Modifiers = lsq.modifiers
+	}
+	for i := range hooks {
+		hooks[i](ctx, _spec)
+	}
+	if err := sqlgraph.QueryNodes(ctx, lsq.driver, _spec); err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nodes, nil
+	}
+	return nodes, nil
+}
+
+func (lsq *LeaderboardScoreQuery) sqlCount(ctx context.Context) (int, error) {
+	_spec := lsq.querySpec()
+	if len(lsq.modifiers) > 0 {
+		_spec.Modifiers = lsq.modifiers
+	}
+	_spec.Node.Columns = lsq.ctx.Fields
+	if len(lsq.ctx.Fields) > 0 {
+		_spec.Unique = lsq.ctx.Unique != nil && *lsq.ctx.Unique
+	}
+	return sqlgraph.CountNodes(ctx, lsq.driver, _spec)
+}
+
+func (lsq *LeaderboardScoreQuery) querySpec() *sqlgraph.QuerySpec {
+	_spec := sqlgraph.NewQuerySpec(leaderboardscore.Table, leaderboardscore.Columns, sqlgraph.NewFieldSpec(leaderboardscore.FieldID, field.TypeString))
+	_spec.From = lsq.sql
+	if unique := lsq.ctx.Unique; unique != nil {
+		_spec.Unique = *unique
+	} else if lsq.path != nil {
+		_spec.Unique = true
+	}
+	if fields := lsq.ctx.Fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, leaderboardscore.FieldID)
+		for i := range fields {
+			if fields[i] != leaderboardscore.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+			}
+		}
+	}
+	if ps := lsq.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if limit := lsq.ctx.Limit; limit != nil {
+		_spec.Limit = *limit
+	}
+	if offset := lsq.ctx.Offset; offset != nil {
+		_spec.Offset = *offset
+	}
+	if ps := lsq.order; len(ps) > 0 {
+		_spec.Order = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	return _spec
+}
+
+func (lsq *LeaderboardScoreQuery) sqlQuery(ctx context.Context) *sql.Selector {
+	builder := sql.Dialect(lsq.driver.Dialect())
+	t1 := builder.Table(leaderboardscore.Table)
+	columns := lsq.ctx.Fields
+	if len(columns) == 0 {
+		columns = leaderboardscore.Columns
+	}
+	selector := builder.Select(t1.Columns(columns...)...).From(t1)
+	if lsq.sql != nil {
+		selector = lsq.sql
+		selector.Select(selector.Columns(columns...)...)
+	}
+	if lsq.ctx.Unique != nil && *lsq.ctx.Unique {
+		selector.Distinct()
+	}
+	for _, m := range lsq.modifiers {
+		m(selector)
+	}
+	for _, p := range lsq.predicates {
+		p(selector)
+	}
+	for _, p := range lsq.order {
+		p(selector)
+	}
+	if offset := lsq.ctx.Offset; offset != nil {
+		// limit is mandatory for offset clause. We start
+		// with default value, and override it below if needed.
+		selector.Offset(*offset).Limit(math.MaxInt32)
+	}
+	if limit := lsq.ctx.Limit; limit != nil {
+		selector.Limit(*limit)
+	}
+	return selector
+}
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (lsq *LeaderboardScoreQuery) Modify(modifiers ...func(s *sql.Selector)) *LeaderboardScoreSelect {
+	lsq.modifiers = append(lsq.modifiers, modifiers...)
+	return lsq.Select()
+}
+
+// LeaderboardScoreGroupBy is the group-by builder for LeaderboardScore entities.
+type LeaderboardScoreGroupBy struct {
+	selector
+	build *LeaderboardScoreQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (lsgb *LeaderboardScoreGroupBy) Aggregate(fns ...AggregateFunc) *LeaderboardScoreGroupBy {
+	lsgb.fns = append(lsgb.fns, fns...)
+	return lsgb
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (lsgb *LeaderboardScoreGroupBy) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, lsgb.build.ctx, "GroupBy")
+	if err := lsgb.build.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*LeaderboardScoreQuery, *LeaderboardScoreGroupBy](ctx, lsgb.build, lsgb, lsgb.build.inters, v)
+}
+
+func (lsgb *LeaderboardScoreGroupBy) sqlScan(ctx context.Context, root *LeaderboardScoreQuery, v any) error {
+	selector := root.sqlQuery(ctx).Select()
+	aggregation := make([]string, 0, len(lsgb.fns))
+	for _, fn := range lsgb.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*lsgb.flds)+len(lsgb.fns))
+		for _, f := range *lsgb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*lsgb.flds...)...)
+	if err := selector.Err(); err != nil {
+		return err
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := lsgb.build.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
+
+// LeaderboardScoreSelect is the builder for selecting fields of LeaderboardScore entities.
+type LeaderboardScoreSelect struct {
+	*LeaderboardScoreQuery
+	selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (lss *LeaderboardScoreSelect) Aggregate(fns ...AggregateFunc) *LeaderboardScoreSelect {
+	lss.fns = append(lss.fns, fns...)
+	return lss
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (lss *LeaderboardScoreSelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, lss.ctx, "Select")
+	if err := lss.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*LeaderboardScoreQuery, *LeaderboardScoreSelect](ctx, lss.LeaderboardScoreQuery, lss, lss.inters, v)
+}
+
+func (lss *LeaderboardScoreSelect) sqlScan(ctx context.Context, root *LeaderboardScoreQuery, v any) error {
+	selector := root.sqlQuery(ctx)
+	aggregation := make([]string, 0, len(lss.fns))
+	for _, fn := range lss.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	switch n := len(*lss.selector.flds); {
+	case n == 0 && len(aggregation) > 0:
+		selector.Select(aggregation...)
+	case n != 0 && len(aggregation) > 0:
+		selector.AppendSelect(aggregation...)
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := lss.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (lss *LeaderboardScoreSelect) Modify(modifiers ...func(s *sql.Selector)) *LeaderboardScoreSelect {
+	lss.modifiers = append(lss.modifiers, modifiers...)
+	return lss
+}
diff --git a/internal/database/ent/db/leaderboardscore_update.go b/internal/database/ent/db/leaderboardscore_update.go
new file mode 100644
index 00000000..600d8717
--- /dev/null
+++ b/internal/database/ent/db/leaderboardscore_update.go
@@ -0,0 +1,439 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/cufee/aftermath/internal/database/ent/db/leaderboardscore"
+	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+// LeaderboardScoreUpdate is the builder for updating LeaderboardScore entities.
+type LeaderboardScoreUpdate struct {
+	config
+	hooks     []Hook
+	mutation  *LeaderboardScoreMutation
+	modifiers []func(*sql.UpdateBuilder)
+}
+
+// Where appends a list predicates to the LeaderboardScoreUpdate builder.
+func (lsu *LeaderboardScoreUpdate) Where(ps ...predicate.LeaderboardScore) *LeaderboardScoreUpdate {
+	lsu.mutation.Where(ps...)
+	return lsu
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (lsu *LeaderboardScoreUpdate) SetUpdatedAt(t time.Time) *LeaderboardScoreUpdate {
+	lsu.mutation.SetUpdatedAt(t)
+	return lsu
+}
+
+// SetType sets the "type" field.
+func (lsu *LeaderboardScoreUpdate) SetType(mt models.ScoreType) *LeaderboardScoreUpdate {
+	lsu.mutation.SetType(mt)
+	return lsu
+}
+
+// SetNillableType sets the "type" field if the given value is not nil.
+func (lsu *LeaderboardScoreUpdate) SetNillableType(mt *models.ScoreType) *LeaderboardScoreUpdate {
+	if mt != nil {
+		lsu.SetType(*mt)
+	}
+	return lsu
+}
+
+// SetScore sets the "score" field.
+func (lsu *LeaderboardScoreUpdate) SetScore(f float32) *LeaderboardScoreUpdate {
+	lsu.mutation.ResetScore()
+	lsu.mutation.SetScore(f)
+	return lsu
+}
+
+// SetNillableScore sets the "score" field if the given value is not nil.
+func (lsu *LeaderboardScoreUpdate) SetNillableScore(f *float32) *LeaderboardScoreUpdate {
+	if f != nil {
+		lsu.SetScore(*f)
+	}
+	return lsu
+}
+
+// AddScore adds f to the "score" field.
+func (lsu *LeaderboardScoreUpdate) AddScore(f float32) *LeaderboardScoreUpdate {
+	lsu.mutation.AddScore(f)
+	return lsu
+}
+
+// SetReferenceID sets the "reference_id" field.
+func (lsu *LeaderboardScoreUpdate) SetReferenceID(s string) *LeaderboardScoreUpdate {
+	lsu.mutation.SetReferenceID(s)
+	return lsu
+}
+
+// SetNillableReferenceID sets the "reference_id" field if the given value is not nil.
+func (lsu *LeaderboardScoreUpdate) SetNillableReferenceID(s *string) *LeaderboardScoreUpdate {
+	if s != nil {
+		lsu.SetReferenceID(*s)
+	}
+	return lsu
+}
+
+// SetLeaderboardID sets the "leaderboard_id" field.
+func (lsu *LeaderboardScoreUpdate) SetLeaderboardID(mi models.LeaderboardID) *LeaderboardScoreUpdate {
+	lsu.mutation.SetLeaderboardID(mi)
+	return lsu
+}
+
+// SetNillableLeaderboardID sets the "leaderboard_id" field if the given value is not nil.
+func (lsu *LeaderboardScoreUpdate) SetNillableLeaderboardID(mi *models.LeaderboardID) *LeaderboardScoreUpdate {
+	if mi != nil {
+		lsu.SetLeaderboardID(*mi)
+	}
+	return lsu
+}
+
+// SetMeta sets the "meta" field.
+func (lsu *LeaderboardScoreUpdate) SetMeta(m map[string]interface{}) *LeaderboardScoreUpdate {
+	lsu.mutation.SetMeta(m)
+	return lsu
+}
+
+// Mutation returns the LeaderboardScoreMutation object of the builder.
+func (lsu *LeaderboardScoreUpdate) Mutation() *LeaderboardScoreMutation {
+	return lsu.mutation
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (lsu *LeaderboardScoreUpdate) Save(ctx context.Context) (int, error) {
+	lsu.defaults()
+	return withHooks(ctx, lsu.sqlSave, lsu.mutation, lsu.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (lsu *LeaderboardScoreUpdate) SaveX(ctx context.Context) int {
+	affected, err := lsu.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return affected
+}
+
+// Exec executes the query.
+func (lsu *LeaderboardScoreUpdate) Exec(ctx context.Context) error {
+	_, err := lsu.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (lsu *LeaderboardScoreUpdate) ExecX(ctx context.Context) {
+	if err := lsu.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (lsu *LeaderboardScoreUpdate) defaults() {
+	if _, ok := lsu.mutation.UpdatedAt(); !ok {
+		v := leaderboardscore.UpdateDefaultUpdatedAt()
+		lsu.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (lsu *LeaderboardScoreUpdate) check() error {
+	if v, ok := lsu.mutation.GetType(); ok {
+		if err := leaderboardscore.TypeValidator(v); err != nil {
+			return &ValidationError{Name: "type", err: fmt.Errorf(`db: validator failed for field "LeaderboardScore.type": %w`, err)}
+		}
+	}
+	if v, ok := lsu.mutation.LeaderboardID(); ok {
+		if err := leaderboardscore.LeaderboardIDValidator(v); err != nil {
+			return &ValidationError{Name: "leaderboard_id", err: fmt.Errorf(`db: validator failed for field "LeaderboardScore.leaderboard_id": %w`, err)}
+		}
+	}
+	return nil
+}
+
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (lsu *LeaderboardScoreUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *LeaderboardScoreUpdate {
+	lsu.modifiers = append(lsu.modifiers, modifiers...)
+	return lsu
+}
+
+func (lsu *LeaderboardScoreUpdate) sqlSave(ctx context.Context) (n int, err error) {
+	if err := lsu.check(); err != nil {
+		return n, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(leaderboardscore.Table, leaderboardscore.Columns, sqlgraph.NewFieldSpec(leaderboardscore.FieldID, field.TypeString))
+	if ps := lsu.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := lsu.mutation.UpdatedAt(); ok {
+		_spec.SetField(leaderboardscore.FieldUpdatedAt, field.TypeTime, value)
+	}
+	if value, ok := lsu.mutation.GetType(); ok {
+		_spec.SetField(leaderboardscore.FieldType, field.TypeEnum, value)
+	}
+	if value, ok := lsu.mutation.Score(); ok {
+		_spec.SetField(leaderboardscore.FieldScore, field.TypeFloat32, value)
+	}
+	if value, ok := lsu.mutation.AddedScore(); ok {
+		_spec.AddField(leaderboardscore.FieldScore, field.TypeFloat32, value)
+	}
+	if value, ok := lsu.mutation.ReferenceID(); ok {
+		_spec.SetField(leaderboardscore.FieldReferenceID, field.TypeString, value)
+	}
+	if value, ok := lsu.mutation.LeaderboardID(); ok {
+		_spec.SetField(leaderboardscore.FieldLeaderboardID, field.TypeEnum, value)
+	}
+	if value, ok := lsu.mutation.Meta(); ok {
+		_spec.SetField(leaderboardscore.FieldMeta, field.TypeJSON, value)
+	}
+	_spec.AddModifiers(lsu.modifiers...)
+	if n, err = sqlgraph.UpdateNodes(ctx, lsu.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{leaderboardscore.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return 0, err
+	}
+	lsu.mutation.done = true
+	return n, nil
+}
+
+// LeaderboardScoreUpdateOne is the builder for updating a single LeaderboardScore entity.
+type LeaderboardScoreUpdateOne struct {
+	config
+	fields    []string
+	hooks     []Hook
+	mutation  *LeaderboardScoreMutation
+	modifiers []func(*sql.UpdateBuilder)
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (lsuo *LeaderboardScoreUpdateOne) SetUpdatedAt(t time.Time) *LeaderboardScoreUpdateOne {
+	lsuo.mutation.SetUpdatedAt(t)
+	return lsuo
+}
+
+// SetType sets the "type" field.
+func (lsuo *LeaderboardScoreUpdateOne) SetType(mt models.ScoreType) *LeaderboardScoreUpdateOne {
+	lsuo.mutation.SetType(mt)
+	return lsuo
+}
+
+// SetNillableType sets the "type" field if the given value is not nil.
+func (lsuo *LeaderboardScoreUpdateOne) SetNillableType(mt *models.ScoreType) *LeaderboardScoreUpdateOne {
+	if mt != nil {
+		lsuo.SetType(*mt)
+	}
+	return lsuo
+}
+
+// SetScore sets the "score" field.
+func (lsuo *LeaderboardScoreUpdateOne) SetScore(f float32) *LeaderboardScoreUpdateOne {
+	lsuo.mutation.ResetScore()
+	lsuo.mutation.SetScore(f)
+	return lsuo
+}
+
+// SetNillableScore sets the "score" field if the given value is not nil.
+func (lsuo *LeaderboardScoreUpdateOne) SetNillableScore(f *float32) *LeaderboardScoreUpdateOne {
+	if f != nil {
+		lsuo.SetScore(*f)
+	}
+	return lsuo
+}
+
+// AddScore adds f to the "score" field.
+func (lsuo *LeaderboardScoreUpdateOne) AddScore(f float32) *LeaderboardScoreUpdateOne {
+	lsuo.mutation.AddScore(f)
+	return lsuo
+}
+
+// SetReferenceID sets the "reference_id" field.
+func (lsuo *LeaderboardScoreUpdateOne) SetReferenceID(s string) *LeaderboardScoreUpdateOne {
+	lsuo.mutation.SetReferenceID(s)
+	return lsuo
+}
+
+// SetNillableReferenceID sets the "reference_id" field if the given value is not nil.
+func (lsuo *LeaderboardScoreUpdateOne) SetNillableReferenceID(s *string) *LeaderboardScoreUpdateOne {
+	if s != nil {
+		lsuo.SetReferenceID(*s)
+	}
+	return lsuo
+}
+
+// SetLeaderboardID sets the "leaderboard_id" field.
+func (lsuo *LeaderboardScoreUpdateOne) SetLeaderboardID(mi models.LeaderboardID) *LeaderboardScoreUpdateOne {
+	lsuo.mutation.SetLeaderboardID(mi)
+	return lsuo
+}
+
+// SetNillableLeaderboardID sets the "leaderboard_id" field if the given value is not nil.
+func (lsuo *LeaderboardScoreUpdateOne) SetNillableLeaderboardID(mi *models.LeaderboardID) *LeaderboardScoreUpdateOne {
+	if mi != nil {
+		lsuo.SetLeaderboardID(*mi)
+	}
+	return lsuo
+}
+
+// SetMeta sets the "meta" field.
+func (lsuo *LeaderboardScoreUpdateOne) SetMeta(m map[string]interface{}) *LeaderboardScoreUpdateOne {
+	lsuo.mutation.SetMeta(m)
+	return lsuo
+}
+
+// Mutation returns the LeaderboardScoreMutation object of the builder.
+func (lsuo *LeaderboardScoreUpdateOne) Mutation() *LeaderboardScoreMutation {
+	return lsuo.mutation
+}
+
+// Where appends a list predicates to the LeaderboardScoreUpdate builder.
+func (lsuo *LeaderboardScoreUpdateOne) Where(ps ...predicate.LeaderboardScore) *LeaderboardScoreUpdateOne {
+	lsuo.mutation.Where(ps...)
+	return lsuo
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (lsuo *LeaderboardScoreUpdateOne) Select(field string, fields ...string) *LeaderboardScoreUpdateOne {
+	lsuo.fields = append([]string{field}, fields...)
+	return lsuo
+}
+
+// Save executes the query and returns the updated LeaderboardScore entity.
+func (lsuo *LeaderboardScoreUpdateOne) Save(ctx context.Context) (*LeaderboardScore, error) {
+	lsuo.defaults()
+	return withHooks(ctx, lsuo.sqlSave, lsuo.mutation, lsuo.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (lsuo *LeaderboardScoreUpdateOne) SaveX(ctx context.Context) *LeaderboardScore {
+	node, err := lsuo.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// Exec executes the query on the entity.
+func (lsuo *LeaderboardScoreUpdateOne) Exec(ctx context.Context) error {
+	_, err := lsuo.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (lsuo *LeaderboardScoreUpdateOne) ExecX(ctx context.Context) {
+	if err := lsuo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (lsuo *LeaderboardScoreUpdateOne) defaults() {
+	if _, ok := lsuo.mutation.UpdatedAt(); !ok {
+		v := leaderboardscore.UpdateDefaultUpdatedAt()
+		lsuo.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (lsuo *LeaderboardScoreUpdateOne) check() error {
+	if v, ok := lsuo.mutation.GetType(); ok {
+		if err := leaderboardscore.TypeValidator(v); err != nil {
+			return &ValidationError{Name: "type", err: fmt.Errorf(`db: validator failed for field "LeaderboardScore.type": %w`, err)}
+		}
+	}
+	if v, ok := lsuo.mutation.LeaderboardID(); ok {
+		if err := leaderboardscore.LeaderboardIDValidator(v); err != nil {
+			return &ValidationError{Name: "leaderboard_id", err: fmt.Errorf(`db: validator failed for field "LeaderboardScore.leaderboard_id": %w`, err)}
+		}
+	}
+	return nil
+}
+
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (lsuo *LeaderboardScoreUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *LeaderboardScoreUpdateOne {
+	lsuo.modifiers = append(lsuo.modifiers, modifiers...)
+	return lsuo
+}
+
+func (lsuo *LeaderboardScoreUpdateOne) sqlSave(ctx context.Context) (_node *LeaderboardScore, err error) {
+	if err := lsuo.check(); err != nil {
+		return _node, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(leaderboardscore.Table, leaderboardscore.Columns, sqlgraph.NewFieldSpec(leaderboardscore.FieldID, field.TypeString))
+	id, ok := lsuo.mutation.ID()
+	if !ok {
+		return nil, &ValidationError{Name: "id", err: errors.New(`db: missing "LeaderboardScore.id" for update`)}
+	}
+	_spec.Node.ID.Value = id
+	if fields := lsuo.fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, leaderboardscore.FieldID)
+		for _, f := range fields {
+			if !leaderboardscore.ValidColumn(f) {
+				return nil, &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+			}
+			if f != leaderboardscore.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, f)
+			}
+		}
+	}
+	if ps := lsuo.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := lsuo.mutation.UpdatedAt(); ok {
+		_spec.SetField(leaderboardscore.FieldUpdatedAt, field.TypeTime, value)
+	}
+	if value, ok := lsuo.mutation.GetType(); ok {
+		_spec.SetField(leaderboardscore.FieldType, field.TypeEnum, value)
+	}
+	if value, ok := lsuo.mutation.Score(); ok {
+		_spec.SetField(leaderboardscore.FieldScore, field.TypeFloat32, value)
+	}
+	if value, ok := lsuo.mutation.AddedScore(); ok {
+		_spec.AddField(leaderboardscore.FieldScore, field.TypeFloat32, value)
+	}
+	if value, ok := lsuo.mutation.ReferenceID(); ok {
+		_spec.SetField(leaderboardscore.FieldReferenceID, field.TypeString, value)
+	}
+	if value, ok := lsuo.mutation.LeaderboardID(); ok {
+		_spec.SetField(leaderboardscore.FieldLeaderboardID, field.TypeEnum, value)
+	}
+	if value, ok := lsuo.mutation.Meta(); ok {
+		_spec.SetField(leaderboardscore.FieldMeta, field.TypeJSON, value)
+	}
+	_spec.AddModifiers(lsuo.modifiers...)
+	_node = &LeaderboardScore{config: lsuo.config}
+	_spec.Assign = _node.assignValues
+	_spec.ScanValues = _node.scanValues
+	if err = sqlgraph.UpdateNode(ctx, lsuo.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{leaderboardscore.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	lsuo.mutation.done = true
+	return _node, nil
+}
diff --git a/internal/database/ent/db/migrate/schema.go b/internal/database/ent/db/migrate/schema.go
index 095dfa27..9d430051 100644
--- a/internal/database/ent/db/migrate/schema.go
+++ b/internal/database/ent/db/migrate/schema.go
@@ -280,7 +280,7 @@ var (
 		{Name: "id", Type: field.TypeString, Unique: true},
 		{Name: "created_at", Type: field.TypeTime},
 		{Name: "updated_at", Type: field.TypeTime},
-		{Name: "type", Type: field.TypeEnum, Enums: []string{"UPDATE_CLANS", "RECORD_SNAPSHOTS", "CLEANUP_DATABASE"}},
+		{Name: "type", Type: field.TypeEnum, Enums: []string{"UPDATE_CLANS", "RECORD_SNAPSHOTS", "ACHIEVEMENT_LEADERBOARDS", "CLEANUP_DATABASE"}},
 		{Name: "reference_id", Type: field.TypeString},
 		{Name: "targets", Type: field.TypeJSON},
 		{Name: "status", Type: field.TypeEnum, Enums: []string{"TASK_SCHEDULED", "TASK_IN_PROGRESS", "TASK_COMPLETE", "TASK_FAILED"}},
@@ -376,6 +376,65 @@ var (
 			},
 		},
 	}
+	// LeaderboardScoresColumns holds the columns for the "leaderboard_scores" table.
+	LeaderboardScoresColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeString, Unique: true},
+		{Name: "created_at", Type: field.TypeTime},
+		{Name: "updated_at", Type: field.TypeTime},
+		{Name: "type", Type: field.TypeEnum, Enums: []string{"custom", "hourly", "daily"}},
+		{Name: "score", Type: field.TypeFloat32},
+		{Name: "reference_id", Type: field.TypeString},
+		{Name: "leaderboard_id", Type: field.TypeEnum, Enums: []string{"mastery-weighted-players", "mastery-weighted-clans"}},
+		{Name: "meta", Type: field.TypeJSON},
+	}
+	// LeaderboardScoresTable holds the schema information for the "leaderboard_scores" table.
+	LeaderboardScoresTable = &schema.Table{
+		Name:       "leaderboard_scores",
+		Columns:    LeaderboardScoresColumns,
+		PrimaryKey: []*schema.Column{LeaderboardScoresColumns[0]},
+		Indexes: []*schema.Index{
+			{
+				Name:    "leaderboardscore_id",
+				Unique:  false,
+				Columns: []*schema.Column{LeaderboardScoresColumns[0]},
+			},
+			{
+				Name:    "leaderboardscore_created_at",
+				Unique:  false,
+				Columns: []*schema.Column{LeaderboardScoresColumns[1]},
+			},
+			{
+				Name:    "leaderboardscore_created_at_type",
+				Unique:  false,
+				Columns: []*schema.Column{LeaderboardScoresColumns[1], LeaderboardScoresColumns[3]},
+			},
+			{
+				Name:    "leaderboardscore_score_type",
+				Unique:  false,
+				Columns: []*schema.Column{LeaderboardScoresColumns[4], LeaderboardScoresColumns[3]},
+			},
+			{
+				Name:    "leaderboardscore_leaderboard_id_type",
+				Unique:  false,
+				Columns: []*schema.Column{LeaderboardScoresColumns[6], LeaderboardScoresColumns[3]},
+			},
+			{
+				Name:    "leaderboardscore_leaderboard_id_score_type",
+				Unique:  false,
+				Columns: []*schema.Column{LeaderboardScoresColumns[6], LeaderboardScoresColumns[4], LeaderboardScoresColumns[3]},
+			},
+			{
+				Name:    "leaderboardscore_leaderboard_id_reference_id_type",
+				Unique:  false,
+				Columns: []*schema.Column{LeaderboardScoresColumns[6], LeaderboardScoresColumns[5], LeaderboardScoresColumns[3]},
+			},
+			{
+				Name:    "leaderboardscore_leaderboard_id_reference_id_score_type",
+				Unique:  false,
+				Columns: []*schema.Column{LeaderboardScoresColumns[6], LeaderboardScoresColumns[5], LeaderboardScoresColumns[4], LeaderboardScoresColumns[3]},
+			},
+		},
+	}
 	// SessionsColumns holds the columns for the "sessions" table.
 	SessionsColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeString, Unique: true},
@@ -701,6 +760,7 @@ var (
 		ClansTable,
 		CronTasksTable,
 		DiscordInteractionsTable,
+		LeaderboardScoresTable,
 		SessionsTable,
 		UsersTable,
 		UserConnectionsTable,
diff --git a/internal/database/ent/db/mutation.go b/internal/database/ent/db/mutation.go
index 148fcef9..6c761807 100644
--- a/internal/database/ent/db/mutation.go
+++ b/internal/database/ent/db/mutation.go
@@ -20,6 +20,7 @@ import (
 	"github.com/cufee/aftermath/internal/database/ent/db/clan"
 	"github.com/cufee/aftermath/internal/database/ent/db/crontask"
 	"github.com/cufee/aftermath/internal/database/ent/db/discordinteraction"
+	"github.com/cufee/aftermath/internal/database/ent/db/leaderboardscore"
 	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
 	"github.com/cufee/aftermath/internal/database/ent/db/session"
 	"github.com/cufee/aftermath/internal/database/ent/db/user"
@@ -52,6 +53,7 @@ const (
 	TypeClan                 = "Clan"
 	TypeCronTask             = "CronTask"
 	TypeDiscordInteraction   = "DiscordInteraction"
+	TypeLeaderboardScore     = "LeaderboardScore"
 	TypeSession              = "Session"
 	TypeUser                 = "User"
 	TypeUserConnection       = "UserConnection"
@@ -7051,6 +7053,698 @@ func (m *DiscordInteractionMutation) ResetEdge(name string) error {
 	return fmt.Errorf("unknown DiscordInteraction edge %s", name)
 }
 
+// LeaderboardScoreMutation represents an operation that mutates the LeaderboardScore nodes in the graph.
+type LeaderboardScoreMutation struct {
+	config
+	op             Op
+	typ            string
+	id             *string
+	created_at     *time.Time
+	updated_at     *time.Time
+	_type          *models.ScoreType
+	score          *float32
+	addscore       *float32
+	reference_id   *string
+	leaderboard_id *models.LeaderboardID
+	meta           *map[string]interface{}
+	clearedFields  map[string]struct{}
+	done           bool
+	oldValue       func(context.Context) (*LeaderboardScore, error)
+	predicates     []predicate.LeaderboardScore
+}
+
+var _ ent.Mutation = (*LeaderboardScoreMutation)(nil)
+
+// leaderboardscoreOption allows management of the mutation configuration using functional options.
+type leaderboardscoreOption func(*LeaderboardScoreMutation)
+
+// newLeaderboardScoreMutation creates new mutation for the LeaderboardScore entity.
+func newLeaderboardScoreMutation(c config, op Op, opts ...leaderboardscoreOption) *LeaderboardScoreMutation {
+	m := &LeaderboardScoreMutation{
+		config:        c,
+		op:            op,
+		typ:           TypeLeaderboardScore,
+		clearedFields: make(map[string]struct{}),
+	}
+	for _, opt := range opts {
+		opt(m)
+	}
+	return m
+}
+
+// withLeaderboardScoreID sets the ID field of the mutation.
+func withLeaderboardScoreID(id string) leaderboardscoreOption {
+	return func(m *LeaderboardScoreMutation) {
+		var (
+			err   error
+			once  sync.Once
+			value *LeaderboardScore
+		)
+		m.oldValue = func(ctx context.Context) (*LeaderboardScore, error) {
+			once.Do(func() {
+				if m.done {
+					err = errors.New("querying old values post mutation is not allowed")
+				} else {
+					value, err = m.Client().LeaderboardScore.Get(ctx, id)
+				}
+			})
+			return value, err
+		}
+		m.id = &id
+	}
+}
+
+// withLeaderboardScore sets the old LeaderboardScore of the mutation.
+func withLeaderboardScore(node *LeaderboardScore) leaderboardscoreOption {
+	return func(m *LeaderboardScoreMutation) {
+		m.oldValue = func(context.Context) (*LeaderboardScore, error) {
+			return node, nil
+		}
+		m.id = &node.ID
+	}
+}
+
+// Client returns a new `ent.Client` from the mutation. If the mutation was
+// executed in a transaction (ent.Tx), a transactional client is returned.
+func (m LeaderboardScoreMutation) Client() *Client {
+	client := &Client{config: m.config}
+	client.init()
+	return client
+}
+
+// Tx returns an `ent.Tx` for mutations that were executed in transactions;
+// it returns an error otherwise.
+func (m LeaderboardScoreMutation) Tx() (*Tx, error) {
+	if _, ok := m.driver.(*txDriver); !ok {
+		return nil, errors.New("db: mutation is not running in a transaction")
+	}
+	tx := &Tx{config: m.config}
+	tx.init()
+	return tx, nil
+}
+
+// SetID sets the value of the id field. Note that this
+// operation is only accepted on creation of LeaderboardScore entities.
+func (m *LeaderboardScoreMutation) SetID(id string) {
+	m.id = &id
+}
+
+// ID returns the ID value in the mutation. Note that the ID is only available
+// if it was provided to the builder or after it was returned from the database.
+func (m *LeaderboardScoreMutation) ID() (id string, exists bool) {
+	if m.id == nil {
+		return
+	}
+	return *m.id, true
+}
+
+// IDs queries the database and returns the entity ids that match the mutation's predicate.
+// That means, if the mutation is applied within a transaction with an isolation level such
+// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
+// or updated by the mutation.
+func (m *LeaderboardScoreMutation) IDs(ctx context.Context) ([]string, error) {
+	switch {
+	case m.op.Is(OpUpdateOne | OpDeleteOne):
+		id, exists := m.ID()
+		if exists {
+			return []string{id}, nil
+		}
+		fallthrough
+	case m.op.Is(OpUpdate | OpDelete):
+		return m.Client().LeaderboardScore.Query().Where(m.predicates...).IDs(ctx)
+	default:
+		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
+	}
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (m *LeaderboardScoreMutation) SetCreatedAt(t time.Time) {
+	m.created_at = &t
+}
+
+// CreatedAt returns the value of the "created_at" field in the mutation.
+func (m *LeaderboardScoreMutation) CreatedAt() (r time.Time, exists bool) {
+	v := m.created_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldCreatedAt returns the old "created_at" field's value of the LeaderboardScore entity.
+// If the LeaderboardScore object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *LeaderboardScoreMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldCreatedAt requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
+	}
+	return oldValue.CreatedAt, nil
+}
+
+// ResetCreatedAt resets all changes to the "created_at" field.
+func (m *LeaderboardScoreMutation) ResetCreatedAt() {
+	m.created_at = nil
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (m *LeaderboardScoreMutation) SetUpdatedAt(t time.Time) {
+	m.updated_at = &t
+}
+
+// UpdatedAt returns the value of the "updated_at" field in the mutation.
+func (m *LeaderboardScoreMutation) UpdatedAt() (r time.Time, exists bool) {
+	v := m.updated_at
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldUpdatedAt returns the old "updated_at" field's value of the LeaderboardScore entity.
+// If the LeaderboardScore object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *LeaderboardScoreMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
+	}
+	return oldValue.UpdatedAt, nil
+}
+
+// ResetUpdatedAt resets all changes to the "updated_at" field.
+func (m *LeaderboardScoreMutation) ResetUpdatedAt() {
+	m.updated_at = nil
+}
+
+// SetType sets the "type" field.
+func (m *LeaderboardScoreMutation) SetType(mt models.ScoreType) {
+	m._type = &mt
+}
+
+// GetType returns the value of the "type" field in the mutation.
+func (m *LeaderboardScoreMutation) GetType() (r models.ScoreType, exists bool) {
+	v := m._type
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldType returns the old "type" field's value of the LeaderboardScore entity.
+// If the LeaderboardScore object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *LeaderboardScoreMutation) OldType(ctx context.Context) (v models.ScoreType, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldType is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldType requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldType: %w", err)
+	}
+	return oldValue.Type, nil
+}
+
+// ResetType resets all changes to the "type" field.
+func (m *LeaderboardScoreMutation) ResetType() {
+	m._type = nil
+}
+
+// SetScore sets the "score" field.
+func (m *LeaderboardScoreMutation) SetScore(f float32) {
+	m.score = &f
+	m.addscore = nil
+}
+
+// Score returns the value of the "score" field in the mutation.
+func (m *LeaderboardScoreMutation) Score() (r float32, exists bool) {
+	v := m.score
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldScore returns the old "score" field's value of the LeaderboardScore entity.
+// If the LeaderboardScore object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *LeaderboardScoreMutation) OldScore(ctx context.Context) (v float32, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldScore is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldScore requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldScore: %w", err)
+	}
+	return oldValue.Score, nil
+}
+
+// AddScore adds f to the "score" field.
+func (m *LeaderboardScoreMutation) AddScore(f float32) {
+	if m.addscore != nil {
+		*m.addscore += f
+	} else {
+		m.addscore = &f
+	}
+}
+
+// AddedScore returns the value that was added to the "score" field in this mutation.
+func (m *LeaderboardScoreMutation) AddedScore() (r float32, exists bool) {
+	v := m.addscore
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetScore resets all changes to the "score" field.
+func (m *LeaderboardScoreMutation) ResetScore() {
+	m.score = nil
+	m.addscore = nil
+}
+
+// SetReferenceID sets the "reference_id" field.
+func (m *LeaderboardScoreMutation) SetReferenceID(s string) {
+	m.reference_id = &s
+}
+
+// ReferenceID returns the value of the "reference_id" field in the mutation.
+func (m *LeaderboardScoreMutation) ReferenceID() (r string, exists bool) {
+	v := m.reference_id
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldReferenceID returns the old "reference_id" field's value of the LeaderboardScore entity.
+// If the LeaderboardScore object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *LeaderboardScoreMutation) OldReferenceID(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldReferenceID is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldReferenceID requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldReferenceID: %w", err)
+	}
+	return oldValue.ReferenceID, nil
+}
+
+// ResetReferenceID resets all changes to the "reference_id" field.
+func (m *LeaderboardScoreMutation) ResetReferenceID() {
+	m.reference_id = nil
+}
+
+// SetLeaderboardID sets the "leaderboard_id" field.
+func (m *LeaderboardScoreMutation) SetLeaderboardID(mi models.LeaderboardID) {
+	m.leaderboard_id = &mi
+}
+
+// LeaderboardID returns the value of the "leaderboard_id" field in the mutation.
+func (m *LeaderboardScoreMutation) LeaderboardID() (r models.LeaderboardID, exists bool) {
+	v := m.leaderboard_id
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldLeaderboardID returns the old "leaderboard_id" field's value of the LeaderboardScore entity.
+// If the LeaderboardScore object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *LeaderboardScoreMutation) OldLeaderboardID(ctx context.Context) (v models.LeaderboardID, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldLeaderboardID is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldLeaderboardID requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldLeaderboardID: %w", err)
+	}
+	return oldValue.LeaderboardID, nil
+}
+
+// ResetLeaderboardID resets all changes to the "leaderboard_id" field.
+func (m *LeaderboardScoreMutation) ResetLeaderboardID() {
+	m.leaderboard_id = nil
+}
+
+// SetMeta sets the "meta" field.
+func (m *LeaderboardScoreMutation) SetMeta(value map[string]interface{}) {
+	m.meta = &value
+}
+
+// Meta returns the value of the "meta" field in the mutation.
+func (m *LeaderboardScoreMutation) Meta() (r map[string]interface{}, exists bool) {
+	v := m.meta
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldMeta returns the old "meta" field's value of the LeaderboardScore entity.
+// If the LeaderboardScore object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *LeaderboardScoreMutation) OldMeta(ctx context.Context) (v map[string]interface{}, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldMeta is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldMeta requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldMeta: %w", err)
+	}
+	return oldValue.Meta, nil
+}
+
+// ResetMeta resets all changes to the "meta" field.
+func (m *LeaderboardScoreMutation) ResetMeta() {
+	m.meta = nil
+}
+
+// Where appends a list predicates to the LeaderboardScoreMutation builder.
+func (m *LeaderboardScoreMutation) Where(ps ...predicate.LeaderboardScore) {
+	m.predicates = append(m.predicates, ps...)
+}
+
+// WhereP appends storage-level predicates to the LeaderboardScoreMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *LeaderboardScoreMutation) WhereP(ps ...func(*sql.Selector)) {
+	p := make([]predicate.LeaderboardScore, len(ps))
+	for i := range ps {
+		p[i] = ps[i]
+	}
+	m.Where(p...)
+}
+
+// Op returns the operation name.
+func (m *LeaderboardScoreMutation) Op() Op {
+	return m.op
+}
+
+// SetOp allows setting the mutation operation.
+func (m *LeaderboardScoreMutation) SetOp(op Op) {
+	m.op = op
+}
+
+// Type returns the node type of this mutation (LeaderboardScore).
+func (m *LeaderboardScoreMutation) Type() string {
+	return m.typ
+}
+
+// Fields returns all fields that were changed during this mutation. Note that in
+// order to get all numeric fields that were incremented/decremented, call
+// AddedFields().
+func (m *LeaderboardScoreMutation) Fields() []string {
+	fields := make([]string, 0, 7)
+	if m.created_at != nil {
+		fields = append(fields, leaderboardscore.FieldCreatedAt)
+	}
+	if m.updated_at != nil {
+		fields = append(fields, leaderboardscore.FieldUpdatedAt)
+	}
+	if m._type != nil {
+		fields = append(fields, leaderboardscore.FieldType)
+	}
+	if m.score != nil {
+		fields = append(fields, leaderboardscore.FieldScore)
+	}
+	if m.reference_id != nil {
+		fields = append(fields, leaderboardscore.FieldReferenceID)
+	}
+	if m.leaderboard_id != nil {
+		fields = append(fields, leaderboardscore.FieldLeaderboardID)
+	}
+	if m.meta != nil {
+		fields = append(fields, leaderboardscore.FieldMeta)
+	}
+	return fields
+}
+
+// Field returns the value of a field with the given name. The second boolean
+// return value indicates that this field was not set, or was not defined in the
+// schema.
+func (m *LeaderboardScoreMutation) Field(name string) (ent.Value, bool) {
+	switch name {
+	case leaderboardscore.FieldCreatedAt:
+		return m.CreatedAt()
+	case leaderboardscore.FieldUpdatedAt:
+		return m.UpdatedAt()
+	case leaderboardscore.FieldType:
+		return m.GetType()
+	case leaderboardscore.FieldScore:
+		return m.Score()
+	case leaderboardscore.FieldReferenceID:
+		return m.ReferenceID()
+	case leaderboardscore.FieldLeaderboardID:
+		return m.LeaderboardID()
+	case leaderboardscore.FieldMeta:
+		return m.Meta()
+	}
+	return nil, false
+}
+
+// OldField returns the old value of the field from the database. An error is
+// returned if the mutation operation is not UpdateOne, or the query to the
+// database failed.
+func (m *LeaderboardScoreMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
+	switch name {
+	case leaderboardscore.FieldCreatedAt:
+		return m.OldCreatedAt(ctx)
+	case leaderboardscore.FieldUpdatedAt:
+		return m.OldUpdatedAt(ctx)
+	case leaderboardscore.FieldType:
+		return m.OldType(ctx)
+	case leaderboardscore.FieldScore:
+		return m.OldScore(ctx)
+	case leaderboardscore.FieldReferenceID:
+		return m.OldReferenceID(ctx)
+	case leaderboardscore.FieldLeaderboardID:
+		return m.OldLeaderboardID(ctx)
+	case leaderboardscore.FieldMeta:
+		return m.OldMeta(ctx)
+	}
+	return nil, fmt.Errorf("unknown LeaderboardScore field %s", name)
+}
+
+// SetField sets the value of a field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *LeaderboardScoreMutation) SetField(name string, value ent.Value) error {
+	switch name {
+	case leaderboardscore.FieldCreatedAt:
+		v, ok := value.(time.Time)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetCreatedAt(v)
+		return nil
+	case leaderboardscore.FieldUpdatedAt:
+		v, ok := value.(time.Time)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetUpdatedAt(v)
+		return nil
+	case leaderboardscore.FieldType:
+		v, ok := value.(models.ScoreType)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetType(v)
+		return nil
+	case leaderboardscore.FieldScore:
+		v, ok := value.(float32)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetScore(v)
+		return nil
+	case leaderboardscore.FieldReferenceID:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetReferenceID(v)
+		return nil
+	case leaderboardscore.FieldLeaderboardID:
+		v, ok := value.(models.LeaderboardID)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetLeaderboardID(v)
+		return nil
+	case leaderboardscore.FieldMeta:
+		v, ok := value.(map[string]interface{})
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetMeta(v)
+		return nil
+	}
+	return fmt.Errorf("unknown LeaderboardScore field %s", name)
+}
+
+// AddedFields returns all numeric fields that were incremented/decremented during
+// this mutation.
+func (m *LeaderboardScoreMutation) AddedFields() []string {
+	var fields []string
+	if m.addscore != nil {
+		fields = append(fields, leaderboardscore.FieldScore)
+	}
+	return fields
+}
+
+// AddedField returns the numeric value that was incremented/decremented on a field
+// with the given name. The second boolean return value indicates that this field
+// was not set, or was not defined in the schema.
+func (m *LeaderboardScoreMutation) AddedField(name string) (ent.Value, bool) {
+	switch name {
+	case leaderboardscore.FieldScore:
+		return m.AddedScore()
+	}
+	return nil, false
+}
+
+// AddField adds the value to the field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *LeaderboardScoreMutation) AddField(name string, value ent.Value) error {
+	switch name {
+	case leaderboardscore.FieldScore:
+		v, ok := value.(float32)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddScore(v)
+		return nil
+	}
+	return fmt.Errorf("unknown LeaderboardScore numeric field %s", name)
+}
+
+// ClearedFields returns all nullable fields that were cleared during this
+// mutation.
+func (m *LeaderboardScoreMutation) ClearedFields() []string {
+	return nil
+}
+
+// FieldCleared returns a boolean indicating if a field with the given name was
+// cleared in this mutation.
+func (m *LeaderboardScoreMutation) FieldCleared(name string) bool {
+	_, ok := m.clearedFields[name]
+	return ok
+}
+
+// ClearField clears the value of the field with the given name. It returns an
+// error if the field is not defined in the schema.
+func (m *LeaderboardScoreMutation) ClearField(name string) error {
+	return fmt.Errorf("unknown LeaderboardScore nullable field %s", name)
+}
+
+// ResetField resets all changes in the mutation for the field with the given name.
+// It returns an error if the field is not defined in the schema.
+func (m *LeaderboardScoreMutation) ResetField(name string) error {
+	switch name {
+	case leaderboardscore.FieldCreatedAt:
+		m.ResetCreatedAt()
+		return nil
+	case leaderboardscore.FieldUpdatedAt:
+		m.ResetUpdatedAt()
+		return nil
+	case leaderboardscore.FieldType:
+		m.ResetType()
+		return nil
+	case leaderboardscore.FieldScore:
+		m.ResetScore()
+		return nil
+	case leaderboardscore.FieldReferenceID:
+		m.ResetReferenceID()
+		return nil
+	case leaderboardscore.FieldLeaderboardID:
+		m.ResetLeaderboardID()
+		return nil
+	case leaderboardscore.FieldMeta:
+		m.ResetMeta()
+		return nil
+	}
+	return fmt.Errorf("unknown LeaderboardScore field %s", name)
+}
+
+// AddedEdges returns all edge names that were set/added in this mutation.
+func (m *LeaderboardScoreMutation) AddedEdges() []string {
+	edges := make([]string, 0, 0)
+	return edges
+}
+
+// AddedIDs returns all IDs (to other nodes) that were added for the given edge
+// name in this mutation.
+func (m *LeaderboardScoreMutation) AddedIDs(name string) []ent.Value {
+	return nil
+}
+
+// RemovedEdges returns all edge names that were removed in this mutation.
+func (m *LeaderboardScoreMutation) RemovedEdges() []string {
+	edges := make([]string, 0, 0)
+	return edges
+}
+
+// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
+// the given name in this mutation.
+func (m *LeaderboardScoreMutation) RemovedIDs(name string) []ent.Value {
+	return nil
+}
+
+// ClearedEdges returns all edge names that were cleared in this mutation.
+func (m *LeaderboardScoreMutation) ClearedEdges() []string {
+	edges := make([]string, 0, 0)
+	return edges
+}
+
+// EdgeCleared returns a boolean which indicates if the edge with the given name
+// was cleared in this mutation.
+func (m *LeaderboardScoreMutation) EdgeCleared(name string) bool {
+	return false
+}
+
+// ClearEdge clears the value of the edge with the given name. It returns an error
+// if that edge is not defined in the schema.
+func (m *LeaderboardScoreMutation) ClearEdge(name string) error {
+	return fmt.Errorf("unknown LeaderboardScore unique edge %s", name)
+}
+
+// ResetEdge resets all changes to the edge with the given name in this mutation.
+// It returns an error if the edge is not defined in the schema.
+func (m *LeaderboardScoreMutation) ResetEdge(name string) error {
+	return fmt.Errorf("unknown LeaderboardScore edge %s", name)
+}
+
 // SessionMutation represents an operation that mutates the Session nodes in the graph.
 type SessionMutation struct {
 	config
diff --git a/internal/database/ent/db/predicate/predicate.go b/internal/database/ent/db/predicate/predicate.go
index 5f57ffbb..8eb4deb6 100644
--- a/internal/database/ent/db/predicate/predicate.go
+++ b/internal/database/ent/db/predicate/predicate.go
@@ -33,6 +33,9 @@ type CronTask func(*sql.Selector)
 // DiscordInteraction is the predicate function for discordinteraction builders.
 type DiscordInteraction func(*sql.Selector)
 
+// LeaderboardScore is the predicate function for leaderboardscore builders.
+type LeaderboardScore func(*sql.Selector)
+
 // Session is the predicate function for session builders.
 type Session func(*sql.Selector)
 
diff --git a/internal/database/ent/db/runtime.go b/internal/database/ent/db/runtime.go
index 34a91098..86a1c61d 100644
--- a/internal/database/ent/db/runtime.go
+++ b/internal/database/ent/db/runtime.go
@@ -14,6 +14,7 @@ import (
 	"github.com/cufee/aftermath/internal/database/ent/db/clan"
 	"github.com/cufee/aftermath/internal/database/ent/db/crontask"
 	"github.com/cufee/aftermath/internal/database/ent/db/discordinteraction"
+	"github.com/cufee/aftermath/internal/database/ent/db/leaderboardscore"
 	"github.com/cufee/aftermath/internal/database/ent/db/session"
 	"github.com/cufee/aftermath/internal/database/ent/db/user"
 	"github.com/cufee/aftermath/internal/database/ent/db/userconnection"
@@ -263,6 +264,22 @@ func init() {
 	discordinteractionDescID := discordinteractionFields[0].Descriptor()
 	// discordinteraction.DefaultID holds the default value on creation for the id field.
 	discordinteraction.DefaultID = discordinteractionDescID.Default.(func() string)
+	leaderboardscoreFields := schema.LeaderboardScore{}.Fields()
+	_ = leaderboardscoreFields
+	// leaderboardscoreDescCreatedAt is the schema descriptor for created_at field.
+	leaderboardscoreDescCreatedAt := leaderboardscoreFields[1].Descriptor()
+	// leaderboardscore.DefaultCreatedAt holds the default value on creation for the created_at field.
+	leaderboardscore.DefaultCreatedAt = leaderboardscoreDescCreatedAt.Default.(func() time.Time)
+	// leaderboardscoreDescUpdatedAt is the schema descriptor for updated_at field.
+	leaderboardscoreDescUpdatedAt := leaderboardscoreFields[2].Descriptor()
+	// leaderboardscore.DefaultUpdatedAt holds the default value on creation for the updated_at field.
+	leaderboardscore.DefaultUpdatedAt = leaderboardscoreDescUpdatedAt.Default.(func() time.Time)
+	// leaderboardscore.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
+	leaderboardscore.UpdateDefaultUpdatedAt = leaderboardscoreDescUpdatedAt.UpdateDefault.(func() time.Time)
+	// leaderboardscoreDescID is the schema descriptor for id field.
+	leaderboardscoreDescID := leaderboardscoreFields[0].Descriptor()
+	// leaderboardscore.DefaultID holds the default value on creation for the id field.
+	leaderboardscore.DefaultID = leaderboardscoreDescID.Default.(func() string)
 	sessionFields := schema.Session{}.Fields()
 	_ = sessionFields
 	// sessionDescCreatedAt is the schema descriptor for created_at field.
diff --git a/internal/database/ent/db/tx.go b/internal/database/ent/db/tx.go
index 72a6edce..e067bd1e 100644
--- a/internal/database/ent/db/tx.go
+++ b/internal/database/ent/db/tx.go
@@ -32,6 +32,8 @@ type Tx struct {
 	CronTask *CronTaskClient
 	// DiscordInteraction is the client for interacting with the DiscordInteraction builders.
 	DiscordInteraction *DiscordInteractionClient
+	// LeaderboardScore is the client for interacting with the LeaderboardScore builders.
+	LeaderboardScore *LeaderboardScoreClient
 	// Session is the client for interacting with the Session builders.
 	Session *SessionClient
 	// User is the client for interacting with the User builders.
@@ -188,6 +190,7 @@ func (tx *Tx) init() {
 	tx.Clan = NewClanClient(tx.config)
 	tx.CronTask = NewCronTaskClient(tx.config)
 	tx.DiscordInteraction = NewDiscordInteractionClient(tx.config)
+	tx.LeaderboardScore = NewLeaderboardScoreClient(tx.config)
 	tx.Session = NewSessionClient(tx.config)
 	tx.User = NewUserClient(tx.config)
 	tx.UserConnection = NewUserConnectionClient(tx.config)
diff --git a/internal/database/snapshots.go b/internal/database/snapshots.go
index d6e3fcb6..5fc7697e 100644
--- a/internal/database/snapshots.go
+++ b/internal/database/snapshots.go
@@ -14,30 +14,143 @@ import (
 )
 
 type getSnapshotQuery struct {
-	vehicleIDs []string
+	referenceIDIn    map[string]struct{}
+	referenceIDNotIn map[string]struct{}
 
 	createdAfter  *time.Time
 	createdBefore *time.Time
+
+	fields []string
 }
 
 type SnapshotQuery func(*getSnapshotQuery)
 
-func WithVehicleIDs(ids []string) SnapshotQuery {
+// --- snapshot query options ---
+
+/*
+Constrain referenceID field for the query
+  - if the final list of reference IDs is > 0, reference_id in (ids) will be added to the query
+*/
+func WithReferenceIDIn(ids ...string) SnapshotQuery {
 	return func(q *getSnapshotQuery) {
-		q.vehicleIDs = ids
+		if q.referenceIDIn == nil {
+			q.referenceIDIn = make(map[string]struct{})
+		}
+		for _, id := range ids {
+			q.referenceIDIn[id] = struct{}{}
+		}
+	}
+}
+
+/*
+Constrain referenceID field for the query
+  - if the final list of reference IDs is > 0, reference_id not in (ids) will be added to the query
+*/
+func WithReferenceIDNotIn(ids ...string) SnapshotQuery {
+	return func(q *getSnapshotQuery) {
+		if q.referenceIDNotIn == nil {
+			q.referenceIDNotIn = make(map[string]struct{})
+		}
+		for _, id := range ids {
+			q.referenceIDNotIn[id] = struct{}{}
+		}
 	}
 }
+
+/*
+Adds a created_at lt constraint
+  - if this constraint is set, records will be sorted by created_at ASC
+*/
 func WithCreatedAfter(after time.Time) SnapshotQuery {
 	return func(q *getSnapshotQuery) {
 		q.createdAfter = &after
 	}
 }
+
+/*
+Adds a created_at gt constraint
+  - if this constraint is set, records will be sorted by created_at DESC
+*/
 func WithCreatedBefore(before time.Time) SnapshotQuery {
 	return func(q *getSnapshotQuery) {
 		q.createdBefore = &before
 	}
 }
 
+/*
+Set fields that will be selected.
+  - Some fields like id, created_at, updated_at will always be selected
+  - Passing 0 length fields will result in select *
+*/
+func WithSelect(fields ...string) SnapshotQuery {
+	return func(q *getSnapshotQuery) {
+		// make sure fields are unique
+		fieldsSet := make(map[string]struct{})
+		for _, field := range append(q.fields, fields...) {
+			fieldsSet[field] = struct{}{}
+		}
+
+		// passing 0 length fields will result in select *
+		q.fields = nil
+		for field := range fieldsSet {
+			q.fields = append(q.fields, field)
+		}
+	}
+}
+
+/*
+Returns a slice of fields for a select statement with all duplicates removed and required fields added
+  - if query.fields is nil, returns a nil slice
+*/
+func (q *getSnapshotQuery) selectFields(required ...string) []string {
+	if q.fields == nil {
+		return nil
+	}
+
+	// maker sure all required fields are part of the slice
+	var requiredFields = make(map[string]struct{})
+	for _, field := range required {
+		requiredFields[field] = struct{}{}
+	}
+
+	for _, field := range q.fields {
+		for required := range requiredFields {
+			if field == required {
+				delete(requiredFields, required)
+			}
+		}
+	}
+	for field := range requiredFields {
+		q.fields = append(q.fields, field)
+	}
+
+	return q.fields
+}
+
+func (q *getSnapshotQuery) refIDIn() []any {
+	if len(q.referenceIDIn) == 0 {
+		return nil
+	}
+	var ids []any
+	for id := range q.referenceIDIn {
+		ids = append(ids, id)
+	}
+	return ids
+}
+
+func (q *getSnapshotQuery) refIDNotIn() []any {
+	if len(q.referenceIDNotIn) == 0 {
+		return nil
+	}
+	var ids []any
+	for id := range q.referenceIDNotIn {
+		ids = append(ids, id)
+	}
+	return ids
+}
+
+// --- record to model ---
+
 func toVehicleSnapshot(record *db.VehicleSnapshot) models.VehicleSnapshot {
 	return models.VehicleSnapshot{
 		ID:             record.ID,
@@ -51,9 +164,117 @@ func toVehicleSnapshot(record *db.VehicleSnapshot) models.VehicleSnapshot {
 	}
 }
 
+func toAccountSnapshot(record *db.AccountSnapshot) models.AccountSnapshot {
+	return models.AccountSnapshot{
+		ID:             record.ID,
+		Type:           record.Type,
+		AccountID:      record.AccountID,
+		ReferenceID:    record.ReferenceID,
+		RatingBattles:  record.RatingFrame,
+		RegularBattles: record.RegularFrame,
+		CreatedAt:      record.CreatedAt,
+		LastBattleTime: record.LastBattleTime,
+	}
+}
+
+func toAchievementsSnapshot(record *db.AchievementsSnapshot) models.AchievementsSnapshot {
+	return models.AchievementsSnapshot{
+		ID:             record.ID,
+		Type:           record.Type,
+		CreatedAt:      record.CreatedAt,
+		LastBattleTime: record.LastBattleTime,
+		ReferenceID:    record.ReferenceID,
+		AccountID:      record.AccountID,
+		Battles:        record.Battles,
+		Data:           record.Data,
+	}
+}
+
+// --- vehicle snapshots ---
+
+/*
+Get complete vehicle snapshots fot each vehicle ID in vehicle IDs for a specific account
+  - passing nil vehicleIDs will return all vehicles available
+*/
+func (c *client) GetVehicleSnapshots(ctx context.Context, accountID string, vehicleIDs []string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.VehicleSnapshot, error) {
+	var query getSnapshotQuery
+	for _, apply := range options {
+		apply(&query)
+	}
+
+	queryString, queryArgs := vehiclesQuery(accountID, vehicleIDs, kind, vehiclesnapshot.FieldVehicleID, query)
+	rows, err := c.db.VehicleSnapshot.QueryContext(ctx, queryString, queryArgs...)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var snapshots []models.VehicleSnapshot
+	for rows.Next() {
+		var record db.VehicleSnapshot
+
+		values, err := record.ScanValues(vehiclesnapshot.Columns)
+		if err != nil {
+			return nil, err
+		}
+		if err := rows.Scan(values...); err != nil {
+			return nil, err
+		}
+
+		err = record.AssignValues(vehiclesnapshot.Columns, values)
+		if err != nil {
+			return nil, err
+		}
+		snapshots = append(snapshots, toVehicleSnapshot(&record))
+	}
+
+	return snapshots, nil
+}
+
+/*
+get last battle times for each vehicle in vehicle IDs for a specific account
+  - passing nil vehicleIDs will return all vehicles available
+*/
+func (c *client) GetVehicleLastBattleTimes(ctx context.Context, accountID string, vehicleIDs []string, kind models.SnapshotType, options ...SnapshotQuery) (map[string]time.Time, error) {
+	var query getSnapshotQuery
+	for _, apply := range options {
+		apply(&query)
+	}
+	WithSelect(vehiclesnapshot.FieldVehicleID, vehiclesnapshot.FieldLastBattleTime)(&query)
+
+	queryString, queryArgs := vehiclesQuery(accountID, vehicleIDs, kind, vehiclesnapshot.FieldVehicleID, query)
+	rows, err := c.db.VehicleSnapshot.QueryContext(ctx, queryString, queryArgs...)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var lastBattleTimes = make(map[string]time.Time)
+	for rows.Next() {
+		var record db.VehicleSnapshot
+
+		values, err := record.ScanValues([]string{vehiclesnapshot.FieldVehicleID, vehiclesnapshot.FieldLastBattleTime})
+		if err != nil {
+			return nil, err
+		}
+		if err := rows.Scan(values...); err != nil {
+			return nil, err
+		}
+
+		err = record.AssignValues([]string{vehiclesnapshot.FieldVehicleID, vehiclesnapshot.FieldLastBattleTime}, values)
+		if err != nil {
+			return nil, err
+		}
+		lastBattleTimes[record.VehicleID] = record.LastBattleTime
+	}
+
+	return lastBattleTimes, nil
+}
+
+// create vehicle snapshots for a specific account
 func (c *client) CreateAccountVehicleSnapshots(ctx context.Context, accountID string, snapshots ...models.VehicleSnapshot) (map[string]error, error) {
 	if len(snapshots) < 1 {
-		return nil, nil
+		return nil, new(db.NotFoundError)
 	}
 
 	account, err := c.db.Account.Get(ctx, accountID)
@@ -87,21 +308,25 @@ func (c *client) CreateAccountVehicleSnapshots(ctx context.Context, accountID st
 	return nil, nil
 }
 
-func (c *client) GetVehicleSnapshots(ctx context.Context, accountID, referenceID string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.VehicleSnapshot, error) {
-	var query getSnapshotQuery
-	for _, apply := range options {
-		apply(&query)
+// build a complete query for vehicle snapshots
+func vehiclesQuery(accountID string, vehicleIDs []string, kind models.SnapshotType, groupBy string, query getSnapshotQuery) (string, []any) {
+	// required where constraints
+	var innerWhere []*sql.Predicate
+	innerWhere = append(innerWhere, sql.EQ(vehiclesnapshot.FieldType, kind), sql.EQ(vehiclesnapshot.FieldAccountID, accountID))
+
+	// optional where constraints
+	if vehicleIDs != nil {
+		innerWhere = append(innerWhere, sql.In(vehiclesnapshot.FieldVehicleID, toAnySlice(vehicleIDs...)...))
+	}
+	if in := query.refIDIn(); in != nil {
+		innerWhere = append(innerWhere, sql.In(vehiclesnapshot.FieldReferenceID, in...))
+	}
+	if nin := query.refIDNotIn(); nin != nil {
+		innerWhere = append(innerWhere, sql.NotIn(vehiclesnapshot.FieldReferenceID, nin...))
 	}
 
-	// this query is impossible to build using the db.VehicleSnapshots methods, so we do it manually
-	var innerWhere []*sql.Predicate
-	innerWhere = append(innerWhere,
-		sql.EQ(vehiclesnapshot.FieldType, kind),
-		sql.EQ(vehiclesnapshot.FieldAccountID, accountID),
-		sql.EQ(vehiclesnapshot.FieldReferenceID, referenceID),
-	)
+	// order and created_at constraints
 	innerOrder := sql.Desc(vehiclesnapshot.FieldCreatedAt)
-
 	if query.createdAfter != nil {
 		innerWhere = append(innerWhere, sql.GT(vehiclesnapshot.FieldCreatedAt, *query.createdAfter))
 		innerOrder = sql.Asc(vehiclesnapshot.FieldCreatedAt)
@@ -110,13 +335,6 @@ func (c *client) GetVehicleSnapshots(ctx context.Context, accountID, referenceID
 		innerWhere = append(innerWhere, sql.LT(vehiclesnapshot.FieldCreatedAt, *query.createdBefore))
 		innerOrder = sql.Desc(vehiclesnapshot.FieldCreatedAt)
 	}
-	if len(query.vehicleIDs) > 0 {
-		var ids []any
-		for _, id := range query.vehicleIDs {
-			ids = append(ids, id)
-		}
-		innerWhere = append(innerWhere, sql.In(vehiclesnapshot.FieldVehicleID, ids...))
-	}
 
 	innerQuery := sql.Select(vehiclesnapshot.Columns...).From(sql.Table(vehiclesnapshot.Table))
 	innerQuery = innerQuery.Where(sql.And(innerWhere...))
@@ -127,19 +345,44 @@ func (c *client) GetVehicleSnapshots(ctx context.Context, accountID, referenceID
 	// wrap the inner query in a GROUP BY
 	wrapper := &sql.Builder{}
 	wrapped := wrapper.Wrap(func(b *sql.Builder) { b.WriteString(innerQueryString) })
-	queryString, _ := sql.Select("*").FromExpr(wrapped).GroupBy(vehiclesnapshot.FieldVehicleID).Query()
 
-	rows, err := c.db.VehicleSnapshot.QueryContext(ctx, queryString, innerQueryArgs...)
+	selector := sql.Select("*")
+	if fields := query.selectFields(groupBy); fields != nil {
+		// make sure FieldVehicleID is selected, we need it for Group By
+		selector = sql.Select(fields...)
+	}
+	queryString, _ := selector.FromExpr(wrapped).GroupBy(groupBy).Query()
+	return queryString, innerQueryArgs
+}
+
+// --- account snapshots ---
+
+/*
+Get complete snapshots for accounts by ID, grouped by account ID
+  - there are no use cases where all accounts should be returned for now, so nil slice of ids will return an error
+*/
+func (c *client) GetAccountSnapshots(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.AccountSnapshot, error) {
+	if len(accountIDs) < 1 {
+		return nil, new(db.NotFoundError)
+	}
+
+	var query getSnapshotQuery
+	for _, apply := range options {
+		apply(&query)
+	}
+
+	queryString, queryArgs := accountsQuery(accountIDs, kind, accountsnapshot.FieldAccountID, query)
+	rows, err := c.db.AccountSnapshot.QueryContext(ctx, queryString, queryArgs...)
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
 
-	var snapshots []models.VehicleSnapshot
+	var snapshots []models.AccountSnapshot
 	for rows.Next() {
-		var record db.VehicleSnapshot
+		var record db.AccountSnapshot
 
-		values, err := record.ScanValues(vehiclesnapshot.Columns)
+		values, err := record.ScanValues(accountsnapshot.Columns)
 		if err != nil {
 			return nil, err
 		}
@@ -147,32 +390,62 @@ func (c *client) GetVehicleSnapshots(ctx context.Context, accountID, referenceID
 			return nil, err
 		}
 
-		err = record.AssignValues(vehiclesnapshot.Columns, values)
+		err = record.AssignValues(accountsnapshot.Columns, values)
 		if err != nil {
 			return nil, err
 		}
-		snapshots = append(snapshots, toVehicleSnapshot(&record))
+		snapshots = append(snapshots, toAccountSnapshot(&record))
 	}
 
 	return snapshots, nil
 }
 
-func toAccountSnapshot(record *db.AccountSnapshot) models.AccountSnapshot {
-	return models.AccountSnapshot{
-		ID:             record.ID,
-		Type:           record.Type,
-		AccountID:      record.AccountID,
-		ReferenceID:    record.ReferenceID,
-		RatingBattles:  record.RatingFrame,
-		RegularBattles: record.RegularFrame,
-		CreatedAt:      record.CreatedAt,
-		LastBattleTime: record.LastBattleTime,
+/*
+Get last battle times for accounts by ID, grouped by account ID
+*/
+func (c *client) GetAccountLastBattleTimes(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...SnapshotQuery) (map[string]time.Time, error) {
+	if len(accountIDs) < 1 {
+		return nil, new(db.NotFoundError)
 	}
+
+	var query getSnapshotQuery
+	for _, apply := range options {
+		apply(&query)
+	}
+	WithSelect(accountsnapshot.FieldAccountID, accountsnapshot.FieldLastBattleTime)(&query)
+
+	queryStr, queryArgs := accountsQuery(accountIDs, kind, accountsnapshot.FieldAccountID, query)
+	rows, err := c.db.AccountSnapshot.QueryContext(ctx, queryStr, queryArgs...)
+	if err != nil {
+		return nil, err
+	}
+
+	var lastBattles = make(map[string]time.Time)
+	for rows.Next() {
+		var record db.AccountSnapshot
+
+		values, err := record.ScanValues([]string{accountsnapshot.FieldAccountID, accountsnapshot.FieldLastBattleTime})
+		if err != nil {
+			return nil, err
+		}
+		if err := rows.Scan(values...); err != nil {
+			return nil, err
+		}
+
+		err = record.AssignValues([]string{accountsnapshot.FieldAccountID, accountsnapshot.FieldLastBattleTime}, values)
+		if err != nil {
+			return nil, err
+		}
+
+		lastBattles[record.ReferenceID] = record.LastBattleTime
+	}
+
+	return lastBattles, nil
 }
 
 func (c *client) CreateAccountSnapshots(ctx context.Context, snapshots ...models.AccountSnapshot) (map[string]error, error) {
 	if len(snapshots) < 1 {
-		return nil, nil
+		return nil, new(db.NotFoundError)
 	}
 
 	var errors = make(map[string]error)
@@ -205,89 +478,87 @@ func (c *client) CreateAccountSnapshots(ctx context.Context, snapshots ...models
 	return nil, nil
 }
 
-func (c *client) GetLastAccountSnapshots(ctx context.Context, accountID string, limit int) ([]models.AccountSnapshot, error) {
-	records, err := c.db.AccountSnapshot.Query().Where(accountsnapshot.AccountID(accountID)).Order(accountsnapshot.ByCreatedAt(sql.OrderDesc())).Limit(limit).All(ctx)
-	if err != nil {
-		return nil, err
-	}
+// build a complete query for account snapshot
+func accountsQuery(accountIDs []string, kind models.SnapshotType, groupBy string, query getSnapshotQuery) (string, []any) {
+	// required where constraints
+	var innerWhere []*sql.Predicate
+	innerWhere = append(innerWhere, sql.EQ(accountsnapshot.FieldType, kind), sql.In(accountsnapshot.FieldAccountID, toAnySlice(accountIDs...)...))
 
-	var snapshots []models.AccountSnapshot
-	for _, r := range records {
-		snapshots = append(snapshots, toAccountSnapshot(r))
+	// optional where constraints
+	if in := query.refIDIn(); in != nil {
+		innerWhere = append(innerWhere, sql.In(accountsnapshot.FieldReferenceID, in...))
 	}
-
-	return snapshots, nil
-}
-
-func (c *client) GetAccountSnapshot(ctx context.Context, accountID, referenceID string, kind models.SnapshotType, options ...SnapshotQuery) (models.AccountSnapshot, error) {
-	var query getSnapshotQuery
-	for _, apply := range options {
-		apply(&query)
+	if nin := query.refIDNotIn(); nin != nil {
+		innerWhere = append(innerWhere, sql.NotIn(accountsnapshot.FieldReferenceID, nin...))
 	}
 
-	var where []predicate.AccountSnapshot
-	order := accountsnapshot.ByCreatedAt(sql.OrderDesc())
-	where = append(where, accountsnapshot.AccountID(accountID), accountsnapshot.ReferenceID(referenceID), accountsnapshot.TypeEQ(kind))
+	// order and created_at constraints
+	innerOrder := sql.Desc(accountsnapshot.FieldCreatedAt)
 	if query.createdAfter != nil {
-		order = accountsnapshot.ByCreatedAt(sql.OrderAsc())
-		where = append(where, accountsnapshot.CreatedAtGT(*query.createdAfter))
+		innerWhere = append(innerWhere, sql.GT(accountsnapshot.FieldCreatedAt, *query.createdAfter))
+		innerOrder = sql.Asc(accountsnapshot.FieldCreatedAt)
 	}
 	if query.createdBefore != nil {
-		where = append(where, accountsnapshot.CreatedAtLT(*query.createdBefore))
+		innerWhere = append(innerWhere, sql.LT(accountsnapshot.FieldCreatedAt, *query.createdBefore))
+		innerOrder = sql.Desc(accountsnapshot.FieldCreatedAt)
 	}
 
-	record, err := c.db.AccountSnapshot.Query().Where(where...).Order(order).First(ctx)
-	if err != nil {
-		return models.AccountSnapshot{}, err
-	}
+	innerQuery := sql.Select(accountsnapshot.Columns...).From(sql.Table(accountsnapshot.Table))
+	innerQuery = innerQuery.Where(sql.And(innerWhere...))
+	innerQuery = innerQuery.OrderBy(innerOrder)
+
+	innerQueryString, innerQueryArgs := innerQuery.Query()
 
-	return toAccountSnapshot(record), nil
+	// wrap the inner query in a GROUP BY
+	wrapper := &sql.Builder{}
+	wrapped := wrapper.Wrap(func(b *sql.Builder) { b.WriteString(innerQueryString) })
+
+	selector := sql.Select("*")
+	if fields := query.selectFields(groupBy); fields != nil {
+		// make sure FieldVehicleID is selected, we need it for Group By
+		selector = sql.Select(fields...)
+	}
+	queryString, _ := selector.FromExpr(wrapped).GroupBy(groupBy).Query()
+	return queryString, innerQueryArgs
 }
 
-func (c *client) GetManyAccountSnapshots(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.AccountSnapshot, error) {
+// --- achievement snapshots ---
+
+func (c *client) GetAchievementSnapshots(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.AchievementsSnapshot, error) {
+	if len(accountIDs) < 1 {
+		return nil, new(db.NotFoundError)
+	}
+
 	var query getSnapshotQuery
 	for _, apply := range options {
 		apply(&query)
 	}
 
-	var where []predicate.AccountSnapshot
-	where = append(where, accountsnapshot.AccountIDIn(accountIDs...), accountsnapshot.TypeEQ(kind))
+	var where []predicate.AchievementsSnapshot
+	where = append(where, achievementssnapshot.AccountIDIn(accountIDs...), achievementssnapshot.TypeEQ(kind))
 	if query.createdAfter != nil {
-		where = append(where, accountsnapshot.CreatedAtGT(*query.createdAfter))
+		where = append(where, achievementssnapshot.CreatedAtGT(*query.createdAfter))
 	}
 	if query.createdBefore != nil {
-		where = append(where, accountsnapshot.CreatedAtLT(*query.createdAfter))
+		where = append(where, achievementssnapshot.CreatedAtLT(*query.createdAfter))
 	}
 
-	records, err := c.db.AccountSnapshot.Query().Where(where...).All(ctx)
+	records, err := c.db.AchievementsSnapshot.Query().Select(query.selectFields()...).Where(where...).All(ctx)
 	if err != nil {
 		return nil, err
 	}
 
-	var snapshots []models.AccountSnapshot
+	var snapshots []models.AchievementsSnapshot
 	for _, r := range records {
-		snapshots = append(snapshots, toAccountSnapshot(r))
+		snapshots = append(snapshots, toAchievementsSnapshot(r))
 	}
 
 	return snapshots, nil
 }
 
-func toAchievementsSnapshot(record *db.AchievementsSnapshot) models.AchievementsSnapshot {
-	return models.AchievementsSnapshot{
-		ID:             record.ID,
-		Type:           record.Type,
-		CreatedAt:      record.CreatedAt,
-		LastBattleTime: record.LastBattleTime,
-		ReferenceID:    record.ReferenceID,
-		AccountID:      record.AccountID,
-		Battles:        record.Battles,
-		Data:           record.Data,
-	}
-}
-
 func (c *client) CreateAccountAchievementSnapshots(ctx context.Context, accountID string, snapshots ...models.AchievementsSnapshot) (map[string]error, error) {
 	if len(snapshots) < 1 {
-		return nil, nil
+		return nil, new(db.NotFoundError)
 	}
 
 	account, err := c.db.Account.Get(ctx, accountID)
@@ -319,72 +590,3 @@ func (c *client) CreateAccountAchievementSnapshots(ctx context.Context, accountI
 	}
 	return nil, nil
 }
-
-func (c *client) GetAchievementsSnapshots(ctx context.Context, accountID string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.AchievementsSnapshot, error) {
-	var query getSnapshotQuery
-	for _, apply := range options {
-		apply(&query)
-	}
-
-	// this query is impossible to build using the db.AchievementSnapshot methods, so we do it manually
-	var innerWhere []*sql.Predicate
-	innerWhere = append(innerWhere,
-		sql.EQ(achievementssnapshot.FieldType, kind),
-		sql.EQ(achievementssnapshot.FieldAccountID, accountID),
-	)
-	innerOrder := sql.Desc(achievementssnapshot.FieldCreatedAt)
-
-	if query.createdAfter != nil {
-		innerWhere = append(innerWhere, sql.GT(achievementssnapshot.FieldCreatedAt, *query.createdAfter))
-		innerOrder = sql.Asc(achievementssnapshot.FieldCreatedAt)
-	}
-	if query.createdBefore != nil {
-		innerWhere = append(innerWhere, sql.LT(achievementssnapshot.FieldCreatedAt, *query.createdBefore))
-		innerOrder = sql.Desc(achievementssnapshot.FieldCreatedAt)
-	}
-	if len(query.vehicleIDs) > 0 {
-		var ids []any
-		for _, id := range query.vehicleIDs {
-			ids = append(ids, id)
-		}
-		innerWhere = append(innerWhere, sql.In(achievementssnapshot.FieldReferenceID, append(ids, accountID)...))
-	}
-
-	innerQuery := sql.Select(achievementssnapshot.Columns...).From(sql.Table(achievementssnapshot.Table))
-	innerQuery = innerQuery.Where(sql.And(innerWhere...))
-	innerQuery = innerQuery.OrderBy(innerOrder)
-
-	innerQueryString, innerQueryArgs := innerQuery.Query()
-
-	// wrap the inner query in a GROUP BY
-	wrapper := &sql.Builder{}
-	wrapped := wrapper.Wrap(func(b *sql.Builder) { b.WriteString(innerQueryString) })
-	queryString, _ := sql.Select("*").FromExpr(wrapped).GroupBy(achievementssnapshot.FieldReferenceID).Query()
-
-	rows, err := c.db.AchievementsSnapshot.QueryContext(ctx, queryString, innerQueryArgs...)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	var snapshots []models.AchievementsSnapshot
-	for rows.Next() {
-		var record db.AchievementsSnapshot
-
-		values, err := record.ScanValues(achievementssnapshot.Columns)
-		if err != nil {
-			return nil, err
-		}
-		if err := rows.Scan(values...); err != nil {
-			return nil, err
-		}
-
-		err = record.AssignValues(achievementssnapshot.Columns, values)
-		if err != nil {
-			return nil, err
-		}
-		snapshots = append(snapshots, toAchievementsSnapshot(&record))
-	}
-
-	return snapshots, nil
-}
diff --git a/internal/database/snapshots_test.go b/internal/database/snapshots_test.go
index 0726554d..a4db4a62 100644
--- a/internal/database/snapshots_test.go
+++ b/internal/database/snapshots_test.go
@@ -98,31 +98,31 @@ func TestGetVehicleSnapshots(t *testing.T) {
 		assert.Nil(t, aErr, "insert returned some errors")
 	}
 	{ // when we check created after, vehicles need to be ordered by createdAt ASC, so we expect to get vehicle2 back
-		vehicles, err := client.GetVehicleSnapshots(ctx, "a1", "r1", models.SnapshotTypeDaily, WithCreatedAfter(createdAtVehicle1))
+		vehicles, err := client.GetVehicleSnapshots(ctx, "a1", nil, models.SnapshotTypeDaily, WithCreatedAfter(createdAtVehicle1), WithReferenceIDIn("r1"))
 		assert.NoError(t, err, "get vehicle snapshot error")
 		assert.Len(t, vehicles, 1, "should return exactly 1 snapshot")
 		assert.True(t, vehicles[0].CreatedAt.Equal(createdAtVehicle2), "wrong vehicle snapshot returned\nvehicles:%#v\nexpected:%#v", vehicles, createdAtVehicle2)
 	}
 	{ // when we check created before, vehicles need to be ordered by createdAt DESC, so we expect to get vehicle2 back
-		vehicles, err := client.GetVehicleSnapshots(ctx, "a1", "r1", models.SnapshotTypeDaily, WithCreatedBefore(createdAtVehicle3))
+		vehicles, err := client.GetVehicleSnapshots(ctx, "a1", nil, models.SnapshotTypeDaily, WithCreatedBefore(createdAtVehicle3), WithReferenceIDIn("r1"))
 		assert.NoError(t, err, "get vehicle snapshot error")
 		assert.Len(t, vehicles, 1, "should return exactly 1 snapshot")
 		assert.True(t, vehicles[0].CreatedAt.Equal(createdAtVehicle2), "wrong vehicle snapshot returned\nvehicles:%#v\nexpected:%#v", vehicles, createdAtVehicle2)
 	}
 	{ // make sure only 1 vehicle is returned per ID
-		vehicles, err := client.GetVehicleSnapshots(ctx, "a1", "r2", models.SnapshotTypeDaily, WithCreatedBefore(createdAtVehicle5.Add(time.Hour)))
+		vehicles, err := client.GetVehicleSnapshots(ctx, "a1", nil, models.SnapshotTypeDaily, WithCreatedBefore(createdAtVehicle5.Add(time.Hour)), WithReferenceIDIn("r2"))
 		assert.NoError(t, err, "get vehicle snapshot error")
 		assert.Len(t, vehicles, 2, "should return exactly 2 snapshot")
 		assert.NotEqual(t, vehicles[0].ID, vehicles[1].ID, "each vehicle id should only be returned once\nvehicles:%#v", vehicles)
 	}
 	{ // get a vehicle with a specific id
-		vehicles, err := client.GetVehicleSnapshots(ctx, "a1", "r2", models.SnapshotTypeDaily, WithVehicleIDs([]string{"v5"}))
+		vehicles, err := client.GetVehicleSnapshots(ctx, "a1", []string{"v5"}, models.SnapshotTypeDaily, WithReferenceIDIn("r2"))
 		assert.NoError(t, err, "get vehicle snapshot error")
 		assert.Len(t, vehicles, 1, "should return exactly 1 snapshot")
 		assert.NotEqual(t, vehicles[0].ID, "v5", "incorrect vehicle returned\nvehicles:%#v", vehicles)
 	}
 	{ // this should return no result
-		vehicles, err := client.GetVehicleSnapshots(ctx, "a1", "r1", models.SnapshotTypeDaily, WithCreatedBefore(createdAtVehicle1))
+		vehicles, err := client.GetVehicleSnapshots(ctx, "a1", nil, models.SnapshotTypeDaily, WithCreatedBefore(createdAtVehicle1), WithReferenceIDIn("r1"))
 		assert.NoError(t, err, "no results from a raw query does not trigger an error")
 		assert.Len(t, vehicles, 0, "return should have no results\nvehicles:%#v", vehicles)
 	}
diff --git a/internal/logic/snapshots.go b/internal/logic/snapshots.go
index c71db3f1..cd98f187 100644
--- a/internal/logic/snapshots.go
+++ b/internal/logic/snapshots.go
@@ -26,20 +26,16 @@ Gets all accounts from WH and their respective snapshots
   - an account is considered valid is it has played a battle since the last snapshot, or has no snapshots
   - as side effect, invalid accounts will be set as private
 */
-func getAndValidateAccounts(ctx context.Context, wgClient wargaming.Client, dbClient database.Client, force bool, realm string, accountIDs ...string) (map[string]types.ExtendedAccount, []string, map[string]*models.AccountSnapshot, error) {
+func getAndValidateAccounts(ctx context.Context, wgClient wargaming.Client, dbClient database.Client, force bool, realm string, accountIDs ...string) (map[string]types.ExtendedAccount, []string, error) {
 	accounts, err := wgClient.BatchAccountByID(ctx, realm, accountIDs)
 	if err != nil {
-		return nil, nil, nil, errors.Wrap(err, "failed to fetch accounts")
+		return nil, nil, errors.Wrap(err, "failed to fetch accounts")
 	}
 
 	// existing snapshots for accounts
-	existingSnapshots, err := dbClient.GetManyAccountSnapshots(ctx, accountIDs, models.SnapshotTypeDaily)
+	existingLastBattleTimes, err := dbClient.GetAccountLastBattleTimes(ctx, accountIDs, models.SnapshotTypeDaily)
 	if err != nil && !database.IsNotFound(err) {
-		return nil, nil, nil, errors.Wrap(err, "failed to get existing snapshots")
-	}
-	existingSnapshotsMap := make(map[string]*models.AccountSnapshot)
-	for _, snapshot := range existingSnapshots {
-		existingSnapshotsMap[snapshot.AccountID] = &snapshot
+		return nil, nil, errors.Wrap(err, "failed to get existing snapshots")
 	}
 
 	// make a new slice just in case some accounts were not returned/are private
@@ -62,13 +58,13 @@ func getAndValidateAccounts(ctx context.Context, wgClient wargaming.Client, dbCl
 		if data.LastBattleTime < 1 {
 			continue
 		}
-		if s, ok := existingSnapshotsMap[id]; !force && (ok && data.LastBattleTime == int(s.LastBattleTime.Unix())) {
+		if s, ok := existingLastBattleTimes[id]; !force && (ok && data.LastBattleTime == int(s.Unix())) {
 			// last snapshot is the same, we can skip it
 			continue
 		}
 		needAnUpdate = append(needAnUpdate, id)
 	}
-	return accounts, needAnUpdate, existingSnapshotsMap, nil
+	return accounts, needAnUpdate, nil
 }
 
 func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbClient database.Client, realm string, force bool, accountIDs ...string) (map[string]error, error) {
@@ -77,7 +73,10 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 	}
 	createdAt := time.Now()
 
-	accounts, accountsNeedAnUpdate, _, err := getAndValidateAccounts(ctx, wgClient, dbClient, force, realm, accountIDs...)
+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+
+	accounts, accountsNeedAnUpdate, err := getAndValidateAccounts(ctx, wgClient, dbClient, force, realm, accountIDs...)
 	if err != nil {
 		return nil, err
 	}
@@ -160,15 +159,11 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 		}
 
 		// get existing vehicle snapshots from db
-		existingSnapshots, err := dbClient.GetVehicleSnapshots(ctx, accountID, accountID, models.SnapshotTypeDaily)
+		existingLastBattleTimes, err := dbClient.GetVehicleLastBattleTimes(ctx, accountID, nil, models.SnapshotTypeDaily)
 		if err != nil && !database.IsNotFound(err) {
 			accountErrors[accountID] = err
 			continue
 		}
-		existingSnapshotsMap := make(map[string]*models.VehicleSnapshot)
-		for _, snapshot := range existingSnapshots {
-			existingSnapshotsMap[snapshot.VehicleID] = &snapshot
-		}
 
 		snapshotStats := fetch.WargamingToStats(realm, accounts[accountID], clans[accountID], vehicles.Data)
 		{ // account snapshot
@@ -189,7 +184,7 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 		vehicleStats := fetch.WargamingVehiclesToFrame(vehicles.Data)
 		if len(vehicles.Data) > 0 {
 			for id, vehicle := range vehicleStats {
-				if s, ok := existingSnapshotsMap[id]; !force && ok && s.LastBattleTime.Equal(vehicle.LastBattleTime) {
+				if s, ok := existingLastBattleTimes[id]; !force && ok && s.Equal(vehicle.LastBattleTime) {
 					// last snapshot is the same, we can skip it
 					continue
 				}
diff --git a/internal/stats/fetch/v1/multisource.go b/internal/stats/fetch/v1/multisource.go
index 3ae56c51..3c13bd93 100644
--- a/internal/stats/fetch/v1/multisource.go
+++ b/internal/stats/fetch/v1/multisource.go
@@ -9,6 +9,7 @@ import (
 	"github.com/pkg/errors"
 
 	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/ent/db"
 	"github.com/cufee/aftermath/internal/database/models"
 
 	"github.com/cufee/aftermath/internal/external/blitzstars"
@@ -310,14 +311,24 @@ func (c *multiSourceClient) SessionStats(ctx context.Context, id string, session
 
 	group.Add(1)
 	go func() {
+		var opts = []database.SnapshotQuery{database.WithCreatedBefore(sessionBefore)}
+		if options.referenceID != "" {
+			opts = append(opts, database.WithReferenceIDIn(options.referenceID))
+		}
+
 		defer group.Done()
-		s, err := c.database.GetAccountSnapshot(ctx, id, options.referenceID, options.snapshotType, database.WithCreatedBefore(sessionBefore))
-		accountSnapshot = retry.DataWithErr[models.AccountSnapshot]{Data: s, Err: err}
+		s, err := c.database.GetAccountSnapshots(ctx, []string{id}, options.snapshotType, opts...)
 		if err != nil {
+			accountSnapshot = retry.DataWithErr[models.AccountSnapshot]{Err: err}
+			return
+		}
+		if len(s) < 1 {
+			accountSnapshot = retry.DataWithErr[models.AccountSnapshot]{Err: new(db.NotFoundError)}
 			return
 		}
+		accountSnapshot = retry.DataWithErr[models.AccountSnapshot]{Data: s[0]}
 
-		v, err := c.database.GetVehicleSnapshots(ctx, id, options.referenceID, options.snapshotType, database.WithCreatedBefore(sessionBefore))
+		v, err := c.database.GetVehicleSnapshots(ctx, id, nil, options.snapshotType, opts...)
 		vehiclesSnapshots = retry.DataWithErr[[]models.VehicleSnapshot]{Data: v, Err: err}
 	}()
 
diff --git a/main.go b/main.go
index 010fae72..5bd95b79 100644
--- a/main.go
+++ b/main.go
@@ -251,7 +251,6 @@ func newDatabaseClientFromEnv() (database.Client, error) {
 
 	client, err := database.NewSQLiteClient(filepath.Join(constants.DatabasePath, constants.DatabaseName))
 	if err != nil {
-
 		return nil, fmt.Errorf("database#NewClient failed %w", err)
 	}
 
diff --git a/tests/static_database.go b/tests/static_database.go
index add0488a..ac269a15 100644
--- a/tests/static_database.go
+++ b/tests/static_database.go
@@ -101,31 +101,31 @@ func (c *staticTestingDatabase) DeleteConnection(ctx context.Context, connection
 	return errors.New("DeleteConnection not implemented")
 }
 
-func (c *staticTestingDatabase) GetAccountSnapshot(ctx context.Context, accountID, referenceID string, kind models.SnapshotType, options ...database.SnapshotQuery) (models.AccountSnapshot, error) {
-	return models.AccountSnapshot{}, errors.New("GetAccountSnapshot not implemented")
+func (c *staticTestingDatabase) GetAccountSnapshots(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...database.SnapshotQuery) ([]models.AccountSnapshot, error) {
+	return nil, errors.New("GetAccountSnapshots not implemented")
 }
 func (c *staticTestingDatabase) CreateAccountSnapshots(ctx context.Context, snapshots ...models.AccountSnapshot) (map[string]error, error) {
 	return nil, errors.New("CreateAccountSnapshots not implemented")
 }
-func (c *staticTestingDatabase) GetLastAccountSnapshots(ctx context.Context, accountID string, limit int) ([]models.AccountSnapshot, error) {
-	return nil, errors.New("GetLastAccountSnapshots not implemented")
+func (c *staticTestingDatabase) GetAccountLastBattleTimes(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...database.SnapshotQuery) (map[string]time.Time, error) {
+	return nil, errors.New("GetAccountLastBattleTimes not implemented")
 }
-func (c *staticTestingDatabase) GetManyAccountSnapshots(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...database.SnapshotQuery) ([]models.AccountSnapshot, error) {
-	return nil, errors.New("GetManyAccountSnapshots not implemented")
-}
-func (c *staticTestingDatabase) GetVehicleSnapshots(ctx context.Context, accountID, referenceID string, kind models.SnapshotType, options ...database.SnapshotQuery) ([]models.VehicleSnapshot, error) {
+func (c *staticTestingDatabase) GetVehicleSnapshots(ctx context.Context, accountID string, vehicleIDs []string, kind models.SnapshotType, options ...database.SnapshotQuery) ([]models.VehicleSnapshot, error) {
 	return nil, errors.New("GetVehicleSnapshots not implemented")
 }
 func (c *staticTestingDatabase) CreateAccountVehicleSnapshots(ctx context.Context, accountID string, snapshots ...models.VehicleSnapshot) (map[string]error, error) {
 	return nil, errors.New("CreateAccountVehicleSnapshots not implemented")
 }
+func (c *staticTestingDatabase) GetVehicleLastBattleTimes(ctx context.Context, accountID string, vehicleIDs []string, kind models.SnapshotType, options ...database.SnapshotQuery) (map[string]time.Time, error) {
+	return nil, errors.New("GetVehicleLastBattleTimes not implemented")
+}
 func (c *staticTestingDatabase) DeleteExpiredSnapshots(ctx context.Context, expiration time.Time) error {
 	return errors.New("DeleteExpiredSnapshots not implemented")
 }
 func (c *staticTestingDatabase) CreateAccountAchievementSnapshots(ctx context.Context, accountID string, snapshots ...models.AchievementsSnapshot) (map[string]error, error) {
 	return nil, errors.New("CreateAccountAchievementSnapshots not implemented")
 }
-func (c *staticTestingDatabase) GetAchievementsSnapshots(ctx context.Context, accountID string, kind models.SnapshotType, options ...database.SnapshotQuery) ([]models.AchievementsSnapshot, error) {
+func (c *staticTestingDatabase) GetAchievementSnapshots(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...database.SnapshotQuery) ([]models.AchievementsSnapshot, error) {
 	return nil, errors.New("GetAchievementsSnapshots not implemented")
 }
 

From 48aa8c4b6792f0bba893b884dfc6497d30541fed Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Mon, 8 Jul 2024 21:25:08 -0400
Subject: [PATCH 319/341] leaderboard queries, tests, fixes

---
 cmd/core/tasks/leaderboards.go         | 112 ++++++---
 internal/database/client.go            |  22 +-
 internal/database/ent/db/time.go       |  13 ++
 internal/database/leaderboards.go      | 108 +++++++++
 internal/database/leaderboards_test.go |  67 ++++++
 internal/database/options.go           | 139 +++++++++++
 internal/database/scan.go              |  44 ++++
 internal/database/snapshots.go         | 305 +++++--------------------
 internal/database/snapshots_test.go    |  10 +-
 internal/logic/leaderboards.go         |  66 ++++++
 internal/logic/snapshots.go            |  42 ++--
 internal/stats/fetch/v1/multisource.go |   2 +-
 tests/static_database.go               |  10 +-
 13 files changed, 628 insertions(+), 312 deletions(-)
 create mode 100644 internal/database/ent/db/time.go
 create mode 100644 internal/database/leaderboards.go
 create mode 100644 internal/database/leaderboards_test.go
 create mode 100644 internal/database/options.go
 create mode 100644 internal/database/scan.go
 create mode 100644 internal/logic/leaderboards.go

diff --git a/cmd/core/tasks/leaderboards.go b/cmd/core/tasks/leaderboards.go
index e320e5d3..3c515240 100644
--- a/cmd/core/tasks/leaderboards.go
+++ b/cmd/core/tasks/leaderboards.go
@@ -1,43 +1,93 @@
 package tasks
 
 import (
+	"context"
+	"strings"
+	"time"
+
 	"github.com/cufee/aftermath/cmd/core"
+	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/logic"
+	"github.com/pkg/errors"
+	"github.com/rs/zerolog/log"
 )
 
 func init() {
-	// defaultHandlers[models.TaskTypeAchievementsLeaderboardUpdate] = TaskHandler{
-	// 	Process: func(ctx context.Context, client core.Client, task *models.Task) error {
-	// 		realm, ok := task.Data["realm"]
-	// 		if !ok {
-	// 			return errors.New("invalid realm")
-	// 		}
-	// 		if len(task.Targets) > 100 {
-	// 			return errors.New("invalid targets length")
-	// 		}
-	// 		if len(task.Targets) < 1 {
-	// 			return errors.New("invalid targets length")
-	// 		}
-
-	// 		ctx, cancel := context.WithCancel(ctx)
-	// 		defer cancel()
-
-	// 		lastBattles, err := client.Wargaming().BatchAccountByID(ctx, realm, task.Targets, "account_id", "last_battle_time")
-	// 		if err != nil {
-	// 			return errors.Wrap(err, "failed to get account data from wargaming")
-	// 		}
-
-	// 		client.Database().GetAchievementsSnapshots(ctx, )
-
-	// 		// calculate the current score for each player
-
-	// 		// save scores to database
-
-	// 		return nil
-	// 	},
-	// }
+	defaultHandlers[models.TaskTypeAchievementsLeaderboardUpdate] = TaskHandler{
+		Process: func(ctx context.Context, client core.Client, task *models.Task) error {
+			realm, ok := task.Data["realm"]
+			if !ok {
+				return errors.New("invalid realm")
+			}
+			if len(task.Targets) > 100 {
+				return errors.New("invalid targets length")
+			}
+			if len(task.Targets) < 1 {
+				return errors.New("invalid targets length")
+			}
+
+			accountErrors, err := logic.UpdateAchievementLeaderboardScores(ctx, client.Wargaming(), client.Database(), realm, false, task.Targets...)
+			if err != nil {
+				return err
+			}
+
+			// retry failed accounts
+			newTargets := make([]string, 0, len(accountErrors))
+			for id, err := range accountErrors {
+				if err == nil {
+					continue
+				}
+				newTargets = append(newTargets, id)
+				task.LogAttempt(models.TaskLog{
+					Timestamp: time.Now(),
+					Error:     err.Error(),
+					Comment:   id,
+				})
+			}
+
+			if len(newTargets) > 0 {
+				task.Targets = newTargets
+				return errors.New("some accounts failed")
+			}
+			return nil
+		},
+	}
 }
 
 func CreateUpdateLeaderboardsTasks(client core.Client, realm string) error {
-	//
+	realm = strings.ToUpper(realm)
+	task := models.Task{
+		Type:           models.TaskTypeAchievementsLeaderboardUpdate,
+		ReferenceID:    "realm_" + realm,
+		ScheduledAfter: time.Now(),
+		Data: map[string]string{
+			"realm": realm,
+		},
+		TriesLeft: 3,
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
+	defer cancel()
+
+	accounts, err := client.Database().GetRealmAccountIDs(ctx, realm)
+	if err != nil {
+		return err
+	}
+	if len(accounts) < 1 {
+		return errors.New("no accounts on realm " + realm)
+	}
+	task.Targets = append(task.Targets, accounts...)
+
+	// This update requires (2 + n) requests per n players
+	// 1 - get all accounts last battle time
+	// 1 - get all account achievements
+	// n - get vehicle achievements for each account
+	tasks := splitTaskByTargets(task, 75)
+	err = client.Database().CreateTasks(ctx, tasks...)
+	if err != nil {
+		return err
+	}
+
+	log.Debug().Int("count", len(tasks)).Msg("scheduled realm leaderboard update tasks")
 	return nil
 }
diff --git a/internal/database/client.go b/internal/database/client.go
index 25440d87..dd60d887 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -7,6 +7,7 @@ import (
 	"sync"
 	"time"
 
+	"entgo.io/ent/dialect/sql"
 	"github.com/cufee/aftermath/internal/database/ent/db"
 	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/permissions"
@@ -55,12 +56,12 @@ type UsersClient interface {
 }
 
 type SnapshotsClient interface {
-	GetAccountSnapshots(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.AccountSnapshot, error)
-	GetAchievementSnapshots(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.AchievementsSnapshot, error)
-	GetVehicleSnapshots(ctx context.Context, accountID string, vehicleIDs []string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.VehicleSnapshot, error)
+	GetAccountSnapshots(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...Query) ([]models.AccountSnapshot, error)
+	GetAchievementSnapshots(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...Query) ([]models.AchievementsSnapshot, error)
+	GetVehicleSnapshots(ctx context.Context, accountID string, vehicleIDs []string, kind models.SnapshotType, options ...Query) ([]models.VehicleSnapshot, error)
 
-	GetAccountLastBattleTimes(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...SnapshotQuery) (map[string]time.Time, error)
-	GetVehicleLastBattleTimes(ctx context.Context, accountID string, vehicleIDs []string, kind models.SnapshotType, options ...SnapshotQuery) (map[string]time.Time, error)
+	GetAccountLastBattleTimes(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...Query) (map[string]time.Time, error)
+	GetVehicleLastBattleTimes(ctx context.Context, accountID string, vehicleIDs []string, kind models.SnapshotType, options ...Query) (map[string]time.Time, error)
 	// last battle times for achievements would be equivalent to account/vehicle ones
 
 	CreateAccountSnapshots(ctx context.Context, snapshots ...models.AccountSnapshot) (map[string]error, error)
@@ -70,6 +71,11 @@ type SnapshotsClient interface {
 	DeleteExpiredSnapshots(ctx context.Context, expiration time.Time) error
 }
 
+type LeaderboardsClient interface {
+	CreateLeaderboardScores(ctx context.Context, scores ...models.LeaderboardScore) (map[string]error, error)
+	GetLeaderboardScores(ctx context.Context, leaderboard models.LeaderboardID, scoreType models.ScoreType, options ...Query) ([]models.LeaderboardScore, error)
+}
+
 type TasksClient interface {
 	CreateTasks(ctx context.Context, tasks ...models.Task) error
 	GetTasks(ctx context.Context, ids ...string) ([]models.Task, error)
@@ -100,6 +106,7 @@ type Client interface {
 	GlossaryClient
 	AccountsClient
 	SnapshotsClient
+	LeaderboardsClient
 
 	TasksClient
 
@@ -200,3 +207,8 @@ func toAnySlice[T any](s ...T) []any {
 	}
 	return a
 }
+
+func wrap(query string) *sql.Builder {
+	wrapper := &sql.Builder{}
+	return wrapper.Wrap(func(b *sql.Builder) { b.WriteString(query) })
+}
diff --git a/internal/database/ent/db/time.go b/internal/database/ent/db/time.go
new file mode 100644
index 00000000..d5b1176e
--- /dev/null
+++ b/internal/database/ent/db/time.go
@@ -0,0 +1,13 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import "time"
+
+func ToTime(v int64) time.Time {
+	return time.UnixMilli(v)
+}
+
+func FromTime(t time.Time) int64 {
+	return t.UnixMilli()
+}
diff --git a/internal/database/leaderboards.go b/internal/database/leaderboards.go
new file mode 100644
index 00000000..6fbe16d1
--- /dev/null
+++ b/internal/database/leaderboards.go
@@ -0,0 +1,108 @@
+package database
+
+import (
+	"context"
+
+	"entgo.io/ent/dialect/sql"
+	"github.com/cufee/aftermath/internal/database/ent/db"
+	"github.com/cufee/aftermath/internal/database/ent/db/leaderboardscore"
+	"github.com/cufee/aftermath/internal/database/models"
+)
+
+func toScore(r *db.LeaderboardScore) models.LeaderboardScore {
+	return models.LeaderboardScore{
+		ID:            r.ID,
+		CreatedAt:     r.CreatedAt,
+		UpdatedAt:     r.UpdatedAt,
+		Type:          r.Type,
+		ReferenceID:   r.ReferenceID,
+		LeaderboardID: r.LeaderboardID,
+		Score:         r.Score,
+		Meta:          r.Meta,
+	}
+}
+
+func (c *client) CreateLeaderboardScores(ctx context.Context, scores ...models.LeaderboardScore) (map[string]error, error) {
+	if len(scores) < 1 {
+		return nil, nil
+	}
+
+	var errors = make(map[string]error)
+	for _, score := range scores {
+		// make a transaction per write to avoid locking for too long
+		err := c.withTx(ctx, func(tx *db.Tx) error {
+			return c.db.LeaderboardScore.Create().
+				SetMeta(score.Meta).
+				SetType(score.Type).
+				SetScore(score.Score).
+				SetCreatedAt(score.CreatedAt).
+				SetReferenceID(score.ReferenceID).
+				SetLeaderboardID(score.LeaderboardID).
+				Exec(ctx)
+		})
+		if err != nil {
+			errors[score.ReferenceID] = err
+		}
+	}
+
+	if len(errors) > 0 {
+		return errors, nil
+	}
+
+	return nil, nil
+}
+
+func (c *client) GetLeaderboardScores(ctx context.Context, leaderboard models.LeaderboardID, scoreType models.ScoreType, opts ...Query) ([]models.LeaderboardScore, error) {
+	var query baseQueryOptions
+	for _, apply := range opts {
+		apply(&query)
+	}
+
+	var where []*sql.Predicate
+	where = append(where, sql.EQ(leaderboardscore.FieldType, scoreType))
+	where = append(where, sql.EQ(leaderboardscore.FieldLeaderboardID, leaderboard))
+
+	orderBy := sql.Desc(leaderboardscore.FieldCreatedAt)
+	if query.createdAfter != nil {
+		where = append(where, sql.GT(leaderboardscore.FieldCreatedAt, *query.createdAfter))
+		orderBy = sql.Asc(leaderboardscore.FieldCreatedAt)
+	}
+	if query.createdBefore != nil {
+		where = append(where, sql.LT(leaderboardscore.FieldCreatedAt, *query.createdBefore))
+		orderBy = sql.Desc(leaderboardscore.FieldCreatedAt)
+	}
+
+	if in := query.refIDIn(); in != nil {
+		where = append(where, sql.In(leaderboardscore.FieldReferenceID, in...))
+	}
+	if nin := query.refIDNotIn(); nin != nil {
+		where = append(where, sql.NotIn(leaderboardscore.FieldReferenceID, nin...))
+	}
+
+	selectFields := []string{"*"}
+	if fields := query.selectFields(leaderboardscore.FieldReferenceID); fields != nil {
+		selectFields = fields
+	}
+
+	q := sql.Select(selectFields...).From(sql.Table(leaderboardscore.Table))
+	q = q.Where(sql.And(where...))
+	q = q.OrderBy(orderBy)
+
+	innerQueryString, queryArgs := q.Query()
+	queryString, _ := sql.Select(selectFields...).FromExpr(wrap(innerQueryString)).GroupBy(leaderboardscore.FieldReferenceID).Query()
+	rows, err := c.db.LeaderboardScore.QueryContext(ctx, queryString, queryArgs...)
+	if err != nil {
+		return nil, err
+	}
+
+	records, err := rowsToRecords[*db.LeaderboardScore](rows, leaderboardscore.Columns)
+	if err != nil {
+		return nil, err
+	}
+
+	var scores []models.LeaderboardScore
+	for _, r := range records {
+		scores = append(scores, toScore(r))
+	}
+	return scores, nil
+}
diff --git a/internal/database/leaderboards_test.go b/internal/database/leaderboards_test.go
new file mode 100644
index 00000000..2e3e0955
--- /dev/null
+++ b/internal/database/leaderboards_test.go
@@ -0,0 +1,67 @@
+package database
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/cufee/aftermath/internal/database/models"
+	_ "github.com/joho/godotenv/autoload"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGetLeaderboardScores(t *testing.T) {
+	client, err := NewSQLiteClient(filepath.Join(os.Getenv("DATABASE_PATH"), os.Getenv("DATABASE_NAME")), WithDebug())
+	assert.NoError(t, err, "new client should not error")
+	defer client.Disconnect()
+
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*15)
+	defer cancel()
+
+	client.db.LeaderboardScore.Delete().Where().Exec(ctx)
+	defer client.db.LeaderboardScore.Delete().Exec(ctx)
+
+	score1CreatedAt := time.Date(2023, 6, 1, 0, 0, 0, 0, time.UTC)
+	score1 := models.LeaderboardScore{
+		CreatedAt:     score1CreatedAt,
+		UpdatedAt:     score1CreatedAt,
+		Type:          models.LeaderboardScoreHourly,
+		ReferenceID:   "r1",
+		LeaderboardID: models.LeaderboardsMasteryWeightedPlayers,
+		Score:         1,
+		Meta:          map[string]any{},
+	}
+	score2CreatedAt := time.Date(2023, 6, 2, 0, 0, 0, 0, time.UTC)
+	score2 := models.LeaderboardScore{
+		CreatedAt:     score2CreatedAt,
+		UpdatedAt:     score2CreatedAt,
+		Type:          models.LeaderboardScoreHourly,
+		ReferenceID:   "r1",
+		LeaderboardID: models.LeaderboardsMasteryWeightedPlayers,
+		Score:         2,
+		Meta:          map[string]any{},
+	}
+	score3CreatedAt := time.Date(2023, 6, 3, 0, 0, 0, 0, time.UTC)
+	score3 := models.LeaderboardScore{
+		CreatedAt:     score3CreatedAt,
+		UpdatedAt:     score3CreatedAt,
+		Type:          models.LeaderboardScoreHourly,
+		ReferenceID:   "r1",
+		LeaderboardID: models.LeaderboardsMasteryWeightedPlayers,
+		Score:         3,
+		Meta:          map[string]any{},
+	}
+
+	sErr, err := client.CreateLeaderboardScores(context.Background(), score1, score2, score3)
+	assert.NoError(t, err, "failed to create scores")
+	assert.Nil(t, sErr, "failed to create scores")
+
+	{ // default order is created_at desc, this should return score3
+		scores, err := client.GetLeaderboardScores(context.Background(), models.LeaderboardsMasteryWeightedPlayers, models.LeaderboardScoreHourly)
+		assert.NoError(t, err, "failed to get leaderboard scores")
+		assert.Len(t, scores, 1, "scores are grouped by referenceID, this should return exactly 1 result")
+		assert.Equal(t, score3.Score, scores[0].Score, "default sort is desc, should return score3")
+	}
+}
diff --git a/internal/database/options.go b/internal/database/options.go
new file mode 100644
index 00000000..8b63620f
--- /dev/null
+++ b/internal/database/options.go
@@ -0,0 +1,139 @@
+package database
+
+import "time"
+
+type baseQueryOptions struct {
+	referenceIDIn    map[string]struct{}
+	referenceIDNotIn map[string]struct{}
+
+	createdAfter  *time.Time
+	createdBefore *time.Time
+
+	fields []string
+}
+
+type Query func(*baseQueryOptions)
+
+// --- snapshot query options ---
+
+/*
+Constrain referenceID field for the query
+  - if the final list of reference IDs is > 0, reference_id in (ids) will be added to the query
+*/
+func WithReferenceIDIn(ids ...string) Query {
+	return func(q *baseQueryOptions) {
+		if q.referenceIDIn == nil {
+			q.referenceIDIn = make(map[string]struct{})
+		}
+		for _, id := range ids {
+			q.referenceIDIn[id] = struct{}{}
+		}
+	}
+}
+
+/*
+Constrain referenceID field for the query
+  - if the final list of reference IDs is > 0, reference_id not in (ids) will be added to the query
+*/
+func WithReferenceIDNotIn(ids ...string) Query {
+	return func(q *baseQueryOptions) {
+		if q.referenceIDNotIn == nil {
+			q.referenceIDNotIn = make(map[string]struct{})
+		}
+		for _, id := range ids {
+			q.referenceIDNotIn[id] = struct{}{}
+		}
+	}
+}
+
+/*
+Adds a created_at lt constraint
+  - if this constraint is set, records will be sorted by created_at ASC
+*/
+func WithCreatedAfter(after time.Time) Query {
+	return func(q *baseQueryOptions) {
+		q.createdAfter = &after
+	}
+}
+
+/*
+Adds a created_at gt constraint
+  - if this constraint is set, records will be sorted by created_at DESC
+*/
+func WithCreatedBefore(before time.Time) Query {
+	return func(q *baseQueryOptions) {
+		q.createdBefore = &before
+	}
+}
+
+/*
+Set fields that will be selected.
+  - Some fields like id, created_at, updated_at will always be selected
+  - Passing 0 length fields will result in select *
+*/
+func WithSelect(fields ...string) Query {
+	return func(q *baseQueryOptions) {
+		// make sure fields are unique
+		fieldsSet := make(map[string]struct{})
+		for _, field := range append(q.fields, fields...) {
+			fieldsSet[field] = struct{}{}
+		}
+
+		// passing 0 length fields will result in select *
+		q.fields = nil
+		for field := range fieldsSet {
+			q.fields = append(q.fields, field)
+		}
+	}
+}
+
+/*
+Returns a slice of fields for a select statement with all duplicates removed and required fields added
+  - if query.fields is nil, returns a nil slice
+*/
+func (q *baseQueryOptions) selectFields(required ...string) []string {
+	if q.fields == nil {
+		return nil
+	}
+
+	// maker sure all required fields are part of the slice
+	var requiredFields = make(map[string]struct{})
+	for _, field := range required {
+		requiredFields[field] = struct{}{}
+	}
+
+	for _, field := range q.fields {
+		for required := range requiredFields {
+			if field == required {
+				delete(requiredFields, required)
+			}
+		}
+	}
+	for field := range requiredFields {
+		q.fields = append(q.fields, field)
+	}
+
+	return q.fields
+}
+
+func (q *baseQueryOptions) refIDIn() []any {
+	if len(q.referenceIDIn) == 0 {
+		return nil
+	}
+	var ids []any
+	for id := range q.referenceIDIn {
+		ids = append(ids, id)
+	}
+	return ids
+}
+
+func (q *baseQueryOptions) refIDNotIn() []any {
+	if len(q.referenceIDNotIn) == 0 {
+		return nil
+	}
+	var ids []any
+	for id := range q.referenceIDNotIn {
+		ids = append(ids, id)
+	}
+	return ids
+}
diff --git a/internal/database/scan.go b/internal/database/scan.go
new file mode 100644
index 00000000..602b40ac
--- /dev/null
+++ b/internal/database/scan.go
@@ -0,0 +1,44 @@
+package database
+
+import (
+	"database/sql"
+
+	"reflect"
+
+	"github.com/pkg/errors"
+)
+
+type scanAssignable interface {
+	ScanValues(columns []string) ([]any, error)
+	AssignValues(columns []string, values []any) error
+}
+
+func rowsToRecords[R scanAssignable](rs *sql.Rows, columns []string) ([]R, error) {
+	var records []R
+
+	recordType := reflect.TypeOf((*R)(nil)).Elem()
+	if recordType.Kind() != reflect.Ptr {
+		return nil, errors.New("type parameter must be a pointer to a struct")
+	}
+
+	for rs.Next() {
+		recordPtr := reflect.New(recordType.Elem())
+		record := recordPtr.Interface().(R)
+
+		values, err := record.ScanValues(columns)
+		if err != nil {
+			return nil, err
+		}
+		if err := rs.Scan(values...); err != nil {
+			return nil, err
+		}
+
+		err = record.AssignValues(columns, values)
+		if err != nil {
+			return nil, err
+		}
+		records = append(records, record)
+	}
+
+	return records, nil
+}
diff --git a/internal/database/snapshots.go b/internal/database/snapshots.go
index 5fc7697e..3b8c9764 100644
--- a/internal/database/snapshots.go
+++ b/internal/database/snapshots.go
@@ -13,142 +13,6 @@ import (
 	"github.com/cufee/aftermath/internal/database/models"
 )
 
-type getSnapshotQuery struct {
-	referenceIDIn    map[string]struct{}
-	referenceIDNotIn map[string]struct{}
-
-	createdAfter  *time.Time
-	createdBefore *time.Time
-
-	fields []string
-}
-
-type SnapshotQuery func(*getSnapshotQuery)
-
-// --- snapshot query options ---
-
-/*
-Constrain referenceID field for the query
-  - if the final list of reference IDs is > 0, reference_id in (ids) will be added to the query
-*/
-func WithReferenceIDIn(ids ...string) SnapshotQuery {
-	return func(q *getSnapshotQuery) {
-		if q.referenceIDIn == nil {
-			q.referenceIDIn = make(map[string]struct{})
-		}
-		for _, id := range ids {
-			q.referenceIDIn[id] = struct{}{}
-		}
-	}
-}
-
-/*
-Constrain referenceID field for the query
-  - if the final list of reference IDs is > 0, reference_id not in (ids) will be added to the query
-*/
-func WithReferenceIDNotIn(ids ...string) SnapshotQuery {
-	return func(q *getSnapshotQuery) {
-		if q.referenceIDNotIn == nil {
-			q.referenceIDNotIn = make(map[string]struct{})
-		}
-		for _, id := range ids {
-			q.referenceIDNotIn[id] = struct{}{}
-		}
-	}
-}
-
-/*
-Adds a created_at lt constraint
-  - if this constraint is set, records will be sorted by created_at ASC
-*/
-func WithCreatedAfter(after time.Time) SnapshotQuery {
-	return func(q *getSnapshotQuery) {
-		q.createdAfter = &after
-	}
-}
-
-/*
-Adds a created_at gt constraint
-  - if this constraint is set, records will be sorted by created_at DESC
-*/
-func WithCreatedBefore(before time.Time) SnapshotQuery {
-	return func(q *getSnapshotQuery) {
-		q.createdBefore = &before
-	}
-}
-
-/*
-Set fields that will be selected.
-  - Some fields like id, created_at, updated_at will always be selected
-  - Passing 0 length fields will result in select *
-*/
-func WithSelect(fields ...string) SnapshotQuery {
-	return func(q *getSnapshotQuery) {
-		// make sure fields are unique
-		fieldsSet := make(map[string]struct{})
-		for _, field := range append(q.fields, fields...) {
-			fieldsSet[field] = struct{}{}
-		}
-
-		// passing 0 length fields will result in select *
-		q.fields = nil
-		for field := range fieldsSet {
-			q.fields = append(q.fields, field)
-		}
-	}
-}
-
-/*
-Returns a slice of fields for a select statement with all duplicates removed and required fields added
-  - if query.fields is nil, returns a nil slice
-*/
-func (q *getSnapshotQuery) selectFields(required ...string) []string {
-	if q.fields == nil {
-		return nil
-	}
-
-	// maker sure all required fields are part of the slice
-	var requiredFields = make(map[string]struct{})
-	for _, field := range required {
-		requiredFields[field] = struct{}{}
-	}
-
-	for _, field := range q.fields {
-		for required := range requiredFields {
-			if field == required {
-				delete(requiredFields, required)
-			}
-		}
-	}
-	for field := range requiredFields {
-		q.fields = append(q.fields, field)
-	}
-
-	return q.fields
-}
-
-func (q *getSnapshotQuery) refIDIn() []any {
-	if len(q.referenceIDIn) == 0 {
-		return nil
-	}
-	var ids []any
-	for id := range q.referenceIDIn {
-		ids = append(ids, id)
-	}
-	return ids
-}
-
-func (q *getSnapshotQuery) refIDNotIn() []any {
-	if len(q.referenceIDNotIn) == 0 {
-		return nil
-	}
-	var ids []any
-	for id := range q.referenceIDNotIn {
-		ids = append(ids, id)
-	}
-	return ids
-}
-
 // --- record to model ---
 
 func toVehicleSnapshot(record *db.VehicleSnapshot) models.VehicleSnapshot {
@@ -196,8 +60,8 @@ func toAchievementsSnapshot(record *db.AchievementsSnapshot) models.Achievements
 Get complete vehicle snapshots fot each vehicle ID in vehicle IDs for a specific account
   - passing nil vehicleIDs will return all vehicles available
 */
-func (c *client) GetVehicleSnapshots(ctx context.Context, accountID string, vehicleIDs []string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.VehicleSnapshot, error) {
-	var query getSnapshotQuery
+func (c *client) GetVehicleSnapshots(ctx context.Context, accountID string, vehicleIDs []string, kind models.SnapshotType, options ...Query) ([]models.VehicleSnapshot, error) {
+	var query baseQueryOptions
 	for _, apply := range options {
 		apply(&query)
 	}
@@ -209,25 +73,15 @@ func (c *client) GetVehicleSnapshots(ctx context.Context, accountID string, vehi
 	}
 	defer rows.Close()
 
-	var snapshots []models.VehicleSnapshot
-	for rows.Next() {
-		var record db.VehicleSnapshot
-
-		values, err := record.ScanValues(vehiclesnapshot.Columns)
-		if err != nil {
-			return nil, err
-		}
-		if err := rows.Scan(values...); err != nil {
-			return nil, err
-		}
-
-		err = record.AssignValues(vehiclesnapshot.Columns, values)
-		if err != nil {
-			return nil, err
-		}
-		snapshots = append(snapshots, toVehicleSnapshot(&record))
+	records, err := rowsToRecords[*db.VehicleSnapshot](rows, vehiclesnapshot.Columns)
+	if err != nil {
+		return nil, err
 	}
 
+	var snapshots []models.VehicleSnapshot
+	for _, r := range records {
+		snapshots = append(snapshots, toVehicleSnapshot(r))
+	}
 	return snapshots, nil
 }
 
@@ -235,8 +89,8 @@ func (c *client) GetVehicleSnapshots(ctx context.Context, accountID string, vehi
 get last battle times for each vehicle in vehicle IDs for a specific account
   - passing nil vehicleIDs will return all vehicles available
 */
-func (c *client) GetVehicleLastBattleTimes(ctx context.Context, accountID string, vehicleIDs []string, kind models.SnapshotType, options ...SnapshotQuery) (map[string]time.Time, error) {
-	var query getSnapshotQuery
+func (c *client) GetVehicleLastBattleTimes(ctx context.Context, accountID string, vehicleIDs []string, kind models.SnapshotType, options ...Query) (map[string]time.Time, error) {
+	var query baseQueryOptions
 	for _, apply := range options {
 		apply(&query)
 	}
@@ -249,23 +103,14 @@ func (c *client) GetVehicleLastBattleTimes(ctx context.Context, accountID string
 	}
 	defer rows.Close()
 
-	var lastBattleTimes = make(map[string]time.Time)
-	for rows.Next() {
-		var record db.VehicleSnapshot
-
-		values, err := record.ScanValues([]string{vehiclesnapshot.FieldVehicleID, vehiclesnapshot.FieldLastBattleTime})
-		if err != nil {
-			return nil, err
-		}
-		if err := rows.Scan(values...); err != nil {
-			return nil, err
-		}
+	records, err := rowsToRecords[*db.VehicleSnapshot](rows, []string{vehiclesnapshot.FieldVehicleID, vehiclesnapshot.FieldLastBattleTime})
+	if err != nil {
+		return nil, err
+	}
 
-		err = record.AssignValues([]string{vehiclesnapshot.FieldVehicleID, vehiclesnapshot.FieldLastBattleTime}, values)
-		if err != nil {
-			return nil, err
-		}
-		lastBattleTimes[record.VehicleID] = record.LastBattleTime
+	var lastBattleTimes = make(map[string]time.Time)
+	for _, r := range records {
+		lastBattleTimes[r.VehicleID] = r.LastBattleTime
 	}
 
 	return lastBattleTimes, nil
@@ -274,7 +119,7 @@ func (c *client) GetVehicleLastBattleTimes(ctx context.Context, accountID string
 // create vehicle snapshots for a specific account
 func (c *client) CreateAccountVehicleSnapshots(ctx context.Context, accountID string, snapshots ...models.VehicleSnapshot) (map[string]error, error) {
 	if len(snapshots) < 1 {
-		return nil, new(db.NotFoundError)
+		return nil, nil
 	}
 
 	account, err := c.db.Account.Get(ctx, accountID)
@@ -309,7 +154,7 @@ func (c *client) CreateAccountVehicleSnapshots(ctx context.Context, accountID st
 }
 
 // build a complete query for vehicle snapshots
-func vehiclesQuery(accountID string, vehicleIDs []string, kind models.SnapshotType, groupBy string, query getSnapshotQuery) (string, []any) {
+func vehiclesQuery(accountID string, vehicleIDs []string, kind models.SnapshotType, groupBy string, query baseQueryOptions) (string, []any) {
 	// required where constraints
 	var innerWhere []*sql.Predicate
 	innerWhere = append(innerWhere, sql.EQ(vehiclesnapshot.FieldType, kind), sql.EQ(vehiclesnapshot.FieldAccountID, accountID))
@@ -336,22 +181,18 @@ func vehiclesQuery(accountID string, vehicleIDs []string, kind models.SnapshotTy
 		innerOrder = sql.Desc(vehiclesnapshot.FieldCreatedAt)
 	}
 
-	innerQuery := sql.Select(vehiclesnapshot.Columns...).From(sql.Table(vehiclesnapshot.Table))
+	selectFields := vehiclesnapshot.Columns
+	if fields := query.selectFields(groupBy); fields != nil {
+		selectFields = fields
+	}
+
+	innerQuery := sql.Select(selectFields...).From(sql.Table(vehiclesnapshot.Table))
 	innerQuery = innerQuery.Where(sql.And(innerWhere...))
 	innerQuery = innerQuery.OrderBy(innerOrder)
 
 	innerQueryString, innerQueryArgs := innerQuery.Query()
 
-	// wrap the inner query in a GROUP BY
-	wrapper := &sql.Builder{}
-	wrapped := wrapper.Wrap(func(b *sql.Builder) { b.WriteString(innerQueryString) })
-
-	selector := sql.Select("*")
-	if fields := query.selectFields(groupBy); fields != nil {
-		// make sure FieldVehicleID is selected, we need it for Group By
-		selector = sql.Select(fields...)
-	}
-	queryString, _ := selector.FromExpr(wrapped).GroupBy(groupBy).Query()
+	queryString, _ := sql.Select(selectFields...).FromExpr(wrap(innerQueryString)).GroupBy(groupBy).Query()
 	return queryString, innerQueryArgs
 }
 
@@ -361,12 +202,12 @@ func vehiclesQuery(accountID string, vehicleIDs []string, kind models.SnapshotTy
 Get complete snapshots for accounts by ID, grouped by account ID
   - there are no use cases where all accounts should be returned for now, so nil slice of ids will return an error
 */
-func (c *client) GetAccountSnapshots(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.AccountSnapshot, error) {
+func (c *client) GetAccountSnapshots(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...Query) ([]models.AccountSnapshot, error) {
 	if len(accountIDs) < 1 {
 		return nil, new(db.NotFoundError)
 	}
 
-	var query getSnapshotQuery
+	var query baseQueryOptions
 	for _, apply := range options {
 		apply(&query)
 	}
@@ -378,37 +219,26 @@ func (c *client) GetAccountSnapshots(ctx context.Context, accountIDs []string, k
 	}
 	defer rows.Close()
 
+	records, err := rowsToRecords[*db.AccountSnapshot](rows, accountsnapshot.Columns)
+	if err != nil {
+		return nil, err
+	}
 	var snapshots []models.AccountSnapshot
-	for rows.Next() {
-		var record db.AccountSnapshot
-
-		values, err := record.ScanValues(accountsnapshot.Columns)
-		if err != nil {
-			return nil, err
-		}
-		if err := rows.Scan(values...); err != nil {
-			return nil, err
-		}
-
-		err = record.AssignValues(accountsnapshot.Columns, values)
-		if err != nil {
-			return nil, err
-		}
-		snapshots = append(snapshots, toAccountSnapshot(&record))
+	for _, r := range records {
+		snapshots = append(snapshots, toAccountSnapshot(r))
 	}
-
 	return snapshots, nil
 }
 
 /*
 Get last battle times for accounts by ID, grouped by account ID
 */
-func (c *client) GetAccountLastBattleTimes(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...SnapshotQuery) (map[string]time.Time, error) {
+func (c *client) GetAccountLastBattleTimes(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...Query) (map[string]time.Time, error) {
 	if len(accountIDs) < 1 {
 		return nil, new(db.NotFoundError)
 	}
 
-	var query getSnapshotQuery
+	var query baseQueryOptions
 	for _, apply := range options {
 		apply(&query)
 	}
@@ -420,32 +250,21 @@ func (c *client) GetAccountLastBattleTimes(ctx context.Context, accountIDs []str
 		return nil, err
 	}
 
-	var lastBattles = make(map[string]time.Time)
-	for rows.Next() {
-		var record db.AccountSnapshot
-
-		values, err := record.ScanValues([]string{accountsnapshot.FieldAccountID, accountsnapshot.FieldLastBattleTime})
-		if err != nil {
-			return nil, err
-		}
-		if err := rows.Scan(values...); err != nil {
-			return nil, err
-		}
-
-		err = record.AssignValues([]string{accountsnapshot.FieldAccountID, accountsnapshot.FieldLastBattleTime}, values)
-		if err != nil {
-			return nil, err
-		}
-
-		lastBattles[record.ReferenceID] = record.LastBattleTime
+	records, err := rowsToRecords[*db.AccountSnapshot](rows, accountsnapshot.Columns)
+	if err != nil {
+		return nil, err
 	}
 
+	var lastBattles = make(map[string]time.Time)
+	for _, r := range records {
+		lastBattles[r.AccountID] = r.LastBattleTime
+	}
 	return lastBattles, nil
 }
 
 func (c *client) CreateAccountSnapshots(ctx context.Context, snapshots ...models.AccountSnapshot) (map[string]error, error) {
 	if len(snapshots) < 1 {
-		return nil, new(db.NotFoundError)
+		return nil, nil
 	}
 
 	var errors = make(map[string]error)
@@ -479,7 +298,7 @@ func (c *client) CreateAccountSnapshots(ctx context.Context, snapshots ...models
 }
 
 // build a complete query for account snapshot
-func accountsQuery(accountIDs []string, kind models.SnapshotType, groupBy string, query getSnapshotQuery) (string, []any) {
+func accountsQuery(accountIDs []string, kind models.SnapshotType, groupBy string, query baseQueryOptions) (string, []any) {
 	// required where constraints
 	var innerWhere []*sql.Predicate
 	innerWhere = append(innerWhere, sql.EQ(accountsnapshot.FieldType, kind), sql.In(accountsnapshot.FieldAccountID, toAnySlice(accountIDs...)...))
@@ -503,47 +322,47 @@ func accountsQuery(accountIDs []string, kind models.SnapshotType, groupBy string
 		innerOrder = sql.Desc(accountsnapshot.FieldCreatedAt)
 	}
 
-	innerQuery := sql.Select(accountsnapshot.Columns...).From(sql.Table(accountsnapshot.Table))
+	selectFields := accountsnapshot.Columns
+	if fields := query.selectFields(groupBy); fields != nil {
+		selectFields = fields
+	}
+
+	innerQuery := sql.Select(selectFields...).From(sql.Table(accountsnapshot.Table))
 	innerQuery = innerQuery.Where(sql.And(innerWhere...))
 	innerQuery = innerQuery.OrderBy(innerOrder)
 
 	innerQueryString, innerQueryArgs := innerQuery.Query()
-
-	// wrap the inner query in a GROUP BY
-	wrapper := &sql.Builder{}
-	wrapped := wrapper.Wrap(func(b *sql.Builder) { b.WriteString(innerQueryString) })
-
-	selector := sql.Select("*")
-	if fields := query.selectFields(groupBy); fields != nil {
-		// make sure FieldVehicleID is selected, we need it for Group By
-		selector = sql.Select(fields...)
-	}
-	queryString, _ := selector.FromExpr(wrapped).GroupBy(groupBy).Query()
+	queryString, _ := sql.Select(selectFields...).FromExpr(wrap(innerQueryString)).GroupBy(groupBy).Query()
 	return queryString, innerQueryArgs
 }
 
 // --- achievement snapshots ---
 
-func (c *client) GetAchievementSnapshots(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...SnapshotQuery) ([]models.AchievementsSnapshot, error) {
+func (c *client) GetAchievementSnapshots(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...Query) ([]models.AchievementsSnapshot, error) {
 	if len(accountIDs) < 1 {
 		return nil, new(db.NotFoundError)
 	}
 
-	var query getSnapshotQuery
+	var query baseQueryOptions
 	for _, apply := range options {
 		apply(&query)
 	}
 
 	var where []predicate.AchievementsSnapshot
+	var orderBy achievementssnapshot.OrderOption
+	orderBy = achievementssnapshot.ByCreatedAt(sql.OrderDesc())
 	where = append(where, achievementssnapshot.AccountIDIn(accountIDs...), achievementssnapshot.TypeEQ(kind))
+
 	if query.createdAfter != nil {
 		where = append(where, achievementssnapshot.CreatedAtGT(*query.createdAfter))
+		orderBy = achievementssnapshot.ByCreatedAt(sql.OrderAsc())
 	}
 	if query.createdBefore != nil {
 		where = append(where, achievementssnapshot.CreatedAtLT(*query.createdAfter))
+		orderBy = achievementssnapshot.ByCreatedAt(sql.OrderDesc())
 	}
 
-	records, err := c.db.AchievementsSnapshot.Query().Select(query.selectFields()...).Where(where...).All(ctx)
+	records, err := c.db.AchievementsSnapshot.Query().Select(query.selectFields()...).Order(orderBy).Where(where...).All(ctx)
 	if err != nil {
 		return nil, err
 	}
@@ -558,7 +377,7 @@ func (c *client) GetAchievementSnapshots(ctx context.Context, accountIDs []strin
 
 func (c *client) CreateAccountAchievementSnapshots(ctx context.Context, accountID string, snapshots ...models.AchievementsSnapshot) (map[string]error, error) {
 	if len(snapshots) < 1 {
-		return nil, new(db.NotFoundError)
+		return nil, nil
 	}
 
 	account, err := c.db.Account.Get(ctx, accountID)
diff --git a/internal/database/snapshots_test.go b/internal/database/snapshots_test.go
index a4db4a62..69ade874 100644
--- a/internal/database/snapshots_test.go
+++ b/internal/database/snapshots_test.go
@@ -24,7 +24,7 @@ func TestGetVehicleSnapshots(t *testing.T) {
 	defer cancel()
 
 	client.db.VehicleSnapshot.Delete().Where().Exec(ctx)
-	defer client.db.VehicleSnapshot.Delete().Exec(ctx)
+	// defer client.db.VehicleSnapshot.Delete().Exec(ctx)
 
 	_, err = client.UpsertAccounts(ctx, []models.Account{{ID: "a1", Realm: "test", Nickname: "test_account"}})
 	assert.NoError(t, err, "failed to upsert an account")
@@ -126,4 +126,12 @@ func TestGetVehicleSnapshots(t *testing.T) {
 		assert.NoError(t, err, "no results from a raw query does not trigger an error")
 		assert.Len(t, vehicles, 0, "return should have no results\nvehicles:%#v", vehicles)
 	}
+	{ // this should return 3 results
+		lastBattles, err := client.GetVehicleLastBattleTimes(ctx, "a1", nil, models.SnapshotTypeDaily)
+		assert.NoError(t, err, "no results from a raw query does not trigger an error")
+		assert.Len(t, lastBattles, 3, "return should have 3 results\nvehicles:%#v", lastBattles)
+		assert.Equal(t, createdAtVehicle3, lastBattles["v1"])
+		assert.Equal(t, createdAtVehicle4, lastBattles["v4"])
+		assert.Equal(t, createdAtVehicle5, lastBattles["v5"])
+	}
 }
diff --git a/internal/logic/leaderboards.go b/internal/logic/leaderboards.go
new file mode 100644
index 00000000..8bc0bb28
--- /dev/null
+++ b/internal/logic/leaderboards.go
@@ -0,0 +1,66 @@
+package logic
+
+import (
+	"context"
+	"time"
+
+	"github.com/cufee/aftermath/internal/database"
+	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/external/wargaming"
+	"github.com/cufee/am-wg-proxy-next/v2/types"
+	"github.com/pkg/errors"
+)
+
+func UpdateAccountAchievementsLeaderboardScores(ctx context.Context, wgClient wargaming.Client, dbClient database.Client, realm string, force bool, accountIDs ...string) (map[string]error, error) {
+	if len(accountIDs) < 1 {
+		return nil, nil
+	}
+	createdAt := time.Now()
+
+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+
+	accounts, err := wgClient.BatchAccountByID(ctx, realm, accountIDs, "account_id", "last_battle_time")
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to fetch accounts")
+	}
+
+	accountsNeedAnUpdate, err := filterActiveAccounts(ctx, dbClient, realm, accounts, false)
+	if err != nil {
+		return nil, err
+	}
+	if len(accountsNeedAnUpdate) < 1 {
+		return nil, nil
+	}
+
+	// get current account achievements
+	achievements, err := wgClient.BatchAccountAchievements(ctx, realm, accountsNeedAnUpdate)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to get account achievements")
+	}
+
+	var scores []models.LeaderboardScore
+	// calculate the current score for each player
+	for id, achievements := range achievements {
+		scores = append(scores, models.LeaderboardScore{
+			ReferenceID:   id,
+			CreatedAt:     createdAt,
+			UpdatedAt:     createdAt,
+			Type:          models.LeaderboardScoreHourly,
+			Score:         masteryAchievementsScore(achievements),
+			LeaderboardID: models.LeaderboardsMasteryWeightedPlayers,
+			Meta: map[string]any{
+				"achievements": achievements,
+			},
+		})
+	}
+
+	// save scores to database
+	_ = scores
+
+	return nil, nil
+}
+
+func masteryAchievementsScore(achievements types.AchievementsFrame) float32 {
+	return float32(achievements.MarkOfMastery)*25 + float32(achievements.MarkOfMasteryI)*5 + float32(achievements.MarkOfMasteryII)*1 + float32(achievements.MarkOfMasteryIII)*1
+}
diff --git a/internal/logic/snapshots.go b/internal/logic/snapshots.go
index cd98f187..fd822fd6 100644
--- a/internal/logic/snapshots.go
+++ b/internal/logic/snapshots.go
@@ -22,39 +22,24 @@ type vehicleBattleData struct {
 }
 
 /*
-Gets all accounts from WH and their respective snapshots
-  - an account is considered valid is it has played a battle since the last snapshot, or has no snapshots
-  - as side effect, invalid accounts will be set as private
+Filter passed in accounts and return active account ids
+  - an account is considered active if it has played a battle since the last snapshot, or has no snapshots
 */
-func getAndValidateAccounts(ctx context.Context, wgClient wargaming.Client, dbClient database.Client, force bool, realm string, accountIDs ...string) (map[string]types.ExtendedAccount, []string, error) {
-	accounts, err := wgClient.BatchAccountByID(ctx, realm, accountIDs)
-	if err != nil {
-		return nil, nil, errors.Wrap(err, "failed to fetch accounts")
+func filterActiveAccounts(ctx context.Context, dbClient database.Client, realm string, accounts map[string]types.ExtendedAccount, force bool) ([]string, error) {
+	var ids []string
+	for id := range accounts {
+		ids = append(ids, id)
 	}
 
 	// existing snapshots for accounts
-	existingLastBattleTimes, err := dbClient.GetAccountLastBattleTimes(ctx, accountIDs, models.SnapshotTypeDaily)
+	existingLastBattleTimes, err := dbClient.GetAccountLastBattleTimes(ctx, ids, models.SnapshotTypeDaily)
 	if err != nil && !database.IsNotFound(err) {
-		return nil, nil, errors.Wrap(err, "failed to get existing snapshots")
+		return nil, errors.Wrap(err, "failed to get existing snapshots")
 	}
 
 	// make a new slice just in case some accounts were not returned/are private
 	var needAnUpdate []string
-	for _, id := range accountIDs {
-		data, ok := accounts[id]
-		if !ok {
-			go func(id string) {
-				log.Debug().Str("accountId", id).Msg("account is private")
-				// update account cache (if it exists) to set account as private
-				ctx, cancel := context.WithTimeout(context.Background(), time.Second)
-				defer cancel()
-				err := dbClient.AccountSetPrivate(ctx, id, true)
-				if err != nil {
-					log.Err(err).Str("accountId", id).Msg("failed to set account status as private")
-				}
-			}(id)
-			continue
-		}
+	for id, data := range accounts {
 		if data.LastBattleTime < 1 {
 			continue
 		}
@@ -64,7 +49,7 @@ func getAndValidateAccounts(ctx context.Context, wgClient wargaming.Client, dbCl
 		}
 		needAnUpdate = append(needAnUpdate, id)
 	}
-	return accounts, needAnUpdate, nil
+	return needAnUpdate, nil
 }
 
 func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbClient database.Client, realm string, force bool, accountIDs ...string) (map[string]error, error) {
@@ -76,7 +61,12 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()
 
-	accounts, accountsNeedAnUpdate, err := getAndValidateAccounts(ctx, wgClient, dbClient, force, realm, accountIDs...)
+	accounts, err := wgClient.BatchAccountByID(ctx, realm, accountIDs)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to fetch accounts")
+	}
+
+	accountsNeedAnUpdate, err := filterActiveAccounts(ctx, dbClient, realm, accounts, false)
 	if err != nil {
 		return nil, err
 	}
diff --git a/internal/stats/fetch/v1/multisource.go b/internal/stats/fetch/v1/multisource.go
index 3c13bd93..bd7fbcc8 100644
--- a/internal/stats/fetch/v1/multisource.go
+++ b/internal/stats/fetch/v1/multisource.go
@@ -311,7 +311,7 @@ func (c *multiSourceClient) SessionStats(ctx context.Context, id string, session
 
 	group.Add(1)
 	go func() {
-		var opts = []database.SnapshotQuery{database.WithCreatedBefore(sessionBefore)}
+		var opts = []database.Query{database.WithCreatedBefore(sessionBefore)}
 		if options.referenceID != "" {
 			opts = append(opts, database.WithReferenceIDIn(options.referenceID))
 		}
diff --git a/tests/static_database.go b/tests/static_database.go
index ac269a15..2cb6e00c 100644
--- a/tests/static_database.go
+++ b/tests/static_database.go
@@ -101,22 +101,22 @@ func (c *staticTestingDatabase) DeleteConnection(ctx context.Context, connection
 	return errors.New("DeleteConnection not implemented")
 }
 
-func (c *staticTestingDatabase) GetAccountSnapshots(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...database.SnapshotQuery) ([]models.AccountSnapshot, error) {
+func (c *staticTestingDatabase) GetAccountSnapshots(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...database.Query) ([]models.AccountSnapshot, error) {
 	return nil, errors.New("GetAccountSnapshots not implemented")
 }
 func (c *staticTestingDatabase) CreateAccountSnapshots(ctx context.Context, snapshots ...models.AccountSnapshot) (map[string]error, error) {
 	return nil, errors.New("CreateAccountSnapshots not implemented")
 }
-func (c *staticTestingDatabase) GetAccountLastBattleTimes(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...database.SnapshotQuery) (map[string]time.Time, error) {
+func (c *staticTestingDatabase) GetAccountLastBattleTimes(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...database.Query) (map[string]time.Time, error) {
 	return nil, errors.New("GetAccountLastBattleTimes not implemented")
 }
-func (c *staticTestingDatabase) GetVehicleSnapshots(ctx context.Context, accountID string, vehicleIDs []string, kind models.SnapshotType, options ...database.SnapshotQuery) ([]models.VehicleSnapshot, error) {
+func (c *staticTestingDatabase) GetVehicleSnapshots(ctx context.Context, accountID string, vehicleIDs []string, kind models.SnapshotType, options ...database.Query) ([]models.VehicleSnapshot, error) {
 	return nil, errors.New("GetVehicleSnapshots not implemented")
 }
 func (c *staticTestingDatabase) CreateAccountVehicleSnapshots(ctx context.Context, accountID string, snapshots ...models.VehicleSnapshot) (map[string]error, error) {
 	return nil, errors.New("CreateAccountVehicleSnapshots not implemented")
 }
-func (c *staticTestingDatabase) GetVehicleLastBattleTimes(ctx context.Context, accountID string, vehicleIDs []string, kind models.SnapshotType, options ...database.SnapshotQuery) (map[string]time.Time, error) {
+func (c *staticTestingDatabase) GetVehicleLastBattleTimes(ctx context.Context, accountID string, vehicleIDs []string, kind models.SnapshotType, options ...database.Query) (map[string]time.Time, error) {
 	return nil, errors.New("GetVehicleLastBattleTimes not implemented")
 }
 func (c *staticTestingDatabase) DeleteExpiredSnapshots(ctx context.Context, expiration time.Time) error {
@@ -125,7 +125,7 @@ func (c *staticTestingDatabase) DeleteExpiredSnapshots(ctx context.Context, expi
 func (c *staticTestingDatabase) CreateAccountAchievementSnapshots(ctx context.Context, accountID string, snapshots ...models.AchievementsSnapshot) (map[string]error, error) {
 	return nil, errors.New("CreateAccountAchievementSnapshots not implemented")
 }
-func (c *staticTestingDatabase) GetAchievementSnapshots(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...database.SnapshotQuery) ([]models.AchievementsSnapshot, error) {
+func (c *staticTestingDatabase) GetAchievementSnapshots(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...database.Query) ([]models.AchievementsSnapshot, error) {
 	return nil, errors.New("GetAchievementsSnapshots not implemented")
 }
 

From 246e0250ddfd971f40635484fde9e5789053c143 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Mon, 8 Jul 2024 21:25:54 -0400
Subject: [PATCH 320/341] cleanup

---
 internal/database/snapshots_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/internal/database/snapshots_test.go b/internal/database/snapshots_test.go
index 69ade874..2c06f582 100644
--- a/internal/database/snapshots_test.go
+++ b/internal/database/snapshots_test.go
@@ -24,7 +24,7 @@ func TestGetVehicleSnapshots(t *testing.T) {
 	defer cancel()
 
 	client.db.VehicleSnapshot.Delete().Where().Exec(ctx)
-	// defer client.db.VehicleSnapshot.Delete().Exec(ctx)
+	defer client.db.VehicleSnapshot.Delete().Exec(ctx)
 
 	_, err = client.UpsertAccounts(ctx, []models.Account{{ID: "a1", Realm: "test", Nickname: "test_account"}})
 	assert.NoError(t, err, "failed to upsert an account")

From 62517e87888cfc3b6ce94bd276d6991c8636ddc8 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Tue, 9 Jul 2024 10:05:54 -0400
Subject: [PATCH 321/341] finished leaderboard update tasks

---
 cmd/core/scheduler/scheduler.go   |  9 ++++-----
 cmd/core/scheduler/workers.go     |  6 +++---
 cmd/core/tasks/cleanup.go         | 11 +++++++++++
 cmd/core/tasks/leaderboards.go    |  2 +-
 internal/database/client.go       |  2 ++
 internal/database/leaderboards.go |  6 ++++++
 internal/logic/leaderboards.go    |  9 +++++++--
 tests/static_database.go          | 10 ++++++++++
 8 files changed, 44 insertions(+), 11 deletions(-)

diff --git a/cmd/core/scheduler/scheduler.go b/cmd/core/scheduler/scheduler.go
index d4c3ebe5..ad506f77 100644
--- a/cmd/core/scheduler/scheduler.go
+++ b/cmd/core/scheduler/scheduler.go
@@ -48,11 +48,10 @@ func RegisterDefaultTasks(s *scheduler, coreClient core.Client) {
 	s.Add("0 1 * * *", CreateSnapshotTasksWorker(coreClient, "EU"))  // EU
 	s.Add("0 18 * * *", CreateSnapshotTasksWorker(coreClient, "AS")) // Asia
 
-	// Achievement leaderboards
-	// ideally, this should not delay snapshots
-	s.Add("25 * * * *", CreateSnapshotTasksWorker(coreClient, "NA")) // NA
-	s.Add("30 * * * *", CreateSnapshotTasksWorker(coreClient, "EU")) // EU
-	s.Add("35 * * * *", CreateSnapshotTasksWorker(coreClient, "AS")) // Asia
+	// Achievement leaderboards. ideally, this should not delay snapshots
+	s.Add("25 * * * *", CreateLeaderboardTasksWorker(coreClient, "NA")) // NA
+	s.Add("30 * * * *", CreateLeaderboardTasksWorker(coreClient, "EU")) // EU
+	s.Add("35 * * * *", CreateLeaderboardTasksWorker(coreClient, "AS")) // Asia
 
 	// Configurations
 	s.Add("0 0 */7 * *", RotateBackgroundPresetsWorker(coreClient))
diff --git a/cmd/core/scheduler/workers.go b/cmd/core/scheduler/workers.go
index 6405abfc..9ecb6885 100644
--- a/cmd/core/scheduler/workers.go
+++ b/cmd/core/scheduler/workers.go
@@ -157,11 +157,11 @@ func UpdateGlossaryWorker(client core.Client) func() {
 	}
 }
 
-func CreateAchievementLeaderboardTasksWorker(client core.Client, realm string) func() {
+func CreateLeaderboardTasksWorker(client core.Client, realm string) func() {
 	return func() {
-		err := tasks.CreateRecordSnapshotsTasks(client, realm)
+		err := tasks.CreateUpdateLeaderboardsTasks(client, realm)
 		if err != nil {
-			log.Err(err).Str("realm", realm).Msg("failed to schedule session update tasks")
+			log.Err(err).Str("realm", realm).Msg("failed to schedule leaderboard update tasks")
 		}
 	}
 }
diff --git a/cmd/core/tasks/cleanup.go b/cmd/core/tasks/cleanup.go
index 5f2c5fc7..ea3d5901 100644
--- a/cmd/core/tasks/cleanup.go
+++ b/cmd/core/tasks/cleanup.go
@@ -44,6 +44,16 @@ func init() {
 					return errors.Wrap(err, "failed to delete expired snapshots")
 				}
 			}
+			{
+				leaderboardsExpiration, err := time.Parse(time.RFC3339, task.Data["expiration_leaderboards"])
+				if err != nil {
+					return errors.Wrap(err, "failed to parse expiration_snapshots to time")
+				}
+				err = client.Database().DeleteExpiredLeaderboardScores(ctx, leaderboardsExpiration)
+				if err != nil && !database.IsNotFound(err) {
+					return errors.Wrap(err, "failed to delete expired leaderboard scores")
+				}
+			}
 
 			return nil
 		},
@@ -60,6 +70,7 @@ func CreateCleanupTasks(client core.Client) error {
 		Type:           models.TaskTypeDatabaseCleanup,
 		Data: map[string]string{
 			"expiration_snapshots":    now.Add(-1 * time.Hour * 24 * 90).Format(time.RFC3339), // 90 days
+			"expiration_leaderboards": now.Add(-1 * time.Hour * 24 * 30).Format(time.RFC3339), // 30 days
 			"expiration_interactions": now.Add(-1 * time.Hour * 24 * 7).Format(time.RFC3339),  // 7 days
 			"expiration_tasks":        now.Add(-1 * time.Hour * 24 * 7).Format(time.RFC3339),  // 7 days
 		},
diff --git a/cmd/core/tasks/leaderboards.go b/cmd/core/tasks/leaderboards.go
index 3c515240..ad72b9bc 100644
--- a/cmd/core/tasks/leaderboards.go
+++ b/cmd/core/tasks/leaderboards.go
@@ -26,7 +26,7 @@ func init() {
 				return errors.New("invalid targets length")
 			}
 
-			accountErrors, err := logic.UpdateAchievementLeaderboardScores(ctx, client.Wargaming(), client.Database(), realm, false, task.Targets...)
+			accountErrors, err := logic.UpdateAccountAchievementsLeaderboardScores(ctx, client.Wargaming(), client.Database(), realm, false, task.Targets...)
 			if err != nil {
 				return err
 			}
diff --git a/internal/database/client.go b/internal/database/client.go
index dd60d887..4abe8ce0 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -74,6 +74,8 @@ type SnapshotsClient interface {
 type LeaderboardsClient interface {
 	CreateLeaderboardScores(ctx context.Context, scores ...models.LeaderboardScore) (map[string]error, error)
 	GetLeaderboardScores(ctx context.Context, leaderboard models.LeaderboardID, scoreType models.ScoreType, options ...Query) ([]models.LeaderboardScore, error)
+
+	DeleteExpiredLeaderboardScores(ctx context.Context, expiration time.Time) error
 }
 
 type TasksClient interface {
diff --git a/internal/database/leaderboards.go b/internal/database/leaderboards.go
index 6fbe16d1..88c885a5 100644
--- a/internal/database/leaderboards.go
+++ b/internal/database/leaderboards.go
@@ -2,6 +2,7 @@ package database
 
 import (
 	"context"
+	"time"
 
 	"entgo.io/ent/dialect/sql"
 	"github.com/cufee/aftermath/internal/database/ent/db"
@@ -106,3 +107,8 @@ func (c *client) GetLeaderboardScores(ctx context.Context, leaderboard models.Le
 	}
 	return scores, nil
 }
+
+func (c *client) DeleteExpiredLeaderboardScores(ctx context.Context, expiration time.Time) error {
+	_, err := c.db.LeaderboardScore.Delete().Where(leaderboardscore.CreatedAtLT(expiration)).Exec(ctx)
+	return err
+}
diff --git a/internal/logic/leaderboards.go b/internal/logic/leaderboards.go
index 8bc0bb28..900c4b8f 100644
--- a/internal/logic/leaderboards.go
+++ b/internal/logic/leaderboards.go
@@ -55,8 +55,13 @@ func UpdateAccountAchievementsLeaderboardScores(ctx context.Context, wgClient wa
 		})
 	}
 
-	// save scores to database
-	_ = scores
+	sErrors, err := dbClient.CreateLeaderboardScores(ctx, scores...)
+	if err != nil {
+		return nil, err
+	}
+	if len(sErrors) > 0 {
+		return sErrors, nil
+	}
 
 	return nil, nil
 }
diff --git a/tests/static_database.go b/tests/static_database.go
index 2cb6e00c..5c392811 100644
--- a/tests/static_database.go
+++ b/tests/static_database.go
@@ -197,3 +197,13 @@ func (c *staticTestingDatabase) FindSession(ctx context.Context, publicID string
 func (c *staticTestingDatabase) UserFromSession(ctx context.Context, publicID string, opts ...database.UserGetOption) (models.User, error) {
 	return DefaultUserWithEdges, nil
 }
+
+func (c *staticTestingDatabase) CreateLeaderboardScores(ctx context.Context, scores ...models.LeaderboardScore) (map[string]error, error) {
+	return nil, errors.New("CreateLeaderboardScores not implemented")
+}
+func (c *staticTestingDatabase) GetLeaderboardScores(ctx context.Context, leaderboard models.LeaderboardID, scoreType models.ScoreType, options ...database.Query) ([]models.LeaderboardScore, error) {
+	return nil, errors.New("GetLeaderboardScores not implemented")
+}
+func (c *staticTestingDatabase) DeleteExpiredLeaderboardScores(ctx context.Context, expiration time.Time) error {
+	return errors.New("DeleteExpiredLeaderboardScores not implemented")
+}

From 095c96ca6046e23acb52b112f2416bce32604702 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Tue, 9 Jul 2024 14:48:36 -0400
Subject: [PATCH 322/341] finished leaderboards first draft

---
 .github/workflows/build-packages.yml          |  21 ++-
 Taskfile.yaml                                 |   6 +
 cmd/core/scheduler/scheduler.go               |  12 +-
 cmd/core/scheduler/workers.go                 |   4 +-
 cmd/core/tasks/cleanup.go                     |  23 ++-
 cmd/core/tasks/leaderboards.go                |  16 +-
 cmd/discord/rest/client.go                    |   2 +-
 internal/database/client.go                   |   4 +-
 internal/database/ent/db/leaderboardscore.go  |  19 ++-
 .../db/leaderboardscore/leaderboardscore.go   |  20 ++-
 .../database/ent/db/leaderboardscore/where.go | 146 ++++++++++++++---
 .../ent/db/leaderboardscore_create.go         |  24 ++-
 .../ent/db/leaderboardscore_update.go         |  68 +++++---
 internal/database/ent/db/migrate/schema.go    |  31 ++--
 internal/database/ent/db/mutation.go          |  68 +++++++-
 .../ent/migrations/20240709150702.sql         |  20 +++
 internal/database/ent/migrations/atlas.sum    |   3 +-
 .../database/ent/schema/leaderboard_score.go  |  14 +-
 internal/database/leaderboards.go             |  19 +--
 internal/database/models/leaderboard_score.go |  23 +--
 internal/logic/leaderboards.go                | 151 ++++++++++++++----
 internal/logic/snapshots.go                   |  29 ++--
 tests/static_database.go                      |   4 +-
 23 files changed, 527 insertions(+), 200 deletions(-)
 create mode 100644 internal/database/ent/migrations/20240709150702.sql

diff --git a/.github/workflows/build-packages.yml b/.github/workflows/build-packages.yml
index 730ee1b3..da621a7d 100644
--- a/.github/workflows/build-packages.yml
+++ b/.github/workflows/build-packages.yml
@@ -67,17 +67,6 @@ jobs:
       # This step uses the `docker/build-push-action` action to build the image, based on your repository's `Dockerfile`. If the build succeeds, it pushes the image to GitHub Packages.
       # It uses the `context` parameter to define the build's context as the set of files located in the specified path. For more information, see "[Usage](https://github.com/docker/build-push-action#usage)" in the README of the `docker/build-push-action` repository.
       # It uses the `tags` and `labels` parameters to tag and label the image with the output from the "meta" step.
-      - name: Build and push migrations Docker image
-        id: push-migrations
-        uses: docker/build-push-action@v6
-        with:
-          context: .
-          push: true
-          # platforms: linux/amd64,linux/arm64
-          tags: ${{ steps.meta-migrations.outputs.tags }}
-          labels: ${{ steps.meta-migrations.outputs.labels }}
-          file: Dockerfile.migrate
-
       - name: Build and push service Docker image
         id: push-service
         uses: docker/build-push-action@v6
@@ -91,6 +80,16 @@ jobs:
           build-args: |
             BRAND_FLAVOR=${{ env.BRAND_FLAVOR }}
             GO_MEM_LIMIT=${{ env.GO_MEM_LIMIT }}
+      - name: Build and push migrations Docker image
+        id: push-migrations
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          push: true
+          # platforms: linux/amd64,linux/arm64
+          tags: ${{ steps.meta-migrations.outputs.tags }}
+          labels: ${{ steps.meta-migrations.outputs.labels }}
+          file: Dockerfile.migrate
       
       # This step generates an artifact attestation for the image, which is an unforgeable statement about where and how it was built. It increases supply chain security for people who consume the image. For more information, see "[AUTOTITLE](/actions/security-guides/using-artifact-attestations-to-establish-provenance-for-builds)." 
       - name: Generate migrations artifact attestation
diff --git a/Taskfile.yaml b/Taskfile.yaml
index 5200e7d2..bfa122d8 100644
--- a/Taskfile.yaml
+++ b/Taskfile.yaml
@@ -34,6 +34,12 @@ tasks:
       # variables will be pulled from global vars declaration unless overwritten in the task call
       - echo "Applying migrations to {{.DATABASE_PATH}}/{{.DATABASE_NAME}}"
       - atlas migrate apply --allow-dirty --dir "file://internal/database/ent/migrations" --tx-mode all --url "sqlite://{{.DATABASE_PATH}}/{{.DATABASE_NAME}}?_fk=1"
+  db-migrate-down:
+    desc: rollback migrations using atlas
+    cmds: 
+      # variables will be pulled from global vars declaration unless overwritten in the task call
+      - echo "Applying down migrations to {{.DATABASE_PATH}}/{{.DATABASE_NAME}}"
+      - atlas migrate down --dir "file://internal/database/ent/migrations" --url "sqlite://{{.DATABASE_PATH}}/{{.DATABASE_NAME}}?_fk=1" --dev-url "sqlite://file?mode=memory&_fk=1" {{ .CLI_ARGS }}
   db-migrate-apply-test:
     desc: apply migrations to the tests database using atlas
     cmds:
diff --git a/cmd/core/scheduler/scheduler.go b/cmd/core/scheduler/scheduler.go
index ad506f77..d9d0ae20 100644
--- a/cmd/core/scheduler/scheduler.go
+++ b/cmd/core/scheduler/scheduler.go
@@ -5,6 +5,7 @@ import (
 	"time"
 
 	"github.com/cufee/aftermath/cmd/core"
+	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/go-co-op/gocron"
 )
 
@@ -49,9 +50,14 @@ func RegisterDefaultTasks(s *scheduler, coreClient core.Client) {
 	s.Add("0 18 * * *", CreateSnapshotTasksWorker(coreClient, "AS")) // Asia
 
 	// Achievement leaderboards. ideally, this should not delay snapshots
-	s.Add("25 * * * *", CreateLeaderboardTasksWorker(coreClient, "NA")) // NA
-	s.Add("30 * * * *", CreateLeaderboardTasksWorker(coreClient, "EU")) // EU
-	s.Add("35 * * * *", CreateLeaderboardTasksWorker(coreClient, "AS")) // Asia
+	// hourly
+	s.Add("25 * * * *", CreateLeaderboardTasksWorker(coreClient, "NA", models.LeaderboardScoreHourly)) // NA
+	s.Add("30 * * * *", CreateLeaderboardTasksWorker(coreClient, "EU", models.LeaderboardScoreHourly)) // EU
+	s.Add("35 * * * *", CreateLeaderboardTasksWorker(coreClient, "AS", models.LeaderboardScoreHourly)) // Asia
+	// daily
+	s.Add("0 8 * * *", CreateLeaderboardTasksWorker(coreClient, "NA", models.LeaderboardScoreDaily))  // NA
+	s.Add("0 0 * * *", CreateLeaderboardTasksWorker(coreClient, "EU", models.LeaderboardScoreDaily))  // EU
+	s.Add("0 17 * * *", CreateLeaderboardTasksWorker(coreClient, "AS", models.LeaderboardScoreDaily)) // Asia
 
 	// Configurations
 	s.Add("0 0 */7 * *", RotateBackgroundPresetsWorker(coreClient))
diff --git a/cmd/core/scheduler/workers.go b/cmd/core/scheduler/workers.go
index 9ecb6885..3c877308 100644
--- a/cmd/core/scheduler/workers.go
+++ b/cmd/core/scheduler/workers.go
@@ -157,9 +157,9 @@ func UpdateGlossaryWorker(client core.Client) func() {
 	}
 }
 
-func CreateLeaderboardTasksWorker(client core.Client, realm string) func() {
+func CreateLeaderboardTasksWorker(client core.Client, realm string, scoreType models.ScoreType) func() {
 	return func() {
-		err := tasks.CreateUpdateLeaderboardsTasks(client, realm)
+		err := tasks.CreateUpdateLeaderboardsTasks(client, realm, scoreType)
 		if err != nil {
 			log.Err(err).Str("realm", realm).Msg("failed to schedule leaderboard update tasks")
 		}
diff --git a/cmd/core/tasks/cleanup.go b/cmd/core/tasks/cleanup.go
index ea3d5901..9adea17e 100644
--- a/cmd/core/tasks/cleanup.go
+++ b/cmd/core/tasks/cleanup.go
@@ -45,11 +45,21 @@ func init() {
 				}
 			}
 			{
-				leaderboardsExpiration, err := time.Parse(time.RFC3339, task.Data["expiration_leaderboards"])
+				leaderboardsExpiration, err := time.Parse(time.RFC3339, task.Data["expiration_leaderboards_daily"])
 				if err != nil {
 					return errors.Wrap(err, "failed to parse expiration_snapshots to time")
 				}
-				err = client.Database().DeleteExpiredLeaderboardScores(ctx, leaderboardsExpiration)
+				err = client.Database().DeleteExpiredLeaderboardScores(ctx, leaderboardsExpiration, models.LeaderboardScoreDaily)
+				if err != nil && !database.IsNotFound(err) {
+					return errors.Wrap(err, "failed to delete expired leaderboard scores")
+				}
+			}
+			{
+				leaderboardsExpiration, err := time.Parse(time.RFC3339, task.Data["expiration_leaderboards_hourly"])
+				if err != nil {
+					return errors.Wrap(err, "failed to parse expiration_snapshots to time")
+				}
+				err = client.Database().DeleteExpiredLeaderboardScores(ctx, leaderboardsExpiration, models.LeaderboardScoreHourly)
 				if err != nil && !database.IsNotFound(err) {
 					return errors.Wrap(err, "failed to delete expired leaderboard scores")
 				}
@@ -69,10 +79,11 @@ func CreateCleanupTasks(client core.Client) error {
 		ReferenceID:    "database_cleanup",
 		Type:           models.TaskTypeDatabaseCleanup,
 		Data: map[string]string{
-			"expiration_snapshots":    now.Add(-1 * time.Hour * 24 * 90).Format(time.RFC3339), // 90 days
-			"expiration_leaderboards": now.Add(-1 * time.Hour * 24 * 30).Format(time.RFC3339), // 30 days
-			"expiration_interactions": now.Add(-1 * time.Hour * 24 * 7).Format(time.RFC3339),  // 7 days
-			"expiration_tasks":        now.Add(-1 * time.Hour * 24 * 7).Format(time.RFC3339),  // 7 days
+			"expiration_leaderboards_hourly": now.Add(-1 * time.Hour * 24).Format(time.RFC3339),      // 1 day
+			"expiration_leaderboards_daily":  now.Add(-1 * time.Hour * 24 * 90).Format(time.RFC3339), // 90 days
+			"expiration_snapshots":           now.Add(-1 * time.Hour * 24 * 90).Format(time.RFC3339), // 90 days
+			"expiration_interactions":        now.Add(-1 * time.Hour * 24 * 7).Format(time.RFC3339),  // 7 days
+			"expiration_tasks":               now.Add(-1 * time.Hour * 24 * 7).Format(time.RFC3339),  // 7 days
 		},
 	}
 
diff --git a/cmd/core/tasks/leaderboards.go b/cmd/core/tasks/leaderboards.go
index ad72b9bc..048e83cf 100644
--- a/cmd/core/tasks/leaderboards.go
+++ b/cmd/core/tasks/leaderboards.go
@@ -2,6 +2,7 @@ package tasks
 
 import (
 	"context"
+	"slices"
 	"strings"
 	"time"
 
@@ -19,6 +20,11 @@ func init() {
 			if !ok {
 				return errors.New("invalid realm")
 			}
+			scoreType, ok := task.Data["type"]
+			if !ok || !slices.Contains(models.ScoreType("").Values(), scoreType) {
+				return errors.New("invalid score type")
+			}
+
 			if len(task.Targets) > 100 {
 				return errors.New("invalid targets length")
 			}
@@ -26,9 +32,9 @@ func init() {
 				return errors.New("invalid targets length")
 			}
 
-			accountErrors, err := logic.UpdateAccountAchievementsLeaderboardScores(ctx, client.Wargaming(), client.Database(), realm, false, task.Targets...)
+			accountErrors, err := logic.RecordCurrentAchievementsLeaderboards(ctx, client.Wargaming(), client.Database(), models.ScoreType(scoreType), realm, false, task.Targets...)
 			if err != nil {
-				return err
+				return err // implicitly retry all targets
 			}
 
 			// retry failed accounts
@@ -50,17 +56,19 @@ func init() {
 				return errors.New("some accounts failed")
 			}
 			return nil
+
 		},
 	}
 }
 
-func CreateUpdateLeaderboardsTasks(client core.Client, realm string) error {
+func CreateUpdateLeaderboardsTasks(client core.Client, realm string, scoreType models.ScoreType) error {
 	realm = strings.ToUpper(realm)
 	task := models.Task{
 		Type:           models.TaskTypeAchievementsLeaderboardUpdate,
 		ReferenceID:    "realm_" + realm,
 		ScheduledAfter: time.Now(),
 		Data: map[string]string{
+			"type":  string(scoreType),
 			"realm": realm,
 		},
 		TriesLeft: 3,
@@ -82,7 +90,7 @@ func CreateUpdateLeaderboardsTasks(client core.Client, realm string) error {
 	// 1 - get all accounts last battle time
 	// 1 - get all account achievements
 	// n - get vehicle achievements for each account
-	tasks := splitTaskByTargets(task, 75)
+	tasks := splitTaskByTargets(task, 50)
 	err = client.Database().CreateTasks(ctx, tasks...)
 	if err != nil {
 		return err
diff --git a/cmd/discord/rest/client.go b/cmd/discord/rest/client.go
index 4adaad56..fdf2d6ad 100644
--- a/cmd/discord/rest/client.go
+++ b/cmd/discord/rest/client.go
@@ -29,7 +29,7 @@ func NewClient(token string) (*Client, error) {
 		http:  http.Client{Timeout: time.Millisecond * 5000}, // discord is very slow sometimes
 	}
 
-	ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*500)
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
 
 	_, err := client.lookupApplicationID(ctx)
diff --git a/internal/database/client.go b/internal/database/client.go
index 4abe8ce0..f873383c 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -73,9 +73,9 @@ type SnapshotsClient interface {
 
 type LeaderboardsClient interface {
 	CreateLeaderboardScores(ctx context.Context, scores ...models.LeaderboardScore) (map[string]error, error)
-	GetLeaderboardScores(ctx context.Context, leaderboard models.LeaderboardID, scoreType models.ScoreType, options ...Query) ([]models.LeaderboardScore, error)
+	GetLeaderboardScores(ctx context.Context, leaderboardID string, scoreType models.ScoreType, options ...Query) ([]models.LeaderboardScore, error)
 
-	DeleteExpiredLeaderboardScores(ctx context.Context, expiration time.Time) error
+	DeleteExpiredLeaderboardScores(ctx context.Context, expiration time.Time, scoreType models.ScoreType) error
 }
 
 type TasksClient interface {
diff --git a/internal/database/ent/db/leaderboardscore.go b/internal/database/ent/db/leaderboardscore.go
index 93fab4ec..6468f119 100644
--- a/internal/database/ent/db/leaderboardscore.go
+++ b/internal/database/ent/db/leaderboardscore.go
@@ -27,10 +27,12 @@ type LeaderboardScore struct {
 	Type models.ScoreType `json:"type,omitempty"`
 	// Score holds the value of the "score" field.
 	Score float32 `json:"score,omitempty"`
+	// AccountID holds the value of the "account_id" field.
+	AccountID string `json:"account_id,omitempty"`
 	// ReferenceID holds the value of the "reference_id" field.
 	ReferenceID string `json:"reference_id,omitempty"`
 	// LeaderboardID holds the value of the "leaderboard_id" field.
-	LeaderboardID models.LeaderboardID `json:"leaderboard_id,omitempty"`
+	LeaderboardID string `json:"leaderboard_id,omitempty"`
 	// Meta holds the value of the "meta" field.
 	Meta         map[string]interface{} `json:"meta,omitempty"`
 	selectValues sql.SelectValues
@@ -45,7 +47,7 @@ func (*LeaderboardScore) scanValues(columns []string) ([]any, error) {
 			values[i] = new([]byte)
 		case leaderboardscore.FieldScore:
 			values[i] = new(sql.NullFloat64)
-		case leaderboardscore.FieldID, leaderboardscore.FieldType, leaderboardscore.FieldReferenceID, leaderboardscore.FieldLeaderboardID:
+		case leaderboardscore.FieldID, leaderboardscore.FieldType, leaderboardscore.FieldAccountID, leaderboardscore.FieldReferenceID, leaderboardscore.FieldLeaderboardID:
 			values[i] = new(sql.NullString)
 		case leaderboardscore.FieldCreatedAt, leaderboardscore.FieldUpdatedAt:
 			values[i] = new(sql.NullTime)
@@ -94,6 +96,12 @@ func (ls *LeaderboardScore) assignValues(columns []string, values []any) error {
 			} else if value.Valid {
 				ls.Score = float32(value.Float64)
 			}
+		case leaderboardscore.FieldAccountID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field account_id", values[i])
+			} else if value.Valid {
+				ls.AccountID = value.String
+			}
 		case leaderboardscore.FieldReferenceID:
 			if value, ok := values[i].(*sql.NullString); !ok {
 				return fmt.Errorf("unexpected type %T for field reference_id", values[i])
@@ -104,7 +112,7 @@ func (ls *LeaderboardScore) assignValues(columns []string, values []any) error {
 			if value, ok := values[i].(*sql.NullString); !ok {
 				return fmt.Errorf("unexpected type %T for field leaderboard_id", values[i])
 			} else if value.Valid {
-				ls.LeaderboardID = models.LeaderboardID(value.String)
+				ls.LeaderboardID = value.String
 			}
 		case leaderboardscore.FieldMeta:
 			if value, ok := values[i].(*[]byte); !ok {
@@ -162,11 +170,14 @@ func (ls *LeaderboardScore) String() string {
 	builder.WriteString("score=")
 	builder.WriteString(fmt.Sprintf("%v", ls.Score))
 	builder.WriteString(", ")
+	builder.WriteString("account_id=")
+	builder.WriteString(ls.AccountID)
+	builder.WriteString(", ")
 	builder.WriteString("reference_id=")
 	builder.WriteString(ls.ReferenceID)
 	builder.WriteString(", ")
 	builder.WriteString("leaderboard_id=")
-	builder.WriteString(fmt.Sprintf("%v", ls.LeaderboardID))
+	builder.WriteString(ls.LeaderboardID)
 	builder.WriteString(", ")
 	builder.WriteString("meta=")
 	builder.WriteString(fmt.Sprintf("%v", ls.Meta))
diff --git a/internal/database/ent/db/leaderboardscore/leaderboardscore.go b/internal/database/ent/db/leaderboardscore/leaderboardscore.go
index 7ed97521..7f8fcd58 100644
--- a/internal/database/ent/db/leaderboardscore/leaderboardscore.go
+++ b/internal/database/ent/db/leaderboardscore/leaderboardscore.go
@@ -23,6 +23,8 @@ const (
 	FieldType = "type"
 	// FieldScore holds the string denoting the score field in the database.
 	FieldScore = "score"
+	// FieldAccountID holds the string denoting the account_id field in the database.
+	FieldAccountID = "account_id"
 	// FieldReferenceID holds the string denoting the reference_id field in the database.
 	FieldReferenceID = "reference_id"
 	// FieldLeaderboardID holds the string denoting the leaderboard_id field in the database.
@@ -40,6 +42,7 @@ var Columns = []string{
 	FieldUpdatedAt,
 	FieldType,
 	FieldScore,
+	FieldAccountID,
 	FieldReferenceID,
 	FieldLeaderboardID,
 	FieldMeta,
@@ -69,23 +72,13 @@ var (
 // TypeValidator is a validator for the "type" field enum values. It is called by the builders before save.
 func TypeValidator(_type models.ScoreType) error {
 	switch _type {
-	case "custom", "hourly", "daily":
+	case "hourly", "daily":
 		return nil
 	default:
 		return fmt.Errorf("leaderboardscore: invalid enum value for type field: %q", _type)
 	}
 }
 
-// LeaderboardIDValidator is a validator for the "leaderboard_id" field enum values. It is called by the builders before save.
-func LeaderboardIDValidator(li models.LeaderboardID) error {
-	switch li {
-	case "mastery-weighted-players", "mastery-weighted-clans":
-		return nil
-	default:
-		return fmt.Errorf("leaderboardscore: invalid enum value for leaderboard_id field: %q", li)
-	}
-}
-
 // OrderOption defines the ordering options for the LeaderboardScore queries.
 type OrderOption func(*sql.Selector)
 
@@ -114,6 +107,11 @@ func ByScore(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldScore, opts...).ToFunc()
 }
 
+// ByAccountID orders the results by the account_id field.
+func ByAccountID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldAccountID, opts...).ToFunc()
+}
+
 // ByReferenceID orders the results by the reference_id field.
 func ByReferenceID(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldReferenceID, opts...).ToFunc()
diff --git a/internal/database/ent/db/leaderboardscore/where.go b/internal/database/ent/db/leaderboardscore/where.go
index 25877ee2..437c1cc7 100644
--- a/internal/database/ent/db/leaderboardscore/where.go
+++ b/internal/database/ent/db/leaderboardscore/where.go
@@ -80,11 +80,21 @@ func Score(v float32) predicate.LeaderboardScore {
 	return predicate.LeaderboardScore(sql.FieldEQ(FieldScore, v))
 }
 
+// AccountID applies equality check predicate on the "account_id" field. It's identical to AccountIDEQ.
+func AccountID(v string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldEQ(FieldAccountID, v))
+}
+
 // ReferenceID applies equality check predicate on the "reference_id" field. It's identical to ReferenceIDEQ.
 func ReferenceID(v string) predicate.LeaderboardScore {
 	return predicate.LeaderboardScore(sql.FieldEQ(FieldReferenceID, v))
 }
 
+// LeaderboardID applies equality check predicate on the "leaderboard_id" field. It's identical to LeaderboardIDEQ.
+func LeaderboardID(v string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldEQ(FieldLeaderboardID, v))
+}
+
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
 func CreatedAtEQ(v time.Time) predicate.LeaderboardScore {
 	return predicate.LeaderboardScore(sql.FieldEQ(FieldCreatedAt, v))
@@ -235,6 +245,71 @@ func ScoreLTE(v float32) predicate.LeaderboardScore {
 	return predicate.LeaderboardScore(sql.FieldLTE(FieldScore, v))
 }
 
+// AccountIDEQ applies the EQ predicate on the "account_id" field.
+func AccountIDEQ(v string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldEQ(FieldAccountID, v))
+}
+
+// AccountIDNEQ applies the NEQ predicate on the "account_id" field.
+func AccountIDNEQ(v string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldNEQ(FieldAccountID, v))
+}
+
+// AccountIDIn applies the In predicate on the "account_id" field.
+func AccountIDIn(vs ...string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldIn(FieldAccountID, vs...))
+}
+
+// AccountIDNotIn applies the NotIn predicate on the "account_id" field.
+func AccountIDNotIn(vs ...string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldNotIn(FieldAccountID, vs...))
+}
+
+// AccountIDGT applies the GT predicate on the "account_id" field.
+func AccountIDGT(v string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldGT(FieldAccountID, v))
+}
+
+// AccountIDGTE applies the GTE predicate on the "account_id" field.
+func AccountIDGTE(v string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldGTE(FieldAccountID, v))
+}
+
+// AccountIDLT applies the LT predicate on the "account_id" field.
+func AccountIDLT(v string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldLT(FieldAccountID, v))
+}
+
+// AccountIDLTE applies the LTE predicate on the "account_id" field.
+func AccountIDLTE(v string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldLTE(FieldAccountID, v))
+}
+
+// AccountIDContains applies the Contains predicate on the "account_id" field.
+func AccountIDContains(v string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldContains(FieldAccountID, v))
+}
+
+// AccountIDHasPrefix applies the HasPrefix predicate on the "account_id" field.
+func AccountIDHasPrefix(v string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldHasPrefix(FieldAccountID, v))
+}
+
+// AccountIDHasSuffix applies the HasSuffix predicate on the "account_id" field.
+func AccountIDHasSuffix(v string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldHasSuffix(FieldAccountID, v))
+}
+
+// AccountIDEqualFold applies the EqualFold predicate on the "account_id" field.
+func AccountIDEqualFold(v string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldEqualFold(FieldAccountID, v))
+}
+
+// AccountIDContainsFold applies the ContainsFold predicate on the "account_id" field.
+func AccountIDContainsFold(v string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldContainsFold(FieldAccountID, v))
+}
+
 // ReferenceIDEQ applies the EQ predicate on the "reference_id" field.
 func ReferenceIDEQ(v string) predicate.LeaderboardScore {
 	return predicate.LeaderboardScore(sql.FieldEQ(FieldReferenceID, v))
@@ -301,33 +376,68 @@ func ReferenceIDContainsFold(v string) predicate.LeaderboardScore {
 }
 
 // LeaderboardIDEQ applies the EQ predicate on the "leaderboard_id" field.
-func LeaderboardIDEQ(v models.LeaderboardID) predicate.LeaderboardScore {
-	vc := v
-	return predicate.LeaderboardScore(sql.FieldEQ(FieldLeaderboardID, vc))
+func LeaderboardIDEQ(v string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldEQ(FieldLeaderboardID, v))
 }
 
 // LeaderboardIDNEQ applies the NEQ predicate on the "leaderboard_id" field.
-func LeaderboardIDNEQ(v models.LeaderboardID) predicate.LeaderboardScore {
-	vc := v
-	return predicate.LeaderboardScore(sql.FieldNEQ(FieldLeaderboardID, vc))
+func LeaderboardIDNEQ(v string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldNEQ(FieldLeaderboardID, v))
 }
 
 // LeaderboardIDIn applies the In predicate on the "leaderboard_id" field.
-func LeaderboardIDIn(vs ...models.LeaderboardID) predicate.LeaderboardScore {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.LeaderboardScore(sql.FieldIn(FieldLeaderboardID, v...))
+func LeaderboardIDIn(vs ...string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldIn(FieldLeaderboardID, vs...))
 }
 
 // LeaderboardIDNotIn applies the NotIn predicate on the "leaderboard_id" field.
-func LeaderboardIDNotIn(vs ...models.LeaderboardID) predicate.LeaderboardScore {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.LeaderboardScore(sql.FieldNotIn(FieldLeaderboardID, v...))
+func LeaderboardIDNotIn(vs ...string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldNotIn(FieldLeaderboardID, vs...))
+}
+
+// LeaderboardIDGT applies the GT predicate on the "leaderboard_id" field.
+func LeaderboardIDGT(v string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldGT(FieldLeaderboardID, v))
+}
+
+// LeaderboardIDGTE applies the GTE predicate on the "leaderboard_id" field.
+func LeaderboardIDGTE(v string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldGTE(FieldLeaderboardID, v))
+}
+
+// LeaderboardIDLT applies the LT predicate on the "leaderboard_id" field.
+func LeaderboardIDLT(v string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldLT(FieldLeaderboardID, v))
+}
+
+// LeaderboardIDLTE applies the LTE predicate on the "leaderboard_id" field.
+func LeaderboardIDLTE(v string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldLTE(FieldLeaderboardID, v))
+}
+
+// LeaderboardIDContains applies the Contains predicate on the "leaderboard_id" field.
+func LeaderboardIDContains(v string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldContains(FieldLeaderboardID, v))
+}
+
+// LeaderboardIDHasPrefix applies the HasPrefix predicate on the "leaderboard_id" field.
+func LeaderboardIDHasPrefix(v string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldHasPrefix(FieldLeaderboardID, v))
+}
+
+// LeaderboardIDHasSuffix applies the HasSuffix predicate on the "leaderboard_id" field.
+func LeaderboardIDHasSuffix(v string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldHasSuffix(FieldLeaderboardID, v))
+}
+
+// LeaderboardIDEqualFold applies the EqualFold predicate on the "leaderboard_id" field.
+func LeaderboardIDEqualFold(v string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldEqualFold(FieldLeaderboardID, v))
+}
+
+// LeaderboardIDContainsFold applies the ContainsFold predicate on the "leaderboard_id" field.
+func LeaderboardIDContainsFold(v string) predicate.LeaderboardScore {
+	return predicate.LeaderboardScore(sql.FieldContainsFold(FieldLeaderboardID, v))
 }
 
 // And groups predicates with the AND operator between them.
diff --git a/internal/database/ent/db/leaderboardscore_create.go b/internal/database/ent/db/leaderboardscore_create.go
index 276e3572..ad6ff331 100644
--- a/internal/database/ent/db/leaderboardscore_create.go
+++ b/internal/database/ent/db/leaderboardscore_create.go
@@ -61,6 +61,12 @@ func (lsc *LeaderboardScoreCreate) SetScore(f float32) *LeaderboardScoreCreate {
 	return lsc
 }
 
+// SetAccountID sets the "account_id" field.
+func (lsc *LeaderboardScoreCreate) SetAccountID(s string) *LeaderboardScoreCreate {
+	lsc.mutation.SetAccountID(s)
+	return lsc
+}
+
 // SetReferenceID sets the "reference_id" field.
 func (lsc *LeaderboardScoreCreate) SetReferenceID(s string) *LeaderboardScoreCreate {
 	lsc.mutation.SetReferenceID(s)
@@ -68,8 +74,8 @@ func (lsc *LeaderboardScoreCreate) SetReferenceID(s string) *LeaderboardScoreCre
 }
 
 // SetLeaderboardID sets the "leaderboard_id" field.
-func (lsc *LeaderboardScoreCreate) SetLeaderboardID(mi models.LeaderboardID) *LeaderboardScoreCreate {
-	lsc.mutation.SetLeaderboardID(mi)
+func (lsc *LeaderboardScoreCreate) SetLeaderboardID(s string) *LeaderboardScoreCreate {
+	lsc.mutation.SetLeaderboardID(s)
 	return lsc
 }
 
@@ -161,17 +167,15 @@ func (lsc *LeaderboardScoreCreate) check() error {
 	if _, ok := lsc.mutation.Score(); !ok {
 		return &ValidationError{Name: "score", err: errors.New(`db: missing required field "LeaderboardScore.score"`)}
 	}
+	if _, ok := lsc.mutation.AccountID(); !ok {
+		return &ValidationError{Name: "account_id", err: errors.New(`db: missing required field "LeaderboardScore.account_id"`)}
+	}
 	if _, ok := lsc.mutation.ReferenceID(); !ok {
 		return &ValidationError{Name: "reference_id", err: errors.New(`db: missing required field "LeaderboardScore.reference_id"`)}
 	}
 	if _, ok := lsc.mutation.LeaderboardID(); !ok {
 		return &ValidationError{Name: "leaderboard_id", err: errors.New(`db: missing required field "LeaderboardScore.leaderboard_id"`)}
 	}
-	if v, ok := lsc.mutation.LeaderboardID(); ok {
-		if err := leaderboardscore.LeaderboardIDValidator(v); err != nil {
-			return &ValidationError{Name: "leaderboard_id", err: fmt.Errorf(`db: validator failed for field "LeaderboardScore.leaderboard_id": %w`, err)}
-		}
-	}
 	if _, ok := lsc.mutation.Meta(); !ok {
 		return &ValidationError{Name: "meta", err: errors.New(`db: missing required field "LeaderboardScore.meta"`)}
 	}
@@ -226,12 +230,16 @@ func (lsc *LeaderboardScoreCreate) createSpec() (*LeaderboardScore, *sqlgraph.Cr
 		_spec.SetField(leaderboardscore.FieldScore, field.TypeFloat32, value)
 		_node.Score = value
 	}
+	if value, ok := lsc.mutation.AccountID(); ok {
+		_spec.SetField(leaderboardscore.FieldAccountID, field.TypeString, value)
+		_node.AccountID = value
+	}
 	if value, ok := lsc.mutation.ReferenceID(); ok {
 		_spec.SetField(leaderboardscore.FieldReferenceID, field.TypeString, value)
 		_node.ReferenceID = value
 	}
 	if value, ok := lsc.mutation.LeaderboardID(); ok {
-		_spec.SetField(leaderboardscore.FieldLeaderboardID, field.TypeEnum, value)
+		_spec.SetField(leaderboardscore.FieldLeaderboardID, field.TypeString, value)
 		_node.LeaderboardID = value
 	}
 	if value, ok := lsc.mutation.Meta(); ok {
diff --git a/internal/database/ent/db/leaderboardscore_update.go b/internal/database/ent/db/leaderboardscore_update.go
index 600d8717..0a232a53 100644
--- a/internal/database/ent/db/leaderboardscore_update.go
+++ b/internal/database/ent/db/leaderboardscore_update.go
@@ -71,6 +71,20 @@ func (lsu *LeaderboardScoreUpdate) AddScore(f float32) *LeaderboardScoreUpdate {
 	return lsu
 }
 
+// SetAccountID sets the "account_id" field.
+func (lsu *LeaderboardScoreUpdate) SetAccountID(s string) *LeaderboardScoreUpdate {
+	lsu.mutation.SetAccountID(s)
+	return lsu
+}
+
+// SetNillableAccountID sets the "account_id" field if the given value is not nil.
+func (lsu *LeaderboardScoreUpdate) SetNillableAccountID(s *string) *LeaderboardScoreUpdate {
+	if s != nil {
+		lsu.SetAccountID(*s)
+	}
+	return lsu
+}
+
 // SetReferenceID sets the "reference_id" field.
 func (lsu *LeaderboardScoreUpdate) SetReferenceID(s string) *LeaderboardScoreUpdate {
 	lsu.mutation.SetReferenceID(s)
@@ -86,15 +100,15 @@ func (lsu *LeaderboardScoreUpdate) SetNillableReferenceID(s *string) *Leaderboar
 }
 
 // SetLeaderboardID sets the "leaderboard_id" field.
-func (lsu *LeaderboardScoreUpdate) SetLeaderboardID(mi models.LeaderboardID) *LeaderboardScoreUpdate {
-	lsu.mutation.SetLeaderboardID(mi)
+func (lsu *LeaderboardScoreUpdate) SetLeaderboardID(s string) *LeaderboardScoreUpdate {
+	lsu.mutation.SetLeaderboardID(s)
 	return lsu
 }
 
 // SetNillableLeaderboardID sets the "leaderboard_id" field if the given value is not nil.
-func (lsu *LeaderboardScoreUpdate) SetNillableLeaderboardID(mi *models.LeaderboardID) *LeaderboardScoreUpdate {
-	if mi != nil {
-		lsu.SetLeaderboardID(*mi)
+func (lsu *LeaderboardScoreUpdate) SetNillableLeaderboardID(s *string) *LeaderboardScoreUpdate {
+	if s != nil {
+		lsu.SetLeaderboardID(*s)
 	}
 	return lsu
 }
@@ -153,11 +167,6 @@ func (lsu *LeaderboardScoreUpdate) check() error {
 			return &ValidationError{Name: "type", err: fmt.Errorf(`db: validator failed for field "LeaderboardScore.type": %w`, err)}
 		}
 	}
-	if v, ok := lsu.mutation.LeaderboardID(); ok {
-		if err := leaderboardscore.LeaderboardIDValidator(v); err != nil {
-			return &ValidationError{Name: "leaderboard_id", err: fmt.Errorf(`db: validator failed for field "LeaderboardScore.leaderboard_id": %w`, err)}
-		}
-	}
 	return nil
 }
 
@@ -191,11 +200,14 @@ func (lsu *LeaderboardScoreUpdate) sqlSave(ctx context.Context) (n int, err erro
 	if value, ok := lsu.mutation.AddedScore(); ok {
 		_spec.AddField(leaderboardscore.FieldScore, field.TypeFloat32, value)
 	}
+	if value, ok := lsu.mutation.AccountID(); ok {
+		_spec.SetField(leaderboardscore.FieldAccountID, field.TypeString, value)
+	}
 	if value, ok := lsu.mutation.ReferenceID(); ok {
 		_spec.SetField(leaderboardscore.FieldReferenceID, field.TypeString, value)
 	}
 	if value, ok := lsu.mutation.LeaderboardID(); ok {
-		_spec.SetField(leaderboardscore.FieldLeaderboardID, field.TypeEnum, value)
+		_spec.SetField(leaderboardscore.FieldLeaderboardID, field.TypeString, value)
 	}
 	if value, ok := lsu.mutation.Meta(); ok {
 		_spec.SetField(leaderboardscore.FieldMeta, field.TypeJSON, value)
@@ -263,6 +275,20 @@ func (lsuo *LeaderboardScoreUpdateOne) AddScore(f float32) *LeaderboardScoreUpda
 	return lsuo
 }
 
+// SetAccountID sets the "account_id" field.
+func (lsuo *LeaderboardScoreUpdateOne) SetAccountID(s string) *LeaderboardScoreUpdateOne {
+	lsuo.mutation.SetAccountID(s)
+	return lsuo
+}
+
+// SetNillableAccountID sets the "account_id" field if the given value is not nil.
+func (lsuo *LeaderboardScoreUpdateOne) SetNillableAccountID(s *string) *LeaderboardScoreUpdateOne {
+	if s != nil {
+		lsuo.SetAccountID(*s)
+	}
+	return lsuo
+}
+
 // SetReferenceID sets the "reference_id" field.
 func (lsuo *LeaderboardScoreUpdateOne) SetReferenceID(s string) *LeaderboardScoreUpdateOne {
 	lsuo.mutation.SetReferenceID(s)
@@ -278,15 +304,15 @@ func (lsuo *LeaderboardScoreUpdateOne) SetNillableReferenceID(s *string) *Leader
 }
 
 // SetLeaderboardID sets the "leaderboard_id" field.
-func (lsuo *LeaderboardScoreUpdateOne) SetLeaderboardID(mi models.LeaderboardID) *LeaderboardScoreUpdateOne {
-	lsuo.mutation.SetLeaderboardID(mi)
+func (lsuo *LeaderboardScoreUpdateOne) SetLeaderboardID(s string) *LeaderboardScoreUpdateOne {
+	lsuo.mutation.SetLeaderboardID(s)
 	return lsuo
 }
 
 // SetNillableLeaderboardID sets the "leaderboard_id" field if the given value is not nil.
-func (lsuo *LeaderboardScoreUpdateOne) SetNillableLeaderboardID(mi *models.LeaderboardID) *LeaderboardScoreUpdateOne {
-	if mi != nil {
-		lsuo.SetLeaderboardID(*mi)
+func (lsuo *LeaderboardScoreUpdateOne) SetNillableLeaderboardID(s *string) *LeaderboardScoreUpdateOne {
+	if s != nil {
+		lsuo.SetLeaderboardID(*s)
 	}
 	return lsuo
 }
@@ -358,11 +384,6 @@ func (lsuo *LeaderboardScoreUpdateOne) check() error {
 			return &ValidationError{Name: "type", err: fmt.Errorf(`db: validator failed for field "LeaderboardScore.type": %w`, err)}
 		}
 	}
-	if v, ok := lsuo.mutation.LeaderboardID(); ok {
-		if err := leaderboardscore.LeaderboardIDValidator(v); err != nil {
-			return &ValidationError{Name: "leaderboard_id", err: fmt.Errorf(`db: validator failed for field "LeaderboardScore.leaderboard_id": %w`, err)}
-		}
-	}
 	return nil
 }
 
@@ -413,11 +434,14 @@ func (lsuo *LeaderboardScoreUpdateOne) sqlSave(ctx context.Context) (_node *Lead
 	if value, ok := lsuo.mutation.AddedScore(); ok {
 		_spec.AddField(leaderboardscore.FieldScore, field.TypeFloat32, value)
 	}
+	if value, ok := lsuo.mutation.AccountID(); ok {
+		_spec.SetField(leaderboardscore.FieldAccountID, field.TypeString, value)
+	}
 	if value, ok := lsuo.mutation.ReferenceID(); ok {
 		_spec.SetField(leaderboardscore.FieldReferenceID, field.TypeString, value)
 	}
 	if value, ok := lsuo.mutation.LeaderboardID(); ok {
-		_spec.SetField(leaderboardscore.FieldLeaderboardID, field.TypeEnum, value)
+		_spec.SetField(leaderboardscore.FieldLeaderboardID, field.TypeString, value)
 	}
 	if value, ok := lsuo.mutation.Meta(); ok {
 		_spec.SetField(leaderboardscore.FieldMeta, field.TypeJSON, value)
diff --git a/internal/database/ent/db/migrate/schema.go b/internal/database/ent/db/migrate/schema.go
index 9d430051..1875f684 100644
--- a/internal/database/ent/db/migrate/schema.go
+++ b/internal/database/ent/db/migrate/schema.go
@@ -381,10 +381,11 @@ var (
 		{Name: "id", Type: field.TypeString, Unique: true},
 		{Name: "created_at", Type: field.TypeTime},
 		{Name: "updated_at", Type: field.TypeTime},
-		{Name: "type", Type: field.TypeEnum, Enums: []string{"custom", "hourly", "daily"}},
+		{Name: "type", Type: field.TypeEnum, Enums: []string{"hourly", "daily"}},
 		{Name: "score", Type: field.TypeFloat32},
+		{Name: "account_id", Type: field.TypeString},
 		{Name: "reference_id", Type: field.TypeString},
-		{Name: "leaderboard_id", Type: field.TypeEnum, Enums: []string{"mastery-weighted-players", "mastery-weighted-clans"}},
+		{Name: "leaderboard_id", Type: field.TypeString},
 		{Name: "meta", Type: field.TypeJSON},
 	}
 	// LeaderboardScoresTable holds the schema information for the "leaderboard_scores" table.
@@ -404,34 +405,24 @@ var (
 				Columns: []*schema.Column{LeaderboardScoresColumns[1]},
 			},
 			{
-				Name:    "leaderboardscore_created_at_type",
-				Unique:  false,
-				Columns: []*schema.Column{LeaderboardScoresColumns[1], LeaderboardScoresColumns[3]},
-			},
-			{
-				Name:    "leaderboardscore_score_type",
-				Unique:  false,
-				Columns: []*schema.Column{LeaderboardScoresColumns[4], LeaderboardScoresColumns[3]},
-			},
-			{
-				Name:    "leaderboardscore_leaderboard_id_type",
+				Name:    "leaderboardscore_account_id",
 				Unique:  false,
-				Columns: []*schema.Column{LeaderboardScoresColumns[6], LeaderboardScoresColumns[3]},
+				Columns: []*schema.Column{LeaderboardScoresColumns[5]},
 			},
 			{
-				Name:    "leaderboardscore_leaderboard_id_score_type",
+				Name:    "leaderboardscore_reference_id",
 				Unique:  false,
-				Columns: []*schema.Column{LeaderboardScoresColumns[6], LeaderboardScoresColumns[4], LeaderboardScoresColumns[3]},
+				Columns: []*schema.Column{LeaderboardScoresColumns[6]},
 			},
 			{
-				Name:    "leaderboardscore_leaderboard_id_reference_id_type",
+				Name:    "leaderboardscore_leaderboard_id_type_account_id",
 				Unique:  false,
-				Columns: []*schema.Column{LeaderboardScoresColumns[6], LeaderboardScoresColumns[5], LeaderboardScoresColumns[3]},
+				Columns: []*schema.Column{LeaderboardScoresColumns[7], LeaderboardScoresColumns[3], LeaderboardScoresColumns[5]},
 			},
 			{
-				Name:    "leaderboardscore_leaderboard_id_reference_id_score_type",
+				Name:    "leaderboardscore_leaderboard_id_type_reference_id",
 				Unique:  false,
-				Columns: []*schema.Column{LeaderboardScoresColumns[6], LeaderboardScoresColumns[5], LeaderboardScoresColumns[4], LeaderboardScoresColumns[3]},
+				Columns: []*schema.Column{LeaderboardScoresColumns[7], LeaderboardScoresColumns[3], LeaderboardScoresColumns[6]},
 			},
 		},
 	}
diff --git a/internal/database/ent/db/mutation.go b/internal/database/ent/db/mutation.go
index 6c761807..306d045d 100644
--- a/internal/database/ent/db/mutation.go
+++ b/internal/database/ent/db/mutation.go
@@ -7064,8 +7064,9 @@ type LeaderboardScoreMutation struct {
 	_type          *models.ScoreType
 	score          *float32
 	addscore       *float32
+	account_id     *string
 	reference_id   *string
-	leaderboard_id *models.LeaderboardID
+	leaderboard_id *string
 	meta           *map[string]interface{}
 	clearedFields  map[string]struct{}
 	done           bool
@@ -7341,6 +7342,42 @@ func (m *LeaderboardScoreMutation) ResetScore() {
 	m.addscore = nil
 }
 
+// SetAccountID sets the "account_id" field.
+func (m *LeaderboardScoreMutation) SetAccountID(s string) {
+	m.account_id = &s
+}
+
+// AccountID returns the value of the "account_id" field in the mutation.
+func (m *LeaderboardScoreMutation) AccountID() (r string, exists bool) {
+	v := m.account_id
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldAccountID returns the old "account_id" field's value of the LeaderboardScore entity.
+// If the LeaderboardScore object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *LeaderboardScoreMutation) OldAccountID(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldAccountID is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldAccountID requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldAccountID: %w", err)
+	}
+	return oldValue.AccountID, nil
+}
+
+// ResetAccountID resets all changes to the "account_id" field.
+func (m *LeaderboardScoreMutation) ResetAccountID() {
+	m.account_id = nil
+}
+
 // SetReferenceID sets the "reference_id" field.
 func (m *LeaderboardScoreMutation) SetReferenceID(s string) {
 	m.reference_id = &s
@@ -7378,12 +7415,12 @@ func (m *LeaderboardScoreMutation) ResetReferenceID() {
 }
 
 // SetLeaderboardID sets the "leaderboard_id" field.
-func (m *LeaderboardScoreMutation) SetLeaderboardID(mi models.LeaderboardID) {
-	m.leaderboard_id = &mi
+func (m *LeaderboardScoreMutation) SetLeaderboardID(s string) {
+	m.leaderboard_id = &s
 }
 
 // LeaderboardID returns the value of the "leaderboard_id" field in the mutation.
-func (m *LeaderboardScoreMutation) LeaderboardID() (r models.LeaderboardID, exists bool) {
+func (m *LeaderboardScoreMutation) LeaderboardID() (r string, exists bool) {
 	v := m.leaderboard_id
 	if v == nil {
 		return
@@ -7394,7 +7431,7 @@ func (m *LeaderboardScoreMutation) LeaderboardID() (r models.LeaderboardID, exis
 // OldLeaderboardID returns the old "leaderboard_id" field's value of the LeaderboardScore entity.
 // If the LeaderboardScore object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *LeaderboardScoreMutation) OldLeaderboardID(ctx context.Context) (v models.LeaderboardID, err error) {
+func (m *LeaderboardScoreMutation) OldLeaderboardID(ctx context.Context) (v string, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldLeaderboardID is only allowed on UpdateOne operations")
 	}
@@ -7483,7 +7520,7 @@ func (m *LeaderboardScoreMutation) Type() string {
 // order to get all numeric fields that were incremented/decremented, call
 // AddedFields().
 func (m *LeaderboardScoreMutation) Fields() []string {
-	fields := make([]string, 0, 7)
+	fields := make([]string, 0, 8)
 	if m.created_at != nil {
 		fields = append(fields, leaderboardscore.FieldCreatedAt)
 	}
@@ -7496,6 +7533,9 @@ func (m *LeaderboardScoreMutation) Fields() []string {
 	if m.score != nil {
 		fields = append(fields, leaderboardscore.FieldScore)
 	}
+	if m.account_id != nil {
+		fields = append(fields, leaderboardscore.FieldAccountID)
+	}
 	if m.reference_id != nil {
 		fields = append(fields, leaderboardscore.FieldReferenceID)
 	}
@@ -7521,6 +7561,8 @@ func (m *LeaderboardScoreMutation) Field(name string) (ent.Value, bool) {
 		return m.GetType()
 	case leaderboardscore.FieldScore:
 		return m.Score()
+	case leaderboardscore.FieldAccountID:
+		return m.AccountID()
 	case leaderboardscore.FieldReferenceID:
 		return m.ReferenceID()
 	case leaderboardscore.FieldLeaderboardID:
@@ -7544,6 +7586,8 @@ func (m *LeaderboardScoreMutation) OldField(ctx context.Context, name string) (e
 		return m.OldType(ctx)
 	case leaderboardscore.FieldScore:
 		return m.OldScore(ctx)
+	case leaderboardscore.FieldAccountID:
+		return m.OldAccountID(ctx)
 	case leaderboardscore.FieldReferenceID:
 		return m.OldReferenceID(ctx)
 	case leaderboardscore.FieldLeaderboardID:
@@ -7587,6 +7631,13 @@ func (m *LeaderboardScoreMutation) SetField(name string, value ent.Value) error
 		}
 		m.SetScore(v)
 		return nil
+	case leaderboardscore.FieldAccountID:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetAccountID(v)
+		return nil
 	case leaderboardscore.FieldReferenceID:
 		v, ok := value.(string)
 		if !ok {
@@ -7595,7 +7646,7 @@ func (m *LeaderboardScoreMutation) SetField(name string, value ent.Value) error
 		m.SetReferenceID(v)
 		return nil
 	case leaderboardscore.FieldLeaderboardID:
-		v, ok := value.(models.LeaderboardID)
+		v, ok := value.(string)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
@@ -7684,6 +7735,9 @@ func (m *LeaderboardScoreMutation) ResetField(name string) error {
 	case leaderboardscore.FieldScore:
 		m.ResetScore()
 		return nil
+	case leaderboardscore.FieldAccountID:
+		m.ResetAccountID()
+		return nil
 	case leaderboardscore.FieldReferenceID:
 		m.ResetReferenceID()
 		return nil
diff --git a/internal/database/ent/migrations/20240709150702.sql b/internal/database/ent/migrations/20240709150702.sql
new file mode 100644
index 00000000..cf19507e
--- /dev/null
+++ b/internal/database/ent/migrations/20240709150702.sql
@@ -0,0 +1,20 @@
+-- Disable the enforcement of foreign-keys constraints
+PRAGMA foreign_keys = off;
+-- Drop "leaderboard_scores" table
+DROP TABLE `leaderboard_scores`;
+-- Create "leaderboard_scores" table
+CREATE TABLE `leaderboard_scores` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `score` real NOT NULL, `account_id` text NOT NULL, `reference_id` text NOT NULL, `leaderboard_id` text NOT NULL, `meta` json NOT NULL, PRIMARY KEY (`id`));
+-- Create index "leaderboardscore_id" to table: "leaderboard_scores"
+CREATE INDEX `leaderboardscore_id` ON `leaderboard_scores` (`id`);
+-- Create index "leaderboardscore_created_at" to table: "leaderboard_scores"
+CREATE INDEX `leaderboardscore_created_at` ON `leaderboard_scores` (`created_at`);
+-- Create index "leaderboardscore_account_id" to table: "leaderboard_scores"
+CREATE INDEX `leaderboardscore_account_id` ON `leaderboard_scores` (`account_id`);
+-- Create index "leaderboardscore_reference_id" to table: "leaderboard_scores"
+CREATE INDEX `leaderboardscore_reference_id` ON `leaderboard_scores` (`reference_id`);
+-- Create index "leaderboardscore_leaderboard_id_type_account_id" to table: "leaderboard_scores"
+CREATE INDEX `leaderboardscore_leaderboard_id_type_account_id` ON `leaderboard_scores` (`leaderboard_id`, `type`, `account_id`);
+-- Create index "leaderboardscore_leaderboard_id_type_reference_id" to table: "leaderboard_scores"
+CREATE INDEX `leaderboardscore_leaderboard_id_type_reference_id` ON `leaderboard_scores` (`leaderboard_id`, `type`, `reference_id`);
+-- Enable back the enforcement of foreign-keys constraints
+PRAGMA foreign_keys = on;
diff --git a/internal/database/ent/migrations/atlas.sum b/internal/database/ent/migrations/atlas.sum
index 32cd7d8d..a9fa283b 100644
--- a/internal/database/ent/migrations/atlas.sum
+++ b/internal/database/ent/migrations/atlas.sum
@@ -1,4 +1,4 @@
-h1:RbUSxWnhyo1kiQgt6Y9HLURMb2YJ/BYgcdibq+u4MIU=
+h1:a5eKPzX+EWfQzKTtr6gpM01SU01OjMY4p85/nU9ZcSA=
 20240627171532.sql h1:480JhjRCpyyix192z/L92yEI7LSsgJhuiK0ljat55TI=
 20240627200953.sql h1:VUQZd1HQrxITMUtNO9HRtnDE8wgtWgRyzduACb3D3u4=
 20240703151859.sql h1:1QQD7uLkRsLESNATRcGMg7k1C+sxYFQh/wI7BXrsKUA=
@@ -6,3 +6,4 @@ h1:RbUSxWnhyo1kiQgt6Y9HLURMb2YJ/BYgcdibq+u4MIU=
 20240703160711.sql h1:26t/4QYITq6eAo2hif8sCLRpuHsCHXt6nyvDnX+Y1oQ=
 20240703180358.sql h1:gxgh1nrquDAOFGT7yGzgqpy5EfQ4Dvgd6c2NMPM3iIs=
 20240708154415.sql h1:csEqKf/8D88IvC1u0lgdHZDavyrlPUS8PMI8+74jIw8=
+20240709150702.sql h1:Cez0W0NMpvejc4AAtO/7U7yEdKhSkYNPkKN3R8ZOkL4=
diff --git a/internal/database/ent/schema/leaderboard_score.go b/internal/database/ent/schema/leaderboard_score.go
index 58fa326d..cbf90223 100644
--- a/internal/database/ent/schema/leaderboard_score.go
+++ b/internal/database/ent/schema/leaderboard_score.go
@@ -17,9 +17,9 @@ func (LeaderboardScore) Fields() []ent.Field {
 		field.Enum("type").
 			GoType(models.ScoreType("")),
 		field.Float32("score"),
+		field.String("account_id"),
 		field.String("reference_id"),
-		field.Enum("leaderboard_id").
-			GoType(models.LeaderboardID("")),
+		field.String("leaderboard_id"),
 		field.JSON("meta", map[string]any{}),
 	)
 }
@@ -32,11 +32,9 @@ func (LeaderboardScore) Indexes() []ent.Index {
 	return []ent.Index{
 		index.Fields("id"),
 		index.Fields("created_at"),
-		index.Fields("created_at", "type"),
-		index.Fields("score", "type"),
-		index.Fields("leaderboard_id", "type"),
-		index.Fields("leaderboard_id", "score", "type"),
-		index.Fields("leaderboard_id", "reference_id", "type"),
-		index.Fields("leaderboard_id", "reference_id", "score", "type"),
+		index.Fields("account_id"),
+		index.Fields("reference_id"),
+		index.Fields("leaderboard_id", "type", "account_id"),
+		index.Fields("leaderboard_id", "type", "reference_id"),
 	}
 }
diff --git a/internal/database/leaderboards.go b/internal/database/leaderboards.go
index 88c885a5..96067017 100644
--- a/internal/database/leaderboards.go
+++ b/internal/database/leaderboards.go
@@ -13,9 +13,10 @@ import (
 func toScore(r *db.LeaderboardScore) models.LeaderboardScore {
 	return models.LeaderboardScore{
 		ID:            r.ID,
+		Type:          r.Type,
 		CreatedAt:     r.CreatedAt,
 		UpdatedAt:     r.UpdatedAt,
-		Type:          r.Type,
+		AccountID:     r.AccountID,
 		ReferenceID:   r.ReferenceID,
 		LeaderboardID: r.LeaderboardID,
 		Score:         r.Score,
@@ -53,7 +54,7 @@ func (c *client) CreateLeaderboardScores(ctx context.Context, scores ...models.L
 	return nil, nil
 }
 
-func (c *client) GetLeaderboardScores(ctx context.Context, leaderboard models.LeaderboardID, scoreType models.ScoreType, opts ...Query) ([]models.LeaderboardScore, error) {
+func (c *client) GetLeaderboardScores(ctx context.Context, leaderboardID string, scoreType models.ScoreType, opts ...Query) ([]models.LeaderboardScore, error) {
 	var query baseQueryOptions
 	for _, apply := range opts {
 		apply(&query)
@@ -61,7 +62,7 @@ func (c *client) GetLeaderboardScores(ctx context.Context, leaderboard models.Le
 
 	var where []*sql.Predicate
 	where = append(where, sql.EQ(leaderboardscore.FieldType, scoreType))
-	where = append(where, sql.EQ(leaderboardscore.FieldLeaderboardID, leaderboard))
+	where = append(where, sql.EQ(leaderboardscore.FieldLeaderboardID, leaderboardID))
 
 	orderBy := sql.Desc(leaderboardscore.FieldCreatedAt)
 	if query.createdAfter != nil {
@@ -80,8 +81,8 @@ func (c *client) GetLeaderboardScores(ctx context.Context, leaderboard models.Le
 		where = append(where, sql.NotIn(leaderboardscore.FieldReferenceID, nin...))
 	}
 
-	selectFields := []string{"*"}
-	if fields := query.selectFields(leaderboardscore.FieldReferenceID); fields != nil {
+	selectFields := leaderboardscore.Columns
+	if fields := query.selectFields(leaderboardscore.FieldAccountID); fields != nil {
 		selectFields = fields
 	}
 
@@ -90,13 +91,13 @@ func (c *client) GetLeaderboardScores(ctx context.Context, leaderboard models.Le
 	q = q.OrderBy(orderBy)
 
 	innerQueryString, queryArgs := q.Query()
-	queryString, _ := sql.Select(selectFields...).FromExpr(wrap(innerQueryString)).GroupBy(leaderboardscore.FieldReferenceID).Query()
+	queryString, _ := sql.Select(selectFields...).FromExpr(wrap(innerQueryString)).GroupBy(leaderboardscore.FieldAccountID).Query()
 	rows, err := c.db.LeaderboardScore.QueryContext(ctx, queryString, queryArgs...)
 	if err != nil {
 		return nil, err
 	}
 
-	records, err := rowsToRecords[*db.LeaderboardScore](rows, leaderboardscore.Columns)
+	records, err := rowsToRecords[*db.LeaderboardScore](rows, selectFields)
 	if err != nil {
 		return nil, err
 	}
@@ -108,7 +109,7 @@ func (c *client) GetLeaderboardScores(ctx context.Context, leaderboard models.Le
 	return scores, nil
 }
 
-func (c *client) DeleteExpiredLeaderboardScores(ctx context.Context, expiration time.Time) error {
-	_, err := c.db.LeaderboardScore.Delete().Where(leaderboardscore.CreatedAtLT(expiration)).Exec(ctx)
+func (c *client) DeleteExpiredLeaderboardScores(ctx context.Context, expiration time.Time, scoreType models.ScoreType) error {
+	_, err := c.db.LeaderboardScore.Delete().Where(leaderboardscore.CreatedAtLT(expiration), leaderboardscore.TypeEQ(scoreType)).Exec(ctx)
 	return err
 }
diff --git a/internal/database/models/leaderboard_score.go b/internal/database/models/leaderboard_score.go
index f99a0e67..2489ad72 100644
--- a/internal/database/models/leaderboard_score.go
+++ b/internal/database/models/leaderboard_score.go
@@ -4,27 +4,12 @@ import (
 	"time"
 )
 
-type LeaderboardID string
-
-// Values provides list valid values for Enum.
-func (LeaderboardID) Values() []string {
-	var kinds []string
-	for _, s := range []LeaderboardID{
-		LeaderboardsMasteryWeightedPlayers,
-		LeaderboardsMasteryWeightedClans,
-	} {
-		kinds = append(kinds, string(s))
-	}
-	return kinds
-}
-
 type ScoreType string
 
 // Values provides list valid values for Enum.
 func (ScoreType) Values() []string {
 	var kinds []string
 	for _, s := range []ScoreType{
-		LeaderboardScoreCustom,
 		LeaderboardScoreHourly,
 		LeaderboardScoreDaily,
 	} {
@@ -34,10 +19,9 @@ func (ScoreType) Values() []string {
 }
 
 const (
-	LeaderboardsMasteryWeightedPlayers LeaderboardID = "mastery-weighted-players"
-	LeaderboardsMasteryWeightedClans   LeaderboardID = "mastery-weighted-clans"
+	LeaderboardsMasteryWeightedPlayers string = "mastery-weighted-players"
+	LeaderboardsMasteryWeightedClans   string = "mastery-weighted-clans"
 
-	LeaderboardScoreCustom ScoreType = "custom"
 	LeaderboardScoreHourly ScoreType = "hourly"
 	LeaderboardScoreDaily  ScoreType = "daily"
 )
@@ -48,8 +32,9 @@ type LeaderboardScore struct {
 	UpdatedAt time.Time
 
 	Type          ScoreType
+	AccountID     string
 	ReferenceID   string
-	LeaderboardID LeaderboardID
+	LeaderboardID string
 
 	Score float32
 	Meta  map[string]any
diff --git a/internal/logic/leaderboards.go b/internal/logic/leaderboards.go
index 900c4b8f..c1f1fc1b 100644
--- a/internal/logic/leaderboards.go
+++ b/internal/logic/leaderboards.go
@@ -2,67 +2,162 @@ package logic
 
 import (
 	"context"
+	"fmt"
+	"sync"
 	"time"
 
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/external/wargaming"
+	"github.com/cufee/aftermath/internal/retry"
 	"github.com/cufee/am-wg-proxy-next/v2/types"
 	"github.com/pkg/errors"
+	"github.com/rs/zerolog/log"
 )
 
-func UpdateAccountAchievementsLeaderboardScores(ctx context.Context, wgClient wargaming.Client, dbClient database.Client, realm string, force bool, accountIDs ...string) (map[string]error, error) {
+func RecordCurrentAchievementsLeaderboards(ctx context.Context, wgClient wargaming.Client, dbClient database.Client, scoreType models.ScoreType, realm string, force bool, accountIDs ...string) (map[string]error, error) {
 	if len(accountIDs) < 1 {
 		return nil, nil
 	}
-	createdAt := time.Now()
 
 	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()
 
-	accounts, err := wgClient.BatchAccountByID(ctx, realm, accountIDs, "account_id", "last_battle_time")
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to fetch accounts")
+	var wg sync.WaitGroup
+	var playerLeaderboard retry.DataWithErr[map[string]models.LeaderboardScore]
+	wg.Add(1) // get last leaderboard entry for each account
+	go func() {
+		defer wg.Done()
+		leaderboard, err := dbClient.GetLeaderboardScores(ctx, models.LeaderboardsMasteryWeightedPlayers, scoreType, database.WithReferenceIDIn(accountIDs...))
+		if err != nil && !database.IsNotFound(err) {
+			playerLeaderboard = retry.DataWithErr[map[string]models.LeaderboardScore]{Err: err}
+			return
+		}
+		leaderboardMap := make(map[string]models.LeaderboardScore)
+		for _, score := range leaderboard {
+			leaderboardMap[score.AccountID] = score
+		}
+		playerLeaderboard = retry.DataWithErr[map[string]models.LeaderboardScore]{Data: leaderboardMap}
+	}()
+
+	var accounts retry.DataWithErr[map[string]types.ExtendedAccount]
+	wg.Add(1) // get account last battle time for all accounts
+	go func() {
+		defer wg.Done()
+		data, err := wgClient.BatchAccountByID(ctx, realm, accountIDs, "account_id", "last_battle_time")
+		accounts = retry.DataWithErr[map[string]types.ExtendedAccount]{Data: data, Err: err}
+	}()
+
+	wg.Wait()
+	if playerLeaderboard.Err != nil {
+		return nil, errors.Wrap(playerLeaderboard.Err, "failed to get player leaderboard scores")
+	}
+	if accounts.Err != nil {
+		return nil, errors.Wrap(accounts.Err, "failed to get accounts from wargaming")
 	}
 
-	accountsNeedAnUpdate, err := filterActiveAccounts(ctx, dbClient, realm, accounts, false)
-	if err != nil {
-		return nil, err
+	var accountsToUpdate []string
+	for _, id := range accountIDs {
+		account, ok := accounts.Data[id]
+		if !ok {
+			continue // wargaming returned no data for account
+		}
+		score, sok := playerLeaderboard.Data[id]
+		lastBattle, lok := score.Meta["lastBattleTime"].(time.Time)
+		if !sok || !lok || lastBattle.Unix() < int64(account.LastBattleTime) { // player has no previous score on the leaderboard, the metadata is missing, or they played
+			accountsToUpdate = append(accountsToUpdate, id)
+		}
 	}
-	if len(accountsNeedAnUpdate) < 1 {
+	if len(accountsToUpdate) < 1 {
 		return nil, nil
 	}
 
-	// get current account achievements
-	achievements, err := wgClient.BatchAccountAchievements(ctx, realm, accountsNeedAnUpdate)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to get account achievements")
+	var accountClans retry.DataWithErr[map[string]types.ClanMember]
+	wg.Add(1) // get account clans for all accounts
+	go func() {
+		defer wg.Done()
+		data, err := wgClient.BatchAccountClan(ctx, realm, accountIDs, "account_id", "clan.clan_id")
+		accountClans = retry.DataWithErr[map[string]types.ClanMember]{Data: data, Err: err}
+	}()
+
+	var currentAchievements retry.DataWithErr[map[string]types.AchievementsFrame]
+	wg.Add(1) // get current achievements for all players
+	go func() {
+		defer wg.Done()
+		data, err := wgClient.BatchAccountAchievements(ctx, realm, accountsToUpdate)
+		currentAchievements = retry.DataWithErr[map[string]types.AchievementsFrame]{Data: data, Err: err}
+	}()
+
+	wg.Wait()
+	if currentAchievements.Err != nil {
+		return nil, currentAchievements.Err
 	}
+	if accountClans.Err != nil { // this error is not critical, but it will delay the leaderboard update for clans
+		log.Err(accountClans.Err).Msg("failed to get account clans")
+	}
+
+	var accountErrors = make(map[string]error)
+	var leaderboardScores []models.LeaderboardScore
+	var clanScores = make(map[string]models.LeaderboardScore)
+	for _, id := range accountsToUpdate {
+		account, ok := accounts.Data[id]
+		if !ok {
+			continue // this should never happen due to the check above, but just in case
+		}
+		achievements, ok := currentAchievements.Data[id]
+		if !ok {
+			accountErrors[id] = errors.New("failed to get account achievements")
+			continue
+		}
 
-	var scores []models.LeaderboardScore
-	// calculate the current score for each player
-	for id, achievements := range achievements {
-		scores = append(scores, models.LeaderboardScore{
+		playerScore := models.LeaderboardScore{
+			Type:          scoreType,
+			AccountID:     id,
 			ReferenceID:   id,
-			CreatedAt:     createdAt,
-			UpdatedAt:     createdAt,
-			Type:          models.LeaderboardScoreHourly,
-			Score:         masteryAchievementsScore(achievements),
 			LeaderboardID: models.LeaderboardsMasteryWeightedPlayers,
+			Score:         masteryAchievementsScore(achievements),
 			Meta: map[string]any{
-				"achievements": achievements,
+				"lastBattleTime": account.LastBattleTime,
+				"frame":          achievements,
 			},
-		})
+		}
+		leaderboardScores = append(leaderboardScores, playerScore)
+
+		clan, ok := accountClans.Data[id]
+		if !ok || clan.ClanID == 0 { // account has no clan, or the request failed
+			continue
+		}
+
+		clanID := fmt.Sprint(clan.ClanID)
+		clanScore := clanScores[clanID]
+		clanScore.Type = scoreType
+		clanScore.ReferenceID = clanID
+		clanScore.LeaderboardID = models.LeaderboardsMasteryWeightedClans
+
+		clanScore.Score += playerScore.Score
+		clanFrame, _ := clanScore.Meta["frame"].(types.AchievementsFrame)
+		clanFrame.Add(&achievements)
+		clanScore.Meta["frame"] = clanFrame
+
+		clanScores[clanID] = clanScore
+	}
+
+	for _, score := range clanScores {
+		leaderboardScores = append(leaderboardScores, score)
 	}
 
-	sErrors, err := dbClient.CreateLeaderboardScores(ctx, scores...)
+	insertErrors, err := dbClient.CreateLeaderboardScores(ctx, leaderboardScores...)
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrap(err, "failed to save leaderboard scores")
 	}
-	if len(sErrors) > 0 {
-		return sErrors, nil
+	for id, err := range insertErrors {
+		if _, ok := clanScores[id]; !ok {
+			accountErrors[id] = err // if this is not a clan-related error
+		}
+	}
+	if len(accountErrors) > 0 {
+		return accountErrors, nil
 	}
-
 	return nil, nil
 }
 
diff --git a/internal/logic/snapshots.go b/internal/logic/snapshots.go
index fd822fd6..09e600e2 100644
--- a/internal/logic/snapshots.go
+++ b/internal/logic/snapshots.go
@@ -25,7 +25,7 @@ type vehicleBattleData struct {
 Filter passed in accounts and return active account ids
   - an account is considered active if it has played a battle since the last snapshot, or has no snapshots
 */
-func filterActiveAccounts(ctx context.Context, dbClient database.Client, realm string, accounts map[string]types.ExtendedAccount, force bool) ([]string, error) {
+func filterActiveAccounts(ctx context.Context, dbClient database.Client, accounts map[string]types.ExtendedAccount, force bool) ([]string, error) {
 	var ids []string
 	for id := range accounts {
 		ids = append(ids, id)
@@ -66,7 +66,7 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 		return nil, errors.Wrap(err, "failed to fetch accounts")
 	}
 
-	accountsNeedAnUpdate, err := filterActiveAccounts(ctx, dbClient, realm, accounts, false)
+	accountsNeedAnUpdate, err := filterActiveAccounts(ctx, dbClient, accounts, false)
 	if err != nil {
 		return nil, err
 	}
@@ -119,18 +119,19 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 		clans = data
 	}()
 
-	group.Add(1)
-	// get account achievements, not critical
-	go func() {
-		defer group.Done()
-		// clans are optional-ish
-		data, err := wgClient.BatchAccountAchievements(ctx, realm, accountsNeedAnUpdate)
-		if err != nil {
-			log.Err(err).Msg("failed to get batch account achievements")
-		}
-		accountAchievements.Data = data
-		accountAchievements.Err = err
-	}()
+	// disabled for now as this data is unused
+	// group.Add(1)
+	// // get account achievements, not critical
+	// go func() {
+	// 	defer group.Done()
+	// 	// clans are optional-ish
+	// 	data, err := wgClient.BatchAccountAchievements(ctx, realm, accountsNeedAnUpdate)
+	// 	if err != nil {
+	// 		log.Err(err).Msg("failed to get batch account achievements")
+	// 	}
+	// 	accountAchievements.Data = data
+	// 	accountAchievements.Err = err
+	// }()
 
 	group.Wait()
 
diff --git a/tests/static_database.go b/tests/static_database.go
index 5c392811..666a291d 100644
--- a/tests/static_database.go
+++ b/tests/static_database.go
@@ -201,9 +201,9 @@ func (c *staticTestingDatabase) UserFromSession(ctx context.Context, publicID st
 func (c *staticTestingDatabase) CreateLeaderboardScores(ctx context.Context, scores ...models.LeaderboardScore) (map[string]error, error) {
 	return nil, errors.New("CreateLeaderboardScores not implemented")
 }
-func (c *staticTestingDatabase) GetLeaderboardScores(ctx context.Context, leaderboard models.LeaderboardID, scoreType models.ScoreType, options ...database.Query) ([]models.LeaderboardScore, error) {
+func (c *staticTestingDatabase) GetLeaderboardScores(ctx context.Context, leaderboard string, scoreType models.ScoreType, options ...database.Query) ([]models.LeaderboardScore, error) {
 	return nil, errors.New("GetLeaderboardScores not implemented")
 }
-func (c *staticTestingDatabase) DeleteExpiredLeaderboardScores(ctx context.Context, expiration time.Time) error {
+func (c *staticTestingDatabase) DeleteExpiredLeaderboardScores(ctx context.Context, expiration time.Time, kind models.ScoreType) error {
 	return errors.New("DeleteExpiredLeaderboardScores not implemented")
 }

From 95cb1f6a6a9122e7e4578579cfdf21623b20213e Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Tue, 9 Jul 2024 15:30:46 -0400
Subject: [PATCH 323/341] using custom logger

---
 cmd/assets/news.go                            |  2 +-
 cmd/core/queue/queue.go                       |  2 +-
 cmd/core/scheduler/workers.go                 |  2 +-
 cmd/core/server/handlers/private/accounts.go  |  2 +-
 cmd/core/tasks/cleanup.go                     |  2 +-
 cmd/core/tasks/leaderboards.go                |  2 +-
 cmd/core/tasks/snapshots.go                   |  2 +-
 cmd/discord/alerts/client.go                  | 57 +++++++++++++++++++
 cmd/discord/commands/interactions.go          |  2 +-
 cmd/discord/commands/session.go               |  2 +-
 cmd/discord/commands/stats.go                 |  2 +-
 cmd/discord/common/context.go                 |  2 +-
 cmd/discord/common/locale.go                  |  2 +-
 cmd/discord/common/reply.go                   |  2 +-
 cmd/discord/rest/client.go                    | 13 ++++-
 cmd/discord/rest/interactions.go              | 21 ++-----
 cmd/discord/rest/webhooks.go                  | 15 +++++
 cmd/discord/router/handler.go                 |  2 +-
 cmd/discord/router/router.go                  |  2 +-
 cmd/frontend/assets/generate/generate.go      |  2 +-
 cmd/frontend/handler/context.go               |  2 +-
 cmd/frontend/logic/discord/oauth.go           |  2 +-
 cmd/frontend/logic/discord/user.go            |  2 +-
 cmd/frontend/middleware/auth.go               |  2 +-
 cmd/frontend/routes/api/auth/discord.go       |  2 +-
 cmd/frontend/routes/api/auth/wargaming.go     |  2 +-
 cmd/frontend/routes/api/login.go              |  2 +-
 dev_web.go                                    |  2 +-
 go.mod                                        |  2 +
 go.sum                                        |  3 +
 internal/constants/alerts.go                  |  8 +++
 internal/database/client.go                   |  2 +-
 internal/files/load.go                        |  2 +-
 internal/log/logger.go                        | 53 +++++++++++++++++
 internal/logic/leaderboards.go                |  2 +-
 internal/logic/snapshots.go                   |  2 +-
 internal/stats/client/v1/session.go           |  2 +-
 internal/stats/fetch/v1/multisource.go        |  2 +-
 internal/stats/fetch/v1/replay/unpack.go      |  2 +-
 internal/stats/render/assets/load.go          |  2 +-
 internal/stats/render/common/v1/block.go      |  2 +-
 .../stats/render/common/v1/player_title.go    |  2 +-
 internal/stats/render/period/v1/cards.go      |  2 +-
 main.go                                       | 18 +++++-
 44 files changed, 205 insertions(+), 55 deletions(-)
 create mode 100644 cmd/discord/alerts/client.go
 create mode 100644 cmd/discord/rest/webhooks.go
 create mode 100644 internal/constants/alerts.go
 create mode 100644 internal/log/logger.go

diff --git a/cmd/assets/news.go b/cmd/assets/news.go
index 2801174e..1a2cf69b 100644
--- a/cmd/assets/news.go
+++ b/cmd/assets/news.go
@@ -11,9 +11,9 @@ import (
 	"sync"
 	"time"
 
+	"github.com/cufee/aftermath/internal/log"
 	"github.com/disintegration/imaging"
 	"github.com/pkg/errors"
-	"github.com/rs/zerolog/log"
 
 	_ "github.com/joho/godotenv/autoload"
 )
diff --git a/cmd/core/queue/queue.go b/cmd/core/queue/queue.go
index b8d311de..ac1a6388 100644
--- a/cmd/core/queue/queue.go
+++ b/cmd/core/queue/queue.go
@@ -13,7 +13,7 @@ import (
 	"github.com/cufee/aftermath/cmd/core/tasks"
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
-	"github.com/rs/zerolog/log"
+	"github.com/cufee/aftermath/internal/log"
 )
 
 type queue struct {
diff --git a/cmd/core/scheduler/workers.go b/cmd/core/scheduler/workers.go
index 3c877308..571f00ec 100644
--- a/cmd/core/scheduler/workers.go
+++ b/cmd/core/scheduler/workers.go
@@ -10,7 +10,7 @@ import (
 
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
-	"github.com/rs/zerolog/log"
+	"github.com/cufee/aftermath/internal/log"
 )
 
 func CreateCleanupTaskWorker(client core.Client) func() {
diff --git a/cmd/core/server/handlers/private/accounts.go b/cmd/core/server/handlers/private/accounts.go
index 2281ae22..3eb78c68 100644
--- a/cmd/core/server/handlers/private/accounts.go
+++ b/cmd/core/server/handlers/private/accounts.go
@@ -10,9 +10,9 @@ import (
 
 	"github.com/cufee/aftermath/cmd/core"
 	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/log"
 	"github.com/cufee/aftermath/internal/stats/fetch/v1"
 	"github.com/cufee/am-wg-proxy-next/v2/types"
-	"github.com/rs/zerolog/log"
 	"golang.org/x/sync/semaphore"
 )
 
diff --git a/cmd/core/tasks/cleanup.go b/cmd/core/tasks/cleanup.go
index 9adea17e..741d4c81 100644
--- a/cmd/core/tasks/cleanup.go
+++ b/cmd/core/tasks/cleanup.go
@@ -79,7 +79,7 @@ func CreateCleanupTasks(client core.Client) error {
 		ReferenceID:    "database_cleanup",
 		Type:           models.TaskTypeDatabaseCleanup,
 		Data: map[string]string{
-			"expiration_leaderboards_hourly": now.Add(-1 * time.Hour * 24).Format(time.RFC3339),      // 1 day
+			"expiration_leaderboards_hourly": now.Add(-1 * time.Hour * 3).Format(time.RFC3339),       // 3 hours
 			"expiration_leaderboards_daily":  now.Add(-1 * time.Hour * 24 * 90).Format(time.RFC3339), // 90 days
 			"expiration_snapshots":           now.Add(-1 * time.Hour * 24 * 90).Format(time.RFC3339), // 90 days
 			"expiration_interactions":        now.Add(-1 * time.Hour * 24 * 7).Format(time.RFC3339),  // 7 days
diff --git a/cmd/core/tasks/leaderboards.go b/cmd/core/tasks/leaderboards.go
index 048e83cf..3a5cd7da 100644
--- a/cmd/core/tasks/leaderboards.go
+++ b/cmd/core/tasks/leaderboards.go
@@ -8,9 +8,9 @@ import (
 
 	"github.com/cufee/aftermath/cmd/core"
 	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/log"
 	"github.com/cufee/aftermath/internal/logic"
 	"github.com/pkg/errors"
-	"github.com/rs/zerolog/log"
 )
 
 func init() {
diff --git a/cmd/core/tasks/snapshots.go b/cmd/core/tasks/snapshots.go
index e6deda26..bf842512 100644
--- a/cmd/core/tasks/snapshots.go
+++ b/cmd/core/tasks/snapshots.go
@@ -9,8 +9,8 @@ import (
 
 	"github.com/cufee/aftermath/cmd/core"
 	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/log"
 	"github.com/cufee/aftermath/internal/logic"
-	"github.com/rs/zerolog/log"
 )
 
 func init() {
diff --git a/cmd/discord/alerts/client.go b/cmd/discord/alerts/client.go
new file mode 100644
index 00000000..62733607
--- /dev/null
+++ b/cmd/discord/alerts/client.go
@@ -0,0 +1,57 @@
+package alerts
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/bwmarrin/discordgo"
+	"github.com/cufee/aftermath/cmd/discord/rest"
+	"github.com/cufee/aftermath/internal/constants"
+	"github.com/pkg/errors"
+	"github.com/rs/zerolog"
+)
+
+type DiscordAlertClient interface {
+	Error(ctx context.Context, header, codeBlock string) error
+}
+
+type alertClient struct {
+	rest       *rest.Client
+	webhookURL string
+}
+
+func NewClient(webhookURL string) (*alertClient, error) {
+	client, err := rest.NewClient("")
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to create a rest client")
+	}
+	return &alertClient{rest: client, webhookURL: webhookURL}, nil
+}
+
+func (c *alertClient) Error(ctx context.Context, header, codeBlock string) error {
+	content := fmt.Sprintf("### An error was logged through zerolog\n%s\n```%s```", header, codeBlock)
+	return c.rest.PostWebhookMessage(ctx, c.webhookURL, discordgo.WebhookParams{
+		Content:  content,
+		Username: constants.FrontendAppName + " Error Report",
+	}, nil)
+
+}
+
+type zerologHook struct {
+	client DiscordAlertClient
+}
+
+func (h *zerologHook) Run(e *zerolog.Event, level zerolog.Level, msg string) {
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
+	defer cancel()
+
+	switch level {
+	case zerolog.ErrorLevel:
+		h.client.Error(ctx, msg, fmt.Sprintf("%v", e.GetCtx().Err()))
+	}
+}
+
+func NewHook(c DiscordAlertClient) *zerologHook {
+	return &zerologHook{client: c}
+}
diff --git a/cmd/discord/commands/interactions.go b/cmd/discord/commands/interactions.go
index 4c52ebca..5ad609cd 100644
--- a/cmd/discord/commands/interactions.go
+++ b/cmd/discord/commands/interactions.go
@@ -15,8 +15,8 @@ import (
 
 	stats "github.com/cufee/aftermath/internal/stats/client/v1"
 
+	"github.com/cufee/aftermath/internal/log"
 	"github.com/pkg/errors"
-	"github.com/rs/zerolog/log"
 )
 
 func newStatsRefreshButton(data models.DiscordInteraction) discordgo.MessageComponent {
diff --git a/cmd/discord/commands/session.go b/cmd/discord/commands/session.go
index 3d04e0b7..c45b55e8 100644
--- a/cmd/discord/commands/session.go
+++ b/cmd/discord/commands/session.go
@@ -10,11 +10,11 @@ import (
 	"github.com/cufee/aftermath/cmd/discord/common"
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/log"
 	"github.com/cufee/aftermath/internal/permissions"
 	stats "github.com/cufee/aftermath/internal/stats/client/v1"
 	"github.com/cufee/aftermath/internal/stats/fetch/v1"
 	"github.com/pkg/errors"
-	"github.com/rs/zerolog/log"
 )
 
 func init() {
diff --git a/cmd/discord/commands/stats.go b/cmd/discord/commands/stats.go
index b1a62021..84fd8e99 100644
--- a/cmd/discord/commands/stats.go
+++ b/cmd/discord/commands/stats.go
@@ -10,9 +10,9 @@ import (
 	"github.com/cufee/aftermath/cmd/discord/common"
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/log"
 	"github.com/cufee/aftermath/internal/permissions"
 	stats "github.com/cufee/aftermath/internal/stats/client/v1"
-	"github.com/rs/zerolog/log"
 )
 
 func init() {
diff --git a/cmd/discord/common/context.go b/cmd/discord/common/context.go
index 93780453..8684f4a6 100644
--- a/cmd/discord/common/context.go
+++ b/cmd/discord/common/context.go
@@ -15,7 +15,7 @@ import (
 	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/localization"
 
-	"github.com/rs/zerolog/log"
+	"github.com/cufee/aftermath/internal/log"
 	"golang.org/x/text/language"
 )
 
diff --git a/cmd/discord/common/locale.go b/cmd/discord/common/locale.go
index 251cdc5e..f805f6ff 100644
--- a/cmd/discord/common/locale.go
+++ b/cmd/discord/common/locale.go
@@ -4,7 +4,7 @@ import (
 	"github.com/bwmarrin/discordgo"
 	"github.com/cufee/aftermath/internal/localization"
 
-	"github.com/rs/zerolog/log"
+	"github.com/cufee/aftermath/internal/log"
 	"golang.org/x/text/language"
 )
 
diff --git a/cmd/discord/common/reply.go b/cmd/discord/common/reply.go
index d107ceff..290635ef 100644
--- a/cmd/discord/common/reply.go
+++ b/cmd/discord/common/reply.go
@@ -8,7 +8,7 @@ import (
 
 	"github.com/bwmarrin/discordgo"
 	"github.com/cufee/aftermath/cmd/discord/rest"
-	"github.com/rs/zerolog/log"
+	"github.com/cufee/aftermath/internal/log"
 )
 
 type reply struct {
diff --git a/cmd/discord/rest/client.go b/cmd/discord/rest/client.go
index fdf2d6ad..34bdc62d 100644
--- a/cmd/discord/rest/client.go
+++ b/cmd/discord/rest/client.go
@@ -60,7 +60,18 @@ func (c *Client) request(method string, url string, payload any) (*http.Request,
 	return req, nil
 }
 
-func (c *Client) requestWithFiles(method string, url string, payload any, files []*discordgo.File) (*http.Request, error) {
+func (c *Client) requestWithFiles(method string, url string, payload any, files []File) (*http.Request, error) {
+	if len(files) > 0 {
+		var df []*discordgo.File
+		for _, f := range files {
+			df = append(df, &discordgo.File{Name: f.Name, Reader: bytes.NewReader(f.Data)})
+		}
+		return c.requestWithFormData(method, url, payload, df)
+	}
+	return c.request(method, url, payload)
+}
+
+func (c *Client) requestWithFormData(method string, url string, payload any, files []*discordgo.File) (*http.Request, error) {
 	buffer := &bytes.Buffer{}
 	writer := multipart.NewWriter(buffer)
 	writer.FormDataContentType()
diff --git a/cmd/discord/rest/interactions.go b/cmd/discord/rest/interactions.go
index bd280f67..d8ca5b58 100644
--- a/cmd/discord/rest/interactions.go
+++ b/cmd/discord/rest/interactions.go
@@ -1,10 +1,8 @@
 package rest
 
 import (
-	"bytes"
 	"context"
 	"errors"
-	"net/http"
 
 	"github.com/bwmarrin/discordgo"
 )
@@ -29,7 +27,7 @@ func (c *Client) UpdateOrSendInteractionResponse(ctx context.Context, appID, int
 }
 
 func (c *Client) SendInteractionResponse(ctx context.Context, interactionID, token string, data discordgo.InteractionResponse, files []File) error {
-	req, err := c.interactionRequest("POST", discordgo.EndpointInteractionResponse(interactionID, token), data, files)
+	req, err := c.requestWithFiles("POST", discordgo.EndpointInteractionResponse(interactionID, token), data, files)
 	if err != nil {
 		return err
 	}
@@ -37,7 +35,7 @@ func (c *Client) SendInteractionResponse(ctx context.Context, interactionID, tok
 }
 
 func (c *Client) UpdateInteractionResponse(ctx context.Context, appID, token string, data discordgo.InteractionResponseData, files []File) error {
-	req, err := c.interactionRequest("PATCH", discordgo.EndpointInteractionResponseActions(appID, token), data, files)
+	req, err := c.requestWithFiles("PATCH", discordgo.EndpointInteractionResponseActions(appID, token), data, files)
 	if err != nil {
 		return err
 	}
@@ -45,7 +43,7 @@ func (c *Client) UpdateInteractionResponse(ctx context.Context, appID, token str
 }
 
 func (c *Client) SendInteractionFollowup(ctx context.Context, appID, token string, data discordgo.InteractionResponse, files []File) error {
-	req, err := c.interactionRequest("POST", discordgo.EndpointFollowupMessage(appID, token), data, files)
+	req, err := c.requestWithFiles("POST", discordgo.EndpointFollowupMessage(appID, token), data, files)
 	if err != nil {
 		return err
 	}
@@ -53,20 +51,9 @@ func (c *Client) SendInteractionFollowup(ctx context.Context, appID, token strin
 }
 
 func (c *Client) EditInteractionFollowup(ctx context.Context, appID, token string, data discordgo.InteractionResponseData, files []File) error {
-	req, err := c.interactionRequest("PATCH", discordgo.EndpointFollowupMessage(appID, token), data, files)
+	req, err := c.requestWithFiles("PATCH", discordgo.EndpointFollowupMessage(appID, token), data, files)
 	if err != nil {
 		return err
 	}
 	return c.do(ctx, req, nil)
 }
-
-func (c *Client) interactionRequest(method string, url string, payload any, files []File) (*http.Request, error) {
-	if len(files) > 0 {
-		var df []*discordgo.File
-		for _, f := range files {
-			df = append(df, &discordgo.File{Name: f.Name, Reader: bytes.NewReader(f.Data)})
-		}
-		return c.requestWithFiles(method, url, payload, df)
-	}
-	return c.request(method, url, payload)
-}
diff --git a/cmd/discord/rest/webhooks.go b/cmd/discord/rest/webhooks.go
new file mode 100644
index 00000000..b33edefc
--- /dev/null
+++ b/cmd/discord/rest/webhooks.go
@@ -0,0 +1,15 @@
+package rest
+
+import (
+	"context"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+func (c *Client) PostWebhookMessage(ctx context.Context, webhookURL string, data discordgo.WebhookParams, files []File) error {
+	req, err := c.requestWithFiles("POST", webhookURL, data, files)
+	if err != nil {
+		return err
+	}
+	return c.do(ctx, req, nil)
+}
diff --git a/cmd/discord/router/handler.go b/cmd/discord/router/handler.go
index 226dfbfb..4138e66e 100644
--- a/cmd/discord/router/handler.go
+++ b/cmd/discord/router/handler.go
@@ -19,8 +19,8 @@ import (
 	"github.com/cufee/aftermath/cmd/discord/commands/builder"
 	"github.com/cufee/aftermath/cmd/discord/common"
 	"github.com/cufee/aftermath/cmd/discord/rest"
+	"github.com/cufee/aftermath/internal/log"
 	"github.com/cufee/aftermath/internal/retry"
-	"github.com/rs/zerolog/log"
 )
 
 var supportedInteractionTypes = []discordgo.InteractionType{discordgo.InteractionApplicationCommand, discordgo.InteractionMessageComponent, discordgo.InteractionApplicationCommandAutocomplete, discordgo.InteractionModalSubmit}
diff --git a/cmd/discord/router/router.go b/cmd/discord/router/router.go
index 71f8dcfd..1485fb3e 100644
--- a/cmd/discord/router/router.go
+++ b/cmd/discord/router/router.go
@@ -10,8 +10,8 @@ import (
 	"github.com/cufee/aftermath/cmd/discord/middleware"
 	"github.com/cufee/aftermath/cmd/discord/rest"
 	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/log"
 	"github.com/cufee/aftermath/internal/logic"
-	"github.com/rs/zerolog/log"
 )
 
 func NewRouter(coreClient core.Client, token, publicKey string) (*Router, error) {
diff --git a/cmd/frontend/assets/generate/generate.go b/cmd/frontend/assets/generate/generate.go
index 0ef79294..4c912321 100644
--- a/cmd/frontend/assets/generate/generate.go
+++ b/cmd/frontend/assets/generate/generate.go
@@ -10,10 +10,10 @@ import (
 	"path/filepath"
 
 	"github.com/cufee/aftermath/cmd/frontend/assets"
+	"github.com/cufee/aftermath/internal/log"
 	"github.com/cufee/aftermath/internal/stats/render/common/v1"
 	"github.com/disintegration/imaging"
 	"github.com/fogleman/gg"
-	"github.com/rs/zerolog/log"
 
 	ico "github.com/Kodeworks/golang-image-ico"
 	"github.com/joho/godotenv"
diff --git a/cmd/frontend/handler/context.go b/cmd/frontend/handler/context.go
index d4c233ce..23ababb6 100644
--- a/cmd/frontend/handler/context.go
+++ b/cmd/frontend/handler/context.go
@@ -15,8 +15,8 @@ import (
 
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/log"
 	"github.com/cufee/aftermath/internal/logic"
-	"github.com/rs/zerolog/log"
 )
 
 var devMode = os.Getenv("AUTH_DEV_MODE") == "true"
diff --git a/cmd/frontend/logic/discord/oauth.go b/cmd/frontend/logic/discord/oauth.go
index d4aadd73..e0679789 100644
--- a/cmd/frontend/logic/discord/oauth.go
+++ b/cmd/frontend/logic/discord/oauth.go
@@ -10,8 +10,8 @@ import (
 
 	"github.com/bwmarrin/discordgo"
 	"github.com/cufee/aftermath/internal/constants"
+	"github.com/cufee/aftermath/internal/log"
 	"github.com/pkg/errors"
-	"github.com/rs/zerolog/log"
 )
 
 type authToken struct {
diff --git a/cmd/frontend/logic/discord/user.go b/cmd/frontend/logic/discord/user.go
index 4940bebc..8784c55a 100644
--- a/cmd/frontend/logic/discord/user.go
+++ b/cmd/frontend/logic/discord/user.go
@@ -6,8 +6,8 @@ import (
 	"net/http"
 
 	"github.com/bwmarrin/discordgo"
+	"github.com/cufee/aftermath/internal/log"
 	"github.com/pkg/errors"
-	"github.com/rs/zerolog/log"
 )
 
 type userResponse struct {
diff --git a/cmd/frontend/middleware/auth.go b/cmd/frontend/middleware/auth.go
index 723e2c1c..d534d449 100644
--- a/cmd/frontend/middleware/auth.go
+++ b/cmd/frontend/middleware/auth.go
@@ -9,7 +9,7 @@ import (
 	"github.com/cufee/aftermath/cmd/frontend/handler"
 	"github.com/cufee/aftermath/cmd/frontend/logic/auth"
 	"github.com/cufee/aftermath/internal/database/models"
-	"github.com/rs/zerolog/log"
+	"github.com/cufee/aftermath/internal/log"
 )
 
 var SessionCheck handler.Middleware = func(ctx *handler.Context, next func(ctx *handler.Context) error) func(ctx *handler.Context) error {
diff --git a/cmd/frontend/routes/api/auth/discord.go b/cmd/frontend/routes/api/auth/discord.go
index 8fae1c84..7fe07475 100644
--- a/cmd/frontend/routes/api/auth/discord.go
+++ b/cmd/frontend/routes/api/auth/discord.go
@@ -8,8 +8,8 @@ import (
 	"github.com/cufee/aftermath/cmd/frontend/handler"
 	"github.com/cufee/aftermath/cmd/frontend/logic/auth"
 	"github.com/cufee/aftermath/cmd/frontend/logic/discord"
+	"github.com/cufee/aftermath/internal/log"
 	"github.com/cufee/aftermath/internal/logic"
-	"github.com/rs/zerolog/log"
 )
 
 var DiscordRedirect handler.Endpoint = func(ctx *handler.Context) error {
diff --git a/cmd/frontend/routes/api/auth/wargaming.go b/cmd/frontend/routes/api/auth/wargaming.go
index 116cb5b5..3206c8fb 100644
--- a/cmd/frontend/routes/api/auth/wargaming.go
+++ b/cmd/frontend/routes/api/auth/wargaming.go
@@ -11,9 +11,9 @@ import (
 	"github.com/cufee/aftermath/internal/constants"
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/log"
 	"github.com/cufee/aftermath/internal/logic"
 	"github.com/pkg/errors"
-	"github.com/rs/zerolog/log"
 )
 
 var WargamingRedirect handler.Endpoint = func(ctx *handler.Context) error {
diff --git a/cmd/frontend/routes/api/login.go b/cmd/frontend/routes/api/login.go
index 27caed8f..c6e74fa0 100644
--- a/cmd/frontend/routes/api/login.go
+++ b/cmd/frontend/routes/api/login.go
@@ -8,8 +8,8 @@ import (
 	"github.com/cufee/aftermath/cmd/frontend/handler"
 	"github.com/cufee/aftermath/cmd/frontend/logic/auth"
 	"github.com/cufee/aftermath/cmd/frontend/logic/discord"
+	"github.com/cufee/aftermath/internal/log"
 	"github.com/cufee/aftermath/internal/logic"
-	"github.com/rs/zerolog/log"
 )
 
 var Login handler.Endpoint = func(ctx *handler.Context) error {
diff --git a/dev_web.go b/dev_web.go
index 7112ac62..4ea1efaa 100644
--- a/dev_web.go
+++ b/dev_web.go
@@ -12,11 +12,11 @@ import (
 	"github.com/cufee/aftermath/cmd/frontend"
 	"github.com/cufee/aftermath/internal/constants"
 	"github.com/cufee/aftermath/internal/localization"
+	"github.com/cufee/aftermath/internal/log"
 	"github.com/cufee/aftermath/internal/stats/render/assets"
 	render "github.com/cufee/aftermath/internal/stats/render/common/v1"
 	"github.com/cufee/aftermath/tests"
 	"github.com/joho/godotenv"
-	"github.com/rs/zerolog/log"
 )
 
 //go:generate go generate ./cmd/frontend/assets/generate
diff --git a/go.mod b/go.mod
index 02914176..50f9541f 100644
--- a/go.mod
+++ b/go.mod
@@ -41,11 +41,13 @@ require (
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/hashicorp/hcl/v2 v2.21.0 // indirect
+	github.com/justinas/alice v1.2.0 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mitchellh/go-wordwrap v1.0.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/robfig/cron/v3 v3.0.1 // indirect
+	github.com/rs/xid v1.5.0 // indirect
 	github.com/tdewolff/parse/v2 v2.7.15 // indirect
 	github.com/zclconf/go-cty v1.14.4 // indirect
 	go.uber.org/atomic v1.11.0 // indirect
diff --git a/go.sum b/go.sum
index 959271d5..17b3ed44 100644
--- a/go.sum
+++ b/go.sum
@@ -50,6 +50,8 @@ github.com/hashicorp/hcl/v2 v2.21.0 h1:lve4q/o/2rqwYOgUg3y3V2YPyD1/zkCLGjIV74Jit
 github.com/hashicorp/hcl/v2 v2.21.0/go.mod h1:62ZYHrXgPoX8xBnzl8QzbWq4dyDsDtfCRgIq1rbJEvA=
 github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
 github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
+github.com/justinas/alice v1.2.0 h1:+MHSA/vccVCF4Uq37S42jwlkvI2Xzl7zTPCN5BnZNVo=
+github.com/justinas/alice v1.2.0/go.mod h1:fN5HRH/reO/zrUflLfTN43t3vXvKzvZIENsNEe7i7qA=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
 github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
@@ -90,6 +92,7 @@ github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzG
 github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
 github.com/rogpeppe/go-internal v1.8.1 h1:geMPLpDpQOgVyCg5z5GoRwLHepNdb71NXb67XFkP+Eg=
 github.com/rogpeppe/go-internal v1.8.1/go.mod h1:JeRgkft04UBgHMgCIwADu4Pn6Mtm5d4nPKWu0nJ5d+o=
+github.com/rs/xid v1.5.0 h1:mKX4bl4iPYJtEIxp6CYiUuLQ/8DYMoz0PUdtGgMFRVc=
 github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
 github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8=
 github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
diff --git a/internal/constants/alerts.go b/internal/constants/alerts.go
new file mode 100644
index 00000000..533180ab
--- /dev/null
+++ b/internal/constants/alerts.go
@@ -0,0 +1,8 @@
+package constants
+
+import "os"
+
+var (
+	DiscordAlertsEnabled           = os.Getenv("DISCORD_ERROR_REPORT_WEBHOOK_URL") != ""
+	DiscordAlertsWebhookURL string = mustGetEnv("DISCORD_ERROR_REPORT_WEBHOOK_URL", func() bool { return !DiscordAlertsEnabled })
+)
diff --git a/internal/database/client.go b/internal/database/client.go
index f873383c..053a5fef 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -10,9 +10,9 @@ import (
 	"entgo.io/ent/dialect/sql"
 	"github.com/cufee/aftermath/internal/database/ent/db"
 	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/log"
 	"github.com/cufee/aftermath/internal/permissions"
 	"github.com/cufee/aftermath/internal/stats/frame"
-	"github.com/rs/zerolog/log"
 
 	_ "github.com/mattn/go-sqlite3"
 )
diff --git a/internal/files/load.go b/internal/files/load.go
index e1e88da7..f8a0f425 100644
--- a/internal/files/load.go
+++ b/internal/files/load.go
@@ -3,7 +3,7 @@ package files
 import (
 	"io/fs"
 
-	"github.com/rs/zerolog/log"
+	"github.com/cufee/aftermath/internal/log"
 )
 
 func ReadDirFiles(dir fs.FS, path string) (map[string][]byte, error) {
diff --git a/internal/log/logger.go b/internal/log/logger.go
new file mode 100644
index 00000000..39b06ba8
--- /dev/null
+++ b/internal/log/logger.go
@@ -0,0 +1,53 @@
+package log
+
+import (
+	"net/http"
+	"os"
+	"time"
+
+	"github.com/justinas/alice"
+	"github.com/rs/zerolog"
+	"github.com/rs/zerolog/hlog"
+	"github.com/rs/zerolog/log"
+)
+
+var globalLogger = zerolog.New(os.Stdout).With().Timestamp().Logger()
+
+func SetupGlobalLogger(setup func(zerolog.Logger) zerolog.Logger) {
+	globalLogger = setup(globalLogger)
+}
+
+func Debug() *zerolog.Event        { return log.Debug() }
+func Info() *zerolog.Event         { return log.Info() }
+func Warn() *zerolog.Event         { return log.Warn() }
+func Err(err error) *zerolog.Event { return log.Err(err) }
+func Error() *zerolog.Event        { return log.Error() }
+func Fatal() *zerolog.Event        { return log.Fatal() }
+
+func HTTPHandler(logger zerolog.Logger) http.Handler {
+	c := alice.New()
+
+	// Install the logger handler with default output on the console
+	c = c.Append(hlog.NewHandler(logger))
+
+	// Install some provided extra handler to set some request's context fields.
+	// Thanks to that handler, all our logs will come with some prepopulated fields.
+	c = c.Append(hlog.AccessHandler(func(r *http.Request, status, size int, duration time.Duration) {
+		hlog.FromRequest(r).Info().
+			Str("method", r.Method).
+			Stringer("url", r.URL).
+			Int("status", status).
+			Int("size", size).
+			Dur("duration", duration).
+			Msg("")
+	}))
+	c = c.Append(hlog.UserAgentHandler("user_agent"))
+	c = c.Append(hlog.RefererHandler("referer"))
+
+	return c.Then(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		// Get the logger from the request's context. You can safely assume it
+		// will be always there: if the handler is removed, hlog.FromRequest
+		// will return a no-op logger.
+		hlog.FromRequest(r).Info().Msg("served request")
+	}))
+}
diff --git a/internal/logic/leaderboards.go b/internal/logic/leaderboards.go
index c1f1fc1b..c984026d 100644
--- a/internal/logic/leaderboards.go
+++ b/internal/logic/leaderboards.go
@@ -9,10 +9,10 @@ import (
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/external/wargaming"
+	"github.com/cufee/aftermath/internal/log"
 	"github.com/cufee/aftermath/internal/retry"
 	"github.com/cufee/am-wg-proxy-next/v2/types"
 	"github.com/pkg/errors"
-	"github.com/rs/zerolog/log"
 )
 
 func RecordCurrentAchievementsLeaderboards(ctx context.Context, wgClient wargaming.Client, dbClient database.Client, scoreType models.ScoreType, realm string, force bool, accountIDs ...string) (map[string]error, error) {
diff --git a/internal/logic/snapshots.go b/internal/logic/snapshots.go
index 09e600e2..f586bf80 100644
--- a/internal/logic/snapshots.go
+++ b/internal/logic/snapshots.go
@@ -9,11 +9,11 @@ import (
 	"github.com/cufee/aftermath/internal/database/models"
 
 	"github.com/cufee/aftermath/internal/external/wargaming"
+	"github.com/cufee/aftermath/internal/log"
 	"github.com/cufee/aftermath/internal/retry"
 	"github.com/cufee/aftermath/internal/stats/fetch/v1"
 	"github.com/cufee/am-wg-proxy-next/v2/types"
 	"github.com/pkg/errors"
-	"github.com/rs/zerolog/log"
 )
 
 type vehicleBattleData struct {
diff --git a/internal/stats/client/v1/session.go b/internal/stats/client/v1/session.go
index 15fb026a..55f3d314 100644
--- a/internal/stats/client/v1/session.go
+++ b/internal/stats/client/v1/session.go
@@ -8,12 +8,12 @@ import (
 
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/localization"
+	"github.com/cufee/aftermath/internal/log"
 	"github.com/cufee/aftermath/internal/logic"
 	"github.com/cufee/aftermath/internal/stats/fetch/v1"
 	"github.com/cufee/aftermath/internal/stats/prepare/common/v1"
 	prepare "github.com/cufee/aftermath/internal/stats/prepare/session/v1"
 	render "github.com/cufee/aftermath/internal/stats/render/session/v1"
-	"github.com/rs/zerolog/log"
 )
 
 func (c *client) SessionCards(ctx context.Context, accountId string, from time.Time, o ...RequestOption) (prepare.Cards, Metadata, error) {
diff --git a/internal/stats/fetch/v1/multisource.go b/internal/stats/fetch/v1/multisource.go
index bd7fbcc8..e54b794c 100644
--- a/internal/stats/fetch/v1/multisource.go
+++ b/internal/stats/fetch/v1/multisource.go
@@ -14,10 +14,10 @@ import (
 
 	"github.com/cufee/aftermath/internal/external/blitzstars"
 	"github.com/cufee/aftermath/internal/external/wargaming"
+	"github.com/cufee/aftermath/internal/log"
 	"github.com/cufee/aftermath/internal/retry"
 	"github.com/cufee/aftermath/internal/stats/frame"
 	"github.com/cufee/am-wg-proxy-next/v2/types"
-	"github.com/rs/zerolog/log"
 )
 
 var _ Client = &multiSourceClient{}
diff --git a/internal/stats/fetch/v1/replay/unpack.go b/internal/stats/fetch/v1/replay/unpack.go
index 65903a6d..b92a0ee6 100644
--- a/internal/stats/fetch/v1/replay/unpack.go
+++ b/internal/stats/fetch/v1/replay/unpack.go
@@ -8,7 +8,7 @@ import (
 	"net/http"
 	"strconv"
 
-	"github.com/rs/zerolog/log"
+	"github.com/cufee/aftermath/internal/log"
 )
 
 func UnpackRemote(link string) (*UnpackedReplay, error) {
diff --git a/internal/stats/render/assets/load.go b/internal/stats/render/assets/load.go
index abb60925..16eac730 100644
--- a/internal/stats/render/assets/load.go
+++ b/internal/stats/render/assets/load.go
@@ -11,8 +11,8 @@ import (
 	"strings"
 
 	"github.com/cufee/aftermath/internal/files"
+	"github.com/cufee/aftermath/internal/log"
 	"github.com/golang/freetype/truetype"
-	"github.com/rs/zerolog/log"
 )
 
 var fontsMap = make(map[string][]byte)
diff --git a/internal/stats/render/common/v1/block.go b/internal/stats/render/common/v1/block.go
index 3b2013b8..850d022e 100644
--- a/internal/stats/render/common/v1/block.go
+++ b/internal/stats/render/common/v1/block.go
@@ -7,8 +7,8 @@ import (
 	"strings"
 	"sync"
 
+	"github.com/cufee/aftermath/internal/log"
 	"github.com/pkg/errors"
-	"github.com/rs/zerolog/log"
 
 	"github.com/disintegration/imaging"
 	"github.com/fogleman/gg"
diff --git a/internal/stats/render/common/v1/player_title.go b/internal/stats/render/common/v1/player_title.go
index 22601331..f31beeb2 100644
--- a/internal/stats/render/common/v1/player_title.go
+++ b/internal/stats/render/common/v1/player_title.go
@@ -4,7 +4,7 @@ import (
 	"image/color"
 
 	"github.com/cufee/aftermath/internal/database/models"
-	"github.com/rs/zerolog/log"
+	"github.com/cufee/aftermath/internal/log"
 )
 
 type TitleCardStyle struct {
diff --git a/internal/stats/render/period/v1/cards.go b/internal/stats/render/period/v1/cards.go
index 87551ddc..f34c723d 100644
--- a/internal/stats/render/period/v1/cards.go
+++ b/internal/stats/render/period/v1/cards.go
@@ -11,7 +11,7 @@ import (
 	"github.com/cufee/aftermath/internal/stats/prepare/period/v1"
 	"github.com/cufee/aftermath/internal/stats/render/common/v1"
 
-	"github.com/rs/zerolog/log"
+	"github.com/cufee/aftermath/internal/log"
 )
 
 func generateCards(stats fetch.AccountStatsOverPeriod, cards period.Cards, subs []models.UserSubscription, opts common.Options) (common.Segments, error) {
diff --git a/main.go b/main.go
index 5bd95b79..6b605298 100644
--- a/main.go
+++ b/main.go
@@ -16,6 +16,7 @@ import (
 	"github.com/cufee/aftermath/cmd/core/queue"
 	"github.com/cufee/aftermath/cmd/core/scheduler"
 	"github.com/cufee/aftermath/cmd/core/tasks"
+	"github.com/cufee/aftermath/cmd/discord/alerts"
 	"github.com/cufee/aftermath/cmd/discord/commands"
 	"github.com/cufee/aftermath/cmd/frontend"
 
@@ -30,10 +31,10 @@ import (
 	"github.com/cufee/aftermath/internal/logic"
 	"github.com/cufee/aftermath/internal/stats/fetch/v1"
 
+	"github.com/cufee/aftermath/internal/log"
 	"github.com/cufee/aftermath/internal/stats/render/assets"
 	render "github.com/cufee/aftermath/internal/stats/render/common/v1"
 	"github.com/rs/zerolog"
-	"github.com/rs/zerolog/log"
 
 	_ "github.com/joho/godotenv/autoload"
 
@@ -52,7 +53,20 @@ func main() {
 
 	// Logger
 	level, _ := zerolog.ParseLevel(os.Getenv("LOG_LEVEL"))
-	zerolog.SetGlobalLevel(level)
+	log.SetupGlobalLogger(func(l zerolog.Logger) zerolog.Logger {
+		return l.Level(level)
+	})
+
+	if constants.DiscordAlertsEnabled {
+		alertClient, err := alerts.NewClient(constants.DiscordAlertsWebhookURL)
+		if err != nil {
+			log.Fatal().Err(err).Msg("alerts#NewClient failed")
+		}
+		hook := alerts.NewHook(alertClient)
+		log.SetupGlobalLogger(func(l zerolog.Logger) zerolog.Logger {
+			return l.Hook(hook)
+		})
+	}
 
 	loadStaticAssets(static)
 	db, err := newDatabaseClientFromEnv()

From 66e14915a1992fc8ff7502a1d8a1df49f84b17b1 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Tue, 9 Jul 2024 16:13:37 -0400
Subject: [PATCH 324/341] added logger middleware

---
 cmd/core/server/server.go | 10 ++++++++--
 go.mod                    |  2 +-
 go.sum                    | 10 ----------
 internal/log/logger.go    | 41 ++++++++++++++++-----------------------
 main.go                   |  4 ++--
 5 files changed, 28 insertions(+), 39 deletions(-)

diff --git a/cmd/core/server/server.go b/cmd/core/server/server.go
index 8c272295..35557adc 100644
--- a/cmd/core/server/server.go
+++ b/cmd/core/server/server.go
@@ -10,16 +10,22 @@ type Handler struct {
 	Func http.HandlerFunc
 }
 
-func NewServer(port string, handlers ...Handler) func() {
+func NewServer(port string, handlers []Handler, middleware ...func(http.Handler) http.Handler) func() {
 	mux := http.NewServeMux()
 	for _, h := range handlers {
 		mux.Handle(h.Path, h.Func)
 	}
+
+	var finalHandler http.Handler = mux
+	for i := len(middleware) - 1; i >= 0; i-- { // Reverse order for correct chaining
+		finalHandler = middleware[i](finalHandler)
+	}
+
 	srv := &http.Server{
 		Addr:         ":" + port,
 		WriteTimeout: 15 * time.Second,
 		ReadTimeout:  5 * time.Second,
-		Handler:      mux,
+		Handler:      finalHandler,
 	}
 	return func() {
 		panic(srv.ListenAndServe())
diff --git a/go.mod b/go.mod
index 50f9541f..ccef4fab 100644
--- a/go.mod
+++ b/go.mod
@@ -14,6 +14,7 @@ require (
 	github.com/go-co-op/gocron v1.37.0
 	github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0
 	github.com/joho/godotenv v1.5.1
+	github.com/justinas/alice v1.2.0
 	github.com/lucsky/cuid v1.2.1
 	github.com/mattn/go-sqlite3 v1.14.22
 	github.com/nlpodyssey/gopickle v0.3.0
@@ -41,7 +42,6 @@ require (
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/hashicorp/hcl/v2 v2.21.0 // indirect
-	github.com/justinas/alice v1.2.0 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mitchellh/go-wordwrap v1.0.1 // indirect
diff --git a/go.sum b/go.sum
index 17b3ed44..937bb073 100644
--- a/go.sum
+++ b/go.sum
@@ -68,16 +68,12 @@ github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/
 github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
-github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/mattn/go-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o4kU=
 github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
 github.com/mitchellh/go-wordwrap v1.0.1 h1:TLuKupo69TCn6TQSyGxwI1EblZZEsQ0vMlAFQflz0v0=
 github.com/mitchellh/go-wordwrap v1.0.1/go.mod h1:R62XHJLzvMFRBbcrT7m7WgmE1eOyTSsCt+hzestvNj0=
 github.com/nlpodyssey/gopickle v0.3.0 h1:BLUE5gxFLyyNOPzlXxt6GoHEMMxD0qhsE4p0CIQyoLw=
 github.com/nlpodyssey/gopickle v0.3.0/go.mod h1:f070HJ/yR+eLi5WmM1OXJEGaTpuJEUiib19olXgYha0=
-github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
-github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
 github.com/pierrec/lz4/v4 v4.1.21 h1:yOVMLb6qSIDP67pl/5F7RepeKYu/VmTyEXvuMI5d9mQ=
 github.com/pierrec/lz4/v4 v4.1.21/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
@@ -85,8 +81,6 @@ github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
-github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
 github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=
 github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
@@ -96,10 +90,6 @@ github.com/rs/xid v1.5.0 h1:mKX4bl4iPYJtEIxp6CYiUuLQ/8DYMoz0PUdtGgMFRVc=
 github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
 github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8=
 github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
-github.com/spf13/cobra v1.7.0 h1:hyqWnYt1ZQShIddO5kBpj3vu05/++x6tJ6dg8EC572I=
-github.com/spf13/cobra v1.7.0/go.mod h1:uLxZILRyS/50WlhOIKD7W6V5bgeIt+4sICxh6uRMrb0=
-github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
-github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
diff --git a/internal/log/logger.go b/internal/log/logger.go
index 39b06ba8..d16e4e8f 100644
--- a/internal/log/logger.go
+++ b/internal/log/logger.go
@@ -3,12 +3,12 @@ package log
 import (
 	"net/http"
 	"os"
+	"strings"
 	"time"
 
 	"github.com/justinas/alice"
 	"github.com/rs/zerolog"
 	"github.com/rs/zerolog/hlog"
-	"github.com/rs/zerolog/log"
 )
 
 var globalLogger = zerolog.New(os.Stdout).With().Timestamp().Logger()
@@ -17,37 +17,30 @@ func SetupGlobalLogger(setup func(zerolog.Logger) zerolog.Logger) {
 	globalLogger = setup(globalLogger)
 }
 
-func Debug() *zerolog.Event        { return log.Debug() }
-func Info() *zerolog.Event         { return log.Info() }
-func Warn() *zerolog.Event         { return log.Warn() }
-func Err(err error) *zerolog.Event { return log.Err(err) }
-func Error() *zerolog.Event        { return log.Error() }
-func Fatal() *zerolog.Event        { return log.Fatal() }
+func Logger() zerolog.Logger { return globalLogger }
 
-func HTTPHandler(logger zerolog.Logger) http.Handler {
+func Debug() *zerolog.Event        { return globalLogger.Debug() }
+func Info() *zerolog.Event         { return globalLogger.Info() }
+func Warn() *zerolog.Event         { return globalLogger.Warn() }
+func Err(err error) *zerolog.Event { return globalLogger.Err(err) }
+func Error() *zerolog.Event        { return globalLogger.Error() }
+func Fatal() *zerolog.Event        { return globalLogger.Fatal() }
+
+func NewMiddleware(logger zerolog.Logger) func(http.Handler) http.Handler {
 	c := alice.New()
 
-	// Install the logger handler with default output on the console
 	c = c.Append(hlog.NewHandler(logger))
-
-	// Install some provided extra handler to set some request's context fields.
-	// Thanks to that handler, all our logs will come with some prepopulated fields.
 	c = c.Append(hlog.AccessHandler(func(r *http.Request, status, size int, duration time.Duration) {
+		if strings.HasPrefix(r.URL.Path, "/assets/") {
+			return
+		}
 		hlog.FromRequest(r).Info().
+			Int("status", status).
 			Str("method", r.Method).
+			Str("duration", duration.String()).
 			Stringer("url", r.URL).
-			Int("status", status).
-			Int("size", size).
-			Dur("duration", duration).
 			Msg("")
 	}))
-	c = c.Append(hlog.UserAgentHandler("user_agent"))
-	c = c.Append(hlog.RefererHandler("referer"))
-
-	return c.Then(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		// Get the logger from the request's context. You can safely assume it
-		// will be always there: if the handler is removed, hlog.FromRequest
-		// will return a no-op logger.
-		hlog.FromRequest(r).Info().Msg("served request")
-	}))
+
+	return c.Then
 }
diff --git a/main.go b/main.go
index 6b605298..2c5ea1d0 100644
--- a/main.go
+++ b/main.go
@@ -110,7 +110,7 @@ func main() {
 				Path: "POST /v1/snapshots/{realm}",
 				Func: private.SaveRealmSnapshots(cacheCoreClient),
 			},
-		}...)
+		}, log.NewMiddleware(log.Logger()))
 		log.Info().Str("port", constants.ServePrivateEndpointsPort).Msg("starting a private server")
 		go servePrivate()
 	}
@@ -131,7 +131,7 @@ func main() {
 	handlers = append(handlers, redirectHandlersFromEnv()...)
 
 	port := os.Getenv("PORT")
-	servePublic := server.NewServer(port, handlers...)
+	servePublic := server.NewServer(port, handlers, log.NewMiddleware(log.Logger()))
 	log.Info().Str("port", port).Msg("starting a public server")
 	go servePublic()
 

From f8047f5f0e0844fdb9a75ae6026e3a4112f4b9b7 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Tue, 9 Jul 2024 16:16:00 -0400
Subject: [PATCH 325/341] removed mem limit, go will use up to container mem
 limit

---
 .github/workflows/build-packages.yml | 1 -
 Dockerfile                           | 3 +--
 2 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/.github/workflows/build-packages.yml b/.github/workflows/build-packages.yml
index da621a7d..7d73c7c1 100644
--- a/.github/workflows/build-packages.yml
+++ b/.github/workflows/build-packages.yml
@@ -79,7 +79,6 @@ jobs:
           file: Dockerfile
           build-args: |
             BRAND_FLAVOR=${{ env.BRAND_FLAVOR }}
-            GO_MEM_LIMIT=${{ env.GO_MEM_LIMIT }}
       - name: Build and push migrations Docker image
         id: push-migrations
         uses: docker/build-push-action@v6
diff --git a/Dockerfile b/Dockerfile
index dd693ab1..2ea16148 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,6 +1,5 @@
 FROM golang:1.22.3-bookworm as builder
 
-ARG GO_MEM_LIMIT=122MiB
 ARG BRAND_FLAVOR=red
 ENV BRAND_FLAVOR $BRAND_FLAVOR
 
@@ -13,7 +12,7 @@ COPY ./ ./
 
 # build a fully standalone binary with zero dependencies
 RUN --mount=type=cache,target=$GOPATH/pkg/mod go generate main.go
-RUN --mount=type=cache,target=$GOPATH/pkg/mod CGO_ENABLED=1 GOOS=linux GOMEMLIMIT=$GO_MEM_LIMIT go build -o /bin/aftermath .
+RUN --mount=type=cache,target=$GOPATH/pkg/mod CGO_ENABLED=1 GOOS=linux go build -o /bin/aftermath .
 
 # Make a scratch container with required files and binary
 FROM debian:stable-slim

From a8896d01560589dc503b23138b091e80506bd653 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Tue, 9 Jul 2024 16:17:47 -0400
Subject: [PATCH 326/341] updated comment, set memory to guaranteed instead of
 burst

---
 docker-compose.base.yaml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docker-compose.base.yaml b/docker-compose.base.yaml
index 34b6bc5b..a56f7e54 100644
--- a/docker-compose.base.yaml
+++ b/docker-compose.base.yaml
@@ -20,9 +20,9 @@ services:
       aftermath-migrate:
         condition: service_completed_successfully
     deploy:
-      # the resource limits are setup during build step and should generally not be adjusted here without changing the build pipeline first
+      # go runtime will try to keep memory usage right under the container limit
       resources:
         reservations:
-          memory: 128m
+          memory: 256m
         limits:
           memory: 256m

From 99f9848e0762a2dbcac5d13727d3e3431f0037eb Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Tue, 9 Jul 2024 16:23:43 -0400
Subject: [PATCH 327/341] tidy

---
 go.sum | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/go.sum b/go.sum
index 937bb073..17b3ed44 100644
--- a/go.sum
+++ b/go.sum
@@ -68,12 +68,16 @@ github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/
 github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
+github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/mattn/go-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o4kU=
 github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
 github.com/mitchellh/go-wordwrap v1.0.1 h1:TLuKupo69TCn6TQSyGxwI1EblZZEsQ0vMlAFQflz0v0=
 github.com/mitchellh/go-wordwrap v1.0.1/go.mod h1:R62XHJLzvMFRBbcrT7m7WgmE1eOyTSsCt+hzestvNj0=
 github.com/nlpodyssey/gopickle v0.3.0 h1:BLUE5gxFLyyNOPzlXxt6GoHEMMxD0qhsE4p0CIQyoLw=
 github.com/nlpodyssey/gopickle v0.3.0/go.mod h1:f070HJ/yR+eLi5WmM1OXJEGaTpuJEUiib19olXgYha0=
+github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
+github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
 github.com/pierrec/lz4/v4 v4.1.21 h1:yOVMLb6qSIDP67pl/5F7RepeKYu/VmTyEXvuMI5d9mQ=
 github.com/pierrec/lz4/v4 v4.1.21/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
@@ -81,6 +85,8 @@ github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
+github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
 github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=
 github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
@@ -90,6 +96,10 @@ github.com/rs/xid v1.5.0 h1:mKX4bl4iPYJtEIxp6CYiUuLQ/8DYMoz0PUdtGgMFRVc=
 github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
 github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8=
 github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
+github.com/spf13/cobra v1.7.0 h1:hyqWnYt1ZQShIddO5kBpj3vu05/++x6tJ6dg8EC572I=
+github.com/spf13/cobra v1.7.0/go.mod h1:uLxZILRyS/50WlhOIKD7W6V5bgeIt+4sICxh6uRMrb0=
+github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=

From c6a1767d9a8ce8cd0a7f605e1ef5fd858ac9d27d Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Tue, 9 Jul 2024 16:27:57 -0400
Subject: [PATCH 328/341] fixed error alerts

---
 cmd/discord/alerts/client.go | 4 ++--
 main.go                      | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/cmd/discord/alerts/client.go b/cmd/discord/alerts/client.go
index 62733607..190dc67a 100644
--- a/cmd/discord/alerts/client.go
+++ b/cmd/discord/alerts/client.go
@@ -21,8 +21,8 @@ type alertClient struct {
 	webhookURL string
 }
 
-func NewClient(webhookURL string) (*alertClient, error) {
-	client, err := rest.NewClient("")
+func NewClient(token string, webhookURL string) (*alertClient, error) {
+	client, err := rest.NewClient(token)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to create a rest client")
 	}
diff --git a/main.go b/main.go
index 2c5ea1d0..9eb101ef 100644
--- a/main.go
+++ b/main.go
@@ -58,7 +58,7 @@ func main() {
 	})
 
 	if constants.DiscordAlertsEnabled {
-		alertClient, err := alerts.NewClient(constants.DiscordAlertsWebhookURL)
+		alertClient, err := alerts.NewClient(constants.DiscordPrimaryToken, constants.DiscordAlertsWebhookURL)
 		if err != nil {
 			log.Fatal().Err(err).Msg("alerts#NewClient failed")
 		}

From 5f94a4e5a0fbaf0e3a21c06862dbc376c67201bf Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Tue, 9 Jul 2024 16:32:12 -0400
Subject: [PATCH 329/341] reset migrations

---
 .../ent/migrations/20240627200953.sql         |  22 ---
 .../ent/migrations/20240703151859.sql         |  22 ---
 .../ent/migrations/20240703160454.sql         |   6 -
 .../ent/migrations/20240703160711.sql         | 142 ------------------
 .../ent/migrations/20240703180358.sql         |   4 -
 .../ent/migrations/20240708154415.sql         |  18 ---
 .../ent/migrations/20240709150702.sql         |  20 ---
 ...{20240627171532.sql => 20240709203105.sql} |  46 ++++--
 internal/database/ent/migrations/atlas.sum    |  11 +-
 9 files changed, 39 insertions(+), 252 deletions(-)
 delete mode 100644 internal/database/ent/migrations/20240627200953.sql
 delete mode 100644 internal/database/ent/migrations/20240703151859.sql
 delete mode 100644 internal/database/ent/migrations/20240703160454.sql
 delete mode 100644 internal/database/ent/migrations/20240703160711.sql
 delete mode 100644 internal/database/ent/migrations/20240703180358.sql
 delete mode 100644 internal/database/ent/migrations/20240708154415.sql
 delete mode 100644 internal/database/ent/migrations/20240709150702.sql
 rename internal/database/ent/migrations/{20240627171532.sql => 20240709203105.sql} (79%)

diff --git a/internal/database/ent/migrations/20240627200953.sql b/internal/database/ent/migrations/20240627200953.sql
deleted file mode 100644
index be677edd..00000000
--- a/internal/database/ent/migrations/20240627200953.sql
+++ /dev/null
@@ -1,22 +0,0 @@
--- Disable the enforcement of foreign-keys constraints
-PRAGMA foreign_keys = off;
--- Create "new_cron_tasks" table
-CREATE TABLE `new_cron_tasks` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `reference_id` text NOT NULL, `targets` json NOT NULL, `status` text NOT NULL, `scheduled_after` datetime NOT NULL, `last_run` datetime NOT NULL, `tries_left` integer NOT NULL DEFAULT (0), `logs` json NOT NULL, `data` json NOT NULL, PRIMARY KEY (`id`));
--- Copy rows from old table "cron_tasks" to new temporary table "new_cron_tasks"
-INSERT INTO `new_cron_tasks` (`id`, `created_at`, `updated_at`, `type`, `reference_id`, `targets`, `status`, `scheduled_after`, `last_run`, `logs`, `data`) SELECT `id`, `created_at`, `updated_at`, `type`, `reference_id`, `targets`, `status`, `scheduled_after`, `last_run`, `logs`, `data` FROM `cron_tasks`;
--- Drop "cron_tasks" table after copying rows
-DROP TABLE `cron_tasks`;
--- Rename temporary table "new_cron_tasks" to "cron_tasks"
-ALTER TABLE `new_cron_tasks` RENAME TO `cron_tasks`;
--- Create index "crontask_id" to table: "cron_tasks"
-CREATE INDEX `crontask_id` ON `cron_tasks` (`id`);
--- Create index "crontask_reference_id" to table: "cron_tasks"
-CREATE INDEX `crontask_reference_id` ON `cron_tasks` (`reference_id`);
--- Create index "crontask_status_last_run" to table: "cron_tasks"
-CREATE INDEX `crontask_status_last_run` ON `cron_tasks` (`status`, `last_run`);
--- Create index "crontask_status_created_at" to table: "cron_tasks"
-CREATE INDEX `crontask_status_created_at` ON `cron_tasks` (`status`, `created_at`);
--- Create index "crontask_status_scheduled_after" to table: "cron_tasks"
-CREATE INDEX `crontask_status_scheduled_after` ON `cron_tasks` (`status`, `scheduled_after`);
--- Enable back the enforcement of foreign-keys constraints
-PRAGMA foreign_keys = on;
diff --git a/internal/database/ent/migrations/20240703151859.sql b/internal/database/ent/migrations/20240703151859.sql
deleted file mode 100644
index b2ceca0a..00000000
--- a/internal/database/ent/migrations/20240703151859.sql
+++ /dev/null
@@ -1,22 +0,0 @@
--- Disable the enforcement of foreign-keys constraints
-PRAGMA foreign_keys = off;
--- Create "new_users" table
-CREATE TABLE `new_users` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `username` text NOT NULL DEFAULT (''), `permissions` text NOT NULL DEFAULT (''), `feature_flags` json NULL, PRIMARY KEY (`id`));
--- Copy rows from old table "users" to new temporary table "new_users"
-INSERT INTO `new_users` (`id`, `created_at`, `updated_at`, `permissions`, `feature_flags`) SELECT `id`, `created_at`, `updated_at`, `permissions`, `feature_flags` FROM `users`;
--- Drop "users" table after copying rows
-DROP TABLE `users`;
--- Rename temporary table "new_users" to "users"
-ALTER TABLE `new_users` RENAME TO `users`;
--- Create index "user_id" to table: "users"
-CREATE INDEX `user_id` ON `users` (`id`);
--- Create index "user_username" to table: "users"
-CREATE INDEX `user_username` ON `users` (`username`);
--- Create "auth_nonces" table
-CREATE TABLE `auth_nonces` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `active` bool NOT NULL, `expires_at` datetime NOT NULL, `identifier` text NOT NULL, `public_id` text NOT NULL, PRIMARY KEY (`id`));
--- Create index "auth_nonces_public_id_key" to table: "auth_nonces"
-CREATE UNIQUE INDEX `auth_nonces_public_id_key` ON `auth_nonces` (`public_id`);
--- Create index "authnonce_public_id_active_expires_at" to table: "auth_nonces"
-CREATE INDEX `authnonce_public_id_active_expires_at` ON `auth_nonces` (`public_id`, `active`, `expires_at`);
--- Enable back the enforcement of foreign-keys constraints
-PRAGMA foreign_keys = on;
diff --git a/internal/database/ent/migrations/20240703160454.sql b/internal/database/ent/migrations/20240703160454.sql
deleted file mode 100644
index dd5c1c46..00000000
--- a/internal/database/ent/migrations/20240703160454.sql
+++ /dev/null
@@ -1,6 +0,0 @@
--- Create "sessions" table
-CREATE TABLE `sessions` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `expires_at` datetime NOT NULL, `public_id` text NOT NULL, `user_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `sessions_users_sessions` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE NO ACTION);
--- Create index "sessions_public_id_key" to table: "sessions"
-CREATE UNIQUE INDEX `sessions_public_id_key` ON `sessions` (`public_id`);
--- Create index "session_public_id_expires_at" to table: "sessions"
-CREATE INDEX `session_public_id_expires_at` ON `sessions` (`public_id`, `expires_at`);
diff --git a/internal/database/ent/migrations/20240703160711.sql b/internal/database/ent/migrations/20240703160711.sql
deleted file mode 100644
index 3e23cb09..00000000
--- a/internal/database/ent/migrations/20240703160711.sql
+++ /dev/null
@@ -1,142 +0,0 @@
--- Disable the enforcement of foreign-keys constraints
-PRAGMA foreign_keys = off;
--- Create "new_account_snapshots" table
-CREATE TABLE `new_account_snapshots` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `last_battle_time` datetime NOT NULL, `reference_id` text NOT NULL, `rating_battles` integer NOT NULL, `rating_frame` json NOT NULL, `regular_battles` integer NOT NULL, `regular_frame` json NOT NULL, `account_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `account_snapshots_accounts_account_snapshots` FOREIGN KEY (`account_id`) REFERENCES `accounts` (`id`) ON DELETE CASCADE);
--- Copy rows from old table "account_snapshots" to new temporary table "new_account_snapshots"
-INSERT INTO `new_account_snapshots` (`id`, `created_at`, `updated_at`, `type`, `last_battle_time`, `reference_id`, `rating_battles`, `rating_frame`, `regular_battles`, `regular_frame`, `account_id`) SELECT `id`, `created_at`, `updated_at`, `type`, `last_battle_time`, `reference_id`, `rating_battles`, `rating_frame`, `regular_battles`, `regular_frame`, `account_id` FROM `account_snapshots`;
--- Drop "account_snapshots" table after copying rows
-DROP TABLE `account_snapshots`;
--- Rename temporary table "new_account_snapshots" to "account_snapshots"
-ALTER TABLE `new_account_snapshots` RENAME TO `account_snapshots`;
--- Create index "accountsnapshot_id" to table: "account_snapshots"
-CREATE INDEX `accountsnapshot_id` ON `account_snapshots` (`id`);
--- Create index "accountsnapshot_created_at" to table: "account_snapshots"
-CREATE INDEX `accountsnapshot_created_at` ON `account_snapshots` (`created_at`);
--- Create index "accountsnapshot_type_account_id_created_at" to table: "account_snapshots"
-CREATE INDEX `accountsnapshot_type_account_id_created_at` ON `account_snapshots` (`type`, `account_id`, `created_at`);
--- Create index "accountsnapshot_type_account_id_reference_id" to table: "account_snapshots"
-CREATE INDEX `accountsnapshot_type_account_id_reference_id` ON `account_snapshots` (`type`, `account_id`, `reference_id`);
--- Create index "accountsnapshot_type_account_id_reference_id_created_at" to table: "account_snapshots"
-CREATE INDEX `accountsnapshot_type_account_id_reference_id_created_at` ON `account_snapshots` (`type`, `account_id`, `reference_id`, `created_at`);
--- Create "new_achievements_snapshots" table
-CREATE TABLE `new_achievements_snapshots` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `reference_id` text NOT NULL, `battles` integer NOT NULL, `last_battle_time` datetime NOT NULL, `data` json NOT NULL, `account_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `achievements_snapshots_accounts_achievement_snapshots` FOREIGN KEY (`account_id`) REFERENCES `accounts` (`id`) ON DELETE CASCADE);
--- Copy rows from old table "achievements_snapshots" to new temporary table "new_achievements_snapshots"
-INSERT INTO `new_achievements_snapshots` (`id`, `created_at`, `updated_at`, `type`, `reference_id`, `battles`, `last_battle_time`, `data`, `account_id`) SELECT `id`, `created_at`, `updated_at`, `type`, `reference_id`, `battles`, `last_battle_time`, `data`, `account_id` FROM `achievements_snapshots`;
--- Drop "achievements_snapshots" table after copying rows
-DROP TABLE `achievements_snapshots`;
--- Rename temporary table "new_achievements_snapshots" to "achievements_snapshots"
-ALTER TABLE `new_achievements_snapshots` RENAME TO `achievements_snapshots`;
--- Create index "achievementssnapshot_id" to table: "achievements_snapshots"
-CREATE INDEX `achievementssnapshot_id` ON `achievements_snapshots` (`id`);
--- Create index "achievementssnapshot_created_at" to table: "achievements_snapshots"
-CREATE INDEX `achievementssnapshot_created_at` ON `achievements_snapshots` (`created_at`);
--- Create index "achievementssnapshot_account_id_reference_id" to table: "achievements_snapshots"
-CREATE INDEX `achievementssnapshot_account_id_reference_id` ON `achievements_snapshots` (`account_id`, `reference_id`);
--- Create index "achievementssnapshot_account_id_reference_id_created_at" to table: "achievements_snapshots"
-CREATE INDEX `achievementssnapshot_account_id_reference_id_created_at` ON `achievements_snapshots` (`account_id`, `reference_id`, `created_at`);
--- Create "new_discord_interactions" table
-CREATE TABLE `new_discord_interactions` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `command` text NOT NULL, `reference_id` text NOT NULL, `type` text NOT NULL, `locale` text NOT NULL, `options` json NOT NULL, `user_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `discord_interactions_users_discord_interactions` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE CASCADE);
--- Copy rows from old table "discord_interactions" to new temporary table "new_discord_interactions"
-INSERT INTO `new_discord_interactions` (`id`, `created_at`, `updated_at`, `command`, `reference_id`, `type`, `locale`, `options`, `user_id`) SELECT `id`, `created_at`, `updated_at`, `command`, `reference_id`, `type`, `locale`, `options`, `user_id` FROM `discord_interactions`;
--- Drop "discord_interactions" table after copying rows
-DROP TABLE `discord_interactions`;
--- Rename temporary table "new_discord_interactions" to "discord_interactions"
-ALTER TABLE `new_discord_interactions` RENAME TO `discord_interactions`;
--- Create index "discordinteraction_id" to table: "discord_interactions"
-CREATE INDEX `discordinteraction_id` ON `discord_interactions` (`id`);
--- Create index "discordinteraction_command" to table: "discord_interactions"
-CREATE INDEX `discordinteraction_command` ON `discord_interactions` (`command`);
--- Create index "discordinteraction_user_id" to table: "discord_interactions"
-CREATE INDEX `discordinteraction_user_id` ON `discord_interactions` (`user_id`);
--- Create index "discordinteraction_user_id_type" to table: "discord_interactions"
-CREATE INDEX `discordinteraction_user_id_type` ON `discord_interactions` (`user_id`, `type`);
--- Create index "discordinteraction_reference_id" to table: "discord_interactions"
-CREATE INDEX `discordinteraction_reference_id` ON `discord_interactions` (`reference_id`);
--- Create "new_user_connections" table
-CREATE TABLE `new_user_connections` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `reference_id` text NOT NULL, `permissions` text NULL DEFAULT (''), `metadata` json NULL, `user_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `user_connections_users_connections` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE CASCADE);
--- Copy rows from old table "user_connections" to new temporary table "new_user_connections"
-INSERT INTO `new_user_connections` (`id`, `created_at`, `updated_at`, `type`, `reference_id`, `permissions`, `metadata`, `user_id`) SELECT `id`, `created_at`, `updated_at`, `type`, `reference_id`, `permissions`, `metadata`, `user_id` FROM `user_connections`;
--- Drop "user_connections" table after copying rows
-DROP TABLE `user_connections`;
--- Rename temporary table "new_user_connections" to "user_connections"
-ALTER TABLE `new_user_connections` RENAME TO `user_connections`;
--- Create index "userconnection_id" to table: "user_connections"
-CREATE INDEX `userconnection_id` ON `user_connections` (`id`);
--- Create index "userconnection_user_id" to table: "user_connections"
-CREATE INDEX `userconnection_user_id` ON `user_connections` (`user_id`);
--- Create index "userconnection_type_user_id" to table: "user_connections"
-CREATE INDEX `userconnection_type_user_id` ON `user_connections` (`type`, `user_id`);
--- Create index "userconnection_reference_id" to table: "user_connections"
-CREATE INDEX `userconnection_reference_id` ON `user_connections` (`reference_id`);
--- Create index "userconnection_type_reference_id" to table: "user_connections"
-CREATE INDEX `userconnection_type_reference_id` ON `user_connections` (`type`, `reference_id`);
--- Create index "userconnection_reference_id_user_id_type" to table: "user_connections"
-CREATE UNIQUE INDEX `userconnection_reference_id_user_id_type` ON `user_connections` (`reference_id`, `user_id`, `type`);
--- Create "new_user_contents" table
-CREATE TABLE `new_user_contents` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `reference_id` text NOT NULL, `value` text NOT NULL, `metadata` json NOT NULL, `user_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `user_contents_users_content` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE CASCADE);
--- Copy rows from old table "user_contents" to new temporary table "new_user_contents"
-INSERT INTO `new_user_contents` (`id`, `created_at`, `updated_at`, `type`, `reference_id`, `value`, `metadata`, `user_id`) SELECT `id`, `created_at`, `updated_at`, `type`, `reference_id`, `value`, `metadata`, `user_id` FROM `user_contents`;
--- Drop "user_contents" table after copying rows
-DROP TABLE `user_contents`;
--- Rename temporary table "new_user_contents" to "user_contents"
-ALTER TABLE `new_user_contents` RENAME TO `user_contents`;
--- Create index "usercontent_id" to table: "user_contents"
-CREATE INDEX `usercontent_id` ON `user_contents` (`id`);
--- Create index "usercontent_user_id" to table: "user_contents"
-CREATE INDEX `usercontent_user_id` ON `user_contents` (`user_id`);
--- Create index "usercontent_type_user_id" to table: "user_contents"
-CREATE INDEX `usercontent_type_user_id` ON `user_contents` (`type`, `user_id`);
--- Create index "usercontent_reference_id" to table: "user_contents"
-CREATE INDEX `usercontent_reference_id` ON `user_contents` (`reference_id`);
--- Create index "usercontent_type_reference_id" to table: "user_contents"
-CREATE INDEX `usercontent_type_reference_id` ON `user_contents` (`type`, `reference_id`);
--- Create "new_user_subscriptions" table
-CREATE TABLE `new_user_subscriptions` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `expires_at` datetime NOT NULL, `permissions` text NOT NULL, `reference_id` text NOT NULL, `user_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `user_subscriptions_users_subscriptions` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE CASCADE);
--- Copy rows from old table "user_subscriptions" to new temporary table "new_user_subscriptions"
-INSERT INTO `new_user_subscriptions` (`id`, `created_at`, `updated_at`, `type`, `expires_at`, `permissions`, `reference_id`, `user_id`) SELECT `id`, `created_at`, `updated_at`, `type`, `expires_at`, `permissions`, `reference_id`, `user_id` FROM `user_subscriptions`;
--- Drop "user_subscriptions" table after copying rows
-DROP TABLE `user_subscriptions`;
--- Rename temporary table "new_user_subscriptions" to "user_subscriptions"
-ALTER TABLE `new_user_subscriptions` RENAME TO `user_subscriptions`;
--- Create index "usersubscription_id" to table: "user_subscriptions"
-CREATE INDEX `usersubscription_id` ON `user_subscriptions` (`id`);
--- Create index "usersubscription_user_id" to table: "user_subscriptions"
-CREATE INDEX `usersubscription_user_id` ON `user_subscriptions` (`user_id`);
--- Create index "usersubscription_type_user_id" to table: "user_subscriptions"
-CREATE INDEX `usersubscription_type_user_id` ON `user_subscriptions` (`type`, `user_id`);
--- Create index "usersubscription_expires_at" to table: "user_subscriptions"
-CREATE INDEX `usersubscription_expires_at` ON `user_subscriptions` (`expires_at`);
--- Create index "usersubscription_expires_at_user_id" to table: "user_subscriptions"
-CREATE INDEX `usersubscription_expires_at_user_id` ON `user_subscriptions` (`expires_at`, `user_id`);
--- Create "new_vehicle_snapshots" table
-CREATE TABLE `new_vehicle_snapshots` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `vehicle_id` text NOT NULL, `reference_id` text NOT NULL, `battles` integer NOT NULL, `last_battle_time` datetime NOT NULL, `frame` json NOT NULL, `account_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `vehicle_snapshots_accounts_vehicle_snapshots` FOREIGN KEY (`account_id`) REFERENCES `accounts` (`id`) ON DELETE CASCADE);
--- Copy rows from old table "vehicle_snapshots" to new temporary table "new_vehicle_snapshots"
-INSERT INTO `new_vehicle_snapshots` (`id`, `created_at`, `updated_at`, `type`, `vehicle_id`, `reference_id`, `battles`, `last_battle_time`, `frame`, `account_id`) SELECT `id`, `created_at`, `updated_at`, `type`, `vehicle_id`, `reference_id`, `battles`, `last_battle_time`, `frame`, `account_id` FROM `vehicle_snapshots`;
--- Drop "vehicle_snapshots" table after copying rows
-DROP TABLE `vehicle_snapshots`;
--- Rename temporary table "new_vehicle_snapshots" to "vehicle_snapshots"
-ALTER TABLE `new_vehicle_snapshots` RENAME TO `vehicle_snapshots`;
--- Create index "vehiclesnapshot_id" to table: "vehicle_snapshots"
-CREATE INDEX `vehiclesnapshot_id` ON `vehicle_snapshots` (`id`);
--- Create index "vehiclesnapshot_created_at" to table: "vehicle_snapshots"
-CREATE INDEX `vehiclesnapshot_created_at` ON `vehicle_snapshots` (`created_at`);
--- Create index "vehiclesnapshot_vehicle_id_created_at" to table: "vehicle_snapshots"
-CREATE INDEX `vehiclesnapshot_vehicle_id_created_at` ON `vehicle_snapshots` (`vehicle_id`, `created_at`);
--- Create index "vehiclesnapshot_account_id_created_at" to table: "vehicle_snapshots"
-CREATE INDEX `vehiclesnapshot_account_id_created_at` ON `vehicle_snapshots` (`account_id`, `created_at`);
--- Create index "vehiclesnapshot_account_id_type_created_at" to table: "vehicle_snapshots"
-CREATE INDEX `vehiclesnapshot_account_id_type_created_at` ON `vehicle_snapshots` (`account_id`, `type`, `created_at`);
--- Create "new_sessions" table
-CREATE TABLE `new_sessions` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `expires_at` datetime NOT NULL, `public_id` text NOT NULL, `user_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `sessions_users_sessions` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE CASCADE);
--- Copy rows from old table "sessions" to new temporary table "new_sessions"
-INSERT INTO `new_sessions` (`id`, `created_at`, `updated_at`, `expires_at`, `public_id`, `user_id`) SELECT `id`, `created_at`, `updated_at`, `expires_at`, `public_id`, `user_id` FROM `sessions`;
--- Drop "sessions" table after copying rows
-DROP TABLE `sessions`;
--- Rename temporary table "new_sessions" to "sessions"
-ALTER TABLE `new_sessions` RENAME TO `sessions`;
--- Create index "sessions_public_id_key" to table: "sessions"
-CREATE UNIQUE INDEX `sessions_public_id_key` ON `sessions` (`public_id`);
--- Create index "session_public_id_expires_at" to table: "sessions"
-CREATE INDEX `session_public_id_expires_at` ON `sessions` (`public_id`, `expires_at`);
--- Enable back the enforcement of foreign-keys constraints
-PRAGMA foreign_keys = on;
diff --git a/internal/database/ent/migrations/20240703180358.sql b/internal/database/ent/migrations/20240703180358.sql
deleted file mode 100644
index 4162fa2b..00000000
--- a/internal/database/ent/migrations/20240703180358.sql
+++ /dev/null
@@ -1,4 +0,0 @@
--- Add column "metadata" to table: "auth_nonces"
-ALTER TABLE `auth_nonces` ADD COLUMN `metadata` json NOT NULL;
--- Add column "metadata" to table: "sessions"
-ALTER TABLE `sessions` ADD COLUMN `metadata` json NOT NULL;
diff --git a/internal/database/ent/migrations/20240708154415.sql b/internal/database/ent/migrations/20240708154415.sql
deleted file mode 100644
index b3346bf7..00000000
--- a/internal/database/ent/migrations/20240708154415.sql
+++ /dev/null
@@ -1,18 +0,0 @@
--- Create "leaderboard_scores" table
-CREATE TABLE `leaderboard_scores` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `score` real NOT NULL, `reference_id` text NOT NULL, `leaderboard_id` text NOT NULL, `meta` json NOT NULL, PRIMARY KEY (`id`));
--- Create index "leaderboardscore_id" to table: "leaderboard_scores"
-CREATE INDEX `leaderboardscore_id` ON `leaderboard_scores` (`id`);
--- Create index "leaderboardscore_created_at" to table: "leaderboard_scores"
-CREATE INDEX `leaderboardscore_created_at` ON `leaderboard_scores` (`created_at`);
--- Create index "leaderboardscore_created_at_type" to table: "leaderboard_scores"
-CREATE INDEX `leaderboardscore_created_at_type` ON `leaderboard_scores` (`created_at`, `type`);
--- Create index "leaderboardscore_score_type" to table: "leaderboard_scores"
-CREATE INDEX `leaderboardscore_score_type` ON `leaderboard_scores` (`score`, `type`);
--- Create index "leaderboardscore_leaderboard_id_type" to table: "leaderboard_scores"
-CREATE INDEX `leaderboardscore_leaderboard_id_type` ON `leaderboard_scores` (`leaderboard_id`, `type`);
--- Create index "leaderboardscore_leaderboard_id_score_type" to table: "leaderboard_scores"
-CREATE INDEX `leaderboardscore_leaderboard_id_score_type` ON `leaderboard_scores` (`leaderboard_id`, `score`, `type`);
--- Create index "leaderboardscore_leaderboard_id_reference_id_type" to table: "leaderboard_scores"
-CREATE INDEX `leaderboardscore_leaderboard_id_reference_id_type` ON `leaderboard_scores` (`leaderboard_id`, `reference_id`, `type`);
--- Create index "leaderboardscore_leaderboard_id_reference_id_score_type" to table: "leaderboard_scores"
-CREATE INDEX `leaderboardscore_leaderboard_id_reference_id_score_type` ON `leaderboard_scores` (`leaderboard_id`, `reference_id`, `score`, `type`);
diff --git a/internal/database/ent/migrations/20240709150702.sql b/internal/database/ent/migrations/20240709150702.sql
deleted file mode 100644
index cf19507e..00000000
--- a/internal/database/ent/migrations/20240709150702.sql
+++ /dev/null
@@ -1,20 +0,0 @@
--- Disable the enforcement of foreign-keys constraints
-PRAGMA foreign_keys = off;
--- Drop "leaderboard_scores" table
-DROP TABLE `leaderboard_scores`;
--- Create "leaderboard_scores" table
-CREATE TABLE `leaderboard_scores` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `score` real NOT NULL, `account_id` text NOT NULL, `reference_id` text NOT NULL, `leaderboard_id` text NOT NULL, `meta` json NOT NULL, PRIMARY KEY (`id`));
--- Create index "leaderboardscore_id" to table: "leaderboard_scores"
-CREATE INDEX `leaderboardscore_id` ON `leaderboard_scores` (`id`);
--- Create index "leaderboardscore_created_at" to table: "leaderboard_scores"
-CREATE INDEX `leaderboardscore_created_at` ON `leaderboard_scores` (`created_at`);
--- Create index "leaderboardscore_account_id" to table: "leaderboard_scores"
-CREATE INDEX `leaderboardscore_account_id` ON `leaderboard_scores` (`account_id`);
--- Create index "leaderboardscore_reference_id" to table: "leaderboard_scores"
-CREATE INDEX `leaderboardscore_reference_id` ON `leaderboard_scores` (`reference_id`);
--- Create index "leaderboardscore_leaderboard_id_type_account_id" to table: "leaderboard_scores"
-CREATE INDEX `leaderboardscore_leaderboard_id_type_account_id` ON `leaderboard_scores` (`leaderboard_id`, `type`, `account_id`);
--- Create index "leaderboardscore_leaderboard_id_type_reference_id" to table: "leaderboard_scores"
-CREATE INDEX `leaderboardscore_leaderboard_id_type_reference_id` ON `leaderboard_scores` (`leaderboard_id`, `type`, `reference_id`);
--- Enable back the enforcement of foreign-keys constraints
-PRAGMA foreign_keys = on;
diff --git a/internal/database/ent/migrations/20240627171532.sql b/internal/database/ent/migrations/20240709203105.sql
similarity index 79%
rename from internal/database/ent/migrations/20240627171532.sql
rename to internal/database/ent/migrations/20240709203105.sql
index 16b6cc27..f122dd35 100644
--- a/internal/database/ent/migrations/20240627171532.sql
+++ b/internal/database/ent/migrations/20240709203105.sql
@@ -11,7 +11,7 @@ CREATE INDEX `account_realm_last_battle_time` ON `accounts` (`realm`, `last_batt
 -- Create index "account_clan_id" to table: "accounts"
 CREATE INDEX `account_clan_id` ON `accounts` (`clan_id`);
 -- Create "account_snapshots" table
-CREATE TABLE `account_snapshots` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `last_battle_time` datetime NOT NULL, `reference_id` text NOT NULL, `rating_battles` integer NOT NULL, `rating_frame` json NOT NULL, `regular_battles` integer NOT NULL, `regular_frame` json NOT NULL, `account_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `account_snapshots_accounts_snapshots` FOREIGN KEY (`account_id`) REFERENCES `accounts` (`id`) ON DELETE NO ACTION);
+CREATE TABLE `account_snapshots` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `last_battle_time` datetime NOT NULL, `reference_id` text NOT NULL, `rating_battles` integer NOT NULL, `rating_frame` json NOT NULL, `regular_battles` integer NOT NULL, `regular_frame` json NOT NULL, `account_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `account_snapshots_accounts_account_snapshots` FOREIGN KEY (`account_id`) REFERENCES `accounts` (`id`) ON DELETE CASCADE);
 -- Create index "accountsnapshot_id" to table: "account_snapshots"
 CREATE INDEX `accountsnapshot_id` ON `account_snapshots` (`id`);
 -- Create index "accountsnapshot_created_at" to table: "account_snapshots"
@@ -23,7 +23,7 @@ CREATE INDEX `accountsnapshot_type_account_id_reference_id` ON `account_snapshot
 -- Create index "accountsnapshot_type_account_id_reference_id_created_at" to table: "account_snapshots"
 CREATE INDEX `accountsnapshot_type_account_id_reference_id_created_at` ON `account_snapshots` (`type`, `account_id`, `reference_id`, `created_at`);
 -- Create "achievements_snapshots" table
-CREATE TABLE `achievements_snapshots` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `reference_id` text NOT NULL, `battles` integer NOT NULL, `last_battle_time` datetime NOT NULL, `data` json NOT NULL, `account_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `achievements_snapshots_accounts_achievement_snapshots` FOREIGN KEY (`account_id`) REFERENCES `accounts` (`id`) ON DELETE NO ACTION);
+CREATE TABLE `achievements_snapshots` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `reference_id` text NOT NULL, `battles` integer NOT NULL, `last_battle_time` datetime NOT NULL, `data` json NOT NULL, `account_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `achievements_snapshots_accounts_achievement_snapshots` FOREIGN KEY (`account_id`) REFERENCES `accounts` (`id`) ON DELETE CASCADE);
 -- Create index "achievementssnapshot_id" to table: "achievements_snapshots"
 CREATE INDEX `achievementssnapshot_id` ON `achievements_snapshots` (`id`);
 -- Create index "achievementssnapshot_created_at" to table: "achievements_snapshots"
@@ -46,6 +46,12 @@ CREATE TABLE `application_commands` (`id` text NOT NULL, `created_at` datetime N
 CREATE INDEX `applicationcommand_id` ON `application_commands` (`id`);
 -- Create index "applicationcommand_options_hash" to table: "application_commands"
 CREATE INDEX `applicationcommand_options_hash` ON `application_commands` (`options_hash`);
+-- Create "auth_nonces" table
+CREATE TABLE `auth_nonces` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `active` bool NOT NULL, `expires_at` datetime NOT NULL, `identifier` text NOT NULL, `public_id` text NOT NULL, `metadata` json NOT NULL, PRIMARY KEY (`id`));
+-- Create index "auth_nonces_public_id_key" to table: "auth_nonces"
+CREATE UNIQUE INDEX `auth_nonces_public_id_key` ON `auth_nonces` (`public_id`);
+-- Create index "authnonce_public_id_active_expires_at" to table: "auth_nonces"
+CREATE INDEX `authnonce_public_id_active_expires_at` ON `auth_nonces` (`public_id`, `active`, `expires_at`);
 -- Create "clans" table
 CREATE TABLE `clans` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `tag` text NOT NULL, `name` text NOT NULL, `emblem_id` text NULL DEFAULT (''), `members` json NOT NULL, PRIMARY KEY (`id`));
 -- Create index "clan_id" to table: "clans"
@@ -55,7 +61,7 @@ CREATE INDEX `clan_tag` ON `clans` (`tag`);
 -- Create index "clan_name" to table: "clans"
 CREATE INDEX `clan_name` ON `clans` (`name`);
 -- Create "cron_tasks" table
-CREATE TABLE `cron_tasks` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `reference_id` text NOT NULL, `targets` json NOT NULL, `status` text NOT NULL, `scheduled_after` datetime NOT NULL, `last_run` datetime NOT NULL, `logs` json NOT NULL, `data` json NOT NULL, PRIMARY KEY (`id`));
+CREATE TABLE `cron_tasks` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `reference_id` text NOT NULL, `targets` json NOT NULL, `status` text NOT NULL, `scheduled_after` datetime NOT NULL, `last_run` datetime NOT NULL, `tries_left` integer NOT NULL DEFAULT (0), `logs` json NOT NULL, `data` json NOT NULL, PRIMARY KEY (`id`));
 -- Create index "crontask_id" to table: "cron_tasks"
 CREATE INDEX `crontask_id` ON `cron_tasks` (`id`);
 -- Create index "crontask_reference_id" to table: "cron_tasks"
@@ -67,7 +73,7 @@ CREATE INDEX `crontask_status_created_at` ON `cron_tasks` (`status`, `created_at
 -- Create index "crontask_status_scheduled_after" to table: "cron_tasks"
 CREATE INDEX `crontask_status_scheduled_after` ON `cron_tasks` (`status`, `scheduled_after`);
 -- Create "discord_interactions" table
-CREATE TABLE `discord_interactions` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `command` text NOT NULL, `reference_id` text NOT NULL, `type` text NOT NULL, `locale` text NOT NULL, `options` json NOT NULL, `user_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `discord_interactions_users_discord_interactions` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE NO ACTION);
+CREATE TABLE `discord_interactions` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `command` text NOT NULL, `reference_id` text NOT NULL, `type` text NOT NULL, `locale` text NOT NULL, `options` json NOT NULL, `user_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `discord_interactions_users_discord_interactions` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE CASCADE);
 -- Create index "discordinteraction_id" to table: "discord_interactions"
 CREATE INDEX `discordinteraction_id` ON `discord_interactions` (`id`);
 -- Create index "discordinteraction_command" to table: "discord_interactions"
@@ -78,12 +84,34 @@ CREATE INDEX `discordinteraction_user_id` ON `discord_interactions` (`user_id`);
 CREATE INDEX `discordinteraction_user_id_type` ON `discord_interactions` (`user_id`, `type`);
 -- Create index "discordinteraction_reference_id" to table: "discord_interactions"
 CREATE INDEX `discordinteraction_reference_id` ON `discord_interactions` (`reference_id`);
+-- Create "leaderboard_scores" table
+CREATE TABLE `leaderboard_scores` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `score` real NOT NULL, `account_id` text NOT NULL, `reference_id` text NOT NULL, `leaderboard_id` text NOT NULL, `meta` json NOT NULL, PRIMARY KEY (`id`));
+-- Create index "leaderboardscore_id" to table: "leaderboard_scores"
+CREATE INDEX `leaderboardscore_id` ON `leaderboard_scores` (`id`);
+-- Create index "leaderboardscore_created_at" to table: "leaderboard_scores"
+CREATE INDEX `leaderboardscore_created_at` ON `leaderboard_scores` (`created_at`);
+-- Create index "leaderboardscore_account_id" to table: "leaderboard_scores"
+CREATE INDEX `leaderboardscore_account_id` ON `leaderboard_scores` (`account_id`);
+-- Create index "leaderboardscore_reference_id" to table: "leaderboard_scores"
+CREATE INDEX `leaderboardscore_reference_id` ON `leaderboard_scores` (`reference_id`);
+-- Create index "leaderboardscore_leaderboard_id_type_account_id" to table: "leaderboard_scores"
+CREATE INDEX `leaderboardscore_leaderboard_id_type_account_id` ON `leaderboard_scores` (`leaderboard_id`, `type`, `account_id`);
+-- Create index "leaderboardscore_leaderboard_id_type_reference_id" to table: "leaderboard_scores"
+CREATE INDEX `leaderboardscore_leaderboard_id_type_reference_id` ON `leaderboard_scores` (`leaderboard_id`, `type`, `reference_id`);
+-- Create "sessions" table
+CREATE TABLE `sessions` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `expires_at` datetime NOT NULL, `public_id` text NOT NULL, `metadata` json NOT NULL, `user_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `sessions_users_sessions` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE CASCADE);
+-- Create index "sessions_public_id_key" to table: "sessions"
+CREATE UNIQUE INDEX `sessions_public_id_key` ON `sessions` (`public_id`);
+-- Create index "session_public_id_expires_at" to table: "sessions"
+CREATE INDEX `session_public_id_expires_at` ON `sessions` (`public_id`, `expires_at`);
 -- Create "users" table
-CREATE TABLE `users` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `permissions` text NOT NULL DEFAULT (''), `feature_flags` json NULL, PRIMARY KEY (`id`));
+CREATE TABLE `users` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `username` text NOT NULL DEFAULT (''), `permissions` text NOT NULL DEFAULT (''), `feature_flags` json NULL, PRIMARY KEY (`id`));
 -- Create index "user_id" to table: "users"
 CREATE INDEX `user_id` ON `users` (`id`);
+-- Create index "user_username" to table: "users"
+CREATE INDEX `user_username` ON `users` (`username`);
 -- Create "user_connections" table
-CREATE TABLE `user_connections` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `reference_id` text NOT NULL, `permissions` text NULL DEFAULT (''), `metadata` json NULL, `user_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `user_connections_users_connections` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE NO ACTION);
+CREATE TABLE `user_connections` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `reference_id` text NOT NULL, `permissions` text NULL DEFAULT (''), `metadata` json NULL, `user_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `user_connections_users_connections` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE CASCADE);
 -- Create index "userconnection_id" to table: "user_connections"
 CREATE INDEX `userconnection_id` ON `user_connections` (`id`);
 -- Create index "userconnection_user_id" to table: "user_connections"
@@ -97,7 +125,7 @@ CREATE INDEX `userconnection_type_reference_id` ON `user_connections` (`type`, `
 -- Create index "userconnection_reference_id_user_id_type" to table: "user_connections"
 CREATE UNIQUE INDEX `userconnection_reference_id_user_id_type` ON `user_connections` (`reference_id`, `user_id`, `type`);
 -- Create "user_contents" table
-CREATE TABLE `user_contents` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `reference_id` text NOT NULL, `value` text NOT NULL, `metadata` json NOT NULL, `user_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `user_contents_users_content` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE NO ACTION);
+CREATE TABLE `user_contents` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `reference_id` text NOT NULL, `value` text NOT NULL, `metadata` json NOT NULL, `user_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `user_contents_users_content` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE CASCADE);
 -- Create index "usercontent_id" to table: "user_contents"
 CREATE INDEX `usercontent_id` ON `user_contents` (`id`);
 -- Create index "usercontent_user_id" to table: "user_contents"
@@ -109,7 +137,7 @@ CREATE INDEX `usercontent_reference_id` ON `user_contents` (`reference_id`);
 -- Create index "usercontent_type_reference_id" to table: "user_contents"
 CREATE INDEX `usercontent_type_reference_id` ON `user_contents` (`type`, `reference_id`);
 -- Create "user_subscriptions" table
-CREATE TABLE `user_subscriptions` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `expires_at` datetime NOT NULL, `permissions` text NOT NULL, `reference_id` text NOT NULL, `user_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `user_subscriptions_users_subscriptions` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE NO ACTION);
+CREATE TABLE `user_subscriptions` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `expires_at` datetime NOT NULL, `permissions` text NOT NULL, `reference_id` text NOT NULL, `user_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `user_subscriptions_users_subscriptions` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE CASCADE);
 -- Create index "usersubscription_id" to table: "user_subscriptions"
 CREATE INDEX `usersubscription_id` ON `user_subscriptions` (`id`);
 -- Create index "usersubscription_user_id" to table: "user_subscriptions"
@@ -129,7 +157,7 @@ CREATE TABLE `vehicle_averages` (`id` text NOT NULL, `created_at` datetime NOT N
 -- Create index "vehicleaverage_id" to table: "vehicle_averages"
 CREATE INDEX `vehicleaverage_id` ON `vehicle_averages` (`id`);
 -- Create "vehicle_snapshots" table
-CREATE TABLE `vehicle_snapshots` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `vehicle_id` text NOT NULL, `reference_id` text NOT NULL, `battles` integer NOT NULL, `last_battle_time` datetime NOT NULL, `frame` json NOT NULL, `account_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `vehicle_snapshots_accounts_vehicle_snapshots` FOREIGN KEY (`account_id`) REFERENCES `accounts` (`id`) ON DELETE NO ACTION);
+CREATE TABLE `vehicle_snapshots` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `vehicle_id` text NOT NULL, `reference_id` text NOT NULL, `battles` integer NOT NULL, `last_battle_time` datetime NOT NULL, `frame` json NOT NULL, `account_id` text NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `vehicle_snapshots_accounts_vehicle_snapshots` FOREIGN KEY (`account_id`) REFERENCES `accounts` (`id`) ON DELETE CASCADE);
 -- Create index "vehiclesnapshot_id" to table: "vehicle_snapshots"
 CREATE INDEX `vehiclesnapshot_id` ON `vehicle_snapshots` (`id`);
 -- Create index "vehiclesnapshot_created_at" to table: "vehicle_snapshots"
diff --git a/internal/database/ent/migrations/atlas.sum b/internal/database/ent/migrations/atlas.sum
index a9fa283b..4cd4e85f 100644
--- a/internal/database/ent/migrations/atlas.sum
+++ b/internal/database/ent/migrations/atlas.sum
@@ -1,9 +1,2 @@
-h1:a5eKPzX+EWfQzKTtr6gpM01SU01OjMY4p85/nU9ZcSA=
-20240627171532.sql h1:480JhjRCpyyix192z/L92yEI7LSsgJhuiK0ljat55TI=
-20240627200953.sql h1:VUQZd1HQrxITMUtNO9HRtnDE8wgtWgRyzduACb3D3u4=
-20240703151859.sql h1:1QQD7uLkRsLESNATRcGMg7k1C+sxYFQh/wI7BXrsKUA=
-20240703160454.sql h1:8KsIVNWGQGGSkh/cvdYdg1SLIRG0BqY262QOu0Icqu4=
-20240703160711.sql h1:26t/4QYITq6eAo2hif8sCLRpuHsCHXt6nyvDnX+Y1oQ=
-20240703180358.sql h1:gxgh1nrquDAOFGT7yGzgqpy5EfQ4Dvgd6c2NMPM3iIs=
-20240708154415.sql h1:csEqKf/8D88IvC1u0lgdHZDavyrlPUS8PMI8+74jIw8=
-20240709150702.sql h1:Cez0W0NMpvejc4AAtO/7U7yEdKhSkYNPkKN3R8ZOkL4=
+h1:a45dq6iNrjJqg7s6+pBhPSNKDBLRaDhx99WM4knQS2o=
+20240709203105.sql h1:zmiEUhVtnH3IM1/S7iyJpJ4PwqhcZw50OcNYMcjTwrE=

From e134af1304659213406de6622f1b106cc7c6ab13 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Tue, 9 Jul 2024 17:05:09 -0400
Subject: [PATCH 330/341] fixed alerting, now logging complete events

---
 cmd/discord/alerts/client.go | 63 +++++++++++++++++++++++++++---------
 main.go                      |  9 ++++--
 2 files changed, 54 insertions(+), 18 deletions(-)

diff --git a/cmd/discord/alerts/client.go b/cmd/discord/alerts/client.go
index 190dc67a..476d1fd0 100644
--- a/cmd/discord/alerts/client.go
+++ b/cmd/discord/alerts/client.go
@@ -2,7 +2,12 @@ package alerts
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
+	"io"
+	"os"
+	"slices"
+	"strings"
 	"time"
 
 	"github.com/bwmarrin/discordgo"
@@ -29,29 +34,55 @@ func NewClient(token string, webhookURL string) (*alertClient, error) {
 	return &alertClient{rest: client, webhookURL: webhookURL}, nil
 }
 
-func (c *alertClient) Error(ctx context.Context, header, codeBlock string) error {
-	content := fmt.Sprintf("### An error was logged through zerolog\n%s\n```%s```", header, codeBlock)
+func (c *alertClient) Error(ctx context.Context, message, codeBlock string) error {
+	content := fmt.Sprintf("%s\n```%s```", message, codeBlock)
 	return c.rest.PostWebhookMessage(ctx, c.webhookURL, discordgo.WebhookParams{
 		Content:  content,
 		Username: constants.FrontendAppName + " Error Report",
 	}, nil)
-
 }
 
-type zerologHook struct {
-	client DiscordAlertClient
-}
+func (c *alertClient) Reader(r io.ReadCloser, levels ...zerolog.Level) {
+	var levelSlice []string
+	for _, l := range levels {
+		levelSlice = append(levelSlice, l.String())
+	}
+	if len(levelSlice) < 1 {
+		return
+	}
 
-func (h *zerologHook) Run(e *zerolog.Event, level zerolog.Level, msg string) {
-	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
-	defer cancel()
+	go func() {
+		dec := json.NewDecoder(r)
 
-	switch level {
-	case zerolog.ErrorLevel:
-		h.client.Error(ctx, msg, fmt.Sprintf("%v", e.GetCtx().Err()))
-	}
-}
+		for {
+			var e = make(map[string]any)
+			err := dec.Decode(&e)
+			if err == io.EOF {
+				return
+			}
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "unmarshaling log failed: %v\n", err)
+				continue
+			}
+
+			level, ok := e["level"].(string)
+			if !ok || !slices.Contains(levelSlice, level) {
+				continue
+			}
+			data, err := json.MarshalIndent(e, "", "  ")
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "marshaling log failed: %v\n", err)
+				continue
+			}
+			message, _ := e["message"].(string)
 
-func NewHook(c DiscordAlertClient) *zerologHook {
-	return &zerologHook{client: c}
+			ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
+			err = c.Error(ctx, "**["+strings.ToUpper(level)+"]**: "+message, string(data))
+			cancel()
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "failed to report an error: %v\n", err)
+				continue
+			}
+		}
+	}()
 }
diff --git a/main.go b/main.go
index 9eb101ef..6c878f3b 100644
--- a/main.go
+++ b/main.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"embed"
 	"fmt"
+	"io"
 	"io/fs"
 	"os/signal"
 	"path/filepath"
@@ -62,12 +63,16 @@ func main() {
 		if err != nil {
 			log.Fatal().Err(err).Msg("alerts#NewClient failed")
 		}
-		hook := alerts.NewHook(alertClient)
+
+		pr, pw := io.Pipe()
 		log.SetupGlobalLogger(func(l zerolog.Logger) zerolog.Logger {
-			return l.Hook(hook)
+			return l.Output(zerolog.MultiLevelWriter(os.Stderr, pw))
 		})
+		alertClient.Reader(pr, zerolog.ErrorLevel)
 	}
 
+	log.Error().Msg("test")
+
 	loadStaticAssets(static)
 	db, err := newDatabaseClientFromEnv()
 	if err != nil {

From 55a2267e1a3e5d3c8f1c3fbc74f89e11d63f22b7 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Tue, 9 Jul 2024 17:40:11 -0400
Subject: [PATCH 331/341] removed unused field

---
 internal/database/ent/db/leaderboardscore.go  | 13 +---
 .../db/leaderboardscore/leaderboardscore.go   |  8 ---
 .../database/ent/db/leaderboardscore/where.go | 70 -------------------
 .../ent/db/leaderboardscore_create.go         | 13 ----
 .../ent/db/leaderboardscore_update.go         | 34 ---------
 internal/database/ent/db/migrate/schema.go    | 15 +---
 internal/database/ent/db/mutation.go          | 56 +--------------
 .../ent/migrations/20240709213804.sql         | 20 ++++++
 internal/database/ent/migrations/atlas.sum    |  3 +-
 .../database/ent/schema/leaderboard_score.go  |  3 -
 internal/database/leaderboards.go             |  5 +-
 internal/database/models/leaderboard_score.go |  1 -
 internal/logic/leaderboards.go                |  3 +-
 main.go                                       |  2 -
 14 files changed, 29 insertions(+), 217 deletions(-)
 create mode 100644 internal/database/ent/migrations/20240709213804.sql

diff --git a/internal/database/ent/db/leaderboardscore.go b/internal/database/ent/db/leaderboardscore.go
index 6468f119..5c4e84e6 100644
--- a/internal/database/ent/db/leaderboardscore.go
+++ b/internal/database/ent/db/leaderboardscore.go
@@ -27,8 +27,6 @@ type LeaderboardScore struct {
 	Type models.ScoreType `json:"type,omitempty"`
 	// Score holds the value of the "score" field.
 	Score float32 `json:"score,omitempty"`
-	// AccountID holds the value of the "account_id" field.
-	AccountID string `json:"account_id,omitempty"`
 	// ReferenceID holds the value of the "reference_id" field.
 	ReferenceID string `json:"reference_id,omitempty"`
 	// LeaderboardID holds the value of the "leaderboard_id" field.
@@ -47,7 +45,7 @@ func (*LeaderboardScore) scanValues(columns []string) ([]any, error) {
 			values[i] = new([]byte)
 		case leaderboardscore.FieldScore:
 			values[i] = new(sql.NullFloat64)
-		case leaderboardscore.FieldID, leaderboardscore.FieldType, leaderboardscore.FieldAccountID, leaderboardscore.FieldReferenceID, leaderboardscore.FieldLeaderboardID:
+		case leaderboardscore.FieldID, leaderboardscore.FieldType, leaderboardscore.FieldReferenceID, leaderboardscore.FieldLeaderboardID:
 			values[i] = new(sql.NullString)
 		case leaderboardscore.FieldCreatedAt, leaderboardscore.FieldUpdatedAt:
 			values[i] = new(sql.NullTime)
@@ -96,12 +94,6 @@ func (ls *LeaderboardScore) assignValues(columns []string, values []any) error {
 			} else if value.Valid {
 				ls.Score = float32(value.Float64)
 			}
-		case leaderboardscore.FieldAccountID:
-			if value, ok := values[i].(*sql.NullString); !ok {
-				return fmt.Errorf("unexpected type %T for field account_id", values[i])
-			} else if value.Valid {
-				ls.AccountID = value.String
-			}
 		case leaderboardscore.FieldReferenceID:
 			if value, ok := values[i].(*sql.NullString); !ok {
 				return fmt.Errorf("unexpected type %T for field reference_id", values[i])
@@ -170,9 +162,6 @@ func (ls *LeaderboardScore) String() string {
 	builder.WriteString("score=")
 	builder.WriteString(fmt.Sprintf("%v", ls.Score))
 	builder.WriteString(", ")
-	builder.WriteString("account_id=")
-	builder.WriteString(ls.AccountID)
-	builder.WriteString(", ")
 	builder.WriteString("reference_id=")
 	builder.WriteString(ls.ReferenceID)
 	builder.WriteString(", ")
diff --git a/internal/database/ent/db/leaderboardscore/leaderboardscore.go b/internal/database/ent/db/leaderboardscore/leaderboardscore.go
index 7f8fcd58..2b583eac 100644
--- a/internal/database/ent/db/leaderboardscore/leaderboardscore.go
+++ b/internal/database/ent/db/leaderboardscore/leaderboardscore.go
@@ -23,8 +23,6 @@ const (
 	FieldType = "type"
 	// FieldScore holds the string denoting the score field in the database.
 	FieldScore = "score"
-	// FieldAccountID holds the string denoting the account_id field in the database.
-	FieldAccountID = "account_id"
 	// FieldReferenceID holds the string denoting the reference_id field in the database.
 	FieldReferenceID = "reference_id"
 	// FieldLeaderboardID holds the string denoting the leaderboard_id field in the database.
@@ -42,7 +40,6 @@ var Columns = []string{
 	FieldUpdatedAt,
 	FieldType,
 	FieldScore,
-	FieldAccountID,
 	FieldReferenceID,
 	FieldLeaderboardID,
 	FieldMeta,
@@ -107,11 +104,6 @@ func ByScore(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldScore, opts...).ToFunc()
 }
 
-// ByAccountID orders the results by the account_id field.
-func ByAccountID(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldAccountID, opts...).ToFunc()
-}
-
 // ByReferenceID orders the results by the reference_id field.
 func ByReferenceID(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldReferenceID, opts...).ToFunc()
diff --git a/internal/database/ent/db/leaderboardscore/where.go b/internal/database/ent/db/leaderboardscore/where.go
index 437c1cc7..f668b578 100644
--- a/internal/database/ent/db/leaderboardscore/where.go
+++ b/internal/database/ent/db/leaderboardscore/where.go
@@ -80,11 +80,6 @@ func Score(v float32) predicate.LeaderboardScore {
 	return predicate.LeaderboardScore(sql.FieldEQ(FieldScore, v))
 }
 
-// AccountID applies equality check predicate on the "account_id" field. It's identical to AccountIDEQ.
-func AccountID(v string) predicate.LeaderboardScore {
-	return predicate.LeaderboardScore(sql.FieldEQ(FieldAccountID, v))
-}
-
 // ReferenceID applies equality check predicate on the "reference_id" field. It's identical to ReferenceIDEQ.
 func ReferenceID(v string) predicate.LeaderboardScore {
 	return predicate.LeaderboardScore(sql.FieldEQ(FieldReferenceID, v))
@@ -245,71 +240,6 @@ func ScoreLTE(v float32) predicate.LeaderboardScore {
 	return predicate.LeaderboardScore(sql.FieldLTE(FieldScore, v))
 }
 
-// AccountIDEQ applies the EQ predicate on the "account_id" field.
-func AccountIDEQ(v string) predicate.LeaderboardScore {
-	return predicate.LeaderboardScore(sql.FieldEQ(FieldAccountID, v))
-}
-
-// AccountIDNEQ applies the NEQ predicate on the "account_id" field.
-func AccountIDNEQ(v string) predicate.LeaderboardScore {
-	return predicate.LeaderboardScore(sql.FieldNEQ(FieldAccountID, v))
-}
-
-// AccountIDIn applies the In predicate on the "account_id" field.
-func AccountIDIn(vs ...string) predicate.LeaderboardScore {
-	return predicate.LeaderboardScore(sql.FieldIn(FieldAccountID, vs...))
-}
-
-// AccountIDNotIn applies the NotIn predicate on the "account_id" field.
-func AccountIDNotIn(vs ...string) predicate.LeaderboardScore {
-	return predicate.LeaderboardScore(sql.FieldNotIn(FieldAccountID, vs...))
-}
-
-// AccountIDGT applies the GT predicate on the "account_id" field.
-func AccountIDGT(v string) predicate.LeaderboardScore {
-	return predicate.LeaderboardScore(sql.FieldGT(FieldAccountID, v))
-}
-
-// AccountIDGTE applies the GTE predicate on the "account_id" field.
-func AccountIDGTE(v string) predicate.LeaderboardScore {
-	return predicate.LeaderboardScore(sql.FieldGTE(FieldAccountID, v))
-}
-
-// AccountIDLT applies the LT predicate on the "account_id" field.
-func AccountIDLT(v string) predicate.LeaderboardScore {
-	return predicate.LeaderboardScore(sql.FieldLT(FieldAccountID, v))
-}
-
-// AccountIDLTE applies the LTE predicate on the "account_id" field.
-func AccountIDLTE(v string) predicate.LeaderboardScore {
-	return predicate.LeaderboardScore(sql.FieldLTE(FieldAccountID, v))
-}
-
-// AccountIDContains applies the Contains predicate on the "account_id" field.
-func AccountIDContains(v string) predicate.LeaderboardScore {
-	return predicate.LeaderboardScore(sql.FieldContains(FieldAccountID, v))
-}
-
-// AccountIDHasPrefix applies the HasPrefix predicate on the "account_id" field.
-func AccountIDHasPrefix(v string) predicate.LeaderboardScore {
-	return predicate.LeaderboardScore(sql.FieldHasPrefix(FieldAccountID, v))
-}
-
-// AccountIDHasSuffix applies the HasSuffix predicate on the "account_id" field.
-func AccountIDHasSuffix(v string) predicate.LeaderboardScore {
-	return predicate.LeaderboardScore(sql.FieldHasSuffix(FieldAccountID, v))
-}
-
-// AccountIDEqualFold applies the EqualFold predicate on the "account_id" field.
-func AccountIDEqualFold(v string) predicate.LeaderboardScore {
-	return predicate.LeaderboardScore(sql.FieldEqualFold(FieldAccountID, v))
-}
-
-// AccountIDContainsFold applies the ContainsFold predicate on the "account_id" field.
-func AccountIDContainsFold(v string) predicate.LeaderboardScore {
-	return predicate.LeaderboardScore(sql.FieldContainsFold(FieldAccountID, v))
-}
-
 // ReferenceIDEQ applies the EQ predicate on the "reference_id" field.
 func ReferenceIDEQ(v string) predicate.LeaderboardScore {
 	return predicate.LeaderboardScore(sql.FieldEQ(FieldReferenceID, v))
diff --git a/internal/database/ent/db/leaderboardscore_create.go b/internal/database/ent/db/leaderboardscore_create.go
index ad6ff331..1fbb79ad 100644
--- a/internal/database/ent/db/leaderboardscore_create.go
+++ b/internal/database/ent/db/leaderboardscore_create.go
@@ -61,12 +61,6 @@ func (lsc *LeaderboardScoreCreate) SetScore(f float32) *LeaderboardScoreCreate {
 	return lsc
 }
 
-// SetAccountID sets the "account_id" field.
-func (lsc *LeaderboardScoreCreate) SetAccountID(s string) *LeaderboardScoreCreate {
-	lsc.mutation.SetAccountID(s)
-	return lsc
-}
-
 // SetReferenceID sets the "reference_id" field.
 func (lsc *LeaderboardScoreCreate) SetReferenceID(s string) *LeaderboardScoreCreate {
 	lsc.mutation.SetReferenceID(s)
@@ -167,9 +161,6 @@ func (lsc *LeaderboardScoreCreate) check() error {
 	if _, ok := lsc.mutation.Score(); !ok {
 		return &ValidationError{Name: "score", err: errors.New(`db: missing required field "LeaderboardScore.score"`)}
 	}
-	if _, ok := lsc.mutation.AccountID(); !ok {
-		return &ValidationError{Name: "account_id", err: errors.New(`db: missing required field "LeaderboardScore.account_id"`)}
-	}
 	if _, ok := lsc.mutation.ReferenceID(); !ok {
 		return &ValidationError{Name: "reference_id", err: errors.New(`db: missing required field "LeaderboardScore.reference_id"`)}
 	}
@@ -230,10 +221,6 @@ func (lsc *LeaderboardScoreCreate) createSpec() (*LeaderboardScore, *sqlgraph.Cr
 		_spec.SetField(leaderboardscore.FieldScore, field.TypeFloat32, value)
 		_node.Score = value
 	}
-	if value, ok := lsc.mutation.AccountID(); ok {
-		_spec.SetField(leaderboardscore.FieldAccountID, field.TypeString, value)
-		_node.AccountID = value
-	}
 	if value, ok := lsc.mutation.ReferenceID(); ok {
 		_spec.SetField(leaderboardscore.FieldReferenceID, field.TypeString, value)
 		_node.ReferenceID = value
diff --git a/internal/database/ent/db/leaderboardscore_update.go b/internal/database/ent/db/leaderboardscore_update.go
index 0a232a53..47c52a8c 100644
--- a/internal/database/ent/db/leaderboardscore_update.go
+++ b/internal/database/ent/db/leaderboardscore_update.go
@@ -71,20 +71,6 @@ func (lsu *LeaderboardScoreUpdate) AddScore(f float32) *LeaderboardScoreUpdate {
 	return lsu
 }
 
-// SetAccountID sets the "account_id" field.
-func (lsu *LeaderboardScoreUpdate) SetAccountID(s string) *LeaderboardScoreUpdate {
-	lsu.mutation.SetAccountID(s)
-	return lsu
-}
-
-// SetNillableAccountID sets the "account_id" field if the given value is not nil.
-func (lsu *LeaderboardScoreUpdate) SetNillableAccountID(s *string) *LeaderboardScoreUpdate {
-	if s != nil {
-		lsu.SetAccountID(*s)
-	}
-	return lsu
-}
-
 // SetReferenceID sets the "reference_id" field.
 func (lsu *LeaderboardScoreUpdate) SetReferenceID(s string) *LeaderboardScoreUpdate {
 	lsu.mutation.SetReferenceID(s)
@@ -200,9 +186,6 @@ func (lsu *LeaderboardScoreUpdate) sqlSave(ctx context.Context) (n int, err erro
 	if value, ok := lsu.mutation.AddedScore(); ok {
 		_spec.AddField(leaderboardscore.FieldScore, field.TypeFloat32, value)
 	}
-	if value, ok := lsu.mutation.AccountID(); ok {
-		_spec.SetField(leaderboardscore.FieldAccountID, field.TypeString, value)
-	}
 	if value, ok := lsu.mutation.ReferenceID(); ok {
 		_spec.SetField(leaderboardscore.FieldReferenceID, field.TypeString, value)
 	}
@@ -275,20 +258,6 @@ func (lsuo *LeaderboardScoreUpdateOne) AddScore(f float32) *LeaderboardScoreUpda
 	return lsuo
 }
 
-// SetAccountID sets the "account_id" field.
-func (lsuo *LeaderboardScoreUpdateOne) SetAccountID(s string) *LeaderboardScoreUpdateOne {
-	lsuo.mutation.SetAccountID(s)
-	return lsuo
-}
-
-// SetNillableAccountID sets the "account_id" field if the given value is not nil.
-func (lsuo *LeaderboardScoreUpdateOne) SetNillableAccountID(s *string) *LeaderboardScoreUpdateOne {
-	if s != nil {
-		lsuo.SetAccountID(*s)
-	}
-	return lsuo
-}
-
 // SetReferenceID sets the "reference_id" field.
 func (lsuo *LeaderboardScoreUpdateOne) SetReferenceID(s string) *LeaderboardScoreUpdateOne {
 	lsuo.mutation.SetReferenceID(s)
@@ -434,9 +403,6 @@ func (lsuo *LeaderboardScoreUpdateOne) sqlSave(ctx context.Context) (_node *Lead
 	if value, ok := lsuo.mutation.AddedScore(); ok {
 		_spec.AddField(leaderboardscore.FieldScore, field.TypeFloat32, value)
 	}
-	if value, ok := lsuo.mutation.AccountID(); ok {
-		_spec.SetField(leaderboardscore.FieldAccountID, field.TypeString, value)
-	}
 	if value, ok := lsuo.mutation.ReferenceID(); ok {
 		_spec.SetField(leaderboardscore.FieldReferenceID, field.TypeString, value)
 	}
diff --git a/internal/database/ent/db/migrate/schema.go b/internal/database/ent/db/migrate/schema.go
index 1875f684..0f5b8889 100644
--- a/internal/database/ent/db/migrate/schema.go
+++ b/internal/database/ent/db/migrate/schema.go
@@ -383,7 +383,6 @@ var (
 		{Name: "updated_at", Type: field.TypeTime},
 		{Name: "type", Type: field.TypeEnum, Enums: []string{"hourly", "daily"}},
 		{Name: "score", Type: field.TypeFloat32},
-		{Name: "account_id", Type: field.TypeString},
 		{Name: "reference_id", Type: field.TypeString},
 		{Name: "leaderboard_id", Type: field.TypeString},
 		{Name: "meta", Type: field.TypeJSON},
@@ -404,25 +403,15 @@ var (
 				Unique:  false,
 				Columns: []*schema.Column{LeaderboardScoresColumns[1]},
 			},
-			{
-				Name:    "leaderboardscore_account_id",
-				Unique:  false,
-				Columns: []*schema.Column{LeaderboardScoresColumns[5]},
-			},
 			{
 				Name:    "leaderboardscore_reference_id",
 				Unique:  false,
-				Columns: []*schema.Column{LeaderboardScoresColumns[6]},
-			},
-			{
-				Name:    "leaderboardscore_leaderboard_id_type_account_id",
-				Unique:  false,
-				Columns: []*schema.Column{LeaderboardScoresColumns[7], LeaderboardScoresColumns[3], LeaderboardScoresColumns[5]},
+				Columns: []*schema.Column{LeaderboardScoresColumns[5]},
 			},
 			{
 				Name:    "leaderboardscore_leaderboard_id_type_reference_id",
 				Unique:  false,
-				Columns: []*schema.Column{LeaderboardScoresColumns[7], LeaderboardScoresColumns[3], LeaderboardScoresColumns[6]},
+				Columns: []*schema.Column{LeaderboardScoresColumns[6], LeaderboardScoresColumns[3], LeaderboardScoresColumns[5]},
 			},
 		},
 	}
diff --git a/internal/database/ent/db/mutation.go b/internal/database/ent/db/mutation.go
index 306d045d..c6ef8ee6 100644
--- a/internal/database/ent/db/mutation.go
+++ b/internal/database/ent/db/mutation.go
@@ -7064,7 +7064,6 @@ type LeaderboardScoreMutation struct {
 	_type          *models.ScoreType
 	score          *float32
 	addscore       *float32
-	account_id     *string
 	reference_id   *string
 	leaderboard_id *string
 	meta           *map[string]interface{}
@@ -7342,42 +7341,6 @@ func (m *LeaderboardScoreMutation) ResetScore() {
 	m.addscore = nil
 }
 
-// SetAccountID sets the "account_id" field.
-func (m *LeaderboardScoreMutation) SetAccountID(s string) {
-	m.account_id = &s
-}
-
-// AccountID returns the value of the "account_id" field in the mutation.
-func (m *LeaderboardScoreMutation) AccountID() (r string, exists bool) {
-	v := m.account_id
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
-// OldAccountID returns the old "account_id" field's value of the LeaderboardScore entity.
-// If the LeaderboardScore object wasn't provided to the builder, the object is fetched from the database.
-// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *LeaderboardScoreMutation) OldAccountID(ctx context.Context) (v string, err error) {
-	if !m.op.Is(OpUpdateOne) {
-		return v, errors.New("OldAccountID is only allowed on UpdateOne operations")
-	}
-	if m.id == nil || m.oldValue == nil {
-		return v, errors.New("OldAccountID requires an ID field in the mutation")
-	}
-	oldValue, err := m.oldValue(ctx)
-	if err != nil {
-		return v, fmt.Errorf("querying old value for OldAccountID: %w", err)
-	}
-	return oldValue.AccountID, nil
-}
-
-// ResetAccountID resets all changes to the "account_id" field.
-func (m *LeaderboardScoreMutation) ResetAccountID() {
-	m.account_id = nil
-}
-
 // SetReferenceID sets the "reference_id" field.
 func (m *LeaderboardScoreMutation) SetReferenceID(s string) {
 	m.reference_id = &s
@@ -7520,7 +7483,7 @@ func (m *LeaderboardScoreMutation) Type() string {
 // order to get all numeric fields that were incremented/decremented, call
 // AddedFields().
 func (m *LeaderboardScoreMutation) Fields() []string {
-	fields := make([]string, 0, 8)
+	fields := make([]string, 0, 7)
 	if m.created_at != nil {
 		fields = append(fields, leaderboardscore.FieldCreatedAt)
 	}
@@ -7533,9 +7496,6 @@ func (m *LeaderboardScoreMutation) Fields() []string {
 	if m.score != nil {
 		fields = append(fields, leaderboardscore.FieldScore)
 	}
-	if m.account_id != nil {
-		fields = append(fields, leaderboardscore.FieldAccountID)
-	}
 	if m.reference_id != nil {
 		fields = append(fields, leaderboardscore.FieldReferenceID)
 	}
@@ -7561,8 +7521,6 @@ func (m *LeaderboardScoreMutation) Field(name string) (ent.Value, bool) {
 		return m.GetType()
 	case leaderboardscore.FieldScore:
 		return m.Score()
-	case leaderboardscore.FieldAccountID:
-		return m.AccountID()
 	case leaderboardscore.FieldReferenceID:
 		return m.ReferenceID()
 	case leaderboardscore.FieldLeaderboardID:
@@ -7586,8 +7544,6 @@ func (m *LeaderboardScoreMutation) OldField(ctx context.Context, name string) (e
 		return m.OldType(ctx)
 	case leaderboardscore.FieldScore:
 		return m.OldScore(ctx)
-	case leaderboardscore.FieldAccountID:
-		return m.OldAccountID(ctx)
 	case leaderboardscore.FieldReferenceID:
 		return m.OldReferenceID(ctx)
 	case leaderboardscore.FieldLeaderboardID:
@@ -7631,13 +7587,6 @@ func (m *LeaderboardScoreMutation) SetField(name string, value ent.Value) error
 		}
 		m.SetScore(v)
 		return nil
-	case leaderboardscore.FieldAccountID:
-		v, ok := value.(string)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.SetAccountID(v)
-		return nil
 	case leaderboardscore.FieldReferenceID:
 		v, ok := value.(string)
 		if !ok {
@@ -7735,9 +7684,6 @@ func (m *LeaderboardScoreMutation) ResetField(name string) error {
 	case leaderboardscore.FieldScore:
 		m.ResetScore()
 		return nil
-	case leaderboardscore.FieldAccountID:
-		m.ResetAccountID()
-		return nil
 	case leaderboardscore.FieldReferenceID:
 		m.ResetReferenceID()
 		return nil
diff --git a/internal/database/ent/migrations/20240709213804.sql b/internal/database/ent/migrations/20240709213804.sql
new file mode 100644
index 00000000..d2490459
--- /dev/null
+++ b/internal/database/ent/migrations/20240709213804.sql
@@ -0,0 +1,20 @@
+-- Disable the enforcement of foreign-keys constraints
+PRAGMA foreign_keys = off;
+-- Create "new_leaderboard_scores" table
+CREATE TABLE `new_leaderboard_scores` (`id` text NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `type` text NOT NULL, `score` real NOT NULL, `reference_id` text NOT NULL, `leaderboard_id` text NOT NULL, `meta` json NOT NULL, PRIMARY KEY (`id`));
+-- Copy rows from old table "leaderboard_scores" to new temporary table "new_leaderboard_scores"
+INSERT INTO `new_leaderboard_scores` (`id`, `created_at`, `updated_at`, `type`, `score`, `reference_id`, `leaderboard_id`, `meta`) SELECT `id`, `created_at`, `updated_at`, `type`, `score`, `reference_id`, `leaderboard_id`, `meta` FROM `leaderboard_scores`;
+-- Drop "leaderboard_scores" table after copying rows
+DROP TABLE `leaderboard_scores`;
+-- Rename temporary table "new_leaderboard_scores" to "leaderboard_scores"
+ALTER TABLE `new_leaderboard_scores` RENAME TO `leaderboard_scores`;
+-- Create index "leaderboardscore_id" to table: "leaderboard_scores"
+CREATE INDEX `leaderboardscore_id` ON `leaderboard_scores` (`id`);
+-- Create index "leaderboardscore_created_at" to table: "leaderboard_scores"
+CREATE INDEX `leaderboardscore_created_at` ON `leaderboard_scores` (`created_at`);
+-- Create index "leaderboardscore_reference_id" to table: "leaderboard_scores"
+CREATE INDEX `leaderboardscore_reference_id` ON `leaderboard_scores` (`reference_id`);
+-- Create index "leaderboardscore_leaderboard_id_type_reference_id" to table: "leaderboard_scores"
+CREATE INDEX `leaderboardscore_leaderboard_id_type_reference_id` ON `leaderboard_scores` (`leaderboard_id`, `type`, `reference_id`);
+-- Enable back the enforcement of foreign-keys constraints
+PRAGMA foreign_keys = on;
diff --git a/internal/database/ent/migrations/atlas.sum b/internal/database/ent/migrations/atlas.sum
index 4cd4e85f..ba69ee30 100644
--- a/internal/database/ent/migrations/atlas.sum
+++ b/internal/database/ent/migrations/atlas.sum
@@ -1,2 +1,3 @@
-h1:a45dq6iNrjJqg7s6+pBhPSNKDBLRaDhx99WM4knQS2o=
+h1:7B9NoTmspiv10N3sx9FWlA1dQyccMUgRW0uT9FDhx0k=
 20240709203105.sql h1:zmiEUhVtnH3IM1/S7iyJpJ4PwqhcZw50OcNYMcjTwrE=
+20240709213804.sql h1:QE6wE3hSW0DpgYCPzwPw7BHWi0NGkcE7qRnJJZIXI6E=
diff --git a/internal/database/ent/schema/leaderboard_score.go b/internal/database/ent/schema/leaderboard_score.go
index cbf90223..8acda2f6 100644
--- a/internal/database/ent/schema/leaderboard_score.go
+++ b/internal/database/ent/schema/leaderboard_score.go
@@ -17,7 +17,6 @@ func (LeaderboardScore) Fields() []ent.Field {
 		field.Enum("type").
 			GoType(models.ScoreType("")),
 		field.Float32("score"),
-		field.String("account_id"),
 		field.String("reference_id"),
 		field.String("leaderboard_id"),
 		field.JSON("meta", map[string]any{}),
@@ -32,9 +31,7 @@ func (LeaderboardScore) Indexes() []ent.Index {
 	return []ent.Index{
 		index.Fields("id"),
 		index.Fields("created_at"),
-		index.Fields("account_id"),
 		index.Fields("reference_id"),
-		index.Fields("leaderboard_id", "type", "account_id"),
 		index.Fields("leaderboard_id", "type", "reference_id"),
 	}
 }
diff --git a/internal/database/leaderboards.go b/internal/database/leaderboards.go
index 96067017..1974cf8d 100644
--- a/internal/database/leaderboards.go
+++ b/internal/database/leaderboards.go
@@ -16,7 +16,6 @@ func toScore(r *db.LeaderboardScore) models.LeaderboardScore {
 		Type:          r.Type,
 		CreatedAt:     r.CreatedAt,
 		UpdatedAt:     r.UpdatedAt,
-		AccountID:     r.AccountID,
 		ReferenceID:   r.ReferenceID,
 		LeaderboardID: r.LeaderboardID,
 		Score:         r.Score,
@@ -82,7 +81,7 @@ func (c *client) GetLeaderboardScores(ctx context.Context, leaderboardID string,
 	}
 
 	selectFields := leaderboardscore.Columns
-	if fields := query.selectFields(leaderboardscore.FieldAccountID); fields != nil {
+	if fields := query.selectFields(leaderboardscore.FieldReferenceID); fields != nil {
 		selectFields = fields
 	}
 
@@ -91,7 +90,7 @@ func (c *client) GetLeaderboardScores(ctx context.Context, leaderboardID string,
 	q = q.OrderBy(orderBy)
 
 	innerQueryString, queryArgs := q.Query()
-	queryString, _ := sql.Select(selectFields...).FromExpr(wrap(innerQueryString)).GroupBy(leaderboardscore.FieldAccountID).Query()
+	queryString, _ := sql.Select(selectFields...).FromExpr(wrap(innerQueryString)).GroupBy(leaderboardscore.FieldReferenceID).Query()
 	rows, err := c.db.LeaderboardScore.QueryContext(ctx, queryString, queryArgs...)
 	if err != nil {
 		return nil, err
diff --git a/internal/database/models/leaderboard_score.go b/internal/database/models/leaderboard_score.go
index 2489ad72..2a0564b3 100644
--- a/internal/database/models/leaderboard_score.go
+++ b/internal/database/models/leaderboard_score.go
@@ -32,7 +32,6 @@ type LeaderboardScore struct {
 	UpdatedAt time.Time
 
 	Type          ScoreType
-	AccountID     string
 	ReferenceID   string
 	LeaderboardID string
 
diff --git a/internal/logic/leaderboards.go b/internal/logic/leaderboards.go
index c984026d..76a17f38 100644
--- a/internal/logic/leaderboards.go
+++ b/internal/logic/leaderboards.go
@@ -35,7 +35,7 @@ func RecordCurrentAchievementsLeaderboards(ctx context.Context, wgClient wargami
 		}
 		leaderboardMap := make(map[string]models.LeaderboardScore)
 		for _, score := range leaderboard {
-			leaderboardMap[score.AccountID] = score
+			leaderboardMap[score.ReferenceID] = score
 		}
 		playerLeaderboard = retry.DataWithErr[map[string]models.LeaderboardScore]{Data: leaderboardMap}
 	}()
@@ -112,7 +112,6 @@ func RecordCurrentAchievementsLeaderboards(ctx context.Context, wgClient wargami
 
 		playerScore := models.LeaderboardScore{
 			Type:          scoreType,
-			AccountID:     id,
 			ReferenceID:   id,
 			LeaderboardID: models.LeaderboardsMasteryWeightedPlayers,
 			Score:         masteryAchievementsScore(achievements),
diff --git a/main.go b/main.go
index 6c878f3b..75a4408f 100644
--- a/main.go
+++ b/main.go
@@ -71,8 +71,6 @@ func main() {
 		alertClient.Reader(pr, zerolog.ErrorLevel)
 	}
 
-	log.Error().Msg("test")
-
 	loadStaticAssets(static)
 	db, err := newDatabaseClientFromEnv()
 	if err != nil {

From 5e938efea737d5fcf5ecfe00c2391fabe88bac7e Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Tue, 9 Jul 2024 17:42:29 -0400
Subject: [PATCH 332/341] ignoring a common error

---
 internal/logic/leaderboards.go | 3 ++-
 internal/logic/snapshots.go    | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/internal/logic/leaderboards.go b/internal/logic/leaderboards.go
index 76a17f38..882d69c6 100644
--- a/internal/logic/leaderboards.go
+++ b/internal/logic/leaderboards.go
@@ -92,7 +92,8 @@ func RecordCurrentAchievementsLeaderboards(ctx context.Context, wgClient wargami
 	if currentAchievements.Err != nil {
 		return nil, currentAchievements.Err
 	}
-	if accountClans.Err != nil { // this error is not critical, but it will delay the leaderboard update for clans
+	// this error is not critical, but it will delay the leaderboard update for clans
+	if accountClans.Err != nil && accountClans.Err.Error() != "SOURCE_NOT_AVAILABLE" {
 		log.Err(accountClans.Err).Msg("failed to get account clans")
 	}
 
diff --git a/internal/logic/snapshots.go b/internal/logic/snapshots.go
index f586bf80..198e854c 100644
--- a/internal/logic/snapshots.go
+++ b/internal/logic/snapshots.go
@@ -113,7 +113,7 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 		defer group.Done()
 		// clans are optional-ish
 		data, err := wgClient.BatchAccountClan(ctx, realm, accountsNeedAnUpdate)
-		if err != nil {
+		if err != nil && err.Error() != "SOURCE_NOT_AVAILABLE" {
 			log.Err(err).Msg("failed to get batch account clans")
 		}
 		clans = data

From 60118dede6989ba4b937235df1f7eed29a6572c0 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Wed, 10 Jul 2024 10:28:14 -0400
Subject: [PATCH 333/341] removed achievement snapshots

---
 internal/database/cleanup.go                  |   6 -
 internal/database/client.go                   |   3 -
 internal/database/ent/db/account.go           |  22 +-
 internal/database/ent/db/account/account.go   |  30 -
 internal/database/ent/db/account/where.go     |  23 -
 internal/database/ent/db/account_create.go    |  32 -
 internal/database/ent/db/account_query.go     | 110 +-
 internal/database/ent/db/account_update.go    | 163 ---
 .../database/ent/db/achievementssnapshot.go   | 219 ----
 .../achievementssnapshot.go                   | 151 ---
 .../ent/db/achievementssnapshot/where.go      | 455 --------
 .../ent/db/achievementssnapshot_create.go     | 367 -------
 .../ent/db/achievementssnapshot_delete.go     |  88 --
 .../ent/db/achievementssnapshot_query.go      | 627 -----------
 .../ent/db/achievementssnapshot_update.go     | 462 ---------
 internal/database/ent/db/client.go            | 281 +----
 internal/database/ent/db/ent.go               |  36 +-
 internal/database/ent/db/expose.go            |  13 -
 internal/database/ent/db/hook/hook.go         |  12 -
 internal/database/ent/db/migrate/schema.go    |  50 -
 internal/database/ent/db/mutation.go          | 970 +-----------------
 .../database/ent/db/predicate/predicate.go    |   3 -
 internal/database/ent/db/runtime.go           |  25 -
 internal/database/ent/db/tx.go                |   3 -
 .../ent/migrations/20240710142748.sql         |   6 +
 internal/database/ent/migrations/atlas.sum    |   3 +-
 internal/database/ent/schema/account.go       |   1 -
 .../ent/schema/achievements_snapshot.go       |  42 -
 internal/database/snapshots.go                |  89 --
 internal/logic/snapshots.go                   |  90 --
 30 files changed, 141 insertions(+), 4241 deletions(-)
 delete mode 100644 internal/database/ent/db/achievementssnapshot.go
 delete mode 100644 internal/database/ent/db/achievementssnapshot/achievementssnapshot.go
 delete mode 100644 internal/database/ent/db/achievementssnapshot/where.go
 delete mode 100644 internal/database/ent/db/achievementssnapshot_create.go
 delete mode 100644 internal/database/ent/db/achievementssnapshot_delete.go
 delete mode 100644 internal/database/ent/db/achievementssnapshot_query.go
 delete mode 100644 internal/database/ent/db/achievementssnapshot_update.go
 create mode 100644 internal/database/ent/migrations/20240710142748.sql
 delete mode 100644 internal/database/ent/schema/achievements_snapshot.go

diff --git a/internal/database/cleanup.go b/internal/database/cleanup.go
index ddc680b1..29ac2036 100644
--- a/internal/database/cleanup.go
+++ b/internal/database/cleanup.go
@@ -6,7 +6,6 @@ import (
 
 	"github.com/cufee/aftermath/internal/database/ent/db"
 	"github.com/cufee/aftermath/internal/database/ent/db/accountsnapshot"
-	"github.com/cufee/aftermath/internal/database/ent/db/achievementssnapshot"
 	"github.com/cufee/aftermath/internal/database/ent/db/crontask"
 	"github.com/cufee/aftermath/internal/database/ent/db/discordinteraction"
 	"github.com/cufee/aftermath/internal/database/ent/db/vehiclesnapshot"
@@ -39,10 +38,5 @@ func (c *client) DeleteExpiredSnapshots(ctx context.Context, expiration time.Tim
 		return err
 	}
 
-	_, err = c.db.AchievementsSnapshot.Delete().Where(achievementssnapshot.CreatedAtLT(expiration)).Exec(ctx)
-	if err != nil {
-		return err
-	}
-
 	return nil
 }
diff --git a/internal/database/client.go b/internal/database/client.go
index 053a5fef..969f26de 100644
--- a/internal/database/client.go
+++ b/internal/database/client.go
@@ -57,16 +57,13 @@ type UsersClient interface {
 
 type SnapshotsClient interface {
 	GetAccountSnapshots(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...Query) ([]models.AccountSnapshot, error)
-	GetAchievementSnapshots(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...Query) ([]models.AchievementsSnapshot, error)
 	GetVehicleSnapshots(ctx context.Context, accountID string, vehicleIDs []string, kind models.SnapshotType, options ...Query) ([]models.VehicleSnapshot, error)
 
 	GetAccountLastBattleTimes(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...Query) (map[string]time.Time, error)
 	GetVehicleLastBattleTimes(ctx context.Context, accountID string, vehicleIDs []string, kind models.SnapshotType, options ...Query) (map[string]time.Time, error)
-	// last battle times for achievements would be equivalent to account/vehicle ones
 
 	CreateAccountSnapshots(ctx context.Context, snapshots ...models.AccountSnapshot) (map[string]error, error)
 	CreateAccountVehicleSnapshots(ctx context.Context, accountID string, snapshots ...models.VehicleSnapshot) (map[string]error, error)
-	CreateAccountAchievementSnapshots(ctx context.Context, accountID string, snapshots ...models.AchievementsSnapshot) (map[string]error, error)
 
 	DeleteExpiredSnapshots(ctx context.Context, expiration time.Time) error
 }
diff --git a/internal/database/ent/db/account.go b/internal/database/ent/db/account.go
index 4412ee60..eac005fd 100644
--- a/internal/database/ent/db/account.go
+++ b/internal/database/ent/db/account.go
@@ -44,15 +44,13 @@ type Account struct {
 type AccountEdges struct {
 	// Clan holds the value of the clan edge.
 	Clan *Clan `json:"clan,omitempty"`
-	// AchievementSnapshots holds the value of the achievement_snapshots edge.
-	AchievementSnapshots []*AchievementsSnapshot `json:"achievement_snapshots,omitempty"`
 	// VehicleSnapshots holds the value of the vehicle_snapshots edge.
 	VehicleSnapshots []*VehicleSnapshot `json:"vehicle_snapshots,omitempty"`
 	// AccountSnapshots holds the value of the account_snapshots edge.
 	AccountSnapshots []*AccountSnapshot `json:"account_snapshots,omitempty"`
 	// loadedTypes holds the information for reporting if a
 	// type was loaded (or requested) in eager-loading or not.
-	loadedTypes [4]bool
+	loadedTypes [3]bool
 }
 
 // ClanOrErr returns the Clan value or an error if the edge
@@ -66,19 +64,10 @@ func (e AccountEdges) ClanOrErr() (*Clan, error) {
 	return nil, &NotLoadedError{edge: "clan"}
 }
 
-// AchievementSnapshotsOrErr returns the AchievementSnapshots value or an error if the edge
-// was not loaded in eager-loading.
-func (e AccountEdges) AchievementSnapshotsOrErr() ([]*AchievementsSnapshot, error) {
-	if e.loadedTypes[1] {
-		return e.AchievementSnapshots, nil
-	}
-	return nil, &NotLoadedError{edge: "achievement_snapshots"}
-}
-
 // VehicleSnapshotsOrErr returns the VehicleSnapshots value or an error if the edge
 // was not loaded in eager-loading.
 func (e AccountEdges) VehicleSnapshotsOrErr() ([]*VehicleSnapshot, error) {
-	if e.loadedTypes[2] {
+	if e.loadedTypes[1] {
 		return e.VehicleSnapshots, nil
 	}
 	return nil, &NotLoadedError{edge: "vehicle_snapshots"}
@@ -87,7 +76,7 @@ func (e AccountEdges) VehicleSnapshotsOrErr() ([]*VehicleSnapshot, error) {
 // AccountSnapshotsOrErr returns the AccountSnapshots value or an error if the edge
 // was not loaded in eager-loading.
 func (e AccountEdges) AccountSnapshotsOrErr() ([]*AccountSnapshot, error) {
-	if e.loadedTypes[3] {
+	if e.loadedTypes[2] {
 		return e.AccountSnapshots, nil
 	}
 	return nil, &NotLoadedError{edge: "account_snapshots"}
@@ -191,11 +180,6 @@ func (a *Account) QueryClan() *ClanQuery {
 	return NewAccountClient(a.config).QueryClan(a)
 }
 
-// QueryAchievementSnapshots queries the "achievement_snapshots" edge of the Account entity.
-func (a *Account) QueryAchievementSnapshots() *AchievementsSnapshotQuery {
-	return NewAccountClient(a.config).QueryAchievementSnapshots(a)
-}
-
 // QueryVehicleSnapshots queries the "vehicle_snapshots" edge of the Account entity.
 func (a *Account) QueryVehicleSnapshots() *VehicleSnapshotQuery {
 	return NewAccountClient(a.config).QueryVehicleSnapshots(a)
diff --git a/internal/database/ent/db/account/account.go b/internal/database/ent/db/account/account.go
index 7be72dac..08eb62c4 100644
--- a/internal/database/ent/db/account/account.go
+++ b/internal/database/ent/db/account/account.go
@@ -32,8 +32,6 @@ const (
 	FieldClanID = "clan_id"
 	// EdgeClan holds the string denoting the clan edge name in mutations.
 	EdgeClan = "clan"
-	// EdgeAchievementSnapshots holds the string denoting the achievement_snapshots edge name in mutations.
-	EdgeAchievementSnapshots = "achievement_snapshots"
 	// EdgeVehicleSnapshots holds the string denoting the vehicle_snapshots edge name in mutations.
 	EdgeVehicleSnapshots = "vehicle_snapshots"
 	// EdgeAccountSnapshots holds the string denoting the account_snapshots edge name in mutations.
@@ -47,13 +45,6 @@ const (
 	ClanInverseTable = "clans"
 	// ClanColumn is the table column denoting the clan relation/edge.
 	ClanColumn = "clan_id"
-	// AchievementSnapshotsTable is the table that holds the achievement_snapshots relation/edge.
-	AchievementSnapshotsTable = "achievements_snapshots"
-	// AchievementSnapshotsInverseTable is the table name for the AchievementsSnapshot entity.
-	// It exists in this package in order to avoid circular dependency with the "achievementssnapshot" package.
-	AchievementSnapshotsInverseTable = "achievements_snapshots"
-	// AchievementSnapshotsColumn is the table column denoting the achievement_snapshots relation/edge.
-	AchievementSnapshotsColumn = "account_id"
 	// VehicleSnapshotsTable is the table that holds the vehicle_snapshots relation/edge.
 	VehicleSnapshotsTable = "vehicle_snapshots"
 	// VehicleSnapshotsInverseTable is the table name for the VehicleSnapshot entity.
@@ -163,20 +154,6 @@ func ByClanField(field string, opts ...sql.OrderTermOption) OrderOption {
 	}
 }
 
-// ByAchievementSnapshotsCount orders the results by achievement_snapshots count.
-func ByAchievementSnapshotsCount(opts ...sql.OrderTermOption) OrderOption {
-	return func(s *sql.Selector) {
-		sqlgraph.OrderByNeighborsCount(s, newAchievementSnapshotsStep(), opts...)
-	}
-}
-
-// ByAchievementSnapshots orders the results by achievement_snapshots terms.
-func ByAchievementSnapshots(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
-	return func(s *sql.Selector) {
-		sqlgraph.OrderByNeighborTerms(s, newAchievementSnapshotsStep(), append([]sql.OrderTerm{term}, terms...)...)
-	}
-}
-
 // ByVehicleSnapshotsCount orders the results by vehicle_snapshots count.
 func ByVehicleSnapshotsCount(opts ...sql.OrderTermOption) OrderOption {
 	return func(s *sql.Selector) {
@@ -211,13 +188,6 @@ func newClanStep() *sqlgraph.Step {
 		sqlgraph.Edge(sqlgraph.M2O, true, ClanTable, ClanColumn),
 	)
 }
-func newAchievementSnapshotsStep() *sqlgraph.Step {
-	return sqlgraph.NewStep(
-		sqlgraph.From(Table, FieldID),
-		sqlgraph.To(AchievementSnapshotsInverseTable, FieldID),
-		sqlgraph.Edge(sqlgraph.O2M, false, AchievementSnapshotsTable, AchievementSnapshotsColumn),
-	)
-}
 func newVehicleSnapshotsStep() *sqlgraph.Step {
 	return sqlgraph.NewStep(
 		sqlgraph.From(Table, FieldID),
diff --git a/internal/database/ent/db/account/where.go b/internal/database/ent/db/account/where.go
index 0c513cd9..39ce7127 100644
--- a/internal/database/ent/db/account/where.go
+++ b/internal/database/ent/db/account/where.go
@@ -503,29 +503,6 @@ func HasClanWith(preds ...predicate.Clan) predicate.Account {
 	})
 }
 
-// HasAchievementSnapshots applies the HasEdge predicate on the "achievement_snapshots" edge.
-func HasAchievementSnapshots() predicate.Account {
-	return predicate.Account(func(s *sql.Selector) {
-		step := sqlgraph.NewStep(
-			sqlgraph.From(Table, FieldID),
-			sqlgraph.Edge(sqlgraph.O2M, false, AchievementSnapshotsTable, AchievementSnapshotsColumn),
-		)
-		sqlgraph.HasNeighbors(s, step)
-	})
-}
-
-// HasAchievementSnapshotsWith applies the HasEdge predicate on the "achievement_snapshots" edge with a given conditions (other predicates).
-func HasAchievementSnapshotsWith(preds ...predicate.AchievementsSnapshot) predicate.Account {
-	return predicate.Account(func(s *sql.Selector) {
-		step := newAchievementSnapshotsStep()
-		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
-			for _, p := range preds {
-				p(s)
-			}
-		})
-	})
-}
-
 // HasVehicleSnapshots applies the HasEdge predicate on the "vehicle_snapshots" edge.
 func HasVehicleSnapshots() predicate.Account {
 	return predicate.Account(func(s *sql.Selector) {
diff --git a/internal/database/ent/db/account_create.go b/internal/database/ent/db/account_create.go
index 9ed86957..6fd7322a 100644
--- a/internal/database/ent/db/account_create.go
+++ b/internal/database/ent/db/account_create.go
@@ -12,7 +12,6 @@ import (
 	"entgo.io/ent/schema/field"
 	"github.com/cufee/aftermath/internal/database/ent/db/account"
 	"github.com/cufee/aftermath/internal/database/ent/db/accountsnapshot"
-	"github.com/cufee/aftermath/internal/database/ent/db/achievementssnapshot"
 	"github.com/cufee/aftermath/internal/database/ent/db/clan"
 	"github.com/cufee/aftermath/internal/database/ent/db/vehiclesnapshot"
 )
@@ -115,21 +114,6 @@ func (ac *AccountCreate) SetClan(c *Clan) *AccountCreate {
 	return ac.SetClanID(c.ID)
 }
 
-// AddAchievementSnapshotIDs adds the "achievement_snapshots" edge to the AchievementsSnapshot entity by IDs.
-func (ac *AccountCreate) AddAchievementSnapshotIDs(ids ...string) *AccountCreate {
-	ac.mutation.AddAchievementSnapshotIDs(ids...)
-	return ac
-}
-
-// AddAchievementSnapshots adds the "achievement_snapshots" edges to the AchievementsSnapshot entity.
-func (ac *AccountCreate) AddAchievementSnapshots(a ...*AchievementsSnapshot) *AccountCreate {
-	ids := make([]string, len(a))
-	for i := range a {
-		ids[i] = a[i].ID
-	}
-	return ac.AddAchievementSnapshotIDs(ids...)
-}
-
 // AddVehicleSnapshotIDs adds the "vehicle_snapshots" edge to the VehicleSnapshot entity by IDs.
 func (ac *AccountCreate) AddVehicleSnapshotIDs(ids ...string) *AccountCreate {
 	ac.mutation.AddVehicleSnapshotIDs(ids...)
@@ -322,22 +306,6 @@ func (ac *AccountCreate) createSpec() (*Account, *sqlgraph.CreateSpec) {
 		_node.ClanID = nodes[0]
 		_spec.Edges = append(_spec.Edges, edge)
 	}
-	if nodes := ac.mutation.AchievementSnapshotsIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   account.AchievementSnapshotsTable,
-			Columns: []string{account.AchievementSnapshotsColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges = append(_spec.Edges, edge)
-	}
 	if nodes := ac.mutation.VehicleSnapshotsIDs(); len(nodes) > 0 {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,
diff --git a/internal/database/ent/db/account_query.go b/internal/database/ent/db/account_query.go
index 38604e4f..8a3e6a5e 100644
--- a/internal/database/ent/db/account_query.go
+++ b/internal/database/ent/db/account_query.go
@@ -13,7 +13,6 @@ import (
 	"entgo.io/ent/schema/field"
 	"github.com/cufee/aftermath/internal/database/ent/db/account"
 	"github.com/cufee/aftermath/internal/database/ent/db/accountsnapshot"
-	"github.com/cufee/aftermath/internal/database/ent/db/achievementssnapshot"
 	"github.com/cufee/aftermath/internal/database/ent/db/clan"
 	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
 	"github.com/cufee/aftermath/internal/database/ent/db/vehiclesnapshot"
@@ -22,15 +21,14 @@ import (
 // AccountQuery is the builder for querying Account entities.
 type AccountQuery struct {
 	config
-	ctx                      *QueryContext
-	order                    []account.OrderOption
-	inters                   []Interceptor
-	predicates               []predicate.Account
-	withClan                 *ClanQuery
-	withAchievementSnapshots *AchievementsSnapshotQuery
-	withVehicleSnapshots     *VehicleSnapshotQuery
-	withAccountSnapshots     *AccountSnapshotQuery
-	modifiers                []func(*sql.Selector)
+	ctx                  *QueryContext
+	order                []account.OrderOption
+	inters               []Interceptor
+	predicates           []predicate.Account
+	withClan             *ClanQuery
+	withVehicleSnapshots *VehicleSnapshotQuery
+	withAccountSnapshots *AccountSnapshotQuery
+	modifiers            []func(*sql.Selector)
 	// intermediate query (i.e. traversal path).
 	sql  *sql.Selector
 	path func(context.Context) (*sql.Selector, error)
@@ -89,28 +87,6 @@ func (aq *AccountQuery) QueryClan() *ClanQuery {
 	return query
 }
 
-// QueryAchievementSnapshots chains the current query on the "achievement_snapshots" edge.
-func (aq *AccountQuery) QueryAchievementSnapshots() *AchievementsSnapshotQuery {
-	query := (&AchievementsSnapshotClient{config: aq.config}).Query()
-	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
-		if err := aq.prepareQuery(ctx); err != nil {
-			return nil, err
-		}
-		selector := aq.sqlQuery(ctx)
-		if err := selector.Err(); err != nil {
-			return nil, err
-		}
-		step := sqlgraph.NewStep(
-			sqlgraph.From(account.Table, account.FieldID, selector),
-			sqlgraph.To(achievementssnapshot.Table, achievementssnapshot.FieldID),
-			sqlgraph.Edge(sqlgraph.O2M, false, account.AchievementSnapshotsTable, account.AchievementSnapshotsColumn),
-		)
-		fromU = sqlgraph.SetNeighbors(aq.driver.Dialect(), step)
-		return fromU, nil
-	}
-	return query
-}
-
 // QueryVehicleSnapshots chains the current query on the "vehicle_snapshots" edge.
 func (aq *AccountQuery) QueryVehicleSnapshots() *VehicleSnapshotQuery {
 	query := (&VehicleSnapshotClient{config: aq.config}).Query()
@@ -342,15 +318,14 @@ func (aq *AccountQuery) Clone() *AccountQuery {
 		return nil
 	}
 	return &AccountQuery{
-		config:                   aq.config,
-		ctx:                      aq.ctx.Clone(),
-		order:                    append([]account.OrderOption{}, aq.order...),
-		inters:                   append([]Interceptor{}, aq.inters...),
-		predicates:               append([]predicate.Account{}, aq.predicates...),
-		withClan:                 aq.withClan.Clone(),
-		withAchievementSnapshots: aq.withAchievementSnapshots.Clone(),
-		withVehicleSnapshots:     aq.withVehicleSnapshots.Clone(),
-		withAccountSnapshots:     aq.withAccountSnapshots.Clone(),
+		config:               aq.config,
+		ctx:                  aq.ctx.Clone(),
+		order:                append([]account.OrderOption{}, aq.order...),
+		inters:               append([]Interceptor{}, aq.inters...),
+		predicates:           append([]predicate.Account{}, aq.predicates...),
+		withClan:             aq.withClan.Clone(),
+		withVehicleSnapshots: aq.withVehicleSnapshots.Clone(),
+		withAccountSnapshots: aq.withAccountSnapshots.Clone(),
 		// clone intermediate query.
 		sql:  aq.sql.Clone(),
 		path: aq.path,
@@ -368,17 +343,6 @@ func (aq *AccountQuery) WithClan(opts ...func(*ClanQuery)) *AccountQuery {
 	return aq
 }
 
-// WithAchievementSnapshots tells the query-builder to eager-load the nodes that are connected to
-// the "achievement_snapshots" edge. The optional arguments are used to configure the query builder of the edge.
-func (aq *AccountQuery) WithAchievementSnapshots(opts ...func(*AchievementsSnapshotQuery)) *AccountQuery {
-	query := (&AchievementsSnapshotClient{config: aq.config}).Query()
-	for _, opt := range opts {
-		opt(query)
-	}
-	aq.withAchievementSnapshots = query
-	return aq
-}
-
 // WithVehicleSnapshots tells the query-builder to eager-load the nodes that are connected to
 // the "vehicle_snapshots" edge. The optional arguments are used to configure the query builder of the edge.
 func (aq *AccountQuery) WithVehicleSnapshots(opts ...func(*VehicleSnapshotQuery)) *AccountQuery {
@@ -479,9 +443,8 @@ func (aq *AccountQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Acco
 	var (
 		nodes       = []*Account{}
 		_spec       = aq.querySpec()
-		loadedTypes = [4]bool{
+		loadedTypes = [3]bool{
 			aq.withClan != nil,
-			aq.withAchievementSnapshots != nil,
 			aq.withVehicleSnapshots != nil,
 			aq.withAccountSnapshots != nil,
 		}
@@ -513,15 +476,6 @@ func (aq *AccountQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Acco
 			return nil, err
 		}
 	}
-	if query := aq.withAchievementSnapshots; query != nil {
-		if err := aq.loadAchievementSnapshots(ctx, query, nodes,
-			func(n *Account) { n.Edges.AchievementSnapshots = []*AchievementsSnapshot{} },
-			func(n *Account, e *AchievementsSnapshot) {
-				n.Edges.AchievementSnapshots = append(n.Edges.AchievementSnapshots, e)
-			}); err != nil {
-			return nil, err
-		}
-	}
 	if query := aq.withVehicleSnapshots; query != nil {
 		if err := aq.loadVehicleSnapshots(ctx, query, nodes,
 			func(n *Account) { n.Edges.VehicleSnapshots = []*VehicleSnapshot{} },
@@ -568,36 +522,6 @@ func (aq *AccountQuery) loadClan(ctx context.Context, query *ClanQuery, nodes []
 	}
 	return nil
 }
-func (aq *AccountQuery) loadAchievementSnapshots(ctx context.Context, query *AchievementsSnapshotQuery, nodes []*Account, init func(*Account), assign func(*Account, *AchievementsSnapshot)) error {
-	fks := make([]driver.Value, 0, len(nodes))
-	nodeids := make(map[string]*Account)
-	for i := range nodes {
-		fks = append(fks, nodes[i].ID)
-		nodeids[nodes[i].ID] = nodes[i]
-		if init != nil {
-			init(nodes[i])
-		}
-	}
-	if len(query.ctx.Fields) > 0 {
-		query.ctx.AppendFieldOnce(achievementssnapshot.FieldAccountID)
-	}
-	query.Where(predicate.AchievementsSnapshot(func(s *sql.Selector) {
-		s.Where(sql.InValues(s.C(account.AchievementSnapshotsColumn), fks...))
-	}))
-	neighbors, err := query.All(ctx)
-	if err != nil {
-		return err
-	}
-	for _, n := range neighbors {
-		fk := n.AccountID
-		node, ok := nodeids[fk]
-		if !ok {
-			return fmt.Errorf(`unexpected referenced foreign-key "account_id" returned %v for node %v`, fk, n.ID)
-		}
-		assign(node, n)
-	}
-	return nil
-}
 func (aq *AccountQuery) loadVehicleSnapshots(ctx context.Context, query *VehicleSnapshotQuery, nodes []*Account, init func(*Account), assign func(*Account, *VehicleSnapshot)) error {
 	fks := make([]driver.Value, 0, len(nodes))
 	nodeids := make(map[string]*Account)
diff --git a/internal/database/ent/db/account_update.go b/internal/database/ent/db/account_update.go
index af4a3d52..a779a6f9 100644
--- a/internal/database/ent/db/account_update.go
+++ b/internal/database/ent/db/account_update.go
@@ -13,7 +13,6 @@ import (
 	"entgo.io/ent/schema/field"
 	"github.com/cufee/aftermath/internal/database/ent/db/account"
 	"github.com/cufee/aftermath/internal/database/ent/db/accountsnapshot"
-	"github.com/cufee/aftermath/internal/database/ent/db/achievementssnapshot"
 	"github.com/cufee/aftermath/internal/database/ent/db/clan"
 	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
 	"github.com/cufee/aftermath/internal/database/ent/db/vehiclesnapshot"
@@ -134,21 +133,6 @@ func (au *AccountUpdate) SetClan(c *Clan) *AccountUpdate {
 	return au.SetClanID(c.ID)
 }
 
-// AddAchievementSnapshotIDs adds the "achievement_snapshots" edge to the AchievementsSnapshot entity by IDs.
-func (au *AccountUpdate) AddAchievementSnapshotIDs(ids ...string) *AccountUpdate {
-	au.mutation.AddAchievementSnapshotIDs(ids...)
-	return au
-}
-
-// AddAchievementSnapshots adds the "achievement_snapshots" edges to the AchievementsSnapshot entity.
-func (au *AccountUpdate) AddAchievementSnapshots(a ...*AchievementsSnapshot) *AccountUpdate {
-	ids := make([]string, len(a))
-	for i := range a {
-		ids[i] = a[i].ID
-	}
-	return au.AddAchievementSnapshotIDs(ids...)
-}
-
 // AddVehicleSnapshotIDs adds the "vehicle_snapshots" edge to the VehicleSnapshot entity by IDs.
 func (au *AccountUpdate) AddVehicleSnapshotIDs(ids ...string) *AccountUpdate {
 	au.mutation.AddVehicleSnapshotIDs(ids...)
@@ -190,27 +174,6 @@ func (au *AccountUpdate) ClearClan() *AccountUpdate {
 	return au
 }
 
-// ClearAchievementSnapshots clears all "achievement_snapshots" edges to the AchievementsSnapshot entity.
-func (au *AccountUpdate) ClearAchievementSnapshots() *AccountUpdate {
-	au.mutation.ClearAchievementSnapshots()
-	return au
-}
-
-// RemoveAchievementSnapshotIDs removes the "achievement_snapshots" edge to AchievementsSnapshot entities by IDs.
-func (au *AccountUpdate) RemoveAchievementSnapshotIDs(ids ...string) *AccountUpdate {
-	au.mutation.RemoveAchievementSnapshotIDs(ids...)
-	return au
-}
-
-// RemoveAchievementSnapshots removes "achievement_snapshots" edges to AchievementsSnapshot entities.
-func (au *AccountUpdate) RemoveAchievementSnapshots(a ...*AchievementsSnapshot) *AccountUpdate {
-	ids := make([]string, len(a))
-	for i := range a {
-		ids[i] = a[i].ID
-	}
-	return au.RemoveAchievementSnapshotIDs(ids...)
-}
-
 // ClearVehicleSnapshots clears all "vehicle_snapshots" edges to the VehicleSnapshot entity.
 func (au *AccountUpdate) ClearVehicleSnapshots() *AccountUpdate {
 	au.mutation.ClearVehicleSnapshots()
@@ -369,51 +332,6 @@ func (au *AccountUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 		_spec.Edges.Add = append(_spec.Edges.Add, edge)
 	}
-	if au.mutation.AchievementSnapshotsCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   account.AchievementSnapshotsTable,
-			Columns: []string{account.AchievementSnapshotsColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString),
-			},
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := au.mutation.RemovedAchievementSnapshotsIDs(); len(nodes) > 0 && !au.mutation.AchievementSnapshotsCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   account.AchievementSnapshotsTable,
-			Columns: []string{account.AchievementSnapshotsColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := au.mutation.AchievementSnapshotsIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   account.AchievementSnapshotsTable,
-			Columns: []string{account.AchievementSnapshotsColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Add = append(_spec.Edges.Add, edge)
-	}
 	if au.mutation.VehicleSnapshotsCleared() {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,
@@ -627,21 +545,6 @@ func (auo *AccountUpdateOne) SetClan(c *Clan) *AccountUpdateOne {
 	return auo.SetClanID(c.ID)
 }
 
-// AddAchievementSnapshotIDs adds the "achievement_snapshots" edge to the AchievementsSnapshot entity by IDs.
-func (auo *AccountUpdateOne) AddAchievementSnapshotIDs(ids ...string) *AccountUpdateOne {
-	auo.mutation.AddAchievementSnapshotIDs(ids...)
-	return auo
-}
-
-// AddAchievementSnapshots adds the "achievement_snapshots" edges to the AchievementsSnapshot entity.
-func (auo *AccountUpdateOne) AddAchievementSnapshots(a ...*AchievementsSnapshot) *AccountUpdateOne {
-	ids := make([]string, len(a))
-	for i := range a {
-		ids[i] = a[i].ID
-	}
-	return auo.AddAchievementSnapshotIDs(ids...)
-}
-
 // AddVehicleSnapshotIDs adds the "vehicle_snapshots" edge to the VehicleSnapshot entity by IDs.
 func (auo *AccountUpdateOne) AddVehicleSnapshotIDs(ids ...string) *AccountUpdateOne {
 	auo.mutation.AddVehicleSnapshotIDs(ids...)
@@ -683,27 +586,6 @@ func (auo *AccountUpdateOne) ClearClan() *AccountUpdateOne {
 	return auo
 }
 
-// ClearAchievementSnapshots clears all "achievement_snapshots" edges to the AchievementsSnapshot entity.
-func (auo *AccountUpdateOne) ClearAchievementSnapshots() *AccountUpdateOne {
-	auo.mutation.ClearAchievementSnapshots()
-	return auo
-}
-
-// RemoveAchievementSnapshotIDs removes the "achievement_snapshots" edge to AchievementsSnapshot entities by IDs.
-func (auo *AccountUpdateOne) RemoveAchievementSnapshotIDs(ids ...string) *AccountUpdateOne {
-	auo.mutation.RemoveAchievementSnapshotIDs(ids...)
-	return auo
-}
-
-// RemoveAchievementSnapshots removes "achievement_snapshots" edges to AchievementsSnapshot entities.
-func (auo *AccountUpdateOne) RemoveAchievementSnapshots(a ...*AchievementsSnapshot) *AccountUpdateOne {
-	ids := make([]string, len(a))
-	for i := range a {
-		ids[i] = a[i].ID
-	}
-	return auo.RemoveAchievementSnapshotIDs(ids...)
-}
-
 // ClearVehicleSnapshots clears all "vehicle_snapshots" edges to the VehicleSnapshot entity.
 func (auo *AccountUpdateOne) ClearVehicleSnapshots() *AccountUpdateOne {
 	auo.mutation.ClearVehicleSnapshots()
@@ -892,51 +774,6 @@ func (auo *AccountUpdateOne) sqlSave(ctx context.Context) (_node *Account, err e
 		}
 		_spec.Edges.Add = append(_spec.Edges.Add, edge)
 	}
-	if auo.mutation.AchievementSnapshotsCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   account.AchievementSnapshotsTable,
-			Columns: []string{account.AchievementSnapshotsColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString),
-			},
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := auo.mutation.RemovedAchievementSnapshotsIDs(); len(nodes) > 0 && !auo.mutation.AchievementSnapshotsCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   account.AchievementSnapshotsTable,
-			Columns: []string{account.AchievementSnapshotsColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := auo.mutation.AchievementSnapshotsIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   account.AchievementSnapshotsTable,
-			Columns: []string{account.AchievementSnapshotsColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Add = append(_spec.Edges.Add, edge)
-	}
 	if auo.mutation.VehicleSnapshotsCleared() {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,
diff --git a/internal/database/ent/db/achievementssnapshot.go b/internal/database/ent/db/achievementssnapshot.go
deleted file mode 100644
index 00969546..00000000
--- a/internal/database/ent/db/achievementssnapshot.go
+++ /dev/null
@@ -1,219 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package db
-
-import (
-	"encoding/json"
-	"fmt"
-	"strings"
-	"time"
-
-	"entgo.io/ent"
-	"entgo.io/ent/dialect/sql"
-	"github.com/cufee/aftermath/internal/database/ent/db/account"
-	"github.com/cufee/aftermath/internal/database/ent/db/achievementssnapshot"
-	"github.com/cufee/aftermath/internal/database/models"
-	"github.com/cufee/am-wg-proxy-next/v2/types"
-)
-
-// AchievementsSnapshot is the model entity for the AchievementsSnapshot schema.
-type AchievementsSnapshot struct {
-	config `json:"-"`
-	// ID of the ent.
-	ID string `json:"id,omitempty"`
-	// CreatedAt holds the value of the "created_at" field.
-	CreatedAt time.Time `json:"created_at,omitempty"`
-	// UpdatedAt holds the value of the "updated_at" field.
-	UpdatedAt time.Time `json:"updated_at,omitempty"`
-	// Type holds the value of the "type" field.
-	Type models.SnapshotType `json:"type,omitempty"`
-	// AccountID holds the value of the "account_id" field.
-	AccountID string `json:"account_id,omitempty"`
-	// ReferenceID holds the value of the "reference_id" field.
-	ReferenceID string `json:"reference_id,omitempty"`
-	// Battles holds the value of the "battles" field.
-	Battles int `json:"battles,omitempty"`
-	// LastBattleTime holds the value of the "last_battle_time" field.
-	LastBattleTime time.Time `json:"last_battle_time,omitempty"`
-	// Data holds the value of the "data" field.
-	Data types.AchievementsFrame `json:"data,omitempty"`
-	// Edges holds the relations/edges for other nodes in the graph.
-	// The values are being populated by the AchievementsSnapshotQuery when eager-loading is set.
-	Edges        AchievementsSnapshotEdges `json:"edges"`
-	selectValues sql.SelectValues
-}
-
-// AchievementsSnapshotEdges holds the relations/edges for other nodes in the graph.
-type AchievementsSnapshotEdges struct {
-	// Account holds the value of the account edge.
-	Account *Account `json:"account,omitempty"`
-	// loadedTypes holds the information for reporting if a
-	// type was loaded (or requested) in eager-loading or not.
-	loadedTypes [1]bool
-}
-
-// AccountOrErr returns the Account value or an error if the edge
-// was not loaded in eager-loading, or loaded but was not found.
-func (e AchievementsSnapshotEdges) AccountOrErr() (*Account, error) {
-	if e.Account != nil {
-		return e.Account, nil
-	} else if e.loadedTypes[0] {
-		return nil, &NotFoundError{label: account.Label}
-	}
-	return nil, &NotLoadedError{edge: "account"}
-}
-
-// scanValues returns the types for scanning values from sql.Rows.
-func (*AchievementsSnapshot) scanValues(columns []string) ([]any, error) {
-	values := make([]any, len(columns))
-	for i := range columns {
-		switch columns[i] {
-		case achievementssnapshot.FieldData:
-			values[i] = new([]byte)
-		case achievementssnapshot.FieldBattles:
-			values[i] = new(sql.NullInt64)
-		case achievementssnapshot.FieldID, achievementssnapshot.FieldType, achievementssnapshot.FieldAccountID, achievementssnapshot.FieldReferenceID:
-			values[i] = new(sql.NullString)
-		case achievementssnapshot.FieldCreatedAt, achievementssnapshot.FieldUpdatedAt, achievementssnapshot.FieldLastBattleTime:
-			values[i] = new(sql.NullTime)
-		default:
-			values[i] = new(sql.UnknownType)
-		}
-	}
-	return values, nil
-}
-
-// assignValues assigns the values that were returned from sql.Rows (after scanning)
-// to the AchievementsSnapshot fields.
-func (as *AchievementsSnapshot) assignValues(columns []string, values []any) error {
-	if m, n := len(values), len(columns); m < n {
-		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
-	}
-	for i := range columns {
-		switch columns[i] {
-		case achievementssnapshot.FieldID:
-			if value, ok := values[i].(*sql.NullString); !ok {
-				return fmt.Errorf("unexpected type %T for field id", values[i])
-			} else if value.Valid {
-				as.ID = value.String
-			}
-		case achievementssnapshot.FieldCreatedAt:
-			if value, ok := values[i].(*sql.NullTime); !ok {
-				return fmt.Errorf("unexpected type %T for field created_at", values[i])
-			} else if value.Valid {
-				as.CreatedAt = value.Time
-			}
-		case achievementssnapshot.FieldUpdatedAt:
-			if value, ok := values[i].(*sql.NullTime); !ok {
-				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
-			} else if value.Valid {
-				as.UpdatedAt = value.Time
-			}
-		case achievementssnapshot.FieldType:
-			if value, ok := values[i].(*sql.NullString); !ok {
-				return fmt.Errorf("unexpected type %T for field type", values[i])
-			} else if value.Valid {
-				as.Type = models.SnapshotType(value.String)
-			}
-		case achievementssnapshot.FieldAccountID:
-			if value, ok := values[i].(*sql.NullString); !ok {
-				return fmt.Errorf("unexpected type %T for field account_id", values[i])
-			} else if value.Valid {
-				as.AccountID = value.String
-			}
-		case achievementssnapshot.FieldReferenceID:
-			if value, ok := values[i].(*sql.NullString); !ok {
-				return fmt.Errorf("unexpected type %T for field reference_id", values[i])
-			} else if value.Valid {
-				as.ReferenceID = value.String
-			}
-		case achievementssnapshot.FieldBattles:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
-				return fmt.Errorf("unexpected type %T for field battles", values[i])
-			} else if value.Valid {
-				as.Battles = int(value.Int64)
-			}
-		case achievementssnapshot.FieldLastBattleTime:
-			if value, ok := values[i].(*sql.NullTime); !ok {
-				return fmt.Errorf("unexpected type %T for field last_battle_time", values[i])
-			} else if value.Valid {
-				as.LastBattleTime = value.Time
-			}
-		case achievementssnapshot.FieldData:
-			if value, ok := values[i].(*[]byte); !ok {
-				return fmt.Errorf("unexpected type %T for field data", values[i])
-			} else if value != nil && len(*value) > 0 {
-				if err := json.Unmarshal(*value, &as.Data); err != nil {
-					return fmt.Errorf("unmarshal field data: %w", err)
-				}
-			}
-		default:
-			as.selectValues.Set(columns[i], values[i])
-		}
-	}
-	return nil
-}
-
-// Value returns the ent.Value that was dynamically selected and assigned to the AchievementsSnapshot.
-// This includes values selected through modifiers, order, etc.
-func (as *AchievementsSnapshot) Value(name string) (ent.Value, error) {
-	return as.selectValues.Get(name)
-}
-
-// QueryAccount queries the "account" edge of the AchievementsSnapshot entity.
-func (as *AchievementsSnapshot) QueryAccount() *AccountQuery {
-	return NewAchievementsSnapshotClient(as.config).QueryAccount(as)
-}
-
-// Update returns a builder for updating this AchievementsSnapshot.
-// Note that you need to call AchievementsSnapshot.Unwrap() before calling this method if this AchievementsSnapshot
-// was returned from a transaction, and the transaction was committed or rolled back.
-func (as *AchievementsSnapshot) Update() *AchievementsSnapshotUpdateOne {
-	return NewAchievementsSnapshotClient(as.config).UpdateOne(as)
-}
-
-// Unwrap unwraps the AchievementsSnapshot entity that was returned from a transaction after it was closed,
-// so that all future queries will be executed through the driver which created the transaction.
-func (as *AchievementsSnapshot) Unwrap() *AchievementsSnapshot {
-	_tx, ok := as.config.driver.(*txDriver)
-	if !ok {
-		panic("db: AchievementsSnapshot is not a transactional entity")
-	}
-	as.config.driver = _tx.drv
-	return as
-}
-
-// String implements the fmt.Stringer.
-func (as *AchievementsSnapshot) String() string {
-	var builder strings.Builder
-	builder.WriteString("AchievementsSnapshot(")
-	builder.WriteString(fmt.Sprintf("id=%v, ", as.ID))
-	builder.WriteString("created_at=")
-	builder.WriteString(as.CreatedAt.Format(time.ANSIC))
-	builder.WriteString(", ")
-	builder.WriteString("updated_at=")
-	builder.WriteString(as.UpdatedAt.Format(time.ANSIC))
-	builder.WriteString(", ")
-	builder.WriteString("type=")
-	builder.WriteString(fmt.Sprintf("%v", as.Type))
-	builder.WriteString(", ")
-	builder.WriteString("account_id=")
-	builder.WriteString(as.AccountID)
-	builder.WriteString(", ")
-	builder.WriteString("reference_id=")
-	builder.WriteString(as.ReferenceID)
-	builder.WriteString(", ")
-	builder.WriteString("battles=")
-	builder.WriteString(fmt.Sprintf("%v", as.Battles))
-	builder.WriteString(", ")
-	builder.WriteString("last_battle_time=")
-	builder.WriteString(as.LastBattleTime.Format(time.ANSIC))
-	builder.WriteString(", ")
-	builder.WriteString("data=")
-	builder.WriteString(fmt.Sprintf("%v", as.Data))
-	builder.WriteByte(')')
-	return builder.String()
-}
-
-// AchievementsSnapshots is a parsable slice of AchievementsSnapshot.
-type AchievementsSnapshots []*AchievementsSnapshot
diff --git a/internal/database/ent/db/achievementssnapshot/achievementssnapshot.go b/internal/database/ent/db/achievementssnapshot/achievementssnapshot.go
deleted file mode 100644
index cad20938..00000000
--- a/internal/database/ent/db/achievementssnapshot/achievementssnapshot.go
+++ /dev/null
@@ -1,151 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package achievementssnapshot
-
-import (
-	"fmt"
-	"time"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"github.com/cufee/aftermath/internal/database/models"
-)
-
-const (
-	// Label holds the string label denoting the achievementssnapshot type in the database.
-	Label = "achievements_snapshot"
-	// FieldID holds the string denoting the id field in the database.
-	FieldID = "id"
-	// FieldCreatedAt holds the string denoting the created_at field in the database.
-	FieldCreatedAt = "created_at"
-	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
-	FieldUpdatedAt = "updated_at"
-	// FieldType holds the string denoting the type field in the database.
-	FieldType = "type"
-	// FieldAccountID holds the string denoting the account_id field in the database.
-	FieldAccountID = "account_id"
-	// FieldReferenceID holds the string denoting the reference_id field in the database.
-	FieldReferenceID = "reference_id"
-	// FieldBattles holds the string denoting the battles field in the database.
-	FieldBattles = "battles"
-	// FieldLastBattleTime holds the string denoting the last_battle_time field in the database.
-	FieldLastBattleTime = "last_battle_time"
-	// FieldData holds the string denoting the data field in the database.
-	FieldData = "data"
-	// EdgeAccount holds the string denoting the account edge name in mutations.
-	EdgeAccount = "account"
-	// Table holds the table name of the achievementssnapshot in the database.
-	Table = "achievements_snapshots"
-	// AccountTable is the table that holds the account relation/edge.
-	AccountTable = "achievements_snapshots"
-	// AccountInverseTable is the table name for the Account entity.
-	// It exists in this package in order to avoid circular dependency with the "account" package.
-	AccountInverseTable = "accounts"
-	// AccountColumn is the table column denoting the account relation/edge.
-	AccountColumn = "account_id"
-)
-
-// Columns holds all SQL columns for achievementssnapshot fields.
-var Columns = []string{
-	FieldID,
-	FieldCreatedAt,
-	FieldUpdatedAt,
-	FieldType,
-	FieldAccountID,
-	FieldReferenceID,
-	FieldBattles,
-	FieldLastBattleTime,
-	FieldData,
-}
-
-// ValidColumn reports if the column name is valid (part of the table columns).
-func ValidColumn(column string) bool {
-	for i := range Columns {
-		if column == Columns[i] {
-			return true
-		}
-	}
-	return false
-}
-
-var (
-	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
-	DefaultCreatedAt func() time.Time
-	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
-	DefaultUpdatedAt func() time.Time
-	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
-	UpdateDefaultUpdatedAt func() time.Time
-	// AccountIDValidator is a validator for the "account_id" field. It is called by the builders before save.
-	AccountIDValidator func(string) error
-	// ReferenceIDValidator is a validator for the "reference_id" field. It is called by the builders before save.
-	ReferenceIDValidator func(string) error
-	// DefaultID holds the default value on creation for the "id" field.
-	DefaultID func() string
-)
-
-// TypeValidator is a validator for the "type" field enum values. It is called by the builders before save.
-func TypeValidator(_type models.SnapshotType) error {
-	switch _type {
-	case "live", "daily":
-		return nil
-	default:
-		return fmt.Errorf("achievementssnapshot: invalid enum value for type field: %q", _type)
-	}
-}
-
-// OrderOption defines the ordering options for the AchievementsSnapshot queries.
-type OrderOption func(*sql.Selector)
-
-// ByID orders the results by the id field.
-func ByID(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldID, opts...).ToFunc()
-}
-
-// ByCreatedAt orders the results by the created_at field.
-func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
-}
-
-// ByUpdatedAt orders the results by the updated_at field.
-func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
-}
-
-// ByType orders the results by the type field.
-func ByType(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldType, opts...).ToFunc()
-}
-
-// ByAccountID orders the results by the account_id field.
-func ByAccountID(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldAccountID, opts...).ToFunc()
-}
-
-// ByReferenceID orders the results by the reference_id field.
-func ByReferenceID(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldReferenceID, opts...).ToFunc()
-}
-
-// ByBattles orders the results by the battles field.
-func ByBattles(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldBattles, opts...).ToFunc()
-}
-
-// ByLastBattleTime orders the results by the last_battle_time field.
-func ByLastBattleTime(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldLastBattleTime, opts...).ToFunc()
-}
-
-// ByAccountField orders the results by account field.
-func ByAccountField(field string, opts ...sql.OrderTermOption) OrderOption {
-	return func(s *sql.Selector) {
-		sqlgraph.OrderByNeighborTerms(s, newAccountStep(), sql.OrderByField(field, opts...))
-	}
-}
-func newAccountStep() *sqlgraph.Step {
-	return sqlgraph.NewStep(
-		sqlgraph.From(Table, FieldID),
-		sqlgraph.To(AccountInverseTable, FieldID),
-		sqlgraph.Edge(sqlgraph.M2O, true, AccountTable, AccountColumn),
-	)
-}
diff --git a/internal/database/ent/db/achievementssnapshot/where.go b/internal/database/ent/db/achievementssnapshot/where.go
deleted file mode 100644
index 3d3e0932..00000000
--- a/internal/database/ent/db/achievementssnapshot/where.go
+++ /dev/null
@@ -1,455 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package achievementssnapshot
-
-import (
-	"time"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
-	"github.com/cufee/aftermath/internal/database/models"
-)
-
-// ID filters vertices based on their ID field.
-func ID(id string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldID, id))
-}
-
-// IDEQ applies the EQ predicate on the ID field.
-func IDEQ(id string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldID, id))
-}
-
-// IDNEQ applies the NEQ predicate on the ID field.
-func IDNEQ(id string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldNEQ(FieldID, id))
-}
-
-// IDIn applies the In predicate on the ID field.
-func IDIn(ids ...string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldIn(FieldID, ids...))
-}
-
-// IDNotIn applies the NotIn predicate on the ID field.
-func IDNotIn(ids ...string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldNotIn(FieldID, ids...))
-}
-
-// IDGT applies the GT predicate on the ID field.
-func IDGT(id string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldGT(FieldID, id))
-}
-
-// IDGTE applies the GTE predicate on the ID field.
-func IDGTE(id string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldGTE(FieldID, id))
-}
-
-// IDLT applies the LT predicate on the ID field.
-func IDLT(id string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldLT(FieldID, id))
-}
-
-// IDLTE applies the LTE predicate on the ID field.
-func IDLTE(id string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldLTE(FieldID, id))
-}
-
-// IDEqualFold applies the EqualFold predicate on the ID field.
-func IDEqualFold(id string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldEqualFold(FieldID, id))
-}
-
-// IDContainsFold applies the ContainsFold predicate on the ID field.
-func IDContainsFold(id string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldContainsFold(FieldID, id))
-}
-
-// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
-func CreatedAt(v time.Time) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldCreatedAt, v))
-}
-
-// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
-func UpdatedAt(v time.Time) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldUpdatedAt, v))
-}
-
-// AccountID applies equality check predicate on the "account_id" field. It's identical to AccountIDEQ.
-func AccountID(v string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldAccountID, v))
-}
-
-// ReferenceID applies equality check predicate on the "reference_id" field. It's identical to ReferenceIDEQ.
-func ReferenceID(v string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldReferenceID, v))
-}
-
-// Battles applies equality check predicate on the "battles" field. It's identical to BattlesEQ.
-func Battles(v int) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldBattles, v))
-}
-
-// LastBattleTime applies equality check predicate on the "last_battle_time" field. It's identical to LastBattleTimeEQ.
-func LastBattleTime(v time.Time) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldLastBattleTime, v))
-}
-
-// CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v time.Time) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldCreatedAt, v))
-}
-
-// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v time.Time) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldNEQ(FieldCreatedAt, v))
-}
-
-// CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...time.Time) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldIn(FieldCreatedAt, vs...))
-}
-
-// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...time.Time) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldNotIn(FieldCreatedAt, vs...))
-}
-
-// CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v time.Time) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldGT(FieldCreatedAt, v))
-}
-
-// CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v time.Time) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldGTE(FieldCreatedAt, v))
-}
-
-// CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v time.Time) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldLT(FieldCreatedAt, v))
-}
-
-// CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v time.Time) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldLTE(FieldCreatedAt, v))
-}
-
-// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
-func UpdatedAtEQ(v time.Time) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldUpdatedAt, v))
-}
-
-// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
-func UpdatedAtNEQ(v time.Time) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldNEQ(FieldUpdatedAt, v))
-}
-
-// UpdatedAtIn applies the In predicate on the "updated_at" field.
-func UpdatedAtIn(vs ...time.Time) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldIn(FieldUpdatedAt, vs...))
-}
-
-// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
-func UpdatedAtNotIn(vs ...time.Time) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldNotIn(FieldUpdatedAt, vs...))
-}
-
-// UpdatedAtGT applies the GT predicate on the "updated_at" field.
-func UpdatedAtGT(v time.Time) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldGT(FieldUpdatedAt, v))
-}
-
-// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
-func UpdatedAtGTE(v time.Time) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldGTE(FieldUpdatedAt, v))
-}
-
-// UpdatedAtLT applies the LT predicate on the "updated_at" field.
-func UpdatedAtLT(v time.Time) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldLT(FieldUpdatedAt, v))
-}
-
-// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
-func UpdatedAtLTE(v time.Time) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldLTE(FieldUpdatedAt, v))
-}
-
-// TypeEQ applies the EQ predicate on the "type" field.
-func TypeEQ(v models.SnapshotType) predicate.AchievementsSnapshot {
-	vc := v
-	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldType, vc))
-}
-
-// TypeNEQ applies the NEQ predicate on the "type" field.
-func TypeNEQ(v models.SnapshotType) predicate.AchievementsSnapshot {
-	vc := v
-	return predicate.AchievementsSnapshot(sql.FieldNEQ(FieldType, vc))
-}
-
-// TypeIn applies the In predicate on the "type" field.
-func TypeIn(vs ...models.SnapshotType) predicate.AchievementsSnapshot {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.AchievementsSnapshot(sql.FieldIn(FieldType, v...))
-}
-
-// TypeNotIn applies the NotIn predicate on the "type" field.
-func TypeNotIn(vs ...models.SnapshotType) predicate.AchievementsSnapshot {
-	v := make([]any, len(vs))
-	for i := range v {
-		v[i] = vs[i]
-	}
-	return predicate.AchievementsSnapshot(sql.FieldNotIn(FieldType, v...))
-}
-
-// AccountIDEQ applies the EQ predicate on the "account_id" field.
-func AccountIDEQ(v string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldAccountID, v))
-}
-
-// AccountIDNEQ applies the NEQ predicate on the "account_id" field.
-func AccountIDNEQ(v string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldNEQ(FieldAccountID, v))
-}
-
-// AccountIDIn applies the In predicate on the "account_id" field.
-func AccountIDIn(vs ...string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldIn(FieldAccountID, vs...))
-}
-
-// AccountIDNotIn applies the NotIn predicate on the "account_id" field.
-func AccountIDNotIn(vs ...string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldNotIn(FieldAccountID, vs...))
-}
-
-// AccountIDGT applies the GT predicate on the "account_id" field.
-func AccountIDGT(v string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldGT(FieldAccountID, v))
-}
-
-// AccountIDGTE applies the GTE predicate on the "account_id" field.
-func AccountIDGTE(v string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldGTE(FieldAccountID, v))
-}
-
-// AccountIDLT applies the LT predicate on the "account_id" field.
-func AccountIDLT(v string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldLT(FieldAccountID, v))
-}
-
-// AccountIDLTE applies the LTE predicate on the "account_id" field.
-func AccountIDLTE(v string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldLTE(FieldAccountID, v))
-}
-
-// AccountIDContains applies the Contains predicate on the "account_id" field.
-func AccountIDContains(v string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldContains(FieldAccountID, v))
-}
-
-// AccountIDHasPrefix applies the HasPrefix predicate on the "account_id" field.
-func AccountIDHasPrefix(v string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldHasPrefix(FieldAccountID, v))
-}
-
-// AccountIDHasSuffix applies the HasSuffix predicate on the "account_id" field.
-func AccountIDHasSuffix(v string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldHasSuffix(FieldAccountID, v))
-}
-
-// AccountIDEqualFold applies the EqualFold predicate on the "account_id" field.
-func AccountIDEqualFold(v string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldEqualFold(FieldAccountID, v))
-}
-
-// AccountIDContainsFold applies the ContainsFold predicate on the "account_id" field.
-func AccountIDContainsFold(v string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldContainsFold(FieldAccountID, v))
-}
-
-// ReferenceIDEQ applies the EQ predicate on the "reference_id" field.
-func ReferenceIDEQ(v string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldReferenceID, v))
-}
-
-// ReferenceIDNEQ applies the NEQ predicate on the "reference_id" field.
-func ReferenceIDNEQ(v string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldNEQ(FieldReferenceID, v))
-}
-
-// ReferenceIDIn applies the In predicate on the "reference_id" field.
-func ReferenceIDIn(vs ...string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldIn(FieldReferenceID, vs...))
-}
-
-// ReferenceIDNotIn applies the NotIn predicate on the "reference_id" field.
-func ReferenceIDNotIn(vs ...string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldNotIn(FieldReferenceID, vs...))
-}
-
-// ReferenceIDGT applies the GT predicate on the "reference_id" field.
-func ReferenceIDGT(v string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldGT(FieldReferenceID, v))
-}
-
-// ReferenceIDGTE applies the GTE predicate on the "reference_id" field.
-func ReferenceIDGTE(v string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldGTE(FieldReferenceID, v))
-}
-
-// ReferenceIDLT applies the LT predicate on the "reference_id" field.
-func ReferenceIDLT(v string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldLT(FieldReferenceID, v))
-}
-
-// ReferenceIDLTE applies the LTE predicate on the "reference_id" field.
-func ReferenceIDLTE(v string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldLTE(FieldReferenceID, v))
-}
-
-// ReferenceIDContains applies the Contains predicate on the "reference_id" field.
-func ReferenceIDContains(v string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldContains(FieldReferenceID, v))
-}
-
-// ReferenceIDHasPrefix applies the HasPrefix predicate on the "reference_id" field.
-func ReferenceIDHasPrefix(v string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldHasPrefix(FieldReferenceID, v))
-}
-
-// ReferenceIDHasSuffix applies the HasSuffix predicate on the "reference_id" field.
-func ReferenceIDHasSuffix(v string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldHasSuffix(FieldReferenceID, v))
-}
-
-// ReferenceIDEqualFold applies the EqualFold predicate on the "reference_id" field.
-func ReferenceIDEqualFold(v string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldEqualFold(FieldReferenceID, v))
-}
-
-// ReferenceIDContainsFold applies the ContainsFold predicate on the "reference_id" field.
-func ReferenceIDContainsFold(v string) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldContainsFold(FieldReferenceID, v))
-}
-
-// BattlesEQ applies the EQ predicate on the "battles" field.
-func BattlesEQ(v int) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldBattles, v))
-}
-
-// BattlesNEQ applies the NEQ predicate on the "battles" field.
-func BattlesNEQ(v int) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldNEQ(FieldBattles, v))
-}
-
-// BattlesIn applies the In predicate on the "battles" field.
-func BattlesIn(vs ...int) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldIn(FieldBattles, vs...))
-}
-
-// BattlesNotIn applies the NotIn predicate on the "battles" field.
-func BattlesNotIn(vs ...int) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldNotIn(FieldBattles, vs...))
-}
-
-// BattlesGT applies the GT predicate on the "battles" field.
-func BattlesGT(v int) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldGT(FieldBattles, v))
-}
-
-// BattlesGTE applies the GTE predicate on the "battles" field.
-func BattlesGTE(v int) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldGTE(FieldBattles, v))
-}
-
-// BattlesLT applies the LT predicate on the "battles" field.
-func BattlesLT(v int) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldLT(FieldBattles, v))
-}
-
-// BattlesLTE applies the LTE predicate on the "battles" field.
-func BattlesLTE(v int) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldLTE(FieldBattles, v))
-}
-
-// LastBattleTimeEQ applies the EQ predicate on the "last_battle_time" field.
-func LastBattleTimeEQ(v time.Time) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldEQ(FieldLastBattleTime, v))
-}
-
-// LastBattleTimeNEQ applies the NEQ predicate on the "last_battle_time" field.
-func LastBattleTimeNEQ(v time.Time) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldNEQ(FieldLastBattleTime, v))
-}
-
-// LastBattleTimeIn applies the In predicate on the "last_battle_time" field.
-func LastBattleTimeIn(vs ...time.Time) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldIn(FieldLastBattleTime, vs...))
-}
-
-// LastBattleTimeNotIn applies the NotIn predicate on the "last_battle_time" field.
-func LastBattleTimeNotIn(vs ...time.Time) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldNotIn(FieldLastBattleTime, vs...))
-}
-
-// LastBattleTimeGT applies the GT predicate on the "last_battle_time" field.
-func LastBattleTimeGT(v time.Time) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldGT(FieldLastBattleTime, v))
-}
-
-// LastBattleTimeGTE applies the GTE predicate on the "last_battle_time" field.
-func LastBattleTimeGTE(v time.Time) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldGTE(FieldLastBattleTime, v))
-}
-
-// LastBattleTimeLT applies the LT predicate on the "last_battle_time" field.
-func LastBattleTimeLT(v time.Time) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldLT(FieldLastBattleTime, v))
-}
-
-// LastBattleTimeLTE applies the LTE predicate on the "last_battle_time" field.
-func LastBattleTimeLTE(v time.Time) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.FieldLTE(FieldLastBattleTime, v))
-}
-
-// HasAccount applies the HasEdge predicate on the "account" edge.
-func HasAccount() predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(func(s *sql.Selector) {
-		step := sqlgraph.NewStep(
-			sqlgraph.From(Table, FieldID),
-			sqlgraph.Edge(sqlgraph.M2O, true, AccountTable, AccountColumn),
-		)
-		sqlgraph.HasNeighbors(s, step)
-	})
-}
-
-// HasAccountWith applies the HasEdge predicate on the "account" edge with a given conditions (other predicates).
-func HasAccountWith(preds ...predicate.Account) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(func(s *sql.Selector) {
-		step := newAccountStep()
-		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
-			for _, p := range preds {
-				p(s)
-			}
-		})
-	})
-}
-
-// And groups predicates with the AND operator between them.
-func And(predicates ...predicate.AchievementsSnapshot) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.AndPredicates(predicates...))
-}
-
-// Or groups predicates with the OR operator between them.
-func Or(predicates ...predicate.AchievementsSnapshot) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.OrPredicates(predicates...))
-}
-
-// Not applies the not operator on the given predicate.
-func Not(p predicate.AchievementsSnapshot) predicate.AchievementsSnapshot {
-	return predicate.AchievementsSnapshot(sql.NotPredicates(p))
-}
diff --git a/internal/database/ent/db/achievementssnapshot_create.go b/internal/database/ent/db/achievementssnapshot_create.go
deleted file mode 100644
index 86e3137d..00000000
--- a/internal/database/ent/db/achievementssnapshot_create.go
+++ /dev/null
@@ -1,367 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package db
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"time"
-
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/schema/field"
-	"github.com/cufee/aftermath/internal/database/ent/db/account"
-	"github.com/cufee/aftermath/internal/database/ent/db/achievementssnapshot"
-	"github.com/cufee/aftermath/internal/database/models"
-	"github.com/cufee/am-wg-proxy-next/v2/types"
-)
-
-// AchievementsSnapshotCreate is the builder for creating a AchievementsSnapshot entity.
-type AchievementsSnapshotCreate struct {
-	config
-	mutation *AchievementsSnapshotMutation
-	hooks    []Hook
-}
-
-// SetCreatedAt sets the "created_at" field.
-func (asc *AchievementsSnapshotCreate) SetCreatedAt(t time.Time) *AchievementsSnapshotCreate {
-	asc.mutation.SetCreatedAt(t)
-	return asc
-}
-
-// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
-func (asc *AchievementsSnapshotCreate) SetNillableCreatedAt(t *time.Time) *AchievementsSnapshotCreate {
-	if t != nil {
-		asc.SetCreatedAt(*t)
-	}
-	return asc
-}
-
-// SetUpdatedAt sets the "updated_at" field.
-func (asc *AchievementsSnapshotCreate) SetUpdatedAt(t time.Time) *AchievementsSnapshotCreate {
-	asc.mutation.SetUpdatedAt(t)
-	return asc
-}
-
-// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
-func (asc *AchievementsSnapshotCreate) SetNillableUpdatedAt(t *time.Time) *AchievementsSnapshotCreate {
-	if t != nil {
-		asc.SetUpdatedAt(*t)
-	}
-	return asc
-}
-
-// SetType sets the "type" field.
-func (asc *AchievementsSnapshotCreate) SetType(mt models.SnapshotType) *AchievementsSnapshotCreate {
-	asc.mutation.SetType(mt)
-	return asc
-}
-
-// SetAccountID sets the "account_id" field.
-func (asc *AchievementsSnapshotCreate) SetAccountID(s string) *AchievementsSnapshotCreate {
-	asc.mutation.SetAccountID(s)
-	return asc
-}
-
-// SetReferenceID sets the "reference_id" field.
-func (asc *AchievementsSnapshotCreate) SetReferenceID(s string) *AchievementsSnapshotCreate {
-	asc.mutation.SetReferenceID(s)
-	return asc
-}
-
-// SetBattles sets the "battles" field.
-func (asc *AchievementsSnapshotCreate) SetBattles(i int) *AchievementsSnapshotCreate {
-	asc.mutation.SetBattles(i)
-	return asc
-}
-
-// SetLastBattleTime sets the "last_battle_time" field.
-func (asc *AchievementsSnapshotCreate) SetLastBattleTime(t time.Time) *AchievementsSnapshotCreate {
-	asc.mutation.SetLastBattleTime(t)
-	return asc
-}
-
-// SetData sets the "data" field.
-func (asc *AchievementsSnapshotCreate) SetData(tf types.AchievementsFrame) *AchievementsSnapshotCreate {
-	asc.mutation.SetData(tf)
-	return asc
-}
-
-// SetID sets the "id" field.
-func (asc *AchievementsSnapshotCreate) SetID(s string) *AchievementsSnapshotCreate {
-	asc.mutation.SetID(s)
-	return asc
-}
-
-// SetNillableID sets the "id" field if the given value is not nil.
-func (asc *AchievementsSnapshotCreate) SetNillableID(s *string) *AchievementsSnapshotCreate {
-	if s != nil {
-		asc.SetID(*s)
-	}
-	return asc
-}
-
-// SetAccount sets the "account" edge to the Account entity.
-func (asc *AchievementsSnapshotCreate) SetAccount(a *Account) *AchievementsSnapshotCreate {
-	return asc.SetAccountID(a.ID)
-}
-
-// Mutation returns the AchievementsSnapshotMutation object of the builder.
-func (asc *AchievementsSnapshotCreate) Mutation() *AchievementsSnapshotMutation {
-	return asc.mutation
-}
-
-// Save creates the AchievementsSnapshot in the database.
-func (asc *AchievementsSnapshotCreate) Save(ctx context.Context) (*AchievementsSnapshot, error) {
-	asc.defaults()
-	return withHooks(ctx, asc.sqlSave, asc.mutation, asc.hooks)
-}
-
-// SaveX calls Save and panics if Save returns an error.
-func (asc *AchievementsSnapshotCreate) SaveX(ctx context.Context) *AchievementsSnapshot {
-	v, err := asc.Save(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return v
-}
-
-// Exec executes the query.
-func (asc *AchievementsSnapshotCreate) Exec(ctx context.Context) error {
-	_, err := asc.Save(ctx)
-	return err
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (asc *AchievementsSnapshotCreate) ExecX(ctx context.Context) {
-	if err := asc.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
-
-// defaults sets the default values of the builder before save.
-func (asc *AchievementsSnapshotCreate) defaults() {
-	if _, ok := asc.mutation.CreatedAt(); !ok {
-		v := achievementssnapshot.DefaultCreatedAt()
-		asc.mutation.SetCreatedAt(v)
-	}
-	if _, ok := asc.mutation.UpdatedAt(); !ok {
-		v := achievementssnapshot.DefaultUpdatedAt()
-		asc.mutation.SetUpdatedAt(v)
-	}
-	if _, ok := asc.mutation.ID(); !ok {
-		v := achievementssnapshot.DefaultID()
-		asc.mutation.SetID(v)
-	}
-}
-
-// check runs all checks and user-defined validators on the builder.
-func (asc *AchievementsSnapshotCreate) check() error {
-	if _, ok := asc.mutation.CreatedAt(); !ok {
-		return &ValidationError{Name: "created_at", err: errors.New(`db: missing required field "AchievementsSnapshot.created_at"`)}
-	}
-	if _, ok := asc.mutation.UpdatedAt(); !ok {
-		return &ValidationError{Name: "updated_at", err: errors.New(`db: missing required field "AchievementsSnapshot.updated_at"`)}
-	}
-	if _, ok := asc.mutation.GetType(); !ok {
-		return &ValidationError{Name: "type", err: errors.New(`db: missing required field "AchievementsSnapshot.type"`)}
-	}
-	if v, ok := asc.mutation.GetType(); ok {
-		if err := achievementssnapshot.TypeValidator(v); err != nil {
-			return &ValidationError{Name: "type", err: fmt.Errorf(`db: validator failed for field "AchievementsSnapshot.type": %w`, err)}
-		}
-	}
-	if _, ok := asc.mutation.AccountID(); !ok {
-		return &ValidationError{Name: "account_id", err: errors.New(`db: missing required field "AchievementsSnapshot.account_id"`)}
-	}
-	if v, ok := asc.mutation.AccountID(); ok {
-		if err := achievementssnapshot.AccountIDValidator(v); err != nil {
-			return &ValidationError{Name: "account_id", err: fmt.Errorf(`db: validator failed for field "AchievementsSnapshot.account_id": %w`, err)}
-		}
-	}
-	if _, ok := asc.mutation.ReferenceID(); !ok {
-		return &ValidationError{Name: "reference_id", err: errors.New(`db: missing required field "AchievementsSnapshot.reference_id"`)}
-	}
-	if v, ok := asc.mutation.ReferenceID(); ok {
-		if err := achievementssnapshot.ReferenceIDValidator(v); err != nil {
-			return &ValidationError{Name: "reference_id", err: fmt.Errorf(`db: validator failed for field "AchievementsSnapshot.reference_id": %w`, err)}
-		}
-	}
-	if _, ok := asc.mutation.Battles(); !ok {
-		return &ValidationError{Name: "battles", err: errors.New(`db: missing required field "AchievementsSnapshot.battles"`)}
-	}
-	if _, ok := asc.mutation.LastBattleTime(); !ok {
-		return &ValidationError{Name: "last_battle_time", err: errors.New(`db: missing required field "AchievementsSnapshot.last_battle_time"`)}
-	}
-	if _, ok := asc.mutation.Data(); !ok {
-		return &ValidationError{Name: "data", err: errors.New(`db: missing required field "AchievementsSnapshot.data"`)}
-	}
-	if _, ok := asc.mutation.AccountID(); !ok {
-		return &ValidationError{Name: "account", err: errors.New(`db: missing required edge "AchievementsSnapshot.account"`)}
-	}
-	return nil
-}
-
-func (asc *AchievementsSnapshotCreate) sqlSave(ctx context.Context) (*AchievementsSnapshot, error) {
-	if err := asc.check(); err != nil {
-		return nil, err
-	}
-	_node, _spec := asc.createSpec()
-	if err := sqlgraph.CreateNode(ctx, asc.driver, _spec); err != nil {
-		if sqlgraph.IsConstraintError(err) {
-			err = &ConstraintError{msg: err.Error(), wrap: err}
-		}
-		return nil, err
-	}
-	if _spec.ID.Value != nil {
-		if id, ok := _spec.ID.Value.(string); ok {
-			_node.ID = id
-		} else {
-			return nil, fmt.Errorf("unexpected AchievementsSnapshot.ID type: %T", _spec.ID.Value)
-		}
-	}
-	asc.mutation.id = &_node.ID
-	asc.mutation.done = true
-	return _node, nil
-}
-
-func (asc *AchievementsSnapshotCreate) createSpec() (*AchievementsSnapshot, *sqlgraph.CreateSpec) {
-	var (
-		_node = &AchievementsSnapshot{config: asc.config}
-		_spec = sqlgraph.NewCreateSpec(achievementssnapshot.Table, sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString))
-	)
-	if id, ok := asc.mutation.ID(); ok {
-		_node.ID = id
-		_spec.ID.Value = id
-	}
-	if value, ok := asc.mutation.CreatedAt(); ok {
-		_spec.SetField(achievementssnapshot.FieldCreatedAt, field.TypeTime, value)
-		_node.CreatedAt = value
-	}
-	if value, ok := asc.mutation.UpdatedAt(); ok {
-		_spec.SetField(achievementssnapshot.FieldUpdatedAt, field.TypeTime, value)
-		_node.UpdatedAt = value
-	}
-	if value, ok := asc.mutation.GetType(); ok {
-		_spec.SetField(achievementssnapshot.FieldType, field.TypeEnum, value)
-		_node.Type = value
-	}
-	if value, ok := asc.mutation.ReferenceID(); ok {
-		_spec.SetField(achievementssnapshot.FieldReferenceID, field.TypeString, value)
-		_node.ReferenceID = value
-	}
-	if value, ok := asc.mutation.Battles(); ok {
-		_spec.SetField(achievementssnapshot.FieldBattles, field.TypeInt, value)
-		_node.Battles = value
-	}
-	if value, ok := asc.mutation.LastBattleTime(); ok {
-		_spec.SetField(achievementssnapshot.FieldLastBattleTime, field.TypeTime, value)
-		_node.LastBattleTime = value
-	}
-	if value, ok := asc.mutation.Data(); ok {
-		_spec.SetField(achievementssnapshot.FieldData, field.TypeJSON, value)
-		_node.Data = value
-	}
-	if nodes := asc.mutation.AccountIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
-			Inverse: true,
-			Table:   achievementssnapshot.AccountTable,
-			Columns: []string{achievementssnapshot.AccountColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(account.FieldID, field.TypeString),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_node.AccountID = nodes[0]
-		_spec.Edges = append(_spec.Edges, edge)
-	}
-	return _node, _spec
-}
-
-// AchievementsSnapshotCreateBulk is the builder for creating many AchievementsSnapshot entities in bulk.
-type AchievementsSnapshotCreateBulk struct {
-	config
-	err      error
-	builders []*AchievementsSnapshotCreate
-}
-
-// Save creates the AchievementsSnapshot entities in the database.
-func (ascb *AchievementsSnapshotCreateBulk) Save(ctx context.Context) ([]*AchievementsSnapshot, error) {
-	if ascb.err != nil {
-		return nil, ascb.err
-	}
-	specs := make([]*sqlgraph.CreateSpec, len(ascb.builders))
-	nodes := make([]*AchievementsSnapshot, len(ascb.builders))
-	mutators := make([]Mutator, len(ascb.builders))
-	for i := range ascb.builders {
-		func(i int, root context.Context) {
-			builder := ascb.builders[i]
-			builder.defaults()
-			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-				mutation, ok := m.(*AchievementsSnapshotMutation)
-				if !ok {
-					return nil, fmt.Errorf("unexpected mutation type %T", m)
-				}
-				if err := builder.check(); err != nil {
-					return nil, err
-				}
-				builder.mutation = mutation
-				var err error
-				nodes[i], specs[i] = builder.createSpec()
-				if i < len(mutators)-1 {
-					_, err = mutators[i+1].Mutate(root, ascb.builders[i+1].mutation)
-				} else {
-					spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
-					// Invoke the actual operation on the latest mutation in the chain.
-					if err = sqlgraph.BatchCreate(ctx, ascb.driver, spec); err != nil {
-						if sqlgraph.IsConstraintError(err) {
-							err = &ConstraintError{msg: err.Error(), wrap: err}
-						}
-					}
-				}
-				if err != nil {
-					return nil, err
-				}
-				mutation.id = &nodes[i].ID
-				mutation.done = true
-				return nodes[i], nil
-			})
-			for i := len(builder.hooks) - 1; i >= 0; i-- {
-				mut = builder.hooks[i](mut)
-			}
-			mutators[i] = mut
-		}(i, ctx)
-	}
-	if len(mutators) > 0 {
-		if _, err := mutators[0].Mutate(ctx, ascb.builders[0].mutation); err != nil {
-			return nil, err
-		}
-	}
-	return nodes, nil
-}
-
-// SaveX is like Save, but panics if an error occurs.
-func (ascb *AchievementsSnapshotCreateBulk) SaveX(ctx context.Context) []*AchievementsSnapshot {
-	v, err := ascb.Save(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return v
-}
-
-// Exec executes the query.
-func (ascb *AchievementsSnapshotCreateBulk) Exec(ctx context.Context) error {
-	_, err := ascb.Save(ctx)
-	return err
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (ascb *AchievementsSnapshotCreateBulk) ExecX(ctx context.Context) {
-	if err := ascb.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
diff --git a/internal/database/ent/db/achievementssnapshot_delete.go b/internal/database/ent/db/achievementssnapshot_delete.go
deleted file mode 100644
index e79eb3c4..00000000
--- a/internal/database/ent/db/achievementssnapshot_delete.go
+++ /dev/null
@@ -1,88 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package db
-
-import (
-	"context"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/schema/field"
-	"github.com/cufee/aftermath/internal/database/ent/db/achievementssnapshot"
-	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
-)
-
-// AchievementsSnapshotDelete is the builder for deleting a AchievementsSnapshot entity.
-type AchievementsSnapshotDelete struct {
-	config
-	hooks    []Hook
-	mutation *AchievementsSnapshotMutation
-}
-
-// Where appends a list predicates to the AchievementsSnapshotDelete builder.
-func (asd *AchievementsSnapshotDelete) Where(ps ...predicate.AchievementsSnapshot) *AchievementsSnapshotDelete {
-	asd.mutation.Where(ps...)
-	return asd
-}
-
-// Exec executes the deletion query and returns how many vertices were deleted.
-func (asd *AchievementsSnapshotDelete) Exec(ctx context.Context) (int, error) {
-	return withHooks(ctx, asd.sqlExec, asd.mutation, asd.hooks)
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (asd *AchievementsSnapshotDelete) ExecX(ctx context.Context) int {
-	n, err := asd.Exec(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return n
-}
-
-func (asd *AchievementsSnapshotDelete) sqlExec(ctx context.Context) (int, error) {
-	_spec := sqlgraph.NewDeleteSpec(achievementssnapshot.Table, sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString))
-	if ps := asd.mutation.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	affected, err := sqlgraph.DeleteNodes(ctx, asd.driver, _spec)
-	if err != nil && sqlgraph.IsConstraintError(err) {
-		err = &ConstraintError{msg: err.Error(), wrap: err}
-	}
-	asd.mutation.done = true
-	return affected, err
-}
-
-// AchievementsSnapshotDeleteOne is the builder for deleting a single AchievementsSnapshot entity.
-type AchievementsSnapshotDeleteOne struct {
-	asd *AchievementsSnapshotDelete
-}
-
-// Where appends a list predicates to the AchievementsSnapshotDelete builder.
-func (asdo *AchievementsSnapshotDeleteOne) Where(ps ...predicate.AchievementsSnapshot) *AchievementsSnapshotDeleteOne {
-	asdo.asd.mutation.Where(ps...)
-	return asdo
-}
-
-// Exec executes the deletion query.
-func (asdo *AchievementsSnapshotDeleteOne) Exec(ctx context.Context) error {
-	n, err := asdo.asd.Exec(ctx)
-	switch {
-	case err != nil:
-		return err
-	case n == 0:
-		return &NotFoundError{achievementssnapshot.Label}
-	default:
-		return nil
-	}
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (asdo *AchievementsSnapshotDeleteOne) ExecX(ctx context.Context) {
-	if err := asdo.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
diff --git a/internal/database/ent/db/achievementssnapshot_query.go b/internal/database/ent/db/achievementssnapshot_query.go
deleted file mode 100644
index 74fe01be..00000000
--- a/internal/database/ent/db/achievementssnapshot_query.go
+++ /dev/null
@@ -1,627 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package db
-
-import (
-	"context"
-	"fmt"
-	"math"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/schema/field"
-	"github.com/cufee/aftermath/internal/database/ent/db/account"
-	"github.com/cufee/aftermath/internal/database/ent/db/achievementssnapshot"
-	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
-)
-
-// AchievementsSnapshotQuery is the builder for querying AchievementsSnapshot entities.
-type AchievementsSnapshotQuery struct {
-	config
-	ctx         *QueryContext
-	order       []achievementssnapshot.OrderOption
-	inters      []Interceptor
-	predicates  []predicate.AchievementsSnapshot
-	withAccount *AccountQuery
-	modifiers   []func(*sql.Selector)
-	// intermediate query (i.e. traversal path).
-	sql  *sql.Selector
-	path func(context.Context) (*sql.Selector, error)
-}
-
-// Where adds a new predicate for the AchievementsSnapshotQuery builder.
-func (asq *AchievementsSnapshotQuery) Where(ps ...predicate.AchievementsSnapshot) *AchievementsSnapshotQuery {
-	asq.predicates = append(asq.predicates, ps...)
-	return asq
-}
-
-// Limit the number of records to be returned by this query.
-func (asq *AchievementsSnapshotQuery) Limit(limit int) *AchievementsSnapshotQuery {
-	asq.ctx.Limit = &limit
-	return asq
-}
-
-// Offset to start from.
-func (asq *AchievementsSnapshotQuery) Offset(offset int) *AchievementsSnapshotQuery {
-	asq.ctx.Offset = &offset
-	return asq
-}
-
-// Unique configures the query builder to filter duplicate records on query.
-// By default, unique is set to true, and can be disabled using this method.
-func (asq *AchievementsSnapshotQuery) Unique(unique bool) *AchievementsSnapshotQuery {
-	asq.ctx.Unique = &unique
-	return asq
-}
-
-// Order specifies how the records should be ordered.
-func (asq *AchievementsSnapshotQuery) Order(o ...achievementssnapshot.OrderOption) *AchievementsSnapshotQuery {
-	asq.order = append(asq.order, o...)
-	return asq
-}
-
-// QueryAccount chains the current query on the "account" edge.
-func (asq *AchievementsSnapshotQuery) QueryAccount() *AccountQuery {
-	query := (&AccountClient{config: asq.config}).Query()
-	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
-		if err := asq.prepareQuery(ctx); err != nil {
-			return nil, err
-		}
-		selector := asq.sqlQuery(ctx)
-		if err := selector.Err(); err != nil {
-			return nil, err
-		}
-		step := sqlgraph.NewStep(
-			sqlgraph.From(achievementssnapshot.Table, achievementssnapshot.FieldID, selector),
-			sqlgraph.To(account.Table, account.FieldID),
-			sqlgraph.Edge(sqlgraph.M2O, true, achievementssnapshot.AccountTable, achievementssnapshot.AccountColumn),
-		)
-		fromU = sqlgraph.SetNeighbors(asq.driver.Dialect(), step)
-		return fromU, nil
-	}
-	return query
-}
-
-// First returns the first AchievementsSnapshot entity from the query.
-// Returns a *NotFoundError when no AchievementsSnapshot was found.
-func (asq *AchievementsSnapshotQuery) First(ctx context.Context) (*AchievementsSnapshot, error) {
-	nodes, err := asq.Limit(1).All(setContextOp(ctx, asq.ctx, "First"))
-	if err != nil {
-		return nil, err
-	}
-	if len(nodes) == 0 {
-		return nil, &NotFoundError{achievementssnapshot.Label}
-	}
-	return nodes[0], nil
-}
-
-// FirstX is like First, but panics if an error occurs.
-func (asq *AchievementsSnapshotQuery) FirstX(ctx context.Context) *AchievementsSnapshot {
-	node, err := asq.First(ctx)
-	if err != nil && !IsNotFound(err) {
-		panic(err)
-	}
-	return node
-}
-
-// FirstID returns the first AchievementsSnapshot ID from the query.
-// Returns a *NotFoundError when no AchievementsSnapshot ID was found.
-func (asq *AchievementsSnapshotQuery) FirstID(ctx context.Context) (id string, err error) {
-	var ids []string
-	if ids, err = asq.Limit(1).IDs(setContextOp(ctx, asq.ctx, "FirstID")); err != nil {
-		return
-	}
-	if len(ids) == 0 {
-		err = &NotFoundError{achievementssnapshot.Label}
-		return
-	}
-	return ids[0], nil
-}
-
-// FirstIDX is like FirstID, but panics if an error occurs.
-func (asq *AchievementsSnapshotQuery) FirstIDX(ctx context.Context) string {
-	id, err := asq.FirstID(ctx)
-	if err != nil && !IsNotFound(err) {
-		panic(err)
-	}
-	return id
-}
-
-// Only returns a single AchievementsSnapshot entity found by the query, ensuring it only returns one.
-// Returns a *NotSingularError when more than one AchievementsSnapshot entity is found.
-// Returns a *NotFoundError when no AchievementsSnapshot entities are found.
-func (asq *AchievementsSnapshotQuery) Only(ctx context.Context) (*AchievementsSnapshot, error) {
-	nodes, err := asq.Limit(2).All(setContextOp(ctx, asq.ctx, "Only"))
-	if err != nil {
-		return nil, err
-	}
-	switch len(nodes) {
-	case 1:
-		return nodes[0], nil
-	case 0:
-		return nil, &NotFoundError{achievementssnapshot.Label}
-	default:
-		return nil, &NotSingularError{achievementssnapshot.Label}
-	}
-}
-
-// OnlyX is like Only, but panics if an error occurs.
-func (asq *AchievementsSnapshotQuery) OnlyX(ctx context.Context) *AchievementsSnapshot {
-	node, err := asq.Only(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return node
-}
-
-// OnlyID is like Only, but returns the only AchievementsSnapshot ID in the query.
-// Returns a *NotSingularError when more than one AchievementsSnapshot ID is found.
-// Returns a *NotFoundError when no entities are found.
-func (asq *AchievementsSnapshotQuery) OnlyID(ctx context.Context) (id string, err error) {
-	var ids []string
-	if ids, err = asq.Limit(2).IDs(setContextOp(ctx, asq.ctx, "OnlyID")); err != nil {
-		return
-	}
-	switch len(ids) {
-	case 1:
-		id = ids[0]
-	case 0:
-		err = &NotFoundError{achievementssnapshot.Label}
-	default:
-		err = &NotSingularError{achievementssnapshot.Label}
-	}
-	return
-}
-
-// OnlyIDX is like OnlyID, but panics if an error occurs.
-func (asq *AchievementsSnapshotQuery) OnlyIDX(ctx context.Context) string {
-	id, err := asq.OnlyID(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return id
-}
-
-// All executes the query and returns a list of AchievementsSnapshots.
-func (asq *AchievementsSnapshotQuery) All(ctx context.Context) ([]*AchievementsSnapshot, error) {
-	ctx = setContextOp(ctx, asq.ctx, "All")
-	if err := asq.prepareQuery(ctx); err != nil {
-		return nil, err
-	}
-	qr := querierAll[[]*AchievementsSnapshot, *AchievementsSnapshotQuery]()
-	return withInterceptors[[]*AchievementsSnapshot](ctx, asq, qr, asq.inters)
-}
-
-// AllX is like All, but panics if an error occurs.
-func (asq *AchievementsSnapshotQuery) AllX(ctx context.Context) []*AchievementsSnapshot {
-	nodes, err := asq.All(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return nodes
-}
-
-// IDs executes the query and returns a list of AchievementsSnapshot IDs.
-func (asq *AchievementsSnapshotQuery) IDs(ctx context.Context) (ids []string, err error) {
-	if asq.ctx.Unique == nil && asq.path != nil {
-		asq.Unique(true)
-	}
-	ctx = setContextOp(ctx, asq.ctx, "IDs")
-	if err = asq.Select(achievementssnapshot.FieldID).Scan(ctx, &ids); err != nil {
-		return nil, err
-	}
-	return ids, nil
-}
-
-// IDsX is like IDs, but panics if an error occurs.
-func (asq *AchievementsSnapshotQuery) IDsX(ctx context.Context) []string {
-	ids, err := asq.IDs(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return ids
-}
-
-// Count returns the count of the given query.
-func (asq *AchievementsSnapshotQuery) Count(ctx context.Context) (int, error) {
-	ctx = setContextOp(ctx, asq.ctx, "Count")
-	if err := asq.prepareQuery(ctx); err != nil {
-		return 0, err
-	}
-	return withInterceptors[int](ctx, asq, querierCount[*AchievementsSnapshotQuery](), asq.inters)
-}
-
-// CountX is like Count, but panics if an error occurs.
-func (asq *AchievementsSnapshotQuery) CountX(ctx context.Context) int {
-	count, err := asq.Count(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return count
-}
-
-// Exist returns true if the query has elements in the graph.
-func (asq *AchievementsSnapshotQuery) Exist(ctx context.Context) (bool, error) {
-	ctx = setContextOp(ctx, asq.ctx, "Exist")
-	switch _, err := asq.FirstID(ctx); {
-	case IsNotFound(err):
-		return false, nil
-	case err != nil:
-		return false, fmt.Errorf("db: check existence: %w", err)
-	default:
-		return true, nil
-	}
-}
-
-// ExistX is like Exist, but panics if an error occurs.
-func (asq *AchievementsSnapshotQuery) ExistX(ctx context.Context) bool {
-	exist, err := asq.Exist(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return exist
-}
-
-// Clone returns a duplicate of the AchievementsSnapshotQuery builder, including all associated steps. It can be
-// used to prepare common query builders and use them differently after the clone is made.
-func (asq *AchievementsSnapshotQuery) Clone() *AchievementsSnapshotQuery {
-	if asq == nil {
-		return nil
-	}
-	return &AchievementsSnapshotQuery{
-		config:      asq.config,
-		ctx:         asq.ctx.Clone(),
-		order:       append([]achievementssnapshot.OrderOption{}, asq.order...),
-		inters:      append([]Interceptor{}, asq.inters...),
-		predicates:  append([]predicate.AchievementsSnapshot{}, asq.predicates...),
-		withAccount: asq.withAccount.Clone(),
-		// clone intermediate query.
-		sql:  asq.sql.Clone(),
-		path: asq.path,
-	}
-}
-
-// WithAccount tells the query-builder to eager-load the nodes that are connected to
-// the "account" edge. The optional arguments are used to configure the query builder of the edge.
-func (asq *AchievementsSnapshotQuery) WithAccount(opts ...func(*AccountQuery)) *AchievementsSnapshotQuery {
-	query := (&AccountClient{config: asq.config}).Query()
-	for _, opt := range opts {
-		opt(query)
-	}
-	asq.withAccount = query
-	return asq
-}
-
-// GroupBy is used to group vertices by one or more fields/columns.
-// It is often used with aggregate functions, like: count, max, mean, min, sum.
-//
-// Example:
-//
-//	var v []struct {
-//		CreatedAt time.Time `json:"created_at,omitempty"`
-//		Count int `json:"count,omitempty"`
-//	}
-//
-//	client.AchievementsSnapshot.Query().
-//		GroupBy(achievementssnapshot.FieldCreatedAt).
-//		Aggregate(db.Count()).
-//		Scan(ctx, &v)
-func (asq *AchievementsSnapshotQuery) GroupBy(field string, fields ...string) *AchievementsSnapshotGroupBy {
-	asq.ctx.Fields = append([]string{field}, fields...)
-	grbuild := &AchievementsSnapshotGroupBy{build: asq}
-	grbuild.flds = &asq.ctx.Fields
-	grbuild.label = achievementssnapshot.Label
-	grbuild.scan = grbuild.Scan
-	return grbuild
-}
-
-// Select allows the selection one or more fields/columns for the given query,
-// instead of selecting all fields in the entity.
-//
-// Example:
-//
-//	var v []struct {
-//		CreatedAt time.Time `json:"created_at,omitempty"`
-//	}
-//
-//	client.AchievementsSnapshot.Query().
-//		Select(achievementssnapshot.FieldCreatedAt).
-//		Scan(ctx, &v)
-func (asq *AchievementsSnapshotQuery) Select(fields ...string) *AchievementsSnapshotSelect {
-	asq.ctx.Fields = append(asq.ctx.Fields, fields...)
-	sbuild := &AchievementsSnapshotSelect{AchievementsSnapshotQuery: asq}
-	sbuild.label = achievementssnapshot.Label
-	sbuild.flds, sbuild.scan = &asq.ctx.Fields, sbuild.Scan
-	return sbuild
-}
-
-// Aggregate returns a AchievementsSnapshotSelect configured with the given aggregations.
-func (asq *AchievementsSnapshotQuery) Aggregate(fns ...AggregateFunc) *AchievementsSnapshotSelect {
-	return asq.Select().Aggregate(fns...)
-}
-
-func (asq *AchievementsSnapshotQuery) prepareQuery(ctx context.Context) error {
-	for _, inter := range asq.inters {
-		if inter == nil {
-			return fmt.Errorf("db: uninitialized interceptor (forgotten import db/runtime?)")
-		}
-		if trv, ok := inter.(Traverser); ok {
-			if err := trv.Traverse(ctx, asq); err != nil {
-				return err
-			}
-		}
-	}
-	for _, f := range asq.ctx.Fields {
-		if !achievementssnapshot.ValidColumn(f) {
-			return &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
-		}
-	}
-	if asq.path != nil {
-		prev, err := asq.path(ctx)
-		if err != nil {
-			return err
-		}
-		asq.sql = prev
-	}
-	return nil
-}
-
-func (asq *AchievementsSnapshotQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*AchievementsSnapshot, error) {
-	var (
-		nodes       = []*AchievementsSnapshot{}
-		_spec       = asq.querySpec()
-		loadedTypes = [1]bool{
-			asq.withAccount != nil,
-		}
-	)
-	_spec.ScanValues = func(columns []string) ([]any, error) {
-		return (*AchievementsSnapshot).scanValues(nil, columns)
-	}
-	_spec.Assign = func(columns []string, values []any) error {
-		node := &AchievementsSnapshot{config: asq.config}
-		nodes = append(nodes, node)
-		node.Edges.loadedTypes = loadedTypes
-		return node.assignValues(columns, values)
-	}
-	if len(asq.modifiers) > 0 {
-		_spec.Modifiers = asq.modifiers
-	}
-	for i := range hooks {
-		hooks[i](ctx, _spec)
-	}
-	if err := sqlgraph.QueryNodes(ctx, asq.driver, _spec); err != nil {
-		return nil, err
-	}
-	if len(nodes) == 0 {
-		return nodes, nil
-	}
-	if query := asq.withAccount; query != nil {
-		if err := asq.loadAccount(ctx, query, nodes, nil,
-			func(n *AchievementsSnapshot, e *Account) { n.Edges.Account = e }); err != nil {
-			return nil, err
-		}
-	}
-	return nodes, nil
-}
-
-func (asq *AchievementsSnapshotQuery) loadAccount(ctx context.Context, query *AccountQuery, nodes []*AchievementsSnapshot, init func(*AchievementsSnapshot), assign func(*AchievementsSnapshot, *Account)) error {
-	ids := make([]string, 0, len(nodes))
-	nodeids := make(map[string][]*AchievementsSnapshot)
-	for i := range nodes {
-		fk := nodes[i].AccountID
-		if _, ok := nodeids[fk]; !ok {
-			ids = append(ids, fk)
-		}
-		nodeids[fk] = append(nodeids[fk], nodes[i])
-	}
-	if len(ids) == 0 {
-		return nil
-	}
-	query.Where(account.IDIn(ids...))
-	neighbors, err := query.All(ctx)
-	if err != nil {
-		return err
-	}
-	for _, n := range neighbors {
-		nodes, ok := nodeids[n.ID]
-		if !ok {
-			return fmt.Errorf(`unexpected foreign-key "account_id" returned %v`, n.ID)
-		}
-		for i := range nodes {
-			assign(nodes[i], n)
-		}
-	}
-	return nil
-}
-
-func (asq *AchievementsSnapshotQuery) sqlCount(ctx context.Context) (int, error) {
-	_spec := asq.querySpec()
-	if len(asq.modifiers) > 0 {
-		_spec.Modifiers = asq.modifiers
-	}
-	_spec.Node.Columns = asq.ctx.Fields
-	if len(asq.ctx.Fields) > 0 {
-		_spec.Unique = asq.ctx.Unique != nil && *asq.ctx.Unique
-	}
-	return sqlgraph.CountNodes(ctx, asq.driver, _spec)
-}
-
-func (asq *AchievementsSnapshotQuery) querySpec() *sqlgraph.QuerySpec {
-	_spec := sqlgraph.NewQuerySpec(achievementssnapshot.Table, achievementssnapshot.Columns, sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString))
-	_spec.From = asq.sql
-	if unique := asq.ctx.Unique; unique != nil {
-		_spec.Unique = *unique
-	} else if asq.path != nil {
-		_spec.Unique = true
-	}
-	if fields := asq.ctx.Fields; len(fields) > 0 {
-		_spec.Node.Columns = make([]string, 0, len(fields))
-		_spec.Node.Columns = append(_spec.Node.Columns, achievementssnapshot.FieldID)
-		for i := range fields {
-			if fields[i] != achievementssnapshot.FieldID {
-				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
-			}
-		}
-		if asq.withAccount != nil {
-			_spec.Node.AddColumnOnce(achievementssnapshot.FieldAccountID)
-		}
-	}
-	if ps := asq.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	if limit := asq.ctx.Limit; limit != nil {
-		_spec.Limit = *limit
-	}
-	if offset := asq.ctx.Offset; offset != nil {
-		_spec.Offset = *offset
-	}
-	if ps := asq.order; len(ps) > 0 {
-		_spec.Order = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	return _spec
-}
-
-func (asq *AchievementsSnapshotQuery) sqlQuery(ctx context.Context) *sql.Selector {
-	builder := sql.Dialect(asq.driver.Dialect())
-	t1 := builder.Table(achievementssnapshot.Table)
-	columns := asq.ctx.Fields
-	if len(columns) == 0 {
-		columns = achievementssnapshot.Columns
-	}
-	selector := builder.Select(t1.Columns(columns...)...).From(t1)
-	if asq.sql != nil {
-		selector = asq.sql
-		selector.Select(selector.Columns(columns...)...)
-	}
-	if asq.ctx.Unique != nil && *asq.ctx.Unique {
-		selector.Distinct()
-	}
-	for _, m := range asq.modifiers {
-		m(selector)
-	}
-	for _, p := range asq.predicates {
-		p(selector)
-	}
-	for _, p := range asq.order {
-		p(selector)
-	}
-	if offset := asq.ctx.Offset; offset != nil {
-		// limit is mandatory for offset clause. We start
-		// with default value, and override it below if needed.
-		selector.Offset(*offset).Limit(math.MaxInt32)
-	}
-	if limit := asq.ctx.Limit; limit != nil {
-		selector.Limit(*limit)
-	}
-	return selector
-}
-
-// Modify adds a query modifier for attaching custom logic to queries.
-func (asq *AchievementsSnapshotQuery) Modify(modifiers ...func(s *sql.Selector)) *AchievementsSnapshotSelect {
-	asq.modifiers = append(asq.modifiers, modifiers...)
-	return asq.Select()
-}
-
-// AchievementsSnapshotGroupBy is the group-by builder for AchievementsSnapshot entities.
-type AchievementsSnapshotGroupBy struct {
-	selector
-	build *AchievementsSnapshotQuery
-}
-
-// Aggregate adds the given aggregation functions to the group-by query.
-func (asgb *AchievementsSnapshotGroupBy) Aggregate(fns ...AggregateFunc) *AchievementsSnapshotGroupBy {
-	asgb.fns = append(asgb.fns, fns...)
-	return asgb
-}
-
-// Scan applies the selector query and scans the result into the given value.
-func (asgb *AchievementsSnapshotGroupBy) Scan(ctx context.Context, v any) error {
-	ctx = setContextOp(ctx, asgb.build.ctx, "GroupBy")
-	if err := asgb.build.prepareQuery(ctx); err != nil {
-		return err
-	}
-	return scanWithInterceptors[*AchievementsSnapshotQuery, *AchievementsSnapshotGroupBy](ctx, asgb.build, asgb, asgb.build.inters, v)
-}
-
-func (asgb *AchievementsSnapshotGroupBy) sqlScan(ctx context.Context, root *AchievementsSnapshotQuery, v any) error {
-	selector := root.sqlQuery(ctx).Select()
-	aggregation := make([]string, 0, len(asgb.fns))
-	for _, fn := range asgb.fns {
-		aggregation = append(aggregation, fn(selector))
-	}
-	if len(selector.SelectedColumns()) == 0 {
-		columns := make([]string, 0, len(*asgb.flds)+len(asgb.fns))
-		for _, f := range *asgb.flds {
-			columns = append(columns, selector.C(f))
-		}
-		columns = append(columns, aggregation...)
-		selector.Select(columns...)
-	}
-	selector.GroupBy(selector.Columns(*asgb.flds...)...)
-	if err := selector.Err(); err != nil {
-		return err
-	}
-	rows := &sql.Rows{}
-	query, args := selector.Query()
-	if err := asgb.build.driver.Query(ctx, query, args, rows); err != nil {
-		return err
-	}
-	defer rows.Close()
-	return sql.ScanSlice(rows, v)
-}
-
-// AchievementsSnapshotSelect is the builder for selecting fields of AchievementsSnapshot entities.
-type AchievementsSnapshotSelect struct {
-	*AchievementsSnapshotQuery
-	selector
-}
-
-// Aggregate adds the given aggregation functions to the selector query.
-func (ass *AchievementsSnapshotSelect) Aggregate(fns ...AggregateFunc) *AchievementsSnapshotSelect {
-	ass.fns = append(ass.fns, fns...)
-	return ass
-}
-
-// Scan applies the selector query and scans the result into the given value.
-func (ass *AchievementsSnapshotSelect) Scan(ctx context.Context, v any) error {
-	ctx = setContextOp(ctx, ass.ctx, "Select")
-	if err := ass.prepareQuery(ctx); err != nil {
-		return err
-	}
-	return scanWithInterceptors[*AchievementsSnapshotQuery, *AchievementsSnapshotSelect](ctx, ass.AchievementsSnapshotQuery, ass, ass.inters, v)
-}
-
-func (ass *AchievementsSnapshotSelect) sqlScan(ctx context.Context, root *AchievementsSnapshotQuery, v any) error {
-	selector := root.sqlQuery(ctx)
-	aggregation := make([]string, 0, len(ass.fns))
-	for _, fn := range ass.fns {
-		aggregation = append(aggregation, fn(selector))
-	}
-	switch n := len(*ass.selector.flds); {
-	case n == 0 && len(aggregation) > 0:
-		selector.Select(aggregation...)
-	case n != 0 && len(aggregation) > 0:
-		selector.AppendSelect(aggregation...)
-	}
-	rows := &sql.Rows{}
-	query, args := selector.Query()
-	if err := ass.driver.Query(ctx, query, args, rows); err != nil {
-		return err
-	}
-	defer rows.Close()
-	return sql.ScanSlice(rows, v)
-}
-
-// Modify adds a query modifier for attaching custom logic to queries.
-func (ass *AchievementsSnapshotSelect) Modify(modifiers ...func(s *sql.Selector)) *AchievementsSnapshotSelect {
-	ass.modifiers = append(ass.modifiers, modifiers...)
-	return ass
-}
diff --git a/internal/database/ent/db/achievementssnapshot_update.go b/internal/database/ent/db/achievementssnapshot_update.go
deleted file mode 100644
index 43b79916..00000000
--- a/internal/database/ent/db/achievementssnapshot_update.go
+++ /dev/null
@@ -1,462 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package db
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"time"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/schema/field"
-	"github.com/cufee/aftermath/internal/database/ent/db/achievementssnapshot"
-	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
-	"github.com/cufee/aftermath/internal/database/models"
-	"github.com/cufee/am-wg-proxy-next/v2/types"
-)
-
-// AchievementsSnapshotUpdate is the builder for updating AchievementsSnapshot entities.
-type AchievementsSnapshotUpdate struct {
-	config
-	hooks     []Hook
-	mutation  *AchievementsSnapshotMutation
-	modifiers []func(*sql.UpdateBuilder)
-}
-
-// Where appends a list predicates to the AchievementsSnapshotUpdate builder.
-func (asu *AchievementsSnapshotUpdate) Where(ps ...predicate.AchievementsSnapshot) *AchievementsSnapshotUpdate {
-	asu.mutation.Where(ps...)
-	return asu
-}
-
-// SetUpdatedAt sets the "updated_at" field.
-func (asu *AchievementsSnapshotUpdate) SetUpdatedAt(t time.Time) *AchievementsSnapshotUpdate {
-	asu.mutation.SetUpdatedAt(t)
-	return asu
-}
-
-// SetType sets the "type" field.
-func (asu *AchievementsSnapshotUpdate) SetType(mt models.SnapshotType) *AchievementsSnapshotUpdate {
-	asu.mutation.SetType(mt)
-	return asu
-}
-
-// SetNillableType sets the "type" field if the given value is not nil.
-func (asu *AchievementsSnapshotUpdate) SetNillableType(mt *models.SnapshotType) *AchievementsSnapshotUpdate {
-	if mt != nil {
-		asu.SetType(*mt)
-	}
-	return asu
-}
-
-// SetReferenceID sets the "reference_id" field.
-func (asu *AchievementsSnapshotUpdate) SetReferenceID(s string) *AchievementsSnapshotUpdate {
-	asu.mutation.SetReferenceID(s)
-	return asu
-}
-
-// SetNillableReferenceID sets the "reference_id" field if the given value is not nil.
-func (asu *AchievementsSnapshotUpdate) SetNillableReferenceID(s *string) *AchievementsSnapshotUpdate {
-	if s != nil {
-		asu.SetReferenceID(*s)
-	}
-	return asu
-}
-
-// SetBattles sets the "battles" field.
-func (asu *AchievementsSnapshotUpdate) SetBattles(i int) *AchievementsSnapshotUpdate {
-	asu.mutation.ResetBattles()
-	asu.mutation.SetBattles(i)
-	return asu
-}
-
-// SetNillableBattles sets the "battles" field if the given value is not nil.
-func (asu *AchievementsSnapshotUpdate) SetNillableBattles(i *int) *AchievementsSnapshotUpdate {
-	if i != nil {
-		asu.SetBattles(*i)
-	}
-	return asu
-}
-
-// AddBattles adds i to the "battles" field.
-func (asu *AchievementsSnapshotUpdate) AddBattles(i int) *AchievementsSnapshotUpdate {
-	asu.mutation.AddBattles(i)
-	return asu
-}
-
-// SetLastBattleTime sets the "last_battle_time" field.
-func (asu *AchievementsSnapshotUpdate) SetLastBattleTime(t time.Time) *AchievementsSnapshotUpdate {
-	asu.mutation.SetLastBattleTime(t)
-	return asu
-}
-
-// SetNillableLastBattleTime sets the "last_battle_time" field if the given value is not nil.
-func (asu *AchievementsSnapshotUpdate) SetNillableLastBattleTime(t *time.Time) *AchievementsSnapshotUpdate {
-	if t != nil {
-		asu.SetLastBattleTime(*t)
-	}
-	return asu
-}
-
-// SetData sets the "data" field.
-func (asu *AchievementsSnapshotUpdate) SetData(tf types.AchievementsFrame) *AchievementsSnapshotUpdate {
-	asu.mutation.SetData(tf)
-	return asu
-}
-
-// SetNillableData sets the "data" field if the given value is not nil.
-func (asu *AchievementsSnapshotUpdate) SetNillableData(tf *types.AchievementsFrame) *AchievementsSnapshotUpdate {
-	if tf != nil {
-		asu.SetData(*tf)
-	}
-	return asu
-}
-
-// Mutation returns the AchievementsSnapshotMutation object of the builder.
-func (asu *AchievementsSnapshotUpdate) Mutation() *AchievementsSnapshotMutation {
-	return asu.mutation
-}
-
-// Save executes the query and returns the number of nodes affected by the update operation.
-func (asu *AchievementsSnapshotUpdate) Save(ctx context.Context) (int, error) {
-	asu.defaults()
-	return withHooks(ctx, asu.sqlSave, asu.mutation, asu.hooks)
-}
-
-// SaveX is like Save, but panics if an error occurs.
-func (asu *AchievementsSnapshotUpdate) SaveX(ctx context.Context) int {
-	affected, err := asu.Save(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return affected
-}
-
-// Exec executes the query.
-func (asu *AchievementsSnapshotUpdate) Exec(ctx context.Context) error {
-	_, err := asu.Save(ctx)
-	return err
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (asu *AchievementsSnapshotUpdate) ExecX(ctx context.Context) {
-	if err := asu.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
-
-// defaults sets the default values of the builder before save.
-func (asu *AchievementsSnapshotUpdate) defaults() {
-	if _, ok := asu.mutation.UpdatedAt(); !ok {
-		v := achievementssnapshot.UpdateDefaultUpdatedAt()
-		asu.mutation.SetUpdatedAt(v)
-	}
-}
-
-// check runs all checks and user-defined validators on the builder.
-func (asu *AchievementsSnapshotUpdate) check() error {
-	if v, ok := asu.mutation.GetType(); ok {
-		if err := achievementssnapshot.TypeValidator(v); err != nil {
-			return &ValidationError{Name: "type", err: fmt.Errorf(`db: validator failed for field "AchievementsSnapshot.type": %w`, err)}
-		}
-	}
-	if v, ok := asu.mutation.ReferenceID(); ok {
-		if err := achievementssnapshot.ReferenceIDValidator(v); err != nil {
-			return &ValidationError{Name: "reference_id", err: fmt.Errorf(`db: validator failed for field "AchievementsSnapshot.reference_id": %w`, err)}
-		}
-	}
-	if _, ok := asu.mutation.AccountID(); asu.mutation.AccountCleared() && !ok {
-		return errors.New(`db: clearing a required unique edge "AchievementsSnapshot.account"`)
-	}
-	return nil
-}
-
-// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
-func (asu *AchievementsSnapshotUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *AchievementsSnapshotUpdate {
-	asu.modifiers = append(asu.modifiers, modifiers...)
-	return asu
-}
-
-func (asu *AchievementsSnapshotUpdate) sqlSave(ctx context.Context) (n int, err error) {
-	if err := asu.check(); err != nil {
-		return n, err
-	}
-	_spec := sqlgraph.NewUpdateSpec(achievementssnapshot.Table, achievementssnapshot.Columns, sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString))
-	if ps := asu.mutation.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	if value, ok := asu.mutation.UpdatedAt(); ok {
-		_spec.SetField(achievementssnapshot.FieldUpdatedAt, field.TypeTime, value)
-	}
-	if value, ok := asu.mutation.GetType(); ok {
-		_spec.SetField(achievementssnapshot.FieldType, field.TypeEnum, value)
-	}
-	if value, ok := asu.mutation.ReferenceID(); ok {
-		_spec.SetField(achievementssnapshot.FieldReferenceID, field.TypeString, value)
-	}
-	if value, ok := asu.mutation.Battles(); ok {
-		_spec.SetField(achievementssnapshot.FieldBattles, field.TypeInt, value)
-	}
-	if value, ok := asu.mutation.AddedBattles(); ok {
-		_spec.AddField(achievementssnapshot.FieldBattles, field.TypeInt, value)
-	}
-	if value, ok := asu.mutation.LastBattleTime(); ok {
-		_spec.SetField(achievementssnapshot.FieldLastBattleTime, field.TypeTime, value)
-	}
-	if value, ok := asu.mutation.Data(); ok {
-		_spec.SetField(achievementssnapshot.FieldData, field.TypeJSON, value)
-	}
-	_spec.AddModifiers(asu.modifiers...)
-	if n, err = sqlgraph.UpdateNodes(ctx, asu.driver, _spec); err != nil {
-		if _, ok := err.(*sqlgraph.NotFoundError); ok {
-			err = &NotFoundError{achievementssnapshot.Label}
-		} else if sqlgraph.IsConstraintError(err) {
-			err = &ConstraintError{msg: err.Error(), wrap: err}
-		}
-		return 0, err
-	}
-	asu.mutation.done = true
-	return n, nil
-}
-
-// AchievementsSnapshotUpdateOne is the builder for updating a single AchievementsSnapshot entity.
-type AchievementsSnapshotUpdateOne struct {
-	config
-	fields    []string
-	hooks     []Hook
-	mutation  *AchievementsSnapshotMutation
-	modifiers []func(*sql.UpdateBuilder)
-}
-
-// SetUpdatedAt sets the "updated_at" field.
-func (asuo *AchievementsSnapshotUpdateOne) SetUpdatedAt(t time.Time) *AchievementsSnapshotUpdateOne {
-	asuo.mutation.SetUpdatedAt(t)
-	return asuo
-}
-
-// SetType sets the "type" field.
-func (asuo *AchievementsSnapshotUpdateOne) SetType(mt models.SnapshotType) *AchievementsSnapshotUpdateOne {
-	asuo.mutation.SetType(mt)
-	return asuo
-}
-
-// SetNillableType sets the "type" field if the given value is not nil.
-func (asuo *AchievementsSnapshotUpdateOne) SetNillableType(mt *models.SnapshotType) *AchievementsSnapshotUpdateOne {
-	if mt != nil {
-		asuo.SetType(*mt)
-	}
-	return asuo
-}
-
-// SetReferenceID sets the "reference_id" field.
-func (asuo *AchievementsSnapshotUpdateOne) SetReferenceID(s string) *AchievementsSnapshotUpdateOne {
-	asuo.mutation.SetReferenceID(s)
-	return asuo
-}
-
-// SetNillableReferenceID sets the "reference_id" field if the given value is not nil.
-func (asuo *AchievementsSnapshotUpdateOne) SetNillableReferenceID(s *string) *AchievementsSnapshotUpdateOne {
-	if s != nil {
-		asuo.SetReferenceID(*s)
-	}
-	return asuo
-}
-
-// SetBattles sets the "battles" field.
-func (asuo *AchievementsSnapshotUpdateOne) SetBattles(i int) *AchievementsSnapshotUpdateOne {
-	asuo.mutation.ResetBattles()
-	asuo.mutation.SetBattles(i)
-	return asuo
-}
-
-// SetNillableBattles sets the "battles" field if the given value is not nil.
-func (asuo *AchievementsSnapshotUpdateOne) SetNillableBattles(i *int) *AchievementsSnapshotUpdateOne {
-	if i != nil {
-		asuo.SetBattles(*i)
-	}
-	return asuo
-}
-
-// AddBattles adds i to the "battles" field.
-func (asuo *AchievementsSnapshotUpdateOne) AddBattles(i int) *AchievementsSnapshotUpdateOne {
-	asuo.mutation.AddBattles(i)
-	return asuo
-}
-
-// SetLastBattleTime sets the "last_battle_time" field.
-func (asuo *AchievementsSnapshotUpdateOne) SetLastBattleTime(t time.Time) *AchievementsSnapshotUpdateOne {
-	asuo.mutation.SetLastBattleTime(t)
-	return asuo
-}
-
-// SetNillableLastBattleTime sets the "last_battle_time" field if the given value is not nil.
-func (asuo *AchievementsSnapshotUpdateOne) SetNillableLastBattleTime(t *time.Time) *AchievementsSnapshotUpdateOne {
-	if t != nil {
-		asuo.SetLastBattleTime(*t)
-	}
-	return asuo
-}
-
-// SetData sets the "data" field.
-func (asuo *AchievementsSnapshotUpdateOne) SetData(tf types.AchievementsFrame) *AchievementsSnapshotUpdateOne {
-	asuo.mutation.SetData(tf)
-	return asuo
-}
-
-// SetNillableData sets the "data" field if the given value is not nil.
-func (asuo *AchievementsSnapshotUpdateOne) SetNillableData(tf *types.AchievementsFrame) *AchievementsSnapshotUpdateOne {
-	if tf != nil {
-		asuo.SetData(*tf)
-	}
-	return asuo
-}
-
-// Mutation returns the AchievementsSnapshotMutation object of the builder.
-func (asuo *AchievementsSnapshotUpdateOne) Mutation() *AchievementsSnapshotMutation {
-	return asuo.mutation
-}
-
-// Where appends a list predicates to the AchievementsSnapshotUpdate builder.
-func (asuo *AchievementsSnapshotUpdateOne) Where(ps ...predicate.AchievementsSnapshot) *AchievementsSnapshotUpdateOne {
-	asuo.mutation.Where(ps...)
-	return asuo
-}
-
-// Select allows selecting one or more fields (columns) of the returned entity.
-// The default is selecting all fields defined in the entity schema.
-func (asuo *AchievementsSnapshotUpdateOne) Select(field string, fields ...string) *AchievementsSnapshotUpdateOne {
-	asuo.fields = append([]string{field}, fields...)
-	return asuo
-}
-
-// Save executes the query and returns the updated AchievementsSnapshot entity.
-func (asuo *AchievementsSnapshotUpdateOne) Save(ctx context.Context) (*AchievementsSnapshot, error) {
-	asuo.defaults()
-	return withHooks(ctx, asuo.sqlSave, asuo.mutation, asuo.hooks)
-}
-
-// SaveX is like Save, but panics if an error occurs.
-func (asuo *AchievementsSnapshotUpdateOne) SaveX(ctx context.Context) *AchievementsSnapshot {
-	node, err := asuo.Save(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return node
-}
-
-// Exec executes the query on the entity.
-func (asuo *AchievementsSnapshotUpdateOne) Exec(ctx context.Context) error {
-	_, err := asuo.Save(ctx)
-	return err
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (asuo *AchievementsSnapshotUpdateOne) ExecX(ctx context.Context) {
-	if err := asuo.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
-
-// defaults sets the default values of the builder before save.
-func (asuo *AchievementsSnapshotUpdateOne) defaults() {
-	if _, ok := asuo.mutation.UpdatedAt(); !ok {
-		v := achievementssnapshot.UpdateDefaultUpdatedAt()
-		asuo.mutation.SetUpdatedAt(v)
-	}
-}
-
-// check runs all checks and user-defined validators on the builder.
-func (asuo *AchievementsSnapshotUpdateOne) check() error {
-	if v, ok := asuo.mutation.GetType(); ok {
-		if err := achievementssnapshot.TypeValidator(v); err != nil {
-			return &ValidationError{Name: "type", err: fmt.Errorf(`db: validator failed for field "AchievementsSnapshot.type": %w`, err)}
-		}
-	}
-	if v, ok := asuo.mutation.ReferenceID(); ok {
-		if err := achievementssnapshot.ReferenceIDValidator(v); err != nil {
-			return &ValidationError{Name: "reference_id", err: fmt.Errorf(`db: validator failed for field "AchievementsSnapshot.reference_id": %w`, err)}
-		}
-	}
-	if _, ok := asuo.mutation.AccountID(); asuo.mutation.AccountCleared() && !ok {
-		return errors.New(`db: clearing a required unique edge "AchievementsSnapshot.account"`)
-	}
-	return nil
-}
-
-// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
-func (asuo *AchievementsSnapshotUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *AchievementsSnapshotUpdateOne {
-	asuo.modifiers = append(asuo.modifiers, modifiers...)
-	return asuo
-}
-
-func (asuo *AchievementsSnapshotUpdateOne) sqlSave(ctx context.Context) (_node *AchievementsSnapshot, err error) {
-	if err := asuo.check(); err != nil {
-		return _node, err
-	}
-	_spec := sqlgraph.NewUpdateSpec(achievementssnapshot.Table, achievementssnapshot.Columns, sqlgraph.NewFieldSpec(achievementssnapshot.FieldID, field.TypeString))
-	id, ok := asuo.mutation.ID()
-	if !ok {
-		return nil, &ValidationError{Name: "id", err: errors.New(`db: missing "AchievementsSnapshot.id" for update`)}
-	}
-	_spec.Node.ID.Value = id
-	if fields := asuo.fields; len(fields) > 0 {
-		_spec.Node.Columns = make([]string, 0, len(fields))
-		_spec.Node.Columns = append(_spec.Node.Columns, achievementssnapshot.FieldID)
-		for _, f := range fields {
-			if !achievementssnapshot.ValidColumn(f) {
-				return nil, &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
-			}
-			if f != achievementssnapshot.FieldID {
-				_spec.Node.Columns = append(_spec.Node.Columns, f)
-			}
-		}
-	}
-	if ps := asuo.mutation.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	if value, ok := asuo.mutation.UpdatedAt(); ok {
-		_spec.SetField(achievementssnapshot.FieldUpdatedAt, field.TypeTime, value)
-	}
-	if value, ok := asuo.mutation.GetType(); ok {
-		_spec.SetField(achievementssnapshot.FieldType, field.TypeEnum, value)
-	}
-	if value, ok := asuo.mutation.ReferenceID(); ok {
-		_spec.SetField(achievementssnapshot.FieldReferenceID, field.TypeString, value)
-	}
-	if value, ok := asuo.mutation.Battles(); ok {
-		_spec.SetField(achievementssnapshot.FieldBattles, field.TypeInt, value)
-	}
-	if value, ok := asuo.mutation.AddedBattles(); ok {
-		_spec.AddField(achievementssnapshot.FieldBattles, field.TypeInt, value)
-	}
-	if value, ok := asuo.mutation.LastBattleTime(); ok {
-		_spec.SetField(achievementssnapshot.FieldLastBattleTime, field.TypeTime, value)
-	}
-	if value, ok := asuo.mutation.Data(); ok {
-		_spec.SetField(achievementssnapshot.FieldData, field.TypeJSON, value)
-	}
-	_spec.AddModifiers(asuo.modifiers...)
-	_node = &AchievementsSnapshot{config: asuo.config}
-	_spec.Assign = _node.assignValues
-	_spec.ScanValues = _node.scanValues
-	if err = sqlgraph.UpdateNode(ctx, asuo.driver, _spec); err != nil {
-		if _, ok := err.(*sqlgraph.NotFoundError); ok {
-			err = &NotFoundError{achievementssnapshot.Label}
-		} else if sqlgraph.IsConstraintError(err) {
-			err = &ConstraintError{msg: err.Error(), wrap: err}
-		}
-		return nil, err
-	}
-	asuo.mutation.done = true
-	return _node, nil
-}
diff --git a/internal/database/ent/db/client.go b/internal/database/ent/db/client.go
index 67301ef3..e1257af3 100644
--- a/internal/database/ent/db/client.go
+++ b/internal/database/ent/db/client.go
@@ -17,7 +17,6 @@ import (
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"github.com/cufee/aftermath/internal/database/ent/db/account"
 	"github.com/cufee/aftermath/internal/database/ent/db/accountsnapshot"
-	"github.com/cufee/aftermath/internal/database/ent/db/achievementssnapshot"
 	"github.com/cufee/aftermath/internal/database/ent/db/appconfiguration"
 	"github.com/cufee/aftermath/internal/database/ent/db/applicationcommand"
 	"github.com/cufee/aftermath/internal/database/ent/db/authnonce"
@@ -46,8 +45,6 @@ type Client struct {
 	Account *AccountClient
 	// AccountSnapshot is the client for interacting with the AccountSnapshot builders.
 	AccountSnapshot *AccountSnapshotClient
-	// AchievementsSnapshot is the client for interacting with the AchievementsSnapshot builders.
-	AchievementsSnapshot *AchievementsSnapshotClient
 	// AppConfiguration is the client for interacting with the AppConfiguration builders.
 	AppConfiguration *AppConfigurationClient
 	// ApplicationCommand is the client for interacting with the ApplicationCommand builders.
@@ -91,7 +88,6 @@ func (c *Client) init() {
 	c.Schema = migrate.NewSchema(c.driver)
 	c.Account = NewAccountClient(c.config)
 	c.AccountSnapshot = NewAccountSnapshotClient(c.config)
-	c.AchievementsSnapshot = NewAchievementsSnapshotClient(c.config)
 	c.AppConfiguration = NewAppConfigurationClient(c.config)
 	c.ApplicationCommand = NewApplicationCommandClient(c.config)
 	c.AuthNonce = NewAuthNonceClient(c.config)
@@ -197,26 +193,25 @@ func (c *Client) Tx(ctx context.Context) (*Tx, error) {
 	cfg := c.config
 	cfg.driver = tx
 	return &Tx{
-		ctx:                  ctx,
-		config:               cfg,
-		Account:              NewAccountClient(cfg),
-		AccountSnapshot:      NewAccountSnapshotClient(cfg),
-		AchievementsSnapshot: NewAchievementsSnapshotClient(cfg),
-		AppConfiguration:     NewAppConfigurationClient(cfg),
-		ApplicationCommand:   NewApplicationCommandClient(cfg),
-		AuthNonce:            NewAuthNonceClient(cfg),
-		Clan:                 NewClanClient(cfg),
-		CronTask:             NewCronTaskClient(cfg),
-		DiscordInteraction:   NewDiscordInteractionClient(cfg),
-		LeaderboardScore:     NewLeaderboardScoreClient(cfg),
-		Session:              NewSessionClient(cfg),
-		User:                 NewUserClient(cfg),
-		UserConnection:       NewUserConnectionClient(cfg),
-		UserContent:          NewUserContentClient(cfg),
-		UserSubscription:     NewUserSubscriptionClient(cfg),
-		Vehicle:              NewVehicleClient(cfg),
-		VehicleAverage:       NewVehicleAverageClient(cfg),
-		VehicleSnapshot:      NewVehicleSnapshotClient(cfg),
+		ctx:                ctx,
+		config:             cfg,
+		Account:            NewAccountClient(cfg),
+		AccountSnapshot:    NewAccountSnapshotClient(cfg),
+		AppConfiguration:   NewAppConfigurationClient(cfg),
+		ApplicationCommand: NewApplicationCommandClient(cfg),
+		AuthNonce:          NewAuthNonceClient(cfg),
+		Clan:               NewClanClient(cfg),
+		CronTask:           NewCronTaskClient(cfg),
+		DiscordInteraction: NewDiscordInteractionClient(cfg),
+		LeaderboardScore:   NewLeaderboardScoreClient(cfg),
+		Session:            NewSessionClient(cfg),
+		User:               NewUserClient(cfg),
+		UserConnection:     NewUserConnectionClient(cfg),
+		UserContent:        NewUserContentClient(cfg),
+		UserSubscription:   NewUserSubscriptionClient(cfg),
+		Vehicle:            NewVehicleClient(cfg),
+		VehicleAverage:     NewVehicleAverageClient(cfg),
+		VehicleSnapshot:    NewVehicleSnapshotClient(cfg),
 	}, nil
 }
 
@@ -234,26 +229,25 @@ func (c *Client) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error)
 	cfg := c.config
 	cfg.driver = &txDriver{tx: tx, drv: c.driver}
 	return &Tx{
-		ctx:                  ctx,
-		config:               cfg,
-		Account:              NewAccountClient(cfg),
-		AccountSnapshot:      NewAccountSnapshotClient(cfg),
-		AchievementsSnapshot: NewAchievementsSnapshotClient(cfg),
-		AppConfiguration:     NewAppConfigurationClient(cfg),
-		ApplicationCommand:   NewApplicationCommandClient(cfg),
-		AuthNonce:            NewAuthNonceClient(cfg),
-		Clan:                 NewClanClient(cfg),
-		CronTask:             NewCronTaskClient(cfg),
-		DiscordInteraction:   NewDiscordInteractionClient(cfg),
-		LeaderboardScore:     NewLeaderboardScoreClient(cfg),
-		Session:              NewSessionClient(cfg),
-		User:                 NewUserClient(cfg),
-		UserConnection:       NewUserConnectionClient(cfg),
-		UserContent:          NewUserContentClient(cfg),
-		UserSubscription:     NewUserSubscriptionClient(cfg),
-		Vehicle:              NewVehicleClient(cfg),
-		VehicleAverage:       NewVehicleAverageClient(cfg),
-		VehicleSnapshot:      NewVehicleSnapshotClient(cfg),
+		ctx:                ctx,
+		config:             cfg,
+		Account:            NewAccountClient(cfg),
+		AccountSnapshot:    NewAccountSnapshotClient(cfg),
+		AppConfiguration:   NewAppConfigurationClient(cfg),
+		ApplicationCommand: NewApplicationCommandClient(cfg),
+		AuthNonce:          NewAuthNonceClient(cfg),
+		Clan:               NewClanClient(cfg),
+		CronTask:           NewCronTaskClient(cfg),
+		DiscordInteraction: NewDiscordInteractionClient(cfg),
+		LeaderboardScore:   NewLeaderboardScoreClient(cfg),
+		Session:            NewSessionClient(cfg),
+		User:               NewUserClient(cfg),
+		UserConnection:     NewUserConnectionClient(cfg),
+		UserContent:        NewUserContentClient(cfg),
+		UserSubscription:   NewUserSubscriptionClient(cfg),
+		Vehicle:            NewVehicleClient(cfg),
+		VehicleAverage:     NewVehicleAverageClient(cfg),
+		VehicleSnapshot:    NewVehicleSnapshotClient(cfg),
 	}, nil
 }
 
@@ -283,10 +277,10 @@ func (c *Client) Close() error {
 // In order to add hooks to a specific client, call: `client.Node.Use(...)`.
 func (c *Client) Use(hooks ...Hook) {
 	for _, n := range []interface{ Use(...Hook) }{
-		c.Account, c.AccountSnapshot, c.AchievementsSnapshot, c.AppConfiguration,
-		c.ApplicationCommand, c.AuthNonce, c.Clan, c.CronTask, c.DiscordInteraction,
-		c.LeaderboardScore, c.Session, c.User, c.UserConnection, c.UserContent,
-		c.UserSubscription, c.Vehicle, c.VehicleAverage, c.VehicleSnapshot,
+		c.Account, c.AccountSnapshot, c.AppConfiguration, c.ApplicationCommand,
+		c.AuthNonce, c.Clan, c.CronTask, c.DiscordInteraction, c.LeaderboardScore,
+		c.Session, c.User, c.UserConnection, c.UserContent, c.UserSubscription,
+		c.Vehicle, c.VehicleAverage, c.VehicleSnapshot,
 	} {
 		n.Use(hooks...)
 	}
@@ -296,10 +290,10 @@ func (c *Client) Use(hooks ...Hook) {
 // In order to add interceptors to a specific client, call: `client.Node.Intercept(...)`.
 func (c *Client) Intercept(interceptors ...Interceptor) {
 	for _, n := range []interface{ Intercept(...Interceptor) }{
-		c.Account, c.AccountSnapshot, c.AchievementsSnapshot, c.AppConfiguration,
-		c.ApplicationCommand, c.AuthNonce, c.Clan, c.CronTask, c.DiscordInteraction,
-		c.LeaderboardScore, c.Session, c.User, c.UserConnection, c.UserContent,
-		c.UserSubscription, c.Vehicle, c.VehicleAverage, c.VehicleSnapshot,
+		c.Account, c.AccountSnapshot, c.AppConfiguration, c.ApplicationCommand,
+		c.AuthNonce, c.Clan, c.CronTask, c.DiscordInteraction, c.LeaderboardScore,
+		c.Session, c.User, c.UserConnection, c.UserContent, c.UserSubscription,
+		c.Vehicle, c.VehicleAverage, c.VehicleSnapshot,
 	} {
 		n.Intercept(interceptors...)
 	}
@@ -312,8 +306,6 @@ func (c *Client) Mutate(ctx context.Context, m Mutation) (Value, error) {
 		return c.Account.mutate(ctx, m)
 	case *AccountSnapshotMutation:
 		return c.AccountSnapshot.mutate(ctx, m)
-	case *AchievementsSnapshotMutation:
-		return c.AchievementsSnapshot.mutate(ctx, m)
 	case *AppConfigurationMutation:
 		return c.AppConfiguration.mutate(ctx, m)
 	case *ApplicationCommandMutation:
@@ -473,22 +465,6 @@ func (c *AccountClient) QueryClan(a *Account) *ClanQuery {
 	return query
 }
 
-// QueryAchievementSnapshots queries the achievement_snapshots edge of a Account.
-func (c *AccountClient) QueryAchievementSnapshots(a *Account) *AchievementsSnapshotQuery {
-	query := (&AchievementsSnapshotClient{config: c.config}).Query()
-	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
-		id := a.ID
-		step := sqlgraph.NewStep(
-			sqlgraph.From(account.Table, account.FieldID, id),
-			sqlgraph.To(achievementssnapshot.Table, achievementssnapshot.FieldID),
-			sqlgraph.Edge(sqlgraph.O2M, false, account.AchievementSnapshotsTable, account.AchievementSnapshotsColumn),
-		)
-		fromV = sqlgraph.Neighbors(a.driver.Dialect(), step)
-		return fromV, nil
-	}
-	return query
-}
-
 // QueryVehicleSnapshots queries the vehicle_snapshots edge of a Account.
 func (c *AccountClient) QueryVehicleSnapshots(a *Account) *VehicleSnapshotQuery {
 	query := (&VehicleSnapshotClient{config: c.config}).Query()
@@ -695,155 +671,6 @@ func (c *AccountSnapshotClient) mutate(ctx context.Context, m *AccountSnapshotMu
 	}
 }
 
-// AchievementsSnapshotClient is a client for the AchievementsSnapshot schema.
-type AchievementsSnapshotClient struct {
-	config
-}
-
-// NewAchievementsSnapshotClient returns a client for the AchievementsSnapshot from the given config.
-func NewAchievementsSnapshotClient(c config) *AchievementsSnapshotClient {
-	return &AchievementsSnapshotClient{config: c}
-}
-
-// Use adds a list of mutation hooks to the hooks stack.
-// A call to `Use(f, g, h)` equals to `achievementssnapshot.Hooks(f(g(h())))`.
-func (c *AchievementsSnapshotClient) Use(hooks ...Hook) {
-	c.hooks.AchievementsSnapshot = append(c.hooks.AchievementsSnapshot, hooks...)
-}
-
-// Intercept adds a list of query interceptors to the interceptors stack.
-// A call to `Intercept(f, g, h)` equals to `achievementssnapshot.Intercept(f(g(h())))`.
-func (c *AchievementsSnapshotClient) Intercept(interceptors ...Interceptor) {
-	c.inters.AchievementsSnapshot = append(c.inters.AchievementsSnapshot, interceptors...)
-}
-
-// Create returns a builder for creating a AchievementsSnapshot entity.
-func (c *AchievementsSnapshotClient) Create() *AchievementsSnapshotCreate {
-	mutation := newAchievementsSnapshotMutation(c.config, OpCreate)
-	return &AchievementsSnapshotCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
-}
-
-// CreateBulk returns a builder for creating a bulk of AchievementsSnapshot entities.
-func (c *AchievementsSnapshotClient) CreateBulk(builders ...*AchievementsSnapshotCreate) *AchievementsSnapshotCreateBulk {
-	return &AchievementsSnapshotCreateBulk{config: c.config, builders: builders}
-}
-
-// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
-// a builder and applies setFunc on it.
-func (c *AchievementsSnapshotClient) MapCreateBulk(slice any, setFunc func(*AchievementsSnapshotCreate, int)) *AchievementsSnapshotCreateBulk {
-	rv := reflect.ValueOf(slice)
-	if rv.Kind() != reflect.Slice {
-		return &AchievementsSnapshotCreateBulk{err: fmt.Errorf("calling to AchievementsSnapshotClient.MapCreateBulk with wrong type %T, need slice", slice)}
-	}
-	builders := make([]*AchievementsSnapshotCreate, rv.Len())
-	for i := 0; i < rv.Len(); i++ {
-		builders[i] = c.Create()
-		setFunc(builders[i], i)
-	}
-	return &AchievementsSnapshotCreateBulk{config: c.config, builders: builders}
-}
-
-// Update returns an update builder for AchievementsSnapshot.
-func (c *AchievementsSnapshotClient) Update() *AchievementsSnapshotUpdate {
-	mutation := newAchievementsSnapshotMutation(c.config, OpUpdate)
-	return &AchievementsSnapshotUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
-}
-
-// UpdateOne returns an update builder for the given entity.
-func (c *AchievementsSnapshotClient) UpdateOne(as *AchievementsSnapshot) *AchievementsSnapshotUpdateOne {
-	mutation := newAchievementsSnapshotMutation(c.config, OpUpdateOne, withAchievementsSnapshot(as))
-	return &AchievementsSnapshotUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
-}
-
-// UpdateOneID returns an update builder for the given id.
-func (c *AchievementsSnapshotClient) UpdateOneID(id string) *AchievementsSnapshotUpdateOne {
-	mutation := newAchievementsSnapshotMutation(c.config, OpUpdateOne, withAchievementsSnapshotID(id))
-	return &AchievementsSnapshotUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
-}
-
-// Delete returns a delete builder for AchievementsSnapshot.
-func (c *AchievementsSnapshotClient) Delete() *AchievementsSnapshotDelete {
-	mutation := newAchievementsSnapshotMutation(c.config, OpDelete)
-	return &AchievementsSnapshotDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
-}
-
-// DeleteOne returns a builder for deleting the given entity.
-func (c *AchievementsSnapshotClient) DeleteOne(as *AchievementsSnapshot) *AchievementsSnapshotDeleteOne {
-	return c.DeleteOneID(as.ID)
-}
-
-// DeleteOneID returns a builder for deleting the given entity by its id.
-func (c *AchievementsSnapshotClient) DeleteOneID(id string) *AchievementsSnapshotDeleteOne {
-	builder := c.Delete().Where(achievementssnapshot.ID(id))
-	builder.mutation.id = &id
-	builder.mutation.op = OpDeleteOne
-	return &AchievementsSnapshotDeleteOne{builder}
-}
-
-// Query returns a query builder for AchievementsSnapshot.
-func (c *AchievementsSnapshotClient) Query() *AchievementsSnapshotQuery {
-	return &AchievementsSnapshotQuery{
-		config: c.config,
-		ctx:    &QueryContext{Type: TypeAchievementsSnapshot},
-		inters: c.Interceptors(),
-	}
-}
-
-// Get returns a AchievementsSnapshot entity by its id.
-func (c *AchievementsSnapshotClient) Get(ctx context.Context, id string) (*AchievementsSnapshot, error) {
-	return c.Query().Where(achievementssnapshot.ID(id)).Only(ctx)
-}
-
-// GetX is like Get, but panics if an error occurs.
-func (c *AchievementsSnapshotClient) GetX(ctx context.Context, id string) *AchievementsSnapshot {
-	obj, err := c.Get(ctx, id)
-	if err != nil {
-		panic(err)
-	}
-	return obj
-}
-
-// QueryAccount queries the account edge of a AchievementsSnapshot.
-func (c *AchievementsSnapshotClient) QueryAccount(as *AchievementsSnapshot) *AccountQuery {
-	query := (&AccountClient{config: c.config}).Query()
-	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
-		id := as.ID
-		step := sqlgraph.NewStep(
-			sqlgraph.From(achievementssnapshot.Table, achievementssnapshot.FieldID, id),
-			sqlgraph.To(account.Table, account.FieldID),
-			sqlgraph.Edge(sqlgraph.M2O, true, achievementssnapshot.AccountTable, achievementssnapshot.AccountColumn),
-		)
-		fromV = sqlgraph.Neighbors(as.driver.Dialect(), step)
-		return fromV, nil
-	}
-	return query
-}
-
-// Hooks returns the client hooks.
-func (c *AchievementsSnapshotClient) Hooks() []Hook {
-	return c.hooks.AchievementsSnapshot
-}
-
-// Interceptors returns the client interceptors.
-func (c *AchievementsSnapshotClient) Interceptors() []Interceptor {
-	return c.inters.AchievementsSnapshot
-}
-
-func (c *AchievementsSnapshotClient) mutate(ctx context.Context, m *AchievementsSnapshotMutation) (Value, error) {
-	switch m.Op() {
-	case OpCreate:
-		return (&AchievementsSnapshotCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
-	case OpUpdate:
-		return (&AchievementsSnapshotUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
-	case OpUpdateOne:
-		return (&AchievementsSnapshotUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
-	case OpDelete, OpDeleteOne:
-		return (&AchievementsSnapshotDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
-	default:
-		return nil, fmt.Errorf("db: unknown AchievementsSnapshot mutation op: %q", m.Op())
-	}
-}
-
 // AppConfigurationClient is a client for the AppConfiguration schema.
 type AppConfigurationClient struct {
 	config
@@ -3034,16 +2861,16 @@ func (c *VehicleSnapshotClient) mutate(ctx context.Context, m *VehicleSnapshotMu
 // hooks and interceptors per client, for fast access.
 type (
 	hooks struct {
-		Account, AccountSnapshot, AchievementsSnapshot, AppConfiguration,
-		ApplicationCommand, AuthNonce, Clan, CronTask, DiscordInteraction,
-		LeaderboardScore, Session, User, UserConnection, UserContent, UserSubscription,
-		Vehicle, VehicleAverage, VehicleSnapshot []ent.Hook
+		Account, AccountSnapshot, AppConfiguration, ApplicationCommand, AuthNonce, Clan,
+		CronTask, DiscordInteraction, LeaderboardScore, Session, User, UserConnection,
+		UserContent, UserSubscription, Vehicle, VehicleAverage,
+		VehicleSnapshot []ent.Hook
 	}
 	inters struct {
-		Account, AccountSnapshot, AchievementsSnapshot, AppConfiguration,
-		ApplicationCommand, AuthNonce, Clan, CronTask, DiscordInteraction,
-		LeaderboardScore, Session, User, UserConnection, UserContent, UserSubscription,
-		Vehicle, VehicleAverage, VehicleSnapshot []ent.Interceptor
+		Account, AccountSnapshot, AppConfiguration, ApplicationCommand, AuthNonce, Clan,
+		CronTask, DiscordInteraction, LeaderboardScore, Session, User, UserConnection,
+		UserContent, UserSubscription, Vehicle, VehicleAverage,
+		VehicleSnapshot []ent.Interceptor
 	}
 )
 
diff --git a/internal/database/ent/db/ent.go b/internal/database/ent/db/ent.go
index 3701a22a..f05277b3 100644
--- a/internal/database/ent/db/ent.go
+++ b/internal/database/ent/db/ent.go
@@ -14,7 +14,6 @@ import (
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"github.com/cufee/aftermath/internal/database/ent/db/account"
 	"github.com/cufee/aftermath/internal/database/ent/db/accountsnapshot"
-	"github.com/cufee/aftermath/internal/database/ent/db/achievementssnapshot"
 	"github.com/cufee/aftermath/internal/database/ent/db/appconfiguration"
 	"github.com/cufee/aftermath/internal/database/ent/db/applicationcommand"
 	"github.com/cufee/aftermath/internal/database/ent/db/authnonce"
@@ -90,24 +89,23 @@ var (
 func checkColumn(table, column string) error {
 	initCheck.Do(func() {
 		columnCheck = sql.NewColumnCheck(map[string]func(string) bool{
-			account.Table:              account.ValidColumn,
-			accountsnapshot.Table:      accountsnapshot.ValidColumn,
-			achievementssnapshot.Table: achievementssnapshot.ValidColumn,
-			appconfiguration.Table:     appconfiguration.ValidColumn,
-			applicationcommand.Table:   applicationcommand.ValidColumn,
-			authnonce.Table:            authnonce.ValidColumn,
-			clan.Table:                 clan.ValidColumn,
-			crontask.Table:             crontask.ValidColumn,
-			discordinteraction.Table:   discordinteraction.ValidColumn,
-			leaderboardscore.Table:     leaderboardscore.ValidColumn,
-			session.Table:              session.ValidColumn,
-			user.Table:                 user.ValidColumn,
-			userconnection.Table:       userconnection.ValidColumn,
-			usercontent.Table:          usercontent.ValidColumn,
-			usersubscription.Table:     usersubscription.ValidColumn,
-			vehicle.Table:              vehicle.ValidColumn,
-			vehicleaverage.Table:       vehicleaverage.ValidColumn,
-			vehiclesnapshot.Table:      vehiclesnapshot.ValidColumn,
+			account.Table:            account.ValidColumn,
+			accountsnapshot.Table:    accountsnapshot.ValidColumn,
+			appconfiguration.Table:   appconfiguration.ValidColumn,
+			applicationcommand.Table: applicationcommand.ValidColumn,
+			authnonce.Table:          authnonce.ValidColumn,
+			clan.Table:               clan.ValidColumn,
+			crontask.Table:           crontask.ValidColumn,
+			discordinteraction.Table: discordinteraction.ValidColumn,
+			leaderboardscore.Table:   leaderboardscore.ValidColumn,
+			session.Table:            session.ValidColumn,
+			user.Table:               user.ValidColumn,
+			userconnection.Table:     userconnection.ValidColumn,
+			usercontent.Table:        usercontent.ValidColumn,
+			usersubscription.Table:   usersubscription.ValidColumn,
+			vehicle.Table:            vehicle.ValidColumn,
+			vehicleaverage.Table:     vehicleaverage.ValidColumn,
+			vehiclesnapshot.Table:    vehiclesnapshot.ValidColumn,
 		})
 	})
 	return columnCheck(table, column)
diff --git a/internal/database/ent/db/expose.go b/internal/database/ent/db/expose.go
index a0d836f3..812a0592 100644
--- a/internal/database/ent/db/expose.go
+++ b/internal/database/ent/db/expose.go
@@ -30,19 +30,6 @@ func (as *AccountSnapshot) ScanValues(columns []string) ([]any, error) {
 	return as.scanValues(columns)
 }
 
-func (as *AchievementsSnapshot) AssignValues(columns []string, values []any) error {
-	if as == nil {
-		return fmt.Errorf("AchievementsSnapshot(nil)")
-	}
-	return as.assignValues(columns, values)
-}
-func (as *AchievementsSnapshot) ScanValues(columns []string) ([]any, error) {
-	if as == nil {
-		return nil, fmt.Errorf("AchievementsSnapshot(nil)")
-	}
-	return as.scanValues(columns)
-}
-
 func (ac *AppConfiguration) AssignValues(columns []string, values []any) error {
 	if ac == nil {
 		return fmt.Errorf("AppConfiguration(nil)")
diff --git a/internal/database/ent/db/hook/hook.go b/internal/database/ent/db/hook/hook.go
index baaa0ac8..c0f5cc4a 100644
--- a/internal/database/ent/db/hook/hook.go
+++ b/internal/database/ent/db/hook/hook.go
@@ -33,18 +33,6 @@ func (f AccountSnapshotFunc) Mutate(ctx context.Context, m db.Mutation) (db.Valu
 	return nil, fmt.Errorf("unexpected mutation type %T. expect *db.AccountSnapshotMutation", m)
 }
 
-// The AchievementsSnapshotFunc type is an adapter to allow the use of ordinary
-// function as AchievementsSnapshot mutator.
-type AchievementsSnapshotFunc func(context.Context, *db.AchievementsSnapshotMutation) (db.Value, error)
-
-// Mutate calls f(ctx, m).
-func (f AchievementsSnapshotFunc) Mutate(ctx context.Context, m db.Mutation) (db.Value, error) {
-	if mv, ok := m.(*db.AchievementsSnapshotMutation); ok {
-		return f(ctx, mv)
-	}
-	return nil, fmt.Errorf("unexpected mutation type %T. expect *db.AchievementsSnapshotMutation", m)
-}
-
 // The AppConfigurationFunc type is an adapter to allow the use of ordinary
 // function as AppConfiguration mutator.
 type AppConfigurationFunc func(context.Context, *db.AppConfigurationMutation) (db.Value, error)
diff --git a/internal/database/ent/db/migrate/schema.go b/internal/database/ent/db/migrate/schema.go
index 0f5b8889..c35e0e53 100644
--- a/internal/database/ent/db/migrate/schema.go
+++ b/internal/database/ent/db/migrate/schema.go
@@ -116,54 +116,6 @@ var (
 			},
 		},
 	}
-	// AchievementsSnapshotsColumns holds the columns for the "achievements_snapshots" table.
-	AchievementsSnapshotsColumns = []*schema.Column{
-		{Name: "id", Type: field.TypeString, Unique: true},
-		{Name: "created_at", Type: field.TypeTime},
-		{Name: "updated_at", Type: field.TypeTime},
-		{Name: "type", Type: field.TypeEnum, Enums: []string{"live", "daily"}},
-		{Name: "reference_id", Type: field.TypeString},
-		{Name: "battles", Type: field.TypeInt},
-		{Name: "last_battle_time", Type: field.TypeTime},
-		{Name: "data", Type: field.TypeJSON},
-		{Name: "account_id", Type: field.TypeString},
-	}
-	// AchievementsSnapshotsTable holds the schema information for the "achievements_snapshots" table.
-	AchievementsSnapshotsTable = &schema.Table{
-		Name:       "achievements_snapshots",
-		Columns:    AchievementsSnapshotsColumns,
-		PrimaryKey: []*schema.Column{AchievementsSnapshotsColumns[0]},
-		ForeignKeys: []*schema.ForeignKey{
-			{
-				Symbol:     "achievements_snapshots_accounts_achievement_snapshots",
-				Columns:    []*schema.Column{AchievementsSnapshotsColumns[8]},
-				RefColumns: []*schema.Column{AccountsColumns[0]},
-				OnDelete:   schema.Cascade,
-			},
-		},
-		Indexes: []*schema.Index{
-			{
-				Name:    "achievementssnapshot_id",
-				Unique:  false,
-				Columns: []*schema.Column{AchievementsSnapshotsColumns[0]},
-			},
-			{
-				Name:    "achievementssnapshot_created_at",
-				Unique:  false,
-				Columns: []*schema.Column{AchievementsSnapshotsColumns[1]},
-			},
-			{
-				Name:    "achievementssnapshot_account_id_reference_id",
-				Unique:  false,
-				Columns: []*schema.Column{AchievementsSnapshotsColumns[8], AchievementsSnapshotsColumns[4]},
-			},
-			{
-				Name:    "achievementssnapshot_account_id_reference_id_created_at",
-				Unique:  false,
-				Columns: []*schema.Column{AchievementsSnapshotsColumns[8], AchievementsSnapshotsColumns[4], AchievementsSnapshotsColumns[1]},
-			},
-		},
-	}
 	// AppConfigurationsColumns holds the columns for the "app_configurations" table.
 	AppConfigurationsColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeString, Unique: true},
@@ -733,7 +685,6 @@ var (
 	Tables = []*schema.Table{
 		AccountsTable,
 		AccountSnapshotsTable,
-		AchievementsSnapshotsTable,
 		AppConfigurationsTable,
 		ApplicationCommandsTable,
 		AuthNoncesTable,
@@ -755,7 +706,6 @@ var (
 func init() {
 	AccountsTable.ForeignKeys[0].RefTable = ClansTable
 	AccountSnapshotsTable.ForeignKeys[0].RefTable = AccountsTable
-	AchievementsSnapshotsTable.ForeignKeys[0].RefTable = AccountsTable
 	DiscordInteractionsTable.ForeignKeys[0].RefTable = UsersTable
 	SessionsTable.ForeignKeys[0].RefTable = UsersTable
 	UserConnectionsTable.ForeignKeys[0].RefTable = UsersTable
diff --git a/internal/database/ent/db/mutation.go b/internal/database/ent/db/mutation.go
index c6ef8ee6..d45e5e54 100644
--- a/internal/database/ent/db/mutation.go
+++ b/internal/database/ent/db/mutation.go
@@ -13,7 +13,6 @@ import (
 	"entgo.io/ent/dialect/sql"
 	"github.com/cufee/aftermath/internal/database/ent/db/account"
 	"github.com/cufee/aftermath/internal/database/ent/db/accountsnapshot"
-	"github.com/cufee/aftermath/internal/database/ent/db/achievementssnapshot"
 	"github.com/cufee/aftermath/internal/database/ent/db/appconfiguration"
 	"github.com/cufee/aftermath/internal/database/ent/db/applicationcommand"
 	"github.com/cufee/aftermath/internal/database/ent/db/authnonce"
@@ -32,7 +31,6 @@ import (
 	"github.com/cufee/aftermath/internal/database/ent/db/vehiclesnapshot"
 	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/stats/frame"
-	"github.com/cufee/am-wg-proxy-next/v2/types"
 )
 
 const (
@@ -44,54 +42,50 @@ const (
 	OpUpdateOne = ent.OpUpdateOne
 
 	// Node types.
-	TypeAccount              = "Account"
-	TypeAccountSnapshot      = "AccountSnapshot"
-	TypeAchievementsSnapshot = "AchievementsSnapshot"
-	TypeAppConfiguration     = "AppConfiguration"
-	TypeApplicationCommand   = "ApplicationCommand"
-	TypeAuthNonce            = "AuthNonce"
-	TypeClan                 = "Clan"
-	TypeCronTask             = "CronTask"
-	TypeDiscordInteraction   = "DiscordInteraction"
-	TypeLeaderboardScore     = "LeaderboardScore"
-	TypeSession              = "Session"
-	TypeUser                 = "User"
-	TypeUserConnection       = "UserConnection"
-	TypeUserContent          = "UserContent"
-	TypeUserSubscription     = "UserSubscription"
-	TypeVehicle              = "Vehicle"
-	TypeVehicleAverage       = "VehicleAverage"
-	TypeVehicleSnapshot      = "VehicleSnapshot"
+	TypeAccount            = "Account"
+	TypeAccountSnapshot    = "AccountSnapshot"
+	TypeAppConfiguration   = "AppConfiguration"
+	TypeApplicationCommand = "ApplicationCommand"
+	TypeAuthNonce          = "AuthNonce"
+	TypeClan               = "Clan"
+	TypeCronTask           = "CronTask"
+	TypeDiscordInteraction = "DiscordInteraction"
+	TypeLeaderboardScore   = "LeaderboardScore"
+	TypeSession            = "Session"
+	TypeUser               = "User"
+	TypeUserConnection     = "UserConnection"
+	TypeUserContent        = "UserContent"
+	TypeUserSubscription   = "UserSubscription"
+	TypeVehicle            = "Vehicle"
+	TypeVehicleAverage     = "VehicleAverage"
+	TypeVehicleSnapshot    = "VehicleSnapshot"
 )
 
 // AccountMutation represents an operation that mutates the Account nodes in the graph.
 type AccountMutation struct {
 	config
-	op                           Op
-	typ                          string
-	id                           *string
-	created_at                   *time.Time
-	updated_at                   *time.Time
-	last_battle_time             *time.Time
-	account_created_at           *time.Time
-	realm                        *string
-	nickname                     *string
-	private                      *bool
-	clearedFields                map[string]struct{}
-	clan                         *string
-	clearedclan                  bool
-	achievement_snapshots        map[string]struct{}
-	removedachievement_snapshots map[string]struct{}
-	clearedachievement_snapshots bool
-	vehicle_snapshots            map[string]struct{}
-	removedvehicle_snapshots     map[string]struct{}
-	clearedvehicle_snapshots     bool
-	account_snapshots            map[string]struct{}
-	removedaccount_snapshots     map[string]struct{}
-	clearedaccount_snapshots     bool
-	done                         bool
-	oldValue                     func(context.Context) (*Account, error)
-	predicates                   []predicate.Account
+	op                       Op
+	typ                      string
+	id                       *string
+	created_at               *time.Time
+	updated_at               *time.Time
+	last_battle_time         *time.Time
+	account_created_at       *time.Time
+	realm                    *string
+	nickname                 *string
+	private                  *bool
+	clearedFields            map[string]struct{}
+	clan                     *string
+	clearedclan              bool
+	vehicle_snapshots        map[string]struct{}
+	removedvehicle_snapshots map[string]struct{}
+	clearedvehicle_snapshots bool
+	account_snapshots        map[string]struct{}
+	removedaccount_snapshots map[string]struct{}
+	clearedaccount_snapshots bool
+	done                     bool
+	oldValue                 func(context.Context) (*Account, error)
+	predicates               []predicate.Account
 }
 
 var _ ent.Mutation = (*AccountMutation)(nil)
@@ -526,60 +520,6 @@ func (m *AccountMutation) ResetClan() {
 	m.clearedclan = false
 }
 
-// AddAchievementSnapshotIDs adds the "achievement_snapshots" edge to the AchievementsSnapshot entity by ids.
-func (m *AccountMutation) AddAchievementSnapshotIDs(ids ...string) {
-	if m.achievement_snapshots == nil {
-		m.achievement_snapshots = make(map[string]struct{})
-	}
-	for i := range ids {
-		m.achievement_snapshots[ids[i]] = struct{}{}
-	}
-}
-
-// ClearAchievementSnapshots clears the "achievement_snapshots" edge to the AchievementsSnapshot entity.
-func (m *AccountMutation) ClearAchievementSnapshots() {
-	m.clearedachievement_snapshots = true
-}
-
-// AchievementSnapshotsCleared reports if the "achievement_snapshots" edge to the AchievementsSnapshot entity was cleared.
-func (m *AccountMutation) AchievementSnapshotsCleared() bool {
-	return m.clearedachievement_snapshots
-}
-
-// RemoveAchievementSnapshotIDs removes the "achievement_snapshots" edge to the AchievementsSnapshot entity by IDs.
-func (m *AccountMutation) RemoveAchievementSnapshotIDs(ids ...string) {
-	if m.removedachievement_snapshots == nil {
-		m.removedachievement_snapshots = make(map[string]struct{})
-	}
-	for i := range ids {
-		delete(m.achievement_snapshots, ids[i])
-		m.removedachievement_snapshots[ids[i]] = struct{}{}
-	}
-}
-
-// RemovedAchievementSnapshots returns the removed IDs of the "achievement_snapshots" edge to the AchievementsSnapshot entity.
-func (m *AccountMutation) RemovedAchievementSnapshotsIDs() (ids []string) {
-	for id := range m.removedachievement_snapshots {
-		ids = append(ids, id)
-	}
-	return
-}
-
-// AchievementSnapshotsIDs returns the "achievement_snapshots" edge IDs in the mutation.
-func (m *AccountMutation) AchievementSnapshotsIDs() (ids []string) {
-	for id := range m.achievement_snapshots {
-		ids = append(ids, id)
-	}
-	return
-}
-
-// ResetAchievementSnapshots resets all changes to the "achievement_snapshots" edge.
-func (m *AccountMutation) ResetAchievementSnapshots() {
-	m.achievement_snapshots = nil
-	m.clearedachievement_snapshots = false
-	m.removedachievement_snapshots = nil
-}
-
 // AddVehicleSnapshotIDs adds the "vehicle_snapshots" edge to the VehicleSnapshot entity by ids.
 func (m *AccountMutation) AddVehicleSnapshotIDs(ids ...string) {
 	if m.vehicle_snapshots == nil {
@@ -949,13 +889,10 @@ func (m *AccountMutation) ResetField(name string) error {
 
 // AddedEdges returns all edge names that were set/added in this mutation.
 func (m *AccountMutation) AddedEdges() []string {
-	edges := make([]string, 0, 4)
+	edges := make([]string, 0, 3)
 	if m.clan != nil {
 		edges = append(edges, account.EdgeClan)
 	}
-	if m.achievement_snapshots != nil {
-		edges = append(edges, account.EdgeAchievementSnapshots)
-	}
 	if m.vehicle_snapshots != nil {
 		edges = append(edges, account.EdgeVehicleSnapshots)
 	}
@@ -973,12 +910,6 @@ func (m *AccountMutation) AddedIDs(name string) []ent.Value {
 		if id := m.clan; id != nil {
 			return []ent.Value{*id}
 		}
-	case account.EdgeAchievementSnapshots:
-		ids := make([]ent.Value, 0, len(m.achievement_snapshots))
-		for id := range m.achievement_snapshots {
-			ids = append(ids, id)
-		}
-		return ids
 	case account.EdgeVehicleSnapshots:
 		ids := make([]ent.Value, 0, len(m.vehicle_snapshots))
 		for id := range m.vehicle_snapshots {
@@ -997,10 +928,7 @@ func (m *AccountMutation) AddedIDs(name string) []ent.Value {
 
 // RemovedEdges returns all edge names that were removed in this mutation.
 func (m *AccountMutation) RemovedEdges() []string {
-	edges := make([]string, 0, 4)
-	if m.removedachievement_snapshots != nil {
-		edges = append(edges, account.EdgeAchievementSnapshots)
-	}
+	edges := make([]string, 0, 3)
 	if m.removedvehicle_snapshots != nil {
 		edges = append(edges, account.EdgeVehicleSnapshots)
 	}
@@ -1014,12 +942,6 @@ func (m *AccountMutation) RemovedEdges() []string {
 // the given name in this mutation.
 func (m *AccountMutation) RemovedIDs(name string) []ent.Value {
 	switch name {
-	case account.EdgeAchievementSnapshots:
-		ids := make([]ent.Value, 0, len(m.removedachievement_snapshots))
-		for id := range m.removedachievement_snapshots {
-			ids = append(ids, id)
-		}
-		return ids
 	case account.EdgeVehicleSnapshots:
 		ids := make([]ent.Value, 0, len(m.removedvehicle_snapshots))
 		for id := range m.removedvehicle_snapshots {
@@ -1038,13 +960,10 @@ func (m *AccountMutation) RemovedIDs(name string) []ent.Value {
 
 // ClearedEdges returns all edge names that were cleared in this mutation.
 func (m *AccountMutation) ClearedEdges() []string {
-	edges := make([]string, 0, 4)
+	edges := make([]string, 0, 3)
 	if m.clearedclan {
 		edges = append(edges, account.EdgeClan)
 	}
-	if m.clearedachievement_snapshots {
-		edges = append(edges, account.EdgeAchievementSnapshots)
-	}
 	if m.clearedvehicle_snapshots {
 		edges = append(edges, account.EdgeVehicleSnapshots)
 	}
@@ -1060,8 +979,6 @@ func (m *AccountMutation) EdgeCleared(name string) bool {
 	switch name {
 	case account.EdgeClan:
 		return m.clearedclan
-	case account.EdgeAchievementSnapshots:
-		return m.clearedachievement_snapshots
 	case account.EdgeVehicleSnapshots:
 		return m.clearedvehicle_snapshots
 	case account.EdgeAccountSnapshots:
@@ -1088,9 +1005,6 @@ func (m *AccountMutation) ResetEdge(name string) error {
 	case account.EdgeClan:
 		m.ResetClan()
 		return nil
-	case account.EdgeAchievementSnapshots:
-		m.ResetAchievementSnapshots()
-		return nil
 	case account.EdgeVehicleSnapshots:
 		m.ResetVehicleSnapshots()
 		return nil
@@ -2042,806 +1956,6 @@ func (m *AccountSnapshotMutation) ResetEdge(name string) error {
 	return fmt.Errorf("unknown AccountSnapshot edge %s", name)
 }
 
-// AchievementsSnapshotMutation represents an operation that mutates the AchievementsSnapshot nodes in the graph.
-type AchievementsSnapshotMutation struct {
-	config
-	op               Op
-	typ              string
-	id               *string
-	created_at       *time.Time
-	updated_at       *time.Time
-	_type            *models.SnapshotType
-	reference_id     *string
-	battles          *int
-	addbattles       *int
-	last_battle_time *time.Time
-	data             *types.AchievementsFrame
-	clearedFields    map[string]struct{}
-	account          *string
-	clearedaccount   bool
-	done             bool
-	oldValue         func(context.Context) (*AchievementsSnapshot, error)
-	predicates       []predicate.AchievementsSnapshot
-}
-
-var _ ent.Mutation = (*AchievementsSnapshotMutation)(nil)
-
-// achievementssnapshotOption allows management of the mutation configuration using functional options.
-type achievementssnapshotOption func(*AchievementsSnapshotMutation)
-
-// newAchievementsSnapshotMutation creates new mutation for the AchievementsSnapshot entity.
-func newAchievementsSnapshotMutation(c config, op Op, opts ...achievementssnapshotOption) *AchievementsSnapshotMutation {
-	m := &AchievementsSnapshotMutation{
-		config:        c,
-		op:            op,
-		typ:           TypeAchievementsSnapshot,
-		clearedFields: make(map[string]struct{}),
-	}
-	for _, opt := range opts {
-		opt(m)
-	}
-	return m
-}
-
-// withAchievementsSnapshotID sets the ID field of the mutation.
-func withAchievementsSnapshotID(id string) achievementssnapshotOption {
-	return func(m *AchievementsSnapshotMutation) {
-		var (
-			err   error
-			once  sync.Once
-			value *AchievementsSnapshot
-		)
-		m.oldValue = func(ctx context.Context) (*AchievementsSnapshot, error) {
-			once.Do(func() {
-				if m.done {
-					err = errors.New("querying old values post mutation is not allowed")
-				} else {
-					value, err = m.Client().AchievementsSnapshot.Get(ctx, id)
-				}
-			})
-			return value, err
-		}
-		m.id = &id
-	}
-}
-
-// withAchievementsSnapshot sets the old AchievementsSnapshot of the mutation.
-func withAchievementsSnapshot(node *AchievementsSnapshot) achievementssnapshotOption {
-	return func(m *AchievementsSnapshotMutation) {
-		m.oldValue = func(context.Context) (*AchievementsSnapshot, error) {
-			return node, nil
-		}
-		m.id = &node.ID
-	}
-}
-
-// Client returns a new `ent.Client` from the mutation. If the mutation was
-// executed in a transaction (ent.Tx), a transactional client is returned.
-func (m AchievementsSnapshotMutation) Client() *Client {
-	client := &Client{config: m.config}
-	client.init()
-	return client
-}
-
-// Tx returns an `ent.Tx` for mutations that were executed in transactions;
-// it returns an error otherwise.
-func (m AchievementsSnapshotMutation) Tx() (*Tx, error) {
-	if _, ok := m.driver.(*txDriver); !ok {
-		return nil, errors.New("db: mutation is not running in a transaction")
-	}
-	tx := &Tx{config: m.config}
-	tx.init()
-	return tx, nil
-}
-
-// SetID sets the value of the id field. Note that this
-// operation is only accepted on creation of AchievementsSnapshot entities.
-func (m *AchievementsSnapshotMutation) SetID(id string) {
-	m.id = &id
-}
-
-// ID returns the ID value in the mutation. Note that the ID is only available
-// if it was provided to the builder or after it was returned from the database.
-func (m *AchievementsSnapshotMutation) ID() (id string, exists bool) {
-	if m.id == nil {
-		return
-	}
-	return *m.id, true
-}
-
-// IDs queries the database and returns the entity ids that match the mutation's predicate.
-// That means, if the mutation is applied within a transaction with an isolation level such
-// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
-// or updated by the mutation.
-func (m *AchievementsSnapshotMutation) IDs(ctx context.Context) ([]string, error) {
-	switch {
-	case m.op.Is(OpUpdateOne | OpDeleteOne):
-		id, exists := m.ID()
-		if exists {
-			return []string{id}, nil
-		}
-		fallthrough
-	case m.op.Is(OpUpdate | OpDelete):
-		return m.Client().AchievementsSnapshot.Query().Where(m.predicates...).IDs(ctx)
-	default:
-		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
-	}
-}
-
-// SetCreatedAt sets the "created_at" field.
-func (m *AchievementsSnapshotMutation) SetCreatedAt(t time.Time) {
-	m.created_at = &t
-}
-
-// CreatedAt returns the value of the "created_at" field in the mutation.
-func (m *AchievementsSnapshotMutation) CreatedAt() (r time.Time, exists bool) {
-	v := m.created_at
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
-// OldCreatedAt returns the old "created_at" field's value of the AchievementsSnapshot entity.
-// If the AchievementsSnapshot object wasn't provided to the builder, the object is fetched from the database.
-// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *AchievementsSnapshotMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
-	if !m.op.Is(OpUpdateOne) {
-		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
-	}
-	if m.id == nil || m.oldValue == nil {
-		return v, errors.New("OldCreatedAt requires an ID field in the mutation")
-	}
-	oldValue, err := m.oldValue(ctx)
-	if err != nil {
-		return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
-	}
-	return oldValue.CreatedAt, nil
-}
-
-// ResetCreatedAt resets all changes to the "created_at" field.
-func (m *AchievementsSnapshotMutation) ResetCreatedAt() {
-	m.created_at = nil
-}
-
-// SetUpdatedAt sets the "updated_at" field.
-func (m *AchievementsSnapshotMutation) SetUpdatedAt(t time.Time) {
-	m.updated_at = &t
-}
-
-// UpdatedAt returns the value of the "updated_at" field in the mutation.
-func (m *AchievementsSnapshotMutation) UpdatedAt() (r time.Time, exists bool) {
-	v := m.updated_at
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
-// OldUpdatedAt returns the old "updated_at" field's value of the AchievementsSnapshot entity.
-// If the AchievementsSnapshot object wasn't provided to the builder, the object is fetched from the database.
-// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *AchievementsSnapshotMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
-	if !m.op.Is(OpUpdateOne) {
-		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
-	}
-	if m.id == nil || m.oldValue == nil {
-		return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
-	}
-	oldValue, err := m.oldValue(ctx)
-	if err != nil {
-		return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
-	}
-	return oldValue.UpdatedAt, nil
-}
-
-// ResetUpdatedAt resets all changes to the "updated_at" field.
-func (m *AchievementsSnapshotMutation) ResetUpdatedAt() {
-	m.updated_at = nil
-}
-
-// SetType sets the "type" field.
-func (m *AchievementsSnapshotMutation) SetType(mt models.SnapshotType) {
-	m._type = &mt
-}
-
-// GetType returns the value of the "type" field in the mutation.
-func (m *AchievementsSnapshotMutation) GetType() (r models.SnapshotType, exists bool) {
-	v := m._type
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
-// OldType returns the old "type" field's value of the AchievementsSnapshot entity.
-// If the AchievementsSnapshot object wasn't provided to the builder, the object is fetched from the database.
-// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *AchievementsSnapshotMutation) OldType(ctx context.Context) (v models.SnapshotType, err error) {
-	if !m.op.Is(OpUpdateOne) {
-		return v, errors.New("OldType is only allowed on UpdateOne operations")
-	}
-	if m.id == nil || m.oldValue == nil {
-		return v, errors.New("OldType requires an ID field in the mutation")
-	}
-	oldValue, err := m.oldValue(ctx)
-	if err != nil {
-		return v, fmt.Errorf("querying old value for OldType: %w", err)
-	}
-	return oldValue.Type, nil
-}
-
-// ResetType resets all changes to the "type" field.
-func (m *AchievementsSnapshotMutation) ResetType() {
-	m._type = nil
-}
-
-// SetAccountID sets the "account_id" field.
-func (m *AchievementsSnapshotMutation) SetAccountID(s string) {
-	m.account = &s
-}
-
-// AccountID returns the value of the "account_id" field in the mutation.
-func (m *AchievementsSnapshotMutation) AccountID() (r string, exists bool) {
-	v := m.account
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
-// OldAccountID returns the old "account_id" field's value of the AchievementsSnapshot entity.
-// If the AchievementsSnapshot object wasn't provided to the builder, the object is fetched from the database.
-// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *AchievementsSnapshotMutation) OldAccountID(ctx context.Context) (v string, err error) {
-	if !m.op.Is(OpUpdateOne) {
-		return v, errors.New("OldAccountID is only allowed on UpdateOne operations")
-	}
-	if m.id == nil || m.oldValue == nil {
-		return v, errors.New("OldAccountID requires an ID field in the mutation")
-	}
-	oldValue, err := m.oldValue(ctx)
-	if err != nil {
-		return v, fmt.Errorf("querying old value for OldAccountID: %w", err)
-	}
-	return oldValue.AccountID, nil
-}
-
-// ResetAccountID resets all changes to the "account_id" field.
-func (m *AchievementsSnapshotMutation) ResetAccountID() {
-	m.account = nil
-}
-
-// SetReferenceID sets the "reference_id" field.
-func (m *AchievementsSnapshotMutation) SetReferenceID(s string) {
-	m.reference_id = &s
-}
-
-// ReferenceID returns the value of the "reference_id" field in the mutation.
-func (m *AchievementsSnapshotMutation) ReferenceID() (r string, exists bool) {
-	v := m.reference_id
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
-// OldReferenceID returns the old "reference_id" field's value of the AchievementsSnapshot entity.
-// If the AchievementsSnapshot object wasn't provided to the builder, the object is fetched from the database.
-// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *AchievementsSnapshotMutation) OldReferenceID(ctx context.Context) (v string, err error) {
-	if !m.op.Is(OpUpdateOne) {
-		return v, errors.New("OldReferenceID is only allowed on UpdateOne operations")
-	}
-	if m.id == nil || m.oldValue == nil {
-		return v, errors.New("OldReferenceID requires an ID field in the mutation")
-	}
-	oldValue, err := m.oldValue(ctx)
-	if err != nil {
-		return v, fmt.Errorf("querying old value for OldReferenceID: %w", err)
-	}
-	return oldValue.ReferenceID, nil
-}
-
-// ResetReferenceID resets all changes to the "reference_id" field.
-func (m *AchievementsSnapshotMutation) ResetReferenceID() {
-	m.reference_id = nil
-}
-
-// SetBattles sets the "battles" field.
-func (m *AchievementsSnapshotMutation) SetBattles(i int) {
-	m.battles = &i
-	m.addbattles = nil
-}
-
-// Battles returns the value of the "battles" field in the mutation.
-func (m *AchievementsSnapshotMutation) Battles() (r int, exists bool) {
-	v := m.battles
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
-// OldBattles returns the old "battles" field's value of the AchievementsSnapshot entity.
-// If the AchievementsSnapshot object wasn't provided to the builder, the object is fetched from the database.
-// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *AchievementsSnapshotMutation) OldBattles(ctx context.Context) (v int, err error) {
-	if !m.op.Is(OpUpdateOne) {
-		return v, errors.New("OldBattles is only allowed on UpdateOne operations")
-	}
-	if m.id == nil || m.oldValue == nil {
-		return v, errors.New("OldBattles requires an ID field in the mutation")
-	}
-	oldValue, err := m.oldValue(ctx)
-	if err != nil {
-		return v, fmt.Errorf("querying old value for OldBattles: %w", err)
-	}
-	return oldValue.Battles, nil
-}
-
-// AddBattles adds i to the "battles" field.
-func (m *AchievementsSnapshotMutation) AddBattles(i int) {
-	if m.addbattles != nil {
-		*m.addbattles += i
-	} else {
-		m.addbattles = &i
-	}
-}
-
-// AddedBattles returns the value that was added to the "battles" field in this mutation.
-func (m *AchievementsSnapshotMutation) AddedBattles() (r int, exists bool) {
-	v := m.addbattles
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
-// ResetBattles resets all changes to the "battles" field.
-func (m *AchievementsSnapshotMutation) ResetBattles() {
-	m.battles = nil
-	m.addbattles = nil
-}
-
-// SetLastBattleTime sets the "last_battle_time" field.
-func (m *AchievementsSnapshotMutation) SetLastBattleTime(t time.Time) {
-	m.last_battle_time = &t
-}
-
-// LastBattleTime returns the value of the "last_battle_time" field in the mutation.
-func (m *AchievementsSnapshotMutation) LastBattleTime() (r time.Time, exists bool) {
-	v := m.last_battle_time
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
-// OldLastBattleTime returns the old "last_battle_time" field's value of the AchievementsSnapshot entity.
-// If the AchievementsSnapshot object wasn't provided to the builder, the object is fetched from the database.
-// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *AchievementsSnapshotMutation) OldLastBattleTime(ctx context.Context) (v time.Time, err error) {
-	if !m.op.Is(OpUpdateOne) {
-		return v, errors.New("OldLastBattleTime is only allowed on UpdateOne operations")
-	}
-	if m.id == nil || m.oldValue == nil {
-		return v, errors.New("OldLastBattleTime requires an ID field in the mutation")
-	}
-	oldValue, err := m.oldValue(ctx)
-	if err != nil {
-		return v, fmt.Errorf("querying old value for OldLastBattleTime: %w", err)
-	}
-	return oldValue.LastBattleTime, nil
-}
-
-// ResetLastBattleTime resets all changes to the "last_battle_time" field.
-func (m *AchievementsSnapshotMutation) ResetLastBattleTime() {
-	m.last_battle_time = nil
-}
-
-// SetData sets the "data" field.
-func (m *AchievementsSnapshotMutation) SetData(tf types.AchievementsFrame) {
-	m.data = &tf
-}
-
-// Data returns the value of the "data" field in the mutation.
-func (m *AchievementsSnapshotMutation) Data() (r types.AchievementsFrame, exists bool) {
-	v := m.data
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
-// OldData returns the old "data" field's value of the AchievementsSnapshot entity.
-// If the AchievementsSnapshot object wasn't provided to the builder, the object is fetched from the database.
-// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *AchievementsSnapshotMutation) OldData(ctx context.Context) (v types.AchievementsFrame, err error) {
-	if !m.op.Is(OpUpdateOne) {
-		return v, errors.New("OldData is only allowed on UpdateOne operations")
-	}
-	if m.id == nil || m.oldValue == nil {
-		return v, errors.New("OldData requires an ID field in the mutation")
-	}
-	oldValue, err := m.oldValue(ctx)
-	if err != nil {
-		return v, fmt.Errorf("querying old value for OldData: %w", err)
-	}
-	return oldValue.Data, nil
-}
-
-// ResetData resets all changes to the "data" field.
-func (m *AchievementsSnapshotMutation) ResetData() {
-	m.data = nil
-}
-
-// ClearAccount clears the "account" edge to the Account entity.
-func (m *AchievementsSnapshotMutation) ClearAccount() {
-	m.clearedaccount = true
-	m.clearedFields[achievementssnapshot.FieldAccountID] = struct{}{}
-}
-
-// AccountCleared reports if the "account" edge to the Account entity was cleared.
-func (m *AchievementsSnapshotMutation) AccountCleared() bool {
-	return m.clearedaccount
-}
-
-// AccountIDs returns the "account" edge IDs in the mutation.
-// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
-// AccountID instead. It exists only for internal usage by the builders.
-func (m *AchievementsSnapshotMutation) AccountIDs() (ids []string) {
-	if id := m.account; id != nil {
-		ids = append(ids, *id)
-	}
-	return
-}
-
-// ResetAccount resets all changes to the "account" edge.
-func (m *AchievementsSnapshotMutation) ResetAccount() {
-	m.account = nil
-	m.clearedaccount = false
-}
-
-// Where appends a list predicates to the AchievementsSnapshotMutation builder.
-func (m *AchievementsSnapshotMutation) Where(ps ...predicate.AchievementsSnapshot) {
-	m.predicates = append(m.predicates, ps...)
-}
-
-// WhereP appends storage-level predicates to the AchievementsSnapshotMutation builder. Using this method,
-// users can use type-assertion to append predicates that do not depend on any generated package.
-func (m *AchievementsSnapshotMutation) WhereP(ps ...func(*sql.Selector)) {
-	p := make([]predicate.AchievementsSnapshot, len(ps))
-	for i := range ps {
-		p[i] = ps[i]
-	}
-	m.Where(p...)
-}
-
-// Op returns the operation name.
-func (m *AchievementsSnapshotMutation) Op() Op {
-	return m.op
-}
-
-// SetOp allows setting the mutation operation.
-func (m *AchievementsSnapshotMutation) SetOp(op Op) {
-	m.op = op
-}
-
-// Type returns the node type of this mutation (AchievementsSnapshot).
-func (m *AchievementsSnapshotMutation) Type() string {
-	return m.typ
-}
-
-// Fields returns all fields that were changed during this mutation. Note that in
-// order to get all numeric fields that were incremented/decremented, call
-// AddedFields().
-func (m *AchievementsSnapshotMutation) Fields() []string {
-	fields := make([]string, 0, 8)
-	if m.created_at != nil {
-		fields = append(fields, achievementssnapshot.FieldCreatedAt)
-	}
-	if m.updated_at != nil {
-		fields = append(fields, achievementssnapshot.FieldUpdatedAt)
-	}
-	if m._type != nil {
-		fields = append(fields, achievementssnapshot.FieldType)
-	}
-	if m.account != nil {
-		fields = append(fields, achievementssnapshot.FieldAccountID)
-	}
-	if m.reference_id != nil {
-		fields = append(fields, achievementssnapshot.FieldReferenceID)
-	}
-	if m.battles != nil {
-		fields = append(fields, achievementssnapshot.FieldBattles)
-	}
-	if m.last_battle_time != nil {
-		fields = append(fields, achievementssnapshot.FieldLastBattleTime)
-	}
-	if m.data != nil {
-		fields = append(fields, achievementssnapshot.FieldData)
-	}
-	return fields
-}
-
-// Field returns the value of a field with the given name. The second boolean
-// return value indicates that this field was not set, or was not defined in the
-// schema.
-func (m *AchievementsSnapshotMutation) Field(name string) (ent.Value, bool) {
-	switch name {
-	case achievementssnapshot.FieldCreatedAt:
-		return m.CreatedAt()
-	case achievementssnapshot.FieldUpdatedAt:
-		return m.UpdatedAt()
-	case achievementssnapshot.FieldType:
-		return m.GetType()
-	case achievementssnapshot.FieldAccountID:
-		return m.AccountID()
-	case achievementssnapshot.FieldReferenceID:
-		return m.ReferenceID()
-	case achievementssnapshot.FieldBattles:
-		return m.Battles()
-	case achievementssnapshot.FieldLastBattleTime:
-		return m.LastBattleTime()
-	case achievementssnapshot.FieldData:
-		return m.Data()
-	}
-	return nil, false
-}
-
-// OldField returns the old value of the field from the database. An error is
-// returned if the mutation operation is not UpdateOne, or the query to the
-// database failed.
-func (m *AchievementsSnapshotMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
-	switch name {
-	case achievementssnapshot.FieldCreatedAt:
-		return m.OldCreatedAt(ctx)
-	case achievementssnapshot.FieldUpdatedAt:
-		return m.OldUpdatedAt(ctx)
-	case achievementssnapshot.FieldType:
-		return m.OldType(ctx)
-	case achievementssnapshot.FieldAccountID:
-		return m.OldAccountID(ctx)
-	case achievementssnapshot.FieldReferenceID:
-		return m.OldReferenceID(ctx)
-	case achievementssnapshot.FieldBattles:
-		return m.OldBattles(ctx)
-	case achievementssnapshot.FieldLastBattleTime:
-		return m.OldLastBattleTime(ctx)
-	case achievementssnapshot.FieldData:
-		return m.OldData(ctx)
-	}
-	return nil, fmt.Errorf("unknown AchievementsSnapshot field %s", name)
-}
-
-// SetField sets the value of a field with the given name. It returns an error if
-// the field is not defined in the schema, or if the type mismatched the field
-// type.
-func (m *AchievementsSnapshotMutation) SetField(name string, value ent.Value) error {
-	switch name {
-	case achievementssnapshot.FieldCreatedAt:
-		v, ok := value.(time.Time)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.SetCreatedAt(v)
-		return nil
-	case achievementssnapshot.FieldUpdatedAt:
-		v, ok := value.(time.Time)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.SetUpdatedAt(v)
-		return nil
-	case achievementssnapshot.FieldType:
-		v, ok := value.(models.SnapshotType)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.SetType(v)
-		return nil
-	case achievementssnapshot.FieldAccountID:
-		v, ok := value.(string)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.SetAccountID(v)
-		return nil
-	case achievementssnapshot.FieldReferenceID:
-		v, ok := value.(string)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.SetReferenceID(v)
-		return nil
-	case achievementssnapshot.FieldBattles:
-		v, ok := value.(int)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.SetBattles(v)
-		return nil
-	case achievementssnapshot.FieldLastBattleTime:
-		v, ok := value.(time.Time)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.SetLastBattleTime(v)
-		return nil
-	case achievementssnapshot.FieldData:
-		v, ok := value.(types.AchievementsFrame)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.SetData(v)
-		return nil
-	}
-	return fmt.Errorf("unknown AchievementsSnapshot field %s", name)
-}
-
-// AddedFields returns all numeric fields that were incremented/decremented during
-// this mutation.
-func (m *AchievementsSnapshotMutation) AddedFields() []string {
-	var fields []string
-	if m.addbattles != nil {
-		fields = append(fields, achievementssnapshot.FieldBattles)
-	}
-	return fields
-}
-
-// AddedField returns the numeric value that was incremented/decremented on a field
-// with the given name. The second boolean return value indicates that this field
-// was not set, or was not defined in the schema.
-func (m *AchievementsSnapshotMutation) AddedField(name string) (ent.Value, bool) {
-	switch name {
-	case achievementssnapshot.FieldBattles:
-		return m.AddedBattles()
-	}
-	return nil, false
-}
-
-// AddField adds the value to the field with the given name. It returns an error if
-// the field is not defined in the schema, or if the type mismatched the field
-// type.
-func (m *AchievementsSnapshotMutation) AddField(name string, value ent.Value) error {
-	switch name {
-	case achievementssnapshot.FieldBattles:
-		v, ok := value.(int)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddBattles(v)
-		return nil
-	}
-	return fmt.Errorf("unknown AchievementsSnapshot numeric field %s", name)
-}
-
-// ClearedFields returns all nullable fields that were cleared during this
-// mutation.
-func (m *AchievementsSnapshotMutation) ClearedFields() []string {
-	return nil
-}
-
-// FieldCleared returns a boolean indicating if a field with the given name was
-// cleared in this mutation.
-func (m *AchievementsSnapshotMutation) FieldCleared(name string) bool {
-	_, ok := m.clearedFields[name]
-	return ok
-}
-
-// ClearField clears the value of the field with the given name. It returns an
-// error if the field is not defined in the schema.
-func (m *AchievementsSnapshotMutation) ClearField(name string) error {
-	return fmt.Errorf("unknown AchievementsSnapshot nullable field %s", name)
-}
-
-// ResetField resets all changes in the mutation for the field with the given name.
-// It returns an error if the field is not defined in the schema.
-func (m *AchievementsSnapshotMutation) ResetField(name string) error {
-	switch name {
-	case achievementssnapshot.FieldCreatedAt:
-		m.ResetCreatedAt()
-		return nil
-	case achievementssnapshot.FieldUpdatedAt:
-		m.ResetUpdatedAt()
-		return nil
-	case achievementssnapshot.FieldType:
-		m.ResetType()
-		return nil
-	case achievementssnapshot.FieldAccountID:
-		m.ResetAccountID()
-		return nil
-	case achievementssnapshot.FieldReferenceID:
-		m.ResetReferenceID()
-		return nil
-	case achievementssnapshot.FieldBattles:
-		m.ResetBattles()
-		return nil
-	case achievementssnapshot.FieldLastBattleTime:
-		m.ResetLastBattleTime()
-		return nil
-	case achievementssnapshot.FieldData:
-		m.ResetData()
-		return nil
-	}
-	return fmt.Errorf("unknown AchievementsSnapshot field %s", name)
-}
-
-// AddedEdges returns all edge names that were set/added in this mutation.
-func (m *AchievementsSnapshotMutation) AddedEdges() []string {
-	edges := make([]string, 0, 1)
-	if m.account != nil {
-		edges = append(edges, achievementssnapshot.EdgeAccount)
-	}
-	return edges
-}
-
-// AddedIDs returns all IDs (to other nodes) that were added for the given edge
-// name in this mutation.
-func (m *AchievementsSnapshotMutation) AddedIDs(name string) []ent.Value {
-	switch name {
-	case achievementssnapshot.EdgeAccount:
-		if id := m.account; id != nil {
-			return []ent.Value{*id}
-		}
-	}
-	return nil
-}
-
-// RemovedEdges returns all edge names that were removed in this mutation.
-func (m *AchievementsSnapshotMutation) RemovedEdges() []string {
-	edges := make([]string, 0, 1)
-	return edges
-}
-
-// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
-// the given name in this mutation.
-func (m *AchievementsSnapshotMutation) RemovedIDs(name string) []ent.Value {
-	return nil
-}
-
-// ClearedEdges returns all edge names that were cleared in this mutation.
-func (m *AchievementsSnapshotMutation) ClearedEdges() []string {
-	edges := make([]string, 0, 1)
-	if m.clearedaccount {
-		edges = append(edges, achievementssnapshot.EdgeAccount)
-	}
-	return edges
-}
-
-// EdgeCleared returns a boolean which indicates if the edge with the given name
-// was cleared in this mutation.
-func (m *AchievementsSnapshotMutation) EdgeCleared(name string) bool {
-	switch name {
-	case achievementssnapshot.EdgeAccount:
-		return m.clearedaccount
-	}
-	return false
-}
-
-// ClearEdge clears the value of the edge with the given name. It returns an error
-// if that edge is not defined in the schema.
-func (m *AchievementsSnapshotMutation) ClearEdge(name string) error {
-	switch name {
-	case achievementssnapshot.EdgeAccount:
-		m.ClearAccount()
-		return nil
-	}
-	return fmt.Errorf("unknown AchievementsSnapshot unique edge %s", name)
-}
-
-// ResetEdge resets all changes to the edge with the given name in this mutation.
-// It returns an error if the edge is not defined in the schema.
-func (m *AchievementsSnapshotMutation) ResetEdge(name string) error {
-	switch name {
-	case achievementssnapshot.EdgeAccount:
-		m.ResetAccount()
-		return nil
-	}
-	return fmt.Errorf("unknown AchievementsSnapshot edge %s", name)
-}
-
 // AppConfigurationMutation represents an operation that mutates the AppConfiguration nodes in the graph.
 type AppConfigurationMutation struct {
 	config
diff --git a/internal/database/ent/db/predicate/predicate.go b/internal/database/ent/db/predicate/predicate.go
index 8eb4deb6..f2fdcde3 100644
--- a/internal/database/ent/db/predicate/predicate.go
+++ b/internal/database/ent/db/predicate/predicate.go
@@ -12,9 +12,6 @@ type Account func(*sql.Selector)
 // AccountSnapshot is the predicate function for accountsnapshot builders.
 type AccountSnapshot func(*sql.Selector)
 
-// AchievementsSnapshot is the predicate function for achievementssnapshot builders.
-type AchievementsSnapshot func(*sql.Selector)
-
 // AppConfiguration is the predicate function for appconfiguration builders.
 type AppConfiguration func(*sql.Selector)
 
diff --git a/internal/database/ent/db/runtime.go b/internal/database/ent/db/runtime.go
index 86a1c61d..0814af83 100644
--- a/internal/database/ent/db/runtime.go
+++ b/internal/database/ent/db/runtime.go
@@ -7,7 +7,6 @@ import (
 
 	"github.com/cufee/aftermath/internal/database/ent/db/account"
 	"github.com/cufee/aftermath/internal/database/ent/db/accountsnapshot"
-	"github.com/cufee/aftermath/internal/database/ent/db/achievementssnapshot"
 	"github.com/cufee/aftermath/internal/database/ent/db/appconfiguration"
 	"github.com/cufee/aftermath/internal/database/ent/db/applicationcommand"
 	"github.com/cufee/aftermath/internal/database/ent/db/authnonce"
@@ -92,30 +91,6 @@ func init() {
 	accountsnapshotDescID := accountsnapshotFields[0].Descriptor()
 	// accountsnapshot.DefaultID holds the default value on creation for the id field.
 	accountsnapshot.DefaultID = accountsnapshotDescID.Default.(func() string)
-	achievementssnapshotFields := schema.AchievementsSnapshot{}.Fields()
-	_ = achievementssnapshotFields
-	// achievementssnapshotDescCreatedAt is the schema descriptor for created_at field.
-	achievementssnapshotDescCreatedAt := achievementssnapshotFields[1].Descriptor()
-	// achievementssnapshot.DefaultCreatedAt holds the default value on creation for the created_at field.
-	achievementssnapshot.DefaultCreatedAt = achievementssnapshotDescCreatedAt.Default.(func() time.Time)
-	// achievementssnapshotDescUpdatedAt is the schema descriptor for updated_at field.
-	achievementssnapshotDescUpdatedAt := achievementssnapshotFields[2].Descriptor()
-	// achievementssnapshot.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	achievementssnapshot.DefaultUpdatedAt = achievementssnapshotDescUpdatedAt.Default.(func() time.Time)
-	// achievementssnapshot.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	achievementssnapshot.UpdateDefaultUpdatedAt = achievementssnapshotDescUpdatedAt.UpdateDefault.(func() time.Time)
-	// achievementssnapshotDescAccountID is the schema descriptor for account_id field.
-	achievementssnapshotDescAccountID := achievementssnapshotFields[4].Descriptor()
-	// achievementssnapshot.AccountIDValidator is a validator for the "account_id" field. It is called by the builders before save.
-	achievementssnapshot.AccountIDValidator = achievementssnapshotDescAccountID.Validators[0].(func(string) error)
-	// achievementssnapshotDescReferenceID is the schema descriptor for reference_id field.
-	achievementssnapshotDescReferenceID := achievementssnapshotFields[5].Descriptor()
-	// achievementssnapshot.ReferenceIDValidator is a validator for the "reference_id" field. It is called by the builders before save.
-	achievementssnapshot.ReferenceIDValidator = achievementssnapshotDescReferenceID.Validators[0].(func(string) error)
-	// achievementssnapshotDescID is the schema descriptor for id field.
-	achievementssnapshotDescID := achievementssnapshotFields[0].Descriptor()
-	// achievementssnapshot.DefaultID holds the default value on creation for the id field.
-	achievementssnapshot.DefaultID = achievementssnapshotDescID.Default.(func() string)
 	appconfigurationFields := schema.AppConfiguration{}.Fields()
 	_ = appconfigurationFields
 	// appconfigurationDescCreatedAt is the schema descriptor for created_at field.
diff --git a/internal/database/ent/db/tx.go b/internal/database/ent/db/tx.go
index e067bd1e..3c1b900e 100644
--- a/internal/database/ent/db/tx.go
+++ b/internal/database/ent/db/tx.go
@@ -18,8 +18,6 @@ type Tx struct {
 	Account *AccountClient
 	// AccountSnapshot is the client for interacting with the AccountSnapshot builders.
 	AccountSnapshot *AccountSnapshotClient
-	// AchievementsSnapshot is the client for interacting with the AchievementsSnapshot builders.
-	AchievementsSnapshot *AchievementsSnapshotClient
 	// AppConfiguration is the client for interacting with the AppConfiguration builders.
 	AppConfiguration *AppConfigurationClient
 	// ApplicationCommand is the client for interacting with the ApplicationCommand builders.
@@ -183,7 +181,6 @@ func (tx *Tx) Client() *Client {
 func (tx *Tx) init() {
 	tx.Account = NewAccountClient(tx.config)
 	tx.AccountSnapshot = NewAccountSnapshotClient(tx.config)
-	tx.AchievementsSnapshot = NewAchievementsSnapshotClient(tx.config)
 	tx.AppConfiguration = NewAppConfigurationClient(tx.config)
 	tx.ApplicationCommand = NewApplicationCommandClient(tx.config)
 	tx.AuthNonce = NewAuthNonceClient(tx.config)
diff --git a/internal/database/ent/migrations/20240710142748.sql b/internal/database/ent/migrations/20240710142748.sql
new file mode 100644
index 00000000..680bcabd
--- /dev/null
+++ b/internal/database/ent/migrations/20240710142748.sql
@@ -0,0 +1,6 @@
+-- Disable the enforcement of foreign-keys constraints
+PRAGMA foreign_keys = off;
+-- Drop "achievements_snapshots" table
+DROP TABLE `achievements_snapshots`;
+-- Enable back the enforcement of foreign-keys constraints
+PRAGMA foreign_keys = on;
diff --git a/internal/database/ent/migrations/atlas.sum b/internal/database/ent/migrations/atlas.sum
index ba69ee30..07d4fed5 100644
--- a/internal/database/ent/migrations/atlas.sum
+++ b/internal/database/ent/migrations/atlas.sum
@@ -1,3 +1,4 @@
-h1:7B9NoTmspiv10N3sx9FWlA1dQyccMUgRW0uT9FDhx0k=
+h1:PC0+YywPJcbReEbDKKDiMLOUPwQYKi8q46VZyoJcyS4=
 20240709203105.sql h1:zmiEUhVtnH3IM1/S7iyJpJ4PwqhcZw50OcNYMcjTwrE=
 20240709213804.sql h1:QE6wE3hSW0DpgYCPzwPw7BHWi0NGkcE7qRnJJZIXI6E=
+20240710142748.sql h1:ikNIxx8rPvm0lIrF9P27v8sK3ucxcKLB49FJMC8axg0=
diff --git a/internal/database/ent/schema/account.go b/internal/database/ent/schema/account.go
index ce4ca153..50cec04a 100644
--- a/internal/database/ent/schema/account.go
+++ b/internal/database/ent/schema/account.go
@@ -42,7 +42,6 @@ func (Account) Fields() []ent.Field {
 func (Account) Edges() []ent.Edge {
 	return []ent.Edge{
 		edge.From("clan", Clan.Type).Ref("accounts").Field("clan_id").Unique(),
-		edge.To("achievement_snapshots", AchievementsSnapshot.Type).Annotations(entsql.OnDelete(entsql.Cascade)),
 		edge.To("vehicle_snapshots", VehicleSnapshot.Type).Annotations(entsql.OnDelete(entsql.Cascade)),
 		edge.To("account_snapshots", AccountSnapshot.Type).Annotations(entsql.OnDelete(entsql.Cascade)),
 	}
diff --git a/internal/database/ent/schema/achievements_snapshot.go b/internal/database/ent/schema/achievements_snapshot.go
deleted file mode 100644
index 9c9c1158..00000000
--- a/internal/database/ent/schema/achievements_snapshot.go
+++ /dev/null
@@ -1,42 +0,0 @@
-package schema
-
-import (
-	"entgo.io/ent"
-	"entgo.io/ent/schema/edge"
-	"entgo.io/ent/schema/field"
-	"entgo.io/ent/schema/index"
-	"github.com/cufee/aftermath/internal/database/models"
-	"github.com/cufee/am-wg-proxy-next/v2/types"
-)
-
-type AchievementsSnapshot struct {
-	ent.Schema
-}
-
-func (AchievementsSnapshot) Fields() []ent.Field {
-	return append(defaultFields,
-		field.Enum("type").
-			GoType(models.SnapshotType("")),
-		field.String("account_id").NotEmpty().Immutable(),
-		field.String("reference_id").NotEmpty(),
-		//
-		field.Int("battles"),
-		field.Time("last_battle_time"),
-		field.JSON("data", types.AchievementsFrame{}),
-	)
-}
-
-func (AchievementsSnapshot) Edges() []ent.Edge {
-	return []ent.Edge{
-		edge.From("account", Account.Type).Ref("achievement_snapshots").Field("account_id").Required().Immutable().Unique(),
-	}
-}
-
-func (AchievementsSnapshot) Indexes() []ent.Index {
-	return []ent.Index{
-		index.Fields("id"),
-		index.Fields("created_at"),
-		index.Fields("account_id", "reference_id"),
-		index.Fields("account_id", "reference_id", "created_at"),
-	}
-}
diff --git a/internal/database/snapshots.go b/internal/database/snapshots.go
index 3b8c9764..57649099 100644
--- a/internal/database/snapshots.go
+++ b/internal/database/snapshots.go
@@ -7,8 +7,6 @@ import (
 	"entgo.io/ent/dialect/sql"
 	"github.com/cufee/aftermath/internal/database/ent/db"
 	"github.com/cufee/aftermath/internal/database/ent/db/accountsnapshot"
-	"github.com/cufee/aftermath/internal/database/ent/db/achievementssnapshot"
-	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
 	"github.com/cufee/aftermath/internal/database/ent/db/vehiclesnapshot"
 	"github.com/cufee/aftermath/internal/database/models"
 )
@@ -41,19 +39,6 @@ func toAccountSnapshot(record *db.AccountSnapshot) models.AccountSnapshot {
 	}
 }
 
-func toAchievementsSnapshot(record *db.AchievementsSnapshot) models.AchievementsSnapshot {
-	return models.AchievementsSnapshot{
-		ID:             record.ID,
-		Type:           record.Type,
-		CreatedAt:      record.CreatedAt,
-		LastBattleTime: record.LastBattleTime,
-		ReferenceID:    record.ReferenceID,
-		AccountID:      record.AccountID,
-		Battles:        record.Battles,
-		Data:           record.Data,
-	}
-}
-
 // --- vehicle snapshots ---
 
 /*
@@ -335,77 +320,3 @@ func accountsQuery(accountIDs []string, kind models.SnapshotType, groupBy string
 	queryString, _ := sql.Select(selectFields...).FromExpr(wrap(innerQueryString)).GroupBy(groupBy).Query()
 	return queryString, innerQueryArgs
 }
-
-// --- achievement snapshots ---
-
-func (c *client) GetAchievementSnapshots(ctx context.Context, accountIDs []string, kind models.SnapshotType, options ...Query) ([]models.AchievementsSnapshot, error) {
-	if len(accountIDs) < 1 {
-		return nil, new(db.NotFoundError)
-	}
-
-	var query baseQueryOptions
-	for _, apply := range options {
-		apply(&query)
-	}
-
-	var where []predicate.AchievementsSnapshot
-	var orderBy achievementssnapshot.OrderOption
-	orderBy = achievementssnapshot.ByCreatedAt(sql.OrderDesc())
-	where = append(where, achievementssnapshot.AccountIDIn(accountIDs...), achievementssnapshot.TypeEQ(kind))
-
-	if query.createdAfter != nil {
-		where = append(where, achievementssnapshot.CreatedAtGT(*query.createdAfter))
-		orderBy = achievementssnapshot.ByCreatedAt(sql.OrderAsc())
-	}
-	if query.createdBefore != nil {
-		where = append(where, achievementssnapshot.CreatedAtLT(*query.createdAfter))
-		orderBy = achievementssnapshot.ByCreatedAt(sql.OrderDesc())
-	}
-
-	records, err := c.db.AchievementsSnapshot.Query().Select(query.selectFields()...).Order(orderBy).Where(where...).All(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	var snapshots []models.AchievementsSnapshot
-	for _, r := range records {
-		snapshots = append(snapshots, toAchievementsSnapshot(r))
-	}
-
-	return snapshots, nil
-}
-
-func (c *client) CreateAccountAchievementSnapshots(ctx context.Context, accountID string, snapshots ...models.AchievementsSnapshot) (map[string]error, error) {
-	if len(snapshots) < 1 {
-		return nil, nil
-	}
-
-	account, err := c.db.Account.Get(ctx, accountID)
-	if err != nil {
-		return nil, err
-	}
-
-	var errors = make(map[string]error)
-	for _, data := range snapshots {
-		// make a transaction per write to avoid locking for too long
-		err := c.withTx(ctx, func(tx *db.Tx) error {
-			return c.db.AchievementsSnapshot.Create().
-				SetType(data.Type).
-				SetData(data.Data).
-				SetBattles(data.Battles).
-				SetCreatedAt(data.CreatedAt).
-				SetReferenceID(data.ReferenceID).
-				SetLastBattleTime(data.LastBattleTime).
-				SetAccount(account).
-				Exec(ctx)
-		})
-		if err != nil {
-			errors[data.ReferenceID] = err
-		}
-	}
-
-	if len(errors) > 0 {
-		return errors, nil
-	}
-	return nil, nil
-}
diff --git a/internal/logic/snapshots.go b/internal/logic/snapshots.go
index 198e854c..30d1e6c2 100644
--- a/internal/logic/snapshots.go
+++ b/internal/logic/snapshots.go
@@ -76,12 +76,9 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 
 	var group sync.WaitGroup
 	var clans = make(map[string]types.ClanMember)
-	var accountAchievements retry.DataWithErr[map[string]types.AchievementsFrame]
 
 	var accountVehiclesMx sync.Mutex
-	var accountVehicleAchievementsMx sync.Mutex
 	accountVehicles := make(map[string]retry.DataWithErr[[]types.VehicleStatsFrame], len(accountsNeedAnUpdate))
-	accountVehicleAchievements := make(map[string]retry.DataWithErr[map[string]types.AchievementsFrame], len(accountsNeedAnUpdate))
 
 	for _, id := range accountsNeedAnUpdate {
 		group.Add(1)
@@ -94,17 +91,6 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 			accountVehicles[id] = retry.DataWithErr[[]types.VehicleStatsFrame]{Data: data, Err: err}
 			accountVehiclesMx.Unlock()
 		}(id)
-
-		group.Add(1)
-		// get account vehicle achievements
-		go func(id string) {
-			defer group.Done()
-			data, err := wgClient.AccountVehicleAchievements(ctx, realm, id)
-
-			accountVehicleAchievementsMx.Lock()
-			accountVehicleAchievements[id] = retry.DataWithErr[map[string]types.AchievementsFrame]{Data: data, Err: err}
-			accountVehicleAchievementsMx.Unlock()
-		}(id)
 	}
 
 	group.Add(1)
@@ -119,20 +105,6 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 		clans = data
 	}()
 
-	// disabled for now as this data is unused
-	// group.Add(1)
-	// // get account achievements, not critical
-	// go func() {
-	// 	defer group.Done()
-	// 	// clans are optional-ish
-	// 	data, err := wgClient.BatchAccountAchievements(ctx, realm, accountsNeedAnUpdate)
-	// 	if err != nil {
-	// 		log.Err(err).Msg("failed to get batch account achievements")
-	// 	}
-	// 	accountAchievements.Data = data
-	// 	accountAchievements.Err = err
-	// }()
-
 	group.Wait()
 
 	var accountErrors = make(map[string]error)
@@ -140,7 +112,6 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 
 	var accountSnapshots []models.AccountSnapshot
 	var vehicleSnapshots = make(map[string][]models.VehicleSnapshot)
-	var achievementsSnapshots = make(map[string][]models.AchievementsSnapshot)
 
 	for _, accountID := range accountsNeedAnUpdate {
 		vehicles := accountVehicles[accountID]
@@ -191,46 +162,6 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 				})
 			}
 		}
-
-		// account achievement snapshot
-		if accountAchievements.Err != nil {
-			accountErrors[accountID] = errors.Wrap(accountAchievements.Err, "failed to get account achievements")
-		}
-		if achievements, ok := accountAchievements.Data[accountID]; ok {
-			achievementsSnapshots[accountID] = append(achievementsSnapshots[accountID], models.AchievementsSnapshot{
-				Data:           achievements,
-				CreatedAt:      createdAt,
-				AccountID:      accountID,
-				ReferenceID:    accountID,
-				Type:           models.SnapshotTypeDaily,
-				LastBattleTime: snapshotStats.LastBattleTime,
-				Battles:        int(snapshotStats.RegularBattles.Battles.Float()),
-			})
-		}
-
-		// account vehicle achievement snapshots
-		if achievements, ok := accountVehicleAchievements[accountID]; ok {
-			if achievements.Err != nil {
-				accountErrors[accountID] = errors.Wrap(achievements.Err, "failed to get vehicle achievements")
-			}
-			for vehicleID, a := range achievements.Data {
-				battleData, ok := vehicleLastBattleTimes[vehicleID]
-				if !ok {
-					// vehicle was not played, no need to save achievements
-					continue
-				}
-
-				achievementsSnapshots[accountID] = append(achievementsSnapshots[accountID], models.AchievementsSnapshot{
-					Data:           a,
-					CreatedAt:      createdAt,
-					AccountID:      accountID,
-					ReferenceID:    vehicleID,
-					Battles:        battleData.Battles,
-					LastBattleTime: battleData.LastBattle,
-					Type:           models.SnapshotTypeDaily,
-				})
-			}
-		}
 	}
 
 	for _, accountSnapshot := range accountSnapshots {
@@ -248,27 +179,6 @@ func RecordAccountSnapshots(ctx context.Context, wgClient wargaming.Client, dbCl
 			}
 		}
 
-		achievements := achievementsSnapshots[accountSnapshot.AccountID]
-		if len(achievements) > 0 {
-			achErr, err := dbClient.CreateAccountAchievementSnapshots(ctx, accountSnapshot.AccountID, achievements...)
-			if err != nil {
-				accountErrors[accountSnapshot.AccountID] = errors.Wrap(err, "failed to save account achievements to database")
-				continue
-			}
-
-			for id, e := range achErr {
-				if e != nil {
-					err = errors.Wrapf(e, "failed to save some achievement snapshots, id %s", id)
-					break
-				}
-			}
-			if err != nil {
-				accountErrors[accountSnapshot.AccountID] = err
-				continue
-			}
-
-		}
-
 		// save account snapshot
 		aErr, err := dbClient.CreateAccountSnapshots(ctx, accountSnapshot)
 		if err != nil {

From 02afa33a32381beecd1aaaf52f99e26242594676 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 11 Jul 2024 12:27:26 -0400
Subject: [PATCH 334/341] using assets repo for glossary

---
 cmd/core/scheduler/scheduler.go            |  4 +-
 cmd/core/scheduler/workers.go              | 55 ++++++++++++++--------
 go.mod                                     | 10 ++--
 go.sum                                     | 22 ++++++---
 internal/database/ent/db/mutation.go       | 11 +++--
 internal/database/ent/db/vehicle.go        |  3 +-
 internal/database/ent/db/vehicle_create.go |  3 +-
 internal/database/ent/db/vehicle_update.go |  5 +-
 internal/database/ent/schema/vehicle.go    |  3 +-
 internal/database/models/vehicle.go        | 11 ++---
 internal/external/github/assets.go         | 31 ++++++++++++
 internal/external/github/assets_test.go    | 23 +++++++++
 main.go                                    |  3 ++
 tests/static_database.go                   |  3 +-
 14 files changed, 138 insertions(+), 49 deletions(-)
 create mode 100644 internal/external/github/assets.go
 create mode 100644 internal/external/github/assets_test.go

diff --git a/cmd/core/scheduler/scheduler.go b/cmd/core/scheduler/scheduler.go
index d9d0ae20..35df3017 100644
--- a/cmd/core/scheduler/scheduler.go
+++ b/cmd/core/scheduler/scheduler.go
@@ -37,8 +37,8 @@ func RegisterDefaultTasks(s *scheduler, coreClient core.Client) {
 	s.Add("0 5 * * *", CreateCleanupTaskWorker(coreClient)) // delete expired documents
 
 	// Glossary - Do it around the same time WG releases game updates
-	s.Add("0 10 * * *", UpdateGlossaryWorker(coreClient))
-	s.Add("0 12 * * *", UpdateGlossaryWorker(coreClient))
+	s.Add("10 12 * * *", UpdateGlossaryWorker(coreClient))
+	s.Add("10 10 * * *", UpdateGlossaryWorker(coreClient))
 	// c.AddFunc("40 9 * * 0", updateAchievementsWorker)
 
 	// Averages - Update averages once daily
diff --git a/cmd/core/scheduler/workers.go b/cmd/core/scheduler/workers.go
index 571f00ec..4b35fb3c 100644
--- a/cmd/core/scheduler/workers.go
+++ b/cmd/core/scheduler/workers.go
@@ -1,15 +1,19 @@
 package scheduler
 
 import (
+	"archive/zip"
+	"bytes"
 	"context"
+	"encoding/json"
+	"io"
 	"time"
 
 	"github.com/cufee/aftermath/cmd/core"
 	"github.com/cufee/aftermath/cmd/core/tasks"
-	"golang.org/x/text/language"
 
 	"github.com/cufee/aftermath/internal/database"
 	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/external/github"
 	"github.com/cufee/aftermath/internal/log"
 )
 
@@ -121,38 +125,49 @@ func UpdateGlossaryWorker(client core.Client) func() {
 	return func() {
 		log.Info().Msg("updating glossary cache")
 
-		ctx, cancel := context.WithTimeout(context.Background(), time.Second*15)
+		dctx, cancel := context.WithTimeout(context.Background(), time.Second*2)
 		defer cancel()
 
-		glossary, err := client.Wargaming().CompleteVehicleGlossary(ctx, "eu", "en")
+		rc, size, err := github.GetLatestGameAssets(dctx)
 		if err != nil {
-			log.Err(err).Msg("failed to get vehicle glossary")
+			log.Err(err).Msg("failed to download latest game assets")
 			return
 		}
 
-		vehicles := make(map[string]models.Vehicle)
-		for id, data := range glossary {
-			vehicles[id] = models.Vehicle{
-				ID:             id,
-				Tier:           data.Tier,
-				LocalizedNames: map[string]string{language.English.String(): data.Name},
-			}
+		data, err := io.ReadAll(rc)
+		rc.Close()
+		if err != nil {
+			log.Err(err).Msg("failed to read assets data")
+			return
 		}
 
-		vErr, err := client.Database().UpsertVehicles(ctx, vehicles)
+		zr, err := zip.NewReader(bytes.NewReader(data), size)
 		if err != nil {
-			log.Err(err).Msg("failed to save vehicle glossary")
+			log.Err(err).Msg("failed to read assets as zip")
 			return
 		}
-		if len(vErr) > 0 {
-			event := log.Error()
-			for id, err := range vErr {
-				event.Str(id, err.Error())
-			}
-			event.Msg("failed to save some vehicle glossaries")
+
+		vf, err := zr.Open("assets/vehicles.json")
+		if err != nil {
+			log.Err(err).Msg("failed to open vehicles.json in assets.zip")
 			return
-		}
+		} else {
+			var vehicles map[string]models.Vehicle
+			err := json.NewDecoder(vf).Decode(&vehicles)
+			if err != nil {
+				log.Err(err).Msg("failed to decode vehicles.json")
+				return
+			}
 
+			vctx, cancel := context.WithTimeout(context.Background(), time.Second*15)
+			defer cancel()
+
+			_, err = client.Database().UpsertVehicles(vctx, vehicles)
+			if err != nil {
+				log.Err(err).Msg("failed to save vehicle glossary")
+				return
+			}
+		}
 		log.Info().Msg("glossary cache updated")
 	}
 }
diff --git a/go.mod b/go.mod
index ccef4fab..8866b1d9 100644
--- a/go.mod
+++ b/go.mod
@@ -8,14 +8,17 @@ require (
 	github.com/PuerkitoBio/goquery v1.8.1
 	github.com/a-h/templ v0.2.731
 	github.com/bwmarrin/discordgo v0.28.1
+	github.com/cufee/aftermath-assets v0.0.1
 	github.com/cufee/am-wg-proxy-next/v2 v2.1.7
 	github.com/disintegration/imaging v1.6.2
 	github.com/fogleman/gg v1.3.0
 	github.com/go-co-op/gocron v1.37.0
 	github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0
+	github.com/google/go-github/v63 v63.0.0
 	github.com/joho/godotenv v1.5.1
 	github.com/justinas/alice v1.2.0
 	github.com/lucsky/cuid v1.2.1
+	github.com/matryer/is v1.4.1
 	github.com/mattn/go-sqlite3 v1.14.22
 	github.com/nlpodyssey/gopickle v0.3.0
 	github.com/pierrec/lz4/v4 v4.1.21
@@ -39,6 +42,7 @@ require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/go-openapi/inflect v0.21.0 // indirect
 	github.com/google/go-cmp v0.6.0 // indirect
+	github.com/google/go-querystring v1.1.0 // indirect
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/hashicorp/hcl/v2 v2.21.0 // indirect
@@ -51,9 +55,9 @@ require (
 	github.com/tdewolff/parse/v2 v2.7.15 // indirect
 	github.com/zclconf/go-cty v1.14.4 // indirect
 	go.uber.org/atomic v1.11.0 // indirect
-	golang.org/x/crypto v0.24.0 // indirect
+	golang.org/x/crypto v0.25.0 // indirect
 	golang.org/x/mod v0.18.0 // indirect
-	golang.org/x/net v0.26.0 // indirect
-	golang.org/x/sys v0.21.0 // indirect
+	golang.org/x/net v0.27.0 // indirect
+	golang.org/x/sys v0.22.0 // indirect
 	golang.org/x/tools v0.22.0 // indirect
 )
diff --git a/go.sum b/go.sum
index 17b3ed44..bdb3dbfa 100644
--- a/go.sum
+++ b/go.sum
@@ -20,6 +20,8 @@ github.com/bwmarrin/discordgo v0.28.1 h1:gXsuo2GBO7NbR6uqmrrBDplPUx2T3nzu775q/Rd
 github.com/bwmarrin/discordgo v0.28.1/go.mod h1:NJZpH+1AfhIcyQsPeuBKsUtYrRnjkyu0kIVMCHkZtRY=
 github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
+github.com/cufee/aftermath-assets v0.0.1 h1:4XBoGrEP/h+H5sHNDI8GF+K4VMTLcrcBaV8uwAfHtrs=
+github.com/cufee/aftermath-assets v0.0.1/go.mod h1:6yCITCiz7POJnUMn1oohvadLA4z5YrFNo3p9EKgRdGU=
 github.com/cufee/am-wg-proxy-next/v2 v2.1.7 h1:cNIQ6hLM/eqqKLuNH0K52AEjzQQqwo7qoi9VOXD6bSM=
 github.com/cufee/am-wg-proxy-next/v2 v2.1.7/go.mod h1:+VxiIdbrdhHdRThASbVmZ5Fz4H6XPCzL3S2Ix6TO/84=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -38,8 +40,13 @@ github.com/go-test/deep v1.0.3/go.mod h1:wGDj63lr65AM2AQyKZd/NYHGb0R+1RLqB8NKt3a
 github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
 github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 h1:DACJavvAHhabrF08vX0COfcOBJRhZ8lUbR+ZWIs0Y5g=
 github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k=
+github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/go-github/v63 v63.0.0 h1:13xwK/wk9alSokujB9lJkuzdmQuVn2QCPeck76wR3nE=
+github.com/google/go-github/v63 v63.0.0/go.mod h1:IqbcrgUmIcEaioWrGYei/09o+ge5vhffGOcxrO0AfmA=
+github.com/google/go-querystring v1.1.0 h1:AnCroh3fv4ZBgVIf1Iwtovgjaw/GiKJo8M8yD/fhyJ8=
+github.com/google/go-querystring v1.1.0/go.mod h1:Kcdr2DB4koayq7X8pmAG4sNG59So17icRSOU623lUBU=
 github.com/google/uuid v1.4.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
@@ -62,6 +69,8 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/lucsky/cuid v1.2.1 h1:MtJrL2OFhvYufUIn48d35QGXyeTC8tn0upumW9WwTHg=
 github.com/lucsky/cuid v1.2.1/go.mod h1:QaaJqckboimOmhRSJXSx/+IT+VTfxfPGSo/6mfgUfmE=
+github.com/matryer/is v1.4.1 h1:55ehd8zaGABKLXQUe2awZ99BD/PTc2ls+KV/dXphgEQ=
+github.com/matryer/is v1.4.1/go.mod h1:8I/i5uYgLzgsgEloJE1U6xx5HkBQpAZvepWuujKwMRU=
 github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
 github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
 github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
@@ -137,8 +146,8 @@ golang.org/x/crypto v0.0.0-20190123085648-057139ce5d2b/go.mod h1:6SG95UA2DQfeDnf
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.24.0 h1:mnl8DM0o513X8fdIkmyFE/5hTYxbwYOjDS/+rK6qpRI=
-golang.org/x/crypto v0.24.0/go.mod h1:Z1PMYSOR5nyMcyAVAIQSKCDwalqy85Aqn1x3Ws4L5DM=
+golang.org/x/crypto v0.25.0 h1:ypSNr+bnYL2YhwoMt2zPxHFmbAN1KZs/njMG3hxUp30=
+golang.org/x/crypto v0.25.0/go.mod h1:T+wALwcMOSE0kXgUAnPAHqTLW+XHgcELELW8VaDgm/M=
 golang.org/x/exp v0.0.0-20240613232115-7f521ea00fb8 h1:yixxcjnhBmY0nkL253HFVIm0JsFHwrHdT3Yh6szTnfY=
 golang.org/x/exp v0.0.0-20240613232115-7f521ea00fb8/go.mod h1:jj3sYF3dwk5D+ghuXyeI3r5MFf+NT2An6/9dOA95KSI=
 golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
@@ -152,8 +161,8 @@ golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v
 golang.org/x/net v0.0.0-20210916014120-12bc252f5db8/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
 golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
-golang.org/x/net v0.26.0 h1:soB7SVo0PWrY4vPW/+ay0jKDNScG2X9wFeYlXIvJsOQ=
-golang.org/x/net v0.26.0/go.mod h1:5YKkiSynbBIh3p6iOc/vibscux0x38BZDkn8sCUPxHE=
+golang.org/x/net v0.27.0 h1:5K3Njcw06/l2y9vpGCSdcxWOYHOUk3dVNGDXN+FvAys=
+golang.org/x/net v0.27.0/go.mod h1:dDi0PyhWNoiUOrAS8uXv/vnScO4wnHQO4mj9fn/RytE=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
@@ -169,8 +178,8 @@ golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.21.0 h1:rF+pYz3DAGSQAxAu1CbC7catZg4ebC4UIeIhKxBZvws=
-golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.22.0 h1:RI27ohtqKCnwULzJLqkv897zojh5/DwS/ENaMzUOaWI=
+golang.org/x/sys v0.22.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
@@ -187,6 +196,7 @@ golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc
 golang.org/x/tools v0.22.0 h1:gqSGLZqv+AI9lIQzniJ0nZDRG5GBPsSi+DRNHWNz6yA=
 golang.org/x/tools v0.22.0/go.mod h1:aCwcsjqvq7Yqt6TNyX7QMU2enbQ/Gt0bo6krSeEri+c=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
diff --git a/internal/database/ent/db/mutation.go b/internal/database/ent/db/mutation.go
index d45e5e54..705cb6c1 100644
--- a/internal/database/ent/db/mutation.go
+++ b/internal/database/ent/db/mutation.go
@@ -31,6 +31,7 @@ import (
 	"github.com/cufee/aftermath/internal/database/ent/db/vehiclesnapshot"
 	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/stats/frame"
+	"golang.org/x/text/language"
 )
 
 const (
@@ -10708,7 +10709,7 @@ type VehicleMutation struct {
 	updated_at      *time.Time
 	tier            *int
 	addtier         *int
-	localized_names *map[string]string
+	localized_names *map[language.Tag]string
 	clearedFields   map[string]struct{}
 	done            bool
 	oldValue        func(context.Context) (*Vehicle, error)
@@ -10948,12 +10949,12 @@ func (m *VehicleMutation) ResetTier() {
 }
 
 // SetLocalizedNames sets the "localized_names" field.
-func (m *VehicleMutation) SetLocalizedNames(value map[string]string) {
+func (m *VehicleMutation) SetLocalizedNames(value map[language.Tag]string) {
 	m.localized_names = &value
 }
 
 // LocalizedNames returns the value of the "localized_names" field in the mutation.
-func (m *VehicleMutation) LocalizedNames() (r map[string]string, exists bool) {
+func (m *VehicleMutation) LocalizedNames() (r map[language.Tag]string, exists bool) {
 	v := m.localized_names
 	if v == nil {
 		return
@@ -10964,7 +10965,7 @@ func (m *VehicleMutation) LocalizedNames() (r map[string]string, exists bool) {
 // OldLocalizedNames returns the old "localized_names" field's value of the Vehicle entity.
 // If the Vehicle object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *VehicleMutation) OldLocalizedNames(ctx context.Context) (v map[string]string, err error) {
+func (m *VehicleMutation) OldLocalizedNames(ctx context.Context) (v map[language.Tag]string, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldLocalizedNames is only allowed on UpdateOne operations")
 	}
@@ -11094,7 +11095,7 @@ func (m *VehicleMutation) SetField(name string, value ent.Value) error {
 		m.SetTier(v)
 		return nil
 	case vehicle.FieldLocalizedNames:
-		v, ok := value.(map[string]string)
+		v, ok := value.(map[language.Tag]string)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}
diff --git a/internal/database/ent/db/vehicle.go b/internal/database/ent/db/vehicle.go
index 78a302ba..d9badd0e 100644
--- a/internal/database/ent/db/vehicle.go
+++ b/internal/database/ent/db/vehicle.go
@@ -11,6 +11,7 @@ import (
 	"entgo.io/ent"
 	"entgo.io/ent/dialect/sql"
 	"github.com/cufee/aftermath/internal/database/ent/db/vehicle"
+	"golang.org/x/text/language"
 )
 
 // Vehicle is the model entity for the Vehicle schema.
@@ -25,7 +26,7 @@ type Vehicle struct {
 	// Tier holds the value of the "tier" field.
 	Tier int `json:"tier,omitempty"`
 	// LocalizedNames holds the value of the "localized_names" field.
-	LocalizedNames map[string]string `json:"localized_names,omitempty"`
+	LocalizedNames map[language.Tag]string `json:"localized_names,omitempty"`
 	selectValues   sql.SelectValues
 }
 
diff --git a/internal/database/ent/db/vehicle_create.go b/internal/database/ent/db/vehicle_create.go
index a11e8725..5774753d 100644
--- a/internal/database/ent/db/vehicle_create.go
+++ b/internal/database/ent/db/vehicle_create.go
@@ -11,6 +11,7 @@ import (
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"entgo.io/ent/schema/field"
 	"github.com/cufee/aftermath/internal/database/ent/db/vehicle"
+	"golang.org/x/text/language"
 )
 
 // VehicleCreate is the builder for creating a Vehicle entity.
@@ -55,7 +56,7 @@ func (vc *VehicleCreate) SetTier(i int) *VehicleCreate {
 }
 
 // SetLocalizedNames sets the "localized_names" field.
-func (vc *VehicleCreate) SetLocalizedNames(m map[string]string) *VehicleCreate {
+func (vc *VehicleCreate) SetLocalizedNames(m map[language.Tag]string) *VehicleCreate {
 	vc.mutation.SetLocalizedNames(m)
 	return vc
 }
diff --git a/internal/database/ent/db/vehicle_update.go b/internal/database/ent/db/vehicle_update.go
index 6ef632ed..d747e79e 100644
--- a/internal/database/ent/db/vehicle_update.go
+++ b/internal/database/ent/db/vehicle_update.go
@@ -13,6 +13,7 @@ import (
 	"entgo.io/ent/schema/field"
 	"github.com/cufee/aftermath/internal/database/ent/db/predicate"
 	"github.com/cufee/aftermath/internal/database/ent/db/vehicle"
+	"golang.org/x/text/language"
 )
 
 // VehicleUpdate is the builder for updating Vehicle entities.
@@ -57,7 +58,7 @@ func (vu *VehicleUpdate) AddTier(i int) *VehicleUpdate {
 }
 
 // SetLocalizedNames sets the "localized_names" field.
-func (vu *VehicleUpdate) SetLocalizedNames(m map[string]string) *VehicleUpdate {
+func (vu *VehicleUpdate) SetLocalizedNames(m map[language.Tag]string) *VehicleUpdate {
 	vu.mutation.SetLocalizedNames(m)
 	return vu
 }
@@ -193,7 +194,7 @@ func (vuo *VehicleUpdateOne) AddTier(i int) *VehicleUpdateOne {
 }
 
 // SetLocalizedNames sets the "localized_names" field.
-func (vuo *VehicleUpdateOne) SetLocalizedNames(m map[string]string) *VehicleUpdateOne {
+func (vuo *VehicleUpdateOne) SetLocalizedNames(m map[language.Tag]string) *VehicleUpdateOne {
 	vuo.mutation.SetLocalizedNames(m)
 	return vuo
 }
diff --git a/internal/database/ent/schema/vehicle.go b/internal/database/ent/schema/vehicle.go
index 0ee5a3d3..0b1a3e76 100644
--- a/internal/database/ent/schema/vehicle.go
+++ b/internal/database/ent/schema/vehicle.go
@@ -4,6 +4,7 @@ import (
 	"entgo.io/ent"
 	"entgo.io/ent/schema/field"
 	"entgo.io/ent/schema/index"
+	"golang.org/x/text/language"
 )
 
 // Vehicle holds the schema definition for the Vehicle entity.
@@ -27,7 +28,7 @@ func (Vehicle) Fields() []ent.Field {
 		field.Int("tier").
 			Min(0). // vehicle that does not exist in official glossary has tier set to 0
 			Max(10),
-		field.JSON("localized_names", map[string]string{}),
+		field.JSON("localized_names", map[language.Tag]string{}),
 	}
 
 }
diff --git a/internal/database/models/vehicle.go b/internal/database/models/vehicle.go
index 4db8346e..414f4628 100644
--- a/internal/database/models/vehicle.go
+++ b/internal/database/models/vehicle.go
@@ -3,20 +3,17 @@ package models
 import (
 	"fmt"
 
+	assets "github.com/cufee/aftermath-assets/types"
 	"golang.org/x/text/language"
 )
 
-type Vehicle struct {
-	ID             string
-	Tier           int
-	LocalizedNames map[string]string
-}
+type Vehicle assets.Vehicle
 
 func (v Vehicle) Name(locale language.Tag) string {
-	if n := v.LocalizedNames[locale.String()]; n != "" {
+	if n := v.LocalizedNames[locale]; n != "" {
 		return n
 	}
-	if n := v.LocalizedNames[language.English.String()]; n != "" {
+	if n := v.LocalizedNames[language.English]; n != "" {
 		return n
 	}
 	return fmt.Sprintf("Secret Tank %s", v.ID)
diff --git a/internal/external/github/assets.go b/internal/external/github/assets.go
new file mode 100644
index 00000000..bf506de1
--- /dev/null
+++ b/internal/external/github/assets.go
@@ -0,0 +1,31 @@
+package github
+
+import (
+	"context"
+	"io"
+	"net/http"
+
+	"github.com/google/go-github/v63/github"
+	"github.com/pkg/errors"
+)
+
+var client = github.NewClient(nil)
+
+func GetLatestGameAssets(ctx context.Context) (io.ReadCloser, int64, error) {
+	release, _, err := client.Repositories.GetLatestRelease(ctx, "cufee", "aftermath-assets")
+	if err != nil {
+		return nil, 0, errors.Wrap(err, "gailed to get latest release")
+	}
+
+	for _, asset := range release.Assets {
+		if *asset.Name == "assets.zip" {
+			rc, _, err := client.Repositories.DownloadReleaseAsset(ctx, "cufee", "aftermath-assets", *asset.ID, http.DefaultClient)
+			if err != nil {
+				return nil, 0, errors.Wrap(err, "failed to download assets.zip")
+			}
+
+			return rc, int64(asset.GetSize()), nil
+		}
+	}
+	return nil, 0, errors.New("assets not found in latest release")
+}
diff --git a/internal/external/github/assets_test.go b/internal/external/github/assets_test.go
new file mode 100644
index 00000000..46736ae7
--- /dev/null
+++ b/internal/external/github/assets_test.go
@@ -0,0 +1,23 @@
+package github
+
+import (
+	"context"
+	"io"
+	"testing"
+
+	"github.com/matryer/is"
+)
+
+func TestGetLatestGameAssets(t *testing.T) {
+	is := is.New(t)
+
+	rc, size, err := GetLatestGameAssets(context.Background())
+	is.NoErr(err)
+	is.True(rc != nil)
+	is.True(size > 0)
+	defer rc.Close()
+
+	data, err := io.ReadAll(rc)
+	is.NoErr(err)
+	is.True(data != nil)
+}
diff --git a/main.go b/main.go
index 75a4408f..849ba3be 100644
--- a/main.go
+++ b/main.go
@@ -90,6 +90,9 @@ func main() {
 	}
 	defer stopScheduler()
 
+	// update vehicle cache in the background on start
+	go scheduler.UpdateGlossaryWorker(cacheCoreClient)()
+
 	// Load some init options to registered admin accounts and etc
 	logic.ApplyInitOptions(liveCoreClient.Database())
 
diff --git a/tests/static_database.go b/tests/static_database.go
index 666a291d..33f75840 100644
--- a/tests/static_database.go
+++ b/tests/static_database.go
@@ -10,6 +10,7 @@ import (
 	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/permissions"
 	"github.com/cufee/aftermath/internal/stats/frame"
+	"golang.org/x/text/language"
 )
 
 var ErrNotFound = &db.NotFoundError{}
@@ -59,7 +60,7 @@ func (c *staticTestingDatabase) UpsertAccounts(ctx context.Context, accounts []m
 func (c *staticTestingDatabase) GetVehicles(ctx context.Context, ids []string) (map[string]models.Vehicle, error) {
 	vehicles := make(map[string]models.Vehicle)
 	for _, id := range ids {
-		vehicles[id] = models.Vehicle{ID: id, Tier: 10, LocalizedNames: map[string]string{"en": "Test Vehicle " + id}}
+		vehicles[id] = models.Vehicle{ID: id, Tier: 10, LocalizedNames: map[language.Tag]string{language.English: "Test Vehicle " + id}}
 	}
 	return vehicles, nil
 }

From eb69118d5d454f9b75465564566042452ccf92f0 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 11 Jul 2024 12:39:39 -0400
Subject: [PATCH 335/341] added retry on interaction reply

---
 cmd/discord/rest/interactions.go | 19 ++++++++++++-------
 cmd/discord/router/handler.go    |  2 +-
 2 files changed, 13 insertions(+), 8 deletions(-)

diff --git a/cmd/discord/rest/interactions.go b/cmd/discord/rest/interactions.go
index d8ca5b58..d2a276d1 100644
--- a/cmd/discord/rest/interactions.go
+++ b/cmd/discord/rest/interactions.go
@@ -3,8 +3,10 @@ package rest
 import (
 	"context"
 	"errors"
+	"time"
 
 	"github.com/bwmarrin/discordgo"
+	"github.com/cufee/aftermath/internal/retry"
 )
 
 type File struct {
@@ -16,14 +18,17 @@ type File struct {
 Optimistically send an interaction response update request with fallback to interaction response send request
 */
 func (c *Client) UpdateOrSendInteractionResponse(ctx context.Context, appID, interactionID, token string, data discordgo.InteractionResponse, files []File) error {
-	err := c.UpdateInteractionResponse(ctx, appID, token, *data.Data, files)
-	if err != nil {
-		if errors.Is(err, ErrUnknownWebhook) || errors.Is(err, ErrUnknownInteraction) {
-			return c.SendInteractionResponse(ctx, interactionID, token, data, files)
+	res := retry.Retry(func() (struct{}, error) {
+		err := c.UpdateInteractionResponse(ctx, appID, token, *data.Data, files)
+		if err != nil {
+			if errors.Is(err, ErrUnknownWebhook) || errors.Is(err, ErrUnknownInteraction) {
+				return struct{}{}, c.SendInteractionResponse(ctx, interactionID, token, data, files)
+			}
+			return struct{}{}, err
 		}
-		return err
-	}
-	return nil
+		return struct{}{}, nil
+	}, 3, time.Millisecond*250)
+	return res.Err
 }
 
 func (c *Client) SendInteractionResponse(ctx context.Context, interactionID, token string, data discordgo.InteractionResponse, files []File) error {
diff --git a/cmd/discord/router/handler.go b/cmd/discord/router/handler.go
index 4138e66e..c21beafd 100644
--- a/cmd/discord/router/handler.go
+++ b/cmd/discord/router/handler.go
@@ -134,7 +134,7 @@ func (router *Router) HTTPHandler() (http.HandlerFunc, error) {
 			// break if the error means we were able to ack on the last request
 			func(err error) bool { return errors.Is(err, rest.ErrInteractionAlreadyAcked) })
 		if res.Err != nil && !errors.Is(res.Err, rest.ErrInteractionAlreadyAcked) {
-			log.Err(res.Err).Str("id", data.ID).Msg("failed to ack an interaction")
+			log.Warn().Err(res.Err).Str("id", data.ID).Msg("failed to ack an interaction")
 			// cross our fingers and hope discord registered one of those requests, or will propagate the ack from the response body
 		}
 

From 17f802175800359f4c9bfec2b3ca3ac4a1b200f0 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 11 Jul 2024 17:19:04 -0400
Subject: [PATCH 336/341] added per vehicle stats

---
 cmd/core/scheduler/workers.go                |   4 +
 cmd/discord/commands/autocomplete.go         | 101 +++++++++++++++++++
 cmd/discord/commands/links.go                |  52 ----------
 cmd/discord/commands/options.go              |  17 ++++
 cmd/discord/commands/session.go              |   2 +-
 cmd/discord/commands/stats.go                |   2 +-
 go.mod                                       |   1 +
 go.sum                                       |   7 ++
 internal/search/vehicles.go                  |  89 ++++++++++++++++
 internal/stats/client/v1/options.go          |  21 ++++
 internal/stats/client/v1/period.go           |   5 +-
 internal/stats/client/v1/session.go          |   3 +-
 internal/stats/fetch/v1/client.go            |   6 ++
 internal/stats/fetch/v1/multisource.go       |  29 +++++-
 internal/stats/prepare/common/v1/options.go  |   4 +
 internal/stats/prepare/period/v1/card.go     |  15 ++-
 internal/stats/prepare/session/v1/card.go    |  33 +++++-
 internal/stats/render/common/v1/options.go   |   6 ++
 internal/stats/render/period/v1/cards.go     |  33 ++++--
 internal/stats/render/period/v1/constants.go |  18 +++-
 internal/stats/render/session/v1/cards.go    |  20 ++--
 render_test.go                               |  83 +++++++++++++++
 22 files changed, 458 insertions(+), 93 deletions(-)
 create mode 100644 cmd/discord/commands/autocomplete.go
 create mode 100644 internal/search/vehicles.go

diff --git a/cmd/core/scheduler/workers.go b/cmd/core/scheduler/workers.go
index 4b35fb3c..dc628f6e 100644
--- a/cmd/core/scheduler/workers.go
+++ b/cmd/core/scheduler/workers.go
@@ -15,6 +15,7 @@ import (
 	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/external/github"
 	"github.com/cufee/aftermath/internal/log"
+	"github.com/cufee/aftermath/internal/search"
 )
 
 func CreateCleanupTaskWorker(client core.Client) func() {
@@ -159,6 +160,9 @@ func UpdateGlossaryWorker(client core.Client) func() {
 				return
 			}
 
+			// load new glossary into the search memory cache
+			search.LoadVehicleCache(vehicles)
+
 			vctx, cancel := context.WithTimeout(context.Background(), time.Second*15)
 			defer cancel()
 
diff --git a/cmd/discord/commands/autocomplete.go b/cmd/discord/commands/autocomplete.go
new file mode 100644
index 00000000..0c33594f
--- /dev/null
+++ b/cmd/discord/commands/autocomplete.go
@@ -0,0 +1,101 @@
+package commands
+
+import (
+	"fmt"
+	"strings"
+	"unicode/utf8"
+
+	"github.com/bwmarrin/discordgo"
+	"github.com/cufee/aftermath/cmd/discord/commands/builder"
+	"github.com/cufee/aftermath/cmd/discord/common"
+	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/search"
+	prepare "github.com/cufee/aftermath/internal/stats/prepare/common/v1"
+)
+
+func init() {
+	LoadedPublic.add(
+		builder.NewCommand("autocomplete_links").
+			ComponentType(func(s string) bool {
+				return s == "autocomplete_links"
+			}).
+			Handler(func(ctx *common.Context) error {
+				var currentDefault string
+				var linkedAccounts []string
+				for _, conn := range ctx.User.Connections {
+					if conn.Type != models.ConnectionTypeWargaming {
+						continue
+					}
+					linkedAccounts = append(linkedAccounts, conn.ReferenceID)
+					if def, _ := conn.Metadata["default"].(bool); def {
+						currentDefault = conn.ReferenceID
+					}
+
+				}
+				if len(linkedAccounts) < 1 {
+					return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: ctx.Localize("links_error_no_accounts_linked"), Value: "error#links_error_no_accounts_linked"})
+				}
+
+				accounts, err := ctx.Core.Database().GetAccounts(ctx.Context, linkedAccounts)
+				if err != nil {
+					return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: ctx.Localize("links_error_no_accounts_linked"), Value: "error#links_error_no_accounts_linked"})
+				}
+
+				var longestName int
+				for _, a := range accounts {
+					if l := utf8.RuneCountInString(a.Nickname); l > longestName {
+						longestName = l
+					}
+				}
+
+				var opts []*discordgo.ApplicationCommandOptionChoice
+				for _, a := range accounts {
+					opts = append(opts, &discordgo.ApplicationCommandOptionChoice{Name: accountToRow(a, longestName, currentDefault == a.ID), Value: fmt.Sprintf("valid#%s#%s#%s", a.ID, a.Nickname, a.Realm)})
+				}
+				return ctx.Reply().Choices(opts...)
+			}),
+	)
+
+	LoadedPublic.add(
+		builder.NewCommand("autocomplete_tank_search").
+			ComponentType(func(s string) bool {
+				return s == "autocomplete_stats" || s == "autocomplete_session"
+			}).
+			Handler(func(ctx *common.Context) error {
+				options := getDefaultStatsOptions(ctx.Options())
+				// if the tank was already found, return the tank
+				if options.TankID != "" {
+					vehicle, ok := search.GetVehicleFromCache(ctx.Locale, options.TankID)
+					if !ok {
+						return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: "stats_acutocomplete_not_enough_length", Value: "error#stats_acutocomplete_not_found"})
+					}
+					return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: fmt.Sprintf("%s %s", prepare.IntToRoman(vehicle.Tier), vehicle.Name(ctx.Locale)), Value: fmt.Sprintf("valid#vehicle#%s", vehicle.ID)})
+				}
+
+				if len(options.TankSearch) < 3 {
+					return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: "stats_acutocomplete_not_enough_length", Value: "error#stats_acutocomplete_not_found"})
+				}
+
+				vehicles, ok := search.SearchVehicles(ctx.Locale, options.TankSearch, 5)
+				if !ok || len(vehicles) < 1 {
+					return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: "stats_acutocomplete_not_found", Value: "error#stats_acutocomplete_not_found"})
+				}
+
+				var opts []*discordgo.ApplicationCommandOptionChoice
+				for _, v := range vehicles {
+					opts = append(opts, &discordgo.ApplicationCommandOptionChoice{Name: fmt.Sprintf("%s %s", prepare.IntToRoman(v.Tier), v.Name(ctx.Locale)), Value: fmt.Sprintf("valid#vehicle#%s", v.ID)})
+				}
+				return ctx.Reply().Choices(opts...)
+			}),
+	)
+}
+
+func accountToRow(account models.Account, padding int, isDefault bool) string {
+	var row string
+	row += "[" + account.Realm + "] "
+	row += account.Nickname + strings.Repeat(" ", padding-utf8.RuneCountInString(account.Nickname))
+	if isDefault {
+		row += " ⭐"
+	}
+	return row
+}
diff --git a/cmd/discord/commands/links.go b/cmd/discord/commands/links.go
index 691e5a9f..6062fda3 100644
--- a/cmd/discord/commands/links.go
+++ b/cmd/discord/commands/links.go
@@ -249,56 +249,4 @@ func init() {
 				}
 			}),
 	)
-
-	LoadedPublic.add(
-		builder.NewCommand("autocomplete_links").
-			ComponentType(func(s string) bool {
-				return s == "autocomplete_links"
-			}).
-			Handler(func(ctx *common.Context) error {
-				var currentDefault string
-				var linkedAccounts []string
-				for _, conn := range ctx.User.Connections {
-					if conn.Type != models.ConnectionTypeWargaming {
-						continue
-					}
-					linkedAccounts = append(linkedAccounts, conn.ReferenceID)
-					if def, _ := conn.Metadata["default"].(bool); def {
-						currentDefault = conn.ReferenceID
-					}
-
-				}
-				if len(linkedAccounts) < 1 {
-					return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: ctx.Localize("links_error_no_accounts_linked"), Value: "error#links_error_no_accounts_linked"})
-				}
-
-				accounts, err := ctx.Core.Database().GetAccounts(ctx.Context, linkedAccounts)
-				if err != nil {
-					return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: ctx.Localize("links_error_no_accounts_linked"), Value: "error#links_error_no_accounts_linked"})
-				}
-
-				var longestName int
-				for _, a := range accounts {
-					if l := utf8.RuneCountInString(a.Nickname); l > longestName {
-						longestName = l
-					}
-				}
-
-				var opts []*discordgo.ApplicationCommandOptionChoice
-				for _, a := range accounts {
-					opts = append(opts, &discordgo.ApplicationCommandOptionChoice{Name: accountToRow(a, longestName, currentDefault == a.ID), Value: fmt.Sprintf("valid#%s#%s#%s", a.ID, a.Nickname, a.Realm)})
-				}
-				return ctx.Reply().Choices(opts...)
-			}),
-	)
-}
-
-func accountToRow(account models.Account, padding int, isDefault bool) string {
-	var row string
-	row += "[" + account.Realm + "] "
-	row += account.Nickname + strings.Repeat(" ", padding-utf8.RuneCountInString(account.Nickname))
-	if isDefault {
-		row += " ⭐"
-	}
-	return row
 }
diff --git a/cmd/discord/commands/options.go b/cmd/discord/commands/options.go
index 701a13b9..7c838051 100644
--- a/cmd/discord/commands/options.go
+++ b/cmd/discord/commands/options.go
@@ -2,6 +2,7 @@ package commands
 
 import (
 	"regexp"
+	"strings"
 	"time"
 
 	"github.com/bwmarrin/discordgo"
@@ -19,6 +20,15 @@ var daysOption = builder.NewOption("days", discordgo.ApplicationCommandOptionInt
 		builder.SetDescKey("common_option_stats_days_description"),
 	)
 
+var vehicleOption = builder.NewOption("tank", discordgo.ApplicationCommandOptionString).
+	Min(3).
+	Max(32).
+	Autocomplete().
+	Params(
+		builder.SetNameKey("common_option_stats_tank_name"),
+		builder.SetDescKey("common_option_stats_tank_description"),
+	)
+
 var nicknameAndServerOptions = []builder.Option{
 	builder.NewOption("nickname", discordgo.ApplicationCommandOptionString).
 		Min(5).
@@ -47,6 +57,7 @@ var userOption = builder.NewOption("user", discordgo.ApplicationCommandOptionUse
 
 var defaultStatsOptions = append([]builder.Option{
 	daysOption,
+	vehicleOption,
 	userOption,
 }, nicknameAndServerOptions...)
 
@@ -56,6 +67,8 @@ type statsOptions struct {
 	Server      string
 	Nickname    string
 	UserID      string
+	TankSearch  string
+	TankID      string
 }
 
 func (o statsOptions) Validate(ctx *common.Context) (string, bool) {
@@ -82,6 +95,10 @@ func (o statsOptions) Validate(ctx *common.Context) (string, bool) {
 func getDefaultStatsOptions(data []*discordgo.ApplicationCommandInteractionDataOption) statsOptions {
 	var options statsOptions
 
+	options.TankSearch, _ = common.GetOption[string](data, "tank")
+	if strings.HasPrefix(options.TankSearch, "valid#vehicle#") {
+		options.TankID = strings.TrimPrefix(options.TankSearch, "valid#vehicle#")
+	}
 	options.Nickname, _ = common.GetOption[string](data, "nickname")
 	options.Server, _ = common.GetOption[string](data, "server")
 	options.UserID, _ = common.GetOption[string](data, "user")
diff --git a/cmd/discord/commands/session.go b/cmd/discord/commands/session.go
index c45b55e8..2b4fd2a7 100644
--- a/cmd/discord/commands/session.go
+++ b/cmd/discord/commands/session.go
@@ -69,7 +69,7 @@ func init() {
 					}
 				}
 
-				image, meta, err := ctx.Core.Stats(ctx.Locale).SessionImage(context.Background(), accountID, options.PeriodStart, stats.WithBackgroundURL(backgroundURL), stats.WithWN8())
+				image, meta, err := ctx.Core.Stats(ctx.Locale).SessionImage(context.Background(), accountID, options.PeriodStart, stats.WithBackgroundURL(backgroundURL), stats.WithWN8(), stats.WithVehicleID(options.TankID))
 				if err != nil {
 					if errors.Is(err, stats.ErrAccountNotTracked) || (errors.Is(err, fetch.ErrSessionNotFound) && options.Days < 1) {
 						return ctx.Reply().Send("session_error_account_was_not_tracked")
diff --git a/cmd/discord/commands/stats.go b/cmd/discord/commands/stats.go
index 84fd8e99..c7317a27 100644
--- a/cmd/discord/commands/stats.go
+++ b/cmd/discord/commands/stats.go
@@ -61,7 +61,7 @@ func init() {
 					// TODO: Get user background
 				}
 
-				image, meta, err := ctx.Core.Stats(ctx.Locale).PeriodImage(context.Background(), accountID, options.PeriodStart, stats.WithBackgroundURL(backgroundURL), stats.WithWN8())
+				image, meta, err := ctx.Core.Stats(ctx.Locale).PeriodImage(context.Background(), accountID, options.PeriodStart, stats.WithBackgroundURL(backgroundURL), stats.WithWN8(), stats.WithVehicleID(options.TankID))
 				if err != nil {
 					return ctx.Err(err)
 				}
diff --git a/go.mod b/go.mod
index 8866b1d9..60138a96 100644
--- a/go.mod
+++ b/go.mod
@@ -46,6 +46,7 @@ require (
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/hashicorp/hcl/v2 v2.21.0 // indirect
+	github.com/lithammer/fuzzysearch v1.1.8 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mitchellh/go-wordwrap v1.0.1 // indirect
diff --git a/go.sum b/go.sum
index bdb3dbfa..1f3e3098 100644
--- a/go.sum
+++ b/go.sum
@@ -67,6 +67,8 @@ github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/lithammer/fuzzysearch v1.1.8 h1:/HIuJnjHuXS8bKaiTMeeDlW2/AyIWk2brx1V8LFgLN4=
+github.com/lithammer/fuzzysearch v1.1.8/go.mod h1:IdqeyBClc3FFqSzYq/MXESsS4S0FsZ5ajtkr5xPLts4=
 github.com/lucsky/cuid v1.2.1 h1:MtJrL2OFhvYufUIn48d35QGXyeTC8tn0upumW9WwTHg=
 github.com/lucsky/cuid v1.2.1/go.mod h1:QaaJqckboimOmhRSJXSx/+IT+VTfxfPGSo/6mfgUfmE=
 github.com/matryer/is v1.4.1 h1:55ehd8zaGABKLXQUe2awZ99BD/PTc2ls+KV/dXphgEQ=
@@ -154,17 +156,20 @@ golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8/go.mod h1:FeLwcggjj3mMvU+o
 golang.org/x/image v0.17.0 h1:nTRVVdajgB8zCMZVsViyzhnMKPwYeroEERRC64JuLco=
 golang.org/x/image v0.17.0/go.mod h1:4yyo5vMFQjVjUcVk4jEQcU9MGy/rulF5WvUILseCM2E=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/mod v0.18.0 h1:5+9lSbEzPSdWkH32vYPBwEpX8KwDbM52Ud9xBUvNlb0=
 golang.org/x/mod v0.18.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20210916014120-12bc252f5db8/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
 golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
 golang.org/x/net v0.27.0 h1:5K3Njcw06/l2y9vpGCSdcxWOYHOUk3dVNGDXN+FvAys=
 golang.org/x/net v0.27.0/go.mod h1:dDi0PyhWNoiUOrAS8uXv/vnScO4wnHQO4mj9fn/RytE=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
 golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20190124100055-b90733256f2e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
@@ -188,11 +193,13 @@ golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
 golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
 golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
 golang.org/x/tools v0.22.0 h1:gqSGLZqv+AI9lIQzniJ0nZDRG5GBPsSi+DRNHWNz6yA=
 golang.org/x/tools v0.22.0/go.mod h1:aCwcsjqvq7Yqt6TNyX7QMU2enbQ/Gt0bo6krSeEri+c=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
diff --git a/internal/search/vehicles.go b/internal/search/vehicles.go
new file mode 100644
index 00000000..2ee17227
--- /dev/null
+++ b/internal/search/vehicles.go
@@ -0,0 +1,89 @@
+package search
+
+import (
+	"fmt"
+	"strings"
+	"sync"
+
+	"github.com/cufee/aftermath/internal/database/models"
+	"github.com/cufee/aftermath/internal/stats/prepare/common/v1"
+	"github.com/lithammer/fuzzysearch/fuzzy"
+	"golang.org/x/text/language"
+)
+
+var cacheLock sync.Mutex
+var vehiclesCache map[string]models.Vehicle
+var vehicleNames map[language.Tag][]string
+var vehicleNameToID map[language.Tag]map[string]string
+
+func LoadVehicleCache(data map[string]models.Vehicle) {
+	newVehicleNameToID := make(map[language.Tag]map[string]string)
+	newVehiclesCache := make(map[string]models.Vehicle)
+	newVehicleNames := make(map[language.Tag][]string)
+
+	for id, vehicle := range data {
+		for tag, value := range vehicle.LocalizedNames {
+			value = strings.ToLower(value)
+			newVehiclesCache[id] = vehicle
+
+			localeNameToID := newVehicleNameToID[tag]
+			if localeNameToID == nil {
+				localeNameToID = make(map[string]string)
+			}
+
+			nameWithTier := strings.ToLower(fmt.Sprintf("%s %s", common.IntToRoman(vehicle.Tier), value))
+			localeNameToID[nameWithTier] = id
+			newVehicleNameToID[tag] = localeNameToID
+			newVehicleNames[tag] = append(newVehicleNames[tag], nameWithTier)
+		}
+	}
+
+	cacheLock.Lock()
+	vehicleNameToID = newVehicleNameToID
+	vehiclesCache = newVehiclesCache
+	vehicleNames = newVehicleNames
+	cacheLock.Unlock()
+}
+
+func GetVehicleFromCache(locale language.Tag, id string) (models.Vehicle, bool) {
+	cacheLock.Lock()
+	v, ok := vehiclesCache[id]
+	cacheLock.Unlock()
+	return v, ok
+}
+
+func SearchVehicles(locale language.Tag, query string, limit int) ([]models.Vehicle, bool) {
+	if len(query) < 3 {
+		return nil, false
+	}
+
+	cacheLock.Lock()
+	terms, ok := vehicleNames[locale]
+	cacheLock.Unlock()
+	if !ok {
+		return nil, false
+	}
+
+	var vehicles []models.Vehicle
+	result := fuzzy.RankFind(strings.ToLower(query), terms)
+	for i, entry := range result {
+		if i >= limit {
+			break
+		}
+		cacheLock.Lock()
+		id, ok := vehicleNameToID[locale][entry.Target]
+		cacheLock.Unlock()
+		if !ok {
+			continue
+		}
+		cacheLock.Lock()
+		v, ok := vehiclesCache[id]
+		cacheLock.Unlock()
+		vehicles = append(vehicles, v)
+	}
+
+	if len(vehicles) < 1 {
+		return nil, false
+	}
+	return vehicles, true
+}
diff --git a/internal/stats/client/v1/options.go b/internal/stats/client/v1/options.go
index 363d2074..227aacad 100644
--- a/internal/stats/client/v1/options.go
+++ b/internal/stats/client/v1/options.go
@@ -3,7 +3,9 @@ package client
 import (
 	"github.com/cufee/aftermath/internal/database/models"
 	"github.com/cufee/aftermath/internal/stats/fetch/v1"
+	prepare "github.com/cufee/aftermath/internal/stats/prepare/common/v1"
 	"github.com/cufee/aftermath/internal/stats/render/common/v1"
+	"golang.org/x/text/language"
 )
 
 type requestOptions struct {
@@ -11,6 +13,7 @@ type requestOptions struct {
 	backgroundURL string
 	referenceID   string
 	promoText     []string
+	vehicleID     string
 	withWN8       bool
 }
 
@@ -19,6 +22,9 @@ type RequestOption func(o *requestOptions)
 func WithWN8() RequestOption {
 	return func(o *requestOptions) { o.withWN8 = true }
 }
+func WithVehicleID(vid string) RequestOption {
+	return func(o *requestOptions) { o.vehicleID = vid }
+}
 func WithReferenceID(refID string) RequestOption {
 	return func(o *requestOptions) { o.referenceID = refID }
 }
@@ -37,10 +43,22 @@ func (o requestOptions) RenderOpts() []common.Option {
 	if o.promoText != nil {
 		copts = append(copts, common.WithPromoText(o.promoText...))
 	}
+	if o.vehicleID != "" {
+		copts = append(copts, common.WithVehicleID(o.vehicleID))
+	}
 	copts = append(copts, common.WithBackground(o.backgroundURL))
 	return copts
 }
 
+func (o requestOptions) PrepareOpts(printer func(string) string, locale language.Tag) []prepare.Option {
+	var popts []prepare.Option
+	popts = append(popts, prepare.WithPrinter(printer, locale))
+	if o.vehicleID != "" {
+		popts = append(popts, prepare.WithVehicleID(o.vehicleID))
+	}
+	return popts
+}
+
 func (o requestOptions) FetchOpts() []fetch.StatsOption {
 	var opts []fetch.StatsOption
 	if o.snapshotType != "" {
@@ -52,5 +70,8 @@ func (o requestOptions) FetchOpts() []fetch.StatsOption {
 	if o.withWN8 {
 		opts = append(opts, fetch.WithWN8())
 	}
+	if o.vehicleID != "" {
+		opts = append(opts, fetch.WithVehicleID(o.vehicleID))
+	}
 	return opts
 }
diff --git a/internal/stats/client/v1/period.go b/internal/stats/client/v1/period.go
index ced5231d..a6ed16fa 100644
--- a/internal/stats/client/v1/period.go
+++ b/internal/stats/client/v1/period.go
@@ -7,7 +7,6 @@ import (
 
 	"github.com/cufee/aftermath/internal/localization"
 	"github.com/cufee/aftermath/internal/stats/fetch/v1"
-	pcommon "github.com/cufee/aftermath/internal/stats/prepare/common/v1"
 	prepare "github.com/cufee/aftermath/internal/stats/prepare/period/v1"
 	render "github.com/cufee/aftermath/internal/stats/render/period/v1"
 )
@@ -26,7 +25,7 @@ func (r *client) PeriodCards(ctx context.Context, accountId string, from time.Ti
 	}
 
 	stop := meta.Timer("fetchClient#PeriodStats")
-	stats, err := r.fetchClient.PeriodStats(ctx, accountId, from, fetch.WithWN8())
+	stats, err := r.fetchClient.PeriodStats(ctx, accountId, from, opts.FetchOpts()...)
 	stop()
 	if err != nil {
 		return prepare.Cards{}, meta, err
@@ -51,7 +50,7 @@ func (r *client) PeriodCards(ctx context.Context, accountId string, from time.Ti
 	stop()
 
 	stop = meta.Timer("prepare#NewCards")
-	cards, err := prepare.NewCards(stats, glossary, pcommon.WithPrinter(printer, r.locale))
+	cards, err := prepare.NewCards(stats, glossary, opts.PrepareOpts(printer, r.locale)...)
 	stop()
 
 	return cards, meta, err
diff --git a/internal/stats/client/v1/session.go b/internal/stats/client/v1/session.go
index 55f3d314..a0915661 100644
--- a/internal/stats/client/v1/session.go
+++ b/internal/stats/client/v1/session.go
@@ -11,7 +11,6 @@ import (
 	"github.com/cufee/aftermath/internal/log"
 	"github.com/cufee/aftermath/internal/logic"
 	"github.com/cufee/aftermath/internal/stats/fetch/v1"
-	"github.com/cufee/aftermath/internal/stats/prepare/common/v1"
 	prepare "github.com/cufee/aftermath/internal/stats/prepare/session/v1"
 	render "github.com/cufee/aftermath/internal/stats/render/session/v1"
 )
@@ -105,7 +104,7 @@ func (c *client) SessionCards(ctx context.Context, accountId string, from time.T
 	stop()
 
 	stop = meta.Timer("prepare#NewCards")
-	cards, err := prepare.NewCards(session, career, glossary, common.WithPrinter(printer, c.locale))
+	cards, err := prepare.NewCards(session, career, glossary, opts.PrepareOpts(printer, c.locale)...)
 	stop()
 	if err != nil {
 		return prepare.Cards{}, meta, err
diff --git a/internal/stats/fetch/v1/client.go b/internal/stats/fetch/v1/client.go
index 79a2ba70..aa533443 100644
--- a/internal/stats/fetch/v1/client.go
+++ b/internal/stats/fetch/v1/client.go
@@ -59,6 +59,7 @@ type Client interface {
 
 type statsOptions struct {
 	withWN8      bool
+	vehicleID    string
 	referenceID  string
 	snapshotType models.SnapshotType
 }
@@ -80,3 +81,8 @@ func WithReferenceID(reference string) StatsOption {
 		so.referenceID = reference
 	}
 }
+func WithVehicleID(id string) StatsOption {
+	return func(so *statsOptions) {
+		so.vehicleID = id
+	}
+}
diff --git a/internal/stats/fetch/v1/multisource.go b/internal/stats/fetch/v1/multisource.go
index e54b794c..9c03e57c 100644
--- a/internal/stats/fetch/v1/multisource.go
+++ b/internal/stats/fetch/v1/multisource.go
@@ -112,6 +112,7 @@ func (c *multiSourceClient) CurrentStats(ctx context.Context, id string, opts ..
 	for _, apply := range opts {
 		apply(&options)
 	}
+	println(options.vehicleID)
 
 	realm := c.wargaming.RealmFromAccountID(id)
 
@@ -142,13 +143,26 @@ func (c *multiSourceClient) CurrentStats(ctx context.Context, id string, opts ..
 			return c.wargaming.AccountVehicles(ctx, realm, id)
 		}, c.retriesPerRequest, c.retrySleepInterval)
 
+		if options.vehicleID != "" {
+			for _, v := range vehicles.Data {
+				if fmt.Sprint(v.TankID) == options.vehicleID {
+					vehicles.Data = []types.VehicleStatsFrame{v}
+					break
+				}
+			}
+			if len(vehicles.Data) > 1 {
+				vehicles.Data = nil
+			}
+		}
+
 		if vehicles.Err != nil || len(vehicles.Data) < 1 || !options.withWN8 {
 			return
 		}
 
 		var ids []string
 		for _, v := range vehicles.Data {
-			ids = append(ids, fmt.Sprint(v.TankID))
+			tid := fmt.Sprint(v.TankID)
+			ids = append(ids, tid)
 		}
 		a, err := c.database.GetVehicleAverages(ctx, ids)
 		averages = retry.DataWithErr[map[string]frame.StatsFrame]{Data: a, Err: err}
@@ -167,6 +181,8 @@ func (c *multiSourceClient) CurrentStats(ctx context.Context, id string, opts ..
 		log.Err(averages.Err).Msg("failed to get tank averages")
 	}
 
+	println(len(vehicles.Data), "vehicle", options.vehicleID)
+
 	stats := WargamingToStats(realm, account.Data, clan, vehicles.Data)
 	if options.withWN8 {
 		stats.AddWN8(averages.Data)
@@ -203,7 +219,7 @@ func (c *multiSourceClient) PeriodStats(ctx context.Context, id string, periodSt
 	go func() {
 		defer group.Done()
 
-		stats, err := c.CurrentStats(ctx, id)
+		stats, err := c.CurrentStats(ctx, id, opts...)
 		current = retry.DataWithErr[AccountStatsOverPeriod]{Data: stats, Err: err}
 
 		if err != nil || stats.RegularBattles.Battles < 1 || !options.withWN8 {
@@ -294,7 +310,7 @@ func (c *multiSourceClient) SessionStats(ctx context.Context, id string, session
 	go func() {
 		defer group.Done()
 
-		stats, err := c.CurrentStats(ctx, id)
+		stats, err := c.CurrentStats(ctx, id, opts...)
 		current = retry.DataWithErr[AccountStatsOverPeriod]{Data: stats, Err: err}
 
 		if err != nil || stats.RegularBattles.Battles < 1 || !options.withWN8 {
@@ -328,7 +344,12 @@ func (c *multiSourceClient) SessionStats(ctx context.Context, id string, session
 		}
 		accountSnapshot = retry.DataWithErr[models.AccountSnapshot]{Data: s[0]}
 
-		v, err := c.database.GetVehicleSnapshots(ctx, id, nil, options.snapshotType, opts...)
+		var vehicles []string
+		if options.vehicleID != "" {
+			vehicles = append(vehicles, options.vehicleID)
+		}
+
+		v, err := c.database.GetVehicleSnapshots(ctx, id, vehicles, options.snapshotType, opts...)
 		vehiclesSnapshots = retry.DataWithErr[[]models.VehicleSnapshot]{Data: v, Err: err}
 	}()
 
diff --git a/internal/stats/prepare/common/v1/options.go b/internal/stats/prepare/common/v1/options.go
index e27fba12..bd8b58eb 100644
--- a/internal/stats/prepare/common/v1/options.go
+++ b/internal/stats/prepare/common/v1/options.go
@@ -5,6 +5,7 @@ import "golang.org/x/text/language"
 var DefaultOptions = options{}
 
 type options struct {
+	VehicleID     string
 	localePrinter func(string) string
 	locale        *language.Tag
 }
@@ -28,3 +29,6 @@ type Option func(*options)
 func WithPrinter(printer func(string) string, locale language.Tag) func(*options) {
 	return func(o *options) { o.localePrinter = printer; o.locale = &locale }
 }
+func WithVehicleID(vid string) func(*options) {
+	return func(o *options) { o.VehicleID = vid }
+}
diff --git a/internal/stats/prepare/period/v1/card.go b/internal/stats/prepare/period/v1/card.go
index a6ffca86..87fc956a 100644
--- a/internal/stats/prepare/period/v1/card.go
+++ b/internal/stats/prepare/period/v1/card.go
@@ -19,13 +19,15 @@ func NewCards(stats fetch.AccountStatsOverPeriod, glossary map[string]models.Veh
 	}
 
 	var cards Cards
-
-	// Overview Card
+	overviewUnrated := stats.RegularBattles.StatsFrame
+	if stats, ok := stats.RegularBattles.Vehicles[options.VehicleID]; ok && options.VehicleID != "" {
+		overviewUnrated = *stats.StatsFrame
+	}
 	for _, column := range overviewBlocks {
 		var columnBlocks []common.StatsBlock[BlockData]
 		for _, preset := range column.blocks {
 			var block common.StatsBlock[BlockData]
-			b, err := presetToBlock(preset, stats.RegularBattles.StatsFrame, stats.RegularBattles.Vehicles, glossary)
+			b, err := presetToBlock(preset, overviewUnrated, stats.RegularBattles.Vehicles, glossary)
 			if err != nil {
 				return Cards{}, err
 			}
@@ -35,11 +37,16 @@ func NewCards(stats fetch.AccountStatsOverPeriod, glossary map[string]models.Veh
 			columnBlocks = append(columnBlocks, block)
 		}
 
+		if options.VehicleID != "" {
+			glossary := glossary[options.VehicleID]
+			glossary.ID = options.VehicleID
+			cards.Overview.Title = fmt.Sprintf("%s %s", common.IntToRoman(glossary.Tier), glossary.Name(options.Locale()))
+		}
 		cards.Overview.Type = common.CardTypeOverview
 		cards.Overview.Blocks = append(cards.Overview.Blocks, OverviewColumn{columnBlocks, column.flavor})
 	}
 
-	if len(stats.RegularBattles.Vehicles) < 1 || len(highlights) < 1 {
+	if len(stats.RegularBattles.Vehicles) < 1 || len(highlights) < 1 || options.VehicleID != "" {
 		return cards, nil
 	}
 
diff --git a/internal/stats/prepare/session/v1/card.go b/internal/stats/prepare/session/v1/card.go
index 55b8db9a..3f48deb9 100644
--- a/internal/stats/prepare/session/v1/card.go
+++ b/internal/stats/prepare/session/v1/card.go
@@ -1,6 +1,7 @@
 package session
 
 import (
+	"fmt"
 	"math"
 	"slices"
 
@@ -22,7 +23,8 @@ func NewCards(session, career fetch.AccountStatsOverPeriod, glossary map[string]
 
 	var cards Cards
 
-	{ // Rating battles overview
+	// Rating battles overview
+	if options.VehicleID == "" {
 		card, err := makeOverviewCard(
 			ratingOverviewBlocks,
 			session.RatingBattles.StatsFrame,
@@ -42,11 +44,30 @@ func NewCards(session, career fetch.AccountStatsOverPeriod, glossary map[string]
 		cards.Rating.Overview = card
 	}
 	{ // Regular battles overview
+		sessionFrame := session.RegularBattles.StatsFrame
+		careerFrame := career.RegularBattles.StatsFrame
+		overviewLabel := "label_overview_unrated"
+		if options.VehicleID != "" {
+			sessionFrame = frame.StatsFrame{}
+			careerFrame = frame.StatsFrame{}
+			s, ok := session.RegularBattles.Vehicles[options.VehicleID]
+			if ok {
+				sessionFrame = *s.StatsFrame
+			}
+			c, ok := career.RegularBattles.Vehicles[options.VehicleID]
+			if ok {
+				careerFrame = *c.StatsFrame
+			}
+			glossary := glossary[options.VehicleID]
+			glossary.ID = options.VehicleID
+			overviewLabel = fmt.Sprintf("%s %s", common.IntToRoman(glossary.Tier), glossary.Name(options.Locale()))
+		}
+
 		card, err := makeOverviewCard(
 			unratedOverviewBlocks,
-			session.RegularBattles.StatsFrame,
-			career.RegularBattles.StatsFrame,
-			"label_overview_unrated",
+			sessionFrame,
+			careerFrame,
+			overviewLabel,
 			options.Printer(),
 			nil,
 		)
@@ -56,6 +77,10 @@ func NewCards(session, career fetch.AccountStatsOverPeriod, glossary map[string]
 		cards.Unrated.Overview = card
 	}
 
+	if options.VehicleID != "" { // we don't vehicle cards if a specific vehicle was selected
+		return cards, nil
+	}
+
 	// Rating battles vehicles
 	var ratingVehicles []frame.VehicleStatsFrame
 	for _, vehicle := range session.RatingBattles.Vehicles {
diff --git a/internal/stats/render/common/v1/options.go b/internal/stats/render/common/v1/options.go
index 24a80543..e9b51162 100644
--- a/internal/stats/render/common/v1/options.go
+++ b/internal/stats/render/common/v1/options.go
@@ -8,6 +8,7 @@ import (
 )
 
 type Options struct {
+	VehicleID  string
 	PromoText  []string
 	Background image.Image
 }
@@ -23,6 +24,11 @@ func WithPromoText(text ...string) Option {
 		o.PromoText = text
 	}
 }
+func WithVehicleID(vid string) Option {
+	return func(o *Options) {
+		o.VehicleID = vid
+	}
+}
 
 func WithBackground(bgURL string) Option {
 	if bgURL == "" {
diff --git a/internal/stats/render/period/v1/cards.go b/internal/stats/render/period/v1/cards.go
index f34c723d..481d29f8 100644
--- a/internal/stats/render/period/v1/cards.go
+++ b/internal/stats/render/period/v1/cards.go
@@ -49,7 +49,7 @@ func generateCards(stats fetch.AccountStatsOverPeriod, cards period.Cards, subs
 				}
 			}
 
-			cardStyle := overviewCardStyle(cardWidth)
+			cardStyle := overviewCardBlocksStyle(cardWidth)
 			paddingAndGaps := (cardStyle.PaddingX+rowStyle.container.PaddingX+rowStyle.blockContainer.PaddingX)*2 + float64(len(cards.Overview.Blocks)-1)*(cardStyle.Gap+rowStyle.container.Gap+rowStyle.blockContainer.Gap)
 
 			overviewCardContentWidth := overviewColumnWidth * float64(len(cards.Overview.Blocks))
@@ -82,13 +82,17 @@ func generateCards(stats fetch.AccountStatsOverPeriod, cards period.Cards, subs
 	// We first render a footer in order to calculate the minimum required width
 	{
 		var footer []string
-		switch strings.ToLower(stats.Realm) {
-		case "na":
-			footer = append(footer, "North America")
-		case "eu":
-			footer = append(footer, "Europe")
-		case "as":
-			footer = append(footer, "Asia")
+		if opts.VehicleID != "" {
+			footer = append(footer, cards.Overview.Title)
+		} else {
+			switch strings.ToLower(stats.Realm) {
+			case "na":
+				footer = append(footer, "North America")
+			case "eu":
+				footer = append(footer, "Europe")
+			case "as":
+				footer = append(footer, "Asia")
+			}
 		}
 
 		sessionTo := stats.PeriodEnd.Format("Jan 2, 2006")
@@ -118,15 +122,17 @@ func generateCards(stats fetch.AccountStatsOverPeriod, cards period.Cards, subs
 
 	// Overview Card
 	{
-		var overviewCardBlocks []common.Block
+		var overviewStatsBlocks []common.Block
 		for _, column := range cards.Overview.Blocks {
 			columnBlock, err := statsBlocksToColumnBlock(getOverviewStyle(overviewColumnWidth), column.Blocks)
 			if err != nil {
 				return segments, err
 			}
-			overviewCardBlocks = append(overviewCardBlocks, columnBlock)
+			overviewStatsBlocks = append(overviewStatsBlocks, columnBlock)
 		}
-		segments.AddContent(common.NewBlocksContent(overviewCardStyle(cardWidth), overviewCardBlocks...))
+		var overviewCardBlocks []common.Block
+		overviewCardBlocks = append(overviewCardBlocks, common.NewBlocksContent(overviewCardBlocksStyle(cardWidth), overviewStatsBlocks...))
+		segments.AddContent(common.NewBlocksContent(overviewCardStyle(), overviewCardBlocks...))
 	}
 
 	// Highlights
@@ -134,6 +140,11 @@ func generateCards(stats fetch.AccountStatsOverPeriod, cards period.Cards, subs
 		segments.AddContent(newHighlightCard(highlightCardStyle(defaultCardStyle(cardWidth)), card))
 	}
 
+	// Vehicle label
+	if opts.VehicleID != "" {
+		//
+	}
+
 	return segments, nil
 }
 
diff --git a/internal/stats/render/period/v1/constants.go b/internal/stats/render/period/v1/constants.go
index 1418e0a3..0a173084 100644
--- a/internal/stats/render/period/v1/constants.go
+++ b/internal/stats/render/period/v1/constants.go
@@ -65,18 +65,30 @@ func defaultCardStyle(width float64) common.Style {
 func titleCardStyle(width float64) common.Style {
 	style := defaultCardStyle(width)
 	style.PaddingX = style.PaddingY
-	style.Gap = style.PaddingY * 2
+	style.Gap = style.PaddingY
 	// style.Debug = true
 	return style
 }
 
-func overviewCardStyle(width float64) common.Style {
+func overviewCardStyle() common.Style {
+	// style := defaultCardStyle(0)
+	style := common.Style{}
+	style.Direction = common.DirectionVertical
+	style.AlignItems = common.AlignItemsCenter
+	style.JustifyContent = common.JustifyContentCenter
+	style.PaddingY = 0
+	style.PaddingX = 0
+	// style.Debug = true
+	style.Gap = 5
+	return style
+}
+
+func overviewCardBlocksStyle(width float64) common.Style {
 	style := defaultCardStyle(width)
 	style.AlignItems = common.AlignItemsEnd
 	style.Direction = common.DirectionHorizontal
 	style.JustifyContent = common.JustifyContentSpaceAround
 	style.PaddingY = 25
-	style.PaddingX = 0
 	style.Gap = 0
 	// style.Debug = true
 	return style
diff --git a/internal/stats/render/session/v1/cards.go b/internal/stats/render/session/v1/cards.go
index 9ba757eb..2cc5fabd 100644
--- a/internal/stats/render/session/v1/cards.go
+++ b/internal/stats/render/session/v1/cards.go
@@ -21,7 +21,7 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 		// when there are 3 vehicle cards and no rating overview cards or there are 6 vehicle cards and some rating battles
 		shouldRenderUnratedHighlights = (session.RegularBattles.Battles > 0 && session.RatingBattles.Battles < 1 && len(cards.Unrated.Vehicles) > renderUnratedVehiclesCount) ||
 			(session.RegularBattles.Battles > 0 && len(cards.Unrated.Vehicles) > 3)
-		shouldRenderRatingOverview = session.RatingBattles.Battles > 0
+		shouldRenderRatingOverview = session.RatingBattles.Battles > 0 && opts.VehicleID == ""
 		shouldRenderRatingVehicles = session.RatingBattles.Battles > 0 && len(cards.Rating.Vehicles) > 0 && len(cards.Unrated.Vehicles) < 1
 		// secondary cards
 		shouldRenderUnratedVehicles = session.RegularBattles.Battles > 0 && len(cards.Unrated.Vehicles) > 0
@@ -156,13 +156,17 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 
 	{
 		var footer []string
-		switch strings.ToLower(session.Realm) {
-		case "na":
-			footer = append(footer, "North America")
-		case "eu":
-			footer = append(footer, "Europe")
-		case "as":
-			footer = append(footer, "Asia")
+		if opts.VehicleID != "" {
+			footer = append(footer, cards.Unrated.Overview.Title)
+		} else {
+			switch strings.ToLower(session.Realm) {
+			case "na":
+				footer = append(footer, "North America")
+			case "eu":
+				footer = append(footer, "Europe")
+			case "as":
+				footer = append(footer, "Asia")
+			}
 		}
 		if session.LastBattleTime.Unix() > 1 {
 			sessionTo := session.PeriodEnd.Format("Jan 2")
diff --git a/render_test.go b/render_test.go
index 8fdde513..d4880edd 100644
--- a/render_test.go
+++ b/render_test.go
@@ -45,6 +45,89 @@ func TestRenderSession(t *testing.T) {
 		assert.NoError(t, err, "failed to create a file")
 		defer f.Close()
 
+		err = image.PNG(f)
+		assert.NoError(t, err, "failed to encode a png image")
+	}
+	{
+		image, _, err := stats.SessionImage(context.Background(), tests.DefaultAccountNA, time.Now(), client.WithBackgroundURL("static://bg-default"), client.WithVehicleID("0"))
+		assert.NoError(t, err, "failed to render a session image")
+		assert.NotNil(t, image, "image is nil")
+
+		f, err := os.Create("tmp/render_test_session_single_large.png")
+		assert.NoError(t, err, "failed to create a file")
+		defer f.Close()
+
+		err = image.PNG(f)
+		assert.NoError(t, err, "failed to encode a png image")
+	}
+	{
+		image, _, err := stats.SessionImage(context.Background(), tests.DefaultAccountNA, time.Now(), client.WithBackgroundURL("static://bg-default"), client.WithVehicleID("0"))
+		assert.NoError(t, err, "failed to render a session image")
+		assert.NotNil(t, image, "image is nil")
+
+		f, err := os.Create("tmp/render_test_session_single_large.png")
+		assert.NoError(t, err, "failed to create a file")
+		defer f.Close()
+
+		err = image.PNG(f)
+		assert.NoError(t, err, "failed to encode a png image")
+	}
+}
+
+func TestRenderPeriod(t *testing.T) {
+	// Logger
+	level, _ := zerolog.ParseLevel(os.Getenv("LOG_LEVEL"))
+	zerolog.SetGlobalLevel(level)
+
+	loadStaticAssets(static)
+
+	stats := client.NewClient(tests.StaticTestingFetch(), tests.StaticTestingDatabase(), nil, language.English)
+
+	{
+		image, _, err := stats.PeriodImage(context.Background(), tests.DefaultAccountNAShort, time.Now())
+		assert.NoError(t, err, "failed to render a session image")
+		assert.NotNil(t, image, "image is nil")
+
+		f, err := os.Create("tmp/render_test_period_full_small.png")
+		assert.NoError(t, err, "failed to create a file")
+		defer f.Close()
+
+		err = image.PNG(f)
+		assert.NoError(t, err, "failed to encode a png image")
+	}
+	{
+		image, _, err := stats.PeriodImage(context.Background(), tests.DefaultAccountNA, time.Now(), client.WithBackgroundURL("static://bg-default"))
+		assert.NoError(t, err, "failed to render a session image")
+		assert.NotNil(t, image, "image is nil")
+
+		f, err := os.Create("tmp/render_test_period_full_large.png")
+		assert.NoError(t, err, "failed to create a file")
+		defer f.Close()
+
+		err = image.PNG(f)
+		assert.NoError(t, err, "failed to encode a png image")
+	}
+	{
+		image, _, err := stats.PeriodImage(context.Background(), tests.DefaultAccountNA, time.Now(), client.WithBackgroundURL("static://bg-default"), client.WithVehicleID("0"))
+		assert.NoError(t, err, "failed to render a session image")
+		assert.NotNil(t, image, "image is nil")
+
+		f, err := os.Create("tmp/render_test_period_single_large.png")
+		assert.NoError(t, err, "failed to create a file")
+		defer f.Close()
+
+		err = image.PNG(f)
+		assert.NoError(t, err, "failed to encode a png image")
+	}
+	{
+		image, _, err := stats.PeriodImage(context.Background(), tests.DefaultAccountNAShort, time.Now(), client.WithBackgroundURL("static://bg-default"), client.WithVehicleID("0"))
+		assert.NoError(t, err, "failed to render a session image")
+		assert.NotNil(t, image, "image is nil")
+
+		f, err := os.Create("tmp/render_test_period_single_small.png")
+		assert.NoError(t, err, "failed to create a file")
+		defer f.Close()
+
 		err = image.PNG(f)
 		assert.NoError(t, err, "failed to encode a png image")
 	}

From b454b88e1498b79aca830b20fd74b6df1d7a0a11 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 11 Jul 2024 17:26:20 -0400
Subject: [PATCH 337/341] maved battles

---
 internal/stats/prepare/period/v1/constants.go | 4 ++--
 internal/stats/prepare/period/v1/preset.go    | 2 +-
 internal/stats/render/period/v1/constants.go  | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/internal/stats/prepare/period/v1/constants.go b/internal/stats/prepare/period/v1/constants.go
index 2b3b9bb4..de603ec9 100644
--- a/internal/stats/prepare/period/v1/constants.go
+++ b/internal/stats/prepare/period/v1/constants.go
@@ -13,8 +13,8 @@ type overviewColumnBlocks struct {
 
 var overviewBlocks = []overviewColumnBlocks{
 	{[]common.Tag{common.TagDamageRatio, common.TagAvgDamage, common.TagAccuracy}, BlockFlavorDefault},
-	{[]common.Tag{common.TagWN8, common.TagBattles}, BlockFlavorSpecial},
-	{[]common.Tag{TagAvgTier, common.TagWinrate, common.TagSurvivalPercent}, BlockFlavorDefault},
+	{[]common.Tag{common.TagWN8}, BlockFlavorSpecial},
+	{[]common.Tag{TagAvgTier, common.TagWinrate, common.TagBattles}, BlockFlavorDefault},
 }
 var highlights = []common.Highlight{common.HighlightBattles, common.HighlightWN8, common.HighlightAvgDamage}
 
diff --git a/internal/stats/prepare/period/v1/preset.go b/internal/stats/prepare/period/v1/preset.go
index fe41b8ae..c0db26be 100644
--- a/internal/stats/prepare/period/v1/preset.go
+++ b/internal/stats/prepare/period/v1/preset.go
@@ -14,7 +14,7 @@ func presetToBlock(preset common.Tag, stats frame.StatsFrame, vehicles map[strin
 		block.Data.Flavor = BlockFlavorSpecial
 
 	case common.TagBattles:
-		block.Data.Flavor = BlockFlavorSpecial
+		block.Data.Flavor = BlockFlavorSecondary
 
 	case common.TagSurvivalRatio:
 		block.Data.Flavor = BlockFlavorSecondary
diff --git a/internal/stats/render/period/v1/constants.go b/internal/stats/render/period/v1/constants.go
index 0a173084..05cba778 100644
--- a/internal/stats/render/period/v1/constants.go
+++ b/internal/stats/render/period/v1/constants.go
@@ -85,7 +85,7 @@ func overviewCardStyle() common.Style {
 
 func overviewCardBlocksStyle(width float64) common.Style {
 	style := defaultCardStyle(width)
-	style.AlignItems = common.AlignItemsEnd
+	style.AlignItems = common.AlignItemsCenter
 	style.Direction = common.DirectionHorizontal
 	style.JustifyContent = common.JustifyContentSpaceAround
 	style.PaddingY = 25

From 0de71a20488c01e146d813af7a0938862cc520d8 Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 11 Jul 2024 17:32:44 -0400
Subject: [PATCH 338/341] passing vehicle id on refresh

---
 cmd/discord/commands/interactions.go            | 4 ++--
 cmd/discord/commands/session.go                 | 1 +
 cmd/discord/commands/stats.go                   | 1 +
 internal/database/models/discord_interaction.go | 1 +
 4 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/cmd/discord/commands/interactions.go b/cmd/discord/commands/interactions.go
index 5ad609cd..fca97ee2 100644
--- a/cmd/discord/commands/interactions.go
+++ b/cmd/discord/commands/interactions.go
@@ -57,7 +57,7 @@ func init() {
 				var meta stats.Metadata
 				switch interaction.Command {
 				case "stats":
-					img, mt, err := ctx.Core.Stats(ctx.Locale).PeriodImage(context.Background(), interaction.Options.AccountID, interaction.Options.PeriodStart, stats.WithBackgroundURL(interaction.Options.BackgroundImageURL), stats.WithWN8())
+					img, mt, err := ctx.Core.Stats(ctx.Locale).PeriodImage(context.Background(), interaction.Options.AccountID, interaction.Options.PeriodStart, stats.WithBackgroundURL(interaction.Options.BackgroundImageURL), stats.WithWN8(), stats.WithVehicleID(interaction.Options.VehicleID))
 					if err != nil {
 						return ctx.Err(err)
 					}
@@ -65,7 +65,7 @@ func init() {
 					meta = mt
 
 				case "session":
-					img, mt, err := ctx.Core.Stats(ctx.Locale).SessionImage(context.Background(), interaction.Options.AccountID, interaction.Options.PeriodStart, stats.WithBackgroundURL(interaction.Options.BackgroundImageURL), stats.WithWN8())
+					img, mt, err := ctx.Core.Stats(ctx.Locale).SessionImage(context.Background(), interaction.Options.AccountID, interaction.Options.PeriodStart, stats.WithBackgroundURL(interaction.Options.BackgroundImageURL), stats.WithWN8(), stats.WithVehicleID(interaction.Options.VehicleID))
 					if err != nil {
 						if errors.Is(err, fetch.ErrSessionNotFound) || errors.Is(err, stats.ErrAccountNotTracked) {
 							return ctx.Reply().Send("stats_refresh_interaction_error_expired")
diff --git a/cmd/discord/commands/session.go b/cmd/discord/commands/session.go
index 2b4fd2a7..4c4c3901 100644
--- a/cmd/discord/commands/session.go
+++ b/cmd/discord/commands/session.go
@@ -83,6 +83,7 @@ func init() {
 				button, saveErr := saveInteractionData(ctx, "session", models.DiscordInteractionOptions{
 					BackgroundImageURL: backgroundURL,
 					PeriodStart:        options.PeriodStart,
+					VehicleID:          options.TankID,
 					AccountID:          accountID,
 				})
 				if saveErr != nil {
diff --git a/cmd/discord/commands/stats.go b/cmd/discord/commands/stats.go
index c7317a27..e5780242 100644
--- a/cmd/discord/commands/stats.go
+++ b/cmd/discord/commands/stats.go
@@ -69,6 +69,7 @@ func init() {
 				button, saveErr := saveInteractionData(ctx, "stats", models.DiscordInteractionOptions{
 					BackgroundImageURL: backgroundURL,
 					PeriodStart:        options.PeriodStart,
+					VehicleID:          options.TankID,
 					AccountID:          accountID,
 				})
 				if saveErr != nil {
diff --git a/internal/database/models/discord_interaction.go b/internal/database/models/discord_interaction.go
index f031317b..5c3a9d6a 100644
--- a/internal/database/models/discord_interaction.go
+++ b/internal/database/models/discord_interaction.go
@@ -48,4 +48,5 @@ type DiscordInteractionOptions struct {
 	BackgroundImageURL string
 	PeriodStart        time.Time
 	AccountID          string
+	VehicleID          string
 }

From dbadcdce12150dd07f8f731ccc333c36e42cc49d Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 11 Jul 2024 17:45:31 -0400
Subject: [PATCH 339/341] added localization to new command strings

---
 cmd/discord/commands/autocomplete.go | 6 +++---
 main.go                              | 5 +++--
 static/localization/en/discord.yaml  | 9 ++++++++-
 3 files changed, 14 insertions(+), 6 deletions(-)

diff --git a/cmd/discord/commands/autocomplete.go b/cmd/discord/commands/autocomplete.go
index 0c33594f..ad5e7375 100644
--- a/cmd/discord/commands/autocomplete.go
+++ b/cmd/discord/commands/autocomplete.go
@@ -67,18 +67,18 @@ func init() {
 				if options.TankID != "" {
 					vehicle, ok := search.GetVehicleFromCache(ctx.Locale, options.TankID)
 					if !ok {
-						return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: "stats_acutocomplete_not_enough_length", Value: "error#stats_acutocomplete_not_found"})
+						return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: ctx.Localize("stats_autocomplete_not_found"), Value: "error#stats_autocomplete_not_found"})
 					}
 					return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: fmt.Sprintf("%s %s", prepare.IntToRoman(vehicle.Tier), vehicle.Name(ctx.Locale)), Value: fmt.Sprintf("valid#vehicle#%s", vehicle.ID)})
 				}
 
 				if len(options.TankSearch) < 3 {
-					return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: "stats_acutocomplete_not_enough_length", Value: "error#stats_acutocomplete_not_found"})
+					return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: ctx.Localize("stats_autocomplete_not_enough_length"), Value: "error#stats_autocomplete_not_enough_length"})
 				}
 
 				vehicles, ok := search.SearchVehicles(ctx.Locale, options.TankSearch, 5)
 				if !ok || len(vehicles) < 1 {
-					return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: "stats_acutocomplete_not_found", Value: "error#stats_acutocomplete_not_found"})
+					return ctx.Reply().Choices(&discordgo.ApplicationCommandOptionChoice{Name: ctx.Localize("stats_autocomplete_not_found"), Value: "error#stats_autocomplete_not_found"})
 				}
 
 				var opts []*discordgo.ApplicationCommandOptionChoice
diff --git a/main.go b/main.go
index 849ba3be..5697b5e4 100644
--- a/main.go
+++ b/main.go
@@ -88,7 +88,6 @@ func main() {
 	if err != nil {
 		log.Fatal().Err(err).Msg("startSchedulerFromEnv failed")
 	}
-	defer stopScheduler()
 
 	// update vehicle cache in the background on start
 	go scheduler.UpdateGlossaryWorker(cacheCoreClient)()
@@ -145,8 +144,10 @@ func main() {
 	signal.Notify(c, os.Interrupt, syscall.SIGTERM)
 
 	sig := <-c
+	log.Info().Msgf("received %s, exiting after cleanup", sig.String())
 	cancel()
-	log.Info().Msgf("received %s, exiting", sig.String())
+	stopScheduler()
+	log.Info().Msg("finished cleanup tasks")
 }
 
 func discordHandlersFromEnv(coreClient core.Client) []server.Handler {
diff --git a/static/localization/en/discord.yaml b/static/localization/en/discord.yaml
index 6dad1136..19ab2e6d 100755
--- a/static/localization/en/discord.yaml
+++ b/static/localization/en/discord.yaml
@@ -176,6 +176,14 @@
   value: "This refresh button has expired. Please use the command instead."
   context: Failed to find required data in order to refresh stats/session
 
+- key: stats_autocomplete_not_found
+  value: "No tanks found matching the name you have entered"
+  context: Search returned no results when a user was typing the tank name in autocomplete
+
+- key: stats_autocomplete_not_enough_length
+  value: "Continue typing to search for available tanks..."
+  context: Shown when a user just started typing and there are not enough characters to search
+
 # /background errors
 - key: background_error_payment_required
   value: "This feature of Aftermath is only available for users with an active subscription.\nYou can subscribe by using the `/subscribe` command or pick a background using `/fancy` instead."
@@ -219,7 +227,6 @@
   value: "Please select a server your account is registered on."
   context: Server not selected
 
-
   # Wargaming specific errors
 - key: wargaming_error_private_account
   value: "This account is marked private by Wargaming and no stats are available for it at this time."

From 447035a24d730ccfa893761d96aa07be7fb73ffa Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 11 Jul 2024 19:51:00 -0400
Subject: [PATCH 340/341] minor styling tweaks

---
 internal/stats/fetch/v1/multisource.go        |  3 ---
 .../stats/render/common/v1/player_title.go    |  8 ++++++--
 internal/stats/render/period/v1/block.go      | 11 +++-------
 internal/stats/render/period/v1/cards.go      |  6 +++---
 internal/stats/render/period/v1/constants.go  | 20 +++++++++++++++----
 internal/stats/render/session/v1/cards.go     |  4 ++--
 6 files changed, 30 insertions(+), 22 deletions(-)

diff --git a/internal/stats/fetch/v1/multisource.go b/internal/stats/fetch/v1/multisource.go
index 9c03e57c..280fd7ce 100644
--- a/internal/stats/fetch/v1/multisource.go
+++ b/internal/stats/fetch/v1/multisource.go
@@ -112,7 +112,6 @@ func (c *multiSourceClient) CurrentStats(ctx context.Context, id string, opts ..
 	for _, apply := range opts {
 		apply(&options)
 	}
-	println(options.vehicleID)
 
 	realm := c.wargaming.RealmFromAccountID(id)
 
@@ -181,8 +180,6 @@ func (c *multiSourceClient) CurrentStats(ctx context.Context, id string, opts ..
 		log.Err(averages.Err).Msg("failed to get tank averages")
 	}
 
-	println(len(vehicles.Data), "vehicle", options.vehicleID)
-
 	stats := WargamingToStats(realm, account.Data, clan, vehicles.Data)
 	if options.withWN8 {
 		stats.AddWN8(averages.Data)
diff --git a/internal/stats/render/common/v1/player_title.go b/internal/stats/render/common/v1/player_title.go
index f31beeb2..5c9f7836 100644
--- a/internal/stats/render/common/v1/player_title.go
+++ b/internal/stats/render/common/v1/player_title.go
@@ -17,7 +17,7 @@ func (style TitleCardStyle) TotalPaddingAndGaps() float64 {
 	return style.Container.PaddingX*2 + style.Container.Gap*2 + style.Nickname.PaddingX*2 + style.ClanTag.PaddingX*4
 }
 
-func DefaultPlayerTitleStyle(containerStyle Style) TitleCardStyle {
+func DefaultPlayerTitleStyle(name string, containerStyle Style) TitleCardStyle {
 	containerStyle.AlignItems = AlignItemsCenter
 	containerStyle.Direction = DirectionHorizontal
 	// containerStyle.Debug = true
@@ -27,9 +27,13 @@ func DefaultPlayerTitleStyle(containerStyle Style) TitleCardStyle {
 	clanTagBackgroundColor.G += 15
 	clanTagBackgroundColor.B += 15
 
+	nameFontSize := FontLarge()
+	if len(name) > 10 {
+		nameFontSize = FontMedium()
+	}
 	return TitleCardStyle{
 		Container: containerStyle,
-		Nickname:  Style{Font: FontLarge(), FontColor: TextPrimary},
+		Nickname:  Style{Font: nameFontSize, FontColor: TextPrimary},
 		ClanTag:   Style{Font: FontMedium(), FontColor: TextSecondary, PaddingX: 10, PaddingY: 5, BackgroundColor: clanTagBackgroundColor, BorderRadius: BorderRadiusSM},
 	}
 }
diff --git a/internal/stats/render/period/v1/block.go b/internal/stats/render/period/v1/block.go
index 96057065..bbe439ce 100644
--- a/internal/stats/render/period/v1/block.go
+++ b/internal/stats/render/period/v1/block.go
@@ -52,18 +52,13 @@ func uniqueBlockWN8(style overviewStyle, stats prepare.StatsBlock[period.BlockDa
 	iconTop := common.AftermathLogo(ratingColors.Background, common.DefaultLogoOptions())
 	iconBlockTop := common.NewImageContent(common.Style{Width: float64(iconTop.Bounds().Dx()), Height: float64(iconTop.Bounds().Dy())}, iconTop)
 
-	style.blockContainer.Gap = 10
+	style.blockContainer.Gap = 5
 	blocks = append(blocks, common.NewBlocksContent(style.blockContainer, iconBlockTop, valueBlock))
 
 	if stats.Value.Float() >= 0 {
 		labelStyle.FontColor = ratingColors.Content
-		blocks = append(blocks, common.NewBlocksContent(common.Style{
-			PaddingY:        5,
-			PaddingX:        10,
-			BorderRadius:    15,
-			BackgroundColor: ratingColors.Background,
-		}, common.NewTextContent(labelStyle, common.GetWN8TierName(stats.Value.Float()))))
+		blocks = append(blocks, common.NewBlocksContent(overviewSpecialRatingPillStyle(ratingColors.Background), common.NewTextContent(labelStyle, common.GetWN8TierName(stats.Value.Float()))))
 	}
 
-	return common.NewBlocksContent(common.Style{Direction: common.DirectionVertical, AlignItems: common.AlignItemsCenter, Gap: 10, PaddingY: 5}, blocks...)
+	return common.NewBlocksContent(common.Style{Direction: common.DirectionVertical, AlignItems: common.AlignItemsCenter, Gap: 0}, blocks...)
 }
diff --git a/internal/stats/render/period/v1/cards.go b/internal/stats/render/period/v1/cards.go
index 481d29f8..6efd0ed9 100644
--- a/internal/stats/render/period/v1/cards.go
+++ b/internal/stats/render/period/v1/cards.go
@@ -27,7 +27,7 @@ func generateCards(stats fetch.AccountStatsOverPeriod, cards period.Cards, subs
 	overviewColumnWidth := float64(common.DefaultLogoOptions().Width())
 	{
 		{
-			titleStyle := common.DefaultPlayerTitleStyle(titleCardStyle(cardWidth))
+			titleStyle := common.DefaultPlayerTitleStyle(stats.Account.Nickname, titleCardStyle(cardWidth))
 			clanSize := common.MeasureString(stats.Account.ClanTag, titleStyle.ClanTag.Font)
 			nameSize := common.MeasureString(stats.Account.Nickname, titleStyle.Nickname.Font)
 			cardWidth = common.Max(cardWidth, titleStyle.TotalPaddingAndGaps()+nameSize.TotalWidth+clanSize.TotalWidth*2)
@@ -45,7 +45,7 @@ func generateCards(stats fetch.AccountStatsOverPeriod, cards period.Cards, subs
 					labelSize := common.MeasureString(label, labelStyle.Font)
 					valueSize := common.MeasureString(block.Value.String(), valueStyle.Font)
 
-					overviewColumnWidth = common.Max(overviewColumnWidth, common.Max(labelSize.TotalWidth, valueSize.TotalWidth)+(rowStyle.container.PaddingX*2))
+					overviewColumnWidth = common.Max(overviewColumnWidth, common.Max(labelSize.TotalWidth+overviewSpecialRatingPillStyle(nil).PaddingX*2, valueSize.TotalWidth))
 				}
 			}
 
@@ -118,7 +118,7 @@ func generateCards(stats fetch.AccountStatsOverPeriod, cards period.Cards, subs
 	}
 
 	// Player Title card
-	segments.AddContent(common.NewPlayerTitleCard(common.DefaultPlayerTitleStyle(titleCardStyle(cardWidth)), stats.Account.Nickname, stats.Account.ClanTag, subs))
+	segments.AddContent(common.NewPlayerTitleCard(common.DefaultPlayerTitleStyle(stats.Account.Nickname, titleCardStyle(cardWidth)), stats.Account.Nickname, stats.Account.ClanTag, subs))
 
 	// Overview Card
 	{
diff --git a/internal/stats/render/period/v1/constants.go b/internal/stats/render/period/v1/constants.go
index 05cba778..0d16b261 100644
--- a/internal/stats/render/period/v1/constants.go
+++ b/internal/stats/render/period/v1/constants.go
@@ -1,6 +1,8 @@
 package period
 
 import (
+	"image/color"
+
 	prepare "github.com/cufee/aftermath/internal/stats/prepare/common/v1"
 	"github.com/cufee/aftermath/internal/stats/prepare/period/v1"
 	"github.com/cufee/aftermath/internal/stats/render/common/v1"
@@ -35,7 +37,7 @@ func getOverviewStyle(columnWidth float64) overviewStyle {
 		Direction:      common.DirectionVertical,
 		AlignItems:     common.AlignItemsCenter,
 		JustifyContent: common.JustifyContentCenter,
-		PaddingX:       10,
+		PaddingX:       0,
 		PaddingY:       0,
 		Gap:            10,
 		Width:          columnWidth,
@@ -78,8 +80,8 @@ func overviewCardStyle() common.Style {
 	style.JustifyContent = common.JustifyContentCenter
 	style.PaddingY = 0
 	style.PaddingX = 0
-	// style.Debug = true
 	style.Gap = 5
+	// style.Debug = true
 	return style
 }
 
@@ -88,12 +90,22 @@ func overviewCardBlocksStyle(width float64) common.Style {
 	style.AlignItems = common.AlignItemsCenter
 	style.Direction = common.DirectionHorizontal
 	style.JustifyContent = common.JustifyContentSpaceAround
-	style.PaddingY = 25
-	style.Gap = 0
+	style.PaddingY = 20
+	style.PaddingX = 10
+	style.Gap = 5
 	// style.Debug = true
 	return style
 }
 
+func overviewSpecialRatingPillStyle(color color.Color) common.Style {
+	return common.Style{
+		PaddingY:        2,
+		PaddingX:        7.5,
+		BorderRadius:    common.BorderRadiusXS,
+		BackgroundColor: color,
+	}
+}
+
 func highlightCardStyle(containerStyle common.Style) highlightStyle {
 	container := containerStyle
 	container.Gap = 10
diff --git a/internal/stats/render/session/v1/cards.go b/internal/stats/render/session/v1/cards.go
index 2cc5fabd..0a855633 100644
--- a/internal/stats/render/session/v1/cards.go
+++ b/internal/stats/render/session/v1/cards.go
@@ -51,7 +51,7 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 	var secondaryCardWidth, totalFrameWidth float64
 
 	{
-		titleStyle := common.DefaultPlayerTitleStyle(playerNameCardStyle(0))
+		titleStyle := common.DefaultPlayerTitleStyle(session.Account.Nickname, playerNameCardStyle(0))
 		clanSize := common.MeasureString(session.Account.ClanTag, titleStyle.ClanTag.Font)
 		nameSize := common.MeasureString(session.Account.Nickname, titleStyle.Nickname.Font)
 		primaryCardWidth = common.Max(primaryCardWidth, titleStyle.TotalPaddingAndGaps()+nameSize.TotalWidth+clanSize.TotalWidth*2)
@@ -196,7 +196,7 @@ func cardsToSegments(session, _ fetch.AccountStatsOverPeriod, cards session.Card
 
 	// player title
 	primaryColumn = append(primaryColumn,
-		common.NewPlayerTitleCard(common.DefaultPlayerTitleStyle(playerNameCardStyle(primaryCardWidth)), session.Account.Nickname, session.Account.ClanTag, subs),
+		common.NewPlayerTitleCard(common.DefaultPlayerTitleStyle(session.Account.Nickname, playerNameCardStyle(primaryCardWidth)), session.Account.Nickname, session.Account.ClanTag, subs),
 	)
 
 	// overview cards

From 6011ecfb21cca5c59fd93c611bf956ab690eec7f Mon Sep 17 00:00:00 2001
From: Vovko <vkouzin@outlook.com>
Date: Thu, 11 Jul 2024 19:59:34 -0400
Subject: [PATCH 341/341] tidy

---
 go.mod |  2 +-
 go.sum | 10 ----------
 2 files changed, 1 insertion(+), 11 deletions(-)

diff --git a/go.mod b/go.mod
index 60138a96..7140a23f 100644
--- a/go.mod
+++ b/go.mod
@@ -17,6 +17,7 @@ require (
 	github.com/google/go-github/v63 v63.0.0
 	github.com/joho/godotenv v1.5.1
 	github.com/justinas/alice v1.2.0
+	github.com/lithammer/fuzzysearch v1.1.8
 	github.com/lucsky/cuid v1.2.1
 	github.com/matryer/is v1.4.1
 	github.com/mattn/go-sqlite3 v1.14.22
@@ -46,7 +47,6 @@ require (
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/hashicorp/hcl/v2 v2.21.0 // indirect
-	github.com/lithammer/fuzzysearch v1.1.8 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mitchellh/go-wordwrap v1.0.1 // indirect
diff --git a/go.sum b/go.sum
index 1f3e3098..15dda7d8 100644
--- a/go.sum
+++ b/go.sum
@@ -79,16 +79,12 @@ github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/
 github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
-github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/mattn/go-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o4kU=
 github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
 github.com/mitchellh/go-wordwrap v1.0.1 h1:TLuKupo69TCn6TQSyGxwI1EblZZEsQ0vMlAFQflz0v0=
 github.com/mitchellh/go-wordwrap v1.0.1/go.mod h1:R62XHJLzvMFRBbcrT7m7WgmE1eOyTSsCt+hzestvNj0=
 github.com/nlpodyssey/gopickle v0.3.0 h1:BLUE5gxFLyyNOPzlXxt6GoHEMMxD0qhsE4p0CIQyoLw=
 github.com/nlpodyssey/gopickle v0.3.0/go.mod h1:f070HJ/yR+eLi5WmM1OXJEGaTpuJEUiib19olXgYha0=
-github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
-github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
 github.com/pierrec/lz4/v4 v4.1.21 h1:yOVMLb6qSIDP67pl/5F7RepeKYu/VmTyEXvuMI5d9mQ=
 github.com/pierrec/lz4/v4 v4.1.21/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
@@ -96,8 +92,6 @@ github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
-github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
 github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=
 github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
@@ -107,10 +101,6 @@ github.com/rs/xid v1.5.0 h1:mKX4bl4iPYJtEIxp6CYiUuLQ/8DYMoz0PUdtGgMFRVc=
 github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
 github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8=
 github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
-github.com/spf13/cobra v1.7.0 h1:hyqWnYt1ZQShIddO5kBpj3vu05/++x6tJ6dg8EC572I=
-github.com/spf13/cobra v1.7.0/go.mod h1:uLxZILRyS/50WlhOIKD7W6V5bgeIt+4sICxh6uRMrb0=
-github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
-github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=