10247 lines
304 KiB
Go
10247 lines
304 KiB
Go
// Code generated by ent, DO NOT EDIT.
|
|
|
|
package ent
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"sync"
|
|
"time"
|
|
"tss-rocks-be/ent/category"
|
|
"tss-rocks-be/ent/categorycontent"
|
|
"tss-rocks-be/ent/contributor"
|
|
"tss-rocks-be/ent/contributorrole"
|
|
"tss-rocks-be/ent/contributorsociallink"
|
|
"tss-rocks-be/ent/daily"
|
|
"tss-rocks-be/ent/dailycategory"
|
|
"tss-rocks-be/ent/dailycategorycontent"
|
|
"tss-rocks-be/ent/dailycontent"
|
|
"tss-rocks-be/ent/media"
|
|
"tss-rocks-be/ent/permission"
|
|
"tss-rocks-be/ent/post"
|
|
"tss-rocks-be/ent/postcontent"
|
|
"tss-rocks-be/ent/postcontributor"
|
|
"tss-rocks-be/ent/predicate"
|
|
"tss-rocks-be/ent/role"
|
|
"tss-rocks-be/ent/user"
|
|
|
|
"entgo.io/ent"
|
|
"entgo.io/ent/dialect/sql"
|
|
)
|
|
|
|
const (
|
|
// Operation types.
|
|
OpCreate = ent.OpCreate
|
|
OpDelete = ent.OpDelete
|
|
OpDeleteOne = ent.OpDeleteOne
|
|
OpUpdate = ent.OpUpdate
|
|
OpUpdateOne = ent.OpUpdateOne
|
|
|
|
// Node types.
|
|
TypeCategory = "Category"
|
|
TypeCategoryContent = "CategoryContent"
|
|
TypeContributor = "Contributor"
|
|
TypeContributorRole = "ContributorRole"
|
|
TypeContributorSocialLink = "ContributorSocialLink"
|
|
TypeDaily = "Daily"
|
|
TypeDailyCategory = "DailyCategory"
|
|
TypeDailyCategoryContent = "DailyCategoryContent"
|
|
TypeDailyContent = "DailyContent"
|
|
TypeMedia = "Media"
|
|
TypePermission = "Permission"
|
|
TypePost = "Post"
|
|
TypePostContent = "PostContent"
|
|
TypePostContributor = "PostContributor"
|
|
TypeRole = "Role"
|
|
TypeUser = "User"
|
|
)
|
|
|
|
// CategoryMutation represents an operation that mutates the Category nodes in the graph.
|
|
type CategoryMutation struct {
|
|
config
|
|
op Op
|
|
typ string
|
|
id *int
|
|
created_at *time.Time
|
|
updated_at *time.Time
|
|
clearedFields map[string]struct{}
|
|
contents map[int]struct{}
|
|
removedcontents map[int]struct{}
|
|
clearedcontents bool
|
|
posts map[int]struct{}
|
|
removedposts map[int]struct{}
|
|
clearedposts bool
|
|
daily_items map[string]struct{}
|
|
removeddaily_items map[string]struct{}
|
|
cleareddaily_items bool
|
|
done bool
|
|
oldValue func(context.Context) (*Category, error)
|
|
predicates []predicate.Category
|
|
}
|
|
|
|
var _ ent.Mutation = (*CategoryMutation)(nil)
|
|
|
|
// categoryOption allows management of the mutation configuration using functional options.
|
|
type categoryOption func(*CategoryMutation)
|
|
|
|
// newCategoryMutation creates new mutation for the Category entity.
|
|
func newCategoryMutation(c config, op Op, opts ...categoryOption) *CategoryMutation {
|
|
m := &CategoryMutation{
|
|
config: c,
|
|
op: op,
|
|
typ: TypeCategory,
|
|
clearedFields: make(map[string]struct{}),
|
|
}
|
|
for _, opt := range opts {
|
|
opt(m)
|
|
}
|
|
return m
|
|
}
|
|
|
|
// withCategoryID sets the ID field of the mutation.
|
|
func withCategoryID(id int) categoryOption {
|
|
return func(m *CategoryMutation) {
|
|
var (
|
|
err error
|
|
once sync.Once
|
|
value *Category
|
|
)
|
|
m.oldValue = func(ctx context.Context) (*Category, error) {
|
|
once.Do(func() {
|
|
if m.done {
|
|
err = errors.New("querying old values post mutation is not allowed")
|
|
} else {
|
|
value, err = m.Client().Category.Get(ctx, id)
|
|
}
|
|
})
|
|
return value, err
|
|
}
|
|
m.id = &id
|
|
}
|
|
}
|
|
|
|
// withCategory sets the old Category of the mutation.
|
|
func withCategory(node *Category) categoryOption {
|
|
return func(m *CategoryMutation) {
|
|
m.oldValue = func(context.Context) (*Category, error) {
|
|
return node, nil
|
|
}
|
|
m.id = &node.ID
|
|
}
|
|
}
|
|
|
|
// Client returns a new `ent.Client` from the mutation. If the mutation was
|
|
// executed in a transaction (ent.Tx), a transactional client is returned.
|
|
func (m CategoryMutation) Client() *Client {
|
|
client := &Client{config: m.config}
|
|
client.init()
|
|
return client
|
|
}
|
|
|
|
// Tx returns an `ent.Tx` for mutations that were executed in transactions;
|
|
// it returns an error otherwise.
|
|
func (m CategoryMutation) Tx() (*Tx, error) {
|
|
if _, ok := m.driver.(*txDriver); !ok {
|
|
return nil, errors.New("ent: mutation is not running in a transaction")
|
|
}
|
|
tx := &Tx{config: m.config}
|
|
tx.init()
|
|
return tx, nil
|
|
}
|
|
|
|
// ID returns the ID value in the mutation. Note that the ID is only available
|
|
// if it was provided to the builder or after it was returned from the database.
|
|
func (m *CategoryMutation) ID() (id int, exists bool) {
|
|
if m.id == nil {
|
|
return
|
|
}
|
|
return *m.id, true
|
|
}
|
|
|
|
// IDs queries the database and returns the entity ids that match the mutation's predicate.
|
|
// That means, if the mutation is applied within a transaction with an isolation level such
|
|
// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
|
|
// or updated by the mutation.
|
|
func (m *CategoryMutation) IDs(ctx context.Context) ([]int, error) {
|
|
switch {
|
|
case m.op.Is(OpUpdateOne | OpDeleteOne):
|
|
id, exists := m.ID()
|
|
if exists {
|
|
return []int{id}, nil
|
|
}
|
|
fallthrough
|
|
case m.op.Is(OpUpdate | OpDelete):
|
|
return m.Client().Category.Query().Where(m.predicates...).IDs(ctx)
|
|
default:
|
|
return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
|
|
}
|
|
}
|
|
|
|
// SetCreatedAt sets the "created_at" field.
|
|
func (m *CategoryMutation) SetCreatedAt(t time.Time) {
|
|
m.created_at = &t
|
|
}
|
|
|
|
// CreatedAt returns the value of the "created_at" field in the mutation.
|
|
func (m *CategoryMutation) CreatedAt() (r time.Time, exists bool) {
|
|
v := m.created_at
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldCreatedAt returns the old "created_at" field's value of the Category entity.
|
|
// If the Category object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *CategoryMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldCreatedAt requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
|
|
}
|
|
return oldValue.CreatedAt, nil
|
|
}
|
|
|
|
// ResetCreatedAt resets all changes to the "created_at" field.
|
|
func (m *CategoryMutation) ResetCreatedAt() {
|
|
m.created_at = nil
|
|
}
|
|
|
|
// SetUpdatedAt sets the "updated_at" field.
|
|
func (m *CategoryMutation) SetUpdatedAt(t time.Time) {
|
|
m.updated_at = &t
|
|
}
|
|
|
|
// UpdatedAt returns the value of the "updated_at" field in the mutation.
|
|
func (m *CategoryMutation) UpdatedAt() (r time.Time, exists bool) {
|
|
v := m.updated_at
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldUpdatedAt returns the old "updated_at" field's value of the Category entity.
|
|
// If the Category object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *CategoryMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
|
|
}
|
|
return oldValue.UpdatedAt, nil
|
|
}
|
|
|
|
// ResetUpdatedAt resets all changes to the "updated_at" field.
|
|
func (m *CategoryMutation) ResetUpdatedAt() {
|
|
m.updated_at = nil
|
|
}
|
|
|
|
// AddContentIDs adds the "contents" edge to the CategoryContent entity by ids.
|
|
func (m *CategoryMutation) AddContentIDs(ids ...int) {
|
|
if m.contents == nil {
|
|
m.contents = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
m.contents[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// ClearContents clears the "contents" edge to the CategoryContent entity.
|
|
func (m *CategoryMutation) ClearContents() {
|
|
m.clearedcontents = true
|
|
}
|
|
|
|
// ContentsCleared reports if the "contents" edge to the CategoryContent entity was cleared.
|
|
func (m *CategoryMutation) ContentsCleared() bool {
|
|
return m.clearedcontents
|
|
}
|
|
|
|
// RemoveContentIDs removes the "contents" edge to the CategoryContent entity by IDs.
|
|
func (m *CategoryMutation) RemoveContentIDs(ids ...int) {
|
|
if m.removedcontents == nil {
|
|
m.removedcontents = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
delete(m.contents, ids[i])
|
|
m.removedcontents[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// RemovedContents returns the removed IDs of the "contents" edge to the CategoryContent entity.
|
|
func (m *CategoryMutation) RemovedContentsIDs() (ids []int) {
|
|
for id := range m.removedcontents {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ContentsIDs returns the "contents" edge IDs in the mutation.
|
|
func (m *CategoryMutation) ContentsIDs() (ids []int) {
|
|
for id := range m.contents {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetContents resets all changes to the "contents" edge.
|
|
func (m *CategoryMutation) ResetContents() {
|
|
m.contents = nil
|
|
m.clearedcontents = false
|
|
m.removedcontents = nil
|
|
}
|
|
|
|
// AddPostIDs adds the "posts" edge to the Post entity by ids.
|
|
func (m *CategoryMutation) AddPostIDs(ids ...int) {
|
|
if m.posts == nil {
|
|
m.posts = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
m.posts[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// ClearPosts clears the "posts" edge to the Post entity.
|
|
func (m *CategoryMutation) ClearPosts() {
|
|
m.clearedposts = true
|
|
}
|
|
|
|
// PostsCleared reports if the "posts" edge to the Post entity was cleared.
|
|
func (m *CategoryMutation) PostsCleared() bool {
|
|
return m.clearedposts
|
|
}
|
|
|
|
// RemovePostIDs removes the "posts" edge to the Post entity by IDs.
|
|
func (m *CategoryMutation) RemovePostIDs(ids ...int) {
|
|
if m.removedposts == nil {
|
|
m.removedposts = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
delete(m.posts, ids[i])
|
|
m.removedposts[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// RemovedPosts returns the removed IDs of the "posts" edge to the Post entity.
|
|
func (m *CategoryMutation) RemovedPostsIDs() (ids []int) {
|
|
for id := range m.removedposts {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// PostsIDs returns the "posts" edge IDs in the mutation.
|
|
func (m *CategoryMutation) PostsIDs() (ids []int) {
|
|
for id := range m.posts {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetPosts resets all changes to the "posts" edge.
|
|
func (m *CategoryMutation) ResetPosts() {
|
|
m.posts = nil
|
|
m.clearedposts = false
|
|
m.removedposts = nil
|
|
}
|
|
|
|
// AddDailyItemIDs adds the "daily_items" edge to the Daily entity by ids.
|
|
func (m *CategoryMutation) AddDailyItemIDs(ids ...string) {
|
|
if m.daily_items == nil {
|
|
m.daily_items = make(map[string]struct{})
|
|
}
|
|
for i := range ids {
|
|
m.daily_items[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// ClearDailyItems clears the "daily_items" edge to the Daily entity.
|
|
func (m *CategoryMutation) ClearDailyItems() {
|
|
m.cleareddaily_items = true
|
|
}
|
|
|
|
// DailyItemsCleared reports if the "daily_items" edge to the Daily entity was cleared.
|
|
func (m *CategoryMutation) DailyItemsCleared() bool {
|
|
return m.cleareddaily_items
|
|
}
|
|
|
|
// RemoveDailyItemIDs removes the "daily_items" edge to the Daily entity by IDs.
|
|
func (m *CategoryMutation) RemoveDailyItemIDs(ids ...string) {
|
|
if m.removeddaily_items == nil {
|
|
m.removeddaily_items = make(map[string]struct{})
|
|
}
|
|
for i := range ids {
|
|
delete(m.daily_items, ids[i])
|
|
m.removeddaily_items[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// RemovedDailyItems returns the removed IDs of the "daily_items" edge to the Daily entity.
|
|
func (m *CategoryMutation) RemovedDailyItemsIDs() (ids []string) {
|
|
for id := range m.removeddaily_items {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// DailyItemsIDs returns the "daily_items" edge IDs in the mutation.
|
|
func (m *CategoryMutation) DailyItemsIDs() (ids []string) {
|
|
for id := range m.daily_items {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetDailyItems resets all changes to the "daily_items" edge.
|
|
func (m *CategoryMutation) ResetDailyItems() {
|
|
m.daily_items = nil
|
|
m.cleareddaily_items = false
|
|
m.removeddaily_items = nil
|
|
}
|
|
|
|
// Where appends a list predicates to the CategoryMutation builder.
|
|
func (m *CategoryMutation) Where(ps ...predicate.Category) {
|
|
m.predicates = append(m.predicates, ps...)
|
|
}
|
|
|
|
// WhereP appends storage-level predicates to the CategoryMutation builder. Using this method,
|
|
// users can use type-assertion to append predicates that do not depend on any generated package.
|
|
func (m *CategoryMutation) WhereP(ps ...func(*sql.Selector)) {
|
|
p := make([]predicate.Category, len(ps))
|
|
for i := range ps {
|
|
p[i] = ps[i]
|
|
}
|
|
m.Where(p...)
|
|
}
|
|
|
|
// Op returns the operation name.
|
|
func (m *CategoryMutation) Op() Op {
|
|
return m.op
|
|
}
|
|
|
|
// SetOp allows setting the mutation operation.
|
|
func (m *CategoryMutation) SetOp(op Op) {
|
|
m.op = op
|
|
}
|
|
|
|
// Type returns the node type of this mutation (Category).
|
|
func (m *CategoryMutation) Type() string {
|
|
return m.typ
|
|
}
|
|
|
|
// Fields returns all fields that were changed during this mutation. Note that in
|
|
// order to get all numeric fields that were incremented/decremented, call
|
|
// AddedFields().
|
|
func (m *CategoryMutation) Fields() []string {
|
|
fields := make([]string, 0, 2)
|
|
if m.created_at != nil {
|
|
fields = append(fields, category.FieldCreatedAt)
|
|
}
|
|
if m.updated_at != nil {
|
|
fields = append(fields, category.FieldUpdatedAt)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// Field returns the value of a field with the given name. The second boolean
|
|
// return value indicates that this field was not set, or was not defined in the
|
|
// schema.
|
|
func (m *CategoryMutation) Field(name string) (ent.Value, bool) {
|
|
switch name {
|
|
case category.FieldCreatedAt:
|
|
return m.CreatedAt()
|
|
case category.FieldUpdatedAt:
|
|
return m.UpdatedAt()
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
// OldField returns the old value of the field from the database. An error is
|
|
// returned if the mutation operation is not UpdateOne, or the query to the
|
|
// database failed.
|
|
func (m *CategoryMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
|
|
switch name {
|
|
case category.FieldCreatedAt:
|
|
return m.OldCreatedAt(ctx)
|
|
case category.FieldUpdatedAt:
|
|
return m.OldUpdatedAt(ctx)
|
|
}
|
|
return nil, fmt.Errorf("unknown Category field %s", name)
|
|
}
|
|
|
|
// SetField sets the value of a field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *CategoryMutation) SetField(name string, value ent.Value) error {
|
|
switch name {
|
|
case category.FieldCreatedAt:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetCreatedAt(v)
|
|
return nil
|
|
case category.FieldUpdatedAt:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetUpdatedAt(v)
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Category field %s", name)
|
|
}
|
|
|
|
// AddedFields returns all numeric fields that were incremented/decremented during
|
|
// this mutation.
|
|
func (m *CategoryMutation) AddedFields() []string {
|
|
return nil
|
|
}
|
|
|
|
// AddedField returns the numeric value that was incremented/decremented on a field
|
|
// with the given name. The second boolean return value indicates that this field
|
|
// was not set, or was not defined in the schema.
|
|
func (m *CategoryMutation) AddedField(name string) (ent.Value, bool) {
|
|
return nil, false
|
|
}
|
|
|
|
// AddField adds the value to the field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *CategoryMutation) AddField(name string, value ent.Value) error {
|
|
switch name {
|
|
}
|
|
return fmt.Errorf("unknown Category numeric field %s", name)
|
|
}
|
|
|
|
// ClearedFields returns all nullable fields that were cleared during this
|
|
// mutation.
|
|
func (m *CategoryMutation) ClearedFields() []string {
|
|
return nil
|
|
}
|
|
|
|
// FieldCleared returns a boolean indicating if a field with the given name was
|
|
// cleared in this mutation.
|
|
func (m *CategoryMutation) FieldCleared(name string) bool {
|
|
_, ok := m.clearedFields[name]
|
|
return ok
|
|
}
|
|
|
|
// ClearField clears the value of the field with the given name. It returns an
|
|
// error if the field is not defined in the schema.
|
|
func (m *CategoryMutation) ClearField(name string) error {
|
|
return fmt.Errorf("unknown Category nullable field %s", name)
|
|
}
|
|
|
|
// ResetField resets all changes in the mutation for the field with the given name.
|
|
// It returns an error if the field is not defined in the schema.
|
|
func (m *CategoryMutation) ResetField(name string) error {
|
|
switch name {
|
|
case category.FieldCreatedAt:
|
|
m.ResetCreatedAt()
|
|
return nil
|
|
case category.FieldUpdatedAt:
|
|
m.ResetUpdatedAt()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Category field %s", name)
|
|
}
|
|
|
|
// AddedEdges returns all edge names that were set/added in this mutation.
|
|
func (m *CategoryMutation) AddedEdges() []string {
|
|
edges := make([]string, 0, 3)
|
|
if m.contents != nil {
|
|
edges = append(edges, category.EdgeContents)
|
|
}
|
|
if m.posts != nil {
|
|
edges = append(edges, category.EdgePosts)
|
|
}
|
|
if m.daily_items != nil {
|
|
edges = append(edges, category.EdgeDailyItems)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// AddedIDs returns all IDs (to other nodes) that were added for the given edge
|
|
// name in this mutation.
|
|
func (m *CategoryMutation) AddedIDs(name string) []ent.Value {
|
|
switch name {
|
|
case category.EdgeContents:
|
|
ids := make([]ent.Value, 0, len(m.contents))
|
|
for id := range m.contents {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
case category.EdgePosts:
|
|
ids := make([]ent.Value, 0, len(m.posts))
|
|
for id := range m.posts {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
case category.EdgeDailyItems:
|
|
ids := make([]ent.Value, 0, len(m.daily_items))
|
|
for id := range m.daily_items {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// RemovedEdges returns all edge names that were removed in this mutation.
|
|
func (m *CategoryMutation) RemovedEdges() []string {
|
|
edges := make([]string, 0, 3)
|
|
if m.removedcontents != nil {
|
|
edges = append(edges, category.EdgeContents)
|
|
}
|
|
if m.removedposts != nil {
|
|
edges = append(edges, category.EdgePosts)
|
|
}
|
|
if m.removeddaily_items != nil {
|
|
edges = append(edges, category.EdgeDailyItems)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
|
|
// the given name in this mutation.
|
|
func (m *CategoryMutation) RemovedIDs(name string) []ent.Value {
|
|
switch name {
|
|
case category.EdgeContents:
|
|
ids := make([]ent.Value, 0, len(m.removedcontents))
|
|
for id := range m.removedcontents {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
case category.EdgePosts:
|
|
ids := make([]ent.Value, 0, len(m.removedposts))
|
|
for id := range m.removedposts {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
case category.EdgeDailyItems:
|
|
ids := make([]ent.Value, 0, len(m.removeddaily_items))
|
|
for id := range m.removeddaily_items {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// ClearedEdges returns all edge names that were cleared in this mutation.
|
|
func (m *CategoryMutation) ClearedEdges() []string {
|
|
edges := make([]string, 0, 3)
|
|
if m.clearedcontents {
|
|
edges = append(edges, category.EdgeContents)
|
|
}
|
|
if m.clearedposts {
|
|
edges = append(edges, category.EdgePosts)
|
|
}
|
|
if m.cleareddaily_items {
|
|
edges = append(edges, category.EdgeDailyItems)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// EdgeCleared returns a boolean which indicates if the edge with the given name
|
|
// was cleared in this mutation.
|
|
func (m *CategoryMutation) EdgeCleared(name string) bool {
|
|
switch name {
|
|
case category.EdgeContents:
|
|
return m.clearedcontents
|
|
case category.EdgePosts:
|
|
return m.clearedposts
|
|
case category.EdgeDailyItems:
|
|
return m.cleareddaily_items
|
|
}
|
|
return false
|
|
}
|
|
|
|
// ClearEdge clears the value of the edge with the given name. It returns an error
|
|
// if that edge is not defined in the schema.
|
|
func (m *CategoryMutation) ClearEdge(name string) error {
|
|
switch name {
|
|
}
|
|
return fmt.Errorf("unknown Category unique edge %s", name)
|
|
}
|
|
|
|
// ResetEdge resets all changes to the edge with the given name in this mutation.
|
|
// It returns an error if the edge is not defined in the schema.
|
|
func (m *CategoryMutation) ResetEdge(name string) error {
|
|
switch name {
|
|
case category.EdgeContents:
|
|
m.ResetContents()
|
|
return nil
|
|
case category.EdgePosts:
|
|
m.ResetPosts()
|
|
return nil
|
|
case category.EdgeDailyItems:
|
|
m.ResetDailyItems()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Category edge %s", name)
|
|
}
|
|
|
|
// CategoryContentMutation represents an operation that mutates the CategoryContent nodes in the graph.
|
|
type CategoryContentMutation struct {
|
|
config
|
|
op Op
|
|
typ string
|
|
id *int
|
|
language_code *categorycontent.LanguageCode
|
|
name *string
|
|
description *string
|
|
slug *string
|
|
clearedFields map[string]struct{}
|
|
category *int
|
|
clearedcategory bool
|
|
done bool
|
|
oldValue func(context.Context) (*CategoryContent, error)
|
|
predicates []predicate.CategoryContent
|
|
}
|
|
|
|
var _ ent.Mutation = (*CategoryContentMutation)(nil)
|
|
|
|
// categorycontentOption allows management of the mutation configuration using functional options.
|
|
type categorycontentOption func(*CategoryContentMutation)
|
|
|
|
// newCategoryContentMutation creates new mutation for the CategoryContent entity.
|
|
func newCategoryContentMutation(c config, op Op, opts ...categorycontentOption) *CategoryContentMutation {
|
|
m := &CategoryContentMutation{
|
|
config: c,
|
|
op: op,
|
|
typ: TypeCategoryContent,
|
|
clearedFields: make(map[string]struct{}),
|
|
}
|
|
for _, opt := range opts {
|
|
opt(m)
|
|
}
|
|
return m
|
|
}
|
|
|
|
// withCategoryContentID sets the ID field of the mutation.
|
|
func withCategoryContentID(id int) categorycontentOption {
|
|
return func(m *CategoryContentMutation) {
|
|
var (
|
|
err error
|
|
once sync.Once
|
|
value *CategoryContent
|
|
)
|
|
m.oldValue = func(ctx context.Context) (*CategoryContent, error) {
|
|
once.Do(func() {
|
|
if m.done {
|
|
err = errors.New("querying old values post mutation is not allowed")
|
|
} else {
|
|
value, err = m.Client().CategoryContent.Get(ctx, id)
|
|
}
|
|
})
|
|
return value, err
|
|
}
|
|
m.id = &id
|
|
}
|
|
}
|
|
|
|
// withCategoryContent sets the old CategoryContent of the mutation.
|
|
func withCategoryContent(node *CategoryContent) categorycontentOption {
|
|
return func(m *CategoryContentMutation) {
|
|
m.oldValue = func(context.Context) (*CategoryContent, error) {
|
|
return node, nil
|
|
}
|
|
m.id = &node.ID
|
|
}
|
|
}
|
|
|
|
// Client returns a new `ent.Client` from the mutation. If the mutation was
|
|
// executed in a transaction (ent.Tx), a transactional client is returned.
|
|
func (m CategoryContentMutation) Client() *Client {
|
|
client := &Client{config: m.config}
|
|
client.init()
|
|
return client
|
|
}
|
|
|
|
// Tx returns an `ent.Tx` for mutations that were executed in transactions;
|
|
// it returns an error otherwise.
|
|
func (m CategoryContentMutation) Tx() (*Tx, error) {
|
|
if _, ok := m.driver.(*txDriver); !ok {
|
|
return nil, errors.New("ent: mutation is not running in a transaction")
|
|
}
|
|
tx := &Tx{config: m.config}
|
|
tx.init()
|
|
return tx, nil
|
|
}
|
|
|
|
// ID returns the ID value in the mutation. Note that the ID is only available
|
|
// if it was provided to the builder or after it was returned from the database.
|
|
func (m *CategoryContentMutation) ID() (id int, exists bool) {
|
|
if m.id == nil {
|
|
return
|
|
}
|
|
return *m.id, true
|
|
}
|
|
|
|
// IDs queries the database and returns the entity ids that match the mutation's predicate.
|
|
// That means, if the mutation is applied within a transaction with an isolation level such
|
|
// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
|
|
// or updated by the mutation.
|
|
func (m *CategoryContentMutation) IDs(ctx context.Context) ([]int, error) {
|
|
switch {
|
|
case m.op.Is(OpUpdateOne | OpDeleteOne):
|
|
id, exists := m.ID()
|
|
if exists {
|
|
return []int{id}, nil
|
|
}
|
|
fallthrough
|
|
case m.op.Is(OpUpdate | OpDelete):
|
|
return m.Client().CategoryContent.Query().Where(m.predicates...).IDs(ctx)
|
|
default:
|
|
return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
|
|
}
|
|
}
|
|
|
|
// SetLanguageCode sets the "language_code" field.
|
|
func (m *CategoryContentMutation) SetLanguageCode(cc categorycontent.LanguageCode) {
|
|
m.language_code = &cc
|
|
}
|
|
|
|
// LanguageCode returns the value of the "language_code" field in the mutation.
|
|
func (m *CategoryContentMutation) LanguageCode() (r categorycontent.LanguageCode, exists bool) {
|
|
v := m.language_code
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldLanguageCode returns the old "language_code" field's value of the CategoryContent entity.
|
|
// If the CategoryContent object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *CategoryContentMutation) OldLanguageCode(ctx context.Context) (v categorycontent.LanguageCode, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldLanguageCode is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldLanguageCode requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldLanguageCode: %w", err)
|
|
}
|
|
return oldValue.LanguageCode, nil
|
|
}
|
|
|
|
// ResetLanguageCode resets all changes to the "language_code" field.
|
|
func (m *CategoryContentMutation) ResetLanguageCode() {
|
|
m.language_code = nil
|
|
}
|
|
|
|
// SetName sets the "name" field.
|
|
func (m *CategoryContentMutation) SetName(s string) {
|
|
m.name = &s
|
|
}
|
|
|
|
// Name returns the value of the "name" field in the mutation.
|
|
func (m *CategoryContentMutation) Name() (r string, exists bool) {
|
|
v := m.name
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldName returns the old "name" field's value of the CategoryContent entity.
|
|
// If the CategoryContent object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *CategoryContentMutation) OldName(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldName is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldName requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldName: %w", err)
|
|
}
|
|
return oldValue.Name, nil
|
|
}
|
|
|
|
// ResetName resets all changes to the "name" field.
|
|
func (m *CategoryContentMutation) ResetName() {
|
|
m.name = nil
|
|
}
|
|
|
|
// SetDescription sets the "description" field.
|
|
func (m *CategoryContentMutation) SetDescription(s string) {
|
|
m.description = &s
|
|
}
|
|
|
|
// Description returns the value of the "description" field in the mutation.
|
|
func (m *CategoryContentMutation) Description() (r string, exists bool) {
|
|
v := m.description
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldDescription returns the old "description" field's value of the CategoryContent entity.
|
|
// If the CategoryContent object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *CategoryContentMutation) OldDescription(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldDescription is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldDescription requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldDescription: %w", err)
|
|
}
|
|
return oldValue.Description, nil
|
|
}
|
|
|
|
// ClearDescription clears the value of the "description" field.
|
|
func (m *CategoryContentMutation) ClearDescription() {
|
|
m.description = nil
|
|
m.clearedFields[categorycontent.FieldDescription] = struct{}{}
|
|
}
|
|
|
|
// DescriptionCleared returns if the "description" field was cleared in this mutation.
|
|
func (m *CategoryContentMutation) DescriptionCleared() bool {
|
|
_, ok := m.clearedFields[categorycontent.FieldDescription]
|
|
return ok
|
|
}
|
|
|
|
// ResetDescription resets all changes to the "description" field.
|
|
func (m *CategoryContentMutation) ResetDescription() {
|
|
m.description = nil
|
|
delete(m.clearedFields, categorycontent.FieldDescription)
|
|
}
|
|
|
|
// SetSlug sets the "slug" field.
|
|
func (m *CategoryContentMutation) SetSlug(s string) {
|
|
m.slug = &s
|
|
}
|
|
|
|
// Slug returns the value of the "slug" field in the mutation.
|
|
func (m *CategoryContentMutation) Slug() (r string, exists bool) {
|
|
v := m.slug
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldSlug returns the old "slug" field's value of the CategoryContent entity.
|
|
// If the CategoryContent object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *CategoryContentMutation) OldSlug(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldSlug is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldSlug requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldSlug: %w", err)
|
|
}
|
|
return oldValue.Slug, nil
|
|
}
|
|
|
|
// ResetSlug resets all changes to the "slug" field.
|
|
func (m *CategoryContentMutation) ResetSlug() {
|
|
m.slug = nil
|
|
}
|
|
|
|
// SetCategoryID sets the "category" edge to the Category entity by id.
|
|
func (m *CategoryContentMutation) SetCategoryID(id int) {
|
|
m.category = &id
|
|
}
|
|
|
|
// ClearCategory clears the "category" edge to the Category entity.
|
|
func (m *CategoryContentMutation) ClearCategory() {
|
|
m.clearedcategory = true
|
|
}
|
|
|
|
// CategoryCleared reports if the "category" edge to the Category entity was cleared.
|
|
func (m *CategoryContentMutation) CategoryCleared() bool {
|
|
return m.clearedcategory
|
|
}
|
|
|
|
// CategoryID returns the "category" edge ID in the mutation.
|
|
func (m *CategoryContentMutation) CategoryID() (id int, exists bool) {
|
|
if m.category != nil {
|
|
return *m.category, true
|
|
}
|
|
return
|
|
}
|
|
|
|
// CategoryIDs returns the "category" edge IDs in the mutation.
|
|
// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
|
|
// CategoryID instead. It exists only for internal usage by the builders.
|
|
func (m *CategoryContentMutation) CategoryIDs() (ids []int) {
|
|
if id := m.category; id != nil {
|
|
ids = append(ids, *id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetCategory resets all changes to the "category" edge.
|
|
func (m *CategoryContentMutation) ResetCategory() {
|
|
m.category = nil
|
|
m.clearedcategory = false
|
|
}
|
|
|
|
// Where appends a list predicates to the CategoryContentMutation builder.
|
|
func (m *CategoryContentMutation) Where(ps ...predicate.CategoryContent) {
|
|
m.predicates = append(m.predicates, ps...)
|
|
}
|
|
|
|
// WhereP appends storage-level predicates to the CategoryContentMutation builder. Using this method,
|
|
// users can use type-assertion to append predicates that do not depend on any generated package.
|
|
func (m *CategoryContentMutation) WhereP(ps ...func(*sql.Selector)) {
|
|
p := make([]predicate.CategoryContent, len(ps))
|
|
for i := range ps {
|
|
p[i] = ps[i]
|
|
}
|
|
m.Where(p...)
|
|
}
|
|
|
|
// Op returns the operation name.
|
|
func (m *CategoryContentMutation) Op() Op {
|
|
return m.op
|
|
}
|
|
|
|
// SetOp allows setting the mutation operation.
|
|
func (m *CategoryContentMutation) SetOp(op Op) {
|
|
m.op = op
|
|
}
|
|
|
|
// Type returns the node type of this mutation (CategoryContent).
|
|
func (m *CategoryContentMutation) Type() string {
|
|
return m.typ
|
|
}
|
|
|
|
// Fields returns all fields that were changed during this mutation. Note that in
|
|
// order to get all numeric fields that were incremented/decremented, call
|
|
// AddedFields().
|
|
func (m *CategoryContentMutation) Fields() []string {
|
|
fields := make([]string, 0, 4)
|
|
if m.language_code != nil {
|
|
fields = append(fields, categorycontent.FieldLanguageCode)
|
|
}
|
|
if m.name != nil {
|
|
fields = append(fields, categorycontent.FieldName)
|
|
}
|
|
if m.description != nil {
|
|
fields = append(fields, categorycontent.FieldDescription)
|
|
}
|
|
if m.slug != nil {
|
|
fields = append(fields, categorycontent.FieldSlug)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// Field returns the value of a field with the given name. The second boolean
|
|
// return value indicates that this field was not set, or was not defined in the
|
|
// schema.
|
|
func (m *CategoryContentMutation) Field(name string) (ent.Value, bool) {
|
|
switch name {
|
|
case categorycontent.FieldLanguageCode:
|
|
return m.LanguageCode()
|
|
case categorycontent.FieldName:
|
|
return m.Name()
|
|
case categorycontent.FieldDescription:
|
|
return m.Description()
|
|
case categorycontent.FieldSlug:
|
|
return m.Slug()
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
// OldField returns the old value of the field from the database. An error is
|
|
// returned if the mutation operation is not UpdateOne, or the query to the
|
|
// database failed.
|
|
func (m *CategoryContentMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
|
|
switch name {
|
|
case categorycontent.FieldLanguageCode:
|
|
return m.OldLanguageCode(ctx)
|
|
case categorycontent.FieldName:
|
|
return m.OldName(ctx)
|
|
case categorycontent.FieldDescription:
|
|
return m.OldDescription(ctx)
|
|
case categorycontent.FieldSlug:
|
|
return m.OldSlug(ctx)
|
|
}
|
|
return nil, fmt.Errorf("unknown CategoryContent field %s", name)
|
|
}
|
|
|
|
// SetField sets the value of a field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *CategoryContentMutation) SetField(name string, value ent.Value) error {
|
|
switch name {
|
|
case categorycontent.FieldLanguageCode:
|
|
v, ok := value.(categorycontent.LanguageCode)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetLanguageCode(v)
|
|
return nil
|
|
case categorycontent.FieldName:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetName(v)
|
|
return nil
|
|
case categorycontent.FieldDescription:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetDescription(v)
|
|
return nil
|
|
case categorycontent.FieldSlug:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetSlug(v)
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown CategoryContent field %s", name)
|
|
}
|
|
|
|
// AddedFields returns all numeric fields that were incremented/decremented during
|
|
// this mutation.
|
|
func (m *CategoryContentMutation) AddedFields() []string {
|
|
return nil
|
|
}
|
|
|
|
// AddedField returns the numeric value that was incremented/decremented on a field
|
|
// with the given name. The second boolean return value indicates that this field
|
|
// was not set, or was not defined in the schema.
|
|
func (m *CategoryContentMutation) AddedField(name string) (ent.Value, bool) {
|
|
return nil, false
|
|
}
|
|
|
|
// AddField adds the value to the field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *CategoryContentMutation) AddField(name string, value ent.Value) error {
|
|
switch name {
|
|
}
|
|
return fmt.Errorf("unknown CategoryContent numeric field %s", name)
|
|
}
|
|
|
|
// ClearedFields returns all nullable fields that were cleared during this
|
|
// mutation.
|
|
func (m *CategoryContentMutation) ClearedFields() []string {
|
|
var fields []string
|
|
if m.FieldCleared(categorycontent.FieldDescription) {
|
|
fields = append(fields, categorycontent.FieldDescription)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// FieldCleared returns a boolean indicating if a field with the given name was
|
|
// cleared in this mutation.
|
|
func (m *CategoryContentMutation) FieldCleared(name string) bool {
|
|
_, ok := m.clearedFields[name]
|
|
return ok
|
|
}
|
|
|
|
// ClearField clears the value of the field with the given name. It returns an
|
|
// error if the field is not defined in the schema.
|
|
func (m *CategoryContentMutation) ClearField(name string) error {
|
|
switch name {
|
|
case categorycontent.FieldDescription:
|
|
m.ClearDescription()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown CategoryContent nullable field %s", name)
|
|
}
|
|
|
|
// ResetField resets all changes in the mutation for the field with the given name.
|
|
// It returns an error if the field is not defined in the schema.
|
|
func (m *CategoryContentMutation) ResetField(name string) error {
|
|
switch name {
|
|
case categorycontent.FieldLanguageCode:
|
|
m.ResetLanguageCode()
|
|
return nil
|
|
case categorycontent.FieldName:
|
|
m.ResetName()
|
|
return nil
|
|
case categorycontent.FieldDescription:
|
|
m.ResetDescription()
|
|
return nil
|
|
case categorycontent.FieldSlug:
|
|
m.ResetSlug()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown CategoryContent field %s", name)
|
|
}
|
|
|
|
// AddedEdges returns all edge names that were set/added in this mutation.
|
|
func (m *CategoryContentMutation) AddedEdges() []string {
|
|
edges := make([]string, 0, 1)
|
|
if m.category != nil {
|
|
edges = append(edges, categorycontent.EdgeCategory)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// AddedIDs returns all IDs (to other nodes) that were added for the given edge
|
|
// name in this mutation.
|
|
func (m *CategoryContentMutation) AddedIDs(name string) []ent.Value {
|
|
switch name {
|
|
case categorycontent.EdgeCategory:
|
|
if id := m.category; id != nil {
|
|
return []ent.Value{*id}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// RemovedEdges returns all edge names that were removed in this mutation.
|
|
func (m *CategoryContentMutation) RemovedEdges() []string {
|
|
edges := make([]string, 0, 1)
|
|
return edges
|
|
}
|
|
|
|
// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
|
|
// the given name in this mutation.
|
|
func (m *CategoryContentMutation) RemovedIDs(name string) []ent.Value {
|
|
return nil
|
|
}
|
|
|
|
// ClearedEdges returns all edge names that were cleared in this mutation.
|
|
func (m *CategoryContentMutation) ClearedEdges() []string {
|
|
edges := make([]string, 0, 1)
|
|
if m.clearedcategory {
|
|
edges = append(edges, categorycontent.EdgeCategory)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// EdgeCleared returns a boolean which indicates if the edge with the given name
|
|
// was cleared in this mutation.
|
|
func (m *CategoryContentMutation) EdgeCleared(name string) bool {
|
|
switch name {
|
|
case categorycontent.EdgeCategory:
|
|
return m.clearedcategory
|
|
}
|
|
return false
|
|
}
|
|
|
|
// ClearEdge clears the value of the edge with the given name. It returns an error
|
|
// if that edge is not defined in the schema.
|
|
func (m *CategoryContentMutation) ClearEdge(name string) error {
|
|
switch name {
|
|
case categorycontent.EdgeCategory:
|
|
m.ClearCategory()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown CategoryContent unique edge %s", name)
|
|
}
|
|
|
|
// ResetEdge resets all changes to the edge with the given name in this mutation.
|
|
// It returns an error if the edge is not defined in the schema.
|
|
func (m *CategoryContentMutation) ResetEdge(name string) error {
|
|
switch name {
|
|
case categorycontent.EdgeCategory:
|
|
m.ResetCategory()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown CategoryContent edge %s", name)
|
|
}
|
|
|
|
// ContributorMutation represents an operation that mutates the Contributor nodes in the graph.
|
|
type ContributorMutation struct {
|
|
config
|
|
op Op
|
|
typ string
|
|
id *int
|
|
name *string
|
|
avatar_url *string
|
|
bio *string
|
|
created_at *time.Time
|
|
updated_at *time.Time
|
|
clearedFields map[string]struct{}
|
|
user *int
|
|
cleareduser bool
|
|
social_links map[int]struct{}
|
|
removedsocial_links map[int]struct{}
|
|
clearedsocial_links bool
|
|
posts map[int]struct{}
|
|
removedposts map[int]struct{}
|
|
clearedposts bool
|
|
done bool
|
|
oldValue func(context.Context) (*Contributor, error)
|
|
predicates []predicate.Contributor
|
|
}
|
|
|
|
var _ ent.Mutation = (*ContributorMutation)(nil)
|
|
|
|
// contributorOption allows management of the mutation configuration using functional options.
|
|
type contributorOption func(*ContributorMutation)
|
|
|
|
// newContributorMutation creates new mutation for the Contributor entity.
|
|
func newContributorMutation(c config, op Op, opts ...contributorOption) *ContributorMutation {
|
|
m := &ContributorMutation{
|
|
config: c,
|
|
op: op,
|
|
typ: TypeContributor,
|
|
clearedFields: make(map[string]struct{}),
|
|
}
|
|
for _, opt := range opts {
|
|
opt(m)
|
|
}
|
|
return m
|
|
}
|
|
|
|
// withContributorID sets the ID field of the mutation.
|
|
func withContributorID(id int) contributorOption {
|
|
return func(m *ContributorMutation) {
|
|
var (
|
|
err error
|
|
once sync.Once
|
|
value *Contributor
|
|
)
|
|
m.oldValue = func(ctx context.Context) (*Contributor, error) {
|
|
once.Do(func() {
|
|
if m.done {
|
|
err = errors.New("querying old values post mutation is not allowed")
|
|
} else {
|
|
value, err = m.Client().Contributor.Get(ctx, id)
|
|
}
|
|
})
|
|
return value, err
|
|
}
|
|
m.id = &id
|
|
}
|
|
}
|
|
|
|
// withContributor sets the old Contributor of the mutation.
|
|
func withContributor(node *Contributor) contributorOption {
|
|
return func(m *ContributorMutation) {
|
|
m.oldValue = func(context.Context) (*Contributor, error) {
|
|
return node, nil
|
|
}
|
|
m.id = &node.ID
|
|
}
|
|
}
|
|
|
|
// Client returns a new `ent.Client` from the mutation. If the mutation was
|
|
// executed in a transaction (ent.Tx), a transactional client is returned.
|
|
func (m ContributorMutation) Client() *Client {
|
|
client := &Client{config: m.config}
|
|
client.init()
|
|
return client
|
|
}
|
|
|
|
// Tx returns an `ent.Tx` for mutations that were executed in transactions;
|
|
// it returns an error otherwise.
|
|
func (m ContributorMutation) Tx() (*Tx, error) {
|
|
if _, ok := m.driver.(*txDriver); !ok {
|
|
return nil, errors.New("ent: mutation is not running in a transaction")
|
|
}
|
|
tx := &Tx{config: m.config}
|
|
tx.init()
|
|
return tx, nil
|
|
}
|
|
|
|
// ID returns the ID value in the mutation. Note that the ID is only available
|
|
// if it was provided to the builder or after it was returned from the database.
|
|
func (m *ContributorMutation) ID() (id int, exists bool) {
|
|
if m.id == nil {
|
|
return
|
|
}
|
|
return *m.id, true
|
|
}
|
|
|
|
// IDs queries the database and returns the entity ids that match the mutation's predicate.
|
|
// That means, if the mutation is applied within a transaction with an isolation level such
|
|
// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
|
|
// or updated by the mutation.
|
|
func (m *ContributorMutation) IDs(ctx context.Context) ([]int, error) {
|
|
switch {
|
|
case m.op.Is(OpUpdateOne | OpDeleteOne):
|
|
id, exists := m.ID()
|
|
if exists {
|
|
return []int{id}, nil
|
|
}
|
|
fallthrough
|
|
case m.op.Is(OpUpdate | OpDelete):
|
|
return m.Client().Contributor.Query().Where(m.predicates...).IDs(ctx)
|
|
default:
|
|
return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
|
|
}
|
|
}
|
|
|
|
// SetName sets the "name" field.
|
|
func (m *ContributorMutation) SetName(s string) {
|
|
m.name = &s
|
|
}
|
|
|
|
// Name returns the value of the "name" field in the mutation.
|
|
func (m *ContributorMutation) Name() (r string, exists bool) {
|
|
v := m.name
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldName returns the old "name" field's value of the Contributor entity.
|
|
// If the Contributor object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *ContributorMutation) OldName(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldName is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldName requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldName: %w", err)
|
|
}
|
|
return oldValue.Name, nil
|
|
}
|
|
|
|
// ResetName resets all changes to the "name" field.
|
|
func (m *ContributorMutation) ResetName() {
|
|
m.name = nil
|
|
}
|
|
|
|
// SetAvatarURL sets the "avatar_url" field.
|
|
func (m *ContributorMutation) SetAvatarURL(s string) {
|
|
m.avatar_url = &s
|
|
}
|
|
|
|
// AvatarURL returns the value of the "avatar_url" field in the mutation.
|
|
func (m *ContributorMutation) AvatarURL() (r string, exists bool) {
|
|
v := m.avatar_url
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldAvatarURL returns the old "avatar_url" field's value of the Contributor entity.
|
|
// If the Contributor object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *ContributorMutation) OldAvatarURL(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldAvatarURL is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldAvatarURL requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldAvatarURL: %w", err)
|
|
}
|
|
return oldValue.AvatarURL, nil
|
|
}
|
|
|
|
// ClearAvatarURL clears the value of the "avatar_url" field.
|
|
func (m *ContributorMutation) ClearAvatarURL() {
|
|
m.avatar_url = nil
|
|
m.clearedFields[contributor.FieldAvatarURL] = struct{}{}
|
|
}
|
|
|
|
// AvatarURLCleared returns if the "avatar_url" field was cleared in this mutation.
|
|
func (m *ContributorMutation) AvatarURLCleared() bool {
|
|
_, ok := m.clearedFields[contributor.FieldAvatarURL]
|
|
return ok
|
|
}
|
|
|
|
// ResetAvatarURL resets all changes to the "avatar_url" field.
|
|
func (m *ContributorMutation) ResetAvatarURL() {
|
|
m.avatar_url = nil
|
|
delete(m.clearedFields, contributor.FieldAvatarURL)
|
|
}
|
|
|
|
// SetBio sets the "bio" field.
|
|
func (m *ContributorMutation) SetBio(s string) {
|
|
m.bio = &s
|
|
}
|
|
|
|
// Bio returns the value of the "bio" field in the mutation.
|
|
func (m *ContributorMutation) Bio() (r string, exists bool) {
|
|
v := m.bio
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldBio returns the old "bio" field's value of the Contributor entity.
|
|
// If the Contributor object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *ContributorMutation) OldBio(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldBio is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldBio requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldBio: %w", err)
|
|
}
|
|
return oldValue.Bio, nil
|
|
}
|
|
|
|
// ClearBio clears the value of the "bio" field.
|
|
func (m *ContributorMutation) ClearBio() {
|
|
m.bio = nil
|
|
m.clearedFields[contributor.FieldBio] = struct{}{}
|
|
}
|
|
|
|
// BioCleared returns if the "bio" field was cleared in this mutation.
|
|
func (m *ContributorMutation) BioCleared() bool {
|
|
_, ok := m.clearedFields[contributor.FieldBio]
|
|
return ok
|
|
}
|
|
|
|
// ResetBio resets all changes to the "bio" field.
|
|
func (m *ContributorMutation) ResetBio() {
|
|
m.bio = nil
|
|
delete(m.clearedFields, contributor.FieldBio)
|
|
}
|
|
|
|
// SetCreatedAt sets the "created_at" field.
|
|
func (m *ContributorMutation) SetCreatedAt(t time.Time) {
|
|
m.created_at = &t
|
|
}
|
|
|
|
// CreatedAt returns the value of the "created_at" field in the mutation.
|
|
func (m *ContributorMutation) CreatedAt() (r time.Time, exists bool) {
|
|
v := m.created_at
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldCreatedAt returns the old "created_at" field's value of the Contributor entity.
|
|
// If the Contributor object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *ContributorMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldCreatedAt requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
|
|
}
|
|
return oldValue.CreatedAt, nil
|
|
}
|
|
|
|
// ResetCreatedAt resets all changes to the "created_at" field.
|
|
func (m *ContributorMutation) ResetCreatedAt() {
|
|
m.created_at = nil
|
|
}
|
|
|
|
// SetUpdatedAt sets the "updated_at" field.
|
|
func (m *ContributorMutation) SetUpdatedAt(t time.Time) {
|
|
m.updated_at = &t
|
|
}
|
|
|
|
// UpdatedAt returns the value of the "updated_at" field in the mutation.
|
|
func (m *ContributorMutation) UpdatedAt() (r time.Time, exists bool) {
|
|
v := m.updated_at
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldUpdatedAt returns the old "updated_at" field's value of the Contributor entity.
|
|
// If the Contributor object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *ContributorMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
|
|
}
|
|
return oldValue.UpdatedAt, nil
|
|
}
|
|
|
|
// ResetUpdatedAt resets all changes to the "updated_at" field.
|
|
func (m *ContributorMutation) ResetUpdatedAt() {
|
|
m.updated_at = nil
|
|
}
|
|
|
|
// SetUserID sets the "user" edge to the User entity by id.
|
|
func (m *ContributorMutation) SetUserID(id int) {
|
|
m.user = &id
|
|
}
|
|
|
|
// ClearUser clears the "user" edge to the User entity.
|
|
func (m *ContributorMutation) ClearUser() {
|
|
m.cleareduser = true
|
|
}
|
|
|
|
// UserCleared reports if the "user" edge to the User entity was cleared.
|
|
func (m *ContributorMutation) UserCleared() bool {
|
|
return m.cleareduser
|
|
}
|
|
|
|
// UserID returns the "user" edge ID in the mutation.
|
|
func (m *ContributorMutation) UserID() (id int, exists bool) {
|
|
if m.user != nil {
|
|
return *m.user, true
|
|
}
|
|
return
|
|
}
|
|
|
|
// UserIDs returns the "user" edge IDs in the mutation.
|
|
// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
|
|
// UserID instead. It exists only for internal usage by the builders.
|
|
func (m *ContributorMutation) UserIDs() (ids []int) {
|
|
if id := m.user; id != nil {
|
|
ids = append(ids, *id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetUser resets all changes to the "user" edge.
|
|
func (m *ContributorMutation) ResetUser() {
|
|
m.user = nil
|
|
m.cleareduser = false
|
|
}
|
|
|
|
// AddSocialLinkIDs adds the "social_links" edge to the ContributorSocialLink entity by ids.
|
|
func (m *ContributorMutation) AddSocialLinkIDs(ids ...int) {
|
|
if m.social_links == nil {
|
|
m.social_links = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
m.social_links[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// ClearSocialLinks clears the "social_links" edge to the ContributorSocialLink entity.
|
|
func (m *ContributorMutation) ClearSocialLinks() {
|
|
m.clearedsocial_links = true
|
|
}
|
|
|
|
// SocialLinksCleared reports if the "social_links" edge to the ContributorSocialLink entity was cleared.
|
|
func (m *ContributorMutation) SocialLinksCleared() bool {
|
|
return m.clearedsocial_links
|
|
}
|
|
|
|
// RemoveSocialLinkIDs removes the "social_links" edge to the ContributorSocialLink entity by IDs.
|
|
func (m *ContributorMutation) RemoveSocialLinkIDs(ids ...int) {
|
|
if m.removedsocial_links == nil {
|
|
m.removedsocial_links = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
delete(m.social_links, ids[i])
|
|
m.removedsocial_links[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// RemovedSocialLinks returns the removed IDs of the "social_links" edge to the ContributorSocialLink entity.
|
|
func (m *ContributorMutation) RemovedSocialLinksIDs() (ids []int) {
|
|
for id := range m.removedsocial_links {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// SocialLinksIDs returns the "social_links" edge IDs in the mutation.
|
|
func (m *ContributorMutation) SocialLinksIDs() (ids []int) {
|
|
for id := range m.social_links {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetSocialLinks resets all changes to the "social_links" edge.
|
|
func (m *ContributorMutation) ResetSocialLinks() {
|
|
m.social_links = nil
|
|
m.clearedsocial_links = false
|
|
m.removedsocial_links = nil
|
|
}
|
|
|
|
// AddPostIDs adds the "posts" edge to the PostContributor entity by ids.
|
|
func (m *ContributorMutation) AddPostIDs(ids ...int) {
|
|
if m.posts == nil {
|
|
m.posts = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
m.posts[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// ClearPosts clears the "posts" edge to the PostContributor entity.
|
|
func (m *ContributorMutation) ClearPosts() {
|
|
m.clearedposts = true
|
|
}
|
|
|
|
// PostsCleared reports if the "posts" edge to the PostContributor entity was cleared.
|
|
func (m *ContributorMutation) PostsCleared() bool {
|
|
return m.clearedposts
|
|
}
|
|
|
|
// RemovePostIDs removes the "posts" edge to the PostContributor entity by IDs.
|
|
func (m *ContributorMutation) RemovePostIDs(ids ...int) {
|
|
if m.removedposts == nil {
|
|
m.removedposts = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
delete(m.posts, ids[i])
|
|
m.removedposts[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// RemovedPosts returns the removed IDs of the "posts" edge to the PostContributor entity.
|
|
func (m *ContributorMutation) RemovedPostsIDs() (ids []int) {
|
|
for id := range m.removedposts {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// PostsIDs returns the "posts" edge IDs in the mutation.
|
|
func (m *ContributorMutation) PostsIDs() (ids []int) {
|
|
for id := range m.posts {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetPosts resets all changes to the "posts" edge.
|
|
func (m *ContributorMutation) ResetPosts() {
|
|
m.posts = nil
|
|
m.clearedposts = false
|
|
m.removedposts = nil
|
|
}
|
|
|
|
// Where appends a list predicates to the ContributorMutation builder.
|
|
func (m *ContributorMutation) Where(ps ...predicate.Contributor) {
|
|
m.predicates = append(m.predicates, ps...)
|
|
}
|
|
|
|
// WhereP appends storage-level predicates to the ContributorMutation builder. Using this method,
|
|
// users can use type-assertion to append predicates that do not depend on any generated package.
|
|
func (m *ContributorMutation) WhereP(ps ...func(*sql.Selector)) {
|
|
p := make([]predicate.Contributor, len(ps))
|
|
for i := range ps {
|
|
p[i] = ps[i]
|
|
}
|
|
m.Where(p...)
|
|
}
|
|
|
|
// Op returns the operation name.
|
|
func (m *ContributorMutation) Op() Op {
|
|
return m.op
|
|
}
|
|
|
|
// SetOp allows setting the mutation operation.
|
|
func (m *ContributorMutation) SetOp(op Op) {
|
|
m.op = op
|
|
}
|
|
|
|
// Type returns the node type of this mutation (Contributor).
|
|
func (m *ContributorMutation) Type() string {
|
|
return m.typ
|
|
}
|
|
|
|
// Fields returns all fields that were changed during this mutation. Note that in
|
|
// order to get all numeric fields that were incremented/decremented, call
|
|
// AddedFields().
|
|
func (m *ContributorMutation) Fields() []string {
|
|
fields := make([]string, 0, 5)
|
|
if m.name != nil {
|
|
fields = append(fields, contributor.FieldName)
|
|
}
|
|
if m.avatar_url != nil {
|
|
fields = append(fields, contributor.FieldAvatarURL)
|
|
}
|
|
if m.bio != nil {
|
|
fields = append(fields, contributor.FieldBio)
|
|
}
|
|
if m.created_at != nil {
|
|
fields = append(fields, contributor.FieldCreatedAt)
|
|
}
|
|
if m.updated_at != nil {
|
|
fields = append(fields, contributor.FieldUpdatedAt)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// Field returns the value of a field with the given name. The second boolean
|
|
// return value indicates that this field was not set, or was not defined in the
|
|
// schema.
|
|
func (m *ContributorMutation) Field(name string) (ent.Value, bool) {
|
|
switch name {
|
|
case contributor.FieldName:
|
|
return m.Name()
|
|
case contributor.FieldAvatarURL:
|
|
return m.AvatarURL()
|
|
case contributor.FieldBio:
|
|
return m.Bio()
|
|
case contributor.FieldCreatedAt:
|
|
return m.CreatedAt()
|
|
case contributor.FieldUpdatedAt:
|
|
return m.UpdatedAt()
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
// OldField returns the old value of the field from the database. An error is
|
|
// returned if the mutation operation is not UpdateOne, or the query to the
|
|
// database failed.
|
|
func (m *ContributorMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
|
|
switch name {
|
|
case contributor.FieldName:
|
|
return m.OldName(ctx)
|
|
case contributor.FieldAvatarURL:
|
|
return m.OldAvatarURL(ctx)
|
|
case contributor.FieldBio:
|
|
return m.OldBio(ctx)
|
|
case contributor.FieldCreatedAt:
|
|
return m.OldCreatedAt(ctx)
|
|
case contributor.FieldUpdatedAt:
|
|
return m.OldUpdatedAt(ctx)
|
|
}
|
|
return nil, fmt.Errorf("unknown Contributor field %s", name)
|
|
}
|
|
|
|
// SetField sets the value of a field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *ContributorMutation) SetField(name string, value ent.Value) error {
|
|
switch name {
|
|
case contributor.FieldName:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetName(v)
|
|
return nil
|
|
case contributor.FieldAvatarURL:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetAvatarURL(v)
|
|
return nil
|
|
case contributor.FieldBio:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetBio(v)
|
|
return nil
|
|
case contributor.FieldCreatedAt:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetCreatedAt(v)
|
|
return nil
|
|
case contributor.FieldUpdatedAt:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetUpdatedAt(v)
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Contributor field %s", name)
|
|
}
|
|
|
|
// AddedFields returns all numeric fields that were incremented/decremented during
|
|
// this mutation.
|
|
func (m *ContributorMutation) AddedFields() []string {
|
|
return nil
|
|
}
|
|
|
|
// AddedField returns the numeric value that was incremented/decremented on a field
|
|
// with the given name. The second boolean return value indicates that this field
|
|
// was not set, or was not defined in the schema.
|
|
func (m *ContributorMutation) AddedField(name string) (ent.Value, bool) {
|
|
return nil, false
|
|
}
|
|
|
|
// AddField adds the value to the field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *ContributorMutation) AddField(name string, value ent.Value) error {
|
|
switch name {
|
|
}
|
|
return fmt.Errorf("unknown Contributor numeric field %s", name)
|
|
}
|
|
|
|
// ClearedFields returns all nullable fields that were cleared during this
|
|
// mutation.
|
|
func (m *ContributorMutation) ClearedFields() []string {
|
|
var fields []string
|
|
if m.FieldCleared(contributor.FieldAvatarURL) {
|
|
fields = append(fields, contributor.FieldAvatarURL)
|
|
}
|
|
if m.FieldCleared(contributor.FieldBio) {
|
|
fields = append(fields, contributor.FieldBio)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// FieldCleared returns a boolean indicating if a field with the given name was
|
|
// cleared in this mutation.
|
|
func (m *ContributorMutation) FieldCleared(name string) bool {
|
|
_, ok := m.clearedFields[name]
|
|
return ok
|
|
}
|
|
|
|
// ClearField clears the value of the field with the given name. It returns an
|
|
// error if the field is not defined in the schema.
|
|
func (m *ContributorMutation) ClearField(name string) error {
|
|
switch name {
|
|
case contributor.FieldAvatarURL:
|
|
m.ClearAvatarURL()
|
|
return nil
|
|
case contributor.FieldBio:
|
|
m.ClearBio()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Contributor nullable field %s", name)
|
|
}
|
|
|
|
// ResetField resets all changes in the mutation for the field with the given name.
|
|
// It returns an error if the field is not defined in the schema.
|
|
func (m *ContributorMutation) ResetField(name string) error {
|
|
switch name {
|
|
case contributor.FieldName:
|
|
m.ResetName()
|
|
return nil
|
|
case contributor.FieldAvatarURL:
|
|
m.ResetAvatarURL()
|
|
return nil
|
|
case contributor.FieldBio:
|
|
m.ResetBio()
|
|
return nil
|
|
case contributor.FieldCreatedAt:
|
|
m.ResetCreatedAt()
|
|
return nil
|
|
case contributor.FieldUpdatedAt:
|
|
m.ResetUpdatedAt()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Contributor field %s", name)
|
|
}
|
|
|
|
// AddedEdges returns all edge names that were set/added in this mutation.
|
|
func (m *ContributorMutation) AddedEdges() []string {
|
|
edges := make([]string, 0, 3)
|
|
if m.user != nil {
|
|
edges = append(edges, contributor.EdgeUser)
|
|
}
|
|
if m.social_links != nil {
|
|
edges = append(edges, contributor.EdgeSocialLinks)
|
|
}
|
|
if m.posts != nil {
|
|
edges = append(edges, contributor.EdgePosts)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// AddedIDs returns all IDs (to other nodes) that were added for the given edge
|
|
// name in this mutation.
|
|
func (m *ContributorMutation) AddedIDs(name string) []ent.Value {
|
|
switch name {
|
|
case contributor.EdgeUser:
|
|
if id := m.user; id != nil {
|
|
return []ent.Value{*id}
|
|
}
|
|
case contributor.EdgeSocialLinks:
|
|
ids := make([]ent.Value, 0, len(m.social_links))
|
|
for id := range m.social_links {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
case contributor.EdgePosts:
|
|
ids := make([]ent.Value, 0, len(m.posts))
|
|
for id := range m.posts {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// RemovedEdges returns all edge names that were removed in this mutation.
|
|
func (m *ContributorMutation) RemovedEdges() []string {
|
|
edges := make([]string, 0, 3)
|
|
if m.removedsocial_links != nil {
|
|
edges = append(edges, contributor.EdgeSocialLinks)
|
|
}
|
|
if m.removedposts != nil {
|
|
edges = append(edges, contributor.EdgePosts)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
|
|
// the given name in this mutation.
|
|
func (m *ContributorMutation) RemovedIDs(name string) []ent.Value {
|
|
switch name {
|
|
case contributor.EdgeSocialLinks:
|
|
ids := make([]ent.Value, 0, len(m.removedsocial_links))
|
|
for id := range m.removedsocial_links {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
case contributor.EdgePosts:
|
|
ids := make([]ent.Value, 0, len(m.removedposts))
|
|
for id := range m.removedposts {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// ClearedEdges returns all edge names that were cleared in this mutation.
|
|
func (m *ContributorMutation) ClearedEdges() []string {
|
|
edges := make([]string, 0, 3)
|
|
if m.cleareduser {
|
|
edges = append(edges, contributor.EdgeUser)
|
|
}
|
|
if m.clearedsocial_links {
|
|
edges = append(edges, contributor.EdgeSocialLinks)
|
|
}
|
|
if m.clearedposts {
|
|
edges = append(edges, contributor.EdgePosts)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// EdgeCleared returns a boolean which indicates if the edge with the given name
|
|
// was cleared in this mutation.
|
|
func (m *ContributorMutation) EdgeCleared(name string) bool {
|
|
switch name {
|
|
case contributor.EdgeUser:
|
|
return m.cleareduser
|
|
case contributor.EdgeSocialLinks:
|
|
return m.clearedsocial_links
|
|
case contributor.EdgePosts:
|
|
return m.clearedposts
|
|
}
|
|
return false
|
|
}
|
|
|
|
// ClearEdge clears the value of the edge with the given name. It returns an error
|
|
// if that edge is not defined in the schema.
|
|
func (m *ContributorMutation) ClearEdge(name string) error {
|
|
switch name {
|
|
case contributor.EdgeUser:
|
|
m.ClearUser()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Contributor unique edge %s", name)
|
|
}
|
|
|
|
// ResetEdge resets all changes to the edge with the given name in this mutation.
|
|
// It returns an error if the edge is not defined in the schema.
|
|
func (m *ContributorMutation) ResetEdge(name string) error {
|
|
switch name {
|
|
case contributor.EdgeUser:
|
|
m.ResetUser()
|
|
return nil
|
|
case contributor.EdgeSocialLinks:
|
|
m.ResetSocialLinks()
|
|
return nil
|
|
case contributor.EdgePosts:
|
|
m.ResetPosts()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Contributor edge %s", name)
|
|
}
|
|
|
|
// ContributorRoleMutation represents an operation that mutates the ContributorRole nodes in the graph.
|
|
type ContributorRoleMutation struct {
|
|
config
|
|
op Op
|
|
typ string
|
|
id *int
|
|
name *string
|
|
clearedFields map[string]struct{}
|
|
post_contributors map[int]struct{}
|
|
removedpost_contributors map[int]struct{}
|
|
clearedpost_contributors bool
|
|
done bool
|
|
oldValue func(context.Context) (*ContributorRole, error)
|
|
predicates []predicate.ContributorRole
|
|
}
|
|
|
|
var _ ent.Mutation = (*ContributorRoleMutation)(nil)
|
|
|
|
// contributorroleOption allows management of the mutation configuration using functional options.
|
|
type contributorroleOption func(*ContributorRoleMutation)
|
|
|
|
// newContributorRoleMutation creates new mutation for the ContributorRole entity.
|
|
func newContributorRoleMutation(c config, op Op, opts ...contributorroleOption) *ContributorRoleMutation {
|
|
m := &ContributorRoleMutation{
|
|
config: c,
|
|
op: op,
|
|
typ: TypeContributorRole,
|
|
clearedFields: make(map[string]struct{}),
|
|
}
|
|
for _, opt := range opts {
|
|
opt(m)
|
|
}
|
|
return m
|
|
}
|
|
|
|
// withContributorRoleID sets the ID field of the mutation.
|
|
func withContributorRoleID(id int) contributorroleOption {
|
|
return func(m *ContributorRoleMutation) {
|
|
var (
|
|
err error
|
|
once sync.Once
|
|
value *ContributorRole
|
|
)
|
|
m.oldValue = func(ctx context.Context) (*ContributorRole, error) {
|
|
once.Do(func() {
|
|
if m.done {
|
|
err = errors.New("querying old values post mutation is not allowed")
|
|
} else {
|
|
value, err = m.Client().ContributorRole.Get(ctx, id)
|
|
}
|
|
})
|
|
return value, err
|
|
}
|
|
m.id = &id
|
|
}
|
|
}
|
|
|
|
// withContributorRole sets the old ContributorRole of the mutation.
|
|
func withContributorRole(node *ContributorRole) contributorroleOption {
|
|
return func(m *ContributorRoleMutation) {
|
|
m.oldValue = func(context.Context) (*ContributorRole, error) {
|
|
return node, nil
|
|
}
|
|
m.id = &node.ID
|
|
}
|
|
}
|
|
|
|
// Client returns a new `ent.Client` from the mutation. If the mutation was
|
|
// executed in a transaction (ent.Tx), a transactional client is returned.
|
|
func (m ContributorRoleMutation) Client() *Client {
|
|
client := &Client{config: m.config}
|
|
client.init()
|
|
return client
|
|
}
|
|
|
|
// Tx returns an `ent.Tx` for mutations that were executed in transactions;
|
|
// it returns an error otherwise.
|
|
func (m ContributorRoleMutation) Tx() (*Tx, error) {
|
|
if _, ok := m.driver.(*txDriver); !ok {
|
|
return nil, errors.New("ent: mutation is not running in a transaction")
|
|
}
|
|
tx := &Tx{config: m.config}
|
|
tx.init()
|
|
return tx, nil
|
|
}
|
|
|
|
// ID returns the ID value in the mutation. Note that the ID is only available
|
|
// if it was provided to the builder or after it was returned from the database.
|
|
func (m *ContributorRoleMutation) ID() (id int, exists bool) {
|
|
if m.id == nil {
|
|
return
|
|
}
|
|
return *m.id, true
|
|
}
|
|
|
|
// IDs queries the database and returns the entity ids that match the mutation's predicate.
|
|
// That means, if the mutation is applied within a transaction with an isolation level such
|
|
// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
|
|
// or updated by the mutation.
|
|
func (m *ContributorRoleMutation) IDs(ctx context.Context) ([]int, error) {
|
|
switch {
|
|
case m.op.Is(OpUpdateOne | OpDeleteOne):
|
|
id, exists := m.ID()
|
|
if exists {
|
|
return []int{id}, nil
|
|
}
|
|
fallthrough
|
|
case m.op.Is(OpUpdate | OpDelete):
|
|
return m.Client().ContributorRole.Query().Where(m.predicates...).IDs(ctx)
|
|
default:
|
|
return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
|
|
}
|
|
}
|
|
|
|
// SetName sets the "name" field.
|
|
func (m *ContributorRoleMutation) SetName(s string) {
|
|
m.name = &s
|
|
}
|
|
|
|
// Name returns the value of the "name" field in the mutation.
|
|
func (m *ContributorRoleMutation) Name() (r string, exists bool) {
|
|
v := m.name
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldName returns the old "name" field's value of the ContributorRole entity.
|
|
// If the ContributorRole object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *ContributorRoleMutation) OldName(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldName is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldName requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldName: %w", err)
|
|
}
|
|
return oldValue.Name, nil
|
|
}
|
|
|
|
// ResetName resets all changes to the "name" field.
|
|
func (m *ContributorRoleMutation) ResetName() {
|
|
m.name = nil
|
|
}
|
|
|
|
// AddPostContributorIDs adds the "post_contributors" edge to the PostContributor entity by ids.
|
|
func (m *ContributorRoleMutation) AddPostContributorIDs(ids ...int) {
|
|
if m.post_contributors == nil {
|
|
m.post_contributors = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
m.post_contributors[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// ClearPostContributors clears the "post_contributors" edge to the PostContributor entity.
|
|
func (m *ContributorRoleMutation) ClearPostContributors() {
|
|
m.clearedpost_contributors = true
|
|
}
|
|
|
|
// PostContributorsCleared reports if the "post_contributors" edge to the PostContributor entity was cleared.
|
|
func (m *ContributorRoleMutation) PostContributorsCleared() bool {
|
|
return m.clearedpost_contributors
|
|
}
|
|
|
|
// RemovePostContributorIDs removes the "post_contributors" edge to the PostContributor entity by IDs.
|
|
func (m *ContributorRoleMutation) RemovePostContributorIDs(ids ...int) {
|
|
if m.removedpost_contributors == nil {
|
|
m.removedpost_contributors = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
delete(m.post_contributors, ids[i])
|
|
m.removedpost_contributors[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// RemovedPostContributors returns the removed IDs of the "post_contributors" edge to the PostContributor entity.
|
|
func (m *ContributorRoleMutation) RemovedPostContributorsIDs() (ids []int) {
|
|
for id := range m.removedpost_contributors {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// PostContributorsIDs returns the "post_contributors" edge IDs in the mutation.
|
|
func (m *ContributorRoleMutation) PostContributorsIDs() (ids []int) {
|
|
for id := range m.post_contributors {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetPostContributors resets all changes to the "post_contributors" edge.
|
|
func (m *ContributorRoleMutation) ResetPostContributors() {
|
|
m.post_contributors = nil
|
|
m.clearedpost_contributors = false
|
|
m.removedpost_contributors = nil
|
|
}
|
|
|
|
// Where appends a list predicates to the ContributorRoleMutation builder.
|
|
func (m *ContributorRoleMutation) Where(ps ...predicate.ContributorRole) {
|
|
m.predicates = append(m.predicates, ps...)
|
|
}
|
|
|
|
// WhereP appends storage-level predicates to the ContributorRoleMutation builder. Using this method,
|
|
// users can use type-assertion to append predicates that do not depend on any generated package.
|
|
func (m *ContributorRoleMutation) WhereP(ps ...func(*sql.Selector)) {
|
|
p := make([]predicate.ContributorRole, len(ps))
|
|
for i := range ps {
|
|
p[i] = ps[i]
|
|
}
|
|
m.Where(p...)
|
|
}
|
|
|
|
// Op returns the operation name.
|
|
func (m *ContributorRoleMutation) Op() Op {
|
|
return m.op
|
|
}
|
|
|
|
// SetOp allows setting the mutation operation.
|
|
func (m *ContributorRoleMutation) SetOp(op Op) {
|
|
m.op = op
|
|
}
|
|
|
|
// Type returns the node type of this mutation (ContributorRole).
|
|
func (m *ContributorRoleMutation) Type() string {
|
|
return m.typ
|
|
}
|
|
|
|
// Fields returns all fields that were changed during this mutation. Note that in
|
|
// order to get all numeric fields that were incremented/decremented, call
|
|
// AddedFields().
|
|
func (m *ContributorRoleMutation) Fields() []string {
|
|
fields := make([]string, 0, 1)
|
|
if m.name != nil {
|
|
fields = append(fields, contributorrole.FieldName)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// Field returns the value of a field with the given name. The second boolean
|
|
// return value indicates that this field was not set, or was not defined in the
|
|
// schema.
|
|
func (m *ContributorRoleMutation) Field(name string) (ent.Value, bool) {
|
|
switch name {
|
|
case contributorrole.FieldName:
|
|
return m.Name()
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
// OldField returns the old value of the field from the database. An error is
|
|
// returned if the mutation operation is not UpdateOne, or the query to the
|
|
// database failed.
|
|
func (m *ContributorRoleMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
|
|
switch name {
|
|
case contributorrole.FieldName:
|
|
return m.OldName(ctx)
|
|
}
|
|
return nil, fmt.Errorf("unknown ContributorRole field %s", name)
|
|
}
|
|
|
|
// SetField sets the value of a field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *ContributorRoleMutation) SetField(name string, value ent.Value) error {
|
|
switch name {
|
|
case contributorrole.FieldName:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetName(v)
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown ContributorRole field %s", name)
|
|
}
|
|
|
|
// AddedFields returns all numeric fields that were incremented/decremented during
|
|
// this mutation.
|
|
func (m *ContributorRoleMutation) AddedFields() []string {
|
|
return nil
|
|
}
|
|
|
|
// AddedField returns the numeric value that was incremented/decremented on a field
|
|
// with the given name. The second boolean return value indicates that this field
|
|
// was not set, or was not defined in the schema.
|
|
func (m *ContributorRoleMutation) AddedField(name string) (ent.Value, bool) {
|
|
return nil, false
|
|
}
|
|
|
|
// AddField adds the value to the field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *ContributorRoleMutation) AddField(name string, value ent.Value) error {
|
|
switch name {
|
|
}
|
|
return fmt.Errorf("unknown ContributorRole numeric field %s", name)
|
|
}
|
|
|
|
// ClearedFields returns all nullable fields that were cleared during this
|
|
// mutation.
|
|
func (m *ContributorRoleMutation) ClearedFields() []string {
|
|
return nil
|
|
}
|
|
|
|
// FieldCleared returns a boolean indicating if a field with the given name was
|
|
// cleared in this mutation.
|
|
func (m *ContributorRoleMutation) FieldCleared(name string) bool {
|
|
_, ok := m.clearedFields[name]
|
|
return ok
|
|
}
|
|
|
|
// ClearField clears the value of the field with the given name. It returns an
|
|
// error if the field is not defined in the schema.
|
|
func (m *ContributorRoleMutation) ClearField(name string) error {
|
|
return fmt.Errorf("unknown ContributorRole nullable field %s", name)
|
|
}
|
|
|
|
// ResetField resets all changes in the mutation for the field with the given name.
|
|
// It returns an error if the field is not defined in the schema.
|
|
func (m *ContributorRoleMutation) ResetField(name string) error {
|
|
switch name {
|
|
case contributorrole.FieldName:
|
|
m.ResetName()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown ContributorRole field %s", name)
|
|
}
|
|
|
|
// AddedEdges returns all edge names that were set/added in this mutation.
|
|
func (m *ContributorRoleMutation) AddedEdges() []string {
|
|
edges := make([]string, 0, 1)
|
|
if m.post_contributors != nil {
|
|
edges = append(edges, contributorrole.EdgePostContributors)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// AddedIDs returns all IDs (to other nodes) that were added for the given edge
|
|
// name in this mutation.
|
|
func (m *ContributorRoleMutation) AddedIDs(name string) []ent.Value {
|
|
switch name {
|
|
case contributorrole.EdgePostContributors:
|
|
ids := make([]ent.Value, 0, len(m.post_contributors))
|
|
for id := range m.post_contributors {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// RemovedEdges returns all edge names that were removed in this mutation.
|
|
func (m *ContributorRoleMutation) RemovedEdges() []string {
|
|
edges := make([]string, 0, 1)
|
|
if m.removedpost_contributors != nil {
|
|
edges = append(edges, contributorrole.EdgePostContributors)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
|
|
// the given name in this mutation.
|
|
func (m *ContributorRoleMutation) RemovedIDs(name string) []ent.Value {
|
|
switch name {
|
|
case contributorrole.EdgePostContributors:
|
|
ids := make([]ent.Value, 0, len(m.removedpost_contributors))
|
|
for id := range m.removedpost_contributors {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// ClearedEdges returns all edge names that were cleared in this mutation.
|
|
func (m *ContributorRoleMutation) ClearedEdges() []string {
|
|
edges := make([]string, 0, 1)
|
|
if m.clearedpost_contributors {
|
|
edges = append(edges, contributorrole.EdgePostContributors)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// EdgeCleared returns a boolean which indicates if the edge with the given name
|
|
// was cleared in this mutation.
|
|
func (m *ContributorRoleMutation) EdgeCleared(name string) bool {
|
|
switch name {
|
|
case contributorrole.EdgePostContributors:
|
|
return m.clearedpost_contributors
|
|
}
|
|
return false
|
|
}
|
|
|
|
// ClearEdge clears the value of the edge with the given name. It returns an error
|
|
// if that edge is not defined in the schema.
|
|
func (m *ContributorRoleMutation) ClearEdge(name string) error {
|
|
switch name {
|
|
}
|
|
return fmt.Errorf("unknown ContributorRole unique edge %s", name)
|
|
}
|
|
|
|
// ResetEdge resets all changes to the edge with the given name in this mutation.
|
|
// It returns an error if the edge is not defined in the schema.
|
|
func (m *ContributorRoleMutation) ResetEdge(name string) error {
|
|
switch name {
|
|
case contributorrole.EdgePostContributors:
|
|
m.ResetPostContributors()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown ContributorRole edge %s", name)
|
|
}
|
|
|
|
// ContributorSocialLinkMutation represents an operation that mutates the ContributorSocialLink nodes in the graph.
|
|
type ContributorSocialLinkMutation struct {
|
|
config
|
|
op Op
|
|
typ string
|
|
id *int
|
|
_type *contributorsociallink.Type
|
|
name *string
|
|
value *string
|
|
clearedFields map[string]struct{}
|
|
contributor *int
|
|
clearedcontributor bool
|
|
done bool
|
|
oldValue func(context.Context) (*ContributorSocialLink, error)
|
|
predicates []predicate.ContributorSocialLink
|
|
}
|
|
|
|
var _ ent.Mutation = (*ContributorSocialLinkMutation)(nil)
|
|
|
|
// contributorsociallinkOption allows management of the mutation configuration using functional options.
|
|
type contributorsociallinkOption func(*ContributorSocialLinkMutation)
|
|
|
|
// newContributorSocialLinkMutation creates new mutation for the ContributorSocialLink entity.
|
|
func newContributorSocialLinkMutation(c config, op Op, opts ...contributorsociallinkOption) *ContributorSocialLinkMutation {
|
|
m := &ContributorSocialLinkMutation{
|
|
config: c,
|
|
op: op,
|
|
typ: TypeContributorSocialLink,
|
|
clearedFields: make(map[string]struct{}),
|
|
}
|
|
for _, opt := range opts {
|
|
opt(m)
|
|
}
|
|
return m
|
|
}
|
|
|
|
// withContributorSocialLinkID sets the ID field of the mutation.
|
|
func withContributorSocialLinkID(id int) contributorsociallinkOption {
|
|
return func(m *ContributorSocialLinkMutation) {
|
|
var (
|
|
err error
|
|
once sync.Once
|
|
value *ContributorSocialLink
|
|
)
|
|
m.oldValue = func(ctx context.Context) (*ContributorSocialLink, error) {
|
|
once.Do(func() {
|
|
if m.done {
|
|
err = errors.New("querying old values post mutation is not allowed")
|
|
} else {
|
|
value, err = m.Client().ContributorSocialLink.Get(ctx, id)
|
|
}
|
|
})
|
|
return value, err
|
|
}
|
|
m.id = &id
|
|
}
|
|
}
|
|
|
|
// withContributorSocialLink sets the old ContributorSocialLink of the mutation.
|
|
func withContributorSocialLink(node *ContributorSocialLink) contributorsociallinkOption {
|
|
return func(m *ContributorSocialLinkMutation) {
|
|
m.oldValue = func(context.Context) (*ContributorSocialLink, error) {
|
|
return node, nil
|
|
}
|
|
m.id = &node.ID
|
|
}
|
|
}
|
|
|
|
// Client returns a new `ent.Client` from the mutation. If the mutation was
|
|
// executed in a transaction (ent.Tx), a transactional client is returned.
|
|
func (m ContributorSocialLinkMutation) Client() *Client {
|
|
client := &Client{config: m.config}
|
|
client.init()
|
|
return client
|
|
}
|
|
|
|
// Tx returns an `ent.Tx` for mutations that were executed in transactions;
|
|
// it returns an error otherwise.
|
|
func (m ContributorSocialLinkMutation) Tx() (*Tx, error) {
|
|
if _, ok := m.driver.(*txDriver); !ok {
|
|
return nil, errors.New("ent: mutation is not running in a transaction")
|
|
}
|
|
tx := &Tx{config: m.config}
|
|
tx.init()
|
|
return tx, nil
|
|
}
|
|
|
|
// ID returns the ID value in the mutation. Note that the ID is only available
|
|
// if it was provided to the builder or after it was returned from the database.
|
|
func (m *ContributorSocialLinkMutation) ID() (id int, exists bool) {
|
|
if m.id == nil {
|
|
return
|
|
}
|
|
return *m.id, true
|
|
}
|
|
|
|
// IDs queries the database and returns the entity ids that match the mutation's predicate.
|
|
// That means, if the mutation is applied within a transaction with an isolation level such
|
|
// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
|
|
// or updated by the mutation.
|
|
func (m *ContributorSocialLinkMutation) IDs(ctx context.Context) ([]int, error) {
|
|
switch {
|
|
case m.op.Is(OpUpdateOne | OpDeleteOne):
|
|
id, exists := m.ID()
|
|
if exists {
|
|
return []int{id}, nil
|
|
}
|
|
fallthrough
|
|
case m.op.Is(OpUpdate | OpDelete):
|
|
return m.Client().ContributorSocialLink.Query().Where(m.predicates...).IDs(ctx)
|
|
default:
|
|
return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
|
|
}
|
|
}
|
|
|
|
// SetType sets the "type" field.
|
|
func (m *ContributorSocialLinkMutation) SetType(c contributorsociallink.Type) {
|
|
m._type = &c
|
|
}
|
|
|
|
// GetType returns the value of the "type" field in the mutation.
|
|
func (m *ContributorSocialLinkMutation) GetType() (r contributorsociallink.Type, exists bool) {
|
|
v := m._type
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldType returns the old "type" field's value of the ContributorSocialLink entity.
|
|
// If the ContributorSocialLink object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *ContributorSocialLinkMutation) OldType(ctx context.Context) (v contributorsociallink.Type, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldType is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldType requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldType: %w", err)
|
|
}
|
|
return oldValue.Type, nil
|
|
}
|
|
|
|
// ResetType resets all changes to the "type" field.
|
|
func (m *ContributorSocialLinkMutation) ResetType() {
|
|
m._type = nil
|
|
}
|
|
|
|
// SetName sets the "name" field.
|
|
func (m *ContributorSocialLinkMutation) SetName(s string) {
|
|
m.name = &s
|
|
}
|
|
|
|
// Name returns the value of the "name" field in the mutation.
|
|
func (m *ContributorSocialLinkMutation) Name() (r string, exists bool) {
|
|
v := m.name
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldName returns the old "name" field's value of the ContributorSocialLink entity.
|
|
// If the ContributorSocialLink object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *ContributorSocialLinkMutation) OldName(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldName is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldName requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldName: %w", err)
|
|
}
|
|
return oldValue.Name, nil
|
|
}
|
|
|
|
// ClearName clears the value of the "name" field.
|
|
func (m *ContributorSocialLinkMutation) ClearName() {
|
|
m.name = nil
|
|
m.clearedFields[contributorsociallink.FieldName] = struct{}{}
|
|
}
|
|
|
|
// NameCleared returns if the "name" field was cleared in this mutation.
|
|
func (m *ContributorSocialLinkMutation) NameCleared() bool {
|
|
_, ok := m.clearedFields[contributorsociallink.FieldName]
|
|
return ok
|
|
}
|
|
|
|
// ResetName resets all changes to the "name" field.
|
|
func (m *ContributorSocialLinkMutation) ResetName() {
|
|
m.name = nil
|
|
delete(m.clearedFields, contributorsociallink.FieldName)
|
|
}
|
|
|
|
// SetValue sets the "value" field.
|
|
func (m *ContributorSocialLinkMutation) SetValue(s string) {
|
|
m.value = &s
|
|
}
|
|
|
|
// Value returns the value of the "value" field in the mutation.
|
|
func (m *ContributorSocialLinkMutation) Value() (r string, exists bool) {
|
|
v := m.value
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldValue returns the old "value" field's value of the ContributorSocialLink entity.
|
|
// If the ContributorSocialLink object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *ContributorSocialLinkMutation) OldValue(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldValue is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldValue requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldValue: %w", err)
|
|
}
|
|
return oldValue.Value, nil
|
|
}
|
|
|
|
// ResetValue resets all changes to the "value" field.
|
|
func (m *ContributorSocialLinkMutation) ResetValue() {
|
|
m.value = nil
|
|
}
|
|
|
|
// SetContributorID sets the "contributor" edge to the Contributor entity by id.
|
|
func (m *ContributorSocialLinkMutation) SetContributorID(id int) {
|
|
m.contributor = &id
|
|
}
|
|
|
|
// ClearContributor clears the "contributor" edge to the Contributor entity.
|
|
func (m *ContributorSocialLinkMutation) ClearContributor() {
|
|
m.clearedcontributor = true
|
|
}
|
|
|
|
// ContributorCleared reports if the "contributor" edge to the Contributor entity was cleared.
|
|
func (m *ContributorSocialLinkMutation) ContributorCleared() bool {
|
|
return m.clearedcontributor
|
|
}
|
|
|
|
// ContributorID returns the "contributor" edge ID in the mutation.
|
|
func (m *ContributorSocialLinkMutation) ContributorID() (id int, exists bool) {
|
|
if m.contributor != nil {
|
|
return *m.contributor, true
|
|
}
|
|
return
|
|
}
|
|
|
|
// ContributorIDs returns the "contributor" edge IDs in the mutation.
|
|
// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
|
|
// ContributorID instead. It exists only for internal usage by the builders.
|
|
func (m *ContributorSocialLinkMutation) ContributorIDs() (ids []int) {
|
|
if id := m.contributor; id != nil {
|
|
ids = append(ids, *id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetContributor resets all changes to the "contributor" edge.
|
|
func (m *ContributorSocialLinkMutation) ResetContributor() {
|
|
m.contributor = nil
|
|
m.clearedcontributor = false
|
|
}
|
|
|
|
// Where appends a list predicates to the ContributorSocialLinkMutation builder.
|
|
func (m *ContributorSocialLinkMutation) Where(ps ...predicate.ContributorSocialLink) {
|
|
m.predicates = append(m.predicates, ps...)
|
|
}
|
|
|
|
// WhereP appends storage-level predicates to the ContributorSocialLinkMutation builder. Using this method,
|
|
// users can use type-assertion to append predicates that do not depend on any generated package.
|
|
func (m *ContributorSocialLinkMutation) WhereP(ps ...func(*sql.Selector)) {
|
|
p := make([]predicate.ContributorSocialLink, len(ps))
|
|
for i := range ps {
|
|
p[i] = ps[i]
|
|
}
|
|
m.Where(p...)
|
|
}
|
|
|
|
// Op returns the operation name.
|
|
func (m *ContributorSocialLinkMutation) Op() Op {
|
|
return m.op
|
|
}
|
|
|
|
// SetOp allows setting the mutation operation.
|
|
func (m *ContributorSocialLinkMutation) SetOp(op Op) {
|
|
m.op = op
|
|
}
|
|
|
|
// Type returns the node type of this mutation (ContributorSocialLink).
|
|
func (m *ContributorSocialLinkMutation) Type() string {
|
|
return m.typ
|
|
}
|
|
|
|
// Fields returns all fields that were changed during this mutation. Note that in
|
|
// order to get all numeric fields that were incremented/decremented, call
|
|
// AddedFields().
|
|
func (m *ContributorSocialLinkMutation) Fields() []string {
|
|
fields := make([]string, 0, 3)
|
|
if m._type != nil {
|
|
fields = append(fields, contributorsociallink.FieldType)
|
|
}
|
|
if m.name != nil {
|
|
fields = append(fields, contributorsociallink.FieldName)
|
|
}
|
|
if m.value != nil {
|
|
fields = append(fields, contributorsociallink.FieldValue)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// Field returns the value of a field with the given name. The second boolean
|
|
// return value indicates that this field was not set, or was not defined in the
|
|
// schema.
|
|
func (m *ContributorSocialLinkMutation) Field(name string) (ent.Value, bool) {
|
|
switch name {
|
|
case contributorsociallink.FieldType:
|
|
return m.GetType()
|
|
case contributorsociallink.FieldName:
|
|
return m.Name()
|
|
case contributorsociallink.FieldValue:
|
|
return m.Value()
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
// OldField returns the old value of the field from the database. An error is
|
|
// returned if the mutation operation is not UpdateOne, or the query to the
|
|
// database failed.
|
|
func (m *ContributorSocialLinkMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
|
|
switch name {
|
|
case contributorsociallink.FieldType:
|
|
return m.OldType(ctx)
|
|
case contributorsociallink.FieldName:
|
|
return m.OldName(ctx)
|
|
case contributorsociallink.FieldValue:
|
|
return m.OldValue(ctx)
|
|
}
|
|
return nil, fmt.Errorf("unknown ContributorSocialLink field %s", name)
|
|
}
|
|
|
|
// SetField sets the value of a field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *ContributorSocialLinkMutation) SetField(name string, value ent.Value) error {
|
|
switch name {
|
|
case contributorsociallink.FieldType:
|
|
v, ok := value.(contributorsociallink.Type)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetType(v)
|
|
return nil
|
|
case contributorsociallink.FieldName:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetName(v)
|
|
return nil
|
|
case contributorsociallink.FieldValue:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetValue(v)
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown ContributorSocialLink field %s", name)
|
|
}
|
|
|
|
// AddedFields returns all numeric fields that were incremented/decremented during
|
|
// this mutation.
|
|
func (m *ContributorSocialLinkMutation) AddedFields() []string {
|
|
return nil
|
|
}
|
|
|
|
// AddedField returns the numeric value that was incremented/decremented on a field
|
|
// with the given name. The second boolean return value indicates that this field
|
|
// was not set, or was not defined in the schema.
|
|
func (m *ContributorSocialLinkMutation) AddedField(name string) (ent.Value, bool) {
|
|
return nil, false
|
|
}
|
|
|
|
// AddField adds the value to the field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *ContributorSocialLinkMutation) AddField(name string, value ent.Value) error {
|
|
switch name {
|
|
}
|
|
return fmt.Errorf("unknown ContributorSocialLink numeric field %s", name)
|
|
}
|
|
|
|
// ClearedFields returns all nullable fields that were cleared during this
|
|
// mutation.
|
|
func (m *ContributorSocialLinkMutation) ClearedFields() []string {
|
|
var fields []string
|
|
if m.FieldCleared(contributorsociallink.FieldName) {
|
|
fields = append(fields, contributorsociallink.FieldName)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// FieldCleared returns a boolean indicating if a field with the given name was
|
|
// cleared in this mutation.
|
|
func (m *ContributorSocialLinkMutation) FieldCleared(name string) bool {
|
|
_, ok := m.clearedFields[name]
|
|
return ok
|
|
}
|
|
|
|
// ClearField clears the value of the field with the given name. It returns an
|
|
// error if the field is not defined in the schema.
|
|
func (m *ContributorSocialLinkMutation) ClearField(name string) error {
|
|
switch name {
|
|
case contributorsociallink.FieldName:
|
|
m.ClearName()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown ContributorSocialLink nullable field %s", name)
|
|
}
|
|
|
|
// ResetField resets all changes in the mutation for the field with the given name.
|
|
// It returns an error if the field is not defined in the schema.
|
|
func (m *ContributorSocialLinkMutation) ResetField(name string) error {
|
|
switch name {
|
|
case contributorsociallink.FieldType:
|
|
m.ResetType()
|
|
return nil
|
|
case contributorsociallink.FieldName:
|
|
m.ResetName()
|
|
return nil
|
|
case contributorsociallink.FieldValue:
|
|
m.ResetValue()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown ContributorSocialLink field %s", name)
|
|
}
|
|
|
|
// AddedEdges returns all edge names that were set/added in this mutation.
|
|
func (m *ContributorSocialLinkMutation) AddedEdges() []string {
|
|
edges := make([]string, 0, 1)
|
|
if m.contributor != nil {
|
|
edges = append(edges, contributorsociallink.EdgeContributor)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// AddedIDs returns all IDs (to other nodes) that were added for the given edge
|
|
// name in this mutation.
|
|
func (m *ContributorSocialLinkMutation) AddedIDs(name string) []ent.Value {
|
|
switch name {
|
|
case contributorsociallink.EdgeContributor:
|
|
if id := m.contributor; id != nil {
|
|
return []ent.Value{*id}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// RemovedEdges returns all edge names that were removed in this mutation.
|
|
func (m *ContributorSocialLinkMutation) RemovedEdges() []string {
|
|
edges := make([]string, 0, 1)
|
|
return edges
|
|
}
|
|
|
|
// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
|
|
// the given name in this mutation.
|
|
func (m *ContributorSocialLinkMutation) RemovedIDs(name string) []ent.Value {
|
|
return nil
|
|
}
|
|
|
|
// ClearedEdges returns all edge names that were cleared in this mutation.
|
|
func (m *ContributorSocialLinkMutation) ClearedEdges() []string {
|
|
edges := make([]string, 0, 1)
|
|
if m.clearedcontributor {
|
|
edges = append(edges, contributorsociallink.EdgeContributor)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// EdgeCleared returns a boolean which indicates if the edge with the given name
|
|
// was cleared in this mutation.
|
|
func (m *ContributorSocialLinkMutation) EdgeCleared(name string) bool {
|
|
switch name {
|
|
case contributorsociallink.EdgeContributor:
|
|
return m.clearedcontributor
|
|
}
|
|
return false
|
|
}
|
|
|
|
// ClearEdge clears the value of the edge with the given name. It returns an error
|
|
// if that edge is not defined in the schema.
|
|
func (m *ContributorSocialLinkMutation) ClearEdge(name string) error {
|
|
switch name {
|
|
case contributorsociallink.EdgeContributor:
|
|
m.ClearContributor()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown ContributorSocialLink unique edge %s", name)
|
|
}
|
|
|
|
// ResetEdge resets all changes to the edge with the given name in this mutation.
|
|
// It returns an error if the edge is not defined in the schema.
|
|
func (m *ContributorSocialLinkMutation) ResetEdge(name string) error {
|
|
switch name {
|
|
case contributorsociallink.EdgeContributor:
|
|
m.ResetContributor()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown ContributorSocialLink edge %s", name)
|
|
}
|
|
|
|
// DailyMutation represents an operation that mutates the Daily nodes in the graph.
|
|
type DailyMutation struct {
|
|
config
|
|
op Op
|
|
typ string
|
|
id *string
|
|
image_url *string
|
|
created_at *time.Time
|
|
updated_at *time.Time
|
|
clearedFields map[string]struct{}
|
|
category *int
|
|
clearedcategory bool
|
|
contents map[int]struct{}
|
|
removedcontents map[int]struct{}
|
|
clearedcontents bool
|
|
done bool
|
|
oldValue func(context.Context) (*Daily, error)
|
|
predicates []predicate.Daily
|
|
}
|
|
|
|
var _ ent.Mutation = (*DailyMutation)(nil)
|
|
|
|
// dailyOption allows management of the mutation configuration using functional options.
|
|
type dailyOption func(*DailyMutation)
|
|
|
|
// newDailyMutation creates new mutation for the Daily entity.
|
|
func newDailyMutation(c config, op Op, opts ...dailyOption) *DailyMutation {
|
|
m := &DailyMutation{
|
|
config: c,
|
|
op: op,
|
|
typ: TypeDaily,
|
|
clearedFields: make(map[string]struct{}),
|
|
}
|
|
for _, opt := range opts {
|
|
opt(m)
|
|
}
|
|
return m
|
|
}
|
|
|
|
// withDailyID sets the ID field of the mutation.
|
|
func withDailyID(id string) dailyOption {
|
|
return func(m *DailyMutation) {
|
|
var (
|
|
err error
|
|
once sync.Once
|
|
value *Daily
|
|
)
|
|
m.oldValue = func(ctx context.Context) (*Daily, error) {
|
|
once.Do(func() {
|
|
if m.done {
|
|
err = errors.New("querying old values post mutation is not allowed")
|
|
} else {
|
|
value, err = m.Client().Daily.Get(ctx, id)
|
|
}
|
|
})
|
|
return value, err
|
|
}
|
|
m.id = &id
|
|
}
|
|
}
|
|
|
|
// withDaily sets the old Daily of the mutation.
|
|
func withDaily(node *Daily) dailyOption {
|
|
return func(m *DailyMutation) {
|
|
m.oldValue = func(context.Context) (*Daily, error) {
|
|
return node, nil
|
|
}
|
|
m.id = &node.ID
|
|
}
|
|
}
|
|
|
|
// Client returns a new `ent.Client` from the mutation. If the mutation was
|
|
// executed in a transaction (ent.Tx), a transactional client is returned.
|
|
func (m DailyMutation) Client() *Client {
|
|
client := &Client{config: m.config}
|
|
client.init()
|
|
return client
|
|
}
|
|
|
|
// Tx returns an `ent.Tx` for mutations that were executed in transactions;
|
|
// it returns an error otherwise.
|
|
func (m DailyMutation) Tx() (*Tx, error) {
|
|
if _, ok := m.driver.(*txDriver); !ok {
|
|
return nil, errors.New("ent: mutation is not running in a transaction")
|
|
}
|
|
tx := &Tx{config: m.config}
|
|
tx.init()
|
|
return tx, nil
|
|
}
|
|
|
|
// SetID sets the value of the id field. Note that this
|
|
// operation is only accepted on creation of Daily entities.
|
|
func (m *DailyMutation) SetID(id string) {
|
|
m.id = &id
|
|
}
|
|
|
|
// ID returns the ID value in the mutation. Note that the ID is only available
|
|
// if it was provided to the builder or after it was returned from the database.
|
|
func (m *DailyMutation) ID() (id string, exists bool) {
|
|
if m.id == nil {
|
|
return
|
|
}
|
|
return *m.id, true
|
|
}
|
|
|
|
// IDs queries the database and returns the entity ids that match the mutation's predicate.
|
|
// That means, if the mutation is applied within a transaction with an isolation level such
|
|
// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
|
|
// or updated by the mutation.
|
|
func (m *DailyMutation) IDs(ctx context.Context) ([]string, error) {
|
|
switch {
|
|
case m.op.Is(OpUpdateOne | OpDeleteOne):
|
|
id, exists := m.ID()
|
|
if exists {
|
|
return []string{id}, nil
|
|
}
|
|
fallthrough
|
|
case m.op.Is(OpUpdate | OpDelete):
|
|
return m.Client().Daily.Query().Where(m.predicates...).IDs(ctx)
|
|
default:
|
|
return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
|
|
}
|
|
}
|
|
|
|
// SetImageURL sets the "image_url" field.
|
|
func (m *DailyMutation) SetImageURL(s string) {
|
|
m.image_url = &s
|
|
}
|
|
|
|
// ImageURL returns the value of the "image_url" field in the mutation.
|
|
func (m *DailyMutation) ImageURL() (r string, exists bool) {
|
|
v := m.image_url
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldImageURL returns the old "image_url" field's value of the Daily entity.
|
|
// If the Daily object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *DailyMutation) OldImageURL(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldImageURL is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldImageURL requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldImageURL: %w", err)
|
|
}
|
|
return oldValue.ImageURL, nil
|
|
}
|
|
|
|
// ResetImageURL resets all changes to the "image_url" field.
|
|
func (m *DailyMutation) ResetImageURL() {
|
|
m.image_url = nil
|
|
}
|
|
|
|
// SetCreatedAt sets the "created_at" field.
|
|
func (m *DailyMutation) SetCreatedAt(t time.Time) {
|
|
m.created_at = &t
|
|
}
|
|
|
|
// CreatedAt returns the value of the "created_at" field in the mutation.
|
|
func (m *DailyMutation) CreatedAt() (r time.Time, exists bool) {
|
|
v := m.created_at
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldCreatedAt returns the old "created_at" field's value of the Daily entity.
|
|
// If the Daily object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *DailyMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldCreatedAt requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
|
|
}
|
|
return oldValue.CreatedAt, nil
|
|
}
|
|
|
|
// ResetCreatedAt resets all changes to the "created_at" field.
|
|
func (m *DailyMutation) ResetCreatedAt() {
|
|
m.created_at = nil
|
|
}
|
|
|
|
// SetUpdatedAt sets the "updated_at" field.
|
|
func (m *DailyMutation) SetUpdatedAt(t time.Time) {
|
|
m.updated_at = &t
|
|
}
|
|
|
|
// UpdatedAt returns the value of the "updated_at" field in the mutation.
|
|
func (m *DailyMutation) UpdatedAt() (r time.Time, exists bool) {
|
|
v := m.updated_at
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldUpdatedAt returns the old "updated_at" field's value of the Daily entity.
|
|
// If the Daily object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *DailyMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
|
|
}
|
|
return oldValue.UpdatedAt, nil
|
|
}
|
|
|
|
// ResetUpdatedAt resets all changes to the "updated_at" field.
|
|
func (m *DailyMutation) ResetUpdatedAt() {
|
|
m.updated_at = nil
|
|
}
|
|
|
|
// SetCategoryID sets the "category" edge to the Category entity by id.
|
|
func (m *DailyMutation) SetCategoryID(id int) {
|
|
m.category = &id
|
|
}
|
|
|
|
// ClearCategory clears the "category" edge to the Category entity.
|
|
func (m *DailyMutation) ClearCategory() {
|
|
m.clearedcategory = true
|
|
}
|
|
|
|
// CategoryCleared reports if the "category" edge to the Category entity was cleared.
|
|
func (m *DailyMutation) CategoryCleared() bool {
|
|
return m.clearedcategory
|
|
}
|
|
|
|
// CategoryID returns the "category" edge ID in the mutation.
|
|
func (m *DailyMutation) CategoryID() (id int, exists bool) {
|
|
if m.category != nil {
|
|
return *m.category, true
|
|
}
|
|
return
|
|
}
|
|
|
|
// CategoryIDs returns the "category" edge IDs in the mutation.
|
|
// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
|
|
// CategoryID instead. It exists only for internal usage by the builders.
|
|
func (m *DailyMutation) CategoryIDs() (ids []int) {
|
|
if id := m.category; id != nil {
|
|
ids = append(ids, *id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetCategory resets all changes to the "category" edge.
|
|
func (m *DailyMutation) ResetCategory() {
|
|
m.category = nil
|
|
m.clearedcategory = false
|
|
}
|
|
|
|
// AddContentIDs adds the "contents" edge to the DailyContent entity by ids.
|
|
func (m *DailyMutation) AddContentIDs(ids ...int) {
|
|
if m.contents == nil {
|
|
m.contents = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
m.contents[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// ClearContents clears the "contents" edge to the DailyContent entity.
|
|
func (m *DailyMutation) ClearContents() {
|
|
m.clearedcontents = true
|
|
}
|
|
|
|
// ContentsCleared reports if the "contents" edge to the DailyContent entity was cleared.
|
|
func (m *DailyMutation) ContentsCleared() bool {
|
|
return m.clearedcontents
|
|
}
|
|
|
|
// RemoveContentIDs removes the "contents" edge to the DailyContent entity by IDs.
|
|
func (m *DailyMutation) RemoveContentIDs(ids ...int) {
|
|
if m.removedcontents == nil {
|
|
m.removedcontents = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
delete(m.contents, ids[i])
|
|
m.removedcontents[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// RemovedContents returns the removed IDs of the "contents" edge to the DailyContent entity.
|
|
func (m *DailyMutation) RemovedContentsIDs() (ids []int) {
|
|
for id := range m.removedcontents {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ContentsIDs returns the "contents" edge IDs in the mutation.
|
|
func (m *DailyMutation) ContentsIDs() (ids []int) {
|
|
for id := range m.contents {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetContents resets all changes to the "contents" edge.
|
|
func (m *DailyMutation) ResetContents() {
|
|
m.contents = nil
|
|
m.clearedcontents = false
|
|
m.removedcontents = nil
|
|
}
|
|
|
|
// Where appends a list predicates to the DailyMutation builder.
|
|
func (m *DailyMutation) Where(ps ...predicate.Daily) {
|
|
m.predicates = append(m.predicates, ps...)
|
|
}
|
|
|
|
// WhereP appends storage-level predicates to the DailyMutation builder. Using this method,
|
|
// users can use type-assertion to append predicates that do not depend on any generated package.
|
|
func (m *DailyMutation) WhereP(ps ...func(*sql.Selector)) {
|
|
p := make([]predicate.Daily, len(ps))
|
|
for i := range ps {
|
|
p[i] = ps[i]
|
|
}
|
|
m.Where(p...)
|
|
}
|
|
|
|
// Op returns the operation name.
|
|
func (m *DailyMutation) Op() Op {
|
|
return m.op
|
|
}
|
|
|
|
// SetOp allows setting the mutation operation.
|
|
func (m *DailyMutation) SetOp(op Op) {
|
|
m.op = op
|
|
}
|
|
|
|
// Type returns the node type of this mutation (Daily).
|
|
func (m *DailyMutation) Type() string {
|
|
return m.typ
|
|
}
|
|
|
|
// Fields returns all fields that were changed during this mutation. Note that in
|
|
// order to get all numeric fields that were incremented/decremented, call
|
|
// AddedFields().
|
|
func (m *DailyMutation) Fields() []string {
|
|
fields := make([]string, 0, 3)
|
|
if m.image_url != nil {
|
|
fields = append(fields, daily.FieldImageURL)
|
|
}
|
|
if m.created_at != nil {
|
|
fields = append(fields, daily.FieldCreatedAt)
|
|
}
|
|
if m.updated_at != nil {
|
|
fields = append(fields, daily.FieldUpdatedAt)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// Field returns the value of a field with the given name. The second boolean
|
|
// return value indicates that this field was not set, or was not defined in the
|
|
// schema.
|
|
func (m *DailyMutation) Field(name string) (ent.Value, bool) {
|
|
switch name {
|
|
case daily.FieldImageURL:
|
|
return m.ImageURL()
|
|
case daily.FieldCreatedAt:
|
|
return m.CreatedAt()
|
|
case daily.FieldUpdatedAt:
|
|
return m.UpdatedAt()
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
// OldField returns the old value of the field from the database. An error is
|
|
// returned if the mutation operation is not UpdateOne, or the query to the
|
|
// database failed.
|
|
func (m *DailyMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
|
|
switch name {
|
|
case daily.FieldImageURL:
|
|
return m.OldImageURL(ctx)
|
|
case daily.FieldCreatedAt:
|
|
return m.OldCreatedAt(ctx)
|
|
case daily.FieldUpdatedAt:
|
|
return m.OldUpdatedAt(ctx)
|
|
}
|
|
return nil, fmt.Errorf("unknown Daily field %s", name)
|
|
}
|
|
|
|
// SetField sets the value of a field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *DailyMutation) SetField(name string, value ent.Value) error {
|
|
switch name {
|
|
case daily.FieldImageURL:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetImageURL(v)
|
|
return nil
|
|
case daily.FieldCreatedAt:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetCreatedAt(v)
|
|
return nil
|
|
case daily.FieldUpdatedAt:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetUpdatedAt(v)
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Daily field %s", name)
|
|
}
|
|
|
|
// AddedFields returns all numeric fields that were incremented/decremented during
|
|
// this mutation.
|
|
func (m *DailyMutation) AddedFields() []string {
|
|
return nil
|
|
}
|
|
|
|
// AddedField returns the numeric value that was incremented/decremented on a field
|
|
// with the given name. The second boolean return value indicates that this field
|
|
// was not set, or was not defined in the schema.
|
|
func (m *DailyMutation) AddedField(name string) (ent.Value, bool) {
|
|
return nil, false
|
|
}
|
|
|
|
// AddField adds the value to the field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *DailyMutation) AddField(name string, value ent.Value) error {
|
|
switch name {
|
|
}
|
|
return fmt.Errorf("unknown Daily numeric field %s", name)
|
|
}
|
|
|
|
// ClearedFields returns all nullable fields that were cleared during this
|
|
// mutation.
|
|
func (m *DailyMutation) ClearedFields() []string {
|
|
return nil
|
|
}
|
|
|
|
// FieldCleared returns a boolean indicating if a field with the given name was
|
|
// cleared in this mutation.
|
|
func (m *DailyMutation) FieldCleared(name string) bool {
|
|
_, ok := m.clearedFields[name]
|
|
return ok
|
|
}
|
|
|
|
// ClearField clears the value of the field with the given name. It returns an
|
|
// error if the field is not defined in the schema.
|
|
func (m *DailyMutation) ClearField(name string) error {
|
|
return fmt.Errorf("unknown Daily nullable field %s", name)
|
|
}
|
|
|
|
// ResetField resets all changes in the mutation for the field with the given name.
|
|
// It returns an error if the field is not defined in the schema.
|
|
func (m *DailyMutation) ResetField(name string) error {
|
|
switch name {
|
|
case daily.FieldImageURL:
|
|
m.ResetImageURL()
|
|
return nil
|
|
case daily.FieldCreatedAt:
|
|
m.ResetCreatedAt()
|
|
return nil
|
|
case daily.FieldUpdatedAt:
|
|
m.ResetUpdatedAt()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Daily field %s", name)
|
|
}
|
|
|
|
// AddedEdges returns all edge names that were set/added in this mutation.
|
|
func (m *DailyMutation) AddedEdges() []string {
|
|
edges := make([]string, 0, 2)
|
|
if m.category != nil {
|
|
edges = append(edges, daily.EdgeCategory)
|
|
}
|
|
if m.contents != nil {
|
|
edges = append(edges, daily.EdgeContents)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// AddedIDs returns all IDs (to other nodes) that were added for the given edge
|
|
// name in this mutation.
|
|
func (m *DailyMutation) AddedIDs(name string) []ent.Value {
|
|
switch name {
|
|
case daily.EdgeCategory:
|
|
if id := m.category; id != nil {
|
|
return []ent.Value{*id}
|
|
}
|
|
case daily.EdgeContents:
|
|
ids := make([]ent.Value, 0, len(m.contents))
|
|
for id := range m.contents {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// RemovedEdges returns all edge names that were removed in this mutation.
|
|
func (m *DailyMutation) RemovedEdges() []string {
|
|
edges := make([]string, 0, 2)
|
|
if m.removedcontents != nil {
|
|
edges = append(edges, daily.EdgeContents)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
|
|
// the given name in this mutation.
|
|
func (m *DailyMutation) RemovedIDs(name string) []ent.Value {
|
|
switch name {
|
|
case daily.EdgeContents:
|
|
ids := make([]ent.Value, 0, len(m.removedcontents))
|
|
for id := range m.removedcontents {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// ClearedEdges returns all edge names that were cleared in this mutation.
|
|
func (m *DailyMutation) ClearedEdges() []string {
|
|
edges := make([]string, 0, 2)
|
|
if m.clearedcategory {
|
|
edges = append(edges, daily.EdgeCategory)
|
|
}
|
|
if m.clearedcontents {
|
|
edges = append(edges, daily.EdgeContents)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// EdgeCleared returns a boolean which indicates if the edge with the given name
|
|
// was cleared in this mutation.
|
|
func (m *DailyMutation) EdgeCleared(name string) bool {
|
|
switch name {
|
|
case daily.EdgeCategory:
|
|
return m.clearedcategory
|
|
case daily.EdgeContents:
|
|
return m.clearedcontents
|
|
}
|
|
return false
|
|
}
|
|
|
|
// ClearEdge clears the value of the edge with the given name. It returns an error
|
|
// if that edge is not defined in the schema.
|
|
func (m *DailyMutation) ClearEdge(name string) error {
|
|
switch name {
|
|
case daily.EdgeCategory:
|
|
m.ClearCategory()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Daily unique edge %s", name)
|
|
}
|
|
|
|
// ResetEdge resets all changes to the edge with the given name in this mutation.
|
|
// It returns an error if the edge is not defined in the schema.
|
|
func (m *DailyMutation) ResetEdge(name string) error {
|
|
switch name {
|
|
case daily.EdgeCategory:
|
|
m.ResetCategory()
|
|
return nil
|
|
case daily.EdgeContents:
|
|
m.ResetContents()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Daily edge %s", name)
|
|
}
|
|
|
|
// DailyCategoryMutation represents an operation that mutates the DailyCategory nodes in the graph.
|
|
type DailyCategoryMutation struct {
|
|
config
|
|
op Op
|
|
typ string
|
|
id *int
|
|
created_at *time.Time
|
|
updated_at *time.Time
|
|
clearedFields map[string]struct{}
|
|
contents map[int]struct{}
|
|
removedcontents map[int]struct{}
|
|
clearedcontents bool
|
|
daily_items map[string]struct{}
|
|
removeddaily_items map[string]struct{}
|
|
cleareddaily_items bool
|
|
done bool
|
|
oldValue func(context.Context) (*DailyCategory, error)
|
|
predicates []predicate.DailyCategory
|
|
}
|
|
|
|
var _ ent.Mutation = (*DailyCategoryMutation)(nil)
|
|
|
|
// dailycategoryOption allows management of the mutation configuration using functional options.
|
|
type dailycategoryOption func(*DailyCategoryMutation)
|
|
|
|
// newDailyCategoryMutation creates new mutation for the DailyCategory entity.
|
|
func newDailyCategoryMutation(c config, op Op, opts ...dailycategoryOption) *DailyCategoryMutation {
|
|
m := &DailyCategoryMutation{
|
|
config: c,
|
|
op: op,
|
|
typ: TypeDailyCategory,
|
|
clearedFields: make(map[string]struct{}),
|
|
}
|
|
for _, opt := range opts {
|
|
opt(m)
|
|
}
|
|
return m
|
|
}
|
|
|
|
// withDailyCategoryID sets the ID field of the mutation.
|
|
func withDailyCategoryID(id int) dailycategoryOption {
|
|
return func(m *DailyCategoryMutation) {
|
|
var (
|
|
err error
|
|
once sync.Once
|
|
value *DailyCategory
|
|
)
|
|
m.oldValue = func(ctx context.Context) (*DailyCategory, error) {
|
|
once.Do(func() {
|
|
if m.done {
|
|
err = errors.New("querying old values post mutation is not allowed")
|
|
} else {
|
|
value, err = m.Client().DailyCategory.Get(ctx, id)
|
|
}
|
|
})
|
|
return value, err
|
|
}
|
|
m.id = &id
|
|
}
|
|
}
|
|
|
|
// withDailyCategory sets the old DailyCategory of the mutation.
|
|
func withDailyCategory(node *DailyCategory) dailycategoryOption {
|
|
return func(m *DailyCategoryMutation) {
|
|
m.oldValue = func(context.Context) (*DailyCategory, error) {
|
|
return node, nil
|
|
}
|
|
m.id = &node.ID
|
|
}
|
|
}
|
|
|
|
// Client returns a new `ent.Client` from the mutation. If the mutation was
|
|
// executed in a transaction (ent.Tx), a transactional client is returned.
|
|
func (m DailyCategoryMutation) Client() *Client {
|
|
client := &Client{config: m.config}
|
|
client.init()
|
|
return client
|
|
}
|
|
|
|
// Tx returns an `ent.Tx` for mutations that were executed in transactions;
|
|
// it returns an error otherwise.
|
|
func (m DailyCategoryMutation) Tx() (*Tx, error) {
|
|
if _, ok := m.driver.(*txDriver); !ok {
|
|
return nil, errors.New("ent: mutation is not running in a transaction")
|
|
}
|
|
tx := &Tx{config: m.config}
|
|
tx.init()
|
|
return tx, nil
|
|
}
|
|
|
|
// ID returns the ID value in the mutation. Note that the ID is only available
|
|
// if it was provided to the builder or after it was returned from the database.
|
|
func (m *DailyCategoryMutation) ID() (id int, exists bool) {
|
|
if m.id == nil {
|
|
return
|
|
}
|
|
return *m.id, true
|
|
}
|
|
|
|
// IDs queries the database and returns the entity ids that match the mutation's predicate.
|
|
// That means, if the mutation is applied within a transaction with an isolation level such
|
|
// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
|
|
// or updated by the mutation.
|
|
func (m *DailyCategoryMutation) IDs(ctx context.Context) ([]int, error) {
|
|
switch {
|
|
case m.op.Is(OpUpdateOne | OpDeleteOne):
|
|
id, exists := m.ID()
|
|
if exists {
|
|
return []int{id}, nil
|
|
}
|
|
fallthrough
|
|
case m.op.Is(OpUpdate | OpDelete):
|
|
return m.Client().DailyCategory.Query().Where(m.predicates...).IDs(ctx)
|
|
default:
|
|
return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
|
|
}
|
|
}
|
|
|
|
// SetCreatedAt sets the "created_at" field.
|
|
func (m *DailyCategoryMutation) SetCreatedAt(t time.Time) {
|
|
m.created_at = &t
|
|
}
|
|
|
|
// CreatedAt returns the value of the "created_at" field in the mutation.
|
|
func (m *DailyCategoryMutation) CreatedAt() (r time.Time, exists bool) {
|
|
v := m.created_at
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldCreatedAt returns the old "created_at" field's value of the DailyCategory entity.
|
|
// If the DailyCategory object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *DailyCategoryMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldCreatedAt requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
|
|
}
|
|
return oldValue.CreatedAt, nil
|
|
}
|
|
|
|
// ResetCreatedAt resets all changes to the "created_at" field.
|
|
func (m *DailyCategoryMutation) ResetCreatedAt() {
|
|
m.created_at = nil
|
|
}
|
|
|
|
// SetUpdatedAt sets the "updated_at" field.
|
|
func (m *DailyCategoryMutation) SetUpdatedAt(t time.Time) {
|
|
m.updated_at = &t
|
|
}
|
|
|
|
// UpdatedAt returns the value of the "updated_at" field in the mutation.
|
|
func (m *DailyCategoryMutation) UpdatedAt() (r time.Time, exists bool) {
|
|
v := m.updated_at
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldUpdatedAt returns the old "updated_at" field's value of the DailyCategory entity.
|
|
// If the DailyCategory object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *DailyCategoryMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
|
|
}
|
|
return oldValue.UpdatedAt, nil
|
|
}
|
|
|
|
// ResetUpdatedAt resets all changes to the "updated_at" field.
|
|
func (m *DailyCategoryMutation) ResetUpdatedAt() {
|
|
m.updated_at = nil
|
|
}
|
|
|
|
// AddContentIDs adds the "contents" edge to the DailyCategoryContent entity by ids.
|
|
func (m *DailyCategoryMutation) AddContentIDs(ids ...int) {
|
|
if m.contents == nil {
|
|
m.contents = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
m.contents[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// ClearContents clears the "contents" edge to the DailyCategoryContent entity.
|
|
func (m *DailyCategoryMutation) ClearContents() {
|
|
m.clearedcontents = true
|
|
}
|
|
|
|
// ContentsCleared reports if the "contents" edge to the DailyCategoryContent entity was cleared.
|
|
func (m *DailyCategoryMutation) ContentsCleared() bool {
|
|
return m.clearedcontents
|
|
}
|
|
|
|
// RemoveContentIDs removes the "contents" edge to the DailyCategoryContent entity by IDs.
|
|
func (m *DailyCategoryMutation) RemoveContentIDs(ids ...int) {
|
|
if m.removedcontents == nil {
|
|
m.removedcontents = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
delete(m.contents, ids[i])
|
|
m.removedcontents[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// RemovedContents returns the removed IDs of the "contents" edge to the DailyCategoryContent entity.
|
|
func (m *DailyCategoryMutation) RemovedContentsIDs() (ids []int) {
|
|
for id := range m.removedcontents {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ContentsIDs returns the "contents" edge IDs in the mutation.
|
|
func (m *DailyCategoryMutation) ContentsIDs() (ids []int) {
|
|
for id := range m.contents {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetContents resets all changes to the "contents" edge.
|
|
func (m *DailyCategoryMutation) ResetContents() {
|
|
m.contents = nil
|
|
m.clearedcontents = false
|
|
m.removedcontents = nil
|
|
}
|
|
|
|
// AddDailyItemIDs adds the "daily_items" edge to the Daily entity by ids.
|
|
func (m *DailyCategoryMutation) AddDailyItemIDs(ids ...string) {
|
|
if m.daily_items == nil {
|
|
m.daily_items = make(map[string]struct{})
|
|
}
|
|
for i := range ids {
|
|
m.daily_items[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// ClearDailyItems clears the "daily_items" edge to the Daily entity.
|
|
func (m *DailyCategoryMutation) ClearDailyItems() {
|
|
m.cleareddaily_items = true
|
|
}
|
|
|
|
// DailyItemsCleared reports if the "daily_items" edge to the Daily entity was cleared.
|
|
func (m *DailyCategoryMutation) DailyItemsCleared() bool {
|
|
return m.cleareddaily_items
|
|
}
|
|
|
|
// RemoveDailyItemIDs removes the "daily_items" edge to the Daily entity by IDs.
|
|
func (m *DailyCategoryMutation) RemoveDailyItemIDs(ids ...string) {
|
|
if m.removeddaily_items == nil {
|
|
m.removeddaily_items = make(map[string]struct{})
|
|
}
|
|
for i := range ids {
|
|
delete(m.daily_items, ids[i])
|
|
m.removeddaily_items[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// RemovedDailyItems returns the removed IDs of the "daily_items" edge to the Daily entity.
|
|
func (m *DailyCategoryMutation) RemovedDailyItemsIDs() (ids []string) {
|
|
for id := range m.removeddaily_items {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// DailyItemsIDs returns the "daily_items" edge IDs in the mutation.
|
|
func (m *DailyCategoryMutation) DailyItemsIDs() (ids []string) {
|
|
for id := range m.daily_items {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetDailyItems resets all changes to the "daily_items" edge.
|
|
func (m *DailyCategoryMutation) ResetDailyItems() {
|
|
m.daily_items = nil
|
|
m.cleareddaily_items = false
|
|
m.removeddaily_items = nil
|
|
}
|
|
|
|
// Where appends a list predicates to the DailyCategoryMutation builder.
|
|
func (m *DailyCategoryMutation) Where(ps ...predicate.DailyCategory) {
|
|
m.predicates = append(m.predicates, ps...)
|
|
}
|
|
|
|
// WhereP appends storage-level predicates to the DailyCategoryMutation builder. Using this method,
|
|
// users can use type-assertion to append predicates that do not depend on any generated package.
|
|
func (m *DailyCategoryMutation) WhereP(ps ...func(*sql.Selector)) {
|
|
p := make([]predicate.DailyCategory, len(ps))
|
|
for i := range ps {
|
|
p[i] = ps[i]
|
|
}
|
|
m.Where(p...)
|
|
}
|
|
|
|
// Op returns the operation name.
|
|
func (m *DailyCategoryMutation) Op() Op {
|
|
return m.op
|
|
}
|
|
|
|
// SetOp allows setting the mutation operation.
|
|
func (m *DailyCategoryMutation) SetOp(op Op) {
|
|
m.op = op
|
|
}
|
|
|
|
// Type returns the node type of this mutation (DailyCategory).
|
|
func (m *DailyCategoryMutation) Type() string {
|
|
return m.typ
|
|
}
|
|
|
|
// Fields returns all fields that were changed during this mutation. Note that in
|
|
// order to get all numeric fields that were incremented/decremented, call
|
|
// AddedFields().
|
|
func (m *DailyCategoryMutation) Fields() []string {
|
|
fields := make([]string, 0, 2)
|
|
if m.created_at != nil {
|
|
fields = append(fields, dailycategory.FieldCreatedAt)
|
|
}
|
|
if m.updated_at != nil {
|
|
fields = append(fields, dailycategory.FieldUpdatedAt)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// Field returns the value of a field with the given name. The second boolean
|
|
// return value indicates that this field was not set, or was not defined in the
|
|
// schema.
|
|
func (m *DailyCategoryMutation) Field(name string) (ent.Value, bool) {
|
|
switch name {
|
|
case dailycategory.FieldCreatedAt:
|
|
return m.CreatedAt()
|
|
case dailycategory.FieldUpdatedAt:
|
|
return m.UpdatedAt()
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
// OldField returns the old value of the field from the database. An error is
|
|
// returned if the mutation operation is not UpdateOne, or the query to the
|
|
// database failed.
|
|
func (m *DailyCategoryMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
|
|
switch name {
|
|
case dailycategory.FieldCreatedAt:
|
|
return m.OldCreatedAt(ctx)
|
|
case dailycategory.FieldUpdatedAt:
|
|
return m.OldUpdatedAt(ctx)
|
|
}
|
|
return nil, fmt.Errorf("unknown DailyCategory field %s", name)
|
|
}
|
|
|
|
// SetField sets the value of a field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *DailyCategoryMutation) SetField(name string, value ent.Value) error {
|
|
switch name {
|
|
case dailycategory.FieldCreatedAt:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetCreatedAt(v)
|
|
return nil
|
|
case dailycategory.FieldUpdatedAt:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetUpdatedAt(v)
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown DailyCategory field %s", name)
|
|
}
|
|
|
|
// AddedFields returns all numeric fields that were incremented/decremented during
|
|
// this mutation.
|
|
func (m *DailyCategoryMutation) AddedFields() []string {
|
|
return nil
|
|
}
|
|
|
|
// AddedField returns the numeric value that was incremented/decremented on a field
|
|
// with the given name. The second boolean return value indicates that this field
|
|
// was not set, or was not defined in the schema.
|
|
func (m *DailyCategoryMutation) AddedField(name string) (ent.Value, bool) {
|
|
return nil, false
|
|
}
|
|
|
|
// AddField adds the value to the field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *DailyCategoryMutation) AddField(name string, value ent.Value) error {
|
|
switch name {
|
|
}
|
|
return fmt.Errorf("unknown DailyCategory numeric field %s", name)
|
|
}
|
|
|
|
// ClearedFields returns all nullable fields that were cleared during this
|
|
// mutation.
|
|
func (m *DailyCategoryMutation) ClearedFields() []string {
|
|
return nil
|
|
}
|
|
|
|
// FieldCleared returns a boolean indicating if a field with the given name was
|
|
// cleared in this mutation.
|
|
func (m *DailyCategoryMutation) FieldCleared(name string) bool {
|
|
_, ok := m.clearedFields[name]
|
|
return ok
|
|
}
|
|
|
|
// ClearField clears the value of the field with the given name. It returns an
|
|
// error if the field is not defined in the schema.
|
|
func (m *DailyCategoryMutation) ClearField(name string) error {
|
|
return fmt.Errorf("unknown DailyCategory nullable field %s", name)
|
|
}
|
|
|
|
// ResetField resets all changes in the mutation for the field with the given name.
|
|
// It returns an error if the field is not defined in the schema.
|
|
func (m *DailyCategoryMutation) ResetField(name string) error {
|
|
switch name {
|
|
case dailycategory.FieldCreatedAt:
|
|
m.ResetCreatedAt()
|
|
return nil
|
|
case dailycategory.FieldUpdatedAt:
|
|
m.ResetUpdatedAt()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown DailyCategory field %s", name)
|
|
}
|
|
|
|
// AddedEdges returns all edge names that were set/added in this mutation.
|
|
func (m *DailyCategoryMutation) AddedEdges() []string {
|
|
edges := make([]string, 0, 2)
|
|
if m.contents != nil {
|
|
edges = append(edges, dailycategory.EdgeContents)
|
|
}
|
|
if m.daily_items != nil {
|
|
edges = append(edges, dailycategory.EdgeDailyItems)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// AddedIDs returns all IDs (to other nodes) that were added for the given edge
|
|
// name in this mutation.
|
|
func (m *DailyCategoryMutation) AddedIDs(name string) []ent.Value {
|
|
switch name {
|
|
case dailycategory.EdgeContents:
|
|
ids := make([]ent.Value, 0, len(m.contents))
|
|
for id := range m.contents {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
case dailycategory.EdgeDailyItems:
|
|
ids := make([]ent.Value, 0, len(m.daily_items))
|
|
for id := range m.daily_items {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// RemovedEdges returns all edge names that were removed in this mutation.
|
|
func (m *DailyCategoryMutation) RemovedEdges() []string {
|
|
edges := make([]string, 0, 2)
|
|
if m.removedcontents != nil {
|
|
edges = append(edges, dailycategory.EdgeContents)
|
|
}
|
|
if m.removeddaily_items != nil {
|
|
edges = append(edges, dailycategory.EdgeDailyItems)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
|
|
// the given name in this mutation.
|
|
func (m *DailyCategoryMutation) RemovedIDs(name string) []ent.Value {
|
|
switch name {
|
|
case dailycategory.EdgeContents:
|
|
ids := make([]ent.Value, 0, len(m.removedcontents))
|
|
for id := range m.removedcontents {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
case dailycategory.EdgeDailyItems:
|
|
ids := make([]ent.Value, 0, len(m.removeddaily_items))
|
|
for id := range m.removeddaily_items {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// ClearedEdges returns all edge names that were cleared in this mutation.
|
|
func (m *DailyCategoryMutation) ClearedEdges() []string {
|
|
edges := make([]string, 0, 2)
|
|
if m.clearedcontents {
|
|
edges = append(edges, dailycategory.EdgeContents)
|
|
}
|
|
if m.cleareddaily_items {
|
|
edges = append(edges, dailycategory.EdgeDailyItems)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// EdgeCleared returns a boolean which indicates if the edge with the given name
|
|
// was cleared in this mutation.
|
|
func (m *DailyCategoryMutation) EdgeCleared(name string) bool {
|
|
switch name {
|
|
case dailycategory.EdgeContents:
|
|
return m.clearedcontents
|
|
case dailycategory.EdgeDailyItems:
|
|
return m.cleareddaily_items
|
|
}
|
|
return false
|
|
}
|
|
|
|
// ClearEdge clears the value of the edge with the given name. It returns an error
|
|
// if that edge is not defined in the schema.
|
|
func (m *DailyCategoryMutation) ClearEdge(name string) error {
|
|
switch name {
|
|
}
|
|
return fmt.Errorf("unknown DailyCategory unique edge %s", name)
|
|
}
|
|
|
|
// ResetEdge resets all changes to the edge with the given name in this mutation.
|
|
// It returns an error if the edge is not defined in the schema.
|
|
func (m *DailyCategoryMutation) ResetEdge(name string) error {
|
|
switch name {
|
|
case dailycategory.EdgeContents:
|
|
m.ResetContents()
|
|
return nil
|
|
case dailycategory.EdgeDailyItems:
|
|
m.ResetDailyItems()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown DailyCategory edge %s", name)
|
|
}
|
|
|
|
// DailyCategoryContentMutation represents an operation that mutates the DailyCategoryContent nodes in the graph.
|
|
type DailyCategoryContentMutation struct {
|
|
config
|
|
op Op
|
|
typ string
|
|
id *int
|
|
language_code *dailycategorycontent.LanguageCode
|
|
name *string
|
|
clearedFields map[string]struct{}
|
|
category *int
|
|
clearedcategory bool
|
|
done bool
|
|
oldValue func(context.Context) (*DailyCategoryContent, error)
|
|
predicates []predicate.DailyCategoryContent
|
|
}
|
|
|
|
var _ ent.Mutation = (*DailyCategoryContentMutation)(nil)
|
|
|
|
// dailycategorycontentOption allows management of the mutation configuration using functional options.
|
|
type dailycategorycontentOption func(*DailyCategoryContentMutation)
|
|
|
|
// newDailyCategoryContentMutation creates new mutation for the DailyCategoryContent entity.
|
|
func newDailyCategoryContentMutation(c config, op Op, opts ...dailycategorycontentOption) *DailyCategoryContentMutation {
|
|
m := &DailyCategoryContentMutation{
|
|
config: c,
|
|
op: op,
|
|
typ: TypeDailyCategoryContent,
|
|
clearedFields: make(map[string]struct{}),
|
|
}
|
|
for _, opt := range opts {
|
|
opt(m)
|
|
}
|
|
return m
|
|
}
|
|
|
|
// withDailyCategoryContentID sets the ID field of the mutation.
|
|
func withDailyCategoryContentID(id int) dailycategorycontentOption {
|
|
return func(m *DailyCategoryContentMutation) {
|
|
var (
|
|
err error
|
|
once sync.Once
|
|
value *DailyCategoryContent
|
|
)
|
|
m.oldValue = func(ctx context.Context) (*DailyCategoryContent, error) {
|
|
once.Do(func() {
|
|
if m.done {
|
|
err = errors.New("querying old values post mutation is not allowed")
|
|
} else {
|
|
value, err = m.Client().DailyCategoryContent.Get(ctx, id)
|
|
}
|
|
})
|
|
return value, err
|
|
}
|
|
m.id = &id
|
|
}
|
|
}
|
|
|
|
// withDailyCategoryContent sets the old DailyCategoryContent of the mutation.
|
|
func withDailyCategoryContent(node *DailyCategoryContent) dailycategorycontentOption {
|
|
return func(m *DailyCategoryContentMutation) {
|
|
m.oldValue = func(context.Context) (*DailyCategoryContent, error) {
|
|
return node, nil
|
|
}
|
|
m.id = &node.ID
|
|
}
|
|
}
|
|
|
|
// Client returns a new `ent.Client` from the mutation. If the mutation was
|
|
// executed in a transaction (ent.Tx), a transactional client is returned.
|
|
func (m DailyCategoryContentMutation) Client() *Client {
|
|
client := &Client{config: m.config}
|
|
client.init()
|
|
return client
|
|
}
|
|
|
|
// Tx returns an `ent.Tx` for mutations that were executed in transactions;
|
|
// it returns an error otherwise.
|
|
func (m DailyCategoryContentMutation) Tx() (*Tx, error) {
|
|
if _, ok := m.driver.(*txDriver); !ok {
|
|
return nil, errors.New("ent: mutation is not running in a transaction")
|
|
}
|
|
tx := &Tx{config: m.config}
|
|
tx.init()
|
|
return tx, nil
|
|
}
|
|
|
|
// ID returns the ID value in the mutation. Note that the ID is only available
|
|
// if it was provided to the builder or after it was returned from the database.
|
|
func (m *DailyCategoryContentMutation) ID() (id int, exists bool) {
|
|
if m.id == nil {
|
|
return
|
|
}
|
|
return *m.id, true
|
|
}
|
|
|
|
// IDs queries the database and returns the entity ids that match the mutation's predicate.
|
|
// That means, if the mutation is applied within a transaction with an isolation level such
|
|
// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
|
|
// or updated by the mutation.
|
|
func (m *DailyCategoryContentMutation) IDs(ctx context.Context) ([]int, error) {
|
|
switch {
|
|
case m.op.Is(OpUpdateOne | OpDeleteOne):
|
|
id, exists := m.ID()
|
|
if exists {
|
|
return []int{id}, nil
|
|
}
|
|
fallthrough
|
|
case m.op.Is(OpUpdate | OpDelete):
|
|
return m.Client().DailyCategoryContent.Query().Where(m.predicates...).IDs(ctx)
|
|
default:
|
|
return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
|
|
}
|
|
}
|
|
|
|
// SetLanguageCode sets the "language_code" field.
|
|
func (m *DailyCategoryContentMutation) SetLanguageCode(dc dailycategorycontent.LanguageCode) {
|
|
m.language_code = &dc
|
|
}
|
|
|
|
// LanguageCode returns the value of the "language_code" field in the mutation.
|
|
func (m *DailyCategoryContentMutation) LanguageCode() (r dailycategorycontent.LanguageCode, exists bool) {
|
|
v := m.language_code
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldLanguageCode returns the old "language_code" field's value of the DailyCategoryContent entity.
|
|
// If the DailyCategoryContent object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *DailyCategoryContentMutation) OldLanguageCode(ctx context.Context) (v dailycategorycontent.LanguageCode, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldLanguageCode is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldLanguageCode requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldLanguageCode: %w", err)
|
|
}
|
|
return oldValue.LanguageCode, nil
|
|
}
|
|
|
|
// ResetLanguageCode resets all changes to the "language_code" field.
|
|
func (m *DailyCategoryContentMutation) ResetLanguageCode() {
|
|
m.language_code = nil
|
|
}
|
|
|
|
// SetName sets the "name" field.
|
|
func (m *DailyCategoryContentMutation) SetName(s string) {
|
|
m.name = &s
|
|
}
|
|
|
|
// Name returns the value of the "name" field in the mutation.
|
|
func (m *DailyCategoryContentMutation) Name() (r string, exists bool) {
|
|
v := m.name
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldName returns the old "name" field's value of the DailyCategoryContent entity.
|
|
// If the DailyCategoryContent object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *DailyCategoryContentMutation) OldName(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldName is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldName requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldName: %w", err)
|
|
}
|
|
return oldValue.Name, nil
|
|
}
|
|
|
|
// ResetName resets all changes to the "name" field.
|
|
func (m *DailyCategoryContentMutation) ResetName() {
|
|
m.name = nil
|
|
}
|
|
|
|
// SetCategoryID sets the "category" edge to the DailyCategory entity by id.
|
|
func (m *DailyCategoryContentMutation) SetCategoryID(id int) {
|
|
m.category = &id
|
|
}
|
|
|
|
// ClearCategory clears the "category" edge to the DailyCategory entity.
|
|
func (m *DailyCategoryContentMutation) ClearCategory() {
|
|
m.clearedcategory = true
|
|
}
|
|
|
|
// CategoryCleared reports if the "category" edge to the DailyCategory entity was cleared.
|
|
func (m *DailyCategoryContentMutation) CategoryCleared() bool {
|
|
return m.clearedcategory
|
|
}
|
|
|
|
// CategoryID returns the "category" edge ID in the mutation.
|
|
func (m *DailyCategoryContentMutation) CategoryID() (id int, exists bool) {
|
|
if m.category != nil {
|
|
return *m.category, true
|
|
}
|
|
return
|
|
}
|
|
|
|
// CategoryIDs returns the "category" edge IDs in the mutation.
|
|
// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
|
|
// CategoryID instead. It exists only for internal usage by the builders.
|
|
func (m *DailyCategoryContentMutation) CategoryIDs() (ids []int) {
|
|
if id := m.category; id != nil {
|
|
ids = append(ids, *id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetCategory resets all changes to the "category" edge.
|
|
func (m *DailyCategoryContentMutation) ResetCategory() {
|
|
m.category = nil
|
|
m.clearedcategory = false
|
|
}
|
|
|
|
// Where appends a list predicates to the DailyCategoryContentMutation builder.
|
|
func (m *DailyCategoryContentMutation) Where(ps ...predicate.DailyCategoryContent) {
|
|
m.predicates = append(m.predicates, ps...)
|
|
}
|
|
|
|
// WhereP appends storage-level predicates to the DailyCategoryContentMutation builder. Using this method,
|
|
// users can use type-assertion to append predicates that do not depend on any generated package.
|
|
func (m *DailyCategoryContentMutation) WhereP(ps ...func(*sql.Selector)) {
|
|
p := make([]predicate.DailyCategoryContent, len(ps))
|
|
for i := range ps {
|
|
p[i] = ps[i]
|
|
}
|
|
m.Where(p...)
|
|
}
|
|
|
|
// Op returns the operation name.
|
|
func (m *DailyCategoryContentMutation) Op() Op {
|
|
return m.op
|
|
}
|
|
|
|
// SetOp allows setting the mutation operation.
|
|
func (m *DailyCategoryContentMutation) SetOp(op Op) {
|
|
m.op = op
|
|
}
|
|
|
|
// Type returns the node type of this mutation (DailyCategoryContent).
|
|
func (m *DailyCategoryContentMutation) Type() string {
|
|
return m.typ
|
|
}
|
|
|
|
// Fields returns all fields that were changed during this mutation. Note that in
|
|
// order to get all numeric fields that were incremented/decremented, call
|
|
// AddedFields().
|
|
func (m *DailyCategoryContentMutation) Fields() []string {
|
|
fields := make([]string, 0, 2)
|
|
if m.language_code != nil {
|
|
fields = append(fields, dailycategorycontent.FieldLanguageCode)
|
|
}
|
|
if m.name != nil {
|
|
fields = append(fields, dailycategorycontent.FieldName)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// Field returns the value of a field with the given name. The second boolean
|
|
// return value indicates that this field was not set, or was not defined in the
|
|
// schema.
|
|
func (m *DailyCategoryContentMutation) Field(name string) (ent.Value, bool) {
|
|
switch name {
|
|
case dailycategorycontent.FieldLanguageCode:
|
|
return m.LanguageCode()
|
|
case dailycategorycontent.FieldName:
|
|
return m.Name()
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
// OldField returns the old value of the field from the database. An error is
|
|
// returned if the mutation operation is not UpdateOne, or the query to the
|
|
// database failed.
|
|
func (m *DailyCategoryContentMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
|
|
switch name {
|
|
case dailycategorycontent.FieldLanguageCode:
|
|
return m.OldLanguageCode(ctx)
|
|
case dailycategorycontent.FieldName:
|
|
return m.OldName(ctx)
|
|
}
|
|
return nil, fmt.Errorf("unknown DailyCategoryContent field %s", name)
|
|
}
|
|
|
|
// SetField sets the value of a field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *DailyCategoryContentMutation) SetField(name string, value ent.Value) error {
|
|
switch name {
|
|
case dailycategorycontent.FieldLanguageCode:
|
|
v, ok := value.(dailycategorycontent.LanguageCode)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetLanguageCode(v)
|
|
return nil
|
|
case dailycategorycontent.FieldName:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetName(v)
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown DailyCategoryContent field %s", name)
|
|
}
|
|
|
|
// AddedFields returns all numeric fields that were incremented/decremented during
|
|
// this mutation.
|
|
func (m *DailyCategoryContentMutation) AddedFields() []string {
|
|
return nil
|
|
}
|
|
|
|
// AddedField returns the numeric value that was incremented/decremented on a field
|
|
// with the given name. The second boolean return value indicates that this field
|
|
// was not set, or was not defined in the schema.
|
|
func (m *DailyCategoryContentMutation) AddedField(name string) (ent.Value, bool) {
|
|
return nil, false
|
|
}
|
|
|
|
// AddField adds the value to the field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *DailyCategoryContentMutation) AddField(name string, value ent.Value) error {
|
|
switch name {
|
|
}
|
|
return fmt.Errorf("unknown DailyCategoryContent numeric field %s", name)
|
|
}
|
|
|
|
// ClearedFields returns all nullable fields that were cleared during this
|
|
// mutation.
|
|
func (m *DailyCategoryContentMutation) ClearedFields() []string {
|
|
return nil
|
|
}
|
|
|
|
// FieldCleared returns a boolean indicating if a field with the given name was
|
|
// cleared in this mutation.
|
|
func (m *DailyCategoryContentMutation) FieldCleared(name string) bool {
|
|
_, ok := m.clearedFields[name]
|
|
return ok
|
|
}
|
|
|
|
// ClearField clears the value of the field with the given name. It returns an
|
|
// error if the field is not defined in the schema.
|
|
func (m *DailyCategoryContentMutation) ClearField(name string) error {
|
|
return fmt.Errorf("unknown DailyCategoryContent nullable field %s", name)
|
|
}
|
|
|
|
// ResetField resets all changes in the mutation for the field with the given name.
|
|
// It returns an error if the field is not defined in the schema.
|
|
func (m *DailyCategoryContentMutation) ResetField(name string) error {
|
|
switch name {
|
|
case dailycategorycontent.FieldLanguageCode:
|
|
m.ResetLanguageCode()
|
|
return nil
|
|
case dailycategorycontent.FieldName:
|
|
m.ResetName()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown DailyCategoryContent field %s", name)
|
|
}
|
|
|
|
// AddedEdges returns all edge names that were set/added in this mutation.
|
|
func (m *DailyCategoryContentMutation) AddedEdges() []string {
|
|
edges := make([]string, 0, 1)
|
|
if m.category != nil {
|
|
edges = append(edges, dailycategorycontent.EdgeCategory)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// AddedIDs returns all IDs (to other nodes) that were added for the given edge
|
|
// name in this mutation.
|
|
func (m *DailyCategoryContentMutation) AddedIDs(name string) []ent.Value {
|
|
switch name {
|
|
case dailycategorycontent.EdgeCategory:
|
|
if id := m.category; id != nil {
|
|
return []ent.Value{*id}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// RemovedEdges returns all edge names that were removed in this mutation.
|
|
func (m *DailyCategoryContentMutation) RemovedEdges() []string {
|
|
edges := make([]string, 0, 1)
|
|
return edges
|
|
}
|
|
|
|
// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
|
|
// the given name in this mutation.
|
|
func (m *DailyCategoryContentMutation) RemovedIDs(name string) []ent.Value {
|
|
return nil
|
|
}
|
|
|
|
// ClearedEdges returns all edge names that were cleared in this mutation.
|
|
func (m *DailyCategoryContentMutation) ClearedEdges() []string {
|
|
edges := make([]string, 0, 1)
|
|
if m.clearedcategory {
|
|
edges = append(edges, dailycategorycontent.EdgeCategory)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// EdgeCleared returns a boolean which indicates if the edge with the given name
|
|
// was cleared in this mutation.
|
|
func (m *DailyCategoryContentMutation) EdgeCleared(name string) bool {
|
|
switch name {
|
|
case dailycategorycontent.EdgeCategory:
|
|
return m.clearedcategory
|
|
}
|
|
return false
|
|
}
|
|
|
|
// ClearEdge clears the value of the edge with the given name. It returns an error
|
|
// if that edge is not defined in the schema.
|
|
func (m *DailyCategoryContentMutation) ClearEdge(name string) error {
|
|
switch name {
|
|
case dailycategorycontent.EdgeCategory:
|
|
m.ClearCategory()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown DailyCategoryContent unique edge %s", name)
|
|
}
|
|
|
|
// ResetEdge resets all changes to the edge with the given name in this mutation.
|
|
// It returns an error if the edge is not defined in the schema.
|
|
func (m *DailyCategoryContentMutation) ResetEdge(name string) error {
|
|
switch name {
|
|
case dailycategorycontent.EdgeCategory:
|
|
m.ResetCategory()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown DailyCategoryContent edge %s", name)
|
|
}
|
|
|
|
// DailyContentMutation represents an operation that mutates the DailyContent nodes in the graph.
|
|
type DailyContentMutation struct {
|
|
config
|
|
op Op
|
|
typ string
|
|
id *int
|
|
language_code *dailycontent.LanguageCode
|
|
quote *string
|
|
clearedFields map[string]struct{}
|
|
daily *string
|
|
cleareddaily bool
|
|
done bool
|
|
oldValue func(context.Context) (*DailyContent, error)
|
|
predicates []predicate.DailyContent
|
|
}
|
|
|
|
var _ ent.Mutation = (*DailyContentMutation)(nil)
|
|
|
|
// dailycontentOption allows management of the mutation configuration using functional options.
|
|
type dailycontentOption func(*DailyContentMutation)
|
|
|
|
// newDailyContentMutation creates new mutation for the DailyContent entity.
|
|
func newDailyContentMutation(c config, op Op, opts ...dailycontentOption) *DailyContentMutation {
|
|
m := &DailyContentMutation{
|
|
config: c,
|
|
op: op,
|
|
typ: TypeDailyContent,
|
|
clearedFields: make(map[string]struct{}),
|
|
}
|
|
for _, opt := range opts {
|
|
opt(m)
|
|
}
|
|
return m
|
|
}
|
|
|
|
// withDailyContentID sets the ID field of the mutation.
|
|
func withDailyContentID(id int) dailycontentOption {
|
|
return func(m *DailyContentMutation) {
|
|
var (
|
|
err error
|
|
once sync.Once
|
|
value *DailyContent
|
|
)
|
|
m.oldValue = func(ctx context.Context) (*DailyContent, error) {
|
|
once.Do(func() {
|
|
if m.done {
|
|
err = errors.New("querying old values post mutation is not allowed")
|
|
} else {
|
|
value, err = m.Client().DailyContent.Get(ctx, id)
|
|
}
|
|
})
|
|
return value, err
|
|
}
|
|
m.id = &id
|
|
}
|
|
}
|
|
|
|
// withDailyContent sets the old DailyContent of the mutation.
|
|
func withDailyContent(node *DailyContent) dailycontentOption {
|
|
return func(m *DailyContentMutation) {
|
|
m.oldValue = func(context.Context) (*DailyContent, error) {
|
|
return node, nil
|
|
}
|
|
m.id = &node.ID
|
|
}
|
|
}
|
|
|
|
// Client returns a new `ent.Client` from the mutation. If the mutation was
|
|
// executed in a transaction (ent.Tx), a transactional client is returned.
|
|
func (m DailyContentMutation) Client() *Client {
|
|
client := &Client{config: m.config}
|
|
client.init()
|
|
return client
|
|
}
|
|
|
|
// Tx returns an `ent.Tx` for mutations that were executed in transactions;
|
|
// it returns an error otherwise.
|
|
func (m DailyContentMutation) Tx() (*Tx, error) {
|
|
if _, ok := m.driver.(*txDriver); !ok {
|
|
return nil, errors.New("ent: mutation is not running in a transaction")
|
|
}
|
|
tx := &Tx{config: m.config}
|
|
tx.init()
|
|
return tx, nil
|
|
}
|
|
|
|
// ID returns the ID value in the mutation. Note that the ID is only available
|
|
// if it was provided to the builder or after it was returned from the database.
|
|
func (m *DailyContentMutation) ID() (id int, exists bool) {
|
|
if m.id == nil {
|
|
return
|
|
}
|
|
return *m.id, true
|
|
}
|
|
|
|
// IDs queries the database and returns the entity ids that match the mutation's predicate.
|
|
// That means, if the mutation is applied within a transaction with an isolation level such
|
|
// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
|
|
// or updated by the mutation.
|
|
func (m *DailyContentMutation) IDs(ctx context.Context) ([]int, error) {
|
|
switch {
|
|
case m.op.Is(OpUpdateOne | OpDeleteOne):
|
|
id, exists := m.ID()
|
|
if exists {
|
|
return []int{id}, nil
|
|
}
|
|
fallthrough
|
|
case m.op.Is(OpUpdate | OpDelete):
|
|
return m.Client().DailyContent.Query().Where(m.predicates...).IDs(ctx)
|
|
default:
|
|
return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
|
|
}
|
|
}
|
|
|
|
// SetLanguageCode sets the "language_code" field.
|
|
func (m *DailyContentMutation) SetLanguageCode(dc dailycontent.LanguageCode) {
|
|
m.language_code = &dc
|
|
}
|
|
|
|
// LanguageCode returns the value of the "language_code" field in the mutation.
|
|
func (m *DailyContentMutation) LanguageCode() (r dailycontent.LanguageCode, exists bool) {
|
|
v := m.language_code
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldLanguageCode returns the old "language_code" field's value of the DailyContent entity.
|
|
// If the DailyContent object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *DailyContentMutation) OldLanguageCode(ctx context.Context) (v dailycontent.LanguageCode, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldLanguageCode is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldLanguageCode requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldLanguageCode: %w", err)
|
|
}
|
|
return oldValue.LanguageCode, nil
|
|
}
|
|
|
|
// ResetLanguageCode resets all changes to the "language_code" field.
|
|
func (m *DailyContentMutation) ResetLanguageCode() {
|
|
m.language_code = nil
|
|
}
|
|
|
|
// SetQuote sets the "quote" field.
|
|
func (m *DailyContentMutation) SetQuote(s string) {
|
|
m.quote = &s
|
|
}
|
|
|
|
// Quote returns the value of the "quote" field in the mutation.
|
|
func (m *DailyContentMutation) Quote() (r string, exists bool) {
|
|
v := m.quote
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldQuote returns the old "quote" field's value of the DailyContent entity.
|
|
// If the DailyContent object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *DailyContentMutation) OldQuote(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldQuote is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldQuote requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldQuote: %w", err)
|
|
}
|
|
return oldValue.Quote, nil
|
|
}
|
|
|
|
// ResetQuote resets all changes to the "quote" field.
|
|
func (m *DailyContentMutation) ResetQuote() {
|
|
m.quote = nil
|
|
}
|
|
|
|
// SetDailyID sets the "daily" edge to the Daily entity by id.
|
|
func (m *DailyContentMutation) SetDailyID(id string) {
|
|
m.daily = &id
|
|
}
|
|
|
|
// ClearDaily clears the "daily" edge to the Daily entity.
|
|
func (m *DailyContentMutation) ClearDaily() {
|
|
m.cleareddaily = true
|
|
}
|
|
|
|
// DailyCleared reports if the "daily" edge to the Daily entity was cleared.
|
|
func (m *DailyContentMutation) DailyCleared() bool {
|
|
return m.cleareddaily
|
|
}
|
|
|
|
// DailyID returns the "daily" edge ID in the mutation.
|
|
func (m *DailyContentMutation) DailyID() (id string, exists bool) {
|
|
if m.daily != nil {
|
|
return *m.daily, true
|
|
}
|
|
return
|
|
}
|
|
|
|
// DailyIDs returns the "daily" edge IDs in the mutation.
|
|
// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
|
|
// DailyID instead. It exists only for internal usage by the builders.
|
|
func (m *DailyContentMutation) DailyIDs() (ids []string) {
|
|
if id := m.daily; id != nil {
|
|
ids = append(ids, *id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetDaily resets all changes to the "daily" edge.
|
|
func (m *DailyContentMutation) ResetDaily() {
|
|
m.daily = nil
|
|
m.cleareddaily = false
|
|
}
|
|
|
|
// Where appends a list predicates to the DailyContentMutation builder.
|
|
func (m *DailyContentMutation) Where(ps ...predicate.DailyContent) {
|
|
m.predicates = append(m.predicates, ps...)
|
|
}
|
|
|
|
// WhereP appends storage-level predicates to the DailyContentMutation builder. Using this method,
|
|
// users can use type-assertion to append predicates that do not depend on any generated package.
|
|
func (m *DailyContentMutation) WhereP(ps ...func(*sql.Selector)) {
|
|
p := make([]predicate.DailyContent, len(ps))
|
|
for i := range ps {
|
|
p[i] = ps[i]
|
|
}
|
|
m.Where(p...)
|
|
}
|
|
|
|
// Op returns the operation name.
|
|
func (m *DailyContentMutation) Op() Op {
|
|
return m.op
|
|
}
|
|
|
|
// SetOp allows setting the mutation operation.
|
|
func (m *DailyContentMutation) SetOp(op Op) {
|
|
m.op = op
|
|
}
|
|
|
|
// Type returns the node type of this mutation (DailyContent).
|
|
func (m *DailyContentMutation) Type() string {
|
|
return m.typ
|
|
}
|
|
|
|
// Fields returns all fields that were changed during this mutation. Note that in
|
|
// order to get all numeric fields that were incremented/decremented, call
|
|
// AddedFields().
|
|
func (m *DailyContentMutation) Fields() []string {
|
|
fields := make([]string, 0, 2)
|
|
if m.language_code != nil {
|
|
fields = append(fields, dailycontent.FieldLanguageCode)
|
|
}
|
|
if m.quote != nil {
|
|
fields = append(fields, dailycontent.FieldQuote)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// Field returns the value of a field with the given name. The second boolean
|
|
// return value indicates that this field was not set, or was not defined in the
|
|
// schema.
|
|
func (m *DailyContentMutation) Field(name string) (ent.Value, bool) {
|
|
switch name {
|
|
case dailycontent.FieldLanguageCode:
|
|
return m.LanguageCode()
|
|
case dailycontent.FieldQuote:
|
|
return m.Quote()
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
// OldField returns the old value of the field from the database. An error is
|
|
// returned if the mutation operation is not UpdateOne, or the query to the
|
|
// database failed.
|
|
func (m *DailyContentMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
|
|
switch name {
|
|
case dailycontent.FieldLanguageCode:
|
|
return m.OldLanguageCode(ctx)
|
|
case dailycontent.FieldQuote:
|
|
return m.OldQuote(ctx)
|
|
}
|
|
return nil, fmt.Errorf("unknown DailyContent field %s", name)
|
|
}
|
|
|
|
// SetField sets the value of a field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *DailyContentMutation) SetField(name string, value ent.Value) error {
|
|
switch name {
|
|
case dailycontent.FieldLanguageCode:
|
|
v, ok := value.(dailycontent.LanguageCode)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetLanguageCode(v)
|
|
return nil
|
|
case dailycontent.FieldQuote:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetQuote(v)
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown DailyContent field %s", name)
|
|
}
|
|
|
|
// AddedFields returns all numeric fields that were incremented/decremented during
|
|
// this mutation.
|
|
func (m *DailyContentMutation) AddedFields() []string {
|
|
return nil
|
|
}
|
|
|
|
// AddedField returns the numeric value that was incremented/decremented on a field
|
|
// with the given name. The second boolean return value indicates that this field
|
|
// was not set, or was not defined in the schema.
|
|
func (m *DailyContentMutation) AddedField(name string) (ent.Value, bool) {
|
|
return nil, false
|
|
}
|
|
|
|
// AddField adds the value to the field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *DailyContentMutation) AddField(name string, value ent.Value) error {
|
|
switch name {
|
|
}
|
|
return fmt.Errorf("unknown DailyContent numeric field %s", name)
|
|
}
|
|
|
|
// ClearedFields returns all nullable fields that were cleared during this
|
|
// mutation.
|
|
func (m *DailyContentMutation) ClearedFields() []string {
|
|
return nil
|
|
}
|
|
|
|
// FieldCleared returns a boolean indicating if a field with the given name was
|
|
// cleared in this mutation.
|
|
func (m *DailyContentMutation) FieldCleared(name string) bool {
|
|
_, ok := m.clearedFields[name]
|
|
return ok
|
|
}
|
|
|
|
// ClearField clears the value of the field with the given name. It returns an
|
|
// error if the field is not defined in the schema.
|
|
func (m *DailyContentMutation) ClearField(name string) error {
|
|
return fmt.Errorf("unknown DailyContent nullable field %s", name)
|
|
}
|
|
|
|
// ResetField resets all changes in the mutation for the field with the given name.
|
|
// It returns an error if the field is not defined in the schema.
|
|
func (m *DailyContentMutation) ResetField(name string) error {
|
|
switch name {
|
|
case dailycontent.FieldLanguageCode:
|
|
m.ResetLanguageCode()
|
|
return nil
|
|
case dailycontent.FieldQuote:
|
|
m.ResetQuote()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown DailyContent field %s", name)
|
|
}
|
|
|
|
// AddedEdges returns all edge names that were set/added in this mutation.
|
|
func (m *DailyContentMutation) AddedEdges() []string {
|
|
edges := make([]string, 0, 1)
|
|
if m.daily != nil {
|
|
edges = append(edges, dailycontent.EdgeDaily)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// AddedIDs returns all IDs (to other nodes) that were added for the given edge
|
|
// name in this mutation.
|
|
func (m *DailyContentMutation) AddedIDs(name string) []ent.Value {
|
|
switch name {
|
|
case dailycontent.EdgeDaily:
|
|
if id := m.daily; id != nil {
|
|
return []ent.Value{*id}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// RemovedEdges returns all edge names that were removed in this mutation.
|
|
func (m *DailyContentMutation) RemovedEdges() []string {
|
|
edges := make([]string, 0, 1)
|
|
return edges
|
|
}
|
|
|
|
// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
|
|
// the given name in this mutation.
|
|
func (m *DailyContentMutation) RemovedIDs(name string) []ent.Value {
|
|
return nil
|
|
}
|
|
|
|
// ClearedEdges returns all edge names that were cleared in this mutation.
|
|
func (m *DailyContentMutation) ClearedEdges() []string {
|
|
edges := make([]string, 0, 1)
|
|
if m.cleareddaily {
|
|
edges = append(edges, dailycontent.EdgeDaily)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// EdgeCleared returns a boolean which indicates if the edge with the given name
|
|
// was cleared in this mutation.
|
|
func (m *DailyContentMutation) EdgeCleared(name string) bool {
|
|
switch name {
|
|
case dailycontent.EdgeDaily:
|
|
return m.cleareddaily
|
|
}
|
|
return false
|
|
}
|
|
|
|
// ClearEdge clears the value of the edge with the given name. It returns an error
|
|
// if that edge is not defined in the schema.
|
|
func (m *DailyContentMutation) ClearEdge(name string) error {
|
|
switch name {
|
|
case dailycontent.EdgeDaily:
|
|
m.ClearDaily()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown DailyContent unique edge %s", name)
|
|
}
|
|
|
|
// ResetEdge resets all changes to the edge with the given name in this mutation.
|
|
// It returns an error if the edge is not defined in the schema.
|
|
func (m *DailyContentMutation) ResetEdge(name string) error {
|
|
switch name {
|
|
case dailycontent.EdgeDaily:
|
|
m.ResetDaily()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown DailyContent edge %s", name)
|
|
}
|
|
|
|
// MediaMutation represents an operation that mutates the Media nodes in the graph.
|
|
type MediaMutation struct {
|
|
config
|
|
op Op
|
|
typ string
|
|
id *int
|
|
storage_id *string
|
|
original_name *string
|
|
mime_type *string
|
|
size *int64
|
|
addsize *int64
|
|
url *string
|
|
created_at *time.Time
|
|
updated_at *time.Time
|
|
created_by *string
|
|
clearedFields map[string]struct{}
|
|
owner *int
|
|
clearedowner bool
|
|
done bool
|
|
oldValue func(context.Context) (*Media, error)
|
|
predicates []predicate.Media
|
|
}
|
|
|
|
var _ ent.Mutation = (*MediaMutation)(nil)
|
|
|
|
// mediaOption allows management of the mutation configuration using functional options.
|
|
type mediaOption func(*MediaMutation)
|
|
|
|
// newMediaMutation creates new mutation for the Media entity.
|
|
func newMediaMutation(c config, op Op, opts ...mediaOption) *MediaMutation {
|
|
m := &MediaMutation{
|
|
config: c,
|
|
op: op,
|
|
typ: TypeMedia,
|
|
clearedFields: make(map[string]struct{}),
|
|
}
|
|
for _, opt := range opts {
|
|
opt(m)
|
|
}
|
|
return m
|
|
}
|
|
|
|
// withMediaID sets the ID field of the mutation.
|
|
func withMediaID(id int) mediaOption {
|
|
return func(m *MediaMutation) {
|
|
var (
|
|
err error
|
|
once sync.Once
|
|
value *Media
|
|
)
|
|
m.oldValue = func(ctx context.Context) (*Media, error) {
|
|
once.Do(func() {
|
|
if m.done {
|
|
err = errors.New("querying old values post mutation is not allowed")
|
|
} else {
|
|
value, err = m.Client().Media.Get(ctx, id)
|
|
}
|
|
})
|
|
return value, err
|
|
}
|
|
m.id = &id
|
|
}
|
|
}
|
|
|
|
// withMedia sets the old Media of the mutation.
|
|
func withMedia(node *Media) mediaOption {
|
|
return func(m *MediaMutation) {
|
|
m.oldValue = func(context.Context) (*Media, error) {
|
|
return node, nil
|
|
}
|
|
m.id = &node.ID
|
|
}
|
|
}
|
|
|
|
// Client returns a new `ent.Client` from the mutation. If the mutation was
|
|
// executed in a transaction (ent.Tx), a transactional client is returned.
|
|
func (m MediaMutation) Client() *Client {
|
|
client := &Client{config: m.config}
|
|
client.init()
|
|
return client
|
|
}
|
|
|
|
// Tx returns an `ent.Tx` for mutations that were executed in transactions;
|
|
// it returns an error otherwise.
|
|
func (m MediaMutation) Tx() (*Tx, error) {
|
|
if _, ok := m.driver.(*txDriver); !ok {
|
|
return nil, errors.New("ent: mutation is not running in a transaction")
|
|
}
|
|
tx := &Tx{config: m.config}
|
|
tx.init()
|
|
return tx, nil
|
|
}
|
|
|
|
// ID returns the ID value in the mutation. Note that the ID is only available
|
|
// if it was provided to the builder or after it was returned from the database.
|
|
func (m *MediaMutation) ID() (id int, exists bool) {
|
|
if m.id == nil {
|
|
return
|
|
}
|
|
return *m.id, true
|
|
}
|
|
|
|
// IDs queries the database and returns the entity ids that match the mutation's predicate.
|
|
// That means, if the mutation is applied within a transaction with an isolation level such
|
|
// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
|
|
// or updated by the mutation.
|
|
func (m *MediaMutation) IDs(ctx context.Context) ([]int, error) {
|
|
switch {
|
|
case m.op.Is(OpUpdateOne | OpDeleteOne):
|
|
id, exists := m.ID()
|
|
if exists {
|
|
return []int{id}, nil
|
|
}
|
|
fallthrough
|
|
case m.op.Is(OpUpdate | OpDelete):
|
|
return m.Client().Media.Query().Where(m.predicates...).IDs(ctx)
|
|
default:
|
|
return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
|
|
}
|
|
}
|
|
|
|
// SetStorageID sets the "storage_id" field.
|
|
func (m *MediaMutation) SetStorageID(s string) {
|
|
m.storage_id = &s
|
|
}
|
|
|
|
// StorageID returns the value of the "storage_id" field in the mutation.
|
|
func (m *MediaMutation) StorageID() (r string, exists bool) {
|
|
v := m.storage_id
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldStorageID returns the old "storage_id" field's value of the Media entity.
|
|
// If the Media object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *MediaMutation) OldStorageID(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldStorageID is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldStorageID requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldStorageID: %w", err)
|
|
}
|
|
return oldValue.StorageID, nil
|
|
}
|
|
|
|
// ResetStorageID resets all changes to the "storage_id" field.
|
|
func (m *MediaMutation) ResetStorageID() {
|
|
m.storage_id = nil
|
|
}
|
|
|
|
// SetOriginalName sets the "original_name" field.
|
|
func (m *MediaMutation) SetOriginalName(s string) {
|
|
m.original_name = &s
|
|
}
|
|
|
|
// OriginalName returns the value of the "original_name" field in the mutation.
|
|
func (m *MediaMutation) OriginalName() (r string, exists bool) {
|
|
v := m.original_name
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldOriginalName returns the old "original_name" field's value of the Media entity.
|
|
// If the Media object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *MediaMutation) OldOriginalName(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldOriginalName is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldOriginalName requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldOriginalName: %w", err)
|
|
}
|
|
return oldValue.OriginalName, nil
|
|
}
|
|
|
|
// ResetOriginalName resets all changes to the "original_name" field.
|
|
func (m *MediaMutation) ResetOriginalName() {
|
|
m.original_name = nil
|
|
}
|
|
|
|
// SetMimeType sets the "mime_type" field.
|
|
func (m *MediaMutation) SetMimeType(s string) {
|
|
m.mime_type = &s
|
|
}
|
|
|
|
// MimeType returns the value of the "mime_type" field in the mutation.
|
|
func (m *MediaMutation) MimeType() (r string, exists bool) {
|
|
v := m.mime_type
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldMimeType returns the old "mime_type" field's value of the Media entity.
|
|
// If the Media object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *MediaMutation) OldMimeType(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldMimeType is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldMimeType requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldMimeType: %w", err)
|
|
}
|
|
return oldValue.MimeType, nil
|
|
}
|
|
|
|
// ResetMimeType resets all changes to the "mime_type" field.
|
|
func (m *MediaMutation) ResetMimeType() {
|
|
m.mime_type = nil
|
|
}
|
|
|
|
// SetSize sets the "size" field.
|
|
func (m *MediaMutation) SetSize(i int64) {
|
|
m.size = &i
|
|
m.addsize = nil
|
|
}
|
|
|
|
// Size returns the value of the "size" field in the mutation.
|
|
func (m *MediaMutation) Size() (r int64, exists bool) {
|
|
v := m.size
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldSize returns the old "size" field's value of the Media entity.
|
|
// If the Media object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *MediaMutation) OldSize(ctx context.Context) (v int64, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldSize is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldSize requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldSize: %w", err)
|
|
}
|
|
return oldValue.Size, nil
|
|
}
|
|
|
|
// AddSize adds i to the "size" field.
|
|
func (m *MediaMutation) AddSize(i int64) {
|
|
if m.addsize != nil {
|
|
*m.addsize += i
|
|
} else {
|
|
m.addsize = &i
|
|
}
|
|
}
|
|
|
|
// AddedSize returns the value that was added to the "size" field in this mutation.
|
|
func (m *MediaMutation) AddedSize() (r int64, exists bool) {
|
|
v := m.addsize
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// ResetSize resets all changes to the "size" field.
|
|
func (m *MediaMutation) ResetSize() {
|
|
m.size = nil
|
|
m.addsize = nil
|
|
}
|
|
|
|
// SetURL sets the "url" field.
|
|
func (m *MediaMutation) SetURL(s string) {
|
|
m.url = &s
|
|
}
|
|
|
|
// URL returns the value of the "url" field in the mutation.
|
|
func (m *MediaMutation) URL() (r string, exists bool) {
|
|
v := m.url
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldURL returns the old "url" field's value of the Media entity.
|
|
// If the Media object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *MediaMutation) OldURL(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldURL is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldURL requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldURL: %w", err)
|
|
}
|
|
return oldValue.URL, nil
|
|
}
|
|
|
|
// ResetURL resets all changes to the "url" field.
|
|
func (m *MediaMutation) ResetURL() {
|
|
m.url = nil
|
|
}
|
|
|
|
// SetCreatedAt sets the "created_at" field.
|
|
func (m *MediaMutation) SetCreatedAt(t time.Time) {
|
|
m.created_at = &t
|
|
}
|
|
|
|
// CreatedAt returns the value of the "created_at" field in the mutation.
|
|
func (m *MediaMutation) CreatedAt() (r time.Time, exists bool) {
|
|
v := m.created_at
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldCreatedAt returns the old "created_at" field's value of the Media entity.
|
|
// If the Media object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *MediaMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldCreatedAt requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
|
|
}
|
|
return oldValue.CreatedAt, nil
|
|
}
|
|
|
|
// ResetCreatedAt resets all changes to the "created_at" field.
|
|
func (m *MediaMutation) ResetCreatedAt() {
|
|
m.created_at = nil
|
|
}
|
|
|
|
// SetUpdatedAt sets the "updated_at" field.
|
|
func (m *MediaMutation) SetUpdatedAt(t time.Time) {
|
|
m.updated_at = &t
|
|
}
|
|
|
|
// UpdatedAt returns the value of the "updated_at" field in the mutation.
|
|
func (m *MediaMutation) UpdatedAt() (r time.Time, exists bool) {
|
|
v := m.updated_at
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldUpdatedAt returns the old "updated_at" field's value of the Media entity.
|
|
// If the Media object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *MediaMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
|
|
}
|
|
return oldValue.UpdatedAt, nil
|
|
}
|
|
|
|
// ResetUpdatedAt resets all changes to the "updated_at" field.
|
|
func (m *MediaMutation) ResetUpdatedAt() {
|
|
m.updated_at = nil
|
|
}
|
|
|
|
// SetCreatedBy sets the "created_by" field.
|
|
func (m *MediaMutation) SetCreatedBy(s string) {
|
|
m.created_by = &s
|
|
}
|
|
|
|
// CreatedBy returns the value of the "created_by" field in the mutation.
|
|
func (m *MediaMutation) CreatedBy() (r string, exists bool) {
|
|
v := m.created_by
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldCreatedBy returns the old "created_by" field's value of the Media entity.
|
|
// If the Media object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *MediaMutation) OldCreatedBy(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldCreatedBy is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldCreatedBy requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldCreatedBy: %w", err)
|
|
}
|
|
return oldValue.CreatedBy, nil
|
|
}
|
|
|
|
// ClearCreatedBy clears the value of the "created_by" field.
|
|
func (m *MediaMutation) ClearCreatedBy() {
|
|
m.created_by = nil
|
|
m.clearedFields[media.FieldCreatedBy] = struct{}{}
|
|
}
|
|
|
|
// CreatedByCleared returns if the "created_by" field was cleared in this mutation.
|
|
func (m *MediaMutation) CreatedByCleared() bool {
|
|
_, ok := m.clearedFields[media.FieldCreatedBy]
|
|
return ok
|
|
}
|
|
|
|
// ResetCreatedBy resets all changes to the "created_by" field.
|
|
func (m *MediaMutation) ResetCreatedBy() {
|
|
m.created_by = nil
|
|
delete(m.clearedFields, media.FieldCreatedBy)
|
|
}
|
|
|
|
// SetOwnerID sets the "owner" edge to the User entity by id.
|
|
func (m *MediaMutation) SetOwnerID(id int) {
|
|
m.owner = &id
|
|
}
|
|
|
|
// ClearOwner clears the "owner" edge to the User entity.
|
|
func (m *MediaMutation) ClearOwner() {
|
|
m.clearedowner = true
|
|
}
|
|
|
|
// OwnerCleared reports if the "owner" edge to the User entity was cleared.
|
|
func (m *MediaMutation) OwnerCleared() bool {
|
|
return m.clearedowner
|
|
}
|
|
|
|
// OwnerID returns the "owner" edge ID in the mutation.
|
|
func (m *MediaMutation) OwnerID() (id int, exists bool) {
|
|
if m.owner != nil {
|
|
return *m.owner, true
|
|
}
|
|
return
|
|
}
|
|
|
|
// OwnerIDs returns the "owner" edge IDs in the mutation.
|
|
// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
|
|
// OwnerID instead. It exists only for internal usage by the builders.
|
|
func (m *MediaMutation) OwnerIDs() (ids []int) {
|
|
if id := m.owner; id != nil {
|
|
ids = append(ids, *id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetOwner resets all changes to the "owner" edge.
|
|
func (m *MediaMutation) ResetOwner() {
|
|
m.owner = nil
|
|
m.clearedowner = false
|
|
}
|
|
|
|
// Where appends a list predicates to the MediaMutation builder.
|
|
func (m *MediaMutation) Where(ps ...predicate.Media) {
|
|
m.predicates = append(m.predicates, ps...)
|
|
}
|
|
|
|
// WhereP appends storage-level predicates to the MediaMutation builder. Using this method,
|
|
// users can use type-assertion to append predicates that do not depend on any generated package.
|
|
func (m *MediaMutation) WhereP(ps ...func(*sql.Selector)) {
|
|
p := make([]predicate.Media, len(ps))
|
|
for i := range ps {
|
|
p[i] = ps[i]
|
|
}
|
|
m.Where(p...)
|
|
}
|
|
|
|
// Op returns the operation name.
|
|
func (m *MediaMutation) Op() Op {
|
|
return m.op
|
|
}
|
|
|
|
// SetOp allows setting the mutation operation.
|
|
func (m *MediaMutation) SetOp(op Op) {
|
|
m.op = op
|
|
}
|
|
|
|
// Type returns the node type of this mutation (Media).
|
|
func (m *MediaMutation) Type() string {
|
|
return m.typ
|
|
}
|
|
|
|
// Fields returns all fields that were changed during this mutation. Note that in
|
|
// order to get all numeric fields that were incremented/decremented, call
|
|
// AddedFields().
|
|
func (m *MediaMutation) Fields() []string {
|
|
fields := make([]string, 0, 8)
|
|
if m.storage_id != nil {
|
|
fields = append(fields, media.FieldStorageID)
|
|
}
|
|
if m.original_name != nil {
|
|
fields = append(fields, media.FieldOriginalName)
|
|
}
|
|
if m.mime_type != nil {
|
|
fields = append(fields, media.FieldMimeType)
|
|
}
|
|
if m.size != nil {
|
|
fields = append(fields, media.FieldSize)
|
|
}
|
|
if m.url != nil {
|
|
fields = append(fields, media.FieldURL)
|
|
}
|
|
if m.created_at != nil {
|
|
fields = append(fields, media.FieldCreatedAt)
|
|
}
|
|
if m.updated_at != nil {
|
|
fields = append(fields, media.FieldUpdatedAt)
|
|
}
|
|
if m.created_by != nil {
|
|
fields = append(fields, media.FieldCreatedBy)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// Field returns the value of a field with the given name. The second boolean
|
|
// return value indicates that this field was not set, or was not defined in the
|
|
// schema.
|
|
func (m *MediaMutation) Field(name string) (ent.Value, bool) {
|
|
switch name {
|
|
case media.FieldStorageID:
|
|
return m.StorageID()
|
|
case media.FieldOriginalName:
|
|
return m.OriginalName()
|
|
case media.FieldMimeType:
|
|
return m.MimeType()
|
|
case media.FieldSize:
|
|
return m.Size()
|
|
case media.FieldURL:
|
|
return m.URL()
|
|
case media.FieldCreatedAt:
|
|
return m.CreatedAt()
|
|
case media.FieldUpdatedAt:
|
|
return m.UpdatedAt()
|
|
case media.FieldCreatedBy:
|
|
return m.CreatedBy()
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
// OldField returns the old value of the field from the database. An error is
|
|
// returned if the mutation operation is not UpdateOne, or the query to the
|
|
// database failed.
|
|
func (m *MediaMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
|
|
switch name {
|
|
case media.FieldStorageID:
|
|
return m.OldStorageID(ctx)
|
|
case media.FieldOriginalName:
|
|
return m.OldOriginalName(ctx)
|
|
case media.FieldMimeType:
|
|
return m.OldMimeType(ctx)
|
|
case media.FieldSize:
|
|
return m.OldSize(ctx)
|
|
case media.FieldURL:
|
|
return m.OldURL(ctx)
|
|
case media.FieldCreatedAt:
|
|
return m.OldCreatedAt(ctx)
|
|
case media.FieldUpdatedAt:
|
|
return m.OldUpdatedAt(ctx)
|
|
case media.FieldCreatedBy:
|
|
return m.OldCreatedBy(ctx)
|
|
}
|
|
return nil, fmt.Errorf("unknown Media field %s", name)
|
|
}
|
|
|
|
// SetField sets the value of a field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *MediaMutation) SetField(name string, value ent.Value) error {
|
|
switch name {
|
|
case media.FieldStorageID:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetStorageID(v)
|
|
return nil
|
|
case media.FieldOriginalName:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetOriginalName(v)
|
|
return nil
|
|
case media.FieldMimeType:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetMimeType(v)
|
|
return nil
|
|
case media.FieldSize:
|
|
v, ok := value.(int64)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetSize(v)
|
|
return nil
|
|
case media.FieldURL:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetURL(v)
|
|
return nil
|
|
case media.FieldCreatedAt:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetCreatedAt(v)
|
|
return nil
|
|
case media.FieldUpdatedAt:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetUpdatedAt(v)
|
|
return nil
|
|
case media.FieldCreatedBy:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetCreatedBy(v)
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Media field %s", name)
|
|
}
|
|
|
|
// AddedFields returns all numeric fields that were incremented/decremented during
|
|
// this mutation.
|
|
func (m *MediaMutation) AddedFields() []string {
|
|
var fields []string
|
|
if m.addsize != nil {
|
|
fields = append(fields, media.FieldSize)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// AddedField returns the numeric value that was incremented/decremented on a field
|
|
// with the given name. The second boolean return value indicates that this field
|
|
// was not set, or was not defined in the schema.
|
|
func (m *MediaMutation) AddedField(name string) (ent.Value, bool) {
|
|
switch name {
|
|
case media.FieldSize:
|
|
return m.AddedSize()
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
// AddField adds the value to the field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *MediaMutation) AddField(name string, value ent.Value) error {
|
|
switch name {
|
|
case media.FieldSize:
|
|
v, ok := value.(int64)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.AddSize(v)
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Media numeric field %s", name)
|
|
}
|
|
|
|
// ClearedFields returns all nullable fields that were cleared during this
|
|
// mutation.
|
|
func (m *MediaMutation) ClearedFields() []string {
|
|
var fields []string
|
|
if m.FieldCleared(media.FieldCreatedBy) {
|
|
fields = append(fields, media.FieldCreatedBy)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// FieldCleared returns a boolean indicating if a field with the given name was
|
|
// cleared in this mutation.
|
|
func (m *MediaMutation) FieldCleared(name string) bool {
|
|
_, ok := m.clearedFields[name]
|
|
return ok
|
|
}
|
|
|
|
// ClearField clears the value of the field with the given name. It returns an
|
|
// error if the field is not defined in the schema.
|
|
func (m *MediaMutation) ClearField(name string) error {
|
|
switch name {
|
|
case media.FieldCreatedBy:
|
|
m.ClearCreatedBy()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Media nullable field %s", name)
|
|
}
|
|
|
|
// ResetField resets all changes in the mutation for the field with the given name.
|
|
// It returns an error if the field is not defined in the schema.
|
|
func (m *MediaMutation) ResetField(name string) error {
|
|
switch name {
|
|
case media.FieldStorageID:
|
|
m.ResetStorageID()
|
|
return nil
|
|
case media.FieldOriginalName:
|
|
m.ResetOriginalName()
|
|
return nil
|
|
case media.FieldMimeType:
|
|
m.ResetMimeType()
|
|
return nil
|
|
case media.FieldSize:
|
|
m.ResetSize()
|
|
return nil
|
|
case media.FieldURL:
|
|
m.ResetURL()
|
|
return nil
|
|
case media.FieldCreatedAt:
|
|
m.ResetCreatedAt()
|
|
return nil
|
|
case media.FieldUpdatedAt:
|
|
m.ResetUpdatedAt()
|
|
return nil
|
|
case media.FieldCreatedBy:
|
|
m.ResetCreatedBy()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Media field %s", name)
|
|
}
|
|
|
|
// AddedEdges returns all edge names that were set/added in this mutation.
|
|
func (m *MediaMutation) AddedEdges() []string {
|
|
edges := make([]string, 0, 1)
|
|
if m.owner != nil {
|
|
edges = append(edges, media.EdgeOwner)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// AddedIDs returns all IDs (to other nodes) that were added for the given edge
|
|
// name in this mutation.
|
|
func (m *MediaMutation) AddedIDs(name string) []ent.Value {
|
|
switch name {
|
|
case media.EdgeOwner:
|
|
if id := m.owner; id != nil {
|
|
return []ent.Value{*id}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// RemovedEdges returns all edge names that were removed in this mutation.
|
|
func (m *MediaMutation) RemovedEdges() []string {
|
|
edges := make([]string, 0, 1)
|
|
return edges
|
|
}
|
|
|
|
// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
|
|
// the given name in this mutation.
|
|
func (m *MediaMutation) RemovedIDs(name string) []ent.Value {
|
|
return nil
|
|
}
|
|
|
|
// ClearedEdges returns all edge names that were cleared in this mutation.
|
|
func (m *MediaMutation) ClearedEdges() []string {
|
|
edges := make([]string, 0, 1)
|
|
if m.clearedowner {
|
|
edges = append(edges, media.EdgeOwner)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// EdgeCleared returns a boolean which indicates if the edge with the given name
|
|
// was cleared in this mutation.
|
|
func (m *MediaMutation) EdgeCleared(name string) bool {
|
|
switch name {
|
|
case media.EdgeOwner:
|
|
return m.clearedowner
|
|
}
|
|
return false
|
|
}
|
|
|
|
// ClearEdge clears the value of the edge with the given name. It returns an error
|
|
// if that edge is not defined in the schema.
|
|
func (m *MediaMutation) ClearEdge(name string) error {
|
|
switch name {
|
|
case media.EdgeOwner:
|
|
m.ClearOwner()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Media unique edge %s", name)
|
|
}
|
|
|
|
// ResetEdge resets all changes to the edge with the given name in this mutation.
|
|
// It returns an error if the edge is not defined in the schema.
|
|
func (m *MediaMutation) ResetEdge(name string) error {
|
|
switch name {
|
|
case media.EdgeOwner:
|
|
m.ResetOwner()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Media edge %s", name)
|
|
}
|
|
|
|
// PermissionMutation represents an operation that mutates the Permission nodes in the graph.
|
|
type PermissionMutation struct {
|
|
config
|
|
op Op
|
|
typ string
|
|
id *int
|
|
resource *string
|
|
action *string
|
|
description *string
|
|
created_at *time.Time
|
|
updated_at *time.Time
|
|
clearedFields map[string]struct{}
|
|
roles map[int]struct{}
|
|
removedroles map[int]struct{}
|
|
clearedroles bool
|
|
done bool
|
|
oldValue func(context.Context) (*Permission, error)
|
|
predicates []predicate.Permission
|
|
}
|
|
|
|
var _ ent.Mutation = (*PermissionMutation)(nil)
|
|
|
|
// permissionOption allows management of the mutation configuration using functional options.
|
|
type permissionOption func(*PermissionMutation)
|
|
|
|
// newPermissionMutation creates new mutation for the Permission entity.
|
|
func newPermissionMutation(c config, op Op, opts ...permissionOption) *PermissionMutation {
|
|
m := &PermissionMutation{
|
|
config: c,
|
|
op: op,
|
|
typ: TypePermission,
|
|
clearedFields: make(map[string]struct{}),
|
|
}
|
|
for _, opt := range opts {
|
|
opt(m)
|
|
}
|
|
return m
|
|
}
|
|
|
|
// withPermissionID sets the ID field of the mutation.
|
|
func withPermissionID(id int) permissionOption {
|
|
return func(m *PermissionMutation) {
|
|
var (
|
|
err error
|
|
once sync.Once
|
|
value *Permission
|
|
)
|
|
m.oldValue = func(ctx context.Context) (*Permission, error) {
|
|
once.Do(func() {
|
|
if m.done {
|
|
err = errors.New("querying old values post mutation is not allowed")
|
|
} else {
|
|
value, err = m.Client().Permission.Get(ctx, id)
|
|
}
|
|
})
|
|
return value, err
|
|
}
|
|
m.id = &id
|
|
}
|
|
}
|
|
|
|
// withPermission sets the old Permission of the mutation.
|
|
func withPermission(node *Permission) permissionOption {
|
|
return func(m *PermissionMutation) {
|
|
m.oldValue = func(context.Context) (*Permission, error) {
|
|
return node, nil
|
|
}
|
|
m.id = &node.ID
|
|
}
|
|
}
|
|
|
|
// Client returns a new `ent.Client` from the mutation. If the mutation was
|
|
// executed in a transaction (ent.Tx), a transactional client is returned.
|
|
func (m PermissionMutation) Client() *Client {
|
|
client := &Client{config: m.config}
|
|
client.init()
|
|
return client
|
|
}
|
|
|
|
// Tx returns an `ent.Tx` for mutations that were executed in transactions;
|
|
// it returns an error otherwise.
|
|
func (m PermissionMutation) Tx() (*Tx, error) {
|
|
if _, ok := m.driver.(*txDriver); !ok {
|
|
return nil, errors.New("ent: mutation is not running in a transaction")
|
|
}
|
|
tx := &Tx{config: m.config}
|
|
tx.init()
|
|
return tx, nil
|
|
}
|
|
|
|
// ID returns the ID value in the mutation. Note that the ID is only available
|
|
// if it was provided to the builder or after it was returned from the database.
|
|
func (m *PermissionMutation) ID() (id int, exists bool) {
|
|
if m.id == nil {
|
|
return
|
|
}
|
|
return *m.id, true
|
|
}
|
|
|
|
// IDs queries the database and returns the entity ids that match the mutation's predicate.
|
|
// That means, if the mutation is applied within a transaction with an isolation level such
|
|
// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
|
|
// or updated by the mutation.
|
|
func (m *PermissionMutation) IDs(ctx context.Context) ([]int, error) {
|
|
switch {
|
|
case m.op.Is(OpUpdateOne | OpDeleteOne):
|
|
id, exists := m.ID()
|
|
if exists {
|
|
return []int{id}, nil
|
|
}
|
|
fallthrough
|
|
case m.op.Is(OpUpdate | OpDelete):
|
|
return m.Client().Permission.Query().Where(m.predicates...).IDs(ctx)
|
|
default:
|
|
return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
|
|
}
|
|
}
|
|
|
|
// SetResource sets the "resource" field.
|
|
func (m *PermissionMutation) SetResource(s string) {
|
|
m.resource = &s
|
|
}
|
|
|
|
// Resource returns the value of the "resource" field in the mutation.
|
|
func (m *PermissionMutation) Resource() (r string, exists bool) {
|
|
v := m.resource
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldResource returns the old "resource" field's value of the Permission entity.
|
|
// If the Permission object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *PermissionMutation) OldResource(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldResource is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldResource requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldResource: %w", err)
|
|
}
|
|
return oldValue.Resource, nil
|
|
}
|
|
|
|
// ResetResource resets all changes to the "resource" field.
|
|
func (m *PermissionMutation) ResetResource() {
|
|
m.resource = nil
|
|
}
|
|
|
|
// SetAction sets the "action" field.
|
|
func (m *PermissionMutation) SetAction(s string) {
|
|
m.action = &s
|
|
}
|
|
|
|
// Action returns the value of the "action" field in the mutation.
|
|
func (m *PermissionMutation) Action() (r string, exists bool) {
|
|
v := m.action
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldAction returns the old "action" field's value of the Permission entity.
|
|
// If the Permission object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *PermissionMutation) OldAction(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldAction is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldAction requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldAction: %w", err)
|
|
}
|
|
return oldValue.Action, nil
|
|
}
|
|
|
|
// ResetAction resets all changes to the "action" field.
|
|
func (m *PermissionMutation) ResetAction() {
|
|
m.action = nil
|
|
}
|
|
|
|
// SetDescription sets the "description" field.
|
|
func (m *PermissionMutation) SetDescription(s string) {
|
|
m.description = &s
|
|
}
|
|
|
|
// Description returns the value of the "description" field in the mutation.
|
|
func (m *PermissionMutation) Description() (r string, exists bool) {
|
|
v := m.description
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldDescription returns the old "description" field's value of the Permission entity.
|
|
// If the Permission object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *PermissionMutation) OldDescription(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldDescription is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldDescription requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldDescription: %w", err)
|
|
}
|
|
return oldValue.Description, nil
|
|
}
|
|
|
|
// ClearDescription clears the value of the "description" field.
|
|
func (m *PermissionMutation) ClearDescription() {
|
|
m.description = nil
|
|
m.clearedFields[permission.FieldDescription] = struct{}{}
|
|
}
|
|
|
|
// DescriptionCleared returns if the "description" field was cleared in this mutation.
|
|
func (m *PermissionMutation) DescriptionCleared() bool {
|
|
_, ok := m.clearedFields[permission.FieldDescription]
|
|
return ok
|
|
}
|
|
|
|
// ResetDescription resets all changes to the "description" field.
|
|
func (m *PermissionMutation) ResetDescription() {
|
|
m.description = nil
|
|
delete(m.clearedFields, permission.FieldDescription)
|
|
}
|
|
|
|
// SetCreatedAt sets the "created_at" field.
|
|
func (m *PermissionMutation) SetCreatedAt(t time.Time) {
|
|
m.created_at = &t
|
|
}
|
|
|
|
// CreatedAt returns the value of the "created_at" field in the mutation.
|
|
func (m *PermissionMutation) CreatedAt() (r time.Time, exists bool) {
|
|
v := m.created_at
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldCreatedAt returns the old "created_at" field's value of the Permission entity.
|
|
// If the Permission object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *PermissionMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldCreatedAt requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
|
|
}
|
|
return oldValue.CreatedAt, nil
|
|
}
|
|
|
|
// ResetCreatedAt resets all changes to the "created_at" field.
|
|
func (m *PermissionMutation) ResetCreatedAt() {
|
|
m.created_at = nil
|
|
}
|
|
|
|
// SetUpdatedAt sets the "updated_at" field.
|
|
func (m *PermissionMutation) SetUpdatedAt(t time.Time) {
|
|
m.updated_at = &t
|
|
}
|
|
|
|
// UpdatedAt returns the value of the "updated_at" field in the mutation.
|
|
func (m *PermissionMutation) UpdatedAt() (r time.Time, exists bool) {
|
|
v := m.updated_at
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldUpdatedAt returns the old "updated_at" field's value of the Permission entity.
|
|
// If the Permission object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *PermissionMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
|
|
}
|
|
return oldValue.UpdatedAt, nil
|
|
}
|
|
|
|
// ResetUpdatedAt resets all changes to the "updated_at" field.
|
|
func (m *PermissionMutation) ResetUpdatedAt() {
|
|
m.updated_at = nil
|
|
}
|
|
|
|
// AddRoleIDs adds the "roles" edge to the Role entity by ids.
|
|
func (m *PermissionMutation) AddRoleIDs(ids ...int) {
|
|
if m.roles == nil {
|
|
m.roles = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
m.roles[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// ClearRoles clears the "roles" edge to the Role entity.
|
|
func (m *PermissionMutation) ClearRoles() {
|
|
m.clearedroles = true
|
|
}
|
|
|
|
// RolesCleared reports if the "roles" edge to the Role entity was cleared.
|
|
func (m *PermissionMutation) RolesCleared() bool {
|
|
return m.clearedroles
|
|
}
|
|
|
|
// RemoveRoleIDs removes the "roles" edge to the Role entity by IDs.
|
|
func (m *PermissionMutation) RemoveRoleIDs(ids ...int) {
|
|
if m.removedroles == nil {
|
|
m.removedroles = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
delete(m.roles, ids[i])
|
|
m.removedroles[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// RemovedRoles returns the removed IDs of the "roles" edge to the Role entity.
|
|
func (m *PermissionMutation) RemovedRolesIDs() (ids []int) {
|
|
for id := range m.removedroles {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// RolesIDs returns the "roles" edge IDs in the mutation.
|
|
func (m *PermissionMutation) RolesIDs() (ids []int) {
|
|
for id := range m.roles {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetRoles resets all changes to the "roles" edge.
|
|
func (m *PermissionMutation) ResetRoles() {
|
|
m.roles = nil
|
|
m.clearedroles = false
|
|
m.removedroles = nil
|
|
}
|
|
|
|
// Where appends a list predicates to the PermissionMutation builder.
|
|
func (m *PermissionMutation) Where(ps ...predicate.Permission) {
|
|
m.predicates = append(m.predicates, ps...)
|
|
}
|
|
|
|
// WhereP appends storage-level predicates to the PermissionMutation builder. Using this method,
|
|
// users can use type-assertion to append predicates that do not depend on any generated package.
|
|
func (m *PermissionMutation) WhereP(ps ...func(*sql.Selector)) {
|
|
p := make([]predicate.Permission, len(ps))
|
|
for i := range ps {
|
|
p[i] = ps[i]
|
|
}
|
|
m.Where(p...)
|
|
}
|
|
|
|
// Op returns the operation name.
|
|
func (m *PermissionMutation) Op() Op {
|
|
return m.op
|
|
}
|
|
|
|
// SetOp allows setting the mutation operation.
|
|
func (m *PermissionMutation) SetOp(op Op) {
|
|
m.op = op
|
|
}
|
|
|
|
// Type returns the node type of this mutation (Permission).
|
|
func (m *PermissionMutation) Type() string {
|
|
return m.typ
|
|
}
|
|
|
|
// Fields returns all fields that were changed during this mutation. Note that in
|
|
// order to get all numeric fields that were incremented/decremented, call
|
|
// AddedFields().
|
|
func (m *PermissionMutation) Fields() []string {
|
|
fields := make([]string, 0, 5)
|
|
if m.resource != nil {
|
|
fields = append(fields, permission.FieldResource)
|
|
}
|
|
if m.action != nil {
|
|
fields = append(fields, permission.FieldAction)
|
|
}
|
|
if m.description != nil {
|
|
fields = append(fields, permission.FieldDescription)
|
|
}
|
|
if m.created_at != nil {
|
|
fields = append(fields, permission.FieldCreatedAt)
|
|
}
|
|
if m.updated_at != nil {
|
|
fields = append(fields, permission.FieldUpdatedAt)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// Field returns the value of a field with the given name. The second boolean
|
|
// return value indicates that this field was not set, or was not defined in the
|
|
// schema.
|
|
func (m *PermissionMutation) Field(name string) (ent.Value, bool) {
|
|
switch name {
|
|
case permission.FieldResource:
|
|
return m.Resource()
|
|
case permission.FieldAction:
|
|
return m.Action()
|
|
case permission.FieldDescription:
|
|
return m.Description()
|
|
case permission.FieldCreatedAt:
|
|
return m.CreatedAt()
|
|
case permission.FieldUpdatedAt:
|
|
return m.UpdatedAt()
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
// OldField returns the old value of the field from the database. An error is
|
|
// returned if the mutation operation is not UpdateOne, or the query to the
|
|
// database failed.
|
|
func (m *PermissionMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
|
|
switch name {
|
|
case permission.FieldResource:
|
|
return m.OldResource(ctx)
|
|
case permission.FieldAction:
|
|
return m.OldAction(ctx)
|
|
case permission.FieldDescription:
|
|
return m.OldDescription(ctx)
|
|
case permission.FieldCreatedAt:
|
|
return m.OldCreatedAt(ctx)
|
|
case permission.FieldUpdatedAt:
|
|
return m.OldUpdatedAt(ctx)
|
|
}
|
|
return nil, fmt.Errorf("unknown Permission field %s", name)
|
|
}
|
|
|
|
// SetField sets the value of a field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *PermissionMutation) SetField(name string, value ent.Value) error {
|
|
switch name {
|
|
case permission.FieldResource:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetResource(v)
|
|
return nil
|
|
case permission.FieldAction:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetAction(v)
|
|
return nil
|
|
case permission.FieldDescription:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetDescription(v)
|
|
return nil
|
|
case permission.FieldCreatedAt:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetCreatedAt(v)
|
|
return nil
|
|
case permission.FieldUpdatedAt:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetUpdatedAt(v)
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Permission field %s", name)
|
|
}
|
|
|
|
// AddedFields returns all numeric fields that were incremented/decremented during
|
|
// this mutation.
|
|
func (m *PermissionMutation) AddedFields() []string {
|
|
return nil
|
|
}
|
|
|
|
// AddedField returns the numeric value that was incremented/decremented on a field
|
|
// with the given name. The second boolean return value indicates that this field
|
|
// was not set, or was not defined in the schema.
|
|
func (m *PermissionMutation) AddedField(name string) (ent.Value, bool) {
|
|
return nil, false
|
|
}
|
|
|
|
// AddField adds the value to the field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *PermissionMutation) AddField(name string, value ent.Value) error {
|
|
switch name {
|
|
}
|
|
return fmt.Errorf("unknown Permission numeric field %s", name)
|
|
}
|
|
|
|
// ClearedFields returns all nullable fields that were cleared during this
|
|
// mutation.
|
|
func (m *PermissionMutation) ClearedFields() []string {
|
|
var fields []string
|
|
if m.FieldCleared(permission.FieldDescription) {
|
|
fields = append(fields, permission.FieldDescription)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// FieldCleared returns a boolean indicating if a field with the given name was
|
|
// cleared in this mutation.
|
|
func (m *PermissionMutation) FieldCleared(name string) bool {
|
|
_, ok := m.clearedFields[name]
|
|
return ok
|
|
}
|
|
|
|
// ClearField clears the value of the field with the given name. It returns an
|
|
// error if the field is not defined in the schema.
|
|
func (m *PermissionMutation) ClearField(name string) error {
|
|
switch name {
|
|
case permission.FieldDescription:
|
|
m.ClearDescription()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Permission nullable field %s", name)
|
|
}
|
|
|
|
// ResetField resets all changes in the mutation for the field with the given name.
|
|
// It returns an error if the field is not defined in the schema.
|
|
func (m *PermissionMutation) ResetField(name string) error {
|
|
switch name {
|
|
case permission.FieldResource:
|
|
m.ResetResource()
|
|
return nil
|
|
case permission.FieldAction:
|
|
m.ResetAction()
|
|
return nil
|
|
case permission.FieldDescription:
|
|
m.ResetDescription()
|
|
return nil
|
|
case permission.FieldCreatedAt:
|
|
m.ResetCreatedAt()
|
|
return nil
|
|
case permission.FieldUpdatedAt:
|
|
m.ResetUpdatedAt()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Permission field %s", name)
|
|
}
|
|
|
|
// AddedEdges returns all edge names that were set/added in this mutation.
|
|
func (m *PermissionMutation) AddedEdges() []string {
|
|
edges := make([]string, 0, 1)
|
|
if m.roles != nil {
|
|
edges = append(edges, permission.EdgeRoles)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// AddedIDs returns all IDs (to other nodes) that were added for the given edge
|
|
// name in this mutation.
|
|
func (m *PermissionMutation) AddedIDs(name string) []ent.Value {
|
|
switch name {
|
|
case permission.EdgeRoles:
|
|
ids := make([]ent.Value, 0, len(m.roles))
|
|
for id := range m.roles {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// RemovedEdges returns all edge names that were removed in this mutation.
|
|
func (m *PermissionMutation) RemovedEdges() []string {
|
|
edges := make([]string, 0, 1)
|
|
if m.removedroles != nil {
|
|
edges = append(edges, permission.EdgeRoles)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
|
|
// the given name in this mutation.
|
|
func (m *PermissionMutation) RemovedIDs(name string) []ent.Value {
|
|
switch name {
|
|
case permission.EdgeRoles:
|
|
ids := make([]ent.Value, 0, len(m.removedroles))
|
|
for id := range m.removedroles {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// ClearedEdges returns all edge names that were cleared in this mutation.
|
|
func (m *PermissionMutation) ClearedEdges() []string {
|
|
edges := make([]string, 0, 1)
|
|
if m.clearedroles {
|
|
edges = append(edges, permission.EdgeRoles)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// EdgeCleared returns a boolean which indicates if the edge with the given name
|
|
// was cleared in this mutation.
|
|
func (m *PermissionMutation) EdgeCleared(name string) bool {
|
|
switch name {
|
|
case permission.EdgeRoles:
|
|
return m.clearedroles
|
|
}
|
|
return false
|
|
}
|
|
|
|
// ClearEdge clears the value of the edge with the given name. It returns an error
|
|
// if that edge is not defined in the schema.
|
|
func (m *PermissionMutation) ClearEdge(name string) error {
|
|
switch name {
|
|
}
|
|
return fmt.Errorf("unknown Permission unique edge %s", name)
|
|
}
|
|
|
|
// ResetEdge resets all changes to the edge with the given name in this mutation.
|
|
// It returns an error if the edge is not defined in the schema.
|
|
func (m *PermissionMutation) ResetEdge(name string) error {
|
|
switch name {
|
|
case permission.EdgeRoles:
|
|
m.ResetRoles()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Permission edge %s", name)
|
|
}
|
|
|
|
// PostMutation represents an operation that mutates the Post nodes in the graph.
|
|
type PostMutation struct {
|
|
config
|
|
op Op
|
|
typ string
|
|
id *int
|
|
status *post.Status
|
|
slug *string
|
|
created_at *time.Time
|
|
updated_at *time.Time
|
|
clearedFields map[string]struct{}
|
|
contents map[int]struct{}
|
|
removedcontents map[int]struct{}
|
|
clearedcontents bool
|
|
contributors map[int]struct{}
|
|
removedcontributors map[int]struct{}
|
|
clearedcontributors bool
|
|
category *int
|
|
clearedcategory bool
|
|
done bool
|
|
oldValue func(context.Context) (*Post, error)
|
|
predicates []predicate.Post
|
|
}
|
|
|
|
var _ ent.Mutation = (*PostMutation)(nil)
|
|
|
|
// postOption allows management of the mutation configuration using functional options.
|
|
type postOption func(*PostMutation)
|
|
|
|
// newPostMutation creates new mutation for the Post entity.
|
|
func newPostMutation(c config, op Op, opts ...postOption) *PostMutation {
|
|
m := &PostMutation{
|
|
config: c,
|
|
op: op,
|
|
typ: TypePost,
|
|
clearedFields: make(map[string]struct{}),
|
|
}
|
|
for _, opt := range opts {
|
|
opt(m)
|
|
}
|
|
return m
|
|
}
|
|
|
|
// withPostID sets the ID field of the mutation.
|
|
func withPostID(id int) postOption {
|
|
return func(m *PostMutation) {
|
|
var (
|
|
err error
|
|
once sync.Once
|
|
value *Post
|
|
)
|
|
m.oldValue = func(ctx context.Context) (*Post, error) {
|
|
once.Do(func() {
|
|
if m.done {
|
|
err = errors.New("querying old values post mutation is not allowed")
|
|
} else {
|
|
value, err = m.Client().Post.Get(ctx, id)
|
|
}
|
|
})
|
|
return value, err
|
|
}
|
|
m.id = &id
|
|
}
|
|
}
|
|
|
|
// withPost sets the old Post of the mutation.
|
|
func withPost(node *Post) postOption {
|
|
return func(m *PostMutation) {
|
|
m.oldValue = func(context.Context) (*Post, error) {
|
|
return node, nil
|
|
}
|
|
m.id = &node.ID
|
|
}
|
|
}
|
|
|
|
// Client returns a new `ent.Client` from the mutation. If the mutation was
|
|
// executed in a transaction (ent.Tx), a transactional client is returned.
|
|
func (m PostMutation) Client() *Client {
|
|
client := &Client{config: m.config}
|
|
client.init()
|
|
return client
|
|
}
|
|
|
|
// Tx returns an `ent.Tx` for mutations that were executed in transactions;
|
|
// it returns an error otherwise.
|
|
func (m PostMutation) Tx() (*Tx, error) {
|
|
if _, ok := m.driver.(*txDriver); !ok {
|
|
return nil, errors.New("ent: mutation is not running in a transaction")
|
|
}
|
|
tx := &Tx{config: m.config}
|
|
tx.init()
|
|
return tx, nil
|
|
}
|
|
|
|
// ID returns the ID value in the mutation. Note that the ID is only available
|
|
// if it was provided to the builder or after it was returned from the database.
|
|
func (m *PostMutation) ID() (id int, exists bool) {
|
|
if m.id == nil {
|
|
return
|
|
}
|
|
return *m.id, true
|
|
}
|
|
|
|
// IDs queries the database and returns the entity ids that match the mutation's predicate.
|
|
// That means, if the mutation is applied within a transaction with an isolation level such
|
|
// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
|
|
// or updated by the mutation.
|
|
func (m *PostMutation) IDs(ctx context.Context) ([]int, error) {
|
|
switch {
|
|
case m.op.Is(OpUpdateOne | OpDeleteOne):
|
|
id, exists := m.ID()
|
|
if exists {
|
|
return []int{id}, nil
|
|
}
|
|
fallthrough
|
|
case m.op.Is(OpUpdate | OpDelete):
|
|
return m.Client().Post.Query().Where(m.predicates...).IDs(ctx)
|
|
default:
|
|
return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
|
|
}
|
|
}
|
|
|
|
// SetStatus sets the "status" field.
|
|
func (m *PostMutation) SetStatus(po post.Status) {
|
|
m.status = &po
|
|
}
|
|
|
|
// Status returns the value of the "status" field in the mutation.
|
|
func (m *PostMutation) Status() (r post.Status, exists bool) {
|
|
v := m.status
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldStatus returns the old "status" field's value of the Post entity.
|
|
// If the Post object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *PostMutation) OldStatus(ctx context.Context) (v post.Status, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldStatus is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldStatus requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldStatus: %w", err)
|
|
}
|
|
return oldValue.Status, nil
|
|
}
|
|
|
|
// ResetStatus resets all changes to the "status" field.
|
|
func (m *PostMutation) ResetStatus() {
|
|
m.status = nil
|
|
}
|
|
|
|
// SetSlug sets the "slug" field.
|
|
func (m *PostMutation) SetSlug(s string) {
|
|
m.slug = &s
|
|
}
|
|
|
|
// Slug returns the value of the "slug" field in the mutation.
|
|
func (m *PostMutation) Slug() (r string, exists bool) {
|
|
v := m.slug
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldSlug returns the old "slug" field's value of the Post entity.
|
|
// If the Post object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *PostMutation) OldSlug(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldSlug is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldSlug requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldSlug: %w", err)
|
|
}
|
|
return oldValue.Slug, nil
|
|
}
|
|
|
|
// ResetSlug resets all changes to the "slug" field.
|
|
func (m *PostMutation) ResetSlug() {
|
|
m.slug = nil
|
|
}
|
|
|
|
// SetCreatedAt sets the "created_at" field.
|
|
func (m *PostMutation) SetCreatedAt(t time.Time) {
|
|
m.created_at = &t
|
|
}
|
|
|
|
// CreatedAt returns the value of the "created_at" field in the mutation.
|
|
func (m *PostMutation) CreatedAt() (r time.Time, exists bool) {
|
|
v := m.created_at
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldCreatedAt returns the old "created_at" field's value of the Post entity.
|
|
// If the Post object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *PostMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldCreatedAt requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
|
|
}
|
|
return oldValue.CreatedAt, nil
|
|
}
|
|
|
|
// ResetCreatedAt resets all changes to the "created_at" field.
|
|
func (m *PostMutation) ResetCreatedAt() {
|
|
m.created_at = nil
|
|
}
|
|
|
|
// SetUpdatedAt sets the "updated_at" field.
|
|
func (m *PostMutation) SetUpdatedAt(t time.Time) {
|
|
m.updated_at = &t
|
|
}
|
|
|
|
// UpdatedAt returns the value of the "updated_at" field in the mutation.
|
|
func (m *PostMutation) UpdatedAt() (r time.Time, exists bool) {
|
|
v := m.updated_at
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldUpdatedAt returns the old "updated_at" field's value of the Post entity.
|
|
// If the Post object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *PostMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
|
|
}
|
|
return oldValue.UpdatedAt, nil
|
|
}
|
|
|
|
// ResetUpdatedAt resets all changes to the "updated_at" field.
|
|
func (m *PostMutation) ResetUpdatedAt() {
|
|
m.updated_at = nil
|
|
}
|
|
|
|
// AddContentIDs adds the "contents" edge to the PostContent entity by ids.
|
|
func (m *PostMutation) AddContentIDs(ids ...int) {
|
|
if m.contents == nil {
|
|
m.contents = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
m.contents[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// ClearContents clears the "contents" edge to the PostContent entity.
|
|
func (m *PostMutation) ClearContents() {
|
|
m.clearedcontents = true
|
|
}
|
|
|
|
// ContentsCleared reports if the "contents" edge to the PostContent entity was cleared.
|
|
func (m *PostMutation) ContentsCleared() bool {
|
|
return m.clearedcontents
|
|
}
|
|
|
|
// RemoveContentIDs removes the "contents" edge to the PostContent entity by IDs.
|
|
func (m *PostMutation) RemoveContentIDs(ids ...int) {
|
|
if m.removedcontents == nil {
|
|
m.removedcontents = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
delete(m.contents, ids[i])
|
|
m.removedcontents[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// RemovedContents returns the removed IDs of the "contents" edge to the PostContent entity.
|
|
func (m *PostMutation) RemovedContentsIDs() (ids []int) {
|
|
for id := range m.removedcontents {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ContentsIDs returns the "contents" edge IDs in the mutation.
|
|
func (m *PostMutation) ContentsIDs() (ids []int) {
|
|
for id := range m.contents {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetContents resets all changes to the "contents" edge.
|
|
func (m *PostMutation) ResetContents() {
|
|
m.contents = nil
|
|
m.clearedcontents = false
|
|
m.removedcontents = nil
|
|
}
|
|
|
|
// AddContributorIDs adds the "contributors" edge to the PostContributor entity by ids.
|
|
func (m *PostMutation) AddContributorIDs(ids ...int) {
|
|
if m.contributors == nil {
|
|
m.contributors = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
m.contributors[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// ClearContributors clears the "contributors" edge to the PostContributor entity.
|
|
func (m *PostMutation) ClearContributors() {
|
|
m.clearedcontributors = true
|
|
}
|
|
|
|
// ContributorsCleared reports if the "contributors" edge to the PostContributor entity was cleared.
|
|
func (m *PostMutation) ContributorsCleared() bool {
|
|
return m.clearedcontributors
|
|
}
|
|
|
|
// RemoveContributorIDs removes the "contributors" edge to the PostContributor entity by IDs.
|
|
func (m *PostMutation) RemoveContributorIDs(ids ...int) {
|
|
if m.removedcontributors == nil {
|
|
m.removedcontributors = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
delete(m.contributors, ids[i])
|
|
m.removedcontributors[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// RemovedContributors returns the removed IDs of the "contributors" edge to the PostContributor entity.
|
|
func (m *PostMutation) RemovedContributorsIDs() (ids []int) {
|
|
for id := range m.removedcontributors {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ContributorsIDs returns the "contributors" edge IDs in the mutation.
|
|
func (m *PostMutation) ContributorsIDs() (ids []int) {
|
|
for id := range m.contributors {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetContributors resets all changes to the "contributors" edge.
|
|
func (m *PostMutation) ResetContributors() {
|
|
m.contributors = nil
|
|
m.clearedcontributors = false
|
|
m.removedcontributors = nil
|
|
}
|
|
|
|
// SetCategoryID sets the "category" edge to the Category entity by id.
|
|
func (m *PostMutation) SetCategoryID(id int) {
|
|
m.category = &id
|
|
}
|
|
|
|
// ClearCategory clears the "category" edge to the Category entity.
|
|
func (m *PostMutation) ClearCategory() {
|
|
m.clearedcategory = true
|
|
}
|
|
|
|
// CategoryCleared reports if the "category" edge to the Category entity was cleared.
|
|
func (m *PostMutation) CategoryCleared() bool {
|
|
return m.clearedcategory
|
|
}
|
|
|
|
// CategoryID returns the "category" edge ID in the mutation.
|
|
func (m *PostMutation) CategoryID() (id int, exists bool) {
|
|
if m.category != nil {
|
|
return *m.category, true
|
|
}
|
|
return
|
|
}
|
|
|
|
// CategoryIDs returns the "category" edge IDs in the mutation.
|
|
// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
|
|
// CategoryID instead. It exists only for internal usage by the builders.
|
|
func (m *PostMutation) CategoryIDs() (ids []int) {
|
|
if id := m.category; id != nil {
|
|
ids = append(ids, *id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetCategory resets all changes to the "category" edge.
|
|
func (m *PostMutation) ResetCategory() {
|
|
m.category = nil
|
|
m.clearedcategory = false
|
|
}
|
|
|
|
// Where appends a list predicates to the PostMutation builder.
|
|
func (m *PostMutation) Where(ps ...predicate.Post) {
|
|
m.predicates = append(m.predicates, ps...)
|
|
}
|
|
|
|
// WhereP appends storage-level predicates to the PostMutation builder. Using this method,
|
|
// users can use type-assertion to append predicates that do not depend on any generated package.
|
|
func (m *PostMutation) WhereP(ps ...func(*sql.Selector)) {
|
|
p := make([]predicate.Post, len(ps))
|
|
for i := range ps {
|
|
p[i] = ps[i]
|
|
}
|
|
m.Where(p...)
|
|
}
|
|
|
|
// Op returns the operation name.
|
|
func (m *PostMutation) Op() Op {
|
|
return m.op
|
|
}
|
|
|
|
// SetOp allows setting the mutation operation.
|
|
func (m *PostMutation) SetOp(op Op) {
|
|
m.op = op
|
|
}
|
|
|
|
// Type returns the node type of this mutation (Post).
|
|
func (m *PostMutation) Type() string {
|
|
return m.typ
|
|
}
|
|
|
|
// Fields returns all fields that were changed during this mutation. Note that in
|
|
// order to get all numeric fields that were incremented/decremented, call
|
|
// AddedFields().
|
|
func (m *PostMutation) Fields() []string {
|
|
fields := make([]string, 0, 4)
|
|
if m.status != nil {
|
|
fields = append(fields, post.FieldStatus)
|
|
}
|
|
if m.slug != nil {
|
|
fields = append(fields, post.FieldSlug)
|
|
}
|
|
if m.created_at != nil {
|
|
fields = append(fields, post.FieldCreatedAt)
|
|
}
|
|
if m.updated_at != nil {
|
|
fields = append(fields, post.FieldUpdatedAt)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// Field returns the value of a field with the given name. The second boolean
|
|
// return value indicates that this field was not set, or was not defined in the
|
|
// schema.
|
|
func (m *PostMutation) Field(name string) (ent.Value, bool) {
|
|
switch name {
|
|
case post.FieldStatus:
|
|
return m.Status()
|
|
case post.FieldSlug:
|
|
return m.Slug()
|
|
case post.FieldCreatedAt:
|
|
return m.CreatedAt()
|
|
case post.FieldUpdatedAt:
|
|
return m.UpdatedAt()
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
// OldField returns the old value of the field from the database. An error is
|
|
// returned if the mutation operation is not UpdateOne, or the query to the
|
|
// database failed.
|
|
func (m *PostMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
|
|
switch name {
|
|
case post.FieldStatus:
|
|
return m.OldStatus(ctx)
|
|
case post.FieldSlug:
|
|
return m.OldSlug(ctx)
|
|
case post.FieldCreatedAt:
|
|
return m.OldCreatedAt(ctx)
|
|
case post.FieldUpdatedAt:
|
|
return m.OldUpdatedAt(ctx)
|
|
}
|
|
return nil, fmt.Errorf("unknown Post field %s", name)
|
|
}
|
|
|
|
// SetField sets the value of a field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *PostMutation) SetField(name string, value ent.Value) error {
|
|
switch name {
|
|
case post.FieldStatus:
|
|
v, ok := value.(post.Status)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetStatus(v)
|
|
return nil
|
|
case post.FieldSlug:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetSlug(v)
|
|
return nil
|
|
case post.FieldCreatedAt:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetCreatedAt(v)
|
|
return nil
|
|
case post.FieldUpdatedAt:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetUpdatedAt(v)
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Post field %s", name)
|
|
}
|
|
|
|
// AddedFields returns all numeric fields that were incremented/decremented during
|
|
// this mutation.
|
|
func (m *PostMutation) AddedFields() []string {
|
|
return nil
|
|
}
|
|
|
|
// AddedField returns the numeric value that was incremented/decremented on a field
|
|
// with the given name. The second boolean return value indicates that this field
|
|
// was not set, or was not defined in the schema.
|
|
func (m *PostMutation) AddedField(name string) (ent.Value, bool) {
|
|
return nil, false
|
|
}
|
|
|
|
// AddField adds the value to the field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *PostMutation) AddField(name string, value ent.Value) error {
|
|
switch name {
|
|
}
|
|
return fmt.Errorf("unknown Post numeric field %s", name)
|
|
}
|
|
|
|
// ClearedFields returns all nullable fields that were cleared during this
|
|
// mutation.
|
|
func (m *PostMutation) ClearedFields() []string {
|
|
return nil
|
|
}
|
|
|
|
// FieldCleared returns a boolean indicating if a field with the given name was
|
|
// cleared in this mutation.
|
|
func (m *PostMutation) FieldCleared(name string) bool {
|
|
_, ok := m.clearedFields[name]
|
|
return ok
|
|
}
|
|
|
|
// ClearField clears the value of the field with the given name. It returns an
|
|
// error if the field is not defined in the schema.
|
|
func (m *PostMutation) ClearField(name string) error {
|
|
return fmt.Errorf("unknown Post nullable field %s", name)
|
|
}
|
|
|
|
// ResetField resets all changes in the mutation for the field with the given name.
|
|
// It returns an error if the field is not defined in the schema.
|
|
func (m *PostMutation) ResetField(name string) error {
|
|
switch name {
|
|
case post.FieldStatus:
|
|
m.ResetStatus()
|
|
return nil
|
|
case post.FieldSlug:
|
|
m.ResetSlug()
|
|
return nil
|
|
case post.FieldCreatedAt:
|
|
m.ResetCreatedAt()
|
|
return nil
|
|
case post.FieldUpdatedAt:
|
|
m.ResetUpdatedAt()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Post field %s", name)
|
|
}
|
|
|
|
// AddedEdges returns all edge names that were set/added in this mutation.
|
|
func (m *PostMutation) AddedEdges() []string {
|
|
edges := make([]string, 0, 3)
|
|
if m.contents != nil {
|
|
edges = append(edges, post.EdgeContents)
|
|
}
|
|
if m.contributors != nil {
|
|
edges = append(edges, post.EdgeContributors)
|
|
}
|
|
if m.category != nil {
|
|
edges = append(edges, post.EdgeCategory)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// AddedIDs returns all IDs (to other nodes) that were added for the given edge
|
|
// name in this mutation.
|
|
func (m *PostMutation) AddedIDs(name string) []ent.Value {
|
|
switch name {
|
|
case post.EdgeContents:
|
|
ids := make([]ent.Value, 0, len(m.contents))
|
|
for id := range m.contents {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
case post.EdgeContributors:
|
|
ids := make([]ent.Value, 0, len(m.contributors))
|
|
for id := range m.contributors {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
case post.EdgeCategory:
|
|
if id := m.category; id != nil {
|
|
return []ent.Value{*id}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// RemovedEdges returns all edge names that were removed in this mutation.
|
|
func (m *PostMutation) RemovedEdges() []string {
|
|
edges := make([]string, 0, 3)
|
|
if m.removedcontents != nil {
|
|
edges = append(edges, post.EdgeContents)
|
|
}
|
|
if m.removedcontributors != nil {
|
|
edges = append(edges, post.EdgeContributors)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
|
|
// the given name in this mutation.
|
|
func (m *PostMutation) RemovedIDs(name string) []ent.Value {
|
|
switch name {
|
|
case post.EdgeContents:
|
|
ids := make([]ent.Value, 0, len(m.removedcontents))
|
|
for id := range m.removedcontents {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
case post.EdgeContributors:
|
|
ids := make([]ent.Value, 0, len(m.removedcontributors))
|
|
for id := range m.removedcontributors {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// ClearedEdges returns all edge names that were cleared in this mutation.
|
|
func (m *PostMutation) ClearedEdges() []string {
|
|
edges := make([]string, 0, 3)
|
|
if m.clearedcontents {
|
|
edges = append(edges, post.EdgeContents)
|
|
}
|
|
if m.clearedcontributors {
|
|
edges = append(edges, post.EdgeContributors)
|
|
}
|
|
if m.clearedcategory {
|
|
edges = append(edges, post.EdgeCategory)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// EdgeCleared returns a boolean which indicates if the edge with the given name
|
|
// was cleared in this mutation.
|
|
func (m *PostMutation) EdgeCleared(name string) bool {
|
|
switch name {
|
|
case post.EdgeContents:
|
|
return m.clearedcontents
|
|
case post.EdgeContributors:
|
|
return m.clearedcontributors
|
|
case post.EdgeCategory:
|
|
return m.clearedcategory
|
|
}
|
|
return false
|
|
}
|
|
|
|
// ClearEdge clears the value of the edge with the given name. It returns an error
|
|
// if that edge is not defined in the schema.
|
|
func (m *PostMutation) ClearEdge(name string) error {
|
|
switch name {
|
|
case post.EdgeCategory:
|
|
m.ClearCategory()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Post unique edge %s", name)
|
|
}
|
|
|
|
// ResetEdge resets all changes to the edge with the given name in this mutation.
|
|
// It returns an error if the edge is not defined in the schema.
|
|
func (m *PostMutation) ResetEdge(name string) error {
|
|
switch name {
|
|
case post.EdgeContents:
|
|
m.ResetContents()
|
|
return nil
|
|
case post.EdgeContributors:
|
|
m.ResetContributors()
|
|
return nil
|
|
case post.EdgeCategory:
|
|
m.ResetCategory()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Post edge %s", name)
|
|
}
|
|
|
|
// PostContentMutation represents an operation that mutates the PostContent nodes in the graph.
|
|
type PostContentMutation struct {
|
|
config
|
|
op Op
|
|
typ string
|
|
id *int
|
|
language_code *postcontent.LanguageCode
|
|
title *string
|
|
content_markdown *string
|
|
summary *string
|
|
meta_keywords *string
|
|
meta_description *string
|
|
slug *string
|
|
clearedFields map[string]struct{}
|
|
post *int
|
|
clearedpost bool
|
|
done bool
|
|
oldValue func(context.Context) (*PostContent, error)
|
|
predicates []predicate.PostContent
|
|
}
|
|
|
|
var _ ent.Mutation = (*PostContentMutation)(nil)
|
|
|
|
// postcontentOption allows management of the mutation configuration using functional options.
|
|
type postcontentOption func(*PostContentMutation)
|
|
|
|
// newPostContentMutation creates new mutation for the PostContent entity.
|
|
func newPostContentMutation(c config, op Op, opts ...postcontentOption) *PostContentMutation {
|
|
m := &PostContentMutation{
|
|
config: c,
|
|
op: op,
|
|
typ: TypePostContent,
|
|
clearedFields: make(map[string]struct{}),
|
|
}
|
|
for _, opt := range opts {
|
|
opt(m)
|
|
}
|
|
return m
|
|
}
|
|
|
|
// withPostContentID sets the ID field of the mutation.
|
|
func withPostContentID(id int) postcontentOption {
|
|
return func(m *PostContentMutation) {
|
|
var (
|
|
err error
|
|
once sync.Once
|
|
value *PostContent
|
|
)
|
|
m.oldValue = func(ctx context.Context) (*PostContent, error) {
|
|
once.Do(func() {
|
|
if m.done {
|
|
err = errors.New("querying old values post mutation is not allowed")
|
|
} else {
|
|
value, err = m.Client().PostContent.Get(ctx, id)
|
|
}
|
|
})
|
|
return value, err
|
|
}
|
|
m.id = &id
|
|
}
|
|
}
|
|
|
|
// withPostContent sets the old PostContent of the mutation.
|
|
func withPostContent(node *PostContent) postcontentOption {
|
|
return func(m *PostContentMutation) {
|
|
m.oldValue = func(context.Context) (*PostContent, error) {
|
|
return node, nil
|
|
}
|
|
m.id = &node.ID
|
|
}
|
|
}
|
|
|
|
// Client returns a new `ent.Client` from the mutation. If the mutation was
|
|
// executed in a transaction (ent.Tx), a transactional client is returned.
|
|
func (m PostContentMutation) Client() *Client {
|
|
client := &Client{config: m.config}
|
|
client.init()
|
|
return client
|
|
}
|
|
|
|
// Tx returns an `ent.Tx` for mutations that were executed in transactions;
|
|
// it returns an error otherwise.
|
|
func (m PostContentMutation) Tx() (*Tx, error) {
|
|
if _, ok := m.driver.(*txDriver); !ok {
|
|
return nil, errors.New("ent: mutation is not running in a transaction")
|
|
}
|
|
tx := &Tx{config: m.config}
|
|
tx.init()
|
|
return tx, nil
|
|
}
|
|
|
|
// ID returns the ID value in the mutation. Note that the ID is only available
|
|
// if it was provided to the builder or after it was returned from the database.
|
|
func (m *PostContentMutation) ID() (id int, exists bool) {
|
|
if m.id == nil {
|
|
return
|
|
}
|
|
return *m.id, true
|
|
}
|
|
|
|
// IDs queries the database and returns the entity ids that match the mutation's predicate.
|
|
// That means, if the mutation is applied within a transaction with an isolation level such
|
|
// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
|
|
// or updated by the mutation.
|
|
func (m *PostContentMutation) IDs(ctx context.Context) ([]int, error) {
|
|
switch {
|
|
case m.op.Is(OpUpdateOne | OpDeleteOne):
|
|
id, exists := m.ID()
|
|
if exists {
|
|
return []int{id}, nil
|
|
}
|
|
fallthrough
|
|
case m.op.Is(OpUpdate | OpDelete):
|
|
return m.Client().PostContent.Query().Where(m.predicates...).IDs(ctx)
|
|
default:
|
|
return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
|
|
}
|
|
}
|
|
|
|
// SetLanguageCode sets the "language_code" field.
|
|
func (m *PostContentMutation) SetLanguageCode(pc postcontent.LanguageCode) {
|
|
m.language_code = &pc
|
|
}
|
|
|
|
// LanguageCode returns the value of the "language_code" field in the mutation.
|
|
func (m *PostContentMutation) LanguageCode() (r postcontent.LanguageCode, exists bool) {
|
|
v := m.language_code
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldLanguageCode returns the old "language_code" field's value of the PostContent entity.
|
|
// If the PostContent object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *PostContentMutation) OldLanguageCode(ctx context.Context) (v postcontent.LanguageCode, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldLanguageCode is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldLanguageCode requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldLanguageCode: %w", err)
|
|
}
|
|
return oldValue.LanguageCode, nil
|
|
}
|
|
|
|
// ResetLanguageCode resets all changes to the "language_code" field.
|
|
func (m *PostContentMutation) ResetLanguageCode() {
|
|
m.language_code = nil
|
|
}
|
|
|
|
// SetTitle sets the "title" field.
|
|
func (m *PostContentMutation) SetTitle(s string) {
|
|
m.title = &s
|
|
}
|
|
|
|
// Title returns the value of the "title" field in the mutation.
|
|
func (m *PostContentMutation) Title() (r string, exists bool) {
|
|
v := m.title
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldTitle returns the old "title" field's value of the PostContent entity.
|
|
// If the PostContent object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *PostContentMutation) OldTitle(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldTitle is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldTitle requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldTitle: %w", err)
|
|
}
|
|
return oldValue.Title, nil
|
|
}
|
|
|
|
// ResetTitle resets all changes to the "title" field.
|
|
func (m *PostContentMutation) ResetTitle() {
|
|
m.title = nil
|
|
}
|
|
|
|
// SetContentMarkdown sets the "content_markdown" field.
|
|
func (m *PostContentMutation) SetContentMarkdown(s string) {
|
|
m.content_markdown = &s
|
|
}
|
|
|
|
// ContentMarkdown returns the value of the "content_markdown" field in the mutation.
|
|
func (m *PostContentMutation) ContentMarkdown() (r string, exists bool) {
|
|
v := m.content_markdown
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldContentMarkdown returns the old "content_markdown" field's value of the PostContent entity.
|
|
// If the PostContent object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *PostContentMutation) OldContentMarkdown(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldContentMarkdown is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldContentMarkdown requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldContentMarkdown: %w", err)
|
|
}
|
|
return oldValue.ContentMarkdown, nil
|
|
}
|
|
|
|
// ResetContentMarkdown resets all changes to the "content_markdown" field.
|
|
func (m *PostContentMutation) ResetContentMarkdown() {
|
|
m.content_markdown = nil
|
|
}
|
|
|
|
// SetSummary sets the "summary" field.
|
|
func (m *PostContentMutation) SetSummary(s string) {
|
|
m.summary = &s
|
|
}
|
|
|
|
// Summary returns the value of the "summary" field in the mutation.
|
|
func (m *PostContentMutation) Summary() (r string, exists bool) {
|
|
v := m.summary
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldSummary returns the old "summary" field's value of the PostContent entity.
|
|
// If the PostContent object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *PostContentMutation) OldSummary(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldSummary is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldSummary requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldSummary: %w", err)
|
|
}
|
|
return oldValue.Summary, nil
|
|
}
|
|
|
|
// ResetSummary resets all changes to the "summary" field.
|
|
func (m *PostContentMutation) ResetSummary() {
|
|
m.summary = nil
|
|
}
|
|
|
|
// SetMetaKeywords sets the "meta_keywords" field.
|
|
func (m *PostContentMutation) SetMetaKeywords(s string) {
|
|
m.meta_keywords = &s
|
|
}
|
|
|
|
// MetaKeywords returns the value of the "meta_keywords" field in the mutation.
|
|
func (m *PostContentMutation) MetaKeywords() (r string, exists bool) {
|
|
v := m.meta_keywords
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldMetaKeywords returns the old "meta_keywords" field's value of the PostContent entity.
|
|
// If the PostContent object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *PostContentMutation) OldMetaKeywords(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldMetaKeywords is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldMetaKeywords requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldMetaKeywords: %w", err)
|
|
}
|
|
return oldValue.MetaKeywords, nil
|
|
}
|
|
|
|
// ClearMetaKeywords clears the value of the "meta_keywords" field.
|
|
func (m *PostContentMutation) ClearMetaKeywords() {
|
|
m.meta_keywords = nil
|
|
m.clearedFields[postcontent.FieldMetaKeywords] = struct{}{}
|
|
}
|
|
|
|
// MetaKeywordsCleared returns if the "meta_keywords" field was cleared in this mutation.
|
|
func (m *PostContentMutation) MetaKeywordsCleared() bool {
|
|
_, ok := m.clearedFields[postcontent.FieldMetaKeywords]
|
|
return ok
|
|
}
|
|
|
|
// ResetMetaKeywords resets all changes to the "meta_keywords" field.
|
|
func (m *PostContentMutation) ResetMetaKeywords() {
|
|
m.meta_keywords = nil
|
|
delete(m.clearedFields, postcontent.FieldMetaKeywords)
|
|
}
|
|
|
|
// SetMetaDescription sets the "meta_description" field.
|
|
func (m *PostContentMutation) SetMetaDescription(s string) {
|
|
m.meta_description = &s
|
|
}
|
|
|
|
// MetaDescription returns the value of the "meta_description" field in the mutation.
|
|
func (m *PostContentMutation) MetaDescription() (r string, exists bool) {
|
|
v := m.meta_description
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldMetaDescription returns the old "meta_description" field's value of the PostContent entity.
|
|
// If the PostContent object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *PostContentMutation) OldMetaDescription(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldMetaDescription is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldMetaDescription requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldMetaDescription: %w", err)
|
|
}
|
|
return oldValue.MetaDescription, nil
|
|
}
|
|
|
|
// ClearMetaDescription clears the value of the "meta_description" field.
|
|
func (m *PostContentMutation) ClearMetaDescription() {
|
|
m.meta_description = nil
|
|
m.clearedFields[postcontent.FieldMetaDescription] = struct{}{}
|
|
}
|
|
|
|
// MetaDescriptionCleared returns if the "meta_description" field was cleared in this mutation.
|
|
func (m *PostContentMutation) MetaDescriptionCleared() bool {
|
|
_, ok := m.clearedFields[postcontent.FieldMetaDescription]
|
|
return ok
|
|
}
|
|
|
|
// ResetMetaDescription resets all changes to the "meta_description" field.
|
|
func (m *PostContentMutation) ResetMetaDescription() {
|
|
m.meta_description = nil
|
|
delete(m.clearedFields, postcontent.FieldMetaDescription)
|
|
}
|
|
|
|
// SetSlug sets the "slug" field.
|
|
func (m *PostContentMutation) SetSlug(s string) {
|
|
m.slug = &s
|
|
}
|
|
|
|
// Slug returns the value of the "slug" field in the mutation.
|
|
func (m *PostContentMutation) Slug() (r string, exists bool) {
|
|
v := m.slug
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldSlug returns the old "slug" field's value of the PostContent entity.
|
|
// If the PostContent object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *PostContentMutation) OldSlug(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldSlug is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldSlug requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldSlug: %w", err)
|
|
}
|
|
return oldValue.Slug, nil
|
|
}
|
|
|
|
// ResetSlug resets all changes to the "slug" field.
|
|
func (m *PostContentMutation) ResetSlug() {
|
|
m.slug = nil
|
|
}
|
|
|
|
// SetPostID sets the "post" edge to the Post entity by id.
|
|
func (m *PostContentMutation) SetPostID(id int) {
|
|
m.post = &id
|
|
}
|
|
|
|
// ClearPost clears the "post" edge to the Post entity.
|
|
func (m *PostContentMutation) ClearPost() {
|
|
m.clearedpost = true
|
|
}
|
|
|
|
// PostCleared reports if the "post" edge to the Post entity was cleared.
|
|
func (m *PostContentMutation) PostCleared() bool {
|
|
return m.clearedpost
|
|
}
|
|
|
|
// PostID returns the "post" edge ID in the mutation.
|
|
func (m *PostContentMutation) PostID() (id int, exists bool) {
|
|
if m.post != nil {
|
|
return *m.post, true
|
|
}
|
|
return
|
|
}
|
|
|
|
// PostIDs returns the "post" edge IDs in the mutation.
|
|
// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
|
|
// PostID instead. It exists only for internal usage by the builders.
|
|
func (m *PostContentMutation) PostIDs() (ids []int) {
|
|
if id := m.post; id != nil {
|
|
ids = append(ids, *id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetPost resets all changes to the "post" edge.
|
|
func (m *PostContentMutation) ResetPost() {
|
|
m.post = nil
|
|
m.clearedpost = false
|
|
}
|
|
|
|
// Where appends a list predicates to the PostContentMutation builder.
|
|
func (m *PostContentMutation) Where(ps ...predicate.PostContent) {
|
|
m.predicates = append(m.predicates, ps...)
|
|
}
|
|
|
|
// WhereP appends storage-level predicates to the PostContentMutation builder. Using this method,
|
|
// users can use type-assertion to append predicates that do not depend on any generated package.
|
|
func (m *PostContentMutation) WhereP(ps ...func(*sql.Selector)) {
|
|
p := make([]predicate.PostContent, len(ps))
|
|
for i := range ps {
|
|
p[i] = ps[i]
|
|
}
|
|
m.Where(p...)
|
|
}
|
|
|
|
// Op returns the operation name.
|
|
func (m *PostContentMutation) Op() Op {
|
|
return m.op
|
|
}
|
|
|
|
// SetOp allows setting the mutation operation.
|
|
func (m *PostContentMutation) SetOp(op Op) {
|
|
m.op = op
|
|
}
|
|
|
|
// Type returns the node type of this mutation (PostContent).
|
|
func (m *PostContentMutation) Type() string {
|
|
return m.typ
|
|
}
|
|
|
|
// Fields returns all fields that were changed during this mutation. Note that in
|
|
// order to get all numeric fields that were incremented/decremented, call
|
|
// AddedFields().
|
|
func (m *PostContentMutation) Fields() []string {
|
|
fields := make([]string, 0, 7)
|
|
if m.language_code != nil {
|
|
fields = append(fields, postcontent.FieldLanguageCode)
|
|
}
|
|
if m.title != nil {
|
|
fields = append(fields, postcontent.FieldTitle)
|
|
}
|
|
if m.content_markdown != nil {
|
|
fields = append(fields, postcontent.FieldContentMarkdown)
|
|
}
|
|
if m.summary != nil {
|
|
fields = append(fields, postcontent.FieldSummary)
|
|
}
|
|
if m.meta_keywords != nil {
|
|
fields = append(fields, postcontent.FieldMetaKeywords)
|
|
}
|
|
if m.meta_description != nil {
|
|
fields = append(fields, postcontent.FieldMetaDescription)
|
|
}
|
|
if m.slug != nil {
|
|
fields = append(fields, postcontent.FieldSlug)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// Field returns the value of a field with the given name. The second boolean
|
|
// return value indicates that this field was not set, or was not defined in the
|
|
// schema.
|
|
func (m *PostContentMutation) Field(name string) (ent.Value, bool) {
|
|
switch name {
|
|
case postcontent.FieldLanguageCode:
|
|
return m.LanguageCode()
|
|
case postcontent.FieldTitle:
|
|
return m.Title()
|
|
case postcontent.FieldContentMarkdown:
|
|
return m.ContentMarkdown()
|
|
case postcontent.FieldSummary:
|
|
return m.Summary()
|
|
case postcontent.FieldMetaKeywords:
|
|
return m.MetaKeywords()
|
|
case postcontent.FieldMetaDescription:
|
|
return m.MetaDescription()
|
|
case postcontent.FieldSlug:
|
|
return m.Slug()
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
// OldField returns the old value of the field from the database. An error is
|
|
// returned if the mutation operation is not UpdateOne, or the query to the
|
|
// database failed.
|
|
func (m *PostContentMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
|
|
switch name {
|
|
case postcontent.FieldLanguageCode:
|
|
return m.OldLanguageCode(ctx)
|
|
case postcontent.FieldTitle:
|
|
return m.OldTitle(ctx)
|
|
case postcontent.FieldContentMarkdown:
|
|
return m.OldContentMarkdown(ctx)
|
|
case postcontent.FieldSummary:
|
|
return m.OldSummary(ctx)
|
|
case postcontent.FieldMetaKeywords:
|
|
return m.OldMetaKeywords(ctx)
|
|
case postcontent.FieldMetaDescription:
|
|
return m.OldMetaDescription(ctx)
|
|
case postcontent.FieldSlug:
|
|
return m.OldSlug(ctx)
|
|
}
|
|
return nil, fmt.Errorf("unknown PostContent field %s", name)
|
|
}
|
|
|
|
// SetField sets the value of a field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *PostContentMutation) SetField(name string, value ent.Value) error {
|
|
switch name {
|
|
case postcontent.FieldLanguageCode:
|
|
v, ok := value.(postcontent.LanguageCode)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetLanguageCode(v)
|
|
return nil
|
|
case postcontent.FieldTitle:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetTitle(v)
|
|
return nil
|
|
case postcontent.FieldContentMarkdown:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetContentMarkdown(v)
|
|
return nil
|
|
case postcontent.FieldSummary:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetSummary(v)
|
|
return nil
|
|
case postcontent.FieldMetaKeywords:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetMetaKeywords(v)
|
|
return nil
|
|
case postcontent.FieldMetaDescription:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetMetaDescription(v)
|
|
return nil
|
|
case postcontent.FieldSlug:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetSlug(v)
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown PostContent field %s", name)
|
|
}
|
|
|
|
// AddedFields returns all numeric fields that were incremented/decremented during
|
|
// this mutation.
|
|
func (m *PostContentMutation) AddedFields() []string {
|
|
return nil
|
|
}
|
|
|
|
// AddedField returns the numeric value that was incremented/decremented on a field
|
|
// with the given name. The second boolean return value indicates that this field
|
|
// was not set, or was not defined in the schema.
|
|
func (m *PostContentMutation) AddedField(name string) (ent.Value, bool) {
|
|
return nil, false
|
|
}
|
|
|
|
// AddField adds the value to the field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *PostContentMutation) AddField(name string, value ent.Value) error {
|
|
switch name {
|
|
}
|
|
return fmt.Errorf("unknown PostContent numeric field %s", name)
|
|
}
|
|
|
|
// ClearedFields returns all nullable fields that were cleared during this
|
|
// mutation.
|
|
func (m *PostContentMutation) ClearedFields() []string {
|
|
var fields []string
|
|
if m.FieldCleared(postcontent.FieldMetaKeywords) {
|
|
fields = append(fields, postcontent.FieldMetaKeywords)
|
|
}
|
|
if m.FieldCleared(postcontent.FieldMetaDescription) {
|
|
fields = append(fields, postcontent.FieldMetaDescription)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// FieldCleared returns a boolean indicating if a field with the given name was
|
|
// cleared in this mutation.
|
|
func (m *PostContentMutation) FieldCleared(name string) bool {
|
|
_, ok := m.clearedFields[name]
|
|
return ok
|
|
}
|
|
|
|
// ClearField clears the value of the field with the given name. It returns an
|
|
// error if the field is not defined in the schema.
|
|
func (m *PostContentMutation) ClearField(name string) error {
|
|
switch name {
|
|
case postcontent.FieldMetaKeywords:
|
|
m.ClearMetaKeywords()
|
|
return nil
|
|
case postcontent.FieldMetaDescription:
|
|
m.ClearMetaDescription()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown PostContent nullable field %s", name)
|
|
}
|
|
|
|
// ResetField resets all changes in the mutation for the field with the given name.
|
|
// It returns an error if the field is not defined in the schema.
|
|
func (m *PostContentMutation) ResetField(name string) error {
|
|
switch name {
|
|
case postcontent.FieldLanguageCode:
|
|
m.ResetLanguageCode()
|
|
return nil
|
|
case postcontent.FieldTitle:
|
|
m.ResetTitle()
|
|
return nil
|
|
case postcontent.FieldContentMarkdown:
|
|
m.ResetContentMarkdown()
|
|
return nil
|
|
case postcontent.FieldSummary:
|
|
m.ResetSummary()
|
|
return nil
|
|
case postcontent.FieldMetaKeywords:
|
|
m.ResetMetaKeywords()
|
|
return nil
|
|
case postcontent.FieldMetaDescription:
|
|
m.ResetMetaDescription()
|
|
return nil
|
|
case postcontent.FieldSlug:
|
|
m.ResetSlug()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown PostContent field %s", name)
|
|
}
|
|
|
|
// AddedEdges returns all edge names that were set/added in this mutation.
|
|
func (m *PostContentMutation) AddedEdges() []string {
|
|
edges := make([]string, 0, 1)
|
|
if m.post != nil {
|
|
edges = append(edges, postcontent.EdgePost)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// AddedIDs returns all IDs (to other nodes) that were added for the given edge
|
|
// name in this mutation.
|
|
func (m *PostContentMutation) AddedIDs(name string) []ent.Value {
|
|
switch name {
|
|
case postcontent.EdgePost:
|
|
if id := m.post; id != nil {
|
|
return []ent.Value{*id}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// RemovedEdges returns all edge names that were removed in this mutation.
|
|
func (m *PostContentMutation) RemovedEdges() []string {
|
|
edges := make([]string, 0, 1)
|
|
return edges
|
|
}
|
|
|
|
// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
|
|
// the given name in this mutation.
|
|
func (m *PostContentMutation) RemovedIDs(name string) []ent.Value {
|
|
return nil
|
|
}
|
|
|
|
// ClearedEdges returns all edge names that were cleared in this mutation.
|
|
func (m *PostContentMutation) ClearedEdges() []string {
|
|
edges := make([]string, 0, 1)
|
|
if m.clearedpost {
|
|
edges = append(edges, postcontent.EdgePost)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// EdgeCleared returns a boolean which indicates if the edge with the given name
|
|
// was cleared in this mutation.
|
|
func (m *PostContentMutation) EdgeCleared(name string) bool {
|
|
switch name {
|
|
case postcontent.EdgePost:
|
|
return m.clearedpost
|
|
}
|
|
return false
|
|
}
|
|
|
|
// ClearEdge clears the value of the edge with the given name. It returns an error
|
|
// if that edge is not defined in the schema.
|
|
func (m *PostContentMutation) ClearEdge(name string) error {
|
|
switch name {
|
|
case postcontent.EdgePost:
|
|
m.ClearPost()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown PostContent unique edge %s", name)
|
|
}
|
|
|
|
// ResetEdge resets all changes to the edge with the given name in this mutation.
|
|
// It returns an error if the edge is not defined in the schema.
|
|
func (m *PostContentMutation) ResetEdge(name string) error {
|
|
switch name {
|
|
case postcontent.EdgePost:
|
|
m.ResetPost()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown PostContent edge %s", name)
|
|
}
|
|
|
|
// PostContributorMutation represents an operation that mutates the PostContributor nodes in the graph.
|
|
type PostContributorMutation struct {
|
|
config
|
|
op Op
|
|
typ string
|
|
id *int
|
|
language_code *postcontributor.LanguageCode
|
|
created_at *time.Time
|
|
clearedFields map[string]struct{}
|
|
post *int
|
|
clearedpost bool
|
|
contributor *int
|
|
clearedcontributor bool
|
|
role *int
|
|
clearedrole bool
|
|
done bool
|
|
oldValue func(context.Context) (*PostContributor, error)
|
|
predicates []predicate.PostContributor
|
|
}
|
|
|
|
var _ ent.Mutation = (*PostContributorMutation)(nil)
|
|
|
|
// postcontributorOption allows management of the mutation configuration using functional options.
|
|
type postcontributorOption func(*PostContributorMutation)
|
|
|
|
// newPostContributorMutation creates new mutation for the PostContributor entity.
|
|
func newPostContributorMutation(c config, op Op, opts ...postcontributorOption) *PostContributorMutation {
|
|
m := &PostContributorMutation{
|
|
config: c,
|
|
op: op,
|
|
typ: TypePostContributor,
|
|
clearedFields: make(map[string]struct{}),
|
|
}
|
|
for _, opt := range opts {
|
|
opt(m)
|
|
}
|
|
return m
|
|
}
|
|
|
|
// withPostContributorID sets the ID field of the mutation.
|
|
func withPostContributorID(id int) postcontributorOption {
|
|
return func(m *PostContributorMutation) {
|
|
var (
|
|
err error
|
|
once sync.Once
|
|
value *PostContributor
|
|
)
|
|
m.oldValue = func(ctx context.Context) (*PostContributor, error) {
|
|
once.Do(func() {
|
|
if m.done {
|
|
err = errors.New("querying old values post mutation is not allowed")
|
|
} else {
|
|
value, err = m.Client().PostContributor.Get(ctx, id)
|
|
}
|
|
})
|
|
return value, err
|
|
}
|
|
m.id = &id
|
|
}
|
|
}
|
|
|
|
// withPostContributor sets the old PostContributor of the mutation.
|
|
func withPostContributor(node *PostContributor) postcontributorOption {
|
|
return func(m *PostContributorMutation) {
|
|
m.oldValue = func(context.Context) (*PostContributor, error) {
|
|
return node, nil
|
|
}
|
|
m.id = &node.ID
|
|
}
|
|
}
|
|
|
|
// Client returns a new `ent.Client` from the mutation. If the mutation was
|
|
// executed in a transaction (ent.Tx), a transactional client is returned.
|
|
func (m PostContributorMutation) Client() *Client {
|
|
client := &Client{config: m.config}
|
|
client.init()
|
|
return client
|
|
}
|
|
|
|
// Tx returns an `ent.Tx` for mutations that were executed in transactions;
|
|
// it returns an error otherwise.
|
|
func (m PostContributorMutation) Tx() (*Tx, error) {
|
|
if _, ok := m.driver.(*txDriver); !ok {
|
|
return nil, errors.New("ent: mutation is not running in a transaction")
|
|
}
|
|
tx := &Tx{config: m.config}
|
|
tx.init()
|
|
return tx, nil
|
|
}
|
|
|
|
// ID returns the ID value in the mutation. Note that the ID is only available
|
|
// if it was provided to the builder or after it was returned from the database.
|
|
func (m *PostContributorMutation) ID() (id int, exists bool) {
|
|
if m.id == nil {
|
|
return
|
|
}
|
|
return *m.id, true
|
|
}
|
|
|
|
// IDs queries the database and returns the entity ids that match the mutation's predicate.
|
|
// That means, if the mutation is applied within a transaction with an isolation level such
|
|
// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
|
|
// or updated by the mutation.
|
|
func (m *PostContributorMutation) IDs(ctx context.Context) ([]int, error) {
|
|
switch {
|
|
case m.op.Is(OpUpdateOne | OpDeleteOne):
|
|
id, exists := m.ID()
|
|
if exists {
|
|
return []int{id}, nil
|
|
}
|
|
fallthrough
|
|
case m.op.Is(OpUpdate | OpDelete):
|
|
return m.Client().PostContributor.Query().Where(m.predicates...).IDs(ctx)
|
|
default:
|
|
return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
|
|
}
|
|
}
|
|
|
|
// SetLanguageCode sets the "language_code" field.
|
|
func (m *PostContributorMutation) SetLanguageCode(pc postcontributor.LanguageCode) {
|
|
m.language_code = &pc
|
|
}
|
|
|
|
// LanguageCode returns the value of the "language_code" field in the mutation.
|
|
func (m *PostContributorMutation) LanguageCode() (r postcontributor.LanguageCode, exists bool) {
|
|
v := m.language_code
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldLanguageCode returns the old "language_code" field's value of the PostContributor entity.
|
|
// If the PostContributor object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *PostContributorMutation) OldLanguageCode(ctx context.Context) (v *postcontributor.LanguageCode, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldLanguageCode is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldLanguageCode requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldLanguageCode: %w", err)
|
|
}
|
|
return oldValue.LanguageCode, nil
|
|
}
|
|
|
|
// ClearLanguageCode clears the value of the "language_code" field.
|
|
func (m *PostContributorMutation) ClearLanguageCode() {
|
|
m.language_code = nil
|
|
m.clearedFields[postcontributor.FieldLanguageCode] = struct{}{}
|
|
}
|
|
|
|
// LanguageCodeCleared returns if the "language_code" field was cleared in this mutation.
|
|
func (m *PostContributorMutation) LanguageCodeCleared() bool {
|
|
_, ok := m.clearedFields[postcontributor.FieldLanguageCode]
|
|
return ok
|
|
}
|
|
|
|
// ResetLanguageCode resets all changes to the "language_code" field.
|
|
func (m *PostContributorMutation) ResetLanguageCode() {
|
|
m.language_code = nil
|
|
delete(m.clearedFields, postcontributor.FieldLanguageCode)
|
|
}
|
|
|
|
// SetCreatedAt sets the "created_at" field.
|
|
func (m *PostContributorMutation) SetCreatedAt(t time.Time) {
|
|
m.created_at = &t
|
|
}
|
|
|
|
// CreatedAt returns the value of the "created_at" field in the mutation.
|
|
func (m *PostContributorMutation) CreatedAt() (r time.Time, exists bool) {
|
|
v := m.created_at
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldCreatedAt returns the old "created_at" field's value of the PostContributor entity.
|
|
// If the PostContributor object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *PostContributorMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldCreatedAt requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
|
|
}
|
|
return oldValue.CreatedAt, nil
|
|
}
|
|
|
|
// ResetCreatedAt resets all changes to the "created_at" field.
|
|
func (m *PostContributorMutation) ResetCreatedAt() {
|
|
m.created_at = nil
|
|
}
|
|
|
|
// SetPostID sets the "post" edge to the Post entity by id.
|
|
func (m *PostContributorMutation) SetPostID(id int) {
|
|
m.post = &id
|
|
}
|
|
|
|
// ClearPost clears the "post" edge to the Post entity.
|
|
func (m *PostContributorMutation) ClearPost() {
|
|
m.clearedpost = true
|
|
}
|
|
|
|
// PostCleared reports if the "post" edge to the Post entity was cleared.
|
|
func (m *PostContributorMutation) PostCleared() bool {
|
|
return m.clearedpost
|
|
}
|
|
|
|
// PostID returns the "post" edge ID in the mutation.
|
|
func (m *PostContributorMutation) PostID() (id int, exists bool) {
|
|
if m.post != nil {
|
|
return *m.post, true
|
|
}
|
|
return
|
|
}
|
|
|
|
// PostIDs returns the "post" edge IDs in the mutation.
|
|
// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
|
|
// PostID instead. It exists only for internal usage by the builders.
|
|
func (m *PostContributorMutation) PostIDs() (ids []int) {
|
|
if id := m.post; id != nil {
|
|
ids = append(ids, *id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetPost resets all changes to the "post" edge.
|
|
func (m *PostContributorMutation) ResetPost() {
|
|
m.post = nil
|
|
m.clearedpost = false
|
|
}
|
|
|
|
// SetContributorID sets the "contributor" edge to the Contributor entity by id.
|
|
func (m *PostContributorMutation) SetContributorID(id int) {
|
|
m.contributor = &id
|
|
}
|
|
|
|
// ClearContributor clears the "contributor" edge to the Contributor entity.
|
|
func (m *PostContributorMutation) ClearContributor() {
|
|
m.clearedcontributor = true
|
|
}
|
|
|
|
// ContributorCleared reports if the "contributor" edge to the Contributor entity was cleared.
|
|
func (m *PostContributorMutation) ContributorCleared() bool {
|
|
return m.clearedcontributor
|
|
}
|
|
|
|
// ContributorID returns the "contributor" edge ID in the mutation.
|
|
func (m *PostContributorMutation) ContributorID() (id int, exists bool) {
|
|
if m.contributor != nil {
|
|
return *m.contributor, true
|
|
}
|
|
return
|
|
}
|
|
|
|
// ContributorIDs returns the "contributor" edge IDs in the mutation.
|
|
// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
|
|
// ContributorID instead. It exists only for internal usage by the builders.
|
|
func (m *PostContributorMutation) ContributorIDs() (ids []int) {
|
|
if id := m.contributor; id != nil {
|
|
ids = append(ids, *id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetContributor resets all changes to the "contributor" edge.
|
|
func (m *PostContributorMutation) ResetContributor() {
|
|
m.contributor = nil
|
|
m.clearedcontributor = false
|
|
}
|
|
|
|
// SetRoleID sets the "role" edge to the ContributorRole entity by id.
|
|
func (m *PostContributorMutation) SetRoleID(id int) {
|
|
m.role = &id
|
|
}
|
|
|
|
// ClearRole clears the "role" edge to the ContributorRole entity.
|
|
func (m *PostContributorMutation) ClearRole() {
|
|
m.clearedrole = true
|
|
}
|
|
|
|
// RoleCleared reports if the "role" edge to the ContributorRole entity was cleared.
|
|
func (m *PostContributorMutation) RoleCleared() bool {
|
|
return m.clearedrole
|
|
}
|
|
|
|
// RoleID returns the "role" edge ID in the mutation.
|
|
func (m *PostContributorMutation) RoleID() (id int, exists bool) {
|
|
if m.role != nil {
|
|
return *m.role, true
|
|
}
|
|
return
|
|
}
|
|
|
|
// RoleIDs returns the "role" edge IDs in the mutation.
|
|
// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
|
|
// RoleID instead. It exists only for internal usage by the builders.
|
|
func (m *PostContributorMutation) RoleIDs() (ids []int) {
|
|
if id := m.role; id != nil {
|
|
ids = append(ids, *id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetRole resets all changes to the "role" edge.
|
|
func (m *PostContributorMutation) ResetRole() {
|
|
m.role = nil
|
|
m.clearedrole = false
|
|
}
|
|
|
|
// Where appends a list predicates to the PostContributorMutation builder.
|
|
func (m *PostContributorMutation) Where(ps ...predicate.PostContributor) {
|
|
m.predicates = append(m.predicates, ps...)
|
|
}
|
|
|
|
// WhereP appends storage-level predicates to the PostContributorMutation builder. Using this method,
|
|
// users can use type-assertion to append predicates that do not depend on any generated package.
|
|
func (m *PostContributorMutation) WhereP(ps ...func(*sql.Selector)) {
|
|
p := make([]predicate.PostContributor, len(ps))
|
|
for i := range ps {
|
|
p[i] = ps[i]
|
|
}
|
|
m.Where(p...)
|
|
}
|
|
|
|
// Op returns the operation name.
|
|
func (m *PostContributorMutation) Op() Op {
|
|
return m.op
|
|
}
|
|
|
|
// SetOp allows setting the mutation operation.
|
|
func (m *PostContributorMutation) SetOp(op Op) {
|
|
m.op = op
|
|
}
|
|
|
|
// Type returns the node type of this mutation (PostContributor).
|
|
func (m *PostContributorMutation) Type() string {
|
|
return m.typ
|
|
}
|
|
|
|
// Fields returns all fields that were changed during this mutation. Note that in
|
|
// order to get all numeric fields that were incremented/decremented, call
|
|
// AddedFields().
|
|
func (m *PostContributorMutation) Fields() []string {
|
|
fields := make([]string, 0, 2)
|
|
if m.language_code != nil {
|
|
fields = append(fields, postcontributor.FieldLanguageCode)
|
|
}
|
|
if m.created_at != nil {
|
|
fields = append(fields, postcontributor.FieldCreatedAt)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// Field returns the value of a field with the given name. The second boolean
|
|
// return value indicates that this field was not set, or was not defined in the
|
|
// schema.
|
|
func (m *PostContributorMutation) Field(name string) (ent.Value, bool) {
|
|
switch name {
|
|
case postcontributor.FieldLanguageCode:
|
|
return m.LanguageCode()
|
|
case postcontributor.FieldCreatedAt:
|
|
return m.CreatedAt()
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
// OldField returns the old value of the field from the database. An error is
|
|
// returned if the mutation operation is not UpdateOne, or the query to the
|
|
// database failed.
|
|
func (m *PostContributorMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
|
|
switch name {
|
|
case postcontributor.FieldLanguageCode:
|
|
return m.OldLanguageCode(ctx)
|
|
case postcontributor.FieldCreatedAt:
|
|
return m.OldCreatedAt(ctx)
|
|
}
|
|
return nil, fmt.Errorf("unknown PostContributor field %s", name)
|
|
}
|
|
|
|
// SetField sets the value of a field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *PostContributorMutation) SetField(name string, value ent.Value) error {
|
|
switch name {
|
|
case postcontributor.FieldLanguageCode:
|
|
v, ok := value.(postcontributor.LanguageCode)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetLanguageCode(v)
|
|
return nil
|
|
case postcontributor.FieldCreatedAt:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetCreatedAt(v)
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown PostContributor field %s", name)
|
|
}
|
|
|
|
// AddedFields returns all numeric fields that were incremented/decremented during
|
|
// this mutation.
|
|
func (m *PostContributorMutation) AddedFields() []string {
|
|
return nil
|
|
}
|
|
|
|
// AddedField returns the numeric value that was incremented/decremented on a field
|
|
// with the given name. The second boolean return value indicates that this field
|
|
// was not set, or was not defined in the schema.
|
|
func (m *PostContributorMutation) AddedField(name string) (ent.Value, bool) {
|
|
return nil, false
|
|
}
|
|
|
|
// AddField adds the value to the field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *PostContributorMutation) AddField(name string, value ent.Value) error {
|
|
switch name {
|
|
}
|
|
return fmt.Errorf("unknown PostContributor numeric field %s", name)
|
|
}
|
|
|
|
// ClearedFields returns all nullable fields that were cleared during this
|
|
// mutation.
|
|
func (m *PostContributorMutation) ClearedFields() []string {
|
|
var fields []string
|
|
if m.FieldCleared(postcontributor.FieldLanguageCode) {
|
|
fields = append(fields, postcontributor.FieldLanguageCode)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// FieldCleared returns a boolean indicating if a field with the given name was
|
|
// cleared in this mutation.
|
|
func (m *PostContributorMutation) FieldCleared(name string) bool {
|
|
_, ok := m.clearedFields[name]
|
|
return ok
|
|
}
|
|
|
|
// ClearField clears the value of the field with the given name. It returns an
|
|
// error if the field is not defined in the schema.
|
|
func (m *PostContributorMutation) ClearField(name string) error {
|
|
switch name {
|
|
case postcontributor.FieldLanguageCode:
|
|
m.ClearLanguageCode()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown PostContributor nullable field %s", name)
|
|
}
|
|
|
|
// ResetField resets all changes in the mutation for the field with the given name.
|
|
// It returns an error if the field is not defined in the schema.
|
|
func (m *PostContributorMutation) ResetField(name string) error {
|
|
switch name {
|
|
case postcontributor.FieldLanguageCode:
|
|
m.ResetLanguageCode()
|
|
return nil
|
|
case postcontributor.FieldCreatedAt:
|
|
m.ResetCreatedAt()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown PostContributor field %s", name)
|
|
}
|
|
|
|
// AddedEdges returns all edge names that were set/added in this mutation.
|
|
func (m *PostContributorMutation) AddedEdges() []string {
|
|
edges := make([]string, 0, 3)
|
|
if m.post != nil {
|
|
edges = append(edges, postcontributor.EdgePost)
|
|
}
|
|
if m.contributor != nil {
|
|
edges = append(edges, postcontributor.EdgeContributor)
|
|
}
|
|
if m.role != nil {
|
|
edges = append(edges, postcontributor.EdgeRole)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// AddedIDs returns all IDs (to other nodes) that were added for the given edge
|
|
// name in this mutation.
|
|
func (m *PostContributorMutation) AddedIDs(name string) []ent.Value {
|
|
switch name {
|
|
case postcontributor.EdgePost:
|
|
if id := m.post; id != nil {
|
|
return []ent.Value{*id}
|
|
}
|
|
case postcontributor.EdgeContributor:
|
|
if id := m.contributor; id != nil {
|
|
return []ent.Value{*id}
|
|
}
|
|
case postcontributor.EdgeRole:
|
|
if id := m.role; id != nil {
|
|
return []ent.Value{*id}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// RemovedEdges returns all edge names that were removed in this mutation.
|
|
func (m *PostContributorMutation) RemovedEdges() []string {
|
|
edges := make([]string, 0, 3)
|
|
return edges
|
|
}
|
|
|
|
// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
|
|
// the given name in this mutation.
|
|
func (m *PostContributorMutation) RemovedIDs(name string) []ent.Value {
|
|
return nil
|
|
}
|
|
|
|
// ClearedEdges returns all edge names that were cleared in this mutation.
|
|
func (m *PostContributorMutation) ClearedEdges() []string {
|
|
edges := make([]string, 0, 3)
|
|
if m.clearedpost {
|
|
edges = append(edges, postcontributor.EdgePost)
|
|
}
|
|
if m.clearedcontributor {
|
|
edges = append(edges, postcontributor.EdgeContributor)
|
|
}
|
|
if m.clearedrole {
|
|
edges = append(edges, postcontributor.EdgeRole)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// EdgeCleared returns a boolean which indicates if the edge with the given name
|
|
// was cleared in this mutation.
|
|
func (m *PostContributorMutation) EdgeCleared(name string) bool {
|
|
switch name {
|
|
case postcontributor.EdgePost:
|
|
return m.clearedpost
|
|
case postcontributor.EdgeContributor:
|
|
return m.clearedcontributor
|
|
case postcontributor.EdgeRole:
|
|
return m.clearedrole
|
|
}
|
|
return false
|
|
}
|
|
|
|
// ClearEdge clears the value of the edge with the given name. It returns an error
|
|
// if that edge is not defined in the schema.
|
|
func (m *PostContributorMutation) ClearEdge(name string) error {
|
|
switch name {
|
|
case postcontributor.EdgePost:
|
|
m.ClearPost()
|
|
return nil
|
|
case postcontributor.EdgeContributor:
|
|
m.ClearContributor()
|
|
return nil
|
|
case postcontributor.EdgeRole:
|
|
m.ClearRole()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown PostContributor unique edge %s", name)
|
|
}
|
|
|
|
// ResetEdge resets all changes to the edge with the given name in this mutation.
|
|
// It returns an error if the edge is not defined in the schema.
|
|
func (m *PostContributorMutation) ResetEdge(name string) error {
|
|
switch name {
|
|
case postcontributor.EdgePost:
|
|
m.ResetPost()
|
|
return nil
|
|
case postcontributor.EdgeContributor:
|
|
m.ResetContributor()
|
|
return nil
|
|
case postcontributor.EdgeRole:
|
|
m.ResetRole()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown PostContributor edge %s", name)
|
|
}
|
|
|
|
// RoleMutation represents an operation that mutates the Role nodes in the graph.
|
|
type RoleMutation struct {
|
|
config
|
|
op Op
|
|
typ string
|
|
id *int
|
|
name *string
|
|
description *string
|
|
created_at *time.Time
|
|
updated_at *time.Time
|
|
clearedFields map[string]struct{}
|
|
permissions map[int]struct{}
|
|
removedpermissions map[int]struct{}
|
|
clearedpermissions bool
|
|
users map[int]struct{}
|
|
removedusers map[int]struct{}
|
|
clearedusers bool
|
|
done bool
|
|
oldValue func(context.Context) (*Role, error)
|
|
predicates []predicate.Role
|
|
}
|
|
|
|
var _ ent.Mutation = (*RoleMutation)(nil)
|
|
|
|
// roleOption allows management of the mutation configuration using functional options.
|
|
type roleOption func(*RoleMutation)
|
|
|
|
// newRoleMutation creates new mutation for the Role entity.
|
|
func newRoleMutation(c config, op Op, opts ...roleOption) *RoleMutation {
|
|
m := &RoleMutation{
|
|
config: c,
|
|
op: op,
|
|
typ: TypeRole,
|
|
clearedFields: make(map[string]struct{}),
|
|
}
|
|
for _, opt := range opts {
|
|
opt(m)
|
|
}
|
|
return m
|
|
}
|
|
|
|
// withRoleID sets the ID field of the mutation.
|
|
func withRoleID(id int) roleOption {
|
|
return func(m *RoleMutation) {
|
|
var (
|
|
err error
|
|
once sync.Once
|
|
value *Role
|
|
)
|
|
m.oldValue = func(ctx context.Context) (*Role, error) {
|
|
once.Do(func() {
|
|
if m.done {
|
|
err = errors.New("querying old values post mutation is not allowed")
|
|
} else {
|
|
value, err = m.Client().Role.Get(ctx, id)
|
|
}
|
|
})
|
|
return value, err
|
|
}
|
|
m.id = &id
|
|
}
|
|
}
|
|
|
|
// withRole sets the old Role of the mutation.
|
|
func withRole(node *Role) roleOption {
|
|
return func(m *RoleMutation) {
|
|
m.oldValue = func(context.Context) (*Role, error) {
|
|
return node, nil
|
|
}
|
|
m.id = &node.ID
|
|
}
|
|
}
|
|
|
|
// Client returns a new `ent.Client` from the mutation. If the mutation was
|
|
// executed in a transaction (ent.Tx), a transactional client is returned.
|
|
func (m RoleMutation) Client() *Client {
|
|
client := &Client{config: m.config}
|
|
client.init()
|
|
return client
|
|
}
|
|
|
|
// Tx returns an `ent.Tx` for mutations that were executed in transactions;
|
|
// it returns an error otherwise.
|
|
func (m RoleMutation) Tx() (*Tx, error) {
|
|
if _, ok := m.driver.(*txDriver); !ok {
|
|
return nil, errors.New("ent: mutation is not running in a transaction")
|
|
}
|
|
tx := &Tx{config: m.config}
|
|
tx.init()
|
|
return tx, nil
|
|
}
|
|
|
|
// ID returns the ID value in the mutation. Note that the ID is only available
|
|
// if it was provided to the builder or after it was returned from the database.
|
|
func (m *RoleMutation) ID() (id int, exists bool) {
|
|
if m.id == nil {
|
|
return
|
|
}
|
|
return *m.id, true
|
|
}
|
|
|
|
// IDs queries the database and returns the entity ids that match the mutation's predicate.
|
|
// That means, if the mutation is applied within a transaction with an isolation level such
|
|
// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
|
|
// or updated by the mutation.
|
|
func (m *RoleMutation) IDs(ctx context.Context) ([]int, error) {
|
|
switch {
|
|
case m.op.Is(OpUpdateOne | OpDeleteOne):
|
|
id, exists := m.ID()
|
|
if exists {
|
|
return []int{id}, nil
|
|
}
|
|
fallthrough
|
|
case m.op.Is(OpUpdate | OpDelete):
|
|
return m.Client().Role.Query().Where(m.predicates...).IDs(ctx)
|
|
default:
|
|
return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
|
|
}
|
|
}
|
|
|
|
// SetName sets the "name" field.
|
|
func (m *RoleMutation) SetName(s string) {
|
|
m.name = &s
|
|
}
|
|
|
|
// Name returns the value of the "name" field in the mutation.
|
|
func (m *RoleMutation) Name() (r string, exists bool) {
|
|
v := m.name
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldName returns the old "name" field's value of the Role entity.
|
|
// If the Role object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *RoleMutation) OldName(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldName is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldName requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldName: %w", err)
|
|
}
|
|
return oldValue.Name, nil
|
|
}
|
|
|
|
// ResetName resets all changes to the "name" field.
|
|
func (m *RoleMutation) ResetName() {
|
|
m.name = nil
|
|
}
|
|
|
|
// SetDescription sets the "description" field.
|
|
func (m *RoleMutation) SetDescription(s string) {
|
|
m.description = &s
|
|
}
|
|
|
|
// Description returns the value of the "description" field in the mutation.
|
|
func (m *RoleMutation) Description() (r string, exists bool) {
|
|
v := m.description
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldDescription returns the old "description" field's value of the Role entity.
|
|
// If the Role object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *RoleMutation) OldDescription(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldDescription is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldDescription requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldDescription: %w", err)
|
|
}
|
|
return oldValue.Description, nil
|
|
}
|
|
|
|
// ClearDescription clears the value of the "description" field.
|
|
func (m *RoleMutation) ClearDescription() {
|
|
m.description = nil
|
|
m.clearedFields[role.FieldDescription] = struct{}{}
|
|
}
|
|
|
|
// DescriptionCleared returns if the "description" field was cleared in this mutation.
|
|
func (m *RoleMutation) DescriptionCleared() bool {
|
|
_, ok := m.clearedFields[role.FieldDescription]
|
|
return ok
|
|
}
|
|
|
|
// ResetDescription resets all changes to the "description" field.
|
|
func (m *RoleMutation) ResetDescription() {
|
|
m.description = nil
|
|
delete(m.clearedFields, role.FieldDescription)
|
|
}
|
|
|
|
// SetCreatedAt sets the "created_at" field.
|
|
func (m *RoleMutation) SetCreatedAt(t time.Time) {
|
|
m.created_at = &t
|
|
}
|
|
|
|
// CreatedAt returns the value of the "created_at" field in the mutation.
|
|
func (m *RoleMutation) CreatedAt() (r time.Time, exists bool) {
|
|
v := m.created_at
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldCreatedAt returns the old "created_at" field's value of the Role entity.
|
|
// If the Role object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *RoleMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldCreatedAt requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
|
|
}
|
|
return oldValue.CreatedAt, nil
|
|
}
|
|
|
|
// ResetCreatedAt resets all changes to the "created_at" field.
|
|
func (m *RoleMutation) ResetCreatedAt() {
|
|
m.created_at = nil
|
|
}
|
|
|
|
// SetUpdatedAt sets the "updated_at" field.
|
|
func (m *RoleMutation) SetUpdatedAt(t time.Time) {
|
|
m.updated_at = &t
|
|
}
|
|
|
|
// UpdatedAt returns the value of the "updated_at" field in the mutation.
|
|
func (m *RoleMutation) UpdatedAt() (r time.Time, exists bool) {
|
|
v := m.updated_at
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldUpdatedAt returns the old "updated_at" field's value of the Role entity.
|
|
// If the Role object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *RoleMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
|
|
}
|
|
return oldValue.UpdatedAt, nil
|
|
}
|
|
|
|
// ResetUpdatedAt resets all changes to the "updated_at" field.
|
|
func (m *RoleMutation) ResetUpdatedAt() {
|
|
m.updated_at = nil
|
|
}
|
|
|
|
// AddPermissionIDs adds the "permissions" edge to the Permission entity by ids.
|
|
func (m *RoleMutation) AddPermissionIDs(ids ...int) {
|
|
if m.permissions == nil {
|
|
m.permissions = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
m.permissions[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// ClearPermissions clears the "permissions" edge to the Permission entity.
|
|
func (m *RoleMutation) ClearPermissions() {
|
|
m.clearedpermissions = true
|
|
}
|
|
|
|
// PermissionsCleared reports if the "permissions" edge to the Permission entity was cleared.
|
|
func (m *RoleMutation) PermissionsCleared() bool {
|
|
return m.clearedpermissions
|
|
}
|
|
|
|
// RemovePermissionIDs removes the "permissions" edge to the Permission entity by IDs.
|
|
func (m *RoleMutation) RemovePermissionIDs(ids ...int) {
|
|
if m.removedpermissions == nil {
|
|
m.removedpermissions = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
delete(m.permissions, ids[i])
|
|
m.removedpermissions[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// RemovedPermissions returns the removed IDs of the "permissions" edge to the Permission entity.
|
|
func (m *RoleMutation) RemovedPermissionsIDs() (ids []int) {
|
|
for id := range m.removedpermissions {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// PermissionsIDs returns the "permissions" edge IDs in the mutation.
|
|
func (m *RoleMutation) PermissionsIDs() (ids []int) {
|
|
for id := range m.permissions {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetPermissions resets all changes to the "permissions" edge.
|
|
func (m *RoleMutation) ResetPermissions() {
|
|
m.permissions = nil
|
|
m.clearedpermissions = false
|
|
m.removedpermissions = nil
|
|
}
|
|
|
|
// AddUserIDs adds the "users" edge to the User entity by ids.
|
|
func (m *RoleMutation) AddUserIDs(ids ...int) {
|
|
if m.users == nil {
|
|
m.users = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
m.users[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// ClearUsers clears the "users" edge to the User entity.
|
|
func (m *RoleMutation) ClearUsers() {
|
|
m.clearedusers = true
|
|
}
|
|
|
|
// UsersCleared reports if the "users" edge to the User entity was cleared.
|
|
func (m *RoleMutation) UsersCleared() bool {
|
|
return m.clearedusers
|
|
}
|
|
|
|
// RemoveUserIDs removes the "users" edge to the User entity by IDs.
|
|
func (m *RoleMutation) RemoveUserIDs(ids ...int) {
|
|
if m.removedusers == nil {
|
|
m.removedusers = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
delete(m.users, ids[i])
|
|
m.removedusers[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// RemovedUsers returns the removed IDs of the "users" edge to the User entity.
|
|
func (m *RoleMutation) RemovedUsersIDs() (ids []int) {
|
|
for id := range m.removedusers {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// UsersIDs returns the "users" edge IDs in the mutation.
|
|
func (m *RoleMutation) UsersIDs() (ids []int) {
|
|
for id := range m.users {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetUsers resets all changes to the "users" edge.
|
|
func (m *RoleMutation) ResetUsers() {
|
|
m.users = nil
|
|
m.clearedusers = false
|
|
m.removedusers = nil
|
|
}
|
|
|
|
// Where appends a list predicates to the RoleMutation builder.
|
|
func (m *RoleMutation) Where(ps ...predicate.Role) {
|
|
m.predicates = append(m.predicates, ps...)
|
|
}
|
|
|
|
// WhereP appends storage-level predicates to the RoleMutation builder. Using this method,
|
|
// users can use type-assertion to append predicates that do not depend on any generated package.
|
|
func (m *RoleMutation) WhereP(ps ...func(*sql.Selector)) {
|
|
p := make([]predicate.Role, len(ps))
|
|
for i := range ps {
|
|
p[i] = ps[i]
|
|
}
|
|
m.Where(p...)
|
|
}
|
|
|
|
// Op returns the operation name.
|
|
func (m *RoleMutation) Op() Op {
|
|
return m.op
|
|
}
|
|
|
|
// SetOp allows setting the mutation operation.
|
|
func (m *RoleMutation) SetOp(op Op) {
|
|
m.op = op
|
|
}
|
|
|
|
// Type returns the node type of this mutation (Role).
|
|
func (m *RoleMutation) Type() string {
|
|
return m.typ
|
|
}
|
|
|
|
// Fields returns all fields that were changed during this mutation. Note that in
|
|
// order to get all numeric fields that were incremented/decremented, call
|
|
// AddedFields().
|
|
func (m *RoleMutation) Fields() []string {
|
|
fields := make([]string, 0, 4)
|
|
if m.name != nil {
|
|
fields = append(fields, role.FieldName)
|
|
}
|
|
if m.description != nil {
|
|
fields = append(fields, role.FieldDescription)
|
|
}
|
|
if m.created_at != nil {
|
|
fields = append(fields, role.FieldCreatedAt)
|
|
}
|
|
if m.updated_at != nil {
|
|
fields = append(fields, role.FieldUpdatedAt)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// Field returns the value of a field with the given name. The second boolean
|
|
// return value indicates that this field was not set, or was not defined in the
|
|
// schema.
|
|
func (m *RoleMutation) Field(name string) (ent.Value, bool) {
|
|
switch name {
|
|
case role.FieldName:
|
|
return m.Name()
|
|
case role.FieldDescription:
|
|
return m.Description()
|
|
case role.FieldCreatedAt:
|
|
return m.CreatedAt()
|
|
case role.FieldUpdatedAt:
|
|
return m.UpdatedAt()
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
// OldField returns the old value of the field from the database. An error is
|
|
// returned if the mutation operation is not UpdateOne, or the query to the
|
|
// database failed.
|
|
func (m *RoleMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
|
|
switch name {
|
|
case role.FieldName:
|
|
return m.OldName(ctx)
|
|
case role.FieldDescription:
|
|
return m.OldDescription(ctx)
|
|
case role.FieldCreatedAt:
|
|
return m.OldCreatedAt(ctx)
|
|
case role.FieldUpdatedAt:
|
|
return m.OldUpdatedAt(ctx)
|
|
}
|
|
return nil, fmt.Errorf("unknown Role field %s", name)
|
|
}
|
|
|
|
// SetField sets the value of a field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *RoleMutation) SetField(name string, value ent.Value) error {
|
|
switch name {
|
|
case role.FieldName:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetName(v)
|
|
return nil
|
|
case role.FieldDescription:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetDescription(v)
|
|
return nil
|
|
case role.FieldCreatedAt:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetCreatedAt(v)
|
|
return nil
|
|
case role.FieldUpdatedAt:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetUpdatedAt(v)
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Role field %s", name)
|
|
}
|
|
|
|
// AddedFields returns all numeric fields that were incremented/decremented during
|
|
// this mutation.
|
|
func (m *RoleMutation) AddedFields() []string {
|
|
return nil
|
|
}
|
|
|
|
// AddedField returns the numeric value that was incremented/decremented on a field
|
|
// with the given name. The second boolean return value indicates that this field
|
|
// was not set, or was not defined in the schema.
|
|
func (m *RoleMutation) AddedField(name string) (ent.Value, bool) {
|
|
return nil, false
|
|
}
|
|
|
|
// AddField adds the value to the field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *RoleMutation) AddField(name string, value ent.Value) error {
|
|
switch name {
|
|
}
|
|
return fmt.Errorf("unknown Role numeric field %s", name)
|
|
}
|
|
|
|
// ClearedFields returns all nullable fields that were cleared during this
|
|
// mutation.
|
|
func (m *RoleMutation) ClearedFields() []string {
|
|
var fields []string
|
|
if m.FieldCleared(role.FieldDescription) {
|
|
fields = append(fields, role.FieldDescription)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// FieldCleared returns a boolean indicating if a field with the given name was
|
|
// cleared in this mutation.
|
|
func (m *RoleMutation) FieldCleared(name string) bool {
|
|
_, ok := m.clearedFields[name]
|
|
return ok
|
|
}
|
|
|
|
// ClearField clears the value of the field with the given name. It returns an
|
|
// error if the field is not defined in the schema.
|
|
func (m *RoleMutation) ClearField(name string) error {
|
|
switch name {
|
|
case role.FieldDescription:
|
|
m.ClearDescription()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Role nullable field %s", name)
|
|
}
|
|
|
|
// ResetField resets all changes in the mutation for the field with the given name.
|
|
// It returns an error if the field is not defined in the schema.
|
|
func (m *RoleMutation) ResetField(name string) error {
|
|
switch name {
|
|
case role.FieldName:
|
|
m.ResetName()
|
|
return nil
|
|
case role.FieldDescription:
|
|
m.ResetDescription()
|
|
return nil
|
|
case role.FieldCreatedAt:
|
|
m.ResetCreatedAt()
|
|
return nil
|
|
case role.FieldUpdatedAt:
|
|
m.ResetUpdatedAt()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Role field %s", name)
|
|
}
|
|
|
|
// AddedEdges returns all edge names that were set/added in this mutation.
|
|
func (m *RoleMutation) AddedEdges() []string {
|
|
edges := make([]string, 0, 2)
|
|
if m.permissions != nil {
|
|
edges = append(edges, role.EdgePermissions)
|
|
}
|
|
if m.users != nil {
|
|
edges = append(edges, role.EdgeUsers)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// AddedIDs returns all IDs (to other nodes) that were added for the given edge
|
|
// name in this mutation.
|
|
func (m *RoleMutation) AddedIDs(name string) []ent.Value {
|
|
switch name {
|
|
case role.EdgePermissions:
|
|
ids := make([]ent.Value, 0, len(m.permissions))
|
|
for id := range m.permissions {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
case role.EdgeUsers:
|
|
ids := make([]ent.Value, 0, len(m.users))
|
|
for id := range m.users {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// RemovedEdges returns all edge names that were removed in this mutation.
|
|
func (m *RoleMutation) RemovedEdges() []string {
|
|
edges := make([]string, 0, 2)
|
|
if m.removedpermissions != nil {
|
|
edges = append(edges, role.EdgePermissions)
|
|
}
|
|
if m.removedusers != nil {
|
|
edges = append(edges, role.EdgeUsers)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
|
|
// the given name in this mutation.
|
|
func (m *RoleMutation) RemovedIDs(name string) []ent.Value {
|
|
switch name {
|
|
case role.EdgePermissions:
|
|
ids := make([]ent.Value, 0, len(m.removedpermissions))
|
|
for id := range m.removedpermissions {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
case role.EdgeUsers:
|
|
ids := make([]ent.Value, 0, len(m.removedusers))
|
|
for id := range m.removedusers {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// ClearedEdges returns all edge names that were cleared in this mutation.
|
|
func (m *RoleMutation) ClearedEdges() []string {
|
|
edges := make([]string, 0, 2)
|
|
if m.clearedpermissions {
|
|
edges = append(edges, role.EdgePermissions)
|
|
}
|
|
if m.clearedusers {
|
|
edges = append(edges, role.EdgeUsers)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// EdgeCleared returns a boolean which indicates if the edge with the given name
|
|
// was cleared in this mutation.
|
|
func (m *RoleMutation) EdgeCleared(name string) bool {
|
|
switch name {
|
|
case role.EdgePermissions:
|
|
return m.clearedpermissions
|
|
case role.EdgeUsers:
|
|
return m.clearedusers
|
|
}
|
|
return false
|
|
}
|
|
|
|
// ClearEdge clears the value of the edge with the given name. It returns an error
|
|
// if that edge is not defined in the schema.
|
|
func (m *RoleMutation) ClearEdge(name string) error {
|
|
switch name {
|
|
}
|
|
return fmt.Errorf("unknown Role unique edge %s", name)
|
|
}
|
|
|
|
// ResetEdge resets all changes to the edge with the given name in this mutation.
|
|
// It returns an error if the edge is not defined in the schema.
|
|
func (m *RoleMutation) ResetEdge(name string) error {
|
|
switch name {
|
|
case role.EdgePermissions:
|
|
m.ResetPermissions()
|
|
return nil
|
|
case role.EdgeUsers:
|
|
m.ResetUsers()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Role edge %s", name)
|
|
}
|
|
|
|
// UserMutation represents an operation that mutates the User nodes in the graph.
|
|
type UserMutation struct {
|
|
config
|
|
op Op
|
|
typ string
|
|
id *int
|
|
username *string
|
|
display_name *string
|
|
email *string
|
|
password_hash *string
|
|
status *user.Status
|
|
created_at *time.Time
|
|
updated_at *time.Time
|
|
clearedFields map[string]struct{}
|
|
roles map[int]struct{}
|
|
removedroles map[int]struct{}
|
|
clearedroles bool
|
|
contributors map[int]struct{}
|
|
removedcontributors map[int]struct{}
|
|
clearedcontributors bool
|
|
media map[int]struct{}
|
|
removedmedia map[int]struct{}
|
|
clearedmedia bool
|
|
done bool
|
|
oldValue func(context.Context) (*User, error)
|
|
predicates []predicate.User
|
|
}
|
|
|
|
var _ ent.Mutation = (*UserMutation)(nil)
|
|
|
|
// userOption allows management of the mutation configuration using functional options.
|
|
type userOption func(*UserMutation)
|
|
|
|
// newUserMutation creates new mutation for the User entity.
|
|
func newUserMutation(c config, op Op, opts ...userOption) *UserMutation {
|
|
m := &UserMutation{
|
|
config: c,
|
|
op: op,
|
|
typ: TypeUser,
|
|
clearedFields: make(map[string]struct{}),
|
|
}
|
|
for _, opt := range opts {
|
|
opt(m)
|
|
}
|
|
return m
|
|
}
|
|
|
|
// withUserID sets the ID field of the mutation.
|
|
func withUserID(id int) userOption {
|
|
return func(m *UserMutation) {
|
|
var (
|
|
err error
|
|
once sync.Once
|
|
value *User
|
|
)
|
|
m.oldValue = func(ctx context.Context) (*User, error) {
|
|
once.Do(func() {
|
|
if m.done {
|
|
err = errors.New("querying old values post mutation is not allowed")
|
|
} else {
|
|
value, err = m.Client().User.Get(ctx, id)
|
|
}
|
|
})
|
|
return value, err
|
|
}
|
|
m.id = &id
|
|
}
|
|
}
|
|
|
|
// withUser sets the old User of the mutation.
|
|
func withUser(node *User) userOption {
|
|
return func(m *UserMutation) {
|
|
m.oldValue = func(context.Context) (*User, error) {
|
|
return node, nil
|
|
}
|
|
m.id = &node.ID
|
|
}
|
|
}
|
|
|
|
// Client returns a new `ent.Client` from the mutation. If the mutation was
|
|
// executed in a transaction (ent.Tx), a transactional client is returned.
|
|
func (m UserMutation) Client() *Client {
|
|
client := &Client{config: m.config}
|
|
client.init()
|
|
return client
|
|
}
|
|
|
|
// Tx returns an `ent.Tx` for mutations that were executed in transactions;
|
|
// it returns an error otherwise.
|
|
func (m UserMutation) Tx() (*Tx, error) {
|
|
if _, ok := m.driver.(*txDriver); !ok {
|
|
return nil, errors.New("ent: mutation is not running in a transaction")
|
|
}
|
|
tx := &Tx{config: m.config}
|
|
tx.init()
|
|
return tx, nil
|
|
}
|
|
|
|
// ID returns the ID value in the mutation. Note that the ID is only available
|
|
// if it was provided to the builder or after it was returned from the database.
|
|
func (m *UserMutation) ID() (id int, exists bool) {
|
|
if m.id == nil {
|
|
return
|
|
}
|
|
return *m.id, true
|
|
}
|
|
|
|
// IDs queries the database and returns the entity ids that match the mutation's predicate.
|
|
// That means, if the mutation is applied within a transaction with an isolation level such
|
|
// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
|
|
// or updated by the mutation.
|
|
func (m *UserMutation) IDs(ctx context.Context) ([]int, error) {
|
|
switch {
|
|
case m.op.Is(OpUpdateOne | OpDeleteOne):
|
|
id, exists := m.ID()
|
|
if exists {
|
|
return []int{id}, nil
|
|
}
|
|
fallthrough
|
|
case m.op.Is(OpUpdate | OpDelete):
|
|
return m.Client().User.Query().Where(m.predicates...).IDs(ctx)
|
|
default:
|
|
return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
|
|
}
|
|
}
|
|
|
|
// SetUsername sets the "username" field.
|
|
func (m *UserMutation) SetUsername(s string) {
|
|
m.username = &s
|
|
}
|
|
|
|
// Username returns the value of the "username" field in the mutation.
|
|
func (m *UserMutation) Username() (r string, exists bool) {
|
|
v := m.username
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldUsername returns the old "username" field's value of the User entity.
|
|
// If the User object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *UserMutation) OldUsername(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldUsername is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldUsername requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldUsername: %w", err)
|
|
}
|
|
return oldValue.Username, nil
|
|
}
|
|
|
|
// ResetUsername resets all changes to the "username" field.
|
|
func (m *UserMutation) ResetUsername() {
|
|
m.username = nil
|
|
}
|
|
|
|
// SetDisplayName sets the "display_name" field.
|
|
func (m *UserMutation) SetDisplayName(s string) {
|
|
m.display_name = &s
|
|
}
|
|
|
|
// DisplayName returns the value of the "display_name" field in the mutation.
|
|
func (m *UserMutation) DisplayName() (r string, exists bool) {
|
|
v := m.display_name
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldDisplayName returns the old "display_name" field's value of the User entity.
|
|
// If the User object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *UserMutation) OldDisplayName(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldDisplayName is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldDisplayName requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldDisplayName: %w", err)
|
|
}
|
|
return oldValue.DisplayName, nil
|
|
}
|
|
|
|
// ClearDisplayName clears the value of the "display_name" field.
|
|
func (m *UserMutation) ClearDisplayName() {
|
|
m.display_name = nil
|
|
m.clearedFields[user.FieldDisplayName] = struct{}{}
|
|
}
|
|
|
|
// DisplayNameCleared returns if the "display_name" field was cleared in this mutation.
|
|
func (m *UserMutation) DisplayNameCleared() bool {
|
|
_, ok := m.clearedFields[user.FieldDisplayName]
|
|
return ok
|
|
}
|
|
|
|
// ResetDisplayName resets all changes to the "display_name" field.
|
|
func (m *UserMutation) ResetDisplayName() {
|
|
m.display_name = nil
|
|
delete(m.clearedFields, user.FieldDisplayName)
|
|
}
|
|
|
|
// SetEmail sets the "email" field.
|
|
func (m *UserMutation) SetEmail(s string) {
|
|
m.email = &s
|
|
}
|
|
|
|
// Email returns the value of the "email" field in the mutation.
|
|
func (m *UserMutation) Email() (r string, exists bool) {
|
|
v := m.email
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldEmail returns the old "email" field's value of the User entity.
|
|
// If the User object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *UserMutation) OldEmail(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldEmail is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldEmail requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldEmail: %w", err)
|
|
}
|
|
return oldValue.Email, nil
|
|
}
|
|
|
|
// ResetEmail resets all changes to the "email" field.
|
|
func (m *UserMutation) ResetEmail() {
|
|
m.email = nil
|
|
}
|
|
|
|
// SetPasswordHash sets the "password_hash" field.
|
|
func (m *UserMutation) SetPasswordHash(s string) {
|
|
m.password_hash = &s
|
|
}
|
|
|
|
// PasswordHash returns the value of the "password_hash" field in the mutation.
|
|
func (m *UserMutation) PasswordHash() (r string, exists bool) {
|
|
v := m.password_hash
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldPasswordHash returns the old "password_hash" field's value of the User entity.
|
|
// If the User object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *UserMutation) OldPasswordHash(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldPasswordHash is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldPasswordHash requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldPasswordHash: %w", err)
|
|
}
|
|
return oldValue.PasswordHash, nil
|
|
}
|
|
|
|
// ResetPasswordHash resets all changes to the "password_hash" field.
|
|
func (m *UserMutation) ResetPasswordHash() {
|
|
m.password_hash = nil
|
|
}
|
|
|
|
// SetStatus sets the "status" field.
|
|
func (m *UserMutation) SetStatus(u user.Status) {
|
|
m.status = &u
|
|
}
|
|
|
|
// Status returns the value of the "status" field in the mutation.
|
|
func (m *UserMutation) Status() (r user.Status, exists bool) {
|
|
v := m.status
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldStatus returns the old "status" field's value of the User entity.
|
|
// If the User object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *UserMutation) OldStatus(ctx context.Context) (v user.Status, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldStatus is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldStatus requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldStatus: %w", err)
|
|
}
|
|
return oldValue.Status, nil
|
|
}
|
|
|
|
// ResetStatus resets all changes to the "status" field.
|
|
func (m *UserMutation) ResetStatus() {
|
|
m.status = nil
|
|
}
|
|
|
|
// SetCreatedAt sets the "created_at" field.
|
|
func (m *UserMutation) SetCreatedAt(t time.Time) {
|
|
m.created_at = &t
|
|
}
|
|
|
|
// CreatedAt returns the value of the "created_at" field in the mutation.
|
|
func (m *UserMutation) CreatedAt() (r time.Time, exists bool) {
|
|
v := m.created_at
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldCreatedAt returns the old "created_at" field's value of the User entity.
|
|
// If the User object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *UserMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldCreatedAt requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
|
|
}
|
|
return oldValue.CreatedAt, nil
|
|
}
|
|
|
|
// ResetCreatedAt resets all changes to the "created_at" field.
|
|
func (m *UserMutation) ResetCreatedAt() {
|
|
m.created_at = nil
|
|
}
|
|
|
|
// SetUpdatedAt sets the "updated_at" field.
|
|
func (m *UserMutation) SetUpdatedAt(t time.Time) {
|
|
m.updated_at = &t
|
|
}
|
|
|
|
// UpdatedAt returns the value of the "updated_at" field in the mutation.
|
|
func (m *UserMutation) UpdatedAt() (r time.Time, exists bool) {
|
|
v := m.updated_at
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldUpdatedAt returns the old "updated_at" field's value of the User entity.
|
|
// If the User object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *UserMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
|
|
}
|
|
return oldValue.UpdatedAt, nil
|
|
}
|
|
|
|
// ResetUpdatedAt resets all changes to the "updated_at" field.
|
|
func (m *UserMutation) ResetUpdatedAt() {
|
|
m.updated_at = nil
|
|
}
|
|
|
|
// AddRoleIDs adds the "roles" edge to the Role entity by ids.
|
|
func (m *UserMutation) AddRoleIDs(ids ...int) {
|
|
if m.roles == nil {
|
|
m.roles = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
m.roles[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// ClearRoles clears the "roles" edge to the Role entity.
|
|
func (m *UserMutation) ClearRoles() {
|
|
m.clearedroles = true
|
|
}
|
|
|
|
// RolesCleared reports if the "roles" edge to the Role entity was cleared.
|
|
func (m *UserMutation) RolesCleared() bool {
|
|
return m.clearedroles
|
|
}
|
|
|
|
// RemoveRoleIDs removes the "roles" edge to the Role entity by IDs.
|
|
func (m *UserMutation) RemoveRoleIDs(ids ...int) {
|
|
if m.removedroles == nil {
|
|
m.removedroles = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
delete(m.roles, ids[i])
|
|
m.removedroles[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// RemovedRoles returns the removed IDs of the "roles" edge to the Role entity.
|
|
func (m *UserMutation) RemovedRolesIDs() (ids []int) {
|
|
for id := range m.removedroles {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// RolesIDs returns the "roles" edge IDs in the mutation.
|
|
func (m *UserMutation) RolesIDs() (ids []int) {
|
|
for id := range m.roles {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetRoles resets all changes to the "roles" edge.
|
|
func (m *UserMutation) ResetRoles() {
|
|
m.roles = nil
|
|
m.clearedroles = false
|
|
m.removedroles = nil
|
|
}
|
|
|
|
// AddContributorIDs adds the "contributors" edge to the Contributor entity by ids.
|
|
func (m *UserMutation) AddContributorIDs(ids ...int) {
|
|
if m.contributors == nil {
|
|
m.contributors = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
m.contributors[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// ClearContributors clears the "contributors" edge to the Contributor entity.
|
|
func (m *UserMutation) ClearContributors() {
|
|
m.clearedcontributors = true
|
|
}
|
|
|
|
// ContributorsCleared reports if the "contributors" edge to the Contributor entity was cleared.
|
|
func (m *UserMutation) ContributorsCleared() bool {
|
|
return m.clearedcontributors
|
|
}
|
|
|
|
// RemoveContributorIDs removes the "contributors" edge to the Contributor entity by IDs.
|
|
func (m *UserMutation) RemoveContributorIDs(ids ...int) {
|
|
if m.removedcontributors == nil {
|
|
m.removedcontributors = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
delete(m.contributors, ids[i])
|
|
m.removedcontributors[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// RemovedContributors returns the removed IDs of the "contributors" edge to the Contributor entity.
|
|
func (m *UserMutation) RemovedContributorsIDs() (ids []int) {
|
|
for id := range m.removedcontributors {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ContributorsIDs returns the "contributors" edge IDs in the mutation.
|
|
func (m *UserMutation) ContributorsIDs() (ids []int) {
|
|
for id := range m.contributors {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetContributors resets all changes to the "contributors" edge.
|
|
func (m *UserMutation) ResetContributors() {
|
|
m.contributors = nil
|
|
m.clearedcontributors = false
|
|
m.removedcontributors = nil
|
|
}
|
|
|
|
// AddMediumIDs adds the "media" edge to the Media entity by ids.
|
|
func (m *UserMutation) AddMediumIDs(ids ...int) {
|
|
if m.media == nil {
|
|
m.media = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
m.media[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// ClearMedia clears the "media" edge to the Media entity.
|
|
func (m *UserMutation) ClearMedia() {
|
|
m.clearedmedia = true
|
|
}
|
|
|
|
// MediaCleared reports if the "media" edge to the Media entity was cleared.
|
|
func (m *UserMutation) MediaCleared() bool {
|
|
return m.clearedmedia
|
|
}
|
|
|
|
// RemoveMediumIDs removes the "media" edge to the Media entity by IDs.
|
|
func (m *UserMutation) RemoveMediumIDs(ids ...int) {
|
|
if m.removedmedia == nil {
|
|
m.removedmedia = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
delete(m.media, ids[i])
|
|
m.removedmedia[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// RemovedMedia returns the removed IDs of the "media" edge to the Media entity.
|
|
func (m *UserMutation) RemovedMediaIDs() (ids []int) {
|
|
for id := range m.removedmedia {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// MediaIDs returns the "media" edge IDs in the mutation.
|
|
func (m *UserMutation) MediaIDs() (ids []int) {
|
|
for id := range m.media {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetMedia resets all changes to the "media" edge.
|
|
func (m *UserMutation) ResetMedia() {
|
|
m.media = nil
|
|
m.clearedmedia = false
|
|
m.removedmedia = nil
|
|
}
|
|
|
|
// Where appends a list predicates to the UserMutation builder.
|
|
func (m *UserMutation) Where(ps ...predicate.User) {
|
|
m.predicates = append(m.predicates, ps...)
|
|
}
|
|
|
|
// WhereP appends storage-level predicates to the UserMutation builder. Using this method,
|
|
// users can use type-assertion to append predicates that do not depend on any generated package.
|
|
func (m *UserMutation) WhereP(ps ...func(*sql.Selector)) {
|
|
p := make([]predicate.User, len(ps))
|
|
for i := range ps {
|
|
p[i] = ps[i]
|
|
}
|
|
m.Where(p...)
|
|
}
|
|
|
|
// Op returns the operation name.
|
|
func (m *UserMutation) Op() Op {
|
|
return m.op
|
|
}
|
|
|
|
// SetOp allows setting the mutation operation.
|
|
func (m *UserMutation) SetOp(op Op) {
|
|
m.op = op
|
|
}
|
|
|
|
// Type returns the node type of this mutation (User).
|
|
func (m *UserMutation) Type() string {
|
|
return m.typ
|
|
}
|
|
|
|
// Fields returns all fields that were changed during this mutation. Note that in
|
|
// order to get all numeric fields that were incremented/decremented, call
|
|
// AddedFields().
|
|
func (m *UserMutation) Fields() []string {
|
|
fields := make([]string, 0, 7)
|
|
if m.username != nil {
|
|
fields = append(fields, user.FieldUsername)
|
|
}
|
|
if m.display_name != nil {
|
|
fields = append(fields, user.FieldDisplayName)
|
|
}
|
|
if m.email != nil {
|
|
fields = append(fields, user.FieldEmail)
|
|
}
|
|
if m.password_hash != nil {
|
|
fields = append(fields, user.FieldPasswordHash)
|
|
}
|
|
if m.status != nil {
|
|
fields = append(fields, user.FieldStatus)
|
|
}
|
|
if m.created_at != nil {
|
|
fields = append(fields, user.FieldCreatedAt)
|
|
}
|
|
if m.updated_at != nil {
|
|
fields = append(fields, user.FieldUpdatedAt)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// Field returns the value of a field with the given name. The second boolean
|
|
// return value indicates that this field was not set, or was not defined in the
|
|
// schema.
|
|
func (m *UserMutation) Field(name string) (ent.Value, bool) {
|
|
switch name {
|
|
case user.FieldUsername:
|
|
return m.Username()
|
|
case user.FieldDisplayName:
|
|
return m.DisplayName()
|
|
case user.FieldEmail:
|
|
return m.Email()
|
|
case user.FieldPasswordHash:
|
|
return m.PasswordHash()
|
|
case user.FieldStatus:
|
|
return m.Status()
|
|
case user.FieldCreatedAt:
|
|
return m.CreatedAt()
|
|
case user.FieldUpdatedAt:
|
|
return m.UpdatedAt()
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
// OldField returns the old value of the field from the database. An error is
|
|
// returned if the mutation operation is not UpdateOne, or the query to the
|
|
// database failed.
|
|
func (m *UserMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
|
|
switch name {
|
|
case user.FieldUsername:
|
|
return m.OldUsername(ctx)
|
|
case user.FieldDisplayName:
|
|
return m.OldDisplayName(ctx)
|
|
case user.FieldEmail:
|
|
return m.OldEmail(ctx)
|
|
case user.FieldPasswordHash:
|
|
return m.OldPasswordHash(ctx)
|
|
case user.FieldStatus:
|
|
return m.OldStatus(ctx)
|
|
case user.FieldCreatedAt:
|
|
return m.OldCreatedAt(ctx)
|
|
case user.FieldUpdatedAt:
|
|
return m.OldUpdatedAt(ctx)
|
|
}
|
|
return nil, fmt.Errorf("unknown User field %s", name)
|
|
}
|
|
|
|
// SetField sets the value of a field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *UserMutation) SetField(name string, value ent.Value) error {
|
|
switch name {
|
|
case user.FieldUsername:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetUsername(v)
|
|
return nil
|
|
case user.FieldDisplayName:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetDisplayName(v)
|
|
return nil
|
|
case user.FieldEmail:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetEmail(v)
|
|
return nil
|
|
case user.FieldPasswordHash:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetPasswordHash(v)
|
|
return nil
|
|
case user.FieldStatus:
|
|
v, ok := value.(user.Status)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetStatus(v)
|
|
return nil
|
|
case user.FieldCreatedAt:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetCreatedAt(v)
|
|
return nil
|
|
case user.FieldUpdatedAt:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetUpdatedAt(v)
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown User field %s", name)
|
|
}
|
|
|
|
// AddedFields returns all numeric fields that were incremented/decremented during
|
|
// this mutation.
|
|
func (m *UserMutation) AddedFields() []string {
|
|
return nil
|
|
}
|
|
|
|
// AddedField returns the numeric value that was incremented/decremented on a field
|
|
// with the given name. The second boolean return value indicates that this field
|
|
// was not set, or was not defined in the schema.
|
|
func (m *UserMutation) AddedField(name string) (ent.Value, bool) {
|
|
return nil, false
|
|
}
|
|
|
|
// AddField adds the value to the field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *UserMutation) AddField(name string, value ent.Value) error {
|
|
switch name {
|
|
}
|
|
return fmt.Errorf("unknown User numeric field %s", name)
|
|
}
|
|
|
|
// ClearedFields returns all nullable fields that were cleared during this
|
|
// mutation.
|
|
func (m *UserMutation) ClearedFields() []string {
|
|
var fields []string
|
|
if m.FieldCleared(user.FieldDisplayName) {
|
|
fields = append(fields, user.FieldDisplayName)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// FieldCleared returns a boolean indicating if a field with the given name was
|
|
// cleared in this mutation.
|
|
func (m *UserMutation) FieldCleared(name string) bool {
|
|
_, ok := m.clearedFields[name]
|
|
return ok
|
|
}
|
|
|
|
// ClearField clears the value of the field with the given name. It returns an
|
|
// error if the field is not defined in the schema.
|
|
func (m *UserMutation) ClearField(name string) error {
|
|
switch name {
|
|
case user.FieldDisplayName:
|
|
m.ClearDisplayName()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown User nullable field %s", name)
|
|
}
|
|
|
|
// ResetField resets all changes in the mutation for the field with the given name.
|
|
// It returns an error if the field is not defined in the schema.
|
|
func (m *UserMutation) ResetField(name string) error {
|
|
switch name {
|
|
case user.FieldUsername:
|
|
m.ResetUsername()
|
|
return nil
|
|
case user.FieldDisplayName:
|
|
m.ResetDisplayName()
|
|
return nil
|
|
case user.FieldEmail:
|
|
m.ResetEmail()
|
|
return nil
|
|
case user.FieldPasswordHash:
|
|
m.ResetPasswordHash()
|
|
return nil
|
|
case user.FieldStatus:
|
|
m.ResetStatus()
|
|
return nil
|
|
case user.FieldCreatedAt:
|
|
m.ResetCreatedAt()
|
|
return nil
|
|
case user.FieldUpdatedAt:
|
|
m.ResetUpdatedAt()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown User field %s", name)
|
|
}
|
|
|
|
// AddedEdges returns all edge names that were set/added in this mutation.
|
|
func (m *UserMutation) AddedEdges() []string {
|
|
edges := make([]string, 0, 3)
|
|
if m.roles != nil {
|
|
edges = append(edges, user.EdgeRoles)
|
|
}
|
|
if m.contributors != nil {
|
|
edges = append(edges, user.EdgeContributors)
|
|
}
|
|
if m.media != nil {
|
|
edges = append(edges, user.EdgeMedia)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// AddedIDs returns all IDs (to other nodes) that were added for the given edge
|
|
// name in this mutation.
|
|
func (m *UserMutation) AddedIDs(name string) []ent.Value {
|
|
switch name {
|
|
case user.EdgeRoles:
|
|
ids := make([]ent.Value, 0, len(m.roles))
|
|
for id := range m.roles {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
case user.EdgeContributors:
|
|
ids := make([]ent.Value, 0, len(m.contributors))
|
|
for id := range m.contributors {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
case user.EdgeMedia:
|
|
ids := make([]ent.Value, 0, len(m.media))
|
|
for id := range m.media {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// RemovedEdges returns all edge names that were removed in this mutation.
|
|
func (m *UserMutation) RemovedEdges() []string {
|
|
edges := make([]string, 0, 3)
|
|
if m.removedroles != nil {
|
|
edges = append(edges, user.EdgeRoles)
|
|
}
|
|
if m.removedcontributors != nil {
|
|
edges = append(edges, user.EdgeContributors)
|
|
}
|
|
if m.removedmedia != nil {
|
|
edges = append(edges, user.EdgeMedia)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
|
|
// the given name in this mutation.
|
|
func (m *UserMutation) RemovedIDs(name string) []ent.Value {
|
|
switch name {
|
|
case user.EdgeRoles:
|
|
ids := make([]ent.Value, 0, len(m.removedroles))
|
|
for id := range m.removedroles {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
case user.EdgeContributors:
|
|
ids := make([]ent.Value, 0, len(m.removedcontributors))
|
|
for id := range m.removedcontributors {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
case user.EdgeMedia:
|
|
ids := make([]ent.Value, 0, len(m.removedmedia))
|
|
for id := range m.removedmedia {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// ClearedEdges returns all edge names that were cleared in this mutation.
|
|
func (m *UserMutation) ClearedEdges() []string {
|
|
edges := make([]string, 0, 3)
|
|
if m.clearedroles {
|
|
edges = append(edges, user.EdgeRoles)
|
|
}
|
|
if m.clearedcontributors {
|
|
edges = append(edges, user.EdgeContributors)
|
|
}
|
|
if m.clearedmedia {
|
|
edges = append(edges, user.EdgeMedia)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// EdgeCleared returns a boolean which indicates if the edge with the given name
|
|
// was cleared in this mutation.
|
|
func (m *UserMutation) EdgeCleared(name string) bool {
|
|
switch name {
|
|
case user.EdgeRoles:
|
|
return m.clearedroles
|
|
case user.EdgeContributors:
|
|
return m.clearedcontributors
|
|
case user.EdgeMedia:
|
|
return m.clearedmedia
|
|
}
|
|
return false
|
|
}
|
|
|
|
// ClearEdge clears the value of the edge with the given name. It returns an error
|
|
// if that edge is not defined in the schema.
|
|
func (m *UserMutation) ClearEdge(name string) error {
|
|
switch name {
|
|
}
|
|
return fmt.Errorf("unknown User unique edge %s", name)
|
|
}
|
|
|
|
// ResetEdge resets all changes to the edge with the given name in this mutation.
|
|
// It returns an error if the edge is not defined in the schema.
|
|
func (m *UserMutation) ResetEdge(name string) error {
|
|
switch name {
|
|
case user.EdgeRoles:
|
|
m.ResetRoles()
|
|
return nil
|
|
case user.EdgeContributors:
|
|
m.ResetContributors()
|
|
return nil
|
|
case user.EdgeMedia:
|
|
m.ResetMedia()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown User edge %s", name)
|
|
}
|