ent

package

Go to main page

Versions in this module

v1

v1.4.3

Sep 30, 2023

Changes in this version

type Vod

+ LocalViews int

type VodCreate

+ func (vc *VodCreate) SetLocalViews(i int) *VodCreate

+ func (vc *VodCreate) SetNillableLocalViews(i *int) *VodCreate

type VodMutation

+ func (m *VodMutation) AddLocalViews(i int)

+ func (m *VodMutation) AddedLocalViews() (r int, exists bool)

+ func (m *VodMutation) LocalViews() (r int, exists bool)

+ func (m *VodMutation) OldLocalViews(ctx context.Context) (v int, err error)

+ func (m *VodMutation) ResetLocalViews()

+ func (m *VodMutation) SetLocalViews(i int)

type VodUpdate

+ func (vu *VodUpdate) AddLocalViews(i int) *VodUpdate

+ func (vu *VodUpdate) SetLocalViews(i int) *VodUpdate

+ func (vu *VodUpdate) SetNillableLocalViews(i *int) *VodUpdate

type VodUpdateOne

+ func (vuo *VodUpdateOne) AddLocalViews(i int) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetLocalViews(i int) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetNillableLocalViews(i *int) *VodUpdateOne

type VodUpsert

+ func (u *VodUpsert) AddLocalViews(v int) *VodUpsert

+ func (u *VodUpsert) SetLocalViews(v int) *VodUpsert

+ func (u *VodUpsert) UpdateLocalViews() *VodUpsert

type VodUpsertBulk

+ func (u *VodUpsertBulk) AddLocalViews(v int) *VodUpsertBulk

+ func (u *VodUpsertBulk) SetLocalViews(v int) *VodUpsertBulk

+ func (u *VodUpsertBulk) UpdateLocalViews() *VodUpsertBulk

type VodUpsertOne

+ func (u *VodUpsertOne) AddLocalViews(v int) *VodUpsertOne

+ func (u *VodUpsertOne) SetLocalViews(v int) *VodUpsertOne

+ func (u *VodUpsertOne) UpdateLocalViews() *VodUpsertOne

v1.4.2

Sep 10, 2023

v1.4.1

Aug 13, 2023

v1.4.0

Jul 22, 2023

v1.3.2

Jul 1, 2023

v1.3.1

Jun 1, 2023

v1.3.0

May 30, 2023

v1.2.14

May 6, 2023

v1.2.13

May 5, 2023

v1.2.12

Apr 30, 2023

Changes in this version

type Channel

+ Retention bool

+ RetentionDays int64

+ func (c *Channel) Value(name string) (ent.Value, error)

type ChannelCreate

+ func (cc *ChannelCreate) SetNillableRetention(b *bool) *ChannelCreate

+ func (cc *ChannelCreate) SetNillableRetentionDays(i *int64) *ChannelCreate

+ func (cc *ChannelCreate) SetRetention(b bool) *ChannelCreate

+ func (cc *ChannelCreate) SetRetentionDays(i int64) *ChannelCreate

type ChannelMutation

+ func (m *ChannelMutation) AddRetentionDays(i int64)

+ func (m *ChannelMutation) AddedRetentionDays() (r int64, exists bool)

+ func (m *ChannelMutation) ClearRetentionDays()

+ func (m *ChannelMutation) OldRetention(ctx context.Context) (v bool, err error)

+ func (m *ChannelMutation) OldRetentionDays(ctx context.Context) (v int64, err error)

+ func (m *ChannelMutation) ResetRetention()

+ func (m *ChannelMutation) ResetRetentionDays()

+ func (m *ChannelMutation) Retention() (r bool, exists bool)

+ func (m *ChannelMutation) RetentionDays() (r int64, exists bool)

+ func (m *ChannelMutation) RetentionDaysCleared() bool

+ func (m *ChannelMutation) SetRetention(b bool)

+ func (m *ChannelMutation) SetRetentionDays(i int64)

type ChannelUpdate

+ func (cu *ChannelUpdate) AddRetentionDays(i int64) *ChannelUpdate

+ func (cu *ChannelUpdate) ClearRetentionDays() *ChannelUpdate

+ func (cu *ChannelUpdate) SetNillableRetention(b *bool) *ChannelUpdate

+ func (cu *ChannelUpdate) SetNillableRetentionDays(i *int64) *ChannelUpdate

+ func (cu *ChannelUpdate) SetRetention(b bool) *ChannelUpdate

+ func (cu *ChannelUpdate) SetRetentionDays(i int64) *ChannelUpdate

type ChannelUpdateOne

+ func (cuo *ChannelUpdateOne) AddRetentionDays(i int64) *ChannelUpdateOne

+ func (cuo *ChannelUpdateOne) ClearRetentionDays() *ChannelUpdateOne

+ func (cuo *ChannelUpdateOne) SetNillableRetention(b *bool) *ChannelUpdateOne

+ func (cuo *ChannelUpdateOne) SetNillableRetentionDays(i *int64) *ChannelUpdateOne

+ func (cuo *ChannelUpdateOne) SetRetention(b bool) *ChannelUpdateOne

+ func (cuo *ChannelUpdateOne) SetRetentionDays(i int64) *ChannelUpdateOne

type ChannelUpsert

+ func (u *ChannelUpsert) AddRetentionDays(v int64) *ChannelUpsert

+ func (u *ChannelUpsert) ClearRetentionDays() *ChannelUpsert

+ func (u *ChannelUpsert) SetRetention(v bool) *ChannelUpsert

+ func (u *ChannelUpsert) SetRetentionDays(v int64) *ChannelUpsert

+ func (u *ChannelUpsert) UpdateRetention() *ChannelUpsert

+ func (u *ChannelUpsert) UpdateRetentionDays() *ChannelUpsert

type ChannelUpsertBulk

+ func (u *ChannelUpsertBulk) AddRetentionDays(v int64) *ChannelUpsertBulk

+ func (u *ChannelUpsertBulk) ClearRetentionDays() *ChannelUpsertBulk

+ func (u *ChannelUpsertBulk) SetRetention(v bool) *ChannelUpsertBulk

+ func (u *ChannelUpsertBulk) SetRetentionDays(v int64) *ChannelUpsertBulk

+ func (u *ChannelUpsertBulk) UpdateRetention() *ChannelUpsertBulk

+ func (u *ChannelUpsertBulk) UpdateRetentionDays() *ChannelUpsertBulk

type ChannelUpsertOne

+ func (u *ChannelUpsertOne) AddRetentionDays(v int64) *ChannelUpsertOne

+ func (u *ChannelUpsertOne) ClearRetentionDays() *ChannelUpsertOne

+ func (u *ChannelUpsertOne) SetRetention(v bool) *ChannelUpsertOne

+ func (u *ChannelUpsertOne) SetRetentionDays(v int64) *ChannelUpsertOne

+ func (u *ChannelUpsertOne) UpdateRetention() *ChannelUpsertOne

+ func (u *ChannelUpsertOne) UpdateRetentionDays() *ChannelUpsertOne

type Live

+ func (l *Live) Value(name string) (ent.Value, error)

type LiveCategory

+ func (lc *LiveCategory) Value(name string) (ent.Value, error)

type Playback

+ func (pl *Playback) Value(name string) (ent.Value, error)

type Playlist

+ func (pl *Playlist) Value(name string) (ent.Value, error)

type Queue

+ func (q *Queue) Value(name string) (ent.Value, error)

type TwitchCategory

+ func (tc *TwitchCategory) Value(name string) (ent.Value, error)

type User

+ func (u *User) Value(name string) (ent.Value, error)

type Vod

+ Locked bool

+ func (v *Vod) Value(name string) (ent.Value, error)

type VodCreate

+ func (vc *VodCreate) SetLocked(b bool) *VodCreate

+ func (vc *VodCreate) SetNillableLocked(b *bool) *VodCreate

type VodMutation

+ func (m *VodMutation) Locked() (r bool, exists bool)

+ func (m *VodMutation) OldLocked(ctx context.Context) (v bool, err error)

+ func (m *VodMutation) ResetLocked()

+ func (m *VodMutation) SetLocked(b bool)

type VodUpdate

+ func (vu *VodUpdate) SetLocked(b bool) *VodUpdate

+ func (vu *VodUpdate) SetNillableLocked(b *bool) *VodUpdate

type VodUpdateOne

+ func (vuo *VodUpdateOne) SetLocked(b bool) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetNillableLocked(b *bool) *VodUpdateOne

type VodUpsert

+ func (u *VodUpsert) SetLocked(v bool) *VodUpsert

+ func (u *VodUpsert) UpdateLocked() *VodUpsert

type VodUpsertBulk

+ func (u *VodUpsertBulk) SetLocked(v bool) *VodUpsertBulk

+ func (u *VodUpsertBulk) UpdateLocked() *VodUpsertBulk

type VodUpsertOne

+ func (u *VodUpsertOne) SetLocked(v bool) *VodUpsertOne

+ func (u *VodUpsertOne) UpdateLocked() *VodUpsertOne

v1.2.11

Apr 5, 2023

v1.2.10

Apr 4, 2023

v1.2.9

Apr 3, 2023

v1.2.8

Apr 1, 2023

v1.2.7

Mar 19, 2023

v1.2.6

Mar 12, 2023

v1.2.5

Feb 26, 2023

v1.2.4

Feb 22, 2023

Changes in this version

+ const TypeLiveCategory

+ const TypeTwitchCategory

type ChannelDeleteOne

+ func (cdo *ChannelDeleteOne) Where(ps ...predicate.Channel) *ChannelDeleteOne

type ChannelUpdateOne

+ func (cuo *ChannelUpdateOne) Where(ps ...predicate.Channel) *ChannelUpdateOne

type ChannelUpsert

+ func (u *ChannelUpsert) ClearExtID() *ChannelUpsert

+ func (u *ChannelUpsert) SetExtID(v string) *ChannelUpsert

+ func (u *ChannelUpsert) UpdateExtID() *ChannelUpsert

type ChannelUpsertBulk

+ func (u *ChannelUpsertBulk) ClearExtID() *ChannelUpsertBulk

+ func (u *ChannelUpsertBulk) SetExtID(v string) *ChannelUpsertBulk

+ func (u *ChannelUpsertBulk) UpdateExtID() *ChannelUpsertBulk

type ChannelUpsertOne

+ func (u *ChannelUpsertOne) ClearExtID() *ChannelUpsertOne

+ func (u *ChannelUpsertOne) SetExtID(v string) *ChannelUpsertOne

+ func (u *ChannelUpsertOne) UpdateExtID() *ChannelUpsertOne

type Client

+ LiveCategory *LiveCategoryClient

+ TwitchCategory *TwitchCategoryClient

type Live

+ func (l *Live) QueryCategories() *LiveCategoryQuery

+ type LiveCategories []*LiveCategory

+ type LiveCategory struct

+ Edges LiveCategoryEdges

+ ID uuid.UUID

+ Name string

+ func (lc *LiveCategory) QueryLive() *LiveQuery

+ func (lc *LiveCategory) String() string

+ func (lc *LiveCategory) Unwrap() *LiveCategory

+ func (lc *LiveCategory) Update() *LiveCategoryUpdateOne

+ type LiveCategoryClient struct

+ func NewLiveCategoryClient(c config) *LiveCategoryClient

+ func (c *LiveCategoryClient) Create() *LiveCategoryCreate

+ func (c *LiveCategoryClient) CreateBulk(builders ...*LiveCategoryCreate) *LiveCategoryCreateBulk

+ func (c *LiveCategoryClient) Delete() *LiveCategoryDelete

+ func (c *LiveCategoryClient) DeleteOne(lc *LiveCategory) *LiveCategoryDeleteOne

+ func (c *LiveCategoryClient) DeleteOneID(id uuid.UUID) *LiveCategoryDeleteOne

+ func (c *LiveCategoryClient) Get(ctx context.Context, id uuid.UUID) (*LiveCategory, error)

+ func (c *LiveCategoryClient) GetX(ctx context.Context, id uuid.UUID) *LiveCategory

+ func (c *LiveCategoryClient) Hooks() []Hook

+ func (c *LiveCategoryClient) Intercept(interceptors ...Interceptor)

+ func (c *LiveCategoryClient) Interceptors() []Interceptor

+ func (c *LiveCategoryClient) Query() *LiveCategoryQuery

+ func (c *LiveCategoryClient) QueryLive(lc *LiveCategory) *LiveQuery

+ func (c *LiveCategoryClient) Update() *LiveCategoryUpdate

+ func (c *LiveCategoryClient) UpdateOne(lc *LiveCategory) *LiveCategoryUpdateOne

+ func (c *LiveCategoryClient) UpdateOneID(id uuid.UUID) *LiveCategoryUpdateOne

+ func (c *LiveCategoryClient) Use(hooks ...Hook)

+ type LiveCategoryCreate struct

+ func (lcc *LiveCategoryCreate) Exec(ctx context.Context) error

+ func (lcc *LiveCategoryCreate) ExecX(ctx context.Context)

+ func (lcc *LiveCategoryCreate) Mutation() *LiveCategoryMutation

+ func (lcc *LiveCategoryCreate) OnConflict(opts ...sql.ConflictOption) *LiveCategoryUpsertOne

+ func (lcc *LiveCategoryCreate) OnConflictColumns(columns ...string) *LiveCategoryUpsertOne

+ func (lcc *LiveCategoryCreate) Save(ctx context.Context) (*LiveCategory, error)

+ func (lcc *LiveCategoryCreate) SaveX(ctx context.Context) *LiveCategory

+ func (lcc *LiveCategoryCreate) SetID(u uuid.UUID) *LiveCategoryCreate

+ func (lcc *LiveCategoryCreate) SetLive(l *Live) *LiveCategoryCreate

+ func (lcc *LiveCategoryCreate) SetLiveID(id uuid.UUID) *LiveCategoryCreate

+ func (lcc *LiveCategoryCreate) SetName(s string) *LiveCategoryCreate

+ func (lcc *LiveCategoryCreate) SetNillableID(u *uuid.UUID) *LiveCategoryCreate

+ type LiveCategoryCreateBulk struct

+ func (lccb *LiveCategoryCreateBulk) Exec(ctx context.Context) error

+ func (lccb *LiveCategoryCreateBulk) ExecX(ctx context.Context)

+ func (lccb *LiveCategoryCreateBulk) OnConflict(opts ...sql.ConflictOption) *LiveCategoryUpsertBulk

+ func (lccb *LiveCategoryCreateBulk) OnConflictColumns(columns ...string) *LiveCategoryUpsertBulk

+ func (lccb *LiveCategoryCreateBulk) Save(ctx context.Context) ([]*LiveCategory, error)

+ func (lccb *LiveCategoryCreateBulk) SaveX(ctx context.Context) []*LiveCategory

+ type LiveCategoryDelete struct

+ func (lcd *LiveCategoryDelete) Exec(ctx context.Context) (int, error)

+ func (lcd *LiveCategoryDelete) ExecX(ctx context.Context) int

+ func (lcd *LiveCategoryDelete) Where(ps ...predicate.LiveCategory) *LiveCategoryDelete

+ type LiveCategoryDeleteOne struct

+ func (lcdo *LiveCategoryDeleteOne) Exec(ctx context.Context) error

+ func (lcdo *LiveCategoryDeleteOne) ExecX(ctx context.Context)

+ func (lcdo *LiveCategoryDeleteOne) Where(ps ...predicate.LiveCategory) *LiveCategoryDeleteOne

+ type LiveCategoryEdges struct

+ Live *Live

+ func (e LiveCategoryEdges) LiveOrErr() (*Live, error)

+ type LiveCategoryGroupBy struct

+ func (lcgb *LiveCategoryGroupBy) Aggregate(fns ...AggregateFunc) *LiveCategoryGroupBy

+ func (lcgb *LiveCategoryGroupBy) Scan(ctx context.Context, v any) error

+ func (s *LiveCategoryGroupBy) Bool(ctx context.Context) (_ bool, err error)

+ func (s *LiveCategoryGroupBy) BoolX(ctx context.Context) bool

+ func (s *LiveCategoryGroupBy) Bools(ctx context.Context) ([]bool, error)

+ func (s *LiveCategoryGroupBy) BoolsX(ctx context.Context) []bool

+ func (s *LiveCategoryGroupBy) Float64(ctx context.Context) (_ float64, err error)

+ func (s *LiveCategoryGroupBy) Float64X(ctx context.Context) float64

+ func (s *LiveCategoryGroupBy) Float64s(ctx context.Context) ([]float64, error)

+ func (s *LiveCategoryGroupBy) Float64sX(ctx context.Context) []float64

+ func (s *LiveCategoryGroupBy) Int(ctx context.Context) (_ int, err error)

+ func (s *LiveCategoryGroupBy) IntX(ctx context.Context) int

+ func (s *LiveCategoryGroupBy) Ints(ctx context.Context) ([]int, error)

+ func (s *LiveCategoryGroupBy) IntsX(ctx context.Context) []int

+ func (s *LiveCategoryGroupBy) ScanX(ctx context.Context, v any)

+ func (s *LiveCategoryGroupBy) String(ctx context.Context) (_ string, err error)

+ func (s *LiveCategoryGroupBy) StringX(ctx context.Context) string

+ func (s *LiveCategoryGroupBy) Strings(ctx context.Context) ([]string, error)

+ func (s *LiveCategoryGroupBy) StringsX(ctx context.Context) []string

+ type LiveCategoryMutation struct

+ func (m *LiveCategoryMutation) AddField(name string, value ent.Value) error

+ func (m *LiveCategoryMutation) AddedEdges() []string

+ func (m *LiveCategoryMutation) AddedField(name string) (ent.Value, bool)

+ func (m *LiveCategoryMutation) AddedFields() []string

+ func (m *LiveCategoryMutation) AddedIDs(name string) []ent.Value

+ func (m *LiveCategoryMutation) ClearEdge(name string) error

+ func (m *LiveCategoryMutation) ClearField(name string) error

+ func (m *LiveCategoryMutation) ClearLive()

+ func (m *LiveCategoryMutation) ClearedEdges() []string

+ func (m *LiveCategoryMutation) ClearedFields() []string

+ func (m *LiveCategoryMutation) EdgeCleared(name string) bool

+ func (m *LiveCategoryMutation) Field(name string) (ent.Value, bool)

+ func (m *LiveCategoryMutation) FieldCleared(name string) bool

+ func (m *LiveCategoryMutation) Fields() []string

+ func (m *LiveCategoryMutation) ID() (id uuid.UUID, exists bool)

+ func (m *LiveCategoryMutation) IDs(ctx context.Context) ([]uuid.UUID, error)

+ func (m *LiveCategoryMutation) LiveCleared() bool

+ func (m *LiveCategoryMutation) LiveID() (id uuid.UUID, exists bool)

+ func (m *LiveCategoryMutation) LiveIDs() (ids []uuid.UUID)

+ func (m *LiveCategoryMutation) Name() (r string, exists bool)

+ func (m *LiveCategoryMutation) OldField(ctx context.Context, name string) (ent.Value, error)

+ func (m *LiveCategoryMutation) OldName(ctx context.Context) (v string, err error)

+ func (m *LiveCategoryMutation) Op() Op

+ func (m *LiveCategoryMutation) RemovedEdges() []string

+ func (m *LiveCategoryMutation) RemovedIDs(name string) []ent.Value

+ func (m *LiveCategoryMutation) ResetEdge(name string) error

+ func (m *LiveCategoryMutation) ResetField(name string) error

+ func (m *LiveCategoryMutation) ResetLive()

+ func (m *LiveCategoryMutation) ResetName()

+ func (m *LiveCategoryMutation) SetField(name string, value ent.Value) error

+ func (m *LiveCategoryMutation) SetID(id uuid.UUID)

+ func (m *LiveCategoryMutation) SetLiveID(id uuid.UUID)

+ func (m *LiveCategoryMutation) SetName(s string)

+ func (m *LiveCategoryMutation) SetOp(op Op)

+ func (m *LiveCategoryMutation) Type() string

+ func (m *LiveCategoryMutation) Where(ps ...predicate.LiveCategory)

+ func (m *LiveCategoryMutation) WhereP(ps ...func(*sql.Selector))

+ func (m LiveCategoryMutation) Client() *Client

+ func (m LiveCategoryMutation) Tx() (*Tx, error)

+ type LiveCategoryQuery struct

+ func (lcq *LiveCategoryQuery) Aggregate(fns ...AggregateFunc) *LiveCategorySelect

+ func (lcq *LiveCategoryQuery) All(ctx context.Context) ([]*LiveCategory, error)

+ func (lcq *LiveCategoryQuery) AllX(ctx context.Context) []*LiveCategory

+ func (lcq *LiveCategoryQuery) Clone() *LiveCategoryQuery

+ func (lcq *LiveCategoryQuery) Count(ctx context.Context) (int, error)

+ func (lcq *LiveCategoryQuery) CountX(ctx context.Context) int

+ func (lcq *LiveCategoryQuery) Exist(ctx context.Context) (bool, error)

+ func (lcq *LiveCategoryQuery) ExistX(ctx context.Context) bool

+ func (lcq *LiveCategoryQuery) First(ctx context.Context) (*LiveCategory, error)

+ func (lcq *LiveCategoryQuery) FirstID(ctx context.Context) (id uuid.UUID, err error)

+ func (lcq *LiveCategoryQuery) FirstIDX(ctx context.Context) uuid.UUID

+ func (lcq *LiveCategoryQuery) FirstX(ctx context.Context) *LiveCategory

+ func (lcq *LiveCategoryQuery) GroupBy(field string, fields ...string) *LiveCategoryGroupBy

+ func (lcq *LiveCategoryQuery) IDs(ctx context.Context) (ids []uuid.UUID, err error)

+ func (lcq *LiveCategoryQuery) IDsX(ctx context.Context) []uuid.UUID

+ func (lcq *LiveCategoryQuery) Limit(limit int) *LiveCategoryQuery

+ func (lcq *LiveCategoryQuery) Offset(offset int) *LiveCategoryQuery

+ func (lcq *LiveCategoryQuery) Only(ctx context.Context) (*LiveCategory, error)

+ func (lcq *LiveCategoryQuery) OnlyID(ctx context.Context) (id uuid.UUID, err error)

+ func (lcq *LiveCategoryQuery) OnlyIDX(ctx context.Context) uuid.UUID

+ func (lcq *LiveCategoryQuery) OnlyX(ctx context.Context) *LiveCategory

+ func (lcq *LiveCategoryQuery) Order(o ...OrderFunc) *LiveCategoryQuery

+ func (lcq *LiveCategoryQuery) QueryLive() *LiveQuery

+ func (lcq *LiveCategoryQuery) Select(fields ...string) *LiveCategorySelect

+ func (lcq *LiveCategoryQuery) Unique(unique bool) *LiveCategoryQuery

+ func (lcq *LiveCategoryQuery) Where(ps ...predicate.LiveCategory) *LiveCategoryQuery

+ func (lcq *LiveCategoryQuery) WithLive(opts ...func(*LiveQuery)) *LiveCategoryQuery

+ type LiveCategorySelect struct

+ func (lcs *LiveCategorySelect) Aggregate(fns ...AggregateFunc) *LiveCategorySelect

+ func (lcs *LiveCategorySelect) Scan(ctx context.Context, v any) error

+ func (s *LiveCategorySelect) Bool(ctx context.Context) (_ bool, err error)

+ func (s *LiveCategorySelect) BoolX(ctx context.Context) bool

+ func (s *LiveCategorySelect) Bools(ctx context.Context) ([]bool, error)

+ func (s *LiveCategorySelect) BoolsX(ctx context.Context) []bool

+ func (s *LiveCategorySelect) Float64(ctx context.Context) (_ float64, err error)

+ func (s *LiveCategorySelect) Float64X(ctx context.Context) float64

+ func (s *LiveCategorySelect) Float64s(ctx context.Context) ([]float64, error)

+ func (s *LiveCategorySelect) Float64sX(ctx context.Context) []float64

+ func (s *LiveCategorySelect) Int(ctx context.Context) (_ int, err error)

+ func (s *LiveCategorySelect) IntX(ctx context.Context) int

+ func (s *LiveCategorySelect) Ints(ctx context.Context) ([]int, error)

+ func (s *LiveCategorySelect) IntsX(ctx context.Context) []int

+ func (s *LiveCategorySelect) ScanX(ctx context.Context, v any)

+ func (s *LiveCategorySelect) String(ctx context.Context) (_ string, err error)

+ func (s *LiveCategorySelect) StringX(ctx context.Context) string

+ func (s *LiveCategorySelect) Strings(ctx context.Context) ([]string, error)

+ func (s *LiveCategorySelect) StringsX(ctx context.Context) []string

+ type LiveCategoryUpdate struct

+ func (lcu *LiveCategoryUpdate) ClearLive() *LiveCategoryUpdate

+ func (lcu *LiveCategoryUpdate) Exec(ctx context.Context) error

+ func (lcu *LiveCategoryUpdate) ExecX(ctx context.Context)

+ func (lcu *LiveCategoryUpdate) Mutation() *LiveCategoryMutation

+ func (lcu *LiveCategoryUpdate) Save(ctx context.Context) (int, error)

+ func (lcu *LiveCategoryUpdate) SaveX(ctx context.Context) int

+ func (lcu *LiveCategoryUpdate) SetLive(l *Live) *LiveCategoryUpdate

+ func (lcu *LiveCategoryUpdate) SetLiveID(id uuid.UUID) *LiveCategoryUpdate

+ func (lcu *LiveCategoryUpdate) SetName(s string) *LiveCategoryUpdate

+ func (lcu *LiveCategoryUpdate) Where(ps ...predicate.LiveCategory) *LiveCategoryUpdate

+ type LiveCategoryUpdateOne struct

+ func (lcuo *LiveCategoryUpdateOne) ClearLive() *LiveCategoryUpdateOne

+ func (lcuo *LiveCategoryUpdateOne) Exec(ctx context.Context) error

+ func (lcuo *LiveCategoryUpdateOne) ExecX(ctx context.Context)

+ func (lcuo *LiveCategoryUpdateOne) Mutation() *LiveCategoryMutation

+ func (lcuo *LiveCategoryUpdateOne) Save(ctx context.Context) (*LiveCategory, error)

+ func (lcuo *LiveCategoryUpdateOne) SaveX(ctx context.Context) *LiveCategory

+ func (lcuo *LiveCategoryUpdateOne) Select(field string, fields ...string) *LiveCategoryUpdateOne

+ func (lcuo *LiveCategoryUpdateOne) SetLive(l *Live) *LiveCategoryUpdateOne

+ func (lcuo *LiveCategoryUpdateOne) SetLiveID(id uuid.UUID) *LiveCategoryUpdateOne

+ func (lcuo *LiveCategoryUpdateOne) SetName(s string) *LiveCategoryUpdateOne

+ func (lcuo *LiveCategoryUpdateOne) Where(ps ...predicate.LiveCategory) *LiveCategoryUpdateOne

+ type LiveCategoryUpsert struct

+ func (u *LiveCategoryUpsert) SetName(v string) *LiveCategoryUpsert

+ func (u *LiveCategoryUpsert) UpdateName() *LiveCategoryUpsert

+ type LiveCategoryUpsertBulk struct

+ func (u *LiveCategoryUpsertBulk) DoNothing() *LiveCategoryUpsertBulk

+ func (u *LiveCategoryUpsertBulk) Exec(ctx context.Context) error

+ func (u *LiveCategoryUpsertBulk) ExecX(ctx context.Context)

+ func (u *LiveCategoryUpsertBulk) Ignore() *LiveCategoryUpsertBulk

+ func (u *LiveCategoryUpsertBulk) SetName(v string) *LiveCategoryUpsertBulk

+ func (u *LiveCategoryUpsertBulk) Update(set func(*LiveCategoryUpsert)) *LiveCategoryUpsertBulk

+ func (u *LiveCategoryUpsertBulk) UpdateName() *LiveCategoryUpsertBulk

+ func (u *LiveCategoryUpsertBulk) UpdateNewValues() *LiveCategoryUpsertBulk

+ type LiveCategoryUpsertOne struct

+ func (u *LiveCategoryUpsertOne) DoNothing() *LiveCategoryUpsertOne

+ func (u *LiveCategoryUpsertOne) Exec(ctx context.Context) error

+ func (u *LiveCategoryUpsertOne) ExecX(ctx context.Context)

+ func (u *LiveCategoryUpsertOne) ID(ctx context.Context) (id uuid.UUID, err error)

+ func (u *LiveCategoryUpsertOne) IDX(ctx context.Context) uuid.UUID

+ func (u *LiveCategoryUpsertOne) Ignore() *LiveCategoryUpsertOne

+ func (u *LiveCategoryUpsertOne) SetName(v string) *LiveCategoryUpsertOne

+ func (u *LiveCategoryUpsertOne) Update(set func(*LiveCategoryUpsert)) *LiveCategoryUpsertOne

+ func (u *LiveCategoryUpsertOne) UpdateName() *LiveCategoryUpsertOne

+ func (u *LiveCategoryUpsertOne) UpdateNewValues() *LiveCategoryUpsertOne

type LiveClient

+ func (c *LiveClient) QueryCategories(l *Live) *LiveCategoryQuery

type LiveCreate

+ func (lc *LiveCreate) AddCategories(l ...*LiveCategory) *LiveCreate

+ func (lc *LiveCreate) AddCategoryIDs(ids ...uuid.UUID) *LiveCreate

type LiveDeleteOne

+ func (ldo *LiveDeleteOne) Where(ps ...predicate.Live) *LiveDeleteOne

type LiveEdges

+ Categories []*LiveCategory

+ func (e LiveEdges) CategoriesOrErr() ([]*LiveCategory, error)

type LiveMutation

+ func (m *LiveMutation) AddCategoryIDs(ids ...uuid.UUID)

+ func (m *LiveMutation) CategoriesCleared() bool

+ func (m *LiveMutation) CategoriesIDs() (ids []uuid.UUID)

+ func (m *LiveMutation) ClearCategories()

+ func (m *LiveMutation) RemoveCategoryIDs(ids ...uuid.UUID)

+ func (m *LiveMutation) RemovedCategoriesIDs() (ids []uuid.UUID)

+ func (m *LiveMutation) ResetCategories()

type LiveQuery

+ func (lq *LiveQuery) QueryCategories() *LiveCategoryQuery

+ func (lq *LiveQuery) WithCategories(opts ...func(*LiveCategoryQuery)) *LiveQuery

type LiveUpdate

+ func (lu *LiveUpdate) AddCategories(l ...*LiveCategory) *LiveUpdate

+ func (lu *LiveUpdate) AddCategoryIDs(ids ...uuid.UUID) *LiveUpdate

+ func (lu *LiveUpdate) ClearCategories() *LiveUpdate

+ func (lu *LiveUpdate) RemoveCategories(l ...*LiveCategory) *LiveUpdate

+ func (lu *LiveUpdate) RemoveCategoryIDs(ids ...uuid.UUID) *LiveUpdate

type LiveUpdateOne

+ func (luo *LiveUpdateOne) AddCategories(l ...*LiveCategory) *LiveUpdateOne

+ func (luo *LiveUpdateOne) AddCategoryIDs(ids ...uuid.UUID) *LiveUpdateOne

+ func (luo *LiveUpdateOne) ClearCategories() *LiveUpdateOne

+ func (luo *LiveUpdateOne) RemoveCategories(l ...*LiveCategory) *LiveUpdateOne

+ func (luo *LiveUpdateOne) RemoveCategoryIDs(ids ...uuid.UUID) *LiveUpdateOne

+ func (luo *LiveUpdateOne) Where(ps ...predicate.Live) *LiveUpdateOne

type LiveUpsert

+ func (u *LiveUpsert) SetDownloadArchives(v bool) *LiveUpsert

+ func (u *LiveUpsert) SetDownloadHighlights(v bool) *LiveUpsert

+ func (u *LiveUpsert) SetDownloadSubOnly(v bool) *LiveUpsert

+ func (u *LiveUpsert) SetDownloadUploads(v bool) *LiveUpsert

+ func (u *LiveUpsert) SetRenderChat(v bool) *LiveUpsert

+ func (u *LiveUpsert) SetWatchLive(v bool) *LiveUpsert

+ func (u *LiveUpsert) SetWatchVod(v bool) *LiveUpsert

+ func (u *LiveUpsert) UpdateDownloadArchives() *LiveUpsert

+ func (u *LiveUpsert) UpdateDownloadHighlights() *LiveUpsert

+ func (u *LiveUpsert) UpdateDownloadSubOnly() *LiveUpsert

+ func (u *LiveUpsert) UpdateDownloadUploads() *LiveUpsert

+ func (u *LiveUpsert) UpdateRenderChat() *LiveUpsert

+ func (u *LiveUpsert) UpdateWatchLive() *LiveUpsert

+ func (u *LiveUpsert) UpdateWatchVod() *LiveUpsert

type LiveUpsertBulk

+ func (u *LiveUpsertBulk) SetDownloadArchives(v bool) *LiveUpsertBulk

+ func (u *LiveUpsertBulk) SetDownloadHighlights(v bool) *LiveUpsertBulk

+ func (u *LiveUpsertBulk) SetDownloadSubOnly(v bool) *LiveUpsertBulk

+ func (u *LiveUpsertBulk) SetDownloadUploads(v bool) *LiveUpsertBulk

+ func (u *LiveUpsertBulk) SetRenderChat(v bool) *LiveUpsertBulk

+ func (u *LiveUpsertBulk) SetWatchLive(v bool) *LiveUpsertBulk

+ func (u *LiveUpsertBulk) SetWatchVod(v bool) *LiveUpsertBulk

+ func (u *LiveUpsertBulk) UpdateDownloadArchives() *LiveUpsertBulk

+ func (u *LiveUpsertBulk) UpdateDownloadHighlights() *LiveUpsertBulk

+ func (u *LiveUpsertBulk) UpdateDownloadSubOnly() *LiveUpsertBulk

+ func (u *LiveUpsertBulk) UpdateDownloadUploads() *LiveUpsertBulk

+ func (u *LiveUpsertBulk) UpdateRenderChat() *LiveUpsertBulk

+ func (u *LiveUpsertBulk) UpdateWatchLive() *LiveUpsertBulk

+ func (u *LiveUpsertBulk) UpdateWatchVod() *LiveUpsertBulk

type LiveUpsertOne

+ func (u *LiveUpsertOne) SetDownloadArchives(v bool) *LiveUpsertOne

+ func (u *LiveUpsertOne) SetDownloadHighlights(v bool) *LiveUpsertOne

+ func (u *LiveUpsertOne) SetDownloadSubOnly(v bool) *LiveUpsertOne

+ func (u *LiveUpsertOne) SetDownloadUploads(v bool) *LiveUpsertOne

+ func (u *LiveUpsertOne) SetRenderChat(v bool) *LiveUpsertOne

+ func (u *LiveUpsertOne) SetWatchLive(v bool) *LiveUpsertOne

+ func (u *LiveUpsertOne) SetWatchVod(v bool) *LiveUpsertOne

+ func (u *LiveUpsertOne) UpdateDownloadArchives() *LiveUpsertOne

+ func (u *LiveUpsertOne) UpdateDownloadHighlights() *LiveUpsertOne

+ func (u *LiveUpsertOne) UpdateDownloadSubOnly() *LiveUpsertOne

+ func (u *LiveUpsertOne) UpdateDownloadUploads() *LiveUpsertOne

+ func (u *LiveUpsertOne) UpdateRenderChat() *LiveUpsertOne

+ func (u *LiveUpsertOne) UpdateWatchLive() *LiveUpsertOne

+ func (u *LiveUpsertOne) UpdateWatchVod() *LiveUpsertOne

type PlaybackDeleteOne

+ func (pdo *PlaybackDeleteOne) Where(ps ...predicate.Playback) *PlaybackDeleteOne

type PlaybackUpdateOne

+ func (puo *PlaybackUpdateOne) Where(ps ...predicate.Playback) *PlaybackUpdateOne

type PlaylistCreate

+ func (pc *PlaylistCreate) OnConflict(opts ...sql.ConflictOption) *PlaylistUpsertOne

