feat: temp disable ffi

chore(deps): bump github.com/golang-jwt/jwt/v5 from 5.2.1 to 5.2.2 in the go_modules group across 1 directory

.github/workflows/go.yml

@@ -29,6 +29,19 @@ jobs:
           registry: ${{ env.REGISTRY }}
           username: ${{ github.actor }}
           password: ${{ secrets.GHCR_TOKEN }}
+
+      - name: Set up Flutter
+        uses: subosito/flutter-action@v2
+        with:
+          channel: stable
+          flutter-version: 3
+
+      - name: Build Web
+        run: |
+          cd ui
+          flutter pub get
+          flutter build web --no-web-resources-cdn
+          
       - name: Extract metadata (tags, labels) for Docker
         id: meta
         uses: docker/metadata-action@v5
@@ -45,4 +58,6 @@ jobs:
           platforms: linux/amd64
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}
+          build-args: |
+            TMDB_API_KEY=${{ secrets.TMDB_API_KEY }}
 

.github/workflows/goreleaser.yml

@@ -19,6 +19,16 @@ jobs:
         uses: actions/checkout@v4
         with:
           fetch-depth: 0
+      - name: Set up Flutter
+        uses: subosito/flutter-action@v2
+        with:
+          channel: stable
+          flutter-version: 3
+      - name: Build Web
+        run: |
+          cd ui
+          flutter pub get
+          flutter build web --no-web-resources-cdn --web-renderer html
       -
         name: Set up Go
         uses: actions/setup-go@v5
@@ -33,7 +43,7 @@ jobs:
           distribution: goreleaser
           # 'latest', 'nightly', or a semver
           version: '~> v2'
-          args: release --clean
+          args: release --clean --skip=validate
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           # Your GoReleaser Pro key, if you are using the 'goreleaser-pro' distribution

.github/workflows/release.yml

@@ -37,12 +37,25 @@ jobs:
           registry: ${{ env.REGISTRY }}
           username: ${{ github.actor }}
           password: ${{ secrets.GHCR_TOKEN }}
+  
       - name: Extract metadata (tags, labels) for Docker
         id: meta
         uses: docker/metadata-action@v5
         with:
           images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
 
+      - name: Set up Flutter
+        uses: subosito/flutter-action@v2
+        with:
+          channel: stable
+          flutter-version: 3
+
+      - name: Build Web
+        run: |
+          cd ui
+          flutter pub get
+          flutter build web --no-web-resources-cdn
+
       - name: Build and push
         id: push
         uses: docker/build-push-action@v6
@@ -50,11 +63,11 @@ jobs:
           context: .
           file: Dockerfile
           push: true
-          platforms: |
-            linux/amd64
-            linux/arm64
+          platforms: linux/amd64,linux/arm64,linux/arm/v7,linux/386,linux/s390x,linux/ppc64le
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}
+          build-args: |
+            TMDB_API_KEY=${{ secrets.TMDB_API_KEY }}
 
       - name: Generate artifact attestation
         uses: actions/attest-build-provenance@v1

Dockerfile

@@ -1,40 +1,37 @@
-FROM instrumentisto/flutter:3 AS flutter
-WORKDIR /app
-COPY ./ui/pubspec.yaml ./ui/pubspec.lock ./
-RUN flutter pub get
-COPY ./ui/ ./
-RUN flutter build web --no-web-resources-cdn --web-renderer html
-
-# 打包依赖阶段使用golang作为基础镜像
-FROM golang:1.22 as builder
+FROM golang:1.23 as builder
 
 # 启用go module
-ENV GO111MODULE=on \
-    GOPROXY=https://goproxy.cn,direct
+ENV GO111MODULE=on
+    #GOPROXY=https://goproxy.cn,direct
 
 WORKDIR /app
 
+ARG TMDB_API_KEY
+
 COPY  go.mod .
 COPY  go.sum .
 RUN go mod download
 
 COPY . .
 
-COPY --from=flutter /app/build/web ./ui/build/web/
 # 指定OS等，并go build
-RUN CGO_ENABLED=1 go build -o polaris -ldflags="-X polaris/db.Version=$(git describe --tags --long)"  ./cmd/ 
+RUN CGO_ENABLED=0 go build -o polaris -ldflags="-X polaris/db.Version=$(git describe --tags --long) -X polaris/db.DefaultTmdbApiKey=$(echo $TMDB_API_KEY)"  ./cmd/polaris
 
 FROM debian:stable-slim
-ENV TZ="Asia/Shanghai" GIN_MODE=release
 
 WORKDIR /app
-RUN apt-get update && apt-get -y install ca-certificates
+RUN apt-get update && apt-get -y install ca-certificates tzdata gosu tini locales && ln -sf /usr/share/zoneinfo/${TZ} /etc/localtime \ 
+    && echo "${TZ}" > /etc/timezone && apt-get clean && sed -i '/en_US.UTF-8/s/^# //g' /etc/locale.gen && locale-gen
+
+ENV TZ="Asia/Shanghai" GIN_MODE=release PUID=0 PGID=0 UMASK=0
+ENV LANG=en_US.UTF-8 LANGUAGE=en_US:en LC_ALL=en_US.UTF-8
 
 # 将上一个阶段publish文件夹下的所有文件复制进来
 COPY --from=builder /app/polaris .
+COPY --from=builder /app/entrypoint.sh .
+RUN chmod +x /app/entrypoint.sh
 
+VOLUME /app/data
 EXPOSE 8080
 
-#USER 1000:1000
-
-ENTRYPOINT ["./polaris"]
+ENTRYPOINT ["tini","./entrypoint.sh"]

Makefile

@@ -0,0 +1,6 @@
+.PHONY: windows
+
+windows:
+	@echo "Building for Windows..."
+	go build -tags c -ldflags="-X polaris/db.Version=$(git describe --tags --long)" -buildmode=c-shared -o ui/windows/libpolaris.dll ./cmd/binding
+	cd ui && flutter build windows

README.md

@@ -1,4 +1,10 @@
-# Polaris
+
+![main_page](./doc/assets/main_page.png)
+
+
+<h1 align="center">Polaris</h1>
+
+<div align="center">
 
 ![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/simon-ding/polaris/go.yml)
 ![GitHub Release](https://img.shields.io/github/v/release/simon-ding/polaris)
@@ -6,54 +12,79 @@
 ![GitHub go.mod Go version](https://img.shields.io/github/go-mod/go-version/simon-ding/polaris)
 
 
-Polaris 是一个电视剧和电影的追踪软件。配置好了之后，当剧集或者电影播出后，会第一时间下载对应的资源。支持本地存储或者webdav。
+**Polaris 是一个电视剧和电影的追踪下载软件。对美剧动漫日剧都有良好的匹配，支持多种存储方式（webdav、alist、本地存储）。**
+
+</div>
 
-![main_page](./doc/assets/main_page.png)
-![detail_page](./doc/assets/detail_page.png)
-![anime](./doc/assets/anime_match.png)
 
 交流群： https://t.me/+8R2nzrlSs2JhMDgx
 
 ## 快速开始
 
-使用此程序参考 [【快速开始】](https://simonding.gitbook.io/polaris/quick_start)
+使用此程序参考 [【快速开始】](./doc/quick_start.md)
 
 ## Features
 
 - [x] 电视剧自动追踪下载
 - [x] 电影自动追踪下载
-- [x] webdav 存储支持，配合 [alist](https://github.com/alist-org/alist) 或阿里云等实现更多功能
+- [x] 本地、webdav、  [alist](https://github.com/alist-org/alist) 存储支持，使用 alist 存储支持秒传功能
 - [x] 事件通知推送，目前支持 Pushover和 Bark，还在扩充中
-- [x] 后台代理支持
+- [x] TMDB 代理支持
 - [x] 用户认证
 - [x] plex 刮削支持
 - [x] NFO 刮削文件支持
 - [x] BT/PT 支持
+- [x] qbittorrent/transmission客户端支持
+- [x] 支持导入plex watchlist，plex里标记，自动导入polaris
 - [x] and more...
 
+## 支持的平台
+
+ - linux/amd64
+ - linux/arm64
+ - linux/arm/v7
+ - linux/386
+ - linux/s390x
+ - linux/ppc64le
+
+## FAQ
+
+- [常见问题 FAQ](./doc/faq.md)
+
 ## Todos
 
-- [ ] qbittorrent客户端支持
+
 - [ ] 更多通知客户端支持
-- [ ] 第三方watchlist导入支持
+- [ ] 更多第三方watchlist导入支持
 - [ ] 手机客户端
 
 
-## 原理
+## 截图
 
-本程序不提供任何视频相关资源，所有的资源都通过 jackett/prowlarr 所对接的BT/PT站点提供。
-    
-1. 此程序通过调用 jackett/prowlarr API搜索相关资源，然后匹配上对应的剧集
-2. 把搜索到的资源送到下载器下载
-3. 下载完成后归入对应的路径
+![main_page](./doc/assets/main_page.png)
+![detail_page](./doc/assets/detail_page.png)
+![anime](./doc/assets/anime_match.png)
 
-## 对比 sonarr/radarr
+
+## 运行原理
+
+Polaris本身不提供任何资源，要使其能正常工作，需要同时安装一个下载客户端（transmission）和一个索引客户端（jackett）。
+
+Polaris通过索引客户端查询相关的BT/PT站点，然后把查到的资源送到下载器，等待下载器下载完成对应资源。下载完成后，根据下载的对应资源，整理到对应的文件夹里去
+
+![](./doc/assets/yuanli.png)
+
+<!-- ## 对比 sonarr/radarr
 * 更好的中文支持
 * 对于动漫、日剧的良好支持，配合国内站点基本能匹配上对应资源
 * 支持 webdav 后端存储，可以配合 alist 或者阿里云来实现下载后实时传到云上的功能。这样外出就可以不依靠家里的宽带来看电影了，或者实现个轻 NAS 功能，下载功能放在本地，数据放在云盘
 * golang 实现后端，相比于 .NET 更节省资源
 * 一个程序同时实现了电影、电视剧功能，不需要装两个程序
-* 当然 sonarr/radarr 也是非常优秀的开源项目，目前 Polaris 功能还没有 sonarr/radarr 丰富
+* 当然 sonarr/radarr 也是非常优秀的开源项目，目前 Polaris 功能还没有 sonarr/radarr 丰富 -->
+
+
+## Stargazers over time
+[![Stargazers over time](https://starchart.cc/simon-ding/polaris.svg?variant=adaptive)](https://starchart.cc/simon-ding/polaris)
 
 -------------
 

cmd/binding/main.go

@@ -0,0 +1,21 @@
+package main
+
+import "C"
+import (
+	"os"
+	"polaris/cmd"
+	"polaris/log"
+)
+
+func main() {}
+
+//export Start
+func Start() {
+	cmd.Start(true)
+}
+
+//export Stop
+func Stop() {
+	log.Infof("stop polaris")
+	os.Exit(0)
+}

cmd/doc.go

@@ -1,30 +1,25 @@
-package main
+package cmd
 
 import (
+	"os"
 	"polaris/db"
 	"polaris/log"
-	"polaris/pkg/utils"
 	"polaris/server"
-	"time"
 )
 
-func main() {
+func Start(sharedLib bool) {
+	if sharedLib || os.Getenv("GIN_MODE") == "release" {
+		log.InitLogger(true)
+	} else {
+		log.InitLogger(false)
+	}
+
 	log.Infof("------------------- Starting Polaris ---------------------")
-
-	utils.MaxPermission()
-
 	dbClient, err := db.Open()
 	if err != nil {
 		log.Panicf("init db error: %v", err)
 	}
 
-	go func() {
-		time.Sleep(2 * time.Second)
-		if err := utils.OpenURL("http://127.0.0.1:8080"); err != nil {
-			log.Errorf("open url error: %v", err)
-		}
-
-	}()
 	s := server.NewServer(dbClient)
 	if err := s.Serve(); err != nil {
 		log.Errorf("server start error: %v", err)

cmd/polaris/polaris.go

@@ -0,0 +1,7 @@
+package main
+
+import "polaris/cmd"
+
+func main() {
+	cmd.Start(false)
+}

db/const.go

@@ -1,6 +1,11 @@
 package db
 
-var Version = "undefined"
+import "polaris/ent/media"
+
+var (
+	Version    = "undefined"
+	DefaultTmdbApiKey = ""
+)
 
 const (
 	SettingTmdbApiKey             = "tmdb_api_key"
@@ -14,9 +19,14 @@ const (
 	SettingNfoSupportEnabled      = "nfo_support_enabled"
 	SettingAllowQiangban          = "filter_qiangban"
 	SettingEnableTmdbAdultContent = "tmdb_adult_content"
-	SetttingSizeLimiter           = "size_limiter"
 	SettingTvNamingFormat         = "tv_naming_format"
 	SettingMovieNamingFormat      = "movie_naming_format"
+	SettingProwlarrInfo           = "prowlarr_info"
+
+	SettingTvSizeLimiter           = "tv_size_limiter"
+	SettingMovieSizeLimiter        = "movie_size_limiter"
+	SettingAcceptedVideoFormats    = "accepted_video_formats"
+	SettingAcceptedSubtitleFormats = "accepted_subtitle_formats"
 )
 
 const (
@@ -39,6 +49,18 @@ const (
 
 const DefaultNamingFormat = "{{.NameCN}} {{.NameEN}} {{if .Year}} ({{.Year}}) {{end}}"
 
+//https://en.wikipedia.org/wiki/Video_file_format
+var defaultAcceptedVideoFormats = []string{
+	".webm", ".mkv", ".flv", ".vob", ".ogv", ".ogg", ".drc", ".mng", ".avi", ".mts", ".m2ts", ".ts",
+	".mov", ".qt", ".wmv", ".yuv", ".rm", ".rmvb", ".viv", ".amv", ".mp4", ".m4p", ".m4v",
+	".mpg", ".mp2", ".mpeg", ".mpe", ".mpv", ".m2v", ".m4v",
+	".svi", ".3gp", ".3g2", ".nsv",
+}
+
+var defaultAcceptedSubtitleFormats = []string{
+	".ass", ".srt", ".vtt", ".webvtt", ".sub", ".idx",
+}
+
 type NamingInfo struct {
 	NameCN string
 	NameEN string
@@ -50,13 +72,31 @@ type ResolutionType string
 
 const JwtSerectKey = "jwt_secrect_key"
 
-type SizeLimiter struct {
-	R720p  Limiter `json:"720p"`
-	R1080p Limiter `json:"1080p"`
-	R2160p Limiter `json:"2160p"`
+type MediaSizeLimiter struct {
+	P720p SizeLimiter `json:"720p"`
+	P1080 SizeLimiter `json:"1080p"`
+	P2160 SizeLimiter `json:"2160p"`
 }
 
-type Limiter struct {
-	Max int `json:"max"`
-	Min int `json:"min"`
+func (m *MediaSizeLimiter) GetLimiter(r media.Resolution) SizeLimiter {
+	if r == media.Resolution1080p {
+		return m.P1080
+	} else if r == media.Resolution720p {
+		return m.P720p
+	} else if r == media.Resolution2160p {
+		return m.P2160
+	}
+	return SizeLimiter{}
+}
+
+type SizeLimiter struct {
+	MaxSIze    int64 `json:"max_size"`
+	MinSize    int64 `json:"min_size"`
+	PreferSIze int64 `json:"prefer_size"`
+}
+
+type ProwlarrSetting struct {
+	Disabled bool   `json:"disabled"`
+	ApiKey   string `json:"api_key"`
+	URL      string `json:"url"`
 }

db/db.go

@@ -17,6 +17,7 @@ import (
 	"polaris/ent/storage"
 	"polaris/log"
 	"polaris/pkg/utils"
+	"slices"
 	"strings"
 	"time"
 
@@ -38,13 +39,14 @@ func Open() (*Client, error) {
 		return nil, errors.Wrap(err, "failed opening connection to sqlite")
 	}
 	//defer client.Close()
-	// Run the auto migration tool.
-	if err := client.Schema.Create(context.Background()); err != nil {
-		return nil, errors.Wrap(err, "failed creating schema resources")
-	}
 	c := &Client{
 		ent: client,
 	}
+	// Run the auto migration tool.
+	if err := c.migrate(); err != nil {
+		return nil, errors.Wrap(err, "migrate")
+	}
+
 	c.init()
 
 	return c, nil
@@ -66,9 +68,13 @@ func (c *Client) init() {
 		log.Infof("set default log level")
 		c.SetSetting(SettingLogLevel, "info")
 	}
-	if tr := c.GetTransmission(); tr == nil {
+	if tr := c.GetAllDonloadClients(); len(tr) == 0 {
 		log.Warnf("no download client, set default download client")
-		c.SaveTransmission("transmission", "http://transmission:9091", "", "")
+		c.SaveDownloader(&ent.DownloadClients{
+			Name:           "transmission",
+			Implementation: downloadclients.ImplementationTransmission,
+			URL:            "http://transmission:9091",
+		})
 	}
 }
 
@@ -153,6 +159,7 @@ func (c *Client) AddMediaWatchlist(m *ent.Media, episodes []int) (*ent.Media, er
 		SetDownloadHistoryEpisodes(m.DownloadHistoryEpisodes).
 		SetLimiter(m.Limiter).
 		SetExtras(m.Extras).
+		SetAlternativeTitles(m.AlternativeTitles).
 		AddEpisodeIDs(episodes...).
 		Save(context.TODO())
 	return r, err
@@ -160,7 +167,7 @@ func (c *Client) AddMediaWatchlist(m *ent.Media, episodes []int) (*ent.Media, er
 }
 
 func (c *Client) GetMediaWatchlist(mediaType media.MediaType) []*ent.Media {
-	list, err := c.ent.Media.Query().Where(media.MediaTypeEQ(mediaType)).All(context.TODO())
+	list, err := c.ent.Media.Query().Where(media.MediaTypeEQ(mediaType)).Order(ent.Desc(media.FieldID)).All(context.TODO())
 	if err != nil {
 		log.Infof("query wtach list error: %v", err)
 		return nil
@@ -189,11 +196,10 @@ type MediaDetails struct {
 	Episodes []*ent.Episode `json:"episodes"`
 }
 
-func (c *Client) GetMediaDetails(id int) *MediaDetails {
+func (c *Client) GetMediaDetails(id int) (*MediaDetails, error) {
 	se, err := c.ent.Media.Query().Where(media.ID(id)).First(context.TODO())
 	if err != nil {
-		log.Errorf("get series %d: %v", id, err)
-		return nil
+		return nil, errors.Errorf("get series %d: %v", id, err)
 	}
 	var md = &MediaDetails{
 		Media: se,
@@ -201,12 +207,11 @@ func (c *Client) GetMediaDetails(id int) *MediaDetails {
 
 	ep, err := se.QueryEpisodes().All(context.Background())
 	if err != nil {
-		log.Errorf("get episodes %d: %v", id, err)
-		return nil
+		return nil, errors.Errorf("get episodes %d: %v", id, err)
 	}
 	md.Episodes = ep
 
-	return md
+	return md, nil
 }
 
 func (c *Client) GetMedia(id int) (*ent.Media, error) {
@@ -219,7 +224,10 @@ func (c *Client) DeleteMedia(id int) error {
 		return err
 	}
 	_, err = c.ent.Media.Delete().Where(media.ID(id)).Exec(context.TODO())
-	return err
+	if err != nil {
+		return err
+	}
+	return c.CleanAllDanglingEpisodes()
 }
 
 func (c *Client) SaveEposideDetail(d *ent.Episode) (int, error) {
@@ -244,6 +252,7 @@ func (c *Client) SaveEposideDetail2(d *ent.Episode) (int, error) {
 		SetMediaID(d.MediaID).
 		SetStatus(d.Status).
 		SetOverview(d.Overview).
+		SetMonitored(d.Monitored).
 		SetTitle(d.Title).Save(context.TODO())
 
 	return ep.ID, err
@@ -256,20 +265,22 @@ type TorznabSetting struct {
 
 func (c *Client) SaveIndexer(in *ent.Indexers) error {
 
-	if in.ID != 0 {
+	count := c.ent.Indexers.Query().Where(indexers.Name(in.Name)).CountX(context.TODO())
+
+	if count > 0 || in.ID != 0 {
 		//update setting
 		return c.ent.Indexers.Update().Where(indexers.ID(in.ID)).SetName(in.Name).SetImplementation(in.Implementation).
-			SetPriority(in.Priority).SetSettings(in.Settings).SetSeedRatio(in.SeedRatio).SetDisabled(in.Disabled).Exec(context.Background())
+			SetPriority(in.Priority).SetSeedRatio(in.SeedRatio).SetDisabled(in.Disabled).
+			SetTvSearch(in.TvSearch).SetMovieSearch(in.MovieSearch).SetSettings("").SetSynced(in.Synced).
+			SetAPIKey(in.APIKey).SetURL(in.URL).
+			Exec(context.Background())
 	}
 	//create new one
-	count := c.ent.Indexers.Query().Where(indexers.Name(in.Name)).CountX(context.TODO())
-	if count > 0 {
-		return fmt.Errorf("name already esxits: %v", in.Name)
-	}
 
 	_, err := c.ent.Indexers.Create().
-		SetName(in.Name).SetImplementation(in.Implementation).SetPriority(in.Priority).SetSettings(in.Settings).SetSeedRatio(in.SeedRatio).
-		SetDisabled(in.Disabled).Save(context.TODO())
+		SetName(in.Name).SetImplementation(in.Implementation).SetPriority(in.Priority).SetSeedRatio(in.SeedRatio).
+		SetTvSearch(in.TvSearch).SetMovieSearch(in.MovieSearch).SetSettings("").SetSynced(in.Synced).
+		SetAPIKey(in.APIKey).SetURL(in.URL).SetDisabled(in.Disabled).Save(context.TODO())
 	if err != nil {
 		return errors.Wrap(err, "save db")
 	}
@@ -277,76 +288,48 @@ func (c *Client) SaveIndexer(in *ent.Indexers) error {
 	return nil
 }
 
-func (c *Client) DeleteTorznab(id int) {
+func (c *Client) DeleteIndexer(id int) {
 	c.ent.Indexers.Delete().Where(indexers.ID(id)).Exec(context.TODO())
 }
 
-func (c *Client) GetIndexer(id int) (*TorznabInfo, error) {
+func (c *Client) GetIndexer(id int) (*ent.Indexers, error) {
 	res, err := c.ent.Indexers.Query().Where(indexers.ID(id)).First(context.TODO())
 	if err != nil {
 		return nil, err
 	}
-	var ss TorznabSetting
-	err = json.Unmarshal([]byte(res.Settings), &ss)
-	if err != nil {
-
-		return nil, fmt.Errorf("unmarshal torznab %s error: %v", res.Name, err)
-	}
-	return &TorznabInfo{Indexers: res, TorznabSetting: ss}, nil
+	return res, nil
 }
 
-type TorznabInfo struct {
-	*ent.Indexers
-	TorznabSetting
+func (c *Client) GetAllIndexers() []*ent.Indexers {
+	res := c.ent.Indexers.Query().Where(indexers.Implementation(IndexerTorznabImpl)).Order(ent.Asc(indexers.FieldID)).AllX(context.TODO())
+	return res
 }
 
-func (c *Client) GetAllTorznabInfo() []*TorznabInfo {
-	res := c.ent.Indexers.Query().Where(indexers.Implementation(IndexerTorznabImpl)).AllX(context.TODO())
-
-	var l = make([]*TorznabInfo, 0, len(res))
-	for _, r := range res {
-		var ss TorznabSetting
-		err := json.Unmarshal([]byte(r.Settings), &ss)
-		if err != nil {
-			log.Errorf("unmarshal torznab %s error: %v", r.Name, err)
-			continue
-		}
-		l = append(l, &TorznabInfo{
-			Indexers:       r,
-			TorznabSetting: ss,
-		})
-	}
-	return l
-}
-
-func (c *Client) SaveTransmission(name, url, user, password string) error {
-	count := c.ent.DownloadClients.Query().Where(downloadclients.Name(name)).CountX(context.TODO())
+func (c *Client) SaveDownloader(downloader *ent.DownloadClients) error {
+	count := c.ent.DownloadClients.Query().Where(downloadclients.Name(downloader.Name)).CountX(context.TODO())
 	if count != 0 {
-		err := c.ent.DownloadClients.Update().Where(downloadclients.Name(name)).
-			SetURL(url).SetUser(user).SetPassword(password).Exec(context.TODO())
+		err := c.ent.DownloadClients.Update().Where(downloadclients.Name(downloader.Name)).SetImplementation(downloader.Implementation).
+			SetURL(downloader.URL).SetUser(downloader.User).SetPassword(downloader.Password).SetPriority1(downloader.Priority1).Exec(context.TODO())
 		return err
 	}
 
-	_, err := c.ent.DownloadClients.Create().SetEnable(true).SetImplementation("transmission").
-		SetName(name).SetURL(url).SetUser(user).SetPassword(password).Save(context.TODO())
+	_, err := c.ent.DownloadClients.Create().SetEnable(true).SetImplementation(downloader.Implementation).
+		SetName(downloader.Name).SetURL(downloader.URL).SetUser(downloader.User).SetPriority1(downloader.Priority1).SetPassword(downloader.Password).Save(context.TODO())
 	return err
 }
 
-func (c *Client) GetTransmission() *ent.DownloadClients {
-	dc, err := c.ent.DownloadClients.Query().Where(downloadclients.Implementation("transmission")).First(context.TODO())
-	if err != nil {
-		log.Errorf("no transmission client found: %v", err)
-		return nil
-	}
-	return dc
-}
-
 func (c *Client) GetAllDonloadClients() []*ent.DownloadClients {
-	cc, err := c.ent.DownloadClients.Query().All(context.TODO())
+	cc, err := c.ent.DownloadClients.Query().Order(ent.Asc(downloadclients.FieldPriority1)).All(context.TODO())
 	if err != nil {
 		log.Errorf("no download client")
 		return nil
 	}
+	cc = append(cc, &ent.DownloadClients{
+		Implementation: downloadclients.ImplementationBuildin,
+		Name:           "内建下载器",
+		Priority1:      9999,
+		Enable:         true,
+	})
 	return cc
 }
 
@@ -376,6 +359,15 @@ func (s *StorageInfo) ToWebDavSetting() WebdavSetting {
 	}
 }
 
+func (s *StorageInfo) ToAlistSetting() WebdavSetting {
+	return WebdavSetting{
+		URL:            s.Settings["url"],
+		User:           s.Settings["user"],
+		Password:       s.Settings["password"],
+		ChangeFileHash: s.Settings["change_file_hash"],
+	}
+}
+
 type WebdavSetting struct {
 	URL            string `json:"url"`
 	User           string `json:"user"`
@@ -434,7 +426,7 @@ type Storage struct {
 }
 
 func (s *Storage) ToWebDavSetting() WebdavSetting {
-	if s.Implementation != storage.ImplementationWebdav {
+	if s.Implementation != storage.ImplementationWebdav && s.Implementation != storage.ImplementationAlist {
 		panic("not webdav storage")
 	}
 	var webdavSetting WebdavSetting
@@ -475,9 +467,10 @@ func (c *Client) SetDefaultStorageByName(name string) error {
 }
 
 func (c *Client) SaveHistoryRecord(h ent.History) (*ent.History, error) {
-	return c.ent.History.Create().SetMediaID(h.MediaID).SetEpisodeID(h.EpisodeID).SetDate(time.Now()).
+	return c.ent.History.Create().SetMediaID(h.MediaID).SetDate(time.Now()).
 		SetStatus(h.Status).SetTargetDir(h.TargetDir).SetSourceTitle(h.SourceTitle).SetIndexerID(h.IndexerID).
-		SetDownloadClientID(h.DownloadClientID).SetSize(h.Size).SetSaved(h.Saved).Save(context.TODO())
+		SetDownloadClientID(h.DownloadClientID).SetSize(h.Size).SetSeasonNum(h.SeasonNum).
+		SetEpisodeNums(h.EpisodeNums).SetHash(h.Hash).SetLink(h.Link).Save(context.TODO())
 }
 
 func (c *Client) SetHistoryStatus(id int, status history.Status) error {
@@ -506,7 +499,7 @@ func (c *Client) GetHistory(id int) *ent.History {
 }
 
 func (c *Client) DeleteHistory(id int) error {
-	_, err := c.ent.History.Delete().Where(history.ID(id)).Exec(context.Background())
+	 err := c.ent.History.Update().Where(history.ID(id)).SetStatus(history.StatusRemoved).Exec(context.Background())
 	return err
 }
 
@@ -532,8 +525,12 @@ func (c *Client) SetEpisodeStatus(id int, status episode.Status) error {
 }
 
 func (c *Client) IsEpisodeDownloadingOrDownloaded(id int) bool {
-	his := c.ent.History.Query().Where(history.EpisodeID(id)).AllX(context.Background())
+	ep, _ := c.GetEpisodeByID(id)
+	his := c.ent.History.Query().Where(history.EpisodeNumsNotNil()).AllX(context.Background())
 	for _, h := range his {
+		if !slices.Contains(h.EpisodeNums, ep.EpisodeNumber) {
+			continue
+		}
 		if h.Status != history.StatusFail {
 			return true
 		}
@@ -615,19 +612,38 @@ func (c *Client) DeleteImportlist(id int) error {
 	return c.ent.ImportList.DeleteOneID(id).Exec(context.TODO())
 }
 
-func (c *Client) GetSizeLimiter() (*SizeLimiter, error) {
-	v := c.GetSetting(SetttingSizeLimiter)
-	var limiter SizeLimiter
+func (c *Client) GetSizeLimiter(mediaType string) (*MediaSizeLimiter, error) {
+	var v string
+	if mediaType == "tv" {
+		v = c.GetSetting(SettingTvSizeLimiter)
+	} else if mediaType == "movie" {
+		v = c.GetSetting(SettingMovieSizeLimiter)
+	} else {
+		return nil, errors.Errorf("media type not supported: %v", mediaType)
+	}
+
+	var limiter MediaSizeLimiter
+	if v == "" {
+		return &limiter, nil
+	}
+
 	err := json.Unmarshal([]byte(v), &limiter)
 	return &limiter, err
 }
 
-func (c *Client) SetSizeLimiter(limiter *SizeLimiter) error {
+func (c *Client) SetSizeLimiter(mediaType string, limiter *MediaSizeLimiter) error {
 	data, err := json.Marshal(limiter)
 	if err != nil {
 		return err
 	}
-	return c.SetSetting(SetttingSizeLimiter, string(data))
+	if mediaType == "tv" {
+		return c.SetSetting(SettingTvSizeLimiter, string(data))
+	} else if mediaType == "movie" {
+		return c.SetSetting(SettingMovieSizeLimiter, string(data))
+	} else {
+		return errors.Errorf("media type not supported: %v", mediaType)
+	}
+
 }
 
 func (c *Client) GetTvNamingFormat() string {
@@ -645,3 +661,89 @@ func (c *Client) GetMovingNamingFormat() string {
 	}
 	return s
 }
+
+func (c *Client) CleanAllDanglingEpisodes() error {
+	_, err := c.ent.Episode.Delete().Where(episode.Not(episode.HasMedia())).Exec(context.Background())
+	return err
+}
+
+func (c *Client) AddBlacklistItem(item *ent.Blacklist) error {
+	return c.ent.Blacklist.Create().SetType(item.Type).SetValue(item.Value).SetNotes(item.Notes).Exec(context.Background())
+}
+
+func (c *Client) GetProwlarrSetting() (*ProwlarrSetting, error) {
+	s := c.GetSetting(SettingProwlarrInfo)
+	if s == "" {
+		return nil, errors.New("prowlarr setting not set")
+	}
+	var se ProwlarrSetting
+	if err := json.Unmarshal([]byte(s), &se); err != nil {
+		return nil, err
+	}
+	return &se, nil
+}
+
+func (c *Client) SaveProwlarrSetting(se *ProwlarrSetting) error {
+	data, err := json.Marshal(se)
+	if err != nil {
+		return err
+	}
+	return c.SetSetting(SettingProwlarrInfo, string(data))
+}
+
+func (c *Client) getAcceptedFormats(key string) ([]string, error) {
+	v := c.GetSetting(key)
+	if v == "" {
+		return nil, nil
+	}
+	var res []string
+
+	err := json.Unmarshal([]byte(v), &res)
+	return res, err
+}
+
+func (c *Client) setAcceptedFormats(key string, v []string) error {
+	data, err := json.Marshal(v)
+	if err != nil {
+		return err
+	}
+	return c.SetSetting(key, string(data))
+}
+
+func (c *Client) GetAcceptedVideoFormats() ([]string, error) {
+	res, err := c.getAcceptedFormats(SettingAcceptedVideoFormats)
+	if err != nil {
+		return nil, err
+	}
+	if res == nil {
+		return defaultAcceptedVideoFormats, nil
+	}
+	return res, nil
+}
+
+func (c *Client) SetAcceptedVideoFormats(key string, v []string) error {
+	return c.setAcceptedFormats(SettingAcceptedVideoFormats, v)
+}
+
+func (c *Client) GetAcceptedSubtitleFormats() ([]string, error) {
+	res, err := c.getAcceptedFormats(SettingAcceptedSubtitleFormats)
+	if err != nil {
+		return nil, err
+	}
+	if res == nil {
+		return defaultAcceptedSubtitleFormats, nil
+	}
+	return res, nil
+}
+
+func (c *Client) SetAcceptedSubtitleFormats(key string, v []string) error {
+	return c.setAcceptedFormats(SettingAcceptedSubtitleFormats, v)
+}
+
+func (c *Client) GetTmdbApiKey() string {
+	k := c.GetSetting(SettingTmdbApiKey)
+	if k == "" {
+		return DefaultTmdbApiKey
+	}
+	return k
+}

db/migrate.go

@@ -0,0 +1,46 @@
+package db
+
+import (
+	"context"
+	"encoding/json"
+	"polaris/log"
+
+	"github.com/pkg/errors"
+)
+
+func (c *Client) migrate() error {
+	// Run the auto migration tool.
+	if err := c.ent.Schema.Create(context.Background()); err != nil {
+		return errors.Wrap(err, "failed creating schema resources")
+	}
+
+	if err := c.migrateIndexerSetting(); err != nil {
+		return errors.Wrap(err, "migrate indexer setting")
+	}
+	return nil
+}
+
+func (c *Client) migrateIndexerSetting() error {
+	indexers := c.GetAllIndexers()
+	for _, in := range indexers {
+
+		if in.Settings == "" {
+			continue
+		}
+		if in.APIKey != "" && in.URL != "" {
+			continue
+		}
+		var setting TorznabSetting
+		err := json.Unmarshal([]byte(in.Settings), &setting)
+		if err != nil {
+			return err
+		}
+		in.APIKey = setting.ApiKey
+		in.URL = setting.URL
+		if err := c.SaveIndexer(in); err != nil {
+			return errors.Wrap(err, "save indexer")
+		}
+		log.Infof("success migrate indexer setting field: %s", in.Name)
+	}
+	return nil
+}

db/notification.go

@@ -73,6 +73,8 @@ func toNotificationClient(cl *ent.NotificationClient) (*NotificationClient, erro
 		settings = notifier.TelegramConfig{}
 	case "bark":
 		settings = notifier.BarkConfig{}
+	case "serverchan":
+		settings = notifier.ServerChanConfig{}
 	}
 	err := json.Unmarshal([]byte(cl.Settings), &settings)
 	if err != nil {

doc/alist.md

@@ -0,0 +1,13 @@
+# alist 对接
+
+> 本程序可以把alist作为一个存储后台使用，下载完成的电影电视剧上传到alist对应的文件夹。配合阿里云、夸克云盘等实现云盘NAS功能。目前支持两种对接方式，webdav和直接对接
+
+## webdav
+
+使用webdav形式对接本程序，支持程序所有功能，但是不支持秒传，上传会比较慢
+
+## alist 直接对接
+
+存储设置里选择 alist，填入对应的信息即可。
+
+优点：支持秒传，上传速度快。缺点：部分功能无法使用（plex和nfo文件刮削）

doc/configuration.md

@@ -2,44 +2,28 @@
 
 要正确使用此程序，需要配置好以下设置：
 
-### TMDB设置
+### 1. TMDB设置
+
 1. 因为此程序需要使用到 TMDB 的数据，使用此程序首先要申请一个 TMDB 的 Api Key. 申请教程请 google [tmdb api key申请](https://www.google.com/search?q=tmdb+api+key%E7%94%B3%E8%AF%B7)
 
 2. 拿到 TMDB Api Key之后，请填到 *设置 -> 常规设置 -> TMDB Api Key里*
 
-### 索引器
+**注意：** TMDB可能需要翻墙才能使用，参考 [TMDB 访问问题](./tmdb.md)
 
-索引器是资源提供者，目前支持 torznab 协议，意味着 polarr 或者 jackett 都可以支持。请自行部署相关程序，或者使用的 docker compose 配置一起拉起
+### 2. 索引器
 
-推荐使用 linuxserver 的镜像：https://docs.linuxserver.io/images/docker-jackett/
+使用配置页面索引器配置或者prowlarr设置，其中一个即可。
 
-#### 索引器配置
+#### jackett配置参考 [jackett](./jackett.md)
 
-索引器配置这里以 jackett 为例。使用默认 docker compose 配置拉起后以 http://< ip >:9117 可访问 jackett 的主页。
+#### prowlarr设置
 
-1. 打开 jackett 主页后，点击页面上面的 Add indexer，会出现 BT/PT 站点列表，选择你需要的站点点击+号添加。如果是PT，请自行配置好相关配置
-
-![add indexer](./assets/add_indexer.png)
-
-![search add](./assets/search_add.png)
-
-
-2. 添加后主页即会显示相应的BT/PT站点，点击 *Copy Torznab Feed* 即得到了我们需要的地址
-
-![copy feed](./assets/copy_feed.png)
-
-3. 回到我们的主程序 Polaris 当中，点击 *设置 -> 索引器设置* -> 点击+号增加新的索引器，输入一个名称，拷贝我们第2步得到的地址到地址栏
-
-![polaris add indexer](./assets/polaris_add_indexer.png)
-
-4. 选相框中我们可以看到，还需要一个 API Key，我们回到 Jackett 中，在页面右上角，复制我们需要的 API Key：
-![api key](./assets/jackett_api_key.png)
-
-5. 恭喜！你已经成功完成了索引器配置。如需要更多的站点，请重复相同的操作完成配置
+1) 取得prowlarr的url和api key， api key在 *Prowlarr 设置 -> 通用 -> API 密钥* 处取得
+2) 对应参数填到 polaris程序，*设置->prowlarr设置*当中
 
 ### 下载器
 
-资源下载器，目前可支持 tansmission，请配置好对应配置
+资源下载器，目前可支持 tansmission/qbittorrent，请配置好对应配置
 
 ![transmission](./assets/downloader.png)
 

doc/faq.md

@@ -0,0 +1,14 @@
+# FAQ
+
+## 1. Polaris 能否使用硬链接代替直接拷贝来节省空间？
+
+可以。
+
+使用本地存储时，默认使用硬链接移动文件，如果下载路径和媒体路径不在同一个挂载路径，硬链接会失败，然后会尝试使用拷贝的方式移动文件。
+
+基于这一点，我们只需要改造一下docker挂载路径，既可以实现硬链接功能。
+
+1. 媒体路径（e.g. /data）同时挂载到polaris和下载器容器，
+2. polaris *设置 -> 下载路径* 设为媒体路径下面的文件夹 （e.g. /data/downloads）
+
+然后Polaris就是使用硬连接，而非拷贝的方式

doc/jackett.md

@@ -0,0 +1,21 @@
+## jackett 索引器配置
+
+1. 打开 jackett 主页后，点击页面上面的 Add indexer，会出现 BT/PT 站点列表，选择你需要的站点点击+号添加。如果是PT，请自行配置好相关配置
+
+![add indexer](./assets/add_indexer.png)
+
+![search add](./assets/search_add.png)
+
+
+2. 添加后主页即会显示相应的BT/PT站点，点击 *Copy Torznab Feed* 即得到了我们需要的地址
+
+![copy feed](./assets/copy_feed.png)
+
+3. 回到我们的主程序 Polaris 当中，点击 *设置 -> 索引器设置* -> 点击+号增加新的索引器，输入一个名称，拷贝我们第2步得到的地址到地址栏
+
+![polaris add indexer](./assets/polaris_add_indexer.png)
+
+4. 选相框中我们可以看到，还需要一个 API Key，我们回到 Jackett 中，在页面右上角，复制我们需要的 API Key：
+![api key](./assets/jackett_api_key.png)
+
+5. 恭喜！你已经成功完成了索引器配置。如需要更多的站点，请重复相同的操作完成配置

doc/quick_start.md

@@ -1,8 +1,83 @@
-## 快速开始
+# 快速开始
 
-最简单部署 Polaris 的方式是使用 docker compose，Polaris要完整运行另外需要一个索引客户端和一个下载客户端。索引客户端支持 polarr 或 jackett，下载客户端目前只支持 transmission。
+## 1. 安装 Polaris
 
-下面是一个示例 docker-compose 配置，为了简单起见，一起拉起了 transmission 和 jackett，你也可选择单独安装
+### 1.1 Docker Compose 方式安装
+
+最简单使用本程序的方式是通过docker compose，下面内容保存成 docker-compose.yml，然后执行 docker compose up -d, 即可拉起程序。
+
+```yaml
+services:
+  polaris:
+    image: ghcr.io/simon-ding/polaris:latest 
+    restart: always
+    environment:
+      - PUID=99 #程序运行的用户UID
+      - PGID=100 #程序运行的用户GID
+      - TZ=Asia/Shanghai #时区
+    volumes:
+      - <配置文件路径>:/app/data #程序配置文件路径
+      - <下载路径>:/downloads #下载路径，需要和下载客户端配置一致
+      - <媒体文件路径>:/data #媒体数据存储路径，也可以启动自己配置webdav存储
+    ports:
+      - 8080:8080 #端口映射，冒号前的端口可自行改为需要的
+```
+
+> latest为发布版本，如果你追求新功能，且能接受bug，可以使用main tag
+
+### 1.2 Docker 方式安装
+
+也可以通过原始 docker 命令的方式安装 Polaris：
+
+```bash
+docker run -d \
+    -v <配置文件路径>:/app/data \
+    -v <下载路径>:/downloads \
+    -v <媒体文件路径>:/data \
+    -e PUID=99 \
+    -e PGID=100 \
+    -e TZ=Asia/Shanghai \
+    -p 8080:8080 \
+    --restart always \
+    ghcr.io/simon-ding/polaris:latest
+```
+
+### 1.3 Unraid 安装
+
+参考下图进行配置
+
+![](./assets/unraid.png)
+
+### 1.4 访问
+拉起之后访问 http://< ip >:8080 即可访问 Polaris 的主页：
+
+![](./assets/main_page.png)
+
+
+## 2. 安装下载客户端
+
+Polaris 需要下载客户端的配合使用，目前支持 Transmission 和 Qbittorrent。推荐使用linuxserver镜像进行安装
+
+ * [linuxserver/transmission](https://docs.linuxserver.io/images/docker-transmission)
+
+ * [linuxserver/qbittorrent](https://docs.linuxserver.io/images/docker-qbittorrent/)
+
+需要注意的是下载客户端内 /downloads 路径的映射地址要和 Polaris的/downloads路径映射保持一致。也就是说他俩都要映射到同一路径。
+
+## 3. 安装 Jackett/Prowlarr
+
+Polaris 如果要正常工作，还需要一个索引客户端的支持，目前支持jackett/prowlarr索引客户端。推荐使用prowlarr，设置更简单
+
+安装方式见：
+
+ * [linuxserver/jackett](https://docs.linuxserver.io/images/docker-jackett/)
+ * [linuxserver/prowlarr](https://docs.linuxserver.io/images/docker-prowlarr/)
+
+
+
+## 4. 联合安装
+
+如果觉得一个个安装麻烦，也可以使用下面docker compose文件，一键拉起所有组件
 
  **注意：** transmission 的下载路径映射要和 polaris 保持一致，如果您不知道怎么做，请保持默认设置。
 
@@ -11,6 +86,10 @@ services:
   polaris:
     image: ghcr.io/simon-ding/polaris:latest
     restart: always
+    environment:
+      - PUID=1000
+      - PGID=1000
+      - TZ=Asia/Shanghai
     volumes:
       - ./config/polaris:/app/data #程序配置文件路径
       - /downloads:/downloads #下载路径，需要和下载客户端配置一致
@@ -43,27 +122,18 @@ services:
     restart: unless-stopped
 ```
 
-拉起之后访问 http://< ip >:8080 的形式访问
+复制上面文件保存成 docker-compose.yml 文件，然后执行下面命令
+
+```bash
+docker compose up -d
+```
 
 
-![](./assets/main_page.png)
-
-## 配置
+## 5. 配置
 
 详细配置请看 [配置篇](./configuration.md)
 
 
-## 开始使用
-
-1. 完成配置之后，我们就可以在右上角的搜索按钮里输入我们想看的电影、电视剧。
-  ![search](./assets/search_series.png)
-
-2. 找到对应电影电视剧后，点击加入想看列表
-  ![add](./assets/add_series.png)
-
-3. 当电影有资源、或者电视剧有更新时，程序就会自动下载对应资源到指定的存储。对于剧集，您也可以进入剧集的详细页面，点击搜索按钮来自己搜索对应集的资源。
-
-
-到此，您已经基本掌握了此程序的使用方式，请尽情体验吧！
-
+## 6. FAQ
 
+- [常见问题 FAQ](./faq.md)

doc/tmdb.md

@@ -0,0 +1,6 @@
+# TMDB 访问问题
+
+由于国内特殊的网络环境，访问 tmdb 可能需要翻墙代理，有两种解决方案
+
+1. 设置路由器全局代理，openwrt等第三方路由固件可以实现这个功能
+2. 使用程序代理功能，*常规->代理地址* 中设置，格式如 http://192.168.0.10:1080

engine/client.go

@@ -0,0 +1,215 @@
+package engine
+
+import (
+	"polaris/db"
+	"polaris/ent"
+	"polaris/ent/downloadclients"
+	"polaris/log"
+	"polaris/pkg"
+	"polaris/pkg/buildin"
+	"polaris/pkg/qbittorrent"
+	"polaris/pkg/tmdb"
+	"polaris/pkg/transmission"
+	"polaris/pkg/utils"
+
+	"github.com/pkg/errors"
+	"github.com/robfig/cron"
+)
+
+func NewEngine(db *db.Client, language string) *Engine {
+	return &Engine{
+		db:       db,
+		cron:     cron.New(),
+		tasks:    utils.Map[int, *Task]{},
+		schedulers: utils.Map[string, scheduler]{},
+		language: language,
+	}
+}
+
+type scheduler struct {
+	cron string
+	f    func() error
+}
+type Engine struct {
+	db         *db.Client
+	cron       *cron.Cron
+	tasks      utils.Map[int, *Task]
+	language   string
+	schedulers utils.Map[string, scheduler]
+}
+
+func (c *Engine) registerCronJob(name string, cron string, f func() error) {
+	c.schedulers.Store(name, scheduler{
+		cron: cron,
+		f:    f,
+	})
+}
+
+func (c *Engine) Init() {
+	go c.reloadTasks()
+	c.addSysCron()
+	go c.checkW500PosterOnStartup()
+}
+
+func (c *Engine) reloadUsingBuildinDownloader(h *ent.History) error{
+	cl, err := buildin.NewDownloader(c.db.GetDownloadDir())
+	if err != nil {
+		log.Warnf("buildin downloader error: %v", err)
+	}
+	t, err := cl.Download(h.Link, h.Hash, c.db.GetDownloadDir())
+	if err != nil {
+		return errors.Wrap(err, "download torrent")
+	}
+	c.tasks.Store(h.ID,  &Task{Torrent: t})
+	return nil
+}
+
+func (c *Engine) reloadTasks() {
+	allTasks := c.db.GetRunningHistories()
+	for _, t := range allTasks {
+		if t.DownloadClientID == 0 {
+			log.Warnf("assume buildin downloader: %v", t.SourceTitle)
+			err := c.reloadUsingBuildinDownloader(t)
+			if err != nil {
+				log.Warnf("buildin downloader error: %v", err)
+			} else {
+				log.Infof("success reloading buildin task: %v", t.SourceTitle)
+			}
+			continue
+		}
+		dl, err := c.db.GetDownloadClient(t.DownloadClientID)
+		if err != nil {
+			log.Warnf("no download client related: %v", t.SourceTitle)
+			continue
+		}
+
+		if dl.Implementation == downloadclients.ImplementationTransmission {
+			if t.Hash != "" { //优先使用hash
+				to, err := transmission.NewTorrentHash(transmission.Config{
+					URL:      dl.URL,
+					User:     dl.User,
+					Password: dl.Password,
+				}, t.Hash)
+				if err != nil {
+					log.Warnf("get task error: %v", err)
+					continue
+				}
+				c.tasks.Store(t.ID, &Task{Torrent: to})
+			} else if t.Link != "" {
+				to, err := transmission.NewTorrent(transmission.Config{
+					URL:      dl.URL,
+					User:     dl.User,
+					Password: dl.Password,
+				}, t.Link)
+				if err != nil {
+					log.Warnf("get task error: %v", err)
+					continue
+				}
+				c.tasks.Store(t.ID, &Task{Torrent: to})
+			}
+		} else if dl.Implementation == downloadclients.ImplementationQbittorrent {
+			if t.Hash != "" {
+				to, err := qbittorrent.NewTorrentHash(qbittorrent.Info{
+					URL:      dl.URL,
+					User:     dl.User,
+					Password: dl.Password,
+				}, t.Hash)
+				if err != nil {
+					log.Warnf("get task error: %v", err)
+					continue
+				}
+				c.tasks.Store(t.ID, &Task{Torrent: to})
+
+			} else if t.Link != "" {
+				to, err := qbittorrent.NewTorrent(qbittorrent.Info{
+					URL:      dl.URL,
+					User:     dl.User,
+					Password: dl.Password,
+				}, t.Link)
+				if err != nil {
+					log.Warnf("get task error: %v", err)
+					continue
+				}
+				c.tasks.Store(t.ID, &Task{Torrent: to})
+			}
+		}
+
+	}
+	log.Infof("------ task reloading done ------")
+}
+
+func (c *Engine) buildInDownloader() (pkg.Downloader, error) {
+	dir := c.db.GetDownloadDir()
+	return buildin.NewDownloader(dir)
+}
+
+func (c *Engine) GetDownloadClient() (pkg.Downloader, *ent.DownloadClients, error) {
+	downloaders := c.db.GetAllDonloadClients()
+	for _, d := range downloaders {
+		if !d.Enable {
+			continue
+		}
+		if d.Implementation == downloadclients.ImplementationTransmission {
+			trc, err := transmission.NewClient(transmission.Config{
+				URL:      d.URL,
+				User:     d.User,
+				Password: d.Password,
+			})
+			if err != nil {
+				log.Warnf("connect to download client error: %v", d.URL)
+				continue
+			}
+			return trc, d, nil
+
+		} else if d.Implementation == downloadclients.ImplementationQbittorrent {
+			qbt, err := qbittorrent.NewClient(d.URL, d.User, d.Password)
+			if err != nil {
+				log.Warnf("connect to download client error: %v", d.URL)
+				continue
+			}
+			return qbt, d, nil
+		} else if d.Implementation == downloadclients.ImplementationBuildin {
+			bin, err := c.buildInDownloader()
+			if err != nil {
+				log.Warnf("connect to download client error: %v", d.URL)
+				continue
+			}
+			return bin, d, nil
+		}
+	}
+
+	return nil, nil, errors.Errorf("no available download client")
+}
+
+func (c *Engine) TMDB() (*tmdb.Client, error) {
+	api := c.db.GetTmdbApiKey()
+	if api == "" {
+		return nil, errors.New("TMDB apiKey not set")
+	}
+	proxy := c.db.GetSetting(db.SettingProxy)
+	adult := c.db.GetSetting(db.SettingEnableTmdbAdultContent)
+	return tmdb.NewClient(api, proxy, adult == "true")
+}
+
+func (c *Engine) MustTMDB() *tmdb.Client {
+	t, err := c.TMDB()
+	if err != nil {
+		log.Panicf("get tmdb: %v", err)
+	}
+	return t
+}
+
+func (c *Engine) RemoveTaskAndTorrent(id int) error {
+	torrent, ok := c.tasks.Load(id)
+	if ok {
+		if err := torrent.Remove(); err != nil {
+			return errors.Wrap(err, "remove torrent")
+		}
+		c.tasks.Delete(id)
+	}
+	return nil
+}
+
+func (c *Engine) GetTasks() utils.Map[int, *Task] {
+	return c.tasks
+}

engine/fliters.go

@@ -0,0 +1 @@
+package engine

engine/importlist.go

@@ -1,4 +1,4 @@
-package core
+package engine
 
 import (
 	"bytes"
@@ -10,11 +10,13 @@ import (
 	"path/filepath"
 	"polaris/db"
 	"polaris/ent"
+	"polaris/ent/episode"
 	"polaris/ent/importlist"
 	"polaris/ent/media"
 	"polaris/ent/schema"
 	"polaris/log"
 	"polaris/pkg/importlist/plexwatchlist"
+	"polaris/pkg/metadata"
 	"polaris/pkg/utils"
 	"regexp"
 	"strings"
@@ -23,7 +25,7 @@ import (
 	"github.com/pkg/errors"
 )
 
-func (c *Client) periodicallyUpdateImportlist() error {
+func (c *Engine) periodicallyUpdateImportlist() error {
 	log.Infof("begin check import list")
 	lists, err := c.db.GetAllImportLists()
 	if err != nil {
@@ -74,6 +76,7 @@ func (c *Client) periodicallyUpdateImportlist() error {
 					if err != nil {
 						log.Errorf("[update_import_lists] add movie to watchlist error: %v", err)
 					} else {
+						c.sendMsg(fmt.Sprintf("成功监控电影：%v", d.Title))
 						log.Infof("[update_import_lists] add movie to watchlist success")
 					}
 				} else if len(tmdbRes.TvResults) > 0 {
@@ -93,6 +96,7 @@ func (c *Client) periodicallyUpdateImportlist() error {
 					if err != nil {
 						log.Errorf("[update_import_lists] add tv to watchlist error: %v", err)
 					} else {
+						c.sendMsg(fmt.Sprintf("成功监控电视剧：%v", d.Name))
 						log.Infof("[update_import_lists] add tv to watchlist success")
 					}
 
@@ -110,11 +114,12 @@ type AddWatchlistIn struct {
 	Resolution              string `json:"resolution" binding:"required"`
 	Folder                  string `json:"folder" binding:"required"`
 	DownloadHistoryEpisodes bool   `json:"download_history_episodes"` //for tv
-	SizeMin                 int    `json:"size_min"`
-	SizeMax                 int    `json:"size_max"`
+	SizeMin                 int64  `json:"size_min"`
+	SizeMax                 int64  `json:"size_max"`
+	PreferSize              int64  `json:"prefer_size"`
 }
 
-func (c *Client) AddTv2Watchlist(in AddWatchlistIn) (interface{}, error) {
+func (c *Engine) AddTv2Watchlist(in AddWatchlistIn) (interface{}, error) {
 	log.Debugf("add tv watchlist input %+v", in)
 	if in.Folder == "" {
 		return nil, errors.New("folder should be provided")
@@ -135,7 +140,7 @@ func (c *Client) AddTv2Watchlist(in AddWatchlistIn) (interface{}, error) {
 	}
 	log.Infof("find detail for tv id %d: %+v", in.TmdbID, detail)
 
-	 lastSeason := 0
+	lastSeason := 0
 	for _, season := range detail.Seasons {
 		if season.SeasonNumber > lastSeason && season.EpisodeCount > 0 { //如果最新一季已经有剧集信息，则以最新一季为准
 			lastSeason = season.SeasonNumber
@@ -144,6 +149,11 @@ func (c *Client) AddTv2Watchlist(in AddWatchlistIn) (interface{}, error) {
 
 	log.Debugf("latest season is %v", lastSeason)
 
+	alterTitles, err := c.getAlterTitles(in.TmdbID, media.MediaTypeTv)
+	if err != nil {
+		return nil, errors.Wrap(err, "get alter titles")
+	}
+
 	var epIds []int
 	for _, season := range detail.Seasons {
 		seasonId := season.SeasonNumber
@@ -190,6 +200,7 @@ func (c *Client) AddTv2Watchlist(in AddWatchlistIn) (interface{}, error) {
 			epIds = append(epIds, epid)
 		}
 	}
+
 	m := &ent.Media{
 		TmdbID:                  int(detail.ID),
 		ImdbID:                  detail.IMDbID,
@@ -208,6 +219,7 @@ func (c *Client) AddTv2Watchlist(in AddWatchlistIn) (interface{}, error) {
 			OriginalLanguage: detail.OriginalLanguage,
 			Genres:           detail.Genres,
 		},
+		AlternativeTitles: alterTitles,
 	}
 
 	r, err := c.db.AddMediaWatchlist(m, epIds)
@@ -218,6 +230,10 @@ func (c *Client) AddTv2Watchlist(in AddWatchlistIn) (interface{}, error) {
 		if err := c.downloadPoster(detail.PosterPath, r.ID); err != nil {
 			log.Errorf("download poster error: %v", err)
 		}
+		if err := c.downloadW500Poster(detail.PosterPath, r.ID); err != nil {
+			log.Errorf("download w500 poster error: %v", err)
+		}
+
 		if err := c.downloadBackdrop(detail.BackdropPath, r.ID); err != nil {
 			log.Errorf("download poster error: %v", err)
 		}
@@ -231,7 +247,43 @@ func (c *Client) AddTv2Watchlist(in AddWatchlistIn) (interface{}, error) {
 	return nil, nil
 }
 
-func (c *Client) AddMovie2Watchlist(in AddWatchlistIn) (interface{}, error) {
+func (c *Engine) getAlterTitles(tmdbId int, mediaType media.MediaType) ([]schema.AlternativeTilte, error) {
+	var titles []schema.AlternativeTilte
+
+	if mediaType == media.MediaTypeTv {
+		alterTitles, err := c.MustTMDB().GetTVAlternativeTitles(tmdbId, c.language)
+		if err != nil {
+			return nil, errors.Wrap(err, "tmdb")
+		}
+
+		for _, t := range alterTitles.Results {
+			titles = append(titles, schema.AlternativeTilte{
+				Iso3166_1: t.Iso3166_1,
+				Title:     t.Title,
+				Type:      t.Type,
+			})
+		}
+
+	} else if mediaType == media.MediaTypeMovie {
+		alterTitles, err := c.MustTMDB().GetMovieAlternativeTitles(tmdbId, c.language)
+		if err != nil {
+			return nil, errors.Wrap(err, "tmdb")
+		}
+
+		for _, t := range alterTitles.Titles {
+			titles = append(titles, schema.AlternativeTilte{
+				Iso3166_1: t.Iso3166_1,
+				Title:     t.Title,
+				Type:      t.Type,
+			})
+		}
+	}
+	log.Debugf("get alternative titles: %+v", titles)
+
+	return titles, nil
+}
+
+func (c *Engine) AddMovie2Watchlist(in AddWatchlistIn) (interface{}, error) {
 	log.Infof("add movie watchlist input: %+v", in)
 	detailCn, err := c.MustTMDB().GetMovieDetails(in.TmdbID, db.LanguageCN)
 	if err != nil {
@@ -249,6 +301,11 @@ func (c *Client) AddMovie2Watchlist(in AddWatchlistIn) (interface{}, error) {
 	}
 	log.Infof("find detail for movie id %d: %v", in.TmdbID, detail)
 
+	alterTitles, err := c.getAlterTitles(in.TmdbID, media.MediaTypeMovie)
+	if err != nil {
+		return nil, errors.Wrap(err, "get alter titles")
+	}
+
 	epid, err := c.db.SaveEposideDetail(&ent.Episode{
 		SeasonNumber:  1,
 		EpisodeNumber: 1,
@@ -263,18 +320,19 @@ func (c *Client) AddMovie2Watchlist(in AddWatchlistIn) (interface{}, error) {
 	log.Infof("added dummy episode for movie: %v", nameEn)
 
 	movie := ent.Media{
-		TmdbID:       int(detail.ID),
-		ImdbID:       detail.IMDbID,
-		MediaType:    media.MediaTypeMovie,
-		NameCn:       nameCn,
-		NameEn:       nameEn,
-		OriginalName: detail.OriginalTitle,
-		Overview:     detail.Overview,
-		AirDate:      detail.ReleaseDate,
-		Resolution:   media.Resolution(in.Resolution),
-		StorageID:    in.StorageID,
-		TargetDir:    in.Folder,
-		Limiter:      schema.MediaLimiter{SizeMin: in.SizeMin, SizeMax: in.SizeMax},
+		TmdbID:            int(detail.ID),
+		ImdbID:            detail.IMDbID,
+		MediaType:         media.MediaTypeMovie,
+		NameCn:            nameCn,
+		NameEn:            nameEn,
+		OriginalName:      detail.OriginalTitle,
+		Overview:          detail.Overview,
+		AirDate:           detail.ReleaseDate,
+		Resolution:        media.Resolution(in.Resolution),
+		StorageID:         in.StorageID,
+		TargetDir:         in.Folder,
+		Limiter:           schema.MediaLimiter{SizeMin: in.SizeMin, SizeMax: in.SizeMax},
+		AlternativeTitles: alterTitles,
 	}
 
 	extras := schema.MediaExtras{
@@ -296,9 +354,16 @@ func (c *Client) AddMovie2Watchlist(in AddWatchlistIn) (interface{}, error) {
 		if err := c.downloadPoster(detail.PosterPath, r.ID); err != nil {
 			log.Errorf("download poster error: %v", err)
 		}
+		if err := c.downloadW500Poster(detail.PosterPath, r.ID); err != nil {
+			log.Errorf("download w500 poster error: %v", err)
+		}
+
 		if err := c.downloadBackdrop(detail.BackdropPath, r.ID); err != nil {
 			log.Errorf("download backdrop error: %v", err)
 		}
+		if err := c.checkMovieFolder(r); err != nil {
+			log.Warnf("check movie folder error: %v", err)
+		}
 	}()
 
 	log.Infof("add movie %s to watchlist success", detail.Title)
@@ -306,6 +371,33 @@ func (c *Client) AddMovie2Watchlist(in AddWatchlistIn) (interface{}, error) {
 
 }
 
+func (c *Engine) checkMovieFolder(m *ent.Media) error {
+	var storageImpl, err = c.GetStorage(m.StorageID, media.MediaTypeMovie)
+	if err != nil {
+		return err
+	}
+	files, err := storageImpl.ReadDir(m.TargetDir)
+	if err != nil {
+		return err
+	}
+	ep, err := c.db.GetMovieDummyEpisode(m.ID)
+	if err != nil {
+		return err
+	}
+
+	for _, f := range files {
+		if f.IsDir() || f.Size() < 100*1000*1000 /* 100M */ { //忽略路径和小于100M的文件
+			continue
+		}
+		meta := metadata.ParseMovie(f.Name())
+		if meta.IsAcceptable(m.NameCn) || meta.IsAcceptable(m.NameEn) {
+			log.Infof("found already downloaded movie: %v", f.Name())
+			c.db.SetEpisodeStatus(ep.ID, episode.StatusDownloaded)
+		}
+	}
+	return nil
+}
+
 func IsJav(detail *tmdb.MovieDetails) bool {
 	if detail.Adult && len(detail.ProductionCountries) > 0 && strings.ToUpper(detail.ProductionCountries[0].Iso3166_1) == "JP" {
 		return true
@@ -313,7 +405,7 @@ func IsJav(detail *tmdb.MovieDetails) bool {
 	return false
 }
 
-func (c *Client) GetJavid(id int) string {
+func (c *Engine) GetJavid(id int) string {
 	alters, err := c.MustTMDB().GetMovieAlternativeTitles(id, c.language)
 	if err != nil {
 		return ""
@@ -326,18 +418,23 @@ func (c *Client) GetJavid(id int) string {
 	return ""
 }
 
-func (c *Client) downloadBackdrop(path string, mediaID int) error {
+func (c *Engine) downloadBackdrop(path string, mediaID int) error {
 	url := "https://image.tmdb.org/t/p/original" + path
 	return c.downloadImage(url, mediaID, "backdrop.jpg")
 }
 
-func (c *Client) downloadPoster(path string, mediaID int) error {
+func (c *Engine) downloadPoster(path string, mediaID int) error {
 	var url = "https://image.tmdb.org/t/p/original" + path
 
 	return c.downloadImage(url, mediaID, "poster.jpg")
 }
 
-func (c *Client) downloadImage(url string, mediaID int, name string) error {
+func (c *Engine) downloadW500Poster(path string, mediaID int) error {
+	url := "https://image.tmdb.org/t/p/w500" + path
+	return c.downloadImage(url, mediaID, "poster_w500.jpg")
+}
+
+func (c *Engine) downloadImage(url string, mediaID int, name string) error {
 
 	log.Infof("try to download image: %v", url)
 	var resp, err = http.Get(url)
@@ -362,7 +459,47 @@ func (c *Client) downloadImage(url string, mediaID int, name string) error {
 
 }
 
-func (c *Client) SuggestedMovieFolderName(tmdbId int) (string, error) {
+func (c *Engine) checkW500PosterOnStartup() {
+	log.Infof("check all w500 posters")
+	all := c.db.GetMediaWatchlist(media.MediaTypeTv)
+	movies := c.db.GetMediaWatchlist(media.MediaTypeMovie)
+	all = append(all, movies...)
+	for _, e := range all {
+		targetFile := filepath.Join(fmt.Sprintf("%v/%d", db.ImgPath, e.ID), "poster_w500.jpg")
+		if _, err := os.Stat(targetFile); err != nil {
+			log.Infof("poster_w500.jpg not exist for %s, will download it", e.NameEn)
+
+			if e.MediaType == media.MediaTypeTv {
+				detail, err := c.MustTMDB().GetTvDetails(e.TmdbID, db.LanguageCN)
+				if err != nil {
+					log.Warnf("get tmdb detail for %s error: %v", e.NameEn, err)
+					continue
+				}
+
+				if err := c.downloadW500Poster(detail.PosterPath, e.ID); err != nil {
+					log.Warnf("download w500 poster error: %v", err)
+					continue
+				}
+
+			} else {
+				detail, err := c.MustTMDB().GetMovieDetails(e.TmdbID, db.LanguageCN)
+				if err != nil {
+					log.Warnf("get tmdb detail for %s error: %v", e.NameEn, err)
+					continue
+				}
+
+				if err := c.downloadW500Poster(detail.PosterPath, e.ID); err != nil {
+					log.Warnf("download w500 poster error: %v", err)
+					continue
+				}
+
+			}
+
+		}
+	}
+}
+
+func (c *Engine) SuggestedMovieFolderName(tmdbId int) (string, error) {
 
 	d1, err := c.MustTMDB().GetMovieDetails(tmdbId, c.language)
 	if err != nil {
@@ -407,7 +544,7 @@ func (c *Client) SuggestedMovieFolderName(tmdbId int) (string, error) {
 	return res, nil
 }
 
-func (c *Client) SuggestedSeriesFolderName(tmdbId int) (string, error) {
+func (c *Engine) SuggestedSeriesFolderName(tmdbId int) (string, error) {
 
 	d, err := c.MustTMDB().GetTvDetails(tmdbId, c.language)
 	if err != nil {

engine/indexer.go

@@ -0,0 +1,79 @@
+package engine
+
+import (
+	"polaris/ent"
+	"polaris/log"
+	"polaris/pkg/prowlarr"
+	"strings"
+
+	"github.com/pkg/errors"
+)
+
+const prowlarrPrefix = "Prowlarr_"
+
+func (c *Engine) SyncProwlarrIndexers(apiKey, url string) error {
+	client := prowlarr.New(apiKey, url)
+	if ins, err := client.GetIndexers(); err != nil {
+		return errors.Wrap(err, "connect to prowlarr error")
+	} else {
+		var prowlarrNames = make(map[string]bool, len(ins))
+		for _, in := range ins {
+			prowlarrNames[in.Name] = true
+		}
+		all := c.db.GetAllIndexers()
+		for _, index := range all {
+
+			if index.Synced {
+				if !prowlarrNames[strings.TrimPrefix(index.Name, prowlarrPrefix)] {
+					c.db.DeleteIndexer(index.ID) //remove deleted indexers
+				}
+			}
+		}
+
+		for _, indexer := range ins {
+			if err := c.db.SaveIndexer(&ent.Indexers{
+				Disabled:  indexer.Disabled,
+				Name:      prowlarrPrefix + indexer.Name,
+				Priority:  indexer.Priority,
+				SeedRatio: indexer.SeedRatio,
+				//Settings:       indexer.Settings,
+				Implementation: "torznab",
+				APIKey:         indexer.APIKey,
+				URL:            indexer.URL,
+				TvSearch:       indexer.TvSearch,
+				MovieSearch:    indexer.MovieSearch,
+				Synced:         true,
+			}); err != nil {
+				return errors.Wrap(err, "save prowlarr indexers")
+			}
+			log.Debugf("synced prowlarr indexer to db: %v", indexer.Name)
+		}
+	}
+	return nil
+}
+
+func (c *Engine) syncProwlarr() error {
+	p, err := c.db.GetProwlarrSetting()
+	if err != nil {
+		return errors.Wrap(err, "db")
+	}
+	if p.Disabled {
+		return nil
+	}
+	if err := c.SyncProwlarrIndexers(p.ApiKey, p.URL); err != nil {
+		return errors.Wrap(err, "sync prowlarr indexers")
+	}
+
+	return nil
+}
+
+func (c *Engine) DeleteAllProwlarrIndexers() error {
+	all := c.db.GetAllIndexers()
+	for _, index := range all {
+		if index.Synced {
+			c.db.DeleteIndexer(index.ID)
+			log.Debugf("success delete prowlarr indexer: %s", index.Name)
+		}
+	}
+	return nil
+}

engine/integration.go

@@ -1,26 +1,27 @@
-package core
+package engine
 
 import (
 	"bytes"
 	"encoding/xml"
 	"fmt"
-	"github.com/pkg/errors"
-	"os"
+	"io/fs"
 	"path/filepath"
 	"polaris/db"
 	"polaris/ent/media"
 	storage1 "polaris/ent/storage"
 	"polaris/log"
+	"polaris/pkg/alist"
 	"polaris/pkg/metadata"
 	"polaris/pkg/notifier"
 	"polaris/pkg/storage"
-	"polaris/pkg/utils"
 	"slices"
 	"strconv"
 	"strings"
+
+	"github.com/pkg/errors"
 )
 
-func (c *Client) writeNfoFile(historyId int) error {
+func (c *Engine) writeNfoFile(historyId int) error {
 	if !c.nfoSupportEnabled() {
 		return nil
 	}
@@ -33,7 +34,7 @@ func (c *Client) writeNfoFile(historyId int) error {
 	}
 
 	if md.MediaType == media.MediaTypeTv { //tvshow.nfo
-		st, err := c.getStorage(md.StorageID, media.MediaTypeTv)
+		st, err := c.GetStorage(md.StorageID, media.MediaTypeTv)
 		if err != nil {
 			return errors.Wrap(err, "get storage")
 		}
@@ -64,11 +65,11 @@ func (c *Client) writeNfoFile(historyId int) error {
 			if err != nil {
 				return errors.Wrap(err, "xml marshal")
 			}
-			return st.WriteFile(nfoPath, data)
+			return st.WriteFile(nfoPath, []byte(xml.Header+string(data)))
 		}
 
 	} else if md.MediaType == media.MediaTypeMovie { //movie.nfo
-		st, err := c.getStorage(md.StorageID, media.MediaTypeMovie)
+		st, err := c.GetStorage(md.StorageID, media.MediaTypeMovie)
 		if err != nil {
 			return errors.Wrap(err, "get storage")
 		}
@@ -99,13 +100,13 @@ func (c *Client) writeNfoFile(historyId int) error {
 			if err != nil {
 				return errors.Wrap(err, "xml marshal")
 			}
-			return st.WriteFile(nfoPath, data)
+			return st.WriteFile(nfoPath, []byte(xml.Header+string(data)))
 		}
 	}
 	return nil
 }
 
-func (c *Client) writePlexmatch(historyId int) error {
+func (c *Engine) writePlexmatch(historyId int) error {
 
 	if !c.plexmatchEnabled() {
 		return nil
@@ -120,7 +121,7 @@ func (c *Client) writePlexmatch(historyId int) error {
 	if series.MediaType != media.MediaTypeTv { //.plexmatch only support tv series
 		return nil
 	}
-	st, err := c.getStorage(series.StorageID, media.MediaTypeTv)
+	st, err := c.GetStorage(series.StorageID, media.MediaTypeTv)
 	if err != nil {
 		return errors.Wrap(err, "get storage")
 	}
@@ -148,64 +149,53 @@ func (c *Client) writePlexmatch(historyId int) error {
 	} else {
 		buff.Write(data)
 	}
+	episodesIds := c.GetEpisodeIds(his)
 
-	if his.EpisodeID > 0 {
-		//single episode download
-		ep, err := c.db.GetEpisodeByID(his.EpisodeID)
+	for _, id := range episodesIds {
+		ep, err := c.db.GetEpisodeByID(id)
 		if err != nil {
-			return errors.Wrap(err, "query episode")
+			log.Warnf("query episode: %v", err)
+			continue
 		}
 		if strings.Contains(buff.String(), ep.TargetFile) {
 			log.Debugf("already write plex episode line: %v", ep.TargetFile)
 			return nil
 		}
 		buff.WriteString(fmt.Sprintf("\nep: %d: %s\n", ep.EpisodeNumber, ep.TargetFile))
-	} else {
-		seasonNum, err := utils.SeasonId(his.TargetDir)
-		if err != nil {
-			return errors.Wrap(err, "no season id")
-		}
-		allEpisodes, err := c.db.GetSeasonEpisodes(his.MediaID, seasonNum)
-		if err != nil {
-			return errors.Wrap(err, "query season episode")
-		}
-		for _, ep := range allEpisodes {
-			if ep.TargetFile == "" {
-				log.Errorf("no episode file of episode %d, season %d", ep.EpisodeNumber, ep.SeasonNumber)
-				//TODO update db
-				continue
-			}
-			if strings.Contains(buff.String(), ep.TargetFile) {
-				log.Debugf("already write plex episode line: %v", ep.TargetFile)
-				continue
-			}
-			buff.WriteString(fmt.Sprintf("\nep: %d: %s\n", ep.EpisodeNumber, ep.TargetFile))
-		}
 
 	}
+
 	log.Infof("write season plexmatch file content: %s", buff.String())
 	return st.WriteFile(seasonPlex, buff.Bytes())
 }
 
-func (c *Client) plexmatchEnabled() bool {
+func (c *Engine) plexmatchEnabled() bool {
 	return c.db.GetSetting(db.SettingPlexMatchEnabled) == "true"
 }
 
-func (c *Client) nfoSupportEnabled() bool {
+func (c *Engine) nfoSupportEnabled() bool {
 	return c.db.GetSetting(db.SettingNfoSupportEnabled) == "true"
 }
 
-func (c *Client) getStorage(storageId int, mediaType media.MediaType) (storage.Storage, error) {
+func (c *Engine) GetStorage(storageId int, mediaType media.MediaType) (storage.Storage, error) {
 	st := c.db.GetStorage(storageId)
 	targetPath := st.TvPath
 	if mediaType == media.MediaTypeMovie {
 		targetPath = st.MoviePath
 	}
+	videoFormats, err := c.db.GetAcceptedVideoFormats()
+	if err != nil {
+		log.Warnf("get accepted video format error: %v", err)
+	}
+	subtitleFormats, err := c.db.GetAcceptedSubtitleFormats()
+	if err != nil {
+		log.Warnf("get accepted subtitle format error: %v", err)
+	}
 
 	switch st.Implementation {
 	case storage1.ImplementationLocal:
 
-		storageImpl1, err := storage.NewLocalStorage(targetPath)
+		storageImpl1, err := storage.NewLocalStorage(targetPath, videoFormats, subtitleFormats)
 		if err != nil {
 			return nil, errors.Wrap(err, "new local")
 		}
@@ -213,16 +203,23 @@ func (c *Client) getStorage(storageId int, mediaType media.MediaType) (storage.S
 
 	case storage1.ImplementationWebdav:
 		ws := st.ToWebDavSetting()
-		storageImpl1, err := storage.NewWebdavStorage(ws.URL, ws.User, ws.Password, targetPath, ws.ChangeFileHash == "true")
+		storageImpl1, err := storage.NewWebdavStorage(ws.URL, ws.User, ws.Password, targetPath, ws.ChangeFileHash == "true", videoFormats, subtitleFormats)
 		if err != nil {
 			return nil, errors.Wrap(err, "new webdav")
 		}
 		return storageImpl1, nil
+	case storage1.ImplementationAlist:
+		cfg := st.ToWebDavSetting()
+		storageImpl1, err := storage.NewAlist(&alist.Config{URL: cfg.URL, Username: cfg.User, Password: cfg.Password}, targetPath, videoFormats, subtitleFormats)
+		if err != nil {
+			return nil, errors.Wrap(err, "alist")
+		}
+		return storageImpl1, nil
 	}
 	return nil, errors.New("no storage found")
 }
 
-func (c *Client) sendMsg(msg string) {
+func (c *Engine) sendMsg(msg string) {
 	clients, err := c.db.GetAllNotificationClients2()
 	if err != nil {
 		log.Errorf("query notification clients: %v", err)
@@ -251,66 +248,36 @@ func (c *Client) sendMsg(msg string) {
 	}
 }
 
-func (c *Client) findEpisodeFilesPreMoving(historyId int) error {
+func (c *Engine) findEpisodeFilesPreMoving(historyId int) error {
 	his := c.db.GetHistory(historyId)
 
-	isSingleEpisode := his.EpisodeID > 0
-	downloadDir := c.db.GetDownloadDir()
-	task := c.tasks[historyId]
-	name, err := task.Name()
+	episodeIds := c.GetEpisodeIds(his)
+
+	task, _ := c.tasks.Load(historyId)
+
+	ff, err := c.db.GetAcceptedVideoFormats()
 	if err != nil {
 		return err
 	}
-	target := filepath.Join(downloadDir, name)
-	fi, err := os.Stat(target)
-	if err != nil {
-		return errors.Wrapf(err, "read dir %v", target)
-	}
-	if isSingleEpisode {
-		if fi.IsDir() {
-			//download single episode in dir
-			//TODO
-		} else {
-			//is file
-			if err := c.db.UpdateEpisodeTargetFile(his.EpisodeID, fi.Name()); err != nil {
-				log.Errorf("writing downloaded file name to db error: %v", err)
+	for _, id := range episodeIds {
+		ep, _ := c.db.GetEpisode(his.MediaID, his.SeasonNum, id)
+		task.WalkFunc()(func(path string, info fs.FileInfo) error {
+			if info.IsDir() {
+				return nil
 			}
-		}
-	} else {
-		if !fi.IsDir() {
-			return fmt.Errorf("not season pack downloaded")
-		}
-		seasonNum, err := utils.SeasonId(his.TargetDir)
-		if err != nil {
-			return errors.Wrap(err, "no season id")
-		}
-
-		files, err := os.ReadDir(target)
-		if err != nil {
-			return err
-		}
-		for _, f := range files {
-			if f.IsDir() { //want media file
-				continue
+			ext := filepath.Ext(info.Name())
+			if slices.Contains(ff, ext) {
+				return nil
 			}
-			excludedExt := []string{".txt", ".srt", ".ass", ".sub"}
-			ext := filepath.Ext(f.Name())
-			if slices.Contains(excludedExt, strings.ToLower(ext)) {
-				continue
-			}
-
-			meta := metadata.ParseTv(f.Name())
-			if meta.Episode > 0 {
-				//episode exists
-				ep, err := c.db.GetEpisode(his.MediaID, seasonNum, meta.Episode)
-				if err != nil {
-					return err
-				}
-				if err := c.db.UpdateEpisodeTargetFile(ep.ID, f.Name()); err != nil {
-					return errors.Wrap(err, "update episode file")
+			meta := metadata.ParseTv(info.Name())
+			if meta.StartEpisode == meta.EndEpisode && meta.StartEpisode == ep.EpisodeNumber {
+				if err := c.db.UpdateEpisodeTargetFile(id, info.Name()); err != nil {
+					log.Errorf("writing downloaded file name to db error: %v", err)
 				}
+
 			}
-		}
+			return nil
+		})
 	}
 	return nil
 }

engine/nfo.go

@@ -1,4 +1,4 @@
-package core
+package engine
 
 import "encoding/xml"
 

engine/resources.go

@@ -0,0 +1,210 @@
+package engine
+
+import (
+	"bytes"
+	"fmt"
+	"polaris/ent"
+	"polaris/ent/episode"
+	"polaris/ent/history"
+	"polaris/ent/media"
+	"polaris/log"
+	"polaris/pkg/metadata"
+	"polaris/pkg/notifier/message"
+	"polaris/pkg/torznab"
+	"polaris/pkg/utils"
+
+	"github.com/pkg/errors"
+)
+
+func (c *Engine) DownloadEpisodeTorrent(r1 torznab.Result, seriesId, seasonNum int, episodeNums ...int) (*string, error) {
+
+	series, err := c.db.GetMedia(seriesId)
+	if err != nil {
+		return nil, fmt.Errorf("no tv series of id %v", seriesId)
+	}
+
+	return c.downloadTorrent(series, r1, seasonNum, episodeNums...)
+}
+
+/*
+tmdb 校验获取的资源名，如果用资源名在tmdb搜索出来的结果能匹配上想要的资源，则认为资源有效，否则无效
+解决名称过于简单的影视会匹配过多资源的问题， 例如：梦魇绝镇 FROM
+*/
+func (c *Engine) checkBtReourceWithTmdb(r *torznab.Result, seriesId int) bool {
+	m := metadata.ParseTv(r.Name)
+	se, err := c.MustTMDB().SearchMedia(m.NameEn, "", 1)
+	if err != nil {
+		log.Warnf("tmdb search error, consider this torrent ok: %v", err)
+		return true
+	} else {
+		if len(se.Results) == 0 {
+			log.Debugf("tmdb search no result, consider this torrent ok: %s", r.Name) //because tv name parse is not accurate
+			return true
+		}
+		series, err := c.db.GetMediaDetails(seriesId)
+		if err != nil {
+			log.Warnf("get media details error: %v", err)
+			return false
+		}
+
+		se0 := se.Results[0]
+		if se0.ID != int64(series.TmdbID) {
+			log.Warnf("bt reosurce name not match tmdb id: %s", r.Name)
+			return false
+		} else { //resource tmdb id match
+			return true
+		}
+	}
+}
+
+func (c *Engine) SearchAndDownload(seriesId, seasonNum int, episodeNums ...int) ([]string, error) {
+
+	res, err := SearchTvSeries(c.db, &SearchParam{
+		MediaId:         seriesId,
+		SeasonNum:       seasonNum,
+		Episodes:        episodeNums,
+		CheckFileSize:   true,
+		CheckResolution: true,
+	})
+	if err != nil {
+		return nil, err
+	}
+	wanted := make(map[int]bool, len(episodeNums))
+	for _, ep := range episodeNums {
+		wanted[ep] = true
+	}
+	var torrentNames []string
+lo:
+	for _, r := range res {
+		if !c.checkBtReourceWithTmdb(&r, seriesId) {
+			continue
+		}
+		m := metadata.ParseTv(r.Name)
+		m.ParseExtraDescription(r.Description)
+		if len(episodeNums) == 0 { //want season pack
+			if m.IsSeasonPack {
+				name, err := c.DownloadEpisodeTorrent(r, seriesId, seasonNum)
+				if err != nil {
+					return nil, err
+				}
+				torrentNames = append(torrentNames, *name)
+				break lo
+			}
+		} else {
+			torrentEpisodes := make([]int, 0)
+			for i := m.StartEpisode; i <= m.EndEpisode; i++ {
+				if !wanted[i] { //torrent has episode not wanted
+					continue lo
+				}
+				torrentEpisodes = append(torrentEpisodes, i)
+			}
+			name, err := c.DownloadEpisodeTorrent(r, seriesId, seasonNum, torrentEpisodes...)
+			if err != nil {
+				return nil, err
+			}
+			torrentNames = append(torrentNames, *name)
+
+			for _, num := range torrentEpisodes {
+				delete(wanted, num) //delete downloaded episode from wanted
+			}
+		}
+	}
+	if len(wanted) > 0 {
+		log.Warnf("still wanted but not downloaded episodes: %v", wanted)
+	}
+	return torrentNames, nil
+}
+
+func (c *Engine) DownloadMovie(m *ent.Media, r1 torznab.Result) (*string, error) {
+	return c.downloadTorrent(m, r1, 0)
+}
+
+func (c *Engine) downloadTorrent(m *ent.Media, r1 torznab.Result, seasonNum int, episodeNums ...int) (*string, error) {
+	trc, dlc, err := c.GetDownloadClient()
+	if err != nil {
+		return nil, errors.Wrap(err, "get download client")
+	}
+
+	downloadDir := c.db.GetDownloadDir()
+	
+	//due to reported bug by user, this will be temporarily disabled
+	// size := utils.AvailableSpace(downloadDir)
+	// if size < uint64(r1.Size) {
+	// 	log.Errorf("space available %v, space needed %v", size, r1.Size)
+	// 	return nil, errors.New("not enough space")
+	// }
+
+	var name = r1.Name
+	var targetDir = m.TargetDir
+	if m.MediaType == media.MediaTypeTv { //tv download
+		targetDir = fmt.Sprintf("%s/Season %02d/", m.TargetDir, seasonNum)
+
+		if len(episodeNums) > 0 {
+			for _, epNum := range episodeNums {
+				ep, err := c.db.GetEpisode(m.ID, seasonNum, epNum)
+				if err != nil {
+					return nil, errors.Errorf("no episode of season %d episode %d", seasonNum, epNum)
+
+				}
+				if ep.Status == episode.StatusMissing {
+					c.db.SetEpisodeStatus(ep.ID, episode.StatusDownloading)
+				}
+			}
+			buff := &bytes.Buffer{}
+			for i, ep := range episodeNums {
+				if i != 0 {
+					buff.WriteString(",")
+
+				}
+				buff.WriteString(fmt.Sprint(ep))
+			}
+			name = fmt.Sprintf("第%s集 (%s)", buff.String(), name)
+
+		} else { //season package download
+			name = fmt.Sprintf("全集 (%s)", name)
+			c.db.SetSeasonAllEpisodeStatus(m.ID, seasonNum, episode.StatusDownloading)
+		}
+
+	} else {
+		ep, _ := c.db.GetMovieDummyEpisode(m.ID)
+		if ep.Status == episode.StatusMissing {
+			c.db.SetEpisodeStatus(ep.ID, episode.StatusDownloading)
+		}
+
+	}
+	hash, err := utils.Link2Hash(r1.Link)
+	if err != nil {
+		return nil, errors.Wrap(err, "get hash")
+	}
+	history, err := c.db.SaveHistoryRecord(ent.History{
+		MediaID:     m.ID,
+		EpisodeNums: episodeNums,
+		SeasonNum:   seasonNum,
+		SourceTitle: r1.Name,
+		TargetDir:   targetDir,
+		Status:      history.StatusRunning,
+		Size:        int(r1.Size),
+		//Saved:            torrent.Save(),
+		Link:             r1.Link,
+		Hash:             hash,
+		DownloadClientID: dlc.ID,
+		IndexerID:        r1.IndexerId,
+	})
+	if err != nil {
+		return nil, errors.Wrap(err, "save record")
+	}
+
+	torrent, err := trc.Download(r1.Link, hash, downloadDir)
+	if err != nil {
+		return nil, errors.Wrap(err, "downloading")
+	}
+	torrent.Start()
+
+	c.tasks.Store(history.ID, &Task{Torrent: torrent})
+
+	c.sendMsg(fmt.Sprintf(message.BeginDownload, name))
+
+	log.Infof("success add %s to download task", r1.Name)
+
+	return &r1.Name, nil
+}

engine/scheduler.go

@@ -1,7 +1,8 @@
-package core
+package engine
 
 import (
 	"fmt"
+	"os"
 	"path/filepath"
 	"polaris/db"
 	"polaris/ent"
@@ -12,13 +13,21 @@ import (
 	"polaris/pkg"
 	"polaris/pkg/notifier/message"
 	"polaris/pkg/utils"
+	"time"
 
 	"github.com/pkg/errors"
 )
 
-func (c *Client) addSysCron() {
+func (c *Engine) addSysCron() {
 	c.registerCronJob("check_running_tasks", "@every 1m", c.checkTasks)
 	c.registerCronJob("check_available_medias_to_download", "0 0 * * * *", func() error {
+		v := os.Getenv("POLARIS_NO_AUTO_DOWNLOAD")
+		if v == "true" {
+			return nil
+		}
+		if err := c.syncProwlarr(); err != nil {
+			log.Warnf("sync prowlarr error: %v", err)
+		}
 		c.downloadAllTvSeries()
 		c.downloadAllMovies()
 		return nil
@@ -36,16 +45,17 @@ func (c *Client) addSysCron() {
 		return true
 	})
 	c.cron.Start()
+	log.Infof("--------- add cron jobs done --------")
 }
 
-func (c *Client) mustAddCron(spec string, cmd func()) {
+func (c *Engine) mustAddCron(spec string, cmd func()) {
 	if err := c.cron.AddFunc(spec, cmd); err != nil {
 		log.Errorf("add func error: %v", err)
 		panic(err)
 	}
 }
 
-func (c *Client) TriggerCronJob(name string) error {
+func (c *Engine) TriggerCronJob(name string) error {
 	job, ok := c.schedulers.Load(name)
 	if !ok {
 		return fmt.Errorf("job name not exists: %s", name)
@@ -53,51 +63,119 @@ func (c *Client) TriggerCronJob(name string) error {
 	return job.f()
 }
 
-func (c *Client) checkTasks() error {
+func (c *Engine) checkTasks() error {
 	log.Debug("begin check tasks...")
-	for id, t := range c.tasks {
+	c.tasks.Range(func(id int, t *Task) bool {
 		r := c.db.GetHistory(id)
 		if !t.Exists() {
 			log.Infof("task no longer exists: %v", id)
 
-			delete(c.tasks, id)
-			continue
+			c.tasks.Delete(id)
+			return true
 		}
 		name, err := t.Name()
 		if err != nil {
-			return errors.Wrap(err, "get name")
+			log.Warnf("get task name error: %v", err)
+			return true
 		}
 
 		progress, err := t.Progress()
 		if err != nil {
-			return errors.Wrap(err, "get progress")
+			log.Warnf("get task progress error: %v", err)
+			return true
 		}
 		log.Infof("task (%s) percentage done: %d%%", name, progress)
 		if progress == 100 {
 
 			if r.Status == history.StatusSeeding {
 				//task already success, check seed ratio
-				torrent := c.tasks[id]
+				torrent, _ := c.tasks.Load(id)
 				ratio, ok := c.isSeedRatioLimitReached(r.IndexerID, torrent)
 				if ok {
 					log.Infof("torrent file seed ratio reached, remove: %v, current seed ratio: %v", name, ratio)
 					torrent.Remove()
-					delete(c.tasks, id)
+					c.tasks.Delete(id)
+					c.setHistoryStatus(id, history.StatusSuccess)
 				} else {
 					log.Infof("torrent file still sedding: %v, current seed ratio: %v", name, ratio)
 				}
-				continue
+				return true
+			} else if r.Status == history.StatusRunning {
+				log.Infof("task is done: %v", name)
+				c.sendMsg(fmt.Sprintf(message.DownloadComplete, name))
+				go c.postTaskProcessing(id)
 			}
-			log.Infof("task is done: %v", name)
-			c.sendMsg(fmt.Sprintf(message.DownloadComplete, name))
-
-			go c.postTaskProcessing(id)
 		}
-	}
+
+		return true
+	})
 	return nil
 }
 
-func (c *Client) postTaskProcessing(id int) {
+/*
+episode 状态有3种：missing、downloading、downloaded
+
+history状态有5种：running, success, fail, uploading, seeding
+
+没有下载的剧集状态都是missing，已下载完成的都是downloaded，正在下载的是downloading
+
+对应的history状态，下载任务创建成功，正常跑着是running，出了问题失败了，就是fail，下载完成的任务会先进入uploading状态进一步处理，
+uploading状态下会传输到对应的存储里面，uploading成功如果需要做种会进入seeding状态，如果不做种进入success状态，失败了会进入fail状态
+
+seeding状态中，会定时检查做种状态，达到指定分享率，会置为success
+
+任务创建成功，episode状态会由missing置为downloading，如果任务失败重新置为missing，如果任务成功进入success或seeding，episode状态应置为downloaded
+
+*/
+
+func (c *Engine) setHistoryStatus(id int, status history.Status) {
+	r := c.db.GetHistory(id)
+
+	episodeIds := c.GetEpisodeIds(r)
+
+	switch status {
+	case history.StatusRunning:
+		c.db.SetHistoryStatus(id, history.StatusRunning)
+		c.setEpsideoStatus(episodeIds, episode.StatusDownloading)
+	case history.StatusSuccess:
+		c.db.SetHistoryStatus(id, history.StatusSuccess)
+		c.setEpsideoStatus(episodeIds, episode.StatusDownloaded)
+
+	case history.StatusUploading:
+		c.db.SetHistoryStatus(id, history.StatusUploading)
+
+	case history.StatusSeeding:
+		c.db.SetHistoryStatus(id, history.StatusSeeding)
+		c.setEpsideoStatus(episodeIds, episode.StatusDownloaded)
+
+	case history.StatusFail:
+		c.db.SetHistoryStatus(id, history.StatusFail)
+		c.setEpsideoStatus(episodeIds, episode.StatusMissing)
+	default:
+		panic(fmt.Sprintf("unkown status %v", status))
+	}
+}
+
+func (c *Engine) setEpsideoStatus(episodeIds []int, status episode.Status) error {
+	for _, id := range episodeIds {
+		ep, err := c.db.GetEpisodeByID(id)
+		if err != nil {
+			return err
+		}
+		if ep.Status == episode.StatusDownloaded {
+			//已经下载完成的任务，不再重新设置状态
+			continue
+		}
+
+		if err := c.db.SetEpisodeStatus(id, status); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (c *Engine) postTaskProcessing(id int) {
 	if err := c.findEpisodeFilesPreMoving(id); err != nil {
 		log.Errorf("finding all episode file error: %v", err)
 	} else {
@@ -113,19 +191,60 @@ func (c *Client) postTaskProcessing(id int) {
 	}
 }
 
-func (c *Client) moveCompletedTask(id int) (err1 error) {
-	torrent := c.tasks[id]
-	r := c.db.GetHistory(id)
-	if r.Status == history.StatusUploading {
-		log.Infof("task %d is already uploading, skip", id)
-		return nil
+func getSeasonNum(h *ent.History) int {
+	if h.SeasonNum != 0 {
+		return h.SeasonNum
 	}
-	c.db.SetHistoryStatus(r.ID, history.StatusUploading)
-	seasonNum, err := utils.SeasonId(r.TargetDir)
+	seasonNum, err := utils.SeasonId(h.TargetDir)
 	if err != nil {
-		log.Errorf("no season id: %v", r.TargetDir)
+		log.Errorf("no season id: %v", h.TargetDir)
 		seasonNum = -1
 	}
+	return seasonNum
+}
+
+func (c *Engine) GetEpisodeIds(r *ent.History) []int {
+	var episodeIds []int
+	seasonNum := getSeasonNum(r)
+
+	// if r.EpisodeID > 0 {
+	// 	episodeIds = append(episodeIds, r.EpisodeID)
+	// }
+	series, err := c.db.GetMediaDetails(r.MediaID)
+	if err != nil {
+		log.Errorf("get media details error: %v", err)
+		return []int{}
+	}
+
+	if len(r.EpisodeNums) > 0 {
+		for _, epNum := range r.EpisodeNums {
+			for _, ep := range series.Episodes {
+				if ep.SeasonNumber == seasonNum && ep.EpisodeNumber == epNum {
+					episodeIds = append(episodeIds, ep.ID)
+				}
+			}
+		}
+	} else {
+		for _, ep := range series.Episodes {
+			if ep.SeasonNumber == seasonNum {
+				episodeIds = append(episodeIds, ep.ID)
+			}
+		}
+
+	}
+	return episodeIds
+}
+
+func (c *Engine) moveCompletedTask(id int) (err1 error) {
+	torrent, _ := c.tasks.Load(id)
+	r := c.db.GetHistory(id)
+	// if r.Status == history.StatusUploading {
+	// 	log.Infof("task %d is already uploading, skip", id)
+	// 	return nil
+	// }
+
+	c.setHistoryStatus(r.ID, history.StatusUploading)
+
 	downloadclient, err := c.db.GetDownloadClient(r.DownloadClientID)
 	if err != nil {
 		log.Errorf("get task download client error: %v, use default one", err)
@@ -139,67 +258,59 @@ func (c *Client) moveCompletedTask(id int) (err1 error) {
 	defer func() {
 
 		if err1 != nil {
-			c.db.SetHistoryStatus(r.ID, history.StatusFail)
-			if r.EpisodeID != 0 {
-				if !c.db.IsEpisodeDownloadingOrDownloaded(r.EpisodeID) {
-					c.db.SetEpisodeStatus(r.EpisodeID, episode.StatusMissing)
-				}
-			} else {
-				c.db.SetSeasonAllEpisodeStatus(r.MediaID, seasonNum, episode.StatusMissing)
-			}
+			c.setHistoryStatus(r.ID, history.StatusFail)
 			c.sendMsg(fmt.Sprintf(message.ProcessingFailed, err1))
 			if downloadclient.RemoveFailedDownloads {
 				log.Debugf("task failed, remove failed torrent and files related")
-				delete(c.tasks, r.ID)
+				c.tasks.Delete(r.ID)
 				torrent.Remove()
 			}
 		}
 	}()
 
-	series := c.db.GetMediaDetails(r.MediaID)
-	if series == nil {
-		return nil
+	series, err := c.db.GetMediaDetails(r.MediaID)
+	if err != nil {
+		return err
 	}
+
 	st := c.db.GetStorage(series.StorageID)
 	log.Infof("move task files to target dir: %v", r.TargetDir)
-	stImpl, err := c.getStorage(st.ID, series.MediaType)
+	stImpl, err := c.GetStorage(st.ID, series.MediaType)
 	if err != nil {
 		return err
 	}
 
 	//如果种子是路径，则会把路径展开，只移动文件，类似 move dir/* dir2/, 如果种子是文件，则会直接移动文件，类似 move file dir/
-	if err := stImpl.Copy(filepath.Join(c.db.GetDownloadDir(), torrentName), r.TargetDir); err != nil {
+	if err := stImpl.Copy(filepath.Join(c.db.GetDownloadDir(), torrentName), r.TargetDir, torrent.WalkFunc()); err != nil {
 		return errors.Wrap(err, "move file")
 	}
+	torrent.UploadProgresser = stImpl.UploadProgress
 
-	c.db.SetHistoryStatus(r.ID, history.StatusSeeding)
-	if r.EpisodeID != 0 {
-		c.db.SetEpisodeStatus(r.EpisodeID, episode.StatusDownloaded)
-	} else {
-		c.db.SetSeasonAllEpisodeStatus(r.MediaID, seasonNum, episode.StatusDownloaded)
-	}
 	c.sendMsg(fmt.Sprintf(message.ProcessingComplete, torrentName))
 
-	//判断是否需要删除本地文件
+	//判断是否需要删除本地文件, TODO prowlarr has no indexer id
 	r1, ok := c.isSeedRatioLimitReached(r.IndexerID, torrent)
 	if downloadclient.RemoveCompletedDownloads && ok {
 		log.Debugf("download complete,remove torrent and files related, torrent: %v, seed ratio: %v", torrentName, r1)
-		c.db.SetHistoryStatus(r.ID, history.StatusSuccess)
-		delete(c.tasks, r.ID)
+		c.setHistoryStatus(r.ID, history.StatusSuccess)
+		c.tasks.Delete(r.ID)
 		torrent.Remove()
+	} else {
+		log.Infof("task complete but still needs seeding: %v", torrentName)
+		c.setHistoryStatus(r.ID, history.StatusSeeding)
 	}
 
 	log.Infof("move downloaded files to target dir success, file: %v, target dir: %v", torrentName, r.TargetDir)
 	return nil
 }
 
-func (c *Client) CheckDownloadedSeriesFiles(m *ent.Media) error {
+func (c *Engine) CheckDownloadedSeriesFiles(m *ent.Media) error {
 	if m.MediaType != media.MediaTypeTv {
 		return nil
 	}
 	log.Infof("check files in directory: %s", m.TargetDir)
 
-	var storageImpl, err = c.getStorage(m.StorageID, media.MediaTypeTv)
+	var storageImpl, err = c.GetStorage(m.StorageID, media.MediaTypeTv)
 	if err != nil {
 		return err
 	}
@@ -247,10 +358,15 @@ func (c *Client) CheckDownloadedSeriesFiles(m *ent.Media) error {
 type Task struct {
 	//Processing bool
 	pkg.Torrent
+	UploadProgresser func() float64
 }
 
-func (c *Client) DownloadSeriesAllEpisodes(id int) []string {
-	tvDetail := c.db.GetMediaDetails(id)
+func (c *Engine) DownloadSeriesAllEpisodes(id int) []string {
+	tvDetail, err := c.db.GetMediaDetails(id)
+	if err != nil {
+		log.Errorf("get media details error: %v", err)
+		return nil
+	}
 	m := make(map[int][]*ent.Episode)
 	for _, ep := range tvDetail.Episodes {
 		m[ep.SeasonNumber] = append(m[ep.SeasonNumber], ep)
@@ -261,40 +377,53 @@ func (c *Client) DownloadSeriesAllEpisodes(id int) []string {
 			continue
 		}
 		wantedSeasonPack := true
+		seasonEpisodesWanted := make(map[int][]int, 0)
 		for _, ep := range epsides {
 			if !ep.Monitored {
 				wantedSeasonPack = false
+				continue
 			}
 			if ep.Status != episode.StatusMissing {
 				wantedSeasonPack = false
+				continue
 			}
+			if ep.AirDate != "" {
+				t, err := time.Parse("2006-01-02", ep.AirDate)
+				if err != nil {
+					continue
+				}
+				/*
+				 -------- now ------ t -----
+				 t - 1day < now 要检测的剧集
+				 提前一天开始检测
+				*/
+				if time.Now().Before(t.Add(-24 * time.Hour)) { //not aired
+					wantedSeasonPack = false
+					continue
+				}
+			}
+			seasonEpisodesWanted[ep.SeasonNumber] = append(seasonEpisodesWanted[ep.SeasonNumber], ep.EpisodeNumber)
 		}
 		if wantedSeasonPack {
-			name, err := c.SearchAndDownload(id, seasonNum, -1)
+			names, err := c.SearchAndDownload(id, seasonNum)
 			if err == nil {
-				allNames = append(allNames, *name)
-				log.Infof("begin download torrent resource: %v", name)
+				allNames = append(allNames, names...)
+				log.Infof("begin download torrent resource: %v", names)
 			} else {
 				log.Warnf("finding season pack error: %v", err)
 				wantedSeasonPack = false
 			}
-
 		}
 		if !wantedSeasonPack {
-			for _, ep := range epsides {
-				if !ep.Monitored {
-					continue
-				}
-				if ep.Status != episode.StatusMissing {
-					continue
-				}
-				name, err := c.SearchAndDownload(id, ep.SeasonNumber, ep.EpisodeNumber)
+
+			for se, eps := range seasonEpisodesWanted {
+				names, err := c.SearchAndDownload(id, se, eps...)
 				if err != nil {
-					log.Warnf("finding resoruces of season %d episode %d error: %v", ep.SeasonNumber, ep.EpisodeNumber, err)
+					log.Warnf("finding resoruces of season %d episode %v error: %v", se, eps, err)
 					continue
 				} else {
-					allNames = append(allNames, *name)
-					log.Infof("begin download torrent resource: %v", name)
+					allNames = append(allNames, names...)
+					log.Infof("begin download torrent resource: %v", names)
 				}
 			}
 
@@ -304,7 +433,7 @@ func (c *Client) DownloadSeriesAllEpisodes(id int) []string {
 	return allNames
 }
 
-func (c *Client) downloadAllTvSeries() {
+func (c *Engine) downloadAllTvSeries() {
 	log.Infof("begin check all tv series resources")
 	allSeries := c.db.GetMediaWatchlist(media.MediaTypeTv)
 	for _, series := range allSeries {
@@ -312,7 +441,7 @@ func (c *Client) downloadAllTvSeries() {
 	}
 }
 
-func (c *Client) downloadAllMovies() {
+func (c *Engine) downloadAllMovies() {
 	log.Infof("begin check all movie resources")
 	allSeries := c.db.GetMediaWatchlist(media.MediaTypeMovie)
 
@@ -323,8 +452,11 @@ func (c *Client) downloadAllMovies() {
 	}
 }
 
-func (c *Client) DownloadMovieByID(id int) (string, error) {
-	detail := c.db.GetMediaDetails(id)
+func (c *Engine) DownloadMovieByID(id int) (string, error) {
+	detail, err := c.db.GetMediaDetails(id)
+	if err != nil {
+		return "", errors.Wrap(err, "get media details")
+	}
 	if len(detail.Episodes) == 0 {
 		return "", fmt.Errorf("no related dummy episode: %v", detail.NameEn)
 	}
@@ -333,18 +465,15 @@ func (c *Client) DownloadMovieByID(id int) (string, error) {
 		return "", nil
 	}
 
-	if name, err := c.downloadMovieSingleEpisode(ep, detail.TargetDir); err != nil {
+	if name, err := c.downloadMovieSingleEpisode(detail.Media, ep); err != nil {
 		return "", errors.Wrap(err, "download movie")
 	} else {
 		return name, nil
 	}
 }
 
-func (c *Client) downloadMovieSingleEpisode(ep *ent.Episode, targetDir string) (string, error) {
-	trc, dlc, err := c.getDownloadClient()
-	if err != nil {
-		return "", errors.Wrap(err, "connect transmission")
-	}
+func (c *Engine) downloadMovieSingleEpisode(m *ent.Media, ep *ent.Episode) (string, error) {
+
 	qiangban := c.db.GetSetting(db.SettingAllowQiangban)
 	allowQiangban := false
 	if qiangban == "true" {
@@ -358,39 +487,19 @@ func (c *Client) downloadMovieSingleEpisode(ep *ent.Episode, targetDir string) (
 		FilterQiangban:  !allowQiangban,
 	})
 	if err != nil {
-
 		return "", errors.Wrap(err, "search movie")
 	}
 	r1 := res[0]
 	log.Infof("begin download torrent resource: %v", r1.Name)
-	torrent, err := trc.Download(r1.Link, c.db.GetDownloadDir())
+
+	s, err := c.downloadTorrent(m, r1, 0)
 	if err != nil {
-		return "", errors.Wrap(err, "downloading")
+		return "", err
 	}
-	torrent.Start()
-
-	history, err := c.db.SaveHistoryRecord(ent.History{
-		MediaID:          ep.MediaID,
-		EpisodeID:        ep.ID,
-		SourceTitle:      r1.Name,
-		TargetDir:        targetDir,
-		Status:           history.StatusRunning,
-		Size:             r1.Size,
-		Saved:            torrent.Save(),
-		DownloadClientID: dlc.ID,
-		IndexerID:        r1.IndexerId,
-	})
-	if err != nil {
-		log.Errorf("save history error: %v", err)
-	}
-
-	c.tasks[history.ID] = &Task{Torrent: torrent}
-
-	c.db.SetEpisodeStatus(ep.ID, episode.StatusDownloading)
-	return r1.Name, nil
+	return *s, nil
 }
 
-func (c *Client) checkAllSeriesNewSeason() error {
+func (c *Engine) checkAllSeriesNewSeason() error {
 	log.Infof("begin checking series all new season")
 	allSeries := c.db.GetMediaWatchlist(media.MediaTypeTv)
 	for _, series := range allSeries {
@@ -402,7 +511,7 @@ func (c *Client) checkAllSeriesNewSeason() error {
 	return nil
 }
 
-func (c *Client) checkSeiesNewSeason(media *ent.Media) error {
+func (c *Engine) checkSeiesNewSeason(media *ent.Media) error {
 	d, err := c.MustTMDB().GetTvDetails(media.TmdbID, c.language)
 	if err != nil {
 		return errors.Wrap(err, "tmdb")
@@ -440,7 +549,7 @@ func (c *Client) checkSeiesNewSeason(media *ent.Media) error {
 	return nil
 }
 
-func (c *Client) isSeedRatioLimitReached(indexId int, t pkg.Torrent)(float64,bool)  {
+func (c *Engine) isSeedRatioLimitReached(indexId int, t pkg.Torrent) (float64, bool) {
 	indexer, err := c.db.GetIndexer(indexId)
 	if err != nil {
 		return 0, true

engine/torrent.go

@@ -1,13 +1,13 @@
-package core
+package engine
 
 import (
 	"fmt"
 	"polaris/db"
+	"polaris/ent"
 	"polaris/ent/media"
 	"polaris/log"
 	"polaris/pkg/metadata"
 	"polaris/pkg/torznab"
-	"regexp"
 	"slices"
 	"sort"
 	"strconv"
@@ -26,28 +26,80 @@ type SearchParam struct {
 	FilterQiangban  bool //for movie, 是否过滤枪版电影
 }
 
+func names2Query(media *ent.Media) []string {
+	var names = []string{media.NameEn}
+
+	if media.NameCn != "" {
+		hasName := false
+		for _, n := range names {
+			if media.NameCn == n {
+				hasName = true
+			}
+		}
+		if !hasName {
+			names = append(names, media.NameCn)
+		}
+
+	}
+	if media.OriginalName != "" {
+		hasName := false
+		for _, n := range names {
+			if media.OriginalName == n {
+				hasName = true
+			}
+		}
+		if !hasName {
+			names = append(names, media.OriginalName)
+		}
+
+	}
+
+	for _, t := range media.AlternativeTitles {
+		if (t.Iso3166_1 == "CN" || t.Iso3166_1 == "US") && t.Type == "" {
+			hasName := false
+			for _, n := range names {
+				if t.Title == n {
+					hasName = true
+				}
+			}
+			if !hasName {
+				names = append(names, t.Title)
+			}
+		}
+	}
+	log.Debugf("name to query %+v", names)
+	return names
+}
+
 func SearchTvSeries(db1 *db.Client, param *SearchParam) ([]torznab.Result, error) {
-	series := db1.GetMediaDetails(param.MediaId)
-	if series == nil {
-		return nil, fmt.Errorf("no tv series of id %v", param.MediaId)
+	series, err := db1.GetMediaDetails(param.MediaId)
+	if err != nil {
+		return nil, fmt.Errorf("no tv series of id %v: %v", param.MediaId, err)
+	}
+	limiter, err := db1.GetSizeLimiter("tv")
+	if err != nil {
+		log.Warnf("get tv size limiter: %v", err)
+		limiter = &db.MediaSizeLimiter{}
 	}
 	log.Debugf("check tv series %s, season %d, episode %v", series.NameEn, param.SeasonNum, param.Episodes)
 
-	res := searchWithTorznab(db1, series.NameEn, series.NameCn, series.OriginalName)
+	names := names2Query(series.Media)
+
+	res := searchWithTorznab(db1, SearchTypeTv, names...)
 
 	var filtered []torznab.Result
+lo:
 	for _, r := range res {
 		//log.Infof("torrent resource: %+v", r)
 		meta := metadata.ParseTv(r.Name)
-		if meta == nil { //cannot parse name
-			continue
-		}
+		meta.ParseExtraDescription(r.Description)
+
 		if isImdbidNotMatch(series.ImdbID, r.ImdbId) { //has imdb id and not match
 			continue
 		}
 
 		if !imdbIDMatchExact(series.ImdbID, r.ImdbId) { //imdb id not exact match, check file name
-			if !torrentNameOk(series, r.Name) {
+			if !torrentNameOk(series, meta) {
 				continue
 			}
 		}
@@ -61,17 +113,26 @@ func SearchTvSeries(db1 *db.Client, param *SearchParam) ([]torznab.Result, error
 			continue
 		}
 
-		if len(param.Episodes) > 0 && !slices.Contains(param.Episodes, meta.Episode) { //not season pack, but episode number not equal
-			continue
-
+		if len(param.Episodes) > 0 { //not season pack, but episode number not equal
+			if meta.StartEpisode <= 0 {
+				continue lo
+			}
+			for i := meta.StartEpisode; i <= meta.EndEpisode; i++ {
+				if !slices.Contains(param.Episodes, i) {
+					continue lo
+				}
+			}
 		} else if len(param.Episodes) == 0 && !meta.IsSeasonPack { //want season pack, but not season pack
 			continue
 		}
-		if param.CheckResolution && meta.Resolution != series.Resolution.String() {
+
+		if param.CheckResolution &&
+			series.Resolution != media.ResolutionAny &&
+			meta.Resolution != series.Resolution.String() {
 			continue
 		}
 
-		if !torrentSizeOk(series, r.Size, param) {
+		if !torrentSizeOk(series, limiter, r.Size, meta.EndEpisode+1-meta.StartEpisode, param) {
 			continue
 		}
 
@@ -105,22 +166,42 @@ func imdbIDMatchExact(id1, id2 string) bool {
 	return id1 == id2
 }
 
-func torrentSizeOk(detail *db.MediaDetails, torrentSize int, param *SearchParam) bool {
-	if param.CheckFileSize {
-		multiplier := 1                                                        //大小倍数，正常为1，如果是季包则为季内集数
-		if detail.MediaType == media.MediaTypeTv && len(param.Episodes) == 0 { //tv season pack
+func torrentSizeOk(detail *db.MediaDetails, globalLimiter *db.MediaSizeLimiter, torrentSize int64,
+	torrentEpisodeNum int, param *SearchParam) bool {
+
+	multiplier := 1 //大小倍数，正常为1，如果是季包则为季内集数
+	if detail.MediaType == media.MediaTypeTv {
+		if len(param.Episodes) == 0 { //want tv season pack
 			multiplier = seasonEpisodeCount(detail, param.SeasonNum)
+		} else {
+			multiplier = torrentEpisodeNum
 		}
+	}
+
+	if param.CheckFileSize { //check file size when trigger automatic download
 
 		if detail.Limiter.SizeMin > 0 { //min size
-			sizeMin := detail.Limiter.SizeMin * multiplier
-			if torrentSize < sizeMin { //比最小要求的大小还要小
+			sizeMin := detail.Limiter.SizeMin * int64(multiplier)
+			if torrentSize < sizeMin { //比最小要求的大小还要小, min size not qualify
+				return false
+			}
+		} else if globalLimiter != nil {
+			resLimiter := globalLimiter.GetLimiter(detail.Resolution)
+			sizeMin := resLimiter.MinSize * int64(multiplier)
+			if torrentSize < sizeMin { //比最小要求的大小还要小, min size not qualify
 				return false
 			}
 		}
+
 		if detail.Limiter.SizeMax > 0 { //max size
-			sizeMax := detail.Limiter.SizeMax * multiplier
-			if torrentSize > sizeMax { //larger than max size wanted
+			sizeMax := detail.Limiter.SizeMax * int64(multiplier)
+			if torrentSize > sizeMax { //larger than max size wanted, max size not qualify
+				return false
+			}
+		} else if globalLimiter != nil {
+			resLimiter := globalLimiter.GetLimiter(detail.Resolution)
+			sizeMax := resLimiter.MaxSIze * int64(multiplier)
+			if torrentSize > sizeMax { //larger than max size wanted, max size not qualify
 				return false
 			}
 		}
@@ -154,14 +235,21 @@ func isNoSeasonSeries(detail *db.MediaDetails) bool {
 }
 
 func SearchMovie(db1 *db.Client, param *SearchParam) ([]torznab.Result, error) {
-	movieDetail := db1.GetMediaDetails(param.MediaId)
-	if movieDetail == nil {
-		return nil, errors.New("no media found of id")
+	movieDetail, err := db1.GetMediaDetails(param.MediaId)
+	if err != nil {
+		return nil, err
 	}
 
-	res := searchWithTorznab(db1, movieDetail.NameEn, movieDetail.NameCn, movieDetail.OriginalName)
-	if movieDetail.Extras.IsJav(){
-		res1 := searchWithTorznab(db1, movieDetail.Extras.JavId)
+	limiter, err := db1.GetSizeLimiter("movie")
+	if err != nil {
+		log.Warnf("get tv size limiter: %v", err)
+		limiter = &db.MediaSizeLimiter{}
+	}
+	names := names2Query(movieDetail.Media)
+
+	res := searchWithTorznab(db1, SearchTypeMovie, names...)
+	if movieDetail.Extras.IsJav() {
+		res1 := searchWithTorznab(db1, SearchTypeMovie, movieDetail.Extras.JavId)
 		res = append(res, res1...)
 	}
 
@@ -177,7 +265,7 @@ func SearchMovie(db1 *db.Client, param *SearchParam) ([]torznab.Result, error) {
 		}
 
 		if !imdbIDMatchExact(movieDetail.ImdbID, r.ImdbId) {
-			if !torrentNameOk(movieDetail, r.Name) {
+			if !torrentNameOk(movieDetail, meta) {
 				continue
 			}
 			if !movieDetail.Extras.IsJav() {
@@ -189,7 +277,9 @@ func SearchMovie(db1 *db.Client, param *SearchParam) ([]torznab.Result, error) {
 			}
 		}
 
-		if param.CheckResolution && meta.Resolution != movieDetail.Resolution.String() {
+		if param.CheckResolution &&
+			movieDetail.Resolution != media.ResolutionAny &&
+			meta.Resolution != movieDetail.Resolution.String() {
 			continue
 		}
 
@@ -197,7 +287,7 @@ func SearchMovie(db1 *db.Client, param *SearchParam) ([]torznab.Result, error) {
 			continue
 		}
 
-		if !torrentSizeOk(movieDetail, r.Size, param) {
+		if !torrentSizeOk(movieDetail, limiter, r.Size, 1, param) {
 			continue
 		}
 
@@ -213,10 +303,18 @@ func SearchMovie(db1 *db.Client, param *SearchParam) ([]torznab.Result, error) {
 
 }
 
-func searchWithTorznab(db *db.Client, queries ...string) []torznab.Result {
+type SearchType int
+
+const (
+	SearchTypeTv    SearchType = 1
+	SearchTypeMovie SearchType = 2
+)
+
+func searchWithTorznab(db *db.Client, t SearchType, queries ...string) []torznab.Result {
 
 	var res []torznab.Result
-	allTorznab := db.GetAllTorznabInfo()
+	allTorznab := db.GetAllIndexers()
+
 	resChan := make(chan []torznab.Result)
 	var wg sync.WaitGroup
 
@@ -224,6 +322,13 @@ func searchWithTorznab(db *db.Client, queries ...string) []torznab.Result {
 		if tor.Disabled {
 			continue
 		}
+		if t == SearchTypeTv && !tor.TvSearch {
+			continue
+		}
+		if t == SearchTypeMovie && !tor.MovieSearch {
+			continue
+		}
+
 		for _, q := range queries {
 			wg.Add(1)
 
@@ -300,19 +405,15 @@ func dedup(list []torznab.Result) []torznab.Result {
 	return res
 }
 
-func torrentNameOk(detail *db.MediaDetails, torrentName string) bool {
-	if detail.Extras.IsJav() && isNameAcceptable(torrentName, detail.Extras.JavId) {
-		return true
-	}
-	return isNameAcceptable(torrentName, detail.NameCn) || isNameAcceptable(torrentName, detail.NameEn) ||
-		isNameAcceptable(torrentName, detail.OriginalName)
+type NameTester interface {
+	IsAcceptable(names ...string) bool
 }
 
-func isNameAcceptable(torrentName, wantedName string) bool {
-	re := regexp.MustCompile(`[^\p{L}\w\s]`)
-	torrentName = re.ReplaceAllString(strings.ToLower(torrentName), " ")
-	wantedName = re.ReplaceAllString(strings.ToLower(wantedName), " ")
-	torrentName = strings.Join(strings.Fields(torrentName), " ")
-	wantedName = strings.Join(strings.Fields(wantedName), " ")
-	return strings.Contains(torrentName, wantedName)
+func torrentNameOk(detail *db.MediaDetails, tester NameTester) bool {
+	if detail.Extras.IsJav() && tester.IsAcceptable(detail.Extras.JavId) {
+		return true
+	}
+	names := names2Query(detail.Media)
+
+	return tester.IsAcceptable(names...)
 }

ent/blacklist.go

@@ -3,34 +3,40 @@
 package ent
 
 import (
+	"encoding/json"
 	"fmt"
-	"polaris/ent/blocklist"
+	"polaris/ent/blacklist"
+	"polaris/ent/schema"
 	"strings"
 
 	"entgo.io/ent"
 	"entgo.io/ent/dialect/sql"
 )
 
-// Blocklist is the model entity for the Blocklist schema.
-type Blocklist struct {
+// Blacklist is the model entity for the Blacklist schema.
+type Blacklist struct {
 	config `json:"-"`
 	// ID of the ent.
 	ID int `json:"id,omitempty"`
 	// Type holds the value of the "type" field.
-	Type blocklist.Type `json:"type,omitempty"`
+	Type blacklist.Type `json:"type,omitempty"`
 	// Value holds the value of the "value" field.
-	Value        string `json:"value,omitempty"`
+	Value schema.BlacklistValue `json:"value,omitempty"`
+	// Notes holds the value of the "notes" field.
+	Notes        string `json:"notes,omitempty"`
 	selectValues sql.SelectValues
 }
 
 // scanValues returns the types for scanning values from sql.Rows.
-func (*Blocklist) scanValues(columns []string) ([]any, error) {
+func (*Blacklist) scanValues(columns []string) ([]any, error) {
 	values := make([]any, len(columns))
 	for i := range columns {
 		switch columns[i] {
-		case blocklist.FieldID:
+		case blacklist.FieldValue:
+			values[i] = new([]byte)
+		case blacklist.FieldID:
 			values[i] = new(sql.NullInt64)
-		case blocklist.FieldType, blocklist.FieldValue:
+		case blacklist.FieldType, blacklist.FieldNotes:
 			values[i] = new(sql.NullString)
 		default:
 			values[i] = new(sql.UnknownType)
@@ -40,30 +46,38 @@ func (*Blocklist) scanValues(columns []string) ([]any, error) {
 }
 
 // assignValues assigns the values that were returned from sql.Rows (after scanning)
-// to the Blocklist fields.
-func (b *Blocklist) assignValues(columns []string, values []any) error {
+// to the Blacklist fields.
+func (b *Blacklist) 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 blocklist.FieldID:
+		case blacklist.FieldID:
 			value, ok := values[i].(*sql.NullInt64)
 			if !ok {
 				return fmt.Errorf("unexpected type %T for field id", value)
 			}
 			b.ID = int(value.Int64)
-		case blocklist.FieldType:
+		case blacklist.FieldType:
 			if value, ok := values[i].(*sql.NullString); !ok {
 				return fmt.Errorf("unexpected type %T for field type", values[i])
 			} else if value.Valid {
-				b.Type = blocklist.Type(value.String)
+				b.Type = blacklist.Type(value.String)
 			}
-		case blocklist.FieldValue:
-			if value, ok := values[i].(*sql.NullString); !ok {
+		case blacklist.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, &b.Value); err != nil {
+					return fmt.Errorf("unmarshal field value: %w", err)
+				}
+			}
+		case blacklist.FieldNotes:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field notes", values[i])
 			} else if value.Valid {
-				b.Value = value.String
+				b.Notes = value.String
 			}
 		default:
 			b.selectValues.Set(columns[i], values[i])
@@ -72,43 +86,46 @@ func (b *Blocklist) assignValues(columns []string, values []any) error {
 	return nil
 }
 
-// GetValue returns the ent.Value that was dynamically selected and assigned to the Blocklist.
+// GetValue returns the ent.Value that was dynamically selected and assigned to the Blacklist.
 // This includes values selected through modifiers, order, etc.
-func (b *Blocklist) GetValue(name string) (ent.Value, error) {
+func (b *Blacklist) GetValue(name string) (ent.Value, error) {
 	return b.selectValues.Get(name)
 }
 
-// Update returns a builder for updating this Blocklist.
-// Note that you need to call Blocklist.Unwrap() before calling this method if this Blocklist
+// Update returns a builder for updating this Blacklist.
+// Note that you need to call Blacklist.Unwrap() before calling this method if this Blacklist
 // was returned from a transaction, and the transaction was committed or rolled back.
-func (b *Blocklist) Update() *BlocklistUpdateOne {
-	return NewBlocklistClient(b.config).UpdateOne(b)
+func (b *Blacklist) Update() *BlacklistUpdateOne {
+	return NewBlacklistClient(b.config).UpdateOne(b)
 }
 
-// Unwrap unwraps the Blocklist entity that was returned from a transaction after it was closed,
+// Unwrap unwraps the Blacklist 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 (b *Blocklist) Unwrap() *Blocklist {
+func (b *Blacklist) Unwrap() *Blacklist {
 	_tx, ok := b.config.driver.(*txDriver)
 	if !ok {
-		panic("ent: Blocklist is not a transactional entity")
+		panic("ent: Blacklist is not a transactional entity")
 	}
 	b.config.driver = _tx.drv
 	return b
 }
 
 // String implements the fmt.Stringer.
-func (b *Blocklist) String() string {
+func (b *Blacklist) String() string {
 	var builder strings.Builder
-	builder.WriteString("Blocklist(")
+	builder.WriteString("Blacklist(")
 	builder.WriteString(fmt.Sprintf("id=%v, ", b.ID))
 	builder.WriteString("type=")
 	builder.WriteString(fmt.Sprintf("%v", b.Type))
 	builder.WriteString(", ")
 	builder.WriteString("value=")
-	builder.WriteString(b.Value)
+	builder.WriteString(fmt.Sprintf("%v", b.Value))
+	builder.WriteString(", ")
+	builder.WriteString("notes=")
+	builder.WriteString(b.Notes)
 	builder.WriteByte(')')
 	return builder.String()
 }
 
-// Blocklists is a parsable slice of Blocklist.
-type Blocklists []*Blocklist
+// Blacklists is a parsable slice of Blacklist.
+type Blacklists []*Blacklist

ent/blacklist/blacklist.go

@@ -1,31 +1,35 @@
 // Code generated by ent, DO NOT EDIT.
 
-package blocklist
+package blacklist
 
 import (
 	"fmt"
+	"polaris/ent/schema"
 
 	"entgo.io/ent/dialect/sql"
 )
 
 const (
-	// Label holds the string label denoting the blocklist type in the database.
-	Label = "blocklist"
+	// Label holds the string label denoting the blacklist type in the database.
+	Label = "blacklist"
 	// FieldID holds the string denoting the id field in the database.
 	FieldID = "id"
 	// FieldType holds the string denoting the type field in the database.
 	FieldType = "type"
 	// FieldValue holds the string denoting the value field in the database.
 	FieldValue = "value"
-	// Table holds the table name of the blocklist in the database.
-	Table = "blocklists"
+	// FieldNotes holds the string denoting the notes field in the database.
+	FieldNotes = "notes"
+	// Table holds the table name of the blacklist in the database.
+	Table = "blacklists"
 )
 
-// Columns holds all SQL columns for blocklist fields.
+// Columns holds all SQL columns for blacklist fields.
 var Columns = []string{
 	FieldID,
 	FieldType,
 	FieldValue,
+	FieldNotes,
 }
 
 // ValidColumn reports if the column name is valid (part of the table columns).
@@ -38,6 +42,11 @@ func ValidColumn(column string) bool {
 	return false
 }
 
+var (
+	// DefaultValue holds the default value on creation for the "value" field.
+	DefaultValue schema.BlacklistValue
+)
+
 // Type defines the type for the "type" enum field.
 type Type string
 
@@ -57,11 +66,11 @@ func TypeValidator(_type Type) error {
 	case TypeMedia, TypeTorrent:
 		return nil
 	default:
-		return fmt.Errorf("blocklist: invalid enum value for type field: %q", _type)
+		return fmt.Errorf("blacklist: invalid enum value for type field: %q", _type)
 	}
 }
 
-// OrderOption defines the ordering options for the Blocklist queries.
+// OrderOption defines the ordering options for the Blacklist queries.
 type OrderOption func(*sql.Selector)
 
 // ByID orders the results by the id field.
@@ -74,7 +83,7 @@ func ByType(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldType, opts...).ToFunc()
 }
 
-// ByValue orders the results by the value field.
-func ByValue(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldValue, opts...).ToFunc()
+// ByNotes orders the results by the notes field.
+func ByNotes(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldNotes, opts...).ToFunc()
 }

ent/blacklist/where.go

@@ -0,0 +1,169 @@
+// Code generated by ent, DO NOT EDIT.
+
+package blacklist
+
+import (
+	"polaris/ent/predicate"
+
+	"entgo.io/ent/dialect/sql"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id int) predicate.Blacklist {
+	return predicate.Blacklist(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id int) predicate.Blacklist {
+	return predicate.Blacklist(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id int) predicate.Blacklist {
+	return predicate.Blacklist(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...int) predicate.Blacklist {
+	return predicate.Blacklist(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...int) predicate.Blacklist {
+	return predicate.Blacklist(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id int) predicate.Blacklist {
+	return predicate.Blacklist(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id int) predicate.Blacklist {
+	return predicate.Blacklist(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id int) predicate.Blacklist {
+	return predicate.Blacklist(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id int) predicate.Blacklist {
+	return predicate.Blacklist(sql.FieldLTE(FieldID, id))
+}
+
+// Notes applies equality check predicate on the "notes" field. It's identical to NotesEQ.
+func Notes(v string) predicate.Blacklist {
+	return predicate.Blacklist(sql.FieldEQ(FieldNotes, v))
+}
+
+// TypeEQ applies the EQ predicate on the "type" field.
+func TypeEQ(v Type) predicate.Blacklist {
+	return predicate.Blacklist(sql.FieldEQ(FieldType, v))
+}
+
+// TypeNEQ applies the NEQ predicate on the "type" field.
+func TypeNEQ(v Type) predicate.Blacklist {
+	return predicate.Blacklist(sql.FieldNEQ(FieldType, v))
+}
+
+// TypeIn applies the In predicate on the "type" field.
+func TypeIn(vs ...Type) predicate.Blacklist {
+	return predicate.Blacklist(sql.FieldIn(FieldType, vs...))
+}
+
+// TypeNotIn applies the NotIn predicate on the "type" field.
+func TypeNotIn(vs ...Type) predicate.Blacklist {
+	return predicate.Blacklist(sql.FieldNotIn(FieldType, vs...))
+}
+
+// NotesEQ applies the EQ predicate on the "notes" field.
+func NotesEQ(v string) predicate.Blacklist {
+	return predicate.Blacklist(sql.FieldEQ(FieldNotes, v))
+}
+
+// NotesNEQ applies the NEQ predicate on the "notes" field.
+func NotesNEQ(v string) predicate.Blacklist {
+	return predicate.Blacklist(sql.FieldNEQ(FieldNotes, v))
+}
+
+// NotesIn applies the In predicate on the "notes" field.
+func NotesIn(vs ...string) predicate.Blacklist {
+	return predicate.Blacklist(sql.FieldIn(FieldNotes, vs...))
+}
+
+// NotesNotIn applies the NotIn predicate on the "notes" field.
+func NotesNotIn(vs ...string) predicate.Blacklist {
+	return predicate.Blacklist(sql.FieldNotIn(FieldNotes, vs...))
+}
+
+// NotesGT applies the GT predicate on the "notes" field.
+func NotesGT(v string) predicate.Blacklist {
+	return predicate.Blacklist(sql.FieldGT(FieldNotes, v))
+}
+
+// NotesGTE applies the GTE predicate on the "notes" field.
+func NotesGTE(v string) predicate.Blacklist {
+	return predicate.Blacklist(sql.FieldGTE(FieldNotes, v))
+}
+
+// NotesLT applies the LT predicate on the "notes" field.
+func NotesLT(v string) predicate.Blacklist {
+	return predicate.Blacklist(sql.FieldLT(FieldNotes, v))
+}
+
+// NotesLTE applies the LTE predicate on the "notes" field.
+func NotesLTE(v string) predicate.Blacklist {
+	return predicate.Blacklist(sql.FieldLTE(FieldNotes, v))
+}
+
+// NotesContains applies the Contains predicate on the "notes" field.
+func NotesContains(v string) predicate.Blacklist {
+	return predicate.Blacklist(sql.FieldContains(FieldNotes, v))
+}
+
+// NotesHasPrefix applies the HasPrefix predicate on the "notes" field.
+func NotesHasPrefix(v string) predicate.Blacklist {
+	return predicate.Blacklist(sql.FieldHasPrefix(FieldNotes, v))
+}
+
+// NotesHasSuffix applies the HasSuffix predicate on the "notes" field.
+func NotesHasSuffix(v string) predicate.Blacklist {
+	return predicate.Blacklist(sql.FieldHasSuffix(FieldNotes, v))
+}
+
+// NotesIsNil applies the IsNil predicate on the "notes" field.
+func NotesIsNil() predicate.Blacklist {
+	return predicate.Blacklist(sql.FieldIsNull(FieldNotes))
+}
+
+// NotesNotNil applies the NotNil predicate on the "notes" field.
+func NotesNotNil() predicate.Blacklist {
+	return predicate.Blacklist(sql.FieldNotNull(FieldNotes))
+}
+
+// NotesEqualFold applies the EqualFold predicate on the "notes" field.
+func NotesEqualFold(v string) predicate.Blacklist {
+	return predicate.Blacklist(sql.FieldEqualFold(FieldNotes, v))
+}
+
+// NotesContainsFold applies the ContainsFold predicate on the "notes" field.
+func NotesContainsFold(v string) predicate.Blacklist {
+	return predicate.Blacklist(sql.FieldContainsFold(FieldNotes, v))
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.Blacklist) predicate.Blacklist {
+	return predicate.Blacklist(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.Blacklist) predicate.Blacklist {
+	return predicate.Blacklist(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.Blacklist) predicate.Blacklist {
+	return predicate.Blacklist(sql.NotPredicates(p))
+}

ent/blacklist_create.go

@@ -6,43 +6,67 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"polaris/ent/blocklist"
+	"polaris/ent/blacklist"
+	"polaris/ent/schema"
 
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"entgo.io/ent/schema/field"
 )
 
-// BlocklistCreate is the builder for creating a Blocklist entity.
-type BlocklistCreate struct {
+// BlacklistCreate is the builder for creating a Blacklist entity.
+type BlacklistCreate struct {
 	config
-	mutation *BlocklistMutation
+	mutation *BlacklistMutation
 	hooks    []Hook
 }
 
 // SetType sets the "type" field.
-func (bc *BlocklistCreate) SetType(b blocklist.Type) *BlocklistCreate {
+func (bc *BlacklistCreate) SetType(b blacklist.Type) *BlacklistCreate {
 	bc.mutation.SetType(b)
 	return bc
 }
 
 // SetValue sets the "value" field.
-func (bc *BlocklistCreate) SetValue(s string) *BlocklistCreate {
-	bc.mutation.SetValue(s)
+func (bc *BlacklistCreate) SetValue(sv schema.BlacklistValue) *BlacklistCreate {
+	bc.mutation.SetValue(sv)
 	return bc
 }
 
-// Mutation returns the BlocklistMutation object of the builder.
-func (bc *BlocklistCreate) Mutation() *BlocklistMutation {
+// SetNillableValue sets the "value" field if the given value is not nil.
+func (bc *BlacklistCreate) SetNillableValue(sv *schema.BlacklistValue) *BlacklistCreate {
+	if sv != nil {
+		bc.SetValue(*sv)
+	}
+	return bc
+}
+
+// SetNotes sets the "notes" field.
+func (bc *BlacklistCreate) SetNotes(s string) *BlacklistCreate {
+	bc.mutation.SetNotes(s)
+	return bc
+}
+
+// SetNillableNotes sets the "notes" field if the given value is not nil.
+func (bc *BlacklistCreate) SetNillableNotes(s *string) *BlacklistCreate {
+	if s != nil {
+		bc.SetNotes(*s)
+	}
+	return bc
+}
+
+// Mutation returns the BlacklistMutation object of the builder.
+func (bc *BlacklistCreate) Mutation() *BlacklistMutation {
 	return bc.mutation
 }
 
-// Save creates the Blocklist in the database.
-func (bc *BlocklistCreate) Save(ctx context.Context) (*Blocklist, error) {
+// Save creates the Blacklist in the database.
+func (bc *BlacklistCreate) Save(ctx context.Context) (*Blacklist, error) {
+	bc.defaults()
 	return withHooks(ctx, bc.sqlSave, bc.mutation, bc.hooks)
 }
 
 // SaveX calls Save and panics if Save returns an error.
-func (bc *BlocklistCreate) SaveX(ctx context.Context) *Blocklist {
+func (bc *BlacklistCreate) SaveX(ctx context.Context) *Blacklist {
 	v, err := bc.Save(ctx)
 	if err != nil {
 		panic(err)
@@ -51,35 +75,43 @@ func (bc *BlocklistCreate) SaveX(ctx context.Context) *Blocklist {
 }
 
 // Exec executes the query.
-func (bc *BlocklistCreate) Exec(ctx context.Context) error {
+func (bc *BlacklistCreate) Exec(ctx context.Context) error {
 	_, err := bc.Save(ctx)
 	return err
 }
 
 // ExecX is like Exec, but panics if an error occurs.
-func (bc *BlocklistCreate) ExecX(ctx context.Context) {
+func (bc *BlacklistCreate) ExecX(ctx context.Context) {
 	if err := bc.Exec(ctx); err != nil {
 		panic(err)
 	}
 }
 
+// defaults sets the default values of the builder before save.
+func (bc *BlacklistCreate) defaults() {
+	if _, ok := bc.mutation.Value(); !ok {
+		v := blacklist.DefaultValue
+		bc.mutation.SetValue(v)
+	}
+}
+
 // check runs all checks and user-defined validators on the builder.
-func (bc *BlocklistCreate) check() error {
+func (bc *BlacklistCreate) check() error {
 	if _, ok := bc.mutation.GetType(); !ok {
-		return &ValidationError{Name: "type", err: errors.New(`ent: missing required field "Blocklist.type"`)}
+		return &ValidationError{Name: "type", err: errors.New(`ent: missing required field "Blacklist.type"`)}
 	}
 	if v, ok := bc.mutation.GetType(); ok {
-		if err := blocklist.TypeValidator(v); err != nil {
-			return &ValidationError{Name: "type", err: fmt.Errorf(`ent: validator failed for field "Blocklist.type": %w`, err)}
+		if err := blacklist.TypeValidator(v); err != nil {
+			return &ValidationError{Name: "type", err: fmt.Errorf(`ent: validator failed for field "Blacklist.type": %w`, err)}
 		}
 	}
 	if _, ok := bc.mutation.Value(); !ok {
-		return &ValidationError{Name: "value", err: errors.New(`ent: missing required field "Blocklist.value"`)}
+		return &ValidationError{Name: "value", err: errors.New(`ent: missing required field "Blacklist.value"`)}
 	}
 	return nil
 }
 
-func (bc *BlocklistCreate) sqlSave(ctx context.Context) (*Blocklist, error) {
+func (bc *BlacklistCreate) sqlSave(ctx context.Context) (*Blacklist, error) {
 	if err := bc.check(); err != nil {
 		return nil, err
 	}
@@ -97,42 +129,47 @@ func (bc *BlocklistCreate) sqlSave(ctx context.Context) (*Blocklist, error) {
 	return _node, nil
 }
 
-func (bc *BlocklistCreate) createSpec() (*Blocklist, *sqlgraph.CreateSpec) {
+func (bc *BlacklistCreate) createSpec() (*Blacklist, *sqlgraph.CreateSpec) {
 	var (
-		_node = &Blocklist{config: bc.config}
-		_spec = sqlgraph.NewCreateSpec(blocklist.Table, sqlgraph.NewFieldSpec(blocklist.FieldID, field.TypeInt))
+		_node = &Blacklist{config: bc.config}
+		_spec = sqlgraph.NewCreateSpec(blacklist.Table, sqlgraph.NewFieldSpec(blacklist.FieldID, field.TypeInt))
 	)
 	if value, ok := bc.mutation.GetType(); ok {
-		_spec.SetField(blocklist.FieldType, field.TypeEnum, value)
+		_spec.SetField(blacklist.FieldType, field.TypeEnum, value)
 		_node.Type = value
 	}
 	if value, ok := bc.mutation.Value(); ok {
-		_spec.SetField(blocklist.FieldValue, field.TypeString, value)
+		_spec.SetField(blacklist.FieldValue, field.TypeJSON, value)
 		_node.Value = value
 	}
+	if value, ok := bc.mutation.Notes(); ok {
+		_spec.SetField(blacklist.FieldNotes, field.TypeString, value)
+		_node.Notes = value
+	}
 	return _node, _spec
 }
 
-// BlocklistCreateBulk is the builder for creating many Blocklist entities in bulk.
-type BlocklistCreateBulk struct {
+// BlacklistCreateBulk is the builder for creating many Blacklist entities in bulk.
+type BlacklistCreateBulk struct {
 	config
 	err      error
-	builders []*BlocklistCreate
+	builders []*BlacklistCreate
 }
 
-// Save creates the Blocklist entities in the database.
-func (bcb *BlocklistCreateBulk) Save(ctx context.Context) ([]*Blocklist, error) {
+// Save creates the Blacklist entities in the database.
+func (bcb *BlacklistCreateBulk) Save(ctx context.Context) ([]*Blacklist, error) {
 	if bcb.err != nil {
 		return nil, bcb.err
 	}
 	specs := make([]*sqlgraph.CreateSpec, len(bcb.builders))
-	nodes := make([]*Blocklist, len(bcb.builders))
+	nodes := make([]*Blacklist, len(bcb.builders))
 	mutators := make([]Mutator, len(bcb.builders))
 	for i := range bcb.builders {
 		func(i int, root context.Context) {
 			builder := bcb.builders[i]
+			builder.defaults()
 			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-				mutation, ok := m.(*BlocklistMutation)
+				mutation, ok := m.(*BlacklistMutation)
 				if !ok {
 					return nil, fmt.Errorf("unexpected mutation type %T", m)
 				}
@@ -179,7 +216,7 @@ func (bcb *BlocklistCreateBulk) Save(ctx context.Context) ([]*Blocklist, error)
 }
 
 // SaveX is like Save, but panics if an error occurs.
-func (bcb *BlocklistCreateBulk) SaveX(ctx context.Context) []*Blocklist {
+func (bcb *BlacklistCreateBulk) SaveX(ctx context.Context) []*Blacklist {
 	v, err := bcb.Save(ctx)
 	if err != nil {
 		panic(err)
@@ -188,13 +225,13 @@ func (bcb *BlocklistCreateBulk) SaveX(ctx context.Context) []*Blocklist {
 }
 
 // Exec executes the query.
-func (bcb *BlocklistCreateBulk) Exec(ctx context.Context) error {
+func (bcb *BlacklistCreateBulk) Exec(ctx context.Context) error {
 	_, err := bcb.Save(ctx)
 	return err
 }
 
 // ExecX is like Exec, but panics if an error occurs.
-func (bcb *BlocklistCreateBulk) ExecX(ctx context.Context) {
+func (bcb *BlacklistCreateBulk) ExecX(ctx context.Context) {
 	if err := bcb.Exec(ctx); err != nil {
 		panic(err)
 	}

ent/blacklist_delete.go

@@ -4,7 +4,7 @@ package ent
 
 import (
 	"context"
-	"polaris/ent/blocklist"
+	"polaris/ent/blacklist"
 	"polaris/ent/predicate"
 
 	"entgo.io/ent/dialect/sql"
@@ -12,26 +12,26 @@ import (
 	"entgo.io/ent/schema/field"
 )
 
-// BlocklistDelete is the builder for deleting a Blocklist entity.
-type BlocklistDelete struct {
+// BlacklistDelete is the builder for deleting a Blacklist entity.
+type BlacklistDelete struct {
 	config
 	hooks    []Hook
-	mutation *BlocklistMutation
+	mutation *BlacklistMutation
 }
 
-// Where appends a list predicates to the BlocklistDelete builder.
-func (bd *BlocklistDelete) Where(ps ...predicate.Blocklist) *BlocklistDelete {
+// Where appends a list predicates to the BlacklistDelete builder.
+func (bd *BlacklistDelete) Where(ps ...predicate.Blacklist) *BlacklistDelete {
 	bd.mutation.Where(ps...)
 	return bd
 }
 
 // Exec executes the deletion query and returns how many vertices were deleted.
-func (bd *BlocklistDelete) Exec(ctx context.Context) (int, error) {
+func (bd *BlacklistDelete) Exec(ctx context.Context) (int, error) {
 	return withHooks(ctx, bd.sqlExec, bd.mutation, bd.hooks)
 }
 
 // ExecX is like Exec, but panics if an error occurs.
-func (bd *BlocklistDelete) ExecX(ctx context.Context) int {
+func (bd *BlacklistDelete) ExecX(ctx context.Context) int {
 	n, err := bd.Exec(ctx)
 	if err != nil {
 		panic(err)
@@ -39,8 +39,8 @@ func (bd *BlocklistDelete) ExecX(ctx context.Context) int {
 	return n
 }
 
-func (bd *BlocklistDelete) sqlExec(ctx context.Context) (int, error) {
-	_spec := sqlgraph.NewDeleteSpec(blocklist.Table, sqlgraph.NewFieldSpec(blocklist.FieldID, field.TypeInt))
+func (bd *BlacklistDelete) sqlExec(ctx context.Context) (int, error) {
+	_spec := sqlgraph.NewDeleteSpec(blacklist.Table, sqlgraph.NewFieldSpec(blacklist.FieldID, field.TypeInt))
 	if ps := bd.mutation.predicates; len(ps) > 0 {
 		_spec.Predicate = func(selector *sql.Selector) {
 			for i := range ps {
@@ -56,32 +56,32 @@ func (bd *BlocklistDelete) sqlExec(ctx context.Context) (int, error) {
 	return affected, err
 }
 
-// BlocklistDeleteOne is the builder for deleting a single Blocklist entity.
-type BlocklistDeleteOne struct {
-	bd *BlocklistDelete
+// BlacklistDeleteOne is the builder for deleting a single Blacklist entity.
+type BlacklistDeleteOne struct {
+	bd *BlacklistDelete
 }
 
-// Where appends a list predicates to the BlocklistDelete builder.
-func (bdo *BlocklistDeleteOne) Where(ps ...predicate.Blocklist) *BlocklistDeleteOne {
+// Where appends a list predicates to the BlacklistDelete builder.
+func (bdo *BlacklistDeleteOne) Where(ps ...predicate.Blacklist) *BlacklistDeleteOne {
 	bdo.bd.mutation.Where(ps...)
 	return bdo
 }
 
 // Exec executes the deletion query.
-func (bdo *BlocklistDeleteOne) Exec(ctx context.Context) error {
+func (bdo *BlacklistDeleteOne) Exec(ctx context.Context) error {
 	n, err := bdo.bd.Exec(ctx)
 	switch {
 	case err != nil:
 		return err
 	case n == 0:
-		return &NotFoundError{blocklist.Label}
+		return &NotFoundError{blacklist.Label}
 	default:
 		return nil
 	}
 }
 
 // ExecX is like Exec, but panics if an error occurs.
-func (bdo *BlocklistDeleteOne) ExecX(ctx context.Context) {
+func (bdo *BlacklistDeleteOne) ExecX(ctx context.Context) {
 	if err := bdo.Exec(ctx); err != nil {
 		panic(err)
 	}

ent/blacklist_query.go

@@ -6,7 +6,7 @@ import (
 	"context"
 	"fmt"
 	"math"
-	"polaris/ent/blocklist"
+	"polaris/ent/blacklist"
 	"polaris/ent/predicate"
 
 	"entgo.io/ent/dialect/sql"
@@ -14,64 +14,64 @@ import (
 	"entgo.io/ent/schema/field"
 )
 
-// BlocklistQuery is the builder for querying Blocklist entities.
-type BlocklistQuery struct {
+// BlacklistQuery is the builder for querying Blacklist entities.
+type BlacklistQuery struct {
 	config
 	ctx        *QueryContext
-	order      []blocklist.OrderOption
+	order      []blacklist.OrderOption
 	inters     []Interceptor
-	predicates []predicate.Blocklist
+	predicates []predicate.Blacklist
 	// intermediate query (i.e. traversal path).
 	sql  *sql.Selector
 	path func(context.Context) (*sql.Selector, error)
 }
 
-// Where adds a new predicate for the BlocklistQuery builder.
-func (bq *BlocklistQuery) Where(ps ...predicate.Blocklist) *BlocklistQuery {
+// Where adds a new predicate for the BlacklistQuery builder.
+func (bq *BlacklistQuery) Where(ps ...predicate.Blacklist) *BlacklistQuery {
 	bq.predicates = append(bq.predicates, ps...)
 	return bq
 }
 
 // Limit the number of records to be returned by this query.
-func (bq *BlocklistQuery) Limit(limit int) *BlocklistQuery {
+func (bq *BlacklistQuery) Limit(limit int) *BlacklistQuery {
 	bq.ctx.Limit = &limit
 	return bq
 }
 
 // Offset to start from.
-func (bq *BlocklistQuery) Offset(offset int) *BlocklistQuery {
+func (bq *BlacklistQuery) Offset(offset int) *BlacklistQuery {
 	bq.ctx.Offset = &offset
 	return bq
 }
 
 // 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 (bq *BlocklistQuery) Unique(unique bool) *BlocklistQuery {
+func (bq *BlacklistQuery) Unique(unique bool) *BlacklistQuery {
 	bq.ctx.Unique = &unique
 	return bq
 }
 
 // Order specifies how the records should be ordered.
-func (bq *BlocklistQuery) Order(o ...blocklist.OrderOption) *BlocklistQuery {
+func (bq *BlacklistQuery) Order(o ...blacklist.OrderOption) *BlacklistQuery {
 	bq.order = append(bq.order, o...)
 	return bq
 }
 
-// First returns the first Blocklist entity from the query.
-// Returns a *NotFoundError when no Blocklist was found.
-func (bq *BlocklistQuery) First(ctx context.Context) (*Blocklist, error) {
+// First returns the first Blacklist entity from the query.
+// Returns a *NotFoundError when no Blacklist was found.
+func (bq *BlacklistQuery) First(ctx context.Context) (*Blacklist, error) {
 	nodes, err := bq.Limit(1).All(setContextOp(ctx, bq.ctx, "First"))
 	if err != nil {
 		return nil, err
 	}
 	if len(nodes) == 0 {
-		return nil, &NotFoundError{blocklist.Label}
+		return nil, &NotFoundError{blacklist.Label}
 	}
 	return nodes[0], nil
 }
 
 // FirstX is like First, but panics if an error occurs.
-func (bq *BlocklistQuery) FirstX(ctx context.Context) *Blocklist {
+func (bq *BlacklistQuery) FirstX(ctx context.Context) *Blacklist {
 	node, err := bq.First(ctx)
 	if err != nil && !IsNotFound(err) {
 		panic(err)
@@ -79,22 +79,22 @@ func (bq *BlocklistQuery) FirstX(ctx context.Context) *Blocklist {
 	return node
 }
 
-// FirstID returns the first Blocklist ID from the query.
-// Returns a *NotFoundError when no Blocklist ID was found.
-func (bq *BlocklistQuery) FirstID(ctx context.Context) (id int, err error) {
+// FirstID returns the first Blacklist ID from the query.
+// Returns a *NotFoundError when no Blacklist ID was found.
+func (bq *BlacklistQuery) FirstID(ctx context.Context) (id int, err error) {
 	var ids []int
 	if ids, err = bq.Limit(1).IDs(setContextOp(ctx, bq.ctx, "FirstID")); err != nil {
 		return
 	}
 	if len(ids) == 0 {
-		err = &NotFoundError{blocklist.Label}
+		err = &NotFoundError{blacklist.Label}
 		return
 	}
 	return ids[0], nil
 }
 
 // FirstIDX is like FirstID, but panics if an error occurs.
-func (bq *BlocklistQuery) FirstIDX(ctx context.Context) int {
+func (bq *BlacklistQuery) FirstIDX(ctx context.Context) int {
 	id, err := bq.FirstID(ctx)
 	if err != nil && !IsNotFound(err) {
 		panic(err)
@@ -102,10 +102,10 @@ func (bq *BlocklistQuery) FirstIDX(ctx context.Context) int {
 	return id
 }
 
-// Only returns a single Blocklist entity found by the query, ensuring it only returns one.
-// Returns a *NotSingularError when more than one Blocklist entity is found.
-// Returns a *NotFoundError when no Blocklist entities are found.
-func (bq *BlocklistQuery) Only(ctx context.Context) (*Blocklist, error) {
+// Only returns a single Blacklist entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one Blacklist entity is found.
+// Returns a *NotFoundError when no Blacklist entities are found.
+func (bq *BlacklistQuery) Only(ctx context.Context) (*Blacklist, error) {
 	nodes, err := bq.Limit(2).All(setContextOp(ctx, bq.ctx, "Only"))
 	if err != nil {
 		return nil, err
@@ -114,14 +114,14 @@ func (bq *BlocklistQuery) Only(ctx context.Context) (*Blocklist, error) {
 	case 1:
 		return nodes[0], nil
 	case 0:
-		return nil, &NotFoundError{blocklist.Label}
+		return nil, &NotFoundError{blacklist.Label}
 	default:
-		return nil, &NotSingularError{blocklist.Label}
+		return nil, &NotSingularError{blacklist.Label}
 	}
 }
 
 // OnlyX is like Only, but panics if an error occurs.
-func (bq *BlocklistQuery) OnlyX(ctx context.Context) *Blocklist {
+func (bq *BlacklistQuery) OnlyX(ctx context.Context) *Blacklist {
 	node, err := bq.Only(ctx)
 	if err != nil {
 		panic(err)
@@ -129,10 +129,10 @@ func (bq *BlocklistQuery) OnlyX(ctx context.Context) *Blocklist {
 	return node
 }
 
-// OnlyID is like Only, but returns the only Blocklist ID in the query.
-// Returns a *NotSingularError when more than one Blocklist ID is found.
+// OnlyID is like Only, but returns the only Blacklist ID in the query.
+// Returns a *NotSingularError when more than one Blacklist ID is found.
 // Returns a *NotFoundError when no entities are found.
-func (bq *BlocklistQuery) OnlyID(ctx context.Context) (id int, err error) {
+func (bq *BlacklistQuery) OnlyID(ctx context.Context) (id int, err error) {
 	var ids []int
 	if ids, err = bq.Limit(2).IDs(setContextOp(ctx, bq.ctx, "OnlyID")); err != nil {
 		return
@@ -141,15 +141,15 @@ func (bq *BlocklistQuery) OnlyID(ctx context.Context) (id int, err error) {
 	case 1:
 		id = ids[0]
 	case 0:
-		err = &NotFoundError{blocklist.Label}
+		err = &NotFoundError{blacklist.Label}
 	default:
-		err = &NotSingularError{blocklist.Label}
+		err = &NotSingularError{blacklist.Label}
 	}
 	return
 }
 
 // OnlyIDX is like OnlyID, but panics if an error occurs.
-func (bq *BlocklistQuery) OnlyIDX(ctx context.Context) int {
+func (bq *BlacklistQuery) OnlyIDX(ctx context.Context) int {
 	id, err := bq.OnlyID(ctx)
 	if err != nil {
 		panic(err)
@@ -157,18 +157,18 @@ func (bq *BlocklistQuery) OnlyIDX(ctx context.Context) int {
 	return id
 }
 
-// All executes the query and returns a list of Blocklists.
-func (bq *BlocklistQuery) All(ctx context.Context) ([]*Blocklist, error) {
+// All executes the query and returns a list of Blacklists.
+func (bq *BlacklistQuery) All(ctx context.Context) ([]*Blacklist, error) {
 	ctx = setContextOp(ctx, bq.ctx, "All")
 	if err := bq.prepareQuery(ctx); err != nil {
 		return nil, err
 	}
-	qr := querierAll[[]*Blocklist, *BlocklistQuery]()
-	return withInterceptors[[]*Blocklist](ctx, bq, qr, bq.inters)
+	qr := querierAll[[]*Blacklist, *BlacklistQuery]()
+	return withInterceptors[[]*Blacklist](ctx, bq, qr, bq.inters)
 }
 
 // AllX is like All, but panics if an error occurs.
-func (bq *BlocklistQuery) AllX(ctx context.Context) []*Blocklist {
+func (bq *BlacklistQuery) AllX(ctx context.Context) []*Blacklist {
 	nodes, err := bq.All(ctx)
 	if err != nil {
 		panic(err)
@@ -176,20 +176,20 @@ func (bq *BlocklistQuery) AllX(ctx context.Context) []*Blocklist {
 	return nodes
 }
 
-// IDs executes the query and returns a list of Blocklist IDs.
-func (bq *BlocklistQuery) IDs(ctx context.Context) (ids []int, err error) {
+// IDs executes the query and returns a list of Blacklist IDs.
+func (bq *BlacklistQuery) IDs(ctx context.Context) (ids []int, err error) {
 	if bq.ctx.Unique == nil && bq.path != nil {
 		bq.Unique(true)
 	}
 	ctx = setContextOp(ctx, bq.ctx, "IDs")
-	if err = bq.Select(blocklist.FieldID).Scan(ctx, &ids); err != nil {
+	if err = bq.Select(blacklist.FieldID).Scan(ctx, &ids); err != nil {
 		return nil, err
 	}
 	return ids, nil
 }
 
 // IDsX is like IDs, but panics if an error occurs.
-func (bq *BlocklistQuery) IDsX(ctx context.Context) []int {
+func (bq *BlacklistQuery) IDsX(ctx context.Context) []int {
 	ids, err := bq.IDs(ctx)
 	if err != nil {
 		panic(err)
@@ -198,16 +198,16 @@ func (bq *BlocklistQuery) IDsX(ctx context.Context) []int {
 }
 
 // Count returns the count of the given query.
-func (bq *BlocklistQuery) Count(ctx context.Context) (int, error) {
+func (bq *BlacklistQuery) Count(ctx context.Context) (int, error) {
 	ctx = setContextOp(ctx, bq.ctx, "Count")
 	if err := bq.prepareQuery(ctx); err != nil {
 		return 0, err
 	}
-	return withInterceptors[int](ctx, bq, querierCount[*BlocklistQuery](), bq.inters)
+	return withInterceptors[int](ctx, bq, querierCount[*BlacklistQuery](), bq.inters)
 }
 
 // CountX is like Count, but panics if an error occurs.
-func (bq *BlocklistQuery) CountX(ctx context.Context) int {
+func (bq *BlacklistQuery) CountX(ctx context.Context) int {
 	count, err := bq.Count(ctx)
 	if err != nil {
 		panic(err)
@@ -216,7 +216,7 @@ func (bq *BlocklistQuery) CountX(ctx context.Context) int {
 }
 
 // Exist returns true if the query has elements in the graph.
-func (bq *BlocklistQuery) Exist(ctx context.Context) (bool, error) {
+func (bq *BlacklistQuery) Exist(ctx context.Context) (bool, error) {
 	ctx = setContextOp(ctx, bq.ctx, "Exist")
 	switch _, err := bq.FirstID(ctx); {
 	case IsNotFound(err):
@@ -229,7 +229,7 @@ func (bq *BlocklistQuery) Exist(ctx context.Context) (bool, error) {
 }
 
 // ExistX is like Exist, but panics if an error occurs.
-func (bq *BlocklistQuery) ExistX(ctx context.Context) bool {
+func (bq *BlacklistQuery) ExistX(ctx context.Context) bool {
 	exist, err := bq.Exist(ctx)
 	if err != nil {
 		panic(err)
@@ -237,18 +237,18 @@ func (bq *BlocklistQuery) ExistX(ctx context.Context) bool {
 	return exist
 }
 
-// Clone returns a duplicate of the BlocklistQuery builder, including all associated steps. It can be
+// Clone returns a duplicate of the BlacklistQuery builder, including all associated steps. It can be
 // used to prepare common query builders and use them differently after the clone is made.
-func (bq *BlocklistQuery) Clone() *BlocklistQuery {
+func (bq *BlacklistQuery) Clone() *BlacklistQuery {
 	if bq == nil {
 		return nil
 	}
-	return &BlocklistQuery{
+	return &BlacklistQuery{
 		config:     bq.config,
 		ctx:        bq.ctx.Clone(),
-		order:      append([]blocklist.OrderOption{}, bq.order...),
+		order:      append([]blacklist.OrderOption{}, bq.order...),
 		inters:     append([]Interceptor{}, bq.inters...),
-		predicates: append([]predicate.Blocklist{}, bq.predicates...),
+		predicates: append([]predicate.Blacklist{}, bq.predicates...),
 		// clone intermediate query.
 		sql:  bq.sql.Clone(),
 		path: bq.path,
@@ -261,19 +261,19 @@ func (bq *BlocklistQuery) Clone() *BlocklistQuery {
 // Example:
 //
 //	var v []struct {
-//		Type blocklist.Type `json:"type,omitempty"`
+//		Type blacklist.Type `json:"type,omitempty"`
 //		Count int `json:"count,omitempty"`
 //	}
 //
-//	client.Blocklist.Query().
-//		GroupBy(blocklist.FieldType).
+//	client.Blacklist.Query().
+//		GroupBy(blacklist.FieldType).
 //		Aggregate(ent.Count()).
 //		Scan(ctx, &v)
-func (bq *BlocklistQuery) GroupBy(field string, fields ...string) *BlocklistGroupBy {
+func (bq *BlacklistQuery) GroupBy(field string, fields ...string) *BlacklistGroupBy {
 	bq.ctx.Fields = append([]string{field}, fields...)
-	grbuild := &BlocklistGroupBy{build: bq}
+	grbuild := &BlacklistGroupBy{build: bq}
 	grbuild.flds = &bq.ctx.Fields
-	grbuild.label = blocklist.Label
+	grbuild.label = blacklist.Label
 	grbuild.scan = grbuild.Scan
 	return grbuild
 }
@@ -284,26 +284,26 @@ func (bq *BlocklistQuery) GroupBy(field string, fields ...string) *BlocklistGrou
 // Example:
 //
 //	var v []struct {
-//		Type blocklist.Type `json:"type,omitempty"`
+//		Type blacklist.Type `json:"type,omitempty"`
 //	}
 //
-//	client.Blocklist.Query().
-//		Select(blocklist.FieldType).
+//	client.Blacklist.Query().
+//		Select(blacklist.FieldType).
 //		Scan(ctx, &v)
-func (bq *BlocklistQuery) Select(fields ...string) *BlocklistSelect {
+func (bq *BlacklistQuery) Select(fields ...string) *BlacklistSelect {
 	bq.ctx.Fields = append(bq.ctx.Fields, fields...)
-	sbuild := &BlocklistSelect{BlocklistQuery: bq}
-	sbuild.label = blocklist.Label
+	sbuild := &BlacklistSelect{BlacklistQuery: bq}
+	sbuild.label = blacklist.Label
 	sbuild.flds, sbuild.scan = &bq.ctx.Fields, sbuild.Scan
 	return sbuild
 }
 
-// Aggregate returns a BlocklistSelect configured with the given aggregations.
-func (bq *BlocklistQuery) Aggregate(fns ...AggregateFunc) *BlocklistSelect {
+// Aggregate returns a BlacklistSelect configured with the given aggregations.
+func (bq *BlacklistQuery) Aggregate(fns ...AggregateFunc) *BlacklistSelect {
 	return bq.Select().Aggregate(fns...)
 }
 
-func (bq *BlocklistQuery) prepareQuery(ctx context.Context) error {
+func (bq *BlacklistQuery) prepareQuery(ctx context.Context) error {
 	for _, inter := range bq.inters {
 		if inter == nil {
 			return fmt.Errorf("ent: uninitialized interceptor (forgotten import ent/runtime?)")
@@ -315,7 +315,7 @@ func (bq *BlocklistQuery) prepareQuery(ctx context.Context) error {
 		}
 	}
 	for _, f := range bq.ctx.Fields {
-		if !blocklist.ValidColumn(f) {
+		if !blacklist.ValidColumn(f) {
 			return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
 		}
 	}
@@ -329,16 +329,16 @@ func (bq *BlocklistQuery) prepareQuery(ctx context.Context) error {
 	return nil
 }
 
-func (bq *BlocklistQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Blocklist, error) {
+func (bq *BlacklistQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Blacklist, error) {
 	var (
-		nodes = []*Blocklist{}
+		nodes = []*Blacklist{}
 		_spec = bq.querySpec()
 	)
 	_spec.ScanValues = func(columns []string) ([]any, error) {
-		return (*Blocklist).scanValues(nil, columns)
+		return (*Blacklist).scanValues(nil, columns)
 	}
 	_spec.Assign = func(columns []string, values []any) error {
-		node := &Blocklist{config: bq.config}
+		node := &Blacklist{config: bq.config}
 		nodes = append(nodes, node)
 		return node.assignValues(columns, values)
 	}
@@ -354,7 +354,7 @@ func (bq *BlocklistQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Bl
 	return nodes, nil
 }
 
-func (bq *BlocklistQuery) sqlCount(ctx context.Context) (int, error) {
+func (bq *BlacklistQuery) sqlCount(ctx context.Context) (int, error) {
 	_spec := bq.querySpec()
 	_spec.Node.Columns = bq.ctx.Fields
 	if len(bq.ctx.Fields) > 0 {
@@ -363,8 +363,8 @@ func (bq *BlocklistQuery) sqlCount(ctx context.Context) (int, error) {
 	return sqlgraph.CountNodes(ctx, bq.driver, _spec)
 }
 
-func (bq *BlocklistQuery) querySpec() *sqlgraph.QuerySpec {
-	_spec := sqlgraph.NewQuerySpec(blocklist.Table, blocklist.Columns, sqlgraph.NewFieldSpec(blocklist.FieldID, field.TypeInt))
+func (bq *BlacklistQuery) querySpec() *sqlgraph.QuerySpec {
+	_spec := sqlgraph.NewQuerySpec(blacklist.Table, blacklist.Columns, sqlgraph.NewFieldSpec(blacklist.FieldID, field.TypeInt))
 	_spec.From = bq.sql
 	if unique := bq.ctx.Unique; unique != nil {
 		_spec.Unique = *unique
@@ -373,9 +373,9 @@ func (bq *BlocklistQuery) querySpec() *sqlgraph.QuerySpec {
 	}
 	if fields := bq.ctx.Fields; len(fields) > 0 {
 		_spec.Node.Columns = make([]string, 0, len(fields))
-		_spec.Node.Columns = append(_spec.Node.Columns, blocklist.FieldID)
+		_spec.Node.Columns = append(_spec.Node.Columns, blacklist.FieldID)
 		for i := range fields {
-			if fields[i] != blocklist.FieldID {
+			if fields[i] != blacklist.FieldID {
 				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
 			}
 		}
@@ -403,12 +403,12 @@ func (bq *BlocklistQuery) querySpec() *sqlgraph.QuerySpec {
 	return _spec
 }
 
-func (bq *BlocklistQuery) sqlQuery(ctx context.Context) *sql.Selector {
+func (bq *BlacklistQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	builder := sql.Dialect(bq.driver.Dialect())
-	t1 := builder.Table(blocklist.Table)
+	t1 := builder.Table(blacklist.Table)
 	columns := bq.ctx.Fields
 	if len(columns) == 0 {
-		columns = blocklist.Columns
+		columns = blacklist.Columns
 	}
 	selector := builder.Select(t1.Columns(columns...)...).From(t1)
 	if bq.sql != nil {
@@ -435,28 +435,28 @@ func (bq *BlocklistQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	return selector
 }
 
-// BlocklistGroupBy is the group-by builder for Blocklist entities.
-type BlocklistGroupBy struct {
+// BlacklistGroupBy is the group-by builder for Blacklist entities.
+type BlacklistGroupBy struct {
 	selector
-	build *BlocklistQuery
+	build *BlacklistQuery
 }
 
 // Aggregate adds the given aggregation functions to the group-by query.
-func (bgb *BlocklistGroupBy) Aggregate(fns ...AggregateFunc) *BlocklistGroupBy {
+func (bgb *BlacklistGroupBy) Aggregate(fns ...AggregateFunc) *BlacklistGroupBy {
 	bgb.fns = append(bgb.fns, fns...)
 	return bgb
 }
 
 // Scan applies the selector query and scans the result into the given value.
-func (bgb *BlocklistGroupBy) Scan(ctx context.Context, v any) error {
+func (bgb *BlacklistGroupBy) Scan(ctx context.Context, v any) error {
 	ctx = setContextOp(ctx, bgb.build.ctx, "GroupBy")
 	if err := bgb.build.prepareQuery(ctx); err != nil {
 		return err
 	}
-	return scanWithInterceptors[*BlocklistQuery, *BlocklistGroupBy](ctx, bgb.build, bgb, bgb.build.inters, v)
+	return scanWithInterceptors[*BlacklistQuery, *BlacklistGroupBy](ctx, bgb.build, bgb, bgb.build.inters, v)
 }
 
-func (bgb *BlocklistGroupBy) sqlScan(ctx context.Context, root *BlocklistQuery, v any) error {
+func (bgb *BlacklistGroupBy) sqlScan(ctx context.Context, root *BlacklistQuery, v any) error {
 	selector := root.sqlQuery(ctx).Select()
 	aggregation := make([]string, 0, len(bgb.fns))
 	for _, fn := range bgb.fns {
@@ -483,28 +483,28 @@ func (bgb *BlocklistGroupBy) sqlScan(ctx context.Context, root *BlocklistQuery,
 	return sql.ScanSlice(rows, v)
 }
 
-// BlocklistSelect is the builder for selecting fields of Blocklist entities.
-type BlocklistSelect struct {
-	*BlocklistQuery
+// BlacklistSelect is the builder for selecting fields of Blacklist entities.
+type BlacklistSelect struct {
+	*BlacklistQuery
 	selector
 }
 
 // Aggregate adds the given aggregation functions to the selector query.
-func (bs *BlocklistSelect) Aggregate(fns ...AggregateFunc) *BlocklistSelect {
+func (bs *BlacklistSelect) Aggregate(fns ...AggregateFunc) *BlacklistSelect {
 	bs.fns = append(bs.fns, fns...)
 	return bs
 }
 
 // Scan applies the selector query and scans the result into the given value.
-func (bs *BlocklistSelect) Scan(ctx context.Context, v any) error {
+func (bs *BlacklistSelect) Scan(ctx context.Context, v any) error {
 	ctx = setContextOp(ctx, bs.ctx, "Select")
 	if err := bs.prepareQuery(ctx); err != nil {
 		return err
 	}
-	return scanWithInterceptors[*BlocklistQuery, *BlocklistSelect](ctx, bs.BlocklistQuery, bs, bs.inters, v)
+	return scanWithInterceptors[*BlacklistQuery, *BlacklistSelect](ctx, bs.BlacklistQuery, bs, bs.inters, v)
 }
 
-func (bs *BlocklistSelect) sqlScan(ctx context.Context, root *BlocklistQuery, v any) error {
+func (bs *BlacklistSelect) sqlScan(ctx context.Context, root *BlacklistQuery, v any) error {
 	selector := root.sqlQuery(ctx)
 	aggregation := make([]string, 0, len(bs.fns))
 	for _, fn := range bs.fns {

ent/blacklist_update.go

@@ -0,0 +1,322 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"polaris/ent/blacklist"
+	"polaris/ent/predicate"
+	"polaris/ent/schema"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+)
+
+// BlacklistUpdate is the builder for updating Blacklist entities.
+type BlacklistUpdate struct {
+	config
+	hooks    []Hook
+	mutation *BlacklistMutation
+}
+
+// Where appends a list predicates to the BlacklistUpdate builder.
+func (bu *BlacklistUpdate) Where(ps ...predicate.Blacklist) *BlacklistUpdate {
+	bu.mutation.Where(ps...)
+	return bu
+}
+
+// SetType sets the "type" field.
+func (bu *BlacklistUpdate) SetType(b blacklist.Type) *BlacklistUpdate {
+	bu.mutation.SetType(b)
+	return bu
+}
+
+// SetNillableType sets the "type" field if the given value is not nil.
+func (bu *BlacklistUpdate) SetNillableType(b *blacklist.Type) *BlacklistUpdate {
+	if b != nil {
+		bu.SetType(*b)
+	}
+	return bu
+}
+
+// SetValue sets the "value" field.
+func (bu *BlacklistUpdate) SetValue(sv schema.BlacklistValue) *BlacklistUpdate {
+	bu.mutation.SetValue(sv)
+	return bu
+}
+
+// SetNillableValue sets the "value" field if the given value is not nil.
+func (bu *BlacklistUpdate) SetNillableValue(sv *schema.BlacklistValue) *BlacklistUpdate {
+	if sv != nil {
+		bu.SetValue(*sv)
+	}
+	return bu
+}
+
+// SetNotes sets the "notes" field.
+func (bu *BlacklistUpdate) SetNotes(s string) *BlacklistUpdate {
+	bu.mutation.SetNotes(s)
+	return bu
+}
+
+// SetNillableNotes sets the "notes" field if the given value is not nil.
+func (bu *BlacklistUpdate) SetNillableNotes(s *string) *BlacklistUpdate {
+	if s != nil {
+		bu.SetNotes(*s)
+	}
+	return bu
+}
+
+// ClearNotes clears the value of the "notes" field.
+func (bu *BlacklistUpdate) ClearNotes() *BlacklistUpdate {
+	bu.mutation.ClearNotes()
+	return bu
+}
+
+// Mutation returns the BlacklistMutation object of the builder.
+func (bu *BlacklistUpdate) Mutation() *BlacklistMutation {
+	return bu.mutation
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (bu *BlacklistUpdate) Save(ctx context.Context) (int, error) {
+	return withHooks(ctx, bu.sqlSave, bu.mutation, bu.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (bu *BlacklistUpdate) SaveX(ctx context.Context) int {
+	affected, err := bu.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return affected
+}
+
+// Exec executes the query.
+func (bu *BlacklistUpdate) Exec(ctx context.Context) error {
+	_, err := bu.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (bu *BlacklistUpdate) ExecX(ctx context.Context) {
+	if err := bu.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (bu *BlacklistUpdate) check() error {
+	if v, ok := bu.mutation.GetType(); ok {
+		if err := blacklist.TypeValidator(v); err != nil {
+			return &ValidationError{Name: "type", err: fmt.Errorf(`ent: validator failed for field "Blacklist.type": %w`, err)}
+		}
+	}
+	return nil
+}
+
+func (bu *BlacklistUpdate) sqlSave(ctx context.Context) (n int, err error) {
+	if err := bu.check(); err != nil {
+		return n, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(blacklist.Table, blacklist.Columns, sqlgraph.NewFieldSpec(blacklist.FieldID, field.TypeInt))
+	if ps := bu.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := bu.mutation.GetType(); ok {
+		_spec.SetField(blacklist.FieldType, field.TypeEnum, value)
+	}
+	if value, ok := bu.mutation.Value(); ok {
+		_spec.SetField(blacklist.FieldValue, field.TypeJSON, value)
+	}
+	if value, ok := bu.mutation.Notes(); ok {
+		_spec.SetField(blacklist.FieldNotes, field.TypeString, value)
+	}
+	if bu.mutation.NotesCleared() {
+		_spec.ClearField(blacklist.FieldNotes, field.TypeString)
+	}
+	if n, err = sqlgraph.UpdateNodes(ctx, bu.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{blacklist.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return 0, err
+	}
+	bu.mutation.done = true
+	return n, nil
+}
+
+// BlacklistUpdateOne is the builder for updating a single Blacklist entity.
+type BlacklistUpdateOne struct {
+	config
+	fields   []string
+	hooks    []Hook
+	mutation *BlacklistMutation
+}
+
+// SetType sets the "type" field.
+func (buo *BlacklistUpdateOne) SetType(b blacklist.Type) *BlacklistUpdateOne {
+	buo.mutation.SetType(b)
+	return buo
+}
+
+// SetNillableType sets the "type" field if the given value is not nil.
+func (buo *BlacklistUpdateOne) SetNillableType(b *blacklist.Type) *BlacklistUpdateOne {
+	if b != nil {
+		buo.SetType(*b)
+	}
+	return buo
+}
+
+// SetValue sets the "value" field.
+func (buo *BlacklistUpdateOne) SetValue(sv schema.BlacklistValue) *BlacklistUpdateOne {
+	buo.mutation.SetValue(sv)
+	return buo
+}
+
+// SetNillableValue sets the "value" field if the given value is not nil.
+func (buo *BlacklistUpdateOne) SetNillableValue(sv *schema.BlacklistValue) *BlacklistUpdateOne {
+	if sv != nil {
+		buo.SetValue(*sv)
+	}
+	return buo
+}
+
+// SetNotes sets the "notes" field.
+func (buo *BlacklistUpdateOne) SetNotes(s string) *BlacklistUpdateOne {
+	buo.mutation.SetNotes(s)
+	return buo
+}
+
+// SetNillableNotes sets the "notes" field if the given value is not nil.
+func (buo *BlacklistUpdateOne) SetNillableNotes(s *string) *BlacklistUpdateOne {
+	if s != nil {
+		buo.SetNotes(*s)
+	}
+	return buo
+}
+
+// ClearNotes clears the value of the "notes" field.
+func (buo *BlacklistUpdateOne) ClearNotes() *BlacklistUpdateOne {
+	buo.mutation.ClearNotes()
+	return buo
+}
+
+// Mutation returns the BlacklistMutation object of the builder.
+func (buo *BlacklistUpdateOne) Mutation() *BlacklistMutation {
+	return buo.mutation
+}
+
+// Where appends a list predicates to the BlacklistUpdate builder.
+func (buo *BlacklistUpdateOne) Where(ps ...predicate.Blacklist) *BlacklistUpdateOne {
+	buo.mutation.Where(ps...)
+	return buo
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (buo *BlacklistUpdateOne) Select(field string, fields ...string) *BlacklistUpdateOne {
+	buo.fields = append([]string{field}, fields...)
+	return buo
+}
+
+// Save executes the query and returns the updated Blacklist entity.
+func (buo *BlacklistUpdateOne) Save(ctx context.Context) (*Blacklist, error) {
+	return withHooks(ctx, buo.sqlSave, buo.mutation, buo.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (buo *BlacklistUpdateOne) SaveX(ctx context.Context) *Blacklist {
+	node, err := buo.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// Exec executes the query on the entity.
+func (buo *BlacklistUpdateOne) Exec(ctx context.Context) error {
+	_, err := buo.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (buo *BlacklistUpdateOne) ExecX(ctx context.Context) {
+	if err := buo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (buo *BlacklistUpdateOne) check() error {
+	if v, ok := buo.mutation.GetType(); ok {
+		if err := blacklist.TypeValidator(v); err != nil {
+			return &ValidationError{Name: "type", err: fmt.Errorf(`ent: validator failed for field "Blacklist.type": %w`, err)}
+		}
+	}
+	return nil
+}
+
+func (buo *BlacklistUpdateOne) sqlSave(ctx context.Context) (_node *Blacklist, err error) {
+	if err := buo.check(); err != nil {
+		return _node, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(blacklist.Table, blacklist.Columns, sqlgraph.NewFieldSpec(blacklist.FieldID, field.TypeInt))
+	id, ok := buo.mutation.ID()
+	if !ok {
+		return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "Blacklist.id" for update`)}
+	}
+	_spec.Node.ID.Value = id
+	if fields := buo.fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, blacklist.FieldID)
+		for _, f := range fields {
+			if !blacklist.ValidColumn(f) {
+				return nil, &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
+			}
+			if f != blacklist.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, f)
+			}
+		}
+	}
+	if ps := buo.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := buo.mutation.GetType(); ok {
+		_spec.SetField(blacklist.FieldType, field.TypeEnum, value)
+	}
+	if value, ok := buo.mutation.Value(); ok {
+		_spec.SetField(blacklist.FieldValue, field.TypeJSON, value)
+	}
+	if value, ok := buo.mutation.Notes(); ok {
+		_spec.SetField(blacklist.FieldNotes, field.TypeString, value)
+	}
+	if buo.mutation.NotesCleared() {
+		_spec.ClearField(blacklist.FieldNotes, field.TypeString)
+	}
+	_node = &Blacklist{config: buo.config}
+	_spec.Assign = _node.assignValues
+	_spec.ScanValues = _node.scanValues
+	if err = sqlgraph.UpdateNode(ctx, buo.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{blacklist.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	buo.mutation.done = true
+	return _node, nil
+}

ent/blocklist/where.go

@@ -1,159 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package blocklist
-
-import (
-	"polaris/ent/predicate"
-
-	"entgo.io/ent/dialect/sql"
-)
-
-// ID filters vertices based on their ID field.
-func ID(id int) predicate.Blocklist {
-	return predicate.Blocklist(sql.FieldEQ(FieldID, id))
-}
-
-// IDEQ applies the EQ predicate on the ID field.
-func IDEQ(id int) predicate.Blocklist {
-	return predicate.Blocklist(sql.FieldEQ(FieldID, id))
-}
-
-// IDNEQ applies the NEQ predicate on the ID field.
-func IDNEQ(id int) predicate.Blocklist {
-	return predicate.Blocklist(sql.FieldNEQ(FieldID, id))
-}
-
-// IDIn applies the In predicate on the ID field.
-func IDIn(ids ...int) predicate.Blocklist {
-	return predicate.Blocklist(sql.FieldIn(FieldID, ids...))
-}
-
-// IDNotIn applies the NotIn predicate on the ID field.
-func IDNotIn(ids ...int) predicate.Blocklist {
-	return predicate.Blocklist(sql.FieldNotIn(FieldID, ids...))
-}
-
-// IDGT applies the GT predicate on the ID field.
-func IDGT(id int) predicate.Blocklist {
-	return predicate.Blocklist(sql.FieldGT(FieldID, id))
-}
-
-// IDGTE applies the GTE predicate on the ID field.
-func IDGTE(id int) predicate.Blocklist {
-	return predicate.Blocklist(sql.FieldGTE(FieldID, id))
-}
-
-// IDLT applies the LT predicate on the ID field.
-func IDLT(id int) predicate.Blocklist {
-	return predicate.Blocklist(sql.FieldLT(FieldID, id))
-}
-
-// IDLTE applies the LTE predicate on the ID field.
-func IDLTE(id int) predicate.Blocklist {
-	return predicate.Blocklist(sql.FieldLTE(FieldID, id))
-}
-
-// Value applies equality check predicate on the "value" field. It's identical to ValueEQ.
-func Value(v string) predicate.Blocklist {
-	return predicate.Blocklist(sql.FieldEQ(FieldValue, v))
-}
-
-// TypeEQ applies the EQ predicate on the "type" field.
-func TypeEQ(v Type) predicate.Blocklist {
-	return predicate.Blocklist(sql.FieldEQ(FieldType, v))
-}
-
-// TypeNEQ applies the NEQ predicate on the "type" field.
-func TypeNEQ(v Type) predicate.Blocklist {
-	return predicate.Blocklist(sql.FieldNEQ(FieldType, v))
-}
-
-// TypeIn applies the In predicate on the "type" field.
-func TypeIn(vs ...Type) predicate.Blocklist {
-	return predicate.Blocklist(sql.FieldIn(FieldType, vs...))
-}
-
-// TypeNotIn applies the NotIn predicate on the "type" field.
-func TypeNotIn(vs ...Type) predicate.Blocklist {
-	return predicate.Blocklist(sql.FieldNotIn(FieldType, vs...))
-}
-
-// ValueEQ applies the EQ predicate on the "value" field.
-func ValueEQ(v string) predicate.Blocklist {
-	return predicate.Blocklist(sql.FieldEQ(FieldValue, v))
-}
-
-// ValueNEQ applies the NEQ predicate on the "value" field.
-func ValueNEQ(v string) predicate.Blocklist {
-	return predicate.Blocklist(sql.FieldNEQ(FieldValue, v))
-}
-
-// ValueIn applies the In predicate on the "value" field.
-func ValueIn(vs ...string) predicate.Blocklist {
-	return predicate.Blocklist(sql.FieldIn(FieldValue, vs...))
-}
-
-// ValueNotIn applies the NotIn predicate on the "value" field.
-func ValueNotIn(vs ...string) predicate.Blocklist {
-	return predicate.Blocklist(sql.FieldNotIn(FieldValue, vs...))
-}
-
-// ValueGT applies the GT predicate on the "value" field.
-func ValueGT(v string) predicate.Blocklist {
-	return predicate.Blocklist(sql.FieldGT(FieldValue, v))
-}
-
-// ValueGTE applies the GTE predicate on the "value" field.
-func ValueGTE(v string) predicate.Blocklist {
-	return predicate.Blocklist(sql.FieldGTE(FieldValue, v))
-}
-
-// ValueLT applies the LT predicate on the "value" field.
-func ValueLT(v string) predicate.Blocklist {
-	return predicate.Blocklist(sql.FieldLT(FieldValue, v))
-}
-
-// ValueLTE applies the LTE predicate on the "value" field.
-func ValueLTE(v string) predicate.Blocklist {
-	return predicate.Blocklist(sql.FieldLTE(FieldValue, v))
-}
-
-// ValueContains applies the Contains predicate on the "value" field.
-func ValueContains(v string) predicate.Blocklist {
-	return predicate.Blocklist(sql.FieldContains(FieldValue, v))
-}
-
-// ValueHasPrefix applies the HasPrefix predicate on the "value" field.
-func ValueHasPrefix(v string) predicate.Blocklist {
-	return predicate.Blocklist(sql.FieldHasPrefix(FieldValue, v))
-}
-
-// ValueHasSuffix applies the HasSuffix predicate on the "value" field.
-func ValueHasSuffix(v string) predicate.Blocklist {
-	return predicate.Blocklist(sql.FieldHasSuffix(FieldValue, v))
-}
-
-// ValueEqualFold applies the EqualFold predicate on the "value" field.
-func ValueEqualFold(v string) predicate.Blocklist {
-	return predicate.Blocklist(sql.FieldEqualFold(FieldValue, v))
-}
-
-// ValueContainsFold applies the ContainsFold predicate on the "value" field.
-func ValueContainsFold(v string) predicate.Blocklist {
-	return predicate.Blocklist(sql.FieldContainsFold(FieldValue, v))
-}
-
-// And groups predicates with the AND operator between them.
-func And(predicates ...predicate.Blocklist) predicate.Blocklist {
-	return predicate.Blocklist(sql.AndPredicates(predicates...))
-}
-
-// Or groups predicates with the OR operator between them.
-func Or(predicates ...predicate.Blocklist) predicate.Blocklist {
-	return predicate.Blocklist(sql.OrPredicates(predicates...))
-}
-
-// Not applies the not operator on the given predicate.
-func Not(p predicate.Blocklist) predicate.Blocklist {
-	return predicate.Blocklist(sql.NotPredicates(p))
-}

ent/blocklist_update.go

@@ -1,269 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"polaris/ent/blocklist"
-	"polaris/ent/predicate"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/schema/field"
-)
-
-// BlocklistUpdate is the builder for updating Blocklist entities.
-type BlocklistUpdate struct {
-	config
-	hooks    []Hook
-	mutation *BlocklistMutation
-}
-
-// Where appends a list predicates to the BlocklistUpdate builder.
-func (bu *BlocklistUpdate) Where(ps ...predicate.Blocklist) *BlocklistUpdate {
-	bu.mutation.Where(ps...)
-	return bu
-}
-
-// SetType sets the "type" field.
-func (bu *BlocklistUpdate) SetType(b blocklist.Type) *BlocklistUpdate {
-	bu.mutation.SetType(b)
-	return bu
-}
-
-// SetNillableType sets the "type" field if the given value is not nil.
-func (bu *BlocklistUpdate) SetNillableType(b *blocklist.Type) *BlocklistUpdate {
-	if b != nil {
-		bu.SetType(*b)
-	}
-	return bu
-}
-
-// SetValue sets the "value" field.
-func (bu *BlocklistUpdate) SetValue(s string) *BlocklistUpdate {
-	bu.mutation.SetValue(s)
-	return bu
-}
-
-// SetNillableValue sets the "value" field if the given value is not nil.
-func (bu *BlocklistUpdate) SetNillableValue(s *string) *BlocklistUpdate {
-	if s != nil {
-		bu.SetValue(*s)
-	}
-	return bu
-}
-
-// Mutation returns the BlocklistMutation object of the builder.
-func (bu *BlocklistUpdate) Mutation() *BlocklistMutation {
-	return bu.mutation
-}
-
-// Save executes the query and returns the number of nodes affected by the update operation.
-func (bu *BlocklistUpdate) Save(ctx context.Context) (int, error) {
-	return withHooks(ctx, bu.sqlSave, bu.mutation, bu.hooks)
-}
-
-// SaveX is like Save, but panics if an error occurs.
-func (bu *BlocklistUpdate) SaveX(ctx context.Context) int {
-	affected, err := bu.Save(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return affected
-}
-
-// Exec executes the query.
-func (bu *BlocklistUpdate) Exec(ctx context.Context) error {
-	_, err := bu.Save(ctx)
-	return err
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (bu *BlocklistUpdate) ExecX(ctx context.Context) {
-	if err := bu.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
-
-// check runs all checks and user-defined validators on the builder.
-func (bu *BlocklistUpdate) check() error {
-	if v, ok := bu.mutation.GetType(); ok {
-		if err := blocklist.TypeValidator(v); err != nil {
-			return &ValidationError{Name: "type", err: fmt.Errorf(`ent: validator failed for field "Blocklist.type": %w`, err)}
-		}
-	}
-	return nil
-}
-
-func (bu *BlocklistUpdate) sqlSave(ctx context.Context) (n int, err error) {
-	if err := bu.check(); err != nil {
-		return n, err
-	}
-	_spec := sqlgraph.NewUpdateSpec(blocklist.Table, blocklist.Columns, sqlgraph.NewFieldSpec(blocklist.FieldID, field.TypeInt))
-	if ps := bu.mutation.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	if value, ok := bu.mutation.GetType(); ok {
-		_spec.SetField(blocklist.FieldType, field.TypeEnum, value)
-	}
-	if value, ok := bu.mutation.Value(); ok {
-		_spec.SetField(blocklist.FieldValue, field.TypeString, value)
-	}
-	if n, err = sqlgraph.UpdateNodes(ctx, bu.driver, _spec); err != nil {
-		if _, ok := err.(*sqlgraph.NotFoundError); ok {
-			err = &NotFoundError{blocklist.Label}
-		} else if sqlgraph.IsConstraintError(err) {
-			err = &ConstraintError{msg: err.Error(), wrap: err}
-		}
-		return 0, err
-	}
-	bu.mutation.done = true
-	return n, nil
-}
-
-// BlocklistUpdateOne is the builder for updating a single Blocklist entity.
-type BlocklistUpdateOne struct {
-	config
-	fields   []string
-	hooks    []Hook
-	mutation *BlocklistMutation
-}
-
-// SetType sets the "type" field.
-func (buo *BlocklistUpdateOne) SetType(b blocklist.Type) *BlocklistUpdateOne {
-	buo.mutation.SetType(b)
-	return buo
-}
-
-// SetNillableType sets the "type" field if the given value is not nil.
-func (buo *BlocklistUpdateOne) SetNillableType(b *blocklist.Type) *BlocklistUpdateOne {
-	if b != nil {
-		buo.SetType(*b)
-	}
-	return buo
-}
-
-// SetValue sets the "value" field.
-func (buo *BlocklistUpdateOne) SetValue(s string) *BlocklistUpdateOne {
-	buo.mutation.SetValue(s)
-	return buo
-}
-
-// SetNillableValue sets the "value" field if the given value is not nil.
-func (buo *BlocklistUpdateOne) SetNillableValue(s *string) *BlocklistUpdateOne {
-	if s != nil {
-		buo.SetValue(*s)
-	}
-	return buo
-}
-
-// Mutation returns the BlocklistMutation object of the builder.
-func (buo *BlocklistUpdateOne) Mutation() *BlocklistMutation {
-	return buo.mutation
-}
-
-// Where appends a list predicates to the BlocklistUpdate builder.
-func (buo *BlocklistUpdateOne) Where(ps ...predicate.Blocklist) *BlocklistUpdateOne {
-	buo.mutation.Where(ps...)
-	return buo
-}
-
-// Select allows selecting one or more fields (columns) of the returned entity.
-// The default is selecting all fields defined in the entity schema.
-func (buo *BlocklistUpdateOne) Select(field string, fields ...string) *BlocklistUpdateOne {
-	buo.fields = append([]string{field}, fields...)
-	return buo
-}
-
-// Save executes the query and returns the updated Blocklist entity.
-func (buo *BlocklistUpdateOne) Save(ctx context.Context) (*Blocklist, error) {
-	return withHooks(ctx, buo.sqlSave, buo.mutation, buo.hooks)
-}
-
-// SaveX is like Save, but panics if an error occurs.
-func (buo *BlocklistUpdateOne) SaveX(ctx context.Context) *Blocklist {
-	node, err := buo.Save(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return node
-}
-
-// Exec executes the query on the entity.
-func (buo *BlocklistUpdateOne) Exec(ctx context.Context) error {
-	_, err := buo.Save(ctx)
-	return err
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (buo *BlocklistUpdateOne) ExecX(ctx context.Context) {
-	if err := buo.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
-
-// check runs all checks and user-defined validators on the builder.
-func (buo *BlocklistUpdateOne) check() error {
-	if v, ok := buo.mutation.GetType(); ok {
-		if err := blocklist.TypeValidator(v); err != nil {
-			return &ValidationError{Name: "type", err: fmt.Errorf(`ent: validator failed for field "Blocklist.type": %w`, err)}
-		}
-	}
-	return nil
-}
-
-func (buo *BlocklistUpdateOne) sqlSave(ctx context.Context) (_node *Blocklist, err error) {
-	if err := buo.check(); err != nil {
-		return _node, err
-	}
-	_spec := sqlgraph.NewUpdateSpec(blocklist.Table, blocklist.Columns, sqlgraph.NewFieldSpec(blocklist.FieldID, field.TypeInt))
-	id, ok := buo.mutation.ID()
-	if !ok {
-		return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "Blocklist.id" for update`)}
-	}
-	_spec.Node.ID.Value = id
-	if fields := buo.fields; len(fields) > 0 {
-		_spec.Node.Columns = make([]string, 0, len(fields))
-		_spec.Node.Columns = append(_spec.Node.Columns, blocklist.FieldID)
-		for _, f := range fields {
-			if !blocklist.ValidColumn(f) {
-				return nil, &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
-			}
-			if f != blocklist.FieldID {
-				_spec.Node.Columns = append(_spec.Node.Columns, f)
-			}
-		}
-	}
-	if ps := buo.mutation.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	if value, ok := buo.mutation.GetType(); ok {
-		_spec.SetField(blocklist.FieldType, field.TypeEnum, value)
-	}
-	if value, ok := buo.mutation.Value(); ok {
-		_spec.SetField(blocklist.FieldValue, field.TypeString, value)
-	}
-	_node = &Blocklist{config: buo.config}
-	_spec.Assign = _node.assignValues
-	_spec.ScanValues = _node.scanValues
-	if err = sqlgraph.UpdateNode(ctx, buo.driver, _spec); err != nil {
-		if _, ok := err.(*sqlgraph.NotFoundError); ok {
-			err = &NotFoundError{blocklist.Label}
-		} else if sqlgraph.IsConstraintError(err) {
-			err = &ConstraintError{msg: err.Error(), wrap: err}
-		}
-		return nil, err
-	}
-	buo.mutation.done = true
-	return _node, nil
-}

ent/client.go

@@ -11,7 +11,7 @@ import (
 
 	"polaris/ent/migrate"
 
-	"polaris/ent/blocklist"
+	"polaris/ent/blacklist"
 	"polaris/ent/downloadclients"
 	"polaris/ent/episode"
 	"polaris/ent/history"
@@ -33,8 +33,8 @@ type Client struct {
 	config
 	// Schema is the client for creating, migrating and dropping schema.
 	Schema *migrate.Schema
-	// Blocklist is the client for interacting with the Blocklist builders.
-	Blocklist *BlocklistClient
+	// Blacklist is the client for interacting with the Blacklist builders.
+	Blacklist *BlacklistClient
 	// DownloadClients is the client for interacting with the DownloadClients builders.
 	DownloadClients *DownloadClientsClient
 	// Episode is the client for interacting with the Episode builders.
@@ -64,7 +64,7 @@ func NewClient(opts ...Option) *Client {
 
 func (c *Client) init() {
 	c.Schema = migrate.NewSchema(c.driver)
-	c.Blocklist = NewBlocklistClient(c.config)
+	c.Blacklist = NewBlacklistClient(c.config)
 	c.DownloadClients = NewDownloadClientsClient(c.config)
 	c.Episode = NewEpisodeClient(c.config)
 	c.History = NewHistoryClient(c.config)
@@ -166,7 +166,7 @@ func (c *Client) Tx(ctx context.Context) (*Tx, error) {
 	return &Tx{
 		ctx:                ctx,
 		config:             cfg,
-		Blocklist:          NewBlocklistClient(cfg),
+		Blacklist:          NewBlacklistClient(cfg),
 		DownloadClients:    NewDownloadClientsClient(cfg),
 		Episode:            NewEpisodeClient(cfg),
 		History:            NewHistoryClient(cfg),
@@ -195,7 +195,7 @@ func (c *Client) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error)
 	return &Tx{
 		ctx:                ctx,
 		config:             cfg,
-		Blocklist:          NewBlocklistClient(cfg),
+		Blacklist:          NewBlacklistClient(cfg),
 		DownloadClients:    NewDownloadClientsClient(cfg),
 		Episode:            NewEpisodeClient(cfg),
 		History:            NewHistoryClient(cfg),
@@ -211,7 +211,7 @@ func (c *Client) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error)
 // Debug returns a new debug-client. It's used to get verbose logging on specific operations.
 //
 //	client.Debug().
-//		Blocklist.
+//		Blacklist.
 //		Query().
 //		Count(ctx)
 func (c *Client) Debug() *Client {
@@ -234,7 +234,7 @@ 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.Blocklist, c.DownloadClients, c.Episode, c.History, c.ImportList, c.Indexers,
+		c.Blacklist, c.DownloadClients, c.Episode, c.History, c.ImportList, c.Indexers,
 		c.Media, c.NotificationClient, c.Settings, c.Storage,
 	} {
 		n.Use(hooks...)
@@ -245,7 +245,7 @@ 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.Blocklist, c.DownloadClients, c.Episode, c.History, c.ImportList, c.Indexers,
+		c.Blacklist, c.DownloadClients, c.Episode, c.History, c.ImportList, c.Indexers,
 		c.Media, c.NotificationClient, c.Settings, c.Storage,
 	} {
 		n.Intercept(interceptors...)
@@ -255,8 +255,8 @@ func (c *Client) Intercept(interceptors ...Interceptor) {
 // Mutate implements the ent.Mutator interface.
 func (c *Client) Mutate(ctx context.Context, m Mutation) (Value, error) {
 	switch m := m.(type) {
-	case *BlocklistMutation:
-		return c.Blocklist.mutate(ctx, m)
+	case *BlacklistMutation:
+		return c.Blacklist.mutate(ctx, m)
 	case *DownloadClientsMutation:
 		return c.DownloadClients.mutate(ctx, m)
 	case *EpisodeMutation:
@@ -280,107 +280,107 @@ func (c *Client) Mutate(ctx context.Context, m Mutation) (Value, error) {
 	}
 }
 
-// BlocklistClient is a client for the Blocklist schema.
-type BlocklistClient struct {
+// BlacklistClient is a client for the Blacklist schema.
+type BlacklistClient struct {
 	config
 }
 
-// NewBlocklistClient returns a client for the Blocklist from the given config.
-func NewBlocklistClient(c config) *BlocklistClient {
-	return &BlocklistClient{config: c}
+// NewBlacklistClient returns a client for the Blacklist from the given config.
+func NewBlacklistClient(c config) *BlacklistClient {
+	return &BlacklistClient{config: c}
 }
 
 // Use adds a list of mutation hooks to the hooks stack.
-// A call to `Use(f, g, h)` equals to `blocklist.Hooks(f(g(h())))`.
-func (c *BlocklistClient) Use(hooks ...Hook) {
-	c.hooks.Blocklist = append(c.hooks.Blocklist, hooks...)
+// A call to `Use(f, g, h)` equals to `blacklist.Hooks(f(g(h())))`.
+func (c *BlacklistClient) Use(hooks ...Hook) {
+	c.hooks.Blacklist = append(c.hooks.Blacklist, hooks...)
 }
 
 // Intercept adds a list of query interceptors to the interceptors stack.
-// A call to `Intercept(f, g, h)` equals to `blocklist.Intercept(f(g(h())))`.
-func (c *BlocklistClient) Intercept(interceptors ...Interceptor) {
-	c.inters.Blocklist = append(c.inters.Blocklist, interceptors...)
+// A call to `Intercept(f, g, h)` equals to `blacklist.Intercept(f(g(h())))`.
+func (c *BlacklistClient) Intercept(interceptors ...Interceptor) {
+	c.inters.Blacklist = append(c.inters.Blacklist, interceptors...)
 }
 
-// Create returns a builder for creating a Blocklist entity.
-func (c *BlocklistClient) Create() *BlocklistCreate {
-	mutation := newBlocklistMutation(c.config, OpCreate)
-	return &BlocklistCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+// Create returns a builder for creating a Blacklist entity.
+func (c *BlacklistClient) Create() *BlacklistCreate {
+	mutation := newBlacklistMutation(c.config, OpCreate)
+	return &BlacklistCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
 }
 
-// CreateBulk returns a builder for creating a bulk of Blocklist entities.
-func (c *BlocklistClient) CreateBulk(builders ...*BlocklistCreate) *BlocklistCreateBulk {
-	return &BlocklistCreateBulk{config: c.config, builders: builders}
+// CreateBulk returns a builder for creating a bulk of Blacklist entities.
+func (c *BlacklistClient) CreateBulk(builders ...*BlacklistCreate) *BlacklistCreateBulk {
+	return &BlacklistCreateBulk{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 *BlocklistClient) MapCreateBulk(slice any, setFunc func(*BlocklistCreate, int)) *BlocklistCreateBulk {
+func (c *BlacklistClient) MapCreateBulk(slice any, setFunc func(*BlacklistCreate, int)) *BlacklistCreateBulk {
 	rv := reflect.ValueOf(slice)
 	if rv.Kind() != reflect.Slice {
-		return &BlocklistCreateBulk{err: fmt.Errorf("calling to BlocklistClient.MapCreateBulk with wrong type %T, need slice", slice)}
+		return &BlacklistCreateBulk{err: fmt.Errorf("calling to BlacklistClient.MapCreateBulk with wrong type %T, need slice", slice)}
 	}
-	builders := make([]*BlocklistCreate, rv.Len())
+	builders := make([]*BlacklistCreate, rv.Len())
 	for i := 0; i < rv.Len(); i++ {
 		builders[i] = c.Create()
 		setFunc(builders[i], i)
 	}
-	return &BlocklistCreateBulk{config: c.config, builders: builders}
+	return &BlacklistCreateBulk{config: c.config, builders: builders}
 }
 
-// Update returns an update builder for Blocklist.
-func (c *BlocklistClient) Update() *BlocklistUpdate {
-	mutation := newBlocklistMutation(c.config, OpUpdate)
-	return &BlocklistUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+// Update returns an update builder for Blacklist.
+func (c *BlacklistClient) Update() *BlacklistUpdate {
+	mutation := newBlacklistMutation(c.config, OpUpdate)
+	return &BlacklistUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
 }
 
 // UpdateOne returns an update builder for the given entity.
-func (c *BlocklistClient) UpdateOne(b *Blocklist) *BlocklistUpdateOne {
-	mutation := newBlocklistMutation(c.config, OpUpdateOne, withBlocklist(b))
-	return &BlocklistUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+func (c *BlacklistClient) UpdateOne(b *Blacklist) *BlacklistUpdateOne {
+	mutation := newBlacklistMutation(c.config, OpUpdateOne, withBlacklist(b))
+	return &BlacklistUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
 }
 
 // UpdateOneID returns an update builder for the given id.
-func (c *BlocklistClient) UpdateOneID(id int) *BlocklistUpdateOne {
-	mutation := newBlocklistMutation(c.config, OpUpdateOne, withBlocklistID(id))
-	return &BlocklistUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+func (c *BlacklistClient) UpdateOneID(id int) *BlacklistUpdateOne {
+	mutation := newBlacklistMutation(c.config, OpUpdateOne, withBlacklistID(id))
+	return &BlacklistUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
 }
 
-// Delete returns a delete builder for Blocklist.
-func (c *BlocklistClient) Delete() *BlocklistDelete {
-	mutation := newBlocklistMutation(c.config, OpDelete)
-	return &BlocklistDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
+// Delete returns a delete builder for Blacklist.
+func (c *BlacklistClient) Delete() *BlacklistDelete {
+	mutation := newBlacklistMutation(c.config, OpDelete)
+	return &BlacklistDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
 }
 
 // DeleteOne returns a builder for deleting the given entity.
-func (c *BlocklistClient) DeleteOne(b *Blocklist) *BlocklistDeleteOne {
+func (c *BlacklistClient) DeleteOne(b *Blacklist) *BlacklistDeleteOne {
 	return c.DeleteOneID(b.ID)
 }
 
 // DeleteOneID returns a builder for deleting the given entity by its id.
-func (c *BlocklistClient) DeleteOneID(id int) *BlocklistDeleteOne {
-	builder := c.Delete().Where(blocklist.ID(id))
+func (c *BlacklistClient) DeleteOneID(id int) *BlacklistDeleteOne {
+	builder := c.Delete().Where(blacklist.ID(id))
 	builder.mutation.id = &id
 	builder.mutation.op = OpDeleteOne
-	return &BlocklistDeleteOne{builder}
+	return &BlacklistDeleteOne{builder}
 }
 
-// Query returns a query builder for Blocklist.
-func (c *BlocklistClient) Query() *BlocklistQuery {
-	return &BlocklistQuery{
+// Query returns a query builder for Blacklist.
+func (c *BlacklistClient) Query() *BlacklistQuery {
+	return &BlacklistQuery{
 		config: c.config,
-		ctx:    &QueryContext{Type: TypeBlocklist},
+		ctx:    &QueryContext{Type: TypeBlacklist},
 		inters: c.Interceptors(),
 	}
 }
 
-// Get returns a Blocklist entity by its id.
-func (c *BlocklistClient) Get(ctx context.Context, id int) (*Blocklist, error) {
-	return c.Query().Where(blocklist.ID(id)).Only(ctx)
+// Get returns a Blacklist entity by its id.
+func (c *BlacklistClient) Get(ctx context.Context, id int) (*Blacklist, error) {
+	return c.Query().Where(blacklist.ID(id)).Only(ctx)
 }
 
 // GetX is like Get, but panics if an error occurs.
-func (c *BlocklistClient) GetX(ctx context.Context, id int) *Blocklist {
+func (c *BlacklistClient) GetX(ctx context.Context, id int) *Blacklist {
 	obj, err := c.Get(ctx, id)
 	if err != nil {
 		panic(err)
@@ -389,27 +389,27 @@ func (c *BlocklistClient) GetX(ctx context.Context, id int) *Blocklist {
 }
 
 // Hooks returns the client hooks.
-func (c *BlocklistClient) Hooks() []Hook {
-	return c.hooks.Blocklist
+func (c *BlacklistClient) Hooks() []Hook {
+	return c.hooks.Blacklist
 }
 
 // Interceptors returns the client interceptors.
-func (c *BlocklistClient) Interceptors() []Interceptor {
-	return c.inters.Blocklist
+func (c *BlacklistClient) Interceptors() []Interceptor {
+	return c.inters.Blacklist
 }
 
-func (c *BlocklistClient) mutate(ctx context.Context, m *BlocklistMutation) (Value, error) {
+func (c *BlacklistClient) mutate(ctx context.Context, m *BlacklistMutation) (Value, error) {
 	switch m.Op() {
 	case OpCreate:
-		return (&BlocklistCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+		return (&BlacklistCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
 	case OpUpdate:
-		return (&BlocklistUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+		return (&BlacklistUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
 	case OpUpdateOne:
-		return (&BlocklistUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+		return (&BlacklistUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
 	case OpDelete, OpDeleteOne:
-		return (&BlocklistDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+		return (&BlacklistDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
 	default:
-		return nil, fmt.Errorf("ent: unknown Blocklist mutation op: %q", m.Op())
+		return nil, fmt.Errorf("ent: unknown Blacklist mutation op: %q", m.Op())
 	}
 }
 
@@ -1645,11 +1645,11 @@ func (c *StorageClient) mutate(ctx context.Context, m *StorageMutation) (Value,
 // hooks and interceptors per client, for fast access.
 type (
 	hooks struct {
-		Blocklist, DownloadClients, Episode, History, ImportList, Indexers, Media,
+		Blacklist, DownloadClients, Episode, History, ImportList, Indexers, Media,
 		NotificationClient, Settings, Storage []ent.Hook
 	}
 	inters struct {
-		Blocklist, DownloadClients, Episode, History, ImportList, Indexers, Media,
+		Blacklist, DownloadClients, Episode, History, ImportList, Indexers, Media,
 		NotificationClient, Settings, Storage []ent.Interceptor
 	}
 )

ent/downloadclients.go

@@ -21,7 +21,7 @@ type DownloadClients struct {
 	// Name holds the value of the "name" field.
 	Name string `json:"name,omitempty"`
 	// Implementation holds the value of the "implementation" field.
-	Implementation string `json:"implementation,omitempty"`
+	Implementation downloadclients.Implementation `json:"implementation,omitempty"`
 	// URL holds the value of the "url" field.
 	URL string `json:"url,omitempty"`
 	// User holds the value of the "user" field.
@@ -30,8 +30,8 @@ type DownloadClients struct {
 	Password string `json:"password,omitempty"`
 	// Settings holds the value of the "settings" field.
 	Settings string `json:"settings,omitempty"`
-	// Priority holds the value of the "priority" field.
-	Priority string `json:"priority,omitempty"`
+	// Priority1 holds the value of the "priority1" field.
+	Priority1 int `json:"priority1,omitempty"`
 	// RemoveCompletedDownloads holds the value of the "remove_completed_downloads" field.
 	RemoveCompletedDownloads bool `json:"remove_completed_downloads,omitempty"`
 	// RemoveFailedDownloads holds the value of the "remove_failed_downloads" field.
@@ -48,9 +48,9 @@ func (*DownloadClients) scanValues(columns []string) ([]any, error) {
 		switch columns[i] {
 		case downloadclients.FieldEnable, downloadclients.FieldRemoveCompletedDownloads, downloadclients.FieldRemoveFailedDownloads:
 			values[i] = new(sql.NullBool)
-		case downloadclients.FieldID:
+		case downloadclients.FieldID, downloadclients.FieldPriority1:
 			values[i] = new(sql.NullInt64)
-		case downloadclients.FieldName, downloadclients.FieldImplementation, downloadclients.FieldURL, downloadclients.FieldUser, downloadclients.FieldPassword, downloadclients.FieldSettings, downloadclients.FieldPriority, downloadclients.FieldTags:
+		case downloadclients.FieldName, downloadclients.FieldImplementation, downloadclients.FieldURL, downloadclients.FieldUser, downloadclients.FieldPassword, downloadclients.FieldSettings, downloadclients.FieldTags:
 			values[i] = new(sql.NullString)
 		default:
 			values[i] = new(sql.UnknownType)
@@ -89,7 +89,7 @@ func (dc *DownloadClients) assignValues(columns []string, values []any) error {
 			if value, ok := values[i].(*sql.NullString); !ok {
 				return fmt.Errorf("unexpected type %T for field implementation", values[i])
 			} else if value.Valid {
-				dc.Implementation = value.String
+				dc.Implementation = downloadclients.Implementation(value.String)
 			}
 		case downloadclients.FieldURL:
 			if value, ok := values[i].(*sql.NullString); !ok {
@@ -115,11 +115,11 @@ func (dc *DownloadClients) assignValues(columns []string, values []any) error {
 			} else if value.Valid {
 				dc.Settings = value.String
 			}
-		case downloadclients.FieldPriority:
-			if value, ok := values[i].(*sql.NullString); !ok {
-				return fmt.Errorf("unexpected type %T for field priority", values[i])
+		case downloadclients.FieldPriority1:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field priority1", values[i])
 			} else if value.Valid {
-				dc.Priority = value.String
+				dc.Priority1 = int(value.Int64)
 			}
 		case downloadclients.FieldRemoveCompletedDownloads:
 			if value, ok := values[i].(*sql.NullBool); !ok {
@@ -182,7 +182,7 @@ func (dc *DownloadClients) String() string {
 	builder.WriteString(dc.Name)
 	builder.WriteString(", ")
 	builder.WriteString("implementation=")
-	builder.WriteString(dc.Implementation)
+	builder.WriteString(fmt.Sprintf("%v", dc.Implementation))
 	builder.WriteString(", ")
 	builder.WriteString("url=")
 	builder.WriteString(dc.URL)
@@ -196,8 +196,8 @@ func (dc *DownloadClients) String() string {
 	builder.WriteString("settings=")
 	builder.WriteString(dc.Settings)
 	builder.WriteString(", ")
-	builder.WriteString("priority=")
-	builder.WriteString(dc.Priority)
+	builder.WriteString("priority1=")
+	builder.WriteString(fmt.Sprintf("%v", dc.Priority1))
 	builder.WriteString(", ")
 	builder.WriteString("remove_completed_downloads=")
 	builder.WriteString(fmt.Sprintf("%v", dc.RemoveCompletedDownloads))

ent/downloadclients/downloadclients.go

@@ -3,6 +3,8 @@
 package downloadclients
 
 import (
+	"fmt"
+
 	"entgo.io/ent/dialect/sql"
 )
 
@@ -25,8 +27,8 @@ const (
 	FieldPassword = "password"
 	// FieldSettings holds the string denoting the settings field in the database.
 	FieldSettings = "settings"
-	// FieldPriority holds the string denoting the priority field in the database.
-	FieldPriority = "priority"
+	// FieldPriority1 holds the string denoting the priority1 field in the database.
+	FieldPriority1 = "priority1"
 	// FieldRemoveCompletedDownloads holds the string denoting the remove_completed_downloads field in the database.
 	FieldRemoveCompletedDownloads = "remove_completed_downloads"
 	// FieldRemoveFailedDownloads holds the string denoting the remove_failed_downloads field in the database.
@@ -47,7 +49,7 @@ var Columns = []string{
 	FieldUser,
 	FieldPassword,
 	FieldSettings,
-	FieldPriority,
+	FieldPriority1,
 	FieldRemoveCompletedDownloads,
 	FieldRemoveFailedDownloads,
 	FieldTags,
@@ -70,8 +72,10 @@ var (
 	DefaultPassword string
 	// DefaultSettings holds the default value on creation for the "settings" field.
 	DefaultSettings string
-	// DefaultPriority holds the default value on creation for the "priority" field.
-	DefaultPriority string
+	// DefaultPriority1 holds the default value on creation for the "priority1" field.
+	DefaultPriority1 int
+	// Priority1Validator is a validator for the "priority1" field. It is called by the builders before save.
+	Priority1Validator func(int) error
 	// DefaultRemoveCompletedDownloads holds the default value on creation for the "remove_completed_downloads" field.
 	DefaultRemoveCompletedDownloads bool
 	// DefaultRemoveFailedDownloads holds the default value on creation for the "remove_failed_downloads" field.
@@ -80,6 +84,30 @@ var (
 	DefaultTags string
 )
 
+// Implementation defines the type for the "implementation" enum field.
+type Implementation string
+
+// Implementation values.
+const (
+	ImplementationTransmission Implementation = "transmission"
+	ImplementationQbittorrent  Implementation = "qbittorrent"
+	ImplementationBuildin      Implementation = "buildin"
+)
+
+func (i Implementation) String() string {
+	return string(i)
+}
+
+// ImplementationValidator is a validator for the "implementation" field enum values. It is called by the builders before save.
+func ImplementationValidator(i Implementation) error {
+	switch i {
+	case ImplementationTransmission, ImplementationQbittorrent, ImplementationBuildin:
+		return nil
+	default:
+		return fmt.Errorf("downloadclients: invalid enum value for implementation field: %q", i)
+	}
+}
+
 // OrderOption defines the ordering options for the DownloadClients queries.
 type OrderOption func(*sql.Selector)
 
@@ -123,9 +151,9 @@ func BySettings(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldSettings, opts...).ToFunc()
 }
 
-// ByPriority orders the results by the priority field.
-func ByPriority(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldPriority, opts...).ToFunc()
+// ByPriority1 orders the results by the priority1 field.
+func ByPriority1(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldPriority1, opts...).ToFunc()
 }
 
 // ByRemoveCompletedDownloads orders the results by the remove_completed_downloads field.

ent/downloadclients/where.go

@@ -63,11 +63,6 @@ func Name(v string) predicate.DownloadClients {
 	return predicate.DownloadClients(sql.FieldEQ(FieldName, v))
 }
 
-// Implementation applies equality check predicate on the "implementation" field. It's identical to ImplementationEQ.
-func Implementation(v string) predicate.DownloadClients {
-	return predicate.DownloadClients(sql.FieldEQ(FieldImplementation, v))
-}
-
 // URL applies equality check predicate on the "url" field. It's identical to URLEQ.
 func URL(v string) predicate.DownloadClients {
 	return predicate.DownloadClients(sql.FieldEQ(FieldURL, v))
@@ -88,9 +83,9 @@ func Settings(v string) predicate.DownloadClients {
 	return predicate.DownloadClients(sql.FieldEQ(FieldSettings, v))
 }
 
-// Priority applies equality check predicate on the "priority" field. It's identical to PriorityEQ.
-func Priority(v string) predicate.DownloadClients {
-	return predicate.DownloadClients(sql.FieldEQ(FieldPriority, v))
+// Priority1 applies equality check predicate on the "priority1" field. It's identical to Priority1EQ.
+func Priority1(v int) predicate.DownloadClients {
+	return predicate.DownloadClients(sql.FieldEQ(FieldPriority1, v))
 }
 
 // RemoveCompletedDownloads applies equality check predicate on the "remove_completed_downloads" field. It's identical to RemoveCompletedDownloadsEQ.
@@ -184,70 +179,25 @@ func NameContainsFold(v string) predicate.DownloadClients {
 }
 
 // ImplementationEQ applies the EQ predicate on the "implementation" field.
-func ImplementationEQ(v string) predicate.DownloadClients {
+func ImplementationEQ(v Implementation) predicate.DownloadClients {
 	return predicate.DownloadClients(sql.FieldEQ(FieldImplementation, v))
 }
 
 // ImplementationNEQ applies the NEQ predicate on the "implementation" field.
-func ImplementationNEQ(v string) predicate.DownloadClients {
+func ImplementationNEQ(v Implementation) predicate.DownloadClients {
 	return predicate.DownloadClients(sql.FieldNEQ(FieldImplementation, v))
 }
 
 // ImplementationIn applies the In predicate on the "implementation" field.
-func ImplementationIn(vs ...string) predicate.DownloadClients {
+func ImplementationIn(vs ...Implementation) predicate.DownloadClients {
 	return predicate.DownloadClients(sql.FieldIn(FieldImplementation, vs...))
 }
 
 // ImplementationNotIn applies the NotIn predicate on the "implementation" field.
-func ImplementationNotIn(vs ...string) predicate.DownloadClients {
+func ImplementationNotIn(vs ...Implementation) predicate.DownloadClients {
 	return predicate.DownloadClients(sql.FieldNotIn(FieldImplementation, vs...))
 }
 
-// ImplementationGT applies the GT predicate on the "implementation" field.
-func ImplementationGT(v string) predicate.DownloadClients {
-	return predicate.DownloadClients(sql.FieldGT(FieldImplementation, v))
-}
-
-// ImplementationGTE applies the GTE predicate on the "implementation" field.
-func ImplementationGTE(v string) predicate.DownloadClients {
-	return predicate.DownloadClients(sql.FieldGTE(FieldImplementation, v))
-}
-
-// ImplementationLT applies the LT predicate on the "implementation" field.
-func ImplementationLT(v string) predicate.DownloadClients {
-	return predicate.DownloadClients(sql.FieldLT(FieldImplementation, v))
-}
-
-// ImplementationLTE applies the LTE predicate on the "implementation" field.
-func ImplementationLTE(v string) predicate.DownloadClients {
-	return predicate.DownloadClients(sql.FieldLTE(FieldImplementation, v))
-}
-
-// ImplementationContains applies the Contains predicate on the "implementation" field.
-func ImplementationContains(v string) predicate.DownloadClients {
-	return predicate.DownloadClients(sql.FieldContains(FieldImplementation, v))
-}
-
-// ImplementationHasPrefix applies the HasPrefix predicate on the "implementation" field.
-func ImplementationHasPrefix(v string) predicate.DownloadClients {
-	return predicate.DownloadClients(sql.FieldHasPrefix(FieldImplementation, v))
-}
-
-// ImplementationHasSuffix applies the HasSuffix predicate on the "implementation" field.
-func ImplementationHasSuffix(v string) predicate.DownloadClients {
-	return predicate.DownloadClients(sql.FieldHasSuffix(FieldImplementation, v))
-}
-
-// ImplementationEqualFold applies the EqualFold predicate on the "implementation" field.
-func ImplementationEqualFold(v string) predicate.DownloadClients {
-	return predicate.DownloadClients(sql.FieldEqualFold(FieldImplementation, v))
-}
-
-// ImplementationContainsFold applies the ContainsFold predicate on the "implementation" field.
-func ImplementationContainsFold(v string) predicate.DownloadClients {
-	return predicate.DownloadClients(sql.FieldContainsFold(FieldImplementation, v))
-}
-
 // URLEQ applies the EQ predicate on the "url" field.
 func URLEQ(v string) predicate.DownloadClients {
 	return predicate.DownloadClients(sql.FieldEQ(FieldURL, v))
@@ -508,69 +458,44 @@ func SettingsContainsFold(v string) predicate.DownloadClients {
 	return predicate.DownloadClients(sql.FieldContainsFold(FieldSettings, v))
 }
 
-// PriorityEQ applies the EQ predicate on the "priority" field.
-func PriorityEQ(v string) predicate.DownloadClients {
-	return predicate.DownloadClients(sql.FieldEQ(FieldPriority, v))
+// Priority1EQ applies the EQ predicate on the "priority1" field.
+func Priority1EQ(v int) predicate.DownloadClients {
+	return predicate.DownloadClients(sql.FieldEQ(FieldPriority1, v))
 }
 
-// PriorityNEQ applies the NEQ predicate on the "priority" field.
-func PriorityNEQ(v string) predicate.DownloadClients {
-	return predicate.DownloadClients(sql.FieldNEQ(FieldPriority, v))
+// Priority1NEQ applies the NEQ predicate on the "priority1" field.
+func Priority1NEQ(v int) predicate.DownloadClients {
+	return predicate.DownloadClients(sql.FieldNEQ(FieldPriority1, v))
 }
 
-// PriorityIn applies the In predicate on the "priority" field.
-func PriorityIn(vs ...string) predicate.DownloadClients {
-	return predicate.DownloadClients(sql.FieldIn(FieldPriority, vs...))
+// Priority1In applies the In predicate on the "priority1" field.
+func Priority1In(vs ...int) predicate.DownloadClients {
+	return predicate.DownloadClients(sql.FieldIn(FieldPriority1, vs...))
 }
 
-// PriorityNotIn applies the NotIn predicate on the "priority" field.
-func PriorityNotIn(vs ...string) predicate.DownloadClients {
-	return predicate.DownloadClients(sql.FieldNotIn(FieldPriority, vs...))
+// Priority1NotIn applies the NotIn predicate on the "priority1" field.
+func Priority1NotIn(vs ...int) predicate.DownloadClients {
+	return predicate.DownloadClients(sql.FieldNotIn(FieldPriority1, vs...))
 }
 
-// PriorityGT applies the GT predicate on the "priority" field.
-func PriorityGT(v string) predicate.DownloadClients {
-	return predicate.DownloadClients(sql.FieldGT(FieldPriority, v))
+// Priority1GT applies the GT predicate on the "priority1" field.
+func Priority1GT(v int) predicate.DownloadClients {
+	return predicate.DownloadClients(sql.FieldGT(FieldPriority1, v))
 }
 
-// PriorityGTE applies the GTE predicate on the "priority" field.
-func PriorityGTE(v string) predicate.DownloadClients {
-	return predicate.DownloadClients(sql.FieldGTE(FieldPriority, v))
+// Priority1GTE applies the GTE predicate on the "priority1" field.
+func Priority1GTE(v int) predicate.DownloadClients {
+	return predicate.DownloadClients(sql.FieldGTE(FieldPriority1, v))
 }
 
-// PriorityLT applies the LT predicate on the "priority" field.
-func PriorityLT(v string) predicate.DownloadClients {
-	return predicate.DownloadClients(sql.FieldLT(FieldPriority, v))
+// Priority1LT applies the LT predicate on the "priority1" field.
+func Priority1LT(v int) predicate.DownloadClients {
+	return predicate.DownloadClients(sql.FieldLT(FieldPriority1, v))
 }
 
-// PriorityLTE applies the LTE predicate on the "priority" field.
-func PriorityLTE(v string) predicate.DownloadClients {
-	return predicate.DownloadClients(sql.FieldLTE(FieldPriority, v))
-}
-
-// PriorityContains applies the Contains predicate on the "priority" field.
-func PriorityContains(v string) predicate.DownloadClients {
-	return predicate.DownloadClients(sql.FieldContains(FieldPriority, v))
-}
-
-// PriorityHasPrefix applies the HasPrefix predicate on the "priority" field.
-func PriorityHasPrefix(v string) predicate.DownloadClients {
-	return predicate.DownloadClients(sql.FieldHasPrefix(FieldPriority, v))
-}
-
-// PriorityHasSuffix applies the HasSuffix predicate on the "priority" field.
-func PriorityHasSuffix(v string) predicate.DownloadClients {
-	return predicate.DownloadClients(sql.FieldHasSuffix(FieldPriority, v))
-}
-
-// PriorityEqualFold applies the EqualFold predicate on the "priority" field.
-func PriorityEqualFold(v string) predicate.DownloadClients {
-	return predicate.DownloadClients(sql.FieldEqualFold(FieldPriority, v))
-}
-
-// PriorityContainsFold applies the ContainsFold predicate on the "priority" field.
-func PriorityContainsFold(v string) predicate.DownloadClients {
-	return predicate.DownloadClients(sql.FieldContainsFold(FieldPriority, v))
+// Priority1LTE applies the LTE predicate on the "priority1" field.
+func Priority1LTE(v int) predicate.DownloadClients {
+	return predicate.DownloadClients(sql.FieldLTE(FieldPriority1, v))
 }
 
 // RemoveCompletedDownloadsEQ applies the EQ predicate on the "remove_completed_downloads" field.

ent/downloadclients_create.go

@@ -32,8 +32,8 @@ func (dcc *DownloadClientsCreate) SetName(s string) *DownloadClientsCreate {
 }
 
 // SetImplementation sets the "implementation" field.
-func (dcc *DownloadClientsCreate) SetImplementation(s string) *DownloadClientsCreate {
-	dcc.mutation.SetImplementation(s)
+func (dcc *DownloadClientsCreate) SetImplementation(d downloadclients.Implementation) *DownloadClientsCreate {
+	dcc.mutation.SetImplementation(d)
 	return dcc
 }
 
@@ -85,16 +85,16 @@ func (dcc *DownloadClientsCreate) SetNillableSettings(s *string) *DownloadClient
 	return dcc
 }
 
-// SetPriority sets the "priority" field.
-func (dcc *DownloadClientsCreate) SetPriority(s string) *DownloadClientsCreate {
-	dcc.mutation.SetPriority(s)
+// SetPriority1 sets the "priority1" field.
+func (dcc *DownloadClientsCreate) SetPriority1(i int) *DownloadClientsCreate {
+	dcc.mutation.SetPriority1(i)
 	return dcc
 }
 
-// SetNillablePriority sets the "priority" field if the given value is not nil.
-func (dcc *DownloadClientsCreate) SetNillablePriority(s *string) *DownloadClientsCreate {
-	if s != nil {
-		dcc.SetPriority(*s)
+// SetNillablePriority1 sets the "priority1" field if the given value is not nil.
+func (dcc *DownloadClientsCreate) SetNillablePriority1(i *int) *DownloadClientsCreate {
+	if i != nil {
+		dcc.SetPriority1(*i)
 	}
 	return dcc
 }
@@ -188,9 +188,9 @@ func (dcc *DownloadClientsCreate) defaults() {
 		v := downloadclients.DefaultSettings
 		dcc.mutation.SetSettings(v)
 	}
-	if _, ok := dcc.mutation.Priority(); !ok {
-		v := downloadclients.DefaultPriority
-		dcc.mutation.SetPriority(v)
+	if _, ok := dcc.mutation.Priority1(); !ok {
+		v := downloadclients.DefaultPriority1
+		dcc.mutation.SetPriority1(v)
 	}
 	if _, ok := dcc.mutation.RemoveCompletedDownloads(); !ok {
 		v := downloadclients.DefaultRemoveCompletedDownloads
@@ -217,6 +217,11 @@ func (dcc *DownloadClientsCreate) check() error {
 	if _, ok := dcc.mutation.Implementation(); !ok {
 		return &ValidationError{Name: "implementation", err: errors.New(`ent: missing required field "DownloadClients.implementation"`)}
 	}
+	if v, ok := dcc.mutation.Implementation(); ok {
+		if err := downloadclients.ImplementationValidator(v); err != nil {
+			return &ValidationError{Name: "implementation", err: fmt.Errorf(`ent: validator failed for field "DownloadClients.implementation": %w`, err)}
+		}
+	}
 	if _, ok := dcc.mutation.URL(); !ok {
 		return &ValidationError{Name: "url", err: errors.New(`ent: missing required field "DownloadClients.url"`)}
 	}
@@ -229,8 +234,13 @@ func (dcc *DownloadClientsCreate) check() error {
 	if _, ok := dcc.mutation.Settings(); !ok {
 		return &ValidationError{Name: "settings", err: errors.New(`ent: missing required field "DownloadClients.settings"`)}
 	}
-	if _, ok := dcc.mutation.Priority(); !ok {
-		return &ValidationError{Name: "priority", err: errors.New(`ent: missing required field "DownloadClients.priority"`)}
+	if _, ok := dcc.mutation.Priority1(); !ok {
+		return &ValidationError{Name: "priority1", err: errors.New(`ent: missing required field "DownloadClients.priority1"`)}
+	}
+	if v, ok := dcc.mutation.Priority1(); ok {
+		if err := downloadclients.Priority1Validator(v); err != nil {
+			return &ValidationError{Name: "priority1", err: fmt.Errorf(`ent: validator failed for field "DownloadClients.priority1": %w`, err)}
+		}
 	}
 	if _, ok := dcc.mutation.RemoveCompletedDownloads(); !ok {
 		return &ValidationError{Name: "remove_completed_downloads", err: errors.New(`ent: missing required field "DownloadClients.remove_completed_downloads"`)}
@@ -276,7 +286,7 @@ func (dcc *DownloadClientsCreate) createSpec() (*DownloadClients, *sqlgraph.Crea
 		_node.Name = value
 	}
 	if value, ok := dcc.mutation.Implementation(); ok {
-		_spec.SetField(downloadclients.FieldImplementation, field.TypeString, value)
+		_spec.SetField(downloadclients.FieldImplementation, field.TypeEnum, value)
 		_node.Implementation = value
 	}
 	if value, ok := dcc.mutation.URL(); ok {
@@ -295,9 +305,9 @@ func (dcc *DownloadClientsCreate) createSpec() (*DownloadClients, *sqlgraph.Crea
 		_spec.SetField(downloadclients.FieldSettings, field.TypeString, value)
 		_node.Settings = value
 	}
-	if value, ok := dcc.mutation.Priority(); ok {
-		_spec.SetField(downloadclients.FieldPriority, field.TypeString, value)
-		_node.Priority = value
+	if value, ok := dcc.mutation.Priority1(); ok {
+		_spec.SetField(downloadclients.FieldPriority1, field.TypeInt, value)
+		_node.Priority1 = value
 	}
 	if value, ok := dcc.mutation.RemoveCompletedDownloads(); ok {
 		_spec.SetField(downloadclients.FieldRemoveCompletedDownloads, field.TypeBool, value)

ent/downloadclients_update.go

@@ -56,15 +56,15 @@ func (dcu *DownloadClientsUpdate) SetNillableName(s *string) *DownloadClientsUpd
 }
 
 // SetImplementation sets the "implementation" field.
-func (dcu *DownloadClientsUpdate) SetImplementation(s string) *DownloadClientsUpdate {
-	dcu.mutation.SetImplementation(s)
+func (dcu *DownloadClientsUpdate) SetImplementation(d downloadclients.Implementation) *DownloadClientsUpdate {
+	dcu.mutation.SetImplementation(d)
 	return dcu
 }
 
 // SetNillableImplementation sets the "implementation" field if the given value is not nil.
-func (dcu *DownloadClientsUpdate) SetNillableImplementation(s *string) *DownloadClientsUpdate {
-	if s != nil {
-		dcu.SetImplementation(*s)
+func (dcu *DownloadClientsUpdate) SetNillableImplementation(d *downloadclients.Implementation) *DownloadClientsUpdate {
+	if d != nil {
+		dcu.SetImplementation(*d)
 	}
 	return dcu
 }
@@ -125,20 +125,27 @@ func (dcu *DownloadClientsUpdate) SetNillableSettings(s *string) *DownloadClient
 	return dcu
 }
 
-// SetPriority sets the "priority" field.
-func (dcu *DownloadClientsUpdate) SetPriority(s string) *DownloadClientsUpdate {
-	dcu.mutation.SetPriority(s)
+// SetPriority1 sets the "priority1" field.
+func (dcu *DownloadClientsUpdate) SetPriority1(i int) *DownloadClientsUpdate {
+	dcu.mutation.ResetPriority1()
+	dcu.mutation.SetPriority1(i)
 	return dcu
 }
 
-// SetNillablePriority sets the "priority" field if the given value is not nil.
-func (dcu *DownloadClientsUpdate) SetNillablePriority(s *string) *DownloadClientsUpdate {
-	if s != nil {
-		dcu.SetPriority(*s)
+// SetNillablePriority1 sets the "priority1" field if the given value is not nil.
+func (dcu *DownloadClientsUpdate) SetNillablePriority1(i *int) *DownloadClientsUpdate {
+	if i != nil {
+		dcu.SetPriority1(*i)
 	}
 	return dcu
 }
 
+// AddPriority1 adds i to the "priority1" field.
+func (dcu *DownloadClientsUpdate) AddPriority1(i int) *DownloadClientsUpdate {
+	dcu.mutation.AddPriority1(i)
+	return dcu
+}
+
 // SetRemoveCompletedDownloads sets the "remove_completed_downloads" field.
 func (dcu *DownloadClientsUpdate) SetRemoveCompletedDownloads(b bool) *DownloadClientsUpdate {
 	dcu.mutation.SetRemoveCompletedDownloads(b)
@@ -213,7 +220,25 @@ func (dcu *DownloadClientsUpdate) ExecX(ctx context.Context) {
 	}
 }
 
+// check runs all checks and user-defined validators on the builder.
+func (dcu *DownloadClientsUpdate) check() error {
+	if v, ok := dcu.mutation.Implementation(); ok {
+		if err := downloadclients.ImplementationValidator(v); err != nil {
+			return &ValidationError{Name: "implementation", err: fmt.Errorf(`ent: validator failed for field "DownloadClients.implementation": %w`, err)}
+		}
+	}
+	if v, ok := dcu.mutation.Priority1(); ok {
+		if err := downloadclients.Priority1Validator(v); err != nil {
+			return &ValidationError{Name: "priority1", err: fmt.Errorf(`ent: validator failed for field "DownloadClients.priority1": %w`, err)}
+		}
+	}
+	return nil
+}
+
 func (dcu *DownloadClientsUpdate) sqlSave(ctx context.Context) (n int, err error) {
+	if err := dcu.check(); err != nil {
+		return n, err
+	}
 	_spec := sqlgraph.NewUpdateSpec(downloadclients.Table, downloadclients.Columns, sqlgraph.NewFieldSpec(downloadclients.FieldID, field.TypeInt))
 	if ps := dcu.mutation.predicates; len(ps) > 0 {
 		_spec.Predicate = func(selector *sql.Selector) {
@@ -229,7 +254,7 @@ func (dcu *DownloadClientsUpdate) sqlSave(ctx context.Context) (n int, err error
 		_spec.SetField(downloadclients.FieldName, field.TypeString, value)
 	}
 	if value, ok := dcu.mutation.Implementation(); ok {
-		_spec.SetField(downloadclients.FieldImplementation, field.TypeString, value)
+		_spec.SetField(downloadclients.FieldImplementation, field.TypeEnum, value)
 	}
 	if value, ok := dcu.mutation.URL(); ok {
 		_spec.SetField(downloadclients.FieldURL, field.TypeString, value)
@@ -243,8 +268,11 @@ func (dcu *DownloadClientsUpdate) sqlSave(ctx context.Context) (n int, err error
 	if value, ok := dcu.mutation.Settings(); ok {
 		_spec.SetField(downloadclients.FieldSettings, field.TypeString, value)
 	}
-	if value, ok := dcu.mutation.Priority(); ok {
-		_spec.SetField(downloadclients.FieldPriority, field.TypeString, value)
+	if value, ok := dcu.mutation.Priority1(); ok {
+		_spec.SetField(downloadclients.FieldPriority1, field.TypeInt, value)
+	}
+	if value, ok := dcu.mutation.AddedPriority1(); ok {
+		_spec.AddField(downloadclients.FieldPriority1, field.TypeInt, value)
 	}
 	if value, ok := dcu.mutation.RemoveCompletedDownloads(); ok {
 		_spec.SetField(downloadclients.FieldRemoveCompletedDownloads, field.TypeBool, value)
@@ -304,15 +332,15 @@ func (dcuo *DownloadClientsUpdateOne) SetNillableName(s *string) *DownloadClient
 }
 
 // SetImplementation sets the "implementation" field.
-func (dcuo *DownloadClientsUpdateOne) SetImplementation(s string) *DownloadClientsUpdateOne {
-	dcuo.mutation.SetImplementation(s)
+func (dcuo *DownloadClientsUpdateOne) SetImplementation(d downloadclients.Implementation) *DownloadClientsUpdateOne {
+	dcuo.mutation.SetImplementation(d)
 	return dcuo
 }
 
 // SetNillableImplementation sets the "implementation" field if the given value is not nil.
-func (dcuo *DownloadClientsUpdateOne) SetNillableImplementation(s *string) *DownloadClientsUpdateOne {
-	if s != nil {
-		dcuo.SetImplementation(*s)
+func (dcuo *DownloadClientsUpdateOne) SetNillableImplementation(d *downloadclients.Implementation) *DownloadClientsUpdateOne {
+	if d != nil {
+		dcuo.SetImplementation(*d)
 	}
 	return dcuo
 }
@@ -373,20 +401,27 @@ func (dcuo *DownloadClientsUpdateOne) SetNillableSettings(s *string) *DownloadCl
 	return dcuo
 }
 
-// SetPriority sets the "priority" field.
-func (dcuo *DownloadClientsUpdateOne) SetPriority(s string) *DownloadClientsUpdateOne {
-	dcuo.mutation.SetPriority(s)
+// SetPriority1 sets the "priority1" field.
+func (dcuo *DownloadClientsUpdateOne) SetPriority1(i int) *DownloadClientsUpdateOne {
+	dcuo.mutation.ResetPriority1()
+	dcuo.mutation.SetPriority1(i)
 	return dcuo
 }
 
-// SetNillablePriority sets the "priority" field if the given value is not nil.
-func (dcuo *DownloadClientsUpdateOne) SetNillablePriority(s *string) *DownloadClientsUpdateOne {
-	if s != nil {
-		dcuo.SetPriority(*s)
+// SetNillablePriority1 sets the "priority1" field if the given value is not nil.
+func (dcuo *DownloadClientsUpdateOne) SetNillablePriority1(i *int) *DownloadClientsUpdateOne {
+	if i != nil {
+		dcuo.SetPriority1(*i)
 	}
 	return dcuo
 }
 
+// AddPriority1 adds i to the "priority1" field.
+func (dcuo *DownloadClientsUpdateOne) AddPriority1(i int) *DownloadClientsUpdateOne {
+	dcuo.mutation.AddPriority1(i)
+	return dcuo
+}
+
 // SetRemoveCompletedDownloads sets the "remove_completed_downloads" field.
 func (dcuo *DownloadClientsUpdateOne) SetRemoveCompletedDownloads(b bool) *DownloadClientsUpdateOne {
 	dcuo.mutation.SetRemoveCompletedDownloads(b)
@@ -474,7 +509,25 @@ func (dcuo *DownloadClientsUpdateOne) ExecX(ctx context.Context) {
 	}
 }
 
+// check runs all checks and user-defined validators on the builder.
+func (dcuo *DownloadClientsUpdateOne) check() error {
+	if v, ok := dcuo.mutation.Implementation(); ok {
+		if err := downloadclients.ImplementationValidator(v); err != nil {
+			return &ValidationError{Name: "implementation", err: fmt.Errorf(`ent: validator failed for field "DownloadClients.implementation": %w`, err)}
+		}
+	}
+	if v, ok := dcuo.mutation.Priority1(); ok {
+		if err := downloadclients.Priority1Validator(v); err != nil {
+			return &ValidationError{Name: "priority1", err: fmt.Errorf(`ent: validator failed for field "DownloadClients.priority1": %w`, err)}
+		}
+	}
+	return nil
+}
+
 func (dcuo *DownloadClientsUpdateOne) sqlSave(ctx context.Context) (_node *DownloadClients, err error) {
+	if err := dcuo.check(); err != nil {
+		return _node, err
+	}
 	_spec := sqlgraph.NewUpdateSpec(downloadclients.Table, downloadclients.Columns, sqlgraph.NewFieldSpec(downloadclients.FieldID, field.TypeInt))
 	id, ok := dcuo.mutation.ID()
 	if !ok {
@@ -507,7 +560,7 @@ func (dcuo *DownloadClientsUpdateOne) sqlSave(ctx context.Context) (_node *Downl
 		_spec.SetField(downloadclients.FieldName, field.TypeString, value)
 	}
 	if value, ok := dcuo.mutation.Implementation(); ok {
-		_spec.SetField(downloadclients.FieldImplementation, field.TypeString, value)
+		_spec.SetField(downloadclients.FieldImplementation, field.TypeEnum, value)
 	}
 	if value, ok := dcuo.mutation.URL(); ok {
 		_spec.SetField(downloadclients.FieldURL, field.TypeString, value)
@@ -521,8 +574,11 @@ func (dcuo *DownloadClientsUpdateOne) sqlSave(ctx context.Context) (_node *Downl
 	if value, ok := dcuo.mutation.Settings(); ok {
 		_spec.SetField(downloadclients.FieldSettings, field.TypeString, value)
 	}
-	if value, ok := dcuo.mutation.Priority(); ok {
-		_spec.SetField(downloadclients.FieldPriority, field.TypeString, value)
+	if value, ok := dcuo.mutation.Priority1(); ok {
+		_spec.SetField(downloadclients.FieldPriority1, field.TypeInt, value)
+	}
+	if value, ok := dcuo.mutation.AddedPriority1(); ok {
+		_spec.AddField(downloadclients.FieldPriority1, field.TypeInt, value)
 	}
 	if value, ok := dcuo.mutation.RemoveCompletedDownloads(); ok {
 		_spec.SetField(downloadclients.FieldRemoveCompletedDownloads, field.TypeBool, value)

ent/ent.go

@@ -6,7 +6,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"polaris/ent/blocklist"
+	"polaris/ent/blacklist"
 	"polaris/ent/downloadclients"
 	"polaris/ent/episode"
 	"polaris/ent/history"
@@ -82,7 +82,7 @@ var (
 func checkColumn(table, column string) error {
 	initCheck.Do(func() {
 		columnCheck = sql.NewColumnCheck(map[string]func(string) bool{
-			blocklist.Table:          blocklist.ValidColumn,
+			blacklist.Table:          blacklist.ValidColumn,
 			downloadclients.Table:    downloadclients.ValidColumn,
 			episode.Table:            episode.ValidColumn,
 			history.Table:            history.ValidColumn,

ent/history.go

@@ -3,6 +3,7 @@
 package ent
 
 import (
+	"encoding/json"
 	"fmt"
 	"polaris/ent/history"
 	"strings"
@@ -19,8 +20,10 @@ type History struct {
 	ID int `json:"id,omitempty"`
 	// MediaID holds the value of the "media_id" field.
 	MediaID int `json:"media_id,omitempty"`
-	// EpisodeID holds the value of the "episode_id" field.
-	EpisodeID int `json:"episode_id,omitempty"`
+	// EpisodeNums holds the value of the "episode_nums" field.
+	EpisodeNums []int `json:"episode_nums,omitempty"`
+	// SeasonNum holds the value of the "season_num" field.
+	SeasonNum int `json:"season_num,omitempty"`
 	// SourceTitle holds the value of the "source_title" field.
 	SourceTitle string `json:"source_title,omitempty"`
 	// Date holds the value of the "date" field.
@@ -33,10 +36,12 @@ type History struct {
 	DownloadClientID int `json:"download_client_id,omitempty"`
 	// IndexerID holds the value of the "indexer_id" field.
 	IndexerID int `json:"indexer_id,omitempty"`
+	// deprecated, use hash instead
+	Link string `json:"link,omitempty"`
+	// torrent hash
+	Hash string `json:"hash,omitempty"`
 	// Status holds the value of the "status" field.
-	Status history.Status `json:"status,omitempty"`
-	// Saved holds the value of the "saved" field.
-	Saved        string `json:"saved,omitempty"`
+	Status       history.Status `json:"status,omitempty"`
 	selectValues sql.SelectValues
 }
 
@@ -45,9 +50,11 @@ func (*History) scanValues(columns []string) ([]any, error) {
 	values := make([]any, len(columns))
 	for i := range columns {
 		switch columns[i] {
-		case history.FieldID, history.FieldMediaID, history.FieldEpisodeID, history.FieldSize, history.FieldDownloadClientID, history.FieldIndexerID:
+		case history.FieldEpisodeNums:
+			values[i] = new([]byte)
+		case history.FieldID, history.FieldMediaID, history.FieldSeasonNum, history.FieldSize, history.FieldDownloadClientID, history.FieldIndexerID:
 			values[i] = new(sql.NullInt64)
-		case history.FieldSourceTitle, history.FieldTargetDir, history.FieldStatus, history.FieldSaved:
+		case history.FieldSourceTitle, history.FieldTargetDir, history.FieldLink, history.FieldHash, history.FieldStatus:
 			values[i] = new(sql.NullString)
 		case history.FieldDate:
 			values[i] = new(sql.NullTime)
@@ -78,11 +85,19 @@ func (h *History) assignValues(columns []string, values []any) error {
 			} else if value.Valid {
 				h.MediaID = int(value.Int64)
 			}
-		case history.FieldEpisodeID:
+		case history.FieldEpisodeNums:
+			if value, ok := values[i].(*[]byte); !ok {
+				return fmt.Errorf("unexpected type %T for field episode_nums", values[i])
+			} else if value != nil && len(*value) > 0 {
+				if err := json.Unmarshal(*value, &h.EpisodeNums); err != nil {
+					return fmt.Errorf("unmarshal field episode_nums: %w", err)
+				}
+			}
+		case history.FieldSeasonNum:
 			if value, ok := values[i].(*sql.NullInt64); !ok {
-				return fmt.Errorf("unexpected type %T for field episode_id", values[i])
+				return fmt.Errorf("unexpected type %T for field season_num", values[i])
 			} else if value.Valid {
-				h.EpisodeID = int(value.Int64)
+				h.SeasonNum = int(value.Int64)
 			}
 		case history.FieldSourceTitle:
 			if value, ok := values[i].(*sql.NullString); !ok {
@@ -120,18 +135,24 @@ func (h *History) assignValues(columns []string, values []any) error {
 			} else if value.Valid {
 				h.IndexerID = int(value.Int64)
 			}
+		case history.FieldLink:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field link", values[i])
+			} else if value.Valid {
+				h.Link = value.String
+			}
+		case history.FieldHash:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field hash", values[i])
+			} else if value.Valid {
+				h.Hash = value.String
+			}
 		case history.FieldStatus:
 			if value, ok := values[i].(*sql.NullString); !ok {
 				return fmt.Errorf("unexpected type %T for field status", values[i])
 			} else if value.Valid {
 				h.Status = history.Status(value.String)
 			}
-		case history.FieldSaved:
-			if value, ok := values[i].(*sql.NullString); !ok {
-				return fmt.Errorf("unexpected type %T for field saved", values[i])
-			} else if value.Valid {
-				h.Saved = value.String
-			}
 		default:
 			h.selectValues.Set(columns[i], values[i])
 		}
@@ -171,8 +192,11 @@ func (h *History) String() string {
 	builder.WriteString("media_id=")
 	builder.WriteString(fmt.Sprintf("%v", h.MediaID))
 	builder.WriteString(", ")
-	builder.WriteString("episode_id=")
-	builder.WriteString(fmt.Sprintf("%v", h.EpisodeID))
+	builder.WriteString("episode_nums=")
+	builder.WriteString(fmt.Sprintf("%v", h.EpisodeNums))
+	builder.WriteString(", ")
+	builder.WriteString("season_num=")
+	builder.WriteString(fmt.Sprintf("%v", h.SeasonNum))
 	builder.WriteString(", ")
 	builder.WriteString("source_title=")
 	builder.WriteString(h.SourceTitle)
@@ -192,11 +216,14 @@ func (h *History) String() string {
 	builder.WriteString("indexer_id=")
 	builder.WriteString(fmt.Sprintf("%v", h.IndexerID))
 	builder.WriteString(", ")
+	builder.WriteString("link=")
+	builder.WriteString(h.Link)
+	builder.WriteString(", ")
+	builder.WriteString("hash=")
+	builder.WriteString(h.Hash)
+	builder.WriteString(", ")
 	builder.WriteString("status=")
 	builder.WriteString(fmt.Sprintf("%v", h.Status))
-	builder.WriteString(", ")
-	builder.WriteString("saved=")
-	builder.WriteString(h.Saved)
 	builder.WriteByte(')')
 	return builder.String()
 }

ent/history/history.go

@@ -15,8 +15,10 @@ const (
 	FieldID = "id"
 	// FieldMediaID holds the string denoting the media_id field in the database.
 	FieldMediaID = "media_id"
-	// FieldEpisodeID holds the string denoting the episode_id field in the database.
-	FieldEpisodeID = "episode_id"
+	// FieldEpisodeNums holds the string denoting the episode_nums field in the database.
+	FieldEpisodeNums = "episode_nums"
+	// FieldSeasonNum holds the string denoting the season_num field in the database.
+	FieldSeasonNum = "season_num"
 	// FieldSourceTitle holds the string denoting the source_title field in the database.
 	FieldSourceTitle = "source_title"
 	// FieldDate holds the string denoting the date field in the database.
@@ -29,10 +31,12 @@ const (
 	FieldDownloadClientID = "download_client_id"
 	// FieldIndexerID holds the string denoting the indexer_id field in the database.
 	FieldIndexerID = "indexer_id"
+	// FieldLink holds the string denoting the link field in the database.
+	FieldLink = "link"
+	// FieldHash holds the string denoting the hash field in the database.
+	FieldHash = "hash"
 	// FieldStatus holds the string denoting the status field in the database.
 	FieldStatus = "status"
-	// FieldSaved holds the string denoting the saved field in the database.
-	FieldSaved = "saved"
 	// Table holds the table name of the history in the database.
 	Table = "histories"
 )
@@ -41,15 +45,17 @@ const (
 var Columns = []string{
 	FieldID,
 	FieldMediaID,
-	FieldEpisodeID,
+	FieldEpisodeNums,
+	FieldSeasonNum,
 	FieldSourceTitle,
 	FieldDate,
 	FieldTargetDir,
 	FieldSize,
 	FieldDownloadClientID,
 	FieldIndexerID,
+	FieldLink,
+	FieldHash,
 	FieldStatus,
-	FieldSaved,
 }
 
 // ValidColumn reports if the column name is valid (part of the table columns).
@@ -77,6 +83,7 @@ const (
 	StatusFail      Status = "fail"
 	StatusUploading Status = "uploading"
 	StatusSeeding   Status = "seeding"
+	StatusRemoved   Status = "removed"
 )
 
 func (s Status) String() string {
@@ -86,7 +93,7 @@ func (s Status) String() string {
 // StatusValidator is a validator for the "status" field enum values. It is called by the builders before save.
 func StatusValidator(s Status) error {
 	switch s {
-	case StatusRunning, StatusSuccess, StatusFail, StatusUploading, StatusSeeding:
+	case StatusRunning, StatusSuccess, StatusFail, StatusUploading, StatusSeeding, StatusRemoved:
 		return nil
 	default:
 		return fmt.Errorf("history: invalid enum value for status field: %q", s)
@@ -106,9 +113,9 @@ func ByMediaID(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldMediaID, opts...).ToFunc()
 }
 
-// ByEpisodeID orders the results by the episode_id field.
-func ByEpisodeID(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldEpisodeID, opts...).ToFunc()
+// BySeasonNum orders the results by the season_num field.
+func BySeasonNum(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldSeasonNum, opts...).ToFunc()
 }
 
 // BySourceTitle orders the results by the source_title field.
@@ -141,12 +148,17 @@ func ByIndexerID(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldIndexerID, opts...).ToFunc()
 }
 
+// ByLink orders the results by the link field.
+func ByLink(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldLink, opts...).ToFunc()
+}
+
+// ByHash orders the results by the hash field.
+func ByHash(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldHash, opts...).ToFunc()
+}
+
 // ByStatus orders the results by the status field.
 func ByStatus(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldStatus, opts...).ToFunc()
 }
-
-// BySaved orders the results by the saved field.
-func BySaved(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldSaved, opts...).ToFunc()
-}

ent/history/where.go

@@ -59,9 +59,9 @@ func MediaID(v int) predicate.History {
 	return predicate.History(sql.FieldEQ(FieldMediaID, v))
 }
 
-// EpisodeID applies equality check predicate on the "episode_id" field. It's identical to EpisodeIDEQ.
-func EpisodeID(v int) predicate.History {
-	return predicate.History(sql.FieldEQ(FieldEpisodeID, v))
+// SeasonNum applies equality check predicate on the "season_num" field. It's identical to SeasonNumEQ.
+func SeasonNum(v int) predicate.History {
+	return predicate.History(sql.FieldEQ(FieldSeasonNum, v))
 }
 
 // SourceTitle applies equality check predicate on the "source_title" field. It's identical to SourceTitleEQ.
@@ -94,9 +94,14 @@ func IndexerID(v int) predicate.History {
 	return predicate.History(sql.FieldEQ(FieldIndexerID, v))
 }
 
-// Saved applies equality check predicate on the "saved" field. It's identical to SavedEQ.
-func Saved(v string) predicate.History {
-	return predicate.History(sql.FieldEQ(FieldSaved, v))
+// Link applies equality check predicate on the "link" field. It's identical to LinkEQ.
+func Link(v string) predicate.History {
+	return predicate.History(sql.FieldEQ(FieldLink, v))
+}
+
+// Hash applies equality check predicate on the "hash" field. It's identical to HashEQ.
+func Hash(v string) predicate.History {
+	return predicate.History(sql.FieldEQ(FieldHash, v))
 }
 
 // MediaIDEQ applies the EQ predicate on the "media_id" field.
@@ -139,54 +144,64 @@ func MediaIDLTE(v int) predicate.History {
 	return predicate.History(sql.FieldLTE(FieldMediaID, v))
 }
 
-// EpisodeIDEQ applies the EQ predicate on the "episode_id" field.
-func EpisodeIDEQ(v int) predicate.History {
-	return predicate.History(sql.FieldEQ(FieldEpisodeID, v))
+// EpisodeNumsIsNil applies the IsNil predicate on the "episode_nums" field.
+func EpisodeNumsIsNil() predicate.History {
+	return predicate.History(sql.FieldIsNull(FieldEpisodeNums))
 }
 
-// EpisodeIDNEQ applies the NEQ predicate on the "episode_id" field.
-func EpisodeIDNEQ(v int) predicate.History {
-	return predicate.History(sql.FieldNEQ(FieldEpisodeID, v))
+// EpisodeNumsNotNil applies the NotNil predicate on the "episode_nums" field.
+func EpisodeNumsNotNil() predicate.History {
+	return predicate.History(sql.FieldNotNull(FieldEpisodeNums))
 }
 
-// EpisodeIDIn applies the In predicate on the "episode_id" field.
-func EpisodeIDIn(vs ...int) predicate.History {
-	return predicate.History(sql.FieldIn(FieldEpisodeID, vs...))
+// SeasonNumEQ applies the EQ predicate on the "season_num" field.
+func SeasonNumEQ(v int) predicate.History {
+	return predicate.History(sql.FieldEQ(FieldSeasonNum, v))
 }
 
-// EpisodeIDNotIn applies the NotIn predicate on the "episode_id" field.
-func EpisodeIDNotIn(vs ...int) predicate.History {
-	return predicate.History(sql.FieldNotIn(FieldEpisodeID, vs...))
+// SeasonNumNEQ applies the NEQ predicate on the "season_num" field.
+func SeasonNumNEQ(v int) predicate.History {
+	return predicate.History(sql.FieldNEQ(FieldSeasonNum, v))
 }
 
-// EpisodeIDGT applies the GT predicate on the "episode_id" field.
-func EpisodeIDGT(v int) predicate.History {
-	return predicate.History(sql.FieldGT(FieldEpisodeID, v))
+// SeasonNumIn applies the In predicate on the "season_num" field.
+func SeasonNumIn(vs ...int) predicate.History {
+	return predicate.History(sql.FieldIn(FieldSeasonNum, vs...))
 }
 
-// EpisodeIDGTE applies the GTE predicate on the "episode_id" field.
-func EpisodeIDGTE(v int) predicate.History {
-	return predicate.History(sql.FieldGTE(FieldEpisodeID, v))
+// SeasonNumNotIn applies the NotIn predicate on the "season_num" field.
+func SeasonNumNotIn(vs ...int) predicate.History {
+	return predicate.History(sql.FieldNotIn(FieldSeasonNum, vs...))
 }
 
-// EpisodeIDLT applies the LT predicate on the "episode_id" field.
-func EpisodeIDLT(v int) predicate.History {
-	return predicate.History(sql.FieldLT(FieldEpisodeID, v))
+// SeasonNumGT applies the GT predicate on the "season_num" field.
+func SeasonNumGT(v int) predicate.History {
+	return predicate.History(sql.FieldGT(FieldSeasonNum, v))
 }
 
-// EpisodeIDLTE applies the LTE predicate on the "episode_id" field.
-func EpisodeIDLTE(v int) predicate.History {
-	return predicate.History(sql.FieldLTE(FieldEpisodeID, v))
+// SeasonNumGTE applies the GTE predicate on the "season_num" field.
+func SeasonNumGTE(v int) predicate.History {
+	return predicate.History(sql.FieldGTE(FieldSeasonNum, v))
 }
 
-// EpisodeIDIsNil applies the IsNil predicate on the "episode_id" field.
-func EpisodeIDIsNil() predicate.History {
-	return predicate.History(sql.FieldIsNull(FieldEpisodeID))
+// SeasonNumLT applies the LT predicate on the "season_num" field.
+func SeasonNumLT(v int) predicate.History {
+	return predicate.History(sql.FieldLT(FieldSeasonNum, v))
 }
 
-// EpisodeIDNotNil applies the NotNil predicate on the "episode_id" field.
-func EpisodeIDNotNil() predicate.History {
-	return predicate.History(sql.FieldNotNull(FieldEpisodeID))
+// SeasonNumLTE applies the LTE predicate on the "season_num" field.
+func SeasonNumLTE(v int) predicate.History {
+	return predicate.History(sql.FieldLTE(FieldSeasonNum, v))
+}
+
+// SeasonNumIsNil applies the IsNil predicate on the "season_num" field.
+func SeasonNumIsNil() predicate.History {
+	return predicate.History(sql.FieldIsNull(FieldSeasonNum))
+}
+
+// SeasonNumNotNil applies the NotNil predicate on the "season_num" field.
+func SeasonNumNotNil() predicate.History {
+	return predicate.History(sql.FieldNotNull(FieldSeasonNum))
 }
 
 // SourceTitleEQ applies the EQ predicate on the "source_title" field.
@@ -499,6 +514,156 @@ func IndexerIDNotNil() predicate.History {
 	return predicate.History(sql.FieldNotNull(FieldIndexerID))
 }
 
+// LinkEQ applies the EQ predicate on the "link" field.
+func LinkEQ(v string) predicate.History {
+	return predicate.History(sql.FieldEQ(FieldLink, v))
+}
+
+// LinkNEQ applies the NEQ predicate on the "link" field.
+func LinkNEQ(v string) predicate.History {
+	return predicate.History(sql.FieldNEQ(FieldLink, v))
+}
+
+// LinkIn applies the In predicate on the "link" field.
+func LinkIn(vs ...string) predicate.History {
+	return predicate.History(sql.FieldIn(FieldLink, vs...))
+}
+
+// LinkNotIn applies the NotIn predicate on the "link" field.
+func LinkNotIn(vs ...string) predicate.History {
+	return predicate.History(sql.FieldNotIn(FieldLink, vs...))
+}
+
+// LinkGT applies the GT predicate on the "link" field.
+func LinkGT(v string) predicate.History {
+	return predicate.History(sql.FieldGT(FieldLink, v))
+}
+
+// LinkGTE applies the GTE predicate on the "link" field.
+func LinkGTE(v string) predicate.History {
+	return predicate.History(sql.FieldGTE(FieldLink, v))
+}
+
+// LinkLT applies the LT predicate on the "link" field.
+func LinkLT(v string) predicate.History {
+	return predicate.History(sql.FieldLT(FieldLink, v))
+}
+
+// LinkLTE applies the LTE predicate on the "link" field.
+func LinkLTE(v string) predicate.History {
+	return predicate.History(sql.FieldLTE(FieldLink, v))
+}
+
+// LinkContains applies the Contains predicate on the "link" field.
+func LinkContains(v string) predicate.History {
+	return predicate.History(sql.FieldContains(FieldLink, v))
+}
+
+// LinkHasPrefix applies the HasPrefix predicate on the "link" field.
+func LinkHasPrefix(v string) predicate.History {
+	return predicate.History(sql.FieldHasPrefix(FieldLink, v))
+}
+
+// LinkHasSuffix applies the HasSuffix predicate on the "link" field.
+func LinkHasSuffix(v string) predicate.History {
+	return predicate.History(sql.FieldHasSuffix(FieldLink, v))
+}
+
+// LinkIsNil applies the IsNil predicate on the "link" field.
+func LinkIsNil() predicate.History {
+	return predicate.History(sql.FieldIsNull(FieldLink))
+}
+
+// LinkNotNil applies the NotNil predicate on the "link" field.
+func LinkNotNil() predicate.History {
+	return predicate.History(sql.FieldNotNull(FieldLink))
+}
+
+// LinkEqualFold applies the EqualFold predicate on the "link" field.
+func LinkEqualFold(v string) predicate.History {
+	return predicate.History(sql.FieldEqualFold(FieldLink, v))
+}
+
+// LinkContainsFold applies the ContainsFold predicate on the "link" field.
+func LinkContainsFold(v string) predicate.History {
+	return predicate.History(sql.FieldContainsFold(FieldLink, v))
+}
+
+// HashEQ applies the EQ predicate on the "hash" field.
+func HashEQ(v string) predicate.History {
+	return predicate.History(sql.FieldEQ(FieldHash, v))
+}
+
+// HashNEQ applies the NEQ predicate on the "hash" field.
+func HashNEQ(v string) predicate.History {
+	return predicate.History(sql.FieldNEQ(FieldHash, v))
+}
+
+// HashIn applies the In predicate on the "hash" field.
+func HashIn(vs ...string) predicate.History {
+	return predicate.History(sql.FieldIn(FieldHash, vs...))
+}
+
+// HashNotIn applies the NotIn predicate on the "hash" field.
+func HashNotIn(vs ...string) predicate.History {
+	return predicate.History(sql.FieldNotIn(FieldHash, vs...))
+}
+
+// HashGT applies the GT predicate on the "hash" field.
+func HashGT(v string) predicate.History {
+	return predicate.History(sql.FieldGT(FieldHash, v))
+}
+
+// HashGTE applies the GTE predicate on the "hash" field.
+func HashGTE(v string) predicate.History {
+	return predicate.History(sql.FieldGTE(FieldHash, v))
+}
+
+// HashLT applies the LT predicate on the "hash" field.
+func HashLT(v string) predicate.History {
+	return predicate.History(sql.FieldLT(FieldHash, v))
+}
+
+// HashLTE applies the LTE predicate on the "hash" field.
+func HashLTE(v string) predicate.History {
+	return predicate.History(sql.FieldLTE(FieldHash, v))
+}
+
+// HashContains applies the Contains predicate on the "hash" field.
+func HashContains(v string) predicate.History {
+	return predicate.History(sql.FieldContains(FieldHash, v))
+}
+
+// HashHasPrefix applies the HasPrefix predicate on the "hash" field.
+func HashHasPrefix(v string) predicate.History {
+	return predicate.History(sql.FieldHasPrefix(FieldHash, v))
+}
+
+// HashHasSuffix applies the HasSuffix predicate on the "hash" field.
+func HashHasSuffix(v string) predicate.History {
+	return predicate.History(sql.FieldHasSuffix(FieldHash, v))
+}
+
+// HashIsNil applies the IsNil predicate on the "hash" field.
+func HashIsNil() predicate.History {
+	return predicate.History(sql.FieldIsNull(FieldHash))
+}
+
+// HashNotNil applies the NotNil predicate on the "hash" field.
+func HashNotNil() predicate.History {
+	return predicate.History(sql.FieldNotNull(FieldHash))
+}
+
+// HashEqualFold applies the EqualFold predicate on the "hash" field.
+func HashEqualFold(v string) predicate.History {
+	return predicate.History(sql.FieldEqualFold(FieldHash, v))
+}
+
+// HashContainsFold applies the ContainsFold predicate on the "hash" field.
+func HashContainsFold(v string) predicate.History {
+	return predicate.History(sql.FieldContainsFold(FieldHash, v))
+}
+
 // StatusEQ applies the EQ predicate on the "status" field.
 func StatusEQ(v Status) predicate.History {
 	return predicate.History(sql.FieldEQ(FieldStatus, v))
@@ -519,81 +684,6 @@ func StatusNotIn(vs ...Status) predicate.History {
 	return predicate.History(sql.FieldNotIn(FieldStatus, vs...))
 }
 
-// SavedEQ applies the EQ predicate on the "saved" field.
-func SavedEQ(v string) predicate.History {
-	return predicate.History(sql.FieldEQ(FieldSaved, v))
-}
-
-// SavedNEQ applies the NEQ predicate on the "saved" field.
-func SavedNEQ(v string) predicate.History {
-	return predicate.History(sql.FieldNEQ(FieldSaved, v))
-}
-
-// SavedIn applies the In predicate on the "saved" field.
-func SavedIn(vs ...string) predicate.History {
-	return predicate.History(sql.FieldIn(FieldSaved, vs...))
-}
-
-// SavedNotIn applies the NotIn predicate on the "saved" field.
-func SavedNotIn(vs ...string) predicate.History {
-	return predicate.History(sql.FieldNotIn(FieldSaved, vs...))
-}
-
-// SavedGT applies the GT predicate on the "saved" field.
-func SavedGT(v string) predicate.History {
-	return predicate.History(sql.FieldGT(FieldSaved, v))
-}
-
-// SavedGTE applies the GTE predicate on the "saved" field.
-func SavedGTE(v string) predicate.History {
-	return predicate.History(sql.FieldGTE(FieldSaved, v))
-}
-
-// SavedLT applies the LT predicate on the "saved" field.
-func SavedLT(v string) predicate.History {
-	return predicate.History(sql.FieldLT(FieldSaved, v))
-}
-
-// SavedLTE applies the LTE predicate on the "saved" field.
-func SavedLTE(v string) predicate.History {
-	return predicate.History(sql.FieldLTE(FieldSaved, v))
-}
-
-// SavedContains applies the Contains predicate on the "saved" field.
-func SavedContains(v string) predicate.History {
-	return predicate.History(sql.FieldContains(FieldSaved, v))
-}
-
-// SavedHasPrefix applies the HasPrefix predicate on the "saved" field.
-func SavedHasPrefix(v string) predicate.History {
-	return predicate.History(sql.FieldHasPrefix(FieldSaved, v))
-}
-
-// SavedHasSuffix applies the HasSuffix predicate on the "saved" field.
-func SavedHasSuffix(v string) predicate.History {
-	return predicate.History(sql.FieldHasSuffix(FieldSaved, v))
-}
-
-// SavedIsNil applies the IsNil predicate on the "saved" field.
-func SavedIsNil() predicate.History {
-	return predicate.History(sql.FieldIsNull(FieldSaved))
-}
-
-// SavedNotNil applies the NotNil predicate on the "saved" field.
-func SavedNotNil() predicate.History {
-	return predicate.History(sql.FieldNotNull(FieldSaved))
-}
-
-// SavedEqualFold applies the EqualFold predicate on the "saved" field.
-func SavedEqualFold(v string) predicate.History {
-	return predicate.History(sql.FieldEqualFold(FieldSaved, v))
-}
-
-// SavedContainsFold applies the ContainsFold predicate on the "saved" field.
-func SavedContainsFold(v string) predicate.History {
-	return predicate.History(sql.FieldContainsFold(FieldSaved, v))
-}
-
 // And groups predicates with the AND operator between them.
 func And(predicates ...predicate.History) predicate.History {
 	return predicate.History(sql.AndPredicates(predicates...))

ent/history_create.go

@@ -26,16 +26,22 @@ func (hc *HistoryCreate) SetMediaID(i int) *HistoryCreate {
 	return hc
 }
 
-// SetEpisodeID sets the "episode_id" field.
-func (hc *HistoryCreate) SetEpisodeID(i int) *HistoryCreate {
-	hc.mutation.SetEpisodeID(i)
+// SetEpisodeNums sets the "episode_nums" field.
+func (hc *HistoryCreate) SetEpisodeNums(i []int) *HistoryCreate {
+	hc.mutation.SetEpisodeNums(i)
 	return hc
 }
 
-// SetNillableEpisodeID sets the "episode_id" field if the given value is not nil.
-func (hc *HistoryCreate) SetNillableEpisodeID(i *int) *HistoryCreate {
+// SetSeasonNum sets the "season_num" field.
+func (hc *HistoryCreate) SetSeasonNum(i int) *HistoryCreate {
+	hc.mutation.SetSeasonNum(i)
+	return hc
+}
+
+// SetNillableSeasonNum sets the "season_num" field if the given value is not nil.
+func (hc *HistoryCreate) SetNillableSeasonNum(i *int) *HistoryCreate {
 	if i != nil {
-		hc.SetEpisodeID(*i)
+		hc.SetSeasonNum(*i)
 	}
 	return hc
 }
@@ -100,26 +106,40 @@ func (hc *HistoryCreate) SetNillableIndexerID(i *int) *HistoryCreate {
 	return hc
 }
 
+// SetLink sets the "link" field.
+func (hc *HistoryCreate) SetLink(s string) *HistoryCreate {
+	hc.mutation.SetLink(s)
+	return hc
+}
+
+// SetNillableLink sets the "link" field if the given value is not nil.
+func (hc *HistoryCreate) SetNillableLink(s *string) *HistoryCreate {
+	if s != nil {
+		hc.SetLink(*s)
+	}
+	return hc
+}
+
+// SetHash sets the "hash" field.
+func (hc *HistoryCreate) SetHash(s string) *HistoryCreate {
+	hc.mutation.SetHash(s)
+	return hc
+}
+
+// SetNillableHash sets the "hash" field if the given value is not nil.
+func (hc *HistoryCreate) SetNillableHash(s *string) *HistoryCreate {
+	if s != nil {
+		hc.SetHash(*s)
+	}
+	return hc
+}
+
 // SetStatus sets the "status" field.
 func (hc *HistoryCreate) SetStatus(h history.Status) *HistoryCreate {
 	hc.mutation.SetStatus(h)
 	return hc
 }
 
-// SetSaved sets the "saved" field.
-func (hc *HistoryCreate) SetSaved(s string) *HistoryCreate {
-	hc.mutation.SetSaved(s)
-	return hc
-}
-
-// SetNillableSaved sets the "saved" field if the given value is not nil.
-func (hc *HistoryCreate) SetNillableSaved(s *string) *HistoryCreate {
-	if s != nil {
-		hc.SetSaved(*s)
-	}
-	return hc
-}
-
 // Mutation returns the HistoryMutation object of the builder.
 func (hc *HistoryCreate) Mutation() *HistoryMutation {
 	return hc.mutation
@@ -216,9 +236,13 @@ func (hc *HistoryCreate) createSpec() (*History, *sqlgraph.CreateSpec) {
 		_spec.SetField(history.FieldMediaID, field.TypeInt, value)
 		_node.MediaID = value
 	}
-	if value, ok := hc.mutation.EpisodeID(); ok {
-		_spec.SetField(history.FieldEpisodeID, field.TypeInt, value)
-		_node.EpisodeID = value
+	if value, ok := hc.mutation.EpisodeNums(); ok {
+		_spec.SetField(history.FieldEpisodeNums, field.TypeJSON, value)
+		_node.EpisodeNums = value
+	}
+	if value, ok := hc.mutation.SeasonNum(); ok {
+		_spec.SetField(history.FieldSeasonNum, field.TypeInt, value)
+		_node.SeasonNum = value
 	}
 	if value, ok := hc.mutation.SourceTitle(); ok {
 		_spec.SetField(history.FieldSourceTitle, field.TypeString, value)
@@ -244,14 +268,18 @@ func (hc *HistoryCreate) createSpec() (*History, *sqlgraph.CreateSpec) {
 		_spec.SetField(history.FieldIndexerID, field.TypeInt, value)
 		_node.IndexerID = value
 	}
+	if value, ok := hc.mutation.Link(); ok {
+		_spec.SetField(history.FieldLink, field.TypeString, value)
+		_node.Link = value
+	}
+	if value, ok := hc.mutation.Hash(); ok {
+		_spec.SetField(history.FieldHash, field.TypeString, value)
+		_node.Hash = value
+	}
 	if value, ok := hc.mutation.Status(); ok {
 		_spec.SetField(history.FieldStatus, field.TypeEnum, value)
 		_node.Status = value
 	}
-	if value, ok := hc.mutation.Saved(); ok {
-		_spec.SetField(history.FieldSaved, field.TypeString, value)
-		_node.Saved = value
-	}
 	return _node, _spec
 }
 

ent/history_update.go

@@ -12,6 +12,7 @@ import (
 
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/dialect/sql/sqljson"
 	"entgo.io/ent/schema/field"
 )
 
@@ -49,30 +50,48 @@ func (hu *HistoryUpdate) AddMediaID(i int) *HistoryUpdate {
 	return hu
 }
 
-// SetEpisodeID sets the "episode_id" field.
-func (hu *HistoryUpdate) SetEpisodeID(i int) *HistoryUpdate {
-	hu.mutation.ResetEpisodeID()
-	hu.mutation.SetEpisodeID(i)
+// SetEpisodeNums sets the "episode_nums" field.
+func (hu *HistoryUpdate) SetEpisodeNums(i []int) *HistoryUpdate {
+	hu.mutation.SetEpisodeNums(i)
 	return hu
 }
 
-// SetNillableEpisodeID sets the "episode_id" field if the given value is not nil.
-func (hu *HistoryUpdate) SetNillableEpisodeID(i *int) *HistoryUpdate {
+// AppendEpisodeNums appends i to the "episode_nums" field.
+func (hu *HistoryUpdate) AppendEpisodeNums(i []int) *HistoryUpdate {
+	hu.mutation.AppendEpisodeNums(i)
+	return hu
+}
+
+// ClearEpisodeNums clears the value of the "episode_nums" field.
+func (hu *HistoryUpdate) ClearEpisodeNums() *HistoryUpdate {
+	hu.mutation.ClearEpisodeNums()
+	return hu
+}
+
+// SetSeasonNum sets the "season_num" field.
+func (hu *HistoryUpdate) SetSeasonNum(i int) *HistoryUpdate {
+	hu.mutation.ResetSeasonNum()
+	hu.mutation.SetSeasonNum(i)
+	return hu
+}
+
+// SetNillableSeasonNum sets the "season_num" field if the given value is not nil.
+func (hu *HistoryUpdate) SetNillableSeasonNum(i *int) *HistoryUpdate {
 	if i != nil {
-		hu.SetEpisodeID(*i)
+		hu.SetSeasonNum(*i)
 	}
 	return hu
 }
 
-// AddEpisodeID adds i to the "episode_id" field.
-func (hu *HistoryUpdate) AddEpisodeID(i int) *HistoryUpdate {
-	hu.mutation.AddEpisodeID(i)
+// AddSeasonNum adds i to the "season_num" field.
+func (hu *HistoryUpdate) AddSeasonNum(i int) *HistoryUpdate {
+	hu.mutation.AddSeasonNum(i)
 	return hu
 }
 
-// ClearEpisodeID clears the value of the "episode_id" field.
-func (hu *HistoryUpdate) ClearEpisodeID() *HistoryUpdate {
-	hu.mutation.ClearEpisodeID()
+// ClearSeasonNum clears the value of the "season_num" field.
+func (hu *HistoryUpdate) ClearSeasonNum() *HistoryUpdate {
+	hu.mutation.ClearSeasonNum()
 	return hu
 }
 
@@ -193,6 +212,46 @@ func (hu *HistoryUpdate) ClearIndexerID() *HistoryUpdate {
 	return hu
 }
 
+// SetLink sets the "link" field.
+func (hu *HistoryUpdate) SetLink(s string) *HistoryUpdate {
+	hu.mutation.SetLink(s)
+	return hu
+}
+
+// SetNillableLink sets the "link" field if the given value is not nil.
+func (hu *HistoryUpdate) SetNillableLink(s *string) *HistoryUpdate {
+	if s != nil {
+		hu.SetLink(*s)
+	}
+	return hu
+}
+
+// ClearLink clears the value of the "link" field.
+func (hu *HistoryUpdate) ClearLink() *HistoryUpdate {
+	hu.mutation.ClearLink()
+	return hu
+}
+
+// SetHash sets the "hash" field.
+func (hu *HistoryUpdate) SetHash(s string) *HistoryUpdate {
+	hu.mutation.SetHash(s)
+	return hu
+}
+
+// SetNillableHash sets the "hash" field if the given value is not nil.
+func (hu *HistoryUpdate) SetNillableHash(s *string) *HistoryUpdate {
+	if s != nil {
+		hu.SetHash(*s)
+	}
+	return hu
+}
+
+// ClearHash clears the value of the "hash" field.
+func (hu *HistoryUpdate) ClearHash() *HistoryUpdate {
+	hu.mutation.ClearHash()
+	return hu
+}
+
 // SetStatus sets the "status" field.
 func (hu *HistoryUpdate) SetStatus(h history.Status) *HistoryUpdate {
 	hu.mutation.SetStatus(h)
@@ -207,26 +266,6 @@ func (hu *HistoryUpdate) SetNillableStatus(h *history.Status) *HistoryUpdate {
 	return hu
 }
 
-// SetSaved sets the "saved" field.
-func (hu *HistoryUpdate) SetSaved(s string) *HistoryUpdate {
-	hu.mutation.SetSaved(s)
-	return hu
-}
-
-// SetNillableSaved sets the "saved" field if the given value is not nil.
-func (hu *HistoryUpdate) SetNillableSaved(s *string) *HistoryUpdate {
-	if s != nil {
-		hu.SetSaved(*s)
-	}
-	return hu
-}
-
-// ClearSaved clears the value of the "saved" field.
-func (hu *HistoryUpdate) ClearSaved() *HistoryUpdate {
-	hu.mutation.ClearSaved()
-	return hu
-}
-
 // Mutation returns the HistoryMutation object of the builder.
 func (hu *HistoryUpdate) Mutation() *HistoryMutation {
 	return hu.mutation
@@ -287,14 +326,25 @@ func (hu *HistoryUpdate) sqlSave(ctx context.Context) (n int, err error) {
 	if value, ok := hu.mutation.AddedMediaID(); ok {
 		_spec.AddField(history.FieldMediaID, field.TypeInt, value)
 	}
-	if value, ok := hu.mutation.EpisodeID(); ok {
-		_spec.SetField(history.FieldEpisodeID, field.TypeInt, value)
+	if value, ok := hu.mutation.EpisodeNums(); ok {
+		_spec.SetField(history.FieldEpisodeNums, field.TypeJSON, value)
 	}
-	if value, ok := hu.mutation.AddedEpisodeID(); ok {
-		_spec.AddField(history.FieldEpisodeID, field.TypeInt, value)
+	if value, ok := hu.mutation.AppendedEpisodeNums(); ok {
+		_spec.AddModifier(func(u *sql.UpdateBuilder) {
+			sqljson.Append(u, history.FieldEpisodeNums, value)
+		})
 	}
-	if hu.mutation.EpisodeIDCleared() {
-		_spec.ClearField(history.FieldEpisodeID, field.TypeInt)
+	if hu.mutation.EpisodeNumsCleared() {
+		_spec.ClearField(history.FieldEpisodeNums, field.TypeJSON)
+	}
+	if value, ok := hu.mutation.SeasonNum(); ok {
+		_spec.SetField(history.FieldSeasonNum, field.TypeInt, value)
+	}
+	if value, ok := hu.mutation.AddedSeasonNum(); ok {
+		_spec.AddField(history.FieldSeasonNum, field.TypeInt, value)
+	}
+	if hu.mutation.SeasonNumCleared() {
+		_spec.ClearField(history.FieldSeasonNum, field.TypeInt)
 	}
 	if value, ok := hu.mutation.SourceTitle(); ok {
 		_spec.SetField(history.FieldSourceTitle, field.TypeString, value)
@@ -329,15 +379,21 @@ func (hu *HistoryUpdate) sqlSave(ctx context.Context) (n int, err error) {
 	if hu.mutation.IndexerIDCleared() {
 		_spec.ClearField(history.FieldIndexerID, field.TypeInt)
 	}
+	if value, ok := hu.mutation.Link(); ok {
+		_spec.SetField(history.FieldLink, field.TypeString, value)
+	}
+	if hu.mutation.LinkCleared() {
+		_spec.ClearField(history.FieldLink, field.TypeString)
+	}
+	if value, ok := hu.mutation.Hash(); ok {
+		_spec.SetField(history.FieldHash, field.TypeString, value)
+	}
+	if hu.mutation.HashCleared() {
+		_spec.ClearField(history.FieldHash, field.TypeString)
+	}
 	if value, ok := hu.mutation.Status(); ok {
 		_spec.SetField(history.FieldStatus, field.TypeEnum, value)
 	}
-	if value, ok := hu.mutation.Saved(); ok {
-		_spec.SetField(history.FieldSaved, field.TypeString, value)
-	}
-	if hu.mutation.SavedCleared() {
-		_spec.ClearField(history.FieldSaved, field.TypeString)
-	}
 	if n, err = sqlgraph.UpdateNodes(ctx, hu.driver, _spec); err != nil {
 		if _, ok := err.(*sqlgraph.NotFoundError); ok {
 			err = &NotFoundError{history.Label}
@@ -379,30 +435,48 @@ func (huo *HistoryUpdateOne) AddMediaID(i int) *HistoryUpdateOne {
 	return huo
 }
 
-// SetEpisodeID sets the "episode_id" field.
-func (huo *HistoryUpdateOne) SetEpisodeID(i int) *HistoryUpdateOne {
-	huo.mutation.ResetEpisodeID()
-	huo.mutation.SetEpisodeID(i)
+// SetEpisodeNums sets the "episode_nums" field.
+func (huo *HistoryUpdateOne) SetEpisodeNums(i []int) *HistoryUpdateOne {
+	huo.mutation.SetEpisodeNums(i)
 	return huo
 }
 
-// SetNillableEpisodeID sets the "episode_id" field if the given value is not nil.
-func (huo *HistoryUpdateOne) SetNillableEpisodeID(i *int) *HistoryUpdateOne {
+// AppendEpisodeNums appends i to the "episode_nums" field.
+func (huo *HistoryUpdateOne) AppendEpisodeNums(i []int) *HistoryUpdateOne {
+	huo.mutation.AppendEpisodeNums(i)
+	return huo
+}
+
+// ClearEpisodeNums clears the value of the "episode_nums" field.
+func (huo *HistoryUpdateOne) ClearEpisodeNums() *HistoryUpdateOne {
+	huo.mutation.ClearEpisodeNums()
+	return huo
+}
+
+// SetSeasonNum sets the "season_num" field.
+func (huo *HistoryUpdateOne) SetSeasonNum(i int) *HistoryUpdateOne {
+	huo.mutation.ResetSeasonNum()
+	huo.mutation.SetSeasonNum(i)
+	return huo
+}
+
+// SetNillableSeasonNum sets the "season_num" field if the given value is not nil.
+func (huo *HistoryUpdateOne) SetNillableSeasonNum(i *int) *HistoryUpdateOne {
 	if i != nil {
-		huo.SetEpisodeID(*i)
+		huo.SetSeasonNum(*i)
 	}
 	return huo
 }
 
-// AddEpisodeID adds i to the "episode_id" field.
-func (huo *HistoryUpdateOne) AddEpisodeID(i int) *HistoryUpdateOne {
-	huo.mutation.AddEpisodeID(i)
+// AddSeasonNum adds i to the "season_num" field.
+func (huo *HistoryUpdateOne) AddSeasonNum(i int) *HistoryUpdateOne {
+	huo.mutation.AddSeasonNum(i)
 	return huo
 }
 
-// ClearEpisodeID clears the value of the "episode_id" field.
-func (huo *HistoryUpdateOne) ClearEpisodeID() *HistoryUpdateOne {
-	huo.mutation.ClearEpisodeID()
+// ClearSeasonNum clears the value of the "season_num" field.
+func (huo *HistoryUpdateOne) ClearSeasonNum() *HistoryUpdateOne {
+	huo.mutation.ClearSeasonNum()
 	return huo
 }
 
@@ -523,6 +597,46 @@ func (huo *HistoryUpdateOne) ClearIndexerID() *HistoryUpdateOne {
 	return huo
 }
 
+// SetLink sets the "link" field.
+func (huo *HistoryUpdateOne) SetLink(s string) *HistoryUpdateOne {
+	huo.mutation.SetLink(s)
+	return huo
+}
+
+// SetNillableLink sets the "link" field if the given value is not nil.
+func (huo *HistoryUpdateOne) SetNillableLink(s *string) *HistoryUpdateOne {
+	if s != nil {
+		huo.SetLink(*s)
+	}
+	return huo
+}
+
+// ClearLink clears the value of the "link" field.
+func (huo *HistoryUpdateOne) ClearLink() *HistoryUpdateOne {
+	huo.mutation.ClearLink()
+	return huo
+}
+
+// SetHash sets the "hash" field.
+func (huo *HistoryUpdateOne) SetHash(s string) *HistoryUpdateOne {
+	huo.mutation.SetHash(s)
+	return huo
+}
+
+// SetNillableHash sets the "hash" field if the given value is not nil.
+func (huo *HistoryUpdateOne) SetNillableHash(s *string) *HistoryUpdateOne {
+	if s != nil {
+		huo.SetHash(*s)
+	}
+	return huo
+}
+
+// ClearHash clears the value of the "hash" field.
+func (huo *HistoryUpdateOne) ClearHash() *HistoryUpdateOne {
+	huo.mutation.ClearHash()
+	return huo
+}
+
 // SetStatus sets the "status" field.
 func (huo *HistoryUpdateOne) SetStatus(h history.Status) *HistoryUpdateOne {
 	huo.mutation.SetStatus(h)
@@ -537,26 +651,6 @@ func (huo *HistoryUpdateOne) SetNillableStatus(h *history.Status) *HistoryUpdate
 	return huo
 }
 
-// SetSaved sets the "saved" field.
-func (huo *HistoryUpdateOne) SetSaved(s string) *HistoryUpdateOne {
-	huo.mutation.SetSaved(s)
-	return huo
-}
-
-// SetNillableSaved sets the "saved" field if the given value is not nil.
-func (huo *HistoryUpdateOne) SetNillableSaved(s *string) *HistoryUpdateOne {
-	if s != nil {
-		huo.SetSaved(*s)
-	}
-	return huo
-}
-
-// ClearSaved clears the value of the "saved" field.
-func (huo *HistoryUpdateOne) ClearSaved() *HistoryUpdateOne {
-	huo.mutation.ClearSaved()
-	return huo
-}
-
 // Mutation returns the HistoryMutation object of the builder.
 func (huo *HistoryUpdateOne) Mutation() *HistoryMutation {
 	return huo.mutation
@@ -647,14 +741,25 @@ func (huo *HistoryUpdateOne) sqlSave(ctx context.Context) (_node *History, err e
 	if value, ok := huo.mutation.AddedMediaID(); ok {
 		_spec.AddField(history.FieldMediaID, field.TypeInt, value)
 	}
-	if value, ok := huo.mutation.EpisodeID(); ok {
-		_spec.SetField(history.FieldEpisodeID, field.TypeInt, value)
+	if value, ok := huo.mutation.EpisodeNums(); ok {
+		_spec.SetField(history.FieldEpisodeNums, field.TypeJSON, value)
 	}
-	if value, ok := huo.mutation.AddedEpisodeID(); ok {
-		_spec.AddField(history.FieldEpisodeID, field.TypeInt, value)
+	if value, ok := huo.mutation.AppendedEpisodeNums(); ok {
+		_spec.AddModifier(func(u *sql.UpdateBuilder) {
+			sqljson.Append(u, history.FieldEpisodeNums, value)
+		})
 	}
-	if huo.mutation.EpisodeIDCleared() {
-		_spec.ClearField(history.FieldEpisodeID, field.TypeInt)
+	if huo.mutation.EpisodeNumsCleared() {
+		_spec.ClearField(history.FieldEpisodeNums, field.TypeJSON)
+	}
+	if value, ok := huo.mutation.SeasonNum(); ok {
+		_spec.SetField(history.FieldSeasonNum, field.TypeInt, value)
+	}
+	if value, ok := huo.mutation.AddedSeasonNum(); ok {
+		_spec.AddField(history.FieldSeasonNum, field.TypeInt, value)
+	}
+	if huo.mutation.SeasonNumCleared() {
+		_spec.ClearField(history.FieldSeasonNum, field.TypeInt)
 	}
 	if value, ok := huo.mutation.SourceTitle(); ok {
 		_spec.SetField(history.FieldSourceTitle, field.TypeString, value)
@@ -689,15 +794,21 @@ func (huo *HistoryUpdateOne) sqlSave(ctx context.Context) (_node *History, err e
 	if huo.mutation.IndexerIDCleared() {
 		_spec.ClearField(history.FieldIndexerID, field.TypeInt)
 	}
+	if value, ok := huo.mutation.Link(); ok {
+		_spec.SetField(history.FieldLink, field.TypeString, value)
+	}
+	if huo.mutation.LinkCleared() {
+		_spec.ClearField(history.FieldLink, field.TypeString)
+	}
+	if value, ok := huo.mutation.Hash(); ok {
+		_spec.SetField(history.FieldHash, field.TypeString, value)
+	}
+	if huo.mutation.HashCleared() {
+		_spec.ClearField(history.FieldHash, field.TypeString)
+	}
 	if value, ok := huo.mutation.Status(); ok {
 		_spec.SetField(history.FieldStatus, field.TypeEnum, value)
 	}
-	if value, ok := huo.mutation.Saved(); ok {
-		_spec.SetField(history.FieldSaved, field.TypeString, value)
-	}
-	if huo.mutation.SavedCleared() {
-		_spec.ClearField(history.FieldSaved, field.TypeString)
-	}
 	_node = &History{config: huo.config}
 	_spec.Assign = _node.assignValues
 	_spec.ScanValues = _node.scanValues

ent/hook/hook.go

@@ -8,16 +8,16 @@ import (
 	"polaris/ent"
 )
 
-// The BlocklistFunc type is an adapter to allow the use of ordinary
-// function as Blocklist mutator.
-type BlocklistFunc func(context.Context, *ent.BlocklistMutation) (ent.Value, error)
+// The BlacklistFunc type is an adapter to allow the use of ordinary
+// function as Blacklist mutator.
+type BlacklistFunc func(context.Context, *ent.BlacklistMutation) (ent.Value, error)
 
 // Mutate calls f(ctx, m).
-func (f BlocklistFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
-	if mv, ok := m.(*ent.BlocklistMutation); ok {
+func (f BlacklistFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
+	if mv, ok := m.(*ent.BlacklistMutation); ok {
 		return f(ctx, mv)
 	}
-	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.BlocklistMutation", m)
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.BlacklistMutation", m)
 }
 
 // The DownloadClientsFunc type is an adapter to allow the use of ordinary

ent/indexers.go

@@ -20,7 +20,7 @@ type Indexers struct {
 	Name string `json:"name,omitempty"`
 	// Implementation holds the value of the "implementation" field.
 	Implementation string `json:"implementation,omitempty"`
-	// Settings holds the value of the "settings" field.
+	// deprecated, use api_key and url
 	Settings string `json:"settings,omitempty"`
 	// EnableRss holds the value of the "enable_rss" field.
 	EnableRss bool `json:"enable_rss,omitempty"`
@@ -29,7 +29,17 @@ type Indexers struct {
 	// minimal seed ratio requied, before removing torrent
 	SeedRatio float32 `json:"seed_ratio,omitempty"`
 	// Disabled holds the value of the "disabled" field.
-	Disabled     bool `json:"disabled,omitempty"`
+	Disabled bool `json:"disabled,omitempty"`
+	// TvSearch holds the value of the "tv_search" field.
+	TvSearch bool `json:"tv_search,omitempty"`
+	// MovieSearch holds the value of the "movie_search" field.
+	MovieSearch bool `json:"movie_search,omitempty"`
+	// APIKey holds the value of the "api_key" field.
+	APIKey string `json:"api_key,omitempty"`
+	// URL holds the value of the "url" field.
+	URL string `json:"url,omitempty"`
+	// synced from prowlarr
+	Synced       bool `json:"synced,omitempty"`
 	selectValues sql.SelectValues
 }
 
@@ -38,13 +48,13 @@ func (*Indexers) scanValues(columns []string) ([]any, error) {
 	values := make([]any, len(columns))
 	for i := range columns {
 		switch columns[i] {
-		case indexers.FieldEnableRss, indexers.FieldDisabled:
+		case indexers.FieldEnableRss, indexers.FieldDisabled, indexers.FieldTvSearch, indexers.FieldMovieSearch, indexers.FieldSynced:
 			values[i] = new(sql.NullBool)
 		case indexers.FieldSeedRatio:
 			values[i] = new(sql.NullFloat64)
 		case indexers.FieldID, indexers.FieldPriority:
 			values[i] = new(sql.NullInt64)
-		case indexers.FieldName, indexers.FieldImplementation, indexers.FieldSettings:
+		case indexers.FieldName, indexers.FieldImplementation, indexers.FieldSettings, indexers.FieldAPIKey, indexers.FieldURL:
 			values[i] = new(sql.NullString)
 		default:
 			values[i] = new(sql.UnknownType)
@@ -109,6 +119,36 @@ func (i *Indexers) assignValues(columns []string, values []any) error {
 			} else if value.Valid {
 				i.Disabled = value.Bool
 			}
+		case indexers.FieldTvSearch:
+			if value, ok := values[j].(*sql.NullBool); !ok {
+				return fmt.Errorf("unexpected type %T for field tv_search", values[j])
+			} else if value.Valid {
+				i.TvSearch = value.Bool
+			}
+		case indexers.FieldMovieSearch:
+			if value, ok := values[j].(*sql.NullBool); !ok {
+				return fmt.Errorf("unexpected type %T for field movie_search", values[j])
+			} else if value.Valid {
+				i.MovieSearch = value.Bool
+			}
+		case indexers.FieldAPIKey:
+			if value, ok := values[j].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field api_key", values[j])
+			} else if value.Valid {
+				i.APIKey = value.String
+			}
+		case indexers.FieldURL:
+			if value, ok := values[j].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field url", values[j])
+			} else if value.Valid {
+				i.URL = value.String
+			}
+		case indexers.FieldSynced:
+			if value, ok := values[j].(*sql.NullBool); !ok {
+				return fmt.Errorf("unexpected type %T for field synced", values[j])
+			} else if value.Valid {
+				i.Synced = value.Bool
+			}
 		default:
 			i.selectValues.Set(columns[j], values[j])
 		}
@@ -165,6 +205,21 @@ func (i *Indexers) String() string {
 	builder.WriteString(", ")
 	builder.WriteString("disabled=")
 	builder.WriteString(fmt.Sprintf("%v", i.Disabled))
+	builder.WriteString(", ")
+	builder.WriteString("tv_search=")
+	builder.WriteString(fmt.Sprintf("%v", i.TvSearch))
+	builder.WriteString(", ")
+	builder.WriteString("movie_search=")
+	builder.WriteString(fmt.Sprintf("%v", i.MovieSearch))
+	builder.WriteString(", ")
+	builder.WriteString("api_key=")
+	builder.WriteString(i.APIKey)
+	builder.WriteString(", ")
+	builder.WriteString("url=")
+	builder.WriteString(i.URL)
+	builder.WriteString(", ")
+	builder.WriteString("synced=")
+	builder.WriteString(fmt.Sprintf("%v", i.Synced))
 	builder.WriteByte(')')
 	return builder.String()
 }

ent/indexers/indexers.go

@@ -25,6 +25,16 @@ const (
 	FieldSeedRatio = "seed_ratio"
 	// FieldDisabled holds the string denoting the disabled field in the database.
 	FieldDisabled = "disabled"
+	// FieldTvSearch holds the string denoting the tv_search field in the database.
+	FieldTvSearch = "tv_search"
+	// FieldMovieSearch holds the string denoting the movie_search field in the database.
+	FieldMovieSearch = "movie_search"
+	// FieldAPIKey holds the string denoting the api_key field in the database.
+	FieldAPIKey = "api_key"
+	// FieldURL holds the string denoting the url field in the database.
+	FieldURL = "url"
+	// FieldSynced holds the string denoting the synced field in the database.
+	FieldSynced = "synced"
 	// Table holds the table name of the indexers in the database.
 	Table = "indexers"
 )
@@ -39,6 +49,11 @@ var Columns = []string{
 	FieldPriority,
 	FieldSeedRatio,
 	FieldDisabled,
+	FieldTvSearch,
+	FieldMovieSearch,
+	FieldAPIKey,
+	FieldURL,
+	FieldSynced,
 }
 
 // ValidColumn reports if the column name is valid (part of the table columns).
@@ -52,6 +67,8 @@ func ValidColumn(column string) bool {
 }
 
 var (
+	// DefaultSettings holds the default value on creation for the "settings" field.
+	DefaultSettings string
 	// DefaultEnableRss holds the default value on creation for the "enable_rss" field.
 	DefaultEnableRss bool
 	// DefaultPriority holds the default value on creation for the "priority" field.
@@ -60,6 +77,12 @@ var (
 	DefaultSeedRatio float32
 	// DefaultDisabled holds the default value on creation for the "disabled" field.
 	DefaultDisabled bool
+	// DefaultTvSearch holds the default value on creation for the "tv_search" field.
+	DefaultTvSearch bool
+	// DefaultMovieSearch holds the default value on creation for the "movie_search" field.
+	DefaultMovieSearch bool
+	// DefaultSynced holds the default value on creation for the "synced" field.
+	DefaultSynced bool
 )
 
 // OrderOption defines the ordering options for the Indexers queries.
@@ -104,3 +127,28 @@ func BySeedRatio(opts ...sql.OrderTermOption) OrderOption {
 func ByDisabled(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldDisabled, opts...).ToFunc()
 }
+
+// ByTvSearch orders the results by the tv_search field.
+func ByTvSearch(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldTvSearch, opts...).ToFunc()
+}
+
+// ByMovieSearch orders the results by the movie_search field.
+func ByMovieSearch(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldMovieSearch, opts...).ToFunc()
+}
+
+// ByAPIKey orders the results by the api_key field.
+func ByAPIKey(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldAPIKey, opts...).ToFunc()
+}
+
+// ByURL orders the results by the url field.
+func ByURL(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldURL, opts...).ToFunc()
+}
+
+// BySynced orders the results by the synced field.
+func BySynced(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldSynced, opts...).ToFunc()
+}

ent/indexers/where.go

@@ -88,6 +88,31 @@ func Disabled(v bool) predicate.Indexers {
 	return predicate.Indexers(sql.FieldEQ(FieldDisabled, v))
 }
 
+// TvSearch applies equality check predicate on the "tv_search" field. It's identical to TvSearchEQ.
+func TvSearch(v bool) predicate.Indexers {
+	return predicate.Indexers(sql.FieldEQ(FieldTvSearch, v))
+}
+
+// MovieSearch applies equality check predicate on the "movie_search" field. It's identical to MovieSearchEQ.
+func MovieSearch(v bool) predicate.Indexers {
+	return predicate.Indexers(sql.FieldEQ(FieldMovieSearch, v))
+}
+
+// APIKey applies equality check predicate on the "api_key" field. It's identical to APIKeyEQ.
+func APIKey(v string) predicate.Indexers {
+	return predicate.Indexers(sql.FieldEQ(FieldAPIKey, v))
+}
+
+// URL applies equality check predicate on the "url" field. It's identical to URLEQ.
+func URL(v string) predicate.Indexers {
+	return predicate.Indexers(sql.FieldEQ(FieldURL, v))
+}
+
+// Synced applies equality check predicate on the "synced" field. It's identical to SyncedEQ.
+func Synced(v bool) predicate.Indexers {
+	return predicate.Indexers(sql.FieldEQ(FieldSynced, v))
+}
+
 // NameEQ applies the EQ predicate on the "name" field.
 func NameEQ(v string) predicate.Indexers {
 	return predicate.Indexers(sql.FieldEQ(FieldName, v))
@@ -273,6 +298,16 @@ func SettingsHasSuffix(v string) predicate.Indexers {
 	return predicate.Indexers(sql.FieldHasSuffix(FieldSettings, v))
 }
 
+// SettingsIsNil applies the IsNil predicate on the "settings" field.
+func SettingsIsNil() predicate.Indexers {
+	return predicate.Indexers(sql.FieldIsNull(FieldSettings))
+}
+
+// SettingsNotNil applies the NotNil predicate on the "settings" field.
+func SettingsNotNil() predicate.Indexers {
+	return predicate.Indexers(sql.FieldNotNull(FieldSettings))
+}
+
 // SettingsEqualFold applies the EqualFold predicate on the "settings" field.
 func SettingsEqualFold(v string) predicate.Indexers {
 	return predicate.Indexers(sql.FieldEqualFold(FieldSettings, v))
@@ -403,6 +438,216 @@ func DisabledNotNil() predicate.Indexers {
 	return predicate.Indexers(sql.FieldNotNull(FieldDisabled))
 }
 
+// TvSearchEQ applies the EQ predicate on the "tv_search" field.
+func TvSearchEQ(v bool) predicate.Indexers {
+	return predicate.Indexers(sql.FieldEQ(FieldTvSearch, v))
+}
+
+// TvSearchNEQ applies the NEQ predicate on the "tv_search" field.
+func TvSearchNEQ(v bool) predicate.Indexers {
+	return predicate.Indexers(sql.FieldNEQ(FieldTvSearch, v))
+}
+
+// TvSearchIsNil applies the IsNil predicate on the "tv_search" field.
+func TvSearchIsNil() predicate.Indexers {
+	return predicate.Indexers(sql.FieldIsNull(FieldTvSearch))
+}
+
+// TvSearchNotNil applies the NotNil predicate on the "tv_search" field.
+func TvSearchNotNil() predicate.Indexers {
+	return predicate.Indexers(sql.FieldNotNull(FieldTvSearch))
+}
+
+// MovieSearchEQ applies the EQ predicate on the "movie_search" field.
+func MovieSearchEQ(v bool) predicate.Indexers {
+	return predicate.Indexers(sql.FieldEQ(FieldMovieSearch, v))
+}
+
+// MovieSearchNEQ applies the NEQ predicate on the "movie_search" field.
+func MovieSearchNEQ(v bool) predicate.Indexers {
+	return predicate.Indexers(sql.FieldNEQ(FieldMovieSearch, v))
+}
+
+// MovieSearchIsNil applies the IsNil predicate on the "movie_search" field.
+func MovieSearchIsNil() predicate.Indexers {
+	return predicate.Indexers(sql.FieldIsNull(FieldMovieSearch))
+}
+
+// MovieSearchNotNil applies the NotNil predicate on the "movie_search" field.
+func MovieSearchNotNil() predicate.Indexers {
+	return predicate.Indexers(sql.FieldNotNull(FieldMovieSearch))
+}
+
+// APIKeyEQ applies the EQ predicate on the "api_key" field.
+func APIKeyEQ(v string) predicate.Indexers {
+	return predicate.Indexers(sql.FieldEQ(FieldAPIKey, v))
+}
+
+// APIKeyNEQ applies the NEQ predicate on the "api_key" field.
+func APIKeyNEQ(v string) predicate.Indexers {
+	return predicate.Indexers(sql.FieldNEQ(FieldAPIKey, v))
+}
+
+// APIKeyIn applies the In predicate on the "api_key" field.
+func APIKeyIn(vs ...string) predicate.Indexers {
+	return predicate.Indexers(sql.FieldIn(FieldAPIKey, vs...))
+}
+
+// APIKeyNotIn applies the NotIn predicate on the "api_key" field.
+func APIKeyNotIn(vs ...string) predicate.Indexers {
+	return predicate.Indexers(sql.FieldNotIn(FieldAPIKey, vs...))
+}
+
+// APIKeyGT applies the GT predicate on the "api_key" field.
+func APIKeyGT(v string) predicate.Indexers {
+	return predicate.Indexers(sql.FieldGT(FieldAPIKey, v))
+}
+
+// APIKeyGTE applies the GTE predicate on the "api_key" field.
+func APIKeyGTE(v string) predicate.Indexers {
+	return predicate.Indexers(sql.FieldGTE(FieldAPIKey, v))
+}
+
+// APIKeyLT applies the LT predicate on the "api_key" field.
+func APIKeyLT(v string) predicate.Indexers {
+	return predicate.Indexers(sql.FieldLT(FieldAPIKey, v))
+}
+
+// APIKeyLTE applies the LTE predicate on the "api_key" field.
+func APIKeyLTE(v string) predicate.Indexers {
+	return predicate.Indexers(sql.FieldLTE(FieldAPIKey, v))
+}
+
+// APIKeyContains applies the Contains predicate on the "api_key" field.
+func APIKeyContains(v string) predicate.Indexers {
+	return predicate.Indexers(sql.FieldContains(FieldAPIKey, v))
+}
+
+// APIKeyHasPrefix applies the HasPrefix predicate on the "api_key" field.
+func APIKeyHasPrefix(v string) predicate.Indexers {
+	return predicate.Indexers(sql.FieldHasPrefix(FieldAPIKey, v))
+}
+
+// APIKeyHasSuffix applies the HasSuffix predicate on the "api_key" field.
+func APIKeyHasSuffix(v string) predicate.Indexers {
+	return predicate.Indexers(sql.FieldHasSuffix(FieldAPIKey, v))
+}
+
+// APIKeyIsNil applies the IsNil predicate on the "api_key" field.
+func APIKeyIsNil() predicate.Indexers {
+	return predicate.Indexers(sql.FieldIsNull(FieldAPIKey))
+}
+
+// APIKeyNotNil applies the NotNil predicate on the "api_key" field.
+func APIKeyNotNil() predicate.Indexers {
+	return predicate.Indexers(sql.FieldNotNull(FieldAPIKey))
+}
+
+// APIKeyEqualFold applies the EqualFold predicate on the "api_key" field.
+func APIKeyEqualFold(v string) predicate.Indexers {
+	return predicate.Indexers(sql.FieldEqualFold(FieldAPIKey, v))
+}
+
+// APIKeyContainsFold applies the ContainsFold predicate on the "api_key" field.
+func APIKeyContainsFold(v string) predicate.Indexers {
+	return predicate.Indexers(sql.FieldContainsFold(FieldAPIKey, v))
+}
+
+// URLEQ applies the EQ predicate on the "url" field.
+func URLEQ(v string) predicate.Indexers {
+	return predicate.Indexers(sql.FieldEQ(FieldURL, v))
+}
+
+// URLNEQ applies the NEQ predicate on the "url" field.
+func URLNEQ(v string) predicate.Indexers {
+	return predicate.Indexers(sql.FieldNEQ(FieldURL, v))
+}
+
+// URLIn applies the In predicate on the "url" field.
+func URLIn(vs ...string) predicate.Indexers {
+	return predicate.Indexers(sql.FieldIn(FieldURL, vs...))
+}
+
+// URLNotIn applies the NotIn predicate on the "url" field.
+func URLNotIn(vs ...string) predicate.Indexers {
+	return predicate.Indexers(sql.FieldNotIn(FieldURL, vs...))
+}
+
+// URLGT applies the GT predicate on the "url" field.
+func URLGT(v string) predicate.Indexers {
+	return predicate.Indexers(sql.FieldGT(FieldURL, v))
+}
+
+// URLGTE applies the GTE predicate on the "url" field.
+func URLGTE(v string) predicate.Indexers {
+	return predicate.Indexers(sql.FieldGTE(FieldURL, v))
+}
+
+// URLLT applies the LT predicate on the "url" field.
+func URLLT(v string) predicate.Indexers {
+	return predicate.Indexers(sql.FieldLT(FieldURL, v))
+}
+
+// URLLTE applies the LTE predicate on the "url" field.
+func URLLTE(v string) predicate.Indexers {
+	return predicate.Indexers(sql.FieldLTE(FieldURL, v))
+}
+
+// URLContains applies the Contains predicate on the "url" field.
+func URLContains(v string) predicate.Indexers {
+	return predicate.Indexers(sql.FieldContains(FieldURL, v))
+}
+
+// URLHasPrefix applies the HasPrefix predicate on the "url" field.
+func URLHasPrefix(v string) predicate.Indexers {
+	return predicate.Indexers(sql.FieldHasPrefix(FieldURL, v))
+}
+
+// URLHasSuffix applies the HasSuffix predicate on the "url" field.
+func URLHasSuffix(v string) predicate.Indexers {
+	return predicate.Indexers(sql.FieldHasSuffix(FieldURL, v))
+}
+
+// URLIsNil applies the IsNil predicate on the "url" field.
+func URLIsNil() predicate.Indexers {
+	return predicate.Indexers(sql.FieldIsNull(FieldURL))
+}
+
+// URLNotNil applies the NotNil predicate on the "url" field.
+func URLNotNil() predicate.Indexers {
+	return predicate.Indexers(sql.FieldNotNull(FieldURL))
+}
+
+// URLEqualFold applies the EqualFold predicate on the "url" field.
+func URLEqualFold(v string) predicate.Indexers {
+	return predicate.Indexers(sql.FieldEqualFold(FieldURL, v))
+}
+
+// URLContainsFold applies the ContainsFold predicate on the "url" field.
+func URLContainsFold(v string) predicate.Indexers {
+	return predicate.Indexers(sql.FieldContainsFold(FieldURL, v))
+}
+
+// SyncedEQ applies the EQ predicate on the "synced" field.
+func SyncedEQ(v bool) predicate.Indexers {
+	return predicate.Indexers(sql.FieldEQ(FieldSynced, v))
+}
+
+// SyncedNEQ applies the NEQ predicate on the "synced" field.
+func SyncedNEQ(v bool) predicate.Indexers {
+	return predicate.Indexers(sql.FieldNEQ(FieldSynced, v))
+}
+
+// SyncedIsNil applies the IsNil predicate on the "synced" field.
+func SyncedIsNil() predicate.Indexers {
+	return predicate.Indexers(sql.FieldIsNull(FieldSynced))
+}
+
+// SyncedNotNil applies the NotNil predicate on the "synced" field.
+func SyncedNotNil() predicate.Indexers {
+	return predicate.Indexers(sql.FieldNotNull(FieldSynced))
+}
+
 // And groups predicates with the AND operator between them.
 func And(predicates ...predicate.Indexers) predicate.Indexers {
 	return predicate.Indexers(sql.AndPredicates(predicates...))

ent/indexers_create.go

@@ -37,6 +37,14 @@ func (ic *IndexersCreate) SetSettings(s string) *IndexersCreate {
 	return ic
 }
 
+// SetNillableSettings sets the "settings" field if the given value is not nil.
+func (ic *IndexersCreate) SetNillableSettings(s *string) *IndexersCreate {
+	if s != nil {
+		ic.SetSettings(*s)
+	}
+	return ic
+}
+
 // SetEnableRss sets the "enable_rss" field.
 func (ic *IndexersCreate) SetEnableRss(b bool) *IndexersCreate {
 	ic.mutation.SetEnableRss(b)
@@ -93,6 +101,76 @@ func (ic *IndexersCreate) SetNillableDisabled(b *bool) *IndexersCreate {
 	return ic
 }
 
+// SetTvSearch sets the "tv_search" field.
+func (ic *IndexersCreate) SetTvSearch(b bool) *IndexersCreate {
+	ic.mutation.SetTvSearch(b)
+	return ic
+}
+
+// SetNillableTvSearch sets the "tv_search" field if the given value is not nil.
+func (ic *IndexersCreate) SetNillableTvSearch(b *bool) *IndexersCreate {
+	if b != nil {
+		ic.SetTvSearch(*b)
+	}
+	return ic
+}
+
+// SetMovieSearch sets the "movie_search" field.
+func (ic *IndexersCreate) SetMovieSearch(b bool) *IndexersCreate {
+	ic.mutation.SetMovieSearch(b)
+	return ic
+}
+
+// SetNillableMovieSearch sets the "movie_search" field if the given value is not nil.
+func (ic *IndexersCreate) SetNillableMovieSearch(b *bool) *IndexersCreate {
+	if b != nil {
+		ic.SetMovieSearch(*b)
+	}
+	return ic
+}
+
+// SetAPIKey sets the "api_key" field.
+func (ic *IndexersCreate) SetAPIKey(s string) *IndexersCreate {
+	ic.mutation.SetAPIKey(s)
+	return ic
+}
+
+// SetNillableAPIKey sets the "api_key" field if the given value is not nil.
+func (ic *IndexersCreate) SetNillableAPIKey(s *string) *IndexersCreate {
+	if s != nil {
+		ic.SetAPIKey(*s)
+	}
+	return ic
+}
+
+// SetURL sets the "url" field.
+func (ic *IndexersCreate) SetURL(s string) *IndexersCreate {
+	ic.mutation.SetURL(s)
+	return ic
+}
+
+// SetNillableURL sets the "url" field if the given value is not nil.
+func (ic *IndexersCreate) SetNillableURL(s *string) *IndexersCreate {
+	if s != nil {
+		ic.SetURL(*s)
+	}
+	return ic
+}
+
+// SetSynced sets the "synced" field.
+func (ic *IndexersCreate) SetSynced(b bool) *IndexersCreate {
+	ic.mutation.SetSynced(b)
+	return ic
+}
+
+// SetNillableSynced sets the "synced" field if the given value is not nil.
+func (ic *IndexersCreate) SetNillableSynced(b *bool) *IndexersCreate {
+	if b != nil {
+		ic.SetSynced(*b)
+	}
+	return ic
+}
+
 // Mutation returns the IndexersMutation object of the builder.
 func (ic *IndexersCreate) Mutation() *IndexersMutation {
 	return ic.mutation
@@ -128,6 +206,10 @@ func (ic *IndexersCreate) ExecX(ctx context.Context) {
 
 // defaults sets the default values of the builder before save.
 func (ic *IndexersCreate) defaults() {
+	if _, ok := ic.mutation.Settings(); !ok {
+		v := indexers.DefaultSettings
+		ic.mutation.SetSettings(v)
+	}
 	if _, ok := ic.mutation.EnableRss(); !ok {
 		v := indexers.DefaultEnableRss
 		ic.mutation.SetEnableRss(v)
@@ -144,6 +226,18 @@ func (ic *IndexersCreate) defaults() {
 		v := indexers.DefaultDisabled
 		ic.mutation.SetDisabled(v)
 	}
+	if _, ok := ic.mutation.TvSearch(); !ok {
+		v := indexers.DefaultTvSearch
+		ic.mutation.SetTvSearch(v)
+	}
+	if _, ok := ic.mutation.MovieSearch(); !ok {
+		v := indexers.DefaultMovieSearch
+		ic.mutation.SetMovieSearch(v)
+	}
+	if _, ok := ic.mutation.Synced(); !ok {
+		v := indexers.DefaultSynced
+		ic.mutation.SetSynced(v)
+	}
 }
 
 // check runs all checks and user-defined validators on the builder.
@@ -154,9 +248,6 @@ func (ic *IndexersCreate) check() error {
 	if _, ok := ic.mutation.Implementation(); !ok {
 		return &ValidationError{Name: "implementation", err: errors.New(`ent: missing required field "Indexers.implementation"`)}
 	}
-	if _, ok := ic.mutation.Settings(); !ok {
-		return &ValidationError{Name: "settings", err: errors.New(`ent: missing required field "Indexers.settings"`)}
-	}
 	if _, ok := ic.mutation.EnableRss(); !ok {
 		return &ValidationError{Name: "enable_rss", err: errors.New(`ent: missing required field "Indexers.enable_rss"`)}
 	}
@@ -217,6 +308,26 @@ func (ic *IndexersCreate) createSpec() (*Indexers, *sqlgraph.CreateSpec) {
 		_spec.SetField(indexers.FieldDisabled, field.TypeBool, value)
 		_node.Disabled = value
 	}
+	if value, ok := ic.mutation.TvSearch(); ok {
+		_spec.SetField(indexers.FieldTvSearch, field.TypeBool, value)
+		_node.TvSearch = value
+	}
+	if value, ok := ic.mutation.MovieSearch(); ok {
+		_spec.SetField(indexers.FieldMovieSearch, field.TypeBool, value)
+		_node.MovieSearch = value
+	}
+	if value, ok := ic.mutation.APIKey(); ok {
+		_spec.SetField(indexers.FieldAPIKey, field.TypeString, value)
+		_node.APIKey = value
+	}
+	if value, ok := ic.mutation.URL(); ok {
+		_spec.SetField(indexers.FieldURL, field.TypeString, value)
+		_node.URL = value
+	}
+	if value, ok := ic.mutation.Synced(); ok {
+		_spec.SetField(indexers.FieldSynced, field.TypeBool, value)
+		_node.Synced = value
+	}
 	return _node, _spec
 }
 

ent/indexers_update.go

@@ -69,6 +69,12 @@ func (iu *IndexersUpdate) SetNillableSettings(s *string) *IndexersUpdate {
 	return iu
 }
 
+// ClearSettings clears the value of the "settings" field.
+func (iu *IndexersUpdate) ClearSettings() *IndexersUpdate {
+	iu.mutation.ClearSettings()
+	return iu
+}
+
 // SetEnableRss sets the "enable_rss" field.
 func (iu *IndexersUpdate) SetEnableRss(b bool) *IndexersUpdate {
 	iu.mutation.SetEnableRss(b)
@@ -151,6 +157,106 @@ func (iu *IndexersUpdate) ClearDisabled() *IndexersUpdate {
 	return iu
 }
 
+// SetTvSearch sets the "tv_search" field.
+func (iu *IndexersUpdate) SetTvSearch(b bool) *IndexersUpdate {
+	iu.mutation.SetTvSearch(b)
+	return iu
+}
+
+// SetNillableTvSearch sets the "tv_search" field if the given value is not nil.
+func (iu *IndexersUpdate) SetNillableTvSearch(b *bool) *IndexersUpdate {
+	if b != nil {
+		iu.SetTvSearch(*b)
+	}
+	return iu
+}
+
+// ClearTvSearch clears the value of the "tv_search" field.
+func (iu *IndexersUpdate) ClearTvSearch() *IndexersUpdate {
+	iu.mutation.ClearTvSearch()
+	return iu
+}
+
+// SetMovieSearch sets the "movie_search" field.
+func (iu *IndexersUpdate) SetMovieSearch(b bool) *IndexersUpdate {
+	iu.mutation.SetMovieSearch(b)
+	return iu
+}
+
+// SetNillableMovieSearch sets the "movie_search" field if the given value is not nil.
+func (iu *IndexersUpdate) SetNillableMovieSearch(b *bool) *IndexersUpdate {
+	if b != nil {
+		iu.SetMovieSearch(*b)
+	}
+	return iu
+}
+
+// ClearMovieSearch clears the value of the "movie_search" field.
+func (iu *IndexersUpdate) ClearMovieSearch() *IndexersUpdate {
+	iu.mutation.ClearMovieSearch()
+	return iu
+}
+
+// SetAPIKey sets the "api_key" field.
+func (iu *IndexersUpdate) SetAPIKey(s string) *IndexersUpdate {
+	iu.mutation.SetAPIKey(s)
+	return iu
+}
+
+// SetNillableAPIKey sets the "api_key" field if the given value is not nil.
+func (iu *IndexersUpdate) SetNillableAPIKey(s *string) *IndexersUpdate {
+	if s != nil {
+		iu.SetAPIKey(*s)
+	}
+	return iu
+}
+
+// ClearAPIKey clears the value of the "api_key" field.
+func (iu *IndexersUpdate) ClearAPIKey() *IndexersUpdate {
+	iu.mutation.ClearAPIKey()
+	return iu
+}
+
+// SetURL sets the "url" field.
+func (iu *IndexersUpdate) SetURL(s string) *IndexersUpdate {
+	iu.mutation.SetURL(s)
+	return iu
+}
+
+// SetNillableURL sets the "url" field if the given value is not nil.
+func (iu *IndexersUpdate) SetNillableURL(s *string) *IndexersUpdate {
+	if s != nil {
+		iu.SetURL(*s)
+	}
+	return iu
+}
+
+// ClearURL clears the value of the "url" field.
+func (iu *IndexersUpdate) ClearURL() *IndexersUpdate {
+	iu.mutation.ClearURL()
+	return iu
+}
+
+// SetSynced sets the "synced" field.
+func (iu *IndexersUpdate) SetSynced(b bool) *IndexersUpdate {
+	iu.mutation.SetSynced(b)
+	return iu
+}
+
+// SetNillableSynced sets the "synced" field if the given value is not nil.
+func (iu *IndexersUpdate) SetNillableSynced(b *bool) *IndexersUpdate {
+	if b != nil {
+		iu.SetSynced(*b)
+	}
+	return iu
+}
+
+// ClearSynced clears the value of the "synced" field.
+func (iu *IndexersUpdate) ClearSynced() *IndexersUpdate {
+	iu.mutation.ClearSynced()
+	return iu
+}
+
 // Mutation returns the IndexersMutation object of the builder.
 func (iu *IndexersUpdate) Mutation() *IndexersMutation {
 	return iu.mutation
@@ -201,6 +307,9 @@ func (iu *IndexersUpdate) sqlSave(ctx context.Context) (n int, err error) {
 	if value, ok := iu.mutation.Settings(); ok {
 		_spec.SetField(indexers.FieldSettings, field.TypeString, value)
 	}
+	if iu.mutation.SettingsCleared() {
+		_spec.ClearField(indexers.FieldSettings, field.TypeString)
+	}
 	if value, ok := iu.mutation.EnableRss(); ok {
 		_spec.SetField(indexers.FieldEnableRss, field.TypeBool, value)
 	}
@@ -225,6 +334,36 @@ func (iu *IndexersUpdate) sqlSave(ctx context.Context) (n int, err error) {
 	if iu.mutation.DisabledCleared() {
 		_spec.ClearField(indexers.FieldDisabled, field.TypeBool)
 	}
+	if value, ok := iu.mutation.TvSearch(); ok {
+		_spec.SetField(indexers.FieldTvSearch, field.TypeBool, value)
+	}
+	if iu.mutation.TvSearchCleared() {
+		_spec.ClearField(indexers.FieldTvSearch, field.TypeBool)
+	}
+	if value, ok := iu.mutation.MovieSearch(); ok {
+		_spec.SetField(indexers.FieldMovieSearch, field.TypeBool, value)
+	}
+	if iu.mutation.MovieSearchCleared() {
+		_spec.ClearField(indexers.FieldMovieSearch, field.TypeBool)
+	}
+	if value, ok := iu.mutation.APIKey(); ok {
+		_spec.SetField(indexers.FieldAPIKey, field.TypeString, value)
+	}
+	if iu.mutation.APIKeyCleared() {
+		_spec.ClearField(indexers.FieldAPIKey, field.TypeString)
+	}
+	if value, ok := iu.mutation.URL(); ok {
+		_spec.SetField(indexers.FieldURL, field.TypeString, value)
+	}
+	if iu.mutation.URLCleared() {
+		_spec.ClearField(indexers.FieldURL, field.TypeString)
+	}
+	if value, ok := iu.mutation.Synced(); ok {
+		_spec.SetField(indexers.FieldSynced, field.TypeBool, value)
+	}
+	if iu.mutation.SyncedCleared() {
+		_spec.ClearField(indexers.FieldSynced, field.TypeBool)
+	}
 	if n, err = sqlgraph.UpdateNodes(ctx, iu.driver, _spec); err != nil {
 		if _, ok := err.(*sqlgraph.NotFoundError); ok {
 			err = &NotFoundError{indexers.Label}
@@ -287,6 +426,12 @@ func (iuo *IndexersUpdateOne) SetNillableSettings(s *string) *IndexersUpdateOne
 	return iuo
 }
 
+// ClearSettings clears the value of the "settings" field.
+func (iuo *IndexersUpdateOne) ClearSettings() *IndexersUpdateOne {
+	iuo.mutation.ClearSettings()
+	return iuo
+}
+
 // SetEnableRss sets the "enable_rss" field.
 func (iuo *IndexersUpdateOne) SetEnableRss(b bool) *IndexersUpdateOne {
 	iuo.mutation.SetEnableRss(b)
@@ -369,6 +514,106 @@ func (iuo *IndexersUpdateOne) ClearDisabled() *IndexersUpdateOne {
 	return iuo
 }
 
+// SetTvSearch sets the "tv_search" field.
+func (iuo *IndexersUpdateOne) SetTvSearch(b bool) *IndexersUpdateOne {
+	iuo.mutation.SetTvSearch(b)
+	return iuo
+}
+
+// SetNillableTvSearch sets the "tv_search" field if the given value is not nil.
+func (iuo *IndexersUpdateOne) SetNillableTvSearch(b *bool) *IndexersUpdateOne {
+	if b != nil {
+		iuo.SetTvSearch(*b)
+	}
+	return iuo
+}
+
+// ClearTvSearch clears the value of the "tv_search" field.
+func (iuo *IndexersUpdateOne) ClearTvSearch() *IndexersUpdateOne {
+	iuo.mutation.ClearTvSearch()
+	return iuo
+}
+
+// SetMovieSearch sets the "movie_search" field.
+func (iuo *IndexersUpdateOne) SetMovieSearch(b bool) *IndexersUpdateOne {
+	iuo.mutation.SetMovieSearch(b)
+	return iuo
+}
+
+// SetNillableMovieSearch sets the "movie_search" field if the given value is not nil.
+func (iuo *IndexersUpdateOne) SetNillableMovieSearch(b *bool) *IndexersUpdateOne {
+	if b != nil {
+		iuo.SetMovieSearch(*b)
+	}
+	return iuo
+}
+
+// ClearMovieSearch clears the value of the "movie_search" field.
+func (iuo *IndexersUpdateOne) ClearMovieSearch() *IndexersUpdateOne {
+	iuo.mutation.ClearMovieSearch()
+	return iuo
+}
+
+// SetAPIKey sets the "api_key" field.
+func (iuo *IndexersUpdateOne) SetAPIKey(s string) *IndexersUpdateOne {
+	iuo.mutation.SetAPIKey(s)
+	return iuo
+}
+
+// SetNillableAPIKey sets the "api_key" field if the given value is not nil.
+func (iuo *IndexersUpdateOne) SetNillableAPIKey(s *string) *IndexersUpdateOne {
+	if s != nil {
+		iuo.SetAPIKey(*s)
+	}
+	return iuo
+}
+
+// ClearAPIKey clears the value of the "api_key" field.
+func (iuo *IndexersUpdateOne) ClearAPIKey() *IndexersUpdateOne {
+	iuo.mutation.ClearAPIKey()
+	return iuo
+}
+
+// SetURL sets the "url" field.
+func (iuo *IndexersUpdateOne) SetURL(s string) *IndexersUpdateOne {
+	iuo.mutation.SetURL(s)
+	return iuo
+}
+
+// SetNillableURL sets the "url" field if the given value is not nil.
+func (iuo *IndexersUpdateOne) SetNillableURL(s *string) *IndexersUpdateOne {
+	if s != nil {
+		iuo.SetURL(*s)
+	}
+	return iuo
+}
+
+// ClearURL clears the value of the "url" field.
+func (iuo *IndexersUpdateOne) ClearURL() *IndexersUpdateOne {
+	iuo.mutation.ClearURL()
+	return iuo
+}
+
+// SetSynced sets the "synced" field.
+func (iuo *IndexersUpdateOne) SetSynced(b bool) *IndexersUpdateOne {
+	iuo.mutation.SetSynced(b)
+	return iuo
+}
+
+// SetNillableSynced sets the "synced" field if the given value is not nil.
+func (iuo *IndexersUpdateOne) SetNillableSynced(b *bool) *IndexersUpdateOne {
+	if b != nil {
+		iuo.SetSynced(*b)
+	}
+	return iuo
+}
+
+// ClearSynced clears the value of the "synced" field.
+func (iuo *IndexersUpdateOne) ClearSynced() *IndexersUpdateOne {
+	iuo.mutation.ClearSynced()
+	return iuo
+}
+
 // Mutation returns the IndexersMutation object of the builder.
 func (iuo *IndexersUpdateOne) Mutation() *IndexersMutation {
 	return iuo.mutation
@@ -449,6 +694,9 @@ func (iuo *IndexersUpdateOne) sqlSave(ctx context.Context) (_node *Indexers, err
 	if value, ok := iuo.mutation.Settings(); ok {
 		_spec.SetField(indexers.FieldSettings, field.TypeString, value)
 	}
+	if iuo.mutation.SettingsCleared() {
+		_spec.ClearField(indexers.FieldSettings, field.TypeString)
+	}
 	if value, ok := iuo.mutation.EnableRss(); ok {
 		_spec.SetField(indexers.FieldEnableRss, field.TypeBool, value)
 	}
@@ -473,6 +721,36 @@ func (iuo *IndexersUpdateOne) sqlSave(ctx context.Context) (_node *Indexers, err
 	if iuo.mutation.DisabledCleared() {
 		_spec.ClearField(indexers.FieldDisabled, field.TypeBool)
 	}
+	if value, ok := iuo.mutation.TvSearch(); ok {
+		_spec.SetField(indexers.FieldTvSearch, field.TypeBool, value)
+	}
+	if iuo.mutation.TvSearchCleared() {
+		_spec.ClearField(indexers.FieldTvSearch, field.TypeBool)
+	}
+	if value, ok := iuo.mutation.MovieSearch(); ok {
+		_spec.SetField(indexers.FieldMovieSearch, field.TypeBool, value)
+	}
+	if iuo.mutation.MovieSearchCleared() {
+		_spec.ClearField(indexers.FieldMovieSearch, field.TypeBool)
+	}
+	if value, ok := iuo.mutation.APIKey(); ok {
+		_spec.SetField(indexers.FieldAPIKey, field.TypeString, value)
+	}
+	if iuo.mutation.APIKeyCleared() {
+		_spec.ClearField(indexers.FieldAPIKey, field.TypeString)
+	}
+	if value, ok := iuo.mutation.URL(); ok {
+		_spec.SetField(indexers.FieldURL, field.TypeString, value)
+	}
+	if iuo.mutation.URLCleared() {
+		_spec.ClearField(indexers.FieldURL, field.TypeString)
+	}
+	if value, ok := iuo.mutation.Synced(); ok {
+		_spec.SetField(indexers.FieldSynced, field.TypeBool, value)
+	}
+	if iuo.mutation.SyncedCleared() {
+		_spec.ClearField(indexers.FieldSynced, field.TypeBool)
+	}
 	_node = &Indexers{config: iuo.config}
 	_spec.Assign = _node.assignValues
 	_spec.ScanValues = _node.scanValues

ent/media.go

@@ -49,6 +49,8 @@ type Media struct {
 	Limiter schema.MediaLimiter `json:"limiter,omitempty"`
 	// Extras holds the value of the "extras" field.
 	Extras schema.MediaExtras `json:"extras,omitempty"`
+	// AlternativeTitles holds the value of the "alternative_titles" field.
+	AlternativeTitles []schema.AlternativeTilte `json:"alternative_titles,omitempty"`
 	// Edges holds the relations/edges for other nodes in the graph.
 	// The values are being populated by the MediaQuery when eager-loading is set.
 	Edges        MediaEdges `json:"edges"`
@@ -78,7 +80,7 @@ func (*Media) scanValues(columns []string) ([]any, error) {
 	values := make([]any, len(columns))
 	for i := range columns {
 		switch columns[i] {
-		case media.FieldLimiter, media.FieldExtras:
+		case media.FieldLimiter, media.FieldExtras, media.FieldAlternativeTitles:
 			values[i] = new([]byte)
 		case media.FieldDownloadHistoryEpisodes:
 			values[i] = new(sql.NullBool)
@@ -203,6 +205,14 @@ func (m *Media) assignValues(columns []string, values []any) error {
 					return fmt.Errorf("unmarshal field extras: %w", err)
 				}
 			}
+		case media.FieldAlternativeTitles:
+			if value, ok := values[i].(*[]byte); !ok {
+				return fmt.Errorf("unexpected type %T for field alternative_titles", values[i])
+			} else if value != nil && len(*value) > 0 {
+				if err := json.Unmarshal(*value, &m.AlternativeTitles); err != nil {
+					return fmt.Errorf("unmarshal field alternative_titles: %w", err)
+				}
+			}
 		default:
 			m.selectValues.Set(columns[i], values[i])
 		}
@@ -288,6 +298,9 @@ func (m *Media) String() string {
 	builder.WriteString(", ")
 	builder.WriteString("extras=")
 	builder.WriteString(fmt.Sprintf("%v", m.Extras))
+	builder.WriteString(", ")
+	builder.WriteString("alternative_titles=")
+	builder.WriteString(fmt.Sprintf("%v", m.AlternativeTitles))
 	builder.WriteByte(')')
 	return builder.String()
 }

ent/media/media.go

@@ -45,6 +45,8 @@ const (
 	FieldLimiter = "limiter"
 	// FieldExtras holds the string denoting the extras field in the database.
 	FieldExtras = "extras"
+	// FieldAlternativeTitles holds the string denoting the alternative_titles field in the database.
+	FieldAlternativeTitles = "alternative_titles"
 	// EdgeEpisodes holds the string denoting the episodes edge name in mutations.
 	EdgeEpisodes = "episodes"
 	// Table holds the table name of the media in the database.
@@ -76,6 +78,7 @@ var Columns = []string{
 	FieldDownloadHistoryEpisodes,
 	FieldLimiter,
 	FieldExtras,
+	FieldAlternativeTitles,
 }
 
 // ValidColumn reports if the column name is valid (part of the table columns).
@@ -131,6 +134,7 @@ const (
 	Resolution720p  Resolution = "720p"
 	Resolution1080p Resolution = "1080p"
 	Resolution2160p Resolution = "2160p"
+	ResolutionAny   Resolution = "any"
 )
 
 func (r Resolution) String() string {
@@ -140,7 +144,7 @@ func (r Resolution) String() string {
 // ResolutionValidator is a validator for the "resolution" field enum values. It is called by the builders before save.
 func ResolutionValidator(r Resolution) error {
 	switch r {
-	case Resolution720p, Resolution1080p, Resolution2160p:
+	case Resolution720p, Resolution1080p, Resolution2160p, ResolutionAny:
 		return nil
 	default:
 		return fmt.Errorf("media: invalid enum value for resolution field: %q", r)

ent/media/where.go

@@ -795,6 +795,16 @@ func ExtrasNotNil() predicate.Media {
 	return predicate.Media(sql.FieldNotNull(FieldExtras))
 }
 
+// AlternativeTitlesIsNil applies the IsNil predicate on the "alternative_titles" field.
+func AlternativeTitlesIsNil() predicate.Media {
+	return predicate.Media(sql.FieldIsNull(FieldAlternativeTitles))
+}
+
+// AlternativeTitlesNotNil applies the NotNil predicate on the "alternative_titles" field.
+func AlternativeTitlesNotNil() predicate.Media {
+	return predicate.Media(sql.FieldNotNull(FieldAlternativeTitles))
+}
+
 // HasEpisodes applies the HasEdge predicate on the "episodes" edge.
 func HasEpisodes() predicate.Media {
 	return predicate.Media(func(s *sql.Selector) {

ent/media_create.go

@@ -184,6 +184,12 @@ func (mc *MediaCreate) SetNillableExtras(se *schema.MediaExtras) *MediaCreate {
 	return mc
 }
 
+// SetAlternativeTitles sets the "alternative_titles" field.
+func (mc *MediaCreate) SetAlternativeTitles(st []schema.AlternativeTilte) *MediaCreate {
+	mc.mutation.SetAlternativeTitles(st)
+	return mc
+}
+
 // AddEpisodeIDs adds the "episodes" edge to the Episode entity by IDs.
 func (mc *MediaCreate) AddEpisodeIDs(ids ...int) *MediaCreate {
 	mc.mutation.AddEpisodeIDs(ids...)
@@ -377,6 +383,10 @@ func (mc *MediaCreate) createSpec() (*Media, *sqlgraph.CreateSpec) {
 		_spec.SetField(media.FieldExtras, field.TypeJSON, value)
 		_node.Extras = value
 	}
+	if value, ok := mc.mutation.AlternativeTitles(); ok {
+		_spec.SetField(media.FieldAlternativeTitles, field.TypeJSON, value)
+		_node.AlternativeTitles = value
+	}
 	if nodes := mc.mutation.EpisodesIDs(); len(nodes) > 0 {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,

ent/media_update.go

@@ -14,6 +14,7 @@ import (
 
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/dialect/sql/sqljson"
 	"entgo.io/ent/schema/field"
 )
 
@@ -290,6 +291,24 @@ func (mu *MediaUpdate) ClearExtras() *MediaUpdate {
 	return mu
 }
 
+// SetAlternativeTitles sets the "alternative_titles" field.
+func (mu *MediaUpdate) SetAlternativeTitles(st []schema.AlternativeTilte) *MediaUpdate {
+	mu.mutation.SetAlternativeTitles(st)
+	return mu
+}
+
+// AppendAlternativeTitles appends st to the "alternative_titles" field.
+func (mu *MediaUpdate) AppendAlternativeTitles(st []schema.AlternativeTilte) *MediaUpdate {
+	mu.mutation.AppendAlternativeTitles(st)
+	return mu
+}
+
+// ClearAlternativeTitles clears the value of the "alternative_titles" field.
+func (mu *MediaUpdate) ClearAlternativeTitles() *MediaUpdate {
+	mu.mutation.ClearAlternativeTitles()
+	return mu
+}
+
 // AddEpisodeIDs adds the "episodes" edge to the Episode entity by IDs.
 func (mu *MediaUpdate) AddEpisodeIDs(ids ...int) *MediaUpdate {
 	mu.mutation.AddEpisodeIDs(ids...)
@@ -454,6 +473,17 @@ func (mu *MediaUpdate) sqlSave(ctx context.Context) (n int, err error) {
 	if mu.mutation.ExtrasCleared() {
 		_spec.ClearField(media.FieldExtras, field.TypeJSON)
 	}
+	if value, ok := mu.mutation.AlternativeTitles(); ok {
+		_spec.SetField(media.FieldAlternativeTitles, field.TypeJSON, value)
+	}
+	if value, ok := mu.mutation.AppendedAlternativeTitles(); ok {
+		_spec.AddModifier(func(u *sql.UpdateBuilder) {
+			sqljson.Append(u, media.FieldAlternativeTitles, value)
+		})
+	}
+	if mu.mutation.AlternativeTitlesCleared() {
+		_spec.ClearField(media.FieldAlternativeTitles, field.TypeJSON)
+	}
 	if mu.mutation.EpisodesCleared() {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,
@@ -779,6 +809,24 @@ func (muo *MediaUpdateOne) ClearExtras() *MediaUpdateOne {
 	return muo
 }
 
+// SetAlternativeTitles sets the "alternative_titles" field.
+func (muo *MediaUpdateOne) SetAlternativeTitles(st []schema.AlternativeTilte) *MediaUpdateOne {
+	muo.mutation.SetAlternativeTitles(st)
+	return muo
+}
+
+// AppendAlternativeTitles appends st to the "alternative_titles" field.
+func (muo *MediaUpdateOne) AppendAlternativeTitles(st []schema.AlternativeTilte) *MediaUpdateOne {
+	muo.mutation.AppendAlternativeTitles(st)
+	return muo
+}
+
+// ClearAlternativeTitles clears the value of the "alternative_titles" field.
+func (muo *MediaUpdateOne) ClearAlternativeTitles() *MediaUpdateOne {
+	muo.mutation.ClearAlternativeTitles()
+	return muo
+}
+
 // AddEpisodeIDs adds the "episodes" edge to the Episode entity by IDs.
 func (muo *MediaUpdateOne) AddEpisodeIDs(ids ...int) *MediaUpdateOne {
 	muo.mutation.AddEpisodeIDs(ids...)
@@ -973,6 +1021,17 @@ func (muo *MediaUpdateOne) sqlSave(ctx context.Context) (_node *Media, err error
 	if muo.mutation.ExtrasCleared() {
 		_spec.ClearField(media.FieldExtras, field.TypeJSON)
 	}
+	if value, ok := muo.mutation.AlternativeTitles(); ok {
+		_spec.SetField(media.FieldAlternativeTitles, field.TypeJSON, value)
+	}
+	if value, ok := muo.mutation.AppendedAlternativeTitles(); ok {
+		_spec.AddModifier(func(u *sql.UpdateBuilder) {
+			sqljson.Append(u, media.FieldAlternativeTitles, value)
+		})
+	}
+	if muo.mutation.AlternativeTitlesCleared() {
+		_spec.ClearField(media.FieldAlternativeTitles, field.TypeJSON)
+	}
 	if muo.mutation.EpisodesCleared() {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,

ent/migrate/schema.go

@@ -8,29 +8,30 @@ import (
 )
 
 var (
-	// BlocklistsColumns holds the columns for the "blocklists" table.
-	BlocklistsColumns = []*schema.Column{
+	// BlacklistsColumns holds the columns for the "blacklists" table.
+	BlacklistsColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeInt, Increment: true},
 		{Name: "type", Type: field.TypeEnum, Enums: []string{"media", "torrent"}},
-		{Name: "value", Type: field.TypeString},
+		{Name: "value", Type: field.TypeJSON},
+		{Name: "notes", Type: field.TypeString, Nullable: true},
 	}
-	// BlocklistsTable holds the schema information for the "blocklists" table.
-	BlocklistsTable = &schema.Table{
-		Name:       "blocklists",
-		Columns:    BlocklistsColumns,
-		PrimaryKey: []*schema.Column{BlocklistsColumns[0]},
+	// BlacklistsTable holds the schema information for the "blacklists" table.
+	BlacklistsTable = &schema.Table{
+		Name:       "blacklists",
+		Columns:    BlacklistsColumns,
+		PrimaryKey: []*schema.Column{BlacklistsColumns[0]},
 	}
 	// DownloadClientsColumns holds the columns for the "download_clients" table.
 	DownloadClientsColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeInt, Increment: true},
 		{Name: "enable", Type: field.TypeBool},
 		{Name: "name", Type: field.TypeString},
-		{Name: "implementation", Type: field.TypeString},
+		{Name: "implementation", Type: field.TypeEnum, Enums: []string{"transmission", "qbittorrent", "buildin"}},
 		{Name: "url", Type: field.TypeString},
 		{Name: "user", Type: field.TypeString, Default: ""},
 		{Name: "password", Type: field.TypeString, Default: ""},
 		{Name: "settings", Type: field.TypeString, Default: ""},
-		{Name: "priority", Type: field.TypeString, Default: ""},
+		{Name: "priority1", Type: field.TypeInt, Default: 1},
 		{Name: "remove_completed_downloads", Type: field.TypeBool, Default: true},
 		{Name: "remove_failed_downloads", Type: field.TypeBool, Default: true},
 		{Name: "tags", Type: field.TypeString, Default: ""},
@@ -72,15 +73,17 @@ var (
 	HistoriesColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeInt, Increment: true},
 		{Name: "media_id", Type: field.TypeInt},
-		{Name: "episode_id", Type: field.TypeInt, Nullable: true},
+		{Name: "episode_nums", Type: field.TypeJSON, Nullable: true},
+		{Name: "season_num", Type: field.TypeInt, Nullable: true},
 		{Name: "source_title", Type: field.TypeString},
 		{Name: "date", Type: field.TypeTime},
 		{Name: "target_dir", Type: field.TypeString},
 		{Name: "size", Type: field.TypeInt, Default: 0},
 		{Name: "download_client_id", Type: field.TypeInt, Nullable: true},
 		{Name: "indexer_id", Type: field.TypeInt, Nullable: true},
-		{Name: "status", Type: field.TypeEnum, Enums: []string{"running", "success", "fail", "uploading", "seeding"}},
-		{Name: "saved", Type: field.TypeString, Nullable: true},
+		{Name: "link", Type: field.TypeString, Nullable: true},
+		{Name: "hash", Type: field.TypeString, Nullable: true},
+		{Name: "status", Type: field.TypeEnum, Enums: []string{"running", "success", "fail", "uploading", "seeding", "removed"}},
 	}
 	// HistoriesTable holds the schema information for the "histories" table.
 	HistoriesTable = &schema.Table{
@@ -109,11 +112,16 @@ var (
 		{Name: "id", Type: field.TypeInt, Increment: true},
 		{Name: "name", Type: field.TypeString},
 		{Name: "implementation", Type: field.TypeString},
-		{Name: "settings", Type: field.TypeString},
+		{Name: "settings", Type: field.TypeString, Nullable: true, Default: ""},
 		{Name: "enable_rss", Type: field.TypeBool, Default: true},
 		{Name: "priority", Type: field.TypeInt, Default: 50},
 		{Name: "seed_ratio", Type: field.TypeFloat32, Nullable: true, Default: 0},
 		{Name: "disabled", Type: field.TypeBool, Nullable: true, Default: false},
+		{Name: "tv_search", Type: field.TypeBool, Nullable: true, Default: true},
+		{Name: "movie_search", Type: field.TypeBool, Nullable: true, Default: true},
+		{Name: "api_key", Type: field.TypeString, Nullable: true},
+		{Name: "url", Type: field.TypeString, Nullable: true},
+		{Name: "synced", Type: field.TypeBool, Nullable: true, Default: false},
 	}
 	// IndexersTable holds the schema information for the "indexers" table.
 	IndexersTable = &schema.Table{
@@ -133,12 +141,13 @@ var (
 		{Name: "overview", Type: field.TypeString},
 		{Name: "created_at", Type: field.TypeTime},
 		{Name: "air_date", Type: field.TypeString, Default: ""},
-		{Name: "resolution", Type: field.TypeEnum, Enums: []string{"720p", "1080p", "2160p"}, Default: "1080p"},
+		{Name: "resolution", Type: field.TypeEnum, Enums: []string{"720p", "1080p", "2160p", "any"}, Default: "1080p"},
 		{Name: "storage_id", Type: field.TypeInt, Nullable: true},
 		{Name: "target_dir", Type: field.TypeString, Nullable: true},
 		{Name: "download_history_episodes", Type: field.TypeBool, Nullable: true, Default: false},
 		{Name: "limiter", Type: field.TypeJSON, Nullable: true},
 		{Name: "extras", Type: field.TypeJSON, Nullable: true},
+		{Name: "alternative_titles", Type: field.TypeJSON, Nullable: true},
 	}
 	// MediaTable holds the schema information for the "media" table.
 	MediaTable = &schema.Table{
@@ -176,7 +185,7 @@ var (
 	StoragesColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeInt, Increment: true},
 		{Name: "name", Type: field.TypeString, Unique: true},
-		{Name: "implementation", Type: field.TypeEnum, Enums: []string{"webdav", "local"}},
+		{Name: "implementation", Type: field.TypeEnum, Enums: []string{"webdav", "local", "alist"}},
 		{Name: "tv_path", Type: field.TypeString, Nullable: true},
 		{Name: "movie_path", Type: field.TypeString, Nullable: true},
 		{Name: "settings", Type: field.TypeString, Nullable: true},
@@ -191,7 +200,7 @@ var (
 	}
 	// Tables holds all the tables in the schema.
 	Tables = []*schema.Table{
-		BlocklistsTable,
+		BlacklistsTable,
 		DownloadClientsTable,
 		EpisodesTable,
 		HistoriesTable,

ent/predicate/predicate.go

@@ -6,8 +6,8 @@ import (
 	"entgo.io/ent/dialect/sql"
 )
 
-// Blocklist is the predicate function for blocklist builders.
-type Blocklist func(*sql.Selector)
+// Blacklist is the predicate function for blacklist builders.
+type Blacklist func(*sql.Selector)
 
 // DownloadClients is the predicate function for downloadclients builders.
 type DownloadClients func(*sql.Selector)

ent/runtime.go

@@ -3,6 +3,7 @@
 package ent
 
 import (
+	"polaris/ent/blacklist"
 	"polaris/ent/downloadclients"
 	"polaris/ent/episode"
 	"polaris/ent/history"
@@ -18,6 +19,12 @@ import (
 // (default values, validators, hooks and policies) and stitches it
 // to their package variables.
 func init() {
+	blacklistFields := schema.Blacklist{}.Fields()
+	_ = blacklistFields
+	// blacklistDescValue is the schema descriptor for value field.
+	blacklistDescValue := blacklistFields[1].Descriptor()
+	// blacklist.DefaultValue holds the default value on creation for the value field.
+	blacklist.DefaultValue = blacklistDescValue.Default.(schema.BlacklistValue)
 	downloadclientsFields := schema.DownloadClients{}.Fields()
 	_ = downloadclientsFields
 	// downloadclientsDescUser is the schema descriptor for user field.
@@ -32,10 +39,12 @@ func init() {
 	downloadclientsDescSettings := downloadclientsFields[6].Descriptor()
 	// downloadclients.DefaultSettings holds the default value on creation for the settings field.
 	downloadclients.DefaultSettings = downloadclientsDescSettings.Default.(string)
-	// downloadclientsDescPriority is the schema descriptor for priority field.
-	downloadclientsDescPriority := downloadclientsFields[7].Descriptor()
-	// downloadclients.DefaultPriority holds the default value on creation for the priority field.
-	downloadclients.DefaultPriority = downloadclientsDescPriority.Default.(string)
+	// downloadclientsDescPriority1 is the schema descriptor for priority1 field.
+	downloadclientsDescPriority1 := downloadclientsFields[7].Descriptor()
+	// downloadclients.DefaultPriority1 holds the default value on creation for the priority1 field.
+	downloadclients.DefaultPriority1 = downloadclientsDescPriority1.Default.(int)
+	// downloadclients.Priority1Validator is a validator for the "priority1" field. It is called by the builders before save.
+	downloadclients.Priority1Validator = downloadclientsDescPriority1.Validators[0].(func(int) error)
 	// downloadclientsDescRemoveCompletedDownloads is the schema descriptor for remove_completed_downloads field.
 	downloadclientsDescRemoveCompletedDownloads := downloadclientsFields[8].Descriptor()
 	// downloadclients.DefaultRemoveCompletedDownloads holds the default value on creation for the remove_completed_downloads field.
@@ -57,11 +66,15 @@ func init() {
 	historyFields := schema.History{}.Fields()
 	_ = historyFields
 	// historyDescSize is the schema descriptor for size field.
-	historyDescSize := historyFields[5].Descriptor()
+	historyDescSize := historyFields[6].Descriptor()
 	// history.DefaultSize holds the default value on creation for the size field.
 	history.DefaultSize = historyDescSize.Default.(int)
 	indexersFields := schema.Indexers{}.Fields()
 	_ = indexersFields
+	// indexersDescSettings is the schema descriptor for settings field.
+	indexersDescSettings := indexersFields[2].Descriptor()
+	// indexers.DefaultSettings holds the default value on creation for the settings field.
+	indexers.DefaultSettings = indexersDescSettings.Default.(string)
 	// indexersDescEnableRss is the schema descriptor for enable_rss field.
 	indexersDescEnableRss := indexersFields[3].Descriptor()
 	// indexers.DefaultEnableRss holds the default value on creation for the enable_rss field.
@@ -78,6 +91,18 @@ func init() {
 	indexersDescDisabled := indexersFields[6].Descriptor()
 	// indexers.DefaultDisabled holds the default value on creation for the disabled field.
 	indexers.DefaultDisabled = indexersDescDisabled.Default.(bool)
+	// indexersDescTvSearch is the schema descriptor for tv_search field.
+	indexersDescTvSearch := indexersFields[7].Descriptor()
+	// indexers.DefaultTvSearch holds the default value on creation for the tv_search field.
+	indexers.DefaultTvSearch = indexersDescTvSearch.Default.(bool)
+	// indexersDescMovieSearch is the schema descriptor for movie_search field.
+	indexersDescMovieSearch := indexersFields[8].Descriptor()
+	// indexers.DefaultMovieSearch holds the default value on creation for the movie_search field.
+	indexers.DefaultMovieSearch = indexersDescMovieSearch.Default.(bool)
+	// indexersDescSynced is the schema descriptor for synced field.
+	indexersDescSynced := indexersFields[11].Descriptor()
+	// indexers.DefaultSynced holds the default value on creation for the synced field.
+	indexers.DefaultSynced = indexersDescSynced.Default.(bool)
 	mediaFields := schema.Media{}.Fields()
 	_ = mediaFields
 	// mediaDescCreatedAt is the schema descriptor for created_at field.

ent/schema/blacklist.go

@@ -0,0 +1,30 @@
+package schema
+
+import (
+	"entgo.io/ent"
+	"entgo.io/ent/schema/field"
+)
+
+// Blacklist holds the schema definition for the Blacklist entity.
+type Blacklist struct {
+	ent.Schema
+}
+
+// Fields of the Blacklist.
+func (Blacklist) Fields() []ent.Field {
+	return []ent.Field{
+		field.Enum("type").Values("media", "torrent"),
+		field.JSON("value", BlacklistValue{}).Default(BlacklistValue{}),
+		field.String("notes").Optional(),
+	}
+}
+
+// Edges of the Blacklist.
+func (Blacklist) Edges() []ent.Edge {
+	return nil
+}
+
+type BlacklistValue struct {
+	TmdbID      int    `json:"tmdb_id"`
+	TorrentHash string `json:"torrent_hash"`
+}

ent/schema/blocklist.go

@@ -1,24 +0,0 @@
-package schema
-
-import (
-	"entgo.io/ent"
-	"entgo.io/ent/schema/field"
-)
-
-// Blocklist holds the schema definition for the Blocklist entity.
-type Blocklist struct {
-	ent.Schema
-}
-
-// Fields of the Blocklist.
-func (Blocklist) Fields() []ent.Field {
-	return  []ent.Field{
-		field.Enum("type").Values("media", "torrent"),
-		field.String("value"),
-	}
-}
-
-// Edges of the Blocklist.
-func (Blocklist) Edges() []ent.Edge {
-	return nil
-}

ent/schema/downloadclients.go

@@ -1,6 +1,8 @@
 package schema
 
 import (
+	"errors"
+
 	"entgo.io/ent"
 	"entgo.io/ent/schema/field"
 )
@@ -15,12 +17,20 @@ func (DownloadClients) Fields() []ent.Field {
 	return []ent.Field{
 		field.Bool("enable"),
 		field.String("name"),
-		field.String("implementation"),
+		field.Enum("implementation").Values("transmission", "qbittorrent", "buildin"),
 		field.String("url"),
 		field.String("user").Default(""),
 		field.String("password").Default(""),
 		field.String("settings").Default(""),
-		field.String("priority").Default(""),
+		field.Int("priority1").Default(1).Validate(func(i int) error {
+			if i > 50 {
+				return errors.ErrUnsupported
+			}
+			if i <= 0 {
+				return errors.ErrUnsupported
+			}
+			return nil
+		}),
 		field.Bool("remove_completed_downloads").Default(true),
 		field.Bool("remove_failed_downloads").Default(true),
 		field.String("tags").Default(""),

ent/schema/history.go

@@ -14,15 +14,19 @@ type History struct {
 func (History) Fields() []ent.Field {
 	return []ent.Field{
 		field.Int("media_id"),
-		field.Int("episode_id").Optional(),
+		//field.Int("episode_id").Optional().Comment("deprecated"),
+		field.Ints("episode_nums").Optional(),
+		field.Int("season_num").Optional(),
 		field.String("source_title"),
 		field.Time("date"),
 		field.String("target_dir"),
 		field.Int("size").Default(0),
 		field.Int("download_client_id").Optional(),
 		field.Int("indexer_id").Optional(),
-		field.Enum("status").Values("running", "success", "fail", "uploading", "seeding"),
-		field.String("saved").Optional(),
+		field.String("link").Optional().Comment("deprecated, use hash instead"), //should be magnet link
+		field.String("hash").Optional().Comment("torrent hash"),
+		field.Enum("status").Values("running", "success", "fail", "uploading", "seeding", "removed"),
+		//field.String("saved").Optional().Comment("deprecated"), //deprecated
 	}
 }
 

ent/schema/indexers.go

@@ -15,11 +15,16 @@ func (Indexers) Fields() []ent.Field {
 	return []ent.Field{
 		field.String("name"),
 		field.String("implementation"),
-		field.String("settings"),
+		field.String("settings").Optional().Default("").Comment("deprecated, use api_key and url"),
 		field.Bool("enable_rss").Default(true),
 		field.Int("priority").Default(50),
 		field.Float32("seed_ratio").Optional().Default(0).Comment("minimal seed ratio requied, before removing torrent"),
 		field.Bool("disabled").Optional().Default(false),
+		field.Bool("tv_search").Optional().Default(true),
+		field.Bool("movie_search").Optional().Default(true),
+		field.String("api_key").Optional(),
+		field.String("url").Optional(),
+		field.Bool("synced").Optional().Default(false).Comment("synced from prowlarr"),
 	}
 }
 

ent/schema/media.go

@@ -25,12 +25,13 @@ func (Media) Fields() []ent.Field {
 		field.String("overview"),
 		field.Time("created_at").Default(time.Now()),
 		field.String("air_date").Default(""),
-		field.Enum("resolution").Values("720p", "1080p", "2160p").Default("1080p"),
+		field.Enum("resolution").Values("720p", "1080p", "2160p", "any").Default("1080p"),
 		field.Int("storage_id").Optional(),
 		field.String("target_dir").Optional(),
 		field.Bool("download_history_episodes").Optional().Default(false).Comment("tv series only"),
 		field.JSON("limiter", MediaLimiter{}).Optional(),
 		field.JSON("extras", MediaExtras{}).Optional(),
+		field.JSON("alternative_titles", []AlternativeTilte{}).Optional(),
 	}
 }
 
@@ -41,9 +42,16 @@ func (Media) Edges() []ent.Edge {
 	}
 }
 
+type AlternativeTilte struct {
+	Iso3166_1 string `json:"iso_3166_1"`
+	Title     string `json:"title"`
+	Type      string `json:"type"`
+}
+
 type MediaLimiter struct {
-	SizeMin int `json:"size_min"` //in B
-	SizeMax int `json:"size_max"` //in B
+	SizeMin    int64 `json:"size_min"` //in B
+	SizeMax    int64 `json:"size_max"` //in B
+	PreferSize int64 `json:"prefer_max"`
 }
 
 type MediaExtras struct {
@@ -51,7 +59,7 @@ type MediaExtras struct {
 	JavId        string `json:"javid"`
 	//OriginCountry    []string `json:"origin_country"`
 	OriginalLanguage string `json:"original_language"`
-	Genres []struct {
+	Genres           []struct {
 		ID   int64  `json:"id"`
 		Name string `json:"name"`
 	} `json:"genres"`

ent/schema/storage.go

@@ -14,7 +14,7 @@ type Storage struct {
 func (Storage) Fields() []ent.Field {
 	return []ent.Field{
 		field.String("name").Unique(),
-		field.Enum("implementation").Values("webdav", "local"),
+		field.Enum("implementation").Values("webdav", "local", "alist"),
 		field.String("tv_path").Optional(),
 		field.String("movie_path").Optional(),
 		field.String("settings").Optional(),

ent/storage/storage.go

@@ -67,6 +67,7 @@ type Implementation string
 const (
 	ImplementationWebdav Implementation = "webdav"
 	ImplementationLocal  Implementation = "local"
+	ImplementationAlist  Implementation = "alist"
 )
 
 func (i Implementation) String() string {
@@ -76,7 +77,7 @@ func (i Implementation) String() string {
 // ImplementationValidator is a validator for the "implementation" field enum values. It is called by the builders before save.
 func ImplementationValidator(i Implementation) error {
 	switch i {
-	case ImplementationWebdav, ImplementationLocal:
+	case ImplementationWebdav, ImplementationLocal, ImplementationAlist:
 		return nil
 	default:
 		return fmt.Errorf("storage: invalid enum value for implementation field: %q", i)

ent/tx.go

@@ -12,8 +12,8 @@ import (
 // Tx is a transactional client that is created by calling Client.Tx().
 type Tx struct {
 	config
-	// Blocklist is the client for interacting with the Blocklist builders.
-	Blocklist *BlocklistClient
+	// Blacklist is the client for interacting with the Blacklist builders.
+	Blacklist *BlacklistClient
 	// DownloadClients is the client for interacting with the DownloadClients builders.
 	DownloadClients *DownloadClientsClient
 	// Episode is the client for interacting with the Episode builders.
@@ -163,7 +163,7 @@ func (tx *Tx) Client() *Client {
 }
 
 func (tx *Tx) init() {
-	tx.Blocklist = NewBlocklistClient(tx.config)
+	tx.Blacklist = NewBlacklistClient(tx.config)
 	tx.DownloadClients = NewDownloadClientsClient(tx.config)
 	tx.Episode = NewEpisodeClient(tx.config)
 	tx.History = NewHistoryClient(tx.config)
@@ -182,7 +182,7 @@ func (tx *Tx) init() {
 // 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: Blocklist.QueryXXX(), the query will be executed
+// applies a query, for example: Blacklist.QueryXXX(), the query will be executed
 // through the driver which created this transaction.
 //
 // Note that txDriver is not goroutine safe.

entrypoint.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+
+groupadd -g ${PGID} abc1
+useradd abc1 -u ${PUID} -g ${PGID} -m -s /bin/bash
+
+## 重设权限
+chown -R "${PUID}:${PGID}" /app/data
+
+umask ${UMASK:-022}
+
+cd /app
+exec gosu "${PUID}:${PGID}" /app/polaris

go.mod

@@ -1,41 +1,127 @@
 module polaris
 
-go 1.22.4
+go 1.23.0
+
+toolchain go1.24.1
 
 require (
 	entgo.io/ent v0.13.1
-	github.com/golang-jwt/jwt/v5 v5.2.1
+	github.com/golang-jwt/jwt/v5 v5.2.2
 	github.com/mattn/go-sqlite3 v1.14.22 // indirect
 	github.com/robfig/cron v1.2.0
 	go.uber.org/zap v1.27.0
-	golang.org/x/net v0.27.0
+	golang.org/x/net v0.37.0
 )
 
 require (
-	github.com/PuerkitoBio/goquery v1.9.2
+	github.com/PuerkitoBio/goquery v1.10.1
+	github.com/anacrolix/torrent v1.58.1
+	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc
 	github.com/gin-contrib/zap v1.1.3
+	github.com/gocolly/colly v1.2.0
 	github.com/ncruces/go-sqlite3 v0.18.4
 	github.com/nikoksr/notify v1.0.0
 	github.com/stretchr/testify v1.9.0
+	golift.io/starr v1.0.0
 )
 
 require (
 	github.com/BurntSushi/toml v1.4.0 // indirect
 	github.com/DATA-DOG/go-sqlmock v1.5.2 // indirect
-	github.com/andybalholm/cascadia v1.3.2 // indirect
+	github.com/RoaringBitmap/roaring v1.2.3 // indirect
+	github.com/ajwerner/btree v0.0.0-20211221152037-f427b3e689c0 // indirect
+	github.com/alecthomas/atomic v0.1.0-alpha2 // indirect
+	github.com/anacrolix/chansync v0.4.1-0.20240627045151-1aa1ac392fe8 // indirect
+	github.com/anacrolix/dht/v2 v2.19.2-0.20221121215055-066ad8494444 // indirect
+	github.com/anacrolix/envpprof v1.3.0 // indirect
+	github.com/anacrolix/generics v0.0.3-0.20240902042256-7fb2702ef0ca // indirect
+	github.com/anacrolix/go-libutp v1.3.2 // indirect
+	github.com/anacrolix/log v0.15.3-0.20240627045001-cd912c641d83 // indirect
+	github.com/anacrolix/missinggo v1.3.0 // indirect
+	github.com/anacrolix/missinggo/perf v1.0.0 // indirect
+	github.com/anacrolix/missinggo/v2 v2.7.4 // indirect
+	github.com/anacrolix/mmsg v1.0.1 // indirect
+	github.com/anacrolix/multiless v0.4.0 // indirect
+	github.com/anacrolix/stm v0.4.0 // indirect
+	github.com/anacrolix/sync v0.5.1 // indirect
+	github.com/anacrolix/upnp v0.1.4 // indirect
+	github.com/anacrolix/utp v0.1.0 // indirect
+	github.com/andybalholm/cascadia v1.3.3 // indirect
+	github.com/antchfx/htmlquery v1.3.4 // indirect
+	github.com/antchfx/xmlquery v1.4.4 // indirect
+	github.com/antchfx/xpath v1.3.3 // indirect
+	github.com/bahlo/generic-list-go v0.2.0 // indirect
+	github.com/benbjohnson/immutable v0.3.0 // indirect
+	github.com/bits-and-blooms/bitset v1.2.2 // indirect
 	github.com/blinkbean/dingtalk v1.1.3 // indirect
-	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
+	github.com/bradfitz/iter v0.0.0-20191230175014-e8f45d346db8 // indirect
+	github.com/cespare/xxhash v1.1.0 // indirect
+	github.com/dustin/go-humanize v1.0.0 // indirect
+	github.com/edsrzf/mmap-go v1.1.0 // indirect
+	github.com/go-llsqlite/adapter v0.0.0-20230927005056-7f5ce7f0c916 // indirect
+	github.com/go-llsqlite/crawshaw v0.5.2-0.20240425034140-f30eb7704568 // indirect
+	github.com/go-logr/logr v1.4.2 // indirect
+	github.com/go-logr/stdr v1.2.2 // indirect
 	github.com/go-telegram-bot-api/telegram-bot-api v4.6.4+incompatible // indirect
 	github.com/go-test/deep v1.0.4 // indirect
+	github.com/gobwas/glob v0.2.3 // indirect
+	github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 // indirect
+	github.com/golang/protobuf v1.5.4 // indirect
+	github.com/google/btree v1.1.2 // indirect
+	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/gregdel/pushover v1.3.1 // indirect
+	github.com/huandu/xstrings v1.3.2 // indirect
+	github.com/kennygrant/sanitize v1.2.4 // indirect
+	github.com/minio/sha256-simd v1.0.0 // indirect
+	github.com/mr-tron/base58 v1.2.0 // indirect
+	github.com/mschoch/smat v0.2.0 // indirect
+	github.com/multiformats/go-multihash v0.2.3 // indirect
+	github.com/multiformats/go-varint v0.0.6 // indirect
 	github.com/ncruces/julianday v1.0.0 // indirect
+	github.com/pion/datachannel v1.5.9 // indirect
+	github.com/pion/dtls/v3 v3.0.3 // indirect
+	github.com/pion/ice/v4 v4.0.2 // indirect
+	github.com/pion/interceptor v0.1.37 // indirect
+	github.com/pion/logging v0.2.2 // indirect
+	github.com/pion/mdns/v2 v2.0.7 // indirect
+	github.com/pion/randutil v0.1.0 // indirect
+	github.com/pion/rtcp v1.2.14 // indirect
+	github.com/pion/rtp v1.8.9 // indirect
+	github.com/pion/sctp v1.8.33 // indirect
+	github.com/pion/sdp/v3 v3.0.9 // indirect
+	github.com/pion/srtp/v3 v3.0.4 // indirect
+	github.com/pion/stun/v3 v3.0.0 // indirect
+	github.com/pion/transport/v3 v3.0.7 // indirect
+	github.com/pion/turn/v4 v4.0.0 // indirect
+	github.com/pion/webrtc/v4 v4.0.0 // indirect
 	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
+	github.com/protolambda/ctxlock v0.1.0 // indirect
+	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
+	github.com/rs/dnscache v0.0.0-20211102005908-e0241e321417 // indirect
+	github.com/saintfish/chardet v0.0.0-20230101081208-5e3ef4b5456d // indirect
+	github.com/spaolacci/murmur3 v1.1.0 // indirect
 	github.com/stretchr/objx v0.5.2 // indirect
 	github.com/technoweenie/multipartstreamer v1.0.1 // indirect
+	github.com/temoto/robotstxt v1.1.2 // indirect
 	github.com/tetratelabs/wazero v1.8.0 // indirect
-	golang.org/x/sync v0.8.0 // indirect
+	github.com/tidwall/btree v1.6.0 // indirect
+	github.com/wlynxg/anet v0.0.3 // indirect
+	go.etcd.io/bbolt v1.3.6 // indirect
+	go.opentelemetry.io/otel v1.28.0 // indirect
+	go.opentelemetry.io/otel/metric v1.28.0 // indirect
+	go.opentelemetry.io/otel/trace v1.28.0 // indirect
+	golang.org/x/sync v0.12.0 // indirect
+	golang.org/x/time v0.5.0 // indirect
+	golang.org/x/tools v0.31.0 // indirect
+	google.golang.org/appengine v1.6.8 // indirect
 	gopkg.in/natefinch/lumberjack.v2 v2.2.1 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
+	lukechampine.com/blake3 v1.1.6 // indirect
+	modernc.org/libc v1.22.3 // indirect
+	modernc.org/mathutil v1.5.0 // indirect
+	modernc.org/memory v1.5.0 // indirect
+	modernc.org/sqlite v1.21.1 // indirect
+	zombiezen.com/go/sqlite v0.13.1 // indirect
 )
 
 require (
@@ -80,12 +166,12 @@ require (
 	github.com/ugorji/go/codec v1.2.12 // indirect
 	github.com/zclconf/go-cty v1.8.0 // indirect
 	golang.org/x/arch v0.8.0 // indirect
-	golang.org/x/crypto v0.27.0
-	golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56
-	golang.org/x/mod v0.19.0 // indirect
-	golang.org/x/sys v0.25.0
-	golang.org/x/text v0.18.0 // indirect
-	google.golang.org/protobuf v1.34.2 // indirect
+	golang.org/x/crypto v0.36.0
+	golang.org/x/exp v0.0.0-20240823005443-9b4947da3948
+	golang.org/x/mod v0.24.0 // indirect
+	golang.org/x/sys v0.31.0
+	golang.org/x/text v0.23.0 // indirect
+	google.golang.org/protobuf v1.36.5 // indirect
 	gopkg.in/ini.v1 v1.67.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -1,37 +1,158 @@
 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=
+cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+crawshaw.io/iox v0.0.0-20181124134642-c51c3df30797/go.mod h1:sXBiorCo8c46JlQV3oXPKINnZ8mcqnye1EkVkqsectk=
+crawshaw.io/sqlite v0.3.2/go.mod h1:igAO5JulrQ1DbdZdtVq48mnZUBAPOeFzer7VhDWNtW4=
 entgo.io/ent v0.13.1 h1:uD8QwN1h6SNphdCCzmkMN3feSUzNnVvV/WIkHKMbzOE=
 entgo.io/ent v0.13.1/go.mod h1:qCEmo+biw3ccBn9OyL4ZK5dfpwg++l1Gxwac5B1206A=
+filippo.io/edwards25519 v1.0.0-rc.1 h1:m0VOOB23frXZvAOK44usCgLWvtsxIoMCTBGJZlpmGfU=
+filippo.io/edwards25519 v1.0.0-rc.1/go.mod h1:N1IkdkCkiLB6tki+MYJoSx2JTY9NUlxZE7eHn5EwJns=
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/BurntSushi/toml v1.4.0 h1:kuoIxZQy2WRRk1pttg9asf+WVv6tWQuBNVmK8+nqPr0=
 github.com/BurntSushi/toml v1.4.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=
 github.com/DATA-DOG/go-sqlmock v1.5.2 h1:OcvFkGmslmlZibjAjaHm3L//6LiuBgolP7OputlJIzU=
 github.com/DATA-DOG/go-sqlmock v1.5.2/go.mod h1:88MAG/4G7SMwSE3CeA0ZKzrT5CiOU3OJ+JlNzwDqpNU=
-github.com/PuerkitoBio/goquery v1.9.2 h1:4/wZksC3KgkQw7SQgkKotmKljk0M6V8TUvA8Wb4yPeE=
-github.com/PuerkitoBio/goquery v1.9.2/go.mod h1:GHPCaP0ODyyxqcNoFGYlAprUFH81NuRPd0GX3Zu2Mvk=
+github.com/OneOfOne/xxhash v1.2.2 h1:KMrpdQIwFcEqXDklaen+P1axHaj9BSKzvpUUfnHldSE=
+github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
+github.com/PuerkitoBio/goquery v1.10.1 h1:Y8JGYUkXWTGRB6Ars3+j3kN0xg1YqqlwvdTV8WTFQcU=
+github.com/PuerkitoBio/goquery v1.10.1/go.mod h1:IYiHrOMps66ag56LEH7QYDDupKXyo5A8qrjIx3ZtujY=
+github.com/RoaringBitmap/roaring v0.4.7/go.mod h1:8khRDP4HmeXns4xIj9oGrKSz7XTQiJx2zgh7AcNke4w=
+github.com/RoaringBitmap/roaring v0.4.17/go.mod h1:D3qVegWTmfCaX4Bl5CrBE9hfrSrrXIr8KVNvRsDi1NI=
+github.com/RoaringBitmap/roaring v0.4.23/go.mod h1:D0gp8kJQgE1A4LQ5wFLggQEyvDi06Mq5mKs52e1TwOo=
+github.com/RoaringBitmap/roaring v1.2.3 h1:yqreLINqIrX22ErkKI0vY47/ivtJr6n+kMhVOVmhWBY=
+github.com/RoaringBitmap/roaring v1.2.3/go.mod h1:plvDsJQpxOC5bw8LRteu/MLWHsHez/3y6cubLI4/1yE=
+github.com/Shopify/sarama v1.19.0/go.mod h1:FVkBWblsNy7DGZRfXLU0O9RCGt5g3g3yEuWXgklEdEo=
+github.com/Shopify/toxiproxy v2.1.4+incompatible/go.mod h1:OXgGpZ6Cli1/URJOF1DMxUHB2q5Ap20/P/eIdh4G0pI=
 github.com/agext/levenshtein v1.2.1 h1:QmvMAjj2aEICytGiWzmxoE0x2KZvE0fvmqMOfy2tjT8=
 github.com/agext/levenshtein v1.2.1/go.mod h1:JEDfjyjHDjOF/1e4FlBE/PkbqA9OfWu2ki2W0IB5558=
-github.com/andybalholm/cascadia v1.3.2 h1:3Xi6Dw5lHF15JtdcmAHD3i1+T8plmv7BQ/nsViSLyss=
-github.com/andybalholm/cascadia v1.3.2/go.mod h1:7gtRlve5FxPPgIgX36uWBX58OdBsSS6lUvCFb+h7KvU=
+github.com/ajwerner/btree v0.0.0-20211221152037-f427b3e689c0 h1:byYvvbfSo3+9efR4IeReh77gVs4PnNDR3AMOE9NJ7a0=
+github.com/ajwerner/btree v0.0.0-20211221152037-f427b3e689c0/go.mod h1:q37NoqncT41qKc048STsifIt69LfUJ8SrWWcz/yam5k=
+github.com/alecthomas/assert/v2 v2.0.0-alpha3 h1:pcHeMvQ3OMstAWgaeaXIAL8uzB9xMm2zlxt+/4ml8lk=
+github.com/alecthomas/assert/v2 v2.0.0-alpha3/go.mod h1:+zD0lmDXTeQj7TgDgCt0ePWxb0hMC1G+PGTsTCv1B9o=
+github.com/alecthomas/atomic v0.1.0-alpha2 h1:dqwXmax66gXvHhsOS4pGPZKqYOlTkapELkLb3MNdlH8=
+github.com/alecthomas/atomic v0.1.0-alpha2/go.mod h1:zD6QGEyw49HIq19caJDc2NMXAy8rNi9ROrxtMXATfyI=
+github.com/alecthomas/repr v0.0.0-20210801044451-80ca428c5142 h1:8Uy0oSf5co/NZXje7U1z8Mpep++QJOldL2hs/sBQf48=
+github.com/alecthomas/repr v0.0.0-20210801044451-80ca428c5142/go.mod h1:2kn6fqh/zIyPLmm3ugklbEi5hg5wS435eygvNfaDQL8=
+github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
+github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
+github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
+github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
+github.com/anacrolix/chansync v0.4.1-0.20240627045151-1aa1ac392fe8 h1:eyb0bBaQKMOh5Se/Qg54shijc8K4zpQiOjEhKFADkQM=
+github.com/anacrolix/chansync v0.4.1-0.20240627045151-1aa1ac392fe8/go.mod h1:DZsatdsdXxD0WiwcGl0nJVwyjCKMDv+knl1q2iBjA2k=
+github.com/anacrolix/dht/v2 v2.19.2-0.20221121215055-066ad8494444 h1:8V0K09lrGoeT2KRJNOtspA7q+OMxGwQqK/Ug0IiaaRE=
+github.com/anacrolix/dht/v2 v2.19.2-0.20221121215055-066ad8494444/go.mod h1:MctKM1HS5YYDb3F30NGJxLE+QPuqWoT5ReW/4jt8xew=
+github.com/anacrolix/envpprof v0.0.0-20180404065416-323002cec2fa/go.mod h1:KgHhUaQMc8cC0+cEflSgCFNFbKwi5h54gqtVn8yhP7c=
+github.com/anacrolix/envpprof v1.0.0/go.mod h1:KgHhUaQMc8cC0+cEflSgCFNFbKwi5h54gqtVn8yhP7c=
+github.com/anacrolix/envpprof v1.1.0/go.mod h1:My7T5oSqVfEn4MD4Meczkw/f5lSIndGAKu/0SM/rkf4=
+github.com/anacrolix/envpprof v1.3.0 h1:WJt9bpuT7A/CDCxPOv/eeZqHWlle/Y0keJUvc6tcJDk=
+github.com/anacrolix/envpprof v1.3.0/go.mod h1:7QIG4CaX1uexQ3tqd5+BRa/9e2D02Wcertl6Yh0jCB0=
+github.com/anacrolix/generics v0.0.0-20230113004304-d6428d516633/go.mod h1:ff2rHB/joTV03aMSSn/AZNnaIpUw0h3njetGsaXcMy8=
+github.com/anacrolix/generics v0.0.3-0.20240902042256-7fb2702ef0ca h1:aiiGqSQWjtVNdi8zUMfA//IrM8fPkv2bWwZVPbDe0wg=
+github.com/anacrolix/generics v0.0.3-0.20240902042256-7fb2702ef0ca/go.mod h1:MN3ve08Z3zSV/rTuX/ouI4lNdlfTxgdafQJiLzyNRB8=
+github.com/anacrolix/go-libutp v1.3.2 h1:WswiaxTIogchbkzNgGHuHRfbrYLpv4o290mlvcx+++M=
+github.com/anacrolix/go-libutp v1.3.2/go.mod h1:fCUiEnXJSe3jsPG554A200Qv+45ZzIIyGEvE56SHmyA=
+github.com/anacrolix/log v0.3.0/go.mod h1:lWvLTqzAnCWPJA08T2HCstZi0L1y2Wyvm3FJgwU9jwU=
+github.com/anacrolix/log v0.6.0/go.mod h1:lWvLTqzAnCWPJA08T2HCstZi0L1y2Wyvm3FJgwU9jwU=
+github.com/anacrolix/log v0.13.1/go.mod h1:D4+CvN8SnruK6zIFS/xPoRJmtvtnxs+CSfDQ+BFxZ68=
+github.com/anacrolix/log v0.14.2/go.mod h1:1OmJESOtxQGNMlUO5rcv96Vpp9mfMqXXbe2RdinFLdY=
+github.com/anacrolix/log v0.15.3-0.20240627045001-cd912c641d83 h1:9o/yVzzLzYaBDFx8B27yhkvBLhNnRAuSTK7Y+yZKVtU=
+github.com/anacrolix/log v0.15.3-0.20240627045001-cd912c641d83/go.mod h1:xvHjsYWWP7yO8PZwtuIp/k0DBlu07pSJqH4SEC78Vwc=
+github.com/anacrolix/lsan v0.0.0-20211126052245-807000409a62 h1:P04VG6Td13FHMgS5ZBcJX23NPC/fiC4cp9bXwYujdYM=
+github.com/anacrolix/lsan v0.0.0-20211126052245-807000409a62/go.mod h1:66cFKPCO7Sl4vbFnAaSq7e4OXtdMhRSBagJGWgmpJbM=
+github.com/anacrolix/missinggo v0.0.0-20180725070939-60ef2fbf63df/go.mod h1:kwGiTUTZ0+p4vAz3VbAI5a30t2YbvemcmspjKwrAz5s=
+github.com/anacrolix/missinggo v1.1.0/go.mod h1:MBJu3Sk/k3ZfGYcS7z18gwfu72Ey/xopPFJJbTi5yIo=
+github.com/anacrolix/missinggo v1.1.2-0.20190815015349-b888af804467/go.mod h1:MBJu3Sk/k3ZfGYcS7z18gwfu72Ey/xopPFJJbTi5yIo=
+github.com/anacrolix/missinggo v1.2.1/go.mod h1:J5cMhif8jPmFoC3+Uvob3OXXNIhOUikzMt+uUjeM21Y=
+github.com/anacrolix/missinggo v1.3.0 h1:06HlMsudotL7BAELRZs0yDZ4yVXsHXGi323QBjAVASw=
+github.com/anacrolix/missinggo v1.3.0/go.mod h1:bqHm8cE8xr+15uVfMG3BFui/TxyB6//H5fwlq/TeqMc=
+github.com/anacrolix/missinggo/perf v1.0.0 h1:7ZOGYziGEBytW49+KmYGTaNfnwUqP1HBsy6BqESAJVw=
+github.com/anacrolix/missinggo/perf v1.0.0/go.mod h1:ljAFWkBuzkO12MQclXzZrosP5urunoLS0Cbvb4V0uMQ=
+github.com/anacrolix/missinggo/v2 v2.2.0/go.mod h1:o0jgJoYOyaoYQ4E2ZMISVa9c88BbUBVQQW4QeRkNCGY=
+github.com/anacrolix/missinggo/v2 v2.5.1/go.mod h1:WEjqh2rmKECd0t1VhQkLGTdIWXO6f6NLjp5GlMZ+6FA=
+github.com/anacrolix/missinggo/v2 v2.7.4 h1:47h5OXoPV8JbA/ACA+FLwKdYbAinuDO8osc2Cu9xkxg=
+github.com/anacrolix/missinggo/v2 v2.7.4/go.mod h1:vVO5FEziQm+NFmJesc7StpkquZk+WJFCaL0Wp//2sa0=
+github.com/anacrolix/mmsg v1.0.1 h1:TxfpV7kX70m3f/O7ielL/2I3OFkMPjrRCPo7+4X5AWw=
+github.com/anacrolix/mmsg v1.0.1/go.mod h1:x8kRaJY/dCrY9Al0PEcj1mb/uFHwP6GCJ9fLl4thEPc=
+github.com/anacrolix/multiless v0.4.0 h1:lqSszHkliMsZd2hsyrDvHOw4AbYWa+ijQ66LzbjqWjM=
+github.com/anacrolix/multiless v0.4.0/go.mod h1:zJv1JF9AqdZiHwxqPgjuOZDGWER6nyE48WBCi/OOrMM=
+github.com/anacrolix/stm v0.2.0/go.mod h1:zoVQRvSiGjGoTmbM0vSLIiaKjWtNPeTvXUSdJQA4hsg=
+github.com/anacrolix/stm v0.4.0 h1:tOGvuFwaBjeu1u9X1eIh9TX8OEedEiEQ1se1FjhFnXY=
+github.com/anacrolix/stm v0.4.0/go.mod h1:GCkwqWoAsP7RfLW+jw+Z0ovrt2OO7wRzcTtFYMYY5t8=
+github.com/anacrolix/sync v0.0.0-20180808010631-44578de4e778/go.mod h1:s735Etp3joe/voe2sdaXLcqDdJSay1O0OPnM0ystjqk=
+github.com/anacrolix/sync v0.3.0/go.mod h1:BbecHL6jDSExojhNtgTFSBcdGerzNc64tz3DCOj/I0g=
+github.com/anacrolix/sync v0.5.1 h1:FbGju6GqSjzVoTgcXTUKkF041lnZkG5P0C3T5RL3SGc=
+github.com/anacrolix/sync v0.5.1/go.mod h1:BbecHL6jDSExojhNtgTFSBcdGerzNc64tz3DCOj/I0g=
+github.com/anacrolix/tagflag v0.0.0-20180109131632-2146c8d41bf0/go.mod h1:1m2U/K6ZT+JZG0+bdMK6qauP49QT4wE5pmhJXOKKCHw=
+github.com/anacrolix/tagflag v1.0.0/go.mod h1:1m2U/K6ZT+JZG0+bdMK6qauP49QT4wE5pmhJXOKKCHw=
+github.com/anacrolix/tagflag v1.1.0/go.mod h1:Scxs9CV10NQatSmbyjqmqmeQNwGzlNe0CMUMIxqHIG8=
+github.com/anacrolix/torrent v1.58.1 h1:6FP+KH57b1gyT2CpVL9fEqf9MGJEgh3xw1VA8rI0pW8=
+github.com/anacrolix/torrent v1.58.1/go.mod h1:/7ZdLuHNKgtCE1gjYJCfbtG9JodBcDaF5ip5EUWRtk8=
+github.com/anacrolix/upnp v0.1.4 h1:+2t2KA6QOhm/49zeNyeVwDu1ZYS9dB9wfxyVvh/wk7U=
+github.com/anacrolix/upnp v0.1.4/go.mod h1:Qyhbqo69gwNWvEk1xNTXsS5j7hMHef9hdr984+9fIic=
+github.com/anacrolix/utp v0.1.0 h1:FOpQOmIwYsnENnz7tAGohA+r6iXpRjrq8ssKSre2Cp4=
+github.com/anacrolix/utp v0.1.0/go.mod h1:MDwc+vsGEq7RMw6lr2GKOEqjWny5hO5OZXRVNaBJ2Dk=
+github.com/andybalholm/cascadia v1.3.3 h1:AG2YHrzJIm4BZ19iwJ/DAua6Btl3IwJX+VI4kktS1LM=
+github.com/andybalholm/cascadia v1.3.3/go.mod h1:xNd9bqTn98Ln4DwST8/nG+H0yuB8Hmgu1YHNnWw0GeA=
+github.com/antchfx/htmlquery v1.3.4 h1:Isd0srPkni2iNTWCwVj/72t7uCphFeor5Q8nCzj1jdQ=
+github.com/antchfx/htmlquery v1.3.4/go.mod h1:K9os0BwIEmLAvTqaNSua8tXLWRWZpocZIH73OzWQbwM=
+github.com/antchfx/xmlquery v1.4.4 h1:mxMEkdYP3pjKSftxss4nUHfjBhnMk4imGoR96FRY2dg=
+github.com/antchfx/xmlquery v1.4.4/go.mod h1:AEPEEPYE9GnA2mj5Ur2L5Q5/2PycJ0N9Fusrx9b12fc=
+github.com/antchfx/xpath v1.3.3 h1:tmuPQa1Uye0Ym1Zn65vxPgfltWb/Lxu2jeqIGteJSRs=
+github.com/antchfx/xpath v1.3.3/go.mod h1:i54GszH55fYfBmoZXapTHN8T8tkcHfRgLyVwwqzXNcs=
+github.com/apache/thrift v0.12.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb+bacwQ=
 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/bahlo/generic-list-go v0.2.0 h1:5sz/EEAK+ls5wF+NeqDpk5+iNdMDXrh3z3nPnH1Wvgk=
+github.com/bahlo/generic-list-go v0.2.0/go.mod h1:2KvAjgMlE5NNynlg/5iLrrCCZ2+5xWbdbCW3pNTGyYg=
+github.com/benbjohnson/immutable v0.2.0/go.mod h1:uc6OHo6PN2++n98KHLxW8ef4W42ylHiQSENghE1ezxI=
+github.com/benbjohnson/immutable v0.3.0 h1:TVRhuZx2wG9SZ0LRdqlbs9S5BZ6Y24hJEHTCgWHZEIw=
+github.com/benbjohnson/immutable v0.3.0/go.mod h1:uc6OHo6PN2++n98KHLxW8ef4W42ylHiQSENghE1ezxI=
+github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
+github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
+github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
+github.com/bits-and-blooms/bitset v1.2.0/go.mod h1:gIdJ4wp64HaoK2YrL1Q5/N7Y16edYb8uY+O0FJTyyDA=
+github.com/bits-and-blooms/bitset v1.2.2 h1:J5gbX05GpMdBjCvQ9MteIg2KKDExr7DrgK+Yc15FvIk=
+github.com/bits-and-blooms/bitset v1.2.2/go.mod h1:gIdJ4wp64HaoK2YrL1Q5/N7Y16edYb8uY+O0FJTyyDA=
 github.com/blinkbean/dingtalk v1.1.3 h1:MbidFZYom7DTFHD/YIs+eaI7kRy52kmWE/sy0xjo6E4=
 github.com/blinkbean/dingtalk v1.1.3/go.mod h1:9BaLuGSBqY3vT5hstValh48DbsKO7vaHaJnG9pXwbto=
+github.com/bradfitz/iter v0.0.0-20140124041915-454541ec3da2/go.mod h1:PyRFw1Lt2wKX4ZVSQ2mk+PeDa1rxyObEDlApuIsUKuo=
+github.com/bradfitz/iter v0.0.0-20190303215204-33e6a9893b0c/go.mod h1:PyRFw1Lt2wKX4ZVSQ2mk+PeDa1rxyObEDlApuIsUKuo=
+github.com/bradfitz/iter v0.0.0-20191230175014-e8f45d346db8 h1:GKTyiRCL6zVf5wWaqKnf+7Qs6GbEPfd4iMOitWzXJx8=
+github.com/bradfitz/iter v0.0.0-20191230175014-e8f45d346db8/go.mod h1:spo1JLcs67NmW1aVLEgtA8Yy1elc+X8y5SRW1sFW4Og=
 github.com/bytedance/sonic v1.11.6 h1:oUp34TzMlL+OY1OUWxHqsdkgC/Zfc85zGqw9siXjrc0=
 github.com/bytedance/sonic v1.11.6/go.mod h1:LysEHSvpvDySVdC2f87zGWf6CIKJcAvqab1ZaiQtds4=
 github.com/bytedance/sonic/loader v0.1.1 h1:c+e5Pt1k/cy5wMveRDyk2X4B9hF4g7an8N3zCYjJFNM=
 github.com/bytedance/sonic/loader v0.1.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
+github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko=
+github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
+github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
 github.com/cloudwego/base64x v0.1.4 h1:jwCgWpFanWmN8xoIUHa2rtzmkd5J2plF/dnLS6Xd/0Y=
 github.com/cloudwego/base64x v0.1.4/go.mod h1:0zlkT4Wn5C6NdauXdJRhSKRlJvmclQ1hhJgA0rcu/8w=
 github.com/cloudwego/iasm v0.2.0 h1:1KNIy1I1H9hNNFEEH3DVnI4UujN+1zjpuk6gwHLTssg=
 github.com/cloudwego/iasm v0.2.0/go.mod h1:8rXZaNYT2n95jn+zTI1sDr+IgcD2GVs0nlbbQPiEFhY=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/cyruzin/golang-tmdb v1.6.3 h1:TKK9h+uuwiDOaFlsVispG1KxqhsSM5Y4ZELnUF3GlqU=
 github.com/cyruzin/golang-tmdb v1.6.3/go.mod h1:ZSryJLCcY+9TiKU+LbouXKns++YBrM8Tizannr05c+I=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815/go.mod h1:WwZ+bS3ebgob9U8Nd0kOddGdZWjyMGR8Wziv+TBNwSE=
+github.com/dustin/go-humanize v0.0.0-20180421182945-02af3965c54e/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
+github.com/dustin/go-humanize v1.0.0 h1:VSnTsYCnlFHaM2/igO1h6X3HA71jcobQuxemgkq4zYo=
+github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
+github.com/eapache/go-resiliency v1.1.0/go.mod h1:kFI+JgMyC7bLPUVY133qvEBtVayf5mFgVsvEsIPBvNs=
+github.com/eapache/go-xerial-snappy v0.0.0-20180814174437-776d5712da21/go.mod h1:+020luEh2TKB4/GOp8oxxtq0Daoen/Cii55CzbTV6DU=
+github.com/eapache/queue v1.1.0/go.mod h1:6eCeP0CKFpHLu8blIFXhExK/dRa7WDZfr6jVFPTqq+I=
+github.com/edsrzf/mmap-go v1.1.0 h1:6EUwBLQ/Mcr1EYLE4Tn1VdW1A4ckqCQWZBw8Hr0kjpQ=
+github.com/edsrzf/mmap-go v1.1.0/go.mod h1:19H/e8pUPLicwkyNgOykDXkJ9F0MHE+Z52B8EIth78Q=
+github.com/frankban/quicktest v1.9.0/go.mod h1:ui7WezCLWMWxVWr1GETZY3smRy0G4KWq9vcPtJmFl7Y=
+github.com/frankban/quicktest v1.14.4/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
 github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
 github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
+github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA=
 github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM=
 github.com/gabriel-vasile/mimetype v1.4.4 h1:QjV6pZ7/XZ7ryI2KuyeEDE8wnh7fHP9YnQy+R0LnH8I=
@@ -44,6 +165,25 @@ github.com/gin-contrib/zap v1.1.3 h1:9e/U9fYd4/OBfmSEBs5hHZq114uACn7bpuzvCkcJySA
 github.com/gin-contrib/zap v1.1.3/go.mod h1:+BD/6NYZKJyUpqVoJEvgeq9GLz8pINEQvak9LHNOTSE=
 github.com/gin-gonic/gin v1.10.0 h1:nTuyha1TYqgedzytsKYqna+DfLos46nTv2ygFy86HFU=
 github.com/gin-gonic/gin v1.10.0/go.mod h1:4PMNQiOhvDRa013RKVbsiNwoyezlm2rm0uX/T7kzp5Y=
+github.com/glycerine/go-unsnap-stream v0.0.0-20180323001048-9f0cb55181dd/go.mod h1:/20jfyN9Y5QPEAprSgKAUr+glWDY39ZiUEAYOEv5dsE=
+github.com/glycerine/go-unsnap-stream v0.0.0-20181221182339-f9677308dec2/go.mod h1:/20jfyN9Y5QPEAprSgKAUr+glWDY39ZiUEAYOEv5dsE=
+github.com/glycerine/go-unsnap-stream v0.0.0-20190901134440-81cf024a9e0a/go.mod h1:/20jfyN9Y5QPEAprSgKAUr+glWDY39ZiUEAYOEv5dsE=
+github.com/glycerine/goconvey v0.0.0-20180728074245-46e3a41ad493/go.mod h1:Ogl1Tioa0aV7gstGFO7KhffUsb9M4ydbEbbxpcEDc24=
+github.com/glycerine/goconvey v0.0.0-20190315024820-982ee783a72e/go.mod h1:Ogl1Tioa0aV7gstGFO7KhffUsb9M4ydbEbbxpcEDc24=
+github.com/glycerine/goconvey v0.0.0-20190410193231-58a59202ab31/go.mod h1:Ogl1Tioa0aV7gstGFO7KhffUsb9M4ydbEbbxpcEDc24=
+github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
+github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
+github.com/go-llsqlite/adapter v0.0.0-20230927005056-7f5ce7f0c916 h1:OyQmpAN302wAopDgwVjgs2HkFawP9ahIEqkUYz7V7CA=
+github.com/go-llsqlite/adapter v0.0.0-20230927005056-7f5ce7f0c916/go.mod h1:DADrR88ONKPPeSGjFp5iEN55Arx3fi2qXZeKCYDpbmU=
+github.com/go-llsqlite/crawshaw v0.5.2-0.20240425034140-f30eb7704568 h1:3EpZo8LxIzF4q3BT+vttQQlRfA6uTtTb/cxVisWa5HM=
+github.com/go-llsqlite/crawshaw v0.5.2-0.20240425034140-f30eb7704568/go.mod h1:/YJdV7uBQaYDE0fwe4z3wwJIZBJxdYzd38ICggWqtaE=
+github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
+github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
+github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
+github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
+github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
+github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
 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-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
@@ -54,26 +194,73 @@ github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJn
 github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
 github.com/go-playground/validator/v10 v10.20.0 h1:K9ISHbSaI0lyB2eWMPJo+kOS/FBExVwjEviJTixqxL8=
 github.com/go-playground/validator/v10 v10.20.0/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM=
+github.com/go-quicktest/qt v1.101.0 h1:O1K29Txy5P2OK0dGo59b7b0LR6wKfIhttaAhHUyn7eI=
+github.com/go-quicktest/qt v1.101.0/go.mod h1:14Bz/f7NwaXPtdYEgzsx46kqSxVwTbzVZsDC26tQJow=
+github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
 github.com/go-telegram-bot-api/telegram-bot-api v4.6.4+incompatible h1:2cauKuaELYAEARXRkq2LrJ0yDDv1rW7+wrTEdVL3uaU=
 github.com/go-telegram-bot-api/telegram-bot-api v4.6.4+incompatible/go.mod h1:qf9acutJ8cwBUhm1bqgz6Bei9/C/c93FPDljKWwsOgM=
 github.com/go-test/deep v1.0.4 h1:u2CU3YKy9I2pmu9pX0eq50wCgjfGIt539SqR7FbHiho=
 github.com/go-test/deep v1.0.4/go.mod h1:wGDj63lr65AM2AQyKZd/NYHGb0R+1RLqB8NKt3aSFNA=
+github.com/gobwas/glob v0.2.3 h1:A4xDbljILXROh+kObIiy5kIaPYD8e96x1tgBhUI5J+Y=
+github.com/gobwas/glob v0.2.3/go.mod h1:d3Ez4x06l9bZtSvzIay5+Yzi0fmZzPgnTbPcKjJAkT8=
 github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
 github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
-github.com/golang-jwt/jwt/v5 v5.2.1 h1:OuVbFODueb089Lh128TAcimifWaLhJwVflnrgM17wHk=
-github.com/golang-jwt/jwt/v5 v5.2.1/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk=
+github.com/gocolly/colly v1.2.0 h1:qRz9YAn8FIH0qzgNUw+HT9UN7wm1oF9OBAilwEWpyrI=
+github.com/gocolly/colly v1.2.0/go.mod h1:Hof5T3ZswNVsOHYmba1u03W65HDWgpV5HifSuueE0EA=
+github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
+github.com/gogo/protobuf v1.2.0/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
+github.com/golang-jwt/jwt/v5 v5.2.2 h1:Rl4B7itRWVtYIHFrSNd7vhTiz9UpLdi6gZhZ3wEeDy8=
+github.com/golang-jwt/jwt/v5 v5.2.2/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
+github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 h1:f+oWsMOmNPc8JmEHVZIycC7hBoQxHH9pNKQORJNozsQ=
+github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8/go.mod h1:wcDNUvekVysuuOpQKo3191zZyTpiI6se1N1ULghS0sw=
+github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
+github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
+github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
+github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
+github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
+github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
+github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
+github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
+github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
+github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
+github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/google/btree v0.0.0-20180124185431-e89373fe6b4a/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
+github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
+github.com/google/btree v1.1.2 h1:xf4v41cLI2Z6FxbKm+8Bu+m8ifhj15JuZ9sa0jZCMUU=
+github.com/google/btree v1.1.2/go.mod h1:qOPhT0dTNdNzV6Z/lhRX0YXUafgPLFUh+gZMl761Gm4=
+github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
+github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 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/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 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/gopherjs/gopherjs v0.0.0-20181103185306-d547d1d9531e/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
+github.com/gopherjs/gopherjs v0.0.0-20190309154008-847fc94819f9/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
+github.com/gopherjs/gopherjs v0.0.0-20190910122728-9d188e94fb99/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
+github.com/gorilla/context v1.1.1/go.mod h1:kBGZzfjB9CEq2AlWe17Uuf7NDRt0dE0s8S51q0aT7Yg=
+github.com/gorilla/mux v1.6.2/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs=
+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/gregdel/pushover v1.3.1 h1:4bMLITOZ15+Zpi6qqoGqOPuVHCwSUvMCgVnN5Xhilfo=
 github.com/gregdel/pushover v1.3.1/go.mod h1:EcaO66Nn1StkpEm1iKtBTV3d2A16SoMsVER1PthX7to=
 github.com/hashicorp/go-cleanhttp v0.5.2 h1:035FKYIWjmULyFRBKPs8TBQoi0x6d9G4xc9neXJWAZQ=
 github.com/hashicorp/go-cleanhttp v0.5.2/go.mod h1:kO/YDlP8L1346E6Sodw+PrpBSV4/SoxCXGY6BqNFT48=
+github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
 github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
 github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
 github.com/hashicorp/hcl/v2 v2.13.0 h1:0Apadu1w6M11dyGFxWnmhhcMjkbAiKCv7G1r/2QgCNc=
@@ -82,16 +269,40 @@ github.com/hekmon/cunits/v2 v2.1.0 h1:k6wIjc4PlacNOHwKEMBgWV2/c8jyD4eRMs5mR1BBhI
 github.com/hekmon/cunits/v2 v2.1.0/go.mod h1:9r1TycXYXaTmEWlAIfFV8JT+Xo59U96yUJAYHxzii2M=
 github.com/hekmon/transmissionrpc/v3 v3.0.0 h1:0Fb11qE0IBh4V4GlOwHNYpqpjcYDp5GouolwrpmcUDQ=
 github.com/hekmon/transmissionrpc/v3 v3.0.0/go.mod h1:38SlNhFzinVUuY87wGj3acOmRxeYZAZfrj6Re7UgCDg=
+github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
+github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
+github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
+github.com/huandu/xstrings v1.0.0/go.mod h1:4qWG/gcEcfX4z/mBDHJ++3ReCw9ibxbsNJbcucJdbSo=
+github.com/huandu/xstrings v1.2.0/go.mod h1:DvyZB1rfVYsBIigL8HwpZgxHwXozlTgGqn63UyNX5k4=
+github.com/huandu/xstrings v1.3.0/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE=
+github.com/huandu/xstrings v1.3.1/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE=
+github.com/huandu/xstrings v1.3.2 h1:L18LIDzqlW6xN2rEkpdV8+oL/IXWJ1APd+vsdYy4Wdw=
+github.com/huandu/xstrings v1.3.2/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE=
+github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
+github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
 github.com/jordan-wright/email v4.0.1-0.20210109023952-943e75fe5223+incompatible h1:jdpOPRN1zP63Td1hDQbZW73xKmzDvZHzVdNYxhnTMDA=
 github.com/jordan-wright/email v4.0.1-0.20210109023952-943e75fe5223+incompatible/go.mod h1:1c7szIrayyPPB/987hsnvNzLushdWf4o/79s3P08L8A=
+github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
+github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
 github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
 github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
+github.com/jtolds/gls v4.2.1+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
+github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
+github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
+github.com/kennygrant/sanitize v1.2.4 h1:gN25/otpP5vAsO2djbMhF/LQX6R7+O1TB4yv8NzpJ3o=
+github.com/kennygrant/sanitize v1.2.4/go.mod h1:LGsjYYtgxbetdg5owWB2mpgUL6e2nfw2eObZ0u0qvak=
+github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
 github.com/kisielk/sqlstruct v0.0.0-20201105191214-5f3e10d3ab46/go.mod h1:yyMNCyc/Ib3bDTKd379tNMpB/7/H5TjM2Y9QJ5THLbE=
+github.com/klauspost/cpuid/v2 v2.0.4/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
 github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
 github.com/klauspost/cpuid/v2 v2.2.7 h1:ZWSB3igEs+d0qvnxR/ZBzXVmxkgt8DdzP6m9pfuVLDM=
 github.com/klauspost/cpuid/v2 v2.2.7/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
 github.com/knz/go-libedit v1.10.1/go.mod h1:MZTVkCWyz0oBc7JOWP3wNAzd002ZbM/5hgShxwh4x8M=
+github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pretty v0.2.0/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
+github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
@@ -106,8 +317,13 @@ github.com/magiconair/properties v1.8.7 h1:IeQXZAiQcpL9mgcAe1Nu6cX9LLw6ExEHKjN0V
 github.com/magiconair/properties v1.8.7/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
 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.9 h1:Lm995f3rfxdpd6TSmuVCHVb/QhupuXlYr8sCI/QdE+0=
+github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
 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/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
+github.com/minio/sha256-simd v1.0.0 h1:v1ta+49hkWZyvaKwrQB8elexRqm6Y0aMLjCNsrYxo6g=
+github.com/minio/sha256-simd v1.0.0/go.mod h1:OuYzVNI5vcoYIAmbIvHPl3N3jUzVedXbKy5RFepssQM=
 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/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=
@@ -115,8 +331,20 @@ github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RR
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
+github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
 github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
+github.com/mr-tron/base58 v1.2.0 h1:T/HDJBh4ZCPbU39/+c3rRvE0uKBQlU27+QI8LJ4t64o=
+github.com/mr-tron/base58 v1.2.0/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc=
+github.com/mschoch/smat v0.0.0-20160514031455-90eadee771ae/go.mod h1:qAyveg+e4CE+eKJXWVjKXM4ck2QobLqTDytGJbLLhJg=
+github.com/mschoch/smat v0.2.0 h1:8imxQsjDm8yFEAVBe7azKmKSgzSkZXDuKkSq9374khM=
+github.com/mschoch/smat v0.2.0/go.mod h1:kc9mz7DoBKqDyiRL7VZN8KvXQMWeTaVnttLRXOlotKw=
+github.com/multiformats/go-multihash v0.2.3 h1:7Lyc8XfX/IY2jWb/gI7JP+o7JEq9hOa7BFvVU9RSh+U=
+github.com/multiformats/go-multihash v0.2.3/go.mod h1:dXgKXCXjBzdscBLk9JkjINiEsCKRVch90MdaGiKsvSM=
+github.com/multiformats/go-varint v0.0.6 h1:gk85QWKxh3TazbLxED/NlDVv8+q+ReFJk7Y2W/KhfNY=
+github.com/multiformats/go-varint v0.0.6/go.mod h1:3Ls8CIEsrijN6+B7PbrXRPxHRPuXSrVKRY101jdMZYE=
+github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
 github.com/natefinch/lumberjack v2.0.0+incompatible h1:4QJd3OLAMgj7ph+yZTuX13Ld4UpgHp07nNdFX7mqFfM=
 github.com/natefinch/lumberjack v2.0.0+incompatible/go.mod h1:Wi9p2TTF5DG5oU+6YfsmYQpsTIOm0B1VNzQg9Mw6nPk=
 github.com/ncruces/go-sqlite3 v0.18.4 h1:Je8o3y33MDwPYY/Cacas8yCsuoUzpNY/AgoSlN2ekyE=
@@ -125,39 +353,128 @@ github.com/ncruces/julianday v1.0.0 h1:fH0OKwa7NWvniGQtxdJRxAgkBMolni2BjDHaWTxqt
 github.com/ncruces/julianday v1.0.0/go.mod h1:Dusn2KvZrrovOMJuOt0TNXL6tB7U2E8kvza5fFc9G7g=
 github.com/nikoksr/notify v1.0.0 h1:qe9/6FRsWdxBgQgWcpvQ0sv8LRGJZDpRB4TkL2uNdO8=
 github.com/nikoksr/notify v1.0.0/go.mod h1:hPaaDt30d6LAA7/5nb0e48Bp/MctDfycCSs8VEgN29I=
+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/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
+github.com/openzipkin/zipkin-go v0.1.6/go.mod h1:QgAqvLzwWbR/WpD4A3cGpPtJrZXNIiJc5AZX7/PBEpw=
 github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM=
 github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs=
+github.com/philhofer/fwd v1.0.0/go.mod h1:gk3iGcWd9+svBvR0sR+KPcfE+RNWozjowpeBVG3ZVNU=
+github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY=
+github.com/pion/datachannel v1.5.9 h1:LpIWAOYPyDrXtU+BW7X0Yt/vGtYxtXQ8ql7dFfYUVZA=
+github.com/pion/datachannel v1.5.9/go.mod h1:kDUuk4CU4Uxp82NH4LQZbISULkX/HtzKa4P7ldf9izE=
+github.com/pion/dtls/v3 v3.0.3 h1:j5ajZbQwff7Z8k3pE3S+rQ4STvKvXUdKsi/07ka+OWM=
+github.com/pion/dtls/v3 v3.0.3/go.mod h1:weOTUyIV4z0bQaVzKe8kpaP17+us3yAuiQsEAG1STMU=
+github.com/pion/ice/v4 v4.0.2 h1:1JhBRX8iQLi0+TfcavTjPjI6GO41MFn4CeTBX+Y9h5s=
+github.com/pion/ice/v4 v4.0.2/go.mod h1:DCdqyzgtsDNYN6/3U8044j3U7qsJ9KFJC92VnOWHvXg=
+github.com/pion/interceptor v0.1.37 h1:aRA8Zpab/wE7/c0O3fh1PqY0AJI3fCSEM5lRWJVorwI=
+github.com/pion/interceptor v0.1.37/go.mod h1:JzxbJ4umVTlZAf+/utHzNesY8tmRkM2lVmkS82TTj8Y=
+github.com/pion/logging v0.2.2 h1:M9+AIj/+pxNsDfAT64+MAVgJO0rsyLnoJKCqf//DoeY=
+github.com/pion/logging v0.2.2/go.mod h1:k0/tDVsRCX2Mb2ZEmTqNa7CWsQPc+YYCB7Q+5pahoms=
+github.com/pion/mdns/v2 v2.0.7 h1:c9kM8ewCgjslaAmicYMFQIde2H9/lrZpjBkN8VwoVtM=
+github.com/pion/mdns/v2 v2.0.7/go.mod h1:vAdSYNAT0Jy3Ru0zl2YiW3Rm/fJCwIeM0nToenfOJKA=
+github.com/pion/randutil v0.1.0 h1:CFG1UdESneORglEsnimhUjf33Rwjubwj6xfiOXBa3mA=
+github.com/pion/randutil v0.1.0/go.mod h1:XcJrSMMbbMRhASFVOlj/5hQial/Y8oH/HVo7TBZq+j8=
+github.com/pion/rtcp v1.2.14 h1:KCkGV3vJ+4DAJmvP0vaQShsb0xkRfWkO540Gy102KyE=
+github.com/pion/rtcp v1.2.14/go.mod h1:sn6qjxvnwyAkkPzPULIbVqSKI5Dv54Rv7VG0kNxh9L4=
+github.com/pion/rtp v1.8.9 h1:E2HX740TZKaqdcPmf4pw6ZZuG8u5RlMMt+l3dxeu6Wk=
+github.com/pion/rtp v1.8.9/go.mod h1:pBGHaFt/yW7bf1jjWAoUjpSNoDnw98KTMg+jWWvziqU=
+github.com/pion/sctp v1.8.33 h1:dSE4wX6uTJBcNm8+YlMg7lw1wqyKHggsP5uKbdj+NZw=
+github.com/pion/sctp v1.8.33/go.mod h1:beTnqSzewI53KWoG3nqB282oDMGrhNxBdb+JZnkCwRM=
+github.com/pion/sdp/v3 v3.0.9 h1:pX++dCHoHUwq43kuwf3PyJfHlwIj4hXA7Vrifiq0IJY=
+github.com/pion/sdp/v3 v3.0.9/go.mod h1:B5xmvENq5IXJimIO4zfp6LAe1fD9N+kFv+V/1lOdz8M=
+github.com/pion/srtp/v3 v3.0.4 h1:2Z6vDVxzrX3UHEgrUyIGM4rRouoC7v+NiF1IHtp9B5M=
+github.com/pion/srtp/v3 v3.0.4/go.mod h1:1Jx3FwDoxpRaTh1oRV8A/6G1BnFL+QI82eK4ms8EEJQ=
+github.com/pion/stun/v3 v3.0.0 h1:4h1gwhWLWuZWOJIJR9s2ferRO+W3zA/b6ijOI6mKzUw=
+github.com/pion/stun/v3 v3.0.0/go.mod h1:HvCN8txt8mwi4FBvS3EmDghW6aQJ24T+y+1TKjB5jyU=
+github.com/pion/transport/v3 v3.0.7 h1:iRbMH05BzSNwhILHoBoAPxoB9xQgOaJk+591KC9P1o0=
+github.com/pion/transport/v3 v3.0.7/go.mod h1:YleKiTZ4vqNxVwh77Z0zytYi7rXHl7j6uPLGhhz9rwo=
+github.com/pion/turn/v4 v4.0.0 h1:qxplo3Rxa9Yg1xXDxxH8xaqcyGUtbHYw4QSCvmFWvhM=
+github.com/pion/turn/v4 v4.0.0/go.mod h1:MuPDkm15nYSklKpN8vWJ9W2M0PlyQZqYt1McGuxG7mA=
+github.com/pion/webrtc/v4 v4.0.0 h1:x8ec7uJQPP3D1iI8ojPAiTOylPI7Fa7QgqZrhpLyqZ8=
+github.com/pion/webrtc/v4 v4.0.0/go.mod h1:SfNn8CcFxR6OUVjLXVslAQ3a3994JhyE3Hw1jAuqEto=
+github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
+github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 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/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
+github.com/prometheus/client_golang v0.9.3-0.20190127221311-3c4408c8b829/go.mod h1:p2iRAGwDERtqlqzRXnrOVns+ignqQo//hLXqYxZYVNs=
+github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
+github.com/prometheus/client_golang v1.5.1/go.mod h1:e9GMxYsXl05ICDXkRhurwBS4Q3OK1iX/F2sw+iXX5zU=
+github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
+github.com/prometheus/client_model v0.0.0-20190115171406-56726106282f/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
+github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/common v0.2.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
+github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
+github.com/prometheus/common v0.9.1/go.mod h1:yhUN8i9wzaXS3w1O07YhxHEBxD+W35wd8bs7vj7HSQ4=
+github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
+github.com/prometheus/procfs v0.0.0-20190117184657-bf6a532e95b1/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
+github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
+github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A=
+github.com/prometheus/procfs v0.0.11/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
+github.com/protolambda/ctxlock v0.1.0 h1:rCUY3+vRdcdZXqT07iXgyr744J2DU2LCBIXowYAjBCE=
+github.com/protolambda/ctxlock v0.1.0/go.mod h1:vefhX6rIZH8rsg5ZpOJfEDYQOppZi19SfPiGOFrNnwM=
+github.com/rcrowley/go-metrics v0.0.0-20181016184325-3113b8401b8a/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4=
+github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
+github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
+github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
 github.com/robfig/cron v1.2.0 h1:ZjScXvvxeQ63Dbyxy76Fj3AT3Ut0aKsyd2/tl3DTMuQ=
 github.com/robfig/cron v1.2.0/go.mod h1:JGuDeoQd7Z6yL4zQhZ3OPEVHB7fL6Ka6skscFHfmt2k=
-github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
+github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
+github.com/rogpeppe/go-internal v1.8.0/go.mod h1:WmiCO8CzOY8rg0OYDC4/i/2WRWAB6poM+XZ2dLUbcbE=
 github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
+github.com/rogpeppe/go-internal v1.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDNXVBh4M=
+github.com/rogpeppe/go-internal v1.11.0/go.mod h1:ddIwULY96R17DhadqLgMfk9H9tvdUzkipdSkR5nkCZA=
+github.com/rs/dnscache v0.0.0-20211102005908-e0241e321417 h1:Lt9DzQALzHoDwMBGJ6v8ObDPR0dzr2a6sXTB1Fq7IHs=
+github.com/rs/dnscache v0.0.0-20211102005908-e0241e321417/go.mod h1:qe5TWALJ8/a1Lqznoc5BDHpYX/8HU60Hm2AwRmqzxqA=
+github.com/ryszard/goskiplist v0.0.0-20150312221310-2dfbae5fcf46 h1:GHRpF1pTW19a8tTFrMLUcfWwyC0pnifVo2ClaLq+hP8=
+github.com/ryszard/goskiplist v0.0.0-20150312221310-2dfbae5fcf46/go.mod h1:uAQ5PCi+MFsC7HjREoAz1BU+Mq60+05gifQSsHSDG/8=
 github.com/sagikazarmark/locafero v0.4.0 h1:HApY1R9zGo4DBgr7dqsTH/JJxLTTsOt7u6keLGt6kNQ=
 github.com/sagikazarmark/locafero v0.4.0/go.mod h1:Pe1W6UlPYUk/+wc/6KFhbORCfqzgYEpgQ3O5fPuL3H4=
 github.com/sagikazarmark/slog-shim v0.1.0 h1:diDBnUNK9N/354PgrxMywXnAwEr1QZcOr6gto+ugjYE=
 github.com/sagikazarmark/slog-shim v0.1.0/go.mod h1:SrcSrq8aKtyuqEI1uvTDTK1arOWRIczQRv+GVI1AkeQ=
+github.com/saintfish/chardet v0.0.0-20230101081208-5e3ef4b5456d h1:hrujxIzL1woJ7AwssoOcM/tq5JjjG2yYOc8odClEiXA=
+github.com/saintfish/chardet v0.0.0-20230101081208-5e3ef4b5456d/go.mod h1:uugorj2VCxiV1x+LzaIdVa9b4S4qGAcH6cbhh4qVxOU=
 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/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
+github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
+github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
+github.com/smartystreets/assertions v0.0.0-20190215210624-980c5ac6f3ac/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
+github.com/smartystreets/goconvey v0.0.0-20181108003508-044398e4856c/go.mod h1:XDJAKZRPZ1CvBcN2aX5YOUTYGHki24fSF0Iv48Ibg0s=
+github.com/smartystreets/goconvey v0.0.0-20190306220146-200a235640ff/go.mod h1:KSQcGKpxUMHk3nbYzs/tIBAM2iDooCn0BmttHOJEbLs=
 github.com/sourcegraph/conc v0.3.0 h1:OQTbbt6P72L20UqAkXXuLOj79LfEanQ+YQFNpLA9ySo=
 github.com/sourcegraph/conc v0.3.0/go.mod h1:Sdozi7LEKbFPqYX2/J+iBAM6HpqSLTASQIKqDmF7Mt0=
+github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
+github.com/spaolacci/murmur3 v1.1.0 h1:7c1g84S4BPRrfL5Xrdp6fOJ206sU9y293DDHaoy0bLI=
+github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
 github.com/spf13/afero v1.11.0 h1:WJQKhtpdm3v2IzqG8VMqrr6Rf3UYpEF239Jy9wNepM8=
 github.com/spf13/afero v1.11.0/go.mod h1:GH9Y3pIexgf1MTIWtNGyogA5MwRIDXGUr+hbWNoBjkY=
 github.com/spf13/cast v1.6.0 h1:GEiTHELF+vaR5dhz3VqZfFSzZjYbgeKDpBxQVS4GYJ0=
 github.com/spf13/cast v1.6.0/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo=
+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/spf13/viper v1.19.0 h1:RWq5SEjt8o25SROyN3z2OrDB9l7RPd3lwTWU8EcEdcI=
 github.com/spf13/viper v1.19.0/go.mod h1:GQUN9bilAbhU/jgc1bKs99f/suXKeUMct8Adx5+Ntkg=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.1.1/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/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
 github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
+github.com/stretchr/testify v1.2.1/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 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=
@@ -169,17 +486,40 @@ github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8
 github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU=
 github.com/technoweenie/multipartstreamer v1.0.1 h1:XRztA5MXiR1TIRHxH2uNxXxaIkKQDeX7m2XsSOlQEnM=
 github.com/technoweenie/multipartstreamer v1.0.1/go.mod h1:jNVxdtShOxzAsukZwTSw6MDx5eUJoiEBsSvzDU9uzog=
+github.com/temoto/robotstxt v1.1.2 h1:W2pOjSJ6SWvldyEuiFXNxz3xZ8aiWX5LbfDiOFd7Fxg=
+github.com/temoto/robotstxt v1.1.2/go.mod h1:+1AmkuG3IYkh1kv0d2qEB9Le88ehNO0zwOr3ujewlOo=
 github.com/tetratelabs/wazero v1.8.0 h1:iEKu0d4c2Pd+QSRieYbnQC9yiFlMS9D+Jr0LsRmcF4g=
 github.com/tetratelabs/wazero v1.8.0/go.mod h1:yAI0XTsMBhREkM/YDAK/zNou3GoiAce1P6+rp/wQhjs=
+github.com/tidwall/btree v1.6.0 h1:LDZfKfQIBHGHWSwckhXI0RPSXzlo+KYdjK7FWSqOzzg=
+github.com/tidwall/btree v1.6.0/go.mod h1:twD9XRA5jj9VUQGELzDO4HPQTNJsoWWfYEL+EUQ2cKY=
+github.com/tinylib/msgp v1.0.2/go.mod h1:+d+yLhGm8mzTaHzB+wgMYrodPfmZrzkirds8fDWklFE=
+github.com/tinylib/msgp v1.1.0/go.mod h1:+d+yLhGm8mzTaHzB+wgMYrodPfmZrzkirds8fDWklFE=
+github.com/tinylib/msgp v1.1.2/go.mod h1:+d+yLhGm8mzTaHzB+wgMYrodPfmZrzkirds8fDWklFE=
 github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
 github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
 github.com/ugorji/go/codec v1.2.12 h1:9LC83zGrHhuUA9l16C9AHXAqEV/2wBQ4nkvumAE65EE=
 github.com/ugorji/go/codec v1.2.12/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
 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/willf/bitset v1.1.9/go.mod h1:RjeCKbqT1RxIR/KWY6phxZiaY1IyutSBfGjNPySAYV4=
+github.com/willf/bitset v1.1.10/go.mod h1:RjeCKbqT1RxIR/KWY6phxZiaY1IyutSBfGjNPySAYV4=
+github.com/wlynxg/anet v0.0.3 h1:PvR53psxFXstc12jelG6f1Lv4MWqE0tI76/hHGjh9rg=
+github.com/wlynxg/anet v0.0.3/go.mod h1:eay5PRQr7fIVAMbTbchTnO9gG65Hg/uYGdc7mguHxoA=
+github.com/yuin/goldmark v1.4.1/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 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.etcd.io/bbolt v1.3.6 h1:/ecaJf0sk1l4l6V4awd65v2C3ILy7MSj+s/x1ADCIMU=
+go.etcd.io/bbolt v1.3.6/go.mod h1:qXsaaIqmgQH0T+OPdb99Bf+PKfBBQVAdyD6TY9G8XM4=
+go.opencensus.io v0.20.1/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk=
+go.opencensus.io v0.20.2/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk=
+go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+go.opentelemetry.io/otel v1.28.0 h1:/SqNcYk+idO0CxKEUOtKQClMK/MimZihKYMruSMViUo=
+go.opentelemetry.io/otel v1.28.0/go.mod h1:q68ijF8Fc8CnMHKyzqL6akLO46ePnjkgfIMIjUIX9z4=
+go.opentelemetry.io/otel/metric v1.28.0 h1:f0HGvSl1KRAU1DLgLGFjrwVyismPlnuU6JD6bOeuA5Q=
+go.opentelemetry.io/otel/metric v1.28.0/go.mod h1:Fb1eVBFZmLVTMb6PPohq3TO9IIhUisDsbJoL/+uQW4s=
+go.opentelemetry.io/otel/trace v1.28.0 h1:GhQ9cUuQGmNDd5BTCP2dAvv75RdMxEfTmYejp+lkx9g=
+go.opentelemetry.io/otel/trace v1.28.0/go.mod h1:jPyXzNPg6da9+38HEwElrQiHlVMTnVfM3/yv2OlIHaI=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
 go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
@@ -189,73 +529,210 @@ go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E=
 golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
 golang.org/x/arch v0.8.0 h1:3wRIsP3pM4yUptoR96otTUOXI367OS0+c9eeRi9doIc=
 golang.org/x/arch v0.8.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
+golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/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-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.27.0 h1:GXm2NjJrPaiv/h1tb2UH8QfgC/hOf/+z0p6PT8o1w7A=
-golang.org/x/crypto v0.27.0/go.mod h1:1Xngt8kV6Dvbssa53Ziq6Eqn0HqbZi5Z6R0ZpwQzt70=
-golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 h1:2dVuKD2vS7b0QIHQbpyTISPd0LeHDbnYEryqj5Q1ug8=
-golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56/go.mod h1:M4RDyNAINzryxdtnbRXRL/OHtkFuWGRjvuhBJpk2IlY=
+golang.org/x/crypto v0.13.0/go.mod h1:y6Z2r+Rw4iayiXXAIxJIDAJ1zMW4yaTpebo8fPOliYc=
+golang.org/x/crypto v0.14.0/go.mod h1:MVFd36DqK4CsrnJYDkBA3VC4m2GkXAM0PvzMCn4JQf4=
+golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
+golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
+golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
+golang.org/x/crypto v0.36.0 h1:AnAEvhDddvBdpY+uR+MyHmuZzzNqXSe/GvuDeob5L34=
+golang.org/x/crypto v0.36.0/go.mod h1:Y4J0ReaxCR1IMaabaSMugxJES1EpwhBHhv2bDHklZvc=
+golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/exp v0.0.0-20220428152302-39d4317da171/go.mod h1:lgLbSvA5ygNOMpwM/9anMpWVlVJ7Z+cHWq/eFuinpGE=
+golang.org/x/exp v0.0.0-20240823005443-9b4947da3948 h1:kx6Ds3MlpiUHKj7syVnbp57++8WpuKPcR5yjLBjvLEA=
+golang.org/x/exp v0.0.0-20240823005443-9b4947da3948/go.mod h1:akd2r19cwCdwSwWeIdzYQGa/EZZyqcOdwWiwj5L5eKQ=
+golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
+golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/mod v0.5.1/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro=
+golang.org/x/mod v0.6.0-dev.0.20211013180041-c96bc1413d57/go.mod h1:3p9vT2HGsQu2K1YbXdKPJLVgG5VJdoTa1poYQBtP1AY=
 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.19.0 h1:fEdghXQSo20giMthA7cd28ZC+jts4amQ3YMXiP5oMQ8=
-golang.org/x/mod v0.19.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
+golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/mod v0.15.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
+golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
+golang.org/x/mod v0.24.0 h1:ZfthKaKaT4NrhGVZHO1/WDTwGES4De8KtWO0SIbNJMU=
+golang.org/x/mod v0.24.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww=
+golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190125091013-d26f9f9a57f3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
+golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 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/net v0.0.0-20211015210444-4f30a5c0130f/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.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns=
-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/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
+golang.org/x/net v0.15.0/go.mod h1:idbUs1IY1+zTqbi8yxTbhexhEEk5ur9LInksu6HrEpk=
+golang.org/x/net v0.17.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE=
+golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
+golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
+golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4=
+golang.org/x/net v0.37.0 h1:1zLorHbz+LYj7MQlSf1+2tPIIgibq2eL5xkrGk6f+2c=
+golang.org/x/net v0.37.0/go.mod h1:ivrbrMbzFq5J41QOQh0siUuly180yBYtLp+CKbEaFx8=
+golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/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.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ=
-golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
+golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.12.0 h1:MHc5BpPuC30uJk597Ri8TV3CNZcTLu6B6z4lJy+g6Jw=
+golang.org/x/sync v0.12.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181122145206-62eef0e2fa9b/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-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200413165638-669c56c373c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200923182605-d9f96fdee20d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 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-20211019181941-9d821ace8654/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.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.25.0 h1:r+8e+loiHxRqhXVl6ML1nO3l1+oFoWbnlu2Ehimmi34=
-golang.org/x/sys v0.25.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.13.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik=
+golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/telemetry v0.0.0-20240228155512-f48c80bd79b2/go.mod h1:TeRTkGYfJXctD9OcfyVLyj2J3IxLnKwHJR8f4D8a3YE=
 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/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY=
+golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
+golang.org/x/term v0.12.0/go.mod h1:owVbMEjm3cBLCHdkQu9b1opXd4ETQWc3BhuQGKgXgvU=
+golang.org/x/term v0.13.0/go.mod h1:LTmsnFJwVN6bCy1rVCoS+qHT1HhALEFxKncY3WNNh4U=
+golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk=
+golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY=
+golang.org/x/term v0.27.0/go.mod h1:iMsnZpn0cago0GOrHO2+Y7u7JPn5AylBrcoWkElMTSM=
 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.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.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=
 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.18.0 h1:XvMDiNzPAl0jr17s6W9lcaIhGUfUORdGCNsuLmPG224=
-golang.org/x/text v0.18.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
+golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
+golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY=
+golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4=
+golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk=
+golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
+golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
+golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.1.8-0.20211029000441-d6a9af8af023/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU=
 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.13.0/go.mod h1:HvlwmtVNQAhOuCjW7xxvovg8wbNq7LwfXh/k7wXUl58=
+golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk=
+golang.org/x/tools v0.24.0 h1:J1shsA93PJUEVaUSaay7UXAyE8aimq3GW0pjlolpa24=
+golang.org/x/tools v0.24.0/go.mod h1:YhNqVBIfWHdzvTLs0d8LCuMhkKUgSUKldakyV7W/WDQ=
+golang.org/x/tools v0.31.0 h1:0EedkvKDbh+qistFTd0Bcwe/YLh4vHwWEkiI0toFIBU=
+golang.org/x/tools v0.31.0/go.mod h1:naFTU+Cev749tSJRXJlna0T3WxKvb1kWEx15xA4SdmQ=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golift.io/starr v1.0.0 h1:IDSaSL+ZYxdLT/Lg//dg/iwZ39LHO3D5CmbLCOgSXbI=
+golift.io/starr v1.0.0/go.mod h1:xnUwp4vK62bDvozW9QHUYc08m6kjwaZnGw3Db65fQHw=
+google.golang.org/api v0.3.1/go.mod h1:6wY9I6uQWHQ8EM57III9mq/AjF+i8G65rmVagqKMtkk=
+google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
+google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
 google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
-google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg=
-google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw=
+google.golang.org/appengine v1.6.8 h1:IhEN5q69dyKagZPYMSdIjS2HqprW324FRQZJcGqPAsM=
+google.golang.org/appengine v1.6.8/go.mod h1:1jJ3jBArFh5pcgW8gCtRJnepW8FzD1V44FJffLiz/Ds=
+google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/grpc v1.17.0/go.mod h1:6QZJwpn2B+Zp71q/5VxRsJ6NXXVCE5NRUHRo+f3cWCs=
+google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
+google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
+google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
+google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
+google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
+google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
+google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
+google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
+google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
+google.golang.org/protobuf v1.36.5 h1:tPhr+woSbjfYvY6/GPufUoYizxw1cF/yFoxJ2fmpwlM=
+google.golang.org/protobuf v1.36.5/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
+gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
 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-20190902080502-41f04d3bba15/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/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
 gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA=
 gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
 gopkg.in/natefinch/lumberjack.v2 v2.2.1 h1:bBRl1b0OH9s/DuPhuXpNl+VtCaJXFZ5/uEFST95x9zc=
 gopkg.in/natefinch/lumberjack.v2 v2.2.1/go.mod h1:YD8tP3GAjkrDg1eZH7EGmyESg/lsYskCTPBJVb9jqSc=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
+gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
 gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 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=
+honnef.co/go/tools v0.0.0-20180728063816-88497007e858/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+lukechampine.com/blake3 v1.1.6 h1:H3cROdztr7RCfoaTpGZFQsrqvweFLrqS73j7L7cmR5c=
+lukechampine.com/blake3 v1.1.6/go.mod h1:tkKEOtDkNtklkXtLNEOGNq5tcV90tJiA1vAA12R78LA=
+modernc.org/libc v1.22.3 h1:D/g6O5ftAfavceqlLOFwaZuA5KYafKwmr30A6iSqoyY=
+modernc.org/libc v1.22.3/go.mod h1:MQrloYP209xa2zHome2a8HLiLm6k0UT8CoHpV74tOFw=
+modernc.org/mathutil v1.5.0 h1:rV0Ko/6SfM+8G+yKiyI830l3Wuz1zRutdslNoQ0kfiQ=
+modernc.org/mathutil v1.5.0/go.mod h1:mZW8CKdRPY1v87qxC/wUdX5O1qDzXMP5TH3wjfpga6E=
+modernc.org/memory v1.5.0 h1:N+/8c5rE6EqugZwHii4IFsaJ7MUhoWX07J5tC/iI5Ds=
+modernc.org/memory v1.5.0/go.mod h1:PkUhL0Mugw21sHPeskwZW4D6VscE/GQJOnIpCnW6pSU=
+modernc.org/sqlite v1.21.1 h1:GyDFqNnESLOhwwDRaHGdp2jKLDzpyT/rNLglX3ZkMSU=
+modernc.org/sqlite v1.21.1/go.mod h1:XwQ0wZPIh1iKb5mkvCJ3szzbhk+tykC8ZWqTRTgYRwI=
 nullprogram.com/x/optparse v1.0.0/go.mod h1:KdyPE+Igbe0jQUrVfMqDMeJQIJZEuyV7pjYmp6pbG50=
 rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=
+zombiezen.com/go/sqlite v0.13.1 h1:qDzxyWWmMtSSEH5qxamqBFmqA2BLSSbtODi3ojaE02o=
+zombiezen.com/go/sqlite v0.13.1/go.mod h1:Ht/5Rg3Ae2hoyh1I7gbWtWAl89CNocfqeb/aAMTkJr4=

log/log.go

@@ -15,12 +15,12 @@ var atom zap.AtomicLevel
 
 const dataPath = "./data"
 
-func init() {
+func InitLogger(toFile bool) {
 	atom = zap.NewAtomicLevel()
 	atom.SetLevel(zap.DebugLevel)
 
 	w := zapcore.Lock(os.Stdout)
-	if os.Getenv("GIN_MODE") == "release" {
+	if toFile {
 		w = zapcore.AddSync(&lumberjack.Logger{
 			Filename:   filepath.Join(dataPath, "logs", "polaris.log"),
 			MaxSize:    50, // megabytes

pkg/alist/alist.go

@@ -0,0 +1,196 @@
+package alist
+
+import (
+	"bytes"
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+
+	"github.com/pkg/errors"
+)
+
+type Resposne[T any] struct {
+	Code    int    `json:"code"`
+	Message string `json:"message"`
+	Data    T      `json:"data"`
+}
+
+type Config struct {
+	Username string
+	Password string
+	URL      string
+}
+
+func New(cfg *Config) *Client {
+	cfg.URL = strings.Trim(cfg.URL, "/")
+	return &Client{
+		cfg:  cfg,
+		http: http.DefaultClient,
+	}
+}
+
+type Client struct {
+	cfg   *Config
+	http  *http.Client
+	token string
+}
+
+func (c *Client) Login() (string, error) {
+	p := map[string]string{
+		"username": c.cfg.Username,
+		"password": c.cfg.Password,
+	}
+	data, _ := json.Marshal(p)
+	resp, err := c.http.Post(c.cfg.URL+loginUrl, "application/json", bytes.NewBuffer(data))
+	if err != nil {
+		return "", errors.Wrap(err, "login")
+	}
+	defer resp.Body.Close()
+	d1, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", errors.Wrap(err, "read body")
+	}
+	var rp Resposne[map[string]string]
+
+	err = json.Unmarshal(d1, &rp)
+	if err != nil {
+		return "", errors.Wrap(err, "json")
+	}
+	if rp.Code != 200 {
+		return "", errors.Errorf("alist error: code %d, %s", rp.Code, rp.Message)
+	}
+	c.token = rp.Data["token"]
+	return c.token, nil
+}
+
+type LsInfo struct {
+	Content []struct {
+		Name     string    `json:"name"`
+		Size     int       `json:"size"`
+		IsDir    bool      `json:"is_dir"`
+		Modified time.Time `json:"modified"`
+		Created  time.Time `json:"created"`
+		Sign     string    `json:"sign"`
+		Thumb    string    `json:"thumb"`
+		Type     int       `json:"type"`
+		Hashinfo string    `json:"hashinfo"`
+		HashInfo any       `json:"hash_info"`
+	} `json:"content"`
+	Total    int    `json:"total"`
+	Readme   string `json:"readme"`
+	Header   string `json:"header"`
+	Write    bool   `json:"write"`
+	Provider string `json:"provider"`
+}
+
+func (c *Client) Ls(dir string) (*LsInfo, error) {
+	in := map[string]string{
+		"path": dir,
+	}
+
+	resp, err := c.post(c.cfg.URL+lsUrl, in)
+	if err != nil {
+		return nil, errors.Wrap(err, "http")
+	}
+
+	var out Resposne[LsInfo]
+	err = json.Unmarshal(resp, &out)
+	if err != nil {
+		return nil, err
+	}
+	if out.Code != 200 {
+		return nil, errors.Errorf("alist error: code %d, %s", out.Code, out.Message)
+	}
+	return &out.Data, nil
+}
+
+func (c *Client) Mkdir(dir string) error {
+	in := map[string]string{
+		"path": dir,
+	}
+	resp, err := c.post(c.cfg.URL+mkdirUrl, in)
+	if err != nil {
+		return errors.Wrap(err, "http")
+	}
+	var out Resposne[any]
+	err = json.Unmarshal(resp, &out)
+	if err != nil {
+		return err
+	}
+	if out.Code != 200 {
+		return errors.Errorf("alist error: code %d, %s", out.Code, out.Message)
+	}
+	return nil
+}
+
+func (c *Client) post(url string, body interface{}) ([]byte, error) {
+	data, err := json.Marshal(body)
+	if err != nil {
+		return nil, err
+	}
+	req, err := http.NewRequest(http.MethodPost, url, bytes.NewReader(data))
+	if err != nil {
+		return nil, errors.Wrap(err, "new request")
+	}
+
+	req.Header.Add("Authorization", c.token)
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := c.http.Do(req)
+	if err != nil {
+		return nil, errors.Wrap(err, "http")
+	}
+	defer resp.Body.Close()
+	d1, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, errors.Wrap(err, "read body")
+	}
+	return d1, nil
+}
+
+type UploadStreamResponse struct {
+	Task struct {
+		ID       string `json:"id"`
+		Name     string `json:"name"`
+		State    int    `json:"state"`
+		Status   string `json:"status"`
+		Progress int    `json:"progress"`
+		Error    string `json:"error"`
+	} `json:"task"`
+}
+
+func (c *Client) UploadStream(reader io.Reader, size int64, toDir string) (*UploadStreamResponse, error) {
+	req, err := http.NewRequest(http.MethodPut, c.cfg.URL+streamUploadUrl, reader)
+	if err != nil {
+		return nil, err
+	}
+
+	req.Header.Add("Authorization", c.token)
+	req.Header.Add("File-Path", url.PathEscape(toDir))
+	req.Header.Add("As-Task", "true")
+	req.Header.Add("Content-Type", "application/octet-stream")
+	req.ContentLength = size
+	res, err := c.http.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer res.Body.Close()
+	d1, err := io.ReadAll(res.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	var out Resposne[UploadStreamResponse]
+	err = json.Unmarshal(d1, &out)
+	if err != nil {
+		return nil, err
+	}
+	if out.Code != 200 {
+		return nil, errors.Errorf("alist error: code %d, %s", out.Code, out.Message)
+	}
+
+	return &out.Data, nil
+}

pkg/alist/alist_test.go

@@ -0,0 +1,46 @@
+package alist
+
+import (
+	"os"
+	"polaris/log"
+	"testing"
+)
+
+func TestLogin(t *testing.T) {
+	c := New(&Config{
+		URL: "http://10.0.0.8:5244/",
+		Username: "",
+		Password: "",
+	})
+	cre, err := c.Login()
+	if err != nil {
+		log.Errorf("login fail: %v", err)
+		t.Fail()
+	} else {
+		log.Errorf("login success: %s", cre)
+	}
+	info, err := c.Ls("/aliyun")
+	if err != nil {
+		log.Errorf("ls fail: %v", err)
+		t.Fail()
+	} else {
+		log.Infof("ls results: %+v", info)
+	}
+
+	f, err := os.Open("/Users/simonding/Downloads/Steam Link_1.3.9_APKPure.apk")
+	if err != nil {
+		log.Errorf("openfile: %v", err)
+		t.Fail()
+	} else {
+		defer f.Close()
+		ss, _ := f.Stat()
+		log.Infof("upload file size %d", ss.Size())
+		info, err := c.UploadStream(f, ss.Size(), "/aliyun/Steam Link_1.3.9_APKPure.apk")
+		if err != nil {
+			log.Errorf("upload error: %v", err)
+			t.Fail()
+		} else {
+			log.Infof("upload success: %+v", info)
+		}
+	}
+}

pkg/alist/url.go

@@ -0,0 +1,8 @@
+package alist
+
+const (
+	loginUrl = "/api/auth/login"
+	lsUrl = "/api/fs/list"
+	mkdirUrl = "/api/fs/mkdir"
+	streamUploadUrl = "/api/fs/put"
+)

pkg/buildin/torrent.go

@@ -0,0 +1,203 @@
+package buildin
+
+import (
+	"fmt"
+	"io/fs"
+	"net/http"
+	"os"
+	"path/filepath"
+	"polaris/log"
+	"polaris/pkg"
+	"strings"
+
+	"github.com/anacrolix/torrent"
+	"github.com/anacrolix/torrent/metainfo"
+	"github.com/pkg/errors"
+)
+
+func NewDownloader(downloadDir string) (*Downloader, error) {
+	cfg := torrent.NewDefaultClientConfig()
+	cfg.DataDir = downloadDir
+	cfg.ListenPort = 51243
+	t, err := torrent.NewClient(cfg)
+	if err != nil {
+		return nil, errors.Wrapf(err, "create torrent client")
+	}
+	return &Downloader{cl: t, dir: downloadDir}, nil
+}
+
+type Downloader struct {
+	cl  *torrent.Client
+	dir string
+}
+
+func (d *Downloader) GetAll() ([]pkg.Torrent, error) {
+	ts := d.cl.Torrents()
+	var res []pkg.Torrent
+	for _, t := range ts {
+		res = append(res, &Torrent{
+			t:    t,
+			cl:   d.cl,
+			hash: t.InfoHash().HexString(),
+		})
+	}
+	return res, nil
+}
+
+func (d *Downloader) Download(link, hash, dir string) (pkg.Torrent, error) {
+
+	if strings.HasPrefix(strings.ToLower(link), "magnet:") {
+		t, err := d.cl.AddMagnet(link)
+		if err != nil {
+			return nil, fmt.Errorf("failed to add magnet: %v", err)
+		}
+		<-t.GotInfo()
+		return &Torrent{
+			t:    t,
+			cl:   d.cl,
+			hash: hash,
+			dir:  d.dir,
+		}, nil
+	}
+	client := &http.Client{
+		CheckRedirect: func(req *http.Request, via []*http.Request) error {
+			return http.ErrUseLastResponse //do not follow redirects
+		},
+	}
+
+	resp, err := client.Get(link)
+	if err != nil {
+		return nil, errors.Wrap(err, "get link")
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode >= 300 && resp.StatusCode < 400 {
+		//redirects
+		tourl := resp.Header.Get("Location")
+		return d.Download(tourl, hash, dir)
+	}
+	info, err := metainfo.Load(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("failed to load metainfo: %v", err)
+	}
+	t, err := d.cl.AddTorrent(info)
+	if err != nil {
+		return nil, fmt.Errorf("failed to add torrent: %v", err)
+	}
+	<-t.GotInfo()
+	return &Torrent{
+		t:    t,
+		cl:   d.cl,
+		hash: hash,
+		dir:  d.dir,
+	}, nil
+}
+
+func NewTorrentFromHash(hash string, downloadDir string) (*Torrent, error) {
+	cl, err := NewDownloader(downloadDir)
+	if err != nil {
+		return nil, errors.Wrap(err, "create downloader")
+	}
+	ttt := cl.cl.Torrents()
+	log.Infof("all torrents: %+v", ttt)
+	t, _ := cl.cl.AddTorrentInfoHash(metainfo.NewHashFromHex(hash))
+	// if new {
+	// 	return nil, fmt.Errorf("torrent not found")
+	// }
+	<-t.GotInfo()
+	return &Torrent{
+		t:    t,
+		cl:   cl.cl,
+		hash: hash,
+		dir:  downloadDir,
+	}, nil
+}
+
+type Torrent struct {
+	t    *torrent.Torrent
+	cl   *torrent.Client
+	hash string
+	dir  string
+}
+
+func (t *Torrent) Name() (string, error) {
+	return t.t.Name(), nil
+}
+
+func (t *Torrent) TotalSize() int64 {
+	var c int64
+	for _, f := range t.t.Files() {
+		c += f.FileInfo().Length
+	}
+	return c
+}
+
+func (t *Torrent) Progress() (int, error) {
+	if t.t.Complete().Bool() {
+		return 100, nil
+	}
+	p := int(t.t.BytesCompleted() * 100 / t.TotalSize())
+	if p >= 100 {
+		p = 99
+	}
+	return 99, nil
+}
+
+func (t *Torrent) Stop() error {
+	return nil
+}
+
+func (t *Torrent) Start() error {
+	<-t.t.GotInfo()
+	t.t.DownloadAll()
+	return nil
+}
+
+func (t *Torrent) Remove() error {
+	files := t.t.Files()
+	for _, file := range files {
+		name := file.Path()
+		if err := os.RemoveAll(filepath.Join(t.dir, name)); err != nil {
+			return errors.Errorf("remove file (%s) error: %v", file.Path(), err)
+		}
+	}
+	t.t.Drop()
+	return nil
+}
+
+func (t *Torrent) Exists() bool {
+	tors := t.cl.Torrents()
+	for _, to := range tors {
+		if to.InfoHash().HexString() == t.hash {
+			return true
+		}
+	}
+	return false
+}
+
+func (t *Torrent) SeedRatio() (float64, error) {
+	return 0, nil
+}
+
+func (t *Torrent) GetHash() string {
+	return t.hash
+}
+
+func (t *Torrent) WalkFunc() func(fn func(path string, info fs.FileInfo) error) error {
+	files := t.t.Files()
+
+	return func(fn func(path string, info fs.FileInfo) error) error {
+		for _, file := range files {
+			name := filepath.Join(t.dir, file.Path())
+			info, err := os.Stat(name)
+			if err != nil {
+				return err
+			}
+
+			if err := fn(name, info); err != nil {
+				return errors.Errorf("proccess file (%s) error: %v", file.Path(), err)
+			}
+		}
+		return nil
+
+	}
+}

pkg/cfg/config.go

@@ -17,7 +17,7 @@ type TMDB struct {
 
 func LoadConfig() (*Config, error) {
 	viper.SetConfigName("config") // name of config file (without extension)
-	viper.SetConfigType("yml")   // REQUIRED if the config file does not have the extension in the name
+	viper.SetConfigType("yml")    // REQUIRED if the config file does not have the extension in the name
 	viper.AddConfigPath(".")
 	viper.AddConfigPath("/app/data")
 

pkg/doc.go

@@ -1,17 +1,22 @@
 package pkg
 
+import "io/fs"
+
 type Torrent interface {
 	Name() (string, error)
 	Progress() (int, error)
 	Stop() error
 	Start() error
 	Remove() error
-	Save() string
+	//Save() string
 	Exists() bool
 	SeedRatio() (float64, error)
+	GetHash() string
+	//Reload() error
+	WalkFunc() func(fn func(path string, info fs.FileInfo) error) error
 }
 
-
-type Storage interface {
-
-}
+type Downloader interface {
+	GetAll() ([]Torrent, error)
+	Download(link, hash, dir string) (Torrent, error)
+}

pkg/eventbus/eventbus.go

@@ -0,0 +1,83 @@
+package eventbus
+
+import (
+	"fmt"
+	"polaris/pkg/utils"
+	"reflect"
+)
+
+type EventBus struct {
+	handlers utils.Map[string, []EventHandler]
+}
+
+type EventHandler struct {
+	callback     reflect.Value
+	async bool
+}
+
+func New() *EventBus {
+	return &EventBus{
+		handlers: utils.Map[string, []EventHandler]{},
+	}
+}
+
+func (e *EventBus) Subscribe(event string, fn any) error{
+	if reflect.TypeOf(fn).Kind() != reflect.Func {
+		return fmt.Errorf("handler must be a function: %v", reflect.TypeOf(fn).Kind())
+	}
+	if handlers, ok := e.handlers.Load(event); ok {
+		handlers = append(handlers, EventHandler{
+			callback: reflect.ValueOf(fn),})
+		e.handlers.Store(event, handlers)
+	} else {
+		e.handlers.Store(event, []EventHandler{
+			{callback: reflect.ValueOf(fn)},
+		})
+	}
+	return nil
+}
+
+func (e *EventBus) SubscribeAsync(event string, fn any) error{
+	if reflect.TypeOf(fn).Kind() != reflect.Func {
+		return fmt.Errorf("handler must be a function: %v", reflect.TypeOf(fn).Kind())
+	}
+
+	if handlers, ok := e.handlers.Load(event); ok {
+		handlers = append(handlers, EventHandler{
+			callback: reflect.ValueOf(fn), async: true,
+		})
+		e.handlers.Store(event, handlers)
+	} else {
+		e.handlers.Store(event, []EventHandler{
+			{callback: reflect.ValueOf(fn), async: true},
+		})
+	}
+	return nil
+}
+
+func (e *EventBus) Publish(event string, args... any) {
+	if handlers, ok := e.handlers.Load(event); ok {
+		for _, handler := range handlers {
+			args1 := reflectArgs(handler,args...)
+			if handler.async {
+				go handler.callback.Call(args1)
+			} else {
+				handler.callback.Call(args1)
+			}
+		}
+	}
+}
+
+func reflectArgs(handler EventHandler,args... any) []reflect.Value {
+	funcType := handler.callback.Type()
+	passedArguments := make([]reflect.Value, len(args))
+	for i, v := range args {
+		if v == nil {
+			passedArguments[i] = reflect.New(funcType.In(i)).Elem()
+		} else {
+			passedArguments[i] = reflect.ValueOf(v)
+		}
+	}
+
+	return passedArguments
+}

pkg/go-qbittorrent/.dockerignore

@@ -0,0 +1,32 @@
+# Include any files or directories that you don't want to be copied to your
+# container here (e.g., local build artifacts, temporary files, etc.).
+#
+# For more help, visit the .dockerignore file reference guide at
+# https://docs.docker.com/engine/reference/builder/#dockerignore-file
+
+**/.DS_Store
+**/.classpath
+**/.dockerignore
+**/.env
+**/.git
+**/.gitignore
+**/.project
+**/.settings
+**/.toolstarget
+**/.vs
+**/.vscode
+**/*.*proj.user
+**/*.dbmdl
+**/*.jfm
+**/bin
+**/charts
+**/docker-compose*
+**/compose*
+**/Dockerfile*
+**/node_modules
+**/npm-debug.log
+**/obj
+**/secrets.dev.yaml
+**/values.dev.yaml
+LICENSE
+README.md

pkg/go-qbittorrent/.gitignore

@@ -0,0 +1 @@
+./main.go

pkg/go-qbittorrent/README.md

@@ -0,0 +1,19 @@
+go-qbittorrent
+==================
+
+Golang wrapper for qBittorrent Web API (for versions above v4.1) forked from [superturkey650](https://github.com/superturkey650/go-qbittorrent) version (only supporting older API version)
+
+This wrapper is based on the methods described in [qBittorrent's Official Web API](https://github.com/qbittorrent/qBittorrent/wiki/WebUI-API-(qBittorrent-4.1)>)
+
+Some methods are only supported in qBittorent's latest version (v4.5 when writing).
+
+It'll be best if you upgrade your client to a latest version.
+
+An example can be found in main.go
+
+Installation
+============
+
+The best way is to install with go get::
+
+    $ go get github.com/simon-ding/go-qbittorrent/qbt

pkg/go-qbittorrent/docs.txt

@@ -0,0 +1,260 @@
+PACKAGE DOCUMENTATION
+
+package qbt
+    import "/Users/me/Repos/go/src/go-qbittorrent/qbt"
+
+
+TYPES
+
+type BasicTorrent struct {
+    AddedOn       int    `json:"added_on"`
+    Category      string `json:"category"`
+    CompletionOn  int64  `json:"completion_on"`
+    Dlspeed       int    `json:"dlspeed"`
+    Eta           int    `json:"eta"`
+    ForceStart    bool   `json:"force_start"`
+    Hash          string `json:"hash"`
+    Name          string `json:"name"`
+    NumComplete   int    `json:"num_complete"`
+    NumIncomplete int    `json:"num_incomplete"`
+    NumLeechs     int    `json:"num_leechs"`
+    NumSeeds      int    `json:"num_seeds"`
+    Priority      int    `json:"priority"`
+    Progress      int    `json:"progress"`
+    Ratio         int    `json:"ratio"`
+    SavePath      string `json:"save_path"`
+    SeqDl         bool   `json:"seq_dl"`
+    Size          int    `json:"size"`
+    State         string `json:"state"`
+    SuperSeeding  bool   `json:"super_seeding"`
+    Upspeed       int    `json:"upspeed"`
+}
+    BasicTorrent holds a basic torrent object from qbittorrent
+
+type Client struct {
+    URL           string
+    Authenticated bool
+    Session       string //replace with session type
+    Jar           http.CookieJar
+    // contains filtered or unexported fields
+}
+    Client creates a connection to qbittorrent and performs requests
+
+func NewClient(url string) *Client
+    NewClient creates a new client connection to qbittorrent
+
+func (c *Client) AddTrackers(infoHash string, trackers string) (*http.Response, error)
+    AddTrackers adds trackers to a specific torrent
+
+func (c *Client) DecreasePriority(infoHashList []string) (*http.Response, error)
+    DecreasePriority decreases the priority of a list of torrents
+
+func (c *Client) DeletePermanently(infoHashList []string) (*http.Response, error)
+    DeletePermanently deletes all files for a list of torrents
+
+func (c *Client) DeleteTemp(infoHashList []string) (*http.Response, error)
+    DeleteTemp deletes the temporary files for a list of torrents
+
+func (c *Client) DownloadFromFile(file string, options map[string]string) (*http.Response, error)
+    DownloadFromFile downloads a torrent from a file
+
+func (c *Client) DownloadFromLink(link string, options map[string]string) (*http.Response, error)
+    DownloadFromLink starts downloading a torrent from a link
+
+func (c *Client) ForceStart(infoHashList []string, value bool) (*http.Response, error)
+    ForceStart force starts a list of torrents
+
+func (c *Client) GetAlternativeSpeedStatus() (status bool, err error)
+    GetAlternativeSpeedStatus gets the alternative speed status of your
+    qbittorrent client
+
+func (c *Client) GetGlobalDownloadLimit() (limit int, err error)
+    GetGlobalDownloadLimit gets the global download limit of your
+    qbittorrent client
+
+func (c *Client) GetGlobalUploadLimit() (limit int, err error)
+    GetGlobalUploadLimit gets the global upload limit of your qbittorrent
+    client
+
+func (c *Client) GetTorrentDownloadLimit(infoHashList []string) (limits map[string]string, err error)
+    GetTorrentDownloadLimit gets the download limit for a list of torrents
+
+func (c *Client) GetTorrentUploadLimit(infoHashList []string) (limits map[string]string, err error)
+    GetTorrentUploadLimit gets the upload limit for a list of torrents
+
+func (c *Client) IncreasePriority(infoHashList []string) (*http.Response, error)
+    IncreasePriority increases the priority of a list of torrents
+
+func (c *Client) Login(username string, password string) (loggedIn bool, err error)
+    Login logs you in to the qbittorrent client
+
+func (c *Client) Logout() (loggedOut bool, err error)
+    Logout logs you out of the qbittorrent client
+
+func (c *Client) Pause(infoHash string) (*http.Response, error)
+    Pause pauses a specific torrent
+
+func (c *Client) PauseAll() (*http.Response, error)
+    PauseAll pauses all torrents
+
+func (c *Client) PauseMultiple(infoHashList []string) (*http.Response, error)
+    PauseMultiple pauses a list of torrents
+
+func (c *Client) Recheck(infoHashList []string) (*http.Response, error)
+    Recheck rechecks a list of torrents
+
+func (c *Client) Resume(infoHash string) (*http.Response, error)
+    Resume resumes a specific torrent
+
+func (c *Client) ResumeAll(infoHashList []string) (*http.Response, error)
+    ResumeAll resumes all torrents
+
+func (c *Client) ResumeMultiple(infoHashList []string) (*http.Response, error)
+    ResumeMultiple resumes a list of torrents
+
+func (c *Client) SetCategory(infoHashList []string, category string) (*http.Response, error)
+    SetCategory sets the category for a list of torrents
+
+func (c *Client) SetFilePriority(infoHash string, fileID string, priority string) (*http.Response, error)
+    SetFilePriority sets the priority for a specific torrent file
+
+func (c *Client) SetGlobalDownloadLimit(limit string) (*http.Response, error)
+    SetGlobalDownloadLimit sets the global download limit of your
+    qbittorrent client
+
+func (c *Client) SetGlobalUploadLimit(limit string) (*http.Response, error)
+    SetGlobalUploadLimit sets the global upload limit of your qbittorrent
+    client
+
+func (c *Client) SetLabel(infoHashList []string, label string) (*http.Response, error)
+    SetLabel sets the labels for a list of torrents
+
+func (c *Client) SetMaxPriority(infoHashList []string) (*http.Response, error)
+    SetMaxPriority sets the max priority for a list of torrents
+
+func (c *Client) SetMinPriority(infoHashList []string) (*http.Response, error)
+    SetMinPriority sets the min priority for a list of torrents
+
+func (c *Client) SetPreferences(params map[string]string) (*http.Response, error)
+    SetPreferences sets the preferences of your qbittorrent client
+
+func (c *Client) SetTorrentDownloadLimit(infoHashList []string, limit string) (*http.Response, error)
+    SetTorrentDownloadLimit sets the download limit for a list of torrents
+
+func (c *Client) SetTorrentUploadLimit(infoHashList []string, limit string) (*http.Response, error)
+    SetTorrentUploadLimit sets the upload limit of a list of torrents
+
+func (c *Client) Shutdown() (shuttingDown bool, err error)
+    Shutdown shuts down the qbittorrent client
+
+func (c *Client) Sync(rid string) (Sync, error)
+    Sync syncs main data of qbittorrent
+
+func (c *Client) ToggleAlternativeSpeed() (*http.Response, error)
+    ToggleAlternativeSpeed toggles the alternative speed of your qbittorrent
+    client
+
+func (c *Client) ToggleFirstLastPiecePriority(infoHashList []string) (*http.Response, error)
+    ToggleFirstLastPiecePriority toggles first last piece priority of a list
+    of torrents
+
+func (c *Client) ToggleSequentialDownload(infoHashList []string) (*http.Response, error)
+    ToggleSequentialDownload toggles the download sequence of a list of
+    torrents
+
+func (c *Client) Torrent(infoHash string) (Torrent, error)
+    Torrent gets a specific torrent
+
+func (c *Client) TorrentFiles(infoHash string) ([]TorrentFile, error)
+    TorrentFiles gets the files of a specifc torrent
+
+func (c *Client) TorrentTrackers(infoHash string) ([]Tracker, error)
+    TorrentTrackers gets all trackers for a specific torrent
+
+func (c *Client) TorrentWebSeeds(infoHash string) ([]WebSeed, error)
+    TorrentWebSeeds gets seeders for a specific torrent
+
+func (c *Client) Torrents(filters map[string]string) (torrentList []BasicTorrent, err error)
+    Torrents gets a list of all torrents in qbittorrent matching your filter
+
+type Sync struct {
+    Categories  []string `json:"categories"`
+    FullUpdate  bool     `json:"full_update"`
+    Rid         int      `json:"rid"`
+    ServerState struct {
+        ConnectionStatus  string `json:"connection_status"`
+        DhtNodes          int    `json:"dht_nodes"`
+        DlInfoData        int    `json:"dl_info_data"`
+        DlInfoSpeed       int    `json:"dl_info_speed"`
+        DlRateLimit       int    `json:"dl_rate_limit"`
+        Queueing          bool   `json:"queueing"`
+        RefreshInterval   int    `json:"refresh_interval"`
+        UpInfoData        int    `json:"up_info_data"`
+        UpInfoSpeed       int    `json:"up_info_speed"`
+        UpRateLimit       int    `json:"up_rate_limit"`
+        UseAltSpeedLimits bool   `json:"use_alt_speed_limits"`
+    } `json:"server_state"`
+    Torrents map[string]Torrent `json:"torrents"`
+}
+    Sync holds the sync response struct
+
+type Torrent struct {
+    AdditionDate           int     `json:"addition_date"`
+    Comment                string  `json:"comment"`
+    CompletionDate         int     `json:"completion_date"`
+    CreatedBy              string  `json:"created_by"`
+    CreationDate           int     `json:"creation_date"`
+    DlLimit                int     `json:"dl_limit"`
+    DlSpeed                int     `json:"dl_speed"`
+    DlSpeedAvg             int     `json:"dl_speed_avg"`
+    Eta                    int     `json:"eta"`
+    LastSeen               int     `json:"last_seen"`
+    NbConnections          int     `json:"nb_connections"`
+    NbConnectionsLimit     int     `json:"nb_connections_limit"`
+    Peers                  int     `json:"peers"`
+    PeersTotal             int     `json:"peers_total"`
+    PieceSize              int     `json:"piece_size"`
+    PiecesHave             int     `json:"pieces_have"`
+    PiecesNum              int     `json:"pieces_num"`
+    Reannounce             int     `json:"reannounce"`
+    SavePath               string  `json:"save_path"`
+    SeedingTime            int     `json:"seeding_time"`
+    Seeds                  int     `json:"seeds"`
+    SeedsTotal             int     `json:"seeds_total"`
+    ShareRatio             float64 `json:"share_ratio"`
+    TimeElapsed            int     `json:"time_elapsed"`
+    TotalDownloaded        int     `json:"total_downloaded"`
+    TotalDownloadedSession int     `json:"total_downloaded_session"`
+    TotalSize              int     `json:"total_size"`
+    TotalUploaded          int     `json:"total_uploaded"`
+    TotalUploadedSession   int     `json:"total_uploaded_session"`
+    TotalWasted            int     `json:"total_wasted"`
+    UpLimit                int     `json:"up_limit"`
+    UpSpeed                int     `json:"up_speed"`
+    UpSpeedAvg             int     `json:"up_speed_avg"`
+}
+    Torrent holds a torrent object from qbittorrent
+
+type TorrentFile struct {
+    IsSeed   bool   `json:"is_seed"`
+    Name     string `json:"name"`
+    Priority int    `json:"priority"`
+    Progress int    `json:"progress"`
+    Size     int    `json:"size"`
+}
+    TorrentFile holds a torrent file object from qbittorrent
+
+type Tracker struct {
+    Msg      string `json:"msg"`
+    NumPeers int    `json:"num_peers"`
+    Status   string `json:"status"`
+    URL      string `json:"url"`
+}
+    Tracker holds a tracker object from qbittorrent
+
+type WebSeed struct {
+    URL string `json:"url"`
+}
+    WebSeed holds a webseed object from qbittorrent
+
+

pkg/go-qbittorrent/go-qbittorrent.go

@@ -0,0 +1,66 @@
+package qbittorrent
+
+import (
+	"fmt"
+	"polaris/pkg/go-qbittorrent/qbt"
+
+	"github.com/davecgh/go-spew/spew"
+)
+
+func main() {
+	// connect to qbittorrent client
+	qb := qbt.NewClient("http://localhost:8181")
+
+	// login to the client
+	loginOpts := qbt.LoginOptions{
+		Username: "username",
+		Password: "password",
+	}
+	err := qb.Login(loginOpts)
+	if err != nil {
+		fmt.Println(err)
+	}
+
+	// ********************
+	// DOWNLOAD A TORRENT *
+	// ********************
+
+	// were not using any filters so the options map is empty
+	downloadOpts := qbt.DownloadOptions{}
+	// set the path to the file
+	//path := "/Users/me/Downloads/Source.Code.2011.1080p.BluRay.H264.AAC-RARBG-[rarbg.to].torrent"
+	links := []string{"http://rarbg.to/download.php?id=9buc5hp&h=d73&f=Courage.the.Cowardly.Dog.1999.S01.1080p.AMZN.WEBRip.DD2.0.x264-NOGRP%5Brartv%5D-[rarbg.to].torrent"}
+	// download the torrent using the file
+	// the wrapper will handle opening and closing the file for you
+	err = qb.DownloadLinks(links, downloadOpts)
+
+	if err != nil {
+		fmt.Println("[-] Download torrent from link")
+		fmt.Println(err)
+	} else {
+		fmt.Println("[+] Download torrent from link")
+	}
+
+	// ******************
+	// GET ALL TORRENTS *
+	// ******************
+	torrentsOpts := qbt.TorrentsOptions{}
+	filter := "inactive"
+	sort := "name"
+	hash := "d739f78a12b241ba62719b1064701ffbb45498a8"
+	torrentsOpts.Filter = &filter
+	torrentsOpts.Sort = &sort
+	torrentsOpts.Hashes = []string{hash}
+	torrents, err := qb.Torrents(torrentsOpts)
+	if err != nil {
+		fmt.Println("[-] Get torrent list")
+		fmt.Println(err)
+	} else {
+		fmt.Println("[+] Get torrent list")
+		if len(torrents) > 0 {
+			spew.Dump(torrents[0])
+		} else {
+			fmt.Println("No torrents found")
+		}
+	}
+}

pkg/go-qbittorrent/qbt/models.go

@@ -0,0 +1,387 @@
+package qbt
+
+// BasicTorrent holds a basic torrent object from qbittorrent
+type BasicTorrent struct {
+	Category               string `json:"category"`
+	CompletionOn           int64  `json:"completion_on"`
+	Dlspeed                int    `json:"dlspeed"`
+	Eta                    int    `json:"eta"`
+	ForceStart             bool   `json:"force_start"`
+	Hash                   string `json:"hash"`
+	Name                   string `json:"name"`
+	NumComplete            int    `json:"num_complete"`
+	NumIncomplete          int    `json:"num_incomplete"`
+	NumLeechs              int    `json:"num_leechs"`
+	NumSeeds               int    `json:"num_seeds"`
+	Priority               int    `json:"priority"`
+	Progress               int    `json:"progress"`
+	Ratio                  int    `json:"ratio"`
+	SavePath               string `json:"save_path"`
+	SeqDl                  bool   `json:"seq_dl"`
+	Size                   int    `json:"size"`
+	State                  string `json:"state"`
+	SuperSeeding           bool   `json:"super_seeding"`
+	Upspeed                int    `json:"upspeed"`
+	FirstLastPiecePriority bool   `json:"f_l_piece_prio"`
+}
+
+// Torrent holds a torrent object from qbittorrent
+// with more information than BasicTorrent
+type Torrent struct {
+	AdditionDate       int     `json:"addition_date"`
+	Comment            string  `json:"comment"`
+	CompletionDate     int     `json:"completion_date"`
+	CreatedBy          string  `json:"created_by"`
+	CreationDate       int     `json:"creation_date"`
+	DlLimit            int     `json:"dl_limit"`
+	DlSpeed            int     `json:"dl_speed"`
+	DlSpeedAvg         int     `json:"dl_speed_avg"`
+	Eta                int     `json:"eta"`
+	LastSeen           int     `json:"last_seen"`
+	NbConnections      int     `json:"nb_connections"`
+	NbConnectionsLimit int     `json:"nb_connections_limit"`
+	Peers              int     `json:"peers"`
+	PeersTotal         int     `json:"peers_total"`
+	PieceSize          int     `json:"piece_size"`
+	PiecesHave         int     `json:"pieces_have"`
+	PiecesNum          int     `json:"pieces_num"`
+	Reannounce         int     `json:"reannounce"`
+	SavePath           string  `json:"save_path"`
+	SeedingTime        int     `json:"seeding_time"`
+	Seeds              int     `json:"seeds"`
+	SeedsTotal         int     `json:"seeds_total"`
+	ShareRatio         float64 `json:"share_ratio"`
+	TimeElapsed        int     `json:"time_elapsed"`
+	TotalDl            int     `json:"total_downloaded"`
+	TotalDlSession     int     `json:"total_downloaded_session"`
+	TotalSize          int     `json:"total_size"`
+	TotalUl            int     `json:"total_uploaded"`
+	TotalUlSession     int     `json:"total_uploaded_session"`
+	TotalWasted        int     `json:"total_wasted"`
+	UpLimit            int     `json:"up_limit"`
+	UpSpeed            int     `json:"up_speed"`
+	UpSpeedAvg         int     `json:"up_speed_avg"`
+}
+
+type TorrentInfo struct {
+	AddedOn           int64   `json:"added_on"`
+	AmountLeft        int64   `json:"amount_left"`
+	AutoTmm           bool    `json:"auto_tmm"`
+	Availability      int64   `json:"availability"`
+	Category          string  `json:"category"`
+	Completed         int64   `json:"completed"`
+	CompletionOn      int64   `json:"completion_on"`
+	ContentPath       string  `json:"content_path"`
+	DlLimit           int64   `json:"dl_limit"`
+	Dlspeed           int64   `json:"dlspeed"`
+	Downloaded        int64   `json:"downloaded"`
+	DownloadedSession int64   `json:"downloaded_session"`
+	Eta               int64   `json:"eta"`
+	FLPiecePrio       bool    `json:"f_l_piece_prio"`
+	ForceStart        bool    `json:"force_start"`
+	Hash              string  `json:"hash"`
+	LastActivity      int64   `json:"last_activity"`
+	MagnetURI         string  `json:"magnet_uri"`
+	MaxRatio          float64 `json:"max_ratio"`
+	MaxSeedingTime    int64   `json:"max_seeding_time"`
+	Name              string  `json:"name"`
+	NumComplete       int64   `json:"num_complete"`
+	NumIncomplete     int64   `json:"num_incomplete"`
+	NumLeechs         int64   `json:"num_leechs"`
+	NumSeeds          int64   `json:"num_seeds"`
+	Priority          int64   `json:"priority"`
+	Progress          float64 `json:"progress"`
+	Ratio             float64 `json:"ratio"`
+	RatioLimit        int64   `json:"ratio_limit"`
+	SavePath          string  `json:"save_path"`
+	SeedingTimeLimit  int64   `json:"seeding_time_limit"`
+	SeenComplete      int64   `json:"seen_complete"`
+	SeqDl             bool    `json:"seq_dl"`
+	Size              int64   `json:"size"`
+	State             string  `json:"state"`
+	SuperSeeding      bool    `json:"super_seeding"`
+	Tags              string  `json:"tags"`
+	TimeActive        int64   `json:"time_active"`
+	TotalSize         int64   `json:"total_size"`
+	Tracker           string  `json:"tracker"`
+	TrackersCount     int64   `json:"trackers_count"`
+	UpLimit           int64   `json:"up_limit"`
+	Uploaded          int64   `json:"uploaded"`
+	UploadedSession   int64   `json:"uploaded_session"`
+	Upspeed           int64   `json:"upspeed"`
+}
+
+// Tracker holds a tracker object from qbittorrent
+type Tracker struct {
+	Msg           string `json:"msg"`
+	NumPeers      int    `json:"num_peers"`
+	NumSeeds      int    `json:"num_seeds"`
+	NumLeeches    int    `json:"num_leeches"`
+	NumDownloaded int    `json:"num_downloaded"`
+	Tier          int    `json:"tier"`
+	Status        int    `json:"status"`
+	URL           string `json:"url"`
+}
+
+// WebSeed holds a webseed object from qbittorrent
+type WebSeed struct {
+	URL string `json:"url"`
+}
+
+// TorrentFile holds a torrent file object from qbittorrent
+type TorrentFile struct {
+	Index        int     `json:"index"`
+	IsSeed       bool    `json:"is_seed"`
+	Name         string  `json:"name"`
+	Availability float32 `json:"availability"`
+	Priority     int     `json:"priority"`
+	Progress     int     `json:"progress"`
+	Size         int     `json:"size"`
+	PieceRange   []int   `json:"piece_range"`
+}
+
+// Sync holds the sync response struct which contains
+// the server state and a map of infohashes to Torrents
+type Sync struct {
+	Categories  []string `json:"categories"`
+	FullUpdate  bool     `json:"full_update"`
+	Rid         int      `json:"rid"`
+	ServerState struct {
+		ConnectionStatus  string `json:"connection_status"`
+		DhtNodes          int    `json:"dht_nodes"`
+		DlInfoData        int    `json:"dl_info_data"`
+		DlInfoSpeed       int    `json:"dl_info_speed"`
+		DlRateLimit       int    `json:"dl_rate_limit"`
+		Queueing          bool   `json:"queueing"`
+		RefreshInterval   int    `json:"refresh_interval"`
+		UpInfoData        int    `json:"up_info_data"`
+		UpInfoSpeed       int    `json:"up_info_speed"`
+		UpRateLimit       int    `json:"up_rate_limit"`
+		UseAltSpeedLimits bool   `json:"use_alt_speed_limits"`
+	} `json:"server_state"`
+	Torrents map[string]Torrent `json:"torrents"`
+}
+
+type BuildInfo struct {
+	QTVersion         string `json:"qt"`
+	LibtorrentVersion string `json:"libtorrent"`
+	BoostVersion      string `json:"boost"`
+	OpenSSLVersion    string `json:"openssl"`
+	AppBitness        string `json:"bitness"`
+}
+
+type Preferences struct {
+	Locale                             string                 `json:"locale"`
+	CreateSubfolderEnabled             bool                   `json:"create_subfolder_enabled"`
+	StartPausedEnabled                 bool                   `json:"start_paused_enabled"`
+	AutoDeleteMode                     int                    `json:"auto_delete_mode"`
+	PreallocateAll                     bool                   `json:"preallocate_all"`
+	IncompleteFilesExt                 bool                   `json:"incomplete_files_ext"`
+	AutoTMMEnabled                     bool                   `json:"auto_tmm_enabled"`
+	TorrentChangedTMMEnabled           bool                   `json:"torrent_changed_tmm_enabled"`
+	SavePathChangedTMMEnabled          bool                   `json:"save_path_changed_tmm_enabled"`
+	CategoryChangedTMMEnabled          bool                   `json:"category_changed_tmm_enabled"`
+	SavePath                           string                 `json:"save_path"`
+	TempPathEnabled                    bool                   `json:"temp_path_enabled"`
+	TempPath                           string                 `json:"temp_path"`
+	ScanDirs                           map[string]interface{} `json:"scan_dirs"`
+	ExportDir                          string                 `json:"export_dir"`
+	ExportDirFin                       string                 `json:"export_dir_fin"`
+	MailNotificationEnabled            string                 `json:"mail_notification_enabled"`
+	MailNotificationSender             string                 `json:"mail_notification_sender"`
+	MailNotificationEmail              string                 `json:"mail_notification_email"`
+	MailNotificationSMPTP              string                 `json:"mail_notification_smtp"`
+	MailNotificationSSLEnabled         bool                   `json:"mail_notification_ssl_enabled"`
+	MailNotificationAuthEnabled        bool                   `json:"mail_notification_auth_enabled"`
+	MailNotificationUsername           string                 `json:"mail_notification_username"`
+	MailNotificationPassword           string                 `json:"mail_notification_password"`
+	AutorunEnabled                     bool                   `json:"autorun_enabled"`
+	AutorunProgram                     string                 `json:"autorun_program"`
+	QueueingEnabled                    bool                   `json:"queueing_enabled"`
+	MaxActiveDls                       int                    `json:"max_active_downloads"`
+	MaxActiveTorrents                  int                    `json:"max_active_torrents"`
+	MaxActiveUls                       int                    `json:"max_active_uploads"`
+	DontCountSlowTorrents              bool                   `json:"dont_count_slow_torrents"`
+	SlowTorrentDlRateThreshold         int                    `json:"slow_torrent_dl_rate_threshold"`
+	SlowTorrentUlRateThreshold         int                    `json:"slow_torrent_ul_rate_threshold"`
+	SlowTorrentInactiveTimer           int                    `json:"slow_torrent_inactive_timer"`
+	MaxRatioEnabled                    bool                   `json:"max_ratio_enabled"`
+	MaxRatio                           float64                `json:"max_ratio"`
+	MaxRatioAct                        bool                   `json:"max_ratio_act"`
+	ListenPort                         int                    `json:"listen_port"`
+	UPNP                               bool                   `json:"upnp"`
+	RandomPort                         bool                   `json:"random_port"`
+	DlLimit                            int                    `json:"dl_limit"`
+	UlLimit                            int                    `json:"up_limit"`
+	MaxConnections                     int                    `json:"max_connec"`
+	MaxConnectionsPerTorrent           int                    `json:"max_connec_per_torrent"`
+	MaxUls                             int                    `json:"max_uploads"`
+	MaxUlsPerTorrent                   int                    `json:"max_uploads_per_torrent"`
+	UTPEnabled                         bool                   `json:"enable_utp"`
+	LimitUTPRate                       bool                   `json:"limit_utp_rate"`
+	LimitTCPOverhead                   bool                   `json:"limit_tcp_overhead"`
+	LimitLANPeers                      bool                   `json:"limit_lan_peers"`
+	AltDlLimit                         int                    `json:"alt_dl_limit"`
+	AltUlLimit                         int                    `json:"alt_up_limit"`
+	SchedulerEnabled                   bool                   `json:"scheduler_enabled"`
+	ScheduleFromHour                   int                    `json:"schedule_from_hour"`
+	ScheduleFromMin                    int                    `json:"schedule_from_min"`
+	ScheduleToHour                     int                    `json:"schedule_to_hour"`
+	ScheduleToMin                      int                    `json:"schedule_to_min"`
+	SchedulerDays                      int                    `json:"scheduler_days"`
+	DHTEnabled                         bool                   `json:"dht"`
+	DHTSameAsBT                        bool                   `json:"dhtSameAsBT"`
+	DHTPort                            int                    `json:"dht_port"`
+	PexEnabled                         bool                   `json:"pex"`
+	LSDEnabled                         bool                   `json:"lsd"`
+	Encryption                         int                    `json:"encryption"`
+	AnonymousMode                      bool                   `json:"anonymous_mode"`
+	ProxyType                          int                    `json:"proxy_type"`
+	ProxyIP                            string                 `json:"proxy_ip"`
+	ProxyPort                          int                    `json:"proxy_port"`
+	ProxyPeerConnections               bool                   `json:"proxy_peer_connections"`
+	ForceProxy                         bool                   `json:"force_proxy"`
+	ProxyAuthEnabled                   bool                   `json:"proxy_auth_enabled"`
+	ProxyUsername                      string                 `json:"proxy_username"`
+	ProxyPassword                      string                 `json:"proxy_password"`
+	IPFilterEnabled                    bool                   `json:"ip_filter_enabled"`
+	IPFilterPath                       string                 `json:"ip_filter_path"`
+	IPFilterTrackers                   string                 `json:"ip_filter_trackers"`
+	WebUIDomainList                    string                 `json:"web_ui_domain_list"`
+	WebUIAddress                       string                 `json:"web_ui_address"`
+	WebUIPort                          int                    `json:"web_ui_port"`
+	WebUIUPNPEnabled                   bool                   `json:"web_ui_upnp"`
+	WebUIUsername                      string                 `json:"web_ui_username"`
+	WebUIPassword                      string                 `json:"web_ui_password"`
+	WebUICSRFProtectionEnabled         bool                   `json:"web_ui_csrf_protection_enabled"`
+	WebUIClickjackingProtectionEnabled bool                   `json:"web_ui_clickjacking_protection_enabled"`
+	BypassLocalAuth                    bool                   `json:"bypass_local_auth"`
+	BypassAuthSubnetWhitelistEnabled   bool                   `json:"bypass_auth_subnet_whitelist_enabled"`
+	BypassAuthSubnetWhitelist          string                 `json:"bypass_auth_subnet_whitelist"`
+	AltWebUIEnabled                    bool                   `json:"alternative_webui_enabled"`
+	AltWebUIPath                       string                 `json:"alternative_webui_path"`
+	UseHTTPS                           bool                   `json:"use_https"`
+	SSLKey                             string                 `json:"ssl_key"`
+	SSLCert                            string                 `json:"ssl_cert"`
+	DynDNSEnabled                      bool                   `json:"dyndns_enabled"`
+	DynDNSService                      int                    `json:"dyndns_service"`
+	DynDNSUsername                     string                 `json:"dyndns_username"`
+	DynDNSPassword                     string                 `json:"dyndns_password"`
+	DynDNSDomain                       string                 `json:"dyndns_domain"`
+	RSSRefreshInterval                 int                    `json:"rss_refresh_interval"`
+	RSSMaxArtPerFeed                   int                    `json:"rss_max_articles_per_feed"`
+	RSSProcessingEnabled               bool                   `json:"rss_processing_enabled"`
+	RSSAutoDlEnabled                   bool                   `json:"rss_auto_downloading_enabled"`
+}
+
+// Log
+type Log struct {
+	ID        int    `json:"id"`
+	Message   string `json:"message"`
+	Timestamp int    `json:"timestamp"`
+	Type      int    `json:"type"`
+}
+
+// PeerLog
+type PeerLog struct {
+	ID        int    `json:"id"`
+	IP        string `json:"ip"`
+	Blocked   bool   `json:"blocked"`
+	Timestamp int    `json:"timestamp"`
+	Reason    string `json:"reason"`
+}
+
+// Info
+type Info struct {
+	ConnectionStatus  string `json:"connection_status"`
+	DHTNodes          int    `json:"dht_nodes"`
+	DlInfoData        int    `json:"dl_info_data"`
+	DlInfoSpeed       int    `json:"dl_info_speed"`
+	DlRateLimit       int    `json:"dl_rate_limit"`
+	UlInfoData        int    `json:"up_info_data"`
+	UlInfoSpeed       int    `json:"up_info_speed"`
+	UlRateLimit       int    `json:"up_rate_limit"`
+	Queueing          bool   `json:"queueing"`
+	UseAltSpeedLimits bool   `json:"use_alt_speed_limits"`
+	RefreshInterval   int    `json:"refresh_interval"`
+}
+
+type TorrentsOptions struct {
+	Filter   *string  // all, downloading, completed, paused, active, inactive => optional
+	Category *string  // => optional
+	Sort     *string  // => optional
+	Reverse  *bool    // => optional
+	Limit    *int     // => optional (no negatives)
+	Offset   *int     // => optional (negatives allowed)
+	Hashes   []string // separated by | => optional
+}
+
+// Category of torrent
+type Category struct {
+	Name     string `json:"name"`
+	SavePath string `json:"savePath"`
+}
+
+// Categories mapping
+type Categories struct {
+	Category map[string]Category
+}
+
+// LoginOptions contains all options for /login endpoint
+type LoginOptions struct {
+	Username string
+	Password string
+}
+
+// AddTrackersOptions contains all options for /addTrackers endpoint
+type AddTrackersOptions struct {
+	Hash     string
+	Trackers []string
+}
+
+// EditTrackerOptions contains all options for /editTracker endpoint
+type EditTrackerOptions struct {
+	Hash    string
+	OrigURL string
+	NewURL  string
+}
+
+// RemoveTrackersOptions contains all options for /removeTrackers endpoint
+type RemoveTrackersOptions struct {
+	Hash     string
+	Trackers []string
+}
+
+type DownloadOptions struct {
+	Savepath                   *string
+	Cookie                     *string
+	Category                   *string
+	SkipHashChecking           *bool
+	Paused                     *bool
+	RootFolder                 *bool
+	Rename                     *string
+	UploadSpeedLimit           *int
+	DownloadSpeedLimit         *int
+	SequentialDownload         *bool
+	AutomaticTorrentManagement *bool
+	FirstLastPiecePriority     *bool
+}
+
+type InfoOptions struct {
+	Filter   *string
+	Category *string
+	Sort     *string
+	Reverse  *bool
+	Limit    *int
+	Offset   *int
+	Hashes   []string
+}
+
+type PriorityValues int
+
+const (
+	Do_not_download  PriorityValues = 0
+	Normal_priority  PriorityValues = 1
+	High_priority    PriorityValues = 6
+	Maximal_priority PriorityValues = 7
+)

pkg/go-qbittorrent/tools/tools.go

@@ -0,0 +1,24 @@
+package tools
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"net/http/httputil"
+)
+
+// PrintResponse prints the body of a response
+func PrintResponse(body io.ReadCloser) {
+	r, _ := io.ReadAll(body)
+	fmt.Println("response: " + string(r))
+}
+
+// PrintRequest prints a request
+func PrintRequest(req *http.Request) error {
+	r, err := httputil.DumpRequest(req, true)
+	if err != nil {
+		return err
+	}
+	fmt.Println("request: " + string(r))
+	return nil
+}

pkg/importlist/douban/douban.go

@@ -2,29 +2,25 @@ package douban
 
 import (
 	"fmt"
+	"io"
 	"net/http"
 	"polaris/log"
 	"polaris/pkg/importlist"
 	"strconv"
 	"strings"
+	"time"
 
 	"github.com/PuerkitoBio/goquery"
+	"github.com/gocolly/colly"
 )
 
-const ua = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36"
+const ua = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36"
 
 func ParseDoulist(doulistUrl string) (*importlist.Response, error) {
 	if !strings.Contains(doulistUrl, "doulist") {
 		return nil, fmt.Errorf("not doulist")
 	}
-
-	req, err := http.NewRequest("GET", doulistUrl, nil)
-	if err != nil {
-		return nil, err
-	}
-	req.Header.Set("User-Agent", ua)
-
-	res, err := http.DefaultClient.Do(req)
+	res, err := doHttpReq("GET", doulistUrl, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -37,6 +33,7 @@ func ParseDoulist(doulistUrl string) (*importlist.Response, error) {
 	if err != nil {
 		return nil, err
 	}
+	var items []importlist.Item
 	doc.Find("div[class=doulist-item]").Each(func(i int, selection *goquery.Selection) {
 		titleDiv := selection.Find("div[class=title]")
 		link := titleDiv.Find("div>a")
@@ -64,25 +61,28 @@ func ParseDoulist(doulistUrl string) (*importlist.Response, error) {
 				}
 			}
 		}
+		_, err := parseDetailPage(strings.TrimSpace(href))
+		if err != nil {
+			log.Errorf("get detail page: %v", err)
+			return
+		}
 
 		item := importlist.Item{
 			Title: strings.TrimSpace(link.Text()),
 			Year:  year,
 		}
+		items = append(items, item)
 		_ = item
-		println(link.Text(), href)
+		//println(link.Text(), href)
 	})
-	return nil, nil
+
+	return &importlist.Response{Items: items}, nil
 }
 
 func parseDetailPage(url string) (string, error) {
-	req, err := http.NewRequest("GET", url, nil)
-	if err != nil {
-		return "", err
-	}
-	req.Header.Set("User-Agent", ua)
+	println(url)
 
-	res, err := http.DefaultClient.Do(req)
+	res, err := doHttpReq("GET", url, nil)
 	if err != nil {
 		return "", err
 	}
@@ -95,6 +95,91 @@ func parseDetailPage(url string) (string, error) {
 	if err != nil {
 		return "", err
 	}
+
+	doc.Find("div[class='subject clearfix']").Each(func(i int, se *goquery.Selection) {
+		println(se.Text())
+		se.Children().Get(1)
+		imdb := se.Find("div[class='info']").First().Children().Last()
+		println(imdb.Text())
+	})
+
 	_ = doc
 	return "", nil
 }
+func NewDoubanWishlist(personId string) *DoubanWishlist {
+	return &DoubanWishlist{PersonId: personId}
+}
+
+type DoubanWishlist struct {
+	PersonId string
+}
+
+const wishlistUrl = "https://movie.douban.com/people/%s/wish?sort=time&start=%d&mode=grid&tags_sort=count"
+
+func (d *DoubanWishlist) GetWishlist(page int) (*importlist.Response, error) {
+	c := colly.NewCollector(colly.UserAgent(ua))
+	c.Limit(&colly.LimitRule{
+		DomainRegexp: "*",
+		Delay:       10 * time.Second,
+		RandomDelay: 2 * time.Second,
+	})
+	url := fmt.Sprintf(wishlistUrl, d.PersonId, (page-1)*15)
+	c.OnHTML("div[class='item comment-item']", func(e *colly.HTMLElement) {
+		if !strings.HasPrefix(e.Request.URL.String(), "https://movie.douban.com/people") {
+			return
+		}
+		e.DOM.Find("div[class='pic'] a[title]").Each(func(i int, selection *goquery.Selection) {
+			println(selection.Attr("href"))
+			url, ok := selection.Attr("href")
+			if ok {
+				c.Visit(url)
+			}
+		})
+	})
+
+	c.OnHTML("#content", func(h *colly.HTMLElement) {
+		var item importlist.Item
+		h.DOM.Find("h1").Each(func(i int, selection *goquery.Selection) {
+			selection.Find("span[property]").Each(func(i int, selection *goquery.Selection) {
+				println(selection.Text())
+				item.Title = selection.Text()
+			})
+			selection.Find("span[class='year']").Each(func(i int, selection *goquery.Selection) {
+				n, _ := strconv.Atoi(selection.Text())
+				item.Year = n
+			})
+
+		})
+		h.DOM.Find("#info").Each(func(i int, s *goquery.Selection) {
+			info := strings.TrimSpace(s.Text()) 
+			lines := strings.Split(info, "\n")
+			if len(lines) == 0 {
+				return
+			}
+			last := lines[len(lines)-1]
+			if !strings.HasPrefix(strings.ToLower(last), "imdb") {
+				return
+			}
+			ss := strings.Split(last, ":")
+			for _, p := range ss {
+				p := strings.TrimSpace(strings.ToLower(p))
+				if strings.HasPrefix(p, "tt") {
+					item.ImdbID = p
+				}
+			}
+		})
+		log.Info(item)
+	})
+
+	return nil, c.Visit(url)
+}
+
+func doHttpReq(method, url string, body io.Reader) (*http.Response, error) {
+
+	req, err := http.NewRequest(method, url, body)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("User-Agent", ua)
+	return http.DefaultClient.Do(req)
+}

pkg/importlist/douban/douban_test.go

@@ -6,6 +6,13 @@ import (
 )
 
 func TestParseDoulist(t *testing.T) {
-	r, err := ParseDoulist("https://www.douban.com/doulist/166422/")
+	r, err := ParseDoulist("https://www.douban.com/doulist/81580/")
 	log.Info(r, err)
 }
+
+
+func Test111(t *testing.T) {
+	d := NewDoubanWishlist("69894889")
+	_, err := d.GetWishlist(1)
+	log.Infof("err: %v", err)
+}

pkg/metadata/movie.go

@@ -2,6 +2,7 @@ package metadata
 
 import (
 	"fmt"
+	"polaris/pkg/utils"
 	"regexp"
 	"strconv"
 	"strings"
@@ -14,6 +15,26 @@ type MovieMetadata struct {
 	IsQingban  bool
 }
 
+func (m *MovieMetadata) IsAcceptable(names... string) bool {
+	for _, name := range names {
+		re := regexp.MustCompile(`[^\p{L}\w\s]`)
+		name = re.ReplaceAllString(strings.ToLower(name), " ")
+		name2 := re.ReplaceAllString(strings.ToLower(m.Name), " ")
+		name = strings.Join(strings.Fields(name), " ")
+		name2 = strings.Join(strings.Fields(name2), " ")
+		if utils.IsASCII(name) { //ascii name should match words
+			re := regexp.MustCompile(`\b` + name + `\b`)
+			return re.MatchString(name2)
+		}
+		
+		if  strings.Contains(name2, name) {
+			return true
+		}
+	}
+	return false
+}
+
+
 func ParseMovie(name string) *MovieMetadata {
 	name = strings.Join(strings.Fields(name), " ") //remove unnessary spaces
 	name = strings.ToLower(strings.TrimSpace(name))

pkg/metadata/tv.go

@@ -7,219 +7,104 @@ import (
 	"regexp"
 	"strconv"
 	"strings"
+	"time"
 )
 
-type Metadata struct {
+type Info struct {
 	NameEn       string
 	NameCn       string
+	Year         int
 	Season       int
-	Episode      int
+	StartEpisode int
+	EndEpisode   int
 	Resolution   string
 	IsSeasonPack bool
 }
 
-func ParseTv(name string) *Metadata {
+func (m *Info) ParseExtraDescription(desc string) {
+	if m.IsSeasonPack { //try to parse episode number with description
+		mm := ParseTv(desc)
+		if mm.StartEpisode > 0 { //sometimes they put episode info in desc text
+			m.IsSeasonPack = false
+			m.StartEpisode = mm.StartEpisode
+			m.EndEpisode = mm.EndEpisode
+		}
+	}
+}
+
+func (m *Info) IsAcceptable(names ...string) bool {
+	re := regexp.MustCompile(`[^\p{L}\w\s]`)
+
+	nameCN := re.ReplaceAllString(strings.ToLower(m.NameCn), " ")
+	nameEN := re.ReplaceAllString(strings.ToLower(m.NameEn), " ")
+	nameCN = strings.Join(strings.Fields(nameCN), " ")
+	nameEN = strings.Join(strings.Fields(nameEN), " ")
+
+	for _, name := range names {
+		name = re.ReplaceAllString(strings.ToLower(name), " ")
+		name = strings.Join(strings.Fields(name), " ")
+		if utils.IsASCII(name) { //ascii name should match words
+			re := regexp.MustCompile(`\b` + name + `\b`)
+			if re.MatchString(nameCN) || re.MatchString(nameEN) {
+				return true
+			} else {
+				continue
+			}
+		}
+
+		if strings.Contains(nameCN, name) || strings.Contains(nameEN, name) {
+			return true
+		}
+
+	}
+	return false
+}
+
+func ParseTv(name string) *Info {
 	name = strings.ToLower(name)
 	name = strings.ReplaceAll(name, "\u200b", "") //remove unicode hidden character
-	if utils.ContainsChineseChar(name) {
-		return parseChineseName(name)
-	}
-	return parseEnglishName(name)
+
+	return parseName(name)
 }
 
-func parseEnglishName(name string) *Metadata {
-	re := regexp.MustCompile(`[^\p{L}\w\s]`)
-	name = re.ReplaceAllString(strings.ToLower(name), " ")
-	newSplits := strings.Split(strings.TrimSpace(name), " ")
-
-	seasonRe := regexp.MustCompile(`^s\d{1,2}`)
-	resRe := regexp.MustCompile(`^\d{3,4}p`)
-	episodeRe := regexp.MustCompile(`e\d{1,3}`)
-
-	var seasonIndex = -1
-	var episodeIndex = -1
-	var resIndex = -1
-	for i, p := range newSplits {
-		p = strings.TrimSpace(p)
-		if p == "" {
-			continue
-		}
-		if seasonRe.MatchString(p) {
-			//season part
-			seasonIndex = i
-		} else if resRe.MatchString(p) {
-			resIndex = i
-		}
-		if i >= seasonIndex && episodeRe.MatchString(p) {
-			episodeIndex = i
+func adjacentNumber(s string, start int) (n1 int, l int) {
+	runes := []rune(s)
+	if start > len(runes)-1 { //out of bound
+		return -1, -1
+	}
+	var n []rune
+	for i := start; i < len(runes); i++ {
+		k := runes[i]
+		if (k < '0' || k > '9') && !chineseNum[k] { //not digit anymore
+			break
 		}
+		n = append(n, k)
 	}
-
-	meta := &Metadata{
-		Season:  -1,
-		Episode: -1,
+	if len(n) == 0 {
+		return -1, -1
 	}
-	if seasonIndex != -1 {
-		//season exists
-		ss := seasonRe.FindAllString(newSplits[seasonIndex], -1)
-		if len(ss) != 0 {
-			//season info
-
-			ssNum := strings.TrimLeft(ss[0], "s")
-			n, err := strconv.Atoi(ssNum)
-			if err != nil {
-				panic(fmt.Sprintf("convert %s error: %v", ssNum, err))
-			}
-			meta.Season = n
-		}
-	} else { //maybe like Season 1?
-		seasonRe := regexp.MustCompile(`season \d{1,2}`)
-		matches := seasonRe.FindAllString(name, -1)
-		if len(matches) > 0 {
-			for i, s := range newSplits {
-				if s == "season" {
-					seasonIndex = i
-				}
-			}
-			numRe := regexp.MustCompile(`\d{1,2}`)
-			seNum := numRe.FindAllString(matches[0], -1)[0]
-			n, err := strconv.Atoi(seNum)
-			if err != nil {
-				panic(fmt.Sprintf("convert %s error: %v", seNum, err))
-			}
-			meta.Season = n
-
-		}
+	m, err := strconv.Atoi(string(n))
+	if err != nil {
+		return chinese2Num[string(n)], len(n)
 	}
-	if episodeIndex != -1 {
-		ep := episodeRe.FindAllString(newSplits[episodeIndex], -1)
-		if len(ep) > 0 {
-			//episode info exists
-			epNum := strings.TrimLeft(ep[0], "e")
-			n, err := strconv.Atoi(epNum)
-			if err != nil {
-				panic(fmt.Sprintf("convert %s error: %v", epNum, err))
-			}
-			meta.Episode = n
-		}
-	} else { //no episode, maybe like  One Punch Man S2 - 08 [1080p].mkv
-
-		// numRe := regexp.MustCompile(`^\d{1,2}$`)
-		// for i, p := range newSplits {
-		// 	if numRe.MatchString(p) {
-		// 		if i > 0 && strings.Contains(newSplits[i-1], "season") { //last word cannot be season
-		// 			continue
-		// 		}
-		// 		if i < seasonIndex {
-		// 			//episode number most likely  should comes alfter season number
-		// 			continue
-		// 		}
-		// 		//episodeIndex = i
-		// 		n, err := strconv.Atoi(p)
-		// 		if err != nil {
-		// 			panic(fmt.Sprintf("convert %s error: %v", p, err))
-		// 		}
-		// 		meta.Episode = n
-
-		// 	}
-		// }
-
-	}
-	if resIndex != -1 {
-		//resolution exists
-		meta.Resolution = newSplits[resIndex]
-	}
-	if meta.Episode == -1 {
-		meta.Episode = -1
-		meta.IsSeasonPack = true
-	}
-
-	if seasonIndex > 0 {
-		//name exists
-		names := newSplits[0:seasonIndex]
-		meta.NameEn = strings.TrimSpace(strings.Join(names, " "))
-	} else {
-		meta.NameEn = name
-	}
-
-	return meta
+	return m, len(n)
 }
 
-func parseChineseName(name string) *Metadata {
-	var meta = parseEnglishName(name)
-	if meta.Season != -1 && (meta.Episode != -1 || meta.IsSeasonPack) {
-		return meta
-	}
-	meta = &Metadata{Season: 1}
-	//season pack
-	packRe := regexp.MustCompile(`(\d{1,2}-\d{1,2})|(全集)`)
-	if packRe.MatchString(name) {
-		meta.IsSeasonPack = true
-	}
-	//resolution
-	resRe := regexp.MustCompile(`\d{3,4}p`)
-	resMatches := resRe.FindAllString(name, -1)
-	if len(resMatches) != 0 {
-		meta.Resolution = resMatches[0]
-	} else {
-		if strings.Contains(name, "720") {
-			meta.Resolution = "720p"
-		} else if strings.Contains(name, "1080") {
-			meta.Resolution = "1080p"
-		}
-
-	}
-
-	//episode number
-	re1 := regexp.MustCompile(`\[\d{1,3}\]`)
-	episodeMatches1 := re1.FindAllString(name, -1)
-	if len(episodeMatches1) > 0 { //[11] [1080p]
-		epNum := strings.TrimRight(strings.TrimLeft(episodeMatches1[0], "["), "]")
-		n, err := strconv.Atoi(epNum)
-		if err != nil {
-			panic(fmt.Sprintf("convert %s error: %v", epNum, err))
-		}
-		meta.Episode = n
-	} else { //【第09話】
-		re2 := regexp.MustCompile(`第\d{1,4}(话|話|集)`)
-		episodeMatches1 := re2.FindAllString(name, -1)
-		if len(episodeMatches1) > 0 {
-			re := regexp.MustCompile(`\d{1,4}`)
-			epNum := re.FindAllString(episodeMatches1[0], -1)[0]
-			n, err := strconv.Atoi(epNum)
-			if err != nil {
-				panic(fmt.Sprintf("convert %s error: %v", epNum, err))
-			}
-			meta.Episode = n
-		} else { //SHY 靦腆英雄 / Shy -05 ( CR 1920x1080 AVC AAC MKV)
-			re3 := regexp.MustCompile(`[^\d\w]\d{1,2}[^\d\w]`)
-			epNums := re3.FindAllString(name, -1)
-			if len(epNums) > 0 {
-
-				re3 := regexp.MustCompile(`\d{1,2}`)
-				epNum := re3.FindAllString(epNums[0], -1)[0]
-				n, err := strconv.Atoi(epNum)
-				if err != nil {
-					panic(fmt.Sprintf("convert %s error: %v", epNum, err))
-				}
-				meta.Episode = n
-			}
-		}
-	}
-
+func findSeason(s string) (n int, p int) {
 	//season numner
 	seasonRe1 := regexp.MustCompile(`s\d{1,2}`)
-	seasonMatches := seasonRe1.FindAllString(name, -1)
+	seasonMatches := seasonRe1.FindAllString(s, -1)
 	if len(seasonMatches) > 0 {
 		seNum := seasonMatches[0][1:]
 		n, err := strconv.Atoi(seNum)
 		if err != nil {
 			panic(fmt.Sprintf("convert %s error: %v", seNum, err))
 		}
-		meta.Season = n
+
+		return n, strings.Index(s, seNum)
 	} else {
 		seasonRe1 := regexp.MustCompile(`season \d{1,2}`)
-		seasonMatches := seasonRe1.FindAllString(name, -1)
+		seasonMatches := seasonRe1.FindAllString(s, -1)
 		if len(seasonMatches) > 0 {
 			re3 := regexp.MustCompile(`\d{1,2}`)
 			seNum := re3.FindAllString(seasonMatches[0], -1)[0]
@@ -227,10 +112,10 @@ func parseChineseName(name string) *Metadata {
 			if err != nil {
 				panic(fmt.Sprintf("convert %s error: %v", seNum, err))
 			}
-			meta.Season = n
+			return n, strings.Index(s, seasonMatches[0])
 		} else {
 			seasonRe1 := regexp.MustCompile(`第.{1,2}季`)
-			seasonMatches := seasonRe1.FindAllString(name, -1)
+			seasonMatches := seasonRe1.FindAllString(s, -1)
 			if len(seasonMatches) > 0 {
 				m1 := []rune(seasonMatches[0])
 				seNum := m1[1 : len(m1)-1]
@@ -239,58 +124,364 @@ func parseChineseName(name string) *Metadata {
 					log.Warnf("parse season number %v error: %v, try to parse using chinese", seNum, err)
 					n = chinese2Num[string(seNum)]
 				}
-				meta.Season = n
+				return n, strings.Index(s, seasonMatches[0])
+			}
+		}
+	}
+	return -1, -1
+}
 
+func findEpisodes(s string) (start int, end int) {
+	var episodeCn = map[rune]bool{
+		'话': true,
+		'話': true,
+		'集': true,
+	}
+
+	rr := []rune(s)
+	for i := 0; i < len(rr); i++ {
+		r := rr[i]
+		if r == 'e' {
+			n, l := adjacentNumber(s, i+1)
+
+			if n > 0 {
+				foundDash := false
+				for j := i + l + 1; j < len(rr); j++ {
+					r1 := rr[j]
+					if r1 == '-' {
+						foundDash = true
+						continue
+					}
+					if r1 == ' ' || r1 == 'e' {
+						continue
+					}
+
+					if foundDash {
+						if r1 == 's' {
+							s1, l1 := adjacentNumber(s, j+1)
+							if s1 > 0 { //S01E01-S01E21
+								n1, _ := adjacentNumber(s, j+l1+2)
+								if n1 > 0 {
+									return n, n1
+								}
+							}
+						}
+						n1, _ := adjacentNumber(s, j)
+						if n1 > 0 {
+							return n, n1
+						}
+					} else {
+						break
+					}
+				}
+				return n, n
+			}
+		} else if r == '第' {
+			n, l := adjacentNumber(s, i+1)
+			if len(rr) > i+l+1 && episodeCn[rr[i+l+1]] {
+				return n, n
+			} else if len(rr) > i+l+1 {
+				if rr[i+l+1] == '-' {
+					n1, l1 := adjacentNumber(s, i+l+2)
+					if episodeCn[rr[i+l+2+l1]] {
+						return n, n1
+					}
+				}
+			}
+
+		}
+	}
+	//episode number
+	re1 := regexp.MustCompile(`\[\d{1,4}\]`)
+	episodeMatches1 := re1.FindAllString(s, -1)
+	if len(episodeMatches1) > 0 { //[11] [1080p], [2022][113][HEVC][GB][4K]
+		for _, m := range episodeMatches1 {
+			epNum := strings.TrimRight(strings.TrimLeft(m, "["), "]")
+			n, err := strconv.Atoi(epNum)
+			if err != nil {
+				log.Debugf("convert %s error: %v", epNum, err)
+				continue
+			}
+			nowYear := time.Now().Year()
+			if n > nowYear-50 { //high possibility is year number
+				continue
+			}
+			return n, n
+		}
+	} else { //【第09話】
+		re2 := regexp.MustCompile(`第\d{1,4}([话話集])`)
+		episodeMatches1 := re2.FindAllString(s, -1)
+		if len(episodeMatches1) > 0 {
+			re := regexp.MustCompile(`\d{1,4}`)
+			epNum := re.FindAllString(episodeMatches1[0], -1)[0]
+			n, err := strconv.Atoi(epNum)
+			if err != nil {
+				panic(fmt.Sprintf("convert %s error: %v", epNum, err))
+			}
+			return n, n
+		} else { //The Road Season 2 Episode 12 XviD-AFG
+			re3 := regexp.MustCompile(`episode \d{1,4}`)
+			epNums := re3.FindAllString(s, -1)
+			if len(epNums) > 0 {
+				re3 := regexp.MustCompile(`\d{1,4}`)
+				epNum := re3.FindAllString(epNums[0], -1)[0]
+				n, err := strconv.Atoi(epNum)
+				if err != nil {
+					panic(fmt.Sprintf("convert %s error: %v", epNum, err))
+				}
+				return n, n
+
+			} else { //SHY 靦腆英雄 / Shy -05 ( CR 1920x1080 AVC AAC MKV)
+				if maybeSeasonPack(s) { //avoid miss match, season pack not use this rule
+					return -1, -1
+				}
+				re3 := regexp.MustCompile(`[^(season)][^\d\w]\d{1,2}[^\d\w]`)
+				epNums := re3.FindAllString(s, -1)
+				if len(epNums) > 0 {
+
+					re3 := regexp.MustCompile(`\d{1,2}`)
+					epNum := re3.FindAllString(epNums[0], -1)[0]
+					n, err := strconv.Atoi(epNum)
+					if err != nil {
+						panic(fmt.Sprintf("convert %s error: %v", epNum, err))
+					}
+					return n, n
+				}
 			}
 		}
 	}
 
-	if meta.IsSeasonPack && meta.Episode != 0 {
-		meta.Season = meta.Episode
-		meta.Episode = -1
+	return -1, -1
+}
+
+func matchResolution(s string) string {
+	//resolution
+	resRe := regexp.MustCompile(`\d{3,4}p`)
+	resMatches := resRe.FindAllString(s, -1)
+	if len(resMatches) != 0 {
+		return resMatches[0]
+	} else {
+		if strings.Contains(s, "720") {
+			return "720p"
+		} else if strings.Contains(s, "1080") {
+			return "1080p"
+		}
 	}
+	return ""
+}
+
+func maybeSeasonPack(s string) bool {
+	//season pack
+	packRe := regexp.MustCompile(`((\d{1,2}-\d{1,2}))|(complete)|(全集)`)
+	if packRe.MatchString(s) {
+		return true
+	}
+	return false
+}
+
+//func parseEnglishName(name string) *Info {
+//	meta := &Info{
+//		//Season:  -1,
+//		Episode: -1,
+//	}
+//
+//	start, end := findEpisodes(name)
+//	if start > 0 && end > 0 {
+//		meta.Episode = start
+//	}
+//
+//	re := regexp.MustCompile(`[^\p{L}\w\s]`)
+//	name = re.ReplaceAllString(strings.ToLower(name), " ")
+//	newSplits := strings.Split(strings.TrimSpace(name), " ")
+//
+//	seasonRe := regexp.MustCompile(`^s\d{1,2}`)
+//	resRe := regexp.MustCompile(`^\d{3,4}p`)
+//	episodeRe := regexp.MustCompile(`e\d{1,3}`)
+//
+//	var seasonIndex = -1
+//	var episodeIndex = -1
+//	var resIndex = -1
+//	for i, p := range newSplits {
+//		p = strings.TrimSpace(p)
+//		if p == "" {
+//			continue
+//		}
+//		if seasonRe.MatchString(p) {
+//			//season part
+//			seasonIndex = i
+//		} else if resRe.MatchString(p) {
+//			resIndex = i
+//		}
+//		if i >= seasonIndex && episodeRe.MatchString(p) {
+//			episodeIndex = i
+//		}
+//	}
+//
+//	if seasonIndex != -1 {
+//		//season exists
+//		ss := seasonRe.FindAllString(newSplits[seasonIndex], -1)
+//		if len(ss) != 0 {
+//			//season info
+//
+//			ssNum := strings.TrimLeft(ss[0], "s")
+//			n, err := strconv.Atoi(ssNum)
+//			if err != nil {
+//				panic(fmt.Sprintf("convert %s error: %v", ssNum, err))
+//			}
+//			meta.Season = n
+//		}
+//	} else { //maybe like Season 1?
+//		seasonRe := regexp.MustCompile(`season \d{1,2}`)
+//		matches := seasonRe.FindAllString(name, -1)
+//		if len(matches) > 0 {
+//			for i, s := range newSplits {
+//				if s == "season" {
+//					seasonIndex = i
+//				}
+//			}
+//			numRe := regexp.MustCompile(`\d{1,2}`)
+//			seNum := numRe.FindAllString(matches[0], -1)[0]
+//			n, err := strconv.Atoi(seNum)
+//			if err != nil {
+//				panic(fmt.Sprintf("convert %s error: %v", seNum, err))
+//			}
+//			meta.Season = n
+//
+//		}
+//	}
+//
+//	if episodeIndex != -1 {
+//		//	ep := episodeRe.FindAllString(newSplits[episodeIndex], -1)
+//		//if len(ep) > 0 {
+//		//	//episode info exists
+//		//	epNum := strings.TrimLeft(ep[0], "e")
+//		//	n, err := strconv.Atoi(epNum)
+//		//	if err != nil {
+//		//		panic(fmt.Sprintf("convert %s error: %v", epNum, err))
+//		//	}
+//		//	meta.Episode = n
+//		//}
+//	} else { //no episode, maybe like  One Punch Man S2 - 08 [1080p].mkv
+//
+//		// numRe := regexp.MustCompile(`^\d{1,2}$`)
+//		// for i, p := range newSplits {
+//		// 	if numRe.MatchString(p) {
+//		// 		if i > 0 && strings.Contains(newSplits[i-1], "season") { //last word cannot be season
+//		// 			continue
+//		// 		}
+//		// 		if i < seasonIndex {
+//		// 			//episode number most likely  should comes alfter season number
+//		// 			continue
+//		// 		}
+//		// 		//episodeIndex = i
+//		// 		n, err := strconv.Atoi(p)
+//		// 		if err != nil {
+//		// 			panic(fmt.Sprintf("convert %s error: %v", p, err))
+//		// 		}
+//		// 		meta.Episode = n
+//
+//		// 	}
+//		// }
+//
+//	}
+//	if resIndex != -1 {
+//		//resolution exists
+//		meta.Resolution = newSplits[resIndex]
+//	}
+//	if meta.Episode == -1 {
+//		meta.Episode = -1
+//		meta.IsSeasonPack = true
+//	}
+//
+//	if seasonIndex > 0 {
+//		//name exists
+//		names := newSplits[0:seasonIndex]
+//		meta.NameEn = strings.TrimSpace(strings.Join(names, " "))
+//	} else {
+//		meta.NameEn = name
+//	}
+//
+//	return meta
+//}
+
+func parseName(name string) *Info {
+	meta := &Info{Season: 1}
+	if strings.TrimSpace(name) == "" {
+		return meta
+	}
+
+	season, p := findSeason(name)
+	if season == -1 {
+		log.Debugf("not find season info: %s", name)
+		if !utils.IsASCII(name) {
+			season = 1
+		}
+		p = len(name) - 1
+	}
+	meta.Season = season
+
+	start, end := findEpisodes(name)
+	if start > 0 && end > 0 {
+		meta.StartEpisode = start
+		meta.EndEpisode = end
+	} else {
+		meta.IsSeasonPack = true
+	}
+
+	meta.Resolution = matchResolution(name)
+
+	//if meta.IsSeasonPack && meta.Episode != 0 {
+	//	meta.Season = meta.Episode
+	//	meta.Episode = -1
+	//}
 
 	//tv name
-
-	fields := strings.FieldsFunc(name, func(r rune) bool {
-		return r == '[' || r == ']' || r == '【' || r == '】'
-	})
-	titleCn := ""
-	title := ""
-	for _, p := range fields { //寻找匹配的最长的字符串，最有可能是名字
-		if utils.ContainsChineseChar(p) && len([]rune(p)) > len([]rune(titleCn)) { //最长含中文字符串
-			titleCn = p
-		}
-		if len([]rune(p)) > len([]rune(title)) { //最长字符串
-			title = p
-		}
-	}
-	re := regexp.MustCompile(`[^\p{L}\w\s]`)
-	title = re.ReplaceAllString(strings.TrimSpace(strings.ToLower(title)), "") //去除标点符号
-	titleCn = re.ReplaceAllString(strings.TrimSpace(strings.ToLower(titleCn)), "")
-
-	meta.NameCn = titleCn
-	cnRe := regexp.MustCompile(`\p{Han}.*\p{Han}`)
-	cnmatches := cnRe.FindAllString(titleCn, -1)
-
-	//titleCn中最长的中文字符
-	if len(cnmatches) > 0 {
-		for _, t := range cnmatches {
-			if len([]rune(t)) > len([]rune(meta.NameCn)) {
-				meta.NameCn = strings.ToLower(t)
+	if utils.IsASCII(name) && p < len(name) && p-1 > 0 {
+		meta.NameEn = strings.TrimSpace(name[:p-1])
+		meta.NameCn = meta.NameEn
+	} else {
+		fields := strings.FieldsFunc(name, func(r rune) bool {
+			return r == '[' || r == ']' || r == '【' || r == '】'
+		})
+		titleCn := ""
+		title := ""
+		for _, p := range fields { //寻找匹配的最长的字符串，最有可能是名字
+			if utils.ContainsChineseChar(p) && len([]rune(p)) > len([]rune(titleCn)) { //最长含中文字符串
+				titleCn = p
+			}
+			if len([]rune(p)) > len([]rune(title)) { //最长字符串
+				title = p
 			}
 		}
-	}
+		re := regexp.MustCompile(`[^\p{L}\w\s]`)
+		title = re.ReplaceAllString(strings.TrimSpace(strings.ToLower(title)), "") //去除标点符号
+		titleCn = re.ReplaceAllString(strings.TrimSpace(strings.ToLower(titleCn)), "")
 
-	//匹配title中最长拉丁字符串
-	enRe := regexp.MustCompile(`[[:ascii:]]*`)
-	enM := enRe.FindAllString(title, -1)
-	if len(enM) > 0 {
-		for _, t := range enM {
-			if len(t) > len(meta.NameEn) {
-				meta.NameEn = strings.TrimSpace(strings.ToLower(t))
+		meta.NameCn = titleCn
+		cnRe := regexp.MustCompile(`\p{Han}.*\p{Han}`)
+		cnmatches := cnRe.FindAllString(titleCn, -1)
+
+		//titleCn中最长的中文字符
+		if len(cnmatches) > 0 {
+			for _, t := range cnmatches {
+				if len([]rune(t)) > len([]rune(meta.NameCn)) {
+					meta.NameCn = strings.ToLower(t)
+				}
 			}
 		}
+		meta.NameEn = title
+
+		////匹配title中最长拉丁字符串
+		//enRe := regexp.MustCompile(`[[:ascii:]]*`)
+		//enM := enRe.FindAllString(title, -1)
+		//if len(enM) > 0 {
+		//	for _, t := range enM {
+		//		if len(t) > len(meta.NameEn) {
+		//			meta.NameEn = strings.TrimSpace(strings.ToLower(t))
+		//		}
+		//	}
+		//}
+
 	}
 
 	return meta
@@ -307,3 +498,15 @@ var chinese2Num = map[string]int{
 	"八": 8,
 	"九": 9,
 }
+
+var chineseNum = map[rune]bool{
+	'一': true,
+	'二': true,
+	'三': true,
+	'四': true,
+	'五': true,
+	'六': true,
+	'七': true,
+	'八': true,
+	'九': true,
+}