diff --git a/db/const.go b/db/const.go index 15ba9f7..71874a0 100644 --- a/db/const.go +++ b/db/const.go @@ -5,8 +5,34 @@ const ( SettingLanguage = "language" SettingJacketUrl = "jacket_url" SettingJacketApiKey = "jacket_api_key" + SettingDownloadDir = "download_dir" ) const ( IndexerTorznabImpl = "torznab" -) \ No newline at end of file +) + +type ResolutionType string + +const ( + Any ResolutionType = "any" + R720p ResolutionType = "720p" + R1080p ResolutionType = "1080p" + R4k ResolutionType = "4k" +) + +func (r ResolutionType) String() string { + return string(r) +} + +const ( + ImplLocal = "local" + ImplWebdav = "webdav" +) + +func StorageImplementations() []string { + return []string{ + ImplLocal, + ImplWebdav, + } +} \ No newline at end of file diff --git a/db/db.go b/db/db.go index 79cebce..fc781de 100644 --- a/db/db.go +++ b/db/db.go @@ -6,10 +6,14 @@ import ( "fmt" "polaris/ent" "polaris/ent/downloadclients" + "polaris/ent/history" "polaris/ent/indexers" "polaris/ent/series" "polaris/ent/settings" + "polaris/ent/storage" "polaris/log" + "slices" + "time" "entgo.io/ent/dialect" tmdb "github.com/cyruzin/golang-tmdb" @@ -65,19 +69,32 @@ func (c *Client) GetLanguage() string { return lang } -func (c *Client) AddWatchlist(path string, detail *tmdb.TVDetails, episodes []int) (*ent.Series, error) { +func (c *Client) AddWatchlist(storageId int, nameEn string, detail *tmdb.TVDetails, episodes []int, res ResolutionType) (*ent.Series, error) { count := c.ent.Series.Query().Where(series.TmdbID(int(detail.ID))).CountX(context.Background()) if count > 0 { return nil, fmt.Errorf("tv series %s already in watchlist", detail.Name) } + if res == "" { + res = R1080p + } + if storageId == 0 { + r, err := c.ent.Storage.Query().Where(storage.Default(true)).First(context.TODO()) + if err == nil { + log.Infof("use default storage: %v", r.Name) + storageId = r.ID + } + } + r, err := c.ent.Series.Create(). SetTmdbID(int(detail.ID)). - SetPath(path). + SetStorageID(storageId). SetOverview(detail.Overview). SetName(detail.Name). + SetNameEn(nameEn). SetOriginalName(detail.OriginalName). SetPosterPath(detail.PosterPath). SetAirDate(detail.FirstAirDate). + SetResolution(res.String()). AddEpisodeIDs(episodes...). Save(context.TODO()) return r, err @@ -206,3 +223,117 @@ func (c *Client) GetAllDonloadClients() []*ent.DownloadClients { func (c *Client) DeleteDownloadCLient(id int) { c.ent.DownloadClients.Delete().Where(downloadclients.ID(id)).Exec(context.TODO()) } + +// Storage is the model entity for the Storage schema. +type StorageInfo struct { + Name string `json:"name"` + Implementation string `json:"implementation"` + Path string `json:"path"` + User string `json:"user"` + Password string `json:"password"` + Default bool `json:"default"` +} + +func (c *Client) AddStorage(s StorageInfo) error { + if !slices.Contains(StorageImplementations(), s.Implementation) { + return fmt.Errorf("implementation not supported: %v", s.Implementation) + } + count := c.ent.Storage.Query().Where(storage.Name(s.Name)).CountX(context.TODO()) + if count > 0 { + //storage already exist, edit exist one + return c.ent.Storage.Update().Where(storage.Name(s.Name)). + SetImplementation(s.Implementation). + SetPath(s.Path). + SetUser(s.User). + SetPassword(s.Password).Exec(context.TODO()) + } + _, err := c.ent.Storage.Create().SetName(s.Name). + SetImplementation(s.Implementation). + SetPath(s.Path). + SetUser(s.User). + SetPassword(s.Password).Save(context.TODO()) + if err != nil { + return err + } + if s.Default { + return c.SetDefaultStorageByName(s.Name) + } + return nil +} + +func (c *Client) GetAllStorage() []*ent.Storage { + data, err := c.ent.Storage.Query().Where(storage.Deleted(false)).All(context.TODO()) + if err != nil { + log.Errorf("get storage: %v", err) + return nil + } + return data +} + +func (c *Client) GetStorage(id int) *ent.Storage { + r, err := c.ent.Storage.Query().Where(storage.ID(id)).First(context.TODO()) + if err != nil { + //use default storage + return c.ent.Storage.Query().Where(storage.Default(true)).FirstX(context.TODO()) + } + return r +} + +func (c *Client) DeleteStorage(id int) error { + return c.ent.Storage.Update().Where(storage.ID(id)).SetDeleted(true).Exec(context.TODO()) +} + +func (c *Client) SetDefaultStorage(id int) error { + err := c.ent.Storage.Update().Where(storage.ID(id)).SetDefault(true).Exec(context.TODO()) + if err != nil { + return err + } + err = c.ent.Storage.Update().Where(storage.Or(storage.ID(id))).SetDefault(false).Exec(context.TODO()) + return err +} + +func (c *Client) SetDefaultStorageByName(name string) error { + err := c.ent.Storage.Update().Where(storage.Name(name)).SetDefault(true).Exec(context.TODO()) + if err != nil { + return err + } + err = c.ent.Storage.Update().Where(storage.Or(storage.Name(name))).SetDefault(false).Exec(context.TODO()) + return err +} + + +func (c *Client) SaveHistoryRecord(h ent.History) (*ent.History,error) { + return c.ent.History.Create().SetSeriesID(h.SeriesID).SetEpisodeID(h.EpisodeID).SetDate(time.Now()). + SetCompleted(h.Completed).SetTargetDir(h.TargetDir).SetSourceTitle(h.SourceTitle).SetSaved(h.Saved).Save(context.TODO()) +} + +func (c *Client) SetHistoryComplete(id int) error { + return c.ent.History.Update().Where(history.ID(id)).SetCompleted(true).Exec(context.TODO()) +} + +func (c *Client) GetHistories() ent.Histories { + h, err := c.ent.History.Query().All(context.TODO()) + if err != nil { + return nil + } + return h +} + +func (c *Client) GetHistory(id int) *ent.History { + return c.ent.History.Query().Where(history.ID(id)).FirstX(context.TODO()) +} + + +func (c *Client) DeleteHistory(id int) error { + _, err := c.ent.History.Delete().Where(history.ID(id)).Exec(context.Background()) + return err +} + + +func (c *Client) GetDownloadDir() string { + r, err := c.ent.Settings.Query().Where(settings.Key(SettingDownloadDir)).First(context.TODO()) + if err != nil { + return "/download" + } + return r.Value +} \ No newline at end of file diff --git a/ent/client.go b/ent/client.go index a75a341..a0b4911 100644 --- a/ent/client.go +++ b/ent/client.go @@ -17,6 +17,7 @@ import ( "polaris/ent/indexers" "polaris/ent/series" "polaris/ent/settings" + "polaris/ent/storage" "entgo.io/ent" "entgo.io/ent/dialect" @@ -41,6 +42,8 @@ type Client struct { Series *SeriesClient // Settings is the client for interacting with the Settings builders. Settings *SettingsClient + // Storage is the client for interacting with the Storage builders. + Storage *StorageClient } // NewClient creates a new client configured with the given options. @@ -58,6 +61,7 @@ func (c *Client) init() { c.Indexers = NewIndexersClient(c.config) c.Series = NewSeriesClient(c.config) c.Settings = NewSettingsClient(c.config) + c.Storage = NewStorageClient(c.config) } type ( @@ -156,6 +160,7 @@ func (c *Client) Tx(ctx context.Context) (*Tx, error) { Indexers: NewIndexersClient(cfg), Series: NewSeriesClient(cfg), Settings: NewSettingsClient(cfg), + Storage: NewStorageClient(cfg), }, nil } @@ -181,6 +186,7 @@ func (c *Client) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error) Indexers: NewIndexersClient(cfg), Series: NewSeriesClient(cfg), Settings: NewSettingsClient(cfg), + Storage: NewStorageClient(cfg), }, nil } @@ -211,6 +217,7 @@ func (c *Client) Close() error { func (c *Client) Use(hooks ...Hook) { for _, n := range []interface{ Use(...Hook) }{ c.DownloadClients, c.Episode, c.History, c.Indexers, c.Series, c.Settings, + c.Storage, } { n.Use(hooks...) } @@ -221,6 +228,7 @@ func (c *Client) Use(hooks ...Hook) { func (c *Client) Intercept(interceptors ...Interceptor) { for _, n := range []interface{ Intercept(...Interceptor) }{ c.DownloadClients, c.Episode, c.History, c.Indexers, c.Series, c.Settings, + c.Storage, } { n.Intercept(interceptors...) } @@ -241,6 +249,8 @@ func (c *Client) Mutate(ctx context.Context, m Mutation) (Value, error) { return c.Series.mutate(ctx, m) case *SettingsMutation: return c.Settings.mutate(ctx, m) + case *StorageMutation: + return c.Storage.mutate(ctx, m) default: return nil, fmt.Errorf("ent: unknown mutation type %T", m) } @@ -1076,12 +1086,147 @@ func (c *SettingsClient) mutate(ctx context.Context, m *SettingsMutation) (Value } } +// StorageClient is a client for the Storage schema. +type StorageClient struct { + config +} + +// NewStorageClient returns a client for the Storage from the given config. +func NewStorageClient(c config) *StorageClient { + return &StorageClient{config: c} +} + +// Use adds a list of mutation hooks to the hooks stack. +// A call to `Use(f, g, h)` equals to `storage.Hooks(f(g(h())))`. +func (c *StorageClient) Use(hooks ...Hook) { + c.hooks.Storage = append(c.hooks.Storage, hooks...) +} + +// Intercept adds a list of query interceptors to the interceptors stack. +// A call to `Intercept(f, g, h)` equals to `storage.Intercept(f(g(h())))`. +func (c *StorageClient) Intercept(interceptors ...Interceptor) { + c.inters.Storage = append(c.inters.Storage, interceptors...) +} + +// Create returns a builder for creating a Storage entity. +func (c *StorageClient) Create() *StorageCreate { + mutation := newStorageMutation(c.config, OpCreate) + return &StorageCreate{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// CreateBulk returns a builder for creating a bulk of Storage entities. +func (c *StorageClient) CreateBulk(builders ...*StorageCreate) *StorageCreateBulk { + return &StorageCreateBulk{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 *StorageClient) MapCreateBulk(slice any, setFunc func(*StorageCreate, int)) *StorageCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &StorageCreateBulk{err: fmt.Errorf("calling to StorageClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*StorageCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &StorageCreateBulk{config: c.config, builders: builders} +} + +// Update returns an update builder for Storage. +func (c *StorageClient) Update() *StorageUpdate { + mutation := newStorageMutation(c.config, OpUpdate) + return &StorageUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// UpdateOne returns an update builder for the given entity. +func (c *StorageClient) UpdateOne(s *Storage) *StorageUpdateOne { + mutation := newStorageMutation(c.config, OpUpdateOne, withStorage(s)) + return &StorageUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// UpdateOneID returns an update builder for the given id. +func (c *StorageClient) UpdateOneID(id int) *StorageUpdateOne { + mutation := newStorageMutation(c.config, OpUpdateOne, withStorageID(id)) + return &StorageUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// Delete returns a delete builder for Storage. +func (c *StorageClient) Delete() *StorageDelete { + mutation := newStorageMutation(c.config, OpDelete) + return &StorageDelete{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// DeleteOne returns a builder for deleting the given entity. +func (c *StorageClient) DeleteOne(s *Storage) *StorageDeleteOne { + return c.DeleteOneID(s.ID) +} + +// DeleteOneID returns a builder for deleting the given entity by its id. +func (c *StorageClient) DeleteOneID(id int) *StorageDeleteOne { + builder := c.Delete().Where(storage.ID(id)) + builder.mutation.id = &id + builder.mutation.op = OpDeleteOne + return &StorageDeleteOne{builder} +} + +// Query returns a query builder for Storage. +func (c *StorageClient) Query() *StorageQuery { + return &StorageQuery{ + config: c.config, + ctx: &QueryContext{Type: TypeStorage}, + inters: c.Interceptors(), + } +} + +// Get returns a Storage entity by its id. +func (c *StorageClient) Get(ctx context.Context, id int) (*Storage, error) { + return c.Query().Where(storage.ID(id)).Only(ctx) +} + +// GetX is like Get, but panics if an error occurs. +func (c *StorageClient) GetX(ctx context.Context, id int) *Storage { + obj, err := c.Get(ctx, id) + if err != nil { + panic(err) + } + return obj +} + +// Hooks returns the client hooks. +func (c *StorageClient) Hooks() []Hook { + return c.hooks.Storage +} + +// Interceptors returns the client interceptors. +func (c *StorageClient) Interceptors() []Interceptor { + return c.inters.Storage +} + +func (c *StorageClient) mutate(ctx context.Context, m *StorageMutation) (Value, error) { + switch m.Op() { + case OpCreate: + return (&StorageCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx) + case OpUpdate: + return (&StorageUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx) + case OpUpdateOne: + return (&StorageUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx) + case OpDelete, OpDeleteOne: + return (&StorageDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx) + default: + return nil, fmt.Errorf("ent: unknown Storage mutation op: %q", m.Op()) + } +} + // hooks and interceptors per client, for fast access. type ( hooks struct { - DownloadClients, Episode, History, Indexers, Series, Settings []ent.Hook + DownloadClients, Episode, History, Indexers, Series, Settings, + Storage []ent.Hook } inters struct { - DownloadClients, Episode, History, Indexers, Series, Settings []ent.Interceptor + DownloadClients, Episode, History, Indexers, Series, Settings, + Storage []ent.Interceptor } ) diff --git a/ent/ent.go b/ent/ent.go index 1f7399d..c83f041 100644 --- a/ent/ent.go +++ b/ent/ent.go @@ -12,6 +12,7 @@ import ( "polaris/ent/indexers" "polaris/ent/series" "polaris/ent/settings" + "polaris/ent/storage" "reflect" "sync" @@ -84,6 +85,7 @@ func checkColumn(table, column string) error { indexers.Table: indexers.ValidColumn, series.Table: series.ValidColumn, settings.Table: settings.ValidColumn, + storage.Table: storage.ValidColumn, }) }) return columnCheck(table, column) diff --git a/ent/history.go b/ent/history.go index 00ce3e6..ecf97b4 100644 --- a/ent/history.go +++ b/ent/history.go @@ -24,7 +24,13 @@ type History struct { // SourceTitle holds the value of the "source_title" field. SourceTitle string `json:"source_title,omitempty"` // Date holds the value of the "date" field. - Date time.Time `json:"date,omitempty"` + Date time.Time `json:"date,omitempty"` + // TargetDir holds the value of the "target_dir" field. + TargetDir string `json:"target_dir,omitempty"` + // Completed holds the value of the "completed" field. + Completed bool `json:"completed,omitempty"` + // Saved holds the value of the "saved" field. + Saved string `json:"saved,omitempty"` selectValues sql.SelectValues } @@ -33,9 +39,11 @@ func (*History) scanValues(columns []string) ([]any, error) { values := make([]any, len(columns)) for i := range columns { switch columns[i] { + case history.FieldCompleted: + values[i] = new(sql.NullBool) case history.FieldID, history.FieldSeriesID, history.FieldEpisodeID: values[i] = new(sql.NullInt64) - case history.FieldSourceTitle: + case history.FieldSourceTitle, history.FieldTargetDir, history.FieldSaved: values[i] = new(sql.NullString) case history.FieldDate: values[i] = new(sql.NullTime) @@ -84,6 +92,24 @@ func (h *History) assignValues(columns []string, values []any) error { } else if value.Valid { h.Date = value.Time } + case history.FieldTargetDir: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field target_dir", values[i]) + } else if value.Valid { + h.TargetDir = value.String + } + case history.FieldCompleted: + if value, ok := values[i].(*sql.NullBool); !ok { + return fmt.Errorf("unexpected type %T for field completed", values[i]) + } else if value.Valid { + h.Completed = value.Bool + } + case history.FieldSaved: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field saved", values[i]) + } else if value.Valid { + h.Saved = value.String + } default: h.selectValues.Set(columns[i], values[i]) } @@ -131,6 +157,15 @@ func (h *History) String() string { builder.WriteString(", ") builder.WriteString("date=") builder.WriteString(h.Date.Format(time.ANSIC)) + builder.WriteString(", ") + builder.WriteString("target_dir=") + builder.WriteString(h.TargetDir) + builder.WriteString(", ") + builder.WriteString("completed=") + builder.WriteString(fmt.Sprintf("%v", h.Completed)) + builder.WriteString(", ") + builder.WriteString("saved=") + builder.WriteString(h.Saved) builder.WriteByte(')') return builder.String() } diff --git a/ent/history/history.go b/ent/history/history.go index 1ef801d..52cd34c 100644 --- a/ent/history/history.go +++ b/ent/history/history.go @@ -19,6 +19,12 @@ const ( FieldSourceTitle = "source_title" // FieldDate holds the string denoting the date field in the database. FieldDate = "date" + // FieldTargetDir holds the string denoting the target_dir field in the database. + FieldTargetDir = "target_dir" + // FieldCompleted holds the string denoting the completed field in the database. + FieldCompleted = "completed" + // FieldSaved holds the string denoting the saved field in the database. + FieldSaved = "saved" // Table holds the table name of the history in the database. Table = "histories" ) @@ -30,6 +36,9 @@ var Columns = []string{ FieldEpisodeID, FieldSourceTitle, FieldDate, + FieldTargetDir, + FieldCompleted, + FieldSaved, } // ValidColumn reports if the column name is valid (part of the table columns). @@ -42,6 +51,11 @@ func ValidColumn(column string) bool { return false } +var ( + // DefaultCompleted holds the default value on creation for the "completed" field. + DefaultCompleted bool +) + // OrderOption defines the ordering options for the History queries. type OrderOption func(*sql.Selector) @@ -69,3 +83,18 @@ func BySourceTitle(opts ...sql.OrderTermOption) OrderOption { func ByDate(opts ...sql.OrderTermOption) OrderOption { return sql.OrderByField(FieldDate, opts...).ToFunc() } + +// ByTargetDir orders the results by the target_dir field. +func ByTargetDir(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldTargetDir, opts...).ToFunc() +} + +// ByCompleted orders the results by the completed field. +func ByCompleted(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldCompleted, opts...).ToFunc() +} + +// BySaved orders the results by the saved field. +func BySaved(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldSaved, opts...).ToFunc() +} diff --git a/ent/history/where.go b/ent/history/where.go index 77450cd..80332d8 100644 --- a/ent/history/where.go +++ b/ent/history/where.go @@ -74,6 +74,21 @@ func Date(v time.Time) predicate.History { return predicate.History(sql.FieldEQ(FieldDate, v)) } +// TargetDir applies equality check predicate on the "target_dir" field. It's identical to TargetDirEQ. +func TargetDir(v string) predicate.History { + return predicate.History(sql.FieldEQ(FieldTargetDir, v)) +} + +// Completed applies equality check predicate on the "completed" field. It's identical to CompletedEQ. +func Completed(v bool) predicate.History { + return predicate.History(sql.FieldEQ(FieldCompleted, v)) +} + +// Saved applies equality check predicate on the "saved" field. It's identical to SavedEQ. +func Saved(v string) predicate.History { + return predicate.History(sql.FieldEQ(FieldSaved, v)) +} + // SeriesIDEQ applies the EQ predicate on the "series_id" field. func SeriesIDEQ(v int) predicate.History { return predicate.History(sql.FieldEQ(FieldSeriesID, v)) @@ -259,6 +274,156 @@ func DateLTE(v time.Time) predicate.History { return predicate.History(sql.FieldLTE(FieldDate, v)) } +// TargetDirEQ applies the EQ predicate on the "target_dir" field. +func TargetDirEQ(v string) predicate.History { + return predicate.History(sql.FieldEQ(FieldTargetDir, v)) +} + +// TargetDirNEQ applies the NEQ predicate on the "target_dir" field. +func TargetDirNEQ(v string) predicate.History { + return predicate.History(sql.FieldNEQ(FieldTargetDir, v)) +} + +// TargetDirIn applies the In predicate on the "target_dir" field. +func TargetDirIn(vs ...string) predicate.History { + return predicate.History(sql.FieldIn(FieldTargetDir, vs...)) +} + +// TargetDirNotIn applies the NotIn predicate on the "target_dir" field. +func TargetDirNotIn(vs ...string) predicate.History { + return predicate.History(sql.FieldNotIn(FieldTargetDir, vs...)) +} + +// TargetDirGT applies the GT predicate on the "target_dir" field. +func TargetDirGT(v string) predicate.History { + return predicate.History(sql.FieldGT(FieldTargetDir, v)) +} + +// TargetDirGTE applies the GTE predicate on the "target_dir" field. +func TargetDirGTE(v string) predicate.History { + return predicate.History(sql.FieldGTE(FieldTargetDir, v)) +} + +// TargetDirLT applies the LT predicate on the "target_dir" field. +func TargetDirLT(v string) predicate.History { + return predicate.History(sql.FieldLT(FieldTargetDir, v)) +} + +// TargetDirLTE applies the LTE predicate on the "target_dir" field. +func TargetDirLTE(v string) predicate.History { + return predicate.History(sql.FieldLTE(FieldTargetDir, v)) +} + +// TargetDirContains applies the Contains predicate on the "target_dir" field. +func TargetDirContains(v string) predicate.History { + return predicate.History(sql.FieldContains(FieldTargetDir, v)) +} + +// TargetDirHasPrefix applies the HasPrefix predicate on the "target_dir" field. +func TargetDirHasPrefix(v string) predicate.History { + return predicate.History(sql.FieldHasPrefix(FieldTargetDir, v)) +} + +// TargetDirHasSuffix applies the HasSuffix predicate on the "target_dir" field. +func TargetDirHasSuffix(v string) predicate.History { + return predicate.History(sql.FieldHasSuffix(FieldTargetDir, v)) +} + +// TargetDirEqualFold applies the EqualFold predicate on the "target_dir" field. +func TargetDirEqualFold(v string) predicate.History { + return predicate.History(sql.FieldEqualFold(FieldTargetDir, v)) +} + +// TargetDirContainsFold applies the ContainsFold predicate on the "target_dir" field. +func TargetDirContainsFold(v string) predicate.History { + return predicate.History(sql.FieldContainsFold(FieldTargetDir, v)) +} + +// CompletedEQ applies the EQ predicate on the "completed" field. +func CompletedEQ(v bool) predicate.History { + return predicate.History(sql.FieldEQ(FieldCompleted, v)) +} + +// CompletedNEQ applies the NEQ predicate on the "completed" field. +func CompletedNEQ(v bool) predicate.History { + return predicate.History(sql.FieldNEQ(FieldCompleted, v)) +} + +// SavedEQ applies the EQ predicate on the "saved" field. +func SavedEQ(v string) predicate.History { + return predicate.History(sql.FieldEQ(FieldSaved, v)) +} + +// SavedNEQ applies the NEQ predicate on the "saved" field. +func SavedNEQ(v string) predicate.History { + return predicate.History(sql.FieldNEQ(FieldSaved, v)) +} + +// SavedIn applies the In predicate on the "saved" field. +func SavedIn(vs ...string) predicate.History { + return predicate.History(sql.FieldIn(FieldSaved, vs...)) +} + +// SavedNotIn applies the NotIn predicate on the "saved" field. +func SavedNotIn(vs ...string) predicate.History { + return predicate.History(sql.FieldNotIn(FieldSaved, vs...)) +} + +// SavedGT applies the GT predicate on the "saved" field. +func SavedGT(v string) predicate.History { + return predicate.History(sql.FieldGT(FieldSaved, v)) +} + +// SavedGTE applies the GTE predicate on the "saved" field. +func SavedGTE(v string) predicate.History { + return predicate.History(sql.FieldGTE(FieldSaved, v)) +} + +// SavedLT applies the LT predicate on the "saved" field. +func SavedLT(v string) predicate.History { + return predicate.History(sql.FieldLT(FieldSaved, v)) +} + +// SavedLTE applies the LTE predicate on the "saved" field. +func SavedLTE(v string) predicate.History { + return predicate.History(sql.FieldLTE(FieldSaved, v)) +} + +// SavedContains applies the Contains predicate on the "saved" field. +func SavedContains(v string) predicate.History { + return predicate.History(sql.FieldContains(FieldSaved, v)) +} + +// SavedHasPrefix applies the HasPrefix predicate on the "saved" field. +func SavedHasPrefix(v string) predicate.History { + return predicate.History(sql.FieldHasPrefix(FieldSaved, v)) +} + +// SavedHasSuffix applies the HasSuffix predicate on the "saved" field. +func SavedHasSuffix(v string) predicate.History { + return predicate.History(sql.FieldHasSuffix(FieldSaved, v)) +} + +// SavedIsNil applies the IsNil predicate on the "saved" field. +func SavedIsNil() predicate.History { + return predicate.History(sql.FieldIsNull(FieldSaved)) +} + +// SavedNotNil applies the NotNil predicate on the "saved" field. +func SavedNotNil() predicate.History { + return predicate.History(sql.FieldNotNull(FieldSaved)) +} + +// SavedEqualFold applies the EqualFold predicate on the "saved" field. +func SavedEqualFold(v string) predicate.History { + return predicate.History(sql.FieldEqualFold(FieldSaved, v)) +} + +// SavedContainsFold applies the ContainsFold predicate on the "saved" field. +func SavedContainsFold(v string) predicate.History { + return predicate.History(sql.FieldContainsFold(FieldSaved, v)) +} + // And groups predicates with the AND operator between them. func And(predicates ...predicate.History) predicate.History { return predicate.History(sql.AndPredicates(predicates...)) diff --git a/ent/history_create.go b/ent/history_create.go index 6674ed3..2fa361f 100644 --- a/ent/history_create.go +++ b/ent/history_create.go @@ -44,6 +44,40 @@ func (hc *HistoryCreate) SetDate(t time.Time) *HistoryCreate { return hc } +// SetTargetDir sets the "target_dir" field. +func (hc *HistoryCreate) SetTargetDir(s string) *HistoryCreate { + hc.mutation.SetTargetDir(s) + return hc +} + +// SetCompleted sets the "completed" field. +func (hc *HistoryCreate) SetCompleted(b bool) *HistoryCreate { + hc.mutation.SetCompleted(b) + return hc +} + +// SetNillableCompleted sets the "completed" field if the given value is not nil. +func (hc *HistoryCreate) SetNillableCompleted(b *bool) *HistoryCreate { + if b != nil { + hc.SetCompleted(*b) + } + return hc +} + +// SetSaved sets the "saved" field. +func (hc *HistoryCreate) SetSaved(s string) *HistoryCreate { + hc.mutation.SetSaved(s) + return hc +} + +// SetNillableSaved sets the "saved" field if the given value is not nil. +func (hc *HistoryCreate) SetNillableSaved(s *string) *HistoryCreate { + if s != nil { + hc.SetSaved(*s) + } + return hc +} + // Mutation returns the HistoryMutation object of the builder. func (hc *HistoryCreate) Mutation() *HistoryMutation { return hc.mutation @@ -51,6 +85,7 @@ func (hc *HistoryCreate) Mutation() *HistoryMutation { // Save creates the History in the database. func (hc *HistoryCreate) Save(ctx context.Context) (*History, error) { + hc.defaults() return withHooks(ctx, hc.sqlSave, hc.mutation, hc.hooks) } @@ -76,6 +111,14 @@ func (hc *HistoryCreate) ExecX(ctx context.Context) { } } +// defaults sets the default values of the builder before save. +func (hc *HistoryCreate) defaults() { + if _, ok := hc.mutation.Completed(); !ok { + v := history.DefaultCompleted + hc.mutation.SetCompleted(v) + } +} + // check runs all checks and user-defined validators on the builder. func (hc *HistoryCreate) check() error { if _, ok := hc.mutation.SeriesID(); !ok { @@ -90,6 +133,12 @@ func (hc *HistoryCreate) check() error { if _, ok := hc.mutation.Date(); !ok { return &ValidationError{Name: "date", err: errors.New(`ent: missing required field "History.date"`)} } + if _, ok := hc.mutation.TargetDir(); !ok { + return &ValidationError{Name: "target_dir", err: errors.New(`ent: missing required field "History.target_dir"`)} + } + if _, ok := hc.mutation.Completed(); !ok { + return &ValidationError{Name: "completed", err: errors.New(`ent: missing required field "History.completed"`)} + } return nil } @@ -132,6 +181,18 @@ func (hc *HistoryCreate) createSpec() (*History, *sqlgraph.CreateSpec) { _spec.SetField(history.FieldDate, field.TypeTime, value) _node.Date = value } + if value, ok := hc.mutation.TargetDir(); ok { + _spec.SetField(history.FieldTargetDir, field.TypeString, value) + _node.TargetDir = value + } + if value, ok := hc.mutation.Completed(); ok { + _spec.SetField(history.FieldCompleted, field.TypeBool, value) + _node.Completed = value + } + if value, ok := hc.mutation.Saved(); ok { + _spec.SetField(history.FieldSaved, field.TypeString, value) + _node.Saved = value + } return _node, _spec } @@ -153,6 +214,7 @@ func (hcb *HistoryCreateBulk) Save(ctx context.Context) ([]*History, error) { for i := range hcb.builders { func(i int, root context.Context) { builder := hcb.builders[i] + builder.defaults() var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) { mutation, ok := m.(*HistoryMutation) if !ok { diff --git a/ent/history_update.go b/ent/history_update.go index 7d7ad2d..f451505 100644 --- a/ent/history_update.go +++ b/ent/history_update.go @@ -98,6 +98,54 @@ func (hu *HistoryUpdate) SetNillableDate(t *time.Time) *HistoryUpdate { return hu } +// SetTargetDir sets the "target_dir" field. +func (hu *HistoryUpdate) SetTargetDir(s string) *HistoryUpdate { + hu.mutation.SetTargetDir(s) + return hu +} + +// SetNillableTargetDir sets the "target_dir" field if the given value is not nil. +func (hu *HistoryUpdate) SetNillableTargetDir(s *string) *HistoryUpdate { + if s != nil { + hu.SetTargetDir(*s) + } + return hu +} + +// SetCompleted sets the "completed" field. +func (hu *HistoryUpdate) SetCompleted(b bool) *HistoryUpdate { + hu.mutation.SetCompleted(b) + return hu +} + +// SetNillableCompleted sets the "completed" field if the given value is not nil. +func (hu *HistoryUpdate) SetNillableCompleted(b *bool) *HistoryUpdate { + if b != nil { + hu.SetCompleted(*b) + } + return hu +} + +// SetSaved sets the "saved" field. +func (hu *HistoryUpdate) SetSaved(s string) *HistoryUpdate { + hu.mutation.SetSaved(s) + return hu +} + +// SetNillableSaved sets the "saved" field if the given value is not nil. +func (hu *HistoryUpdate) SetNillableSaved(s *string) *HistoryUpdate { + if s != nil { + hu.SetSaved(*s) + } + return hu +} + +// ClearSaved clears the value of the "saved" field. +func (hu *HistoryUpdate) ClearSaved() *HistoryUpdate { + hu.mutation.ClearSaved() + return hu +} + // Mutation returns the HistoryMutation object of the builder. func (hu *HistoryUpdate) Mutation() *HistoryMutation { return hu.mutation @@ -157,6 +205,18 @@ func (hu *HistoryUpdate) sqlSave(ctx context.Context) (n int, err error) { if value, ok := hu.mutation.Date(); ok { _spec.SetField(history.FieldDate, field.TypeTime, value) } + if value, ok := hu.mutation.TargetDir(); ok { + _spec.SetField(history.FieldTargetDir, field.TypeString, value) + } + if value, ok := hu.mutation.Completed(); ok { + _spec.SetField(history.FieldCompleted, field.TypeBool, value) + } + if value, ok := hu.mutation.Saved(); ok { + _spec.SetField(history.FieldSaved, field.TypeString, value) + } + if hu.mutation.SavedCleared() { + _spec.ClearField(history.FieldSaved, field.TypeString) + } if n, err = sqlgraph.UpdateNodes(ctx, hu.driver, _spec); err != nil { if _, ok := err.(*sqlgraph.NotFoundError); ok { err = &NotFoundError{history.Label} @@ -247,6 +307,54 @@ func (huo *HistoryUpdateOne) SetNillableDate(t *time.Time) *HistoryUpdateOne { return huo } +// SetTargetDir sets the "target_dir" field. +func (huo *HistoryUpdateOne) SetTargetDir(s string) *HistoryUpdateOne { + huo.mutation.SetTargetDir(s) + return huo +} + +// SetNillableTargetDir sets the "target_dir" field if the given value is not nil. +func (huo *HistoryUpdateOne) SetNillableTargetDir(s *string) *HistoryUpdateOne { + if s != nil { + huo.SetTargetDir(*s) + } + return huo +} + +// SetCompleted sets the "completed" field. +func (huo *HistoryUpdateOne) SetCompleted(b bool) *HistoryUpdateOne { + huo.mutation.SetCompleted(b) + return huo +} + +// SetNillableCompleted sets the "completed" field if the given value is not nil. +func (huo *HistoryUpdateOne) SetNillableCompleted(b *bool) *HistoryUpdateOne { + if b != nil { + huo.SetCompleted(*b) + } + return huo +} + +// SetSaved sets the "saved" field. +func (huo *HistoryUpdateOne) SetSaved(s string) *HistoryUpdateOne { + huo.mutation.SetSaved(s) + return huo +} + +// SetNillableSaved sets the "saved" field if the given value is not nil. +func (huo *HistoryUpdateOne) SetNillableSaved(s *string) *HistoryUpdateOne { + if s != nil { + huo.SetSaved(*s) + } + return huo +} + +// ClearSaved clears the value of the "saved" field. +func (huo *HistoryUpdateOne) ClearSaved() *HistoryUpdateOne { + huo.mutation.ClearSaved() + return huo +} + // Mutation returns the HistoryMutation object of the builder. func (huo *HistoryUpdateOne) Mutation() *HistoryMutation { return huo.mutation @@ -336,6 +444,18 @@ func (huo *HistoryUpdateOne) sqlSave(ctx context.Context) (_node *History, err e if value, ok := huo.mutation.Date(); ok { _spec.SetField(history.FieldDate, field.TypeTime, value) } + if value, ok := huo.mutation.TargetDir(); ok { + _spec.SetField(history.FieldTargetDir, field.TypeString, value) + } + if value, ok := huo.mutation.Completed(); ok { + _spec.SetField(history.FieldCompleted, field.TypeBool, value) + } + if value, ok := huo.mutation.Saved(); ok { + _spec.SetField(history.FieldSaved, field.TypeString, value) + } + if huo.mutation.SavedCleared() { + _spec.ClearField(history.FieldSaved, field.TypeString) + } _node = &History{config: huo.config} _spec.Assign = _node.assignValues _spec.ScanValues = _node.scanValues diff --git a/ent/hook/hook.go b/ent/hook/hook.go index be3e8df..bccf2a8 100644 --- a/ent/hook/hook.go +++ b/ent/hook/hook.go @@ -80,6 +80,18 @@ func (f SettingsFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, er return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.SettingsMutation", m) } +// The StorageFunc type is an adapter to allow the use of ordinary +// function as Storage mutator. +type StorageFunc func(context.Context, *ent.StorageMutation) (ent.Value, error) + +// Mutate calls f(ctx, m). +func (f StorageFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) { + if mv, ok := m.(*ent.StorageMutation); ok { + return f(ctx, mv) + } + return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.StorageMutation", m) +} + // Condition is a hook condition function. type Condition func(context.Context, ent.Mutation) bool diff --git a/ent/migrate/schema.go b/ent/migrate/schema.go index 59ce95a..b0337b6 100644 --- a/ent/migrate/schema.go +++ b/ent/migrate/schema.go @@ -60,6 +60,9 @@ var ( {Name: "episode_id", Type: field.TypeInt}, {Name: "source_title", Type: field.TypeString}, {Name: "date", Type: field.TypeTime}, + {Name: "target_dir", Type: field.TypeString}, + {Name: "completed", Type: field.TypeBool, Default: false}, + {Name: "saved", Type: field.TypeString, Nullable: true}, } // HistoriesTable holds the schema information for the "histories" table. HistoriesTable = &schema.Table{ @@ -88,12 +91,14 @@ var ( {Name: "tmdb_id", Type: field.TypeInt}, {Name: "imdb_id", Type: field.TypeString, Nullable: true}, {Name: "name", Type: field.TypeString}, + {Name: "name_en", Type: field.TypeString, Nullable: true}, {Name: "original_name", Type: field.TypeString}, {Name: "overview", Type: field.TypeString}, - {Name: "path", Type: field.TypeString}, {Name: "poster_path", Type: field.TypeString, Nullable: true}, {Name: "created_at", Type: field.TypeTime}, {Name: "air_date", Type: field.TypeString, Default: ""}, + {Name: "resolution", Type: field.TypeString, Default: ""}, + {Name: "storage_id", Type: field.TypeInt, Nullable: true}, } // SeriesTable holds the schema information for the "series" table. SeriesTable = &schema.Table{ @@ -113,6 +118,23 @@ var ( Columns: SettingsColumns, PrimaryKey: []*schema.Column{SettingsColumns[0]}, } + // StoragesColumns holds the columns for the "storages" table. + StoragesColumns = []*schema.Column{ + {Name: "id", Type: field.TypeInt, Increment: true}, + {Name: "name", Type: field.TypeString, Unique: true}, + {Name: "implementation", Type: field.TypeString}, + {Name: "path", Type: field.TypeString}, + {Name: "user", Type: field.TypeString, Nullable: true}, + {Name: "password", Type: field.TypeString, Nullable: true}, + {Name: "deleted", Type: field.TypeBool, Default: false}, + {Name: "default", Type: field.TypeBool, Default: false}, + } + // StoragesTable holds the schema information for the "storages" table. + StoragesTable = &schema.Table{ + Name: "storages", + Columns: StoragesColumns, + PrimaryKey: []*schema.Column{StoragesColumns[0]}, + } // Tables holds all the tables in the schema. Tables = []*schema.Table{ DownloadClientsTable, @@ -121,6 +143,7 @@ var ( IndexersTable, SeriesTable, SettingsTable, + StoragesTable, } ) diff --git a/ent/mutation.go b/ent/mutation.go index 1f045fa..8362680 100644 --- a/ent/mutation.go +++ b/ent/mutation.go @@ -13,6 +13,7 @@ import ( "polaris/ent/predicate" "polaris/ent/series" "polaris/ent/settings" + "polaris/ent/storage" "sync" "time" @@ -35,6 +36,7 @@ const ( TypeIndexers = "Indexers" TypeSeries = "Series" TypeSettings = "Settings" + TypeStorage = "Storage" ) // DownloadClientsMutation represents an operation that mutates the DownloadClients nodes in the graph. @@ -1656,6 +1658,9 @@ type HistoryMutation struct { addepisode_id *int source_title *string date *time.Time + target_dir *string + completed *bool + saved *string clearedFields map[string]struct{} done bool oldValue func(context.Context) (*History, error) @@ -1944,6 +1949,127 @@ func (m *HistoryMutation) ResetDate() { m.date = nil } +// SetTargetDir sets the "target_dir" field. +func (m *HistoryMutation) SetTargetDir(s string) { + m.target_dir = &s +} + +// TargetDir returns the value of the "target_dir" field in the mutation. +func (m *HistoryMutation) TargetDir() (r string, exists bool) { + v := m.target_dir + if v == nil { + return + } + return *v, true +} + +// OldTargetDir returns the old "target_dir" field's value of the History entity. +// If the History 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 *HistoryMutation) OldTargetDir(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldTargetDir is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldTargetDir requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldTargetDir: %w", err) + } + return oldValue.TargetDir, nil +} + +// ResetTargetDir resets all changes to the "target_dir" field. +func (m *HistoryMutation) ResetTargetDir() { + m.target_dir = nil +} + +// SetCompleted sets the "completed" field. +func (m *HistoryMutation) SetCompleted(b bool) { + m.completed = &b +} + +// Completed returns the value of the "completed" field in the mutation. +func (m *HistoryMutation) Completed() (r bool, exists bool) { + v := m.completed + if v == nil { + return + } + return *v, true +} + +// OldCompleted returns the old "completed" field's value of the History entity. +// If the History 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 *HistoryMutation) OldCompleted(ctx context.Context) (v bool, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldCompleted is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldCompleted requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldCompleted: %w", err) + } + return oldValue.Completed, nil +} + +// ResetCompleted resets all changes to the "completed" field. +func (m *HistoryMutation) ResetCompleted() { + m.completed = nil +} + +// SetSaved sets the "saved" field. +func (m *HistoryMutation) SetSaved(s string) { + m.saved = &s +} + +// Saved returns the value of the "saved" field in the mutation. +func (m *HistoryMutation) Saved() (r string, exists bool) { + v := m.saved + if v == nil { + return + } + return *v, true +} + +// OldSaved returns the old "saved" field's value of the History entity. +// If the History 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 *HistoryMutation) OldSaved(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldSaved is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldSaved requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldSaved: %w", err) + } + return oldValue.Saved, nil +} + +// ClearSaved clears the value of the "saved" field. +func (m *HistoryMutation) ClearSaved() { + m.saved = nil + m.clearedFields[history.FieldSaved] = struct{}{} +} + +// SavedCleared returns if the "saved" field was cleared in this mutation. +func (m *HistoryMutation) SavedCleared() bool { + _, ok := m.clearedFields[history.FieldSaved] + return ok +} + +// ResetSaved resets all changes to the "saved" field. +func (m *HistoryMutation) ResetSaved() { + m.saved = nil + delete(m.clearedFields, history.FieldSaved) +} + // Where appends a list predicates to the HistoryMutation builder. func (m *HistoryMutation) Where(ps ...predicate.History) { m.predicates = append(m.predicates, ps...) @@ -1978,7 +2104,7 @@ func (m *HistoryMutation) Type() string { // order to get all numeric fields that were incremented/decremented, call // AddedFields(). func (m *HistoryMutation) Fields() []string { - fields := make([]string, 0, 4) + fields := make([]string, 0, 7) if m.series_id != nil { fields = append(fields, history.FieldSeriesID) } @@ -1991,6 +2117,15 @@ func (m *HistoryMutation) Fields() []string { if m.date != nil { fields = append(fields, history.FieldDate) } + if m.target_dir != nil { + fields = append(fields, history.FieldTargetDir) + } + if m.completed != nil { + fields = append(fields, history.FieldCompleted) + } + if m.saved != nil { + fields = append(fields, history.FieldSaved) + } return fields } @@ -2007,6 +2142,12 @@ func (m *HistoryMutation) Field(name string) (ent.Value, bool) { return m.SourceTitle() case history.FieldDate: return m.Date() + case history.FieldTargetDir: + return m.TargetDir() + case history.FieldCompleted: + return m.Completed() + case history.FieldSaved: + return m.Saved() } return nil, false } @@ -2024,6 +2165,12 @@ func (m *HistoryMutation) OldField(ctx context.Context, name string) (ent.Value, return m.OldSourceTitle(ctx) case history.FieldDate: return m.OldDate(ctx) + case history.FieldTargetDir: + return m.OldTargetDir(ctx) + case history.FieldCompleted: + return m.OldCompleted(ctx) + case history.FieldSaved: + return m.OldSaved(ctx) } return nil, fmt.Errorf("unknown History field %s", name) } @@ -2061,6 +2208,27 @@ func (m *HistoryMutation) SetField(name string, value ent.Value) error { } m.SetDate(v) return nil + case history.FieldTargetDir: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetTargetDir(v) + return nil + case history.FieldCompleted: + v, ok := value.(bool) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetCompleted(v) + return nil + case history.FieldSaved: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetSaved(v) + return nil } return fmt.Errorf("unknown History field %s", name) } @@ -2117,7 +2285,11 @@ func (m *HistoryMutation) AddField(name string, value ent.Value) error { // ClearedFields returns all nullable fields that were cleared during this // mutation. func (m *HistoryMutation) ClearedFields() []string { - return nil + var fields []string + if m.FieldCleared(history.FieldSaved) { + fields = append(fields, history.FieldSaved) + } + return fields } // FieldCleared returns a boolean indicating if a field with the given name was @@ -2130,6 +2302,11 @@ func (m *HistoryMutation) FieldCleared(name string) bool { // 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 *HistoryMutation) ClearField(name string) error { + switch name { + case history.FieldSaved: + m.ClearSaved() + return nil + } return fmt.Errorf("unknown History nullable field %s", name) } @@ -2149,6 +2326,15 @@ func (m *HistoryMutation) ResetField(name string) error { case history.FieldDate: m.ResetDate() return nil + case history.FieldTargetDir: + m.ResetTargetDir() + return nil + case history.FieldCompleted: + m.ResetCompleted() + return nil + case history.FieldSaved: + m.ResetSaved() + return nil } return fmt.Errorf("unknown History field %s", name) } @@ -2789,12 +2975,15 @@ type SeriesMutation struct { addtmdb_id *int imdb_id *string name *string + name_en *string original_name *string overview *string - _path *string poster_path *string created_at *time.Time air_date *string + resolution *string + storage_id *int + addstorage_id *int clearedFields map[string]struct{} episodes map[int]struct{} removedepisodes map[int]struct{} @@ -3043,6 +3232,55 @@ func (m *SeriesMutation) ResetName() { m.name = nil } +// SetNameEn sets the "name_en" field. +func (m *SeriesMutation) SetNameEn(s string) { + m.name_en = &s +} + +// NameEn returns the value of the "name_en" field in the mutation. +func (m *SeriesMutation) NameEn() (r string, exists bool) { + v := m.name_en + if v == nil { + return + } + return *v, true +} + +// OldNameEn returns the old "name_en" field's value of the Series entity. +// If the Series 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 *SeriesMutation) OldNameEn(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldNameEn is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldNameEn requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldNameEn: %w", err) + } + return oldValue.NameEn, nil +} + +// ClearNameEn clears the value of the "name_en" field. +func (m *SeriesMutation) ClearNameEn() { + m.name_en = nil + m.clearedFields[series.FieldNameEn] = struct{}{} +} + +// NameEnCleared returns if the "name_en" field was cleared in this mutation. +func (m *SeriesMutation) NameEnCleared() bool { + _, ok := m.clearedFields[series.FieldNameEn] + return ok +} + +// ResetNameEn resets all changes to the "name_en" field. +func (m *SeriesMutation) ResetNameEn() { + m.name_en = nil + delete(m.clearedFields, series.FieldNameEn) +} + // SetOriginalName sets the "original_name" field. func (m *SeriesMutation) SetOriginalName(s string) { m.original_name = &s @@ -3115,42 +3353,6 @@ func (m *SeriesMutation) ResetOverview() { m.overview = nil } -// SetPath sets the "path" field. -func (m *SeriesMutation) SetPath(s string) { - m._path = &s -} - -// Path returns the value of the "path" field in the mutation. -func (m *SeriesMutation) Path() (r string, exists bool) { - v := m._path - if v == nil { - return - } - return *v, true -} - -// OldPath returns the old "path" field's value of the Series entity. -// If the Series 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 *SeriesMutation) OldPath(ctx context.Context) (v string, err error) { - if !m.op.Is(OpUpdateOne) { - return v, errors.New("OldPath is only allowed on UpdateOne operations") - } - if m.id == nil || m.oldValue == nil { - return v, errors.New("OldPath requires an ID field in the mutation") - } - oldValue, err := m.oldValue(ctx) - if err != nil { - return v, fmt.Errorf("querying old value for OldPath: %w", err) - } - return oldValue.Path, nil -} - -// ResetPath resets all changes to the "path" field. -func (m *SeriesMutation) ResetPath() { - m._path = nil -} - // SetPosterPath sets the "poster_path" field. func (m *SeriesMutation) SetPosterPath(s string) { m.poster_path = &s @@ -3272,6 +3474,112 @@ func (m *SeriesMutation) ResetAirDate() { m.air_date = nil } +// SetResolution sets the "resolution" field. +func (m *SeriesMutation) SetResolution(s string) { + m.resolution = &s +} + +// Resolution returns the value of the "resolution" field in the mutation. +func (m *SeriesMutation) Resolution() (r string, exists bool) { + v := m.resolution + if v == nil { + return + } + return *v, true +} + +// OldResolution returns the old "resolution" field's value of the Series entity. +// If the Series 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 *SeriesMutation) OldResolution(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldResolution is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldResolution requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldResolution: %w", err) + } + return oldValue.Resolution, nil +} + +// ResetResolution resets all changes to the "resolution" field. +func (m *SeriesMutation) ResetResolution() { + m.resolution = nil +} + +// SetStorageID sets the "storage_id" field. +func (m *SeriesMutation) 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 *SeriesMutation) 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 Series entity. +// If the Series 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 *SeriesMutation) 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 *SeriesMutation) 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 *SeriesMutation) AddedStorageID() (r int, exists bool) { + v := m.addstorage_id + if v == nil { + return + } + return *v, true +} + +// ClearStorageID clears the value of the "storage_id" field. +func (m *SeriesMutation) ClearStorageID() { + m.storage_id = nil + m.addstorage_id = nil + m.clearedFields[series.FieldStorageID] = struct{}{} +} + +// StorageIDCleared returns if the "storage_id" field was cleared in this mutation. +func (m *SeriesMutation) StorageIDCleared() bool { + _, ok := m.clearedFields[series.FieldStorageID] + return ok +} + +// ResetStorageID resets all changes to the "storage_id" field. +func (m *SeriesMutation) ResetStorageID() { + m.storage_id = nil + m.addstorage_id = nil + delete(m.clearedFields, series.FieldStorageID) +} + // AddEpisodeIDs adds the "episodes" edge to the Episode entity by ids. func (m *SeriesMutation) AddEpisodeIDs(ids ...int) { if m.episodes == nil { @@ -3360,7 +3668,7 @@ func (m *SeriesMutation) Type() string { // order to get all numeric fields that were incremented/decremented, call // AddedFields(). func (m *SeriesMutation) Fields() []string { - fields := make([]string, 0, 9) + fields := make([]string, 0, 11) if m.tmdb_id != nil { fields = append(fields, series.FieldTmdbID) } @@ -3370,15 +3678,15 @@ func (m *SeriesMutation) Fields() []string { if m.name != nil { fields = append(fields, series.FieldName) } + if m.name_en != nil { + fields = append(fields, series.FieldNameEn) + } if m.original_name != nil { fields = append(fields, series.FieldOriginalName) } if m.overview != nil { fields = append(fields, series.FieldOverview) } - if m._path != nil { - fields = append(fields, series.FieldPath) - } if m.poster_path != nil { fields = append(fields, series.FieldPosterPath) } @@ -3388,6 +3696,12 @@ func (m *SeriesMutation) Fields() []string { if m.air_date != nil { fields = append(fields, series.FieldAirDate) } + if m.resolution != nil { + fields = append(fields, series.FieldResolution) + } + if m.storage_id != nil { + fields = append(fields, series.FieldStorageID) + } return fields } @@ -3402,18 +3716,22 @@ func (m *SeriesMutation) Field(name string) (ent.Value, bool) { return m.ImdbID() case series.FieldName: return m.Name() + case series.FieldNameEn: + return m.NameEn() case series.FieldOriginalName: return m.OriginalName() case series.FieldOverview: return m.Overview() - case series.FieldPath: - return m.Path() case series.FieldPosterPath: return m.PosterPath() case series.FieldCreatedAt: return m.CreatedAt() case series.FieldAirDate: return m.AirDate() + case series.FieldResolution: + return m.Resolution() + case series.FieldStorageID: + return m.StorageID() } return nil, false } @@ -3429,18 +3747,22 @@ func (m *SeriesMutation) OldField(ctx context.Context, name string) (ent.Value, return m.OldImdbID(ctx) case series.FieldName: return m.OldName(ctx) + case series.FieldNameEn: + return m.OldNameEn(ctx) case series.FieldOriginalName: return m.OldOriginalName(ctx) case series.FieldOverview: return m.OldOverview(ctx) - case series.FieldPath: - return m.OldPath(ctx) case series.FieldPosterPath: return m.OldPosterPath(ctx) case series.FieldCreatedAt: return m.OldCreatedAt(ctx) case series.FieldAirDate: return m.OldAirDate(ctx) + case series.FieldResolution: + return m.OldResolution(ctx) + case series.FieldStorageID: + return m.OldStorageID(ctx) } return nil, fmt.Errorf("unknown Series field %s", name) } @@ -3471,6 +3793,13 @@ func (m *SeriesMutation) SetField(name string, value ent.Value) error { } m.SetName(v) return nil + case series.FieldNameEn: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetNameEn(v) + return nil case series.FieldOriginalName: v, ok := value.(string) if !ok { @@ -3485,13 +3814,6 @@ func (m *SeriesMutation) SetField(name string, value ent.Value) error { } m.SetOverview(v) return nil - case series.FieldPath: - v, ok := value.(string) - if !ok { - return fmt.Errorf("unexpected type %T for field %s", value, name) - } - m.SetPath(v) - return nil case series.FieldPosterPath: v, ok := value.(string) if !ok { @@ -3513,6 +3835,20 @@ func (m *SeriesMutation) SetField(name string, value ent.Value) error { } m.SetAirDate(v) return nil + case series.FieldResolution: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetResolution(v) + return nil + case series.FieldStorageID: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetStorageID(v) + return nil } return fmt.Errorf("unknown Series field %s", name) } @@ -3524,6 +3860,9 @@ func (m *SeriesMutation) AddedFields() []string { if m.addtmdb_id != nil { fields = append(fields, series.FieldTmdbID) } + if m.addstorage_id != nil { + fields = append(fields, series.FieldStorageID) + } return fields } @@ -3534,6 +3873,8 @@ func (m *SeriesMutation) AddedField(name string) (ent.Value, bool) { switch name { case series.FieldTmdbID: return m.AddedTmdbID() + case series.FieldStorageID: + return m.AddedStorageID() } return nil, false } @@ -3550,6 +3891,13 @@ func (m *SeriesMutation) AddField(name string, value ent.Value) error { } m.AddTmdbID(v) return nil + case series.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 Series numeric field %s", name) } @@ -3561,9 +3909,15 @@ func (m *SeriesMutation) ClearedFields() []string { if m.FieldCleared(series.FieldImdbID) { fields = append(fields, series.FieldImdbID) } + if m.FieldCleared(series.FieldNameEn) { + fields = append(fields, series.FieldNameEn) + } if m.FieldCleared(series.FieldPosterPath) { fields = append(fields, series.FieldPosterPath) } + if m.FieldCleared(series.FieldStorageID) { + fields = append(fields, series.FieldStorageID) + } return fields } @@ -3581,9 +3935,15 @@ func (m *SeriesMutation) ClearField(name string) error { case series.FieldImdbID: m.ClearImdbID() return nil + case series.FieldNameEn: + m.ClearNameEn() + return nil case series.FieldPosterPath: m.ClearPosterPath() return nil + case series.FieldStorageID: + m.ClearStorageID() + return nil } return fmt.Errorf("unknown Series nullable field %s", name) } @@ -3601,15 +3961,15 @@ func (m *SeriesMutation) ResetField(name string) error { case series.FieldName: m.ResetName() return nil + case series.FieldNameEn: + m.ResetNameEn() + return nil case series.FieldOriginalName: m.ResetOriginalName() return nil case series.FieldOverview: m.ResetOverview() return nil - case series.FieldPath: - m.ResetPath() - return nil case series.FieldPosterPath: m.ResetPosterPath() return nil @@ -3619,6 +3979,12 @@ func (m *SeriesMutation) ResetField(name string) error { case series.FieldAirDate: m.ResetAirDate() return nil + case series.FieldResolution: + m.ResetResolution() + return nil + case series.FieldStorageID: + m.ResetStorageID() + return nil } return fmt.Errorf("unknown Series field %s", name) } @@ -4086,3 +4452,694 @@ func (m *SettingsMutation) ClearEdge(name string) error { func (m *SettingsMutation) ResetEdge(name string) error { return fmt.Errorf("unknown Settings edge %s", name) } + +// StorageMutation represents an operation that mutates the Storage nodes in the graph. +type StorageMutation struct { + config + op Op + typ string + id *int + name *string + implementation *string + _path *string + user *string + password *string + deleted *bool + _default *bool + clearedFields map[string]struct{} + done bool + oldValue func(context.Context) (*Storage, error) + predicates []predicate.Storage +} + +var _ ent.Mutation = (*StorageMutation)(nil) + +// storageOption allows management of the mutation configuration using functional options. +type storageOption func(*StorageMutation) + +// newStorageMutation creates new mutation for the Storage entity. +func newStorageMutation(c config, op Op, opts ...storageOption) *StorageMutation { + m := &StorageMutation{ + config: c, + op: op, + typ: TypeStorage, + clearedFields: make(map[string]struct{}), + } + for _, opt := range opts { + opt(m) + } + return m +} + +// withStorageID sets the ID field of the mutation. +func withStorageID(id int) storageOption { + return func(m *StorageMutation) { + var ( + err error + once sync.Once + value *Storage + ) + m.oldValue = func(ctx context.Context) (*Storage, error) { + once.Do(func() { + if m.done { + err = errors.New("querying old values post mutation is not allowed") + } else { + value, err = m.Client().Storage.Get(ctx, id) + } + }) + return value, err + } + m.id = &id + } +} + +// withStorage sets the old Storage of the mutation. +func withStorage(node *Storage) storageOption { + return func(m *StorageMutation) { + m.oldValue = func(context.Context) (*Storage, 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 StorageMutation) 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 StorageMutation) 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 *StorageMutation) 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 *StorageMutation) 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().Storage.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 *StorageMutation) SetName(s string) { + m.name = &s +} + +// Name returns the value of the "name" field in the mutation. +func (m *StorageMutation) 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 Storage entity. +// If the Storage 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 *StorageMutation) 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 *StorageMutation) ResetName() { + m.name = nil +} + +// SetImplementation sets the "implementation" field. +func (m *StorageMutation) SetImplementation(s string) { + m.implementation = &s +} + +// Implementation returns the value of the "implementation" field in the mutation. +func (m *StorageMutation) Implementation() (r string, exists bool) { + v := m.implementation + if v == nil { + return + } + return *v, true +} + +// OldImplementation returns the old "implementation" field's value of the Storage entity. +// If the Storage 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 *StorageMutation) OldImplementation(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldImplementation is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldImplementation requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldImplementation: %w", err) + } + return oldValue.Implementation, nil +} + +// ResetImplementation resets all changes to the "implementation" field. +func (m *StorageMutation) ResetImplementation() { + m.implementation = nil +} + +// SetPath sets the "path" field. +func (m *StorageMutation) SetPath(s string) { + m._path = &s +} + +// Path returns the value of the "path" field in the mutation. +func (m *StorageMutation) Path() (r string, exists bool) { + v := m._path + if v == nil { + return + } + return *v, true +} + +// OldPath returns the old "path" field's value of the Storage entity. +// If the Storage 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 *StorageMutation) OldPath(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldPath is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldPath requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldPath: %w", err) + } + return oldValue.Path, nil +} + +// ResetPath resets all changes to the "path" field. +func (m *StorageMutation) ResetPath() { + m._path = nil +} + +// SetUser sets the "user" field. +func (m *StorageMutation) SetUser(s string) { + m.user = &s +} + +// User returns the value of the "user" field in the mutation. +func (m *StorageMutation) User() (r string, exists bool) { + v := m.user + if v == nil { + return + } + return *v, true +} + +// OldUser returns the old "user" field's value of the Storage entity. +// If the Storage 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 *StorageMutation) OldUser(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldUser is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldUser requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldUser: %w", err) + } + return oldValue.User, nil +} + +// ClearUser clears the value of the "user" field. +func (m *StorageMutation) ClearUser() { + m.user = nil + m.clearedFields[storage.FieldUser] = struct{}{} +} + +// UserCleared returns if the "user" field was cleared in this mutation. +func (m *StorageMutation) UserCleared() bool { + _, ok := m.clearedFields[storage.FieldUser] + return ok +} + +// ResetUser resets all changes to the "user" field. +func (m *StorageMutation) ResetUser() { + m.user = nil + delete(m.clearedFields, storage.FieldUser) +} + +// SetPassword sets the "password" field. +func (m *StorageMutation) SetPassword(s string) { + m.password = &s +} + +// Password returns the value of the "password" field in the mutation. +func (m *StorageMutation) Password() (r string, exists bool) { + v := m.password + if v == nil { + return + } + return *v, true +} + +// OldPassword returns the old "password" field's value of the Storage entity. +// If the Storage 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 *StorageMutation) OldPassword(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldPassword is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldPassword requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldPassword: %w", err) + } + return oldValue.Password, nil +} + +// ClearPassword clears the value of the "password" field. +func (m *StorageMutation) ClearPassword() { + m.password = nil + m.clearedFields[storage.FieldPassword] = struct{}{} +} + +// PasswordCleared returns if the "password" field was cleared in this mutation. +func (m *StorageMutation) PasswordCleared() bool { + _, ok := m.clearedFields[storage.FieldPassword] + return ok +} + +// ResetPassword resets all changes to the "password" field. +func (m *StorageMutation) ResetPassword() { + m.password = nil + delete(m.clearedFields, storage.FieldPassword) +} + +// SetDeleted sets the "deleted" field. +func (m *StorageMutation) SetDeleted(b bool) { + m.deleted = &b +} + +// Deleted returns the value of the "deleted" field in the mutation. +func (m *StorageMutation) Deleted() (r bool, exists bool) { + v := m.deleted + if v == nil { + return + } + return *v, true +} + +// OldDeleted returns the old "deleted" field's value of the Storage entity. +// If the Storage 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 *StorageMutation) OldDeleted(ctx context.Context) (v bool, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldDeleted is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldDeleted requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldDeleted: %w", err) + } + return oldValue.Deleted, nil +} + +// ResetDeleted resets all changes to the "deleted" field. +func (m *StorageMutation) ResetDeleted() { + m.deleted = nil +} + +// SetDefault sets the "default" field. +func (m *StorageMutation) SetDefault(b bool) { + m._default = &b +} + +// Default returns the value of the "default" field in the mutation. +func (m *StorageMutation) Default() (r bool, exists bool) { + v := m._default + if v == nil { + return + } + return *v, true +} + +// OldDefault returns the old "default" field's value of the Storage entity. +// If the Storage 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 *StorageMutation) OldDefault(ctx context.Context) (v bool, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldDefault is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldDefault requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldDefault: %w", err) + } + return oldValue.Default, nil +} + +// ResetDefault resets all changes to the "default" field. +func (m *StorageMutation) ResetDefault() { + m._default = nil +} + +// Where appends a list predicates to the StorageMutation builder. +func (m *StorageMutation) Where(ps ...predicate.Storage) { + m.predicates = append(m.predicates, ps...) +} + +// WhereP appends storage-level predicates to the StorageMutation builder. Using this method, +// users can use type-assertion to append predicates that do not depend on any generated package. +func (m *StorageMutation) WhereP(ps ...func(*sql.Selector)) { + p := make([]predicate.Storage, len(ps)) + for i := range ps { + p[i] = ps[i] + } + m.Where(p...) +} + +// Op returns the operation name. +func (m *StorageMutation) Op() Op { + return m.op +} + +// SetOp allows setting the mutation operation. +func (m *StorageMutation) SetOp(op Op) { + m.op = op +} + +// Type returns the node type of this mutation (Storage). +func (m *StorageMutation) 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 *StorageMutation) Fields() []string { + fields := make([]string, 0, 7) + if m.name != nil { + fields = append(fields, storage.FieldName) + } + if m.implementation != nil { + fields = append(fields, storage.FieldImplementation) + } + if m._path != nil { + fields = append(fields, storage.FieldPath) + } + if m.user != nil { + fields = append(fields, storage.FieldUser) + } + if m.password != nil { + fields = append(fields, storage.FieldPassword) + } + if m.deleted != nil { + fields = append(fields, storage.FieldDeleted) + } + if m._default != nil { + fields = append(fields, storage.FieldDefault) + } + 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 *StorageMutation) Field(name string) (ent.Value, bool) { + switch name { + case storage.FieldName: + return m.Name() + case storage.FieldImplementation: + return m.Implementation() + case storage.FieldPath: + return m.Path() + case storage.FieldUser: + return m.User() + case storage.FieldPassword: + return m.Password() + case storage.FieldDeleted: + return m.Deleted() + case storage.FieldDefault: + return m.Default() + } + 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 *StorageMutation) OldField(ctx context.Context, name string) (ent.Value, error) { + switch name { + case storage.FieldName: + return m.OldName(ctx) + case storage.FieldImplementation: + return m.OldImplementation(ctx) + case storage.FieldPath: + return m.OldPath(ctx) + case storage.FieldUser: + return m.OldUser(ctx) + case storage.FieldPassword: + return m.OldPassword(ctx) + case storage.FieldDeleted: + return m.OldDeleted(ctx) + case storage.FieldDefault: + return m.OldDefault(ctx) + } + return nil, fmt.Errorf("unknown Storage 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 *StorageMutation) SetField(name string, value ent.Value) error { + switch name { + case storage.FieldName: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetName(v) + return nil + case storage.FieldImplementation: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetImplementation(v) + return nil + case storage.FieldPath: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetPath(v) + return nil + case storage.FieldUser: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetUser(v) + return nil + case storage.FieldPassword: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetPassword(v) + return nil + case storage.FieldDeleted: + v, ok := value.(bool) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetDeleted(v) + return nil + case storage.FieldDefault: + v, ok := value.(bool) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetDefault(v) + return nil + } + return fmt.Errorf("unknown Storage field %s", name) +} + +// AddedFields returns all numeric fields that were incremented/decremented during +// this mutation. +func (m *StorageMutation) AddedFields() []string { + return nil +} + +// AddedField returns the numeric value that was incremented/decremented on a field +// with the given name. The second boolean return value indicates that this field +// was not set, or was not defined in the schema. +func (m *StorageMutation) AddedField(name string) (ent.Value, bool) { + return nil, false +} + +// AddField adds the value to the field with the given name. It returns an error if +// the field is not defined in the schema, or if the type mismatched the field +// type. +func (m *StorageMutation) AddField(name string, value ent.Value) error { + switch name { + } + return fmt.Errorf("unknown Storage numeric field %s", name) +} + +// ClearedFields returns all nullable fields that were cleared during this +// mutation. +func (m *StorageMutation) ClearedFields() []string { + var fields []string + if m.FieldCleared(storage.FieldUser) { + fields = append(fields, storage.FieldUser) + } + if m.FieldCleared(storage.FieldPassword) { + fields = append(fields, storage.FieldPassword) + } + return fields +} + +// FieldCleared returns a boolean indicating if a field with the given name was +// cleared in this mutation. +func (m *StorageMutation) 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 *StorageMutation) ClearField(name string) error { + switch name { + case storage.FieldUser: + m.ClearUser() + return nil + case storage.FieldPassword: + m.ClearPassword() + return nil + } + return fmt.Errorf("unknown Storage 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 *StorageMutation) ResetField(name string) error { + switch name { + case storage.FieldName: + m.ResetName() + return nil + case storage.FieldImplementation: + m.ResetImplementation() + return nil + case storage.FieldPath: + m.ResetPath() + return nil + case storage.FieldUser: + m.ResetUser() + return nil + case storage.FieldPassword: + m.ResetPassword() + return nil + case storage.FieldDeleted: + m.ResetDeleted() + return nil + case storage.FieldDefault: + m.ResetDefault() + return nil + } + return fmt.Errorf("unknown Storage field %s", name) +} + +// AddedEdges returns all edge names that were set/added in this mutation. +func (m *StorageMutation) 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 *StorageMutation) AddedIDs(name string) []ent.Value { + return nil +} + +// RemovedEdges returns all edge names that were removed in this mutation. +func (m *StorageMutation) 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 *StorageMutation) RemovedIDs(name string) []ent.Value { + return nil +} + +// ClearedEdges returns all edge names that were cleared in this mutation. +func (m *StorageMutation) 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 *StorageMutation) 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 *StorageMutation) ClearEdge(name string) error { + return fmt.Errorf("unknown Storage 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 *StorageMutation) ResetEdge(name string) error { + return fmt.Errorf("unknown Storage edge %s", name) +} diff --git a/ent/predicate/predicate.go b/ent/predicate/predicate.go index e92296a..9000e59 100644 --- a/ent/predicate/predicate.go +++ b/ent/predicate/predicate.go @@ -23,3 +23,6 @@ type Series func(*sql.Selector) // Settings is the predicate function for settings builders. type Settings func(*sql.Selector) + +// Storage is the predicate function for storage builders. +type Storage func(*sql.Selector) diff --git a/ent/runtime.go b/ent/runtime.go index 814721b..026a4e8 100644 --- a/ent/runtime.go +++ b/ent/runtime.go @@ -4,9 +4,11 @@ package ent import ( "polaris/ent/downloadclients" + "polaris/ent/history" "polaris/ent/indexers" "polaris/ent/schema" "polaris/ent/series" + "polaris/ent/storage" "time" ) @@ -44,6 +46,12 @@ func init() { downloadclientsDescTags := downloadclientsFields[10].Descriptor() // downloadclients.DefaultTags holds the default value on creation for the tags field. downloadclients.DefaultTags = downloadclientsDescTags.Default.(string) + historyFields := schema.History{}.Fields() + _ = historyFields + // historyDescCompleted is the schema descriptor for completed field. + historyDescCompleted := historyFields[5].Descriptor() + // history.DefaultCompleted holds the default value on creation for the completed field. + history.DefaultCompleted = historyDescCompleted.Default.(bool) indexersFields := schema.Indexers{}.Fields() _ = indexersFields // indexersDescEnableRss is the schema descriptor for enable_rss field. @@ -60,4 +68,18 @@ func init() { seriesDescAirDate := seriesFields[8].Descriptor() // series.DefaultAirDate holds the default value on creation for the air_date field. series.DefaultAirDate = seriesDescAirDate.Default.(string) + // seriesDescResolution is the schema descriptor for resolution field. + seriesDescResolution := seriesFields[9].Descriptor() + // series.DefaultResolution holds the default value on creation for the resolution field. + series.DefaultResolution = seriesDescResolution.Default.(string) + storageFields := schema.Storage{}.Fields() + _ = storageFields + // storageDescDeleted is the schema descriptor for deleted field. + storageDescDeleted := storageFields[5].Descriptor() + // storage.DefaultDeleted holds the default value on creation for the deleted field. + storage.DefaultDeleted = storageDescDeleted.Default.(bool) + // storageDescDefault is the schema descriptor for default field. + storageDescDefault := storageFields[6].Descriptor() + // storage.DefaultDefault holds the default value on creation for the default field. + storage.DefaultDefault = storageDescDefault.Default.(bool) } diff --git a/ent/schema/history.go b/ent/schema/history.go index b351fd8..206398d 100644 --- a/ent/schema/history.go +++ b/ent/schema/history.go @@ -17,6 +17,9 @@ func (History) Fields() []ent.Field { field.Int("episode_id"), field.String("source_title"), field.Time("date"), + field.String("target_dir"), + field.Bool("completed").Default(false), + field.String("saved").Optional(), } } diff --git a/ent/schema/series.go b/ent/schema/series.go index d9c53f1..0a3366b 100644 --- a/ent/schema/series.go +++ b/ent/schema/series.go @@ -19,12 +19,14 @@ func (Series) Fields() []ent.Field { field.Int("tmdb_id"), field.String("imdb_id").Optional(), field.String("name"), + field.String("name_en").Optional(), field.String("original_name"), field.String("overview"), - field.String("path"), field.String("poster_path").Optional(), field.Time("created_at").Default(time.Now()), field.String("air_date").Default(""), + field.String("resolution").Default(""), + field.Int("storage_id").Optional(), } } diff --git a/ent/schema/storage.go b/ent/schema/storage.go new file mode 100644 index 0000000..44d2979 --- /dev/null +++ b/ent/schema/storage.go @@ -0,0 +1,29 @@ +package schema + +import ( + "entgo.io/ent" + "entgo.io/ent/schema/field" +) + +// Storage holds the schema definition for the Storage entity. +type Storage struct { + ent.Schema +} + +// Fields of the Storage. +func (Storage) Fields() []ent.Field { + return []ent.Field{ + field.String("name").Unique(), + field.String("implementation"), + field.String("path"), + field.String("user").Optional(), + field.String("password").Optional(), + field.Bool("deleted").Default(false), + field.Bool("default").Default(false), + } +} + +// Edges of the Storage. +func (Storage) Edges() []ent.Edge { + return nil +} diff --git a/ent/series.go b/ent/series.go index a2651f5..cd215ec 100644 --- a/ent/series.go +++ b/ent/series.go @@ -23,18 +23,22 @@ type Series struct { ImdbID string `json:"imdb_id,omitempty"` // Name holds the value of the "name" field. Name string `json:"name,omitempty"` + // NameEn holds the value of the "name_en" field. + NameEn string `json:"name_en,omitempty"` // OriginalName holds the value of the "original_name" field. OriginalName string `json:"original_name,omitempty"` // Overview holds the value of the "overview" field. Overview string `json:"overview,omitempty"` - // Path holds the value of the "path" field. - Path string `json:"path,omitempty"` // PosterPath holds the value of the "poster_path" field. PosterPath string `json:"poster_path,omitempty"` // CreatedAt holds the value of the "created_at" field. CreatedAt time.Time `json:"created_at,omitempty"` // AirDate holds the value of the "air_date" field. AirDate string `json:"air_date,omitempty"` + // Resolution holds the value of the "resolution" field. + Resolution string `json:"resolution,omitempty"` + // StorageID holds the value of the "storage_id" field. + StorageID int `json:"storage_id,omitempty"` // Edges holds the relations/edges for other nodes in the graph. // The values are being populated by the SeriesQuery when eager-loading is set. Edges SeriesEdges `json:"edges"` @@ -64,9 +68,9 @@ func (*Series) scanValues(columns []string) ([]any, error) { values := make([]any, len(columns)) for i := range columns { switch columns[i] { - case series.FieldID, series.FieldTmdbID: + case series.FieldID, series.FieldTmdbID, series.FieldStorageID: values[i] = new(sql.NullInt64) - case series.FieldImdbID, series.FieldName, series.FieldOriginalName, series.FieldOverview, series.FieldPath, series.FieldPosterPath, series.FieldAirDate: + case series.FieldImdbID, series.FieldName, series.FieldNameEn, series.FieldOriginalName, series.FieldOverview, series.FieldPosterPath, series.FieldAirDate, series.FieldResolution: values[i] = new(sql.NullString) case series.FieldCreatedAt: values[i] = new(sql.NullTime) @@ -109,6 +113,12 @@ func (s *Series) assignValues(columns []string, values []any) error { } else if value.Valid { s.Name = value.String } + case series.FieldNameEn: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field name_en", values[i]) + } else if value.Valid { + s.NameEn = value.String + } case series.FieldOriginalName: if value, ok := values[i].(*sql.NullString); !ok { return fmt.Errorf("unexpected type %T for field original_name", values[i]) @@ -121,12 +131,6 @@ func (s *Series) assignValues(columns []string, values []any) error { } else if value.Valid { s.Overview = value.String } - case series.FieldPath: - if value, ok := values[i].(*sql.NullString); !ok { - return fmt.Errorf("unexpected type %T for field path", values[i]) - } else if value.Valid { - s.Path = value.String - } case series.FieldPosterPath: if value, ok := values[i].(*sql.NullString); !ok { return fmt.Errorf("unexpected type %T for field poster_path", values[i]) @@ -145,6 +149,18 @@ func (s *Series) assignValues(columns []string, values []any) error { } else if value.Valid { s.AirDate = value.String } + case series.FieldResolution: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field resolution", values[i]) + } else if value.Valid { + s.Resolution = value.String + } + case series.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 { + s.StorageID = int(value.Int64) + } default: s.selectValues.Set(columns[i], values[i]) } @@ -195,15 +211,15 @@ func (s *Series) String() string { builder.WriteString("name=") builder.WriteString(s.Name) builder.WriteString(", ") + builder.WriteString("name_en=") + builder.WriteString(s.NameEn) + builder.WriteString(", ") builder.WriteString("original_name=") builder.WriteString(s.OriginalName) builder.WriteString(", ") builder.WriteString("overview=") builder.WriteString(s.Overview) builder.WriteString(", ") - builder.WriteString("path=") - builder.WriteString(s.Path) - builder.WriteString(", ") builder.WriteString("poster_path=") builder.WriteString(s.PosterPath) builder.WriteString(", ") @@ -212,6 +228,12 @@ func (s *Series) String() string { builder.WriteString(", ") builder.WriteString("air_date=") builder.WriteString(s.AirDate) + builder.WriteString(", ") + builder.WriteString("resolution=") + builder.WriteString(s.Resolution) + builder.WriteString(", ") + builder.WriteString("storage_id=") + builder.WriteString(fmt.Sprintf("%v", s.StorageID)) builder.WriteByte(')') return builder.String() } diff --git a/ent/series/series.go b/ent/series/series.go index 3ebcc67..ff90d1d 100644 --- a/ent/series/series.go +++ b/ent/series/series.go @@ -20,18 +20,22 @@ const ( FieldImdbID = "imdb_id" // FieldName holds the string denoting the name field in the database. FieldName = "name" + // FieldNameEn holds the string denoting the name_en field in the database. + FieldNameEn = "name_en" // FieldOriginalName holds the string denoting the original_name field in the database. FieldOriginalName = "original_name" // FieldOverview holds the string denoting the overview field in the database. FieldOverview = "overview" - // FieldPath holds the string denoting the path field in the database. - FieldPath = "path" // FieldPosterPath holds the string denoting the poster_path field in the database. FieldPosterPath = "poster_path" // FieldCreatedAt holds the string denoting the created_at field in the database. FieldCreatedAt = "created_at" // FieldAirDate holds the string denoting the air_date field in the database. FieldAirDate = "air_date" + // FieldResolution holds the string denoting the resolution field in the database. + FieldResolution = "resolution" + // FieldStorageID holds the string denoting the storage_id field in the database. + FieldStorageID = "storage_id" // EdgeEpisodes holds the string denoting the episodes edge name in mutations. EdgeEpisodes = "episodes" // Table holds the table name of the series in the database. @@ -51,12 +55,14 @@ var Columns = []string{ FieldTmdbID, FieldImdbID, FieldName, + FieldNameEn, FieldOriginalName, FieldOverview, - FieldPath, FieldPosterPath, FieldCreatedAt, FieldAirDate, + FieldResolution, + FieldStorageID, } // ValidColumn reports if the column name is valid (part of the table columns). @@ -74,6 +80,8 @@ var ( DefaultCreatedAt time.Time // DefaultAirDate holds the default value on creation for the "air_date" field. DefaultAirDate string + // DefaultResolution holds the default value on creation for the "resolution" field. + DefaultResolution string ) // OrderOption defines the ordering options for the Series queries. @@ -99,6 +107,11 @@ func ByName(opts ...sql.OrderTermOption) OrderOption { return sql.OrderByField(FieldName, opts...).ToFunc() } +// ByNameEn orders the results by the name_en field. +func ByNameEn(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldNameEn, opts...).ToFunc() +} + // ByOriginalName orders the results by the original_name field. func ByOriginalName(opts ...sql.OrderTermOption) OrderOption { return sql.OrderByField(FieldOriginalName, opts...).ToFunc() @@ -109,11 +122,6 @@ func ByOverview(opts ...sql.OrderTermOption) OrderOption { return sql.OrderByField(FieldOverview, opts...).ToFunc() } -// ByPath orders the results by the path field. -func ByPath(opts ...sql.OrderTermOption) OrderOption { - return sql.OrderByField(FieldPath, opts...).ToFunc() -} - // ByPosterPath orders the results by the poster_path field. func ByPosterPath(opts ...sql.OrderTermOption) OrderOption { return sql.OrderByField(FieldPosterPath, opts...).ToFunc() @@ -129,6 +137,16 @@ func ByAirDate(opts ...sql.OrderTermOption) OrderOption { return sql.OrderByField(FieldAirDate, opts...).ToFunc() } +// ByResolution orders the results by the resolution field. +func ByResolution(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldResolution, opts...).ToFunc() +} + +// ByStorageID orders the results by the storage_id field. +func ByStorageID(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldStorageID, opts...).ToFunc() +} + // ByEpisodesCount orders the results by episodes count. func ByEpisodesCount(opts ...sql.OrderTermOption) OrderOption { return func(s *sql.Selector) { diff --git a/ent/series/where.go b/ent/series/where.go index e17b64c..969b40f 100644 --- a/ent/series/where.go +++ b/ent/series/where.go @@ -70,6 +70,11 @@ func Name(v string) predicate.Series { return predicate.Series(sql.FieldEQ(FieldName, v)) } +// NameEn applies equality check predicate on the "name_en" field. It's identical to NameEnEQ. +func NameEn(v string) predicate.Series { + return predicate.Series(sql.FieldEQ(FieldNameEn, v)) +} + // OriginalName applies equality check predicate on the "original_name" field. It's identical to OriginalNameEQ. func OriginalName(v string) predicate.Series { return predicate.Series(sql.FieldEQ(FieldOriginalName, v)) @@ -80,11 +85,6 @@ func Overview(v string) predicate.Series { return predicate.Series(sql.FieldEQ(FieldOverview, v)) } -// Path applies equality check predicate on the "path" field. It's identical to PathEQ. -func Path(v string) predicate.Series { - return predicate.Series(sql.FieldEQ(FieldPath, v)) -} - // PosterPath applies equality check predicate on the "poster_path" field. It's identical to PosterPathEQ. func PosterPath(v string) predicate.Series { return predicate.Series(sql.FieldEQ(FieldPosterPath, v)) @@ -100,6 +100,16 @@ func AirDate(v string) predicate.Series { return predicate.Series(sql.FieldEQ(FieldAirDate, v)) } +// Resolution applies equality check predicate on the "resolution" field. It's identical to ResolutionEQ. +func Resolution(v string) predicate.Series { + return predicate.Series(sql.FieldEQ(FieldResolution, v)) +} + +// StorageID applies equality check predicate on the "storage_id" field. It's identical to StorageIDEQ. +func StorageID(v int) predicate.Series { + return predicate.Series(sql.FieldEQ(FieldStorageID, v)) +} + // TmdbIDEQ applies the EQ predicate on the "tmdb_id" field. func TmdbIDEQ(v int) predicate.Series { return predicate.Series(sql.FieldEQ(FieldTmdbID, v)) @@ -280,6 +290,81 @@ func NameContainsFold(v string) predicate.Series { return predicate.Series(sql.FieldContainsFold(FieldName, v)) } +// NameEnEQ applies the EQ predicate on the "name_en" field. +func NameEnEQ(v string) predicate.Series { + return predicate.Series(sql.FieldEQ(FieldNameEn, v)) +} + +// NameEnNEQ applies the NEQ predicate on the "name_en" field. +func NameEnNEQ(v string) predicate.Series { + return predicate.Series(sql.FieldNEQ(FieldNameEn, v)) +} + +// NameEnIn applies the In predicate on the "name_en" field. +func NameEnIn(vs ...string) predicate.Series { + return predicate.Series(sql.FieldIn(FieldNameEn, vs...)) +} + +// NameEnNotIn applies the NotIn predicate on the "name_en" field. +func NameEnNotIn(vs ...string) predicate.Series { + return predicate.Series(sql.FieldNotIn(FieldNameEn, vs...)) +} + +// NameEnGT applies the GT predicate on the "name_en" field. +func NameEnGT(v string) predicate.Series { + return predicate.Series(sql.FieldGT(FieldNameEn, v)) +} + +// NameEnGTE applies the GTE predicate on the "name_en" field. +func NameEnGTE(v string) predicate.Series { + return predicate.Series(sql.FieldGTE(FieldNameEn, v)) +} + +// NameEnLT applies the LT predicate on the "name_en" field. +func NameEnLT(v string) predicate.Series { + return predicate.Series(sql.FieldLT(FieldNameEn, v)) +} + +// NameEnLTE applies the LTE predicate on the "name_en" field. +func NameEnLTE(v string) predicate.Series { + return predicate.Series(sql.FieldLTE(FieldNameEn, v)) +} + +// NameEnContains applies the Contains predicate on the "name_en" field. +func NameEnContains(v string) predicate.Series { + return predicate.Series(sql.FieldContains(FieldNameEn, v)) +} + +// NameEnHasPrefix applies the HasPrefix predicate on the "name_en" field. +func NameEnHasPrefix(v string) predicate.Series { + return predicate.Series(sql.FieldHasPrefix(FieldNameEn, v)) +} + +// NameEnHasSuffix applies the HasSuffix predicate on the "name_en" field. +func NameEnHasSuffix(v string) predicate.Series { + return predicate.Series(sql.FieldHasSuffix(FieldNameEn, v)) +} + +// NameEnIsNil applies the IsNil predicate on the "name_en" field. +func NameEnIsNil() predicate.Series { + return predicate.Series(sql.FieldIsNull(FieldNameEn)) +} + +// NameEnNotNil applies the NotNil predicate on the "name_en" field. +func NameEnNotNil() predicate.Series { + return predicate.Series(sql.FieldNotNull(FieldNameEn)) +} + +// NameEnEqualFold applies the EqualFold predicate on the "name_en" field. +func NameEnEqualFold(v string) predicate.Series { + return predicate.Series(sql.FieldEqualFold(FieldNameEn, v)) +} + +// NameEnContainsFold applies the ContainsFold predicate on the "name_en" field. +func NameEnContainsFold(v string) predicate.Series { + return predicate.Series(sql.FieldContainsFold(FieldNameEn, v)) +} + // OriginalNameEQ applies the EQ predicate on the "original_name" field. func OriginalNameEQ(v string) predicate.Series { return predicate.Series(sql.FieldEQ(FieldOriginalName, v)) @@ -410,71 +495,6 @@ func OverviewContainsFold(v string) predicate.Series { return predicate.Series(sql.FieldContainsFold(FieldOverview, v)) } -// PathEQ applies the EQ predicate on the "path" field. -func PathEQ(v string) predicate.Series { - return predicate.Series(sql.FieldEQ(FieldPath, v)) -} - -// PathNEQ applies the NEQ predicate on the "path" field. -func PathNEQ(v string) predicate.Series { - return predicate.Series(sql.FieldNEQ(FieldPath, v)) -} - -// PathIn applies the In predicate on the "path" field. -func PathIn(vs ...string) predicate.Series { - return predicate.Series(sql.FieldIn(FieldPath, vs...)) -} - -// PathNotIn applies the NotIn predicate on the "path" field. -func PathNotIn(vs ...string) predicate.Series { - return predicate.Series(sql.FieldNotIn(FieldPath, vs...)) -} - -// PathGT applies the GT predicate on the "path" field. -func PathGT(v string) predicate.Series { - return predicate.Series(sql.FieldGT(FieldPath, v)) -} - -// PathGTE applies the GTE predicate on the "path" field. -func PathGTE(v string) predicate.Series { - return predicate.Series(sql.FieldGTE(FieldPath, v)) -} - -// PathLT applies the LT predicate on the "path" field. -func PathLT(v string) predicate.Series { - return predicate.Series(sql.FieldLT(FieldPath, v)) -} - -// PathLTE applies the LTE predicate on the "path" field. -func PathLTE(v string) predicate.Series { - return predicate.Series(sql.FieldLTE(FieldPath, v)) -} - -// PathContains applies the Contains predicate on the "path" field. -func PathContains(v string) predicate.Series { - return predicate.Series(sql.FieldContains(FieldPath, v)) -} - -// PathHasPrefix applies the HasPrefix predicate on the "path" field. -func PathHasPrefix(v string) predicate.Series { - return predicate.Series(sql.FieldHasPrefix(FieldPath, v)) -} - -// PathHasSuffix applies the HasSuffix predicate on the "path" field. -func PathHasSuffix(v string) predicate.Series { - return predicate.Series(sql.FieldHasSuffix(FieldPath, v)) -} - -// PathEqualFold applies the EqualFold predicate on the "path" field. -func PathEqualFold(v string) predicate.Series { - return predicate.Series(sql.FieldEqualFold(FieldPath, v)) -} - -// PathContainsFold applies the ContainsFold predicate on the "path" field. -func PathContainsFold(v string) predicate.Series { - return predicate.Series(sql.FieldContainsFold(FieldPath, v)) -} - // PosterPathEQ applies the EQ predicate on the "poster_path" field. func PosterPathEQ(v string) predicate.Series { return predicate.Series(sql.FieldEQ(FieldPosterPath, v)) @@ -655,6 +675,121 @@ func AirDateContainsFold(v string) predicate.Series { return predicate.Series(sql.FieldContainsFold(FieldAirDate, v)) } +// ResolutionEQ applies the EQ predicate on the "resolution" field. +func ResolutionEQ(v string) predicate.Series { + return predicate.Series(sql.FieldEQ(FieldResolution, v)) +} + +// ResolutionNEQ applies the NEQ predicate on the "resolution" field. +func ResolutionNEQ(v string) predicate.Series { + return predicate.Series(sql.FieldNEQ(FieldResolution, v)) +} + +// ResolutionIn applies the In predicate on the "resolution" field. +func ResolutionIn(vs ...string) predicate.Series { + return predicate.Series(sql.FieldIn(FieldResolution, vs...)) +} + +// ResolutionNotIn applies the NotIn predicate on the "resolution" field. +func ResolutionNotIn(vs ...string) predicate.Series { + return predicate.Series(sql.FieldNotIn(FieldResolution, vs...)) +} + +// ResolutionGT applies the GT predicate on the "resolution" field. +func ResolutionGT(v string) predicate.Series { + return predicate.Series(sql.FieldGT(FieldResolution, v)) +} + +// ResolutionGTE applies the GTE predicate on the "resolution" field. +func ResolutionGTE(v string) predicate.Series { + return predicate.Series(sql.FieldGTE(FieldResolution, v)) +} + +// ResolutionLT applies the LT predicate on the "resolution" field. +func ResolutionLT(v string) predicate.Series { + return predicate.Series(sql.FieldLT(FieldResolution, v)) +} + +// ResolutionLTE applies the LTE predicate on the "resolution" field. +func ResolutionLTE(v string) predicate.Series { + return predicate.Series(sql.FieldLTE(FieldResolution, v)) +} + +// ResolutionContains applies the Contains predicate on the "resolution" field. +func ResolutionContains(v string) predicate.Series { + return predicate.Series(sql.FieldContains(FieldResolution, v)) +} + +// ResolutionHasPrefix applies the HasPrefix predicate on the "resolution" field. +func ResolutionHasPrefix(v string) predicate.Series { + return predicate.Series(sql.FieldHasPrefix(FieldResolution, v)) +} + +// ResolutionHasSuffix applies the HasSuffix predicate on the "resolution" field. +func ResolutionHasSuffix(v string) predicate.Series { + return predicate.Series(sql.FieldHasSuffix(FieldResolution, v)) +} + +// ResolutionEqualFold applies the EqualFold predicate on the "resolution" field. +func ResolutionEqualFold(v string) predicate.Series { + return predicate.Series(sql.FieldEqualFold(FieldResolution, v)) +} + +// ResolutionContainsFold applies the ContainsFold predicate on the "resolution" field. +func ResolutionContainsFold(v string) predicate.Series { + return predicate.Series(sql.FieldContainsFold(FieldResolution, v)) +} + +// StorageIDEQ applies the EQ predicate on the "storage_id" field. +func StorageIDEQ(v int) predicate.Series { + return predicate.Series(sql.FieldEQ(FieldStorageID, v)) +} + +// StorageIDNEQ applies the NEQ predicate on the "storage_id" field. +func StorageIDNEQ(v int) predicate.Series { + return predicate.Series(sql.FieldNEQ(FieldStorageID, v)) +} + +// StorageIDIn applies the In predicate on the "storage_id" field. +func StorageIDIn(vs ...int) predicate.Series { + return predicate.Series(sql.FieldIn(FieldStorageID, vs...)) +} + +// StorageIDNotIn applies the NotIn predicate on the "storage_id" field. +func StorageIDNotIn(vs ...int) predicate.Series { + return predicate.Series(sql.FieldNotIn(FieldStorageID, vs...)) +} + +// StorageIDGT applies the GT predicate on the "storage_id" field. +func StorageIDGT(v int) predicate.Series { + return predicate.Series(sql.FieldGT(FieldStorageID, v)) +} + +// StorageIDGTE applies the GTE predicate on the "storage_id" field. +func StorageIDGTE(v int) predicate.Series { + return predicate.Series(sql.FieldGTE(FieldStorageID, v)) +} + +// StorageIDLT applies the LT predicate on the "storage_id" field. +func StorageIDLT(v int) predicate.Series { + return predicate.Series(sql.FieldLT(FieldStorageID, v)) +} + +// StorageIDLTE applies the LTE predicate on the "storage_id" field. +func StorageIDLTE(v int) predicate.Series { + return predicate.Series(sql.FieldLTE(FieldStorageID, v)) +} + +// StorageIDIsNil applies the IsNil predicate on the "storage_id" field. +func StorageIDIsNil() predicate.Series { + return predicate.Series(sql.FieldIsNull(FieldStorageID)) +} + +// StorageIDNotNil applies the NotNil predicate on the "storage_id" field. +func StorageIDNotNil() predicate.Series { + return predicate.Series(sql.FieldNotNull(FieldStorageID)) +} + // HasEpisodes applies the HasEdge predicate on the "episodes" edge. func HasEpisodes() predicate.Series { return predicate.Series(func(s *sql.Selector) { diff --git a/ent/series_create.go b/ent/series_create.go index 33edb53..4d564ba 100644 --- a/ent/series_create.go +++ b/ent/series_create.go @@ -47,6 +47,20 @@ func (sc *SeriesCreate) SetName(s string) *SeriesCreate { return sc } +// SetNameEn sets the "name_en" field. +func (sc *SeriesCreate) SetNameEn(s string) *SeriesCreate { + sc.mutation.SetNameEn(s) + return sc +} + +// SetNillableNameEn sets the "name_en" field if the given value is not nil. +func (sc *SeriesCreate) SetNillableNameEn(s *string) *SeriesCreate { + if s != nil { + sc.SetNameEn(*s) + } + return sc +} + // SetOriginalName sets the "original_name" field. func (sc *SeriesCreate) SetOriginalName(s string) *SeriesCreate { sc.mutation.SetOriginalName(s) @@ -59,12 +73,6 @@ func (sc *SeriesCreate) SetOverview(s string) *SeriesCreate { return sc } -// SetPath sets the "path" field. -func (sc *SeriesCreate) SetPath(s string) *SeriesCreate { - sc.mutation.SetPath(s) - return sc -} - // SetPosterPath sets the "poster_path" field. func (sc *SeriesCreate) SetPosterPath(s string) *SeriesCreate { sc.mutation.SetPosterPath(s) @@ -107,6 +115,34 @@ func (sc *SeriesCreate) SetNillableAirDate(s *string) *SeriesCreate { return sc } +// SetResolution sets the "resolution" field. +func (sc *SeriesCreate) SetResolution(s string) *SeriesCreate { + sc.mutation.SetResolution(s) + return sc +} + +// SetNillableResolution sets the "resolution" field if the given value is not nil. +func (sc *SeriesCreate) SetNillableResolution(s *string) *SeriesCreate { + if s != nil { + sc.SetResolution(*s) + } + return sc +} + +// SetStorageID sets the "storage_id" field. +func (sc *SeriesCreate) SetStorageID(i int) *SeriesCreate { + sc.mutation.SetStorageID(i) + return sc +} + +// SetNillableStorageID sets the "storage_id" field if the given value is not nil. +func (sc *SeriesCreate) SetNillableStorageID(i *int) *SeriesCreate { + if i != nil { + sc.SetStorageID(*i) + } + return sc +} + // AddEpisodeIDs adds the "episodes" edge to the Episode entity by IDs. func (sc *SeriesCreate) AddEpisodeIDs(ids ...int) *SeriesCreate { sc.mutation.AddEpisodeIDs(ids...) @@ -165,6 +201,10 @@ func (sc *SeriesCreate) defaults() { v := series.DefaultAirDate sc.mutation.SetAirDate(v) } + if _, ok := sc.mutation.Resolution(); !ok { + v := series.DefaultResolution + sc.mutation.SetResolution(v) + } } // check runs all checks and user-defined validators on the builder. @@ -181,15 +221,15 @@ func (sc *SeriesCreate) check() error { if _, ok := sc.mutation.Overview(); !ok { return &ValidationError{Name: "overview", err: errors.New(`ent: missing required field "Series.overview"`)} } - if _, ok := sc.mutation.Path(); !ok { - return &ValidationError{Name: "path", err: errors.New(`ent: missing required field "Series.path"`)} - } if _, ok := sc.mutation.CreatedAt(); !ok { return &ValidationError{Name: "created_at", err: errors.New(`ent: missing required field "Series.created_at"`)} } if _, ok := sc.mutation.AirDate(); !ok { return &ValidationError{Name: "air_date", err: errors.New(`ent: missing required field "Series.air_date"`)} } + if _, ok := sc.mutation.Resolution(); !ok { + return &ValidationError{Name: "resolution", err: errors.New(`ent: missing required field "Series.resolution"`)} + } return nil } @@ -228,6 +268,10 @@ func (sc *SeriesCreate) createSpec() (*Series, *sqlgraph.CreateSpec) { _spec.SetField(series.FieldName, field.TypeString, value) _node.Name = value } + if value, ok := sc.mutation.NameEn(); ok { + _spec.SetField(series.FieldNameEn, field.TypeString, value) + _node.NameEn = value + } if value, ok := sc.mutation.OriginalName(); ok { _spec.SetField(series.FieldOriginalName, field.TypeString, value) _node.OriginalName = value @@ -236,10 +280,6 @@ func (sc *SeriesCreate) createSpec() (*Series, *sqlgraph.CreateSpec) { _spec.SetField(series.FieldOverview, field.TypeString, value) _node.Overview = value } - if value, ok := sc.mutation.Path(); ok { - _spec.SetField(series.FieldPath, field.TypeString, value) - _node.Path = value - } if value, ok := sc.mutation.PosterPath(); ok { _spec.SetField(series.FieldPosterPath, field.TypeString, value) _node.PosterPath = value @@ -252,6 +292,14 @@ func (sc *SeriesCreate) createSpec() (*Series, *sqlgraph.CreateSpec) { _spec.SetField(series.FieldAirDate, field.TypeString, value) _node.AirDate = value } + if value, ok := sc.mutation.Resolution(); ok { + _spec.SetField(series.FieldResolution, field.TypeString, value) + _node.Resolution = value + } + if value, ok := sc.mutation.StorageID(); ok { + _spec.SetField(series.FieldStorageID, field.TypeInt, value) + _node.StorageID = value + } if nodes := sc.mutation.EpisodesIDs(); len(nodes) > 0 { edge := &sqlgraph.EdgeSpec{ Rel: sqlgraph.O2M, diff --git a/ent/series_update.go b/ent/series_update.go index d30dfc8..5bde156 100644 --- a/ent/series_update.go +++ b/ent/series_update.go @@ -84,6 +84,26 @@ func (su *SeriesUpdate) SetNillableName(s *string) *SeriesUpdate { return su } +// SetNameEn sets the "name_en" field. +func (su *SeriesUpdate) SetNameEn(s string) *SeriesUpdate { + su.mutation.SetNameEn(s) + return su +} + +// SetNillableNameEn sets the "name_en" field if the given value is not nil. +func (su *SeriesUpdate) SetNillableNameEn(s *string) *SeriesUpdate { + if s != nil { + su.SetNameEn(*s) + } + return su +} + +// ClearNameEn clears the value of the "name_en" field. +func (su *SeriesUpdate) ClearNameEn() *SeriesUpdate { + su.mutation.ClearNameEn() + return su +} + // SetOriginalName sets the "original_name" field. func (su *SeriesUpdate) SetOriginalName(s string) *SeriesUpdate { su.mutation.SetOriginalName(s) @@ -112,20 +132,6 @@ func (su *SeriesUpdate) SetNillableOverview(s *string) *SeriesUpdate { return su } -// SetPath sets the "path" field. -func (su *SeriesUpdate) SetPath(s string) *SeriesUpdate { - su.mutation.SetPath(s) - return su -} - -// SetNillablePath sets the "path" field if the given value is not nil. -func (su *SeriesUpdate) SetNillablePath(s *string) *SeriesUpdate { - if s != nil { - su.SetPath(*s) - } - return su -} - // SetPosterPath sets the "poster_path" field. func (su *SeriesUpdate) SetPosterPath(s string) *SeriesUpdate { su.mutation.SetPosterPath(s) @@ -174,6 +180,47 @@ func (su *SeriesUpdate) SetNillableAirDate(s *string) *SeriesUpdate { return su } +// SetResolution sets the "resolution" field. +func (su *SeriesUpdate) SetResolution(s string) *SeriesUpdate { + su.mutation.SetResolution(s) + return su +} + +// SetNillableResolution sets the "resolution" field if the given value is not nil. +func (su *SeriesUpdate) SetNillableResolution(s *string) *SeriesUpdate { + if s != nil { + su.SetResolution(*s) + } + return su +} + +// SetStorageID sets the "storage_id" field. +func (su *SeriesUpdate) SetStorageID(i int) *SeriesUpdate { + su.mutation.ResetStorageID() + su.mutation.SetStorageID(i) + return su +} + +// SetNillableStorageID sets the "storage_id" field if the given value is not nil. +func (su *SeriesUpdate) SetNillableStorageID(i *int) *SeriesUpdate { + if i != nil { + su.SetStorageID(*i) + } + return su +} + +// AddStorageID adds i to the "storage_id" field. +func (su *SeriesUpdate) AddStorageID(i int) *SeriesUpdate { + su.mutation.AddStorageID(i) + return su +} + +// ClearStorageID clears the value of the "storage_id" field. +func (su *SeriesUpdate) ClearStorageID() *SeriesUpdate { + su.mutation.ClearStorageID() + return su +} + // AddEpisodeIDs adds the "episodes" edge to the Episode entity by IDs. func (su *SeriesUpdate) AddEpisodeIDs(ids ...int) *SeriesUpdate { su.mutation.AddEpisodeIDs(ids...) @@ -266,15 +313,18 @@ func (su *SeriesUpdate) sqlSave(ctx context.Context) (n int, err error) { if value, ok := su.mutation.Name(); ok { _spec.SetField(series.FieldName, field.TypeString, value) } + if value, ok := su.mutation.NameEn(); ok { + _spec.SetField(series.FieldNameEn, field.TypeString, value) + } + if su.mutation.NameEnCleared() { + _spec.ClearField(series.FieldNameEn, field.TypeString) + } if value, ok := su.mutation.OriginalName(); ok { _spec.SetField(series.FieldOriginalName, field.TypeString, value) } if value, ok := su.mutation.Overview(); ok { _spec.SetField(series.FieldOverview, field.TypeString, value) } - if value, ok := su.mutation.Path(); ok { - _spec.SetField(series.FieldPath, field.TypeString, value) - } if value, ok := su.mutation.PosterPath(); ok { _spec.SetField(series.FieldPosterPath, field.TypeString, value) } @@ -287,6 +337,18 @@ func (su *SeriesUpdate) sqlSave(ctx context.Context) (n int, err error) { if value, ok := su.mutation.AirDate(); ok { _spec.SetField(series.FieldAirDate, field.TypeString, value) } + if value, ok := su.mutation.Resolution(); ok { + _spec.SetField(series.FieldResolution, field.TypeString, value) + } + if value, ok := su.mutation.StorageID(); ok { + _spec.SetField(series.FieldStorageID, field.TypeInt, value) + } + if value, ok := su.mutation.AddedStorageID(); ok { + _spec.AddField(series.FieldStorageID, field.TypeInt, value) + } + if su.mutation.StorageIDCleared() { + _spec.ClearField(series.FieldStorageID, field.TypeInt) + } if su.mutation.EpisodesCleared() { edge := &sqlgraph.EdgeSpec{ Rel: sqlgraph.O2M, @@ -407,6 +469,26 @@ func (suo *SeriesUpdateOne) SetNillableName(s *string) *SeriesUpdateOne { return suo } +// SetNameEn sets the "name_en" field. +func (suo *SeriesUpdateOne) SetNameEn(s string) *SeriesUpdateOne { + suo.mutation.SetNameEn(s) + return suo +} + +// SetNillableNameEn sets the "name_en" field if the given value is not nil. +func (suo *SeriesUpdateOne) SetNillableNameEn(s *string) *SeriesUpdateOne { + if s != nil { + suo.SetNameEn(*s) + } + return suo +} + +// ClearNameEn clears the value of the "name_en" field. +func (suo *SeriesUpdateOne) ClearNameEn() *SeriesUpdateOne { + suo.mutation.ClearNameEn() + return suo +} + // SetOriginalName sets the "original_name" field. func (suo *SeriesUpdateOne) SetOriginalName(s string) *SeriesUpdateOne { suo.mutation.SetOriginalName(s) @@ -435,20 +517,6 @@ func (suo *SeriesUpdateOne) SetNillableOverview(s *string) *SeriesUpdateOne { return suo } -// SetPath sets the "path" field. -func (suo *SeriesUpdateOne) SetPath(s string) *SeriesUpdateOne { - suo.mutation.SetPath(s) - return suo -} - -// SetNillablePath sets the "path" field if the given value is not nil. -func (suo *SeriesUpdateOne) SetNillablePath(s *string) *SeriesUpdateOne { - if s != nil { - suo.SetPath(*s) - } - return suo -} - // SetPosterPath sets the "poster_path" field. func (suo *SeriesUpdateOne) SetPosterPath(s string) *SeriesUpdateOne { suo.mutation.SetPosterPath(s) @@ -497,6 +565,47 @@ func (suo *SeriesUpdateOne) SetNillableAirDate(s *string) *SeriesUpdateOne { return suo } +// SetResolution sets the "resolution" field. +func (suo *SeriesUpdateOne) SetResolution(s string) *SeriesUpdateOne { + suo.mutation.SetResolution(s) + return suo +} + +// SetNillableResolution sets the "resolution" field if the given value is not nil. +func (suo *SeriesUpdateOne) SetNillableResolution(s *string) *SeriesUpdateOne { + if s != nil { + suo.SetResolution(*s) + } + return suo +} + +// SetStorageID sets the "storage_id" field. +func (suo *SeriesUpdateOne) SetStorageID(i int) *SeriesUpdateOne { + suo.mutation.ResetStorageID() + suo.mutation.SetStorageID(i) + return suo +} + +// SetNillableStorageID sets the "storage_id" field if the given value is not nil. +func (suo *SeriesUpdateOne) SetNillableStorageID(i *int) *SeriesUpdateOne { + if i != nil { + suo.SetStorageID(*i) + } + return suo +} + +// AddStorageID adds i to the "storage_id" field. +func (suo *SeriesUpdateOne) AddStorageID(i int) *SeriesUpdateOne { + suo.mutation.AddStorageID(i) + return suo +} + +// ClearStorageID clears the value of the "storage_id" field. +func (suo *SeriesUpdateOne) ClearStorageID() *SeriesUpdateOne { + suo.mutation.ClearStorageID() + return suo +} + // AddEpisodeIDs adds the "episodes" edge to the Episode entity by IDs. func (suo *SeriesUpdateOne) AddEpisodeIDs(ids ...int) *SeriesUpdateOne { suo.mutation.AddEpisodeIDs(ids...) @@ -619,15 +728,18 @@ func (suo *SeriesUpdateOne) sqlSave(ctx context.Context) (_node *Series, err err if value, ok := suo.mutation.Name(); ok { _spec.SetField(series.FieldName, field.TypeString, value) } + if value, ok := suo.mutation.NameEn(); ok { + _spec.SetField(series.FieldNameEn, field.TypeString, value) + } + if suo.mutation.NameEnCleared() { + _spec.ClearField(series.FieldNameEn, field.TypeString) + } if value, ok := suo.mutation.OriginalName(); ok { _spec.SetField(series.FieldOriginalName, field.TypeString, value) } if value, ok := suo.mutation.Overview(); ok { _spec.SetField(series.FieldOverview, field.TypeString, value) } - if value, ok := suo.mutation.Path(); ok { - _spec.SetField(series.FieldPath, field.TypeString, value) - } if value, ok := suo.mutation.PosterPath(); ok { _spec.SetField(series.FieldPosterPath, field.TypeString, value) } @@ -640,6 +752,18 @@ func (suo *SeriesUpdateOne) sqlSave(ctx context.Context) (_node *Series, err err if value, ok := suo.mutation.AirDate(); ok { _spec.SetField(series.FieldAirDate, field.TypeString, value) } + if value, ok := suo.mutation.Resolution(); ok { + _spec.SetField(series.FieldResolution, field.TypeString, value) + } + if value, ok := suo.mutation.StorageID(); ok { + _spec.SetField(series.FieldStorageID, field.TypeInt, value) + } + if value, ok := suo.mutation.AddedStorageID(); ok { + _spec.AddField(series.FieldStorageID, field.TypeInt, value) + } + if suo.mutation.StorageIDCleared() { + _spec.ClearField(series.FieldStorageID, field.TypeInt) + } if suo.mutation.EpisodesCleared() { edge := &sqlgraph.EdgeSpec{ Rel: sqlgraph.O2M, diff --git a/ent/storage.go b/ent/storage.go new file mode 100644 index 0000000..760e8d1 --- /dev/null +++ b/ent/storage.go @@ -0,0 +1,171 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "fmt" + "polaris/ent/storage" + "strings" + + "entgo.io/ent" + "entgo.io/ent/dialect/sql" +) + +// Storage is the model entity for the Storage schema. +type Storage 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"` + // Implementation holds the value of the "implementation" field. + Implementation string `json:"implementation,omitempty"` + // Path holds the value of the "path" field. + Path string `json:"path,omitempty"` + // User holds the value of the "user" field. + User string `json:"user,omitempty"` + // Password holds the value of the "password" field. + Password string `json:"password,omitempty"` + // Deleted holds the value of the "deleted" field. + Deleted bool `json:"deleted,omitempty"` + // Default holds the value of the "default" field. + Default bool `json:"default,omitempty"` + selectValues sql.SelectValues +} + +// scanValues returns the types for scanning values from sql.Rows. +func (*Storage) scanValues(columns []string) ([]any, error) { + values := make([]any, len(columns)) + for i := range columns { + switch columns[i] { + case storage.FieldDeleted, storage.FieldDefault: + values[i] = new(sql.NullBool) + case storage.FieldID: + values[i] = new(sql.NullInt64) + case storage.FieldName, storage.FieldImplementation, storage.FieldPath, storage.FieldUser, storage.FieldPassword: + 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 Storage fields. +func (s *Storage) 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 storage.FieldID: + value, ok := values[i].(*sql.NullInt64) + if !ok { + return fmt.Errorf("unexpected type %T for field id", value) + } + s.ID = int(value.Int64) + case storage.FieldName: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field name", values[i]) + } else if value.Valid { + s.Name = value.String + } + case storage.FieldImplementation: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field implementation", values[i]) + } else if value.Valid { + s.Implementation = value.String + } + case storage.FieldPath: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field path", values[i]) + } else if value.Valid { + s.Path = value.String + } + case storage.FieldUser: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field user", values[i]) + } else if value.Valid { + s.User = value.String + } + case storage.FieldPassword: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field password", values[i]) + } else if value.Valid { + s.Password = value.String + } + case storage.FieldDeleted: + if value, ok := values[i].(*sql.NullBool); !ok { + return fmt.Errorf("unexpected type %T for field deleted", values[i]) + } else if value.Valid { + s.Deleted = value.Bool + } + case storage.FieldDefault: + if value, ok := values[i].(*sql.NullBool); !ok { + return fmt.Errorf("unexpected type %T for field default", values[i]) + } else if value.Valid { + s.Default = value.Bool + } + default: + s.selectValues.Set(columns[i], values[i]) + } + } + return nil +} + +// Value returns the ent.Value that was dynamically selected and assigned to the Storage. +// This includes values selected through modifiers, order, etc. +func (s *Storage) Value(name string) (ent.Value, error) { + return s.selectValues.Get(name) +} + +// Update returns a builder for updating this Storage. +// Note that you need to call Storage.Unwrap() before calling this method if this Storage +// was returned from a transaction, and the transaction was committed or rolled back. +func (s *Storage) Update() *StorageUpdateOne { + return NewStorageClient(s.config).UpdateOne(s) +} + +// Unwrap unwraps the Storage entity that was returned from a transaction after it was closed, +// so that all future queries will be executed through the driver which created the transaction. +func (s *Storage) Unwrap() *Storage { + _tx, ok := s.config.driver.(*txDriver) + if !ok { + panic("ent: Storage is not a transactional entity") + } + s.config.driver = _tx.drv + return s +} + +// String implements the fmt.Stringer. +func (s *Storage) String() string { + var builder strings.Builder + builder.WriteString("Storage(") + builder.WriteString(fmt.Sprintf("id=%v, ", s.ID)) + builder.WriteString("name=") + builder.WriteString(s.Name) + builder.WriteString(", ") + builder.WriteString("implementation=") + builder.WriteString(s.Implementation) + builder.WriteString(", ") + builder.WriteString("path=") + builder.WriteString(s.Path) + builder.WriteString(", ") + builder.WriteString("user=") + builder.WriteString(s.User) + builder.WriteString(", ") + builder.WriteString("password=") + builder.WriteString(s.Password) + builder.WriteString(", ") + builder.WriteString("deleted=") + builder.WriteString(fmt.Sprintf("%v", s.Deleted)) + builder.WriteString(", ") + builder.WriteString("default=") + builder.WriteString(fmt.Sprintf("%v", s.Default)) + builder.WriteByte(')') + return builder.String() +} + +// Storages is a parsable slice of Storage. +type Storages []*Storage diff --git a/ent/storage/storage.go b/ent/storage/storage.go new file mode 100644 index 0000000..e1d0985 --- /dev/null +++ b/ent/storage/storage.go @@ -0,0 +1,102 @@ +// Code generated by ent, DO NOT EDIT. + +package storage + +import ( + "entgo.io/ent/dialect/sql" +) + +const ( + // Label holds the string label denoting the storage type in the database. + Label = "storage" + // 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" + // FieldImplementation holds the string denoting the implementation field in the database. + FieldImplementation = "implementation" + // FieldPath holds the string denoting the path field in the database. + FieldPath = "path" + // FieldUser holds the string denoting the user field in the database. + FieldUser = "user" + // FieldPassword holds the string denoting the password field in the database. + FieldPassword = "password" + // FieldDeleted holds the string denoting the deleted field in the database. + FieldDeleted = "deleted" + // FieldDefault holds the string denoting the default field in the database. + FieldDefault = "default" + // Table holds the table name of the storage in the database. + Table = "storages" +) + +// Columns holds all SQL columns for storage fields. +var Columns = []string{ + FieldID, + FieldName, + FieldImplementation, + FieldPath, + FieldUser, + FieldPassword, + FieldDeleted, + FieldDefault, +} + +// ValidColumn reports if the column name is valid (part of the table columns). +func ValidColumn(column string) bool { + for i := range Columns { + if column == Columns[i] { + return true + } + } + return false +} + +var ( + // DefaultDeleted holds the default value on creation for the "deleted" field. + DefaultDeleted bool + // DefaultDefault holds the default value on creation for the "default" field. + DefaultDefault bool +) + +// OrderOption defines the ordering options for the Storage 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() +} + +// ByImplementation orders the results by the implementation field. +func ByImplementation(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldImplementation, opts...).ToFunc() +} + +// ByPath orders the results by the path field. +func ByPath(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldPath, opts...).ToFunc() +} + +// ByUser orders the results by the user field. +func ByUser(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldUser, opts...).ToFunc() +} + +// ByPassword orders the results by the password field. +func ByPassword(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldPassword, opts...).ToFunc() +} + +// ByDeleted orders the results by the deleted field. +func ByDeleted(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldDeleted, opts...).ToFunc() +} + +// ByDefault orders the results by the default field. +func ByDefault(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldDefault, opts...).ToFunc() +} diff --git a/ent/storage/where.go b/ent/storage/where.go new file mode 100644 index 0000000..bf7a36d --- /dev/null +++ b/ent/storage/where.go @@ -0,0 +1,469 @@ +// Code generated by ent, DO NOT EDIT. + +package storage + +import ( + "polaris/ent/predicate" + + "entgo.io/ent/dialect/sql" +) + +// ID filters vertices based on their ID field. +func ID(id int) predicate.Storage { + return predicate.Storage(sql.FieldEQ(FieldID, id)) +} + +// IDEQ applies the EQ predicate on the ID field. +func IDEQ(id int) predicate.Storage { + return predicate.Storage(sql.FieldEQ(FieldID, id)) +} + +// IDNEQ applies the NEQ predicate on the ID field. +func IDNEQ(id int) predicate.Storage { + return predicate.Storage(sql.FieldNEQ(FieldID, id)) +} + +// IDIn applies the In predicate on the ID field. +func IDIn(ids ...int) predicate.Storage { + return predicate.Storage(sql.FieldIn(FieldID, ids...)) +} + +// IDNotIn applies the NotIn predicate on the ID field. +func IDNotIn(ids ...int) predicate.Storage { + return predicate.Storage(sql.FieldNotIn(FieldID, ids...)) +} + +// IDGT applies the GT predicate on the ID field. +func IDGT(id int) predicate.Storage { + return predicate.Storage(sql.FieldGT(FieldID, id)) +} + +// IDGTE applies the GTE predicate on the ID field. +func IDGTE(id int) predicate.Storage { + return predicate.Storage(sql.FieldGTE(FieldID, id)) +} + +// IDLT applies the LT predicate on the ID field. +func IDLT(id int) predicate.Storage { + return predicate.Storage(sql.FieldLT(FieldID, id)) +} + +// IDLTE applies the LTE predicate on the ID field. +func IDLTE(id int) predicate.Storage { + return predicate.Storage(sql.FieldLTE(FieldID, id)) +} + +// Name applies equality check predicate on the "name" field. It's identical to NameEQ. +func Name(v string) predicate.Storage { + return predicate.Storage(sql.FieldEQ(FieldName, v)) +} + +// Implementation applies equality check predicate on the "implementation" field. It's identical to ImplementationEQ. +func Implementation(v string) predicate.Storage { + return predicate.Storage(sql.FieldEQ(FieldImplementation, v)) +} + +// Path applies equality check predicate on the "path" field. It's identical to PathEQ. +func Path(v string) predicate.Storage { + return predicate.Storage(sql.FieldEQ(FieldPath, v)) +} + +// User applies equality check predicate on the "user" field. It's identical to UserEQ. +func User(v string) predicate.Storage { + return predicate.Storage(sql.FieldEQ(FieldUser, v)) +} + +// Password applies equality check predicate on the "password" field. It's identical to PasswordEQ. +func Password(v string) predicate.Storage { + return predicate.Storage(sql.FieldEQ(FieldPassword, v)) +} + +// Deleted applies equality check predicate on the "deleted" field. It's identical to DeletedEQ. +func Deleted(v bool) predicate.Storage { + return predicate.Storage(sql.FieldEQ(FieldDeleted, v)) +} + +// Default applies equality check predicate on the "default" field. It's identical to DefaultEQ. +func Default(v bool) predicate.Storage { + return predicate.Storage(sql.FieldEQ(FieldDefault, v)) +} + +// NameEQ applies the EQ predicate on the "name" field. +func NameEQ(v string) predicate.Storage { + return predicate.Storage(sql.FieldEQ(FieldName, v)) +} + +// NameNEQ applies the NEQ predicate on the "name" field. +func NameNEQ(v string) predicate.Storage { + return predicate.Storage(sql.FieldNEQ(FieldName, v)) +} + +// NameIn applies the In predicate on the "name" field. +func NameIn(vs ...string) predicate.Storage { + return predicate.Storage(sql.FieldIn(FieldName, vs...)) +} + +// NameNotIn applies the NotIn predicate on the "name" field. +func NameNotIn(vs ...string) predicate.Storage { + return predicate.Storage(sql.FieldNotIn(FieldName, vs...)) +} + +// NameGT applies the GT predicate on the "name" field. +func NameGT(v string) predicate.Storage { + return predicate.Storage(sql.FieldGT(FieldName, v)) +} + +// NameGTE applies the GTE predicate on the "name" field. +func NameGTE(v string) predicate.Storage { + return predicate.Storage(sql.FieldGTE(FieldName, v)) +} + +// NameLT applies the LT predicate on the "name" field. +func NameLT(v string) predicate.Storage { + return predicate.Storage(sql.FieldLT(FieldName, v)) +} + +// NameLTE applies the LTE predicate on the "name" field. +func NameLTE(v string) predicate.Storage { + return predicate.Storage(sql.FieldLTE(FieldName, v)) +} + +// NameContains applies the Contains predicate on the "name" field. +func NameContains(v string) predicate.Storage { + return predicate.Storage(sql.FieldContains(FieldName, v)) +} + +// NameHasPrefix applies the HasPrefix predicate on the "name" field. +func NameHasPrefix(v string) predicate.Storage { + return predicate.Storage(sql.FieldHasPrefix(FieldName, v)) +} + +// NameHasSuffix applies the HasSuffix predicate on the "name" field. +func NameHasSuffix(v string) predicate.Storage { + return predicate.Storage(sql.FieldHasSuffix(FieldName, v)) +} + +// NameEqualFold applies the EqualFold predicate on the "name" field. +func NameEqualFold(v string) predicate.Storage { + return predicate.Storage(sql.FieldEqualFold(FieldName, v)) +} + +// NameContainsFold applies the ContainsFold predicate on the "name" field. +func NameContainsFold(v string) predicate.Storage { + return predicate.Storage(sql.FieldContainsFold(FieldName, v)) +} + +// ImplementationEQ applies the EQ predicate on the "implementation" field. +func ImplementationEQ(v string) predicate.Storage { + return predicate.Storage(sql.FieldEQ(FieldImplementation, v)) +} + +// ImplementationNEQ applies the NEQ predicate on the "implementation" field. +func ImplementationNEQ(v string) predicate.Storage { + return predicate.Storage(sql.FieldNEQ(FieldImplementation, v)) +} + +// ImplementationIn applies the In predicate on the "implementation" field. +func ImplementationIn(vs ...string) predicate.Storage { + return predicate.Storage(sql.FieldIn(FieldImplementation, vs...)) +} + +// ImplementationNotIn applies the NotIn predicate on the "implementation" field. +func ImplementationNotIn(vs ...string) predicate.Storage { + return predicate.Storage(sql.FieldNotIn(FieldImplementation, vs...)) +} + +// ImplementationGT applies the GT predicate on the "implementation" field. +func ImplementationGT(v string) predicate.Storage { + return predicate.Storage(sql.FieldGT(FieldImplementation, v)) +} + +// ImplementationGTE applies the GTE predicate on the "implementation" field. +func ImplementationGTE(v string) predicate.Storage { + return predicate.Storage(sql.FieldGTE(FieldImplementation, v)) +} + +// ImplementationLT applies the LT predicate on the "implementation" field. +func ImplementationLT(v string) predicate.Storage { + return predicate.Storage(sql.FieldLT(FieldImplementation, v)) +} + +// ImplementationLTE applies the LTE predicate on the "implementation" field. +func ImplementationLTE(v string) predicate.Storage { + return predicate.Storage(sql.FieldLTE(FieldImplementation, v)) +} + +// ImplementationContains applies the Contains predicate on the "implementation" field. +func ImplementationContains(v string) predicate.Storage { + return predicate.Storage(sql.FieldContains(FieldImplementation, v)) +} + +// ImplementationHasPrefix applies the HasPrefix predicate on the "implementation" field. +func ImplementationHasPrefix(v string) predicate.Storage { + return predicate.Storage(sql.FieldHasPrefix(FieldImplementation, v)) +} + +// ImplementationHasSuffix applies the HasSuffix predicate on the "implementation" field. +func ImplementationHasSuffix(v string) predicate.Storage { + return predicate.Storage(sql.FieldHasSuffix(FieldImplementation, v)) +} + +// ImplementationEqualFold applies the EqualFold predicate on the "implementation" field. +func ImplementationEqualFold(v string) predicate.Storage { + return predicate.Storage(sql.FieldEqualFold(FieldImplementation, v)) +} + +// ImplementationContainsFold applies the ContainsFold predicate on the "implementation" field. +func ImplementationContainsFold(v string) predicate.Storage { + return predicate.Storage(sql.FieldContainsFold(FieldImplementation, v)) +} + +// PathEQ applies the EQ predicate on the "path" field. +func PathEQ(v string) predicate.Storage { + return predicate.Storage(sql.FieldEQ(FieldPath, v)) +} + +// PathNEQ applies the NEQ predicate on the "path" field. +func PathNEQ(v string) predicate.Storage { + return predicate.Storage(sql.FieldNEQ(FieldPath, v)) +} + +// PathIn applies the In predicate on the "path" field. +func PathIn(vs ...string) predicate.Storage { + return predicate.Storage(sql.FieldIn(FieldPath, vs...)) +} + +// PathNotIn applies the NotIn predicate on the "path" field. +func PathNotIn(vs ...string) predicate.Storage { + return predicate.Storage(sql.FieldNotIn(FieldPath, vs...)) +} + +// PathGT applies the GT predicate on the "path" field. +func PathGT(v string) predicate.Storage { + return predicate.Storage(sql.FieldGT(FieldPath, v)) +} + +// PathGTE applies the GTE predicate on the "path" field. +func PathGTE(v string) predicate.Storage { + return predicate.Storage(sql.FieldGTE(FieldPath, v)) +} + +// PathLT applies the LT predicate on the "path" field. +func PathLT(v string) predicate.Storage { + return predicate.Storage(sql.FieldLT(FieldPath, v)) +} + +// PathLTE applies the LTE predicate on the "path" field. +func PathLTE(v string) predicate.Storage { + return predicate.Storage(sql.FieldLTE(FieldPath, v)) +} + +// PathContains applies the Contains predicate on the "path" field. +func PathContains(v string) predicate.Storage { + return predicate.Storage(sql.FieldContains(FieldPath, v)) +} + +// PathHasPrefix applies the HasPrefix predicate on the "path" field. +func PathHasPrefix(v string) predicate.Storage { + return predicate.Storage(sql.FieldHasPrefix(FieldPath, v)) +} + +// PathHasSuffix applies the HasSuffix predicate on the "path" field. +func PathHasSuffix(v string) predicate.Storage { + return predicate.Storage(sql.FieldHasSuffix(FieldPath, v)) +} + +// PathEqualFold applies the EqualFold predicate on the "path" field. +func PathEqualFold(v string) predicate.Storage { + return predicate.Storage(sql.FieldEqualFold(FieldPath, v)) +} + +// PathContainsFold applies the ContainsFold predicate on the "path" field. +func PathContainsFold(v string) predicate.Storage { + return predicate.Storage(sql.FieldContainsFold(FieldPath, v)) +} + +// UserEQ applies the EQ predicate on the "user" field. +func UserEQ(v string) predicate.Storage { + return predicate.Storage(sql.FieldEQ(FieldUser, v)) +} + +// UserNEQ applies the NEQ predicate on the "user" field. +func UserNEQ(v string) predicate.Storage { + return predicate.Storage(sql.FieldNEQ(FieldUser, v)) +} + +// UserIn applies the In predicate on the "user" field. +func UserIn(vs ...string) predicate.Storage { + return predicate.Storage(sql.FieldIn(FieldUser, vs...)) +} + +// UserNotIn applies the NotIn predicate on the "user" field. +func UserNotIn(vs ...string) predicate.Storage { + return predicate.Storage(sql.FieldNotIn(FieldUser, vs...)) +} + +// UserGT applies the GT predicate on the "user" field. +func UserGT(v string) predicate.Storage { + return predicate.Storage(sql.FieldGT(FieldUser, v)) +} + +// UserGTE applies the GTE predicate on the "user" field. +func UserGTE(v string) predicate.Storage { + return predicate.Storage(sql.FieldGTE(FieldUser, v)) +} + +// UserLT applies the LT predicate on the "user" field. +func UserLT(v string) predicate.Storage { + return predicate.Storage(sql.FieldLT(FieldUser, v)) +} + +// UserLTE applies the LTE predicate on the "user" field. +func UserLTE(v string) predicate.Storage { + return predicate.Storage(sql.FieldLTE(FieldUser, v)) +} + +// UserContains applies the Contains predicate on the "user" field. +func UserContains(v string) predicate.Storage { + return predicate.Storage(sql.FieldContains(FieldUser, v)) +} + +// UserHasPrefix applies the HasPrefix predicate on the "user" field. +func UserHasPrefix(v string) predicate.Storage { + return predicate.Storage(sql.FieldHasPrefix(FieldUser, v)) +} + +// UserHasSuffix applies the HasSuffix predicate on the "user" field. +func UserHasSuffix(v string) predicate.Storage { + return predicate.Storage(sql.FieldHasSuffix(FieldUser, v)) +} + +// UserIsNil applies the IsNil predicate on the "user" field. +func UserIsNil() predicate.Storage { + return predicate.Storage(sql.FieldIsNull(FieldUser)) +} + +// UserNotNil applies the NotNil predicate on the "user" field. +func UserNotNil() predicate.Storage { + return predicate.Storage(sql.FieldNotNull(FieldUser)) +} + +// UserEqualFold applies the EqualFold predicate on the "user" field. +func UserEqualFold(v string) predicate.Storage { + return predicate.Storage(sql.FieldEqualFold(FieldUser, v)) +} + +// UserContainsFold applies the ContainsFold predicate on the "user" field. +func UserContainsFold(v string) predicate.Storage { + return predicate.Storage(sql.FieldContainsFold(FieldUser, v)) +} + +// PasswordEQ applies the EQ predicate on the "password" field. +func PasswordEQ(v string) predicate.Storage { + return predicate.Storage(sql.FieldEQ(FieldPassword, v)) +} + +// PasswordNEQ applies the NEQ predicate on the "password" field. +func PasswordNEQ(v string) predicate.Storage { + return predicate.Storage(sql.FieldNEQ(FieldPassword, v)) +} + +// PasswordIn applies the In predicate on the "password" field. +func PasswordIn(vs ...string) predicate.Storage { + return predicate.Storage(sql.FieldIn(FieldPassword, vs...)) +} + +// PasswordNotIn applies the NotIn predicate on the "password" field. +func PasswordNotIn(vs ...string) predicate.Storage { + return predicate.Storage(sql.FieldNotIn(FieldPassword, vs...)) +} + +// PasswordGT applies the GT predicate on the "password" field. +func PasswordGT(v string) predicate.Storage { + return predicate.Storage(sql.FieldGT(FieldPassword, v)) +} + +// PasswordGTE applies the GTE predicate on the "password" field. +func PasswordGTE(v string) predicate.Storage { + return predicate.Storage(sql.FieldGTE(FieldPassword, v)) +} + +// PasswordLT applies the LT predicate on the "password" field. +func PasswordLT(v string) predicate.Storage { + return predicate.Storage(sql.FieldLT(FieldPassword, v)) +} + +// PasswordLTE applies the LTE predicate on the "password" field. +func PasswordLTE(v string) predicate.Storage { + return predicate.Storage(sql.FieldLTE(FieldPassword, v)) +} + +// PasswordContains applies the Contains predicate on the "password" field. +func PasswordContains(v string) predicate.Storage { + return predicate.Storage(sql.FieldContains(FieldPassword, v)) +} + +// PasswordHasPrefix applies the HasPrefix predicate on the "password" field. +func PasswordHasPrefix(v string) predicate.Storage { + return predicate.Storage(sql.FieldHasPrefix(FieldPassword, v)) +} + +// PasswordHasSuffix applies the HasSuffix predicate on the "password" field. +func PasswordHasSuffix(v string) predicate.Storage { + return predicate.Storage(sql.FieldHasSuffix(FieldPassword, v)) +} + +// PasswordIsNil applies the IsNil predicate on the "password" field. +func PasswordIsNil() predicate.Storage { + return predicate.Storage(sql.FieldIsNull(FieldPassword)) +} + +// PasswordNotNil applies the NotNil predicate on the "password" field. +func PasswordNotNil() predicate.Storage { + return predicate.Storage(sql.FieldNotNull(FieldPassword)) +} + +// PasswordEqualFold applies the EqualFold predicate on the "password" field. +func PasswordEqualFold(v string) predicate.Storage { + return predicate.Storage(sql.FieldEqualFold(FieldPassword, v)) +} + +// PasswordContainsFold applies the ContainsFold predicate on the "password" field. +func PasswordContainsFold(v string) predicate.Storage { + return predicate.Storage(sql.FieldContainsFold(FieldPassword, v)) +} + +// DeletedEQ applies the EQ predicate on the "deleted" field. +func DeletedEQ(v bool) predicate.Storage { + return predicate.Storage(sql.FieldEQ(FieldDeleted, v)) +} + +// DeletedNEQ applies the NEQ predicate on the "deleted" field. +func DeletedNEQ(v bool) predicate.Storage { + return predicate.Storage(sql.FieldNEQ(FieldDeleted, v)) +} + +// DefaultEQ applies the EQ predicate on the "default" field. +func DefaultEQ(v bool) predicate.Storage { + return predicate.Storage(sql.FieldEQ(FieldDefault, v)) +} + +// DefaultNEQ applies the NEQ predicate on the "default" field. +func DefaultNEQ(v bool) predicate.Storage { + return predicate.Storage(sql.FieldNEQ(FieldDefault, v)) +} + +// And groups predicates with the AND operator between them. +func And(predicates ...predicate.Storage) predicate.Storage { + return predicate.Storage(sql.AndPredicates(predicates...)) +} + +// Or groups predicates with the OR operator between them. +func Or(predicates ...predicate.Storage) predicate.Storage { + return predicate.Storage(sql.OrPredicates(predicates...)) +} + +// Not applies the not operator on the given predicate. +func Not(p predicate.Storage) predicate.Storage { + return predicate.Storage(sql.NotPredicates(p)) +} diff --git a/ent/storage_create.go b/ent/storage_create.go new file mode 100644 index 0000000..6b86d12 --- /dev/null +++ b/ent/storage_create.go @@ -0,0 +1,301 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "context" + "errors" + "fmt" + "polaris/ent/storage" + + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" +) + +// StorageCreate is the builder for creating a Storage entity. +type StorageCreate struct { + config + mutation *StorageMutation + hooks []Hook +} + +// SetName sets the "name" field. +func (sc *StorageCreate) SetName(s string) *StorageCreate { + sc.mutation.SetName(s) + return sc +} + +// SetImplementation sets the "implementation" field. +func (sc *StorageCreate) SetImplementation(s string) *StorageCreate { + sc.mutation.SetImplementation(s) + return sc +} + +// SetPath sets the "path" field. +func (sc *StorageCreate) SetPath(s string) *StorageCreate { + sc.mutation.SetPath(s) + return sc +} + +// SetUser sets the "user" field. +func (sc *StorageCreate) SetUser(s string) *StorageCreate { + sc.mutation.SetUser(s) + return sc +} + +// SetNillableUser sets the "user" field if the given value is not nil. +func (sc *StorageCreate) SetNillableUser(s *string) *StorageCreate { + if s != nil { + sc.SetUser(*s) + } + return sc +} + +// SetPassword sets the "password" field. +func (sc *StorageCreate) SetPassword(s string) *StorageCreate { + sc.mutation.SetPassword(s) + return sc +} + +// SetNillablePassword sets the "password" field if the given value is not nil. +func (sc *StorageCreate) SetNillablePassword(s *string) *StorageCreate { + if s != nil { + sc.SetPassword(*s) + } + return sc +} + +// SetDeleted sets the "deleted" field. +func (sc *StorageCreate) SetDeleted(b bool) *StorageCreate { + sc.mutation.SetDeleted(b) + return sc +} + +// SetNillableDeleted sets the "deleted" field if the given value is not nil. +func (sc *StorageCreate) SetNillableDeleted(b *bool) *StorageCreate { + if b != nil { + sc.SetDeleted(*b) + } + return sc +} + +// SetDefault sets the "default" field. +func (sc *StorageCreate) SetDefault(b bool) *StorageCreate { + sc.mutation.SetDefault(b) + return sc +} + +// SetNillableDefault sets the "default" field if the given value is not nil. +func (sc *StorageCreate) SetNillableDefault(b *bool) *StorageCreate { + if b != nil { + sc.SetDefault(*b) + } + return sc +} + +// Mutation returns the StorageMutation object of the builder. +func (sc *StorageCreate) Mutation() *StorageMutation { + return sc.mutation +} + +// Save creates the Storage in the database. +func (sc *StorageCreate) Save(ctx context.Context) (*Storage, error) { + sc.defaults() + return withHooks(ctx, sc.sqlSave, sc.mutation, sc.hooks) +} + +// SaveX calls Save and panics if Save returns an error. +func (sc *StorageCreate) SaveX(ctx context.Context) *Storage { + v, err := sc.Save(ctx) + if err != nil { + panic(err) + } + return v +} + +// Exec executes the query. +func (sc *StorageCreate) Exec(ctx context.Context) error { + _, err := sc.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (sc *StorageCreate) ExecX(ctx context.Context) { + if err := sc.Exec(ctx); err != nil { + panic(err) + } +} + +// defaults sets the default values of the builder before save. +func (sc *StorageCreate) defaults() { + if _, ok := sc.mutation.Deleted(); !ok { + v := storage.DefaultDeleted + sc.mutation.SetDeleted(v) + } + if _, ok := sc.mutation.Default(); !ok { + v := storage.DefaultDefault + sc.mutation.SetDefault(v) + } +} + +// check runs all checks and user-defined validators on the builder. +func (sc *StorageCreate) check() error { + if _, ok := sc.mutation.Name(); !ok { + return &ValidationError{Name: "name", err: errors.New(`ent: missing required field "Storage.name"`)} + } + if _, ok := sc.mutation.Implementation(); !ok { + return &ValidationError{Name: "implementation", err: errors.New(`ent: missing required field "Storage.implementation"`)} + } + if _, ok := sc.mutation.Path(); !ok { + return &ValidationError{Name: "path", err: errors.New(`ent: missing required field "Storage.path"`)} + } + if _, ok := sc.mutation.Deleted(); !ok { + return &ValidationError{Name: "deleted", err: errors.New(`ent: missing required field "Storage.deleted"`)} + } + if _, ok := sc.mutation.Default(); !ok { + return &ValidationError{Name: "default", err: errors.New(`ent: missing required field "Storage.default"`)} + } + return nil +} + +func (sc *StorageCreate) sqlSave(ctx context.Context) (*Storage, error) { + if err := sc.check(); err != nil { + return nil, err + } + _node, _spec := sc.createSpec() + if err := sqlgraph.CreateNode(ctx, sc.driver, _spec); err != nil { + if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + return nil, err + } + id := _spec.ID.Value.(int64) + _node.ID = int(id) + sc.mutation.id = &_node.ID + sc.mutation.done = true + return _node, nil +} + +func (sc *StorageCreate) createSpec() (*Storage, *sqlgraph.CreateSpec) { + var ( + _node = &Storage{config: sc.config} + _spec = sqlgraph.NewCreateSpec(storage.Table, sqlgraph.NewFieldSpec(storage.FieldID, field.TypeInt)) + ) + if value, ok := sc.mutation.Name(); ok { + _spec.SetField(storage.FieldName, field.TypeString, value) + _node.Name = value + } + if value, ok := sc.mutation.Implementation(); ok { + _spec.SetField(storage.FieldImplementation, field.TypeString, value) + _node.Implementation = value + } + if value, ok := sc.mutation.Path(); ok { + _spec.SetField(storage.FieldPath, field.TypeString, value) + _node.Path = value + } + if value, ok := sc.mutation.User(); ok { + _spec.SetField(storage.FieldUser, field.TypeString, value) + _node.User = value + } + if value, ok := sc.mutation.Password(); ok { + _spec.SetField(storage.FieldPassword, field.TypeString, value) + _node.Password = value + } + if value, ok := sc.mutation.Deleted(); ok { + _spec.SetField(storage.FieldDeleted, field.TypeBool, value) + _node.Deleted = value + } + if value, ok := sc.mutation.Default(); ok { + _spec.SetField(storage.FieldDefault, field.TypeBool, value) + _node.Default = value + } + return _node, _spec +} + +// StorageCreateBulk is the builder for creating many Storage entities in bulk. +type StorageCreateBulk struct { + config + err error + builders []*StorageCreate +} + +// Save creates the Storage entities in the database. +func (scb *StorageCreateBulk) Save(ctx context.Context) ([]*Storage, error) { + if scb.err != nil { + return nil, scb.err + } + specs := make([]*sqlgraph.CreateSpec, len(scb.builders)) + nodes := make([]*Storage, len(scb.builders)) + mutators := make([]Mutator, len(scb.builders)) + for i := range scb.builders { + func(i int, root context.Context) { + builder := scb.builders[i] + builder.defaults() + var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) { + mutation, ok := m.(*StorageMutation) + if !ok { + return nil, fmt.Errorf("unexpected mutation type %T", m) + } + if err := builder.check(); err != nil { + return nil, err + } + builder.mutation = mutation + var err error + nodes[i], specs[i] = builder.createSpec() + if i < len(mutators)-1 { + _, err = mutators[i+1].Mutate(root, scb.builders[i+1].mutation) + } else { + spec := &sqlgraph.BatchCreateSpec{Nodes: specs} + // Invoke the actual operation on the latest mutation in the chain. + if err = sqlgraph.BatchCreate(ctx, scb.driver, spec); err != nil { + if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + } + } + if err != nil { + return nil, err + } + mutation.id = &nodes[i].ID + 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, scb.builders[0].mutation); err != nil { + return nil, err + } + } + return nodes, nil +} + +// SaveX is like Save, but panics if an error occurs. +func (scb *StorageCreateBulk) SaveX(ctx context.Context) []*Storage { + v, err := scb.Save(ctx) + if err != nil { + panic(err) + } + return v +} + +// Exec executes the query. +func (scb *StorageCreateBulk) Exec(ctx context.Context) error { + _, err := scb.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (scb *StorageCreateBulk) ExecX(ctx context.Context) { + if err := scb.Exec(ctx); err != nil { + panic(err) + } +} diff --git a/ent/storage_delete.go b/ent/storage_delete.go new file mode 100644 index 0000000..e5dd46b --- /dev/null +++ b/ent/storage_delete.go @@ -0,0 +1,88 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "context" + "polaris/ent/predicate" + "polaris/ent/storage" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" +) + +// StorageDelete is the builder for deleting a Storage entity. +type StorageDelete struct { + config + hooks []Hook + mutation *StorageMutation +} + +// Where appends a list predicates to the StorageDelete builder. +func (sd *StorageDelete) Where(ps ...predicate.Storage) *StorageDelete { + sd.mutation.Where(ps...) + return sd +} + +// Exec executes the deletion query and returns how many vertices were deleted. +func (sd *StorageDelete) Exec(ctx context.Context) (int, error) { + return withHooks(ctx, sd.sqlExec, sd.mutation, sd.hooks) +} + +// ExecX is like Exec, but panics if an error occurs. +func (sd *StorageDelete) ExecX(ctx context.Context) int { + n, err := sd.Exec(ctx) + if err != nil { + panic(err) + } + return n +} + +func (sd *StorageDelete) sqlExec(ctx context.Context) (int, error) { + _spec := sqlgraph.NewDeleteSpec(storage.Table, sqlgraph.NewFieldSpec(storage.FieldID, field.TypeInt)) + if ps := sd.mutation.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + affected, err := sqlgraph.DeleteNodes(ctx, sd.driver, _spec) + if err != nil && sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + sd.mutation.done = true + return affected, err +} + +// StorageDeleteOne is the builder for deleting a single Storage entity. +type StorageDeleteOne struct { + sd *StorageDelete +} + +// Where appends a list predicates to the StorageDelete builder. +func (sdo *StorageDeleteOne) Where(ps ...predicate.Storage) *StorageDeleteOne { + sdo.sd.mutation.Where(ps...) + return sdo +} + +// Exec executes the deletion query. +func (sdo *StorageDeleteOne) Exec(ctx context.Context) error { + n, err := sdo.sd.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &NotFoundError{storage.Label} + default: + return nil + } +} + +// ExecX is like Exec, but panics if an error occurs. +func (sdo *StorageDeleteOne) ExecX(ctx context.Context) { + if err := sdo.Exec(ctx); err != nil { + panic(err) + } +} diff --git a/ent/storage_query.go b/ent/storage_query.go new file mode 100644 index 0000000..afff766 --- /dev/null +++ b/ent/storage_query.go @@ -0,0 +1,526 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "context" + "fmt" + "math" + "polaris/ent/predicate" + "polaris/ent/storage" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" +) + +// StorageQuery is the builder for querying Storage entities. +type StorageQuery struct { + config + ctx *QueryContext + order []storage.OrderOption + inters []Interceptor + predicates []predicate.Storage + // intermediate query (i.e. traversal path). + sql *sql.Selector + path func(context.Context) (*sql.Selector, error) +} + +// Where adds a new predicate for the StorageQuery builder. +func (sq *StorageQuery) Where(ps ...predicate.Storage) *StorageQuery { + sq.predicates = append(sq.predicates, ps...) + return sq +} + +// Limit the number of records to be returned by this query. +func (sq *StorageQuery) Limit(limit int) *StorageQuery { + sq.ctx.Limit = &limit + return sq +} + +// Offset to start from. +func (sq *StorageQuery) Offset(offset int) *StorageQuery { + sq.ctx.Offset = &offset + return sq +} + +// Unique configures the query builder to filter duplicate records on query. +// By default, unique is set to true, and can be disabled using this method. +func (sq *StorageQuery) Unique(unique bool) *StorageQuery { + sq.ctx.Unique = &unique + return sq +} + +// Order specifies how the records should be ordered. +func (sq *StorageQuery) Order(o ...storage.OrderOption) *StorageQuery { + sq.order = append(sq.order, o...) + return sq +} + +// First returns the first Storage entity from the query. +// Returns a *NotFoundError when no Storage was found. +func (sq *StorageQuery) First(ctx context.Context) (*Storage, error) { + nodes, err := sq.Limit(1).All(setContextOp(ctx, sq.ctx, "First")) + if err != nil { + return nil, err + } + if len(nodes) == 0 { + return nil, &NotFoundError{storage.Label} + } + return nodes[0], nil +} + +// FirstX is like First, but panics if an error occurs. +func (sq *StorageQuery) FirstX(ctx context.Context) *Storage { + node, err := sq.First(ctx) + if err != nil && !IsNotFound(err) { + panic(err) + } + return node +} + +// FirstID returns the first Storage ID from the query. +// Returns a *NotFoundError when no Storage ID was found. +func (sq *StorageQuery) FirstID(ctx context.Context) (id int, err error) { + var ids []int + if ids, err = sq.Limit(1).IDs(setContextOp(ctx, sq.ctx, "FirstID")); err != nil { + return + } + if len(ids) == 0 { + err = &NotFoundError{storage.Label} + return + } + return ids[0], nil +} + +// FirstIDX is like FirstID, but panics if an error occurs. +func (sq *StorageQuery) FirstIDX(ctx context.Context) int { + id, err := sq.FirstID(ctx) + if err != nil && !IsNotFound(err) { + panic(err) + } + return id +} + +// Only returns a single Storage entity found by the query, ensuring it only returns one. +// Returns a *NotSingularError when more than one Storage entity is found. +// Returns a *NotFoundError when no Storage entities are found. +func (sq *StorageQuery) Only(ctx context.Context) (*Storage, error) { + nodes, err := sq.Limit(2).All(setContextOp(ctx, sq.ctx, "Only")) + if err != nil { + return nil, err + } + switch len(nodes) { + case 1: + return nodes[0], nil + case 0: + return nil, &NotFoundError{storage.Label} + default: + return nil, &NotSingularError{storage.Label} + } +} + +// OnlyX is like Only, but panics if an error occurs. +func (sq *StorageQuery) OnlyX(ctx context.Context) *Storage { + node, err := sq.Only(ctx) + if err != nil { + panic(err) + } + return node +} + +// OnlyID is like Only, but returns the only Storage ID in the query. +// Returns a *NotSingularError when more than one Storage ID is found. +// Returns a *NotFoundError when no entities are found. +func (sq *StorageQuery) OnlyID(ctx context.Context) (id int, err error) { + var ids []int + if ids, err = sq.Limit(2).IDs(setContextOp(ctx, sq.ctx, "OnlyID")); err != nil { + return + } + switch len(ids) { + case 1: + id = ids[0] + case 0: + err = &NotFoundError{storage.Label} + default: + err = &NotSingularError{storage.Label} + } + return +} + +// OnlyIDX is like OnlyID, but panics if an error occurs. +func (sq *StorageQuery) OnlyIDX(ctx context.Context) int { + id, err := sq.OnlyID(ctx) + if err != nil { + panic(err) + } + return id +} + +// All executes the query and returns a list of Storages. +func (sq *StorageQuery) All(ctx context.Context) ([]*Storage, error) { + ctx = setContextOp(ctx, sq.ctx, "All") + if err := sq.prepareQuery(ctx); err != nil { + return nil, err + } + qr := querierAll[[]*Storage, *StorageQuery]() + return withInterceptors[[]*Storage](ctx, sq, qr, sq.inters) +} + +// AllX is like All, but panics if an error occurs. +func (sq *StorageQuery) AllX(ctx context.Context) []*Storage { + nodes, err := sq.All(ctx) + if err != nil { + panic(err) + } + return nodes +} + +// IDs executes the query and returns a list of Storage IDs. +func (sq *StorageQuery) IDs(ctx context.Context) (ids []int, err error) { + if sq.ctx.Unique == nil && sq.path != nil { + sq.Unique(true) + } + ctx = setContextOp(ctx, sq.ctx, "IDs") + if err = sq.Select(storage.FieldID).Scan(ctx, &ids); err != nil { + return nil, err + } + return ids, nil +} + +// IDsX is like IDs, but panics if an error occurs. +func (sq *StorageQuery) IDsX(ctx context.Context) []int { + ids, err := sq.IDs(ctx) + if err != nil { + panic(err) + } + return ids +} + +// Count returns the count of the given query. +func (sq *StorageQuery) Count(ctx context.Context) (int, error) { + ctx = setContextOp(ctx, sq.ctx, "Count") + if err := sq.prepareQuery(ctx); err != nil { + return 0, err + } + return withInterceptors[int](ctx, sq, querierCount[*StorageQuery](), sq.inters) +} + +// CountX is like Count, but panics if an error occurs. +func (sq *StorageQuery) CountX(ctx context.Context) int { + count, err := sq.Count(ctx) + if err != nil { + panic(err) + } + return count +} + +// Exist returns true if the query has elements in the graph. +func (sq *StorageQuery) Exist(ctx context.Context) (bool, error) { + ctx = setContextOp(ctx, sq.ctx, "Exist") + switch _, err := sq.FirstID(ctx); { + case IsNotFound(err): + return false, nil + case err != nil: + return false, fmt.Errorf("ent: check existence: %w", err) + default: + return true, nil + } +} + +// ExistX is like Exist, but panics if an error occurs. +func (sq *StorageQuery) ExistX(ctx context.Context) bool { + exist, err := sq.Exist(ctx) + if err != nil { + panic(err) + } + return exist +} + +// Clone returns a duplicate of the StorageQuery builder, including all associated steps. It can be +// used to prepare common query builders and use them differently after the clone is made. +func (sq *StorageQuery) Clone() *StorageQuery { + if sq == nil { + return nil + } + return &StorageQuery{ + config: sq.config, + ctx: sq.ctx.Clone(), + order: append([]storage.OrderOption{}, sq.order...), + inters: append([]Interceptor{}, sq.inters...), + predicates: append([]predicate.Storage{}, sq.predicates...), + // clone intermediate query. + sql: sq.sql.Clone(), + path: sq.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.Storage.Query(). +// GroupBy(storage.FieldName). +// Aggregate(ent.Count()). +// Scan(ctx, &v) +func (sq *StorageQuery) GroupBy(field string, fields ...string) *StorageGroupBy { + sq.ctx.Fields = append([]string{field}, fields...) + grbuild := &StorageGroupBy{build: sq} + grbuild.flds = &sq.ctx.Fields + grbuild.label = storage.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.Storage.Query(). +// Select(storage.FieldName). +// Scan(ctx, &v) +func (sq *StorageQuery) Select(fields ...string) *StorageSelect { + sq.ctx.Fields = append(sq.ctx.Fields, fields...) + sbuild := &StorageSelect{StorageQuery: sq} + sbuild.label = storage.Label + sbuild.flds, sbuild.scan = &sq.ctx.Fields, sbuild.Scan + return sbuild +} + +// Aggregate returns a StorageSelect configured with the given aggregations. +func (sq *StorageQuery) Aggregate(fns ...AggregateFunc) *StorageSelect { + return sq.Select().Aggregate(fns...) +} + +func (sq *StorageQuery) prepareQuery(ctx context.Context) error { + for _, inter := range sq.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, sq); err != nil { + return err + } + } + } + for _, f := range sq.ctx.Fields { + if !storage.ValidColumn(f) { + return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)} + } + } + if sq.path != nil { + prev, err := sq.path(ctx) + if err != nil { + return err + } + sq.sql = prev + } + return nil +} + +func (sq *StorageQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Storage, error) { + var ( + nodes = []*Storage{} + _spec = sq.querySpec() + ) + _spec.ScanValues = func(columns []string) ([]any, error) { + return (*Storage).scanValues(nil, columns) + } + _spec.Assign = func(columns []string, values []any) error { + node := &Storage{config: sq.config} + nodes = append(nodes, node) + return node.assignValues(columns, values) + } + for i := range hooks { + hooks[i](ctx, _spec) + } + if err := sqlgraph.QueryNodes(ctx, sq.driver, _spec); err != nil { + return nil, err + } + if len(nodes) == 0 { + return nodes, nil + } + return nodes, nil +} + +func (sq *StorageQuery) sqlCount(ctx context.Context) (int, error) { + _spec := sq.querySpec() + _spec.Node.Columns = sq.ctx.Fields + if len(sq.ctx.Fields) > 0 { + _spec.Unique = sq.ctx.Unique != nil && *sq.ctx.Unique + } + return sqlgraph.CountNodes(ctx, sq.driver, _spec) +} + +func (sq *StorageQuery) querySpec() *sqlgraph.QuerySpec { + _spec := sqlgraph.NewQuerySpec(storage.Table, storage.Columns, sqlgraph.NewFieldSpec(storage.FieldID, field.TypeInt)) + _spec.From = sq.sql + if unique := sq.ctx.Unique; unique != nil { + _spec.Unique = *unique + } else if sq.path != nil { + _spec.Unique = true + } + if fields := sq.ctx.Fields; len(fields) > 0 { + _spec.Node.Columns = make([]string, 0, len(fields)) + _spec.Node.Columns = append(_spec.Node.Columns, storage.FieldID) + for i := range fields { + if fields[i] != storage.FieldID { + _spec.Node.Columns = append(_spec.Node.Columns, fields[i]) + } + } + } + if ps := sq.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + if limit := sq.ctx.Limit; limit != nil { + _spec.Limit = *limit + } + if offset := sq.ctx.Offset; offset != nil { + _spec.Offset = *offset + } + if ps := sq.order; len(ps) > 0 { + _spec.Order = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + return _spec +} + +func (sq *StorageQuery) sqlQuery(ctx context.Context) *sql.Selector { + builder := sql.Dialect(sq.driver.Dialect()) + t1 := builder.Table(storage.Table) + columns := sq.ctx.Fields + if len(columns) == 0 { + columns = storage.Columns + } + selector := builder.Select(t1.Columns(columns...)...).From(t1) + if sq.sql != nil { + selector = sq.sql + selector.Select(selector.Columns(columns...)...) + } + if sq.ctx.Unique != nil && *sq.ctx.Unique { + selector.Distinct() + } + for _, p := range sq.predicates { + p(selector) + } + for _, p := range sq.order { + p(selector) + } + if offset := sq.ctx.Offset; offset != nil { + // limit is mandatory for offset clause. We start + // with default value, and override it below if needed. + selector.Offset(*offset).Limit(math.MaxInt32) + } + if limit := sq.ctx.Limit; limit != nil { + selector.Limit(*limit) + } + return selector +} + +// StorageGroupBy is the group-by builder for Storage entities. +type StorageGroupBy struct { + selector + build *StorageQuery +} + +// Aggregate adds the given aggregation functions to the group-by query. +func (sgb *StorageGroupBy) Aggregate(fns ...AggregateFunc) *StorageGroupBy { + sgb.fns = append(sgb.fns, fns...) + return sgb +} + +// Scan applies the selector query and scans the result into the given value. +func (sgb *StorageGroupBy) Scan(ctx context.Context, v any) error { + ctx = setContextOp(ctx, sgb.build.ctx, "GroupBy") + if err := sgb.build.prepareQuery(ctx); err != nil { + return err + } + return scanWithInterceptors[*StorageQuery, *StorageGroupBy](ctx, sgb.build, sgb, sgb.build.inters, v) +} + +func (sgb *StorageGroupBy) sqlScan(ctx context.Context, root *StorageQuery, v any) error { + selector := root.sqlQuery(ctx).Select() + aggregation := make([]string, 0, len(sgb.fns)) + for _, fn := range sgb.fns { + aggregation = append(aggregation, fn(selector)) + } + if len(selector.SelectedColumns()) == 0 { + columns := make([]string, 0, len(*sgb.flds)+len(sgb.fns)) + for _, f := range *sgb.flds { + columns = append(columns, selector.C(f)) + } + columns = append(columns, aggregation...) + selector.Select(columns...) + } + selector.GroupBy(selector.Columns(*sgb.flds...)...) + if err := selector.Err(); err != nil { + return err + } + rows := &sql.Rows{} + query, args := selector.Query() + if err := sgb.build.driver.Query(ctx, query, args, rows); err != nil { + return err + } + defer rows.Close() + return sql.ScanSlice(rows, v) +} + +// StorageSelect is the builder for selecting fields of Storage entities. +type StorageSelect struct { + *StorageQuery + selector +} + +// Aggregate adds the given aggregation functions to the selector query. +func (ss *StorageSelect) Aggregate(fns ...AggregateFunc) *StorageSelect { + ss.fns = append(ss.fns, fns...) + return ss +} + +// Scan applies the selector query and scans the result into the given value. +func (ss *StorageSelect) Scan(ctx context.Context, v any) error { + ctx = setContextOp(ctx, ss.ctx, "Select") + if err := ss.prepareQuery(ctx); err != nil { + return err + } + return scanWithInterceptors[*StorageQuery, *StorageSelect](ctx, ss.StorageQuery, ss, ss.inters, v) +} + +func (ss *StorageSelect) sqlScan(ctx context.Context, root *StorageQuery, v any) error { + selector := root.sqlQuery(ctx) + aggregation := make([]string, 0, len(ss.fns)) + for _, fn := range ss.fns { + aggregation = append(aggregation, fn(selector)) + } + switch n := len(*ss.selector.flds); { + case n == 0 && len(aggregation) > 0: + selector.Select(aggregation...) + case n != 0 && len(aggregation) > 0: + selector.AppendSelect(aggregation...) + } + rows := &sql.Rows{} + query, args := selector.Query() + if err := ss.driver.Query(ctx, query, args, rows); err != nil { + return err + } + defer rows.Close() + return sql.ScanSlice(rows, v) +} diff --git a/ent/storage_update.go b/ent/storage_update.go new file mode 100644 index 0000000..13aa551 --- /dev/null +++ b/ent/storage_update.go @@ -0,0 +1,449 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "context" + "errors" + "fmt" + "polaris/ent/predicate" + "polaris/ent/storage" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" +) + +// StorageUpdate is the builder for updating Storage entities. +type StorageUpdate struct { + config + hooks []Hook + mutation *StorageMutation +} + +// Where appends a list predicates to the StorageUpdate builder. +func (su *StorageUpdate) Where(ps ...predicate.Storage) *StorageUpdate { + su.mutation.Where(ps...) + return su +} + +// SetName sets the "name" field. +func (su *StorageUpdate) SetName(s string) *StorageUpdate { + su.mutation.SetName(s) + return su +} + +// SetNillableName sets the "name" field if the given value is not nil. +func (su *StorageUpdate) SetNillableName(s *string) *StorageUpdate { + if s != nil { + su.SetName(*s) + } + return su +} + +// SetImplementation sets the "implementation" field. +func (su *StorageUpdate) SetImplementation(s string) *StorageUpdate { + su.mutation.SetImplementation(s) + return su +} + +// SetNillableImplementation sets the "implementation" field if the given value is not nil. +func (su *StorageUpdate) SetNillableImplementation(s *string) *StorageUpdate { + if s != nil { + su.SetImplementation(*s) + } + return su +} + +// SetPath sets the "path" field. +func (su *StorageUpdate) SetPath(s string) *StorageUpdate { + su.mutation.SetPath(s) + return su +} + +// SetNillablePath sets the "path" field if the given value is not nil. +func (su *StorageUpdate) SetNillablePath(s *string) *StorageUpdate { + if s != nil { + su.SetPath(*s) + } + return su +} + +// SetUser sets the "user" field. +func (su *StorageUpdate) SetUser(s string) *StorageUpdate { + su.mutation.SetUser(s) + return su +} + +// SetNillableUser sets the "user" field if the given value is not nil. +func (su *StorageUpdate) SetNillableUser(s *string) *StorageUpdate { + if s != nil { + su.SetUser(*s) + } + return su +} + +// ClearUser clears the value of the "user" field. +func (su *StorageUpdate) ClearUser() *StorageUpdate { + su.mutation.ClearUser() + return su +} + +// SetPassword sets the "password" field. +func (su *StorageUpdate) SetPassword(s string) *StorageUpdate { + su.mutation.SetPassword(s) + return su +} + +// SetNillablePassword sets the "password" field if the given value is not nil. +func (su *StorageUpdate) SetNillablePassword(s *string) *StorageUpdate { + if s != nil { + su.SetPassword(*s) + } + return su +} + +// ClearPassword clears the value of the "password" field. +func (su *StorageUpdate) ClearPassword() *StorageUpdate { + su.mutation.ClearPassword() + return su +} + +// SetDeleted sets the "deleted" field. +func (su *StorageUpdate) SetDeleted(b bool) *StorageUpdate { + su.mutation.SetDeleted(b) + return su +} + +// SetNillableDeleted sets the "deleted" field if the given value is not nil. +func (su *StorageUpdate) SetNillableDeleted(b *bool) *StorageUpdate { + if b != nil { + su.SetDeleted(*b) + } + return su +} + +// SetDefault sets the "default" field. +func (su *StorageUpdate) SetDefault(b bool) *StorageUpdate { + su.mutation.SetDefault(b) + return su +} + +// SetNillableDefault sets the "default" field if the given value is not nil. +func (su *StorageUpdate) SetNillableDefault(b *bool) *StorageUpdate { + if b != nil { + su.SetDefault(*b) + } + return su +} + +// Mutation returns the StorageMutation object of the builder. +func (su *StorageUpdate) Mutation() *StorageMutation { + return su.mutation +} + +// Save executes the query and returns the number of nodes affected by the update operation. +func (su *StorageUpdate) Save(ctx context.Context) (int, error) { + return withHooks(ctx, su.sqlSave, su.mutation, su.hooks) +} + +// SaveX is like Save, but panics if an error occurs. +func (su *StorageUpdate) SaveX(ctx context.Context) int { + affected, err := su.Save(ctx) + if err != nil { + panic(err) + } + return affected +} + +// Exec executes the query. +func (su *StorageUpdate) Exec(ctx context.Context) error { + _, err := su.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (su *StorageUpdate) ExecX(ctx context.Context) { + if err := su.Exec(ctx); err != nil { + panic(err) + } +} + +func (su *StorageUpdate) sqlSave(ctx context.Context) (n int, err error) { + _spec := sqlgraph.NewUpdateSpec(storage.Table, storage.Columns, sqlgraph.NewFieldSpec(storage.FieldID, field.TypeInt)) + if ps := su.mutation.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + if value, ok := su.mutation.Name(); ok { + _spec.SetField(storage.FieldName, field.TypeString, value) + } + if value, ok := su.mutation.Implementation(); ok { + _spec.SetField(storage.FieldImplementation, field.TypeString, value) + } + if value, ok := su.mutation.Path(); ok { + _spec.SetField(storage.FieldPath, field.TypeString, value) + } + if value, ok := su.mutation.User(); ok { + _spec.SetField(storage.FieldUser, field.TypeString, value) + } + if su.mutation.UserCleared() { + _spec.ClearField(storage.FieldUser, field.TypeString) + } + if value, ok := su.mutation.Password(); ok { + _spec.SetField(storage.FieldPassword, field.TypeString, value) + } + if su.mutation.PasswordCleared() { + _spec.ClearField(storage.FieldPassword, field.TypeString) + } + if value, ok := su.mutation.Deleted(); ok { + _spec.SetField(storage.FieldDeleted, field.TypeBool, value) + } + if value, ok := su.mutation.Default(); ok { + _spec.SetField(storage.FieldDefault, field.TypeBool, value) + } + if n, err = sqlgraph.UpdateNodes(ctx, su.driver, _spec); err != nil { + if _, ok := err.(*sqlgraph.NotFoundError); ok { + err = &NotFoundError{storage.Label} + } else if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + return 0, err + } + su.mutation.done = true + return n, nil +} + +// StorageUpdateOne is the builder for updating a single Storage entity. +type StorageUpdateOne struct { + config + fields []string + hooks []Hook + mutation *StorageMutation +} + +// SetName sets the "name" field. +func (suo *StorageUpdateOne) SetName(s string) *StorageUpdateOne { + suo.mutation.SetName(s) + return suo +} + +// SetNillableName sets the "name" field if the given value is not nil. +func (suo *StorageUpdateOne) SetNillableName(s *string) *StorageUpdateOne { + if s != nil { + suo.SetName(*s) + } + return suo +} + +// SetImplementation sets the "implementation" field. +func (suo *StorageUpdateOne) SetImplementation(s string) *StorageUpdateOne { + suo.mutation.SetImplementation(s) + return suo +} + +// SetNillableImplementation sets the "implementation" field if the given value is not nil. +func (suo *StorageUpdateOne) SetNillableImplementation(s *string) *StorageUpdateOne { + if s != nil { + suo.SetImplementation(*s) + } + return suo +} + +// SetPath sets the "path" field. +func (suo *StorageUpdateOne) SetPath(s string) *StorageUpdateOne { + suo.mutation.SetPath(s) + return suo +} + +// SetNillablePath sets the "path" field if the given value is not nil. +func (suo *StorageUpdateOne) SetNillablePath(s *string) *StorageUpdateOne { + if s != nil { + suo.SetPath(*s) + } + return suo +} + +// SetUser sets the "user" field. +func (suo *StorageUpdateOne) SetUser(s string) *StorageUpdateOne { + suo.mutation.SetUser(s) + return suo +} + +// SetNillableUser sets the "user" field if the given value is not nil. +func (suo *StorageUpdateOne) SetNillableUser(s *string) *StorageUpdateOne { + if s != nil { + suo.SetUser(*s) + } + return suo +} + +// ClearUser clears the value of the "user" field. +func (suo *StorageUpdateOne) ClearUser() *StorageUpdateOne { + suo.mutation.ClearUser() + return suo +} + +// SetPassword sets the "password" field. +func (suo *StorageUpdateOne) SetPassword(s string) *StorageUpdateOne { + suo.mutation.SetPassword(s) + return suo +} + +// SetNillablePassword sets the "password" field if the given value is not nil. +func (suo *StorageUpdateOne) SetNillablePassword(s *string) *StorageUpdateOne { + if s != nil { + suo.SetPassword(*s) + } + return suo +} + +// ClearPassword clears the value of the "password" field. +func (suo *StorageUpdateOne) ClearPassword() *StorageUpdateOne { + suo.mutation.ClearPassword() + return suo +} + +// SetDeleted sets the "deleted" field. +func (suo *StorageUpdateOne) SetDeleted(b bool) *StorageUpdateOne { + suo.mutation.SetDeleted(b) + return suo +} + +// SetNillableDeleted sets the "deleted" field if the given value is not nil. +func (suo *StorageUpdateOne) SetNillableDeleted(b *bool) *StorageUpdateOne { + if b != nil { + suo.SetDeleted(*b) + } + return suo +} + +// SetDefault sets the "default" field. +func (suo *StorageUpdateOne) SetDefault(b bool) *StorageUpdateOne { + suo.mutation.SetDefault(b) + return suo +} + +// SetNillableDefault sets the "default" field if the given value is not nil. +func (suo *StorageUpdateOne) SetNillableDefault(b *bool) *StorageUpdateOne { + if b != nil { + suo.SetDefault(*b) + } + return suo +} + +// Mutation returns the StorageMutation object of the builder. +func (suo *StorageUpdateOne) Mutation() *StorageMutation { + return suo.mutation +} + +// Where appends a list predicates to the StorageUpdate builder. +func (suo *StorageUpdateOne) Where(ps ...predicate.Storage) *StorageUpdateOne { + suo.mutation.Where(ps...) + return suo +} + +// Select allows selecting one or more fields (columns) of the returned entity. +// The default is selecting all fields defined in the entity schema. +func (suo *StorageUpdateOne) Select(field string, fields ...string) *StorageUpdateOne { + suo.fields = append([]string{field}, fields...) + return suo +} + +// Save executes the query and returns the updated Storage entity. +func (suo *StorageUpdateOne) Save(ctx context.Context) (*Storage, error) { + return withHooks(ctx, suo.sqlSave, suo.mutation, suo.hooks) +} + +// SaveX is like Save, but panics if an error occurs. +func (suo *StorageUpdateOne) SaveX(ctx context.Context) *Storage { + node, err := suo.Save(ctx) + if err != nil { + panic(err) + } + return node +} + +// Exec executes the query on the entity. +func (suo *StorageUpdateOne) Exec(ctx context.Context) error { + _, err := suo.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (suo *StorageUpdateOne) ExecX(ctx context.Context) { + if err := suo.Exec(ctx); err != nil { + panic(err) + } +} + +func (suo *StorageUpdateOne) sqlSave(ctx context.Context) (_node *Storage, err error) { + _spec := sqlgraph.NewUpdateSpec(storage.Table, storage.Columns, sqlgraph.NewFieldSpec(storage.FieldID, field.TypeInt)) + id, ok := suo.mutation.ID() + if !ok { + return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "Storage.id" for update`)} + } + _spec.Node.ID.Value = id + if fields := suo.fields; len(fields) > 0 { + _spec.Node.Columns = make([]string, 0, len(fields)) + _spec.Node.Columns = append(_spec.Node.Columns, storage.FieldID) + for _, f := range fields { + if !storage.ValidColumn(f) { + return nil, &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)} + } + if f != storage.FieldID { + _spec.Node.Columns = append(_spec.Node.Columns, f) + } + } + } + if ps := suo.mutation.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + if value, ok := suo.mutation.Name(); ok { + _spec.SetField(storage.FieldName, field.TypeString, value) + } + if value, ok := suo.mutation.Implementation(); ok { + _spec.SetField(storage.FieldImplementation, field.TypeString, value) + } + if value, ok := suo.mutation.Path(); ok { + _spec.SetField(storage.FieldPath, field.TypeString, value) + } + if value, ok := suo.mutation.User(); ok { + _spec.SetField(storage.FieldUser, field.TypeString, value) + } + if suo.mutation.UserCleared() { + _spec.ClearField(storage.FieldUser, field.TypeString) + } + if value, ok := suo.mutation.Password(); ok { + _spec.SetField(storage.FieldPassword, field.TypeString, value) + } + if suo.mutation.PasswordCleared() { + _spec.ClearField(storage.FieldPassword, field.TypeString) + } + if value, ok := suo.mutation.Deleted(); ok { + _spec.SetField(storage.FieldDeleted, field.TypeBool, value) + } + if value, ok := suo.mutation.Default(); ok { + _spec.SetField(storage.FieldDefault, field.TypeBool, value) + } + _node = &Storage{config: suo.config} + _spec.Assign = _node.assignValues + _spec.ScanValues = _node.scanValues + if err = sqlgraph.UpdateNode(ctx, suo.driver, _spec); err != nil { + if _, ok := err.(*sqlgraph.NotFoundError); ok { + err = &NotFoundError{storage.Label} + } else if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + return nil, err + } + suo.mutation.done = true + return _node, nil +} diff --git a/ent/tx.go b/ent/tx.go index 4a14cb0..7776517 100644 --- a/ent/tx.go +++ b/ent/tx.go @@ -24,6 +24,8 @@ type Tx struct { Series *SeriesClient // Settings is the client for interacting with the Settings builders. Settings *SettingsClient + // Storage is the client for interacting with the Storage builders. + Storage *StorageClient // lazily loaded. client *Client @@ -161,6 +163,7 @@ func (tx *Tx) init() { tx.Indexers = NewIndexersClient(tx.config) tx.Series = NewSeriesClient(tx.config) tx.Settings = NewSettingsClient(tx.config) + tx.Storage = NewStorageClient(tx.config) } // txDriver wraps the given dialect.Tx with a nop dialect.Driver implementation. diff --git a/go.mod b/go.mod index 3f07fa2..ec42012 100644 --- a/go.mod +++ b/go.mod @@ -18,6 +18,7 @@ require ( github.com/bytedance/sonic/loader v0.1.1 // indirect github.com/cloudwego/base64x v0.1.4 // indirect github.com/cloudwego/iasm v0.2.0 // indirect + github.com/emersion/go-webdav v0.5.0 // indirect github.com/fsnotify/fsnotify v1.7.0 // indirect github.com/gabriel-vasile/mimetype v1.4.3 // indirect github.com/gin-contrib/sse v0.1.0 // indirect diff --git a/go.sum b/go.sum index 869ee55..82e7ed5 100644 --- a/go.sum +++ b/go.sum @@ -22,6 +22,10 @@ github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSs github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/emersion/go-ical v0.0.0-20220601085725-0864dccc089f/go.mod h1:2MKFUgfNMULRxqZkadG1Vh44we3y5gJAtTBlVsx1BKQ= +github.com/emersion/go-vcard v0.0.0-20230815062825-8fda7d206ec9/go.mod h1:HMJKR5wlh/ziNp+sHEDV2ltblO4JD2+IdDOWtGcQBTM= +github.com/emersion/go-webdav v0.5.0 h1:Ak/BQLgAihJt/UxJbCsEXDPxS5Uw4nZzgIMOq3rkKjc= +github.com/emersion/go-webdav v0.5.0/go.mod h1:ycyIzTelG5pHln4t+Y32/zBvmrM7+mV7x+V+Gx4ZQno= github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8= github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0= github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA= @@ -147,6 +151,8 @@ github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsT github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8= github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU= +github.com/teambition/rrule-go v1.7.2/go.mod h1:mBJ1Ht5uboJ6jexKdNUJg2NcwP8uUMNvStWXlJD3MvU= +github.com/teambition/rrule-go v1.8.2/go.mod h1:Ieq5AbrKGciP1V//Wq8ktsTXwSwJHDD5mD/wLBGl3p4= github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI= github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08= github.com/ugorji/go/codec v1.2.12 h1:9LC83zGrHhuUA9l16C9AHXAqEV/2wBQ4nkvumAE65EE= diff --git a/pkg/doc.go b/pkg/doc.go new file mode 100644 index 0000000..b6af485 --- /dev/null +++ b/pkg/doc.go @@ -0,0 +1,15 @@ +package pkg + +type Torrent interface { + Name() string + Progress() int + Stop() error + Start() error + Remove() error + Save() string +} + + +type Storage interface { + +} \ No newline at end of file diff --git a/pkg/storage/local.go b/pkg/storage/local.go new file mode 100644 index 0000000..a238d63 --- /dev/null +++ b/pkg/storage/local.go @@ -0,0 +1,59 @@ +package storage + +import ( + "io" + "io/fs" + "os" + "path/filepath" + + "github.com/pkg/errors" +) + +type Storage interface { + Move(src, dest string) error + ReadDir(dir string) ([]FileInfo, error) +} + +func NewLocalStorage(dir string) *LocalStorage { + return &LocalStorage{dir: dir} +} + +type LocalStorage struct { + dir string +} + +func (l *LocalStorage) Move(src, dest string) error { + targetDir := filepath.Join(l.dir, dest) + err := filepath.Walk(src, func(path string, info fs.FileInfo, err error) error { + destName := filepath.Join(targetDir, info.Name()) + srcName := filepath.Join(src, info.Name()) + if info.IsDir() { + + if err := os.Mkdir(destName, 0666); err != nil { + return errors.Wrapf(err, "mkdir %v", destName) + } + + } else { //is file + if writer, err := os.Create(destName); err != nil { + return errors.Wrapf(err, "create file %s", destName) + } else { + defer writer.Close() + if f, err := os.OpenFile(srcName, os.O_RDONLY, 0666); err != nil { + return errors.Wrapf(err, "read file %v", srcName) + } else { //open success + defer f.Close() + _, err := io.Copy(writer, f) + if err != nil { + return errors.Wrap(err, "transmitting data error") + } + } + } + } + return nil + }) + if err != nil { + return errors.Wrap(err, "move file error") + } + return os.RemoveAll(src) + +} diff --git a/pkg/storage/webdav.go b/pkg/storage/webdav.go new file mode 100644 index 0000000..ad25c83 --- /dev/null +++ b/pkg/storage/webdav.go @@ -0,0 +1,98 @@ +package storage + +import ( + "context" + "io" + "io/fs" + "net/http" + "os" + "path/filepath" + "polaris/log" + "time" + + "github.com/emersion/go-webdav" + "github.com/pkg/errors" +) +type FileInfo struct { + Path string + Size int64 + ModTime time.Time + IsDir bool + MIMEType string + ETag string +} + + +type WebdavStorage struct { + fs *webdav.Client +} + +func NewWebdavStorage(url, user, password string) (*WebdavStorage, error) { + c, err := webdav.NewClient(webdav.HTTPClientWithBasicAuth(http.DefaultClient, user, password), url) + if err != nil { + return nil, errors.Wrap(err, "new webdav") + } + fs, _ := c.ReadDir(context.TODO(), "./", false) + for _, f := range fs { + log.Infof("file: %v", f) + } + return &WebdavStorage{ + fs: c, + }, nil +} + + +func (w *WebdavStorage) Move(local, remote string) error { + + err := filepath.Walk(local, func(path string, info fs.FileInfo, err error) error { + name := filepath.Join(remote, info.Name()) + if info.IsDir() { + + if err := w.fs.Mkdir(context.TODO(), name); err != nil { + return errors.Wrapf(err, "mkdir %v", name) + } + + } else {//is file + if writer, err := w.fs.Create(context.TODO(), name); err != nil { + return errors.Wrapf(err, "create file %s", name) + } else { + defer writer.Close() + if f, err := os.OpenFile(name, os.O_RDONLY, 0666); err != nil { + return errors.Wrapf(err, "read file %v", name) + } else { //open success + defer f.Close() + _, err := io.Copy(writer, f) + if err != nil { + return errors.Wrap(err, "transmitting data error") + } + } + } + } + return nil + }) + if err != nil { + return errors.Wrap(err, "move file error") + } + return os.RemoveAll(local) +} + +func (w *WebdavStorage) ReadDir(dir string) ([]FileInfo,error) { + fi, err := w.fs.ReadDir(context.TODO(), dir, false) + if err != nil { + return nil, err + } + var res []FileInfo = make([]FileInfo, 0, len(fi)) + for _, f := range fi { + res = append(res, FileInfo{ + Path: f.Path, + Size : f.Size, + ModTime : f.ModTime, + IsDir : f.IsDir, + MIMEType : f.MIMEType, + ETag : f.ETag, + + }) + } + return res, nil +} + diff --git a/pkg/tmdb/tmdb.go b/pkg/tmdb/tmdb.go index 0fcb94d..479d30f 100644 --- a/pkg/tmdb/tmdb.go +++ b/pkg/tmdb/tmdb.go @@ -48,6 +48,10 @@ func (c *Client) GetSeasonDetails(id, seasonNumber int, language string) (*tmdb. return c.tmdbClient.GetTVSeasonDetails(id, seasonNumber, withLangOption(language)) } +func (c *Client) GetTVAlternativeTitles(id int, language string) (*tmdb.TVAlternativeTitles, error) { + return c.tmdbClient.GetTVAlternativeTitles(id, withLangOption(language)) +} + func wrapLanguage(lang string) string { if lang == "" { lang = "zh-CN" diff --git a/pkg/transmission/transmission.go b/pkg/transmission/transmission.go index 3fa0ecf..aa5c156 100644 --- a/pkg/transmission/transmission.go +++ b/pkg/transmission/transmission.go @@ -2,6 +2,8 @@ package transmission import ( "net/url" + "strconv" + "github.com/hekmon/transmissionrpc" "github.com/pkg/errors" ) @@ -22,7 +24,48 @@ type Client struct { c *transmissionrpc.Client } -func (c *Client) Download(magnet string) (*transmissionrpc.Torrent, error) { - t, err := c.c.TorrentAdd(&transmissionrpc.TorrentAddPayload{Filename: &magnet}) - return t, err +func (c *Client) Download(magnet, dir string) (*Torrent, error) { + t, err := c.c.TorrentAdd(&transmissionrpc.TorrentAddPayload{ + Filename: &magnet, + DownloadDir: &dir, + }) + return &Torrent{ + t: t, + c: c.c, + }, err } + +type Torrent struct { + t *transmissionrpc.Torrent + c *transmissionrpc.Client +} + +func (t *Torrent) Name() string { + return *t.t.Name +} + +func (t *Torrent) Progress() int { + if *t.t.IsFinished { + return 100 + } + return int(*t.t.PercentDone*100) +} + +func (t *Torrent) Stop() error { + return t.c.TorrentStopIDs([]int64{*t.t.ID}) +} + +func (t *Torrent) Start() error { + return t.c.TorrentStartIDs([]int64{*t.t.ID}) +} + +func (t *Torrent) Remove() error { + return t.c.TorrentRemove(&transmissionrpc.TorrentRemovePayload{ + IDs: []int64{*t.t.ID}, + DeleteLocalData: true, + }) +} + +func (t *Torrent) Save() string { + return strconv.Itoa(int(*t.t.ID)) +} \ No newline at end of file diff --git a/server/resources.go b/server/resources.go index 118f809..1623296 100644 --- a/server/resources.go +++ b/server/resources.go @@ -3,10 +3,12 @@ package server import ( "fmt" "polaris/db" + "polaris/ent" "polaris/log" "polaris/pkg/torznab" "polaris/pkg/transmission" "strconv" + "strings" "github.com/gin-gonic/gin" "github.com/pkg/errors" @@ -88,6 +90,15 @@ func (s *Server) SearchAndDownload(c *gin.Context) (interface{}, error) { if series == nil { return nil, fmt.Errorf("no tv series of id %v", in.ID) } + var ep *ent.Episode + for _, e := range series.Episodes { + if e.SeasonNumber == in.Season && e.EpisodeNumber == in.Episode { + ep = e + } + } + if ep == nil { + return nil, errors.Errorf("no episode of season %d episode %d", in.Season, in.Episode) + } res := s.searchTvWithTorznab(series.OriginalName, in.Season, in.Episode) if len(res) == 0 { @@ -95,11 +106,33 @@ func (s *Server) SearchAndDownload(c *gin.Context) (interface{}, error) { } r1 := res[0] log.Infof("found resource to download: %v", r1) - torrent, err := trc.Download(r1.Magnet) + torrent, err := trc.Download(r1.Magnet, s.db.GetDownloadDir()) if err != nil { return nil, errors.Wrap(err, "downloading") } - s.tasks[r1.Name] = torrent + torrent.Start() + + var name = series.NameEn + if name == "" { + name = series.OriginalName + } + var year = strings.Split(series.AirDate, "-")[0] + + dir := fmt.Sprintf("%s (%s)/Season %02d", name, year, ep.SeasonNumber) + + history, err :=s.db.SaveHistoryRecord(ent.History{ + SeriesID: ep.SeriesID, + EpisodeID: ep.ID, + SourceTitle: r1.Name, + TargetDir: dir, + Completed: false, + Saved: torrent.Save(), + }) + if err != nil { + return nil, errors.Wrap(err, "save record") + } + s.tasks[history.ID] = torrent + // t, err := downloader.DownloadByMagnet(r1.Magnet, "~") // if err != nil { // return nil, errors.Wrap(err, "download torrent") diff --git a/server/scheduler.go b/server/scheduler.go new file mode 100644 index 0000000..8fcde28 --- /dev/null +++ b/server/scheduler.go @@ -0,0 +1,49 @@ +package server + +import ( + "path/filepath" + "polaris/db" + "polaris/log" + "polaris/pkg/storage" + + "github.com/pkg/errors" +) + +func (s *Server) scheduler() { + s.cron.AddFunc("@every 1m", s.checkTasks) +} + +func (s *Server) checkTasks() { + for id, t := range s.tasks { + log.Infof("task %s percentage done: %d%%", t.Name(), t.Progress()) + if t.Progress() == 100 { + log.Infof("task is done: %v", t.Name()) + s.moveCompletedTask(id) + } + } +} + +func (s *Server) moveCompletedTask(id int) error { + torrent := s.tasks[id] + r := s.db.GetHistory(id) + series := s.db.GetSeriesDetails(r.SeriesID) + st := s.db.GetStorage(series.StorageID) + if st.Implementation == db.ImplWebdav { + storageImpl, err := storage.NewWebdavStorage(st.Path, st.User, st.Password) + if err != nil { + return errors.Wrap(err, "new webdav") + } + if err := storageImpl.Move(filepath.Join(s.db.GetDownloadDir(), torrent.Name()), r.TargetDir); err != nil { + return errors.Wrap(err, "move webdav") + } + } else if st.Implementation == db.ImplLocal { + storageImpl := storage.NewLocalStorage(st.Path) + + if err := storageImpl.Move(filepath.Join(s.db.GetDownloadDir(), torrent.Name()), r.TargetDir); err != nil { + return errors.Wrap(err, "move webdav") + } + + } + log.Infof("move downloaded files to target dir success, file: %v, target dir: %v", torrent.Name(), r.TargetDir) + return nil +} diff --git a/server/server.go b/server/server.go index 3ab000d..ae5a236 100644 --- a/server/server.go +++ b/server/server.go @@ -3,11 +3,11 @@ package server import ( "polaris/db" "polaris/log" + "polaris/pkg" "polaris/pkg/tmdb" "polaris/ui" "github.com/gin-contrib/static" - "github.com/hekmon/transmissionrpc" "github.com/robfig/cron" "github.com/gin-gonic/gin" @@ -20,7 +20,7 @@ func NewServer(db *db.Client) *Server { r: r, db: db, cron: cron.New(), - tasks: make(map[string]*transmissionrpc.Torrent), + tasks: make(map[int]pkg.Torrent), } } @@ -29,18 +29,9 @@ type Server struct { db *db.Client cron *cron.Cron language string - tasks map[string]*transmissionrpc.Torrent + tasks map[int]pkg.Torrent } -func (s *Server) scheduler() { - s.cron.AddFunc("@every 1m", s.checkTasks) -} - -func (s *Server) checkTasks() { - for name, t := range s.tasks { - log.Infof("task %s percentage done: %f", name, *t.PercentDone) - } -} func (s *Server) Serve() error { s.scheduler() @@ -76,6 +67,12 @@ func (s *Server) Serve() error { downloader.POST("/add", HttpHandler(s.AddDownloadClient)) downloader.DELETE("/del/:id", HttpHandler(s.DeleteDownloadCLient)) } + storage := api.Group("/storage") + { + storage.GET("/", HttpHandler(s.GetAllStorage)) + storage.POST("/", HttpHandler(s.AddStorage)) + storage.DELETE("/:id", HttpHandler(s.DeleteStorage)) + } s.language = s.db.GetLanguage() return s.r.Run(":8080") diff --git a/server/storage.go b/server/storage.go new file mode 100644 index 0000000..b7a72a5 --- /dev/null +++ b/server/storage.go @@ -0,0 +1,37 @@ +package server + +import ( + "fmt" + "polaris/db" + "polaris/log" + "strconv" + + "github.com/gin-gonic/gin" + "github.com/pkg/errors" +) + +func (s *Server) GetAllStorage(c *gin.Context) (interface{}, error) { + data := s.db.GetAllStorage() + return data, nil +} + +func (s *Server) AddStorage(c *gin.Context) (interface{}, error) { + var in db.StorageInfo + if err := c.ShouldBindJSON(&in); err != nil { + return nil, errors.Wrap(err, "bind json") + } + + log.Infof("received add storage input: %v", in) + err := s.db.AddStorage(in) + return nil, err +} + +func (s *Server) DeleteStorage(c *gin.Context) (interface{}, error) { + ids := c.Param("id") + id, err := strconv.Atoi(ids) + if err != nil { + return nil, fmt.Errorf("id is not int: %v", ids) + } + err = s.db.DeleteStorage(id) + return nil, err +} diff --git a/server/watchlist.go b/server/watchlist.go index 79b5c34..6da2c98 100644 --- a/server/watchlist.go +++ b/server/watchlist.go @@ -1,6 +1,7 @@ package server import ( + "polaris/db" "polaris/ent" "polaris/log" "strconv" @@ -27,8 +28,8 @@ func (s *Server) SearchTvSeries(c *gin.Context) (interface{}, error) { } type addWatchlistIn struct { - ID int `json:"id" binding:"required"` - RootFolder string `json:"folder" binding:"required"` + TmdbID int `json:"id" binding:"required"` + StorageID int `json:"folder"` } func (s *Server) AddWatchlist(c *gin.Context) (interface{}, error) { @@ -36,11 +37,22 @@ func (s *Server) AddWatchlist(c *gin.Context) (interface{}, error) { if err := c.ShouldBindJSON(&in); err != nil { return nil, errors.Wrap(err, "bind query") } - detail, err := s.MustTMDB().GetTvDetails(in.ID, s.language) + detail, err := s.MustTMDB().GetTvDetails(in.TmdbID, s.language) if err != nil { return nil, errors.Wrap(err, "get tv detail") } - log.Infof("find detail for tv id %d: %v", in.ID, detail) + log.Infof("find detail for tv id %d: %v", in.TmdbID, detail) + var nameEn = detail.OriginalName + alterTitles, err := s.MustTMDB().GetTVAlternativeTitles(in.TmdbID, s.language) + if err == nil { + for _, r := range alterTitles.Results { + if r.Iso3166_1 == "US" { + log.Infof("found en name: %s", r.Title) + nameEn = r.Title + } + } + } + var epIds []int @@ -66,7 +78,7 @@ func (s *Server) AddWatchlist(c *gin.Context) (interface{}, error) { epIds = append(epIds, epid) } } - _, err = s.db.AddWatchlist(in.RootFolder, detail, epIds) + _, err = s.db.AddWatchlist(in.StorageID, nameEn, detail, epIds, db.R1080p) if err != nil { return nil, errors.Wrap(err, "add to list") } diff --git a/ui/lib/system_settings.dart b/ui/lib/system_settings.dart index 0749660..a4705b0 100644 --- a/ui/lib/system_settings.dart +++ b/ui/lib/system_settings.dart @@ -4,7 +4,7 @@ import 'package:ui/providers/settings.dart'; import 'package:ui/utils.dart'; class SystemSettingsPage extends ConsumerStatefulWidget { - static const route = "/systemsettings"; + static const route = "/settings"; const SystemSettingsPage({super.key}); @override