+ func (pc *PlaylistCreate) OnConflictColumns(columns ...string) *PlaylistUpsertOne

type PlaylistCreateBulk

+ func (pcb *PlaylistCreateBulk) OnConflict(opts ...sql.ConflictOption) *PlaylistUpsertBulk

+ func (pcb *PlaylistCreateBulk) OnConflictColumns(columns ...string) *PlaylistUpsertBulk

type PlaylistDeleteOne

+ func (pdo *PlaylistDeleteOne) Where(ps ...predicate.Playlist) *PlaylistDeleteOne

type PlaylistUpdateOne

+ func (puo *PlaylistUpdateOne) Where(ps ...predicate.Playlist) *PlaylistUpdateOne

+ type PlaylistUpsert struct

+ func (u *PlaylistUpsert) ClearDescription() *PlaylistUpsert

+ func (u *PlaylistUpsert) ClearThumbnailPath() *PlaylistUpsert

+ func (u *PlaylistUpsert) SetDescription(v string) *PlaylistUpsert

+ func (u *PlaylistUpsert) SetName(v string) *PlaylistUpsert

+ func (u *PlaylistUpsert) SetThumbnailPath(v string) *PlaylistUpsert

+ func (u *PlaylistUpsert) SetUpdatedAt(v time.Time) *PlaylistUpsert

+ func (u *PlaylistUpsert) UpdateDescription() *PlaylistUpsert

+ func (u *PlaylistUpsert) UpdateName() *PlaylistUpsert

+ func (u *PlaylistUpsert) UpdateThumbnailPath() *PlaylistUpsert

+ func (u *PlaylistUpsert) UpdateUpdatedAt() *PlaylistUpsert

+ type PlaylistUpsertBulk struct

+ func (u *PlaylistUpsertBulk) ClearDescription() *PlaylistUpsertBulk

+ func (u *PlaylistUpsertBulk) ClearThumbnailPath() *PlaylistUpsertBulk

+ func (u *PlaylistUpsertBulk) DoNothing() *PlaylistUpsertBulk

+ func (u *PlaylistUpsertBulk) Exec(ctx context.Context) error

+ func (u *PlaylistUpsertBulk) ExecX(ctx context.Context)

+ func (u *PlaylistUpsertBulk) Ignore() *PlaylistUpsertBulk

+ func (u *PlaylistUpsertBulk) SetDescription(v string) *PlaylistUpsertBulk

+ func (u *PlaylistUpsertBulk) SetName(v string) *PlaylistUpsertBulk

+ func (u *PlaylistUpsertBulk) SetThumbnailPath(v string) *PlaylistUpsertBulk

+ func (u *PlaylistUpsertBulk) SetUpdatedAt(v time.Time) *PlaylistUpsertBulk

+ func (u *PlaylistUpsertBulk) Update(set func(*PlaylistUpsert)) *PlaylistUpsertBulk

+ func (u *PlaylistUpsertBulk) UpdateDescription() *PlaylistUpsertBulk

+ func (u *PlaylistUpsertBulk) UpdateName() *PlaylistUpsertBulk

+ func (u *PlaylistUpsertBulk) UpdateNewValues() *PlaylistUpsertBulk

+ func (u *PlaylistUpsertBulk) UpdateThumbnailPath() *PlaylistUpsertBulk

+ func (u *PlaylistUpsertBulk) UpdateUpdatedAt() *PlaylistUpsertBulk

+ type PlaylistUpsertOne struct

+ func (u *PlaylistUpsertOne) ClearDescription() *PlaylistUpsertOne

+ func (u *PlaylistUpsertOne) ClearThumbnailPath() *PlaylistUpsertOne

+ func (u *PlaylistUpsertOne) DoNothing() *PlaylistUpsertOne

+ func (u *PlaylistUpsertOne) Exec(ctx context.Context) error

+ func (u *PlaylistUpsertOne) ExecX(ctx context.Context)

+ func (u *PlaylistUpsertOne) ID(ctx context.Context) (id uuid.UUID, err error)

+ func (u *PlaylistUpsertOne) IDX(ctx context.Context) uuid.UUID

+ func (u *PlaylistUpsertOne) Ignore() *PlaylistUpsertOne

+ func (u *PlaylistUpsertOne) SetDescription(v string) *PlaylistUpsertOne

+ func (u *PlaylistUpsertOne) SetName(v string) *PlaylistUpsertOne

+ func (u *PlaylistUpsertOne) SetThumbnailPath(v string) *PlaylistUpsertOne

+ func (u *PlaylistUpsertOne) SetUpdatedAt(v time.Time) *PlaylistUpsertOne

+ func (u *PlaylistUpsertOne) Update(set func(*PlaylistUpsert)) *PlaylistUpsertOne

+ func (u *PlaylistUpsertOne) UpdateDescription() *PlaylistUpsertOne

+ func (u *PlaylistUpsertOne) UpdateName() *PlaylistUpsertOne

+ func (u *PlaylistUpsertOne) UpdateNewValues() *PlaylistUpsertOne

+ func (u *PlaylistUpsertOne) UpdateThumbnailPath() *PlaylistUpsertOne

+ func (u *PlaylistUpsertOne) UpdateUpdatedAt() *PlaylistUpsertOne

+ type QueryContext = ent.QueryContext

type QueueDeleteOne

+ func (qdo *QueueDeleteOne) Where(ps ...predicate.Queue) *QueueDeleteOne

type QueueUpdateOne

+ func (quo *QueueUpdateOne) Where(ps ...predicate.Queue) *QueueUpdateOne

type QueueUpsert

+ func (u *QueueUpsert) ClearRenderChat() *QueueUpsert

+ func (u *QueueUpsert) SetRenderChat(v bool) *QueueUpsert

+ func (u *QueueUpsert) UpdateRenderChat() *QueueUpsert

type QueueUpsertBulk

+ func (u *QueueUpsertBulk) ClearRenderChat() *QueueUpsertBulk

+ func (u *QueueUpsertBulk) SetRenderChat(v bool) *QueueUpsertBulk

+ func (u *QueueUpsertBulk) UpdateRenderChat() *QueueUpsertBulk

type QueueUpsertOne

+ func (u *QueueUpsertOne) ClearRenderChat() *QueueUpsertOne

+ func (u *QueueUpsertOne) SetRenderChat(v bool) *QueueUpsertOne

+ func (u *QueueUpsertOne) UpdateRenderChat() *QueueUpsertOne

+ type TwitchCategories []*TwitchCategory

+ type TwitchCategory struct

+ BoxArtURL string

+ CreatedAt time.Time

+ ID string

+ IgdbID string

+ Name string

+ UpdatedAt time.Time

+ func (tc *TwitchCategory) String() string

+ func (tc *TwitchCategory) Unwrap() *TwitchCategory

+ func (tc *TwitchCategory) Update() *TwitchCategoryUpdateOne

+ type TwitchCategoryClient struct

+ func NewTwitchCategoryClient(c config) *TwitchCategoryClient

+ func (c *TwitchCategoryClient) Create() *TwitchCategoryCreate

+ func (c *TwitchCategoryClient) CreateBulk(builders ...*TwitchCategoryCreate) *TwitchCategoryCreateBulk

+ func (c *TwitchCategoryClient) Delete() *TwitchCategoryDelete

+ func (c *TwitchCategoryClient) DeleteOne(tc *TwitchCategory) *TwitchCategoryDeleteOne

+ func (c *TwitchCategoryClient) DeleteOneID(id string) *TwitchCategoryDeleteOne

+ func (c *TwitchCategoryClient) Get(ctx context.Context, id string) (*TwitchCategory, error)

+ func (c *TwitchCategoryClient) GetX(ctx context.Context, id string) *TwitchCategory

+ func (c *TwitchCategoryClient) Hooks() []Hook

+ func (c *TwitchCategoryClient) Intercept(interceptors ...Interceptor)

+ func (c *TwitchCategoryClient) Interceptors() []Interceptor

+ func (c *TwitchCategoryClient) Query() *TwitchCategoryQuery

+ func (c *TwitchCategoryClient) Update() *TwitchCategoryUpdate

+ func (c *TwitchCategoryClient) UpdateOne(tc *TwitchCategory) *TwitchCategoryUpdateOne

+ func (c *TwitchCategoryClient) UpdateOneID(id string) *TwitchCategoryUpdateOne

+ func (c *TwitchCategoryClient) Use(hooks ...Hook)

+ type TwitchCategoryCreate struct

+ func (tcc *TwitchCategoryCreate) Exec(ctx context.Context) error

+ func (tcc *TwitchCategoryCreate) ExecX(ctx context.Context)

+ func (tcc *TwitchCategoryCreate) Mutation() *TwitchCategoryMutation

+ func (tcc *TwitchCategoryCreate) OnConflict(opts ...sql.ConflictOption) *TwitchCategoryUpsertOne

+ func (tcc *TwitchCategoryCreate) OnConflictColumns(columns ...string) *TwitchCategoryUpsertOne

+ func (tcc *TwitchCategoryCreate) Save(ctx context.Context) (*TwitchCategory, error)

+ func (tcc *TwitchCategoryCreate) SaveX(ctx context.Context) *TwitchCategory

+ func (tcc *TwitchCategoryCreate) SetBoxArtURL(s string) *TwitchCategoryCreate

+ func (tcc *TwitchCategoryCreate) SetCreatedAt(t time.Time) *TwitchCategoryCreate

+ func (tcc *TwitchCategoryCreate) SetID(s string) *TwitchCategoryCreate

+ func (tcc *TwitchCategoryCreate) SetIgdbID(s string) *TwitchCategoryCreate

+ func (tcc *TwitchCategoryCreate) SetName(s string) *TwitchCategoryCreate

+ func (tcc *TwitchCategoryCreate) SetNillableBoxArtURL(s *string) *TwitchCategoryCreate

+ func (tcc *TwitchCategoryCreate) SetNillableCreatedAt(t *time.Time) *TwitchCategoryCreate

+ func (tcc *TwitchCategoryCreate) SetNillableIgdbID(s *string) *TwitchCategoryCreate

+ func (tcc *TwitchCategoryCreate) SetNillableUpdatedAt(t *time.Time) *TwitchCategoryCreate

+ func (tcc *TwitchCategoryCreate) SetUpdatedAt(t time.Time) *TwitchCategoryCreate

+ type TwitchCategoryCreateBulk struct

+ func (tccb *TwitchCategoryCreateBulk) Exec(ctx context.Context) error

+ func (tccb *TwitchCategoryCreateBulk) ExecX(ctx context.Context)

+ func (tccb *TwitchCategoryCreateBulk) OnConflict(opts ...sql.ConflictOption) *TwitchCategoryUpsertBulk

+ func (tccb *TwitchCategoryCreateBulk) OnConflictColumns(columns ...string) *TwitchCategoryUpsertBulk

+ func (tccb *TwitchCategoryCreateBulk) Save(ctx context.Context) ([]*TwitchCategory, error)

+ func (tccb *TwitchCategoryCreateBulk) SaveX(ctx context.Context) []*TwitchCategory

+ type TwitchCategoryDelete struct

+ func (tcd *TwitchCategoryDelete) Exec(ctx context.Context) (int, error)

+ func (tcd *TwitchCategoryDelete) ExecX(ctx context.Context) int

+ func (tcd *TwitchCategoryDelete) Where(ps ...predicate.TwitchCategory) *TwitchCategoryDelete

+ type TwitchCategoryDeleteOne struct

+ func (tcdo *TwitchCategoryDeleteOne) Exec(ctx context.Context) error

+ func (tcdo *TwitchCategoryDeleteOne) ExecX(ctx context.Context)

+ func (tcdo *TwitchCategoryDeleteOne) Where(ps ...predicate.TwitchCategory) *TwitchCategoryDeleteOne

+ type TwitchCategoryGroupBy struct

+ func (s *TwitchCategoryGroupBy) Bool(ctx context.Context) (_ bool, err error)

+ func (s *TwitchCategoryGroupBy) BoolX(ctx context.Context) bool

+ func (s *TwitchCategoryGroupBy) Bools(ctx context.Context) ([]bool, error)

+ func (s *TwitchCategoryGroupBy) BoolsX(ctx context.Context) []bool

+ func (s *TwitchCategoryGroupBy) Float64(ctx context.Context) (_ float64, err error)

+ func (s *TwitchCategoryGroupBy) Float64X(ctx context.Context) float64

+ func (s *TwitchCategoryGroupBy) Float64s(ctx context.Context) ([]float64, error)

+ func (s *TwitchCategoryGroupBy) Float64sX(ctx context.Context) []float64

+ func (s *TwitchCategoryGroupBy) Int(ctx context.Context) (_ int, err error)

+ func (s *TwitchCategoryGroupBy) IntX(ctx context.Context) int

+ func (s *TwitchCategoryGroupBy) Ints(ctx context.Context) ([]int, error)

+ func (s *TwitchCategoryGroupBy) IntsX(ctx context.Context) []int

+ func (s *TwitchCategoryGroupBy) ScanX(ctx context.Context, v any)

+ func (s *TwitchCategoryGroupBy) String(ctx context.Context) (_ string, err error)

+ func (s *TwitchCategoryGroupBy) StringX(ctx context.Context) string

+ func (s *TwitchCategoryGroupBy) Strings(ctx context.Context) ([]string, error)

+ func (s *TwitchCategoryGroupBy) StringsX(ctx context.Context) []string

+ func (tcgb *TwitchCategoryGroupBy) Aggregate(fns ...AggregateFunc) *TwitchCategoryGroupBy

+ func (tcgb *TwitchCategoryGroupBy) Scan(ctx context.Context, v any) error

+ type TwitchCategoryMutation struct

+ func (m *TwitchCategoryMutation) AddField(name string, value ent.Value) error

+ func (m *TwitchCategoryMutation) AddedEdges() []string

+ func (m *TwitchCategoryMutation) AddedField(name string) (ent.Value, bool)

+ func (m *TwitchCategoryMutation) AddedFields() []string

+ func (m *TwitchCategoryMutation) AddedIDs(name string) []ent.Value

+ func (m *TwitchCategoryMutation) BoxArtURL() (r string, exists bool)

+ func (m *TwitchCategoryMutation) BoxArtURLCleared() bool

+ func (m *TwitchCategoryMutation) ClearBoxArtURL()

+ func (m *TwitchCategoryMutation) ClearEdge(name string) error

+ func (m *TwitchCategoryMutation) ClearField(name string) error

+ func (m *TwitchCategoryMutation) ClearIgdbID()

+ func (m *TwitchCategoryMutation) ClearedEdges() []string

+ func (m *TwitchCategoryMutation) ClearedFields() []string

+ func (m *TwitchCategoryMutation) CreatedAt() (r time.Time, exists bool)

+ func (m *TwitchCategoryMutation) EdgeCleared(name string) bool

+ func (m *TwitchCategoryMutation) Field(name string) (ent.Value, bool)

+ func (m *TwitchCategoryMutation) FieldCleared(name string) bool

+ func (m *TwitchCategoryMutation) Fields() []string

+ func (m *TwitchCategoryMutation) ID() (id string, exists bool)

+ func (m *TwitchCategoryMutation) IDs(ctx context.Context) ([]string, error)

+ func (m *TwitchCategoryMutation) IgdbID() (r string, exists bool)

+ func (m *TwitchCategoryMutation) IgdbIDCleared() bool

+ func (m *TwitchCategoryMutation) Name() (r string, exists bool)

+ func (m *TwitchCategoryMutation) OldBoxArtURL(ctx context.Context) (v string, err error)

+ func (m *TwitchCategoryMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error)

+ func (m *TwitchCategoryMutation) OldField(ctx context.Context, name string) (ent.Value, error)

+ func (m *TwitchCategoryMutation) OldIgdbID(ctx context.Context) (v string, err error)

+ func (m *TwitchCategoryMutation) OldName(ctx context.Context) (v string, err error)

+ func (m *TwitchCategoryMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error)

+ func (m *TwitchCategoryMutation) Op() Op

+ func (m *TwitchCategoryMutation) RemovedEdges() []string

+ func (m *TwitchCategoryMutation) RemovedIDs(name string) []ent.Value

+ func (m *TwitchCategoryMutation) ResetBoxArtURL()

+ func (m *TwitchCategoryMutation) ResetCreatedAt()

+ func (m *TwitchCategoryMutation) ResetEdge(name string) error

+ func (m *TwitchCategoryMutation) ResetField(name string) error

+ func (m *TwitchCategoryMutation) ResetIgdbID()

+ func (m *TwitchCategoryMutation) ResetName()

+ func (m *TwitchCategoryMutation) ResetUpdatedAt()

+ func (m *TwitchCategoryMutation) SetBoxArtURL(s string)

+ func (m *TwitchCategoryMutation) SetCreatedAt(t time.Time)

+ func (m *TwitchCategoryMutation) SetField(name string, value ent.Value) error

+ func (m *TwitchCategoryMutation) SetID(id string)

+ func (m *TwitchCategoryMutation) SetIgdbID(s string)

+ func (m *TwitchCategoryMutation) SetName(s string)

+ func (m *TwitchCategoryMutation) SetOp(op Op)

+ func (m *TwitchCategoryMutation) SetUpdatedAt(t time.Time)

+ func (m *TwitchCategoryMutation) Type() string

+ func (m *TwitchCategoryMutation) UpdatedAt() (r time.Time, exists bool)

+ func (m *TwitchCategoryMutation) Where(ps ...predicate.TwitchCategory)

+ func (m *TwitchCategoryMutation) WhereP(ps ...func(*sql.Selector))

+ func (m TwitchCategoryMutation) Client() *Client

+ func (m TwitchCategoryMutation) Tx() (*Tx, error)

+ type TwitchCategoryQuery struct

+ func (tcq *TwitchCategoryQuery) Aggregate(fns ...AggregateFunc) *TwitchCategorySelect

+ func (tcq *TwitchCategoryQuery) All(ctx context.Context) ([]*TwitchCategory, error)

+ func (tcq *TwitchCategoryQuery) AllX(ctx context.Context) []*TwitchCategory

+ func (tcq *TwitchCategoryQuery) Clone() *TwitchCategoryQuery

+ func (tcq *TwitchCategoryQuery) Count(ctx context.Context) (int, error)

+ func (tcq *TwitchCategoryQuery) CountX(ctx context.Context) int

+ func (tcq *TwitchCategoryQuery) Exist(ctx context.Context) (bool, error)

+ func (tcq *TwitchCategoryQuery) ExistX(ctx context.Context) bool

+ func (tcq *TwitchCategoryQuery) First(ctx context.Context) (*TwitchCategory, error)

+ func (tcq *TwitchCategoryQuery) FirstID(ctx context.Context) (id string, err error)

+ func (tcq *TwitchCategoryQuery) FirstIDX(ctx context.Context) string

+ func (tcq *TwitchCategoryQuery) FirstX(ctx context.Context) *TwitchCategory

+ func (tcq *TwitchCategoryQuery) GroupBy(field string, fields ...string) *TwitchCategoryGroupBy

+ func (tcq *TwitchCategoryQuery) IDs(ctx context.Context) (ids []string, err error)

+ func (tcq *TwitchCategoryQuery) IDsX(ctx context.Context) []string

+ func (tcq *TwitchCategoryQuery) Limit(limit int) *TwitchCategoryQuery

+ func (tcq *TwitchCategoryQuery) Offset(offset int) *TwitchCategoryQuery

+ func (tcq *TwitchCategoryQuery) Only(ctx context.Context) (*TwitchCategory, error)

+ func (tcq *TwitchCategoryQuery) OnlyID(ctx context.Context) (id string, err error)

+ func (tcq *TwitchCategoryQuery) OnlyIDX(ctx context.Context) string

+ func (tcq *TwitchCategoryQuery) OnlyX(ctx context.Context) *TwitchCategory

+ func (tcq *TwitchCategoryQuery) Order(o ...OrderFunc) *TwitchCategoryQuery

+ func (tcq *TwitchCategoryQuery) Select(fields ...string) *TwitchCategorySelect

+ func (tcq *TwitchCategoryQuery) Unique(unique bool) *TwitchCategoryQuery

+ func (tcq *TwitchCategoryQuery) Where(ps ...predicate.TwitchCategory) *TwitchCategoryQuery

+ type TwitchCategorySelect struct

+ func (s *TwitchCategorySelect) Bool(ctx context.Context) (_ bool, err error)

+ func (s *TwitchCategorySelect) BoolX(ctx context.Context) bool

+ func (s *TwitchCategorySelect) Bools(ctx context.Context) ([]bool, error)

+ func (s *TwitchCategorySelect) BoolsX(ctx context.Context) []bool

+ func (s *TwitchCategorySelect) Float64(ctx context.Context) (_ float64, err error)

+ func (s *TwitchCategorySelect) Float64X(ctx context.Context) float64

+ func (s *TwitchCategorySelect) Float64s(ctx context.Context) ([]float64, error)

+ func (s *TwitchCategorySelect) Float64sX(ctx context.Context) []float64

+ func (s *TwitchCategorySelect) Int(ctx context.Context) (_ int, err error)

+ func (s *TwitchCategorySelect) IntX(ctx context.Context) int

+ func (s *TwitchCategorySelect) Ints(ctx context.Context) ([]int, error)

+ func (s *TwitchCategorySelect) IntsX(ctx context.Context) []int

+ func (s *TwitchCategorySelect) ScanX(ctx context.Context, v any)

+ func (s *TwitchCategorySelect) String(ctx context.Context) (_ string, err error)

+ func (s *TwitchCategorySelect) StringX(ctx context.Context) string

+ func (s *TwitchCategorySelect) Strings(ctx context.Context) ([]string, error)

+ func (s *TwitchCategorySelect) StringsX(ctx context.Context) []string

+ func (tcs *TwitchCategorySelect) Aggregate(fns ...AggregateFunc) *TwitchCategorySelect

+ func (tcs *TwitchCategorySelect) Scan(ctx context.Context, v any) error

+ type TwitchCategoryUpdate struct

+ func (tcu *TwitchCategoryUpdate) ClearBoxArtURL() *TwitchCategoryUpdate

+ func (tcu *TwitchCategoryUpdate) ClearIgdbID() *TwitchCategoryUpdate

+ func (tcu *TwitchCategoryUpdate) Exec(ctx context.Context) error

+ func (tcu *TwitchCategoryUpdate) ExecX(ctx context.Context)

+ func (tcu *TwitchCategoryUpdate) Mutation() *TwitchCategoryMutation

+ func (tcu *TwitchCategoryUpdate) Save(ctx context.Context) (int, error)

+ func (tcu *TwitchCategoryUpdate) SaveX(ctx context.Context) int

+ func (tcu *TwitchCategoryUpdate) SetBoxArtURL(s string) *TwitchCategoryUpdate

+ func (tcu *TwitchCategoryUpdate) SetIgdbID(s string) *TwitchCategoryUpdate

+ func (tcu *TwitchCategoryUpdate) SetName(s string) *TwitchCategoryUpdate

+ func (tcu *TwitchCategoryUpdate) SetNillableBoxArtURL(s *string) *TwitchCategoryUpdate

+ func (tcu *TwitchCategoryUpdate) SetNillableIgdbID(s *string) *TwitchCategoryUpdate

+ func (tcu *TwitchCategoryUpdate) SetUpdatedAt(t time.Time) *TwitchCategoryUpdate

+ func (tcu *TwitchCategoryUpdate) Where(ps ...predicate.TwitchCategory) *TwitchCategoryUpdate

+ type TwitchCategoryUpdateOne struct

+ func (tcuo *TwitchCategoryUpdateOne) ClearBoxArtURL() *TwitchCategoryUpdateOne

+ func (tcuo *TwitchCategoryUpdateOne) ClearIgdbID() *TwitchCategoryUpdateOne

+ func (tcuo *TwitchCategoryUpdateOne) Exec(ctx context.Context) error

+ func (tcuo *TwitchCategoryUpdateOne) ExecX(ctx context.Context)

+ func (tcuo *TwitchCategoryUpdateOne) Mutation() *TwitchCategoryMutation

+ func (tcuo *TwitchCategoryUpdateOne) Save(ctx context.Context) (*TwitchCategory, error)

+ func (tcuo *TwitchCategoryUpdateOne) SaveX(ctx context.Context) *TwitchCategory

+ func (tcuo *TwitchCategoryUpdateOne) Select(field string, fields ...string) *TwitchCategoryUpdateOne

+ func (tcuo *TwitchCategoryUpdateOne) SetBoxArtURL(s string) *TwitchCategoryUpdateOne

+ func (tcuo *TwitchCategoryUpdateOne) SetIgdbID(s string) *TwitchCategoryUpdateOne

+ func (tcuo *TwitchCategoryUpdateOne) SetName(s string) *TwitchCategoryUpdateOne

+ func (tcuo *TwitchCategoryUpdateOne) SetNillableBoxArtURL(s *string) *TwitchCategoryUpdateOne

+ func (tcuo *TwitchCategoryUpdateOne) SetNillableIgdbID(s *string) *TwitchCategoryUpdateOne

+ func (tcuo *TwitchCategoryUpdateOne) SetUpdatedAt(t time.Time) *TwitchCategoryUpdateOne

+ func (tcuo *TwitchCategoryUpdateOne) Where(ps ...predicate.TwitchCategory) *TwitchCategoryUpdateOne

+ type TwitchCategoryUpsert struct

+ func (u *TwitchCategoryUpsert) ClearBoxArtURL() *TwitchCategoryUpsert

+ func (u *TwitchCategoryUpsert) ClearIgdbID() *TwitchCategoryUpsert

+ func (u *TwitchCategoryUpsert) SetBoxArtURL(v string) *TwitchCategoryUpsert

+ func (u *TwitchCategoryUpsert) SetIgdbID(v string) *TwitchCategoryUpsert

+ func (u *TwitchCategoryUpsert) SetName(v string) *TwitchCategoryUpsert

+ func (u *TwitchCategoryUpsert) SetUpdatedAt(v time.Time) *TwitchCategoryUpsert

+ func (u *TwitchCategoryUpsert) UpdateBoxArtURL() *TwitchCategoryUpsert

+ func (u *TwitchCategoryUpsert) UpdateIgdbID() *TwitchCategoryUpsert

+ func (u *TwitchCategoryUpsert) UpdateName() *TwitchCategoryUpsert

+ func (u *TwitchCategoryUpsert) UpdateUpdatedAt() *TwitchCategoryUpsert

+ type TwitchCategoryUpsertBulk struct

+ func (u *TwitchCategoryUpsertBulk) ClearBoxArtURL() *TwitchCategoryUpsertBulk

+ func (u *TwitchCategoryUpsertBulk) ClearIgdbID() *TwitchCategoryUpsertBulk

+ func (u *TwitchCategoryUpsertBulk) DoNothing() *TwitchCategoryUpsertBulk

+ func (u *TwitchCategoryUpsertBulk) Exec(ctx context.Context) error

+ func (u *TwitchCategoryUpsertBulk) ExecX(ctx context.Context)

+ func (u *TwitchCategoryUpsertBulk) Ignore() *TwitchCategoryUpsertBulk

+ func (u *TwitchCategoryUpsertBulk) SetBoxArtURL(v string) *TwitchCategoryUpsertBulk

+ func (u *TwitchCategoryUpsertBulk) SetIgdbID(v string) *TwitchCategoryUpsertBulk

+ func (u *TwitchCategoryUpsertBulk) SetName(v string) *TwitchCategoryUpsertBulk

+ func (u *TwitchCategoryUpsertBulk) SetUpdatedAt(v time.Time) *TwitchCategoryUpsertBulk

+ func (u *TwitchCategoryUpsertBulk) Update(set func(*TwitchCategoryUpsert)) *TwitchCategoryUpsertBulk

+ func (u *TwitchCategoryUpsertBulk) UpdateBoxArtURL() *TwitchCategoryUpsertBulk

+ func (u *TwitchCategoryUpsertBulk) UpdateIgdbID() *TwitchCategoryUpsertBulk

+ func (u *TwitchCategoryUpsertBulk) UpdateName() *TwitchCategoryUpsertBulk

+ func (u *TwitchCategoryUpsertBulk) UpdateNewValues() *TwitchCategoryUpsertBulk

+ func (u *TwitchCategoryUpsertBulk) UpdateUpdatedAt() *TwitchCategoryUpsertBulk

+ type TwitchCategoryUpsertOne struct

+ func (u *TwitchCategoryUpsertOne) ClearBoxArtURL() *TwitchCategoryUpsertOne

+ func (u *TwitchCategoryUpsertOne) ClearIgdbID() *TwitchCategoryUpsertOne

+ func (u *TwitchCategoryUpsertOne) DoNothing() *TwitchCategoryUpsertOne

+ func (u *TwitchCategoryUpsertOne) Exec(ctx context.Context) error

+ func (u *TwitchCategoryUpsertOne) ExecX(ctx context.Context)

+ func (u *TwitchCategoryUpsertOne) ID(ctx context.Context) (id string, err error)

+ func (u *TwitchCategoryUpsertOne) IDX(ctx context.Context) string

+ func (u *TwitchCategoryUpsertOne) Ignore() *TwitchCategoryUpsertOne

+ func (u *TwitchCategoryUpsertOne) SetBoxArtURL(v string) *TwitchCategoryUpsertOne

+ func (u *TwitchCategoryUpsertOne) SetIgdbID(v string) *TwitchCategoryUpsertOne

+ func (u *TwitchCategoryUpsertOne) SetName(v string) *TwitchCategoryUpsertOne

+ func (u *TwitchCategoryUpsertOne) SetUpdatedAt(v time.Time) *TwitchCategoryUpsertOne

+ func (u *TwitchCategoryUpsertOne) Update(set func(*TwitchCategoryUpsert)) *TwitchCategoryUpsertOne

+ func (u *TwitchCategoryUpsertOne) UpdateBoxArtURL() *TwitchCategoryUpsertOne

+ func (u *TwitchCategoryUpsertOne) UpdateIgdbID() *TwitchCategoryUpsertOne

+ func (u *TwitchCategoryUpsertOne) UpdateName() *TwitchCategoryUpsertOne

+ func (u *TwitchCategoryUpsertOne) UpdateNewValues() *TwitchCategoryUpsertOne

+ func (u *TwitchCategoryUpsertOne) UpdateUpdatedAt() *TwitchCategoryUpsertOne

type Tx

+ LiveCategory *LiveCategoryClient

+ TwitchCategory *TwitchCategoryClient

type UserDeleteOne

+ func (udo *UserDeleteOne) Where(ps ...predicate.User) *UserDeleteOne

type UserUpdateOne

+ func (uuo *UserUpdateOne) Where(ps ...predicate.User) *UserUpdateOne

type UserUpsert

+ func (u *UserUpsert) ClearPassword() *UserUpsert

+ func (u *UserUpsert) ClearSub() *UserUpsert

+ func (u *UserUpsert) SetOauth(v bool) *UserUpsert

+ func (u *UserUpsert) SetSub(v string) *UserUpsert

+ func (u *UserUpsert) UpdateOauth() *UserUpsert

+ func (u *UserUpsert) UpdateSub() *UserUpsert

type UserUpsertBulk

+ func (u *UserUpsertBulk) ClearPassword() *UserUpsertBulk

+ func (u *UserUpsertBulk) ClearSub() *UserUpsertBulk

+ func (u *UserUpsertBulk) SetOauth(v bool) *UserUpsertBulk

+ func (u *UserUpsertBulk) SetSub(v string) *UserUpsertBulk

+ func (u *UserUpsertBulk) UpdateOauth() *UserUpsertBulk

+ func (u *UserUpsertBulk) UpdateSub() *UserUpsertBulk

type UserUpsertOne

+ func (u *UserUpsertOne) ClearPassword() *UserUpsertOne

+ func (u *UserUpsertOne) ClearSub() *UserUpsertOne

+ func (u *UserUpsertOne) SetOauth(v bool) *UserUpsertOne

+ func (u *UserUpsertOne) SetSub(v string) *UserUpsertOne

+ func (u *UserUpsertOne) UpdateOauth() *UserUpsertOne

+ func (u *UserUpsertOne) UpdateSub() *UserUpsertOne

type VodDeleteOne

+ func (vdo *VodDeleteOne) Where(ps ...predicate.Vod) *VodDeleteOne

type VodUpdateOne

+ func (vuo *VodUpdateOne) Where(ps ...predicate.Vod) *VodUpdateOne

type VodUpsert

+ func (u *VodUpsert) ClearCaptionPath() *VodUpsert

+ func (u *VodUpsert) ClearFileName() *VodUpsert

+ func (u *VodUpsert) ClearFolderName() *VodUpsert

+ func (u *VodUpsert) SetCaptionPath(v string) *VodUpsert

+ func (u *VodUpsert) SetFileName(v string) *VodUpsert

+ func (u *VodUpsert) SetFolderName(v string) *VodUpsert

+ func (u *VodUpsert) UpdateCaptionPath() *VodUpsert

+ func (u *VodUpsert) UpdateFileName() *VodUpsert

+ func (u *VodUpsert) UpdateFolderName() *VodUpsert

type VodUpsertBulk

+ func (u *VodUpsertBulk) ClearCaptionPath() *VodUpsertBulk

+ func (u *VodUpsertBulk) ClearFileName() *VodUpsertBulk

+ func (u *VodUpsertBulk) ClearFolderName() *VodUpsertBulk

+ func (u *VodUpsertBulk) SetCaptionPath(v string) *VodUpsertBulk

+ func (u *VodUpsertBulk) SetFileName(v string) *VodUpsertBulk

+ func (u *VodUpsertBulk) SetFolderName(v string) *VodUpsertBulk

+ func (u *VodUpsertBulk) UpdateCaptionPath() *VodUpsertBulk

+ func (u *VodUpsertBulk) UpdateFileName() *VodUpsertBulk

+ func (u *VodUpsertBulk) UpdateFolderName() *VodUpsertBulk

type VodUpsertOne

+ func (u *VodUpsertOne) ClearCaptionPath() *VodUpsertOne

+ func (u *VodUpsertOne) ClearFileName() *VodUpsertOne

+ func (u *VodUpsertOne) ClearFolderName() *VodUpsertOne

+ func (u *VodUpsertOne) SetCaptionPath(v string) *VodUpsertOne

+ func (u *VodUpsertOne) SetFileName(v string) *VodUpsertOne

+ func (u *VodUpsertOne) SetFolderName(v string) *VodUpsertOne

+ func (u *VodUpsertOne) UpdateCaptionPath() *VodUpsertOne

+ func (u *VodUpsertOne) UpdateFileName() *VodUpsertOne

+ func (u *VodUpsertOne) UpdateFolderName() *VodUpsertOne

v1.2.3

Feb 7, 2023

v1.2.2

Jan 25, 2023

v1.2.1

Jan 24, 2023

v1.2.0

Jan 20, 2023

Changes in this version

type Live

+ DownloadSubOnly bool

type LiveCreate

+ func (lc *LiveCreate) SetDownloadSubOnly(b bool) *LiveCreate

+ func (lc *LiveCreate) SetNillableDownloadSubOnly(b *bool) *LiveCreate

type LiveMutation

+ func (m *LiveMutation) DownloadSubOnly() (r bool, exists bool)

+ func (m *LiveMutation) OldDownloadSubOnly(ctx context.Context) (v bool, err error)

+ func (m *LiveMutation) ResetDownloadSubOnly()

+ func (m *LiveMutation) SetDownloadSubOnly(b bool)

type LiveUpdate

+ func (lu *LiveUpdate) SetDownloadSubOnly(b bool) *LiveUpdate

+ func (lu *LiveUpdate) SetNillableDownloadSubOnly(b *bool) *LiveUpdate

type LiveUpdateOne

+ func (luo *LiveUpdateOne) SetDownloadSubOnly(b bool) *LiveUpdateOne

+ func (luo *LiveUpdateOne) SetNillableDownloadSubOnly(b *bool) *LiveUpdateOne

v1.1.9

Jan 16, 2023

Changes in this version

type Vod

+ CaptionPath string

type VodCreate

+ func (vc *VodCreate) SetCaptionPath(s string) *VodCreate

+ func (vc *VodCreate) SetNillableCaptionPath(s *string) *VodCreate

type VodMutation

+ func (m *VodMutation) CaptionPath() (r string, exists bool)

+ func (m *VodMutation) CaptionPathCleared() bool

+ func (m *VodMutation) ClearCaptionPath()

+ func (m *VodMutation) OldCaptionPath(ctx context.Context) (v string, err error)

+ func (m *VodMutation) ResetCaptionPath()

+ func (m *VodMutation) SetCaptionPath(s string)

type VodUpdate

+ func (vu *VodUpdate) ClearCaptionPath() *VodUpdate

+ func (vu *VodUpdate) SetCaptionPath(s string) *VodUpdate

+ func (vu *VodUpdate) SetNillableCaptionPath(s *string) *VodUpdate

type VodUpdateOne

+ func (vuo *VodUpdateOne) ClearCaptionPath() *VodUpdateOne

+ func (vuo *VodUpdateOne) SetCaptionPath(s string) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetNillableCaptionPath(s *string) *VodUpdateOne

v1.1.8

Jan 15, 2023

v1.1.7

Jan 11, 2023

Changes in this version

type ChannelClient

+ func (c *ChannelClient) Intercept(interceptors ...Interceptor)

+ func (c *ChannelClient) Interceptors() []Interceptor

type ChannelMutation

+ func (m *ChannelMutation) SetOp(op Op)

+ func (m *ChannelMutation) WhereP(ps ...func(*sql.Selector))

type ChannelQuery

+ func (cq *ChannelQuery) Aggregate(fns ...AggregateFunc) *ChannelSelect

type ChannelSelect

+ func (cs *ChannelSelect) Aggregate(fns ...AggregateFunc) *ChannelSelect

type Client

+ func (c *Client) Intercept(interceptors ...Interceptor)

+ func (c *Client) Mutate(ctx context.Context, m Mutation) (Value, error)

+ type InterceptFunc = ent.InterceptFunc

+ type Interceptor = ent.Interceptor

type Live

+ RenderChat bool

type LiveClient

+ func (c *LiveClient) Intercept(interceptors ...Interceptor)

+ func (c *LiveClient) Interceptors() []Interceptor

type LiveCreate

+ func (lc *LiveCreate) SetNillableRenderChat(b *bool) *LiveCreate

+ func (lc *LiveCreate) SetRenderChat(b bool) *LiveCreate

type LiveMutation

+ func (m *LiveMutation) OldRenderChat(ctx context.Context) (v bool, err error)

+ func (m *LiveMutation) RenderChat() (r bool, exists bool)

+ func (m *LiveMutation) ResetRenderChat()

+ func (m *LiveMutation) SetOp(op Op)

+ func (m *LiveMutation) SetRenderChat(b bool)

+ func (m *LiveMutation) WhereP(ps ...func(*sql.Selector))

type LiveQuery

+ func (lq *LiveQuery) Aggregate(fns ...AggregateFunc) *LiveSelect

type LiveSelect

+ func (ls *LiveSelect) Aggregate(fns ...AggregateFunc) *LiveSelect

type LiveUpdate

+ func (lu *LiveUpdate) SetNillableRenderChat(b *bool) *LiveUpdate

+ func (lu *LiveUpdate) SetRenderChat(b bool) *LiveUpdate

type LiveUpdateOne

+ func (luo *LiveUpdateOne) SetNillableRenderChat(b *bool) *LiveUpdateOne

+ func (luo *LiveUpdateOne) SetRenderChat(b bool) *LiveUpdateOne

type PlaybackClient

+ func (c *PlaybackClient) Intercept(interceptors ...Interceptor)

+ func (c *PlaybackClient) Interceptors() []Interceptor

type PlaybackMutation

+ func (m *PlaybackMutation) SetOp(op Op)

+ func (m *PlaybackMutation) WhereP(ps ...func(*sql.Selector))

type PlaybackQuery

+ func (pq *PlaybackQuery) Aggregate(fns ...AggregateFunc) *PlaybackSelect

type PlaybackSelect

+ func (ps *PlaybackSelect) Aggregate(fns ...AggregateFunc) *PlaybackSelect

type PlaylistClient

+ func (c *PlaylistClient) Intercept(interceptors ...Interceptor)

+ func (c *PlaylistClient) Interceptors() []Interceptor

type PlaylistMutation

+ func (m *PlaylistMutation) SetOp(op Op)

+ func (m *PlaylistMutation) WhereP(ps ...func(*sql.Selector))

type PlaylistQuery

+ func (pq *PlaylistQuery) Aggregate(fns ...AggregateFunc) *PlaylistSelect

type PlaylistSelect

+ func (ps *PlaylistSelect) Aggregate(fns ...AggregateFunc) *PlaylistSelect

+ type Querier = ent.Querier

+ type QuerierFunc = ent.QuerierFunc

type Queue

+ RenderChat bool

type QueueClient

+ func (c *QueueClient) Intercept(interceptors ...Interceptor)

+ func (c *QueueClient) Interceptors() []Interceptor

type QueueCreate

+ func (qc *QueueCreate) SetNillableRenderChat(b *bool) *QueueCreate

+ func (qc *QueueCreate) SetRenderChat(b bool) *QueueCreate

type QueueMutation

+ func (m *QueueMutation) ClearRenderChat()

+ func (m *QueueMutation) OldRenderChat(ctx context.Context) (v bool, err error)

+ func (m *QueueMutation) RenderChat() (r bool, exists bool)

+ func (m *QueueMutation) RenderChatCleared() bool

+ func (m *QueueMutation) ResetRenderChat()

+ func (m *QueueMutation) SetOp(op Op)

+ func (m *QueueMutation) SetRenderChat(b bool)

+ func (m *QueueMutation) WhereP(ps ...func(*sql.Selector))

type QueueQuery

+ func (qq *QueueQuery) Aggregate(fns ...AggregateFunc) *QueueSelect

type QueueSelect

+ func (qs *QueueSelect) Aggregate(fns ...AggregateFunc) *QueueSelect

type QueueUpdate

+ func (qu *QueueUpdate) ClearRenderChat() *QueueUpdate

+ func (qu *QueueUpdate) SetNillableRenderChat(b *bool) *QueueUpdate

+ func (qu *QueueUpdate) SetRenderChat(b bool) *QueueUpdate

type QueueUpdateOne

+ func (quo *QueueUpdateOne) ClearRenderChat() *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetNillableRenderChat(b *bool) *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetRenderChat(b bool) *QueueUpdateOne

+ type TraverseFunc = ent.TraverseFunc

+ type Traverser = ent.Traverser

type UserClient

+ func (c *UserClient) Intercept(interceptors ...Interceptor)

+ func (c *UserClient) Interceptors() []Interceptor

type UserMutation

+ func (m *UserMutation) SetOp(op Op)

+ func (m *UserMutation) WhereP(ps ...func(*sql.Selector))

type UserQuery

+ func (uq *UserQuery) Aggregate(fns ...AggregateFunc) *UserSelect

type UserSelect

+ func (us *UserSelect) Aggregate(fns ...AggregateFunc) *UserSelect

type Vod

+ FileName string

+ FolderName string

type VodClient

+ func (c *VodClient) Intercept(interceptors ...Interceptor)

+ func (c *VodClient) Interceptors() []Interceptor

type VodCreate

+ func (vc *VodCreate) SetFileName(s string) *VodCreate

+ func (vc *VodCreate) SetFolderName(s string) *VodCreate

+ func (vc *VodCreate) SetNillableFileName(s *string) *VodCreate

+ func (vc *VodCreate) SetNillableFolderName(s *string) *VodCreate

type VodMutation

+ func (m *VodMutation) ClearFileName()

+ func (m *VodMutation) ClearFolderName()

+ func (m *VodMutation) FileName() (r string, exists bool)

+ func (m *VodMutation) FileNameCleared() bool

+ func (m *VodMutation) FolderName() (r string, exists bool)

+ func (m *VodMutation) FolderNameCleared() bool

+ func (m *VodMutation) OldFileName(ctx context.Context) (v string, err error)

+ func (m *VodMutation) OldFolderName(ctx context.Context) (v string, err error)

+ func (m *VodMutation) ResetFileName()

+ func (m *VodMutation) ResetFolderName()

+ func (m *VodMutation) SetFileName(s string)

+ func (m *VodMutation) SetFolderName(s string)

+ func (m *VodMutation) SetOp(op Op)

+ func (m *VodMutation) WhereP(ps ...func(*sql.Selector))

type VodQuery

+ func (vq *VodQuery) Aggregate(fns ...AggregateFunc) *VodSelect

type VodSelect

+ func (vs *VodSelect) Aggregate(fns ...AggregateFunc) *VodSelect

type VodUpdate

+ func (vu *VodUpdate) ClearFileName() *VodUpdate

+ func (vu *VodUpdate) ClearFolderName() *VodUpdate

+ func (vu *VodUpdate) SetFileName(s string) *VodUpdate

+ func (vu *VodUpdate) SetFolderName(s string) *VodUpdate

+ func (vu *VodUpdate) SetNillableFileName(s *string) *VodUpdate

+ func (vu *VodUpdate) SetNillableFolderName(s *string) *VodUpdate

type VodUpdateOne

+ func (vuo *VodUpdateOne) ClearFileName() *VodUpdateOne

+ func (vuo *VodUpdateOne) ClearFolderName() *VodUpdateOne

+ func (vuo *VodUpdateOne) SetFileName(s string) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetFolderName(s string) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetNillableFileName(s *string) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetNillableFolderName(s *string) *VodUpdateOne

v1.1.6

Jan 8, 2023

v1.1.5

Jan 6, 2023

v1.1.4

Jan 3, 2023

v1.1.3

Dec 20, 2022

v1.1.2

Dec 16, 2022

v1.1.1

Nov 25, 2022

v1.1.0

Nov 23, 2022

Changes in this version

type Channel

+ ExtID string

type ChannelCreate

+ func (cc *ChannelCreate) SetExtID(s string) *ChannelCreate

+ func (cc *ChannelCreate) SetNillableExtID(s *string) *ChannelCreate

type ChannelMutation

+ func (m *ChannelMutation) ClearExtID()

+ func (m *ChannelMutation) ExtID() (r string, exists bool)

+ func (m *ChannelMutation) ExtIDCleared() bool

+ func (m *ChannelMutation) OldExtID(ctx context.Context) (v string, err error)

+ func (m *ChannelMutation) ResetExtID()

+ func (m *ChannelMutation) SetExtID(s string)

type ChannelUpdate

+ func (cu *ChannelUpdate) ClearExtID() *ChannelUpdate

+ func (cu *ChannelUpdate) SetExtID(s string) *ChannelUpdate

+ func (cu *ChannelUpdate) SetNillableExtID(s *string) *ChannelUpdate

type ChannelUpdateOne

+ func (cuo *ChannelUpdateOne) ClearExtID() *ChannelUpdateOne

+ func (cuo *ChannelUpdateOne) SetExtID(s string) *ChannelUpdateOne

+ func (cuo *ChannelUpdateOne) SetNillableExtID(s *string) *ChannelUpdateOne

type Live

+ DownloadArchives bool

+ DownloadHighlights bool

+ DownloadUploads bool

+ WatchLive bool

+ WatchVod bool

type LiveCreate

+ func (lc *LiveCreate) SetDownloadArchives(b bool) *LiveCreate

+ func (lc *LiveCreate) SetDownloadHighlights(b bool) *LiveCreate

+ func (lc *LiveCreate) SetDownloadUploads(b bool) *LiveCreate

+ func (lc *LiveCreate) SetNillableDownloadArchives(b *bool) *LiveCreate

+ func (lc *LiveCreate) SetNillableDownloadHighlights(b *bool) *LiveCreate

+ func (lc *LiveCreate) SetNillableDownloadUploads(b *bool) *LiveCreate

+ func (lc *LiveCreate) SetNillableWatchLive(b *bool) *LiveCreate

+ func (lc *LiveCreate) SetNillableWatchVod(b *bool) *LiveCreate

+ func (lc *LiveCreate) SetWatchLive(b bool) *LiveCreate

+ func (lc *LiveCreate) SetWatchVod(b bool) *LiveCreate

type LiveMutation

+ func (m *LiveMutation) DownloadArchives() (r bool, exists bool)

+ func (m *LiveMutation) DownloadHighlights() (r bool, exists bool)

+ func (m *LiveMutation) DownloadUploads() (r bool, exists bool)

+ func (m *LiveMutation) OldDownloadArchives(ctx context.Context) (v bool, err error)

+ func (m *LiveMutation) OldDownloadHighlights(ctx context.Context) (v bool, err error)

+ func (m *LiveMutation) OldDownloadUploads(ctx context.Context) (v bool, err error)

+ func (m *LiveMutation) OldWatchLive(ctx context.Context) (v bool, err error)

+ func (m *LiveMutation) OldWatchVod(ctx context.Context) (v bool, err error)

+ func (m *LiveMutation) ResetDownloadArchives()

+ func (m *LiveMutation) ResetDownloadHighlights()

+ func (m *LiveMutation) ResetDownloadUploads()

+ func (m *LiveMutation) ResetWatchLive()

+ func (m *LiveMutation) ResetWatchVod()

+ func (m *LiveMutation) SetDownloadArchives(b bool)

+ func (m *LiveMutation) SetDownloadHighlights(b bool)

+ func (m *LiveMutation) SetDownloadUploads(b bool)

+ func (m *LiveMutation) SetWatchLive(b bool)

+ func (m *LiveMutation) SetWatchVod(b bool)

+ func (m *LiveMutation) WatchLive() (r bool, exists bool)

+ func (m *LiveMutation) WatchVod() (r bool, exists bool)

type LiveUpdate

+ func (lu *LiveUpdate) SetDownloadArchives(b bool) *LiveUpdate

+ func (lu *LiveUpdate) SetDownloadHighlights(b bool) *LiveUpdate

+ func (lu *LiveUpdate) SetDownloadUploads(b bool) *LiveUpdate

+ func (lu *LiveUpdate) SetNillableDownloadArchives(b *bool) *LiveUpdate

+ func (lu *LiveUpdate) SetNillableDownloadHighlights(b *bool) *LiveUpdate

+ func (lu *LiveUpdate) SetNillableDownloadUploads(b *bool) *LiveUpdate

+ func (lu *LiveUpdate) SetNillableWatchLive(b *bool) *LiveUpdate

+ func (lu *LiveUpdate) SetNillableWatchVod(b *bool) *LiveUpdate

+ func (lu *LiveUpdate) SetWatchLive(b bool) *LiveUpdate

+ func (lu *LiveUpdate) SetWatchVod(b bool) *LiveUpdate

type LiveUpdateOne

+ func (luo *LiveUpdateOne) SetDownloadArchives(b bool) *LiveUpdateOne

+ func (luo *LiveUpdateOne) SetDownloadHighlights(b bool) *LiveUpdateOne

+ func (luo *LiveUpdateOne) SetDownloadUploads(b bool) *LiveUpdateOne

+ func (luo *LiveUpdateOne) SetNillableDownloadArchives(b *bool) *LiveUpdateOne

+ func (luo *LiveUpdateOne) SetNillableDownloadHighlights(b *bool) *LiveUpdateOne

+ func (luo *LiveUpdateOne) SetNillableDownloadUploads(b *bool) *LiveUpdateOne

+ func (luo *LiveUpdateOne) SetNillableWatchLive(b *bool) *LiveUpdateOne

+ func (luo *LiveUpdateOne) SetNillableWatchVod(b *bool) *LiveUpdateOne

+ func (luo *LiveUpdateOne) SetWatchLive(b bool) *LiveUpdateOne

+ func (luo *LiveUpdateOne) SetWatchVod(b bool) *LiveUpdateOne

v1.0.9

Nov 18, 2022

v1.0.8

Nov 15, 2022

Changes in this version

type User

+ Oauth bool

+ Sub string

type UserCreate

+ func (uc *UserCreate) SetNillableOauth(b *bool) *UserCreate

+ func (uc *UserCreate) SetNillablePassword(s *string) *UserCreate

+ func (uc *UserCreate) SetNillableSub(s *string) *UserCreate

+ func (uc *UserCreate) SetOauth(b bool) *UserCreate

+ func (uc *UserCreate) SetSub(s string) *UserCreate

type UserMutation

+ func (m *UserMutation) ClearPassword()

+ func (m *UserMutation) ClearSub()

+ func (m *UserMutation) Oauth() (r bool, exists bool)

+ func (m *UserMutation) OldOauth(ctx context.Context) (v bool, err error)

+ func (m *UserMutation) OldSub(ctx context.Context) (v string, err error)

+ func (m *UserMutation) PasswordCleared() bool

+ func (m *UserMutation) ResetOauth()

+ func (m *UserMutation) ResetSub()

+ func (m *UserMutation) SetOauth(b bool)

+ func (m *UserMutation) SetSub(s string)

+ func (m *UserMutation) Sub() (r string, exists bool)

+ func (m *UserMutation) SubCleared() bool

type UserUpdate

+ func (uu *UserUpdate) ClearPassword() *UserUpdate

+ func (uu *UserUpdate) ClearSub() *UserUpdate

+ func (uu *UserUpdate) SetNillableOauth(b *bool) *UserUpdate

+ func (uu *UserUpdate) SetNillablePassword(s *string) *UserUpdate

+ func (uu *UserUpdate) SetNillableSub(s *string) *UserUpdate

+ func (uu *UserUpdate) SetOauth(b bool) *UserUpdate

+ func (uu *UserUpdate) SetSub(s string) *UserUpdate

type UserUpdateOne

+ func (uuo *UserUpdateOne) ClearPassword() *UserUpdateOne

+ func (uuo *UserUpdateOne) ClearSub() *UserUpdateOne

+ func (uuo *UserUpdateOne) SetNillableOauth(b *bool) *UserUpdateOne

+ func (uuo *UserUpdateOne) SetNillablePassword(s *string) *UserUpdateOne

+ func (uuo *UserUpdateOne) SetNillableSub(s *string) *UserUpdateOne

+ func (uuo *UserUpdateOne) SetOauth(b bool) *UserUpdateOne

+ func (uuo *UserUpdateOne) SetSub(s string) *UserUpdateOne

v1.0.7

Nov 4, 2022

v1.0.6

Oct 29, 2022

v1.0.5

Sep 20, 2022

v1.0.4

Sep 13, 2022

v1.0.3

Sep 7, 2022

v1.0.2

Aug 16, 2022

v1.0.1

Aug 1, 2022

v1.0.0

Jul 29, 2022

Changes in this version

+ const TypePlaylist

type Client

+ Playlist *PlaylistClient

+ type Playlist struct

+ CreatedAt time.Time

+ Description string

+ Edges PlaylistEdges

+ ID uuid.UUID

+ Name string

+ ThumbnailPath string

+ UpdatedAt time.Time

+ func (pl *Playlist) QueryVods() *VodQuery

+ func (pl *Playlist) String() string

+ func (pl *Playlist) Unwrap() *Playlist

+ func (pl *Playlist) Update() *PlaylistUpdateOne

+ type PlaylistClient struct

+ func NewPlaylistClient(c config) *PlaylistClient

+ func (c *PlaylistClient) Create() *PlaylistCreate

+ func (c *PlaylistClient) CreateBulk(builders ...*PlaylistCreate) *PlaylistCreateBulk

+ func (c *PlaylistClient) Delete() *PlaylistDelete

+ func (c *PlaylistClient) DeleteOne(pl *Playlist) *PlaylistDeleteOne

+ func (c *PlaylistClient) DeleteOneID(id uuid.UUID) *PlaylistDeleteOne

+ func (c *PlaylistClient) Get(ctx context.Context, id uuid.UUID) (*Playlist, error)

+ func (c *PlaylistClient) GetX(ctx context.Context, id uuid.UUID) *Playlist

+ func (c *PlaylistClient) Hooks() []Hook

+ func (c *PlaylistClient) Query() *PlaylistQuery

+ func (c *PlaylistClient) QueryVods(pl *Playlist) *VodQuery

+ func (c *PlaylistClient) Update() *PlaylistUpdate

+ func (c *PlaylistClient) UpdateOne(pl *Playlist) *PlaylistUpdateOne

+ func (c *PlaylistClient) UpdateOneID(id uuid.UUID) *PlaylistUpdateOne

+ func (c *PlaylistClient) Use(hooks ...Hook)

+ type PlaylistCreate struct

+ func (pc *PlaylistCreate) AddVodIDs(ids ...uuid.UUID) *PlaylistCreate

+ func (pc *PlaylistCreate) AddVods(v ...*Vod) *PlaylistCreate

+ func (pc *PlaylistCreate) Exec(ctx context.Context) error

+ func (pc *PlaylistCreate) ExecX(ctx context.Context)

+ func (pc *PlaylistCreate) Mutation() *PlaylistMutation

+ func (pc *PlaylistCreate) Save(ctx context.Context) (*Playlist, error)

+ func (pc *PlaylistCreate) SaveX(ctx context.Context) *Playlist

+ func (pc *PlaylistCreate) SetCreatedAt(t time.Time) *PlaylistCreate

+ func (pc *PlaylistCreate) SetDescription(s string) *PlaylistCreate

+ func (pc *PlaylistCreate) SetID(u uuid.UUID) *PlaylistCreate

+ func (pc *PlaylistCreate) SetName(s string) *PlaylistCreate

+ func (pc *PlaylistCreate) SetNillableCreatedAt(t *time.Time) *PlaylistCreate

+ func (pc *PlaylistCreate) SetNillableDescription(s *string) *PlaylistCreate

+ func (pc *PlaylistCreate) SetNillableID(u *uuid.UUID) *PlaylistCreate

+ func (pc *PlaylistCreate) SetNillableThumbnailPath(s *string) *PlaylistCreate

+ func (pc *PlaylistCreate) SetNillableUpdatedAt(t *time.Time) *PlaylistCreate

+ func (pc *PlaylistCreate) SetThumbnailPath(s string) *PlaylistCreate

+ func (pc *PlaylistCreate) SetUpdatedAt(t time.Time) *PlaylistCreate

+ type PlaylistCreateBulk struct

+ func (pcb *PlaylistCreateBulk) Exec(ctx context.Context) error

+ func (pcb *PlaylistCreateBulk) ExecX(ctx context.Context)

+ func (pcb *PlaylistCreateBulk) Save(ctx context.Context) ([]*Playlist, error)

+ func (pcb *PlaylistCreateBulk) SaveX(ctx context.Context) []*Playlist

+ type PlaylistDelete struct

+ func (pd *PlaylistDelete) Exec(ctx context.Context) (int, error)

+ func (pd *PlaylistDelete) ExecX(ctx context.Context) int

+ func (pd *PlaylistDelete) Where(ps ...predicate.Playlist) *PlaylistDelete

+ type PlaylistDeleteOne struct

+ func (pdo *PlaylistDeleteOne) Exec(ctx context.Context) error

+ func (pdo *PlaylistDeleteOne) ExecX(ctx context.Context)

+ type PlaylistEdges struct

+ Vods []*Vod

+ func (e PlaylistEdges) VodsOrErr() ([]*Vod, error)

+ type PlaylistGroupBy struct

+ func (pgb *PlaylistGroupBy) Aggregate(fns ...AggregateFunc) *PlaylistGroupBy

+ func (pgb *PlaylistGroupBy) Scan(ctx context.Context, v interface{}) error

+ func (s *PlaylistGroupBy) Bool(ctx context.Context) (_ bool, err error)

+ func (s *PlaylistGroupBy) BoolX(ctx context.Context) bool

+ func (s *PlaylistGroupBy) Bools(ctx context.Context) ([]bool, error)

+ func (s *PlaylistGroupBy) BoolsX(ctx context.Context) []bool

+ func (s *PlaylistGroupBy) Float64(ctx context.Context) (_ float64, err error)

+ func (s *PlaylistGroupBy) Float64X(ctx context.Context) float64

+ func (s *PlaylistGroupBy) Float64s(ctx context.Context) ([]float64, error)

+ func (s *PlaylistGroupBy) Float64sX(ctx context.Context) []float64

+ func (s *PlaylistGroupBy) Int(ctx context.Context) (_ int, err error)

+ func (s *PlaylistGroupBy) IntX(ctx context.Context) int

+ func (s *PlaylistGroupBy) Ints(ctx context.Context) ([]int, error)

+ func (s *PlaylistGroupBy) IntsX(ctx context.Context) []int

+ func (s *PlaylistGroupBy) ScanX(ctx context.Context, v interface{})

+ func (s *PlaylistGroupBy) String(ctx context.Context) (_ string, err error)

+ func (s *PlaylistGroupBy) StringX(ctx context.Context) string

+ func (s *PlaylistGroupBy) Strings(ctx context.Context) ([]string, error)

+ func (s *PlaylistGroupBy) StringsX(ctx context.Context) []string

+ type PlaylistMutation struct

+ func (m *PlaylistMutation) AddField(name string, value ent.Value) error

+ func (m *PlaylistMutation) AddVodIDs(ids ...uuid.UUID)

+ func (m *PlaylistMutation) AddedEdges() []string

+ func (m *PlaylistMutation) AddedField(name string) (ent.Value, bool)

+ func (m *PlaylistMutation) AddedFields() []string

+ func (m *PlaylistMutation) AddedIDs(name string) []ent.Value

+ func (m *PlaylistMutation) ClearDescription()

+ func (m *PlaylistMutation) ClearEdge(name string) error

+ func (m *PlaylistMutation) ClearField(name string) error

+ func (m *PlaylistMutation) ClearThumbnailPath()

+ func (m *PlaylistMutation) ClearVods()

+ func (m *PlaylistMutation) ClearedEdges() []string

+ func (m *PlaylistMutation) ClearedFields() []string

+ func (m *PlaylistMutation) CreatedAt() (r time.Time, exists bool)

+ func (m *PlaylistMutation) Description() (r string, exists bool)

+ func (m *PlaylistMutation) DescriptionCleared() bool

+ func (m *PlaylistMutation) EdgeCleared(name string) bool

+ func (m *PlaylistMutation) Field(name string) (ent.Value, bool)

+ func (m *PlaylistMutation) FieldCleared(name string) bool

+ func (m *PlaylistMutation) Fields() []string

+ func (m *PlaylistMutation) ID() (id uuid.UUID, exists bool)

+ func (m *PlaylistMutation) IDs(ctx context.Context) ([]uuid.UUID, error)

+ func (m *PlaylistMutation) Name() (r string, exists bool)

+ func (m *PlaylistMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error)

+ func (m *PlaylistMutation) OldDescription(ctx context.Context) (v string, err error)

+ func (m *PlaylistMutation) OldField(ctx context.Context, name string) (ent.Value, error)

+ func (m *PlaylistMutation) OldName(ctx context.Context) (v string, err error)

+ func (m *PlaylistMutation) OldThumbnailPath(ctx context.Context) (v string, err error)

+ func (m *PlaylistMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error)

+ func (m *PlaylistMutation) Op() Op

+ func (m *PlaylistMutation) RemoveVodIDs(ids ...uuid.UUID)

+ func (m *PlaylistMutation) RemovedEdges() []string

+ func (m *PlaylistMutation) RemovedIDs(name string) []ent.Value

+ func (m *PlaylistMutation) RemovedVodsIDs() (ids []uuid.UUID)

+ func (m *PlaylistMutation) ResetCreatedAt()

+ func (m *PlaylistMutation) ResetDescription()

+ func (m *PlaylistMutation) ResetEdge(name string) error

+ func (m *PlaylistMutation) ResetField(name string) error

+ func (m *PlaylistMutation) ResetName()

+ func (m *PlaylistMutation) ResetThumbnailPath()

+ func (m *PlaylistMutation) ResetUpdatedAt()

+ func (m *PlaylistMutation) ResetVods()

+ func (m *PlaylistMutation) SetCreatedAt(t time.Time)

+ func (m *PlaylistMutation) SetDescription(s string)

+ func (m *PlaylistMutation) SetField(name string, value ent.Value) error

+ func (m *PlaylistMutation) SetID(id uuid.UUID)

+ func (m *PlaylistMutation) SetName(s string)

+ func (m *PlaylistMutation) SetThumbnailPath(s string)

+ func (m *PlaylistMutation) SetUpdatedAt(t time.Time)

+ func (m *PlaylistMutation) ThumbnailPath() (r string, exists bool)

+ func (m *PlaylistMutation) ThumbnailPathCleared() bool

+ func (m *PlaylistMutation) Type() string

+ func (m *PlaylistMutation) UpdatedAt() (r time.Time, exists bool)

+ func (m *PlaylistMutation) VodsCleared() bool

+ func (m *PlaylistMutation) VodsIDs() (ids []uuid.UUID)

+ func (m *PlaylistMutation) Where(ps ...predicate.Playlist)

+ func (m PlaylistMutation) Client() *Client

+ func (m PlaylistMutation) Tx() (*Tx, error)

+ type PlaylistQuery struct

+ func (pq *PlaylistQuery) All(ctx context.Context) ([]*Playlist, error)

+ func (pq *PlaylistQuery) AllX(ctx context.Context) []*Playlist

+ func (pq *PlaylistQuery) Clone() *PlaylistQuery

+ func (pq *PlaylistQuery) Count(ctx context.Context) (int, error)

+ func (pq *PlaylistQuery) CountX(ctx context.Context) int

+ func (pq *PlaylistQuery) Exist(ctx context.Context) (bool, error)

+ func (pq *PlaylistQuery) ExistX(ctx context.Context) bool

+ func (pq *PlaylistQuery) First(ctx context.Context) (*Playlist, error)

+ func (pq *PlaylistQuery) FirstID(ctx context.Context) (id uuid.UUID, err error)

+ func (pq *PlaylistQuery) FirstIDX(ctx context.Context) uuid.UUID

+ func (pq *PlaylistQuery) FirstX(ctx context.Context) *Playlist

+ func (pq *PlaylistQuery) GroupBy(field string, fields ...string) *PlaylistGroupBy

+ func (pq *PlaylistQuery) IDs(ctx context.Context) ([]uuid.UUID, error)

+ func (pq *PlaylistQuery) IDsX(ctx context.Context) []uuid.UUID

+ func (pq *PlaylistQuery) Limit(limit int) *PlaylistQuery

+ func (pq *PlaylistQuery) Offset(offset int) *PlaylistQuery

+ func (pq *PlaylistQuery) Only(ctx context.Context) (*Playlist, error)

+ func (pq *PlaylistQuery) OnlyID(ctx context.Context) (id uuid.UUID, err error)

+ func (pq *PlaylistQuery) OnlyIDX(ctx context.Context) uuid.UUID

+ func (pq *PlaylistQuery) OnlyX(ctx context.Context) *Playlist

+ func (pq *PlaylistQuery) Order(o ...OrderFunc) *PlaylistQuery

+ func (pq *PlaylistQuery) QueryVods() *VodQuery

+ func (pq *PlaylistQuery) Select(fields ...string) *PlaylistSelect

+ func (pq *PlaylistQuery) Unique(unique bool) *PlaylistQuery

+ func (pq *PlaylistQuery) Where(ps ...predicate.Playlist) *PlaylistQuery

+ func (pq *PlaylistQuery) WithVods(opts ...func(*VodQuery)) *PlaylistQuery

+ type PlaylistSelect struct

+ func (ps *PlaylistSelect) Scan(ctx context.Context, v interface{}) error

+ func (s *PlaylistSelect) Bool(ctx context.Context) (_ bool, err error)

+ func (s *PlaylistSelect) BoolX(ctx context.Context) bool

+ func (s *PlaylistSelect) Bools(ctx context.Context) ([]bool, error)

+ func (s *PlaylistSelect) BoolsX(ctx context.Context) []bool

+ func (s *PlaylistSelect) Float64(ctx context.Context) (_ float64, err error)

+ func (s *PlaylistSelect) Float64X(ctx context.Context) float64

+ func (s *PlaylistSelect) Float64s(ctx context.Context) ([]float64, error)

+ func (s *PlaylistSelect) Float64sX(ctx context.Context) []float64

+ func (s *PlaylistSelect) Int(ctx context.Context) (_ int, err error)

+ func (s *PlaylistSelect) IntX(ctx context.Context) int

+ func (s *PlaylistSelect) Ints(ctx context.Context) ([]int, error)

+ func (s *PlaylistSelect) IntsX(ctx context.Context) []int

+ func (s *PlaylistSelect) ScanX(ctx context.Context, v interface{})

+ func (s *PlaylistSelect) String(ctx context.Context) (_ string, err error)

+ func (s *PlaylistSelect) StringX(ctx context.Context) string

+ func (s *PlaylistSelect) Strings(ctx context.Context) ([]string, error)

+ func (s *PlaylistSelect) StringsX(ctx context.Context) []string

+ type PlaylistUpdate struct

+ func (pu *PlaylistUpdate) AddVodIDs(ids ...uuid.UUID) *PlaylistUpdate

+ func (pu *PlaylistUpdate) AddVods(v ...*Vod) *PlaylistUpdate

+ func (pu *PlaylistUpdate) ClearDescription() *PlaylistUpdate

+ func (pu *PlaylistUpdate) ClearThumbnailPath() *PlaylistUpdate

+ func (pu *PlaylistUpdate) ClearVods() *PlaylistUpdate

+ func (pu *PlaylistUpdate) Exec(ctx context.Context) error

+ func (pu *PlaylistUpdate) ExecX(ctx context.Context)

+ func (pu *PlaylistUpdate) Mutation() *PlaylistMutation

+ func (pu *PlaylistUpdate) RemoveVodIDs(ids ...uuid.UUID) *PlaylistUpdate

+ func (pu *PlaylistUpdate) RemoveVods(v ...*Vod) *PlaylistUpdate

+ func (pu *PlaylistUpdate) Save(ctx context.Context) (int, error)

+ func (pu *PlaylistUpdate) SaveX(ctx context.Context) int

+ func (pu *PlaylistUpdate) SetDescription(s string) *PlaylistUpdate

+ func (pu *PlaylistUpdate) SetName(s string) *PlaylistUpdate

+ func (pu *PlaylistUpdate) SetNillableDescription(s *string) *PlaylistUpdate

+ func (pu *PlaylistUpdate) SetNillableThumbnailPath(s *string) *PlaylistUpdate

+ func (pu *PlaylistUpdate) SetThumbnailPath(s string) *PlaylistUpdate

+ func (pu *PlaylistUpdate) SetUpdatedAt(t time.Time) *PlaylistUpdate

+ func (pu *PlaylistUpdate) Where(ps ...predicate.Playlist) *PlaylistUpdate

+ type PlaylistUpdateOne struct

+ func (puo *PlaylistUpdateOne) AddVodIDs(ids ...uuid.UUID) *PlaylistUpdateOne

+ func (puo *PlaylistUpdateOne) AddVods(v ...*Vod) *PlaylistUpdateOne

+ func (puo *PlaylistUpdateOne) ClearDescription() *PlaylistUpdateOne

+ func (puo *PlaylistUpdateOne) ClearThumbnailPath() *PlaylistUpdateOne

+ func (puo *PlaylistUpdateOne) ClearVods() *PlaylistUpdateOne

+ func (puo *PlaylistUpdateOne) Exec(ctx context.Context) error

+ func (puo *PlaylistUpdateOne) ExecX(ctx context.Context)

+ func (puo *PlaylistUpdateOne) Mutation() *PlaylistMutation

+ func (puo *PlaylistUpdateOne) RemoveVodIDs(ids ...uuid.UUID) *PlaylistUpdateOne

+ func (puo *PlaylistUpdateOne) RemoveVods(v ...*Vod) *PlaylistUpdateOne

+ func (puo *PlaylistUpdateOne) Save(ctx context.Context) (*Playlist, error)

+ func (puo *PlaylistUpdateOne) SaveX(ctx context.Context) *Playlist

+ func (puo *PlaylistUpdateOne) Select(field string, fields ...string) *PlaylistUpdateOne

+ func (puo *PlaylistUpdateOne) SetDescription(s string) *PlaylistUpdateOne

+ func (puo *PlaylistUpdateOne) SetName(s string) *PlaylistUpdateOne

+ func (puo *PlaylistUpdateOne) SetNillableDescription(s *string) *PlaylistUpdateOne

+ func (puo *PlaylistUpdateOne) SetNillableThumbnailPath(s *string) *PlaylistUpdateOne

