fix: tv name parse

db/const.go

@@ -14,6 +14,9 @@ const (
 	SettingNfoSupportEnabled      = "nfo_support_enabled"
 	SettingAllowQiangban          = "filter_qiangban"
 	SettingEnableTmdbAdultContent = "tmdb_adult_content"
+	SetttingSizeLimiter           = "size_limiter"
+	SettingTvNamingFormat         = "tv_naming_format"
+	SettingMovieNamingFormat      = "movie_naming_format"
 )
 
 const (
@@ -34,6 +37,26 @@ const (
 	LanguageCN = "zh-CN"
 )
 
+const DefaultNamingFormat = "{{.NameCN}} {{.NameEN}} {{if .Year}} ({{.Year}}) {{end}}"
+
+type NamingInfo struct {
+	NameCN string
+	NameEN string
+	Year   string
+	TmdbID int
+}
+
 type ResolutionType string
 
 const JwtSerectKey = "jwt_secrect_key"
+
+type SizeLimiter struct {
+	R720p  Limiter `json:"720p"`
+	R1080p Limiter `json:"1080p"`
+	R2160p Limiter `json:"2160p"`
+}
+
+type Limiter struct {
+	Max int `json:"max"`
+	Min int `json:"min"`
+}

db/db.go

@@ -9,6 +9,7 @@ import (
 	"polaris/ent/downloadclients"
 	"polaris/ent/episode"
 	"polaris/ent/history"
+	"polaris/ent/importlist"
 	"polaris/ent/indexers"
 	"polaris/ent/media"
 	"polaris/ent/schema"
@@ -118,7 +119,7 @@ func (c *Client) GetLanguage() string {
 	lang := c.GetSetting(SettingLanguage)
 	log.Infof("get application language: %s", lang)
 	if lang == "" {
-		return "zh-CN"
+		return LanguageCN
 	}
 	return lang
 }
@@ -529,6 +530,16 @@ func (c *Client) SetEpisodeStatus(id int, status episode.Status) error {
 	return c.ent.Episode.Update().Where(episode.ID(id)).SetStatus(status).Exec(context.TODO())
 }
 
+func (c *Client) IsEpisodeDownloadingOrDownloaded(id int) bool {
+	his := c.ent.History.Query().Where(history.EpisodeID(id)).AllX(context.Background())
+	for _, h := range his {
+		if h.Status != history.StatusFail {
+			return true
+		}
+	}
+	return false
+}
+
 func (c *Client) SetSeasonAllEpisodeStatus(mediaID, seasonNum int, status episode.Status) error {
 	return c.ent.Episode.Update().Where(episode.MediaID(mediaID), episode.SeasonNumber(seasonNum)).SetStatus(status).Exec(context.TODO())
 }
@@ -580,3 +591,56 @@ func (c *Client) UpdateEpisodeTargetFile(id int, filename string) error {
 func (c *Client) GetSeasonEpisodes(mediaId, seasonNum int) ([]*ent.Episode, error) {
 	return c.ent.Episode.Query().Where(episode.MediaID(mediaId), episode.SeasonNumber(seasonNum)).All(context.Background())
 }
+
+func (c *Client) GetAllImportLists() ([]*ent.ImportList, error) {
+	return c.ent.ImportList.Query().All(context.Background())
+}
+
+func (c *Client) AddImportlist(il *ent.ImportList) error {
+	count, err := c.ent.ImportList.Query().Where(importlist.Name(il.Name)).Count(context.Background())
+	if err != nil {
+		return err
+	}
+	if count > 0 {
+		//edit exist record
+		return c.ent.ImportList.Update().Where(importlist.Name(il.Name)).
+			SetURL(il.URL).SetQulity(il.Qulity).SetType(il.Type).SetStorageID(il.StorageID).Exec(context.Background())
+	}
+	return c.ent.ImportList.Create().SetName(il.Name).SetURL(il.URL).SetQulity(il.Qulity).SetStorageID(il.StorageID).
+		SetType(il.Type).Exec(context.Background())
+}
+
+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
+	err := json.Unmarshal([]byte(v), &limiter)
+	return &limiter, err
+}
+
+func (c *Client) SetSizeLimiter(limiter *SizeLimiter) error {
+	data, err := json.Marshal(limiter)
+	if err != nil {
+		return err
+	}
+	return c.SetSetting(SetttingSizeLimiter, string(data))
+}
+
+func (c *Client) GetTvNamingFormat() string {
+	s := c.GetSetting(SettingTvNamingFormat)
+	if s == "" {
+		return DefaultNamingFormat
+	}
+	return s
+}
+
+func (c *Client) GetMovingNamingFormat() string {
+	s := c.GetSetting(SettingMovieNamingFormat)
+	if s == "" {
+		return DefaultNamingFormat
+	}
+	return s
+}

ent/client.go

@@ -14,6 +14,7 @@ import (
 	"polaris/ent/downloadclients"
 	"polaris/ent/episode"
 	"polaris/ent/history"
+	"polaris/ent/importlist"
 	"polaris/ent/indexers"
 	"polaris/ent/media"
 	"polaris/ent/notificationclient"
@@ -37,6 +38,8 @@ type Client struct {
 	Episode *EpisodeClient
 	// History is the client for interacting with the History builders.
 	History *HistoryClient
+	// ImportList is the client for interacting with the ImportList builders.
+	ImportList *ImportListClient
 	// Indexers is the client for interacting with the Indexers builders.
 	Indexers *IndexersClient
 	// Media is the client for interacting with the Media builders.
@@ -61,6 +64,7 @@ func (c *Client) init() {
 	c.DownloadClients = NewDownloadClientsClient(c.config)
 	c.Episode = NewEpisodeClient(c.config)
 	c.History = NewHistoryClient(c.config)
+	c.ImportList = NewImportListClient(c.config)
 	c.Indexers = NewIndexersClient(c.config)
 	c.Media = NewMediaClient(c.config)
 	c.NotificationClient = NewNotificationClientClient(c.config)
@@ -161,6 +165,7 @@ func (c *Client) Tx(ctx context.Context) (*Tx, error) {
 		DownloadClients:    NewDownloadClientsClient(cfg),
 		Episode:            NewEpisodeClient(cfg),
 		History:            NewHistoryClient(cfg),
+		ImportList:         NewImportListClient(cfg),
 		Indexers:           NewIndexersClient(cfg),
 		Media:              NewMediaClient(cfg),
 		NotificationClient: NewNotificationClientClient(cfg),
@@ -188,6 +193,7 @@ func (c *Client) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error)
 		DownloadClients:    NewDownloadClientsClient(cfg),
 		Episode:            NewEpisodeClient(cfg),
 		History:            NewHistoryClient(cfg),
+		ImportList:         NewImportListClient(cfg),
 		Indexers:           NewIndexersClient(cfg),
 		Media:              NewMediaClient(cfg),
 		NotificationClient: NewNotificationClientClient(cfg),
@@ -222,7 +228,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.DownloadClients, c.Episode, c.History, c.Indexers, c.Media,
+		c.DownloadClients, c.Episode, c.History, c.ImportList, c.Indexers, c.Media,
 		c.NotificationClient, c.Settings, c.Storage,
 	} {
 		n.Use(hooks...)
@@ -233,7 +239,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.DownloadClients, c.Episode, c.History, c.Indexers, c.Media,
+		c.DownloadClients, c.Episode, c.History, c.ImportList, c.Indexers, c.Media,
 		c.NotificationClient, c.Settings, c.Storage,
 	} {
 		n.Intercept(interceptors...)
@@ -249,6 +255,8 @@ func (c *Client) Mutate(ctx context.Context, m Mutation) (Value, error) {
 		return c.Episode.mutate(ctx, m)
 	case *HistoryMutation:
 		return c.History.mutate(ctx, m)
+	case *ImportListMutation:
+		return c.ImportList.mutate(ctx, m)
 	case *IndexersMutation:
 		return c.Indexers.mutate(ctx, m)
 	case *MediaMutation:
@@ -679,6 +687,139 @@ func (c *HistoryClient) mutate(ctx context.Context, m *HistoryMutation) (Value,
 	}
 }
 
+// ImportListClient is a client for the ImportList schema.
+type ImportListClient struct {
+	config
+}
+
+// NewImportListClient returns a client for the ImportList from the given config.
+func NewImportListClient(c config) *ImportListClient {
+	return &ImportListClient{config: c}
+}
+
+// Use adds a list of mutation hooks to the hooks stack.
+// A call to `Use(f, g, h)` equals to `importlist.Hooks(f(g(h())))`.
+func (c *ImportListClient) Use(hooks ...Hook) {
+	c.hooks.ImportList = append(c.hooks.ImportList, hooks...)
+}
+
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `importlist.Intercept(f(g(h())))`.
+func (c *ImportListClient) Intercept(interceptors ...Interceptor) {
+	c.inters.ImportList = append(c.inters.ImportList, interceptors...)
+}
+
+// Create returns a builder for creating a ImportList entity.
+func (c *ImportListClient) Create() *ImportListCreate {
+	mutation := newImportListMutation(c.config, OpCreate)
+	return &ImportListCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// CreateBulk returns a builder for creating a bulk of ImportList entities.
+func (c *ImportListClient) CreateBulk(builders ...*ImportListCreate) *ImportListCreateBulk {
+	return &ImportListCreateBulk{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 *ImportListClient) MapCreateBulk(slice any, setFunc func(*ImportListCreate, int)) *ImportListCreateBulk {
+	rv := reflect.ValueOf(slice)
+	if rv.Kind() != reflect.Slice {
+		return &ImportListCreateBulk{err: fmt.Errorf("calling to ImportListClient.MapCreateBulk with wrong type %T, need slice", slice)}
+	}
+	builders := make([]*ImportListCreate, rv.Len())
+	for i := 0; i < rv.Len(); i++ {
+		builders[i] = c.Create()
+		setFunc(builders[i], i)
+	}
+	return &ImportListCreateBulk{config: c.config, builders: builders}
+}
+
+// Update returns an update builder for ImportList.
+func (c *ImportListClient) Update() *ImportListUpdate {
+	mutation := newImportListMutation(c.config, OpUpdate)
+	return &ImportListUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOne returns an update builder for the given entity.
+func (c *ImportListClient) UpdateOne(il *ImportList) *ImportListUpdateOne {
+	mutation := newImportListMutation(c.config, OpUpdateOne, withImportList(il))
+	return &ImportListUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOneID returns an update builder for the given id.
+func (c *ImportListClient) UpdateOneID(id int) *ImportListUpdateOne {
+	mutation := newImportListMutation(c.config, OpUpdateOne, withImportListID(id))
+	return &ImportListUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// Delete returns a delete builder for ImportList.
+func (c *ImportListClient) Delete() *ImportListDelete {
+	mutation := newImportListMutation(c.config, OpDelete)
+	return &ImportListDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// DeleteOne returns a builder for deleting the given entity.
+func (c *ImportListClient) DeleteOne(il *ImportList) *ImportListDeleteOne {
+	return c.DeleteOneID(il.ID)
+}
+
+// DeleteOneID returns a builder for deleting the given entity by its id.
+func (c *ImportListClient) DeleteOneID(id int) *ImportListDeleteOne {
+	builder := c.Delete().Where(importlist.ID(id))
+	builder.mutation.id = &id
+	builder.mutation.op = OpDeleteOne
+	return &ImportListDeleteOne{builder}
+}
+
+// Query returns a query builder for ImportList.
+func (c *ImportListClient) Query() *ImportListQuery {
+	return &ImportListQuery{
+		config: c.config,
+		ctx:    &QueryContext{Type: TypeImportList},
+		inters: c.Interceptors(),
+	}
+}
+
+// Get returns a ImportList entity by its id.
+func (c *ImportListClient) Get(ctx context.Context, id int) (*ImportList, error) {
+	return c.Query().Where(importlist.ID(id)).Only(ctx)
+}
+
+// GetX is like Get, but panics if an error occurs.
+func (c *ImportListClient) GetX(ctx context.Context, id int) *ImportList {
+	obj, err := c.Get(ctx, id)
+	if err != nil {
+		panic(err)
+	}
+	return obj
+}
+
+// Hooks returns the client hooks.
+func (c *ImportListClient) Hooks() []Hook {
+	return c.hooks.ImportList
+}
+
+// Interceptors returns the client interceptors.
+func (c *ImportListClient) Interceptors() []Interceptor {
+	return c.inters.ImportList
+}
+
+func (c *ImportListClient) mutate(ctx context.Context, m *ImportListMutation) (Value, error) {
+	switch m.Op() {
+	case OpCreate:
+		return (&ImportListCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdate:
+		return (&ImportListUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdateOne:
+		return (&ImportListUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpDelete, OpDeleteOne:
+		return (&ImportListDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+	default:
+		return nil, fmt.Errorf("ent: unknown ImportList mutation op: %q", m.Op())
+	}
+}
+
 // IndexersClient is a client for the Indexers schema.
 type IndexersClient struct {
 	config
@@ -1363,11 +1504,11 @@ func (c *StorageClient) mutate(ctx context.Context, m *StorageMutation) (Value,
 // hooks and interceptors per client, for fast access.
 type (
 	hooks struct {
-		DownloadClients, Episode, History, Indexers, Media, NotificationClient,
-		Settings, Storage []ent.Hook
+		DownloadClients, Episode, History, ImportList, Indexers, Media,
+		NotificationClient, Settings, Storage []ent.Hook
 	}
 	inters struct {
-		DownloadClients, Episode, History, Indexers, Media, NotificationClient,
-		Settings, Storage []ent.Interceptor
+		DownloadClients, Episode, History, ImportList, Indexers, Media,
+		NotificationClient, Settings, Storage []ent.Interceptor
 	}
 )

ent/ent.go

@@ -9,6 +9,7 @@ import (
 	"polaris/ent/downloadclients"
 	"polaris/ent/episode"
 	"polaris/ent/history"
+	"polaris/ent/importlist"
 	"polaris/ent/indexers"
 	"polaris/ent/media"
 	"polaris/ent/notificationclient"
@@ -83,6 +84,7 @@ func checkColumn(table, column string) error {
 			downloadclients.Table:    downloadclients.ValidColumn,
 			episode.Table:            episode.ValidColumn,
 			history.Table:            history.ValidColumn,
+			importlist.Table:         importlist.ValidColumn,
 			indexers.Table:           indexers.ValidColumn,
 			media.Table:              media.ValidColumn,
 			notificationclient.Table: notificationclient.ValidColumn,

ent/hook/hook.go

@@ -44,6 +44,18 @@ func (f HistoryFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, err
 	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.HistoryMutation", m)
 }
 
+// The ImportListFunc type is an adapter to allow the use of ordinary
+// function as ImportList mutator.
+type ImportListFunc func(context.Context, *ent.ImportListMutation) (ent.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f ImportListFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
+	if mv, ok := m.(*ent.ImportListMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.ImportListMutation", m)
+}
+
 // The IndexersFunc type is an adapter to allow the use of ordinary
 // function as Indexers mutator.
 type IndexersFunc func(context.Context, *ent.IndexersMutation) (ent.Value, error)

ent/importlist.go

@@ -0,0 +1,164 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"encoding/json"
+	"fmt"
+	"polaris/ent/importlist"
+	"polaris/ent/schema"
+	"strings"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+)
+
+// ImportList is the model entity for the ImportList schema.
+type ImportList struct {
+	config `json:"-"`
+	// ID of the ent.
+	ID int `json:"id,omitempty"`
+	// Name holds the value of the "name" field.
+	Name string `json:"name,omitempty"`
+	// Type holds the value of the "type" field.
+	Type importlist.Type `json:"type,omitempty"`
+	// URL holds the value of the "url" field.
+	URL string `json:"url,omitempty"`
+	// Qulity holds the value of the "qulity" field.
+	Qulity string `json:"qulity,omitempty"`
+	// StorageID holds the value of the "storage_id" field.
+	StorageID int `json:"storage_id,omitempty"`
+	// Settings holds the value of the "settings" field.
+	Settings     schema.ImportListSettings `json:"settings,omitempty"`
+	selectValues sql.SelectValues
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*ImportList) scanValues(columns []string) ([]any, error) {
+	values := make([]any, len(columns))
+	for i := range columns {
+		switch columns[i] {
+		case importlist.FieldSettings:
+			values[i] = new([]byte)
+		case importlist.FieldID, importlist.FieldStorageID:
+			values[i] = new(sql.NullInt64)
+		case importlist.FieldName, importlist.FieldType, importlist.FieldURL, importlist.FieldQulity:
+			values[i] = new(sql.NullString)
+		default:
+			values[i] = new(sql.UnknownType)
+		}
+	}
+	return values, nil
+}
+
+// assignValues assigns the values that were returned from sql.Rows (after scanning)
+// to the ImportList fields.
+func (il *ImportList) 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 importlist.FieldID:
+			value, ok := values[i].(*sql.NullInt64)
+			if !ok {
+				return fmt.Errorf("unexpected type %T for field id", value)
+			}
+			il.ID = int(value.Int64)
+		case importlist.FieldName:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field name", values[i])
+			} else if value.Valid {
+				il.Name = value.String
+			}
+		case importlist.FieldType:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field type", values[i])
+			} else if value.Valid {
+				il.Type = importlist.Type(value.String)
+			}
+		case importlist.FieldURL:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field url", values[i])
+			} else if value.Valid {
+				il.URL = value.String
+			}
+		case importlist.FieldQulity:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field qulity", values[i])
+			} else if value.Valid {
+				il.Qulity = value.String
+			}
+		case importlist.FieldStorageID:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field storage_id", values[i])
+			} else if value.Valid {
+				il.StorageID = int(value.Int64)
+			}
+		case importlist.FieldSettings:
+			if value, ok := values[i].(*[]byte); !ok {
+				return fmt.Errorf("unexpected type %T for field settings", values[i])
+			} else if value != nil && len(*value) > 0 {
+				if err := json.Unmarshal(*value, &il.Settings); err != nil {
+					return fmt.Errorf("unmarshal field settings: %w", err)
+				}
+			}
+		default:
+			il.selectValues.Set(columns[i], values[i])
+		}
+	}
+	return nil
+}
+
+// Value returns the ent.Value that was dynamically selected and assigned to the ImportList.
+// This includes values selected through modifiers, order, etc.
+func (il *ImportList) Value(name string) (ent.Value, error) {
+	return il.selectValues.Get(name)
+}
+
+// Update returns a builder for updating this ImportList.
+// Note that you need to call ImportList.Unwrap() before calling this method if this ImportList
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (il *ImportList) Update() *ImportListUpdateOne {
+	return NewImportListClient(il.config).UpdateOne(il)
+}
+
+// Unwrap unwraps the ImportList 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 (il *ImportList) Unwrap() *ImportList {
+	_tx, ok := il.config.driver.(*txDriver)
+	if !ok {
+		panic("ent: ImportList is not a transactional entity")
+	}
+	il.config.driver = _tx.drv
+	return il
+}
+
+// String implements the fmt.Stringer.
+func (il *ImportList) String() string {
+	var builder strings.Builder
+	builder.WriteString("ImportList(")
+	builder.WriteString(fmt.Sprintf("id=%v, ", il.ID))
+	builder.WriteString("name=")
+	builder.WriteString(il.Name)
+	builder.WriteString(", ")
+	builder.WriteString("type=")
+	builder.WriteString(fmt.Sprintf("%v", il.Type))
+	builder.WriteString(", ")
+	builder.WriteString("url=")
+	builder.WriteString(il.URL)
+	builder.WriteString(", ")
+	builder.WriteString("qulity=")
+	builder.WriteString(il.Qulity)
+	builder.WriteString(", ")
+	builder.WriteString("storage_id=")
+	builder.WriteString(fmt.Sprintf("%v", il.StorageID))
+	builder.WriteString(", ")
+	builder.WriteString("settings=")
+	builder.WriteString(fmt.Sprintf("%v", il.Settings))
+	builder.WriteByte(')')
+	return builder.String()
+}
+
+// ImportLists is a parsable slice of ImportList.
+type ImportLists []*ImportList

ent/importlist/importlist.go

@@ -0,0 +1,107 @@
+// Code generated by ent, DO NOT EDIT.
+
+package importlist
+
+import (
+	"fmt"
+
+	"entgo.io/ent/dialect/sql"
+)
+
+const (
+	// Label holds the string label denoting the importlist type in the database.
+	Label = "import_list"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldName holds the string denoting the name field in the database.
+	FieldName = "name"
+	// FieldType holds the string denoting the type field in the database.
+	FieldType = "type"
+	// FieldURL holds the string denoting the url field in the database.
+	FieldURL = "url"
+	// FieldQulity holds the string denoting the qulity field in the database.
+	FieldQulity = "qulity"
+	// FieldStorageID holds the string denoting the storage_id field in the database.
+	FieldStorageID = "storage_id"
+	// FieldSettings holds the string denoting the settings field in the database.
+	FieldSettings = "settings"
+	// Table holds the table name of the importlist in the database.
+	Table = "import_lists"
+)
+
+// Columns holds all SQL columns for importlist fields.
+var Columns = []string{
+	FieldID,
+	FieldName,
+	FieldType,
+	FieldURL,
+	FieldQulity,
+	FieldStorageID,
+	FieldSettings,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+// Type defines the type for the "type" enum field.
+type Type string
+
+// Type values.
+const (
+	TypePlex    Type = "plex"
+	TypeDoulist Type = "doulist"
+)
+
+func (_type Type) String() string {
+	return string(_type)
+}
+
+// TypeValidator is a validator for the "type" field enum values. It is called by the builders before save.
+func TypeValidator(_type Type) error {
+	switch _type {
+	case TypePlex, TypeDoulist:
+		return nil
+	default:
+		return fmt.Errorf("importlist: invalid enum value for type field: %q", _type)
+	}
+}
+
+// OrderOption defines the ordering options for the ImportList queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByName orders the results by the name field.
+func ByName(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldName, opts...).ToFunc()
+}
+
+// ByType orders the results by the type field.
+func ByType(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldType, opts...).ToFunc()
+}
+
+// ByURL orders the results by the url field.
+func ByURL(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldURL, opts...).ToFunc()
+}
+
+// ByQulity orders the results by the qulity field.
+func ByQulity(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldQulity, opts...).ToFunc()
+}
+
+// ByStorageID orders the results by the storage_id field.
+func ByStorageID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldStorageID, opts...).ToFunc()
+}

ent/importlist/where.go

@@ -0,0 +1,364 @@
+// Code generated by ent, DO NOT EDIT.
+
+package importlist
+
+import (
+	"polaris/ent/predicate"
+
+	"entgo.io/ent/dialect/sql"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id int) predicate.ImportList {
+	return predicate.ImportList(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id int) predicate.ImportList {
+	return predicate.ImportList(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id int) predicate.ImportList {
+	return predicate.ImportList(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...int) predicate.ImportList {
+	return predicate.ImportList(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...int) predicate.ImportList {
+	return predicate.ImportList(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id int) predicate.ImportList {
+	return predicate.ImportList(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id int) predicate.ImportList {
+	return predicate.ImportList(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id int) predicate.ImportList {
+	return predicate.ImportList(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id int) predicate.ImportList {
+	return predicate.ImportList(sql.FieldLTE(FieldID, id))
+}
+
+// Name applies equality check predicate on the "name" field. It's identical to NameEQ.
+func Name(v string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldEQ(FieldName, v))
+}
+
+// URL applies equality check predicate on the "url" field. It's identical to URLEQ.
+func URL(v string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldEQ(FieldURL, v))
+}
+
+// Qulity applies equality check predicate on the "qulity" field. It's identical to QulityEQ.
+func Qulity(v string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldEQ(FieldQulity, v))
+}
+
+// StorageID applies equality check predicate on the "storage_id" field. It's identical to StorageIDEQ.
+func StorageID(v int) predicate.ImportList {
+	return predicate.ImportList(sql.FieldEQ(FieldStorageID, v))
+}
+
+// NameEQ applies the EQ predicate on the "name" field.
+func NameEQ(v string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldEQ(FieldName, v))
+}
+
+// NameNEQ applies the NEQ predicate on the "name" field.
+func NameNEQ(v string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldNEQ(FieldName, v))
+}
+
+// NameIn applies the In predicate on the "name" field.
+func NameIn(vs ...string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldIn(FieldName, vs...))
+}
+
+// NameNotIn applies the NotIn predicate on the "name" field.
+func NameNotIn(vs ...string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldNotIn(FieldName, vs...))
+}
+
+// NameGT applies the GT predicate on the "name" field.
+func NameGT(v string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldGT(FieldName, v))
+}
+
+// NameGTE applies the GTE predicate on the "name" field.
+func NameGTE(v string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldGTE(FieldName, v))
+}
+
+// NameLT applies the LT predicate on the "name" field.
+func NameLT(v string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldLT(FieldName, v))
+}
+
+// NameLTE applies the LTE predicate on the "name" field.
+func NameLTE(v string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldLTE(FieldName, v))
+}
+
+// NameContains applies the Contains predicate on the "name" field.
+func NameContains(v string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldContains(FieldName, v))
+}
+
+// NameHasPrefix applies the HasPrefix predicate on the "name" field.
+func NameHasPrefix(v string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldHasPrefix(FieldName, v))
+}
+
+// NameHasSuffix applies the HasSuffix predicate on the "name" field.
+func NameHasSuffix(v string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldHasSuffix(FieldName, v))
+}
+
+// NameEqualFold applies the EqualFold predicate on the "name" field.
+func NameEqualFold(v string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldEqualFold(FieldName, v))
+}
+
+// NameContainsFold applies the ContainsFold predicate on the "name" field.
+func NameContainsFold(v string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldContainsFold(FieldName, v))
+}
+
+// TypeEQ applies the EQ predicate on the "type" field.
+func TypeEQ(v Type) predicate.ImportList {
+	return predicate.ImportList(sql.FieldEQ(FieldType, v))
+}
+
+// TypeNEQ applies the NEQ predicate on the "type" field.
+func TypeNEQ(v Type) predicate.ImportList {
+	return predicate.ImportList(sql.FieldNEQ(FieldType, v))
+}
+
+// TypeIn applies the In predicate on the "type" field.
+func TypeIn(vs ...Type) predicate.ImportList {
+	return predicate.ImportList(sql.FieldIn(FieldType, vs...))
+}
+
+// TypeNotIn applies the NotIn predicate on the "type" field.
+func TypeNotIn(vs ...Type) predicate.ImportList {
+	return predicate.ImportList(sql.FieldNotIn(FieldType, vs...))
+}
+
+// URLEQ applies the EQ predicate on the "url" field.
+func URLEQ(v string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldEQ(FieldURL, v))
+}
+
+// URLNEQ applies the NEQ predicate on the "url" field.
+func URLNEQ(v string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldNEQ(FieldURL, v))
+}
+
+// URLIn applies the In predicate on the "url" field.
+func URLIn(vs ...string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldIn(FieldURL, vs...))
+}
+
+// URLNotIn applies the NotIn predicate on the "url" field.
+func URLNotIn(vs ...string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldNotIn(FieldURL, vs...))
+}
+
+// URLGT applies the GT predicate on the "url" field.
+func URLGT(v string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldGT(FieldURL, v))
+}
+
+// URLGTE applies the GTE predicate on the "url" field.
+func URLGTE(v string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldGTE(FieldURL, v))
+}
+
+// URLLT applies the LT predicate on the "url" field.
+func URLLT(v string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldLT(FieldURL, v))
+}
+
+// URLLTE applies the LTE predicate on the "url" field.
+func URLLTE(v string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldLTE(FieldURL, v))
+}
+
+// URLContains applies the Contains predicate on the "url" field.
+func URLContains(v string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldContains(FieldURL, v))
+}
+
+// URLHasPrefix applies the HasPrefix predicate on the "url" field.
+func URLHasPrefix(v string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldHasPrefix(FieldURL, v))
+}
+
+// URLHasSuffix applies the HasSuffix predicate on the "url" field.
+func URLHasSuffix(v string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldHasSuffix(FieldURL, v))
+}
+
+// URLIsNil applies the IsNil predicate on the "url" field.
+func URLIsNil() predicate.ImportList {
+	return predicate.ImportList(sql.FieldIsNull(FieldURL))
+}
+
+// URLNotNil applies the NotNil predicate on the "url" field.
+func URLNotNil() predicate.ImportList {
+	return predicate.ImportList(sql.FieldNotNull(FieldURL))
+}
+
+// URLEqualFold applies the EqualFold predicate on the "url" field.
+func URLEqualFold(v string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldEqualFold(FieldURL, v))
+}
+
+// URLContainsFold applies the ContainsFold predicate on the "url" field.
+func URLContainsFold(v string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldContainsFold(FieldURL, v))
+}
+
+// QulityEQ applies the EQ predicate on the "qulity" field.
+func QulityEQ(v string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldEQ(FieldQulity, v))
+}
+
+// QulityNEQ applies the NEQ predicate on the "qulity" field.
+func QulityNEQ(v string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldNEQ(FieldQulity, v))
+}
+
+// QulityIn applies the In predicate on the "qulity" field.
+func QulityIn(vs ...string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldIn(FieldQulity, vs...))
+}
+
+// QulityNotIn applies the NotIn predicate on the "qulity" field.
+func QulityNotIn(vs ...string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldNotIn(FieldQulity, vs...))
+}
+
+// QulityGT applies the GT predicate on the "qulity" field.
+func QulityGT(v string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldGT(FieldQulity, v))
+}
+
+// QulityGTE applies the GTE predicate on the "qulity" field.
+func QulityGTE(v string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldGTE(FieldQulity, v))
+}
+
+// QulityLT applies the LT predicate on the "qulity" field.
+func QulityLT(v string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldLT(FieldQulity, v))
+}
+
+// QulityLTE applies the LTE predicate on the "qulity" field.
+func QulityLTE(v string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldLTE(FieldQulity, v))
+}
+
+// QulityContains applies the Contains predicate on the "qulity" field.
+func QulityContains(v string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldContains(FieldQulity, v))
+}
+
+// QulityHasPrefix applies the HasPrefix predicate on the "qulity" field.
+func QulityHasPrefix(v string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldHasPrefix(FieldQulity, v))
+}
+
+// QulityHasSuffix applies the HasSuffix predicate on the "qulity" field.
+func QulityHasSuffix(v string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldHasSuffix(FieldQulity, v))
+}
+
+// QulityEqualFold applies the EqualFold predicate on the "qulity" field.
+func QulityEqualFold(v string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldEqualFold(FieldQulity, v))
+}
+
+// QulityContainsFold applies the ContainsFold predicate on the "qulity" field.
+func QulityContainsFold(v string) predicate.ImportList {
+	return predicate.ImportList(sql.FieldContainsFold(FieldQulity, v))
+}
+
+// StorageIDEQ applies the EQ predicate on the "storage_id" field.
+func StorageIDEQ(v int) predicate.ImportList {
+	return predicate.ImportList(sql.FieldEQ(FieldStorageID, v))
+}
+
+// StorageIDNEQ applies the NEQ predicate on the "storage_id" field.
+func StorageIDNEQ(v int) predicate.ImportList {
+	return predicate.ImportList(sql.FieldNEQ(FieldStorageID, v))
+}
+
+// StorageIDIn applies the In predicate on the "storage_id" field.
+func StorageIDIn(vs ...int) predicate.ImportList {
+	return predicate.ImportList(sql.FieldIn(FieldStorageID, vs...))
+}
+
+// StorageIDNotIn applies the NotIn predicate on the "storage_id" field.
+func StorageIDNotIn(vs ...int) predicate.ImportList {
+	return predicate.ImportList(sql.FieldNotIn(FieldStorageID, vs...))
+}
+
+// StorageIDGT applies the GT predicate on the "storage_id" field.
+func StorageIDGT(v int) predicate.ImportList {
+	return predicate.ImportList(sql.FieldGT(FieldStorageID, v))
+}
+
+// StorageIDGTE applies the GTE predicate on the "storage_id" field.
+func StorageIDGTE(v int) predicate.ImportList {
+	return predicate.ImportList(sql.FieldGTE(FieldStorageID, v))
+}
+
+// StorageIDLT applies the LT predicate on the "storage_id" field.
+func StorageIDLT(v int) predicate.ImportList {
+	return predicate.ImportList(sql.FieldLT(FieldStorageID, v))
+}
+
+// StorageIDLTE applies the LTE predicate on the "storage_id" field.
+func StorageIDLTE(v int) predicate.ImportList {
+	return predicate.ImportList(sql.FieldLTE(FieldStorageID, v))
+}
+
+// SettingsIsNil applies the IsNil predicate on the "settings" field.
+func SettingsIsNil() predicate.ImportList {
+	return predicate.ImportList(sql.FieldIsNull(FieldSettings))
+}
+
+// SettingsNotNil applies the NotNil predicate on the "settings" field.
+func SettingsNotNil() predicate.ImportList {
+	return predicate.ImportList(sql.FieldNotNull(FieldSettings))
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.ImportList) predicate.ImportList {
+	return predicate.ImportList(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.ImportList) predicate.ImportList {
+	return predicate.ImportList(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.ImportList) predicate.ImportList {
+	return predicate.ImportList(sql.NotPredicates(p))
+}

ent/importlist_create.go

@@ -0,0 +1,264 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"polaris/ent/importlist"
+	"polaris/ent/schema"
+
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+)
+
+// ImportListCreate is the builder for creating a ImportList entity.
+type ImportListCreate struct {
+	config
+	mutation *ImportListMutation
+	hooks    []Hook
+}
+
+// SetName sets the "name" field.
+func (ilc *ImportListCreate) SetName(s string) *ImportListCreate {
+	ilc.mutation.SetName(s)
+	return ilc
+}
+
+// SetType sets the "type" field.
+func (ilc *ImportListCreate) SetType(i importlist.Type) *ImportListCreate {
+	ilc.mutation.SetType(i)
+	return ilc
+}
+
+// SetURL sets the "url" field.
+func (ilc *ImportListCreate) SetURL(s string) *ImportListCreate {
+	ilc.mutation.SetURL(s)
+	return ilc
+}
+
+// SetNillableURL sets the "url" field if the given value is not nil.
+func (ilc *ImportListCreate) SetNillableURL(s *string) *ImportListCreate {
+	if s != nil {
+		ilc.SetURL(*s)
+	}
+	return ilc
+}
+
+// SetQulity sets the "qulity" field.
+func (ilc *ImportListCreate) SetQulity(s string) *ImportListCreate {
+	ilc.mutation.SetQulity(s)
+	return ilc
+}
+
+// SetStorageID sets the "storage_id" field.
+func (ilc *ImportListCreate) SetStorageID(i int) *ImportListCreate {
+	ilc.mutation.SetStorageID(i)
+	return ilc
+}
+
+// SetSettings sets the "settings" field.
+func (ilc *ImportListCreate) SetSettings(sls schema.ImportListSettings) *ImportListCreate {
+	ilc.mutation.SetSettings(sls)
+	return ilc
+}
+
+// SetNillableSettings sets the "settings" field if the given value is not nil.
+func (ilc *ImportListCreate) SetNillableSettings(sls *schema.ImportListSettings) *ImportListCreate {
+	if sls != nil {
+		ilc.SetSettings(*sls)
+	}
+	return ilc
+}
+
+// Mutation returns the ImportListMutation object of the builder.
+func (ilc *ImportListCreate) Mutation() *ImportListMutation {
+	return ilc.mutation
+}
+
+// Save creates the ImportList in the database.
+func (ilc *ImportListCreate) Save(ctx context.Context) (*ImportList, error) {
+	return withHooks(ctx, ilc.sqlSave, ilc.mutation, ilc.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (ilc *ImportListCreate) SaveX(ctx context.Context) *ImportList {
+	v, err := ilc.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (ilc *ImportListCreate) Exec(ctx context.Context) error {
+	_, err := ilc.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (ilc *ImportListCreate) ExecX(ctx context.Context) {
+	if err := ilc.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (ilc *ImportListCreate) check() error {
+	if _, ok := ilc.mutation.Name(); !ok {
+		return &ValidationError{Name: "name", err: errors.New(`ent: missing required field "ImportList.name"`)}
+	}
+	if _, ok := ilc.mutation.GetType(); !ok {
+		return &ValidationError{Name: "type", err: errors.New(`ent: missing required field "ImportList.type"`)}
+	}
+	if v, ok := ilc.mutation.GetType(); ok {
+		if err := importlist.TypeValidator(v); err != nil {
+			return &ValidationError{Name: "type", err: fmt.Errorf(`ent: validator failed for field "ImportList.type": %w`, err)}
+		}
+	}
+	if _, ok := ilc.mutation.Qulity(); !ok {
+		return &ValidationError{Name: "qulity", err: errors.New(`ent: missing required field "ImportList.qulity"`)}
+	}
+	if _, ok := ilc.mutation.StorageID(); !ok {
+		return &ValidationError{Name: "storage_id", err: errors.New(`ent: missing required field "ImportList.storage_id"`)}
+	}
+	return nil
+}
+
+func (ilc *ImportListCreate) sqlSave(ctx context.Context) (*ImportList, error) {
+	if err := ilc.check(); err != nil {
+		return nil, err
+	}
+	_node, _spec := ilc.createSpec()
+	if err := sqlgraph.CreateNode(ctx, ilc.driver, _spec); err != nil {
+		if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	id := _spec.ID.Value.(int64)
+	_node.ID = int(id)
+	ilc.mutation.id = &_node.ID
+	ilc.mutation.done = true
+	return _node, nil
+}
+
+func (ilc *ImportListCreate) createSpec() (*ImportList, *sqlgraph.CreateSpec) {
+	var (
+		_node = &ImportList{config: ilc.config}
+		_spec = sqlgraph.NewCreateSpec(importlist.Table, sqlgraph.NewFieldSpec(importlist.FieldID, field.TypeInt))
+	)
+	if value, ok := ilc.mutation.Name(); ok {
+		_spec.SetField(importlist.FieldName, field.TypeString, value)
+		_node.Name = value
+	}
+	if value, ok := ilc.mutation.GetType(); ok {
+		_spec.SetField(importlist.FieldType, field.TypeEnum, value)
+		_node.Type = value
+	}
+	if value, ok := ilc.mutation.URL(); ok {
+		_spec.SetField(importlist.FieldURL, field.TypeString, value)
+		_node.URL = value
+	}
+	if value, ok := ilc.mutation.Qulity(); ok {
+		_spec.SetField(importlist.FieldQulity, field.TypeString, value)
+		_node.Qulity = value
+	}
+	if value, ok := ilc.mutation.StorageID(); ok {
+		_spec.SetField(importlist.FieldStorageID, field.TypeInt, value)
+		_node.StorageID = value
+	}
+	if value, ok := ilc.mutation.Settings(); ok {
+		_spec.SetField(importlist.FieldSettings, field.TypeJSON, value)
+		_node.Settings = value
+	}
+	return _node, _spec
+}
+
+// ImportListCreateBulk is the builder for creating many ImportList entities in bulk.
+type ImportListCreateBulk struct {
+	config
+	err      error
+	builders []*ImportListCreate
+}
+
+// Save creates the ImportList entities in the database.
+func (ilcb *ImportListCreateBulk) Save(ctx context.Context) ([]*ImportList, error) {
+	if ilcb.err != nil {
+		return nil, ilcb.err
+	}
+	specs := make([]*sqlgraph.CreateSpec, len(ilcb.builders))
+	nodes := make([]*ImportList, len(ilcb.builders))
+	mutators := make([]Mutator, len(ilcb.builders))
+	for i := range ilcb.builders {
+		func(i int, root context.Context) {
+			builder := ilcb.builders[i]
+			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+				mutation, ok := m.(*ImportListMutation)
+				if !ok {
+					return nil, fmt.Errorf("unexpected mutation type %T", m)
+				}
+				if err := builder.check(); err != nil {
+					return nil, err
+				}
+				builder.mutation = mutation
+				var err error
+				nodes[i], specs[i] = builder.createSpec()
+				if i < len(mutators)-1 {
+					_, err = mutators[i+1].Mutate(root, ilcb.builders[i+1].mutation)
+				} else {
+					spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
+					// Invoke the actual operation on the latest mutation in the chain.
+					if err = sqlgraph.BatchCreate(ctx, ilcb.driver, spec); err != nil {
+						if sqlgraph.IsConstraintError(err) {
+							err = &ConstraintError{msg: err.Error(), wrap: err}
+						}
+					}
+				}
+				if err != nil {
+					return nil, err
+				}
+				mutation.id = &nodes[i].ID
+				if specs[i].ID.Value != nil {
+					id := specs[i].ID.Value.(int64)
+					nodes[i].ID = int(id)
+				}
+				mutation.done = true
+				return nodes[i], nil
+			})
+			for i := len(builder.hooks) - 1; i >= 0; i-- {
+				mut = builder.hooks[i](mut)
+			}
+			mutators[i] = mut
+		}(i, ctx)
+	}
+	if len(mutators) > 0 {
+		if _, err := mutators[0].Mutate(ctx, ilcb.builders[0].mutation); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (ilcb *ImportListCreateBulk) SaveX(ctx context.Context) []*ImportList {
+	v, err := ilcb.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (ilcb *ImportListCreateBulk) Exec(ctx context.Context) error {
+	_, err := ilcb.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (ilcb *ImportListCreateBulk) ExecX(ctx context.Context) {
+	if err := ilcb.Exec(ctx); err != nil {
+		panic(err)
+	}
+}

ent/importlist_delete.go

@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"polaris/ent/importlist"
+	"polaris/ent/predicate"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+)
+
+// ImportListDelete is the builder for deleting a ImportList entity.
+type ImportListDelete struct {
+	config
+	hooks    []Hook
+	mutation *ImportListMutation
+}
+
+// Where appends a list predicates to the ImportListDelete builder.
+func (ild *ImportListDelete) Where(ps ...predicate.ImportList) *ImportListDelete {
+	ild.mutation.Where(ps...)
+	return ild
+}
+
+// Exec executes the deletion query and returns how many vertices were deleted.
+func (ild *ImportListDelete) Exec(ctx context.Context) (int, error) {
+	return withHooks(ctx, ild.sqlExec, ild.mutation, ild.hooks)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (ild *ImportListDelete) ExecX(ctx context.Context) int {
+	n, err := ild.Exec(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return n
+}
+
+func (ild *ImportListDelete) sqlExec(ctx context.Context) (int, error) {
+	_spec := sqlgraph.NewDeleteSpec(importlist.Table, sqlgraph.NewFieldSpec(importlist.FieldID, field.TypeInt))
+	if ps := ild.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	affected, err := sqlgraph.DeleteNodes(ctx, ild.driver, _spec)
+	if err != nil && sqlgraph.IsConstraintError(err) {
+		err = &ConstraintError{msg: err.Error(), wrap: err}
+	}
+	ild.mutation.done = true
+	return affected, err
+}
+
+// ImportListDeleteOne is the builder for deleting a single ImportList entity.
+type ImportListDeleteOne struct {
+	ild *ImportListDelete
+}
+
+// Where appends a list predicates to the ImportListDelete builder.
+func (ildo *ImportListDeleteOne) Where(ps ...predicate.ImportList) *ImportListDeleteOne {
+	ildo.ild.mutation.Where(ps...)
+	return ildo
+}
+
+// Exec executes the deletion query.
+func (ildo *ImportListDeleteOne) Exec(ctx context.Context) error {
+	n, err := ildo.ild.Exec(ctx)
+	switch {
+	case err != nil:
+		return err
+	case n == 0:
+		return &NotFoundError{importlist.Label}
+	default:
+		return nil
+	}
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (ildo *ImportListDeleteOne) ExecX(ctx context.Context) {
+	if err := ildo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}

ent/importlist_query.go

@@ -0,0 +1,526 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"fmt"
+	"math"
+	"polaris/ent/importlist"
+	"polaris/ent/predicate"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+)
+
+// ImportListQuery is the builder for querying ImportList entities.
+type ImportListQuery struct {
+	config
+	ctx        *QueryContext
+	order      []importlist.OrderOption
+	inters     []Interceptor
+	predicates []predicate.ImportList
+	// intermediate query (i.e. traversal path).
+	sql  *sql.Selector
+	path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the ImportListQuery builder.
+func (ilq *ImportListQuery) Where(ps ...predicate.ImportList) *ImportListQuery {
+	ilq.predicates = append(ilq.predicates, ps...)
+	return ilq
+}
+
+// Limit the number of records to be returned by this query.
+func (ilq *ImportListQuery) Limit(limit int) *ImportListQuery {
+	ilq.ctx.Limit = &limit
+	return ilq
+}
+
+// Offset to start from.
+func (ilq *ImportListQuery) Offset(offset int) *ImportListQuery {
+	ilq.ctx.Offset = &offset
+	return ilq
+}
+
+// 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 (ilq *ImportListQuery) Unique(unique bool) *ImportListQuery {
+	ilq.ctx.Unique = &unique
+	return ilq
+}
+
+// Order specifies how the records should be ordered.
+func (ilq *ImportListQuery) Order(o ...importlist.OrderOption) *ImportListQuery {
+	ilq.order = append(ilq.order, o...)
+	return ilq
+}
+
+// First returns the first ImportList entity from the query.
+// Returns a *NotFoundError when no ImportList was found.
+func (ilq *ImportListQuery) First(ctx context.Context) (*ImportList, error) {
+	nodes, err := ilq.Limit(1).All(setContextOp(ctx, ilq.ctx, "First"))
+	if err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nil, &NotFoundError{importlist.Label}
+	}
+	return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (ilq *ImportListQuery) FirstX(ctx context.Context) *ImportList {
+	node, err := ilq.First(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return node
+}
+
+// FirstID returns the first ImportList ID from the query.
+// Returns a *NotFoundError when no ImportList ID was found.
+func (ilq *ImportListQuery) FirstID(ctx context.Context) (id int, err error) {
+	var ids []int
+	if ids, err = ilq.Limit(1).IDs(setContextOp(ctx, ilq.ctx, "FirstID")); err != nil {
+		return
+	}
+	if len(ids) == 0 {
+		err = &NotFoundError{importlist.Label}
+		return
+	}
+	return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (ilq *ImportListQuery) FirstIDX(ctx context.Context) int {
+	id, err := ilq.FirstID(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return id
+}
+
+// Only returns a single ImportList entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one ImportList entity is found.
+// Returns a *NotFoundError when no ImportList entities are found.
+func (ilq *ImportListQuery) Only(ctx context.Context) (*ImportList, error) {
+	nodes, err := ilq.Limit(2).All(setContextOp(ctx, ilq.ctx, "Only"))
+	if err != nil {
+		return nil, err
+	}
+	switch len(nodes) {
+	case 1:
+		return nodes[0], nil
+	case 0:
+		return nil, &NotFoundError{importlist.Label}
+	default:
+		return nil, &NotSingularError{importlist.Label}
+	}
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (ilq *ImportListQuery) OnlyX(ctx context.Context) *ImportList {
+	node, err := ilq.Only(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// OnlyID is like Only, but returns the only ImportList ID in the query.
+// Returns a *NotSingularError when more than one ImportList ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (ilq *ImportListQuery) OnlyID(ctx context.Context) (id int, err error) {
+	var ids []int
+	if ids, err = ilq.Limit(2).IDs(setContextOp(ctx, ilq.ctx, "OnlyID")); err != nil {
+		return
+	}
+	switch len(ids) {
+	case 1:
+		id = ids[0]
+	case 0:
+		err = &NotFoundError{importlist.Label}
+	default:
+		err = &NotSingularError{importlist.Label}
+	}
+	return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (ilq *ImportListQuery) OnlyIDX(ctx context.Context) int {
+	id, err := ilq.OnlyID(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return id
+}
+
+// All executes the query and returns a list of ImportLists.
+func (ilq *ImportListQuery) All(ctx context.Context) ([]*ImportList, error) {
+	ctx = setContextOp(ctx, ilq.ctx, "All")
+	if err := ilq.prepareQuery(ctx); err != nil {
+		return nil, err
+	}
+	qr := querierAll[[]*ImportList, *ImportListQuery]()
+	return withInterceptors[[]*ImportList](ctx, ilq, qr, ilq.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (ilq *ImportListQuery) AllX(ctx context.Context) []*ImportList {
+	nodes, err := ilq.All(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return nodes
+}
+
+// IDs executes the query and returns a list of ImportList IDs.
+func (ilq *ImportListQuery) IDs(ctx context.Context) (ids []int, err error) {
+	if ilq.ctx.Unique == nil && ilq.path != nil {
+		ilq.Unique(true)
+	}
+	ctx = setContextOp(ctx, ilq.ctx, "IDs")
+	if err = ilq.Select(importlist.FieldID).Scan(ctx, &ids); err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (ilq *ImportListQuery) IDsX(ctx context.Context) []int {
+	ids, err := ilq.IDs(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return ids
+}
+
+// Count returns the count of the given query.
+func (ilq *ImportListQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, ilq.ctx, "Count")
+	if err := ilq.prepareQuery(ctx); err != nil {
+		return 0, err
+	}
+	return withInterceptors[int](ctx, ilq, querierCount[*ImportListQuery](), ilq.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (ilq *ImportListQuery) CountX(ctx context.Context) int {
+	count, err := ilq.Count(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (ilq *ImportListQuery) Exist(ctx context.Context) (bool, error) {
+	ctx = setContextOp(ctx, ilq.ctx, "Exist")
+	switch _, err := ilq.FirstID(ctx); {
+	case IsNotFound(err):
+		return false, nil
+	case err != nil:
+		return false, fmt.Errorf("ent: check existence: %w", err)
+	default:
+		return true, nil
+	}
+}
+
+// ExistX is like Exist, but panics if an error occurs.
+func (ilq *ImportListQuery) ExistX(ctx context.Context) bool {
+	exist, err := ilq.Exist(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return exist
+}
+
+// Clone returns a duplicate of the ImportListQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (ilq *ImportListQuery) Clone() *ImportListQuery {
+	if ilq == nil {
+		return nil
+	}
+	return &ImportListQuery{
+		config:     ilq.config,
+		ctx:        ilq.ctx.Clone(),
+		order:      append([]importlist.OrderOption{}, ilq.order...),
+		inters:     append([]Interceptor{}, ilq.inters...),
+		predicates: append([]predicate.ImportList{}, ilq.predicates...),
+		// clone intermediate query.
+		sql:  ilq.sql.Clone(),
+		path: ilq.path,
+	}
+}
+
+// GroupBy is used to group vertices by one or more fields/columns.
+// It is often used with aggregate functions, like: count, max, mean, min, sum.
+//
+// Example:
+//
+//	var v []struct {
+//		Name string `json:"name,omitempty"`
+//		Count int `json:"count,omitempty"`
+//	}
+//
+//	client.ImportList.Query().
+//		GroupBy(importlist.FieldName).
+//		Aggregate(ent.Count()).
+//		Scan(ctx, &v)
+func (ilq *ImportListQuery) GroupBy(field string, fields ...string) *ImportListGroupBy {
+	ilq.ctx.Fields = append([]string{field}, fields...)
+	grbuild := &ImportListGroupBy{build: ilq}
+	grbuild.flds = &ilq.ctx.Fields
+	grbuild.label = importlist.Label
+	grbuild.scan = grbuild.Scan
+	return grbuild
+}
+
+// Select allows the selection one or more fields/columns for the given query,
+// instead of selecting all fields in the entity.
+//
+// Example:
+//
+//	var v []struct {
+//		Name string `json:"name,omitempty"`
+//	}
+//
+//	client.ImportList.Query().
+//		Select(importlist.FieldName).
+//		Scan(ctx, &v)
+func (ilq *ImportListQuery) Select(fields ...string) *ImportListSelect {
+	ilq.ctx.Fields = append(ilq.ctx.Fields, fields...)
+	sbuild := &ImportListSelect{ImportListQuery: ilq}
+	sbuild.label = importlist.Label
+	sbuild.flds, sbuild.scan = &ilq.ctx.Fields, sbuild.Scan
+	return sbuild
+}
+
+// Aggregate returns a ImportListSelect configured with the given aggregations.
+func (ilq *ImportListQuery) Aggregate(fns ...AggregateFunc) *ImportListSelect {
+	return ilq.Select().Aggregate(fns...)
+}
+
+func (ilq *ImportListQuery) prepareQuery(ctx context.Context) error {
+	for _, inter := range ilq.inters {
+		if inter == nil {
+			return fmt.Errorf("ent: uninitialized interceptor (forgotten import ent/runtime?)")
+		}
+		if trv, ok := inter.(Traverser); ok {
+			if err := trv.Traverse(ctx, ilq); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range ilq.ctx.Fields {
+		if !importlist.ValidColumn(f) {
+			return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
+		}
+	}
+	if ilq.path != nil {
+		prev, err := ilq.path(ctx)
+		if err != nil {
+			return err
+		}
+		ilq.sql = prev
+	}
+	return nil
+}
+
+func (ilq *ImportListQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*ImportList, error) {
+	var (
+		nodes = []*ImportList{}
+		_spec = ilq.querySpec()
+	)
+	_spec.ScanValues = func(columns []string) ([]any, error) {
+		return (*ImportList).scanValues(nil, columns)
+	}
+	_spec.Assign = func(columns []string, values []any) error {
+		node := &ImportList{config: ilq.config}
+		nodes = append(nodes, node)
+		return node.assignValues(columns, values)
+	}
+	for i := range hooks {
+		hooks[i](ctx, _spec)
+	}
+	if err := sqlgraph.QueryNodes(ctx, ilq.driver, _spec); err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nodes, nil
+	}
+	return nodes, nil
+}
+
+func (ilq *ImportListQuery) sqlCount(ctx context.Context) (int, error) {
+	_spec := ilq.querySpec()
+	_spec.Node.Columns = ilq.ctx.Fields
+	if len(ilq.ctx.Fields) > 0 {
+		_spec.Unique = ilq.ctx.Unique != nil && *ilq.ctx.Unique
+	}
+	return sqlgraph.CountNodes(ctx, ilq.driver, _spec)
+}
+
+func (ilq *ImportListQuery) querySpec() *sqlgraph.QuerySpec {
+	_spec := sqlgraph.NewQuerySpec(importlist.Table, importlist.Columns, sqlgraph.NewFieldSpec(importlist.FieldID, field.TypeInt))
+	_spec.From = ilq.sql
+	if unique := ilq.ctx.Unique; unique != nil {
+		_spec.Unique = *unique
+	} else if ilq.path != nil {
+		_spec.Unique = true
+	}
+	if fields := ilq.ctx.Fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, importlist.FieldID)
+		for i := range fields {
+			if fields[i] != importlist.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+			}
+		}
+	}
+	if ps := ilq.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if limit := ilq.ctx.Limit; limit != nil {
+		_spec.Limit = *limit
+	}
+	if offset := ilq.ctx.Offset; offset != nil {
+		_spec.Offset = *offset
+	}
+	if ps := ilq.order; len(ps) > 0 {
+		_spec.Order = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	return _spec
+}
+
+func (ilq *ImportListQuery) sqlQuery(ctx context.Context) *sql.Selector {
+	builder := sql.Dialect(ilq.driver.Dialect())
+	t1 := builder.Table(importlist.Table)
+	columns := ilq.ctx.Fields
+	if len(columns) == 0 {
+		columns = importlist.Columns
+	}
+	selector := builder.Select(t1.Columns(columns...)...).From(t1)
+	if ilq.sql != nil {
+		selector = ilq.sql
+		selector.Select(selector.Columns(columns...)...)
+	}
+	if ilq.ctx.Unique != nil && *ilq.ctx.Unique {
+		selector.Distinct()
+	}
+	for _, p := range ilq.predicates {
+		p(selector)
+	}
+	for _, p := range ilq.order {
+		p(selector)
+	}
+	if offset := ilq.ctx.Offset; offset != nil {
+		// limit is mandatory for offset clause. We start
+		// with default value, and override it below if needed.
+		selector.Offset(*offset).Limit(math.MaxInt32)
+	}
+	if limit := ilq.ctx.Limit; limit != nil {
+		selector.Limit(*limit)
+	}
+	return selector
+}
+
+// ImportListGroupBy is the group-by builder for ImportList entities.
+type ImportListGroupBy struct {
+	selector
+	build *ImportListQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (ilgb *ImportListGroupBy) Aggregate(fns ...AggregateFunc) *ImportListGroupBy {
+	ilgb.fns = append(ilgb.fns, fns...)
+	return ilgb
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (ilgb *ImportListGroupBy) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, ilgb.build.ctx, "GroupBy")
+	if err := ilgb.build.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*ImportListQuery, *ImportListGroupBy](ctx, ilgb.build, ilgb, ilgb.build.inters, v)
+}
+
+func (ilgb *ImportListGroupBy) sqlScan(ctx context.Context, root *ImportListQuery, v any) error {
+	selector := root.sqlQuery(ctx).Select()
+	aggregation := make([]string, 0, len(ilgb.fns))
+	for _, fn := range ilgb.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*ilgb.flds)+len(ilgb.fns))
+		for _, f := range *ilgb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*ilgb.flds...)...)
+	if err := selector.Err(); err != nil {
+		return err
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := ilgb.build.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
+
+// ImportListSelect is the builder for selecting fields of ImportList entities.
+type ImportListSelect struct {
+	*ImportListQuery
+	selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (ils *ImportListSelect) Aggregate(fns ...AggregateFunc) *ImportListSelect {
+	ils.fns = append(ils.fns, fns...)
+	return ils
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (ils *ImportListSelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, ils.ctx, "Select")
+	if err := ils.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*ImportListQuery, *ImportListSelect](ctx, ils.ImportListQuery, ils, ils.inters, v)
+}
+
+func (ils *ImportListSelect) sqlScan(ctx context.Context, root *ImportListQuery, v any) error {
+	selector := root.sqlQuery(ctx)
+	aggregation := make([]string, 0, len(ils.fns))
+	for _, fn := range ils.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	switch n := len(*ils.selector.flds); {
+	case n == 0 && len(aggregation) > 0:
+		selector.Select(aggregation...)
+	case n != 0 && len(aggregation) > 0:
+		selector.AppendSelect(aggregation...)
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := ils.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}

ent/importlist_update.go

@@ -0,0 +1,462 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"polaris/ent/importlist"
+	"polaris/ent/predicate"
+	"polaris/ent/schema"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+)
+
+// ImportListUpdate is the builder for updating ImportList entities.
+type ImportListUpdate struct {
+	config
+	hooks    []Hook
+	mutation *ImportListMutation
+}
+
+// Where appends a list predicates to the ImportListUpdate builder.
+func (ilu *ImportListUpdate) Where(ps ...predicate.ImportList) *ImportListUpdate {
+	ilu.mutation.Where(ps...)
+	return ilu
+}
+
+// SetName sets the "name" field.
+func (ilu *ImportListUpdate) SetName(s string) *ImportListUpdate {
+	ilu.mutation.SetName(s)
+	return ilu
+}
+
+// SetNillableName sets the "name" field if the given value is not nil.
+func (ilu *ImportListUpdate) SetNillableName(s *string) *ImportListUpdate {
+	if s != nil {
+		ilu.SetName(*s)
+	}
+	return ilu
+}
+
+// SetType sets the "type" field.
+func (ilu *ImportListUpdate) SetType(i importlist.Type) *ImportListUpdate {
+	ilu.mutation.SetType(i)
+	return ilu
+}
+
+// SetNillableType sets the "type" field if the given value is not nil.
+func (ilu *ImportListUpdate) SetNillableType(i *importlist.Type) *ImportListUpdate {
+	if i != nil {
+		ilu.SetType(*i)
+	}
+	return ilu
+}
+
+// SetURL sets the "url" field.
+func (ilu *ImportListUpdate) SetURL(s string) *ImportListUpdate {
+	ilu.mutation.SetURL(s)
+	return ilu
+}
+
+// SetNillableURL sets the "url" field if the given value is not nil.
+func (ilu *ImportListUpdate) SetNillableURL(s *string) *ImportListUpdate {
+	if s != nil {
+		ilu.SetURL(*s)
+	}
+	return ilu
+}
+
+// ClearURL clears the value of the "url" field.
+func (ilu *ImportListUpdate) ClearURL() *ImportListUpdate {
+	ilu.mutation.ClearURL()
+	return ilu
+}
+
+// SetQulity sets the "qulity" field.
+func (ilu *ImportListUpdate) SetQulity(s string) *ImportListUpdate {
+	ilu.mutation.SetQulity(s)
+	return ilu
+}
+
+// SetNillableQulity sets the "qulity" field if the given value is not nil.
+func (ilu *ImportListUpdate) SetNillableQulity(s *string) *ImportListUpdate {
+	if s != nil {
+		ilu.SetQulity(*s)
+	}
+	return ilu
+}
+
+// SetStorageID sets the "storage_id" field.
+func (ilu *ImportListUpdate) SetStorageID(i int) *ImportListUpdate {
+	ilu.mutation.ResetStorageID()
+	ilu.mutation.SetStorageID(i)
+	return ilu
+}
+
+// SetNillableStorageID sets the "storage_id" field if the given value is not nil.
+func (ilu *ImportListUpdate) SetNillableStorageID(i *int) *ImportListUpdate {
+	if i != nil {
+		ilu.SetStorageID(*i)
+	}
+	return ilu
+}
+
+// AddStorageID adds i to the "storage_id" field.
+func (ilu *ImportListUpdate) AddStorageID(i int) *ImportListUpdate {
+	ilu.mutation.AddStorageID(i)
+	return ilu
+}
+
+// SetSettings sets the "settings" field.
+func (ilu *ImportListUpdate) SetSettings(sls schema.ImportListSettings) *ImportListUpdate {
+	ilu.mutation.SetSettings(sls)
+	return ilu
+}
+
+// SetNillableSettings sets the "settings" field if the given value is not nil.
+func (ilu *ImportListUpdate) SetNillableSettings(sls *schema.ImportListSettings) *ImportListUpdate {
+	if sls != nil {
+		ilu.SetSettings(*sls)
+	}
+	return ilu
+}
+
+// ClearSettings clears the value of the "settings" field.
+func (ilu *ImportListUpdate) ClearSettings() *ImportListUpdate {
+	ilu.mutation.ClearSettings()
+	return ilu
+}
+
+// Mutation returns the ImportListMutation object of the builder.
+func (ilu *ImportListUpdate) Mutation() *ImportListMutation {
+	return ilu.mutation
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (ilu *ImportListUpdate) Save(ctx context.Context) (int, error) {
+	return withHooks(ctx, ilu.sqlSave, ilu.mutation, ilu.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (ilu *ImportListUpdate) SaveX(ctx context.Context) int {
+	affected, err := ilu.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return affected
+}
+
+// Exec executes the query.
+func (ilu *ImportListUpdate) Exec(ctx context.Context) error {
+	_, err := ilu.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (ilu *ImportListUpdate) ExecX(ctx context.Context) {
+	if err := ilu.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (ilu *ImportListUpdate) check() error {
+	if v, ok := ilu.mutation.GetType(); ok {
+		if err := importlist.TypeValidator(v); err != nil {
+			return &ValidationError{Name: "type", err: fmt.Errorf(`ent: validator failed for field "ImportList.type": %w`, err)}
+		}
+	}
+	return nil
+}
+
+func (ilu *ImportListUpdate) sqlSave(ctx context.Context) (n int, err error) {
+	if err := ilu.check(); err != nil {
+		return n, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(importlist.Table, importlist.Columns, sqlgraph.NewFieldSpec(importlist.FieldID, field.TypeInt))
+	if ps := ilu.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := ilu.mutation.Name(); ok {
+		_spec.SetField(importlist.FieldName, field.TypeString, value)
+	}
+	if value, ok := ilu.mutation.GetType(); ok {
+		_spec.SetField(importlist.FieldType, field.TypeEnum, value)
+	}
+	if value, ok := ilu.mutation.URL(); ok {
+		_spec.SetField(importlist.FieldURL, field.TypeString, value)
+	}
+	if ilu.mutation.URLCleared() {
+		_spec.ClearField(importlist.FieldURL, field.TypeString)
+	}
+	if value, ok := ilu.mutation.Qulity(); ok {
+		_spec.SetField(importlist.FieldQulity, field.TypeString, value)
+	}
+	if value, ok := ilu.mutation.StorageID(); ok {
+		_spec.SetField(importlist.FieldStorageID, field.TypeInt, value)
+	}
+	if value, ok := ilu.mutation.AddedStorageID(); ok {
+		_spec.AddField(importlist.FieldStorageID, field.TypeInt, value)
+	}
+	if value, ok := ilu.mutation.Settings(); ok {
+		_spec.SetField(importlist.FieldSettings, field.TypeJSON, value)
+	}
+	if ilu.mutation.SettingsCleared() {
+		_spec.ClearField(importlist.FieldSettings, field.TypeJSON)
+	}
+	if n, err = sqlgraph.UpdateNodes(ctx, ilu.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{importlist.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return 0, err
+	}
+	ilu.mutation.done = true
+	return n, nil
+}
+
+// ImportListUpdateOne is the builder for updating a single ImportList entity.
+type ImportListUpdateOne struct {
+	config
+	fields   []string
+	hooks    []Hook
+	mutation *ImportListMutation
+}
+
+// SetName sets the "name" field.
+func (iluo *ImportListUpdateOne) SetName(s string) *ImportListUpdateOne {
+	iluo.mutation.SetName(s)
+	return iluo
+}
+
+// SetNillableName sets the "name" field if the given value is not nil.
+func (iluo *ImportListUpdateOne) SetNillableName(s *string) *ImportListUpdateOne {
+	if s != nil {
+		iluo.SetName(*s)
+	}
+	return iluo
+}
+
+// SetType sets the "type" field.
+func (iluo *ImportListUpdateOne) SetType(i importlist.Type) *ImportListUpdateOne {
+	iluo.mutation.SetType(i)
+	return iluo
+}
+
+// SetNillableType sets the "type" field if the given value is not nil.
+func (iluo *ImportListUpdateOne) SetNillableType(i *importlist.Type) *ImportListUpdateOne {
+	if i != nil {
+		iluo.SetType(*i)
+	}
+	return iluo
+}
+
+// SetURL sets the "url" field.
+func (iluo *ImportListUpdateOne) SetURL(s string) *ImportListUpdateOne {
+	iluo.mutation.SetURL(s)
+	return iluo
+}
+
+// SetNillableURL sets the "url" field if the given value is not nil.
+func (iluo *ImportListUpdateOne) SetNillableURL(s *string) *ImportListUpdateOne {
+	if s != nil {
+		iluo.SetURL(*s)
+	}
+	return iluo
+}
+
+// ClearURL clears the value of the "url" field.
+func (iluo *ImportListUpdateOne) ClearURL() *ImportListUpdateOne {
+	iluo.mutation.ClearURL()
+	return iluo
+}
+
+// SetQulity sets the "qulity" field.
+func (iluo *ImportListUpdateOne) SetQulity(s string) *ImportListUpdateOne {
+	iluo.mutation.SetQulity(s)
+	return iluo
+}
+
+// SetNillableQulity sets the "qulity" field if the given value is not nil.
+func (iluo *ImportListUpdateOne) SetNillableQulity(s *string) *ImportListUpdateOne {
+	if s != nil {
+		iluo.SetQulity(*s)
+	}
+	return iluo
+}
+
+// SetStorageID sets the "storage_id" field.
+func (iluo *ImportListUpdateOne) SetStorageID(i int) *ImportListUpdateOne {
+	iluo.mutation.ResetStorageID()
+	iluo.mutation.SetStorageID(i)
+	return iluo
+}
+
+// SetNillableStorageID sets the "storage_id" field if the given value is not nil.
+func (iluo *ImportListUpdateOne) SetNillableStorageID(i *int) *ImportListUpdateOne {
+	if i != nil {
+		iluo.SetStorageID(*i)
+	}
+	return iluo
+}
+
+// AddStorageID adds i to the "storage_id" field.
+func (iluo *ImportListUpdateOne) AddStorageID(i int) *ImportListUpdateOne {
+	iluo.mutation.AddStorageID(i)
+	return iluo
+}
+
+// SetSettings sets the "settings" field.
+func (iluo *ImportListUpdateOne) SetSettings(sls schema.ImportListSettings) *ImportListUpdateOne {
+	iluo.mutation.SetSettings(sls)
+	return iluo
+}
+
+// SetNillableSettings sets the "settings" field if the given value is not nil.
+func (iluo *ImportListUpdateOne) SetNillableSettings(sls *schema.ImportListSettings) *ImportListUpdateOne {
+	if sls != nil {
+		iluo.SetSettings(*sls)
+	}
+	return iluo
+}
+
+// ClearSettings clears the value of the "settings" field.
+func (iluo *ImportListUpdateOne) ClearSettings() *ImportListUpdateOne {
+	iluo.mutation.ClearSettings()
+	return iluo
+}
+
+// Mutation returns the ImportListMutation object of the builder.
+func (iluo *ImportListUpdateOne) Mutation() *ImportListMutation {
+	return iluo.mutation
+}
+
+// Where appends a list predicates to the ImportListUpdate builder.
+func (iluo *ImportListUpdateOne) Where(ps ...predicate.ImportList) *ImportListUpdateOne {
+	iluo.mutation.Where(ps...)
+	return iluo
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (iluo *ImportListUpdateOne) Select(field string, fields ...string) *ImportListUpdateOne {
+	iluo.fields = append([]string{field}, fields...)
+	return iluo
+}
+
+// Save executes the query and returns the updated ImportList entity.
+func (iluo *ImportListUpdateOne) Save(ctx context.Context) (*ImportList, error) {
+	return withHooks(ctx, iluo.sqlSave, iluo.mutation, iluo.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (iluo *ImportListUpdateOne) SaveX(ctx context.Context) *ImportList {
+	node, err := iluo.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// Exec executes the query on the entity.
+func (iluo *ImportListUpdateOne) Exec(ctx context.Context) error {
+	_, err := iluo.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (iluo *ImportListUpdateOne) ExecX(ctx context.Context) {
+	if err := iluo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (iluo *ImportListUpdateOne) check() error {
+	if v, ok := iluo.mutation.GetType(); ok {
+		if err := importlist.TypeValidator(v); err != nil {
+			return &ValidationError{Name: "type", err: fmt.Errorf(`ent: validator failed for field "ImportList.type": %w`, err)}
+		}
+	}
+	return nil
+}
+
+func (iluo *ImportListUpdateOne) sqlSave(ctx context.Context) (_node *ImportList, err error) {
+	if err := iluo.check(); err != nil {
+		return _node, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(importlist.Table, importlist.Columns, sqlgraph.NewFieldSpec(importlist.FieldID, field.TypeInt))
+	id, ok := iluo.mutation.ID()
+	if !ok {
+		return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "ImportList.id" for update`)}
+	}
+	_spec.Node.ID.Value = id
+	if fields := iluo.fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, importlist.FieldID)
+		for _, f := range fields {
+			if !importlist.ValidColumn(f) {
+				return nil, &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
+			}
+			if f != importlist.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, f)
+			}
+		}
+	}
+	if ps := iluo.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := iluo.mutation.Name(); ok {
+		_spec.SetField(importlist.FieldName, field.TypeString, value)
+	}
+	if value, ok := iluo.mutation.GetType(); ok {
+		_spec.SetField(importlist.FieldType, field.TypeEnum, value)
+	}
+	if value, ok := iluo.mutation.URL(); ok {
+		_spec.SetField(importlist.FieldURL, field.TypeString, value)
+	}
+	if iluo.mutation.URLCleared() {
+		_spec.ClearField(importlist.FieldURL, field.TypeString)
+	}
+	if value, ok := iluo.mutation.Qulity(); ok {
+		_spec.SetField(importlist.FieldQulity, field.TypeString, value)
+	}
+	if value, ok := iluo.mutation.StorageID(); ok {
+		_spec.SetField(importlist.FieldStorageID, field.TypeInt, value)
+	}
+	if value, ok := iluo.mutation.AddedStorageID(); ok {
+		_spec.AddField(importlist.FieldStorageID, field.TypeInt, value)
+	}
+	if value, ok := iluo.mutation.Settings(); ok {
+		_spec.SetField(importlist.FieldSettings, field.TypeJSON, value)
+	}
+	if iluo.mutation.SettingsCleared() {
+		_spec.ClearField(importlist.FieldSettings, field.TypeJSON)
+	}
+	_node = &ImportList{config: iluo.config}
+	_spec.Assign = _node.assignValues
+	_spec.ScanValues = _node.scanValues
+	if err = sqlgraph.UpdateNode(ctx, iluo.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{importlist.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	iluo.mutation.done = true
+	return _node, nil
+}

ent/migrate/schema.go

@@ -76,6 +76,22 @@ var (
 		Columns:    HistoriesColumns,
 		PrimaryKey: []*schema.Column{HistoriesColumns[0]},
 	}
+	// ImportListsColumns holds the columns for the "import_lists" table.
+	ImportListsColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeInt, Increment: true},
+		{Name: "name", Type: field.TypeString},
+		{Name: "type", Type: field.TypeEnum, Enums: []string{"plex", "doulist"}},
+		{Name: "url", Type: field.TypeString, Nullable: true},
+		{Name: "qulity", Type: field.TypeString},
+		{Name: "storage_id", Type: field.TypeInt},
+		{Name: "settings", Type: field.TypeJSON, Nullable: true},
+	}
+	// ImportListsTable holds the schema information for the "import_lists" table.
+	ImportListsTable = &schema.Table{
+		Name:       "import_lists",
+		Columns:    ImportListsColumns,
+		PrimaryKey: []*schema.Column{ImportListsColumns[0]},
+	}
 	// IndexersColumns holds the columns for the "indexers" table.
 	IndexersColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeInt, Increment: true},
@@ -166,6 +182,7 @@ var (
 		DownloadClientsTable,
 		EpisodesTable,
 		HistoriesTable,
+		ImportListsTable,
 		IndexersTable,
 		MediaTable,
 		NotificationClientsTable,

ent/mutation.go

@@ -9,6 +9,7 @@ import (
 	"polaris/ent/downloadclients"
 	"polaris/ent/episode"
 	"polaris/ent/history"
+	"polaris/ent/importlist"
 	"polaris/ent/indexers"
 	"polaris/ent/media"
 	"polaris/ent/notificationclient"
@@ -35,6 +36,7 @@ const (
 	TypeDownloadClients    = "DownloadClients"
 	TypeEpisode            = "Episode"
 	TypeHistory            = "History"
+	TypeImportList         = "ImportList"
 	TypeIndexers           = "Indexers"
 	TypeMedia              = "Media"
 	TypeNotificationClient = "NotificationClient"
@@ -2892,6 +2894,679 @@ func (m *HistoryMutation) ResetEdge(name string) error {
 	return fmt.Errorf("unknown History edge %s", name)
 }
 
+// ImportListMutation represents an operation that mutates the ImportList nodes in the graph.
+type ImportListMutation struct {
+	config
+	op            Op
+	typ           string
+	id            *int
+	name          *string
+	_type         *importlist.Type
+	url           *string
+	qulity        *string
+	storage_id    *int
+	addstorage_id *int
+	settings      *schema.ImportListSettings
+	clearedFields map[string]struct{}
+	done          bool
+	oldValue      func(context.Context) (*ImportList, error)
+	predicates    []predicate.ImportList
+}
+
+var _ ent.Mutation = (*ImportListMutation)(nil)
+
+// importlistOption allows management of the mutation configuration using functional options.
+type importlistOption func(*ImportListMutation)
+
+// newImportListMutation creates new mutation for the ImportList entity.
+func newImportListMutation(c config, op Op, opts ...importlistOption) *ImportListMutation {
+	m := &ImportListMutation{
+		config:        c,
+		op:            op,
+		typ:           TypeImportList,
+		clearedFields: make(map[string]struct{}),
+	}
+	for _, opt := range opts {
+		opt(m)
+	}
+	return m
+}
+
+// withImportListID sets the ID field of the mutation.
+func withImportListID(id int) importlistOption {
+	return func(m *ImportListMutation) {
+		var (
+			err   error
+			once  sync.Once
+			value *ImportList
+		)
+		m.oldValue = func(ctx context.Context) (*ImportList, error) {
+			once.Do(func() {
+				if m.done {
+					err = errors.New("querying old values post mutation is not allowed")
+				} else {
+					value, err = m.Client().ImportList.Get(ctx, id)
+				}
+			})
+			return value, err
+		}
+		m.id = &id
+	}
+}
+
+// withImportList sets the old ImportList of the mutation.
+func withImportList(node *ImportList) importlistOption {
+	return func(m *ImportListMutation) {
+		m.oldValue = func(context.Context) (*ImportList, error) {
+			return node, nil
+		}
+		m.id = &node.ID
+	}
+}
+
+// Client returns a new `ent.Client` from the mutation. If the mutation was
+// executed in a transaction (ent.Tx), a transactional client is returned.
+func (m ImportListMutation) Client() *Client {
+	client := &Client{config: m.config}
+	client.init()
+	return client
+}
+
+// Tx returns an `ent.Tx` for mutations that were executed in transactions;
+// it returns an error otherwise.
+func (m ImportListMutation) Tx() (*Tx, error) {
+	if _, ok := m.driver.(*txDriver); !ok {
+		return nil, errors.New("ent: mutation is not running in a transaction")
+	}
+	tx := &Tx{config: m.config}
+	tx.init()
+	return tx, nil
+}
+
+// ID returns the ID value in the mutation. Note that the ID is only available
+// if it was provided to the builder or after it was returned from the database.
+func (m *ImportListMutation) ID() (id int, exists bool) {
+	if m.id == nil {
+		return
+	}
+	return *m.id, true
+}
+
+// IDs queries the database and returns the entity ids that match the mutation's predicate.
+// That means, if the mutation is applied within a transaction with an isolation level such
+// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
+// or updated by the mutation.
+func (m *ImportListMutation) IDs(ctx context.Context) ([]int, error) {
+	switch {
+	case m.op.Is(OpUpdateOne | OpDeleteOne):
+		id, exists := m.ID()
+		if exists {
+			return []int{id}, nil
+		}
+		fallthrough
+	case m.op.Is(OpUpdate | OpDelete):
+		return m.Client().ImportList.Query().Where(m.predicates...).IDs(ctx)
+	default:
+		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
+	}
+}
+
+// SetName sets the "name" field.
+func (m *ImportListMutation) SetName(s string) {
+	m.name = &s
+}
+
+// Name returns the value of the "name" field in the mutation.
+func (m *ImportListMutation) Name() (r string, exists bool) {
+	v := m.name
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldName returns the old "name" field's value of the ImportList entity.
+// If the ImportList object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *ImportListMutation) OldName(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldName is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldName requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldName: %w", err)
+	}
+	return oldValue.Name, nil
+}
+
+// ResetName resets all changes to the "name" field.
+func (m *ImportListMutation) ResetName() {
+	m.name = nil
+}
+
+// SetType sets the "type" field.
+func (m *ImportListMutation) SetType(i importlist.Type) {
+	m._type = &i
+}
+
+// GetType returns the value of the "type" field in the mutation.
+func (m *ImportListMutation) GetType() (r importlist.Type, exists bool) {
+	v := m._type
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldType returns the old "type" field's value of the ImportList entity.
+// If the ImportList object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *ImportListMutation) OldType(ctx context.Context) (v importlist.Type, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldType is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldType requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldType: %w", err)
+	}
+	return oldValue.Type, nil
+}
+
+// ResetType resets all changes to the "type" field.
+func (m *ImportListMutation) ResetType() {
+	m._type = nil
+}
+
+// SetURL sets the "url" field.
+func (m *ImportListMutation) SetURL(s string) {
+	m.url = &s
+}
+
+// URL returns the value of the "url" field in the mutation.
+func (m *ImportListMutation) URL() (r string, exists bool) {
+	v := m.url
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldURL returns the old "url" field's value of the ImportList entity.
+// If the ImportList object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *ImportListMutation) OldURL(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldURL is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldURL requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldURL: %w", err)
+	}
+	return oldValue.URL, nil
+}
+
+// ClearURL clears the value of the "url" field.
+func (m *ImportListMutation) ClearURL() {
+	m.url = nil
+	m.clearedFields[importlist.FieldURL] = struct{}{}
+}
+
+// URLCleared returns if the "url" field was cleared in this mutation.
+func (m *ImportListMutation) URLCleared() bool {
+	_, ok := m.clearedFields[importlist.FieldURL]
+	return ok
+}
+
+// ResetURL resets all changes to the "url" field.
+func (m *ImportListMutation) ResetURL() {
+	m.url = nil
+	delete(m.clearedFields, importlist.FieldURL)
+}
+
+// SetQulity sets the "qulity" field.
+func (m *ImportListMutation) SetQulity(s string) {
+	m.qulity = &s
+}
+
+// Qulity returns the value of the "qulity" field in the mutation.
+func (m *ImportListMutation) Qulity() (r string, exists bool) {
+	v := m.qulity
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldQulity returns the old "qulity" field's value of the ImportList entity.
+// If the ImportList object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *ImportListMutation) OldQulity(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldQulity is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldQulity requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldQulity: %w", err)
+	}
+	return oldValue.Qulity, nil
+}
+
+// ResetQulity resets all changes to the "qulity" field.
+func (m *ImportListMutation) ResetQulity() {
+	m.qulity = nil
+}
+
+// SetStorageID sets the "storage_id" field.
+func (m *ImportListMutation) SetStorageID(i int) {
+	m.storage_id = &i
+	m.addstorage_id = nil
+}
+
+// StorageID returns the value of the "storage_id" field in the mutation.
+func (m *ImportListMutation) StorageID() (r int, exists bool) {
+	v := m.storage_id
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldStorageID returns the old "storage_id" field's value of the ImportList entity.
+// If the ImportList object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *ImportListMutation) OldStorageID(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldStorageID is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldStorageID requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldStorageID: %w", err)
+	}
+	return oldValue.StorageID, nil
+}
+
+// AddStorageID adds i to the "storage_id" field.
+func (m *ImportListMutation) AddStorageID(i int) {
+	if m.addstorage_id != nil {
+		*m.addstorage_id += i
+	} else {
+		m.addstorage_id = &i
+	}
+}
+
+// AddedStorageID returns the value that was added to the "storage_id" field in this mutation.
+func (m *ImportListMutation) AddedStorageID() (r int, exists bool) {
+	v := m.addstorage_id
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetStorageID resets all changes to the "storage_id" field.
+func (m *ImportListMutation) ResetStorageID() {
+	m.storage_id = nil
+	m.addstorage_id = nil
+}
+
+// SetSettings sets the "settings" field.
+func (m *ImportListMutation) SetSettings(sls schema.ImportListSettings) {
+	m.settings = &sls
+}
+
+// Settings returns the value of the "settings" field in the mutation.
+func (m *ImportListMutation) Settings() (r schema.ImportListSettings, exists bool) {
+	v := m.settings
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldSettings returns the old "settings" field's value of the ImportList entity.
+// If the ImportList object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *ImportListMutation) OldSettings(ctx context.Context) (v schema.ImportListSettings, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldSettings is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldSettings requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldSettings: %w", err)
+	}
+	return oldValue.Settings, nil
+}
+
+// ClearSettings clears the value of the "settings" field.
+func (m *ImportListMutation) ClearSettings() {
+	m.settings = nil
+	m.clearedFields[importlist.FieldSettings] = struct{}{}
+}
+
+// SettingsCleared returns if the "settings" field was cleared in this mutation.
+func (m *ImportListMutation) SettingsCleared() bool {
+	_, ok := m.clearedFields[importlist.FieldSettings]
+	return ok
+}
+
+// ResetSettings resets all changes to the "settings" field.
+func (m *ImportListMutation) ResetSettings() {
+	m.settings = nil
+	delete(m.clearedFields, importlist.FieldSettings)
+}
+
+// Where appends a list predicates to the ImportListMutation builder.
+func (m *ImportListMutation) Where(ps ...predicate.ImportList) {
+	m.predicates = append(m.predicates, ps...)
+}
+
+// WhereP appends storage-level predicates to the ImportListMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *ImportListMutation) WhereP(ps ...func(*sql.Selector)) {
+	p := make([]predicate.ImportList, len(ps))
+	for i := range ps {
+		p[i] = ps[i]
+	}
+	m.Where(p...)
+}
+
+// Op returns the operation name.
+func (m *ImportListMutation) Op() Op {
+	return m.op
+}
+
+// SetOp allows setting the mutation operation.
+func (m *ImportListMutation) SetOp(op Op) {
+	m.op = op
+}
+
+// Type returns the node type of this mutation (ImportList).
+func (m *ImportListMutation) Type() string {
+	return m.typ
+}
+
+// Fields returns all fields that were changed during this mutation. Note that in
+// order to get all numeric fields that were incremented/decremented, call
+// AddedFields().
+func (m *ImportListMutation) Fields() []string {
+	fields := make([]string, 0, 6)
+	if m.name != nil {
+		fields = append(fields, importlist.FieldName)
+	}
+	if m._type != nil {
+		fields = append(fields, importlist.FieldType)
+	}
+	if m.url != nil {
+		fields = append(fields, importlist.FieldURL)
+	}
+	if m.qulity != nil {
+		fields = append(fields, importlist.FieldQulity)
+	}
+	if m.storage_id != nil {
+		fields = append(fields, importlist.FieldStorageID)
+	}
+	if m.settings != nil {
+		fields = append(fields, importlist.FieldSettings)
+	}
+	return fields
+}
+
+// Field returns the value of a field with the given name. The second boolean
+// return value indicates that this field was not set, or was not defined in the
+// schema.
+func (m *ImportListMutation) Field(name string) (ent.Value, bool) {
+	switch name {
+	case importlist.FieldName:
+		return m.Name()
+	case importlist.FieldType:
+		return m.GetType()
+	case importlist.FieldURL:
+		return m.URL()
+	case importlist.FieldQulity:
+		return m.Qulity()
+	case importlist.FieldStorageID:
+		return m.StorageID()
+	case importlist.FieldSettings:
+		return m.Settings()
+	}
+	return nil, false
+}
+
+// OldField returns the old value of the field from the database. An error is
+// returned if the mutation operation is not UpdateOne, or the query to the
+// database failed.
+func (m *ImportListMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
+	switch name {
+	case importlist.FieldName:
+		return m.OldName(ctx)
+	case importlist.FieldType:
+		return m.OldType(ctx)
+	case importlist.FieldURL:
+		return m.OldURL(ctx)
+	case importlist.FieldQulity:
+		return m.OldQulity(ctx)
+	case importlist.FieldStorageID:
+		return m.OldStorageID(ctx)
+	case importlist.FieldSettings:
+		return m.OldSettings(ctx)
+	}
+	return nil, fmt.Errorf("unknown ImportList field %s", name)
+}
+
+// SetField sets the value of a field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *ImportListMutation) SetField(name string, value ent.Value) error {
+	switch name {
+	case importlist.FieldName:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetName(v)
+		return nil
+	case importlist.FieldType:
+		v, ok := value.(importlist.Type)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetType(v)
+		return nil
+	case importlist.FieldURL:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetURL(v)
+		return nil
+	case importlist.FieldQulity:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetQulity(v)
+		return nil
+	case importlist.FieldStorageID:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetStorageID(v)
+		return nil
+	case importlist.FieldSettings:
+		v, ok := value.(schema.ImportListSettings)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetSettings(v)
+		return nil
+	}
+	return fmt.Errorf("unknown ImportList field %s", name)
+}
+
+// AddedFields returns all numeric fields that were incremented/decremented during
+// this mutation.
+func (m *ImportListMutation) AddedFields() []string {
+	var fields []string
+	if m.addstorage_id != nil {
+		fields = append(fields, importlist.FieldStorageID)
+	}
+	return fields
+}
+
+// AddedField returns the numeric value that was incremented/decremented on a field
+// with the given name. The second boolean return value indicates that this field
+// was not set, or was not defined in the schema.
+func (m *ImportListMutation) AddedField(name string) (ent.Value, bool) {
+	switch name {
+	case importlist.FieldStorageID:
+		return m.AddedStorageID()
+	}
+	return nil, false
+}
+
+// AddField adds the value to the field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *ImportListMutation) AddField(name string, value ent.Value) error {
+	switch name {
+	case importlist.FieldStorageID:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddStorageID(v)
+		return nil
+	}
+	return fmt.Errorf("unknown ImportList numeric field %s", name)
+}
+
+// ClearedFields returns all nullable fields that were cleared during this
+// mutation.
+func (m *ImportListMutation) ClearedFields() []string {
+	var fields []string
+	if m.FieldCleared(importlist.FieldURL) {
+		fields = append(fields, importlist.FieldURL)
+	}
+	if m.FieldCleared(importlist.FieldSettings) {
+		fields = append(fields, importlist.FieldSettings)
+	}
+	return fields
+}
+
+// FieldCleared returns a boolean indicating if a field with the given name was
+// cleared in this mutation.
+func (m *ImportListMutation) FieldCleared(name string) bool {
+	_, ok := m.clearedFields[name]
+	return ok
+}
+
+// ClearField clears the value of the field with the given name. It returns an
+// error if the field is not defined in the schema.
+func (m *ImportListMutation) ClearField(name string) error {
+	switch name {
+	case importlist.FieldURL:
+		m.ClearURL()
+		return nil
+	case importlist.FieldSettings:
+		m.ClearSettings()
+		return nil
+	}
+	return fmt.Errorf("unknown ImportList nullable field %s", name)
+}
+
+// ResetField resets all changes in the mutation for the field with the given name.
+// It returns an error if the field is not defined in the schema.
+func (m *ImportListMutation) ResetField(name string) error {
+	switch name {
+	case importlist.FieldName:
+		m.ResetName()
+		return nil
+	case importlist.FieldType:
+		m.ResetType()
+		return nil
+	case importlist.FieldURL:
+		m.ResetURL()
+		return nil
+	case importlist.FieldQulity:
+		m.ResetQulity()
+		return nil
+	case importlist.FieldStorageID:
+		m.ResetStorageID()
+		return nil
+	case importlist.FieldSettings:
+		m.ResetSettings()
+		return nil
+	}
+	return fmt.Errorf("unknown ImportList field %s", name)
+}
+
+// AddedEdges returns all edge names that were set/added in this mutation.
+func (m *ImportListMutation) AddedEdges() []string {
+	edges := make([]string, 0, 0)
+	return edges
+}
+
+// AddedIDs returns all IDs (to other nodes) that were added for the given edge
+// name in this mutation.
+func (m *ImportListMutation) AddedIDs(name string) []ent.Value {
+	return nil
+}
+
+// RemovedEdges returns all edge names that were removed in this mutation.
+func (m *ImportListMutation) RemovedEdges() []string {
+	edges := make([]string, 0, 0)
+	return edges
+}
+
+// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
+// the given name in this mutation.
+func (m *ImportListMutation) RemovedIDs(name string) []ent.Value {
+	return nil
+}
+
+// ClearedEdges returns all edge names that were cleared in this mutation.
+func (m *ImportListMutation) ClearedEdges() []string {
+	edges := make([]string, 0, 0)
+	return edges
+}
+
+// EdgeCleared returns a boolean which indicates if the edge with the given name
+// was cleared in this mutation.
+func (m *ImportListMutation) EdgeCleared(name string) bool {
+	return false
+}
+
+// ClearEdge clears the value of the edge with the given name. It returns an error
+// if that edge is not defined in the schema.
+func (m *ImportListMutation) ClearEdge(name string) error {
+	return fmt.Errorf("unknown ImportList unique edge %s", name)
+}
+
+// ResetEdge resets all changes to the edge with the given name in this mutation.
+// It returns an error if the edge is not defined in the schema.
+func (m *ImportListMutation) ResetEdge(name string) error {
+	return fmt.Errorf("unknown ImportList edge %s", name)
+}
+
 // IndexersMutation represents an operation that mutates the Indexers nodes in the graph.
 type IndexersMutation struct {
 	config

ent/predicate/predicate.go

@@ -15,6 +15,9 @@ type Episode func(*sql.Selector)
 // History is the predicate function for history builders.
 type History func(*sql.Selector)
 
+// ImportList is the predicate function for importlist builders.
+type ImportList func(*sql.Selector)
+
 // Indexers is the predicate function for indexers builders.
 type Indexers func(*sql.Selector)
 

ent/schema/importlist.go

@@ -0,0 +1,32 @@
+package schema
+
+import (
+	"entgo.io/ent"
+	"entgo.io/ent/schema/field"
+)
+
+// ImportList holds the schema definition for the ImportList entity.
+type ImportList struct {
+	ent.Schema
+}
+
+// Fields of the ImportList.
+func (ImportList) Fields() []ent.Field {
+	return []ent.Field{
+		field.String("name"),
+		field.Enum("type").Values("plex", "doulist"),
+		field.String("url").Optional(),
+		field.String("qulity"),
+		field.Int("storage_id"),
+		field.JSON("settings", ImportListSettings{}).Optional(),
+	}
+}
+
+// Edges of the ImportList.
+func (ImportList) Edges() []ent.Edge {
+	return nil
+}
+
+type ImportListSettings struct {
+	//Url string `json:"url"`
+}

ent/tx.go

@@ -18,6 +18,8 @@ type Tx struct {
 	Episode *EpisodeClient
 	// History is the client for interacting with the History builders.
 	History *HistoryClient
+	// ImportList is the client for interacting with the ImportList builders.
+	ImportList *ImportListClient
 	// Indexers is the client for interacting with the Indexers builders.
 	Indexers *IndexersClient
 	// Media is the client for interacting with the Media builders.
@@ -162,6 +164,7 @@ func (tx *Tx) init() {
 	tx.DownloadClients = NewDownloadClientsClient(tx.config)
 	tx.Episode = NewEpisodeClient(tx.config)
 	tx.History = NewHistoryClient(tx.config)
+	tx.ImportList = NewImportListClient(tx.config)
 	tx.Indexers = NewIndexersClient(tx.config)
 	tx.Media = NewMediaClient(tx.config)
 	tx.NotificationClient = NewNotificationClientClient(tx.config)

go.mod

@@ -19,6 +19,8 @@ require (
 
 require (
 	github.com/BurntSushi/toml v1.4.0 // indirect
+	github.com/PuerkitoBio/goquery v1.9.2 // indirect
+	github.com/andybalholm/cascadia v1.3.2 // indirect
 	github.com/blinkbean/dingtalk v1.1.3 // indirect
 	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
 	github.com/go-telegram-bot-api/telegram-bot-api v4.6.4+incompatible // indirect

go.sum

@@ -6,8 +6,12 @@ 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.0 h1:Shsta01QNfFxHCfpW6YH2STWB0MudeXXEWMr20OEh60=
 github.com/DATA-DOG/go-sqlmock v1.5.0/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM=
+github.com/PuerkitoBio/goquery v1.9.2 h1:4/wZksC3KgkQw7SQgkKotmKljk0M6V8TUvA8Wb4yPeE=
+github.com/PuerkitoBio/goquery v1.9.2/go.mod h1:GHPCaP0ODyyxqcNoFGYlAprUFH81NuRPd0GX3Zu2Mvk=
 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/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/blinkbean/dingtalk v1.1.3 h1:MbidFZYom7DTFHD/YIs+eaI7kRy52kmWE/sy0xjo6E4=
@@ -172,6 +176,7 @@ github.com/ugorji/go/codec v1.2.12 h1:9LC83zGrHhuUA9l16C9AHXAqEV/2wBQ4nkvumAE65E
 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/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.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
@@ -184,31 +189,59 @@ golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUu
 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-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.25.0 h1:ypSNr+bnYL2YhwoMt2zPxHFmbAN1KZs/njMG3hxUp30=
 golang.org/x/crypto v0.25.0/go.mod h1:T+wALwcMOSE0kXgUAnPAHqTLW+XHgcELELW8VaDgm/M=
 golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 h1:2dVuKD2vS7b0QIHQbpyTISPd0LeHDbnYEryqj5Q1ug8=
 golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56/go.mod h1:M4RDyNAINzryxdtnbRXRL/OHtkFuWGRjvuhBJpk2IlY=
+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/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
+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-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/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
 golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.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.22.0 h1:RI27ohtqKCnwULzJLqkv897zojh5/DwS/ENaMzUOaWI=
 golang.org/x/sys v0.22.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
+golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY=
 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.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
 golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
 golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
 golang.org/x/tools v0.23.0 h1:SGsXPZ+2l4JsgaCKkx+FQ9YZ5XEtA1GZYuoDjenLjvg=
 golang.org/x/tools v0.23.0/go.mod h1:pnu6ufv6vQkll6szChhK3C3L/ruaIv5eBeztNG8wtsI=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 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=

pkg/doc.go

@@ -1,14 +1,14 @@
 package pkg
 
 type Torrent interface {
-	Name() string
-	Progress() int
+	Name() (string, error)
+	Progress() (int, error)
 	Stop() error
 	Start() error
 	Remove() error
 	Save() string
 	Exists() bool
-	SeedRatio() *float64
+	SeedRatio() (float64, error)
 }
 
 

pkg/importlist/douban/douban.go

@@ -0,0 +1,100 @@
+package douban
+
+import (
+	"fmt"
+	"net/http"
+	"polaris/log"
+	"polaris/pkg/importlist"
+	"strconv"
+	"strings"
+
+	"github.com/PuerkitoBio/goquery"
+)
+
+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"
+
+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)
+	if err != nil {
+		return nil, err
+	}
+	defer res.Body.Close()
+	if res.StatusCode != 200 {
+		return nil, fmt.Errorf("status code error: %d %s", res.StatusCode, res.Status)
+
+	}
+	doc, err := goquery.NewDocumentFromReader(res.Body)
+	if err != nil {
+		return nil, err
+	}
+	doc.Find("div[class=doulist-item]").Each(func(i int, selection *goquery.Selection) {
+		titleDiv := selection.Find("div[class=title]")
+		link := titleDiv.Find("div>a")
+		href, ok := link.Attr("href")
+		if !ok {
+			return
+		}
+		abstract := selection.Find("div[class=abstract]")
+
+		lines := strings.Split(abstract.Text(), "\n")
+		year := 0
+		for _, l := range lines {
+			if strings.Contains(l, "年份") {
+				ppp := strings.Split(l, ":")
+				if len(ppp) < 2 {
+					continue
+				} else {
+					n := ppp[1]
+					n1, err := strconv.Atoi(strings.TrimSpace(n))
+					if err != nil {
+						log.Errorf("convert year number %s to int error: %v", n, err)
+						continue
+					}
+					year = n1
+				}
+			}
+		}
+
+		item := importlist.Item{
+			Title: strings.TrimSpace(link.Text()),
+			Year:  year,
+		}
+		_ = item
+		println(link.Text(), href)
+	})
+	return nil, 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)
+
+	res, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return "", err
+	}
+	defer res.Body.Close()
+	if res.StatusCode != 200 {
+		return "", fmt.Errorf("status code error: %d %s", res.StatusCode, res.Status)
+
+	}
+	doc, err := goquery.NewDocumentFromReader(res.Body)
+	if err != nil {
+		return "", err
+	}
+	_ = doc
+	return "", nil
+}

pkg/importlist/douban/douban_test.go

@@ -0,0 +1,11 @@
+package douban
+
+import (
+	"polaris/log"
+	"testing"
+)
+
+func TestParseDoulist(t *testing.T) {
+	r, err := ParseDoulist("https://www.douban.com/doulist/166422/")
+	log.Info(r, err)
+}

pkg/importlist/importlist.go

@@ -0,0 +1,13 @@
+package importlist
+
+type Item struct {
+	Title  string
+	Year   int
+	ImdbID string
+	TvdbID string
+	TmdbID string
+}
+
+type Response struct {
+	Items []Item
+}

pkg/importlist/plexwatchlist/plex.go

@@ -0,0 +1,96 @@
+package plexwatchlist
+
+import (
+	"encoding/xml"
+	"io"
+	"net/http"
+	"polaris/pkg/importlist"
+	"strings"
+
+	"github.com/pkg/errors"
+)
+
+type Response struct {
+	XMLName xml.Name `xml:"rss"`
+	Text    string   `xml:",chardata"`
+	Atom    string   `xml:"atom,attr"`
+	Media   string   `xml:"media,attr"`
+	Version string   `xml:"version,attr"`
+	Channel struct {
+		Text  string `xml:",chardata"`
+		Title string `xml:"title"`
+		Link  struct {
+			Text string `xml:",chardata"`
+			Href string `xml:"href,attr"`
+			Rel  string `xml:"rel,attr"`
+			Type string `xml:"type,attr"`
+		} `xml:"link"`
+		Description string `xml:"description"`
+		Category    string `xml:"category"`
+		Item        []struct {
+			Text        string `xml:",chardata"`
+			Title       string `xml:"title"`
+			PubDate     string `xml:"pubDate"`
+			Link        string `xml:"link"`
+			Description string `xml:"description"`
+			Category    string `xml:"category"`
+			Credit      []struct {
+				Text string `xml:",chardata"`
+				Role string `xml:"role,attr"`
+			} `xml:"credit"`
+			Thumbnail struct {
+				Text string `xml:",chardata"`
+				URL  string `xml:"url,attr"`
+			} `xml:"thumbnail"`
+			Keywords string `xml:"keywords"`
+			Rating   struct {
+				Text   string `xml:",chardata"`
+				Scheme string `xml:"scheme,attr"`
+			} `xml:"rating"`
+			Guid struct {
+				Text        string `xml:",chardata"`
+				IsPermaLink string `xml:"isPermaLink,attr"`
+			} `xml:"guid"`
+		} `xml:"item"`
+	} `xml:"channel"`
+}
+
+func (r *Response) convert() *importlist.Response {
+	res := &importlist.Response{}
+	for _, im := range r.Channel.Item {
+		item := importlist.Item{
+			Title: im.Title,
+		}
+		id := strings.ToLower(im.Guid.Text)
+		if strings.HasPrefix(id, "tvdb") {
+			tvdbid := strings.TrimPrefix(id, "tvdb://")
+			item.TvdbID = tvdbid
+		} else if strings.HasPrefix(id, "imdb") {
+			imdbid := strings.TrimPrefix(id, "imdb://")
+			item.ImdbID = imdbid
+		} else if strings.HasPrefix(id, "tmdb") {
+			tmdbid := strings.TrimPrefix(id, "tmdb://")
+			item.TmdbID = tmdbid
+		}
+		res.Items = append(res.Items, item)
+	}
+	return res
+}
+
+func ParsePlexWatchlist(url string) (*importlist.Response, error) {
+	resp, err := http.Get(url)
+	if err != nil {
+		return nil, errors.Wrap(err, "http get")
+	}
+	defer resp.Body.Close()
+	data, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, errors.Wrap(err, "read data")
+	}
+	var rrr Response
+	err = xml.Unmarshal(data, &rrr)
+	if err != nil {
+		return nil, errors.Wrap(err, "xml")
+	}
+	return rrr.convert(), nil
+}

pkg/metadata/tv.go

@@ -2,6 +2,7 @@ package metadata
 
 import (
 	"fmt"
+	"polaris/log"
 	"polaris/pkg/utils"
 	"regexp"
 	"strconv"
@@ -170,7 +171,7 @@ func parseChineseName(name string) *Metadata {
 	}
 
 	//episode number
-	re1 := regexp.MustCompile(`\[\d{1,2}\]`)
+	re1 := regexp.MustCompile(`\[\d{1,3}\]`)
 	episodeMatches1 := re1.FindAllString(name, -1)
 	if len(episodeMatches1) > 0 { //[11] [1080p]
 		epNum := strings.TrimRight(strings.TrimLeft(episodeMatches1[0], "["), "]")
@@ -228,12 +229,17 @@ func parseChineseName(name string) *Metadata {
 			}
 			meta.Season = n
 		} else {
-			seasonRe1 := regexp.MustCompile(`第.{1}季`)
+			seasonRe1 := regexp.MustCompile(`第.{1,2}季`)
 			seasonMatches := seasonRe1.FindAllString(name, -1)
 			if len(seasonMatches) > 0 {
-				se := []rune(seasonMatches[0])
-				seNum := se[1]
-				meta.Season = chinese2Num[string(seNum)]
+				m1 := []rune(seasonMatches[0])
+				seNum := m1[1 : len(m1)-1]
+				n, err := strconv.Atoi(string(seNum))
+				if err != nil {
+					log.Warnf("parse season number %v error: %v, try to parse using chinese", seNum, err)
+					n = chinese2Num[string(seNum)]
+				}
+				meta.Season = n
 
 			}
 		}
@@ -245,24 +251,29 @@ func parseChineseName(name string) *Metadata {
 	}
 
 	//tv name
-	title := name
 
-	fields := strings.FieldsFunc(title, func(r rune) bool {
+	fields := strings.FieldsFunc(name, func(r rune) bool {
 		return r == '[' || r == ']' || r == '【' || r == '】'
 	})
-	title = ""
+	titleCn := ""
+	title := ""
 	for _, p := range fields { //寻找匹配的最长的字符串，最有可能是名字
-		if len([]rune(p)) > len([]rune(title)) {
+		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)), "")
+	title = re.ReplaceAllString(strings.TrimSpace(strings.ToLower(title)), "") //去除标点符号
+	titleCn = re.ReplaceAllString(strings.TrimSpace(strings.ToLower(titleCn)), "")
 
-	meta.NameCn = title
+	meta.NameCn = titleCn
 	cnRe := regexp.MustCompile(`\p{Han}.*\p{Han}`)
-	cnmatches := cnRe.FindAllString(title, -1)
+	cnmatches := cnRe.FindAllString(titleCn, -1)
 
+	//titleCn中最长的中文字符
 	if len(cnmatches) > 0 {
 		for _, t := range cnmatches {
 			if len([]rune(t)) > len([]rune(meta.NameCn)) {
@@ -271,12 +282,13 @@ func parseChineseName(name string) *Metadata {
 		}
 	}
 
+	//匹配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.ToLower(t)
+				meta.NameEn = strings.TrimSpace(strings.ToLower(t))
 			}
 		}
 	}

pkg/metadata/tv_test.go

@@ -137,11 +137,11 @@ func Test_ParseTV13(t *testing.T) {
 }
 
 func Test_ParseTV14(t *testing.T) {
-	s1 := ""
+	s1 := "[GM-Team][国漫][斗破苍穹 第5季][Fights Break Sphere Ⅴ][2022][113][HEVC][GB][4K]"
 	m := ParseTv(s1)
 	log.Infof("results: %+v", m)
-	assert.Equal(t, 2, m.Season)
-	assert.Equal(t, 01, m.Episode)
+	assert.Equal(t, 5, m.Season)
+	assert.Equal(t, 113, m.Episode)
 	assert.Equal(t, false, m.IsSeasonPack)
-	assert.Equal(t, "720p", m.Resolution)
-}
+	//assert.Equal(t, "720p", m.Resolution)
+}

pkg/tmdb/tmdb.go

@@ -13,8 +13,8 @@ import (
 )
 
 type Client struct {
-	apiKey     string
-	tmdbClient *tmdb.Client
+	apiKey             string
+	tmdbClient         *tmdb.Client
 	enableAdultContent bool
 }
 
@@ -43,8 +43,8 @@ func NewClient(apiKey, proxyUrl string, enableAdultContent bool) (*Client, error
 	}
 
 	return &Client{
-		apiKey:     apiKey,
-		tmdbClient: tmdbClient,
+		apiKey:             apiKey,
+		tmdbClient:         tmdbClient,
 		enableAdultContent: enableAdultContent,
 	}, nil
 }
@@ -59,7 +59,7 @@ func (c *Client) GetTvDetails(id int, language string) (*tmdb.TVDetails, error)
 	if !episodeNameUseful(d.LastEpisodeToAir.Name) {
 		log.Debug("should fetch english version")
 		var detailEN *tmdb.TVDetails
-		if language == "zh-CN" {
+		if language == "zh-CN" || language == "" {
 			detailEN, err = c.tmdbClient.GetTVDetails(id, withExternalIDs(withLangOption("en-US")))
 			if err != nil {
 				return d, nil
@@ -167,7 +167,7 @@ func (c *Client) GetEposideDetail(id, seasonNumber, eposideNumber int, language
 	}
 	if !episodeNameUseful(d.Name) {
 		var detailEN *tmdb.TVEpisodeDetails
-		if language == "zh-CN" {
+		if language == "zh-CN" || language == "" {
 			detailEN, err = c.tmdbClient.GetTVEpisodeDetails(id, seasonNumber, eposideNumber, withLangOption("en-US"))
 			if err != nil {
 				return d, nil
@@ -189,7 +189,7 @@ func (c *Client) GetSeasonDetails(id, seasonNumber int, language string) (*tmdb.
 		return nil, err
 	}
 	var detailEN *tmdb.TVSeasonDetails
-	if language == "zh-CN" {
+	if language == "zh-CN" || language == "" {
 		detailEN, err = c.tmdbClient.GetTVSeasonDetails(id, seasonNumber, withLangOption("en-US"))
 		if err != nil {
 			return detailCN, nil
@@ -213,6 +213,17 @@ func (c *Client) GetMovieAlternativeTitles(id int, language string) (*tmdb.Movie
 	return c.tmdbClient.GetMovieAlternativeTitles(id, withLangOption(language))
 }
 
+func (c *Client) GetByImdbId(imdbId string, lang string) (*tmdb.FindByID, error) {
+	m := withLangOption(lang)
+	m["external_source"] = "imdb_id"
+	return c.tmdbClient.GetFindByID(imdbId, m)
+}
+
+func (c *Client) GetByTvdbId(imdbId string, lang string) (*tmdb.FindByID, error) {
+	m := withLangOption(lang)
+	m["external_source"] = "tvdb_id"
+	return c.tmdbClient.GetFindByID(imdbId, m)
+}
 
 func wrapLanguage(lang string) string {
 	if lang == "" {

pkg/transmission/transmission.go

@@ -53,7 +53,7 @@ func (c *Client) GetAll() ([]*Torrent, error) {
 	var torrents []*Torrent
 	for _, t := range all {
 		torrents = append(torrents, &Torrent{
-			ID:     *t.ID,
+			Hash:     *t.HashString,
 			c:      c.c,
 			Config: c.cfg,		
 		})
@@ -86,12 +86,12 @@ func (c *Client) Download(link, dir string) (*Torrent, error) {
 		DownloadDir: &dir,
 	})
 	log.Infof("get torrent info: %+v", t)
-	if t.ID == nil {
+	if t.HashString == nil {
 		return nil, fmt.Errorf("download torrent error: %v", link)
 	}
 
 	return &Torrent{
-		ID:     *t.ID,
+		Hash:     *t.HashString,
 		c:      c.c,
 		Config: c.cfg,
 	}, err
@@ -100,7 +100,7 @@ func (c *Client) Download(link, dir string) (*Torrent, error) {
 type Torrent struct {
 	//t *transmissionrpc.Torrent
 	c  *transmissionrpc.Client
-	ID int64 `json:"id"`
+	Hash string `json:"hash"`
 	Config
 }
 
@@ -113,68 +113,92 @@ func (t *Torrent) reloadClient() error {
 	return nil
 }
 
-func (t *Torrent) getTorrent() transmissionrpc.Torrent {
-	r, err := t.c.TorrentGetAllFor(context.TODO(), []int64{t.ID})
+func (t *Torrent) getTorrent() (transmissionrpc.Torrent, error) {
+	r, err := t.c.TorrentGetAllForHashes(context.TODO(), []string{t.Hash})
 	if err != nil {
 		log.Errorf("get torrent info for error: %v", err)
 	}
-	return r[0]
+	if len(r) == 0 {
+		return transmissionrpc.Torrent{}, fmt.Errorf("no torrent")
+	}
+	return r[0], nil
 }
 
 func (t *Torrent) Exists() bool {
-	r, err := t.c.TorrentGetAllFor(context.TODO(), []int64{t.ID})
+	r, err := t.c.TorrentGetAllForHashes(context.TODO(), []string{t.Hash})
 	if err != nil {
 		log.Errorf("get torrent info for error: %v", err)
 	}
 	return len(r) > 0
 }
 
-func (t *Torrent) Name() string {
-	if !t.Exists() {
-		return ""
+
+func (t *Torrent) Name() (string, error) {
+	tt, err := t.getTorrent()
+	if err != nil {
+		return "", err
 	}
-	return *t.getTorrent().Name
+	return *tt.Name, nil
 }
 
-func (t *Torrent) Progress() int {
-	if t.getTorrent().IsFinished != nil && *t.getTorrent().IsFinished {
-		return 100
+func (t *Torrent) Progress() (int, error) {
+	tt, err := t.getTorrent()
+	if err != nil {
+		return 0, err
 	}
-	if t.getTorrent().PercentComplete != nil && *t.getTorrent().PercentComplete >= 1 {
-		return 100
+	if tt.IsFinished != nil && *tt.IsFinished {
+		return 100, nil
+	}
+	if tt.PercentComplete != nil && *tt.PercentComplete >= 1 {
+		return 100, nil
 	}
 
-	if t.getTorrent().PercentComplete != nil {
-		p := int(*t.getTorrent().PercentComplete * 100)
+	if tt.PercentComplete != nil {
+		p := int(*tt.PercentComplete * 100)
 		if p == 100 {
 			p = 99
 		}
-		return p
+		return p, nil
 	}
-	return 0
+	return 0, nil
 }
 
 func (t *Torrent) Stop() error {
-	return t.c.TorrentStopIDs(context.TODO(), []int64{t.ID})
+	return t.c.TorrentStopHashes(context.TODO(), []string{t.Hash})
 }
 
-func (t *Torrent) SeedRatio() *float64 {
-	return t.getTorrent().UploadRatio
+func (t *Torrent) SeedRatio() (float64, error) {
+	tt, err := t.getTorrent()
+	if err != nil {
+		return 0, err
+	}
+	if tt.UploadRatio == nil {
+		return 0, nil
+	}
+	return *tt.UploadRatio, nil
 }
 
 func (t *Torrent) Start() error {
-	return t.c.TorrentStartIDs(context.TODO(), []int64{t.ID})
+	return t.c.TorrentStartHashes(context.TODO(), []string{t.Hash})
 }
 
 func (t *Torrent) Remove() error {
+	tt, err := t.getTorrent()
+	if err != nil {
+		return errors.Wrap(err, "get torrent")
+	}
 	return t.c.TorrentRemove(context.TODO(), transmissionrpc.TorrentRemovePayload{
-		IDs:             []int64{t.ID},
+		IDs:             []int64{*tt.ID},
 		DeleteLocalData: true,
 	})
 }
 
-func (t *Torrent) Size() int {
-	return int(t.getTorrent().TotalSize.Byte())
+func (t *Torrent) Size() (int, error) {
+	tt, err := t.getTorrent()
+	if err != nil {
+		return 0, errors.Wrap(err, "get torrent")
+	}
+	return int(tt.TotalSize.Byte()), nil
 }
 
 func (t *Torrent) Save() string {

pkg/utils/utils.go

@@ -1,6 +1,7 @@
 package utils
 
 import (
+	"encoding/json"
 	"os"
 	"regexp"
 	"strconv"
@@ -147,3 +148,38 @@ func ChangeFileHash(name string) error {
 	}
 	return nil
 }
+
+func TrimFields(v interface{}) error {
+	bytes, err := json.Marshal(v)
+	if err != nil {
+		return err
+	}
+	var mapSI map[string]interface{}
+	if err := json.Unmarshal(bytes, &mapSI); err != nil {
+		return err
+	}
+	mapSI = trimMapStringInterface(mapSI).(map[string]interface{})
+	bytes2, err := json.Marshal(mapSI)
+	if err != nil {
+		return err
+	}
+	if err := json.Unmarshal(bytes2, v); err != nil {
+		return err
+	}
+	return nil
+}
+
+func trimMapStringInterface(data interface{}) interface{} {
+	if values, valid := data.([]interface{}); valid {
+		for i := range values {
+			data.([]interface{})[i] = trimMapStringInterface(values[i])
+		}
+	} else if values, valid := data.(map[string]interface{}); valid {
+		for k, v := range values {
+			data.(map[string]interface{})[k] = trimMapStringInterface(v)
+		}
+	} else if value, valid := data.(string); valid {
+		data = strings.TrimSpace(value)
+	}
+	return data
+}

server/activity.go

@@ -16,7 +16,7 @@ import (
 type Activity struct {
 	*ent.History
 	Progress  int     `json:"progress"`
-	SeedRatio float32 `json:"seed_ratio"`
+	SeedRatio float64 `json:"seed_ratio"`
 }
 
 func (s *Server) GetAllActivities(c *gin.Context) (interface{}, error) {
@@ -30,8 +30,18 @@ func (s *Server) GetAllActivities(c *gin.Context) (interface{}, error) {
 			}
 			for id, task := range s.core.GetTasks() {
 				if h.ID == id && task.Exists() {
-					a.Progress = task.Progress()
-					a.SeedRatio = float32(*task.SeedRatio())
+					p, err := task.Progress()
+					if err != nil {
+						log.Warnf("get task progress error: %v", err)
+					} else {
+						a.Progress = p
+					}
+					r, err := task.SeedRatio()
+					if err != nil {
+						log.Warnf("get task seed ratio error: %v", err)
+					} else {
+						a.SeedRatio = r
+					}
 				}
 			}
 			activities = append(activities, a)
@@ -68,9 +78,13 @@ func (s *Server) RemoveActivity(c *gin.Context) (interface{}, error) {
 	if err := s.core.RemoveTaskAndTorrent(his.ID); err != nil {
 		return nil, errors.Wrap(err, "remove torrent")
 	}
+	err = s.db.DeleteHistory(id)
+	if err != nil {
+		return nil, errors.Wrap(err, "db")
+	}
 
 	if his.EpisodeID != 0 {
-		if his.Status == history.StatusRunning || his.Status == history.StatusUploading {
+		if !s.db.IsEpisodeDownloadingOrDownloaded(his.EpisodeID) {
 			s.db.SetEpisodeStatus(his.EpisodeID, episode.StatusMissing)
 		}
 
@@ -85,10 +99,6 @@ func (s *Server) RemoveActivity(c *gin.Context) (interface{}, error) {
 		}
 	}
 
-	err = s.db.DeleteHistory(id)
-	if err != nil {
-		return nil, errors.Wrap(err, "db")
-	}
 	log.Infof("history record successful deleted: %v", his.SourceTitle)
 	return nil, nil
 }
@@ -107,7 +117,7 @@ func (s *Server) GetMediaDownloadHistory(c *gin.Context) (interface{}, error) {
 
 type TorrentInfo struct {
 	Name      string  `json:"name"`
-	ID        int64   `json:"id"`
+	ID        string  `json:"id"`
 	SeedRatio float32 `json:"seed_ratio"`
 	Progress  int     `json:"progress"`
 }
@@ -126,10 +136,12 @@ func (s *Server) GetAllTorrents(c *gin.Context) (interface{}, error) {
 		if !t.Exists() {
 			continue
 		}
+		name, _ := t.Name()
+		p, _ := t.Progress()
 		infos = append(infos, TorrentInfo{
-			Name:     t.Name(),
-			ID:       t.ID,
-			Progress: t.Progress(),
+			Name:     name,
+			ID:       t.Hash,
+			Progress: p,
 		})
 	}
 	return infos, nil

server/core/client.go

@@ -6,6 +6,7 @@ import (
 	"polaris/log"
 	"polaris/pkg/tmdb"
 	"polaris/pkg/transmission"
+	"polaris/pkg/utils"
 
 	"github.com/pkg/errors"
 	"github.com/robfig/cron"
@@ -20,11 +21,23 @@ func NewClient(db *db.Client, language string) *Client {
 	}
 }
 
+type scheduler struct {
+	cron string
+	f func() error 
+}
 type Client struct {
 	db       *db.Client
 	cron     *cron.Cron
 	tasks    map[int]*Task
 	language string
+	schedulers utils.Map[string, scheduler]
+}
+
+func (c *Client) registerCronJob(name string, cron string, f func() error) {
+	c.schedulers.Store(name, scheduler{
+		cron: cron,
+		f: f,
+	})
 }
 
 func (c *Client) Init() {

server/core/importlist.go

@@ -0,0 +1,457 @@
+package core
+
+import (
+	"bytes"
+	"fmt"
+	"html/template"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+	"polaris/db"
+	"polaris/ent"
+	"polaris/ent/importlist"
+	"polaris/ent/media"
+	"polaris/ent/schema"
+	"polaris/log"
+	"polaris/pkg/importlist/plexwatchlist"
+	"polaris/pkg/utils"
+	"regexp"
+	"strings"
+
+	tmdb "github.com/cyruzin/golang-tmdb"
+	"github.com/pkg/errors"
+)
+
+func (c *Client) periodicallyUpdateImportlist() error {
+	log.Infof("begin check import list")
+	lists, err := c.db.GetAllImportLists()
+	if err != nil {
+		return errors.Wrap(err, "get from db")
+	}
+	for _, l := range lists {
+		log.Infof("check import list content for %v", l.Name)
+		if l.Type == importlist.TypePlex {
+			res, err := plexwatchlist.ParsePlexWatchlist(l.URL)
+			if err != nil {
+				log.Errorf("parse plex watchlist: %v", err)
+				continue
+			}
+			for _, item := range res.Items {
+				var tmdbRes *tmdb.FindByID
+				if item.ImdbID != "" {
+					tmdbRes1, err := c.MustTMDB().GetByImdbId(item.ImdbID, c.language)
+					if err != nil {
+						log.Errorf("get by imdb id error: %v", err)
+						continue
+					}
+					tmdbRes = tmdbRes1
+				} else if item.TvdbID != "" {
+					tmdbRes1, err := c.MustTMDB().GetByTvdbId(item.TvdbID, c.language)
+					if err != nil {
+						log.Errorf("get by imdb id error: %v", err)
+						continue
+					}
+					tmdbRes = tmdbRes1
+				}
+				if tmdbRes == nil {
+					log.Errorf("can not find media for : %+v", item)
+					continue
+				}
+				if len(tmdbRes.MovieResults) > 0 {
+					d := tmdbRes.MovieResults[0]
+					name, err := c.SuggestedMovieFolderName(int(d.ID))
+					if err != nil {
+						log.Errorf("suggesting name error: %v", err)
+						continue
+					}
+					_, err = c.AddMovie2Watchlist(AddWatchlistIn{
+						TmdbID:     int(d.ID),
+						StorageID:  l.StorageID,
+						Resolution: l.Qulity,
+						Folder:     name,
+					})
+					if err != nil {
+						log.Errorf("[update_import_lists] add movie to watchlist error: %v", err)
+					} else {
+						log.Infof("[update_import_lists] add movie to watchlist success")
+					}
+				} else if len(tmdbRes.TvResults) > 0 {
+					d := tmdbRes.TvResults[0]
+					name, err := c.SuggestedSeriesFolderName(int(d.ID))
+					if err != nil {
+						log.Errorf("suggesting name error: %v", err)
+						continue
+					}
+
+					_, err = c.AddTv2Watchlist(AddWatchlistIn{
+						TmdbID:     int(d.ID),
+						StorageID:  l.StorageID,
+						Resolution: l.Qulity,
+						Folder:     name,
+					})
+					if err != nil {
+						log.Errorf("[update_import_lists] add tv to watchlist error: %v", err)
+					} else {
+						log.Infof("[update_import_lists] add tv to watchlist success")
+					}
+
+				}
+
+			}
+		}
+	}
+	return nil
+}
+
+type AddWatchlistIn struct {
+	TmdbID                  int    `json:"tmdb_id" binding:"required"`
+	StorageID               int    `json:"storage_id" `
+	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"`
+}
+
+func (c *Client) AddTv2Watchlist(in AddWatchlistIn) (interface{}, error) {
+	log.Debugf("add tv watchlist input %+v", in)
+	if in.Folder == "" {
+		return nil, errors.New("folder should be provided")
+	}
+	detailCn, err := c.MustTMDB().GetTvDetails(in.TmdbID, db.LanguageCN)
+	if err != nil {
+		return nil, errors.Wrap(err, "get tv detail")
+	}
+	var nameCn = detailCn.Name
+
+	detailEn, _ := c.MustTMDB().GetTvDetails(in.TmdbID, db.LanguageEN)
+	var nameEn = detailEn.Name
+	var detail *tmdb.TVDetails
+	if c.language == "" || c.language == db.LanguageCN {
+		detail = detailCn
+	} else {
+		detail = detailEn
+	}
+	log.Infof("find detail for tv id %d: %+v", in.TmdbID, detail)
+
+	 lastSeason := 0
+	for _, season := range detail.Seasons {
+		if season.SeasonNumber > lastSeason && season.EpisodeCount > 0 { //如果最新一季已经有剧集信息，则以最新一季为准
+			lastSeason = season.SeasonNumber
+		}
+	}
+
+	log.Debugf("latest season is %v", lastSeason)
+
+	var epIds []int
+	for _, season := range detail.Seasons {
+		seasonId := season.SeasonNumber
+		se, err := c.MustTMDB().GetSeasonDetails(int(detail.ID), seasonId, c.language)
+		if err != nil {
+			log.Errorf("get season detail (%s) error: %v", detail.Name, err)
+			continue
+		}
+
+		shouldMonitor := seasonId >= lastSeason //监控最新的一季
+
+		for _, ep := range se.Episodes {
+
+			// //如果设置下载往期剧集，则监控所有剧集。如果没有则监控未上映的剧集，考虑时差等问题留24h余量
+			// if in.DownloadHistoryEpisodes {
+			// 	shouldMonitor = true
+			// } else {
+			// 	t, err := time.Parse("2006-01-02", ep.AirDate)
+			// 	if err != nil {
+			// 		log.Error("air date not known, will monitor: %v", ep.AirDate)
+			// 		shouldMonitor = true
+
+			// 	} else {
+			// 		if time.Since(t) < 24*time.Hour { //monitor episode air 24h before now
+			// 			shouldMonitor = true
+			// 		}
+			// 	}
+			// }
+
+			ep := ent.Episode{
+				SeasonNumber:  seasonId,
+				EpisodeNumber: ep.EpisodeNumber,
+				Title:         ep.Name,
+				Overview:      ep.Overview,
+				AirDate:       ep.AirDate,
+				Monitored:     shouldMonitor,
+			}
+			epid, err := c.db.SaveEposideDetail(&ep)
+			if err != nil {
+				log.Errorf("save episode info error: %v", err)
+				continue
+			}
+			log.Debugf("success save episode %+v", ep)
+			epIds = append(epIds, epid)
+		}
+	}
+	m := &ent.Media{
+		TmdbID:                  int(detail.ID),
+		ImdbID:                  detail.IMDbID,
+		MediaType:               media.MediaTypeTv,
+		NameCn:                  nameCn,
+		NameEn:                  nameEn,
+		OriginalName:            detail.OriginalName,
+		Overview:                detail.Overview,
+		AirDate:                 detail.FirstAirDate,
+		Resolution:              media.Resolution(in.Resolution),
+		StorageID:               in.StorageID,
+		TargetDir:               in.Folder,
+		DownloadHistoryEpisodes: in.DownloadHistoryEpisodes,
+		Limiter:                 schema.MediaLimiter{SizeMin: in.SizeMin, SizeMax: in.SizeMax},
+		Extras: schema.MediaExtras{
+			OriginalLanguage: detail.OriginalLanguage,
+			Genres:           detail.Genres,
+		},
+	}
+
+	r, err := c.db.AddMediaWatchlist(m, epIds)
+	if err != nil {
+		return nil, errors.Wrap(err, "add to list")
+	}
+	go func() {
+		if err := c.downloadPoster(detail.PosterPath, r.ID); err != nil {
+			log.Errorf("download poster error: %v", err)
+		}
+		if err := c.downloadBackdrop(detail.BackdropPath, r.ID); err != nil {
+			log.Errorf("download poster error: %v", err)
+		}
+		if err := c.CheckDownloadedSeriesFiles(r); err != nil {
+			log.Errorf("check downloaded files error: %v", err)
+		}
+
+	}()
+
+	log.Infof("add tv %s to watchlist success", detail.Name)
+	return nil, nil
+}
+
+func (c *Client) 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 {
+		return nil, errors.Wrap(err, "get movie detail")
+	}
+	var nameCn = detailCn.Title
+
+	detailEn, _ := c.MustTMDB().GetMovieDetails(in.TmdbID, db.LanguageEN)
+	var nameEn = detailEn.Title
+	var detail *tmdb.MovieDetails
+	if c.language == "" || c.language == db.LanguageCN {
+		detail = detailCn
+	} else {
+		detail = detailEn
+	}
+	log.Infof("find detail for movie id %d: %v", in.TmdbID, detail)
+
+	epid, err := c.db.SaveEposideDetail(&ent.Episode{
+		SeasonNumber:  1,
+		EpisodeNumber: 1,
+		Title:         "dummy episode for movies",
+		Overview:      "dummy episode for movies",
+		AirDate:       detail.ReleaseDate,
+		Monitored:     true,
+	})
+	if err != nil {
+		return nil, errors.Wrap(err, "add dummy episode")
+	}
+	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},
+	}
+
+	extras := schema.MediaExtras{
+		IsAdultMovie:     detail.Adult,
+		OriginalLanguage: detail.OriginalLanguage,
+		Genres:           detail.Genres,
+	}
+	if IsJav(detail) {
+		javid := c.GetJavid(in.TmdbID)
+		extras.JavId = javid
+	}
+
+	movie.Extras = extras
+	r, err := c.db.AddMediaWatchlist(&movie, []int{epid})
+	if err != nil {
+		return nil, errors.Wrap(err, "add to list")
+	}
+	go func() {
+		if err := c.downloadPoster(detail.PosterPath, r.ID); err != nil {
+			log.Errorf("download poster error: %v", err)
+		}
+		if err := c.downloadBackdrop(detail.BackdropPath, r.ID); err != nil {
+			log.Errorf("download backdrop error: %v", err)
+		}
+	}()
+
+	log.Infof("add movie %s to watchlist success", detail.Title)
+	return nil, nil
+
+}
+
+func IsJav(detail *tmdb.MovieDetails) bool {
+	if detail.Adult && len(detail.ProductionCountries) > 0 && strings.ToUpper(detail.ProductionCountries[0].Iso3166_1) == "JP" {
+		return true
+	}
+	return false
+}
+
+func (c *Client) GetJavid(id int) string {
+	alters, err := c.MustTMDB().GetMovieAlternativeTitles(id, c.language)
+	if err != nil {
+		return ""
+	}
+	for _, t := range alters.Titles {
+		if t.Iso3166_1 == "JP" && t.Type == "" {
+			return t.Title
+		}
+	}
+	return ""
+}
+
+func (c *Client) 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 {
+	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 {
+
+	log.Infof("try to download image: %v", url)
+	var resp, err = http.Get(url)
+	if err != nil {
+		return errors.Wrap(err, "http get")
+	}
+	targetDir := fmt.Sprintf("%v/%d", db.ImgPath, mediaID)
+	os.MkdirAll(targetDir, 0777)
+	//ext := filepath.Ext(path)
+	targetFile := filepath.Join(targetDir, name)
+	f, err := os.Create(targetFile)
+	if err != nil {
+		return errors.Wrap(err, "new file")
+	}
+	defer f.Close()
+	_, err = io.Copy(f, resp.Body)
+	if err != nil {
+		return errors.Wrap(err, "copy http response")
+	}
+	log.Infof("image successfully downlaoded: %v", targetFile)
+	return nil
+
+}
+
+func (c *Client) SuggestedMovieFolderName(tmdbId int) (string, error) {
+
+	d1, err := c.MustTMDB().GetMovieDetails(tmdbId, c.language)
+	if err != nil {
+		return "", errors.Wrap(err, "get movie details")
+	}
+	name := d1.Title
+
+	if IsJav(d1) {
+		javid := c.GetJavid(tmdbId)
+		if javid != "" {
+			return javid, nil
+		}
+	}
+	info := db.NamingInfo{TmdbID: tmdbId}
+	if utils.IsASCII(name) {
+		info.NameEN = stripExtraCharacters(name)
+	} else {
+		info.NameCN = stripExtraCharacters(name)
+		en, err := c.MustTMDB().GetMovieDetails(tmdbId, db.LanguageEN)
+		if err != nil {
+			log.Errorf("get en tv detail error: %v", err)
+		} else {
+			info.NameEN = stripExtraCharacters(en.Title)
+		}
+	}
+	year := strings.Split(d1.ReleaseDate, "-")[0]
+	info.Year = year
+	movieNamingFormat := c.db.GetMovingNamingFormat()
+
+	tmpl, err := template.New("test").Parse(movieNamingFormat)
+	if err != nil {
+		return "", errors.Wrap(err, "naming format")
+	}
+	buff := &bytes.Buffer{}
+	err = tmpl.Execute(buff, info)
+	if err != nil {
+		return "", errors.Wrap(err, "tmpl exec")
+	}
+	res := strings.TrimSpace(buff.String())
+
+	log.Infof("tv series of tmdb id %v suggestting name is %v", tmdbId, res)
+	return res, nil
+}
+
+func (c *Client) SuggestedSeriesFolderName(tmdbId int) (string, error) {
+
+	d, err := c.MustTMDB().GetTvDetails(tmdbId, c.language)
+	if err != nil {
+		return "", errors.Wrap(err, "get tv details")
+	}
+
+	name := d.Name
+
+	info := db.NamingInfo{TmdbID: tmdbId}
+	if utils.IsASCII(name) {
+		info.NameEN = stripExtraCharacters(name)
+	} else {
+		info.NameCN = stripExtraCharacters(name)
+		en, err := c.MustTMDB().GetTvDetails(tmdbId, db.LanguageEN)
+		if err != nil {
+			log.Errorf("get en tv detail error: %v", err)
+		} else {
+			if en.Name != name { //sometimes en name is in chinese
+				info.NameEN = stripExtraCharacters(en.Name)
+			}
+		}
+	}
+	year := strings.Split(d.FirstAirDate, "-")[0]
+	info.Year = year
+
+	tvNamingFormat := c.db.GetTvNamingFormat()
+
+	tmpl, err := template.New("test").Parse(tvNamingFormat)
+	if err != nil {
+		return "", errors.Wrap(err, "naming format")
+	}
+	buff := &bytes.Buffer{}
+	err = tmpl.Execute(buff, info)
+	if err != nil {
+		return "", errors.Wrap(err, "tmpl exec")
+	}
+	res := strings.TrimSpace(buff.String())
+
+	log.Infof("tv series of tmdb id %v suggestting name is %v", tmdbId, res)
+	return res, nil
+}
+
+func stripExtraCharacters(s string) string {
+	re := regexp.MustCompile(`[^\p{L}\w\s]`)
+	s = re.ReplaceAllString(s, " ")
+	return strings.Join(strings.Fields(s), " ")
+}

server/core/integration.go

@@ -257,7 +257,11 @@ func (c *Client) findEpisodeFilesPreMoving(historyId int) error {
 	isSingleEpisode := his.EpisodeID > 0
 	downloadDir := c.db.GetDownloadDir()
 	task := c.tasks[historyId]
-	target := filepath.Join(downloadDir, task.Name())
+	name, err := task.Name()
+	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)

server/core/scheduler.go

@@ -17,12 +17,24 @@ import (
 )
 
 func (c *Client) addSysCron() {
-	c.mustAddCron("@every 1m", c.checkTasks)
-	c.mustAddCron("0 0 * * * *", func() {
+	c.registerCronJob("check_running_tasks", "@every 1m", c.checkTasks)
+	c.registerCronJob("check_available_medias_to_download", "0 0 * * * *", func() error {
 		c.downloadAllTvSeries()
 		c.downloadAllMovies()
+		return nil
+	})
+	c.registerCronJob("check_series_new_release", "0 0 */12 * * *", c.checkAllSeriesNewSeason)
+	c.registerCronJob("update_import_lists", "0 30 * * * *", c.periodicallyUpdateImportlist)
+
+	c.schedulers.Range(func(key string, value scheduler) bool {
+		log.Debugf("add cron job: %v", key)
+		c.mustAddCron(value.cron, func() {
+			if err := value.f(); err != nil {
+				log.Errorf("exexuting cron job %s error: %v", key, err)
+			}
+		})
+		return true
 	})
-	c.mustAddCron("0 0 */12 * * *", c.checkAllSeriesNewSeason)
 	c.cron.Start()
 }
 
@@ -33,7 +45,15 @@ func (c *Client) mustAddCron(spec string, cmd func()) {
 	}
 }
 
-func (c *Client) checkTasks() {
+func (c *Client) TriggerCronJob(name string) error {
+	job, ok := c.schedulers.Load(name)
+	if !ok {
+		return fmt.Errorf("job name not exists: %s", name)
+	}
+	return job.f()
+}
+
+func (c *Client) checkTasks() error {
 	log.Debug("begin check tasks...")
 	for id, t := range c.tasks {
 		r := c.db.GetHistory(id)
@@ -43,28 +63,38 @@ func (c *Client) checkTasks() {
 			delete(c.tasks, id)
 			continue
 		}
-		log.Infof("task (%s) percentage done: %d%%", t.Name(), t.Progress())
-		if t.Progress() == 100 {
+		name, err := t.Name()
+		if err != nil {
+			return errors.Wrap(err, "get name")
+		}
+
+		progress, err := t.Progress()
+		if err != nil {
+			return errors.Wrap(err, "get progress")
+		}
+		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]
-				ok := c.isSeedRatioLimitReached(r.IndexerID, torrent)
+				ratio, ok := c.isSeedRatioLimitReached(r.IndexerID, torrent)
 				if ok {
-					log.Infof("torrent file seed ratio reached, remove: %v, current seed ratio: %v", torrent.Name(), *torrent.SeedRatio())
+					log.Infof("torrent file seed ratio reached, remove: %v, current seed ratio: %v", name, ratio)
 					torrent.Remove()
 					delete(c.tasks, id)
 				} else {
-					log.Infof("torrent file still sedding: %v, current seed ratio: %v", torrent.Name(), *torrent.SeedRatio())
+					log.Infof("torrent file still sedding: %v, current seed ratio: %v", name, ratio)
 				}
 				continue
 			}
-			log.Infof("task is done: %v", t.Name())
-			c.sendMsg(fmt.Sprintf(message.DownloadComplete, t.Name()))
+			log.Infof("task is done: %v", name)
+			c.sendMsg(fmt.Sprintf(message.DownloadComplete, name))
 
 			go c.postTaskProcessing(id)
 		}
 	}
+	return nil
 }
 
 func (c *Client) postTaskProcessing(id int) {
@@ -101,14 +131,19 @@ func (c *Client) moveCompletedTask(id int) (err1 error) {
 		log.Errorf("get task download client error: %v, use default one", err)
 		downloadclient = &ent.DownloadClients{RemoveCompletedDownloads: true, RemoveFailedDownloads: true}
 	}
-	torrentName := torrent.Name()
+	torrentName, err := torrent.Name()
+	if err != nil {
+		return err
+	}
 
 	defer func() {
 
 		if err1 != nil {
 			c.db.SetHistoryStatus(r.ID, history.StatusFail)
 			if r.EpisodeID != 0 {
-				c.db.SetEpisodeStatus(r.EpisodeID, episode.StatusMissing)
+				if !c.db.IsEpisodeDownloadingOrDownloaded(r.EpisodeID) {
+					c.db.SetEpisodeStatus(r.EpisodeID, episode.StatusMissing)
+				}
 			} else {
 				c.db.SetSeasonAllEpisodeStatus(r.MediaID, seasonNum, episode.StatusMissing)
 			}
@@ -146,9 +181,9 @@ func (c *Client) moveCompletedTask(id int) (err1 error) {
 	c.sendMsg(fmt.Sprintf(message.ProcessingComplete, torrentName))
 
 	//判断是否需要删除本地文件
-	ok := c.isSeedRatioLimitReached(r.IndexerID, torrent)
+	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, *torrent.SeedRatio())
+		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)
 		torrent.Remove()
@@ -355,7 +390,7 @@ func (c *Client) downloadMovieSingleEpisode(ep *ent.Episode, targetDir string) (
 	return r1.Name, nil
 }
 
-func (c *Client) checkAllSeriesNewSeason() {
+func (c *Client) checkAllSeriesNewSeason() error {
 	log.Infof("begin checking series all new season")
 	allSeries := c.db.GetMediaWatchlist(media.MediaTypeTv)
 	for _, series := range allSeries {
@@ -364,6 +399,7 @@ func (c *Client) checkAllSeriesNewSeason() {
 			log.Errorf("check series new season error: series name %v, error: %v", series.NameEn, err)
 		}
 	}
+	return nil
 }
 
 func (c *Client) checkSeiesNewSeason(media *ent.Media) error {
@@ -404,15 +440,15 @@ func (c *Client) checkSeiesNewSeason(media *ent.Media) error {
 	return nil
 }
 
-func (c *Client) isSeedRatioLimitReached(indexId int, t pkg.Torrent) bool {
+func (c *Client) isSeedRatioLimitReached(indexId int, t pkg.Torrent)(float64,bool)  {
 	indexer, err := c.db.GetIndexer(indexId)
 	if err != nil {
-		return true
+		return 0, true
 	}
-	currentRatio := t.SeedRatio()
-	if currentRatio == nil {
-		log.Warnf("get current seed ratio error, current ratio is nil")
-		return indexer.SeedRatio == 0
+	currentRatio, err := t.SeedRatio()
+	if err != nil {
+		log.Warnf("get current seed ratio error: %v", err)
+		return currentRatio, indexer.SeedRatio == 0
 	}
-	return *currentRatio >= float64(indexer.SeedRatio)
+	return currentRatio, currentRatio >= float64(indexer.SeedRatio)
 }

server/importlist.go

@@ -0,0 +1,63 @@
+package server
+
+import (
+	"fmt"
+	"polaris/ent"
+	"polaris/ent/importlist"
+	"polaris/pkg/utils"
+
+	"github.com/gin-gonic/gin"
+	"github.com/pkg/errors"
+)
+
+func (s *Server) getAllImportLists(c *gin.Context) (interface{}, error) {
+	lists, err := s.db.GetAllImportLists()
+	return lists, err
+}
+
+type addImportlistIn struct {
+	Name      string `json:"name" binding:"required"`
+	Url       string `json:"url"`
+	Type      string `json:"type"`
+	Qulity    string `json:"qulity"`
+	StorageId int    `json:"storage_id"`
+}
+
+func (s *Server) addImportlist(c *gin.Context) (interface{}, error) {
+	var in addImportlistIn
+
+	if err := c.ShouldBindJSON(&in); err != nil {
+		return nil, errors.Wrap(err, "json")
+	}
+	utils.TrimFields(&in)
+	
+	st := s.db.GetStorage(in.StorageId)
+	if st == nil {
+		return nil, fmt.Errorf("storage id not exist: %v", in.StorageId)
+	}
+	err := s.db.AddImportlist(&ent.ImportList{
+		Name:      in.Name,
+		URL:       in.Url,
+		Type:      importlist.Type(in.Type),
+		Qulity:    in.Qulity,
+		StorageID: in.StorageId,
+	})
+	if err != nil {
+		return nil, err
+	}
+	return "success", nil
+}
+
+type deleteImportlistIn struct {
+	ID int `json:"id"`
+}
+
+func (s *Server) deleteImportList(c *gin.Context) (interface{}, error) {
+	var in deleteImportlistIn
+
+	if err := c.ShouldBindJSON(&in); err != nil {
+		return nil, errors.Wrap(err, "json")
+	}
+	s.db.DeleteImportlist(in.ID)
+	return "sucess", nil
+}

server/notify_client.go

@@ -2,6 +2,7 @@ package server
 
 import (
 	"polaris/ent"
+	"polaris/pkg/utils"
 	"strconv"
 
 	"github.com/gin-gonic/gin"
@@ -35,6 +36,7 @@ func (s *Server) AddNotificationClient(c *gin.Context) (interface{}, error) {
 	if err := c.ShouldBindJSON(&in); err != nil {
 		return nil, errors.Wrap(err, "json")
 	}
+	utils.TrimFields(&in)
 
 	err := s.db.AddNotificationClient(in.Name, in.Service, in.Settings, in.Enabled)
 	if err != nil {

server/server.go

@@ -22,8 +22,9 @@ import (
 func NewServer(db *db.Client) *Server {
 	r := gin.Default()
 	s := &Server{
-		r:  r,
-		db: db,
+		r:        r,
+		db:       db,
+		language: db.GetLanguage(),
 	}
 	s.core = core.NewClient(db, s.language)
 	return s
@@ -68,6 +69,7 @@ func (s *Server) Serve() error {
 		setting.POST("/parse/tv", HttpHandler(s.ParseTv))
 		setting.POST("/parse/movie", HttpHandler(s.ParseMovie))
 		setting.POST("/monitoring", HttpHandler(s.ChangeEpisodeMonitoring))
+		setting.POST("/cron/trigger", HttpHandler(s.TriggerCronJob))
 	}
 	activity := api.Group("/activity")
 	{
@@ -120,8 +122,13 @@ func (s *Server) Serve() error {
 		notifier.DELETE("/id/:id", HttpHandler(s.DeleteNotificationClient))
 		notifier.POST("/add", HttpHandler(s.AddNotificationClient))
 	}
+	importlist := api.Group("/importlist")
+	{
+		importlist.GET("/", HttpHandler(s.getAllImportLists))
+		importlist.POST("/add", HttpHandler(s.addImportlist))
+		importlist.DELETE("/delete", HttpHandler(s.deleteImportList))
+	}
 
-	s.language = s.db.GetLanguage()
 	return s.r.Run(":8080")
 }
 
@@ -132,7 +139,7 @@ func (s *Server) TMDB() (*tmdb.Client, error) {
 	}
 	proxy := s.db.GetSetting(db.SettingProxy)
 	adult := s.db.GetSetting(db.SettingEnableTmdbAdultContent)
-	return tmdb.NewClient(api, proxy, adult=="true")
+	return tmdb.NewClient(api, proxy, adult == "true")
 }
 
 func (s *Server) MustTMDB() *tmdb.Client {

server/setting.go

@@ -3,10 +3,12 @@ package server
 import (
 	"encoding/json"
 	"fmt"
+	"html/template"
 	"polaris/db"
 	"polaris/ent"
 	"polaris/log"
 	"polaris/pkg/transmission"
+	"polaris/pkg/utils"
 	"strconv"
 
 	"github.com/gin-gonic/gin"
@@ -22,6 +24,8 @@ type GeneralSettings struct {
 	EnableNfo          bool   `json:"enable_nfo"`
 	AllowQiangban      bool   `json:"allow_qiangban"`
 	EnableAdultContent bool   `json:"enable_adult_content"`
+	TvNamingFormat     string `json:"tv_naming_format"`
+	MovieNamingFormat  string `json:"movie_naming_format"`
 }
 
 func (s *Server) SetSetting(c *gin.Context) (interface{}, error) {
@@ -29,6 +33,8 @@ func (s *Server) SetSetting(c *gin.Context) (interface{}, error) {
 	if err := c.ShouldBindJSON(&in); err != nil {
 		return nil, errors.Wrap(err, "bind json")
 	}
+	utils.TrimFields(&in)
+
 	log.Infof("set setting input: %+v", in)
 	if in.TmdbApiKey != "" {
 		if err := s.db.SetSetting(db.SettingTmdbApiKey, in.TmdbApiKey); err != nil {
@@ -46,7 +52,25 @@ func (s *Server) SetSetting(c *gin.Context) (interface{}, error) {
 		if err := s.db.SetSetting(db.SettingLogLevel, in.LogLevel); err != nil {
 			return nil, errors.Wrap(err, "save log level")
 		}
+	}
+	if in.TvNamingFormat != "" {
+		if _, err := template.New("test").Parse(in.TvNamingFormat); err != nil {
+			return nil, errors.Wrap(err, "tv format")
+		}
 
+		s.db.SetSetting(db.SettingTvNamingFormat, in.TvNamingFormat)
+	} else {
+		s.db.SetSetting(db.SettingTvNamingFormat, "")
+	}
+
+	if in.MovieNamingFormat != "" {
+		if _, err := template.New("test").Parse(in.MovieNamingFormat); err != nil {
+			return nil, errors.Wrap(err, "movie format")
+		}
+
+		s.db.SetSetting(db.SettingMovieNamingFormat, in.MovieNamingFormat)
+	} else {
+		s.db.SetSetting(db.SettingMovieNamingFormat, "")
 	}
 
 	plexmatchEnabled := s.db.GetSetting(db.SettingPlexMatchEnabled)
@@ -74,7 +98,6 @@ func (s *Server) SetSetting(c *gin.Context) (interface{}, error) {
 	} else {
 		s.db.SetSetting(db.SettingEnableTmdbAdultContent, "false")
 	}
-
 	return nil, nil
 }
 
@@ -86,15 +109,19 @@ func (s *Server) GetSetting(c *gin.Context) (interface{}, error) {
 	allowQiangban := s.db.GetSetting(db.SettingAllowQiangban)
 	enableNfo := s.db.GetSetting(db.SettingNfoSupportEnabled)
 	enableAdult := s.db.GetSetting(db.SettingEnableTmdbAdultContent)
+	tvFormat := s.db.GetTvNamingFormat()
+	movieFormat := s.db.GetMovingNamingFormat()
 	return &GeneralSettings{
-		TmdbApiKey:      tmdb,
-		DownloadDir:     downloadDir,
-		LogLevel:        logLevel,
-		Proxy:           s.db.GetSetting(db.SettingProxy),
-		EnablePlexmatch: plexmatchEnabled == "true",
-		AllowQiangban:   allowQiangban == "true",
-		EnableNfo:       enableNfo == "true",
+		TmdbApiKey:         tmdb,
+		DownloadDir:        downloadDir,
+		LogLevel:           logLevel,
+		Proxy:              s.db.GetSetting(db.SettingProxy),
+		EnablePlexmatch:    plexmatchEnabled == "true",
+		AllowQiangban:      allowQiangban == "true",
+		EnableNfo:          enableNfo == "true",
 		EnableAdultContent: enableAdult == "true",
+		TvNamingFormat:     tvFormat,
+		MovieNamingFormat:  movieFormat,
 	}, nil
 }
 
@@ -113,6 +140,7 @@ func (s *Server) AddTorznabInfo(c *gin.Context) (interface{}, error) {
 	if err := c.ShouldBindJSON(&in); err != nil {
 		return nil, errors.Wrap(err, "bind json")
 	}
+	utils.TrimFields(&in)
 
 	log.Infof("add indexer settings: %+v", in)
 	setting := db.TorznabSetting{
@@ -188,6 +216,7 @@ func (s *Server) AddDownloadClient(c *gin.Context) (interface{}, error) {
 	if err := c.ShouldBindJSON(&in); err != nil {
 		return nil, errors.Wrap(err, "bind json")
 	}
+	utils.TrimFields(&in)
 	//test connection
 	_, err := transmission.NewClient(transmission.Config{
 		URL:      in.URL,
@@ -246,3 +275,20 @@ func (s *Server) EditMediaMetadata(c *gin.Context) (interface{}, error) {
 	}
 	return "success", nil
 }
+
+type triggerCronJobIn struct {
+	JobName string `json:"job_name"`
+}
+
+func (s *Server) TriggerCronJob(c *gin.Context) (interface{}, error) {
+	var in triggerCronJobIn
+	if err := c.ShouldBindJSON(&in); err != nil {
+		return nil, errors.Wrap(err, "bind")
+	}
+
+	err := s.core.TriggerCronJob(in.JobName)
+	if err != nil {
+		return nil, err
+	}
+	return "success", nil
+}

server/storage.go

@@ -3,12 +3,11 @@ package server
 import (
 	"fmt"
 	"polaris/db"
-	"regexp"
 
 	"polaris/log"
 	"polaris/pkg/storage"
+	"polaris/pkg/utils"
 	"strconv"
-	"strings"
 
 	"github.com/gin-gonic/gin"
 	"github.com/pkg/errors"
@@ -24,6 +23,7 @@ func (s *Server) AddStorage(c *gin.Context) (interface{}, error) {
 	if err := c.ShouldBindJSON(&in); err != nil {
 		return nil, errors.Wrap(err, "bind json")
 	}
+	utils.TrimFields(&in)
 
 	if in.Implementation == "webdav" {
 		//test webdav
@@ -61,31 +61,10 @@ func (s *Server) SuggestedSeriesFolderName(c *gin.Context) (interface{}, error)
 	if err != nil {
 		return nil, fmt.Errorf("id is not int: %v", ids)
 	}
-	d, err := s.MustTMDB().GetTvDetails(id, s.language)
+	name, err := s.core.SuggestedSeriesFolderName(id)
 	if err != nil {
-		return nil, errors.Wrap(err, "get tv details")
+		return nil, err
 	}
-
-	name := d.Name
-
-	if s.language == db.LanguageCN {
-		en, err := s.MustTMDB().GetTvDetails(id, db.LanguageEN)
-		if err != nil {
-			log.Errorf("get en tv detail error: %v", err)
-		} else {
-			name = fmt.Sprintf("%s %s", d.Name, en.Name)
-		}
-	}
-	//remove extra characters
-	re := regexp.MustCompile(`[^\p{L}\w\s]`)
-	name = re.ReplaceAllString(strings.ToLower(name), " ")
-	name = strings.Join(strings.Fields(name), " ")
-	year := strings.Split(d.FirstAirDate, "-")[0]
-	if year != "" {
-		name = fmt.Sprintf("%s (%s)", name, year)
-	}
-
-	log.Infof("tv series of tmdb id %v suggestting name is %v", id, name)
 	return gin.H{"name": name}, nil
 }
 
@@ -95,36 +74,9 @@ func (s *Server) SuggestedMovieFolderName(c *gin.Context) (interface{}, error) {
 	if err != nil {
 		return nil, fmt.Errorf("id is not int: %v", ids)
 	}
-	d1, err := s.MustTMDB().GetMovieDetails(id, s.language)
+	name, err := s.core.SuggestedMovieFolderName(id)
 	if err != nil {
-		return nil, errors.Wrap(err, "get movie details")
+		return nil, err
 	}
-	name := d1.Title
-
-	if isJav(d1) {
-		javid := s.getJavid(id)
-		if javid != "" {
-			return gin.H{"name": javid}, nil
-		}
-	}
-
-	if s.language == db.LanguageCN {
-		en, err := s.MustTMDB().GetMovieDetails(id, db.LanguageEN)
-		if err != nil {
-			log.Errorf("get en movie detail error: %v", err)
-		} else {
-			name = fmt.Sprintf("%s %s", d1.Title, en.Title)
-		}
-	}
-	//remove extra characters
-	re := regexp.MustCompile(`[^\p{L}\w\s]`)
-	name = re.ReplaceAllString(strings.ToLower(name), " ")
-	name = strings.Join(strings.Fields(name), " ")
-	year := strings.Split(d1.ReleaseDate, "-")[0]
-	if year != "" {
-		name = fmt.Sprintf("%s (%s)", name, year)
-	}
-
-	log.Infof("tv series of tmdb id %v suggestting name is %v", id, name)
 	return gin.H{"name": name}, nil
 }

server/watchlist.go

@@ -1,22 +1,16 @@
 package server
 
 import (
-	"fmt"
-	"io"
-	"net/http"
 	"os"
 	"path/filepath"
 	"polaris/db"
 	"polaris/ent"
 	"polaris/ent/episode"
 	"polaris/ent/media"
-	"polaris/ent/schema"
 	"polaris/log"
+	"polaris/server/core"
 	"strconv"
-	"strings"
-	"time"
 
-	tmdb "github.com/cyruzin/golang-tmdb"
 	"github.com/gin-gonic/gin"
 	"github.com/pkg/errors"
 )
@@ -73,245 +67,19 @@ type addWatchlistIn struct {
 }
 
 func (s *Server) AddTv2Watchlist(c *gin.Context) (interface{}, error) {
-	var in addWatchlistIn
+	var in core.AddWatchlistIn
 	if err := c.ShouldBindJSON(&in); err != nil {
 		return nil, errors.Wrap(err, "bind query")
 	}
-	log.Debugf("add tv watchlist input %+v", in)
-	if in.Folder == "" {
-		return nil, errors.New("folder should be provided")
-	}
-	detailCn, err := s.MustTMDB().GetTvDetails(in.TmdbID, db.LanguageCN)
-	if err != nil {
-		return nil, errors.Wrap(err, "get tv detail")
-	}
-	var nameCn = detailCn.Name
-
-	detailEn, _ := s.MustTMDB().GetTvDetails(in.TmdbID, db.LanguageEN)
-	var nameEn = detailEn.Name
-	var detail *tmdb.TVDetails
-	if s.language == "" || s.language == db.LanguageCN {
-		detail = detailCn
-	} else {
-		detail = detailEn
-	}
-	log.Infof("find detail for tv id %d: %v", in.TmdbID, detail)
-
-	var epIds []int
-	for _, season := range detail.Seasons {
-		seasonId := season.SeasonNumber
-		se, err := s.MustTMDB().GetSeasonDetails(int(detail.ID), seasonId, s.language)
-		if err != nil {
-			log.Errorf("get season detail (%s) error: %v", detail.Name, err)
-			continue
-		}
-		for _, ep := range se.Episodes {
-			shouldMonitor := false
-			//如果设置下载往期剧集，则监控所有剧集。如果没有则监控未上映的剧集，考虑时差等问题留24h余量
-			if in.DownloadHistoryEpisodes {
-				shouldMonitor = true
-			} else {
-				t, err := time.Parse("2006-01-02", ep.AirDate)
-				if err != nil {
-					log.Error("air date not known, will monitor: %v", ep.AirDate)
-					shouldMonitor = true
-
-				} else {
-					if time.Since(t) < 24*time.Hour { //monitor episode air 24h before now
-						shouldMonitor = true
-					}
-				}
-			}
-
-			epid, err := s.db.SaveEposideDetail(&ent.Episode{
-				SeasonNumber:  seasonId,
-				EpisodeNumber: ep.EpisodeNumber,
-				Title:         ep.Name,
-				Overview:      ep.Overview,
-				AirDate:       ep.AirDate,
-				Monitored:     shouldMonitor,
-			})
-			if err != nil {
-				log.Errorf("save episode info error: %v", err)
-				continue
-			}
-			epIds = append(epIds, epid)
-		}
-	}
-	m := &ent.Media{
-		TmdbID:                  int(detail.ID),
-		ImdbID:                  detail.IMDbID,
-		MediaType:               media.MediaTypeTv,
-		NameCn:                  nameCn,
-		NameEn:                  nameEn,
-		OriginalName:            detail.OriginalName,
-		Overview:                detail.Overview,
-		AirDate:                 detail.FirstAirDate,
-		Resolution:              media.Resolution(in.Resolution),
-		StorageID:               in.StorageID,
-		TargetDir:               in.Folder,
-		DownloadHistoryEpisodes: in.DownloadHistoryEpisodes,
-		Limiter:                 schema.MediaLimiter{SizeMin: in.SizeMin, SizeMax: in.SizeMax},
-		Extras: schema.MediaExtras{
-			OriginalLanguage: detail.OriginalLanguage,
-			Genres:           detail.Genres,
-		},
-	}
-
-	r, err := s.db.AddMediaWatchlist(m, epIds)
-	if err != nil {
-		return nil, errors.Wrap(err, "add to list")
-	}
-	go func() {
-		if err := s.downloadPoster(detail.PosterPath, r.ID); err != nil {
-			log.Errorf("download poster error: %v", err)
-		}
-		if err := s.downloadBackdrop(detail.BackdropPath, r.ID); err != nil {
-			log.Errorf("download poster error: %v", err)
-		}
-		if err := s.core.CheckDownloadedSeriesFiles(r); err != nil {
-			log.Errorf("check downloaded files error: %v", err)
-		}
-
-	}()
-
-	log.Infof("add tv %s to watchlist success", detail.Name)
-	return nil, nil
-}
-
-func isJav(detail *tmdb.MovieDetails) bool {
-	if detail.Adult && len(detail.ProductionCountries) > 0 && strings.ToUpper(detail.ProductionCountries[0].Iso3166_1) == "JP" {
-		return true
-	}
-	return false
-}
-
-func (s *Server) getJavid(id int) string {
-	alters, err := s.MustTMDB().GetMovieAlternativeTitles(id, s.language)
-	if err != nil {
-		return ""
-	}
-	for _, t := range alters.Titles {
-		if t.Iso3166_1 == "JP" && t.Type == "" {
-			return t.Title
-		}
-	}
-	return ""
+	return s.core.AddTv2Watchlist(in)
 }
 
 func (s *Server) AddMovie2Watchlist(c *gin.Context) (interface{}, error) {
-	var in addWatchlistIn
+	var in core.AddWatchlistIn
 	if err := c.ShouldBindJSON(&in); err != nil {
 		return nil, errors.Wrap(err, "bind query")
 	}
-	log.Infof("add movie watchlist input: %+v", in)
-	detailCn, err := s.MustTMDB().GetMovieDetails(in.TmdbID, db.LanguageCN)
-	if err != nil {
-		return nil, errors.Wrap(err, "get movie detail")
-	}
-	var nameCn = detailCn.Title
-
-	detailEn, _ := s.MustTMDB().GetMovieDetails(in.TmdbID, db.LanguageEN)
-	var nameEn = detailEn.Title
-	var detail *tmdb.MovieDetails
-	if s.language == "" || s.language == db.LanguageCN {
-		detail = detailCn
-	} else {
-		detail = detailEn
-	}
-	log.Infof("find detail for movie id %d: %v", in.TmdbID, detail)
-
-	epid, err := s.db.SaveEposideDetail(&ent.Episode{
-		SeasonNumber:  1,
-		EpisodeNumber: 1,
-		Title:         "dummy episode for movies",
-		Overview:      "dummy episode for movies",
-		AirDate:       detail.ReleaseDate,
-		Monitored:     true,
-	})
-	if err != nil {
-		return nil, errors.Wrap(err, "add dummy episode")
-	}
-	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},
-	}
-
-	extras := schema.MediaExtras{
-		IsAdultMovie:     detail.Adult,
-		OriginalLanguage: detail.OriginalLanguage,
-		Genres:           detail.Genres,
-	}
-	if isJav(detail) {
-		javid := s.getJavid(in.TmdbID)
-		extras.JavId = javid
-	}
-
-	movie.Extras = extras
-	r, err := s.db.AddMediaWatchlist(&movie, []int{epid})
-	if err != nil {
-		return nil, errors.Wrap(err, "add to list")
-	}
-	go func() {
-		if err := s.downloadPoster(detail.PosterPath, r.ID); err != nil {
-			log.Errorf("download poster error: %v", err)
-		}
-		if err := s.downloadBackdrop(detail.BackdropPath, r.ID); err != nil {
-			log.Errorf("download backdrop error: %v", err)
-		}
-	}()
-
-	log.Infof("add movie %s to watchlist success", detail.Title)
-	return nil, nil
-
-}
-
-func (s *Server) downloadBackdrop(path string, mediaID int) error {
-	url := "https://image.tmdb.org/t/p/original" + path
-	return s.downloadImage(url, mediaID, "backdrop.jpg")
-}
-
-func (s *Server) downloadPoster(path string, mediaID int) error {
-	var url = "https://image.tmdb.org/t/p/original" + path
-
-	return s.downloadImage(url, mediaID, "poster.jpg")
-}
-
-func (s *Server) downloadImage(url string, mediaID int, name string) error {
-
-	log.Infof("try to download image: %v", url)
-	var resp, err = http.Get(url)
-	if err != nil {
-		return errors.Wrap(err, "http get")
-	}
-	targetDir := fmt.Sprintf("%v/%d", db.ImgPath, mediaID)
-	os.MkdirAll(targetDir, 0777)
-	//ext := filepath.Ext(path)
-	targetFile := filepath.Join(targetDir, name)
-	f, err := os.Create(targetFile)
-	if err != nil {
-		return errors.Wrap(err, "new file")
-	}
-	defer f.Close()
-	_, err = io.Copy(f, resp.Body)
-	if err != nil {
-		return errors.Wrap(err, "copy http response")
-	}
-	log.Infof("image successfully downlaoded: %v", targetFile)
-	return nil
-
+	return s.core.AddMovie2Watchlist(in)
 }
 
 type MediaWithStatus struct {

ui/lib/activity.dart

@@ -138,7 +138,7 @@ class _ActivityPageState extends ConsumerState<ActivityPage>
                           trailing: selectedTab == 0
                               ? IconButton(
                                   tooltip: "删除任务",
-                                  onPressed: () => onDelete()(ac.id!),
+                                  onPressed: () => onDelete()(ac.id!.toString()),
                                   icon: const Icon(Icons.delete))
                               : const Text("-"),
                         ),
@@ -155,7 +155,7 @@ class _ActivityPageState extends ConsumerState<ActivityPage>
     );
   }
 
-  Function(int) onDelete() {
+  Function(String) onDelete() {
     return (id) {
       final f = ref
           .read(activitiesDataProvider("active").notifier)

ui/lib/calendar.dart

@@ -0,0 +1,60 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:table_calendar/table_calendar.dart';
+
+class Calendar extends ConsumerStatefulWidget {
+  @override
+  ConsumerState<ConsumerStatefulWidget> createState() {
+    return _CalendarSate();
+  }
+}
+
+class _CalendarSate extends ConsumerState<Calendar> {
+  DateTime? _selectedDay;
+  DateTime _focusedDay = DateTime.now();
+  CalendarFormat _calendarFormat = CalendarFormat.month;
+
+  @override
+  Widget build(BuildContext context) {
+    return TableCalendar(
+      locale: "zh_CN",
+      firstDay: DateTime.utc(2010, 10, 16),
+      lastDay: DateTime.utc(2030, 3, 14),
+      focusedDay: _focusedDay,
+      selectedDayPredicate: (day) {
+        return isSameDay(_selectedDay, day);
+      },
+      onDaySelected: (selectedDay, focusedDay) {
+        setState(() {
+          _selectedDay = selectedDay;
+          _focusedDay = focusedDay; // update `_focusedDay` here as well
+        });
+      },
+      calendarFormat: _calendarFormat,
+      onFormatChanged: (format) {
+        setState(() {
+          _calendarFormat = format;
+        });
+      },
+
+      //locale: "zh_CN",
+      //eventLoader: (day) {},
+    );
+  }
+}
+
+showCalendar(BuildContext context) {
+  return showDialog<void>(
+    context: context,
+    barrierDismissible: true,
+    builder: (BuildContext context) {
+      return AlertDialog(
+        //title: Text("资源"),
+        content: SizedBox(
+            width: MediaQuery.of(context).size.width * 0.7,
+            height: MediaQuery.of(context).size.height * 0.6,
+            child: Calendar()),
+      );
+    },
+  );
+}

ui/lib/main.dart

@@ -2,7 +2,9 @@ import 'package:flutter/material.dart';
 import 'package:flutter_adaptive_scaffold/flutter_adaptive_scaffold.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:go_router/go_router.dart';
+import 'package:intl/date_symbol_data_local.dart';
 import 'package:ui/activity.dart';
+import 'package:ui/calendar.dart';
 import 'package:ui/login_page.dart';
 import 'package:ui/movie_watchlist.dart';
 import 'package:ui/providers/APIs.dart';
@@ -14,7 +16,7 @@ import 'package:ui/welcome_page.dart';
 import 'package:ui/widgets/utils.dart';
 
 void main() {
-  runApp(const MyApp());
+  initializeDateFormatting().then((_) => runApp(MyApp()));
 }
 
 class MyApp extends ConsumerStatefulWidget {
@@ -219,6 +221,9 @@ class _MainSkeletonState extends State<MainSkeleton> {
                   (BuildContext context, SearchController controller) {
             return [Text("dadada")];
           }),
+          IconButton(
+              onPressed: () => showCalendar(context),
+              icon: Icon(Icons.calendar_month)),
           MenuAnchor(
             menuChildren: [
               MenuItemButton(

ui/lib/providers/APIs.dart

@@ -36,6 +36,9 @@ class APIs {
   static final logFilesUrl = "$_baseUrl/api/v1/setting/logfiles";
   static final aboutUrl = "$_baseUrl/api/v1/setting/about";
   static final changeMonitoringUrl = "$_baseUrl/api/v1/setting/monitoring";
+  static final addImportlistUrl = "$_baseUrl/api/v1/importlist/add";
+  static final deleteImportlistUrl = "$_baseUrl/api/v1/importlist/delete";
+  static final getAllImportlists = "$_baseUrl/api/v1/importlist/";
 
   static final notifierAllUrl = "$_baseUrl/api/v1/notifier/all";
   static final notifierDeleteUrl = "$_baseUrl/api/v1/notifier/id/";
@@ -43,6 +46,8 @@ class APIs {
 
   static final tmdbImgBaseUrl = "$_baseUrl/api/v1/posters";
 
+  static final cronJobUrl = "$_baseUrl/api/v1/setting/cron/trigger";
+
   static const tmdbApiKey = "tmdb_api_key";
   static const downloadDirKey = "download_dir";
 
@@ -97,4 +102,14 @@ class APIs {
       context.go('/login');
     }
   }
+
+  static Future<void> triggerCronJob(String name) async {
+    var resp = await getDio().post(APIs.cronJobUrl, data: {"job_name": name});
+
+    var sp = ServerResponse.fromJson(resp.data);
+
+    if (sp.code != 0) {
+      throw sp.message;
+    }
+  }
 }

ui/lib/providers/activity.dart

@@ -47,7 +47,7 @@ class ActivityData extends AutoDisposeFamilyAsyncNotifier<List<Activity>, String
     return activities;
   }
 
-  Future<void> deleteActivity(int id) async {
+  Future<void> deleteActivity(String id) async {
     final dio = await APIs.getDio();
     var resp = await dio.delete("${APIs.activityUrl}$id");
     final sp = ServerResponse.fromJson(resp.data);

ui/lib/providers/settings.dart

@@ -21,6 +21,10 @@ var storageSettingProvider =
     AsyncNotifierProvider.autoDispose<StorageSettingData, List<Storage>>(
         StorageSettingData.new);
 
+var importlistProvider =
+    AsyncNotifierProvider.autoDispose<ImportListData, List<ImportList>>(
+        ImportListData.new);
+
 class EditSettingData extends AutoDisposeAsyncNotifier<GeneralSetting> {
   @override
   FutureOr<GeneralSetting> build() async {
@@ -55,6 +59,8 @@ class GeneralSetting {
   bool? allowQiangban;
   bool? enableNfo;
   bool? enableAdult;
+  String? tvNamingFormat;
+  String? movieNamingFormat;
 
   GeneralSetting(
       {this.tmdbApiKey,
@@ -64,6 +70,8 @@ class GeneralSetting {
       this.enablePlexmatch,
       this.enableNfo,
       this.allowQiangban,
+      this.tvNamingFormat,
+      this.movieNamingFormat,
       this.enableAdult});
 
   factory GeneralSetting.fromJson(Map<String, dynamic> json) {
@@ -72,9 +80,11 @@ class GeneralSetting {
         downloadDIr: json["download_dir"],
         logLevel: json["log_level"],
         proxy: json["proxy"],
-        enableAdult: json["enable_adult_content"]??false,
+        enableAdult: json["enable_adult_content"] ?? false,
         allowQiangban: json["allow_qiangban"] ?? false,
         enableNfo: json["enable_nfo"] ?? false,
+        tvNamingFormat: json["tv_naming_format"],
+        movieNamingFormat: json["movie_naming_format"],
         enablePlexmatch: json["enable_plexmatch"] ?? false);
   }
 
@@ -88,6 +98,8 @@ class GeneralSetting {
     data["allow_qiangban"] = allowQiangban;
     data["enable_nfo"] = enableNfo;
     data["enable_adult_content"] = enableAdult;
+    data["tv_naming_format"] = tvNamingFormat;
+    data["movie_naming_format"] = movieNamingFormat;
     return data;
   }
 }
@@ -413,3 +425,77 @@ class About {
     );
   }
 }
+
+class ImportList {
+  final int? id;
+  final String? name;
+  final String? url;
+  final String? qulity;
+  final int? storageId;
+  final String? type;
+  ImportList({
+    this.id,
+    this.name,
+    this.url,
+    this.qulity,
+    this.storageId,
+    this.type,
+  });
+
+  factory ImportList.fromJson(Map<String, dynamic> json) {
+    return ImportList(
+        id: json["id"],
+        name: json["name"],
+        url: json["url"],
+        qulity: json["qulity"],
+        type: json["type"],
+        storageId: json["storage_id"]);
+  }
+
+  Map<String, dynamic> tojson() => {
+        "name": name,
+        "url": url,
+        "qulity": qulity,
+        "type": type,
+        "storage_id": storageId
+      };
+}
+
+class ImportListData extends AutoDisposeAsyncNotifier<List<ImportList>> {
+  @override
+  FutureOr<List<ImportList>> build() async {
+    final dio = APIs.getDio();
+    var resp = await dio.get(APIs.getAllImportlists);
+    var sp = ServerResponse.fromJson(resp.data);
+    if (sp.code != 0) {
+      throw sp.message;
+    }
+    List<ImportList> list = List.empty(growable: true);
+
+    for (var item in sp.data as List) {
+      var il = ImportList.fromJson(item);
+      list.add(il);
+    }
+    return list;
+  }
+
+  addImportlist(ImportList il) async {
+    final dio = APIs.getDio();
+    var resp = await dio.post(APIs.addImportlistUrl, data: il.tojson());
+    var sp = ServerResponse.fromJson(resp.data);
+    if (sp.code != 0) {
+      throw sp.message;
+    }
+    ref.invalidateSelf();
+  }
+
+  deleteimportlist(int id) async {
+    final dio = APIs.getDio();
+    var resp = await dio.post(APIs.deleteImportlistUrl, data: {"id": id});
+    var sp = ServerResponse.fromJson(resp.data);
+    if (sp.code != 0) {
+      throw sp.message;
+    }
+    ref.invalidateSelf();
+  }
+}

ui/lib/providers/welcome_data.dart

@@ -115,7 +115,7 @@ class SearchPageData
       if (sp.code != 0) {
         throw sp.message;
       }
-      ref.invalidate(tvWatchlistDataProvider);
+      //ref.invalidate(tvWatchlistDataProvider);
     } else {
       var resp = await dio.post(APIs.watchlistMovieUrl, data: {
         "tmdb_id": tmdbId,

ui/lib/settings/dialog.dart

@@ -17,7 +17,7 @@ Future<void> showSettingDialog(
           content: SingleChildScrollView(
             child: SizedBox(
               width: 400,
-              child: body,
+              child: SelectionArea(child: body),
             ),
           ),
           actions: <Widget>[

ui/lib/settings/general.dart

@@ -38,6 +38,8 @@ class _GeneralState extends ConsumerState<GeneralSettings> {
               "allow_qiangban": v.allowQiangban,
               "enable_nfo": v.enableNfo,
               "enable_adult": v.enableAdult,
+              "tv_naming_format": v.tvNamingFormat,
+              "movie_naming_format": v.movieNamingFormat,
             },
             child: Column(
               crossAxisAlignment: CrossAxisAlignment.start,
@@ -63,8 +65,25 @@ class _GeneralState extends ConsumerState<GeneralSettings> {
                   decoration: const InputDecoration(
                       labelText: "代理地址",
                       icon: Icon(Icons.web),
+                      hintText: "http://10.0.0.1:1080",
                       helperText: "后台联网代理地址，留空表示不启用代理"),
                 ),
+                FormBuilderTextField(
+                  decoration: const InputDecoration(
+                      icon: Icon(Icons.folder),
+                      labelText: "电视剧路径命名规则",
+                      helperText:
+                          "go template语法，可用的变量为：.NameCN, .NameEN, .Year, .TmdbID"),
+                  name: "tv_naming_format",
+                ),
+                FormBuilderTextField(
+                  decoration: const InputDecoration(
+                      icon: Icon(Icons.folder),
+                      labelText: "电影路径命名规则",
+                      helperText:
+                          "go template语法，可用的变量为：.NameCN, .NameEN, .Year, .TmdbID"),
+                  name: "movie_naming_format",
+                ),
                 SizedBox(
                   width: 300,
                   child: FormBuilderDropdown(
@@ -136,6 +155,9 @@ class _GeneralState extends ConsumerState<GeneralSettings> {
                                     allowQiangban: values["allow_qiangban"],
                                     enableAdult: values["enable_adult"],
                                     enableNfo: values["enable_nfo"],
+                                    tvNamingFormat: values["tv_naming_format"],
+                                    movieNamingFormat:
+                                        values["movie_naming_format"],
                                     enablePlexmatch:
                                         values["enable_plexmatch"]))
                                 .then((v) => showSnakeBar("更新成功"));

ui/lib/settings/importlist.dart

@@ -0,0 +1,147 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_form_builder/flutter_form_builder.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:form_builder_validators/form_builder_validators.dart';
+import 'package:ui/providers/settings.dart';
+import 'package:ui/settings/dialog.dart';
+import 'package:ui/widgets/progress_indicator.dart';
+import 'package:ui/widgets/widgets.dart';
+
+class Importlist extends ConsumerStatefulWidget {
+  const Importlist({super.key});
+
+  @override
+  ConsumerState<ConsumerStatefulWidget> createState() {
+    return _ImportlistState();
+  }
+}
+
+class _ImportlistState extends ConsumerState<Importlist> {
+  @override
+  Widget build(BuildContext context) {
+    var importlists = ref.watch(importlistProvider);
+
+    return importlists.when(
+        data: (value) => Wrap(
+              children: List.generate(value.length + 1, (i) {
+                if (i < value.length) {
+                  var indexer = value[i];
+                  return SettingsCard(
+                      onTap: () => showImportlistDetails(indexer),
+                      child: Text(indexer.name ?? ""));
+                }
+                return SettingsCard(
+                    onTap: () => showImportlistDetails(ImportList()),
+                    child: const Icon(Icons.add));
+              }),
+            ),
+        error: (err, trace) => Text("$err"),
+        loading: () => const MyProgressIndicator());
+  }
+
+  Future<void> showImportlistDetails(ImportList list) {
+    final _formKey = GlobalKey<FormBuilderState>();
+    String? _selectedType = list.type;
+
+    var body = StatefulBuilder(builder: (context, setState) {
+      return FormBuilder(
+        key: _formKey,
+        initialValue: {
+          "name": list.name,
+          "url": list.url,
+          "qulity": list.qulity,
+          "type": list.type,
+          "storage_id": list.storageId
+        },
+        child: Column(
+          children: [
+            FormBuilderDropdown(
+              name: "type",
+              decoration: const InputDecoration(
+                  labelText: "类型",
+                  hintText:
+                      "Plex Watchlist: https://support.plex.tv/articles/universal-watchlist/"),
+              items: const [
+                DropdownMenuItem(value: "plex", child: Text("Plex Watchlist")),
+              ],
+              onChanged: (value) {
+                setState(() {
+                  _selectedType = value;
+                });
+              },
+            ),
+            _selectedType == "plex"
+                ? const Text(
+                    "Plex Watchlist: https://support.plex.tv/articles/universal-watchlist/")
+                : const Text(""),
+            FormBuilderTextField(
+              name: "name",
+              decoration: Commons.requiredTextFieldStyle(text: "名称"),
+              autovalidateMode: AutovalidateMode.onUserInteraction,
+              validator: FormBuilderValidators.required(),
+            ),
+            FormBuilderTextField(
+              name: "url",
+              decoration: Commons.requiredTextFieldStyle(text: "地址"),
+              autovalidateMode: AutovalidateMode.onUserInteraction,
+              validator: FormBuilderValidators.required(),
+            ),
+            FormBuilderDropdown(
+              name: "qulity",
+              decoration: const InputDecoration(labelText: "清晰度"),
+              items: const [
+                DropdownMenuItem(value: "720p", child: Text("720p")),
+                DropdownMenuItem(value: "1080p", child: Text("1080p")),
+                DropdownMenuItem(value: "2160p", child: Text("2160p")),
+              ],
+            ),
+            Consumer(
+              builder: (context, ref, child) {
+                var storage = ref.watch(storageSettingProvider);
+                return storage.when(
+                    data: (v) {
+                      return FormBuilderDropdown(
+                        name: "storage_id",
+                        decoration: const InputDecoration(labelText: "存储"),
+                        items: List.generate(
+                            v.length,
+                            (i) => DropdownMenuItem(
+                                  value: v[i].id,
+                                  child: Text(v[i].name!),
+                                )),
+                      );
+                    },
+                    error: (err, trace) => Text("$err"),
+                    loading: () => const MyProgressIndicator());
+              },
+            ),
+          ],
+        ),
+      );
+    });
+
+    onDelete() async {
+      return ref.read(importlistProvider.notifier).deleteimportlist(list.id!);
+    }
+
+    onSubmit() async {
+      if (_formKey.currentState!.saveAndValidate()) {
+        var values = _formKey.currentState!.value;
+
+        return ref.read(importlistProvider.notifier).addImportlist(ImportList(
+              id: list.id,
+              name: values["name"],
+              url: values["url"],
+              type: values["type"],
+              qulity: values["qulity"],
+              storageId: values["storage_id"],
+            ));
+      } else {
+        throw "validation_error";
+      }
+    }
+
+    return showSettingDialog(
+        context, "监控列表", list.id != null, body, onSubmit, onDelete);
+  }
+}

ui/lib/settings/notifier.dart

@@ -116,6 +116,7 @@ class _NotifierState extends ConsumerState<NotifierSettings> {
       },
       child: Column(
         children: [
+          const Text("https://bark.day.app/#/"),
           FormBuilderTextField(
             name: "name",
             decoration: Commons.requiredTextFieldStyle(text: "名称"),
@@ -176,6 +177,7 @@ class _NotifierState extends ConsumerState<NotifierSettings> {
       },
       child: Column(
         children: [
+          const Text("https://pushover.net/"),
           FormBuilderTextField(
             name: "name",
             decoration: Commons.requiredTextFieldStyle(text: "名称"),

ui/lib/settings/settings.dart

@@ -3,6 +3,7 @@ import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:ui/settings/auth.dart';
 import 'package:ui/settings/downloader.dart';
 import 'package:ui/settings/general.dart';
+import 'package:ui/settings/importlist.dart';
 import 'package:ui/settings/indexer.dart';
 import 'package:ui/settings/notifier.dart';
 import 'package:ui/settings/storage.dart';
@@ -21,49 +22,25 @@ class _SystemSettingsPageState extends ConsumerState<SystemSettingsPage> {
   @override
   Widget build(BuildContext context) {
     return ListView(
-      children: const [
-        ExpansionTile(
-          expandedAlignment: Alignment.centerLeft,
-          childrenPadding: EdgeInsets.fromLTRB(20, 0, 20, 0),
-          initiallyExpanded: true,
-          title: Text("常规"),
-          children: [GeneralSettings()],
-        ),
-        ExpansionTile(
-          expandedAlignment: Alignment.centerLeft,
-          childrenPadding: EdgeInsets.fromLTRB(20, 0, 20, 0),
-          initiallyExpanded: false,
-          title: Text("索引器"),
-          children: [IndexerSettings()],
-        ),
-        ExpansionTile(
-          expandedAlignment: Alignment.centerLeft,
-          childrenPadding: EdgeInsets.fromLTRB(20, 0, 20, 0),
-          initiallyExpanded: false,
-          title: Text("下载器"),
-          children: [DownloaderSettings()],
-        ),
-        ExpansionTile(
-          expandedAlignment: Alignment.centerLeft,
-          childrenPadding: EdgeInsets.fromLTRB(20, 0, 20, 0),
-          initiallyExpanded: false,
-          title: Text("存储"),
-          children: [StorageSettings()],
-        ),
-        ExpansionTile(
-          expandedAlignment: Alignment.centerLeft,
-          childrenPadding: EdgeInsets.fromLTRB(20, 0, 20, 0),
-          initiallyExpanded: false,
-          title: Text("通知客户端"),
-          children: [NotifierSettings()],
-        ),
-        ExpansionTile(
-          childrenPadding: EdgeInsets.fromLTRB(20, 0, 20, 0),
-          initiallyExpanded: false,
-          title: Text("认证"),
-          children: [AuthSettings()],
-        ),
+      children: [
+        getExpansionTile("常规", const GeneralSettings()),
+        getExpansionTile("索引器", const IndexerSettings()),
+        getExpansionTile("下载器", const DownloaderSettings()),
+        getExpansionTile("存储", const StorageSettings()),
+        getExpansionTile("通知客户端", const NotifierSettings()),
+        getExpansionTile("监控列表", const Importlist()),
+        getExpansionTile("认证", const AuthSettings())
       ],
     );
   }
+
+  Widget getExpansionTile(String name, Widget body) {
+    return ExpansionTile(
+      childrenPadding: const EdgeInsets.fromLTRB(20, 0, 20, 0),
+      expandedAlignment: Alignment.topLeft,
+      initiallyExpanded: false,
+      title: Text(name),
+      children: [body],
+    );
+  }
 }

ui/lib/system_page.dart

@@ -5,6 +5,7 @@ import 'package:ui/providers/APIs.dart';
 import 'package:ui/providers/settings.dart';
 import 'package:ui/widgets/utils.dart';
 import 'package:ui/widgets/progress_indicator.dart';
+import 'package:ui/widgets/widgets.dart';
 import 'package:url_launcher/url_launcher.dart';
 
 class SystemPage extends ConsumerStatefulWidget {
@@ -28,8 +29,8 @@ class _SystemPageState extends ConsumerState<SystemPage> {
           ExpansionTile(
             expandedCrossAxisAlignment: CrossAxisAlignment.stretch,
             initiallyExpanded: true,
-            childrenPadding: EdgeInsets.all(20),
-            title: Text("日志"),
+            childrenPadding: const EdgeInsets.all(20),
+            title: const Text("日志"),
             children: [
               logs.when(
                   data: (list) {
@@ -59,7 +60,62 @@ class _SystemPageState extends ConsumerState<SystemPage> {
             ],
           ),
           ExpansionTile(
-            title: Text("关于"),
+            expandedCrossAxisAlignment: CrossAxisAlignment.stretch,
+            initiallyExpanded: true,
+            childrenPadding: const EdgeInsets.all(20),
+            title: const Text("定时任务"),
+            children: [
+              logs.when(
+                  data: (list) {
+                    return DataTable(columns: const [
+                      DataColumn(label: Text("任务")),
+                      DataColumn(label: Text("间隔")),
+                      DataColumn(label: Text("手动触发"))
+                    ], rows: [
+                      DataRow(cells: [
+                        const DataCell(Text("检查并处理已完成任务")),
+                        const DataCell(Text("每分钟")),
+                        DataCell(LoadingIconButton(
+                          icon: Icons.not_started,
+                          onPressed: () =>
+                              APIs.triggerCronJob("check_running_tasks"),
+                        ))
+                      ]),
+                      DataRow(cells: [
+                        const DataCell(Text("下载监控中的剧集和电影")),
+                        const DataCell(Text("每小时")),
+                        DataCell(LoadingIconButton(
+                          icon: Icons.not_started,
+                          onPressed: () => APIs.triggerCronJob(
+                              "check_available_medias_to_download"),
+                        ))
+                      ]),
+                      DataRow(cells: [
+                        const DataCell(Text("更新监控列表")),
+                        const DataCell(Text("每小时")),
+                        DataCell(IconButton(
+                          icon: const Icon(Icons.not_started),
+                          onPressed: () =>
+                              APIs.triggerCronJob("update_import_lists"),
+                        ))
+                      ]),
+                      DataRow(cells: [
+                        const DataCell(Text("更新最新剧集信息")),
+                        const DataCell(Text("每天2次")),
+                        DataCell(LoadingIconButton(
+                          icon: Icons.not_started,
+                          onPressed: () =>
+                              APIs.triggerCronJob("check_series_new_release"),
+                        ))
+                      ]),
+                    ]);
+                  },
+                  error: (err, trace) => Text("$err"),
+                  loading: () => const MyProgressIndicator())
+            ],
+          ),
+          ExpansionTile(
+            title: const Text("关于"),
             expandedCrossAxisAlignment: CrossAxisAlignment.center,
             initiallyExpanded: true,
             children: [

ui/lib/welcome_page.dart

@@ -98,8 +98,8 @@ class MediaCard extends StatelessWidget {
                       LinearProgressIndicator(
                         value: 1,
                         color: item.downloadedNum! >= item.monitoredNum!
-                            ? Colors.green
-                            : Colors.blue,
+                            ? Colors.teal
+                            : Colors.lightGreen,
                       ),
                       Text(
                         item.name!,

ui/lib/widgets/detail_card.dart

@@ -38,7 +38,7 @@ class _DetailCardState extends ConsumerState<DetailCard> {
       margin: const EdgeInsets.all(4),
       clipBehavior: Clip.hardEdge,
       child: Container(
-        constraints: BoxConstraints(maxHeight: 400),
+        constraints: const BoxConstraints(maxHeight: 400),
         decoration: BoxDecoration(
             image: DecorationImage(
                 fit: BoxFit.cover,
@@ -52,7 +52,7 @@ class _DetailCardState extends ConsumerState<DetailCard> {
           child: Row(
             children: <Widget>[
               screenWidth < 600
-                  ? SizedBox()
+                  ? const SizedBox()
                   : Flexible(
                       flex: 2,
                       child: Padding(
@@ -72,14 +72,14 @@ class _DetailCardState extends ConsumerState<DetailCard> {
                       children: [
                         //const Text(""),
                         Text(
-                          "${widget.details.name} ${widget.details.name != widget.details.originalName ? widget.details.originalName : ''} (${widget.details.airDate!.split("-")[0]})",
+                          "${widget.details.name} ${widget.details.name != widget.details.originalName ? widget.details.originalName : ''} ${widget.details.airDate == null ? "" : (widget.details.airDate!.split("-")[0])}",
                           style: const TextStyle(
                               fontSize: 24,
                               fontWeight: FontWeight.bold,
                               height: 2.5),
                         ),
                         const Divider(thickness: 1, height: 1),
-                        Text(
+                        const Text(
                           "",
                           style: TextStyle(height: 0.2),
                         ),
@@ -93,14 +93,14 @@ class _DetailCardState extends ConsumerState<DetailCard> {
                               label: Text(
                                   "${widget.details.storage!.name}: ${widget.details.mediaType == "tv" ? widget.details.storage!.tvPath : widget.details.storage!.moviePath}"
                                   "${widget.details.targetDir}"),
-                              padding: EdgeInsets.all(0),
+                              padding: const EdgeInsets.all(0),
                             ),
                             Chip(
                               clipBehavior: Clip.hardEdge,
                               shape: ContinuousRectangleBorder(
                                   borderRadius: BorderRadius.circular(100.0)),
                               label: Text("${widget.details.resolution}"),
-                              padding: EdgeInsets.all(0),
+                              padding: const EdgeInsets.all(0),
                             ),
                             widget.details.limiter != null &&
                                     widget.details.limiter!.sizeMax > 0
@@ -109,13 +109,13 @@ class _DetailCardState extends ConsumerState<DetailCard> {
                                     shape: ContinuousRectangleBorder(
                                         borderRadius:
                                             BorderRadius.circular(100.0)),
-                                    padding: EdgeInsets.all(0),
+                                    padding: const EdgeInsets.all(0),
                                     label: Text(
                                         "${(widget.details.limiter!.sizeMin).readableFileSize()} - ${(widget.details.limiter!.sizeMax).readableFileSize()}"))
                                 : const SizedBox(),
                             MenuAnchor(
-                              style:
-                                  MenuStyle(alignment: Alignment.bottomRight),
+                              style: const MenuStyle(
+                                  alignment: Alignment.bottomRight),
                               menuChildren: [
                                 ActionChip.elevated(
                                     onPressed: () => launchUrl(url),
@@ -124,10 +124,10 @@ class _DetailCardState extends ConsumerState<DetailCard> {
                                     shape: ContinuousRectangleBorder(
                                         borderRadius:
                                             BorderRadius.circular(100.0)),
-                                    padding: EdgeInsets.all(0),
-                                    label: Text("TMDB")),
+                                    padding: const EdgeInsets.all(0),
+                                    label: const Text("TMDB")),
                                 isBlank(widget.details.imdbid)
-                                    ? SizedBox()
+                                    ? const SizedBox()
                                     : ActionChip.elevated(
                                         onPressed: () => launchUrl(imdbUrl),
                                         backgroundColor: Colors.indigo[700],
@@ -135,8 +135,8 @@ class _DetailCardState extends ConsumerState<DetailCard> {
                                         shape: ContinuousRectangleBorder(
                                             borderRadius:
                                                 BorderRadius.circular(100.0)),
-                                        padding: EdgeInsets.all(0),
-                                        label: Text("IMDB"),
+                                        padding: const EdgeInsets.all(0),
+                                        label: const Text("IMDB"),
                                       )
                               ],
                               builder: (context, controller, child) {
@@ -152,8 +152,8 @@ class _DetailCardState extends ConsumerState<DetailCard> {
                                     shape: ContinuousRectangleBorder(
                                         borderRadius:
                                             BorderRadius.circular(100.0)),
-                                    padding: EdgeInsets.all(0),
-                                    label: Text("外部链接"));
+                                    padding: const EdgeInsets.all(0),
+                                    label: const Text("外部链接"));
                               },
                             ),
                           ],
@@ -170,7 +170,7 @@ class _DetailCardState extends ConsumerState<DetailCard> {
                           children: [
                             downloadButton(),
                             editIcon(),
-                            deleteIcon(),
+                            deleteIcon(context),
                           ],
                         )
                       ],
@@ -185,14 +185,14 @@ class _DetailCardState extends ConsumerState<DetailCard> {
     );
   }
 
-  Widget deleteIcon() {
+  Widget deleteIcon(BuildContext oriContext) {
     return IconButton(
         tooltip: widget.details.mediaType == "tv" ? "删除剧集" : "删除电影",
-        onPressed: () => showConfirmDialog(),
+        onPressed: () => showConfirmDialog(oriContext),
         icon: const Icon(Icons.delete));
   }
 
-  Future<void> showConfirmDialog() {
+  Future<void> showConfirmDialog(BuildContext oriContext) {
     return showDialog<void>(
       context: context,
       barrierDismissible: true,
@@ -210,9 +210,13 @@ class _DetailCardState extends ConsumerState<DetailCard> {
                       .read(mediaDetailsProvider(widget.details.id.toString())
                           .notifier)
                       .delete()
-                      .then((v) => context.go(widget.details.mediaType == "tv"
+                      .then((v) {
+                    if (oriContext.mounted) {
+                      oriContext.go(widget.details.mediaType == "tv"
                           ? WelcomePage.routeTv
-                          : WelcomePage.routeMoivie));
+                          : WelcomePage.routeMoivie);
+                    }
+                  });
                   Navigator.of(context).pop();
                 },
                 child: const Text("确认"))
@@ -292,7 +296,11 @@ class _DetailCardState extends ConsumerState<DetailCard> {
                             .notifier)
                         .edit(values["resolution"], values["target_dir"],
                             values["limiter"])
-                        .then((v) => Navigator.of(context).pop());
+                        .then((v) {
+                      if (context.mounted) {
+                        Navigator.of(context).pop();
+                      }
+                    });
                   }
                 },
                 label: const Text("确认"))

ui/lib/widgets/widgets.dart

@@ -142,7 +142,7 @@ class _MySliderState extends State<MyRangeSlider> {
 }
 
 class LoadingIconButton extends StatefulWidget {
-  LoadingIconButton({required this.onPressed, required this.icon, this.tooltip});
+  const LoadingIconButton({super.key, required this.onPressed, required this.icon, this.tooltip});
   final Future<void> Function() onPressed;
   final IconData icon;
   final String? tooltip;
@@ -187,7 +187,7 @@ class _LoadingIconButtonState extends State<LoadingIconButton> {
 }
 
 class LoadingTextButton extends StatefulWidget {
-  LoadingTextButton({required this.onPressed, required this.label});
+  const LoadingTextButton({super.key, required this.onPressed, required this.label});
   final Future<void> Function() onPressed;
   final Widget label;
 

ui/pubspec.lock

@@ -365,6 +365,14 @@ packages:
       url: "https://pub.flutter-io.cn"
     source: hosted
     version: "3.2.0"
+  simple_gesture_detector:
+    dependency: transitive
+    description:
+      name: simple_gesture_detector
+      sha256: ba2cd5af24ff20a0b8d609cec3f40e5b0744d2a71804a2616ae086b9c19d19a3
+      url: "https://pub.flutter-io.cn"
+    source: hosted
+    version: "0.2.1"
   sky_engine:
     dependency: transitive
     description: flutter
@@ -410,6 +418,14 @@ packages:
       url: "https://pub.flutter-io.cn"
     source: hosted
     version: "1.2.0"
+  table_calendar:
+    dependency: "direct main"
+    description:
+      name: table_calendar
+      sha256: "4ca32b2fc919452c9974abd4c6ea611a63e33b9e4f0b8c38dba3ac1f4a6549d1"
+      url: "https://pub.flutter-io.cn"
+    source: hosted
+    version: "3.1.2"
   term_glyph:
     dependency: transitive
     description:
@@ -518,10 +534,10 @@ packages:
     dependency: transitive
     description:
       name: vm_service
-      sha256: f652077d0bdf60abe4c1f6377448e8655008eef28f128bc023f7b5e8dfeb48fc
+      sha256: "5c5f338a667b4c644744b661f309fb8080bb94b18a7e91ef1dbd343bed00ed6d"
       url: "https://pub.flutter-io.cn"
     source: hosted
-    version: "14.2.4"
+    version: "14.2.5"
   web:
     dependency: transitive
     description:

ui/pubspec.yaml

@@ -46,6 +46,7 @@ dependencies:
   form_builder_validators: ^11.0.0
   url_launcher: ^6.3.0
   timeago: ^3.7.0
+  table_calendar: ^3.1.2
 
 dev_dependencies:
   flutter_test: