feat: prowlarr refactor and support prowlarr seed ratio

server/core/indexer.go

@@ -0,0 +1,80 @@
+package core
+
+import (
+	"polaris/ent"
+	"polaris/log"
+	"polaris/pkg/prowlarr"
+	"strings"
+
+	"github.com/pkg/errors"
+)
+
+const prowlarrPrefix = "Prowlarr_"
+
+func (c *Client) 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 *Client) 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 *Client) 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
+}

server/core/scheduler.go

@@ -25,6 +25,9 @@ func (c *Client) addSysCron() {
 		if v == "true" {
 			return nil
 		}
+		if err := c.syncProwlarr(); err != nil {
+			log.Warnf("sync prowlarr error: %v", err)
+		}
 		c.downloadAllTvSeries()
 		c.downloadAllMovies()
 		return nil
@@ -224,7 +227,7 @@ func (c *Client) moveCompletedTask(id int) (err1 error) {
 	}
 	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)

server/core/torrent.go

@@ -7,7 +7,6 @@ import (
 	"polaris/ent/media"
 	"polaris/log"
 	"polaris/pkg/metadata"
-	"polaris/pkg/prowlarr"
 	"polaris/pkg/torznab"
 	"slices"
 	"sort"
@@ -86,7 +85,7 @@ func SearchTvSeries(db1 *db.Client, param *SearchParam) ([]torznab.Result, error
 
 	names := names2Query(series.Media)
 
-	res := searchWithTorznab(db1, prowlarr.TV, names...)
+	res := searchWithTorznab(db1, SearchTypeTv, names...)
 
 	var filtered []torznab.Result
 lo:
@@ -248,9 +247,9 @@ func SearchMovie(db1 *db.Client, param *SearchParam) ([]torznab.Result, error) {
 	}
 	names := names2Query(movieDetail.Media)
 
-	res := searchWithTorznab(db1, prowlarr.Movie, names...)
+	res := searchWithTorznab(db1, SearchTypeMovie, names...)
 	if movieDetail.Extras.IsJav() {
-		res1 := searchWithTorznab(db1, prowlarr.Movie, movieDetail.Extras.JavId)
+		res1 := searchWithTorznab(db1, SearchTypeMovie, movieDetail.Extras.JavId)
 		res = append(res, res1...)
 	}
 
@@ -304,21 +303,18 @@ func SearchMovie(db1 *db.Client, param *SearchParam) ([]torznab.Result, error) {
 
 }
 
-func searchWithTorznab(db *db.Client, t prowlarr.ProwlarrSupportType, 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()
 
-	p, err := db.GetProwlarrSetting()
-	if err == nil && !p.Disabled { //prowlarr exists
-		c := prowlarr.New(p.ApiKey, p.URL)
-		all, err := c.GetIndexers(t)
-		if err != nil {
-			log.Warnf("get prowlarr all indexer error: %v", err)
-		} else {
-			allTorznab = append(allTorznab, all...)
-		}
-	}
 	resChan := make(chan []torznab.Result)
 	var wg sync.WaitGroup
 
@@ -326,6 +322,13 @@ func searchWithTorznab(db *db.Client, t prowlarr.ProwlarrSupportType, queries ..
 		if tor.Disabled {
 			continue
 		}
+		if t == SearchTypeTv && !tor.TvSearch {
+			continue
+		}
+		if t == SearchTypeMovie && !tor.MovieSearch {
+			continue
+		}
+
 		for _, q := range queries {
 			wg.Add(1)
 

server/setting.go

@@ -1,14 +1,12 @@
 package server
 
 import (
-	"encoding/json"
 	"fmt"
 	"html/template"
 	"polaris/db"
 	"polaris/ent"
 	"polaris/ent/downloadclients"
 	"polaris/log"
-	"polaris/pkg/prowlarr"
 	"polaris/pkg/qbittorrent"
 	"polaris/pkg/torznab"
 	"polaris/pkg/transmission"
@@ -146,29 +144,25 @@ func (s *Server) AddTorznabInfo(c *gin.Context) (interface{}, error) {
 	utils.TrimFields(&in)
 
 	log.Infof("add indexer settings: %+v", in)
-	setting := db.TorznabSetting{
-		URL:    in.URL,
-		ApiKey: in.ApiKey,
-	}
 
-	data, err := json.Marshal(setting)
-	if err != nil {
-		return nil, errors.Wrap(err, "marshal json")
-	}
 	if in.Priority > 128 {
 		in.Priority = 128
 	}
+	if in.Priority < 1 {
+		in.Priority = 1
+	}
 
 	indexer := ent.Indexers{
 		ID:             in.ID,
 		Name:           in.Name,
 		Implementation: "torznab",
-		Settings:       string(data),
 		Priority:       in.Priority,
 		Disabled:       in.Disabled,
 		SeedRatio:      in.SeedRatio,
+		APIKey:         in.ApiKey,
+		URL:            in.URL,
 	}
-	err = s.db.SaveIndexer(&indexer)
+	err := s.db.SaveIndexer(&indexer)
 	if err != nil {
 		return nil, errors.Wrap(err, "add ")
 	}
@@ -183,12 +177,12 @@ func (s *Server) DeleteTorznabInfo(c *gin.Context) (interface{}, error) {
 	if err != nil {
 		return nil, fmt.Errorf("id is not correct: %v", ids)
 	}
-	s.db.DeleteTorznab(id)
+	s.db.DeleteIndexer(id)
 	return "success", nil
 }
 
 func (s *Server) GetAllIndexers(c *gin.Context) (interface{}, error) {
-	indexers := s.db.GetAllTorznabInfo()
+	indexers := s.db.GetAllIndexers()
 	if len(indexers) == 0 {
 		return nil, nil
 	}
@@ -316,11 +310,16 @@ func (s *Server) SaveProwlarrSetting(c *gin.Context) (interface{}, error) {
 	if err := c.ShouldBindJSON(&in); err != nil {
 		return nil, err
 	}
-	if !in.Disabled {
-		client := prowlarr.New(in.ApiKey, in.URL)
-		if _, err := client.GetIndexers(prowlarr.TV); err != nil {
-			return nil, errors.Wrap(err, "connect to prowlarr error")
+
+	if in.Disabled {
+		if err := s.core.DeleteAllProwlarrIndexers(); err != nil {
+			return nil, errors.Wrap(err, "delete prowlarr indexers")
 		}
+	} else {
+		if err := s.core.SyncProwlarrIndexers(in.ApiKey, in.URL); err != nil {
+			return nil, errors.Wrap(err, "verify prowlarr")
+		}
+
 	}
 	err := s.db.SaveProwlarrSetting(&in)
 	if err != nil {