+ func (puo *PlaylistUpdateOne) SetThumbnailPath(s string) *PlaylistUpdateOne

+ func (puo *PlaylistUpdateOne) SetUpdatedAt(t time.Time) *PlaylistUpdateOne

+ type Playlists []*Playlist

type Tx

+ Playlist *PlaylistClient

type Vod

+ func (v *Vod) QueryPlaylists() *PlaylistQuery

type VodClient

+ func (c *VodClient) QueryPlaylists(v *Vod) *PlaylistQuery

type VodCreate

+ func (vc *VodCreate) AddPlaylistIDs(ids ...uuid.UUID) *VodCreate

+ func (vc *VodCreate) AddPlaylists(p ...*Playlist) *VodCreate

type VodEdges

+ Playlists []*Playlist

+ func (e VodEdges) PlaylistsOrErr() ([]*Playlist, error)

type VodMutation

+ func (m *VodMutation) AddPlaylistIDs(ids ...uuid.UUID)

+ func (m *VodMutation) ClearPlaylists()

+ func (m *VodMutation) PlaylistsCleared() bool

+ func (m *VodMutation) PlaylistsIDs() (ids []uuid.UUID)

+ func (m *VodMutation) RemovePlaylistIDs(ids ...uuid.UUID)

+ func (m *VodMutation) RemovedPlaylistsIDs() (ids []uuid.UUID)

+ func (m *VodMutation) ResetPlaylists()

type VodQuery

+ func (vq *VodQuery) QueryPlaylists() *PlaylistQuery

+ func (vq *VodQuery) WithPlaylists(opts ...func(*PlaylistQuery)) *VodQuery

type VodUpdate

+ func (vu *VodUpdate) AddPlaylistIDs(ids ...uuid.UUID) *VodUpdate

+ func (vu *VodUpdate) AddPlaylists(p ...*Playlist) *VodUpdate

+ func (vu *VodUpdate) ClearPlaylists() *VodUpdate

+ func (vu *VodUpdate) RemovePlaylistIDs(ids ...uuid.UUID) *VodUpdate

+ func (vu *VodUpdate) RemovePlaylists(p ...*Playlist) *VodUpdate

type VodUpdateOne

+ func (vuo *VodUpdateOne) AddPlaylistIDs(ids ...uuid.UUID) *VodUpdateOne

+ func (vuo *VodUpdateOne) AddPlaylists(p ...*Playlist) *VodUpdateOne

+ func (vuo *VodUpdateOne) ClearPlaylists() *VodUpdateOne

+ func (vuo *VodUpdateOne) RemovePlaylistIDs(ids ...uuid.UUID) *VodUpdateOne

+ func (vuo *VodUpdateOne) RemovePlaylists(p ...*Playlist) *VodUpdateOne

v0

v0.0.3

Jul 25, 2022

v0.0.2

Jul 22, 2022

Changes in this version

+ const TypePlayback

type ChannelCreate

+ func (cc *ChannelCreate) OnConflict(opts ...sql.ConflictOption) *ChannelUpsertOne

+ func (cc *ChannelCreate) OnConflictColumns(columns ...string) *ChannelUpsertOne

type ChannelCreateBulk

+ func (ccb *ChannelCreateBulk) OnConflict(opts ...sql.ConflictOption) *ChannelUpsertBulk

+ func (ccb *ChannelCreateBulk) OnConflictColumns(columns ...string) *ChannelUpsertBulk

type ChannelQuery

+ func (cq *ChannelQuery) Modify(modifiers ...func(s *sql.Selector)) *ChannelSelect

type ChannelSelect

+ func (cs *ChannelSelect) Modify(modifiers ...func(s *sql.Selector)) *ChannelSelect

+ type ChannelUpsert struct

+ func (u *ChannelUpsert) SetCreatedAt(v time.Time) *ChannelUpsert

+ func (u *ChannelUpsert) SetDisplayName(v string) *ChannelUpsert

+ func (u *ChannelUpsert) SetImagePath(v string) *ChannelUpsert

+ func (u *ChannelUpsert) SetName(v string) *ChannelUpsert

+ func (u *ChannelUpsert) SetUpdatedAt(v time.Time) *ChannelUpsert

+ func (u *ChannelUpsert) UpdateCreatedAt() *ChannelUpsert

+ func (u *ChannelUpsert) UpdateDisplayName() *ChannelUpsert

+ func (u *ChannelUpsert) UpdateImagePath() *ChannelUpsert

+ func (u *ChannelUpsert) UpdateName() *ChannelUpsert

+ func (u *ChannelUpsert) UpdateUpdatedAt() *ChannelUpsert

+ type ChannelUpsertBulk struct

+ func (u *ChannelUpsertBulk) DoNothing() *ChannelUpsertBulk

+ func (u *ChannelUpsertBulk) Exec(ctx context.Context) error

+ func (u *ChannelUpsertBulk) ExecX(ctx context.Context)

+ func (u *ChannelUpsertBulk) Ignore() *ChannelUpsertBulk

+ func (u *ChannelUpsertBulk) SetCreatedAt(v time.Time) *ChannelUpsertBulk

+ func (u *ChannelUpsertBulk) SetDisplayName(v string) *ChannelUpsertBulk

+ func (u *ChannelUpsertBulk) SetImagePath(v string) *ChannelUpsertBulk

+ func (u *ChannelUpsertBulk) SetName(v string) *ChannelUpsertBulk

+ func (u *ChannelUpsertBulk) SetUpdatedAt(v time.Time) *ChannelUpsertBulk

+ func (u *ChannelUpsertBulk) Update(set func(*ChannelUpsert)) *ChannelUpsertBulk

+ func (u *ChannelUpsertBulk) UpdateCreatedAt() *ChannelUpsertBulk

+ func (u *ChannelUpsertBulk) UpdateDisplayName() *ChannelUpsertBulk

+ func (u *ChannelUpsertBulk) UpdateImagePath() *ChannelUpsertBulk

+ func (u *ChannelUpsertBulk) UpdateName() *ChannelUpsertBulk

+ func (u *ChannelUpsertBulk) UpdateNewValues() *ChannelUpsertBulk

+ func (u *ChannelUpsertBulk) UpdateUpdatedAt() *ChannelUpsertBulk

+ type ChannelUpsertOne struct

+ func (u *ChannelUpsertOne) DoNothing() *ChannelUpsertOne

+ func (u *ChannelUpsertOne) Exec(ctx context.Context) error

+ func (u *ChannelUpsertOne) ExecX(ctx context.Context)

+ func (u *ChannelUpsertOne) ID(ctx context.Context) (id uuid.UUID, err error)

+ func (u *ChannelUpsertOne) IDX(ctx context.Context) uuid.UUID

+ func (u *ChannelUpsertOne) Ignore() *ChannelUpsertOne

+ func (u *ChannelUpsertOne) SetCreatedAt(v time.Time) *ChannelUpsertOne

+ func (u *ChannelUpsertOne) SetDisplayName(v string) *ChannelUpsertOne

+ func (u *ChannelUpsertOne) SetImagePath(v string) *ChannelUpsertOne

+ func (u *ChannelUpsertOne) SetName(v string) *ChannelUpsertOne

+ func (u *ChannelUpsertOne) SetUpdatedAt(v time.Time) *ChannelUpsertOne

+ func (u *ChannelUpsertOne) Update(set func(*ChannelUpsert)) *ChannelUpsertOne

+ func (u *ChannelUpsertOne) UpdateCreatedAt() *ChannelUpsertOne

+ func (u *ChannelUpsertOne) UpdateDisplayName() *ChannelUpsertOne

+ func (u *ChannelUpsertOne) UpdateImagePath() *ChannelUpsertOne

+ func (u *ChannelUpsertOne) UpdateName() *ChannelUpsertOne

+ func (u *ChannelUpsertOne) UpdateNewValues() *ChannelUpsertOne

+ func (u *ChannelUpsertOne) UpdateUpdatedAt() *ChannelUpsertOne

type Client

+ Playback *PlaybackClient

type LiveCreate

+ func (lc *LiveCreate) OnConflict(opts ...sql.ConflictOption) *LiveUpsertOne

+ func (lc *LiveCreate) OnConflictColumns(columns ...string) *LiveUpsertOne

type LiveCreateBulk

+ func (lcb *LiveCreateBulk) OnConflict(opts ...sql.ConflictOption) *LiveUpsertBulk

+ func (lcb *LiveCreateBulk) OnConflictColumns(columns ...string) *LiveUpsertBulk

type LiveQuery

+ func (lq *LiveQuery) Modify(modifiers ...func(s *sql.Selector)) *LiveSelect

type LiveSelect

+ func (ls *LiveSelect) Modify(modifiers ...func(s *sql.Selector)) *LiveSelect

+ type LiveUpsert struct

+ func (u *LiveUpsert) ClearResolution() *LiveUpsert

+ func (u *LiveUpsert) SetArchiveChat(v bool) *LiveUpsert

+ func (u *LiveUpsert) SetCreatedAt(v time.Time) *LiveUpsert

+ func (u *LiveUpsert) SetIsLive(v bool) *LiveUpsert

+ func (u *LiveUpsert) SetLastLive(v time.Time) *LiveUpsert

+ func (u *LiveUpsert) SetResolution(v string) *LiveUpsert

+ func (u *LiveUpsert) SetUpdatedAt(v time.Time) *LiveUpsert

+ func (u *LiveUpsert) UpdateArchiveChat() *LiveUpsert

+ func (u *LiveUpsert) UpdateCreatedAt() *LiveUpsert

+ func (u *LiveUpsert) UpdateIsLive() *LiveUpsert

+ func (u *LiveUpsert) UpdateLastLive() *LiveUpsert

+ func (u *LiveUpsert) UpdateResolution() *LiveUpsert

+ func (u *LiveUpsert) UpdateUpdatedAt() *LiveUpsert

+ type LiveUpsertBulk struct

+ func (u *LiveUpsertBulk) ClearResolution() *LiveUpsertBulk

+ func (u *LiveUpsertBulk) DoNothing() *LiveUpsertBulk

+ func (u *LiveUpsertBulk) Exec(ctx context.Context) error

+ func (u *LiveUpsertBulk) ExecX(ctx context.Context)

+ func (u *LiveUpsertBulk) Ignore() *LiveUpsertBulk

+ func (u *LiveUpsertBulk) SetArchiveChat(v bool) *LiveUpsertBulk

+ func (u *LiveUpsertBulk) SetCreatedAt(v time.Time) *LiveUpsertBulk

+ func (u *LiveUpsertBulk) SetIsLive(v bool) *LiveUpsertBulk

+ func (u *LiveUpsertBulk) SetLastLive(v time.Time) *LiveUpsertBulk

+ func (u *LiveUpsertBulk) SetResolution(v string) *LiveUpsertBulk

+ func (u *LiveUpsertBulk) SetUpdatedAt(v time.Time) *LiveUpsertBulk

+ func (u *LiveUpsertBulk) Update(set func(*LiveUpsert)) *LiveUpsertBulk

+ func (u *LiveUpsertBulk) UpdateArchiveChat() *LiveUpsertBulk

+ func (u *LiveUpsertBulk) UpdateCreatedAt() *LiveUpsertBulk

+ func (u *LiveUpsertBulk) UpdateIsLive() *LiveUpsertBulk

+ func (u *LiveUpsertBulk) UpdateLastLive() *LiveUpsertBulk

+ func (u *LiveUpsertBulk) UpdateNewValues() *LiveUpsertBulk

+ func (u *LiveUpsertBulk) UpdateResolution() *LiveUpsertBulk

+ func (u *LiveUpsertBulk) UpdateUpdatedAt() *LiveUpsertBulk

+ type LiveUpsertOne struct

+ func (u *LiveUpsertOne) ClearResolution() *LiveUpsertOne

+ func (u *LiveUpsertOne) DoNothing() *LiveUpsertOne

+ func (u *LiveUpsertOne) Exec(ctx context.Context) error

+ func (u *LiveUpsertOne) ExecX(ctx context.Context)

+ func (u *LiveUpsertOne) ID(ctx context.Context) (id uuid.UUID, err error)

+ func (u *LiveUpsertOne) IDX(ctx context.Context) uuid.UUID

+ func (u *LiveUpsertOne) Ignore() *LiveUpsertOne

+ func (u *LiveUpsertOne) SetArchiveChat(v bool) *LiveUpsertOne

+ func (u *LiveUpsertOne) SetCreatedAt(v time.Time) *LiveUpsertOne

+ func (u *LiveUpsertOne) SetIsLive(v bool) *LiveUpsertOne

+ func (u *LiveUpsertOne) SetLastLive(v time.Time) *LiveUpsertOne

+ func (u *LiveUpsertOne) SetResolution(v string) *LiveUpsertOne

+ func (u *LiveUpsertOne) SetUpdatedAt(v time.Time) *LiveUpsertOne

+ func (u *LiveUpsertOne) Update(set func(*LiveUpsert)) *LiveUpsertOne

+ func (u *LiveUpsertOne) UpdateArchiveChat() *LiveUpsertOne

+ func (u *LiveUpsertOne) UpdateCreatedAt() *LiveUpsertOne

+ func (u *LiveUpsertOne) UpdateIsLive() *LiveUpsertOne

+ func (u *LiveUpsertOne) UpdateLastLive() *LiveUpsertOne

+ func (u *LiveUpsertOne) UpdateNewValues() *LiveUpsertOne

+ func (u *LiveUpsertOne) UpdateResolution() *LiveUpsertOne

+ func (u *LiveUpsertOne) UpdateUpdatedAt() *LiveUpsertOne

+ type Playback struct

+ CreatedAt time.Time

+ ID uuid.UUID

+ Status utils.PlaybackStatus

+ Time int

+ UpdatedAt time.Time

+ UserID uuid.UUID

+ VodID uuid.UUID

+ func (pl *Playback) String() string

+ func (pl *Playback) Unwrap() *Playback

+ func (pl *Playback) Update() *PlaybackUpdateOne

+ type PlaybackClient struct

+ func NewPlaybackClient(c config) *PlaybackClient

+ func (c *PlaybackClient) Create() *PlaybackCreate

+ func (c *PlaybackClient) CreateBulk(builders ...*PlaybackCreate) *PlaybackCreateBulk

+ func (c *PlaybackClient) Delete() *PlaybackDelete

+ func (c *PlaybackClient) DeleteOne(pl *Playback) *PlaybackDeleteOne

+ func (c *PlaybackClient) DeleteOneID(id uuid.UUID) *PlaybackDeleteOne

+ func (c *PlaybackClient) Get(ctx context.Context, id uuid.UUID) (*Playback, error)

+ func (c *PlaybackClient) GetX(ctx context.Context, id uuid.UUID) *Playback

+ func (c *PlaybackClient) Hooks() []Hook

+ func (c *PlaybackClient) Query() *PlaybackQuery

+ func (c *PlaybackClient) Update() *PlaybackUpdate

+ func (c *PlaybackClient) UpdateOne(pl *Playback) *PlaybackUpdateOne

+ func (c *PlaybackClient) UpdateOneID(id uuid.UUID) *PlaybackUpdateOne

+ func (c *PlaybackClient) Use(hooks ...Hook)

+ type PlaybackCreate struct

+ func (pc *PlaybackCreate) Exec(ctx context.Context) error

+ func (pc *PlaybackCreate) ExecX(ctx context.Context)

+ func (pc *PlaybackCreate) Mutation() *PlaybackMutation

+ func (pc *PlaybackCreate) OnConflict(opts ...sql.ConflictOption) *PlaybackUpsertOne

+ func (pc *PlaybackCreate) OnConflictColumns(columns ...string) *PlaybackUpsertOne

+ func (pc *PlaybackCreate) Save(ctx context.Context) (*Playback, error)

+ func (pc *PlaybackCreate) SaveX(ctx context.Context) *Playback

+ func (pc *PlaybackCreate) SetCreatedAt(t time.Time) *PlaybackCreate

+ func (pc *PlaybackCreate) SetID(u uuid.UUID) *PlaybackCreate

+ func (pc *PlaybackCreate) SetNillableCreatedAt(t *time.Time) *PlaybackCreate

+ func (pc *PlaybackCreate) SetNillableID(u *uuid.UUID) *PlaybackCreate

+ func (pc *PlaybackCreate) SetNillableStatus(us *utils.PlaybackStatus) *PlaybackCreate

+ func (pc *PlaybackCreate) SetNillableTime(i *int) *PlaybackCreate

+ func (pc *PlaybackCreate) SetNillableUpdatedAt(t *time.Time) *PlaybackCreate

+ func (pc *PlaybackCreate) SetStatus(us utils.PlaybackStatus) *PlaybackCreate

+ func (pc *PlaybackCreate) SetTime(i int) *PlaybackCreate

+ func (pc *PlaybackCreate) SetUpdatedAt(t time.Time) *PlaybackCreate

+ func (pc *PlaybackCreate) SetUserID(u uuid.UUID) *PlaybackCreate

+ func (pc *PlaybackCreate) SetVodID(u uuid.UUID) *PlaybackCreate

+ type PlaybackCreateBulk struct

+ func (pcb *PlaybackCreateBulk) Exec(ctx context.Context) error

+ func (pcb *PlaybackCreateBulk) ExecX(ctx context.Context)

+ func (pcb *PlaybackCreateBulk) OnConflict(opts ...sql.ConflictOption) *PlaybackUpsertBulk

+ func (pcb *PlaybackCreateBulk) OnConflictColumns(columns ...string) *PlaybackUpsertBulk

+ func (pcb *PlaybackCreateBulk) Save(ctx context.Context) ([]*Playback, error)

+ func (pcb *PlaybackCreateBulk) SaveX(ctx context.Context) []*Playback

+ type PlaybackDelete struct

+ func (pd *PlaybackDelete) Exec(ctx context.Context) (int, error)

+ func (pd *PlaybackDelete) ExecX(ctx context.Context) int

+ func (pd *PlaybackDelete) Where(ps ...predicate.Playback) *PlaybackDelete

+ type PlaybackDeleteOne struct

+ func (pdo *PlaybackDeleteOne) Exec(ctx context.Context) error

+ func (pdo *PlaybackDeleteOne) ExecX(ctx context.Context)

+ type PlaybackGroupBy struct

+ func (pgb *PlaybackGroupBy) Aggregate(fns ...AggregateFunc) *PlaybackGroupBy

+ func (pgb *PlaybackGroupBy) Bool(ctx context.Context) (_ bool, err error)

+ func (pgb *PlaybackGroupBy) BoolX(ctx context.Context) bool

+ func (pgb *PlaybackGroupBy) Bools(ctx context.Context) ([]bool, error)

+ func (pgb *PlaybackGroupBy) BoolsX(ctx context.Context) []bool

+ func (pgb *PlaybackGroupBy) Float64(ctx context.Context) (_ float64, err error)

+ func (pgb *PlaybackGroupBy) Float64X(ctx context.Context) float64

+ func (pgb *PlaybackGroupBy) Float64s(ctx context.Context) ([]float64, error)

+ func (pgb *PlaybackGroupBy) Float64sX(ctx context.Context) []float64

+ func (pgb *PlaybackGroupBy) Int(ctx context.Context) (_ int, err error)

+ func (pgb *PlaybackGroupBy) IntX(ctx context.Context) int

+ func (pgb *PlaybackGroupBy) Ints(ctx context.Context) ([]int, error)

+ func (pgb *PlaybackGroupBy) IntsX(ctx context.Context) []int

+ func (pgb *PlaybackGroupBy) Scan(ctx context.Context, v interface{}) error

+ func (pgb *PlaybackGroupBy) ScanX(ctx context.Context, v interface{})

+ func (pgb *PlaybackGroupBy) String(ctx context.Context) (_ string, err error)

+ func (pgb *PlaybackGroupBy) StringX(ctx context.Context) string

+ func (pgb *PlaybackGroupBy) Strings(ctx context.Context) ([]string, error)

+ func (pgb *PlaybackGroupBy) StringsX(ctx context.Context) []string

+ type PlaybackMutation struct

+ func (m *PlaybackMutation) AddField(name string, value ent.Value) error

+ func (m *PlaybackMutation) AddTime(i int)

+ func (m *PlaybackMutation) AddedEdges() []string

+ func (m *PlaybackMutation) AddedField(name string) (ent.Value, bool)

+ func (m *PlaybackMutation) AddedFields() []string

+ func (m *PlaybackMutation) AddedIDs(name string) []ent.Value

+ func (m *PlaybackMutation) AddedTime() (r int, exists bool)

+ func (m *PlaybackMutation) ClearEdge(name string) error

+ func (m *PlaybackMutation) ClearField(name string) error

+ func (m *PlaybackMutation) ClearStatus()

+ func (m *PlaybackMutation) ClearedEdges() []string

+ func (m *PlaybackMutation) ClearedFields() []string

+ func (m *PlaybackMutation) CreatedAt() (r time.Time, exists bool)

+ func (m *PlaybackMutation) EdgeCleared(name string) bool

+ func (m *PlaybackMutation) Field(name string) (ent.Value, bool)

+ func (m *PlaybackMutation) FieldCleared(name string) bool

+ func (m *PlaybackMutation) Fields() []string

+ func (m *PlaybackMutation) ID() (id uuid.UUID, exists bool)

+ func (m *PlaybackMutation) IDs(ctx context.Context) ([]uuid.UUID, error)

+ func (m *PlaybackMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error)

+ func (m *PlaybackMutation) OldField(ctx context.Context, name string) (ent.Value, error)

+ func (m *PlaybackMutation) OldStatus(ctx context.Context) (v utils.PlaybackStatus, err error)

+ func (m *PlaybackMutation) OldTime(ctx context.Context) (v int, err error)

+ func (m *PlaybackMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error)

+ func (m *PlaybackMutation) OldUserID(ctx context.Context) (v uuid.UUID, err error)

+ func (m *PlaybackMutation) OldVodID(ctx context.Context) (v uuid.UUID, err error)

+ func (m *PlaybackMutation) Op() Op

+ func (m *PlaybackMutation) RemovedEdges() []string

+ func (m *PlaybackMutation) RemovedIDs(name string) []ent.Value

+ func (m *PlaybackMutation) ResetCreatedAt()

+ func (m *PlaybackMutation) ResetEdge(name string) error

+ func (m *PlaybackMutation) ResetField(name string) error

+ func (m *PlaybackMutation) ResetStatus()

+ func (m *PlaybackMutation) ResetTime()

+ func (m *PlaybackMutation) ResetUpdatedAt()

+ func (m *PlaybackMutation) ResetUserID()

+ func (m *PlaybackMutation) ResetVodID()

+ func (m *PlaybackMutation) SetCreatedAt(t time.Time)

+ func (m *PlaybackMutation) SetField(name string, value ent.Value) error

+ func (m *PlaybackMutation) SetID(id uuid.UUID)

+ func (m *PlaybackMutation) SetStatus(us utils.PlaybackStatus)

+ func (m *PlaybackMutation) SetTime(i int)

+ func (m *PlaybackMutation) SetUpdatedAt(t time.Time)

+ func (m *PlaybackMutation) SetUserID(u uuid.UUID)

+ func (m *PlaybackMutation) SetVodID(u uuid.UUID)

+ func (m *PlaybackMutation) Status() (r utils.PlaybackStatus, exists bool)

+ func (m *PlaybackMutation) StatusCleared() bool

+ func (m *PlaybackMutation) Time() (r int, exists bool)

+ func (m *PlaybackMutation) Type() string

+ func (m *PlaybackMutation) UpdatedAt() (r time.Time, exists bool)

+ func (m *PlaybackMutation) UserID() (r uuid.UUID, exists bool)

+ func (m *PlaybackMutation) VodID() (r uuid.UUID, exists bool)

+ func (m *PlaybackMutation) Where(ps ...predicate.Playback)

+ func (m PlaybackMutation) Client() *Client

+ func (m PlaybackMutation) Tx() (*Tx, error)

+ type PlaybackQuery struct

+ func (pq *PlaybackQuery) All(ctx context.Context) ([]*Playback, error)

+ func (pq *PlaybackQuery) AllX(ctx context.Context) []*Playback

+ func (pq *PlaybackQuery) Clone() *PlaybackQuery

+ func (pq *PlaybackQuery) Count(ctx context.Context) (int, error)

+ func (pq *PlaybackQuery) CountX(ctx context.Context) int

+ func (pq *PlaybackQuery) Exist(ctx context.Context) (bool, error)

+ func (pq *PlaybackQuery) ExistX(ctx context.Context) bool

+ func (pq *PlaybackQuery) First(ctx context.Context) (*Playback, error)

+ func (pq *PlaybackQuery) FirstID(ctx context.Context) (id uuid.UUID, err error)

+ func (pq *PlaybackQuery) FirstIDX(ctx context.Context) uuid.UUID

+ func (pq *PlaybackQuery) FirstX(ctx context.Context) *Playback

+ func (pq *PlaybackQuery) GroupBy(field string, fields ...string) *PlaybackGroupBy

+ func (pq *PlaybackQuery) IDs(ctx context.Context) ([]uuid.UUID, error)

+ func (pq *PlaybackQuery) IDsX(ctx context.Context) []uuid.UUID

+ func (pq *PlaybackQuery) Limit(limit int) *PlaybackQuery

+ func (pq *PlaybackQuery) Modify(modifiers ...func(s *sql.Selector)) *PlaybackSelect

+ func (pq *PlaybackQuery) Offset(offset int) *PlaybackQuery

+ func (pq *PlaybackQuery) Only(ctx context.Context) (*Playback, error)

+ func (pq *PlaybackQuery) OnlyID(ctx context.Context) (id uuid.UUID, err error)

+ func (pq *PlaybackQuery) OnlyIDX(ctx context.Context) uuid.UUID

+ func (pq *PlaybackQuery) OnlyX(ctx context.Context) *Playback

+ func (pq *PlaybackQuery) Order(o ...OrderFunc) *PlaybackQuery

+ func (pq *PlaybackQuery) Select(fields ...string) *PlaybackSelect

+ func (pq *PlaybackQuery) Unique(unique bool) *PlaybackQuery

+ func (pq *PlaybackQuery) Where(ps ...predicate.Playback) *PlaybackQuery

+ type PlaybackSelect struct

+ func (ps *PlaybackSelect) Bool(ctx context.Context) (_ bool, err error)

+ func (ps *PlaybackSelect) BoolX(ctx context.Context) bool

+ func (ps *PlaybackSelect) Bools(ctx context.Context) ([]bool, error)

+ func (ps *PlaybackSelect) BoolsX(ctx context.Context) []bool

+ func (ps *PlaybackSelect) Float64(ctx context.Context) (_ float64, err error)

+ func (ps *PlaybackSelect) Float64X(ctx context.Context) float64

+ func (ps *PlaybackSelect) Float64s(ctx context.Context) ([]float64, error)

+ func (ps *PlaybackSelect) Float64sX(ctx context.Context) []float64

+ func (ps *PlaybackSelect) Int(ctx context.Context) (_ int, err error)

+ func (ps *PlaybackSelect) IntX(ctx context.Context) int

+ func (ps *PlaybackSelect) Ints(ctx context.Context) ([]int, error)

+ func (ps *PlaybackSelect) IntsX(ctx context.Context) []int

+ func (ps *PlaybackSelect) Modify(modifiers ...func(s *sql.Selector)) *PlaybackSelect

+ func (ps *PlaybackSelect) Scan(ctx context.Context, v interface{}) error

+ func (ps *PlaybackSelect) ScanX(ctx context.Context, v interface{})

+ func (ps *PlaybackSelect) String(ctx context.Context) (_ string, err error)

+ func (ps *PlaybackSelect) StringX(ctx context.Context) string

+ func (ps *PlaybackSelect) Strings(ctx context.Context) ([]string, error)

+ func (ps *PlaybackSelect) StringsX(ctx context.Context) []string

+ type PlaybackUpdate struct

+ func (pu *PlaybackUpdate) AddTime(i int) *PlaybackUpdate

+ func (pu *PlaybackUpdate) ClearStatus() *PlaybackUpdate

+ func (pu *PlaybackUpdate) Exec(ctx context.Context) error

+ func (pu *PlaybackUpdate) ExecX(ctx context.Context)

+ func (pu *PlaybackUpdate) Mutation() *PlaybackMutation

+ func (pu *PlaybackUpdate) Save(ctx context.Context) (int, error)

+ func (pu *PlaybackUpdate) SaveX(ctx context.Context) int

+ func (pu *PlaybackUpdate) SetNillableStatus(us *utils.PlaybackStatus) *PlaybackUpdate

+ func (pu *PlaybackUpdate) SetNillableTime(i *int) *PlaybackUpdate

+ func (pu *PlaybackUpdate) SetStatus(us utils.PlaybackStatus) *PlaybackUpdate

+ func (pu *PlaybackUpdate) SetTime(i int) *PlaybackUpdate

+ func (pu *PlaybackUpdate) SetUpdatedAt(t time.Time) *PlaybackUpdate

+ func (pu *PlaybackUpdate) SetUserID(u uuid.UUID) *PlaybackUpdate

+ func (pu *PlaybackUpdate) SetVodID(u uuid.UUID) *PlaybackUpdate

+ func (pu *PlaybackUpdate) Where(ps ...predicate.Playback) *PlaybackUpdate

+ type PlaybackUpdateOne struct

+ func (puo *PlaybackUpdateOne) AddTime(i int) *PlaybackUpdateOne

+ func (puo *PlaybackUpdateOne) ClearStatus() *PlaybackUpdateOne

+ func (puo *PlaybackUpdateOne) Exec(ctx context.Context) error

+ func (puo *PlaybackUpdateOne) ExecX(ctx context.Context)

+ func (puo *PlaybackUpdateOne) Mutation() *PlaybackMutation

+ func (puo *PlaybackUpdateOne) Save(ctx context.Context) (*Playback, error)

+ func (puo *PlaybackUpdateOne) SaveX(ctx context.Context) *Playback

+ func (puo *PlaybackUpdateOne) Select(field string, fields ...string) *PlaybackUpdateOne

+ func (puo *PlaybackUpdateOne) SetNillableStatus(us *utils.PlaybackStatus) *PlaybackUpdateOne

+ func (puo *PlaybackUpdateOne) SetNillableTime(i *int) *PlaybackUpdateOne

+ func (puo *PlaybackUpdateOne) SetStatus(us utils.PlaybackStatus) *PlaybackUpdateOne

+ func (puo *PlaybackUpdateOne) SetTime(i int) *PlaybackUpdateOne

+ func (puo *PlaybackUpdateOne) SetUpdatedAt(t time.Time) *PlaybackUpdateOne

+ func (puo *PlaybackUpdateOne) SetUserID(u uuid.UUID) *PlaybackUpdateOne

+ func (puo *PlaybackUpdateOne) SetVodID(u uuid.UUID) *PlaybackUpdateOne

+ type PlaybackUpsert struct

+ func (u *PlaybackUpsert) AddTime(v int) *PlaybackUpsert

+ func (u *PlaybackUpsert) ClearStatus() *PlaybackUpsert

+ func (u *PlaybackUpsert) SetCreatedAt(v time.Time) *PlaybackUpsert

+ func (u *PlaybackUpsert) SetStatus(v utils.PlaybackStatus) *PlaybackUpsert

+ func (u *PlaybackUpsert) SetTime(v int) *PlaybackUpsert

+ func (u *PlaybackUpsert) SetUpdatedAt(v time.Time) *PlaybackUpsert

+ func (u *PlaybackUpsert) SetUserID(v uuid.UUID) *PlaybackUpsert

+ func (u *PlaybackUpsert) SetVodID(v uuid.UUID) *PlaybackUpsert

+ func (u *PlaybackUpsert) UpdateCreatedAt() *PlaybackUpsert

+ func (u *PlaybackUpsert) UpdateStatus() *PlaybackUpsert

+ func (u *PlaybackUpsert) UpdateTime() *PlaybackUpsert

+ func (u *PlaybackUpsert) UpdateUpdatedAt() *PlaybackUpsert

+ func (u *PlaybackUpsert) UpdateUserID() *PlaybackUpsert

+ func (u *PlaybackUpsert) UpdateVodID() *PlaybackUpsert

+ type PlaybackUpsertBulk struct

+ func (u *PlaybackUpsertBulk) AddTime(v int) *PlaybackUpsertBulk

+ func (u *PlaybackUpsertBulk) ClearStatus() *PlaybackUpsertBulk

+ func (u *PlaybackUpsertBulk) DoNothing() *PlaybackUpsertBulk

+ func (u *PlaybackUpsertBulk) Exec(ctx context.Context) error

+ func (u *PlaybackUpsertBulk) ExecX(ctx context.Context)

+ func (u *PlaybackUpsertBulk) Ignore() *PlaybackUpsertBulk

+ func (u *PlaybackUpsertBulk) SetCreatedAt(v time.Time) *PlaybackUpsertBulk

+ func (u *PlaybackUpsertBulk) SetStatus(v utils.PlaybackStatus) *PlaybackUpsertBulk

+ func (u *PlaybackUpsertBulk) SetTime(v int) *PlaybackUpsertBulk

+ func (u *PlaybackUpsertBulk) SetUpdatedAt(v time.Time) *PlaybackUpsertBulk

+ func (u *PlaybackUpsertBulk) SetUserID(v uuid.UUID) *PlaybackUpsertBulk

+ func (u *PlaybackUpsertBulk) SetVodID(v uuid.UUID) *PlaybackUpsertBulk

+ func (u *PlaybackUpsertBulk) Update(set func(*PlaybackUpsert)) *PlaybackUpsertBulk

+ func (u *PlaybackUpsertBulk) UpdateCreatedAt() *PlaybackUpsertBulk

+ func (u *PlaybackUpsertBulk) UpdateNewValues() *PlaybackUpsertBulk

+ func (u *PlaybackUpsertBulk) UpdateStatus() *PlaybackUpsertBulk

+ func (u *PlaybackUpsertBulk) UpdateTime() *PlaybackUpsertBulk

+ func (u *PlaybackUpsertBulk) UpdateUpdatedAt() *PlaybackUpsertBulk

+ func (u *PlaybackUpsertBulk) UpdateUserID() *PlaybackUpsertBulk

+ func (u *PlaybackUpsertBulk) UpdateVodID() *PlaybackUpsertBulk

+ type PlaybackUpsertOne struct

+ func (u *PlaybackUpsertOne) AddTime(v int) *PlaybackUpsertOne

+ func (u *PlaybackUpsertOne) ClearStatus() *PlaybackUpsertOne

+ func (u *PlaybackUpsertOne) DoNothing() *PlaybackUpsertOne

+ func (u *PlaybackUpsertOne) Exec(ctx context.Context) error

+ func (u *PlaybackUpsertOne) ExecX(ctx context.Context)

+ func (u *PlaybackUpsertOne) ID(ctx context.Context) (id uuid.UUID, err error)

+ func (u *PlaybackUpsertOne) IDX(ctx context.Context) uuid.UUID

+ func (u *PlaybackUpsertOne) Ignore() *PlaybackUpsertOne

+ func (u *PlaybackUpsertOne) SetCreatedAt(v time.Time) *PlaybackUpsertOne

+ func (u *PlaybackUpsertOne) SetStatus(v utils.PlaybackStatus) *PlaybackUpsertOne

+ func (u *PlaybackUpsertOne) SetTime(v int) *PlaybackUpsertOne

+ func (u *PlaybackUpsertOne) SetUpdatedAt(v time.Time) *PlaybackUpsertOne

+ func (u *PlaybackUpsertOne) SetUserID(v uuid.UUID) *PlaybackUpsertOne

+ func (u *PlaybackUpsertOne) SetVodID(v uuid.UUID) *PlaybackUpsertOne

+ func (u *PlaybackUpsertOne) Update(set func(*PlaybackUpsert)) *PlaybackUpsertOne

+ func (u *PlaybackUpsertOne) UpdateCreatedAt() *PlaybackUpsertOne

+ func (u *PlaybackUpsertOne) UpdateNewValues() *PlaybackUpsertOne

+ func (u *PlaybackUpsertOne) UpdateStatus() *PlaybackUpsertOne

+ func (u *PlaybackUpsertOne) UpdateTime() *PlaybackUpsertOne

+ func (u *PlaybackUpsertOne) UpdateUpdatedAt() *PlaybackUpsertOne

+ func (u *PlaybackUpsertOne) UpdateUserID() *PlaybackUpsertOne

+ func (u *PlaybackUpsertOne) UpdateVodID() *PlaybackUpsertOne

+ type Playbacks []*Playback

type QueueCreate

+ func (qc *QueueCreate) OnConflict(opts ...sql.ConflictOption) *QueueUpsertOne

+ func (qc *QueueCreate) OnConflictColumns(columns ...string) *QueueUpsertOne

type QueueCreateBulk

+ func (qcb *QueueCreateBulk) OnConflict(opts ...sql.ConflictOption) *QueueUpsertBulk

+ func (qcb *QueueCreateBulk) OnConflictColumns(columns ...string) *QueueUpsertBulk

type QueueQuery

+ func (qq *QueueQuery) Modify(modifiers ...func(s *sql.Selector)) *QueueSelect

type QueueSelect

+ func (qs *QueueSelect) Modify(modifiers ...func(s *sql.Selector)) *QueueSelect

+ type QueueUpsert struct

+ func (u *QueueUpsert) ClearChatStart() *QueueUpsert

+ func (u *QueueUpsert) ClearTaskChatConvert() *QueueUpsert

+ func (u *QueueUpsert) ClearTaskChatDownload() *QueueUpsert

+ func (u *QueueUpsert) ClearTaskChatMove() *QueueUpsert

+ func (u *QueueUpsert) ClearTaskChatRender() *QueueUpsert

+ func (u *QueueUpsert) ClearTaskVideoConvert() *QueueUpsert

+ func (u *QueueUpsert) ClearTaskVideoDownload() *QueueUpsert

+ func (u *QueueUpsert) ClearTaskVideoMove() *QueueUpsert

+ func (u *QueueUpsert) ClearTaskVodCreateFolder() *QueueUpsert

+ func (u *QueueUpsert) ClearTaskVodDownloadThumbnail() *QueueUpsert

+ func (u *QueueUpsert) ClearTaskVodSaveInfo() *QueueUpsert

+ func (u *QueueUpsert) SetChatProcessing(v bool) *QueueUpsert

+ func (u *QueueUpsert) SetChatStart(v time.Time) *QueueUpsert

+ func (u *QueueUpsert) SetCreatedAt(v time.Time) *QueueUpsert

+ func (u *QueueUpsert) SetLiveArchive(v bool) *QueueUpsert

+ func (u *QueueUpsert) SetOnHold(v bool) *QueueUpsert

+ func (u *QueueUpsert) SetProcessing(v bool) *QueueUpsert

+ func (u *QueueUpsert) SetTaskChatConvert(v utils.TaskStatus) *QueueUpsert

+ func (u *QueueUpsert) SetTaskChatDownload(v utils.TaskStatus) *QueueUpsert

+ func (u *QueueUpsert) SetTaskChatMove(v utils.TaskStatus) *QueueUpsert

+ func (u *QueueUpsert) SetTaskChatRender(v utils.TaskStatus) *QueueUpsert

+ func (u *QueueUpsert) SetTaskVideoConvert(v utils.TaskStatus) *QueueUpsert

+ func (u *QueueUpsert) SetTaskVideoDownload(v utils.TaskStatus) *QueueUpsert

+ func (u *QueueUpsert) SetTaskVideoMove(v utils.TaskStatus) *QueueUpsert

+ func (u *QueueUpsert) SetTaskVodCreateFolder(v utils.TaskStatus) *QueueUpsert

+ func (u *QueueUpsert) SetTaskVodDownloadThumbnail(v utils.TaskStatus) *QueueUpsert

+ func (u *QueueUpsert) SetTaskVodSaveInfo(v utils.TaskStatus) *QueueUpsert

+ func (u *QueueUpsert) SetUpdatedAt(v time.Time) *QueueUpsert

+ func (u *QueueUpsert) SetVideoProcessing(v bool) *QueueUpsert

+ func (u *QueueUpsert) UpdateChatProcessing() *QueueUpsert

+ func (u *QueueUpsert) UpdateChatStart() *QueueUpsert

+ func (u *QueueUpsert) UpdateCreatedAt() *QueueUpsert

+ func (u *QueueUpsert) UpdateLiveArchive() *QueueUpsert

+ func (u *QueueUpsert) UpdateOnHold() *QueueUpsert

+ func (u *QueueUpsert) UpdateProcessing() *QueueUpsert

+ func (u *QueueUpsert) UpdateTaskChatConvert() *QueueUpsert

+ func (u *QueueUpsert) UpdateTaskChatDownload() *QueueUpsert

+ func (u *QueueUpsert) UpdateTaskChatMove() *QueueUpsert

+ func (u *QueueUpsert) UpdateTaskChatRender() *QueueUpsert

+ func (u *QueueUpsert) UpdateTaskVideoConvert() *QueueUpsert

+ func (u *QueueUpsert) UpdateTaskVideoDownload() *QueueUpsert

+ func (u *QueueUpsert) UpdateTaskVideoMove() *QueueUpsert

+ func (u *QueueUpsert) UpdateTaskVodCreateFolder() *QueueUpsert

+ func (u *QueueUpsert) UpdateTaskVodDownloadThumbnail() *QueueUpsert

+ func (u *QueueUpsert) UpdateTaskVodSaveInfo() *QueueUpsert

+ func (u *QueueUpsert) UpdateUpdatedAt() *QueueUpsert

+ func (u *QueueUpsert) UpdateVideoProcessing() *QueueUpsert

+ type QueueUpsertBulk struct

+ func (u *QueueUpsertBulk) ClearChatStart() *QueueUpsertBulk

+ func (u *QueueUpsertBulk) ClearTaskChatConvert() *QueueUpsertBulk

+ func (u *QueueUpsertBulk) ClearTaskChatDownload() *QueueUpsertBulk

+ func (u *QueueUpsertBulk) ClearTaskChatMove() *QueueUpsertBulk

+ func (u *QueueUpsertBulk) ClearTaskChatRender() *QueueUpsertBulk

+ func (u *QueueUpsertBulk) ClearTaskVideoConvert() *QueueUpsertBulk

+ func (u *QueueUpsertBulk) ClearTaskVideoDownload() *QueueUpsertBulk

+ func (u *QueueUpsertBulk) ClearTaskVideoMove() *QueueUpsertBulk

+ func (u *QueueUpsertBulk) ClearTaskVodCreateFolder() *QueueUpsertBulk

+ func (u *QueueUpsertBulk) ClearTaskVodDownloadThumbnail() *QueueUpsertBulk

+ func (u *QueueUpsertBulk) ClearTaskVodSaveInfo() *QueueUpsertBulk

+ func (u *QueueUpsertBulk) DoNothing() *QueueUpsertBulk

+ func (u *QueueUpsertBulk) Exec(ctx context.Context) error

+ func (u *QueueUpsertBulk) ExecX(ctx context.Context)

+ func (u *QueueUpsertBulk) Ignore() *QueueUpsertBulk

+ func (u *QueueUpsertBulk) SetChatProcessing(v bool) *QueueUpsertBulk

+ func (u *QueueUpsertBulk) SetChatStart(v time.Time) *QueueUpsertBulk

+ func (u *QueueUpsertBulk) SetCreatedAt(v time.Time) *QueueUpsertBulk

+ func (u *QueueUpsertBulk) SetLiveArchive(v bool) *QueueUpsertBulk

+ func (u *QueueUpsertBulk) SetOnHold(v bool) *QueueUpsertBulk

+ func (u *QueueUpsertBulk) SetProcessing(v bool) *QueueUpsertBulk

+ func (u *QueueUpsertBulk) SetTaskChatConvert(v utils.TaskStatus) *QueueUpsertBulk

+ func (u *QueueUpsertBulk) SetTaskChatDownload(v utils.TaskStatus) *QueueUpsertBulk

+ func (u *QueueUpsertBulk) SetTaskChatMove(v utils.TaskStatus) *QueueUpsertBulk

+ func (u *QueueUpsertBulk) SetTaskChatRender(v utils.TaskStatus) *QueueUpsertBulk

+ func (u *QueueUpsertBulk) SetTaskVideoConvert(v utils.TaskStatus) *QueueUpsertBulk

+ func (u *QueueUpsertBulk) SetTaskVideoDownload(v utils.TaskStatus) *QueueUpsertBulk

+ func (u *QueueUpsertBulk) SetTaskVideoMove(v utils.TaskStatus) *QueueUpsertBulk

+ func (u *QueueUpsertBulk) SetTaskVodCreateFolder(v utils.TaskStatus) *QueueUpsertBulk

+ func (u *QueueUpsertBulk) SetTaskVodDownloadThumbnail(v utils.TaskStatus) *QueueUpsertBulk

+ func (u *QueueUpsertBulk) SetTaskVodSaveInfo(v utils.TaskStatus) *QueueUpsertBulk

+ func (u *QueueUpsertBulk) SetUpdatedAt(v time.Time) *QueueUpsertBulk

+ func (u *QueueUpsertBulk) SetVideoProcessing(v bool) *QueueUpsertBulk

+ func (u *QueueUpsertBulk) Update(set func(*QueueUpsert)) *QueueUpsertBulk

+ func (u *QueueUpsertBulk) UpdateChatProcessing() *QueueUpsertBulk

+ func (u *QueueUpsertBulk) UpdateChatStart() *QueueUpsertBulk

+ func (u *QueueUpsertBulk) UpdateCreatedAt() *QueueUpsertBulk

+ func (u *QueueUpsertBulk) UpdateLiveArchive() *QueueUpsertBulk

+ func (u *QueueUpsertBulk) UpdateNewValues() *QueueUpsertBulk

+ func (u *QueueUpsertBulk) UpdateOnHold() *QueueUpsertBulk

+ func (u *QueueUpsertBulk) UpdateProcessing() *QueueUpsertBulk

+ func (u *QueueUpsertBulk) UpdateTaskChatConvert() *QueueUpsertBulk

+ func (u *QueueUpsertBulk) UpdateTaskChatDownload() *QueueUpsertBulk

+ func (u *QueueUpsertBulk) UpdateTaskChatMove() *QueueUpsertBulk

+ func (u *QueueUpsertBulk) UpdateTaskChatRender() *QueueUpsertBulk

+ func (u *QueueUpsertBulk) UpdateTaskVideoConvert() *QueueUpsertBulk

+ func (u *QueueUpsertBulk) UpdateTaskVideoDownload() *QueueUpsertBulk

+ func (u *QueueUpsertBulk) UpdateTaskVideoMove() *QueueUpsertBulk

+ func (u *QueueUpsertBulk) UpdateTaskVodCreateFolder() *QueueUpsertBulk

+ func (u *QueueUpsertBulk) UpdateTaskVodDownloadThumbnail() *QueueUpsertBulk

+ func (u *QueueUpsertBulk) UpdateTaskVodSaveInfo() *QueueUpsertBulk

+ func (u *QueueUpsertBulk) UpdateUpdatedAt() *QueueUpsertBulk

+ func (u *QueueUpsertBulk) UpdateVideoProcessing() *QueueUpsertBulk

+ type QueueUpsertOne struct

+ func (u *QueueUpsertOne) ClearChatStart() *QueueUpsertOne

+ func (u *QueueUpsertOne) ClearTaskChatConvert() *QueueUpsertOne

+ func (u *QueueUpsertOne) ClearTaskChatDownload() *QueueUpsertOne

+ func (u *QueueUpsertOne) ClearTaskChatMove() *QueueUpsertOne

+ func (u *QueueUpsertOne) ClearTaskChatRender() *QueueUpsertOne

+ func (u *QueueUpsertOne) ClearTaskVideoConvert() *QueueUpsertOne

+ func (u *QueueUpsertOne) ClearTaskVideoDownload() *QueueUpsertOne

+ func (u *QueueUpsertOne) ClearTaskVideoMove() *QueueUpsertOne

+ func (u *QueueUpsertOne) ClearTaskVodCreateFolder() *QueueUpsertOne

+ func (u *QueueUpsertOne) ClearTaskVodDownloadThumbnail() *QueueUpsertOne

+ func (u *QueueUpsertOne) ClearTaskVodSaveInfo() *QueueUpsertOne

+ func (u *QueueUpsertOne) DoNothing() *QueueUpsertOne

+ func (u *QueueUpsertOne) Exec(ctx context.Context) error

+ func (u *QueueUpsertOne) ExecX(ctx context.Context)

+ func (u *QueueUpsertOne) ID(ctx context.Context) (id uuid.UUID, err error)

+ func (u *QueueUpsertOne) IDX(ctx context.Context) uuid.UUID

+ func (u *QueueUpsertOne) Ignore() *QueueUpsertOne

+ func (u *QueueUpsertOne) SetChatProcessing(v bool) *QueueUpsertOne

+ func (u *QueueUpsertOne) SetChatStart(v time.Time) *QueueUpsertOne

+ func (u *QueueUpsertOne) SetCreatedAt(v time.Time) *QueueUpsertOne

+ func (u *QueueUpsertOne) SetLiveArchive(v bool) *QueueUpsertOne

+ func (u *QueueUpsertOne) SetOnHold(v bool) *QueueUpsertOne

+ func (u *QueueUpsertOne) SetProcessing(v bool) *QueueUpsertOne

+ func (u *QueueUpsertOne) SetTaskChatConvert(v utils.TaskStatus) *QueueUpsertOne

+ func (u *QueueUpsertOne) SetTaskChatDownload(v utils.TaskStatus) *QueueUpsertOne

+ func (u *QueueUpsertOne) SetTaskChatMove(v utils.TaskStatus) *QueueUpsertOne

+ func (u *QueueUpsertOne) SetTaskChatRender(v utils.TaskStatus) *QueueUpsertOne

+ func (u *QueueUpsertOne) SetTaskVideoConvert(v utils.TaskStatus) *QueueUpsertOne

+ func (u *QueueUpsertOne) SetTaskVideoDownload(v utils.TaskStatus) *QueueUpsertOne

+ func (u *QueueUpsertOne) SetTaskVideoMove(v utils.TaskStatus) *QueueUpsertOne

+ func (u *QueueUpsertOne) SetTaskVodCreateFolder(v utils.TaskStatus) *QueueUpsertOne

+ func (u *QueueUpsertOne) SetTaskVodDownloadThumbnail(v utils.TaskStatus) *QueueUpsertOne

+ func (u *QueueUpsertOne) SetTaskVodSaveInfo(v utils.TaskStatus) *QueueUpsertOne

+ func (u *QueueUpsertOne) SetUpdatedAt(v time.Time) *QueueUpsertOne

+ func (u *QueueUpsertOne) SetVideoProcessing(v bool) *QueueUpsertOne

+ func (u *QueueUpsertOne) Update(set func(*QueueUpsert)) *QueueUpsertOne

+ func (u *QueueUpsertOne) UpdateChatProcessing() *QueueUpsertOne

+ func (u *QueueUpsertOne) UpdateChatStart() *QueueUpsertOne

+ func (u *QueueUpsertOne) UpdateCreatedAt() *QueueUpsertOne

+ func (u *QueueUpsertOne) UpdateLiveArchive() *QueueUpsertOne

+ func (u *QueueUpsertOne) UpdateNewValues() *QueueUpsertOne

+ func (u *QueueUpsertOne) UpdateOnHold() *QueueUpsertOne

+ func (u *QueueUpsertOne) UpdateProcessing() *QueueUpsertOne

+ func (u *QueueUpsertOne) UpdateTaskChatConvert() *QueueUpsertOne

+ func (u *QueueUpsertOne) UpdateTaskChatDownload() *QueueUpsertOne

+ func (u *QueueUpsertOne) UpdateTaskChatMove() *QueueUpsertOne

+ func (u *QueueUpsertOne) UpdateTaskChatRender() *QueueUpsertOne

+ func (u *QueueUpsertOne) UpdateTaskVideoConvert() *QueueUpsertOne

+ func (u *QueueUpsertOne) UpdateTaskVideoDownload() *QueueUpsertOne

+ func (u *QueueUpsertOne) UpdateTaskVideoMove() *QueueUpsertOne

+ func (u *QueueUpsertOne) UpdateTaskVodCreateFolder() *QueueUpsertOne

+ func (u *QueueUpsertOne) UpdateTaskVodDownloadThumbnail() *QueueUpsertOne

+ func (u *QueueUpsertOne) UpdateTaskVodSaveInfo() *QueueUpsertOne

+ func (u *QueueUpsertOne) UpdateUpdatedAt() *QueueUpsertOne

+ func (u *QueueUpsertOne) UpdateVideoProcessing() *QueueUpsertOne

type Tx

+ Playback *PlaybackClient

type UserCreate

+ func (uc *UserCreate) OnConflict(opts ...sql.ConflictOption) *UserUpsertOne

+ func (uc *UserCreate) OnConflictColumns(columns ...string) *UserUpsertOne

type UserCreateBulk

+ func (ucb *UserCreateBulk) OnConflict(opts ...sql.ConflictOption) *UserUpsertBulk

+ func (ucb *UserCreateBulk) OnConflictColumns(columns ...string) *UserUpsertBulk

type UserQuery

+ func (uq *UserQuery) Modify(modifiers ...func(s *sql.Selector)) *UserSelect

type UserSelect

+ func (us *UserSelect) Modify(modifiers ...func(s *sql.Selector)) *UserSelect

+ type UserUpsert struct

+ func (u *UserUpsert) ClearWebhook() *UserUpsert

+ func (u *UserUpsert) SetCreatedAt(v time.Time) *UserUpsert

+ func (u *UserUpsert) SetPassword(v string) *UserUpsert

+ func (u *UserUpsert) SetRole(v utils.Role) *UserUpsert

+ func (u *UserUpsert) SetUpdatedAt(v time.Time) *UserUpsert

+ func (u *UserUpsert) SetUsername(v string) *UserUpsert

+ func (u *UserUpsert) SetWebhook(v string) *UserUpsert

+ func (u *UserUpsert) UpdateCreatedAt() *UserUpsert

+ func (u *UserUpsert) UpdatePassword() *UserUpsert

+ func (u *UserUpsert) UpdateRole() *UserUpsert

+ func (u *UserUpsert) UpdateUpdatedAt() *UserUpsert

+ func (u *UserUpsert) UpdateUsername() *UserUpsert

+ func (u *UserUpsert) UpdateWebhook() *UserUpsert

+ type UserUpsertBulk struct

+ func (u *UserUpsertBulk) ClearWebhook() *UserUpsertBulk

+ func (u *UserUpsertBulk) DoNothing() *UserUpsertBulk

+ func (u *UserUpsertBulk) Exec(ctx context.Context) error

+ func (u *UserUpsertBulk) ExecX(ctx context.Context)

+ func (u *UserUpsertBulk) Ignore() *UserUpsertBulk

+ func (u *UserUpsertBulk) SetCreatedAt(v time.Time) *UserUpsertBulk

+ func (u *UserUpsertBulk) SetPassword(v string) *UserUpsertBulk

+ func (u *UserUpsertBulk) SetRole(v utils.Role) *UserUpsertBulk

+ func (u *UserUpsertBulk) SetUpdatedAt(v time.Time) *UserUpsertBulk

+ func (u *UserUpsertBulk) SetUsername(v string) *UserUpsertBulk

+ func (u *UserUpsertBulk) SetWebhook(v string) *UserUpsertBulk

+ func (u *UserUpsertBulk) Update(set func(*UserUpsert)) *UserUpsertBulk

+ func (u *UserUpsertBulk) UpdateCreatedAt() *UserUpsertBulk

+ func (u *UserUpsertBulk) UpdateNewValues() *UserUpsertBulk

+ func (u *UserUpsertBulk) UpdatePassword() *UserUpsertBulk

+ func (u *UserUpsertBulk) UpdateRole() *UserUpsertBulk

+ func (u *UserUpsertBulk) UpdateUpdatedAt() *UserUpsertBulk

+ func (u *UserUpsertBulk) UpdateUsername() *UserUpsertBulk

+ func (u *UserUpsertBulk) UpdateWebhook() *UserUpsertBulk

+ type UserUpsertOne struct

+ func (u *UserUpsertOne) ClearWebhook() *UserUpsertOne

+ func (u *UserUpsertOne) DoNothing() *UserUpsertOne

+ func (u *UserUpsertOne) Exec(ctx context.Context) error

+ func (u *UserUpsertOne) ExecX(ctx context.Context)

+ func (u *UserUpsertOne) ID(ctx context.Context) (id uuid.UUID, err error)

+ func (u *UserUpsertOne) IDX(ctx context.Context) uuid.UUID

+ func (u *UserUpsertOne) Ignore() *UserUpsertOne

+ func (u *UserUpsertOne) SetCreatedAt(v time.Time) *UserUpsertOne

+ func (u *UserUpsertOne) SetPassword(v string) *UserUpsertOne

+ func (u *UserUpsertOne) SetRole(v utils.Role) *UserUpsertOne

+ func (u *UserUpsertOne) SetUpdatedAt(v time.Time) *UserUpsertOne

+ func (u *UserUpsertOne) SetUsername(v string) *UserUpsertOne

+ func (u *UserUpsertOne) SetWebhook(v string) *UserUpsertOne

+ func (u *UserUpsertOne) Update(set func(*UserUpsert)) *UserUpsertOne

+ func (u *UserUpsertOne) UpdateCreatedAt() *UserUpsertOne

+ func (u *UserUpsertOne) UpdateNewValues() *UserUpsertOne

+ func (u *UserUpsertOne) UpdatePassword() *UserUpsertOne

+ func (u *UserUpsertOne) UpdateRole() *UserUpsertOne

+ func (u *UserUpsertOne) UpdateUpdatedAt() *UserUpsertOne

+ func (u *UserUpsertOne) UpdateUsername() *UserUpsertOne

+ func (u *UserUpsertOne) UpdateWebhook() *UserUpsertOne

type VodCreate

+ func (vc *VodCreate) OnConflict(opts ...sql.ConflictOption) *VodUpsertOne

+ func (vc *VodCreate) OnConflictColumns(columns ...string) *VodUpsertOne

type VodCreateBulk

+ func (vcb *VodCreateBulk) OnConflict(opts ...sql.ConflictOption) *VodUpsertBulk

+ func (vcb *VodCreateBulk) OnConflictColumns(columns ...string) *VodUpsertBulk

type VodQuery

+ func (vq *VodQuery) Modify(modifiers ...func(s *sql.Selector)) *VodSelect

type VodSelect

+ func (vs *VodSelect) Modify(modifiers ...func(s *sql.Selector)) *VodSelect

+ type VodUpsert struct

+ func (u *VodUpsert) AddDuration(v int) *VodUpsert

+ func (u *VodUpsert) AddViews(v int) *VodUpsert

+ func (u *VodUpsert) ClearChatPath() *VodUpsert

+ func (u *VodUpsert) ClearChatVideoPath() *VodUpsert

+ func (u *VodUpsert) ClearInfoPath() *VodUpsert

+ func (u *VodUpsert) ClearResolution() *VodUpsert

+ func (u *VodUpsert) ClearThumbnailPath() *VodUpsert

+ func (u *VodUpsert) SetChatPath(v string) *VodUpsert

+ func (u *VodUpsert) SetChatVideoPath(v string) *VodUpsert

+ func (u *VodUpsert) SetCreatedAt(v time.Time) *VodUpsert

+ func (u *VodUpsert) SetDuration(v int) *VodUpsert

+ func (u *VodUpsert) SetExtID(v string) *VodUpsert

+ func (u *VodUpsert) SetInfoPath(v string) *VodUpsert

+ func (u *VodUpsert) SetPlatform(v utils.VodPlatform) *VodUpsert

+ func (u *VodUpsert) SetProcessing(v bool) *VodUpsert

+ func (u *VodUpsert) SetResolution(v string) *VodUpsert

+ func (u *VodUpsert) SetStreamedAt(v time.Time) *VodUpsert

+ func (u *VodUpsert) SetThumbnailPath(v string) *VodUpsert

+ func (u *VodUpsert) SetTitle(v string) *VodUpsert

+ func (u *VodUpsert) SetType(v utils.VodType) *VodUpsert

+ func (u *VodUpsert) SetUpdatedAt(v time.Time) *VodUpsert

+ func (u *VodUpsert) SetVideoPath(v string) *VodUpsert

+ func (u *VodUpsert) SetViews(v int) *VodUpsert

+ func (u *VodUpsert) SetWebThumbnailPath(v string) *VodUpsert

+ func (u *VodUpsert) UpdateChatPath() *VodUpsert

+ func (u *VodUpsert) UpdateChatVideoPath() *VodUpsert

+ func (u *VodUpsert) UpdateCreatedAt() *VodUpsert

+ func (u *VodUpsert) UpdateDuration() *VodUpsert

+ func (u *VodUpsert) UpdateExtID() *VodUpsert

+ func (u *VodUpsert) UpdateInfoPath() *VodUpsert

+ func (u *VodUpsert) UpdatePlatform() *VodUpsert

+ func (u *VodUpsert) UpdateProcessing() *VodUpsert

+ func (u *VodUpsert) UpdateResolution() *VodUpsert

+ func (u *VodUpsert) UpdateStreamedAt() *VodUpsert

+ func (u *VodUpsert) UpdateThumbnailPath() *VodUpsert

+ func (u *VodUpsert) UpdateTitle() *VodUpsert

+ func (u *VodUpsert) UpdateType() *VodUpsert

+ func (u *VodUpsert) UpdateUpdatedAt() *VodUpsert

+ func (u *VodUpsert) UpdateVideoPath() *VodUpsert

+ func (u *VodUpsert) UpdateViews() *VodUpsert

+ func (u *VodUpsert) UpdateWebThumbnailPath() *VodUpsert

+ type VodUpsertBulk struct

+ func (u *VodUpsertBulk) AddDuration(v int) *VodUpsertBulk

+ func (u *VodUpsertBulk) AddViews(v int) *VodUpsertBulk

+ func (u *VodUpsertBulk) ClearChatPath() *VodUpsertBulk

+ func (u *VodUpsertBulk) ClearChatVideoPath() *VodUpsertBulk

+ func (u *VodUpsertBulk) ClearInfoPath() *VodUpsertBulk

+ func (u *VodUpsertBulk) ClearResolution() *VodUpsertBulk

+ func (u *VodUpsertBulk) ClearThumbnailPath() *VodUpsertBulk

+ func (u *VodUpsertBulk) DoNothing() *VodUpsertBulk

+ func (u *VodUpsertBulk) Exec(ctx context.Context) error

+ func (u *VodUpsertBulk) ExecX(ctx context.Context)

+ func (u *VodUpsertBulk) Ignore() *VodUpsertBulk

+ func (u *VodUpsertBulk) SetChatPath(v string) *VodUpsertBulk

+ func (u *VodUpsertBulk) SetChatVideoPath(v string) *VodUpsertBulk

+ func (u *VodUpsertBulk) SetCreatedAt(v time.Time) *VodUpsertBulk

+ func (u *VodUpsertBulk) SetDuration(v int) *VodUpsertBulk

+ func (u *VodUpsertBulk) SetExtID(v string) *VodUpsertBulk

+ func (u *VodUpsertBulk) SetInfoPath(v string) *VodUpsertBulk

+ func (u *VodUpsertBulk) SetPlatform(v utils.VodPlatform) *VodUpsertBulk

+ func (u *VodUpsertBulk) SetProcessing(v bool) *VodUpsertBulk

+ func (u *VodUpsertBulk) SetResolution(v string) *VodUpsertBulk

+ func (u *VodUpsertBulk) SetStreamedAt(v time.Time) *VodUpsertBulk

+ func (u *VodUpsertBulk) SetThumbnailPath(v string) *VodUpsertBulk

+ func (u *VodUpsertBulk) SetTitle(v string) *VodUpsertBulk

+ func (u *VodUpsertBulk) SetType(v utils.VodType) *VodUpsertBulk

+ func (u *VodUpsertBulk) SetUpdatedAt(v time.Time) *VodUpsertBulk

+ func (u *VodUpsertBulk) SetVideoPath(v string) *VodUpsertBulk

+ func (u *VodUpsertBulk) SetViews(v int) *VodUpsertBulk

+ func (u *VodUpsertBulk) SetWebThumbnailPath(v string) *VodUpsertBulk

+ func (u *VodUpsertBulk) Update(set func(*VodUpsert)) *VodUpsertBulk

+ func (u *VodUpsertBulk) UpdateChatPath() *VodUpsertBulk

+ func (u *VodUpsertBulk) UpdateChatVideoPath() *VodUpsertBulk

+ func (u *VodUpsertBulk) UpdateCreatedAt() *VodUpsertBulk

+ func (u *VodUpsertBulk) UpdateDuration() *VodUpsertBulk

+ func (u *VodUpsertBulk) UpdateExtID() *VodUpsertBulk

+ func (u *VodUpsertBulk) UpdateInfoPath() *VodUpsertBulk

+ func (u *VodUpsertBulk) UpdateNewValues() *VodUpsertBulk

+ func (u *VodUpsertBulk) UpdatePlatform() *VodUpsertBulk

+ func (u *VodUpsertBulk) UpdateProcessing() *VodUpsertBulk

+ func (u *VodUpsertBulk) UpdateResolution() *VodUpsertBulk

+ func (u *VodUpsertBulk) UpdateStreamedAt() *VodUpsertBulk

+ func (u *VodUpsertBulk) UpdateThumbnailPath() *VodUpsertBulk

+ func (u *VodUpsertBulk) UpdateTitle() *VodUpsertBulk

+ func (u *VodUpsertBulk) UpdateType() *VodUpsertBulk

+ func (u *VodUpsertBulk) UpdateUpdatedAt() *VodUpsertBulk

+ func (u *VodUpsertBulk) UpdateVideoPath() *VodUpsertBulk

+ func (u *VodUpsertBulk) UpdateViews() *VodUpsertBulk

+ func (u *VodUpsertBulk) UpdateWebThumbnailPath() *VodUpsertBulk

+ type VodUpsertOne struct

+ func (u *VodUpsertOne) AddDuration(v int) *VodUpsertOne

+ func (u *VodUpsertOne) AddViews(v int) *VodUpsertOne

+ func (u *VodUpsertOne) ClearChatPath() *VodUpsertOne

+ func (u *VodUpsertOne) ClearChatVideoPath() *VodUpsertOne

+ func (u *VodUpsertOne) ClearInfoPath() *VodUpsertOne

+ func (u *VodUpsertOne) ClearResolution() *VodUpsertOne

+ func (u *VodUpsertOne) ClearThumbnailPath() *VodUpsertOne

+ func (u *VodUpsertOne) DoNothing() *VodUpsertOne

+ func (u *VodUpsertOne) Exec(ctx context.Context) error

+ func (u *VodUpsertOne) ExecX(ctx context.Context)

+ func (u *VodUpsertOne) ID(ctx context.Context) (id uuid.UUID, err error)

+ func (u *VodUpsertOne) IDX(ctx context.Context) uuid.UUID

+ func (u *VodUpsertOne) Ignore() *VodUpsertOne

+ func (u *VodUpsertOne) SetChatPath(v string) *VodUpsertOne

+ func (u *VodUpsertOne) SetChatVideoPath(v string) *VodUpsertOne

+ func (u *VodUpsertOne) SetCreatedAt(v time.Time) *VodUpsertOne

+ func (u *VodUpsertOne) SetDuration(v int) *VodUpsertOne

+ func (u *VodUpsertOne) SetExtID(v string) *VodUpsertOne

+ func (u *VodUpsertOne) SetInfoPath(v string) *VodUpsertOne

+ func (u *VodUpsertOne) SetPlatform(v utils.VodPlatform) *VodUpsertOne

+ func (u *VodUpsertOne) SetProcessing(v bool) *VodUpsertOne

+ func (u *VodUpsertOne) SetResolution(v string) *VodUpsertOne

+ func (u *VodUpsertOne) SetStreamedAt(v time.Time) *VodUpsertOne

+ func (u *VodUpsertOne) SetThumbnailPath(v string) *VodUpsertOne

+ func (u *VodUpsertOne) SetTitle(v string) *VodUpsertOne

+ func (u *VodUpsertOne) SetType(v utils.VodType) *VodUpsertOne

+ func (u *VodUpsertOne) SetUpdatedAt(v time.Time) *VodUpsertOne

+ func (u *VodUpsertOne) SetVideoPath(v string) *VodUpsertOne

+ func (u *VodUpsertOne) SetViews(v int) *VodUpsertOne

+ func (u *VodUpsertOne) SetWebThumbnailPath(v string) *VodUpsertOne

+ func (u *VodUpsertOne) Update(set func(*VodUpsert)) *VodUpsertOne

+ func (u *VodUpsertOne) UpdateChatPath() *VodUpsertOne

+ func (u *VodUpsertOne) UpdateChatVideoPath() *VodUpsertOne

+ func (u *VodUpsertOne) UpdateCreatedAt() *VodUpsertOne

+ func (u *VodUpsertOne) UpdateDuration() *VodUpsertOne

+ func (u *VodUpsertOne) UpdateExtID() *VodUpsertOne

+ func (u *VodUpsertOne) UpdateInfoPath() *VodUpsertOne

+ func (u *VodUpsertOne) UpdateNewValues() *VodUpsertOne

+ func (u *VodUpsertOne) UpdatePlatform() *VodUpsertOne

+ func (u *VodUpsertOne) UpdateProcessing() *VodUpsertOne

+ func (u *VodUpsertOne) UpdateResolution() *VodUpsertOne

+ func (u *VodUpsertOne) UpdateStreamedAt() *VodUpsertOne

+ func (u *VodUpsertOne) UpdateThumbnailPath() *VodUpsertOne

+ func (u *VodUpsertOne) UpdateTitle() *VodUpsertOne

+ func (u *VodUpsertOne) UpdateType() *VodUpsertOne

+ func (u *VodUpsertOne) UpdateUpdatedAt() *VodUpsertOne

+ func (u *VodUpsertOne) UpdateVideoPath() *VodUpsertOne

+ func (u *VodUpsertOne) UpdateViews() *VodUpsertOne

+ func (u *VodUpsertOne) UpdateWebThumbnailPath() *VodUpsertOne

v0.0.1

Jul 21, 2022

Changes in this version

+ const OpCreate

+ const OpDelete

+ const OpDeleteOne

+ const OpUpdate

+ const OpUpdateOne

+ const TypeChannel

+ const TypeLive

+ const TypeQueue

+ const TypeUser

+ const TypeVod

+ func IsConstraintError(err error) bool

+ func IsNotFound(err error) bool

+ func IsNotLoaded(err error) bool

+ func IsNotSingular(err error) bool

+ func IsValidationError(err error) bool

+ func MaskNotFound(err error) error

+ func NewContext(parent context.Context, c *Client) context.Context

+ func NewTxContext(parent context.Context, tx *Tx) context.Context

+ type AggregateFunc func(*sql.Selector) string

+ func As(fn AggregateFunc, end string) AggregateFunc

+ func Count() AggregateFunc

+ func Max(field string) AggregateFunc

+ func Mean(field string) AggregateFunc

+ func Min(field string) AggregateFunc

+ func Sum(field string) AggregateFunc

+ type Channel struct

+ CreatedAt time.Time

+ DisplayName string

+ Edges ChannelEdges

+ ID uuid.UUID

+ ImagePath string

+ Name string

+ UpdatedAt time.Time

+ func (c *Channel) QueryLive() *LiveQuery

+ func (c *Channel) QueryVods() *VodQuery

+ func (c *Channel) String() string

+ func (c *Channel) Unwrap() *Channel

+ func (c *Channel) Update() *ChannelUpdateOne

+ type ChannelClient struct

+ func NewChannelClient(c config) *ChannelClient

+ func (c *ChannelClient) Create() *ChannelCreate

+ func (c *ChannelClient) CreateBulk(builders ...*ChannelCreate) *ChannelCreateBulk

+ func (c *ChannelClient) Delete() *ChannelDelete

+ func (c *ChannelClient) DeleteOne(ch *Channel) *ChannelDeleteOne

+ func (c *ChannelClient) DeleteOneID(id uuid.UUID) *ChannelDeleteOne

+ func (c *ChannelClient) Get(ctx context.Context, id uuid.UUID) (*Channel, error)

+ func (c *ChannelClient) GetX(ctx context.Context, id uuid.UUID) *Channel

+ func (c *ChannelClient) Hooks() []Hook

+ func (c *ChannelClient) Query() *ChannelQuery

+ func (c *ChannelClient) QueryLive(ch *Channel) *LiveQuery

+ func (c *ChannelClient) QueryVods(ch *Channel) *VodQuery

+ func (c *ChannelClient) Update() *ChannelUpdate

+ func (c *ChannelClient) UpdateOne(ch *Channel) *ChannelUpdateOne

+ func (c *ChannelClient) UpdateOneID(id uuid.UUID) *ChannelUpdateOne

+ func (c *ChannelClient) Use(hooks ...Hook)

+ type ChannelCreate struct

+ func (cc *ChannelCreate) AddLive(l ...*Live) *ChannelCreate

+ func (cc *ChannelCreate) AddLiveIDs(ids ...uuid.UUID) *ChannelCreate

+ func (cc *ChannelCreate) AddVodIDs(ids ...uuid.UUID) *ChannelCreate

+ func (cc *ChannelCreate) AddVods(v ...*Vod) *ChannelCreate

+ func (cc *ChannelCreate) Exec(ctx context.Context) error

+ func (cc *ChannelCreate) ExecX(ctx context.Context)

+ func (cc *ChannelCreate) Mutation() *ChannelMutation

+ func (cc *ChannelCreate) Save(ctx context.Context) (*Channel, error)

+ func (cc *ChannelCreate) SaveX(ctx context.Context) *Channel

+ func (cc *ChannelCreate) SetCreatedAt(t time.Time) *ChannelCreate

+ func (cc *ChannelCreate) SetDisplayName(s string) *ChannelCreate

+ func (cc *ChannelCreate) SetID(u uuid.UUID) *ChannelCreate

+ func (cc *ChannelCreate) SetImagePath(s string) *ChannelCreate

+ func (cc *ChannelCreate) SetName(s string) *ChannelCreate

+ func (cc *ChannelCreate) SetNillableCreatedAt(t *time.Time) *ChannelCreate

+ func (cc *ChannelCreate) SetNillableID(u *uuid.UUID) *ChannelCreate

+ func (cc *ChannelCreate) SetNillableUpdatedAt(t *time.Time) *ChannelCreate

+ func (cc *ChannelCreate) SetUpdatedAt(t time.Time) *ChannelCreate

+ type ChannelCreateBulk struct

+ func (ccb *ChannelCreateBulk) Exec(ctx context.Context) error

+ func (ccb *ChannelCreateBulk) ExecX(ctx context.Context)

+ func (ccb *ChannelCreateBulk) Save(ctx context.Context) ([]*Channel, error)

+ func (ccb *ChannelCreateBulk) SaveX(ctx context.Context) []*Channel

+ type ChannelDelete struct

+ func (cd *ChannelDelete) Exec(ctx context.Context) (int, error)

+ func (cd *ChannelDelete) ExecX(ctx context.Context) int

+ func (cd *ChannelDelete) Where(ps ...predicate.Channel) *ChannelDelete

+ type ChannelDeleteOne struct

+ func (cdo *ChannelDeleteOne) Exec(ctx context.Context) error

+ func (cdo *ChannelDeleteOne) ExecX(ctx context.Context)

+ type ChannelEdges struct

+ Live []*Live

+ Vods []*Vod

+ func (e ChannelEdges) LiveOrErr() ([]*Live, error)

+ func (e ChannelEdges) VodsOrErr() ([]*Vod, error)

+ type ChannelGroupBy struct

+ func (cgb *ChannelGroupBy) Aggregate(fns ...AggregateFunc) *ChannelGroupBy

+ func (cgb *ChannelGroupBy) Bool(ctx context.Context) (_ bool, err error)

+ func (cgb *ChannelGroupBy) BoolX(ctx context.Context) bool

+ func (cgb *ChannelGroupBy) Bools(ctx context.Context) ([]bool, error)

+ func (cgb *ChannelGroupBy) BoolsX(ctx context.Context) []bool

+ func (cgb *ChannelGroupBy) Float64(ctx context.Context) (_ float64, err error)

+ func (cgb *ChannelGroupBy) Float64X(ctx context.Context) float64

+ func (cgb *ChannelGroupBy) Float64s(ctx context.Context) ([]float64, error)

+ func (cgb *ChannelGroupBy) Float64sX(ctx context.Context) []float64

+ func (cgb *ChannelGroupBy) Int(ctx context.Context) (_ int, err error)

+ func (cgb *ChannelGroupBy) IntX(ctx context.Context) int

+ func (cgb *ChannelGroupBy) Ints(ctx context.Context) ([]int, error)

+ func (cgb *ChannelGroupBy) IntsX(ctx context.Context) []int

+ func (cgb *ChannelGroupBy) Scan(ctx context.Context, v interface{}) error

+ func (cgb *ChannelGroupBy) ScanX(ctx context.Context, v interface{})

+ func (cgb *ChannelGroupBy) String(ctx context.Context) (_ string, err error)

+ func (cgb *ChannelGroupBy) StringX(ctx context.Context) string

+ func (cgb *ChannelGroupBy) Strings(ctx context.Context) ([]string, error)

+ func (cgb *ChannelGroupBy) StringsX(ctx context.Context) []string

+ type ChannelMutation struct

+ func (m *ChannelMutation) AddField(name string, value ent.Value) error

+ func (m *ChannelMutation) AddLiveIDs(ids ...uuid.UUID)

+ func (m *ChannelMutation) AddVodIDs(ids ...uuid.UUID)

+ func (m *ChannelMutation) AddedEdges() []string

+ func (m *ChannelMutation) AddedField(name string) (ent.Value, bool)

+ func (m *ChannelMutation) AddedFields() []string

+ func (m *ChannelMutation) AddedIDs(name string) []ent.Value

+ func (m *ChannelMutation) ClearEdge(name string) error

+ func (m *ChannelMutation) ClearField(name string) error

+ func (m *ChannelMutation) ClearLive()

+ func (m *ChannelMutation) ClearVods()

+ func (m *ChannelMutation) ClearedEdges() []string

+ func (m *ChannelMutation) ClearedFields() []string

+ func (m *ChannelMutation) CreatedAt() (r time.Time, exists bool)

+ func (m *ChannelMutation) DisplayName() (r string, exists bool)

+ func (m *ChannelMutation) EdgeCleared(name string) bool

+ func (m *ChannelMutation) Field(name string) (ent.Value, bool)

+ func (m *ChannelMutation) FieldCleared(name string) bool

+ func (m *ChannelMutation) Fields() []string

+ func (m *ChannelMutation) ID() (id uuid.UUID, exists bool)

+ func (m *ChannelMutation) IDs(ctx context.Context) ([]uuid.UUID, error)

+ func (m *ChannelMutation) ImagePath() (r string, exists bool)

+ func (m *ChannelMutation) LiveCleared() bool

+ func (m *ChannelMutation) LiveIDs() (ids []uuid.UUID)

+ func (m *ChannelMutation) Name() (r string, exists bool)

+ func (m *ChannelMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error)

+ func (m *ChannelMutation) OldDisplayName(ctx context.Context) (v string, err error)

+ func (m *ChannelMutation) OldField(ctx context.Context, name string) (ent.Value, error)

+ func (m *ChannelMutation) OldImagePath(ctx context.Context) (v string, err error)

+ func (m *ChannelMutation) OldName(ctx context.Context) (v string, err error)

+ func (m *ChannelMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error)

+ func (m *ChannelMutation) Op() Op

+ func (m *ChannelMutation) RemoveLiveIDs(ids ...uuid.UUID)

+ func (m *ChannelMutation) RemoveVodIDs(ids ...uuid.UUID)

+ func (m *ChannelMutation) RemovedEdges() []string

+ func (m *ChannelMutation) RemovedIDs(name string) []ent.Value

+ func (m *ChannelMutation) RemovedLiveIDs() (ids []uuid.UUID)

+ func (m *ChannelMutation) RemovedVodsIDs() (ids []uuid.UUID)

+ func (m *ChannelMutation) ResetCreatedAt()

+ func (m *ChannelMutation) ResetDisplayName()

+ func (m *ChannelMutation) ResetEdge(name string) error

+ func (m *ChannelMutation) ResetField(name string) error

+ func (m *ChannelMutation) ResetImagePath()

+ func (m *ChannelMutation) ResetLive()

+ func (m *ChannelMutation) ResetName()

+ func (m *ChannelMutation) ResetUpdatedAt()

+ func (m *ChannelMutation) ResetVods()

+ func (m *ChannelMutation) SetCreatedAt(t time.Time)

+ func (m *ChannelMutation) SetDisplayName(s string)

+ func (m *ChannelMutation) SetField(name string, value ent.Value) error

+ func (m *ChannelMutation) SetID(id uuid.UUID)

+ func (m *ChannelMutation) SetImagePath(s string)

+ func (m *ChannelMutation) SetName(s string)

+ func (m *ChannelMutation) SetUpdatedAt(t time.Time)

+ func (m *ChannelMutation) Type() string

+ func (m *ChannelMutation) UpdatedAt() (r time.Time, exists bool)

+ func (m *ChannelMutation) VodsCleared() bool

+ func (m *ChannelMutation) VodsIDs() (ids []uuid.UUID)

+ func (m *ChannelMutation) Where(ps ...predicate.Channel)

+ func (m ChannelMutation) Client() *Client

+ func (m ChannelMutation) Tx() (*Tx, error)

+ type ChannelQuery struct

+ func (cq *ChannelQuery) All(ctx context.Context) ([]*Channel, error)

+ func (cq *ChannelQuery) AllX(ctx context.Context) []*Channel

+ func (cq *ChannelQuery) Clone() *ChannelQuery

+ func (cq *ChannelQuery) Count(ctx context.Context) (int, error)

+ func (cq *ChannelQuery) CountX(ctx context.Context) int

+ func (cq *ChannelQuery) Exist(ctx context.Context) (bool, error)

+ func (cq *ChannelQuery) ExistX(ctx context.Context) bool

+ func (cq *ChannelQuery) First(ctx context.Context) (*Channel, error)

+ func (cq *ChannelQuery) FirstID(ctx context.Context) (id uuid.UUID, err error)

+ func (cq *ChannelQuery) FirstIDX(ctx context.Context) uuid.UUID

+ func (cq *ChannelQuery) FirstX(ctx context.Context) *Channel

+ func (cq *ChannelQuery) GroupBy(field string, fields ...string) *ChannelGroupBy

+ func (cq *ChannelQuery) IDs(ctx context.Context) ([]uuid.UUID, error)

+ func (cq *ChannelQuery) IDsX(ctx context.Context) []uuid.UUID

+ func (cq *ChannelQuery) Limit(limit int) *ChannelQuery

+ func (cq *ChannelQuery) Offset(offset int) *ChannelQuery

+ func (cq *ChannelQuery) Only(ctx context.Context) (*Channel, error)

+ func (cq *ChannelQuery) OnlyID(ctx context.Context) (id uuid.UUID, err error)

+ func (cq *ChannelQuery) OnlyIDX(ctx context.Context) uuid.UUID

+ func (cq *ChannelQuery) OnlyX(ctx context.Context) *Channel

+ func (cq *ChannelQuery) Order(o ...OrderFunc) *ChannelQuery

+ func (cq *ChannelQuery) QueryLive() *LiveQuery

+ func (cq *ChannelQuery) QueryVods() *VodQuery

+ func (cq *ChannelQuery) Select(fields ...string) *ChannelSelect

+ func (cq *ChannelQuery) Unique(unique bool) *ChannelQuery

+ func (cq *ChannelQuery) Where(ps ...predicate.Channel) *ChannelQuery

+ func (cq *ChannelQuery) WithLive(opts ...func(*LiveQuery)) *ChannelQuery

+ func (cq *ChannelQuery) WithVods(opts ...func(*VodQuery)) *ChannelQuery

+ type ChannelSelect struct

+ func (cs *ChannelSelect) Bool(ctx context.Context) (_ bool, err error)

+ func (cs *ChannelSelect) BoolX(ctx context.Context) bool

+ func (cs *ChannelSelect) Bools(ctx context.Context) ([]bool, error)

+ func (cs *ChannelSelect) BoolsX(ctx context.Context) []bool

+ func (cs *ChannelSelect) Float64(ctx context.Context) (_ float64, err error)

+ func (cs *ChannelSelect) Float64X(ctx context.Context) float64

+ func (cs *ChannelSelect) Float64s(ctx context.Context) ([]float64, error)

+ func (cs *ChannelSelect) Float64sX(ctx context.Context) []float64

+ func (cs *ChannelSelect) Int(ctx context.Context) (_ int, err error)

+ func (cs *ChannelSelect) IntX(ctx context.Context) int

+ func (cs *ChannelSelect) Ints(ctx context.Context) ([]int, error)

+ func (cs *ChannelSelect) IntsX(ctx context.Context) []int

+ func (cs *ChannelSelect) Scan(ctx context.Context, v interface{}) error

+ func (cs *ChannelSelect) ScanX(ctx context.Context, v interface{})

+ func (cs *ChannelSelect) String(ctx context.Context) (_ string, err error)

+ func (cs *ChannelSelect) StringX(ctx context.Context) string

+ func (cs *ChannelSelect) Strings(ctx context.Context) ([]string, error)

+ func (cs *ChannelSelect) StringsX(ctx context.Context) []string

+ type ChannelUpdate struct

+ func (cu *ChannelUpdate) AddLive(l ...*Live) *ChannelUpdate

+ func (cu *ChannelUpdate) AddLiveIDs(ids ...uuid.UUID) *ChannelUpdate

+ func (cu *ChannelUpdate) AddVodIDs(ids ...uuid.UUID) *ChannelUpdate

+ func (cu *ChannelUpdate) AddVods(v ...*Vod) *ChannelUpdate

+ func (cu *ChannelUpdate) ClearLive() *ChannelUpdate

+ func (cu *ChannelUpdate) ClearVods() *ChannelUpdate

+ func (cu *ChannelUpdate) Exec(ctx context.Context) error

+ func (cu *ChannelUpdate) ExecX(ctx context.Context)

+ func (cu *ChannelUpdate) Mutation() *ChannelMutation

+ func (cu *ChannelUpdate) RemoveLive(l ...*Live) *ChannelUpdate

+ func (cu *ChannelUpdate) RemoveLiveIDs(ids ...uuid.UUID) *ChannelUpdate

+ func (cu *ChannelUpdate) RemoveVodIDs(ids ...uuid.UUID) *ChannelUpdate

+ func (cu *ChannelUpdate) RemoveVods(v ...*Vod) *ChannelUpdate

+ func (cu *ChannelUpdate) Save(ctx context.Context) (int, error)

+ func (cu *ChannelUpdate) SaveX(ctx context.Context) int

+ func (cu *ChannelUpdate) SetDisplayName(s string) *ChannelUpdate

+ func (cu *ChannelUpdate) SetImagePath(s string) *ChannelUpdate

+ func (cu *ChannelUpdate) SetName(s string) *ChannelUpdate

+ func (cu *ChannelUpdate) SetUpdatedAt(t time.Time) *ChannelUpdate

+ func (cu *ChannelUpdate) Where(ps ...predicate.Channel) *ChannelUpdate

+ type ChannelUpdateOne struct

+ func (cuo *ChannelUpdateOne) AddLive(l ...*Live) *ChannelUpdateOne

+ func (cuo *ChannelUpdateOne) AddLiveIDs(ids ...uuid.UUID) *ChannelUpdateOne

+ func (cuo *ChannelUpdateOne) AddVodIDs(ids ...uuid.UUID) *ChannelUpdateOne

+ func (cuo *ChannelUpdateOne) AddVods(v ...*Vod) *ChannelUpdateOne

+ func (cuo *ChannelUpdateOne) ClearLive() *ChannelUpdateOne

+ func (cuo *ChannelUpdateOne) ClearVods() *ChannelUpdateOne

+ func (cuo *ChannelUpdateOne) Exec(ctx context.Context) error

+ func (cuo *ChannelUpdateOne) ExecX(ctx context.Context)

+ func (cuo *ChannelUpdateOne) Mutation() *ChannelMutation

+ func (cuo *ChannelUpdateOne) RemoveLive(l ...*Live) *ChannelUpdateOne

+ func (cuo *ChannelUpdateOne) RemoveLiveIDs(ids ...uuid.UUID) *ChannelUpdateOne

+ func (cuo *ChannelUpdateOne) RemoveVodIDs(ids ...uuid.UUID) *ChannelUpdateOne

+ func (cuo *ChannelUpdateOne) RemoveVods(v ...*Vod) *ChannelUpdateOne

+ func (cuo *ChannelUpdateOne) Save(ctx context.Context) (*Channel, error)

+ func (cuo *ChannelUpdateOne) SaveX(ctx context.Context) *Channel

+ func (cuo *ChannelUpdateOne) Select(field string, fields ...string) *ChannelUpdateOne

+ func (cuo *ChannelUpdateOne) SetDisplayName(s string) *ChannelUpdateOne

+ func (cuo *ChannelUpdateOne) SetImagePath(s string) *ChannelUpdateOne

+ func (cuo *ChannelUpdateOne) SetName(s string) *ChannelUpdateOne

+ func (cuo *ChannelUpdateOne) SetUpdatedAt(t time.Time) *ChannelUpdateOne

+ type Channels []*Channel

+ type Client struct

+ Channel *ChannelClient

+ Live *LiveClient

+ Queue *QueueClient

+ Schema *migrate.Schema

+ User *UserClient

+ Vod *VodClient

+ func FromContext(ctx context.Context) *Client

+ func NewClient(opts ...Option) *Client

+ func Open(driverName, dataSourceName string, options ...Option) (*Client, error)

+ func (c *Client) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error)

+ func (c *Client) Close() error

+ func (c *Client) Debug() *Client

+ func (c *Client) Tx(ctx context.Context) (*Tx, error)

+ func (c *Client) Use(hooks ...Hook)

+ type CommitFunc func(context.Context, *Tx) error

+ func (f CommitFunc) Commit(ctx context.Context, tx *Tx) error

+ type CommitHook func(Committer) Committer

+ type Committer interface

+ Commit func(context.Context, *Tx) error

+ type ConstraintError struct

+ func (e *ConstraintError) Unwrap() error

+ func (e ConstraintError) Error() string

+ type Hook = ent.Hook

+ type Live struct

+ ArchiveChat bool

+ CreatedAt time.Time

+ Edges LiveEdges

+ ID uuid.UUID

+ IsLive bool

+ LastLive time.Time

+ Resolution string

+ UpdatedAt time.Time

+ func (l *Live) QueryChannel() *ChannelQuery

+ func (l *Live) String() string

+ func (l *Live) Unwrap() *Live

+ func (l *Live) Update() *LiveUpdateOne

+ type LiveClient struct

+ func NewLiveClient(c config) *LiveClient

+ func (c *LiveClient) Create() *LiveCreate

+ func (c *LiveClient) CreateBulk(builders ...*LiveCreate) *LiveCreateBulk

+ func (c *LiveClient) Delete() *LiveDelete

+ func (c *LiveClient) DeleteOne(l *Live) *LiveDeleteOne

+ func (c *LiveClient) DeleteOneID(id uuid.UUID) *LiveDeleteOne

+ func (c *LiveClient) Get(ctx context.Context, id uuid.UUID) (*Live, error)

+ func (c *LiveClient) GetX(ctx context.Context, id uuid.UUID) *Live

+ func (c *LiveClient) Hooks() []Hook

+ func (c *LiveClient) Query() *LiveQuery

+ func (c *LiveClient) QueryChannel(l *Live) *ChannelQuery

+ func (c *LiveClient) Update() *LiveUpdate

+ func (c *LiveClient) UpdateOne(l *Live) *LiveUpdateOne

+ func (c *LiveClient) UpdateOneID(id uuid.UUID) *LiveUpdateOne

+ func (c *LiveClient) Use(hooks ...Hook)

+ type LiveCreate struct

+ func (lc *LiveCreate) Exec(ctx context.Context) error

+ func (lc *LiveCreate) ExecX(ctx context.Context)

+ func (lc *LiveCreate) Mutation() *LiveMutation

+ func (lc *LiveCreate) Save(ctx context.Context) (*Live, error)

+ func (lc *LiveCreate) SaveX(ctx context.Context) *Live

+ func (lc *LiveCreate) SetArchiveChat(b bool) *LiveCreate

+ func (lc *LiveCreate) SetChannel(c *Channel) *LiveCreate

+ func (lc *LiveCreate) SetChannelID(id uuid.UUID) *LiveCreate

+ func (lc *LiveCreate) SetCreatedAt(t time.Time) *LiveCreate

+ func (lc *LiveCreate) SetID(u uuid.UUID) *LiveCreate

+ func (lc *LiveCreate) SetIsLive(b bool) *LiveCreate

+ func (lc *LiveCreate) SetLastLive(t time.Time) *LiveCreate

+ func (lc *LiveCreate) SetNillableArchiveChat(b *bool) *LiveCreate

+ func (lc *LiveCreate) SetNillableCreatedAt(t *time.Time) *LiveCreate

+ func (lc *LiveCreate) SetNillableID(u *uuid.UUID) *LiveCreate

+ func (lc *LiveCreate) SetNillableIsLive(b *bool) *LiveCreate

+ func (lc *LiveCreate) SetNillableLastLive(t *time.Time) *LiveCreate

+ func (lc *LiveCreate) SetNillableResolution(s *string) *LiveCreate

+ func (lc *LiveCreate) SetNillableUpdatedAt(t *time.Time) *LiveCreate

+ func (lc *LiveCreate) SetResolution(s string) *LiveCreate

+ func (lc *LiveCreate) SetUpdatedAt(t time.Time) *LiveCreate

+ type LiveCreateBulk struct

+ func (lcb *LiveCreateBulk) Exec(ctx context.Context) error

+ func (lcb *LiveCreateBulk) ExecX(ctx context.Context)

+ func (lcb *LiveCreateBulk) Save(ctx context.Context) ([]*Live, error)

+ func (lcb *LiveCreateBulk) SaveX(ctx context.Context) []*Live

+ type LiveDelete struct

+ func (ld *LiveDelete) Exec(ctx context.Context) (int, error)

+ func (ld *LiveDelete) ExecX(ctx context.Context) int

+ func (ld *LiveDelete) Where(ps ...predicate.Live) *LiveDelete

+ type LiveDeleteOne struct

+ func (ldo *LiveDeleteOne) Exec(ctx context.Context) error

+ func (ldo *LiveDeleteOne) ExecX(ctx context.Context)

+ type LiveEdges struct

+ Channel *Channel

+ func (e LiveEdges) ChannelOrErr() (*Channel, error)

+ type LiveGroupBy struct

+ func (lgb *LiveGroupBy) Aggregate(fns ...AggregateFunc) *LiveGroupBy

+ func (lgb *LiveGroupBy) Bool(ctx context.Context) (_ bool, err error)

+ func (lgb *LiveGroupBy) BoolX(ctx context.Context) bool

+ func (lgb *LiveGroupBy) Bools(ctx context.Context) ([]bool, error)

+ func (lgb *LiveGroupBy) BoolsX(ctx context.Context) []bool

+ func (lgb *LiveGroupBy) Float64(ctx context.Context) (_ float64, err error)

+ func (lgb *LiveGroupBy) Float64X(ctx context.Context) float64

+ func (lgb *LiveGroupBy) Float64s(ctx context.Context) ([]float64, error)

+ func (lgb *LiveGroupBy) Float64sX(ctx context.Context) []float64

+ func (lgb *LiveGroupBy) Int(ctx context.Context) (_ int, err error)

+ func (lgb *LiveGroupBy) IntX(ctx context.Context) int

+ func (lgb *LiveGroupBy) Ints(ctx context.Context) ([]int, error)

+ func (lgb *LiveGroupBy) IntsX(ctx context.Context) []int

+ func (lgb *LiveGroupBy) Scan(ctx context.Context, v interface{}) error

+ func (lgb *LiveGroupBy) ScanX(ctx context.Context, v interface{})

+ func (lgb *LiveGroupBy) String(ctx context.Context) (_ string, err error)

+ func (lgb *LiveGroupBy) StringX(ctx context.Context) string

+ func (lgb *LiveGroupBy) Strings(ctx context.Context) ([]string, error)

+ func (lgb *LiveGroupBy) StringsX(ctx context.Context) []string

+ type LiveMutation struct

+ func (m *LiveMutation) AddField(name string, value ent.Value) error

+ func (m *LiveMutation) AddedEdges() []string

+ func (m *LiveMutation) AddedField(name string) (ent.Value, bool)

+ func (m *LiveMutation) AddedFields() []string

+ func (m *LiveMutation) AddedIDs(name string) []ent.Value

+ func (m *LiveMutation) ArchiveChat() (r bool, exists bool)

+ func (m *LiveMutation) ChannelCleared() bool

+ func (m *LiveMutation) ChannelID() (id uuid.UUID, exists bool)

+ func (m *LiveMutation) ChannelIDs() (ids []uuid.UUID)

+ func (m *LiveMutation) ClearChannel()

+ func (m *LiveMutation) ClearEdge(name string) error

+ func (m *LiveMutation) ClearField(name string) error

+ func (m *LiveMutation) ClearResolution()

+ func (m *LiveMutation) ClearedEdges() []string

+ func (m *LiveMutation) ClearedFields() []string

+ func (m *LiveMutation) CreatedAt() (r time.Time, exists bool)

+ func (m *LiveMutation) EdgeCleared(name string) bool

+ func (m *LiveMutation) Field(name string) (ent.Value, bool)

+ func (m *LiveMutation) FieldCleared(name string) bool

+ func (m *LiveMutation) Fields() []string

+ func (m *LiveMutation) ID() (id uuid.UUID, exists bool)

+ func (m *LiveMutation) IDs(ctx context.Context) ([]uuid.UUID, error)

+ func (m *LiveMutation) IsLive() (r bool, exists bool)

+ func (m *LiveMutation) LastLive() (r time.Time, exists bool)

+ func (m *LiveMutation) OldArchiveChat(ctx context.Context) (v bool, err error)

+ func (m *LiveMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error)

+ func (m *LiveMutation) OldField(ctx context.Context, name string) (ent.Value, error)

+ func (m *LiveMutation) OldIsLive(ctx context.Context) (v bool, err error)

+ func (m *LiveMutation) OldLastLive(ctx context.Context) (v time.Time, err error)

+ func (m *LiveMutation) OldResolution(ctx context.Context) (v string, err error)

+ func (m *LiveMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error)

+ func (m *LiveMutation) Op() Op

+ func (m *LiveMutation) RemovedEdges() []string

+ func (m *LiveMutation) RemovedIDs(name string) []ent.Value

+ func (m *LiveMutation) ResetArchiveChat()

+ func (m *LiveMutation) ResetChannel()

+ func (m *LiveMutation) ResetCreatedAt()

+ func (m *LiveMutation) ResetEdge(name string) error

+ func (m *LiveMutation) ResetField(name string) error

+ func (m *LiveMutation) ResetIsLive()

+ func (m *LiveMutation) ResetLastLive()

+ func (m *LiveMutation) ResetResolution()

+ func (m *LiveMutation) ResetUpdatedAt()

+ func (m *LiveMutation) Resolution() (r string, exists bool)

+ func (m *LiveMutation) ResolutionCleared() bool

+ func (m *LiveMutation) SetArchiveChat(b bool)

+ func (m *LiveMutation) SetChannelID(id uuid.UUID)

+ func (m *LiveMutation) SetCreatedAt(t time.Time)

+ func (m *LiveMutation) SetField(name string, value ent.Value) error

+ func (m *LiveMutation) SetID(id uuid.UUID)

+ func (m *LiveMutation) SetIsLive(b bool)

+ func (m *LiveMutation) SetLastLive(t time.Time)

+ func (m *LiveMutation) SetResolution(s string)

+ func (m *LiveMutation) SetUpdatedAt(t time.Time)

+ func (m *LiveMutation) Type() string

+ func (m *LiveMutation) UpdatedAt() (r time.Time, exists bool)

+ func (m *LiveMutation) Where(ps ...predicate.Live)

+ func (m LiveMutation) Client() *Client

+ func (m LiveMutation) Tx() (*Tx, error)

+ type LiveQuery struct

+ func (lq *LiveQuery) All(ctx context.Context) ([]*Live, error)

+ func (lq *LiveQuery) AllX(ctx context.Context) []*Live

+ func (lq *LiveQuery) Clone() *LiveQuery

+ func (lq *LiveQuery) Count(ctx context.Context) (int, error)

+ func (lq *LiveQuery) CountX(ctx context.Context) int

+ func (lq *LiveQuery) Exist(ctx context.Context) (bool, error)

+ func (lq *LiveQuery) ExistX(ctx context.Context) bool

+ func (lq *LiveQuery) First(ctx context.Context) (*Live, error)

+ func (lq *LiveQuery) FirstID(ctx context.Context) (id uuid.UUID, err error)

+ func (lq *LiveQuery) FirstIDX(ctx context.Context) uuid.UUID

+ func (lq *LiveQuery) FirstX(ctx context.Context) *Live

+ func (lq *LiveQuery) GroupBy(field string, fields ...string) *LiveGroupBy

+ func (lq *LiveQuery) IDs(ctx context.Context) ([]uuid.UUID, error)

+ func (lq *LiveQuery) IDsX(ctx context.Context) []uuid.UUID

+ func (lq *LiveQuery) Limit(limit int) *LiveQuery

+ func (lq *LiveQuery) Offset(offset int) *LiveQuery

+ func (lq *LiveQuery) Only(ctx context.Context) (*Live, error)

+ func (lq *LiveQuery) OnlyID(ctx context.Context) (id uuid.UUID, err error)

+ func (lq *LiveQuery) OnlyIDX(ctx context.Context) uuid.UUID

+ func (lq *LiveQuery) OnlyX(ctx context.Context) *Live

+ func (lq *LiveQuery) Order(o ...OrderFunc) *LiveQuery

+ func (lq *LiveQuery) QueryChannel() *ChannelQuery

+ func (lq *LiveQuery) Select(fields ...string) *LiveSelect

+ func (lq *LiveQuery) Unique(unique bool) *LiveQuery

+ func (lq *LiveQuery) Where(ps ...predicate.Live) *LiveQuery

+ func (lq *LiveQuery) WithChannel(opts ...func(*ChannelQuery)) *LiveQuery

+ type LiveSelect struct

+ func (ls *LiveSelect) Bool(ctx context.Context) (_ bool, err error)

+ func (ls *LiveSelect) BoolX(ctx context.Context) bool

+ func (ls *LiveSelect) Bools(ctx context.Context) ([]bool, error)

+ func (ls *LiveSelect) BoolsX(ctx context.Context) []bool

+ func (ls *LiveSelect) Float64(ctx context.Context) (_ float64, err error)

+ func (ls *LiveSelect) Float64X(ctx context.Context) float64

+ func (ls *LiveSelect) Float64s(ctx context.Context) ([]float64, error)

+ func (ls *LiveSelect) Float64sX(ctx context.Context) []float64

+ func (ls *LiveSelect) Int(ctx context.Context) (_ int, err error)

+ func (ls *LiveSelect) IntX(ctx context.Context) int

+ func (ls *LiveSelect) Ints(ctx context.Context) ([]int, error)

+ func (ls *LiveSelect) IntsX(ctx context.Context) []int

+ func (ls *LiveSelect) Scan(ctx context.Context, v interface{}) error

+ func (ls *LiveSelect) ScanX(ctx context.Context, v interface{})

+ func (ls *LiveSelect) String(ctx context.Context) (_ string, err error)

+ func (ls *LiveSelect) StringX(ctx context.Context) string

+ func (ls *LiveSelect) Strings(ctx context.Context) ([]string, error)

+ func (ls *LiveSelect) StringsX(ctx context.Context) []string

+ type LiveUpdate struct

+ func (lu *LiveUpdate) ClearChannel() *LiveUpdate

+ func (lu *LiveUpdate) ClearResolution() *LiveUpdate

+ func (lu *LiveUpdate) Exec(ctx context.Context) error

+ func (lu *LiveUpdate) ExecX(ctx context.Context)

+ func (lu *LiveUpdate) Mutation() *LiveMutation

+ func (lu *LiveUpdate) Save(ctx context.Context) (int, error)

+ func (lu *LiveUpdate) SaveX(ctx context.Context) int

+ func (lu *LiveUpdate) SetArchiveChat(b bool) *LiveUpdate

+ func (lu *LiveUpdate) SetChannel(c *Channel) *LiveUpdate

+ func (lu *LiveUpdate) SetChannelID(id uuid.UUID) *LiveUpdate

+ func (lu *LiveUpdate) SetIsLive(b bool) *LiveUpdate

+ func (lu *LiveUpdate) SetLastLive(t time.Time) *LiveUpdate

+ func (lu *LiveUpdate) SetNillableArchiveChat(b *bool) *LiveUpdate

+ func (lu *LiveUpdate) SetNillableIsLive(b *bool) *LiveUpdate

+ func (lu *LiveUpdate) SetNillableLastLive(t *time.Time) *LiveUpdate

+ func (lu *LiveUpdate) SetNillableResolution(s *string) *LiveUpdate

+ func (lu *LiveUpdate) SetResolution(s string) *LiveUpdate

+ func (lu *LiveUpdate) SetUpdatedAt(t time.Time) *LiveUpdate

+ func (lu *LiveUpdate) Where(ps ...predicate.Live) *LiveUpdate

+ type LiveUpdateOne struct

+ func (luo *LiveUpdateOne) ClearChannel() *LiveUpdateOne

+ func (luo *LiveUpdateOne) ClearResolution() *LiveUpdateOne

+ func (luo *LiveUpdateOne) Exec(ctx context.Context) error

+ func (luo *LiveUpdateOne) ExecX(ctx context.Context)

+ func (luo *LiveUpdateOne) Mutation() *LiveMutation

+ func (luo *LiveUpdateOne) Save(ctx context.Context) (*Live, error)

+ func (luo *LiveUpdateOne) SaveX(ctx context.Context) *Live

+ func (luo *LiveUpdateOne) Select(field string, fields ...string) *LiveUpdateOne

+ func (luo *LiveUpdateOne) SetArchiveChat(b bool) *LiveUpdateOne

+ func (luo *LiveUpdateOne) SetChannel(c *Channel) *LiveUpdateOne

+ func (luo *LiveUpdateOne) SetChannelID(id uuid.UUID) *LiveUpdateOne

+ func (luo *LiveUpdateOne) SetIsLive(b bool) *LiveUpdateOne

+ func (luo *LiveUpdateOne) SetLastLive(t time.Time) *LiveUpdateOne

+ func (luo *LiveUpdateOne) SetNillableArchiveChat(b *bool) *LiveUpdateOne

+ func (luo *LiveUpdateOne) SetNillableIsLive(b *bool) *LiveUpdateOne

+ func (luo *LiveUpdateOne) SetNillableLastLive(t *time.Time) *LiveUpdateOne

+ func (luo *LiveUpdateOne) SetNillableResolution(s *string) *LiveUpdateOne

+ func (luo *LiveUpdateOne) SetResolution(s string) *LiveUpdateOne

+ func (luo *LiveUpdateOne) SetUpdatedAt(t time.Time) *LiveUpdateOne

+ type Lives []*Live

+ type MutateFunc = ent.MutateFunc

+ type Mutation = ent.Mutation

+ type Mutator = ent.Mutator

+ type NotFoundError struct

+ func (e *NotFoundError) Error() string

+ type NotLoadedError struct

+ func (e *NotLoadedError) Error() string

+ type NotSingularError struct

+ func (e *NotSingularError) Error() string

+ type Op = ent.Op

+ type Option func(*config)

+ func Debug() Option

+ func Driver(driver dialect.Driver) Option

+ func Log(fn func(...interface{})) Option

+ type OrderFunc func(*sql.Selector)

+ func Asc(fields ...string) OrderFunc

+ func Desc(fields ...string) OrderFunc

+ type Policy = ent.Policy

+ type Query = ent.Query

+ type Queue struct

+ ChatProcessing bool

+ ChatStart time.Time

+ CreatedAt time.Time

+ Edges QueueEdges

+ ID uuid.UUID

+ LiveArchive bool

+ OnHold bool

+ Processing bool

+ TaskChatConvert utils.TaskStatus

+ TaskChatDownload utils.TaskStatus

+ TaskChatMove utils.TaskStatus

+ TaskChatRender utils.TaskStatus

+ TaskVideoConvert utils.TaskStatus

+ TaskVideoDownload utils.TaskStatus

+ TaskVideoMove utils.TaskStatus

+ TaskVodCreateFolder utils.TaskStatus

+ TaskVodDownloadThumbnail utils.TaskStatus

+ TaskVodSaveInfo utils.TaskStatus

+ UpdatedAt time.Time

+ VideoProcessing bool

+ func (q *Queue) QueryVod() *VodQuery

+ func (q *Queue) String() string

+ func (q *Queue) Unwrap() *Queue

+ func (q *Queue) Update() *QueueUpdateOne

+ type QueueClient struct

+ func NewQueueClient(c config) *QueueClient

+ func (c *QueueClient) Create() *QueueCreate

+ func (c *QueueClient) CreateBulk(builders ...*QueueCreate) *QueueCreateBulk

+ func (c *QueueClient) Delete() *QueueDelete

+ func (c *QueueClient) DeleteOne(q *Queue) *QueueDeleteOne

+ func (c *QueueClient) DeleteOneID(id uuid.UUID) *QueueDeleteOne

+ func (c *QueueClient) Get(ctx context.Context, id uuid.UUID) (*Queue, error)

+ func (c *QueueClient) GetX(ctx context.Context, id uuid.UUID) *Queue

+ func (c *QueueClient) Hooks() []Hook

+ func (c *QueueClient) Query() *QueueQuery

+ func (c *QueueClient) QueryVod(q *Queue) *VodQuery

+ func (c *QueueClient) Update() *QueueUpdate

+ func (c *QueueClient) UpdateOne(q *Queue) *QueueUpdateOne

+ func (c *QueueClient) UpdateOneID(id uuid.UUID) *QueueUpdateOne

+ func (c *QueueClient) Use(hooks ...Hook)

+ type QueueCreate struct

+ func (qc *QueueCreate) Exec(ctx context.Context) error

+ func (qc *QueueCreate) ExecX(ctx context.Context)

+ func (qc *QueueCreate) Mutation() *QueueMutation

+ func (qc *QueueCreate) Save(ctx context.Context) (*Queue, error)

+ func (qc *QueueCreate) SaveX(ctx context.Context) *Queue

+ func (qc *QueueCreate) SetChatProcessing(b bool) *QueueCreate

+ func (qc *QueueCreate) SetChatStart(t time.Time) *QueueCreate

+ func (qc *QueueCreate) SetCreatedAt(t time.Time) *QueueCreate

+ func (qc *QueueCreate) SetID(u uuid.UUID) *QueueCreate

+ func (qc *QueueCreate) SetLiveArchive(b bool) *QueueCreate

+ func (qc *QueueCreate) SetNillableChatProcessing(b *bool) *QueueCreate

+ func (qc *QueueCreate) SetNillableChatStart(t *time.Time) *QueueCreate

+ func (qc *QueueCreate) SetNillableCreatedAt(t *time.Time) *QueueCreate

+ func (qc *QueueCreate) SetNillableID(u *uuid.UUID) *QueueCreate

+ func (qc *QueueCreate) SetNillableLiveArchive(b *bool) *QueueCreate

+ func (qc *QueueCreate) SetNillableOnHold(b *bool) *QueueCreate

+ func (qc *QueueCreate) SetNillableProcessing(b *bool) *QueueCreate

+ func (qc *QueueCreate) SetNillableTaskChatConvert(us *utils.TaskStatus) *QueueCreate

+ func (qc *QueueCreate) SetNillableTaskChatDownload(us *utils.TaskStatus) *QueueCreate

+ func (qc *QueueCreate) SetNillableTaskChatMove(us *utils.TaskStatus) *QueueCreate

+ func (qc *QueueCreate) SetNillableTaskChatRender(us *utils.TaskStatus) *QueueCreate

+ func (qc *QueueCreate) SetNillableTaskVideoConvert(us *utils.TaskStatus) *QueueCreate

+ func (qc *QueueCreate) SetNillableTaskVideoDownload(us *utils.TaskStatus) *QueueCreate

+ func (qc *QueueCreate) SetNillableTaskVideoMove(us *utils.TaskStatus) *QueueCreate

+ func (qc *QueueCreate) SetNillableTaskVodCreateFolder(us *utils.TaskStatus) *QueueCreate

+ func (qc *QueueCreate) SetNillableTaskVodDownloadThumbnail(us *utils.TaskStatus) *QueueCreate

+ func (qc *QueueCreate) SetNillableTaskVodSaveInfo(us *utils.TaskStatus) *QueueCreate

+ func (qc *QueueCreate) SetNillableUpdatedAt(t *time.Time) *QueueCreate

+ func (qc *QueueCreate) SetNillableVideoProcessing(b *bool) *QueueCreate

+ func (qc *QueueCreate) SetOnHold(b bool) *QueueCreate

+ func (qc *QueueCreate) SetProcessing(b bool) *QueueCreate

+ func (qc *QueueCreate) SetTaskChatConvert(us utils.TaskStatus) *QueueCreate

+ func (qc *QueueCreate) SetTaskChatDownload(us utils.TaskStatus) *QueueCreate

+ func (qc *QueueCreate) SetTaskChatMove(us utils.TaskStatus) *QueueCreate

+ func (qc *QueueCreate) SetTaskChatRender(us utils.TaskStatus) *QueueCreate

+ func (qc *QueueCreate) SetTaskVideoConvert(us utils.TaskStatus) *QueueCreate

+ func (qc *QueueCreate) SetTaskVideoDownload(us utils.TaskStatus) *QueueCreate

+ func (qc *QueueCreate) SetTaskVideoMove(us utils.TaskStatus) *QueueCreate

+ func (qc *QueueCreate) SetTaskVodCreateFolder(us utils.TaskStatus) *QueueCreate

+ func (qc *QueueCreate) SetTaskVodDownloadThumbnail(us utils.TaskStatus) *QueueCreate

+ func (qc *QueueCreate) SetTaskVodSaveInfo(us utils.TaskStatus) *QueueCreate

+ func (qc *QueueCreate) SetUpdatedAt(t time.Time) *QueueCreate

+ func (qc *QueueCreate) SetVideoProcessing(b bool) *QueueCreate

+ func (qc *QueueCreate) SetVod(v *Vod) *QueueCreate

+ func (qc *QueueCreate) SetVodID(id uuid.UUID) *QueueCreate

+ type QueueCreateBulk struct

+ func (qcb *QueueCreateBulk) Exec(ctx context.Context) error

+ func (qcb *QueueCreateBulk) ExecX(ctx context.Context)

+ func (qcb *QueueCreateBulk) Save(ctx context.Context) ([]*Queue, error)

+ func (qcb *QueueCreateBulk) SaveX(ctx context.Context) []*Queue

+ type QueueDelete struct

+ func (qd *QueueDelete) Exec(ctx context.Context) (int, error)

+ func (qd *QueueDelete) ExecX(ctx context.Context) int

+ func (qd *QueueDelete) Where(ps ...predicate.Queue) *QueueDelete

+ type QueueDeleteOne struct

+ func (qdo *QueueDeleteOne) Exec(ctx context.Context) error

+ func (qdo *QueueDeleteOne) ExecX(ctx context.Context)

+ type QueueEdges struct

+ Vod *Vod

+ func (e QueueEdges) VodOrErr() (*Vod, error)

+ type QueueGroupBy struct

+ func (qgb *QueueGroupBy) Aggregate(fns ...AggregateFunc) *QueueGroupBy

+ func (qgb *QueueGroupBy) Bool(ctx context.Context) (_ bool, err error)

+ func (qgb *QueueGroupBy) BoolX(ctx context.Context) bool

+ func (qgb *QueueGroupBy) Bools(ctx context.Context) ([]bool, error)

+ func (qgb *QueueGroupBy) BoolsX(ctx context.Context) []bool

+ func (qgb *QueueGroupBy) Float64(ctx context.Context) (_ float64, err error)

+ func (qgb *QueueGroupBy) Float64X(ctx context.Context) float64

+ func (qgb *QueueGroupBy) Float64s(ctx context.Context) ([]float64, error)

+ func (qgb *QueueGroupBy) Float64sX(ctx context.Context) []float64

+ func (qgb *QueueGroupBy) Int(ctx context.Context) (_ int, err error)

+ func (qgb *QueueGroupBy) IntX(ctx context.Context) int

+ func (qgb *QueueGroupBy) Ints(ctx context.Context) ([]int, error)

+ func (qgb *QueueGroupBy) IntsX(ctx context.Context) []int

+ func (qgb *QueueGroupBy) Scan(ctx context.Context, v interface{}) error

+ func (qgb *QueueGroupBy) ScanX(ctx context.Context, v interface{})

+ func (qgb *QueueGroupBy) String(ctx context.Context) (_ string, err error)

+ func (qgb *QueueGroupBy) StringX(ctx context.Context) string

+ func (qgb *QueueGroupBy) Strings(ctx context.Context) ([]string, error)

+ func (qgb *QueueGroupBy) StringsX(ctx context.Context) []string

+ type QueueMutation struct

+ func (m *QueueMutation) AddField(name string, value ent.Value) error

+ func (m *QueueMutation) AddedEdges() []string

+ func (m *QueueMutation) AddedField(name string) (ent.Value, bool)

+ func (m *QueueMutation) AddedFields() []string

+ func (m *QueueMutation) AddedIDs(name string) []ent.Value

+ func (m *QueueMutation) ChatProcessing() (r bool, exists bool)

+ func (m *QueueMutation) ChatStart() (r time.Time, exists bool)

+ func (m *QueueMutation) ChatStartCleared() bool

+ func (m *QueueMutation) ClearChatStart()

+ func (m *QueueMutation) ClearEdge(name string) error

+ func (m *QueueMutation) ClearField(name string) error

+ func (m *QueueMutation) ClearTaskChatConvert()

+ func (m *QueueMutation) ClearTaskChatDownload()

+ func (m *QueueMutation) ClearTaskChatMove()

+ func (m *QueueMutation) ClearTaskChatRender()

+ func (m *QueueMutation) ClearTaskVideoConvert()

+ func (m *QueueMutation) ClearTaskVideoDownload()

+ func (m *QueueMutation) ClearTaskVideoMove()

+ func (m *QueueMutation) ClearTaskVodCreateFolder()

+ func (m *QueueMutation) ClearTaskVodDownloadThumbnail()

+ func (m *QueueMutation) ClearTaskVodSaveInfo()

+ func (m *QueueMutation) ClearVod()

+ func (m *QueueMutation) ClearedEdges() []string

+ func (m *QueueMutation) ClearedFields() []string

+ func (m *QueueMutation) CreatedAt() (r time.Time, exists bool)

+ func (m *QueueMutation) EdgeCleared(name string) bool

+ func (m *QueueMutation) Field(name string) (ent.Value, bool)

+ func (m *QueueMutation) FieldCleared(name string) bool

+ func (m *QueueMutation) Fields() []string

+ func (m *QueueMutation) ID() (id uuid.UUID, exists bool)

+ func (m *QueueMutation) IDs(ctx context.Context) ([]uuid.UUID, error)

+ func (m *QueueMutation) LiveArchive() (r bool, exists bool)

+ func (m *QueueMutation) OldChatProcessing(ctx context.Context) (v bool, err error)

+ func (m *QueueMutation) OldChatStart(ctx context.Context) (v time.Time, err error)

+ func (m *QueueMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error)

+ func (m *QueueMutation) OldField(ctx context.Context, name string) (ent.Value, error)

+ func (m *QueueMutation) OldLiveArchive(ctx context.Context) (v bool, err error)

+ func (m *QueueMutation) OldOnHold(ctx context.Context) (v bool, err error)

+ func (m *QueueMutation) OldProcessing(ctx context.Context) (v bool, err error)

+ func (m *QueueMutation) OldTaskChatConvert(ctx context.Context) (v utils.TaskStatus, err error)

+ func (m *QueueMutation) OldTaskChatDownload(ctx context.Context) (v utils.TaskStatus, err error)

+ func (m *QueueMutation) OldTaskChatMove(ctx context.Context) (v utils.TaskStatus, err error)

+ func (m *QueueMutation) OldTaskChatRender(ctx context.Context) (v utils.TaskStatus, err error)

+ func (m *QueueMutation) OldTaskVideoConvert(ctx context.Context) (v utils.TaskStatus, err error)

+ func (m *QueueMutation) OldTaskVideoDownload(ctx context.Context) (v utils.TaskStatus, err error)

+ func (m *QueueMutation) OldTaskVideoMove(ctx context.Context) (v utils.TaskStatus, err error)

+ func (m *QueueMutation) OldTaskVodCreateFolder(ctx context.Context) (v utils.TaskStatus, err error)

+ func (m *QueueMutation) OldTaskVodDownloadThumbnail(ctx context.Context) (v utils.TaskStatus, err error)

+ func (m *QueueMutation) OldTaskVodSaveInfo(ctx context.Context) (v utils.TaskStatus, err error)

+ func (m *QueueMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error)

+ func (m *QueueMutation) OldVideoProcessing(ctx context.Context) (v bool, err error)

+ func (m *QueueMutation) OnHold() (r bool, exists bool)

+ func (m *QueueMutation) Op() Op

+ func (m *QueueMutation) Processing() (r bool, exists bool)

+ func (m *QueueMutation) RemovedEdges() []string

+ func (m *QueueMutation) RemovedIDs(name string) []ent.Value

+ func (m *QueueMutation) ResetChatProcessing()

+ func (m *QueueMutation) ResetChatStart()

+ func (m *QueueMutation) ResetCreatedAt()

+ func (m *QueueMutation) ResetEdge(name string) error

+ func (m *QueueMutation) ResetField(name string) error

+ func (m *QueueMutation) ResetLiveArchive()

+ func (m *QueueMutation) ResetOnHold()

+ func (m *QueueMutation) ResetProcessing()

+ func (m *QueueMutation) ResetTaskChatConvert()

+ func (m *QueueMutation) ResetTaskChatDownload()

+ func (m *QueueMutation) ResetTaskChatMove()

+ func (m *QueueMutation) ResetTaskChatRender()

+ func (m *QueueMutation) ResetTaskVideoConvert()

+ func (m *QueueMutation) ResetTaskVideoDownload()

+ func (m *QueueMutation) ResetTaskVideoMove()

+ func (m *QueueMutation) ResetTaskVodCreateFolder()

+ func (m *QueueMutation) ResetTaskVodDownloadThumbnail()

+ func (m *QueueMutation) ResetTaskVodSaveInfo()

+ func (m *QueueMutation) ResetUpdatedAt()

+ func (m *QueueMutation) ResetVideoProcessing()

+ func (m *QueueMutation) ResetVod()

+ func (m *QueueMutation) SetChatProcessing(b bool)

+ func (m *QueueMutation) SetChatStart(t time.Time)

+ func (m *QueueMutation) SetCreatedAt(t time.Time)

+ func (m *QueueMutation) SetField(name string, value ent.Value) error

+ func (m *QueueMutation) SetID(id uuid.UUID)

+ func (m *QueueMutation) SetLiveArchive(b bool)

+ func (m *QueueMutation) SetOnHold(b bool)

+ func (m *QueueMutation) SetProcessing(b bool)

+ func (m *QueueMutation) SetTaskChatConvert(us utils.TaskStatus)

+ func (m *QueueMutation) SetTaskChatDownload(us utils.TaskStatus)

+ func (m *QueueMutation) SetTaskChatMove(us utils.TaskStatus)

+ func (m *QueueMutation) SetTaskChatRender(us utils.TaskStatus)

+ func (m *QueueMutation) SetTaskVideoConvert(us utils.TaskStatus)

+ func (m *QueueMutation) SetTaskVideoDownload(us utils.TaskStatus)

+ func (m *QueueMutation) SetTaskVideoMove(us utils.TaskStatus)

+ func (m *QueueMutation) SetTaskVodCreateFolder(us utils.TaskStatus)

+ func (m *QueueMutation) SetTaskVodDownloadThumbnail(us utils.TaskStatus)

+ func (m *QueueMutation) SetTaskVodSaveInfo(us utils.TaskStatus)

+ func (m *QueueMutation) SetUpdatedAt(t time.Time)

+ func (m *QueueMutation) SetVideoProcessing(b bool)

+ func (m *QueueMutation) SetVodID(id uuid.UUID)

+ func (m *QueueMutation) TaskChatConvert() (r utils.TaskStatus, exists bool)

+ func (m *QueueMutation) TaskChatConvertCleared() bool

+ func (m *QueueMutation) TaskChatDownload() (r utils.TaskStatus, exists bool)

+ func (m *QueueMutation) TaskChatDownloadCleared() bool

+ func (m *QueueMutation) TaskChatMove() (r utils.TaskStatus, exists bool)

+ func (m *QueueMutation) TaskChatMoveCleared() bool

+ func (m *QueueMutation) TaskChatRender() (r utils.TaskStatus, exists bool)

+ func (m *QueueMutation) TaskChatRenderCleared() bool

+ func (m *QueueMutation) TaskVideoConvert() (r utils.TaskStatus, exists bool)

+ func (m *QueueMutation) TaskVideoConvertCleared() bool

+ func (m *QueueMutation) TaskVideoDownload() (r utils.TaskStatus, exists bool)

+ func (m *QueueMutation) TaskVideoDownloadCleared() bool

+ func (m *QueueMutation) TaskVideoMove() (r utils.TaskStatus, exists bool)

+ func (m *QueueMutation) TaskVideoMoveCleared() bool

+ func (m *QueueMutation) TaskVodCreateFolder() (r utils.TaskStatus, exists bool)

+ func (m *QueueMutation) TaskVodCreateFolderCleared() bool

+ func (m *QueueMutation) TaskVodDownloadThumbnail() (r utils.TaskStatus, exists bool)

+ func (m *QueueMutation) TaskVodDownloadThumbnailCleared() bool

+ func (m *QueueMutation) TaskVodSaveInfo() (r utils.TaskStatus, exists bool)

+ func (m *QueueMutation) TaskVodSaveInfoCleared() bool

+ func (m *QueueMutation) Type() string

+ func (m *QueueMutation) UpdatedAt() (r time.Time, exists bool)

+ func (m *QueueMutation) VideoProcessing() (r bool, exists bool)

+ func (m *QueueMutation) VodCleared() bool

+ func (m *QueueMutation) VodID() (id uuid.UUID, exists bool)

+ func (m *QueueMutation) VodIDs() (ids []uuid.UUID)

+ func (m *QueueMutation) Where(ps ...predicate.Queue)

+ func (m QueueMutation) Client() *Client

+ func (m QueueMutation) Tx() (*Tx, error)

+ type QueueQuery struct

+ func (qq *QueueQuery) All(ctx context.Context) ([]*Queue, error)

+ func (qq *QueueQuery) AllX(ctx context.Context) []*Queue

+ func (qq *QueueQuery) Clone() *QueueQuery

+ func (qq *QueueQuery) Count(ctx context.Context) (int, error)

+ func (qq *QueueQuery) CountX(ctx context.Context) int

+ func (qq *QueueQuery) Exist(ctx context.Context) (bool, error)

+ func (qq *QueueQuery) ExistX(ctx context.Context) bool

+ func (qq *QueueQuery) First(ctx context.Context) (*Queue, error)

+ func (qq *QueueQuery) FirstID(ctx context.Context) (id uuid.UUID, err error)

+ func (qq *QueueQuery) FirstIDX(ctx context.Context) uuid.UUID

+ func (qq *QueueQuery) FirstX(ctx context.Context) *Queue

+ func (qq *QueueQuery) GroupBy(field string, fields ...string) *QueueGroupBy

+ func (qq *QueueQuery) IDs(ctx context.Context) ([]uuid.UUID, error)

+ func (qq *QueueQuery) IDsX(ctx context.Context) []uuid.UUID

+ func (qq *QueueQuery) Limit(limit int) *QueueQuery

+ func (qq *QueueQuery) Offset(offset int) *QueueQuery

+ func (qq *QueueQuery) Only(ctx context.Context) (*Queue, error)

+ func (qq *QueueQuery) OnlyID(ctx context.Context) (id uuid.UUID, err error)

+ func (qq *QueueQuery) OnlyIDX(ctx context.Context) uuid.UUID

+ func (qq *QueueQuery) OnlyX(ctx context.Context) *Queue

+ func (qq *QueueQuery) Order(o ...OrderFunc) *QueueQuery

+ func (qq *QueueQuery) QueryVod() *VodQuery

+ func (qq *QueueQuery) Select(fields ...string) *QueueSelect

+ func (qq *QueueQuery) Unique(unique bool) *QueueQuery

+ func (qq *QueueQuery) Where(ps ...predicate.Queue) *QueueQuery

+ func (qq *QueueQuery) WithVod(opts ...func(*VodQuery)) *QueueQuery

+ type QueueSelect struct

+ func (qs *QueueSelect) Bool(ctx context.Context) (_ bool, err error)

+ func (qs *QueueSelect) BoolX(ctx context.Context) bool

+ func (qs *QueueSelect) Bools(ctx context.Context) ([]bool, error)

+ func (qs *QueueSelect) BoolsX(ctx context.Context) []bool

+ func (qs *QueueSelect) Float64(ctx context.Context) (_ float64, err error)

+ func (qs *QueueSelect) Float64X(ctx context.Context) float64

+ func (qs *QueueSelect) Float64s(ctx context.Context) ([]float64, error)

+ func (qs *QueueSelect) Float64sX(ctx context.Context) []float64

+ func (qs *QueueSelect) Int(ctx context.Context) (_ int, err error)

+ func (qs *QueueSelect) IntX(ctx context.Context) int

+ func (qs *QueueSelect) Ints(ctx context.Context) ([]int, error)

+ func (qs *QueueSelect) IntsX(ctx context.Context) []int

+ func (qs *QueueSelect) Scan(ctx context.Context, v interface{}) error

+ func (qs *QueueSelect) ScanX(ctx context.Context, v interface{})

+ func (qs *QueueSelect) String(ctx context.Context) (_ string, err error)

+ func (qs *QueueSelect) StringX(ctx context.Context) string

+ func (qs *QueueSelect) Strings(ctx context.Context) ([]string, error)

+ func (qs *QueueSelect) StringsX(ctx context.Context) []string

+ type QueueUpdate struct

+ func (qu *QueueUpdate) ClearChatStart() *QueueUpdate

+ func (qu *QueueUpdate) ClearTaskChatConvert() *QueueUpdate

+ func (qu *QueueUpdate) ClearTaskChatDownload() *QueueUpdate

+ func (qu *QueueUpdate) ClearTaskChatMove() *QueueUpdate

+ func (qu *QueueUpdate) ClearTaskChatRender() *QueueUpdate

+ func (qu *QueueUpdate) ClearTaskVideoConvert() *QueueUpdate

+ func (qu *QueueUpdate) ClearTaskVideoDownload() *QueueUpdate

+ func (qu *QueueUpdate) ClearTaskVideoMove() *QueueUpdate

+ func (qu *QueueUpdate) ClearTaskVodCreateFolder() *QueueUpdate

+ func (qu *QueueUpdate) ClearTaskVodDownloadThumbnail() *QueueUpdate

+ func (qu *QueueUpdate) ClearTaskVodSaveInfo() *QueueUpdate

+ func (qu *QueueUpdate) ClearVod() *QueueUpdate

+ func (qu *QueueUpdate) Exec(ctx context.Context) error

+ func (qu *QueueUpdate) ExecX(ctx context.Context)

+ func (qu *QueueUpdate) Mutation() *QueueMutation

+ func (qu *QueueUpdate) Save(ctx context.Context) (int, error)

+ func (qu *QueueUpdate) SaveX(ctx context.Context) int

+ func (qu *QueueUpdate) SetChatProcessing(b bool) *QueueUpdate

+ func (qu *QueueUpdate) SetChatStart(t time.Time) *QueueUpdate

+ func (qu *QueueUpdate) SetLiveArchive(b bool) *QueueUpdate

+ func (qu *QueueUpdate) SetNillableChatProcessing(b *bool) *QueueUpdate

+ func (qu *QueueUpdate) SetNillableChatStart(t *time.Time) *QueueUpdate

+ func (qu *QueueUpdate) SetNillableLiveArchive(b *bool) *QueueUpdate

+ func (qu *QueueUpdate) SetNillableOnHold(b *bool) *QueueUpdate

+ func (qu *QueueUpdate) SetNillableProcessing(b *bool) *QueueUpdate

+ func (qu *QueueUpdate) SetNillableTaskChatConvert(us *utils.TaskStatus) *QueueUpdate

+ func (qu *QueueUpdate) SetNillableTaskChatDownload(us *utils.TaskStatus) *QueueUpdate

+ func (qu *QueueUpdate) SetNillableTaskChatMove(us *utils.TaskStatus) *QueueUpdate

+ func (qu *QueueUpdate) SetNillableTaskChatRender(us *utils.TaskStatus) *QueueUpdate

+ func (qu *QueueUpdate) SetNillableTaskVideoConvert(us *utils.TaskStatus) *QueueUpdate

+ func (qu *QueueUpdate) SetNillableTaskVideoDownload(us *utils.TaskStatus) *QueueUpdate

+ func (qu *QueueUpdate) SetNillableTaskVideoMove(us *utils.TaskStatus) *QueueUpdate

+ func (qu *QueueUpdate) SetNillableTaskVodCreateFolder(us *utils.TaskStatus) *QueueUpdate

+ func (qu *QueueUpdate) SetNillableTaskVodDownloadThumbnail(us *utils.TaskStatus) *QueueUpdate

+ func (qu *QueueUpdate) SetNillableTaskVodSaveInfo(us *utils.TaskStatus) *QueueUpdate

+ func (qu *QueueUpdate) SetNillableVideoProcessing(b *bool) *QueueUpdate

+ func (qu *QueueUpdate) SetOnHold(b bool) *QueueUpdate

+ func (qu *QueueUpdate) SetProcessing(b bool) *QueueUpdate

+ func (qu *QueueUpdate) SetTaskChatConvert(us utils.TaskStatus) *QueueUpdate

+ func (qu *QueueUpdate) SetTaskChatDownload(us utils.TaskStatus) *QueueUpdate

+ func (qu *QueueUpdate) SetTaskChatMove(us utils.TaskStatus) *QueueUpdate

+ func (qu *QueueUpdate) SetTaskChatRender(us utils.TaskStatus) *QueueUpdate

+ func (qu *QueueUpdate) SetTaskVideoConvert(us utils.TaskStatus) *QueueUpdate

+ func (qu *QueueUpdate) SetTaskVideoDownload(us utils.TaskStatus) *QueueUpdate

+ func (qu *QueueUpdate) SetTaskVideoMove(us utils.TaskStatus) *QueueUpdate

+ func (qu *QueueUpdate) SetTaskVodCreateFolder(us utils.TaskStatus) *QueueUpdate

+ func (qu *QueueUpdate) SetTaskVodDownloadThumbnail(us utils.TaskStatus) *QueueUpdate

+ func (qu *QueueUpdate) SetTaskVodSaveInfo(us utils.TaskStatus) *QueueUpdate

+ func (qu *QueueUpdate) SetUpdatedAt(t time.Time) *QueueUpdate

+ func (qu *QueueUpdate) SetVideoProcessing(b bool) *QueueUpdate

+ func (qu *QueueUpdate) SetVod(v *Vod) *QueueUpdate

+ func (qu *QueueUpdate) SetVodID(id uuid.UUID) *QueueUpdate

+ func (qu *QueueUpdate) Where(ps ...predicate.Queue) *QueueUpdate

+ type QueueUpdateOne struct

+ func (quo *QueueUpdateOne) ClearChatStart() *QueueUpdateOne

+ func (quo *QueueUpdateOne) ClearTaskChatConvert() *QueueUpdateOne

+ func (quo *QueueUpdateOne) ClearTaskChatDownload() *QueueUpdateOne

+ func (quo *QueueUpdateOne) ClearTaskChatMove() *QueueUpdateOne

+ func (quo *QueueUpdateOne) ClearTaskChatRender() *QueueUpdateOne

+ func (quo *QueueUpdateOne) ClearTaskVideoConvert() *QueueUpdateOne

+ func (quo *QueueUpdateOne) ClearTaskVideoDownload() *QueueUpdateOne

+ func (quo *QueueUpdateOne) ClearTaskVideoMove() *QueueUpdateOne

+ func (quo *QueueUpdateOne) ClearTaskVodCreateFolder() *QueueUpdateOne

+ func (quo *QueueUpdateOne) ClearTaskVodDownloadThumbnail() *QueueUpdateOne

+ func (quo *QueueUpdateOne) ClearTaskVodSaveInfo() *QueueUpdateOne

+ func (quo *QueueUpdateOne) ClearVod() *QueueUpdateOne

+ func (quo *QueueUpdateOne) Exec(ctx context.Context) error

+ func (quo *QueueUpdateOne) ExecX(ctx context.Context)

+ func (quo *QueueUpdateOne) Mutation() *QueueMutation

+ func (quo *QueueUpdateOne) Save(ctx context.Context) (*Queue, error)

+ func (quo *QueueUpdateOne) SaveX(ctx context.Context) *Queue

+ func (quo *QueueUpdateOne) Select(field string, fields ...string) *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetChatProcessing(b bool) *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetChatStart(t time.Time) *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetLiveArchive(b bool) *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetNillableChatProcessing(b *bool) *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetNillableChatStart(t *time.Time) *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetNillableLiveArchive(b *bool) *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetNillableOnHold(b *bool) *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetNillableProcessing(b *bool) *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetNillableTaskChatConvert(us *utils.TaskStatus) *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetNillableTaskChatDownload(us *utils.TaskStatus) *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetNillableTaskChatMove(us *utils.TaskStatus) *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetNillableTaskChatRender(us *utils.TaskStatus) *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetNillableTaskVideoConvert(us *utils.TaskStatus) *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetNillableTaskVideoDownload(us *utils.TaskStatus) *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetNillableTaskVideoMove(us *utils.TaskStatus) *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetNillableTaskVodCreateFolder(us *utils.TaskStatus) *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetNillableTaskVodDownloadThumbnail(us *utils.TaskStatus) *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetNillableTaskVodSaveInfo(us *utils.TaskStatus) *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetNillableVideoProcessing(b *bool) *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetOnHold(b bool) *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetProcessing(b bool) *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetTaskChatConvert(us utils.TaskStatus) *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetTaskChatDownload(us utils.TaskStatus) *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetTaskChatMove(us utils.TaskStatus) *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetTaskChatRender(us utils.TaskStatus) *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetTaskVideoConvert(us utils.TaskStatus) *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetTaskVideoDownload(us utils.TaskStatus) *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetTaskVideoMove(us utils.TaskStatus) *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetTaskVodCreateFolder(us utils.TaskStatus) *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetTaskVodDownloadThumbnail(us utils.TaskStatus) *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetTaskVodSaveInfo(us utils.TaskStatus) *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetUpdatedAt(t time.Time) *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetVideoProcessing(b bool) *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetVod(v *Vod) *QueueUpdateOne

+ func (quo *QueueUpdateOne) SetVodID(id uuid.UUID) *QueueUpdateOne

+ type Queues []*Queue

+ type RollbackFunc func(context.Context, *Tx) error

+ func (f RollbackFunc) Rollback(ctx context.Context, tx *Tx) error

+ type RollbackHook func(Rollbacker) Rollbacker

+ type Rollbacker interface

+ Rollback func(context.Context, *Tx) error

+ type Tx struct

+ Channel *ChannelClient

+ Live *LiveClient

+ Queue *QueueClient

+ User *UserClient

+ Vod *VodClient

+ func TxFromContext(ctx context.Context) *Tx

+ func (tx *Tx) Client() *Client

+ func (tx *Tx) Commit() error

+ func (tx *Tx) OnCommit(f CommitHook)

+ func (tx *Tx) OnRollback(f RollbackHook)

+ func (tx *Tx) Rollback() error

+ type User struct

+ CreatedAt time.Time

+ ID uuid.UUID

+ Password string

+ Role utils.Role

+ UpdatedAt time.Time

+ Username string

+ Webhook string

+ func (u *User) String() string

+ func (u *User) Unwrap() *User

+ func (u *User) Update() *UserUpdateOne

+ type UserClient struct

+ func NewUserClient(c config) *UserClient

+ func (c *UserClient) Create() *UserCreate

+ func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk

+ func (c *UserClient) Delete() *UserDelete

+ func (c *UserClient) DeleteOne(u *User) *UserDeleteOne

+ func (c *UserClient) DeleteOneID(id uuid.UUID) *UserDeleteOne

+ func (c *UserClient) Get(ctx context.Context, id uuid.UUID) (*User, error)

+ func (c *UserClient) GetX(ctx context.Context, id uuid.UUID) *User

+ func (c *UserClient) Hooks() []Hook

+ func (c *UserClient) Query() *UserQuery

+ func (c *UserClient) Update() *UserUpdate

+ func (c *UserClient) UpdateOne(u *User) *UserUpdateOne

+ func (c *UserClient) UpdateOneID(id uuid.UUID) *UserUpdateOne

+ func (c *UserClient) Use(hooks ...Hook)

+ type UserCreate struct

+ func (uc *UserCreate) Exec(ctx context.Context) error

+ func (uc *UserCreate) ExecX(ctx context.Context)

+ func (uc *UserCreate) Mutation() *UserMutation

+ func (uc *UserCreate) Save(ctx context.Context) (*User, error)

+ func (uc *UserCreate) SaveX(ctx context.Context) *User

+ func (uc *UserCreate) SetCreatedAt(t time.Time) *UserCreate

+ func (uc *UserCreate) SetID(u uuid.UUID) *UserCreate

+ func (uc *UserCreate) SetNillableCreatedAt(t *time.Time) *UserCreate

+ func (uc *UserCreate) SetNillableID(u *uuid.UUID) *UserCreate

+ func (uc *UserCreate) SetNillableRole(u *utils.Role) *UserCreate

+ func (uc *UserCreate) SetNillableUpdatedAt(t *time.Time) *UserCreate

+ func (uc *UserCreate) SetNillableWebhook(s *string) *UserCreate

+ func (uc *UserCreate) SetPassword(s string) *UserCreate

+ func (uc *UserCreate) SetRole(u utils.Role) *UserCreate

+ func (uc *UserCreate) SetUpdatedAt(t time.Time) *UserCreate

+ func (uc *UserCreate) SetUsername(s string) *UserCreate

+ func (uc *UserCreate) SetWebhook(s string) *UserCreate

+ type UserCreateBulk struct

+ func (ucb *UserCreateBulk) Exec(ctx context.Context) error

+ func (ucb *UserCreateBulk) ExecX(ctx context.Context)

+ func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error)

+ func (ucb *UserCreateBulk) SaveX(ctx context.Context) []*User

+ type UserDelete struct

+ func (ud *UserDelete) Exec(ctx context.Context) (int, error)

+ func (ud *UserDelete) ExecX(ctx context.Context) int

+ func (ud *UserDelete) Where(ps ...predicate.User) *UserDelete

+ type UserDeleteOne struct

+ func (udo *UserDeleteOne) Exec(ctx context.Context) error

+ func (udo *UserDeleteOne) ExecX(ctx context.Context)

+ type UserGroupBy struct

+ func (ugb *UserGroupBy) Aggregate(fns ...AggregateFunc) *UserGroupBy

+ func (ugb *UserGroupBy) Bool(ctx context.Context) (_ bool, err error)

+ func (ugb *UserGroupBy) BoolX(ctx context.Context) bool

+ func (ugb *UserGroupBy) Bools(ctx context.Context) ([]bool, error)

+ func (ugb *UserGroupBy) BoolsX(ctx context.Context) []bool

+ func (ugb *UserGroupBy) Float64(ctx context.Context) (_ float64, err error)

+ func (ugb *UserGroupBy) Float64X(ctx context.Context) float64

+ func (ugb *UserGroupBy) Float64s(ctx context.Context) ([]float64, error)

+ func (ugb *UserGroupBy) Float64sX(ctx context.Context) []float64

+ func (ugb *UserGroupBy) Int(ctx context.Context) (_ int, err error)

+ func (ugb *UserGroupBy) IntX(ctx context.Context) int

+ func (ugb *UserGroupBy) Ints(ctx context.Context) ([]int, error)

+ func (ugb *UserGroupBy) IntsX(ctx context.Context) []int

+ func (ugb *UserGroupBy) Scan(ctx context.Context, v interface{}) error

+ func (ugb *UserGroupBy) ScanX(ctx context.Context, v interface{})

+ func (ugb *UserGroupBy) String(ctx context.Context) (_ string, err error)

+ func (ugb *UserGroupBy) StringX(ctx context.Context) string

+ func (ugb *UserGroupBy) Strings(ctx context.Context) ([]string, error)

+ func (ugb *UserGroupBy) StringsX(ctx context.Context) []string

+ type UserMutation struct

+ func (m *UserMutation) AddField(name string, value ent.Value) error

+ func (m *UserMutation) AddedEdges() []string

+ func (m *UserMutation) AddedField(name string) (ent.Value, bool)

+ func (m *UserMutation) AddedFields() []string

+ func (m *UserMutation) AddedIDs(name string) []ent.Value

+ func (m *UserMutation) ClearEdge(name string) error

+ func (m *UserMutation) ClearField(name string) error

+ func (m *UserMutation) ClearWebhook()

+ func (m *UserMutation) ClearedEdges() []string

+ func (m *UserMutation) ClearedFields() []string

+ func (m *UserMutation) CreatedAt() (r time.Time, exists bool)

+ func (m *UserMutation) EdgeCleared(name string) bool

+ func (m *UserMutation) Field(name string) (ent.Value, bool)

+ func (m *UserMutation) FieldCleared(name string) bool

+ func (m *UserMutation) Fields() []string

+ func (m *UserMutation) ID() (id uuid.UUID, exists bool)

+ func (m *UserMutation) IDs(ctx context.Context) ([]uuid.UUID, error)

+ func (m *UserMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error)

+ func (m *UserMutation) OldField(ctx context.Context, name string) (ent.Value, error)

+ func (m *UserMutation) OldPassword(ctx context.Context) (v string, err error)

+ func (m *UserMutation) OldRole(ctx context.Context) (v utils.Role, err error)

+ func (m *UserMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error)

+ func (m *UserMutation) OldUsername(ctx context.Context) (v string, err error)

+ func (m *UserMutation) OldWebhook(ctx context.Context) (v string, err error)

+ func (m *UserMutation) Op() Op

+ func (m *UserMutation) Password() (r string, exists bool)

+ func (m *UserMutation) RemovedEdges() []string

+ func (m *UserMutation) RemovedIDs(name string) []ent.Value

+ func (m *UserMutation) ResetCreatedAt()

+ func (m *UserMutation) ResetEdge(name string) error

+ func (m *UserMutation) ResetField(name string) error

+ func (m *UserMutation) ResetPassword()

+ func (m *UserMutation) ResetRole()

+ func (m *UserMutation) ResetUpdatedAt()

+ func (m *UserMutation) ResetUsername()

+ func (m *UserMutation) ResetWebhook()

+ func (m *UserMutation) Role() (r utils.Role, exists bool)

+ func (m *UserMutation) SetCreatedAt(t time.Time)

+ func (m *UserMutation) SetField(name string, value ent.Value) error

+ func (m *UserMutation) SetID(id uuid.UUID)

+ func (m *UserMutation) SetPassword(s string)

+ func (m *UserMutation) SetRole(u utils.Role)

+ func (m *UserMutation) SetUpdatedAt(t time.Time)

+ func (m *UserMutation) SetUsername(s string)

+ func (m *UserMutation) SetWebhook(s string)

+ func (m *UserMutation) Type() string

+ func (m *UserMutation) UpdatedAt() (r time.Time, exists bool)

+ func (m *UserMutation) Username() (r string, exists bool)

+ func (m *UserMutation) Webhook() (r string, exists bool)

+ func (m *UserMutation) WebhookCleared() bool

+ func (m *UserMutation) Where(ps ...predicate.User)

+ func (m UserMutation) Client() *Client

+ func (m UserMutation) Tx() (*Tx, error)

+ type UserQuery struct

+ func (uq *UserQuery) All(ctx context.Context) ([]*User, error)

+ func (uq *UserQuery) AllX(ctx context.Context) []*User

+ func (uq *UserQuery) Clone() *UserQuery

+ func (uq *UserQuery) Count(ctx context.Context) (int, error)

+ func (uq *UserQuery) CountX(ctx context.Context) int

+ func (uq *UserQuery) Exist(ctx context.Context) (bool, error)

+ func (uq *UserQuery) ExistX(ctx context.Context) bool

+ func (uq *UserQuery) First(ctx context.Context) (*User, error)

+ func (uq *UserQuery) FirstID(ctx context.Context) (id uuid.UUID, err error)

+ func (uq *UserQuery) FirstIDX(ctx context.Context) uuid.UUID

+ func (uq *UserQuery) FirstX(ctx context.Context) *User

+ func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy

+ func (uq *UserQuery) IDs(ctx context.Context) ([]uuid.UUID, error)

+ func (uq *UserQuery) IDsX(ctx context.Context) []uuid.UUID

+ func (uq *UserQuery) Limit(limit int) *UserQuery

+ func (uq *UserQuery) Offset(offset int) *UserQuery

+ func (uq *UserQuery) Only(ctx context.Context) (*User, error)

+ func (uq *UserQuery) OnlyID(ctx context.Context) (id uuid.UUID, err error)

+ func (uq *UserQuery) OnlyIDX(ctx context.Context) uuid.UUID

+ func (uq *UserQuery) OnlyX(ctx context.Context) *User

+ func (uq *UserQuery) Order(o ...OrderFunc) *UserQuery

+ func (uq *UserQuery) Select(fields ...string) *UserSelect

+ func (uq *UserQuery) Unique(unique bool) *UserQuery

+ func (uq *UserQuery) Where(ps ...predicate.User) *UserQuery

+ type UserSelect struct

+ func (us *UserSelect) Bool(ctx context.Context) (_ bool, err error)

+ func (us *UserSelect) BoolX(ctx context.Context) bool

+ func (us *UserSelect) Bools(ctx context.Context) ([]bool, error)

+ func (us *UserSelect) BoolsX(ctx context.Context) []bool

+ func (us *UserSelect) Float64(ctx context.Context) (_ float64, err error)

+ func (us *UserSelect) Float64X(ctx context.Context) float64

+ func (us *UserSelect) Float64s(ctx context.Context) ([]float64, error)

+ func (us *UserSelect) Float64sX(ctx context.Context) []float64

+ func (us *UserSelect) Int(ctx context.Context) (_ int, err error)

+ func (us *UserSelect) IntX(ctx context.Context) int

+ func (us *UserSelect) Ints(ctx context.Context) ([]int, error)

+ func (us *UserSelect) IntsX(ctx context.Context) []int

+ func (us *UserSelect) Scan(ctx context.Context, v interface{}) error

+ func (us *UserSelect) ScanX(ctx context.Context, v interface{})

+ func (us *UserSelect) String(ctx context.Context) (_ string, err error)

+ func (us *UserSelect) StringX(ctx context.Context) string

+ func (us *UserSelect) Strings(ctx context.Context) ([]string, error)

+ func (us *UserSelect) StringsX(ctx context.Context) []string

+ type UserUpdate struct

+ func (uu *UserUpdate) ClearWebhook() *UserUpdate

+ func (uu *UserUpdate) Exec(ctx context.Context) error

+ func (uu *UserUpdate) ExecX(ctx context.Context)

+ func (uu *UserUpdate) Mutation() *UserMutation

+ func (uu *UserUpdate) Save(ctx context.Context) (int, error)

+ func (uu *UserUpdate) SaveX(ctx context.Context) int

+ func (uu *UserUpdate) SetNillableRole(u *utils.Role) *UserUpdate

+ func (uu *UserUpdate) SetNillableWebhook(s *string) *UserUpdate

+ func (uu *UserUpdate) SetPassword(s string) *UserUpdate

+ func (uu *UserUpdate) SetRole(u utils.Role) *UserUpdate

+ func (uu *UserUpdate) SetUpdatedAt(t time.Time) *UserUpdate

+ func (uu *UserUpdate) SetUsername(s string) *UserUpdate

+ func (uu *UserUpdate) SetWebhook(s string) *UserUpdate

+ func (uu *UserUpdate) Where(ps ...predicate.User) *UserUpdate

+ type UserUpdateOne struct

+ func (uuo *UserUpdateOne) ClearWebhook() *UserUpdateOne

+ func (uuo *UserUpdateOne) Exec(ctx context.Context) error

+ func (uuo *UserUpdateOne) ExecX(ctx context.Context)

+ func (uuo *UserUpdateOne) Mutation() *UserMutation

+ func (uuo *UserUpdateOne) Save(ctx context.Context) (*User, error)

+ func (uuo *UserUpdateOne) SaveX(ctx context.Context) *User

+ func (uuo *UserUpdateOne) Select(field string, fields ...string) *UserUpdateOne

+ func (uuo *UserUpdateOne) SetNillableRole(u *utils.Role) *UserUpdateOne

+ func (uuo *UserUpdateOne) SetNillableWebhook(s *string) *UserUpdateOne

+ func (uuo *UserUpdateOne) SetPassword(s string) *UserUpdateOne

+ func (uuo *UserUpdateOne) SetRole(u utils.Role) *UserUpdateOne

+ func (uuo *UserUpdateOne) SetUpdatedAt(t time.Time) *UserUpdateOne

+ func (uuo *UserUpdateOne) SetUsername(s string) *UserUpdateOne

+ func (uuo *UserUpdateOne) SetWebhook(s string) *UserUpdateOne

+ type Users []*User

+ type ValidationError struct

+ Name string

+ func (e *ValidationError) Error() string

+ func (e *ValidationError) Unwrap() error

+ type Value = ent.Value

+ type Vod struct

+ ChatPath string

+ ChatVideoPath string

+ CreatedAt time.Time

+ Duration int

+ Edges VodEdges

+ ExtID string

+ ID uuid.UUID

+ InfoPath string

+ Platform utils.VodPlatform

+ Processing bool

+ Resolution string

+ StreamedAt time.Time

+ ThumbnailPath string

+ Title string

+ Type utils.VodType

+ UpdatedAt time.Time

+ VideoPath string

+ Views int

+ WebThumbnailPath string

+ func (v *Vod) QueryChannel() *ChannelQuery

+ func (v *Vod) QueryQueue() *QueueQuery

+ func (v *Vod) String() string

+ func (v *Vod) Unwrap() *Vod

+ func (v *Vod) Update() *VodUpdateOne

+ type VodClient struct

+ func NewVodClient(c config) *VodClient

+ func (c *VodClient) Create() *VodCreate

+ func (c *VodClient) CreateBulk(builders ...*VodCreate) *VodCreateBulk

+ func (c *VodClient) Delete() *VodDelete

+ func (c *VodClient) DeleteOne(v *Vod) *VodDeleteOne

+ func (c *VodClient) DeleteOneID(id uuid.UUID) *VodDeleteOne

+ func (c *VodClient) Get(ctx context.Context, id uuid.UUID) (*Vod, error)

+ func (c *VodClient) GetX(ctx context.Context, id uuid.UUID) *Vod

+ func (c *VodClient) Hooks() []Hook

+ func (c *VodClient) Query() *VodQuery

+ func (c *VodClient) QueryChannel(v *Vod) *ChannelQuery

+ func (c *VodClient) QueryQueue(v *Vod) *QueueQuery

+ func (c *VodClient) Update() *VodUpdate

+ func (c *VodClient) UpdateOne(v *Vod) *VodUpdateOne

+ func (c *VodClient) UpdateOneID(id uuid.UUID) *VodUpdateOne

+ func (c *VodClient) Use(hooks ...Hook)

+ type VodCreate struct

+ func (vc *VodCreate) Exec(ctx context.Context) error

+ func (vc *VodCreate) ExecX(ctx context.Context)

+ func (vc *VodCreate) Mutation() *VodMutation

+ func (vc *VodCreate) Save(ctx context.Context) (*Vod, error)

+ func (vc *VodCreate) SaveX(ctx context.Context) *Vod

+ func (vc *VodCreate) SetChannel(c *Channel) *VodCreate

+ func (vc *VodCreate) SetChannelID(id uuid.UUID) *VodCreate

+ func (vc *VodCreate) SetChatPath(s string) *VodCreate

+ func (vc *VodCreate) SetChatVideoPath(s string) *VodCreate

+ func (vc *VodCreate) SetCreatedAt(t time.Time) *VodCreate

+ func (vc *VodCreate) SetDuration(i int) *VodCreate

+ func (vc *VodCreate) SetExtID(s string) *VodCreate

+ func (vc *VodCreate) SetID(u uuid.UUID) *VodCreate

+ func (vc *VodCreate) SetInfoPath(s string) *VodCreate

+ func (vc *VodCreate) SetNillableChatPath(s *string) *VodCreate

+ func (vc *VodCreate) SetNillableChatVideoPath(s *string) *VodCreate

+ func (vc *VodCreate) SetNillableCreatedAt(t *time.Time) *VodCreate

+ func (vc *VodCreate) SetNillableDuration(i *int) *VodCreate

+ func (vc *VodCreate) SetNillableID(u *uuid.UUID) *VodCreate

+ func (vc *VodCreate) SetNillableInfoPath(s *string) *VodCreate

+ func (vc *VodCreate) SetNillablePlatform(up *utils.VodPlatform) *VodCreate

+ func (vc *VodCreate) SetNillableProcessing(b *bool) *VodCreate

+ func (vc *VodCreate) SetNillableQueueID(id *uuid.UUID) *VodCreate

+ func (vc *VodCreate) SetNillableResolution(s *string) *VodCreate

+ func (vc *VodCreate) SetNillableStreamedAt(t *time.Time) *VodCreate

+ func (vc *VodCreate) SetNillableThumbnailPath(s *string) *VodCreate

+ func (vc *VodCreate) SetNillableType(ut *utils.VodType) *VodCreate

+ func (vc *VodCreate) SetNillableUpdatedAt(t *time.Time) *VodCreate

+ func (vc *VodCreate) SetNillableViews(i *int) *VodCreate

+ func (vc *VodCreate) SetPlatform(up utils.VodPlatform) *VodCreate

+ func (vc *VodCreate) SetProcessing(b bool) *VodCreate

+ func (vc *VodCreate) SetQueue(q *Queue) *VodCreate

+ func (vc *VodCreate) SetQueueID(id uuid.UUID) *VodCreate

+ func (vc *VodCreate) SetResolution(s string) *VodCreate

+ func (vc *VodCreate) SetStreamedAt(t time.Time) *VodCreate

+ func (vc *VodCreate) SetThumbnailPath(s string) *VodCreate

+ func (vc *VodCreate) SetTitle(s string) *VodCreate

+ func (vc *VodCreate) SetType(ut utils.VodType) *VodCreate

+ func (vc *VodCreate) SetUpdatedAt(t time.Time) *VodCreate

+ func (vc *VodCreate) SetVideoPath(s string) *VodCreate

+ func (vc *VodCreate) SetViews(i int) *VodCreate

+ func (vc *VodCreate) SetWebThumbnailPath(s string) *VodCreate

+ type VodCreateBulk struct

+ func (vcb *VodCreateBulk) Exec(ctx context.Context) error

+ func (vcb *VodCreateBulk) ExecX(ctx context.Context)

+ func (vcb *VodCreateBulk) Save(ctx context.Context) ([]*Vod, error)

+ func (vcb *VodCreateBulk) SaveX(ctx context.Context) []*Vod

+ type VodDelete struct

+ func (vd *VodDelete) Exec(ctx context.Context) (int, error)

+ func (vd *VodDelete) ExecX(ctx context.Context) int

+ func (vd *VodDelete) Where(ps ...predicate.Vod) *VodDelete

+ type VodDeleteOne struct

+ func (vdo *VodDeleteOne) Exec(ctx context.Context) error

+ func (vdo *VodDeleteOne) ExecX(ctx context.Context)

+ type VodEdges struct

+ Channel *Channel

+ Queue *Queue

+ func (e VodEdges) ChannelOrErr() (*Channel, error)

+ func (e VodEdges) QueueOrErr() (*Queue, error)

+ type VodGroupBy struct

+ func (vgb *VodGroupBy) Aggregate(fns ...AggregateFunc) *VodGroupBy

+ func (vgb *VodGroupBy) Bool(ctx context.Context) (_ bool, err error)

+ func (vgb *VodGroupBy) BoolX(ctx context.Context) bool

+ func (vgb *VodGroupBy) Bools(ctx context.Context) ([]bool, error)

+ func (vgb *VodGroupBy) BoolsX(ctx context.Context) []bool

+ func (vgb *VodGroupBy) Float64(ctx context.Context) (_ float64, err error)

+ func (vgb *VodGroupBy) Float64X(ctx context.Context) float64

+ func (vgb *VodGroupBy) Float64s(ctx context.Context) ([]float64, error)

+ func (vgb *VodGroupBy) Float64sX(ctx context.Context) []float64

+ func (vgb *VodGroupBy) Int(ctx context.Context) (_ int, err error)

+ func (vgb *VodGroupBy) IntX(ctx context.Context) int

+ func (vgb *VodGroupBy) Ints(ctx context.Context) ([]int, error)

+ func (vgb *VodGroupBy) IntsX(ctx context.Context) []int

+ func (vgb *VodGroupBy) Scan(ctx context.Context, v interface{}) error

+ func (vgb *VodGroupBy) ScanX(ctx context.Context, v interface{})

+ func (vgb *VodGroupBy) String(ctx context.Context) (_ string, err error)

+ func (vgb *VodGroupBy) StringX(ctx context.Context) string

+ func (vgb *VodGroupBy) Strings(ctx context.Context) ([]string, error)

+ func (vgb *VodGroupBy) StringsX(ctx context.Context) []string

+ type VodMutation struct

+ func (m *VodMutation) AddDuration(i int)

+ func (m *VodMutation) AddField(name string, value ent.Value) error

+ func (m *VodMutation) AddViews(i int)

+ func (m *VodMutation) AddedDuration() (r int, exists bool)

+ func (m *VodMutation) AddedEdges() []string

+ func (m *VodMutation) AddedField(name string) (ent.Value, bool)

+ func (m *VodMutation) AddedFields() []string

+ func (m *VodMutation) AddedIDs(name string) []ent.Value

+ func (m *VodMutation) AddedViews() (r int, exists bool)

+ func (m *VodMutation) ChannelCleared() bool

+ func (m *VodMutation) ChannelID() (id uuid.UUID, exists bool)

+ func (m *VodMutation) ChannelIDs() (ids []uuid.UUID)

+ func (m *VodMutation) ChatPath() (r string, exists bool)

+ func (m *VodMutation) ChatPathCleared() bool

+ func (m *VodMutation) ChatVideoPath() (r string, exists bool)

+ func (m *VodMutation) ChatVideoPathCleared() bool

+ func (m *VodMutation) ClearChannel()

+ func (m *VodMutation) ClearChatPath()

+ func (m *VodMutation) ClearChatVideoPath()

+ func (m *VodMutation) ClearEdge(name string) error

+ func (m *VodMutation) ClearField(name string) error

+ func (m *VodMutation) ClearInfoPath()

+ func (m *VodMutation) ClearQueue()

+ func (m *VodMutation) ClearResolution()

+ func (m *VodMutation) ClearThumbnailPath()

+ func (m *VodMutation) ClearedEdges() []string

+ func (m *VodMutation) ClearedFields() []string

+ func (m *VodMutation) CreatedAt() (r time.Time, exists bool)

+ func (m *VodMutation) Duration() (r int, exists bool)

+ func (m *VodMutation) EdgeCleared(name string) bool

+ func (m *VodMutation) ExtID() (r string, exists bool)

+ func (m *VodMutation) Field(name string) (ent.Value, bool)

+ func (m *VodMutation) FieldCleared(name string) bool

+ func (m *VodMutation) Fields() []string

+ func (m *VodMutation) GetType() (r utils.VodType, exists bool)

+ func (m *VodMutation) ID() (id uuid.UUID, exists bool)

+ func (m *VodMutation) IDs(ctx context.Context) ([]uuid.UUID, error)

+ func (m *VodMutation) InfoPath() (r string, exists bool)

+ func (m *VodMutation) InfoPathCleared() bool

+ func (m *VodMutation) OldChatPath(ctx context.Context) (v string, err error)

+ func (m *VodMutation) OldChatVideoPath(ctx context.Context) (v string, err error)

+ func (m *VodMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error)

+ func (m *VodMutation) OldDuration(ctx context.Context) (v int, err error)

+ func (m *VodMutation) OldExtID(ctx context.Context) (v string, err error)

+ func (m *VodMutation) OldField(ctx context.Context, name string) (ent.Value, error)

+ func (m *VodMutation) OldInfoPath(ctx context.Context) (v string, err error)

+ func (m *VodMutation) OldPlatform(ctx context.Context) (v utils.VodPlatform, err error)

+ func (m *VodMutation) OldProcessing(ctx context.Context) (v bool, err error)

+ func (m *VodMutation) OldResolution(ctx context.Context) (v string, err error)

+ func (m *VodMutation) OldStreamedAt(ctx context.Context) (v time.Time, err error)

+ func (m *VodMutation) OldThumbnailPath(ctx context.Context) (v string, err error)

+ func (m *VodMutation) OldTitle(ctx context.Context) (v string, err error)

+ func (m *VodMutation) OldType(ctx context.Context) (v utils.VodType, err error)

+ func (m *VodMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error)

+ func (m *VodMutation) OldVideoPath(ctx context.Context) (v string, err error)

+ func (m *VodMutation) OldViews(ctx context.Context) (v int, err error)

+ func (m *VodMutation) OldWebThumbnailPath(ctx context.Context) (v string, err error)

+ func (m *VodMutation) Op() Op

+ func (m *VodMutation) Platform() (r utils.VodPlatform, exists bool)

+ func (m *VodMutation) Processing() (r bool, exists bool)

+ func (m *VodMutation) QueueCleared() bool

+ func (m *VodMutation) QueueID() (id uuid.UUID, exists bool)

+ func (m *VodMutation) QueueIDs() (ids []uuid.UUID)

+ func (m *VodMutation) RemovedEdges() []string

+ func (m *VodMutation) RemovedIDs(name string) []ent.Value

+ func (m *VodMutation) ResetChannel()

+ func (m *VodMutation) ResetChatPath()

+ func (m *VodMutation) ResetChatVideoPath()

+ func (m *VodMutation) ResetCreatedAt()

+ func (m *VodMutation) ResetDuration()

+ func (m *VodMutation) ResetEdge(name string) error

+ func (m *VodMutation) ResetExtID()

+ func (m *VodMutation) ResetField(name string) error

+ func (m *VodMutation) ResetInfoPath()

+ func (m *VodMutation) ResetPlatform()

+ func (m *VodMutation) ResetProcessing()

+ func (m *VodMutation) ResetQueue()

+ func (m *VodMutation) ResetResolution()

+ func (m *VodMutation) ResetStreamedAt()

+ func (m *VodMutation) ResetThumbnailPath()

+ func (m *VodMutation) ResetTitle()

+ func (m *VodMutation) ResetType()

+ func (m *VodMutation) ResetUpdatedAt()

+ func (m *VodMutation) ResetVideoPath()

+ func (m *VodMutation) ResetViews()

+ func (m *VodMutation) ResetWebThumbnailPath()

+ func (m *VodMutation) Resolution() (r string, exists bool)

+ func (m *VodMutation) ResolutionCleared() bool

+ func (m *VodMutation) SetChannelID(id uuid.UUID)

+ func (m *VodMutation) SetChatPath(s string)

+ func (m *VodMutation) SetChatVideoPath(s string)

+ func (m *VodMutation) SetCreatedAt(t time.Time)

+ func (m *VodMutation) SetDuration(i int)

+ func (m *VodMutation) SetExtID(s string)

+ func (m *VodMutation) SetField(name string, value ent.Value) error

+ func (m *VodMutation) SetID(id uuid.UUID)

+ func (m *VodMutation) SetInfoPath(s string)

+ func (m *VodMutation) SetPlatform(up utils.VodPlatform)

+ func (m *VodMutation) SetProcessing(b bool)

+ func (m *VodMutation) SetQueueID(id uuid.UUID)

+ func (m *VodMutation) SetResolution(s string)

+ func (m *VodMutation) SetStreamedAt(t time.Time)

+ func (m *VodMutation) SetThumbnailPath(s string)

+ func (m *VodMutation) SetTitle(s string)

+ func (m *VodMutation) SetType(ut utils.VodType)

+ func (m *VodMutation) SetUpdatedAt(t time.Time)

+ func (m *VodMutation) SetVideoPath(s string)

+ func (m *VodMutation) SetViews(i int)

+ func (m *VodMutation) SetWebThumbnailPath(s string)

+ func (m *VodMutation) StreamedAt() (r time.Time, exists bool)

+ func (m *VodMutation) ThumbnailPath() (r string, exists bool)

+ func (m *VodMutation) ThumbnailPathCleared() bool

+ func (m *VodMutation) Title() (r string, exists bool)

+ func (m *VodMutation) Type() string

+ func (m *VodMutation) UpdatedAt() (r time.Time, exists bool)

+ func (m *VodMutation) VideoPath() (r string, exists bool)

+ func (m *VodMutation) Views() (r int, exists bool)

+ func (m *VodMutation) WebThumbnailPath() (r string, exists bool)

+ func (m *VodMutation) Where(ps ...predicate.Vod)

+ func (m VodMutation) Client() *Client

+ func (m VodMutation) Tx() (*Tx, error)

+ type VodQuery struct

+ func (vq *VodQuery) All(ctx context.Context) ([]*Vod, error)

+ func (vq *VodQuery) AllX(ctx context.Context) []*Vod

+ func (vq *VodQuery) Clone() *VodQuery

+ func (vq *VodQuery) Count(ctx context.Context) (int, error)

+ func (vq *VodQuery) CountX(ctx context.Context) int

+ func (vq *VodQuery) Exist(ctx context.Context) (bool, error)

+ func (vq *VodQuery) ExistX(ctx context.Context) bool

+ func (vq *VodQuery) First(ctx context.Context) (*Vod, error)

+ func (vq *VodQuery) FirstID(ctx context.Context) (id uuid.UUID, err error)

+ func (vq *VodQuery) FirstIDX(ctx context.Context) uuid.UUID

+ func (vq *VodQuery) FirstX(ctx context.Context) *Vod

+ func (vq *VodQuery) GroupBy(field string, fields ...string) *VodGroupBy

+ func (vq *VodQuery) IDs(ctx context.Context) ([]uuid.UUID, error)

+ func (vq *VodQuery) IDsX(ctx context.Context) []uuid.UUID

+ func (vq *VodQuery) Limit(limit int) *VodQuery

+ func (vq *VodQuery) Offset(offset int) *VodQuery

+ func (vq *VodQuery) Only(ctx context.Context) (*Vod, error)

+ func (vq *VodQuery) OnlyID(ctx context.Context) (id uuid.UUID, err error)

+ func (vq *VodQuery) OnlyIDX(ctx context.Context) uuid.UUID

+ func (vq *VodQuery) OnlyX(ctx context.Context) *Vod

+ func (vq *VodQuery) Order(o ...OrderFunc) *VodQuery

+ func (vq *VodQuery) QueryChannel() *ChannelQuery

+ func (vq *VodQuery) QueryQueue() *QueueQuery

+ func (vq *VodQuery) Select(fields ...string) *VodSelect

+ func (vq *VodQuery) Unique(unique bool) *VodQuery

+ func (vq *VodQuery) Where(ps ...predicate.Vod) *VodQuery

+ func (vq *VodQuery) WithChannel(opts ...func(*ChannelQuery)) *VodQuery

+ func (vq *VodQuery) WithQueue(opts ...func(*QueueQuery)) *VodQuery

+ type VodSelect struct

+ func (vs *VodSelect) Bool(ctx context.Context) (_ bool, err error)

+ func (vs *VodSelect) BoolX(ctx context.Context) bool

+ func (vs *VodSelect) Bools(ctx context.Context) ([]bool, error)

+ func (vs *VodSelect) BoolsX(ctx context.Context) []bool

+ func (vs *VodSelect) Float64(ctx context.Context) (_ float64, err error)

+ func (vs *VodSelect) Float64X(ctx context.Context) float64

+ func (vs *VodSelect) Float64s(ctx context.Context) ([]float64, error)

+ func (vs *VodSelect) Float64sX(ctx context.Context) []float64

+ func (vs *VodSelect) Int(ctx context.Context) (_ int, err error)

+ func (vs *VodSelect) IntX(ctx context.Context) int

+ func (vs *VodSelect) Ints(ctx context.Context) ([]int, error)

+ func (vs *VodSelect) IntsX(ctx context.Context) []int

+ func (vs *VodSelect) Scan(ctx context.Context, v interface{}) error

+ func (vs *VodSelect) ScanX(ctx context.Context, v interface{})

+ func (vs *VodSelect) String(ctx context.Context) (_ string, err error)

+ func (vs *VodSelect) StringX(ctx context.Context) string

+ func (vs *VodSelect) Strings(ctx context.Context) ([]string, error)

+ func (vs *VodSelect) StringsX(ctx context.Context) []string

+ type VodUpdate struct

+ func (vu *VodUpdate) AddDuration(i int) *VodUpdate

+ func (vu *VodUpdate) AddViews(i int) *VodUpdate

+ func (vu *VodUpdate) ClearChannel() *VodUpdate

+ func (vu *VodUpdate) ClearChatPath() *VodUpdate

+ func (vu *VodUpdate) ClearChatVideoPath() *VodUpdate

+ func (vu *VodUpdate) ClearInfoPath() *VodUpdate

+ func (vu *VodUpdate) ClearQueue() *VodUpdate

+ func (vu *VodUpdate) ClearResolution() *VodUpdate

+ func (vu *VodUpdate) ClearThumbnailPath() *VodUpdate

+ func (vu *VodUpdate) Exec(ctx context.Context) error

+ func (vu *VodUpdate) ExecX(ctx context.Context)

+ func (vu *VodUpdate) Mutation() *VodMutation

+ func (vu *VodUpdate) Save(ctx context.Context) (int, error)

+ func (vu *VodUpdate) SaveX(ctx context.Context) int

+ func (vu *VodUpdate) SetChannel(c *Channel) *VodUpdate

+ func (vu *VodUpdate) SetChannelID(id uuid.UUID) *VodUpdate

+ func (vu *VodUpdate) SetChatPath(s string) *VodUpdate

+ func (vu *VodUpdate) SetChatVideoPath(s string) *VodUpdate

+ func (vu *VodUpdate) SetDuration(i int) *VodUpdate

+ func (vu *VodUpdate) SetExtID(s string) *VodUpdate

+ func (vu *VodUpdate) SetInfoPath(s string) *VodUpdate

+ func (vu *VodUpdate) SetNillableChatPath(s *string) *VodUpdate

+ func (vu *VodUpdate) SetNillableChatVideoPath(s *string) *VodUpdate

+ func (vu *VodUpdate) SetNillableDuration(i *int) *VodUpdate

+ func (vu *VodUpdate) SetNillableInfoPath(s *string) *VodUpdate

+ func (vu *VodUpdate) SetNillablePlatform(up *utils.VodPlatform) *VodUpdate

+ func (vu *VodUpdate) SetNillableProcessing(b *bool) *VodUpdate

+ func (vu *VodUpdate) SetNillableQueueID(id *uuid.UUID) *VodUpdate

+ func (vu *VodUpdate) SetNillableResolution(s *string) *VodUpdate

+ func (vu *VodUpdate) SetNillableStreamedAt(t *time.Time) *VodUpdate

+ func (vu *VodUpdate) SetNillableThumbnailPath(s *string) *VodUpdate

+ func (vu *VodUpdate) SetNillableType(ut *utils.VodType) *VodUpdate

+ func (vu *VodUpdate) SetNillableViews(i *int) *VodUpdate

+ func (vu *VodUpdate) SetPlatform(up utils.VodPlatform) *VodUpdate

+ func (vu *VodUpdate) SetProcessing(b bool) *VodUpdate

+ func (vu *VodUpdate) SetQueue(q *Queue) *VodUpdate

+ func (vu *VodUpdate) SetQueueID(id uuid.UUID) *VodUpdate

+ func (vu *VodUpdate) SetResolution(s string) *VodUpdate

+ func (vu *VodUpdate) SetStreamedAt(t time.Time) *VodUpdate

+ func (vu *VodUpdate) SetThumbnailPath(s string) *VodUpdate

+ func (vu *VodUpdate) SetTitle(s string) *VodUpdate

+ func (vu *VodUpdate) SetType(ut utils.VodType) *VodUpdate

+ func (vu *VodUpdate) SetUpdatedAt(t time.Time) *VodUpdate

+ func (vu *VodUpdate) SetVideoPath(s string) *VodUpdate

+ func (vu *VodUpdate) SetViews(i int) *VodUpdate

+ func (vu *VodUpdate) SetWebThumbnailPath(s string) *VodUpdate

+ func (vu *VodUpdate) Where(ps ...predicate.Vod) *VodUpdate

+ type VodUpdateOne struct

+ func (vuo *VodUpdateOne) AddDuration(i int) *VodUpdateOne

+ func (vuo *VodUpdateOne) AddViews(i int) *VodUpdateOne

+ func (vuo *VodUpdateOne) ClearChannel() *VodUpdateOne

+ func (vuo *VodUpdateOne) ClearChatPath() *VodUpdateOne

+ func (vuo *VodUpdateOne) ClearChatVideoPath() *VodUpdateOne

+ func (vuo *VodUpdateOne) ClearInfoPath() *VodUpdateOne

+ func (vuo *VodUpdateOne) ClearQueue() *VodUpdateOne

+ func (vuo *VodUpdateOne) ClearResolution() *VodUpdateOne

+ func (vuo *VodUpdateOne) ClearThumbnailPath() *VodUpdateOne

+ func (vuo *VodUpdateOne) Exec(ctx context.Context) error

+ func (vuo *VodUpdateOne) ExecX(ctx context.Context)

+ func (vuo *VodUpdateOne) Mutation() *VodMutation

+ func (vuo *VodUpdateOne) Save(ctx context.Context) (*Vod, error)

+ func (vuo *VodUpdateOne) SaveX(ctx context.Context) *Vod

+ func (vuo *VodUpdateOne) Select(field string, fields ...string) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetChannel(c *Channel) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetChannelID(id uuid.UUID) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetChatPath(s string) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetChatVideoPath(s string) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetDuration(i int) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetExtID(s string) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetInfoPath(s string) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetNillableChatPath(s *string) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetNillableChatVideoPath(s *string) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetNillableDuration(i *int) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetNillableInfoPath(s *string) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetNillablePlatform(up *utils.VodPlatform) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetNillableProcessing(b *bool) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetNillableQueueID(id *uuid.UUID) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetNillableResolution(s *string) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetNillableStreamedAt(t *time.Time) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetNillableThumbnailPath(s *string) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetNillableType(ut *utils.VodType) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetNillableViews(i *int) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetPlatform(up utils.VodPlatform) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetProcessing(b bool) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetQueue(q *Queue) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetQueueID(id uuid.UUID) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetResolution(s string) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetStreamedAt(t time.Time) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetThumbnailPath(s string) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetTitle(s string) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetType(ut utils.VodType) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetUpdatedAt(t time.Time) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetVideoPath(s string) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetViews(i int) *VodUpdateOne

+ func (vuo *VodUpdateOne) SetWebThumbnailPath(s string) *VodUpdateOne

+ type Vods []*Vod

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL